mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![John Stultz](/assets/img/avatar_default.png)
With the generic RTC rework, the UIE mode irqs are handled in the generic layer, and only hardware specific ioctls get passed down to the rtc driver layer. So this patch removes the UIE mode ioctl handling in the rtc driver layer, which never get used. CC: Thomas Gleixner <tglx@linutronix.de> CC: Alessandro Zummo <a.zummo@towertech.it> CC: Marcelo Roberto Jimenez <mroberto@cpti.cetuc.puc-rio.br> CC: rtc-linux@googlegroups.com Signed-off-by: John Stultz <john.stultz@linaro.org>
710 lines
18 KiB
C
710 lines
18 KiB
C
/*
|
|
* An I2C driver for Ricoh RS5C372, R2025S/D and RV5C38[67] RTCs
|
|
*
|
|
* Copyright (C) 2005 Pavel Mironchik <pmironchik@optifacio.net>
|
|
* Copyright (C) 2006 Tower Technologies
|
|
* Copyright (C) 2008 Paul Mundt
|
|
*
|
|
* 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 <linux/slab.h>
|
|
|
|
#define DRV_VERSION "0.6"
|
|
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
#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
|
|
# 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)
|
|
# define R2025_CTRL2_XST (1 << 5)
|
|
# define RS5C_CTRL2_XSTP (1 << 4) /* only if !R2025S/D */
|
|
# 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,
|
|
rtc_r2025sd,
|
|
rtc_rs5c372a,
|
|
rtc_rs5c372b,
|
|
rtc_rv5c386,
|
|
rtc_rv5c387a,
|
|
};
|
|
|
|
static const struct i2c_device_id rs5c372_id[] = {
|
|
{ "r2025sd", rtc_r2025sd },
|
|
{ "rs5c372a", rtc_rs5c372a },
|
|
{ "rs5c372b", rtc_rs5c372b },
|
|
{ "rv5c386", rtc_rv5c386 },
|
|
{ "rv5c387a", rtc_rv5c387a },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(i2c, rs5c372_id);
|
|
|
|
/* 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;
|
|
unsigned smbus:1;
|
|
char buf[17];
|
|
char *regs;
|
|
};
|
|
|
|
static int rs5c_get_regs(struct rs5c372 *rs5c)
|
|
{
|
|
struct i2c_client *client = rs5c->client;
|
|
struct i2c_msg msgs[] = {
|
|
{ client->addr, I2C_M_RD, sizeof rs5c->buf, rs5c->buf },
|
|
};
|
|
|
|
/* 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.
|
|
*
|
|
* 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.
|
|
*/
|
|
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;
|
|
}
|
|
}
|
|
|
|
dev_dbg(&client->dev,
|
|
"%02x %02x %02x (%02x) %02x %02x %02x (%02x), "
|
|
"%02x %02x %02x, %02x %02x %02x; %02x %02x\n",
|
|
rs5c->regs[0], rs5c->regs[1], rs5c->regs[2], rs5c->regs[3],
|
|
rs5c->regs[4], rs5c->regs[5], rs5c->regs[6], rs5c->regs[7],
|
|
rs5c->regs[8], rs5c->regs[9], rs5c->regs[10], rs5c->regs[11],
|
|
rs5c->regs[12], rs5c->regs[13], rs5c->regs[14], rs5c->regs[15]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static unsigned rs5c_reg2hr(struct rs5c372 *rs5c, unsigned reg)
|
|
{
|
|
unsigned hour;
|
|
|
|
if (rs5c->time24)
|
|
return bcd2bin(reg & 0x3f);
|
|
|
|
hour = bcd2bin(reg & 0x1f);
|
|
if (hour == 12)
|
|
hour = 0;
|
|
if (reg & 0x20)
|
|
hour += 12;
|
|
return hour;
|
|
}
|
|
|
|
static unsigned rs5c_hr2reg(struct rs5c372 *rs5c, unsigned hour)
|
|
{
|
|
if (rs5c->time24)
|
|
return bin2bcd(hour);
|
|
|
|
if (hour > 12)
|
|
return 0x20 | bin2bcd(hour - 12);
|
|
if (hour == 12)
|
|
return 0x20 | bin2bcd(12);
|
|
if (hour == 0)
|
|
return bin2bcd(12);
|
|
return bin2bcd(hour);
|
|
}
|
|
|
|
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);
|
|
|
|
if (status < 0)
|
|
return status;
|
|
|
|
tm->tm_sec = bcd2bin(rs5c->regs[RS5C372_REG_SECS] & 0x7f);
|
|
tm->tm_min = bcd2bin(rs5c->regs[RS5C372_REG_MINS] & 0x7f);
|
|
tm->tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C372_REG_HOURS]);
|
|
|
|
tm->tm_wday = bcd2bin(rs5c->regs[RS5C372_REG_WDAY] & 0x07);
|
|
tm->tm_mday = bcd2bin(rs5c->regs[RS5C372_REG_DAY] & 0x3f);
|
|
|
|
/* tm->tm_mon is zero-based */
|
|
tm->tm_mon = bcd2bin(rs5c->regs[RS5C372_REG_MONTH] & 0x1f) - 1;
|
|
|
|
/* year is 1900 + tm->tm_year */
|
|
tm->tm_year = bcd2bin(rs5c->regs[RS5C372_REG_YEAR]) + 100;
|
|
|
|
dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
|
|
"mday=%d, mon=%d, year=%d, wday=%d\n",
|
|
__func__,
|
|
tm->tm_sec, tm->tm_min, tm->tm_hour,
|
|
tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
|
|
|
|
/* rtc might need initialization */
|
|
return rtc_valid_tm(tm);
|
|
}
|
|
|
|
static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
|
|
{
|
|
struct rs5c372 *rs5c = i2c_get_clientdata(client);
|
|
unsigned char buf[7];
|
|
int addr;
|
|
|
|
dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d "
|
|
"mday=%d, mon=%d, year=%d, wday=%d\n",
|
|
__func__,
|
|
tm->tm_sec, tm->tm_min, tm->tm_hour,
|
|
tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
|
|
|
|
addr = RS5C_ADDR(RS5C372_REG_SECS);
|
|
buf[0] = bin2bcd(tm->tm_sec);
|
|
buf[1] = bin2bcd(tm->tm_min);
|
|
buf[2] = rs5c_hr2reg(rs5c, tm->tm_hour);
|
|
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);
|
|
|
|
if (i2c_smbus_write_i2c_block_data(client, addr, sizeof(buf), buf) < 0) {
|
|
dev_err(&client->dev, "%s: write error\n", __func__);
|
|
return -EIO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
|
|
#define NEED_TRIM
|
|
#endif
|
|
|
|
#if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
|
|
#define NEED_TRIM
|
|
#endif
|
|
|
|
#ifdef NEED_TRIM
|
|
static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
|
|
{
|
|
struct rs5c372 *rs5c372 = i2c_get_clientdata(client);
|
|
u8 tmp = rs5c372->regs[RS5C372_REG_TRIM];
|
|
|
|
if (osc)
|
|
*osc = (tmp & RS5C372_TRIM_XSL) ? 32000 : 32768;
|
|
|
|
if (trim) {
|
|
dev_dbg(&client->dev, "%s: raw trim=%x\n", __func__, tmp);
|
|
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;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
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) {
|
|
printk(KERN_WARNING "%s: can't update alarm\n",
|
|
rs5c->rtc->name);
|
|
status = -EIO;
|
|
} else
|
|
rs5c->regs[RS5C_REG_CTRL1] = buf;
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
/* 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;
|
|
t->time.tm_min = bcd2bin(rs5c->regs[RS5C_REG_ALARM_A_MIN] & 0x7f);
|
|
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);
|
|
int status, addr, i;
|
|
unsigned char buf[3];
|
|
|
|
/* 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) {
|
|
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) {
|
|
pr_debug("%s: can't disable alarm\n", rs5c->rtc->name);
|
|
return -EIO;
|
|
}
|
|
rs5c->regs[RS5C_REG_CTRL1] = buf[0];
|
|
}
|
|
|
|
/* set alarm */
|
|
buf[0] = bin2bcd(t->time.tm_min);
|
|
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) {
|
|
pr_debug("%s: can't set alarm time\n", rs5c->rtc->name);
|
|
return -EIO;
|
|
}
|
|
}
|
|
|
|
/* ... and maybe enable its irq */
|
|
if (t->enabled) {
|
|
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)
|
|
printk(KERN_WARNING "%s: can't enable alarm\n",
|
|
rs5c->rtc->name);
|
|
rs5c->regs[RS5C_REG_CTRL1] = buf[0];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
|
|
|
|
static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq)
|
|
{
|
|
int err, osc, trim;
|
|
|
|
err = rs5c372_get_trim(to_i2c_client(dev), &osc, &trim);
|
|
if (err == 0) {
|
|
seq_printf(seq, "crystal\t\t: %d.%03d KHz\n",
|
|
osc / 1000, osc % 1000);
|
|
seq_printf(seq, "trim\t\t: %d\n", trim);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
#define rs5c372_rtc_proc NULL
|
|
#endif
|
|
|
|
static const struct rtc_class_ops rs5c372_rtc_ops = {
|
|
.proc = rs5c372_rtc_proc,
|
|
.read_time = rs5c372_rtc_read_time,
|
|
.set_time = rs5c372_rtc_set_time,
|
|
.read_alarm = rs5c_read_alarm,
|
|
.set_alarm = rs5c_set_alarm,
|
|
.alarm_irq_enable = rs5c_rtc_alarm_irq_enable,
|
|
};
|
|
|
|
#if defined(CONFIG_RTC_INTF_SYSFS) || defined(CONFIG_RTC_INTF_SYSFS_MODULE)
|
|
|
|
static ssize_t rs5c372_sysfs_show_trim(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
int err, trim;
|
|
|
|
err = rs5c372_get_trim(to_i2c_client(dev), NULL, &trim);
|
|
if (err)
|
|
return err;
|
|
|
|
return sprintf(buf, "%d\n", trim);
|
|
}
|
|
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)
|
|
{
|
|
int err, osc;
|
|
|
|
err = rs5c372_get_trim(to_i2c_client(dev), &osc, NULL);
|
|
if (err)
|
|
return err;
|
|
|
|
return sprintf(buf, "%d.%03d KHz\n", osc / 1000, osc % 1000);
|
|
}
|
|
static DEVICE_ATTR(osc, S_IRUGO, rs5c372_sysfs_show_osc, NULL);
|
|
|
|
static int rs5c_sysfs_register(struct device *dev)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static void rs5c_sysfs_unregister(struct device *dev)
|
|
{
|
|
device_remove_file(dev, &dev_attr_trim);
|
|
device_remove_file(dev, &dev_attr_osc);
|
|
}
|
|
|
|
#else
|
|
static int rs5c_sysfs_register(struct device *dev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void rs5c_sysfs_unregister(struct device *dev)
|
|
{
|
|
/* nothing */
|
|
}
|
|
#endif /* SYSFS */
|
|
|
|
static struct i2c_driver rs5c372_driver;
|
|
|
|
static int rs5c_oscillator_setup(struct rs5c372 *rs5c372)
|
|
{
|
|
unsigned char buf[2];
|
|
int addr, i, ret = 0;
|
|
|
|
if (rs5c372->type == rtc_r2025sd) {
|
|
if (!(rs5c372->regs[RS5C_REG_CTRL2] & R2025_CTRL2_XST))
|
|
return ret;
|
|
rs5c372->regs[RS5C_REG_CTRL2] &= ~R2025_CTRL2_XST;
|
|
} else {
|
|
if (!(rs5c372->regs[RS5C_REG_CTRL2] & RS5C_CTRL2_XSTP))
|
|
return ret;
|
|
rs5c372->regs[RS5C_REG_CTRL2] &= ~RS5C_CTRL2_XSTP;
|
|
}
|
|
|
|
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;
|
|
case rtc_r2025sd:
|
|
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;
|
|
}
|
|
|
|
static int rs5c372_probe(struct i2c_client *client,
|
|
const struct i2c_device_id *id)
|
|
{
|
|
int err = 0;
|
|
int smbus_mode = 0;
|
|
struct rs5c372 *rs5c372;
|
|
struct rtc_time tm;
|
|
|
|
dev_dbg(&client->dev, "%s\n", __func__);
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
if (!(rs5c372 = kzalloc(sizeof(struct rs5c372), GFP_KERNEL))) {
|
|
err = -ENOMEM;
|
|
goto exit;
|
|
}
|
|
|
|
rs5c372->client = client;
|
|
i2c_set_clientdata(client, rs5c372);
|
|
rs5c372->type = id->driver_data;
|
|
|
|
/* we read registers 0x0f then 0x00-0x0f; skip the first one */
|
|
rs5c372->regs = &rs5c372->buf[1];
|
|
rs5c372->smbus = smbus_mode;
|
|
|
|
err = rs5c_get_regs(rs5c372);
|
|
if (err < 0)
|
|
goto exit_kfree;
|
|
|
|
/* 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;
|
|
case rtc_r2025sd:
|
|
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");
|
|
goto exit_kfree;
|
|
}
|
|
|
|
/* if the oscillator lost power and no other software (like
|
|
* the bootloader) set it up, do it here.
|
|
*
|
|
* The R2025S/D does this a little differently than the other
|
|
* parts, so we special case that..
|
|
*/
|
|
err = rs5c_oscillator_setup(rs5c372);
|
|
if (unlikely(err < 0)) {
|
|
dev_err(&client->dev, "setup error\n");
|
|
goto exit_kfree;
|
|
}
|
|
|
|
if (rs5c372_get_datetime(client, &tm) < 0)
|
|
dev_warn(&client->dev, "clock needs to be set\n");
|
|
|
|
dev_info(&client->dev, "%s found, %s, driver version " DRV_VERSION "\n",
|
|
({ char *s; switch (rs5c372->type) {
|
|
case rtc_r2025sd: s = "r2025sd"; break;
|
|
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"
|
|
);
|
|
|
|
/* REVISIT use client->irq to register alarm irq ... */
|
|
|
|
rs5c372->rtc = rtc_device_register(rs5c372_driver.driver.name,
|
|
&client->dev, &rs5c372_rtc_ops, THIS_MODULE);
|
|
|
|
if (IS_ERR(rs5c372->rtc)) {
|
|
err = PTR_ERR(rs5c372->rtc);
|
|
goto exit_kfree;
|
|
}
|
|
|
|
err = rs5c_sysfs_register(&client->dev);
|
|
if (err)
|
|
goto exit_devreg;
|
|
|
|
return 0;
|
|
|
|
exit_devreg:
|
|
rtc_device_unregister(rs5c372->rtc);
|
|
|
|
exit_kfree:
|
|
kfree(rs5c372);
|
|
|
|
exit:
|
|
return err;
|
|
}
|
|
|
|
static int rs5c372_remove(struct i2c_client *client)
|
|
{
|
|
struct rs5c372 *rs5c372 = i2c_get_clientdata(client);
|
|
|
|
rtc_device_unregister(rs5c372->rtc);
|
|
rs5c_sysfs_unregister(&client->dev);
|
|
kfree(rs5c372);
|
|
return 0;
|
|
}
|
|
|
|
static struct i2c_driver rs5c372_driver = {
|
|
.driver = {
|
|
.name = "rtc-rs5c372",
|
|
},
|
|
.probe = rs5c372_probe,
|
|
.remove = rs5c372_remove,
|
|
.id_table = rs5c372_id,
|
|
};
|
|
|
|
static __init int rs5c372_init(void)
|
|
{
|
|
return i2c_add_driver(&rs5c372_driver);
|
|
}
|
|
|
|
static __exit void rs5c372_exit(void)
|
|
{
|
|
i2c_del_driver(&rs5c372_driver);
|
|
}
|
|
|
|
module_init(rs5c372_init);
|
|
module_exit(rs5c372_exit);
|
|
|
|
MODULE_AUTHOR(
|
|
"Pavel Mironchik <pmironchik@optifacio.net>, "
|
|
"Alessandro Zummo <a.zummo@towertech.it>, "
|
|
"Paul Mundt <lethal@linux-sh.org>");
|
|
MODULE_DESCRIPTION("Ricoh RS5C372 RTC driver");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_VERSION(DRV_VERSION);
|