2006-03-27 02:16:45 -07:00
|
|
|
/*
|
2008-10-15 23:03:03 -06:00
|
|
|
* An I2C driver for Ricoh RS5C372, R2025S/D and RV5C38[67] RTCs
|
2006-03-27 02:16:45 -07:00
|
|
|
*
|
|
|
|
* Copyright (C) 2005 Pavel Mironchik <pmironchik@optifacio.net>
|
|
|
|
* Copyright (C) 2006 Tower Technologies
|
2008-10-15 23:03:01 -06:00
|
|
|
* Copyright (C) 2008 Paul Mundt
|
2006-03-27 02:16:45 -07:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/rtc.h>
|
|
|
|
#include <linux/bcd.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2011-05-27 07:57:25 -06:00
|
|
|
#include <linux/module.h>
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
/*
|
|
|
|
* Ricoh has a family of I2C based RTCs, which differ only slightly from
|
|
|
|
* each other. Differences center on pinout (e.g. how many interrupts,
|
|
|
|
* output clock, etc) and how the control registers are used. The '372
|
|
|
|
* is significant only because that's the one this driver first supported.
|
|
|
|
*/
|
2006-03-27 02:16:45 -07:00
|
|
|
#define RS5C372_REG_SECS 0
|
|
|
|
#define RS5C372_REG_MINS 1
|
|
|
|
#define RS5C372_REG_HOURS 2
|
|
|
|
#define RS5C372_REG_WDAY 3
|
|
|
|
#define RS5C372_REG_DAY 4
|
|
|
|
#define RS5C372_REG_MONTH 5
|
|
|
|
#define RS5C372_REG_YEAR 6
|
|
|
|
#define RS5C372_REG_TRIM 7
|
2007-01-05 17:36:37 -07:00
|
|
|
# define RS5C372_TRIM_XSL 0x80
|
|
|
|
# define RS5C372_TRIM_MASK 0x7F
|
|
|
|
|
|
|
|
#define RS5C_REG_ALARM_A_MIN 8 /* or ALARM_W */
|
|
|
|
#define RS5C_REG_ALARM_A_HOURS 9
|
|
|
|
#define RS5C_REG_ALARM_A_WDAY 10
|
|
|
|
|
|
|
|
#define RS5C_REG_ALARM_B_MIN 11 /* or ALARM_D */
|
|
|
|
#define RS5C_REG_ALARM_B_HOURS 12
|
|
|
|
#define RS5C_REG_ALARM_B_WDAY 13 /* (ALARM_B only) */
|
|
|
|
|
|
|
|
#define RS5C_REG_CTRL1 14
|
|
|
|
# define RS5C_CTRL1_AALE (1 << 7) /* or WALE */
|
|
|
|
# define RS5C_CTRL1_BALE (1 << 6) /* or DALE */
|
|
|
|
# define RV5C387_CTRL1_24 (1 << 5)
|
|
|
|
# define RS5C372A_CTRL1_SL1 (1 << 5)
|
|
|
|
# define RS5C_CTRL1_CT_MASK (7 << 0)
|
|
|
|
# define RS5C_CTRL1_CT0 (0 << 0) /* no periodic irq */
|
|
|
|
# define RS5C_CTRL1_CT4 (4 << 0) /* 1 Hz level irq */
|
|
|
|
#define RS5C_REG_CTRL2 15
|
|
|
|
# define RS5C372_CTRL2_24 (1 << 5)
|
2008-10-15 23:03:03 -06:00
|
|
|
# define R2025_CTRL2_XST (1 << 5)
|
|
|
|
# define RS5C_CTRL2_XSTP (1 << 4) /* only if !R2025S/D */
|
2007-01-05 17:36:37 -07:00
|
|
|
# define RS5C_CTRL2_CTFG (1 << 2)
|
|
|
|
# define RS5C_CTRL2_AAFG (1 << 1) /* or WAFG */
|
|
|
|
# define RS5C_CTRL2_BAFG (1 << 0) /* or DAFG */
|
|
|
|
|
|
|
|
|
|
|
|
/* to read (style 1) or write registers starting at R */
|
|
|
|
#define RS5C_ADDR(R) (((R) << 4) | 0)
|
|
|
|
|
|
|
|
|
|
|
|
enum rtc_type {
|
|
|
|
rtc_undef = 0,
|
2008-10-15 23:03:03 -06:00
|
|
|
rtc_r2025sd,
|
2013-05-07 17:18:11 -06:00
|
|
|
rtc_r2221tl,
|
2007-01-05 17:36:37 -07:00
|
|
|
rtc_rs5c372a,
|
|
|
|
rtc_rs5c372b,
|
|
|
|
rtc_rv5c386,
|
|
|
|
rtc_rv5c387a,
|
|
|
|
};
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2008-04-29 15:11:40 -06:00
|
|
|
static const struct i2c_device_id rs5c372_id[] = {
|
2008-10-15 23:03:03 -06:00
|
|
|
{ "r2025sd", rtc_r2025sd },
|
2013-05-07 17:18:11 -06:00
|
|
|
{ "r2221tl", rtc_r2221tl },
|
2008-04-29 15:11:40 -06:00
|
|
|
{ "rs5c372a", rtc_rs5c372a },
|
|
|
|
{ "rs5c372b", rtc_rs5c372b },
|
|
|
|
{ "rv5c386", rtc_rv5c386 },
|
|
|
|
{ "rv5c387a", rtc_rv5c387a },
|
|
|
|
{ }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(i2c, rs5c372_id);
|
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
/* REVISIT: this assumes that:
|
|
|
|
* - we're in the 21st century, so it's safe to ignore the century
|
|
|
|
* bit for rv5c38[67] (REG_MONTH bit 7);
|
|
|
|
* - we should use ALARM_A not ALARM_B (may be wrong on some boards)
|
|
|
|
*/
|
|
|
|
struct rs5c372 {
|
|
|
|
struct i2c_client *client;
|
|
|
|
struct rtc_device *rtc;
|
|
|
|
enum rtc_type type;
|
|
|
|
unsigned time24:1;
|
|
|
|
unsigned has_irq:1;
|
2008-10-15 23:03:01 -06:00
|
|
|
unsigned smbus:1;
|
2007-01-05 17:36:37 -07:00
|
|
|
char buf[17];
|
|
|
|
char *regs;
|
|
|
|
};
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
static int rs5c_get_regs(struct rs5c372 *rs5c)
|
|
|
|
{
|
|
|
|
struct i2c_client *client = rs5c->client;
|
|
|
|
struct i2c_msg msgs[] = {
|
2012-10-04 18:14:22 -06:00
|
|
|
{
|
|
|
|
.addr = client->addr,
|
|
|
|
.flags = I2C_M_RD,
|
|
|
|
.len = sizeof(rs5c->buf),
|
|
|
|
.buf = rs5c->buf
|
|
|
|
},
|
2007-01-05 17:36:37 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/* This implements the third reading method from the datasheet, using
|
|
|
|
* an internal address that's reset after each transaction (by STOP)
|
|
|
|
* to 0x0f ... so we read extra registers, and skip the first one.
|
|
|
|
*
|
|
|
|
* The first method doesn't work with the iop3xx adapter driver, on at
|
|
|
|
* least 80219 chips; this works around that bug.
|
2008-10-15 23:03:01 -06:00
|
|
|
*
|
|
|
|
* The third method on the other hand doesn't work for the SMBus-only
|
|
|
|
* configurations, so we use the the first method there, stripping off
|
|
|
|
* the extra register in the process.
|
2007-01-05 17:36:37 -07:00
|
|
|
*/
|
2008-10-15 23:03:01 -06:00
|
|
|
if (rs5c->smbus) {
|
|
|
|
int addr = RS5C_ADDR(RS5C372_REG_SECS);
|
|
|
|
int size = sizeof(rs5c->buf) - 1;
|
|
|
|
|
|
|
|
if (i2c_smbus_read_i2c_block_data(client, addr, size,
|
|
|
|
rs5c->buf + 1) != size) {
|
|
|
|
dev_warn(&client->dev, "can't read registers\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ((i2c_transfer(client->adapter, msgs, 1)) != 1) {
|
|
|
|
dev_warn(&client->dev, "can't read registers\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
2007-01-05 17:36:37 -07:00
|
|
|
}
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
dev_dbg(&client->dev,
|
2014-10-13 16:53:12 -06:00
|
|
|
"%3ph (%02x) %3ph (%02x), %3ph, %3ph; %02x %02x\n",
|
|
|
|
rs5c->regs + 0, rs5c->regs[3],
|
|
|
|
rs5c->regs + 4, rs5c->regs[7],
|
|
|
|
rs5c->regs + 8, rs5c->regs + 11,
|
|
|
|
rs5c->regs[14], rs5c->regs[15]);
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2006-12-06 21:39:13 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
static unsigned rs5c_reg2hr(struct rs5c372 *rs5c, unsigned reg)
|
|
|
|
{
|
|
|
|
unsigned hour;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
if (rs5c->time24)
|
2008-10-18 21:28:41 -06:00
|
|
|
return bcd2bin(reg & 0x3f);
|
2007-01-05 17:36:37 -07:00
|
|
|
|
2008-10-18 21:28:41 -06:00
|
|
|
hour = bcd2bin(reg & 0x1f);
|
2007-01-05 17:36:37 -07:00
|
|
|
if (hour == 12)
|
|
|
|
hour = 0;
|
|
|
|
if (reg & 0x20)
|
|
|
|
hour += 12;
|
|
|
|
return hour;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned rs5c_hr2reg(struct rs5c372 *rs5c, unsigned hour)
|
2006-03-27 02:16:45 -07:00
|
|
|
{
|
2007-01-05 17:36:37 -07:00
|
|
|
if (rs5c->time24)
|
2008-10-18 21:28:41 -06:00
|
|
|
return bin2bcd(hour);
|
2007-01-05 17:36:37 -07:00
|
|
|
|
|
|
|
if (hour > 12)
|
2008-10-18 21:28:41 -06:00
|
|
|
return 0x20 | bin2bcd(hour - 12);
|
2007-01-05 17:36:37 -07:00
|
|
|
if (hour == 12)
|
2008-10-18 21:28:41 -06:00
|
|
|
return 0x20 | bin2bcd(12);
|
2007-01-05 17:36:37 -07:00
|
|
|
if (hour == 0)
|
2008-10-18 21:28:41 -06:00
|
|
|
return bin2bcd(12);
|
|
|
|
return bin2bcd(hour);
|
2007-01-05 17:36:37 -07:00
|
|
|
}
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
static int rs5c372_get_datetime(struct i2c_client *client, struct rtc_time *tm)
|
|
|
|
{
|
|
|
|
struct rs5c372 *rs5c = i2c_get_clientdata(client);
|
|
|
|
int status = rs5c_get_regs(rs5c);
|
2006-12-06 21:39:13 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
if (status < 0)
|
|
|
|
return status;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2008-10-18 21:28:41 -06:00
|
|
|
tm->tm_sec = bcd2bin(rs5c->regs[RS5C372_REG_SECS] & 0x7f);
|
|
|
|
tm->tm_min = bcd2bin(rs5c->regs[RS5C372_REG_MINS] & 0x7f);
|
2007-01-05 17:36:37 -07:00
|
|
|
tm->tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C372_REG_HOURS]);
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2008-10-18 21:28:41 -06:00
|
|
|
tm->tm_wday = bcd2bin(rs5c->regs[RS5C372_REG_WDAY] & 0x07);
|
|
|
|
tm->tm_mday = bcd2bin(rs5c->regs[RS5C372_REG_DAY] & 0x3f);
|
2006-03-27 02:16:45 -07:00
|
|
|
|
|
|
|
/* tm->tm_mon is zero-based */
|
2008-10-18 21:28:41 -06:00
|
|
|
tm->tm_mon = bcd2bin(rs5c->regs[RS5C372_REG_MONTH] & 0x1f) - 1;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
|
|
|
/* year is 1900 + tm->tm_year */
|
2008-10-18 21:28:41 -06:00
|
|
|
tm->tm_year = bcd2bin(rs5c->regs[RS5C372_REG_YEAR]) + 100;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
|
|
|
dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
|
|
|
|
"mday=%d, mon=%d, year=%d, wday=%d\n",
|
2008-04-28 03:12:00 -06:00
|
|
|
__func__,
|
2006-03-27 02:16:45 -07:00
|
|
|
tm->tm_sec, tm->tm_min, tm->tm_hour,
|
|
|
|
tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
|
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
/* rtc might need initialization */
|
|
|
|
return rtc_valid_tm(tm);
|
2006-03-27 02:16:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
|
|
|
|
{
|
2007-01-05 17:36:37 -07:00
|
|
|
struct rs5c372 *rs5c = i2c_get_clientdata(client);
|
2010-12-21 18:24:24 -07:00
|
|
|
unsigned char buf[7];
|
2008-10-15 23:03:01 -06:00
|
|
|
int addr;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d "
|
2006-03-27 02:16:45 -07:00
|
|
|
"mday=%d, mon=%d, year=%d, wday=%d\n",
|
2008-04-28 03:12:00 -06:00
|
|
|
__func__,
|
2007-01-05 17:36:37 -07:00
|
|
|
tm->tm_sec, tm->tm_min, tm->tm_hour,
|
2006-03-27 02:16:45 -07:00
|
|
|
tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
|
|
|
|
|
2008-10-15 23:03:01 -06:00
|
|
|
addr = RS5C_ADDR(RS5C372_REG_SECS);
|
2008-10-18 21:28:41 -06:00
|
|
|
buf[0] = bin2bcd(tm->tm_sec);
|
|
|
|
buf[1] = bin2bcd(tm->tm_min);
|
2008-10-15 23:03:01 -06:00
|
|
|
buf[2] = rs5c_hr2reg(rs5c, tm->tm_hour);
|
2008-10-18 21:28:41 -06:00
|
|
|
buf[3] = bin2bcd(tm->tm_wday);
|
|
|
|
buf[4] = bin2bcd(tm->tm_mday);
|
|
|
|
buf[5] = bin2bcd(tm->tm_mon + 1);
|
|
|
|
buf[6] = bin2bcd(tm->tm_year - 100);
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2008-10-15 23:03:01 -06:00
|
|
|
if (i2c_smbus_write_i2c_block_data(client, addr, sizeof(buf), buf) < 0) {
|
2008-04-28 03:12:00 -06:00
|
|
|
dev_err(&client->dev, "%s: write error\n", __func__);
|
2006-03-27 02:16:45 -07:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-26 16:17:35 -06:00
|
|
|
#if IS_ENABLED(CONFIG_RTC_INTF_PROC)
|
2007-01-05 17:36:37 -07:00
|
|
|
#define NEED_TRIM
|
|
|
|
#endif
|
|
|
|
|
2016-04-26 16:17:35 -06:00
|
|
|
#if IS_ENABLED(CONFIG_RTC_INTF_SYSFS)
|
2007-01-05 17:36:37 -07:00
|
|
|
#define NEED_TRIM
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef NEED_TRIM
|
2006-03-27 02:16:45 -07:00
|
|
|
static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
|
|
|
|
{
|
2006-12-06 21:39:13 -07:00
|
|
|
struct rs5c372 *rs5c372 = i2c_get_clientdata(client);
|
2007-01-05 17:36:37 -07:00
|
|
|
u8 tmp = rs5c372->regs[RS5C372_REG_TRIM];
|
2006-03-27 02:16:45 -07:00
|
|
|
|
|
|
|
if (osc)
|
2006-12-06 21:39:13 -07:00
|
|
|
*osc = (tmp & RS5C372_TRIM_XSL) ? 32000 : 32768;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2006-11-25 12:09:29 -07:00
|
|
|
if (trim) {
|
2008-04-28 03:12:00 -06:00
|
|
|
dev_dbg(&client->dev, "%s: raw trim=%x\n", __func__, tmp);
|
2007-01-05 17:36:37 -07:00
|
|
|
tmp &= RS5C372_TRIM_MASK;
|
|
|
|
if (tmp & 0x3e) {
|
|
|
|
int t = tmp & 0x3f;
|
|
|
|
|
|
|
|
if (tmp & 0x40)
|
|
|
|
t = (~t | (s8)0xc0) + 1;
|
|
|
|
else
|
|
|
|
t = t - 1;
|
|
|
|
|
|
|
|
tmp = t * 2;
|
|
|
|
} else
|
|
|
|
tmp = 0;
|
|
|
|
*trim = tmp;
|
2006-11-25 12:09:29 -07:00
|
|
|
}
|
2006-03-27 02:16:45 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2007-01-05 17:36:37 -07:00
|
|
|
#endif
|
2006-03-27 02:16:45 -07:00
|
|
|
|
|
|
|
static int rs5c372_rtc_read_time(struct device *dev, struct rtc_time *tm)
|
|
|
|
{
|
|
|
|
return rs5c372_get_datetime(to_i2c_client(dev), tm);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rs5c372_rtc_set_time(struct device *dev, struct rtc_time *tm)
|
|
|
|
{
|
|
|
|
return rs5c372_set_datetime(to_i2c_client(dev), tm);
|
|
|
|
}
|
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
|
2011-02-02 18:02:41 -07:00
|
|
|
static int rs5c_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
|
|
|
|
{
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
struct rs5c372 *rs5c = i2c_get_clientdata(client);
|
|
|
|
unsigned char buf;
|
|
|
|
int status, addr;
|
|
|
|
|
|
|
|
buf = rs5c->regs[RS5C_REG_CTRL1];
|
|
|
|
|
|
|
|
if (!rs5c->has_irq)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
status = rs5c_get_regs(rs5c);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
addr = RS5C_ADDR(RS5C_REG_CTRL1);
|
|
|
|
if (enabled)
|
|
|
|
buf |= RS5C_CTRL1_AALE;
|
|
|
|
else
|
|
|
|
buf &= ~RS5C_CTRL1_AALE;
|
|
|
|
|
|
|
|
if (i2c_smbus_write_byte_data(client, addr, buf) < 0) {
|
2013-02-21 17:45:27 -07:00
|
|
|
dev_warn(dev, "can't update alarm\n");
|
2011-02-02 18:02:41 -07:00
|
|
|
status = -EIO;
|
|
|
|
} else
|
|
|
|
rs5c->regs[RS5C_REG_CTRL1] = buf;
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
/* NOTE: Since RTC_WKALM_{RD,SET} were originally defined for EFI,
|
|
|
|
* which only exposes a polled programming interface; and since
|
|
|
|
* these calls map directly to those EFI requests; we don't demand
|
|
|
|
* we have an IRQ for this chip when we go through this API.
|
|
|
|
*
|
|
|
|
* The older x86_pc derived RTC_ALM_{READ,SET} calls require irqs
|
|
|
|
* though, managed through RTC_AIE_{ON,OFF} requests.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int rs5c_read_alarm(struct device *dev, struct rtc_wkalrm *t)
|
|
|
|
{
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
struct rs5c372 *rs5c = i2c_get_clientdata(client);
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = rs5c_get_regs(rs5c);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
/* report alarm time */
|
|
|
|
t->time.tm_sec = 0;
|
2008-10-18 21:28:41 -06:00
|
|
|
t->time.tm_min = bcd2bin(rs5c->regs[RS5C_REG_ALARM_A_MIN] & 0x7f);
|
2007-01-05 17:36:37 -07:00
|
|
|
t->time.tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C_REG_ALARM_A_HOURS]);
|
|
|
|
t->time.tm_mday = -1;
|
|
|
|
t->time.tm_mon = -1;
|
|
|
|
t->time.tm_year = -1;
|
|
|
|
t->time.tm_wday = -1;
|
|
|
|
t->time.tm_yday = -1;
|
|
|
|
t->time.tm_isdst = -1;
|
|
|
|
|
|
|
|
/* ... and status */
|
|
|
|
t->enabled = !!(rs5c->regs[RS5C_REG_CTRL1] & RS5C_CTRL1_AALE);
|
|
|
|
t->pending = !!(rs5c->regs[RS5C_REG_CTRL2] & RS5C_CTRL2_AAFG);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rs5c_set_alarm(struct device *dev, struct rtc_wkalrm *t)
|
|
|
|
{
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
|
|
|
struct rs5c372 *rs5c = i2c_get_clientdata(client);
|
2008-10-15 23:03:01 -06:00
|
|
|
int status, addr, i;
|
|
|
|
unsigned char buf[3];
|
2007-01-05 17:36:37 -07:00
|
|
|
|
|
|
|
/* only handle up to 24 hours in the future, like RTC_ALM_SET */
|
|
|
|
if (t->time.tm_mday != -1
|
|
|
|
|| t->time.tm_mon != -1
|
|
|
|
|| t->time.tm_year != -1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* REVISIT: round up tm_sec */
|
|
|
|
|
|
|
|
/* if needed, disable irq (clears pending status) */
|
|
|
|
status = rs5c_get_regs(rs5c);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
if (rs5c->regs[RS5C_REG_CTRL1] & RS5C_CTRL1_AALE) {
|
2008-10-15 23:03:01 -06:00
|
|
|
addr = RS5C_ADDR(RS5C_REG_CTRL1);
|
|
|
|
buf[0] = rs5c->regs[RS5C_REG_CTRL1] & ~RS5C_CTRL1_AALE;
|
|
|
|
if (i2c_smbus_write_byte_data(client, addr, buf[0]) < 0) {
|
2013-02-21 17:45:27 -07:00
|
|
|
dev_dbg(dev, "can't disable alarm\n");
|
2007-01-05 17:36:37 -07:00
|
|
|
return -EIO;
|
|
|
|
}
|
2008-10-15 23:03:01 -06:00
|
|
|
rs5c->regs[RS5C_REG_CTRL1] = buf[0];
|
2007-01-05 17:36:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* set alarm */
|
2008-10-18 21:28:41 -06:00
|
|
|
buf[0] = bin2bcd(t->time.tm_min);
|
2008-10-15 23:03:01 -06:00
|
|
|
buf[1] = rs5c_hr2reg(rs5c, t->time.tm_hour);
|
|
|
|
buf[2] = 0x7f; /* any/all days */
|
|
|
|
|
|
|
|
for (i = 0; i < sizeof(buf); i++) {
|
|
|
|
addr = RS5C_ADDR(RS5C_REG_ALARM_A_MIN + i);
|
|
|
|
if (i2c_smbus_write_byte_data(client, addr, buf[i]) < 0) {
|
2013-02-21 17:45:27 -07:00
|
|
|
dev_dbg(dev, "can't set alarm time\n");
|
2008-10-15 23:03:01 -06:00
|
|
|
return -EIO;
|
|
|
|
}
|
2007-01-05 17:36:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ... and maybe enable its irq */
|
|
|
|
if (t->enabled) {
|
2008-10-15 23:03:01 -06:00
|
|
|
addr = RS5C_ADDR(RS5C_REG_CTRL1);
|
|
|
|
buf[0] = rs5c->regs[RS5C_REG_CTRL1] | RS5C_CTRL1_AALE;
|
|
|
|
if (i2c_smbus_write_byte_data(client, addr, buf[0]) < 0)
|
2013-02-21 17:45:27 -07:00
|
|
|
dev_warn(dev, "can't enable alarm\n");
|
2008-10-15 23:03:01 -06:00
|
|
|
rs5c->regs[RS5C_REG_CTRL1] = buf[0];
|
2007-01-05 17:36:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-26 16:17:35 -06:00
|
|
|
#if IS_ENABLED(CONFIG_RTC_INTF_PROC)
|
2007-01-05 17:36:37 -07:00
|
|
|
|
2006-03-27 02:16:45 -07:00
|
|
|
static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq)
|
|
|
|
{
|
|
|
|
int err, osc, trim;
|
|
|
|
|
2006-04-10 23:54:43 -06:00
|
|
|
err = rs5c372_get_trim(to_i2c_client(dev), &osc, &trim);
|
|
|
|
if (err == 0) {
|
2007-01-05 17:36:37 -07:00
|
|
|
seq_printf(seq, "crystal\t\t: %d.%03d KHz\n",
|
|
|
|
osc / 1000, osc % 1000);
|
|
|
|
seq_printf(seq, "trim\t\t: %d\n", trim);
|
2006-03-27 02:16:45 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
#else
|
|
|
|
#define rs5c372_rtc_proc NULL
|
|
|
|
#endif
|
|
|
|
|
2006-10-01 00:28:17 -06:00
|
|
|
static const struct rtc_class_ops rs5c372_rtc_ops = {
|
2006-03-27 02:16:45 -07:00
|
|
|
.proc = rs5c372_rtc_proc,
|
|
|
|
.read_time = rs5c372_rtc_read_time,
|
|
|
|
.set_time = rs5c372_rtc_set_time,
|
2007-01-05 17:36:37 -07:00
|
|
|
.read_alarm = rs5c_read_alarm,
|
|
|
|
.set_alarm = rs5c_set_alarm,
|
2011-02-02 18:02:41 -07:00
|
|
|
.alarm_irq_enable = rs5c_rtc_alarm_irq_enable,
|
2006-03-27 02:16:45 -07:00
|
|
|
};
|
|
|
|
|
2016-04-26 16:17:35 -06:00
|
|
|
#if IS_ENABLED(CONFIG_RTC_INTF_SYSFS)
|
2007-01-05 17:36:37 -07:00
|
|
|
|
2006-03-27 02:16:45 -07:00
|
|
|
static ssize_t rs5c372_sysfs_show_trim(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2006-04-10 23:54:44 -06:00
|
|
|
int err, trim;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2006-04-10 23:54:44 -06:00
|
|
|
err = rs5c372_get_trim(to_i2c_client(dev), NULL, &trim);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
return sprintf(buf, "%d\n", trim);
|
2006-03-27 02:16:45 -07:00
|
|
|
}
|
|
|
|
static DEVICE_ATTR(trim, S_IRUGO, rs5c372_sysfs_show_trim, NULL);
|
|
|
|
|
|
|
|
static ssize_t rs5c372_sysfs_show_osc(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2006-04-10 23:54:44 -06:00
|
|
|
int err, osc;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2006-04-10 23:54:44 -06:00
|
|
|
err = rs5c372_get_trim(to_i2c_client(dev), &osc, NULL);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2006-04-10 23:54:44 -06:00
|
|
|
return sprintf(buf, "%d.%03d KHz\n", osc / 1000, osc % 1000);
|
2006-03-27 02:16:45 -07:00
|
|
|
}
|
|
|
|
static DEVICE_ATTR(osc, S_IRUGO, rs5c372_sysfs_show_osc, NULL);
|
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
static int rs5c_sysfs_register(struct device *dev)
|
2006-03-27 02:16:45 -07:00
|
|
|
{
|
2007-01-05 17:36:37 -07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = device_create_file(dev, &dev_attr_trim);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
err = device_create_file(dev, &dev_attr_osc);
|
|
|
|
if (err)
|
|
|
|
device_remove_file(dev, &dev_attr_trim);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-07-17 05:04:55 -06:00
|
|
|
static void rs5c_sysfs_unregister(struct device *dev)
|
|
|
|
{
|
|
|
|
device_remove_file(dev, &dev_attr_trim);
|
|
|
|
device_remove_file(dev, &dev_attr_osc);
|
|
|
|
}
|
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
#else
|
|
|
|
static int rs5c_sysfs_register(struct device *dev)
|
|
|
|
{
|
|
|
|
return 0;
|
2006-03-27 02:16:45 -07:00
|
|
|
}
|
2007-07-17 05:04:55 -06:00
|
|
|
|
|
|
|
static void rs5c_sysfs_unregister(struct device *dev)
|
|
|
|
{
|
|
|
|
/* nothing */
|
|
|
|
}
|
2007-01-05 17:36:37 -07:00
|
|
|
#endif /* SYSFS */
|
|
|
|
|
|
|
|
static struct i2c_driver rs5c372_driver;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2008-10-15 23:03:01 -06:00
|
|
|
static int rs5c_oscillator_setup(struct rs5c372 *rs5c372)
|
|
|
|
{
|
|
|
|
unsigned char buf[2];
|
|
|
|
int addr, i, ret = 0;
|
|
|
|
|
2008-10-15 23:03:03 -06:00
|
|
|
if (rs5c372->type == rtc_r2025sd) {
|
2010-06-02 07:53:05 -06:00
|
|
|
if (rs5c372->regs[RS5C_REG_CTRL2] & R2025_CTRL2_XST)
|
2008-10-15 23:03:03 -06:00
|
|
|
return ret;
|
2010-06-02 07:53:05 -06:00
|
|
|
rs5c372->regs[RS5C_REG_CTRL2] |= R2025_CTRL2_XST;
|
2008-10-15 23:03:03 -06:00
|
|
|
} else {
|
|
|
|
if (!(rs5c372->regs[RS5C_REG_CTRL2] & RS5C_CTRL2_XSTP))
|
|
|
|
return ret;
|
|
|
|
rs5c372->regs[RS5C_REG_CTRL2] &= ~RS5C_CTRL2_XSTP;
|
|
|
|
}
|
2008-10-15 23:03:01 -06:00
|
|
|
|
|
|
|
addr = RS5C_ADDR(RS5C_REG_CTRL1);
|
|
|
|
buf[0] = rs5c372->regs[RS5C_REG_CTRL1];
|
|
|
|
buf[1] = rs5c372->regs[RS5C_REG_CTRL2];
|
|
|
|
|
|
|
|
/* use 24hr mode */
|
|
|
|
switch (rs5c372->type) {
|
|
|
|
case rtc_rs5c372a:
|
|
|
|
case rtc_rs5c372b:
|
|
|
|
buf[1] |= RS5C372_CTRL2_24;
|
|
|
|
rs5c372->time24 = 1;
|
|
|
|
break;
|
2008-10-15 23:03:03 -06:00
|
|
|
case rtc_r2025sd:
|
2013-05-07 17:18:11 -06:00
|
|
|
case rtc_r2221tl:
|
2008-10-15 23:03:01 -06:00
|
|
|
case rtc_rv5c386:
|
|
|
|
case rtc_rv5c387a:
|
|
|
|
buf[0] |= RV5C387_CTRL1_24;
|
|
|
|
rs5c372->time24 = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* impossible */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < sizeof(buf); i++) {
|
|
|
|
addr = RS5C_ADDR(RS5C_REG_CTRL1 + i);
|
|
|
|
ret = i2c_smbus_write_byte_data(rs5c372->client, addr, buf[i]);
|
|
|
|
if (unlikely(ret < 0))
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
rs5c372->regs[RS5C_REG_CTRL1] = buf[0];
|
|
|
|
rs5c372->regs[RS5C_REG_CTRL2] = buf[1];
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-29 15:11:39 -06:00
|
|
|
static int rs5c372_probe(struct i2c_client *client,
|
|
|
|
const struct i2c_device_id *id)
|
2006-03-27 02:16:45 -07:00
|
|
|
{
|
|
|
|
int err = 0;
|
2008-10-15 23:03:01 -06:00
|
|
|
int smbus_mode = 0;
|
2006-12-06 21:39:13 -07:00
|
|
|
struct rs5c372 *rs5c372;
|
2007-01-05 17:36:37 -07:00
|
|
|
struct rtc_time tm;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2008-04-28 03:12:00 -06:00
|
|
|
dev_dbg(&client->dev, "%s\n", __func__);
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2008-10-15 23:03:01 -06:00
|
|
|
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
|
|
|
|
I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) {
|
|
|
|
/*
|
|
|
|
* If we don't have any master mode adapter, try breaking
|
|
|
|
* it down in to the barest of capabilities.
|
|
|
|
*/
|
|
|
|
if (i2c_check_functionality(client->adapter,
|
|
|
|
I2C_FUNC_SMBUS_BYTE_DATA |
|
|
|
|
I2C_FUNC_SMBUS_I2C_BLOCK))
|
|
|
|
smbus_mode = 1;
|
|
|
|
else {
|
|
|
|
/* Still no good, give up */
|
|
|
|
err = -ENODEV;
|
|
|
|
goto exit;
|
|
|
|
}
|
2006-03-27 02:16:45 -07:00
|
|
|
}
|
|
|
|
|
2013-04-29 17:20:52 -06:00
|
|
|
rs5c372 = devm_kzalloc(&client->dev, sizeof(struct rs5c372),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!rs5c372) {
|
2006-03-27 02:16:45 -07:00
|
|
|
err = -ENOMEM;
|
|
|
|
goto exit;
|
|
|
|
}
|
2007-01-05 17:36:37 -07:00
|
|
|
|
|
|
|
rs5c372->client = client;
|
2006-12-06 21:39:13 -07:00
|
|
|
i2c_set_clientdata(client, rs5c372);
|
2008-04-29 15:11:40 -06:00
|
|
|
rs5c372->type = id->driver_data;
|
2006-12-06 21:39:13 -07:00
|
|
|
|
2008-04-28 03:11:57 -06:00
|
|
|
/* we read registers 0x0f then 0x00-0x0f; skip the first one */
|
|
|
|
rs5c372->regs = &rs5c372->buf[1];
|
2008-10-15 23:03:01 -06:00
|
|
|
rs5c372->smbus = smbus_mode;
|
2008-04-28 03:11:57 -06:00
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
err = rs5c_get_regs(rs5c372);
|
|
|
|
if (err < 0)
|
2013-04-29 17:20:52 -06:00
|
|
|
goto exit;
|
2007-01-05 17:36:37 -07:00
|
|
|
|
|
|
|
/* clock may be set for am/pm or 24 hr time */
|
|
|
|
switch (rs5c372->type) {
|
|
|
|
case rtc_rs5c372a:
|
|
|
|
case rtc_rs5c372b:
|
|
|
|
/* alarm uses ALARM_A; and nINTRA on 372a, nINTR on 372b.
|
|
|
|
* so does periodic irq, except some 327a modes.
|
|
|
|
*/
|
|
|
|
if (rs5c372->regs[RS5C_REG_CTRL2] & RS5C372_CTRL2_24)
|
|
|
|
rs5c372->time24 = 1;
|
|
|
|
break;
|
2008-10-15 23:03:03 -06:00
|
|
|
case rtc_r2025sd:
|
2013-05-07 17:18:11 -06:00
|
|
|
case rtc_r2221tl:
|
2007-01-05 17:36:37 -07:00
|
|
|
case rtc_rv5c386:
|
|
|
|
case rtc_rv5c387a:
|
|
|
|
if (rs5c372->regs[RS5C_REG_CTRL1] & RV5C387_CTRL1_24)
|
|
|
|
rs5c372->time24 = 1;
|
|
|
|
/* alarm uses ALARM_W; and nINTRB for alarm and periodic
|
|
|
|
* irq, on both 386 and 387
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_err(&client->dev, "unknown RTC type\n");
|
2013-04-29 17:20:52 -06:00
|
|
|
goto exit;
|
2007-01-05 17:36:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* if the oscillator lost power and no other software (like
|
|
|
|
* the bootloader) set it up, do it here.
|
2008-10-15 23:03:03 -06:00
|
|
|
*
|
|
|
|
* The R2025S/D does this a little differently than the other
|
|
|
|
* parts, so we special case that..
|
2007-01-05 17:36:37 -07:00
|
|
|
*/
|
2008-10-15 23:03:01 -06:00
|
|
|
err = rs5c_oscillator_setup(rs5c372);
|
|
|
|
if (unlikely(err < 0)) {
|
|
|
|
dev_err(&client->dev, "setup error\n");
|
2013-04-29 17:20:52 -06:00
|
|
|
goto exit;
|
2007-01-05 17:36:37 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (rs5c372_get_datetime(client, &tm) < 0)
|
|
|
|
dev_warn(&client->dev, "clock needs to be set\n");
|
|
|
|
|
2016-03-31 07:07:26 -06:00
|
|
|
dev_info(&client->dev, "%s found, %s\n",
|
2007-01-05 17:36:37 -07:00
|
|
|
({ char *s; switch (rs5c372->type) {
|
2008-10-15 23:03:03 -06:00
|
|
|
case rtc_r2025sd: s = "r2025sd"; break;
|
2013-05-07 17:18:11 -06:00
|
|
|
case rtc_r2221tl: s = "r2221tl"; break;
|
2007-01-05 17:36:37 -07:00
|
|
|
case rtc_rs5c372a: s = "rs5c372a"; break;
|
|
|
|
case rtc_rs5c372b: s = "rs5c372b"; break;
|
|
|
|
case rtc_rv5c386: s = "rv5c386"; break;
|
|
|
|
case rtc_rv5c387a: s = "rv5c387a"; break;
|
|
|
|
default: s = "chip"; break;
|
|
|
|
}; s;}),
|
|
|
|
rs5c372->time24 ? "24hr" : "am/pm"
|
|
|
|
);
|
|
|
|
|
2007-07-17 05:04:55 -06:00
|
|
|
/* REVISIT use client->irq to register alarm irq ... */
|
2013-04-29 17:20:52 -06:00
|
|
|
rs5c372->rtc = devm_rtc_device_register(&client->dev,
|
|
|
|
rs5c372_driver.driver.name,
|
|
|
|
&rs5c372_rtc_ops, THIS_MODULE);
|
2006-03-27 02:16:45 -07:00
|
|
|
|
2006-12-06 21:39:13 -07:00
|
|
|
if (IS_ERR(rs5c372->rtc)) {
|
|
|
|
err = PTR_ERR(rs5c372->rtc);
|
2013-04-29 17:20:52 -06:00
|
|
|
goto exit;
|
2006-03-27 02:16:45 -07:00
|
|
|
}
|
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
err = rs5c_sysfs_register(&client->dev);
|
2006-12-06 21:39:13 -07:00
|
|
|
if (err)
|
2013-04-29 17:20:52 -06:00
|
|
|
goto exit;
|
2006-03-27 02:16:45 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
exit:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-07-17 05:04:55 -06:00
|
|
|
static int rs5c372_remove(struct i2c_client *client)
|
2007-01-05 17:36:37 -07:00
|
|
|
{
|
2007-07-17 05:04:55 -06:00
|
|
|
rs5c_sysfs_unregister(&client->dev);
|
2006-03-27 02:16:45 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-01-05 17:36:37 -07:00
|
|
|
static struct i2c_driver rs5c372_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "rtc-rs5c372",
|
|
|
|
},
|
2007-07-17 05:04:55 -06:00
|
|
|
.probe = rs5c372_probe,
|
|
|
|
.remove = rs5c372_remove,
|
2008-04-29 15:11:40 -06:00
|
|
|
.id_table = rs5c372_id,
|
2007-01-05 17:36:37 -07:00
|
|
|
};
|
|
|
|
|
2012-03-23 16:02:31 -06:00
|
|
|
module_i2c_driver(rs5c372_driver);
|
2006-03-27 02:16:45 -07:00
|
|
|
|
|
|
|
MODULE_AUTHOR(
|
|
|
|
"Pavel Mironchik <pmironchik@optifacio.net>, "
|
2008-10-15 23:03:01 -06:00
|
|
|
"Alessandro Zummo <a.zummo@towertech.it>, "
|
|
|
|
"Paul Mundt <lethal@linux-sh.org>");
|
2006-03-27 02:16:45 -07:00
|
|
|
MODULE_DESCRIPTION("Ricoh RS5C372 RTC driver");
|
|
|
|
MODULE_LICENSE("GPL");
|