2 * rtc-twl.c -- TWL Real Time Clock interface
4 * Copyright (C) 2007 MontaVista Software, Inc
5 * Author: Alexandre Rusev <source@mvista.com>
7 * Based on original TI driver twl4030-rtc.c
8 * Copyright (C) 2006 Texas Instruments, Inc.
11 * Copyright (C) 2003 MontaVista Software, Inc.
12 * Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
13 * Copyright (C) 2006 David Brownell
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version
18 * 2 of the License, or (at your option) any later version.
21 #include <linux/kernel.h>
22 #include <linux/errno.h>
23 #include <linux/init.h>
24 #include <linux/module.h>
25 #include <linux/types.h>
26 #include <linux/rtc.h>
27 #include <linux/bcd.h>
28 #include <linux/platform_device.h>
29 #include <linux/interrupt.h>
31 #include <linux/i2c/twl.h>
35 * RTC block register offsets (use TWL_MODULE_RTC)
46 REG_ALARM_SECONDS_REG
,
47 REG_ALARM_MINUTES_REG
,
55 REG_RTC_INTERRUPTS_REG
,
60 static const u8 twl4030_rtc_reg_map
[] = {
61 [REG_SECONDS_REG
] = 0x00,
62 [REG_MINUTES_REG
] = 0x01,
63 [REG_HOURS_REG
] = 0x02,
64 [REG_DAYS_REG
] = 0x03,
65 [REG_MONTHS_REG
] = 0x04,
66 [REG_YEARS_REG
] = 0x05,
67 [REG_WEEKS_REG
] = 0x06,
69 [REG_ALARM_SECONDS_REG
] = 0x07,
70 [REG_ALARM_MINUTES_REG
] = 0x08,
71 [REG_ALARM_HOURS_REG
] = 0x09,
72 [REG_ALARM_DAYS_REG
] = 0x0A,
73 [REG_ALARM_MONTHS_REG
] = 0x0B,
74 [REG_ALARM_YEARS_REG
] = 0x0C,
76 [REG_RTC_CTRL_REG
] = 0x0D,
77 [REG_RTC_STATUS_REG
] = 0x0E,
78 [REG_RTC_INTERRUPTS_REG
] = 0x0F,
80 [REG_RTC_COMP_LSB_REG
] = 0x10,
81 [REG_RTC_COMP_MSB_REG
] = 0x11,
83 static const u8 twl6030_rtc_reg_map
[] = {
84 [REG_SECONDS_REG
] = 0x00,
85 [REG_MINUTES_REG
] = 0x01,
86 [REG_HOURS_REG
] = 0x02,
87 [REG_DAYS_REG
] = 0x03,
88 [REG_MONTHS_REG
] = 0x04,
89 [REG_YEARS_REG
] = 0x05,
90 [REG_WEEKS_REG
] = 0x06,
92 [REG_ALARM_SECONDS_REG
] = 0x08,
93 [REG_ALARM_MINUTES_REG
] = 0x09,
94 [REG_ALARM_HOURS_REG
] = 0x0A,
95 [REG_ALARM_DAYS_REG
] = 0x0B,
96 [REG_ALARM_MONTHS_REG
] = 0x0C,
97 [REG_ALARM_YEARS_REG
] = 0x0D,
99 [REG_RTC_CTRL_REG
] = 0x10,
100 [REG_RTC_STATUS_REG
] = 0x11,
101 [REG_RTC_INTERRUPTS_REG
] = 0x12,
103 [REG_RTC_COMP_LSB_REG
] = 0x13,
104 [REG_RTC_COMP_MSB_REG
] = 0x14,
107 /* RTC_CTRL_REG bitfields */
108 #define BIT_RTC_CTRL_REG_STOP_RTC_M 0x01
109 #define BIT_RTC_CTRL_REG_ROUND_30S_M 0x02
110 #define BIT_RTC_CTRL_REG_AUTO_COMP_M 0x04
111 #define BIT_RTC_CTRL_REG_MODE_12_24_M 0x08
112 #define BIT_RTC_CTRL_REG_TEST_MODE_M 0x10
113 #define BIT_RTC_CTRL_REG_SET_32_COUNTER_M 0x20
114 #define BIT_RTC_CTRL_REG_GET_TIME_M 0x40
115 #define BIT_RTC_CTRL_REG_RTC_V_OPT 0x80
117 /* RTC_STATUS_REG bitfields */
118 #define BIT_RTC_STATUS_REG_RUN_M 0x02
119 #define BIT_RTC_STATUS_REG_1S_EVENT_M 0x04
120 #define BIT_RTC_STATUS_REG_1M_EVENT_M 0x08
121 #define BIT_RTC_STATUS_REG_1H_EVENT_M 0x10
122 #define BIT_RTC_STATUS_REG_1D_EVENT_M 0x20
123 #define BIT_RTC_STATUS_REG_ALARM_M 0x40
124 #define BIT_RTC_STATUS_REG_POWER_UP_M 0x80
126 /* RTC_INTERRUPTS_REG bitfields */
127 #define BIT_RTC_INTERRUPTS_REG_EVERY_M 0x03
128 #define BIT_RTC_INTERRUPTS_REG_IT_TIMER_M 0x04
129 #define BIT_RTC_INTERRUPTS_REG_IT_ALARM_M 0x08
132 /* REG_SECONDS_REG through REG_YEARS_REG is how many registers? */
133 #define ALL_TIME_REGS 6
135 /*----------------------------------------------------------------------*/
136 static u8
*rtc_reg_map
;
139 * Supports 1 byte read from TWL RTC register.
141 static int twl_rtc_read_u8(u8
*data
, u8 reg
)
145 ret
= twl_i2c_read_u8(TWL_MODULE_RTC
, data
, (rtc_reg_map
[reg
]));
147 pr_err("twl_rtc: Could not read TWL"
148 "register %X - error %d\n", reg
, ret
);
153 * Supports 1 byte write to TWL RTC registers.
155 static int twl_rtc_write_u8(u8 data
, u8 reg
)
159 ret
= twl_i2c_write_u8(TWL_MODULE_RTC
, data
, (rtc_reg_map
[reg
]));
161 pr_err("twl_rtc: Could not write TWL"
162 "register %X - error %d\n", reg
, ret
);
167 * Cache the value for timer/alarm interrupts register; this is
168 * only changed by callers holding rtc ops lock (or resume).
170 static unsigned char rtc_irq_bits
;
173 * Enable 1/second update and/or alarm interrupts.
175 static int set_rtc_irq_bit(unsigned char bit
)
180 /* if the bit is set, return from here */
181 if (rtc_irq_bits
& bit
)
184 val
= rtc_irq_bits
| bit
;
185 val
&= ~BIT_RTC_INTERRUPTS_REG_EVERY_M
;
186 ret
= twl_rtc_write_u8(val
, REG_RTC_INTERRUPTS_REG
);
194 * Disable update and/or alarm interrupts.
196 static int mask_rtc_irq_bit(unsigned char bit
)
201 /* if the bit is clear, return from here */
202 if (!(rtc_irq_bits
& bit
))
205 val
= rtc_irq_bits
& ~bit
;
206 ret
= twl_rtc_write_u8(val
, REG_RTC_INTERRUPTS_REG
);
213 static int twl_rtc_alarm_irq_enable(struct device
*dev
, unsigned enabled
)
218 ret
= set_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M
);
220 ret
= mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M
);
226 * Gets current TWL RTC time and date parameters.
228 * The RTC's time/alarm representation is not what gmtime(3) requires
231 * - Months are 1..12 vs Linux 0-11
232 * - Years are 0..99 vs Linux 1900..N (we assume 21st century)
234 static int twl_rtc_read_time(struct device
*dev
, struct rtc_time
*tm
)
236 unsigned char rtc_data
[ALL_TIME_REGS
+ 1];
241 ret
= twl_rtc_read_u8(&save_control
, REG_RTC_CTRL_REG
);
243 dev_err(dev
, "%s: reading CTRL_REG, error %d\n", __func__
, ret
);
246 /* for twl6030/32 make sure BIT_RTC_CTRL_REG_GET_TIME_M is clear */
247 if (twl_class_is_6030()) {
248 if (save_control
& BIT_RTC_CTRL_REG_GET_TIME_M
) {
249 save_control
&= ~BIT_RTC_CTRL_REG_GET_TIME_M
;
250 ret
= twl_rtc_write_u8(save_control
, REG_RTC_CTRL_REG
);
252 dev_err(dev
, "%s clr GET_TIME, error %d\n",
259 /* Copy RTC counting registers to static registers or latches */
260 rtc_control
= save_control
| BIT_RTC_CTRL_REG_GET_TIME_M
;
262 /* for twl6030/32 enable read access to static shadowed registers */
263 if (twl_class_is_6030())
264 rtc_control
|= BIT_RTC_CTRL_REG_RTC_V_OPT
;
266 ret
= twl_rtc_write_u8(rtc_control
, REG_RTC_CTRL_REG
);
268 dev_err(dev
, "%s: writing CTRL_REG, error %d\n", __func__
, ret
);
272 ret
= twl_i2c_read(TWL_MODULE_RTC
, rtc_data
,
273 (rtc_reg_map
[REG_SECONDS_REG
]), ALL_TIME_REGS
);
276 dev_err(dev
, "%s: reading data, error %d\n", __func__
, ret
);
280 /* for twl6030 restore original state of rtc control register */
281 if (twl_class_is_6030()) {
282 ret
= twl_rtc_write_u8(save_control
, REG_RTC_CTRL_REG
);
284 dev_err(dev
, "%s: restore CTRL_REG, error %d\n",
290 tm
->tm_sec
= bcd2bin(rtc_data
[0]);
291 tm
->tm_min
= bcd2bin(rtc_data
[1]);
292 tm
->tm_hour
= bcd2bin(rtc_data
[2]);
293 tm
->tm_mday
= bcd2bin(rtc_data
[3]);
294 tm
->tm_mon
= bcd2bin(rtc_data
[4]) - 1;
295 tm
->tm_year
= bcd2bin(rtc_data
[5]) + 100;
300 static int twl_rtc_set_time(struct device
*dev
, struct rtc_time
*tm
)
302 unsigned char save_control
;
303 unsigned char rtc_data
[ALL_TIME_REGS
+ 1];
306 rtc_data
[1] = bin2bcd(tm
->tm_sec
);
307 rtc_data
[2] = bin2bcd(tm
->tm_min
);
308 rtc_data
[3] = bin2bcd(tm
->tm_hour
);
309 rtc_data
[4] = bin2bcd(tm
->tm_mday
);
310 rtc_data
[5] = bin2bcd(tm
->tm_mon
+ 1);
311 rtc_data
[6] = bin2bcd(tm
->tm_year
- 100);
313 /* Stop RTC while updating the TC registers */
314 ret
= twl_rtc_read_u8(&save_control
, REG_RTC_CTRL_REG
);
318 save_control
&= ~BIT_RTC_CTRL_REG_STOP_RTC_M
;
319 ret
= twl_rtc_write_u8(save_control
, REG_RTC_CTRL_REG
);
323 /* update all the time registers in one shot */
324 ret
= twl_i2c_write(TWL_MODULE_RTC
, rtc_data
,
325 (rtc_reg_map
[REG_SECONDS_REG
]), ALL_TIME_REGS
);
327 dev_err(dev
, "rtc_set_time error %d\n", ret
);
332 save_control
|= BIT_RTC_CTRL_REG_STOP_RTC_M
;
333 ret
= twl_rtc_write_u8(save_control
, REG_RTC_CTRL_REG
);
340 * Gets current TWL RTC alarm time.
342 static int twl_rtc_read_alarm(struct device
*dev
, struct rtc_wkalrm
*alm
)
344 unsigned char rtc_data
[ALL_TIME_REGS
+ 1];
347 ret
= twl_i2c_read(TWL_MODULE_RTC
, rtc_data
,
348 (rtc_reg_map
[REG_ALARM_SECONDS_REG
]), ALL_TIME_REGS
);
350 dev_err(dev
, "rtc_read_alarm error %d\n", ret
);
354 /* some of these fields may be wildcard/"match all" */
355 alm
->time
.tm_sec
= bcd2bin(rtc_data
[0]);
356 alm
->time
.tm_min
= bcd2bin(rtc_data
[1]);
357 alm
->time
.tm_hour
= bcd2bin(rtc_data
[2]);
358 alm
->time
.tm_mday
= bcd2bin(rtc_data
[3]);
359 alm
->time
.tm_mon
= bcd2bin(rtc_data
[4]) - 1;
360 alm
->time
.tm_year
= bcd2bin(rtc_data
[5]) + 100;
362 /* report cached alarm enable state */
363 if (rtc_irq_bits
& BIT_RTC_INTERRUPTS_REG_IT_ALARM_M
)
369 static int twl_rtc_set_alarm(struct device
*dev
, struct rtc_wkalrm
*alm
)
371 unsigned char alarm_data
[ALL_TIME_REGS
+ 1];
374 ret
= twl_rtc_alarm_irq_enable(dev
, 0);
378 alarm_data
[1] = bin2bcd(alm
->time
.tm_sec
);
379 alarm_data
[2] = bin2bcd(alm
->time
.tm_min
);
380 alarm_data
[3] = bin2bcd(alm
->time
.tm_hour
);
381 alarm_data
[4] = bin2bcd(alm
->time
.tm_mday
);
382 alarm_data
[5] = bin2bcd(alm
->time
.tm_mon
+ 1);
383 alarm_data
[6] = bin2bcd(alm
->time
.tm_year
- 100);
385 /* update all the alarm registers in one shot */
386 ret
= twl_i2c_write(TWL_MODULE_RTC
, alarm_data
,
387 (rtc_reg_map
[REG_ALARM_SECONDS_REG
]), ALL_TIME_REGS
);
389 dev_err(dev
, "rtc_set_alarm error %d\n", ret
);
394 ret
= twl_rtc_alarm_irq_enable(dev
, 1);
399 static irqreturn_t
twl_rtc_interrupt(int irq
, void *rtc
)
401 unsigned long events
;
406 res
= twl_rtc_read_u8(&rd_reg
, REG_RTC_STATUS_REG
);
410 * Figure out source of interrupt: ALARM or TIMER in RTC_STATUS_REG.
411 * only one (ALARM or RTC) interrupt source may be enabled
412 * at time, we also could check our results
413 * by reading RTS_INTERRUPTS_REGISTER[IT_TIMER,IT_ALARM]
415 if (rd_reg
& BIT_RTC_STATUS_REG_ALARM_M
)
416 events
= RTC_IRQF
| RTC_AF
;
418 events
= RTC_IRQF
| RTC_PF
;
420 res
= twl_rtc_write_u8(BIT_RTC_STATUS_REG_ALARM_M
,
425 if (twl_class_is_4030()) {
426 /* Clear on Read enabled. RTC_IT bit of TWL4030_INT_PWR_ISR1
427 * needs 2 reads to clear the interrupt. One read is done in
428 * do_twl_pwrirq(). Doing the second read, to clear
431 * FIXME the reason PWR_ISR1 needs an extra read is that
432 * RTC_IF retriggered until we cleared REG_ALARM_M above.
433 * But re-reading like this is a bad hack; by doing so we
434 * risk wrongly clearing status for some other IRQ (losing
435 * the interrupt). Be smarter about handling RTC_UF ...
437 res
= twl_i2c_read_u8(TWL4030_MODULE_INT
,
438 &rd_reg
, TWL4030_INT_PWR_ISR1
);
443 /* Notify RTC core on event */
444 rtc_update_irq(rtc
, 1, events
);
451 static struct rtc_class_ops twl_rtc_ops
= {
452 .read_time
= twl_rtc_read_time
,
453 .set_time
= twl_rtc_set_time
,
454 .read_alarm
= twl_rtc_read_alarm
,
455 .set_alarm
= twl_rtc_set_alarm
,
456 .alarm_irq_enable
= twl_rtc_alarm_irq_enable
,
459 /*----------------------------------------------------------------------*/
461 static int __devinit
twl_rtc_probe(struct platform_device
*pdev
)
463 struct rtc_device
*rtc
;
465 int irq
= platform_get_irq(pdev
, 0);
471 ret
= twl_rtc_read_u8(&rd_reg
, REG_RTC_STATUS_REG
);
475 if (rd_reg
& BIT_RTC_STATUS_REG_POWER_UP_M
)
476 dev_warn(&pdev
->dev
, "Power up reset detected.\n");
478 if (rd_reg
& BIT_RTC_STATUS_REG_ALARM_M
)
479 dev_warn(&pdev
->dev
, "Pending Alarm interrupt detected.\n");
481 /* Clear RTC Power up reset and pending alarm interrupts */
482 ret
= twl_rtc_write_u8(rd_reg
, REG_RTC_STATUS_REG
);
486 if (twl_class_is_6030()) {
487 twl6030_interrupt_unmask(TWL6030_RTC_INT_MASK
,
489 twl6030_interrupt_unmask(TWL6030_RTC_INT_MASK
,
493 dev_info(&pdev
->dev
, "Enabling TWL-RTC\n");
494 ret
= twl_rtc_write_u8(BIT_RTC_CTRL_REG_STOP_RTC_M
, REG_RTC_CTRL_REG
);
498 /* init cached IRQ enable bits */
499 ret
= twl_rtc_read_u8(&rtc_irq_bits
, REG_RTC_INTERRUPTS_REG
);
503 rtc
= rtc_device_register(pdev
->name
,
504 &pdev
->dev
, &twl_rtc_ops
, THIS_MODULE
);
507 dev_err(&pdev
->dev
, "can't register RTC device, err %ld\n",
512 ret
= request_threaded_irq(irq
, NULL
, twl_rtc_interrupt
,
513 IRQF_TRIGGER_RISING
| IRQF_ONESHOT
,
514 dev_name(&rtc
->dev
), rtc
);
516 dev_err(&pdev
->dev
, "IRQ is not free.\n");
520 platform_set_drvdata(pdev
, rtc
);
524 rtc_device_unregister(rtc
);
530 * Disable all TWL RTC module interrupts.
531 * Sets status flag to free.
533 static int __devexit
twl_rtc_remove(struct platform_device
*pdev
)
535 /* leave rtc running, but disable irqs */
536 struct rtc_device
*rtc
= platform_get_drvdata(pdev
);
537 int irq
= platform_get_irq(pdev
, 0);
539 mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_ALARM_M
);
540 mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M
);
541 if (twl_class_is_6030()) {
542 twl6030_interrupt_mask(TWL6030_RTC_INT_MASK
,
544 twl6030_interrupt_mask(TWL6030_RTC_INT_MASK
,
551 rtc_device_unregister(rtc
);
552 platform_set_drvdata(pdev
, NULL
);
556 static void twl_rtc_shutdown(struct platform_device
*pdev
)
558 /* mask timer interrupts, but leave alarm interrupts on to enable
559 power-on when alarm is triggered */
560 mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M
);
565 static unsigned char irqstat
;
567 static int twl_rtc_suspend(struct platform_device
*pdev
, pm_message_t state
)
569 irqstat
= rtc_irq_bits
;
571 mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M
);
575 static int twl_rtc_resume(struct platform_device
*pdev
)
577 set_rtc_irq_bit(irqstat
);
582 #define twl_rtc_suspend NULL
583 #define twl_rtc_resume NULL
586 static const struct of_device_id twl_rtc_of_match
[] = {
587 {.compatible
= "ti,twl4030-rtc", },
590 MODULE_DEVICE_TABLE(of
, twl_rtc_of_match
);
591 MODULE_ALIAS("platform:twl_rtc");
593 static struct platform_driver twl4030rtc_driver
= {
594 .probe
= twl_rtc_probe
,
595 .remove
= __devexit_p(twl_rtc_remove
),
596 .shutdown
= twl_rtc_shutdown
,
597 .suspend
= twl_rtc_suspend
,
598 .resume
= twl_rtc_resume
,
600 .owner
= THIS_MODULE
,
602 .of_match_table
= twl_rtc_of_match
,
606 static int __init
twl_rtc_init(void)
608 if (twl_class_is_4030())
609 rtc_reg_map
= (u8
*) twl4030_rtc_reg_map
;
611 rtc_reg_map
= (u8
*) twl6030_rtc_reg_map
;
613 return platform_driver_register(&twl4030rtc_driver
);
615 module_init(twl_rtc_init
);
617 static void __exit
twl_rtc_exit(void)
619 platform_driver_unregister(&twl4030rtc_driver
);
621 module_exit(twl_rtc_exit
);
623 MODULE_AUTHOR("Texas Instruments, MontaVista Software");
624 MODULE_LICENSE("GPL");