2 * I2C client/driver for the ST M41T80 family of i2c rtc chips.
4 * Author: Alexander Bigga <ab@mycable.de>
6 * Based on m41t00.c by Mark A. Greer <mgreer@mvista.com>
8 * 2006 (c) mycable GmbH
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
18 #include <linux/bcd.h>
19 #include <linux/i2c.h>
20 #include <linux/init.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/rtc.h>
24 #include <linux/slab.h>
25 #include <linux/mutex.h>
26 #include <linux/string.h>
27 #ifdef CONFIG_RTC_DRV_M41T80_WDT
29 #include <linux/ioctl.h>
30 #include <linux/miscdevice.h>
31 #include <linux/reboot.h>
32 #include <linux/watchdog.h>
35 #define M41T80_REG_SSEC 0x00
36 #define M41T80_REG_SEC 0x01
37 #define M41T80_REG_MIN 0x02
38 #define M41T80_REG_HOUR 0x03
39 #define M41T80_REG_WDAY 0x04
40 #define M41T80_REG_DAY 0x05
41 #define M41T80_REG_MON 0x06
42 #define M41T80_REG_YEAR 0x07
43 #define M41T80_REG_ALARM_MON 0x0a
44 #define M41T80_REG_ALARM_DAY 0x0b
45 #define M41T80_REG_ALARM_HOUR 0x0c
46 #define M41T80_REG_ALARM_MIN 0x0d
47 #define M41T80_REG_ALARM_SEC 0x0e
48 #define M41T80_REG_FLAGS 0x0f
49 #define M41T80_REG_SQW 0x13
51 #define M41T80_DATETIME_REG_SIZE (M41T80_REG_YEAR + 1)
52 #define M41T80_ALARM_REG_SIZE \
53 (M41T80_REG_ALARM_SEC + 1 - M41T80_REG_ALARM_MON)
55 #define M41T80_SEC_ST BIT(7) /* ST: Stop Bit */
56 #define M41T80_ALMON_AFE BIT(7) /* AFE: AF Enable Bit */
57 #define M41T80_ALMON_SQWE BIT(6) /* SQWE: SQW Enable Bit */
58 #define M41T80_ALHOUR_HT BIT(6) /* HT: Halt Update Bit */
59 #define M41T80_FLAGS_AF BIT(6) /* AF: Alarm Flag Bit */
60 #define M41T80_FLAGS_BATT_LOW BIT(4) /* BL: Battery Low Bit */
61 #define M41T80_WATCHDOG_RB2 BIT(7) /* RB: Watchdog resolution */
62 #define M41T80_WATCHDOG_RB1 BIT(1) /* RB: Watchdog resolution */
63 #define M41T80_WATCHDOG_RB0 BIT(0) /* RB: Watchdog resolution */
65 #define M41T80_FEATURE_HT BIT(0) /* Halt feature */
66 #define M41T80_FEATURE_BL BIT(1) /* Battery low indicator */
67 #define M41T80_FEATURE_SQ BIT(2) /* Squarewave feature */
68 #define M41T80_FEATURE_WD BIT(3) /* Extra watchdog resolution */
69 #define M41T80_FEATURE_SQ_ALT BIT(4) /* RSx bits are in reg 4 */
71 static DEFINE_MUTEX(m41t80_rtc_mutex
);
72 static const struct i2c_device_id m41t80_id
[] = {
73 { "m41t62", M41T80_FEATURE_SQ
| M41T80_FEATURE_SQ_ALT
},
74 { "m41t65", M41T80_FEATURE_HT
| M41T80_FEATURE_WD
},
75 { "m41t80", M41T80_FEATURE_SQ
},
76 { "m41t81", M41T80_FEATURE_HT
| M41T80_FEATURE_SQ
},
77 { "m41t81s", M41T80_FEATURE_HT
| M41T80_FEATURE_BL
| M41T80_FEATURE_SQ
},
78 { "m41t82", M41T80_FEATURE_HT
| M41T80_FEATURE_BL
| M41T80_FEATURE_SQ
},
79 { "m41t83", M41T80_FEATURE_HT
| M41T80_FEATURE_BL
| M41T80_FEATURE_SQ
},
80 { "m41st84", M41T80_FEATURE_HT
| M41T80_FEATURE_BL
| M41T80_FEATURE_SQ
},
81 { "m41st85", M41T80_FEATURE_HT
| M41T80_FEATURE_BL
| M41T80_FEATURE_SQ
},
82 { "m41st87", M41T80_FEATURE_HT
| M41T80_FEATURE_BL
| M41T80_FEATURE_SQ
},
83 { "rv4162", M41T80_FEATURE_SQ
| M41T80_FEATURE_WD
| M41T80_FEATURE_SQ_ALT
},
86 MODULE_DEVICE_TABLE(i2c
, m41t80_id
);
90 struct rtc_device
*rtc
;
93 static int m41t80_get_datetime(struct i2c_client
*client
,
99 err
= i2c_smbus_read_i2c_block_data(client
, M41T80_REG_SSEC
,
102 dev_err(&client
->dev
, "Unable to read date\n");
106 tm
->tm_sec
= bcd2bin(buf
[M41T80_REG_SEC
] & 0x7f);
107 tm
->tm_min
= bcd2bin(buf
[M41T80_REG_MIN
] & 0x7f);
108 tm
->tm_hour
= bcd2bin(buf
[M41T80_REG_HOUR
] & 0x3f);
109 tm
->tm_mday
= bcd2bin(buf
[M41T80_REG_DAY
] & 0x3f);
110 tm
->tm_wday
= buf
[M41T80_REG_WDAY
] & 0x07;
111 tm
->tm_mon
= bcd2bin(buf
[M41T80_REG_MON
] & 0x1f) - 1;
113 /* assume 20YY not 19YY, and ignore the Century Bit */
114 tm
->tm_year
= bcd2bin(buf
[M41T80_REG_YEAR
]) + 100;
115 return rtc_valid_tm(tm
);
118 /* Sets the given date and time to the real time clock. */
119 static int m41t80_set_datetime(struct i2c_client
*client
, struct rtc_time
*tm
)
121 unsigned char buf
[8];
124 if (tm
->tm_year
< 100 || tm
->tm_year
> 199)
127 buf
[M41T80_REG_SSEC
] = 0;
128 buf
[M41T80_REG_SEC
] = bin2bcd(tm
->tm_sec
);
129 buf
[M41T80_REG_MIN
] = bin2bcd(tm
->tm_min
);
130 buf
[M41T80_REG_HOUR
] = bin2bcd(tm
->tm_hour
);
131 buf
[M41T80_REG_DAY
] = bin2bcd(tm
->tm_mday
);
132 buf
[M41T80_REG_MON
] = bin2bcd(tm
->tm_mon
+ 1);
133 buf
[M41T80_REG_YEAR
] = bin2bcd(tm
->tm_year
- 100);
134 buf
[M41T80_REG_WDAY
] = tm
->tm_wday
;
136 err
= i2c_smbus_write_i2c_block_data(client
, M41T80_REG_SSEC
,
139 dev_err(&client
->dev
, "Unable to write to date registers\n");
146 static int m41t80_rtc_proc(struct device
*dev
, struct seq_file
*seq
)
148 struct i2c_client
*client
= to_i2c_client(dev
);
149 struct m41t80_data
*clientdata
= i2c_get_clientdata(client
);
152 if (clientdata
->features
& M41T80_FEATURE_BL
) {
153 reg
= i2c_smbus_read_byte_data(client
, M41T80_REG_FLAGS
);
154 seq_printf(seq
, "battery\t\t: %s\n",
155 (reg
& M41T80_FLAGS_BATT_LOW
) ? "exhausted" : "ok");
160 static int m41t80_rtc_read_time(struct device
*dev
, struct rtc_time
*tm
)
162 return m41t80_get_datetime(to_i2c_client(dev
), tm
);
165 static int m41t80_rtc_set_time(struct device
*dev
, struct rtc_time
*tm
)
167 return m41t80_set_datetime(to_i2c_client(dev
), tm
);
171 * XXX - m41t80 alarm functionality is reported broken.
172 * until it is fixed, don't register alarm functions.
174 static struct rtc_class_ops m41t80_rtc_ops
= {
175 .read_time
= m41t80_rtc_read_time
,
176 .set_time
= m41t80_rtc_set_time
,
177 .proc
= m41t80_rtc_proc
,
180 static ssize_t
flags_show(struct device
*dev
,
181 struct device_attribute
*attr
, char *buf
)
183 struct i2c_client
*client
= to_i2c_client(dev
);
186 val
= i2c_smbus_read_byte_data(client
, M41T80_REG_FLAGS
);
189 return sprintf(buf
, "%#x\n", val
);
191 static DEVICE_ATTR_RO(flags
);
193 static ssize_t
sqwfreq_show(struct device
*dev
,
194 struct device_attribute
*attr
, char *buf
)
196 struct i2c_client
*client
= to_i2c_client(dev
);
197 struct m41t80_data
*clientdata
= i2c_get_clientdata(client
);
200 if (!(clientdata
->features
& M41T80_FEATURE_SQ
))
203 reg_sqw
= M41T80_REG_SQW
;
204 if (clientdata
->features
& M41T80_FEATURE_SQ_ALT
)
205 reg_sqw
= M41T80_REG_WDAY
;
206 val
= i2c_smbus_read_byte_data(client
, reg_sqw
);
209 val
= (val
>> 4) & 0xf;
219 return sprintf(buf
, "%d\n", val
);
222 static ssize_t
sqwfreq_store(struct device
*dev
,
223 struct device_attribute
*attr
,
224 const char *buf
, size_t count
)
226 struct i2c_client
*client
= to_i2c_client(dev
);
227 struct m41t80_data
*clientdata
= i2c_get_clientdata(client
);
228 int almon
, sqw
, reg_sqw
, rc
;
231 rc
= kstrtoul(buf
, 0, &val
);
235 if (!(clientdata
->features
& M41T80_FEATURE_SQ
))
239 if (!is_power_of_2(val
))
249 /* disable SQW, set SQW frequency & re-enable */
250 almon
= i2c_smbus_read_byte_data(client
, M41T80_REG_ALARM_MON
);
253 reg_sqw
= M41T80_REG_SQW
;
254 if (clientdata
->features
& M41T80_FEATURE_SQ_ALT
)
255 reg_sqw
= M41T80_REG_WDAY
;
256 sqw
= i2c_smbus_read_byte_data(client
, reg_sqw
);
259 sqw
= (sqw
& 0x0f) | (val
<< 4);
261 rc
= i2c_smbus_write_byte_data(client
, M41T80_REG_ALARM_MON
,
262 almon
& ~M41T80_ALMON_SQWE
);
267 rc
= i2c_smbus_write_byte_data(client
, reg_sqw
, sqw
);
271 rc
= i2c_smbus_write_byte_data(client
, M41T80_REG_ALARM_MON
,
272 almon
| M41T80_ALMON_SQWE
);
278 static DEVICE_ATTR_RW(sqwfreq
);
280 static struct attribute
*attrs
[] = {
281 &dev_attr_flags
.attr
,
282 &dev_attr_sqwfreq
.attr
,
286 static struct attribute_group attr_group
= {
290 #ifdef CONFIG_RTC_DRV_M41T80_WDT
292 *****************************************************************************
296 *****************************************************************************
298 static struct i2c_client
*save_client
;
301 #define WD_TIMO 60 /* 1..31 seconds */
303 static int wdt_margin
= WD_TIMO
;
304 module_param(wdt_margin
, int, 0);
305 MODULE_PARM_DESC(wdt_margin
, "Watchdog timeout in seconds (default 60s)");
307 static unsigned long wdt_is_open
;
308 static int boot_flag
;
313 * Reload counter one with the watchdog timeout. We don't bother reloading
314 * the cascade counter.
316 static void wdt_ping(void)
318 unsigned char i2c_data
[2];
319 struct i2c_msg msgs1
[1] = {
321 .addr
= save_client
->addr
,
327 struct m41t80_data
*clientdata
= i2c_get_clientdata(save_client
);
329 i2c_data
[0] = 0x09; /* watchdog register */
332 i2c_data
[1] = (wdt_margin
& 0xFC) | 0x83; /* resolution = 4s */
335 * WDS = 1 (0x80), mulitplier = WD_TIMO, resolution = 1s (0x02)
337 i2c_data
[1] = wdt_margin
<< 2 | 0x82;
340 * M41T65 has three bits for watchdog resolution. Don't set bit 7, as
341 * that would be an invalid resolution.
343 if (clientdata
->features
& M41T80_FEATURE_WD
)
344 i2c_data
[1] &= ~M41T80_WATCHDOG_RB2
;
346 i2c_transfer(save_client
->adapter
, msgs1
, 1);
354 static void wdt_disable(void)
356 unsigned char i2c_data
[2], i2c_buf
[0x10];
357 struct i2c_msg msgs0
[2] = {
359 .addr
= save_client
->addr
,
365 .addr
= save_client
->addr
,
371 struct i2c_msg msgs1
[1] = {
373 .addr
= save_client
->addr
,
381 i2c_transfer(save_client
->adapter
, msgs0
, 2);
385 i2c_transfer(save_client
->adapter
, msgs1
, 1);
390 * @file: file handle to the watchdog
391 * @buf: buffer to write (unused as data does not matter here
392 * @count: count of bytes
393 * @ppos: pointer to the position to write. No seeks allowed
395 * A write to a watchdog device is defined as a keepalive signal. Any
396 * write of data will do, as we we don't define content meaning.
398 static ssize_t
wdt_write(struct file
*file
, const char __user
*buf
,
399 size_t count
, loff_t
*ppos
)
408 static ssize_t
wdt_read(struct file
*file
, char __user
*buf
,
409 size_t count
, loff_t
*ppos
)
416 * @inode: inode of the device
417 * @file: file handle to the device
418 * @cmd: watchdog command
419 * @arg: argument pointer
421 * The watchdog API defines a common set of functions for all watchdogs
422 * according to their available features. We only actually usefully support
423 * querying capabilities and current status.
425 static int wdt_ioctl(struct file
*file
, unsigned int cmd
,
429 static struct watchdog_info ident
= {
430 .options
= WDIOF_POWERUNDER
| WDIOF_KEEPALIVEPING
|
432 .firmware_version
= 1,
433 .identity
= "M41T80 WTD"
437 case WDIOC_GETSUPPORT
:
438 return copy_to_user((struct watchdog_info __user
*)arg
, &ident
,
439 sizeof(ident
)) ? -EFAULT
: 0;
441 case WDIOC_GETSTATUS
:
442 case WDIOC_GETBOOTSTATUS
:
443 return put_user(boot_flag
, (int __user
*)arg
);
444 case WDIOC_KEEPALIVE
:
447 case WDIOC_SETTIMEOUT
:
448 if (get_user(new_margin
, (int __user
*)arg
))
450 /* Arbitrary, can't find the card's limits */
451 if (new_margin
< 1 || new_margin
> 124)
453 wdt_margin
= new_margin
;
456 case WDIOC_GETTIMEOUT
:
457 return put_user(wdt_margin
, (int __user
*)arg
);
459 case WDIOC_SETOPTIONS
:
460 if (copy_from_user(&rv
, (int __user
*)arg
, sizeof(int)))
463 if (rv
& WDIOS_DISABLECARD
) {
464 pr_info("disable watchdog\n");
468 if (rv
& WDIOS_ENABLECARD
) {
469 pr_info("enable watchdog\n");
478 static long wdt_unlocked_ioctl(struct file
*file
, unsigned int cmd
,
483 mutex_lock(&m41t80_rtc_mutex
);
484 ret
= wdt_ioctl(file
, cmd
, arg
);
485 mutex_unlock(&m41t80_rtc_mutex
);
492 * @inode: inode of device
493 * @file: file handle to device
496 static int wdt_open(struct inode
*inode
, struct file
*file
)
498 if (MINOR(inode
->i_rdev
) == WATCHDOG_MINOR
) {
499 mutex_lock(&m41t80_rtc_mutex
);
500 if (test_and_set_bit(0, &wdt_is_open
)) {
501 mutex_unlock(&m41t80_rtc_mutex
);
508 mutex_unlock(&m41t80_rtc_mutex
);
509 return nonseekable_open(inode
, file
);
516 * @inode: inode to board
517 * @file: file handle to board
520 static int wdt_release(struct inode
*inode
, struct file
*file
)
522 if (MINOR(inode
->i_rdev
) == WATCHDOG_MINOR
)
523 clear_bit(0, &wdt_is_open
);
529 * @this: our notifier block
530 * @code: the event being reported
533 * Our notifier is called on system shutdowns. We want to turn the card
534 * off at reboot otherwise the machine will reboot again during memory
535 * test or worse yet during the following fsck. This would suck, in fact
536 * trust me - if it happens it does suck.
538 static int wdt_notify_sys(struct notifier_block
*this, unsigned long code
,
541 if (code
== SYS_DOWN
|| code
== SYS_HALT
)
542 /* Disable Watchdog */
547 static const struct file_operations wdt_fops
= {
548 .owner
= THIS_MODULE
,
550 .unlocked_ioctl
= wdt_unlocked_ioctl
,
553 .release
= wdt_release
,
557 static struct miscdevice wdt_dev
= {
558 .minor
= WATCHDOG_MINOR
,
564 * The WDT card needs to learn about soft shutdowns in order to
565 * turn the timebomb registers off.
567 static struct notifier_block wdt_notifier
= {
568 .notifier_call
= wdt_notify_sys
,
570 #endif /* CONFIG_RTC_DRV_M41T80_WDT */
573 *****************************************************************************
577 *****************************************************************************
580 static void m41t80_remove_sysfs_group(void *_dev
)
582 struct device
*dev
= _dev
;
584 sysfs_remove_group(&dev
->kobj
, &attr_group
);
587 static int m41t80_probe(struct i2c_client
*client
,
588 const struct i2c_device_id
*id
)
590 struct i2c_adapter
*adapter
= to_i2c_adapter(client
->dev
.parent
);
592 struct rtc_device
*rtc
= NULL
;
594 struct m41t80_data
*clientdata
= NULL
;
596 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_SMBUS_I2C_BLOCK
|
597 I2C_FUNC_SMBUS_BYTE_DATA
)) {
598 dev_err(&adapter
->dev
, "doesn't support I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK\n");
602 clientdata
= devm_kzalloc(&client
->dev
, sizeof(*clientdata
),
607 clientdata
->features
= id
->driver_data
;
608 i2c_set_clientdata(client
, clientdata
);
610 rtc
= devm_rtc_device_register(&client
->dev
, client
->name
,
611 &m41t80_rtc_ops
, THIS_MODULE
);
615 clientdata
->rtc
= rtc
;
617 /* Make sure HT (Halt Update) bit is cleared */
618 rc
= i2c_smbus_read_byte_data(client
, M41T80_REG_ALARM_HOUR
);
620 if (rc
>= 0 && rc
& M41T80_ALHOUR_HT
) {
621 if (clientdata
->features
& M41T80_FEATURE_HT
) {
622 m41t80_get_datetime(client
, &tm
);
623 dev_info(&client
->dev
, "HT bit was set!\n");
624 dev_info(&client
->dev
,
625 "Power Down at %04i-%02i-%02i %02i:%02i:%02i\n",
627 tm
.tm_mon
+ 1, tm
.tm_mday
, tm
.tm_hour
,
628 tm
.tm_min
, tm
.tm_sec
);
630 rc
= i2c_smbus_write_byte_data(client
, M41T80_REG_ALARM_HOUR
,
631 rc
& ~M41T80_ALHOUR_HT
);
635 dev_err(&client
->dev
, "Can't clear HT bit\n");
639 /* Make sure ST (stop) bit is cleared */
640 rc
= i2c_smbus_read_byte_data(client
, M41T80_REG_SEC
);
642 if (rc
>= 0 && rc
& M41T80_SEC_ST
)
643 rc
= i2c_smbus_write_byte_data(client
, M41T80_REG_SEC
,
644 rc
& ~M41T80_SEC_ST
);
646 dev_err(&client
->dev
, "Can't clear ST bit\n");
650 /* Export sysfs entries */
651 rc
= sysfs_create_group(&(&client
->dev
)->kobj
, &attr_group
);
653 dev_err(&client
->dev
, "Failed to create sysfs group: %d\n", rc
);
657 rc
= devm_add_action(&client
->dev
, m41t80_remove_sysfs_group
,
660 m41t80_remove_sysfs_group(&client
->dev
);
661 dev_err(&client
->dev
,
662 "Failed to add sysfs cleanup action: %d\n", rc
);
666 #ifdef CONFIG_RTC_DRV_M41T80_WDT
667 if (clientdata
->features
& M41T80_FEATURE_HT
) {
668 save_client
= client
;
669 rc
= misc_register(&wdt_dev
);
672 rc
= register_reboot_notifier(&wdt_notifier
);
674 misc_deregister(&wdt_dev
);
682 static int m41t80_remove(struct i2c_client
*client
)
684 #ifdef CONFIG_RTC_DRV_M41T80_WDT
685 struct m41t80_data
*clientdata
= i2c_get_clientdata(client
);
687 if (clientdata
->features
& M41T80_FEATURE_HT
) {
688 misc_deregister(&wdt_dev
);
689 unregister_reboot_notifier(&wdt_notifier
);
696 static struct i2c_driver m41t80_driver
= {
698 .name
= "rtc-m41t80",
700 .probe
= m41t80_probe
,
701 .remove
= m41t80_remove
,
702 .id_table
= m41t80_id
,
705 module_i2c_driver(m41t80_driver
);
707 MODULE_AUTHOR("Alexander Bigga <ab@mycable.de>");
708 MODULE_DESCRIPTION("ST Microelectronics M41T80 series RTC I2C Client Driver");
709 MODULE_LICENSE("GPL");