2 * An I2C driver for the Philips PCF8563 RTC
3 * Copyright 2005-06 Tower Technologies
5 * Author: Alessandro Zummo <a.zummo@towertech.it>
6 * Maintainers: http://www.nslu2-linux.org/
8 * based on the other drivers in this same directory.
10 * http://www.semiconductors.philips.com/acrobat/datasheets/PCF8563-04.pdf
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
17 #include <linux/i2c.h>
18 #include <linux/bcd.h>
19 #include <linux/rtc.h>
20 #include <linux/slab.h>
21 #include <linux/module.h>
23 #include <linux/err.h>
25 #define DRV_VERSION "0.4.3"
27 #define PCF8563_REG_ST1 0x00 /* status */
28 #define PCF8563_REG_ST2 0x01
29 #define PCF8563_BIT_AIE (1 << 1)
30 #define PCF8563_BIT_AF (1 << 3)
32 #define PCF8563_REG_SC 0x02 /* datetime */
33 #define PCF8563_REG_MN 0x03
34 #define PCF8563_REG_HR 0x04
35 #define PCF8563_REG_DM 0x05
36 #define PCF8563_REG_DW 0x06
37 #define PCF8563_REG_MO 0x07
38 #define PCF8563_REG_YR 0x08
40 #define PCF8563_REG_AMN 0x09 /* alarm */
42 #define PCF8563_REG_CLKO 0x0D /* clock out */
43 #define PCF8563_REG_TMRC 0x0E /* timer control */
44 #define PCF8563_REG_TMR 0x0F /* timer */
46 #define PCF8563_SC_LV 0x80 /* low voltage */
47 #define PCF8563_MO_C 0x80 /* century */
49 static struct i2c_driver pcf8563_driver
;
52 struct rtc_device
*rtc
;
54 * The meaning of MO_C bit varies by the chip type.
55 * From PCF8563 datasheet: this bit is toggled when the years
56 * register overflows from 99 to 00
57 * 0 indicates the century is 20xx
58 * 1 indicates the century is 19xx
59 * From RTC8564 datasheet: this bit indicates change of
60 * century. When the year digit data overflows from 99 to 00,
61 * this bit is set. By presetting it to 0 while still in the
62 * 20th century, it will be set in year 2000, ...
63 * There seems no reliable way to know how the system use this
64 * bit. So let's do it heuristically, assuming we are live in
67 int c_polarity
; /* 0: MO_C=1 means 19xx, otherwise MO_C=1 means 20xx */
68 int voltage_low
; /* incicates if a low_voltage was detected */
70 struct i2c_client
*client
;
73 static int pcf8563_read_block_data(struct i2c_client
*client
, unsigned char reg
,
74 unsigned char length
, unsigned char *buf
)
76 struct i2c_msg msgs
[] = {
90 if ((i2c_transfer(client
->adapter
, msgs
, 2)) != 2) {
91 dev_err(&client
->dev
, "%s: read error\n", __func__
);
98 static int pcf8563_write_block_data(struct i2c_client
*client
,
99 unsigned char reg
, unsigned char length
,
104 for (i
= 0; i
< length
; i
++) {
105 unsigned char data
[2] = { reg
+ i
, buf
[i
] };
107 err
= i2c_master_send(client
, data
, sizeof(data
));
108 if (err
!= sizeof(data
)) {
109 dev_err(&client
->dev
,
110 "%s: err=%d addr=%02x, data=%02x\n",
111 __func__
, err
, data
[0], data
[1]);
119 static int pcf8563_set_alarm_mode(struct i2c_client
*client
, bool on
)
121 unsigned char buf
[2];
124 err
= pcf8563_read_block_data(client
, PCF8563_REG_ST2
, 1, buf
+ 1);
129 buf
[1] |= PCF8563_BIT_AIE
;
131 buf
[1] &= ~PCF8563_BIT_AIE
;
133 buf
[1] &= ~PCF8563_BIT_AF
;
134 buf
[0] = PCF8563_REG_ST2
;
136 err
= pcf8563_write_block_data(client
, PCF8563_REG_ST2
, 1, buf
+ 1);
138 dev_err(&client
->dev
, "%s: write error\n", __func__
);
145 static int pcf8563_get_alarm_mode(struct i2c_client
*client
, unsigned char *en
,
151 err
= pcf8563_read_block_data(client
, PCF8563_REG_ST2
, 1, &buf
);
156 *en
= !!(buf
& PCF8563_BIT_AIE
);
158 *pen
= !!(buf
& PCF8563_BIT_AF
);
163 static irqreturn_t
pcf8563_irq(int irq
, void *dev_id
)
165 struct pcf8563
*pcf8563
= i2c_get_clientdata(dev_id
);
169 err
= pcf8563_get_alarm_mode(pcf8563
->client
, NULL
, &pending
);
174 rtc_update_irq(pcf8563
->rtc
, 1, RTC_IRQF
| RTC_AF
);
175 pcf8563_set_alarm_mode(pcf8563
->client
, 1);
183 * In the routines that deal directly with the pcf8563 hardware, we use
184 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
186 static int pcf8563_get_datetime(struct i2c_client
*client
, struct rtc_time
*tm
)
188 struct pcf8563
*pcf8563
= i2c_get_clientdata(client
);
189 unsigned char buf
[9];
192 err
= pcf8563_read_block_data(client
, PCF8563_REG_ST1
, 9, buf
);
196 if (buf
[PCF8563_REG_SC
] & PCF8563_SC_LV
) {
197 pcf8563
->voltage_low
= 1;
198 dev_info(&client
->dev
,
199 "low voltage detected, date/time is not reliable.\n");
202 dev_dbg(&client
->dev
,
203 "%s: raw data is st1=%02x, st2=%02x, sec=%02x, min=%02x, hr=%02x, "
204 "mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
206 buf
[0], buf
[1], buf
[2], buf
[3],
207 buf
[4], buf
[5], buf
[6], buf
[7],
211 tm
->tm_sec
= bcd2bin(buf
[PCF8563_REG_SC
] & 0x7F);
212 tm
->tm_min
= bcd2bin(buf
[PCF8563_REG_MN
] & 0x7F);
213 tm
->tm_hour
= bcd2bin(buf
[PCF8563_REG_HR
] & 0x3F); /* rtc hr 0-23 */
214 tm
->tm_mday
= bcd2bin(buf
[PCF8563_REG_DM
] & 0x3F);
215 tm
->tm_wday
= buf
[PCF8563_REG_DW
] & 0x07;
216 tm
->tm_mon
= bcd2bin(buf
[PCF8563_REG_MO
] & 0x1F) - 1; /* rtc mn 1-12 */
217 tm
->tm_year
= bcd2bin(buf
[PCF8563_REG_YR
]);
218 if (tm
->tm_year
< 70)
219 tm
->tm_year
+= 100; /* assume we are in 1970...2069 */
220 /* detect the polarity heuristically. see note above. */
221 pcf8563
->c_polarity
= (buf
[PCF8563_REG_MO
] & PCF8563_MO_C
) ?
222 (tm
->tm_year
>= 100) : (tm
->tm_year
< 100);
224 dev_dbg(&client
->dev
, "%s: tm is secs=%d, mins=%d, hours=%d, "
225 "mday=%d, mon=%d, year=%d, wday=%d\n",
227 tm
->tm_sec
, tm
->tm_min
, tm
->tm_hour
,
228 tm
->tm_mday
, tm
->tm_mon
, tm
->tm_year
, tm
->tm_wday
);
230 /* the clock can give out invalid datetime, but we cannot return
231 * -EINVAL otherwise hwclock will refuse to set the time on bootup.
233 if (rtc_valid_tm(tm
) < 0)
234 dev_err(&client
->dev
, "retrieved date/time is not valid.\n");
239 static int pcf8563_set_datetime(struct i2c_client
*client
, struct rtc_time
*tm
)
241 struct pcf8563
*pcf8563
= i2c_get_clientdata(client
);
243 unsigned char buf
[9];
245 dev_dbg(&client
->dev
, "%s: secs=%d, mins=%d, hours=%d, "
246 "mday=%d, mon=%d, year=%d, wday=%d\n",
248 tm
->tm_sec
, tm
->tm_min
, tm
->tm_hour
,
249 tm
->tm_mday
, tm
->tm_mon
, tm
->tm_year
, tm
->tm_wday
);
251 /* hours, minutes and seconds */
252 buf
[PCF8563_REG_SC
] = bin2bcd(tm
->tm_sec
);
253 buf
[PCF8563_REG_MN
] = bin2bcd(tm
->tm_min
);
254 buf
[PCF8563_REG_HR
] = bin2bcd(tm
->tm_hour
);
256 buf
[PCF8563_REG_DM
] = bin2bcd(tm
->tm_mday
);
259 buf
[PCF8563_REG_MO
] = bin2bcd(tm
->tm_mon
+ 1);
261 /* year and century */
262 buf
[PCF8563_REG_YR
] = bin2bcd(tm
->tm_year
% 100);
263 if (pcf8563
->c_polarity
? (tm
->tm_year
>= 100) : (tm
->tm_year
< 100))
264 buf
[PCF8563_REG_MO
] |= PCF8563_MO_C
;
266 buf
[PCF8563_REG_DW
] = tm
->tm_wday
& 0x07;
268 err
= pcf8563_write_block_data(client
, PCF8563_REG_SC
,
269 9 - PCF8563_REG_SC
, buf
+ PCF8563_REG_SC
);
276 #ifdef CONFIG_RTC_INTF_DEV
277 static int pcf8563_rtc_ioctl(struct device
*dev
, unsigned int cmd
, unsigned long arg
)
279 struct pcf8563
*pcf8563
= i2c_get_clientdata(to_i2c_client(dev
));
284 if (pcf8563
->voltage_low
)
285 dev_info(dev
, "low voltage detected, date/time is not reliable.\n");
287 if (copy_to_user((void __user
*)arg
, &pcf8563
->voltage_low
,
293 * Clear the VL bit in the seconds register in case
294 * the time has not been set already (which would
295 * have cleared it). This does not really matter
296 * because of the cached voltage_low value but do it
297 * anyway for consistency.
299 if (pcf8563_get_datetime(to_i2c_client(dev
), &tm
))
300 pcf8563_set_datetime(to_i2c_client(dev
), &tm
);
302 /* Clear the cached value. */
303 pcf8563
->voltage_low
= 0;
311 #define pcf8563_rtc_ioctl NULL
314 static int pcf8563_rtc_read_time(struct device
*dev
, struct rtc_time
*tm
)
316 return pcf8563_get_datetime(to_i2c_client(dev
), tm
);
319 static int pcf8563_rtc_set_time(struct device
*dev
, struct rtc_time
*tm
)
321 return pcf8563_set_datetime(to_i2c_client(dev
), tm
);
324 static int pcf8563_rtc_read_alarm(struct device
*dev
, struct rtc_wkalrm
*tm
)
326 struct i2c_client
*client
= to_i2c_client(dev
);
327 unsigned char buf
[4];
330 err
= pcf8563_read_block_data(client
, PCF8563_REG_AMN
, 4, buf
);
334 dev_dbg(&client
->dev
,
335 "%s: raw data is min=%02x, hr=%02x, mday=%02x, wday=%02x\n",
336 __func__
, buf
[0], buf
[1], buf
[2], buf
[3]);
338 tm
->time
.tm_min
= bcd2bin(buf
[0] & 0x7F);
339 tm
->time
.tm_hour
= bcd2bin(buf
[1] & 0x7F);
340 tm
->time
.tm_mday
= bcd2bin(buf
[2] & 0x1F);
341 tm
->time
.tm_wday
= bcd2bin(buf
[3] & 0x7);
342 tm
->time
.tm_mon
= -1;
343 tm
->time
.tm_year
= -1;
344 tm
->time
.tm_yday
= -1;
345 tm
->time
.tm_isdst
= -1;
347 err
= pcf8563_get_alarm_mode(client
, &tm
->enabled
, &tm
->pending
);
351 dev_dbg(&client
->dev
, "%s: tm is mins=%d, hours=%d, mday=%d, wday=%d,"
352 " enabled=%d, pending=%d\n", __func__
, tm
->time
.tm_min
,
353 tm
->time
.tm_hour
, tm
->time
.tm_mday
, tm
->time
.tm_wday
,
354 tm
->enabled
, tm
->pending
);
359 static int pcf8563_rtc_set_alarm(struct device
*dev
, struct rtc_wkalrm
*tm
)
361 struct i2c_client
*client
= to_i2c_client(dev
);
362 unsigned char buf
[4];
365 dev_dbg(dev
, "%s, min=%d hour=%d wday=%d mday=%d "
366 "enabled=%d pending=%d\n", __func__
,
367 tm
->time
.tm_min
, tm
->time
.tm_hour
, tm
->time
.tm_wday
,
368 tm
->time
.tm_mday
, tm
->enabled
, tm
->pending
);
370 buf
[0] = bin2bcd(tm
->time
.tm_min
);
371 buf
[1] = bin2bcd(tm
->time
.tm_hour
);
372 buf
[2] = bin2bcd(tm
->time
.tm_mday
);
373 buf
[3] = tm
->time
.tm_wday
& 0x07;
375 err
= pcf8563_write_block_data(client
, PCF8563_REG_AMN
, 4, buf
);
379 return pcf8563_set_alarm_mode(client
, 1);
382 static int pcf8563_irq_enable(struct device
*dev
, unsigned int enabled
)
384 return pcf8563_set_alarm_mode(to_i2c_client(dev
), !!enabled
);
387 static const struct rtc_class_ops pcf8563_rtc_ops
= {
388 .ioctl
= pcf8563_rtc_ioctl
,
389 .read_time
= pcf8563_rtc_read_time
,
390 .set_time
= pcf8563_rtc_set_time
,
391 .read_alarm
= pcf8563_rtc_read_alarm
,
392 .set_alarm
= pcf8563_rtc_set_alarm
,
393 .alarm_irq_enable
= pcf8563_irq_enable
,
396 static int pcf8563_probe(struct i2c_client
*client
,
397 const struct i2c_device_id
*id
)
399 struct pcf8563
*pcf8563
;
402 dev_dbg(&client
->dev
, "%s\n", __func__
);
404 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_I2C
))
407 pcf8563
= devm_kzalloc(&client
->dev
, sizeof(struct pcf8563
),
412 dev_info(&client
->dev
, "chip found, driver version " DRV_VERSION
"\n");
414 i2c_set_clientdata(client
, pcf8563
);
415 pcf8563
->client
= client
;
416 device_set_wakeup_capable(&client
->dev
, 1);
418 pcf8563
->rtc
= devm_rtc_device_register(&client
->dev
,
419 pcf8563_driver
.driver
.name
,
420 &pcf8563_rtc_ops
, THIS_MODULE
);
422 if (IS_ERR(pcf8563
->rtc
))
423 return PTR_ERR(pcf8563
->rtc
);
425 if (client
->irq
> 0) {
426 err
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
428 IRQF_SHARED
|IRQF_ONESHOT
|IRQF_TRIGGER_FALLING
,
429 pcf8563
->rtc
->name
, client
);
431 dev_err(&client
->dev
, "unable to request IRQ %d\n",
441 static const struct i2c_device_id pcf8563_id
[] = {
446 MODULE_DEVICE_TABLE(i2c
, pcf8563_id
);
449 static const struct of_device_id pcf8563_of_match
[] = {
450 { .compatible
= "nxp,pcf8563" },
453 MODULE_DEVICE_TABLE(of
, pcf8563_of_match
);
456 static struct i2c_driver pcf8563_driver
= {
458 .name
= "rtc-pcf8563",
459 .owner
= THIS_MODULE
,
460 .of_match_table
= of_match_ptr(pcf8563_of_match
),
462 .probe
= pcf8563_probe
,
463 .id_table
= pcf8563_id
,
466 module_i2c_driver(pcf8563_driver
);
468 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
469 MODULE_DESCRIPTION("Philips PCF8563/Epson RTC8564 RTC driver");
470 MODULE_LICENSE("GPL");
471 MODULE_VERSION(DRV_VERSION
);