[PATCH] rtc framewok: rtc_wkalrm.enabled reporting updates
[linux-2.6.git] / drivers / rtc / rtc-omap.c
1 /*
2  * TI OMAP1 Real Time Clock interface for Linux
3  *
4  * Copyright (C) 2003 MontaVista Software, Inc.
5  * Author: George G. Davis <gdavis@mvista.com> or <source@mvista.com>
6  *
7  * Copyright (C) 2006 David Brownell (new RTC framework)
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version
12  * 2 of the License, or (at your option) any later version.
13  */
14
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/ioport.h>
19 #include <linux/delay.h>
20 #include <linux/rtc.h>
21 #include <linux/bcd.h>
22 #include <linux/platform_device.h>
23
24 #include <asm/io.h>
25 #include <asm/mach/time.h>
26
27
28 /* The OMAP1 RTC is a year/month/day/hours/minutes/seconds BCD clock
29  * with century-range alarm matching, driven by the 32kHz clock.
30  *
31  * The main user-visible ways it differs from PC RTCs are by omitting
32  * "don't care" alarm fields and sub-second periodic IRQs, and having
33  * an autoadjust mechanism to calibrate to the true oscillator rate.
34  *
35  * Board-specific wiring options include using split power mode with
36  * RTC_OFF_NOFF used as the reset signal (so the RTC won't be reset),
37  * and wiring RTC_WAKE_INT (so the RTC alarm can wake the system from
38  * low power modes).  See the BOARD-SPECIFIC CUSTOMIZATION comment.
39  */
40
41 #define OMAP_RTC_BASE                   0xfffb4800
42
43 /* RTC registers */
44 #define OMAP_RTC_SECONDS_REG            0x00
45 #define OMAP_RTC_MINUTES_REG            0x04
46 #define OMAP_RTC_HOURS_REG              0x08
47 #define OMAP_RTC_DAYS_REG               0x0C
48 #define OMAP_RTC_MONTHS_REG             0x10
49 #define OMAP_RTC_YEARS_REG              0x14
50 #define OMAP_RTC_WEEKS_REG              0x18
51
52 #define OMAP_RTC_ALARM_SECONDS_REG      0x20
53 #define OMAP_RTC_ALARM_MINUTES_REG      0x24
54 #define OMAP_RTC_ALARM_HOURS_REG        0x28
55 #define OMAP_RTC_ALARM_DAYS_REG         0x2c
56 #define OMAP_RTC_ALARM_MONTHS_REG       0x30
57 #define OMAP_RTC_ALARM_YEARS_REG        0x34
58
59 #define OMAP_RTC_CTRL_REG               0x40
60 #define OMAP_RTC_STATUS_REG             0x44
61 #define OMAP_RTC_INTERRUPTS_REG         0x48
62
63 #define OMAP_RTC_COMP_LSB_REG           0x4c
64 #define OMAP_RTC_COMP_MSB_REG           0x50
65 #define OMAP_RTC_OSC_REG                0x54
66
67 /* OMAP_RTC_CTRL_REG bit fields: */
68 #define OMAP_RTC_CTRL_SPLIT             (1<<7)
69 #define OMAP_RTC_CTRL_DISABLE           (1<<6)
70 #define OMAP_RTC_CTRL_SET_32_COUNTER    (1<<5)
71 #define OMAP_RTC_CTRL_TEST              (1<<4)
72 #define OMAP_RTC_CTRL_MODE_12_24        (1<<3)
73 #define OMAP_RTC_CTRL_AUTO_COMP         (1<<2)
74 #define OMAP_RTC_CTRL_ROUND_30S         (1<<1)
75 #define OMAP_RTC_CTRL_STOP              (1<<0)
76
77 /* OMAP_RTC_STATUS_REG bit fields: */
78 #define OMAP_RTC_STATUS_POWER_UP        (1<<7)
79 #define OMAP_RTC_STATUS_ALARM           (1<<6)
80 #define OMAP_RTC_STATUS_1D_EVENT        (1<<5)
81 #define OMAP_RTC_STATUS_1H_EVENT        (1<<4)
82 #define OMAP_RTC_STATUS_1M_EVENT        (1<<3)
83 #define OMAP_RTC_STATUS_1S_EVENT        (1<<2)
84 #define OMAP_RTC_STATUS_RUN             (1<<1)
85 #define OMAP_RTC_STATUS_BUSY            (1<<0)
86
87 /* OMAP_RTC_INTERRUPTS_REG bit fields: */
88 #define OMAP_RTC_INTERRUPTS_IT_ALARM    (1<<3)
89 #define OMAP_RTC_INTERRUPTS_IT_TIMER    (1<<2)
90
91
92 #define rtc_read(addr)          omap_readb(OMAP_RTC_BASE + (addr))
93 #define rtc_write(val, addr)    omap_writeb(val, OMAP_RTC_BASE + (addr))
94
95
96 /* platform_bus isn't hotpluggable, so for static linkage it'd be safe
97  * to get rid of probe() and remove() code ... too bad the driver struct
98  * remembers probe(), that's about 25% of the runtime footprint!!
99  */
100 #ifndef MODULE
101 #undef  __devexit
102 #undef  __devexit_p
103 #define __devexit       __exit
104 #define __devexit_p     __exit_p
105 #endif
106
107
108 /* we rely on the rtc framework to handle locking (rtc->ops_lock),
109  * so the only other requirement is that register accesses which
110  * require BUSY to be clear are made with IRQs locally disabled
111  */
112 static void rtc_wait_not_busy(void)
113 {
114         int     count = 0;
115         u8      status;
116
117         /* BUSY may stay active for 1/32768 second (~30 usec) */
118         for (count = 0; count < 50; count++) {
119                 status = rtc_read(OMAP_RTC_STATUS_REG);
120                 if ((status & (u8)OMAP_RTC_STATUS_BUSY) == 0)
121                         break;
122                 udelay(1);
123         }
124         /* now we have ~15 usec to read/write various registers */
125 }
126
127 static irqreturn_t rtc_irq(int irq, void *class_dev)
128 {
129         unsigned long           events = 0;
130         u8                      irq_data;
131
132         irq_data = rtc_read(OMAP_RTC_STATUS_REG);
133
134         /* alarm irq? */
135         if (irq_data & OMAP_RTC_STATUS_ALARM) {
136                 rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
137                 events |= RTC_IRQF | RTC_AF;
138         }
139
140         /* 1/sec periodic/update irq? */
141         if (irq_data & OMAP_RTC_STATUS_1S_EVENT)
142                 events |= RTC_IRQF | RTC_UF;
143
144         rtc_update_irq(class_dev, 1, events);
145
146         return IRQ_HANDLED;
147 }
148
149 #ifdef  CONFIG_RTC_INTF_DEV
150
151 static int
152 omap_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
153 {
154         u8 reg;
155
156         switch (cmd) {
157         case RTC_AIE_OFF:
158         case RTC_AIE_ON:
159         case RTC_UIE_OFF:
160         case RTC_UIE_ON:
161                 break;
162         default:
163                 return -ENOIOCTLCMD;
164         }
165
166         local_irq_disable();
167         rtc_wait_not_busy();
168         reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
169         switch (cmd) {
170         /* AIE = Alarm Interrupt Enable */
171         case RTC_AIE_OFF:
172                 reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
173                 break;
174         case RTC_AIE_ON:
175                 reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
176                 break;
177         /* UIE = Update Interrupt Enable (1/second) */
178         case RTC_UIE_OFF:
179                 reg &= ~OMAP_RTC_INTERRUPTS_IT_TIMER;
180                 break;
181         case RTC_UIE_ON:
182                 reg |= OMAP_RTC_INTERRUPTS_IT_TIMER;
183                 break;
184         }
185         rtc_wait_not_busy();
186         rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
187         local_irq_enable();
188
189         return 0;
190 }
191
192 #else
193 #define omap_rtc_ioctl  NULL
194 #endif
195
196 /* this hardware doesn't support "don't care" alarm fields */
197 static int tm2bcd(struct rtc_time *tm)
198 {
199         if (rtc_valid_tm(tm) != 0)
200                 return -EINVAL;
201
202         tm->tm_sec = BIN2BCD(tm->tm_sec);
203         tm->tm_min = BIN2BCD(tm->tm_min);
204         tm->tm_hour = BIN2BCD(tm->tm_hour);
205         tm->tm_mday = BIN2BCD(tm->tm_mday);
206
207         tm->tm_mon = BIN2BCD(tm->tm_mon + 1);
208
209         /* epoch == 1900 */
210         if (tm->tm_year < 100 || tm->tm_year > 199)
211                 return -EINVAL;
212         tm->tm_year = BIN2BCD(tm->tm_year - 100);
213
214         return 0;
215 }
216
217 static void bcd2tm(struct rtc_time *tm)
218 {
219         tm->tm_sec = BCD2BIN(tm->tm_sec);
220         tm->tm_min = BCD2BIN(tm->tm_min);
221         tm->tm_hour = BCD2BIN(tm->tm_hour);
222         tm->tm_mday = BCD2BIN(tm->tm_mday);
223         tm->tm_mon = BCD2BIN(tm->tm_mon) - 1;
224         /* epoch == 1900 */
225         tm->tm_year = BCD2BIN(tm->tm_year) + 100;
226 }
227
228
229 static int omap_rtc_read_time(struct device *dev, struct rtc_time *tm)
230 {
231         /* we don't report wday/yday/isdst ... */
232         local_irq_disable();
233         rtc_wait_not_busy();
234
235         tm->tm_sec = rtc_read(OMAP_RTC_SECONDS_REG);
236         tm->tm_min = rtc_read(OMAP_RTC_MINUTES_REG);
237         tm->tm_hour = rtc_read(OMAP_RTC_HOURS_REG);
238         tm->tm_mday = rtc_read(OMAP_RTC_DAYS_REG);
239         tm->tm_mon = rtc_read(OMAP_RTC_MONTHS_REG);
240         tm->tm_year = rtc_read(OMAP_RTC_YEARS_REG);
241
242         local_irq_enable();
243
244         bcd2tm(tm);
245         return 0;
246 }
247
248 static int omap_rtc_set_time(struct device *dev, struct rtc_time *tm)
249 {
250         if (tm2bcd(tm) < 0)
251                 return -EINVAL;
252         local_irq_disable();
253         rtc_wait_not_busy();
254
255         rtc_write(tm->tm_year, OMAP_RTC_YEARS_REG);
256         rtc_write(tm->tm_mon, OMAP_RTC_MONTHS_REG);
257         rtc_write(tm->tm_mday, OMAP_RTC_DAYS_REG);
258         rtc_write(tm->tm_hour, OMAP_RTC_HOURS_REG);
259         rtc_write(tm->tm_min, OMAP_RTC_MINUTES_REG);
260         rtc_write(tm->tm_sec, OMAP_RTC_SECONDS_REG);
261
262         local_irq_enable();
263
264         return 0;
265 }
266
267 static int omap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
268 {
269         local_irq_disable();
270         rtc_wait_not_busy();
271
272         alm->time.tm_sec = rtc_read(OMAP_RTC_ALARM_SECONDS_REG);
273         alm->time.tm_min = rtc_read(OMAP_RTC_ALARM_MINUTES_REG);
274         alm->time.tm_hour = rtc_read(OMAP_RTC_ALARM_HOURS_REG);
275         alm->time.tm_mday = rtc_read(OMAP_RTC_ALARM_DAYS_REG);
276         alm->time.tm_mon = rtc_read(OMAP_RTC_ALARM_MONTHS_REG);
277         alm->time.tm_year = rtc_read(OMAP_RTC_ALARM_YEARS_REG);
278
279         local_irq_enable();
280
281         bcd2tm(&alm->time);
282         alm->enabled = !!(rtc_read(OMAP_RTC_INTERRUPTS_REG)
283                         & OMAP_RTC_INTERRUPTS_IT_ALARM);
284
285         return 0;
286 }
287
288 static int omap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
289 {
290         u8 reg;
291
292         /* Much userspace code uses RTC_ALM_SET, thus "don't care" for
293          * day/month/year specifies alarms up to 24 hours in the future.
294          * So we need to handle that ... but let's ignore the "don't care"
295          * values for hours/minutes/seconds.
296          */
297         if (alm->time.tm_mday <= 0
298                         && alm->time.tm_mon < 0
299                         && alm->time.tm_year < 0) {
300                 struct rtc_time tm;
301                 unsigned long now, then;
302
303                 omap_rtc_read_time(dev, &tm);
304                 rtc_tm_to_time(&tm, &now);
305
306                 alm->time.tm_mday = tm.tm_mday;
307                 alm->time.tm_mon = tm.tm_mon;
308                 alm->time.tm_year = tm.tm_year;
309                 rtc_tm_to_time(&alm->time, &then);
310
311                 /* sometimes the alarm wraps into tomorrow */
312                 if (then < now) {
313                         rtc_time_to_tm(now + 24 * 60 * 60, &tm);
314                         alm->time.tm_mday = tm.tm_mday;
315                         alm->time.tm_mon = tm.tm_mon;
316                         alm->time.tm_year = tm.tm_year;
317                 }
318         }
319
320         if (tm2bcd(&alm->time) < 0)
321                 return -EINVAL;
322
323         local_irq_disable();
324         rtc_wait_not_busy();
325
326         rtc_write(alm->time.tm_year, OMAP_RTC_ALARM_YEARS_REG);
327         rtc_write(alm->time.tm_mon, OMAP_RTC_ALARM_MONTHS_REG);
328         rtc_write(alm->time.tm_mday, OMAP_RTC_ALARM_DAYS_REG);
329         rtc_write(alm->time.tm_hour, OMAP_RTC_ALARM_HOURS_REG);
330         rtc_write(alm->time.tm_min, OMAP_RTC_ALARM_MINUTES_REG);
331         rtc_write(alm->time.tm_sec, OMAP_RTC_ALARM_SECONDS_REG);
332
333         reg = rtc_read(OMAP_RTC_INTERRUPTS_REG);
334         if (alm->enabled)
335                 reg |= OMAP_RTC_INTERRUPTS_IT_ALARM;
336         else
337                 reg &= ~OMAP_RTC_INTERRUPTS_IT_ALARM;
338         rtc_write(reg, OMAP_RTC_INTERRUPTS_REG);
339
340         local_irq_enable();
341
342         return 0;
343 }
344
345 static struct rtc_class_ops omap_rtc_ops = {
346         .ioctl          = omap_rtc_ioctl,
347         .read_time      = omap_rtc_read_time,
348         .set_time       = omap_rtc_set_time,
349         .read_alarm     = omap_rtc_read_alarm,
350         .set_alarm      = omap_rtc_set_alarm,
351 };
352
353 static int omap_rtc_alarm;
354 static int omap_rtc_timer;
355
356 static int __devinit omap_rtc_probe(struct platform_device *pdev)
357 {
358         struct resource         *res, *mem;
359         struct rtc_device       *rtc;
360         u8                      reg, new_ctrl;
361
362         omap_rtc_timer = platform_get_irq(pdev, 0);
363         if (omap_rtc_timer <= 0) {
364                 pr_debug("%s: no update irq?\n", pdev->name);
365                 return -ENOENT;
366         }
367
368         omap_rtc_alarm = platform_get_irq(pdev, 1);
369         if (omap_rtc_alarm <= 0) {
370                 pr_debug("%s: no alarm irq?\n", pdev->name);
371                 return -ENOENT;
372         }
373
374         /* NOTE:  using static mapping for RTC registers */
375         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
376         if (res && res->start != OMAP_RTC_BASE) {
377                 pr_debug("%s: RTC registers at %08x, expected %08x\n",
378                         pdev->name, (unsigned) res->start, OMAP_RTC_BASE);
379                 return -ENOENT;
380         }
381
382         if (res)
383                 mem = request_mem_region(res->start,
384                                 res->end - res->start + 1,
385                                 pdev->name);
386         else
387                 mem = NULL;
388         if (!mem) {
389                 pr_debug("%s: RTC registers at %08x are not free\n",
390                         pdev->name, OMAP_RTC_BASE);
391                 return -EBUSY;
392         }
393
394         rtc = rtc_device_register(pdev->name, &pdev->dev,
395                         &omap_rtc_ops, THIS_MODULE);
396         if (IS_ERR(rtc)) {
397                 pr_debug("%s: can't register RTC device, err %ld\n",
398                         pdev->name, PTR_ERR(rtc));
399                 goto fail;
400         }
401         platform_set_drvdata(pdev, rtc);
402         class_set_devdata(&rtc->class_dev, mem);
403
404         /* clear pending irqs, and set 1/second periodic,
405          * which we'll use instead of update irqs
406          */
407         rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
408
409         /* clear old status */
410         reg = rtc_read(OMAP_RTC_STATUS_REG);
411         if (reg & (u8) OMAP_RTC_STATUS_POWER_UP) {
412                 pr_info("%s: RTC power up reset detected\n",
413                         pdev->name);
414                 rtc_write(OMAP_RTC_STATUS_POWER_UP, OMAP_RTC_STATUS_REG);
415         }
416         if (reg & (u8) OMAP_RTC_STATUS_ALARM)
417                 rtc_write(OMAP_RTC_STATUS_ALARM, OMAP_RTC_STATUS_REG);
418
419         /* handle periodic and alarm irqs */
420         if (request_irq(omap_rtc_timer, rtc_irq, SA_INTERRUPT,
421                         rtc->class_dev.class_id, &rtc->class_dev)) {
422                 pr_debug("%s: RTC timer interrupt IRQ%d already claimed\n",
423                         pdev->name, omap_rtc_timer);
424                 goto fail0;
425         }
426         if (request_irq(omap_rtc_alarm, rtc_irq, SA_INTERRUPT,
427                         rtc->class_dev.class_id, &rtc->class_dev)) {
428                 pr_debug("%s: RTC alarm interrupt IRQ%d already claimed\n",
429                         pdev->name, omap_rtc_alarm);
430                 goto fail1;
431         }
432
433         /* On boards with split power, RTC_ON_NOFF won't reset the RTC */
434         reg = rtc_read(OMAP_RTC_CTRL_REG);
435         if (reg & (u8) OMAP_RTC_CTRL_STOP)
436                 pr_info("%s: already running\n", pdev->name);
437
438         /* force to 24 hour mode */
439         new_ctrl = reg & ~(OMAP_RTC_CTRL_SPLIT|OMAP_RTC_CTRL_AUTO_COMP);
440         new_ctrl |= OMAP_RTC_CTRL_STOP;
441
442         /* BOARD-SPECIFIC CUSTOMIZATION CAN GO HERE:
443          *
444          *  - Boards wired so that RTC_WAKE_INT does something, and muxed
445          *    right (W13_1610_RTC_WAKE_INT is the default after chip reset),
446          *    should initialize the device wakeup flag appropriately.
447          *
448          *  - Boards wired so RTC_ON_nOFF is used as the reset signal,
449          *    rather than nPWRON_RESET, should forcibly enable split
450          *    power mode.  (Some chip errata report that RTC_CTRL_SPLIT
451          *    is write-only, and always reads as zero...)
452          */
453         device_init_wakeup(&pdev->dev, 0);
454
455         if (new_ctrl & (u8) OMAP_RTC_CTRL_SPLIT)
456                 pr_info("%s: split power mode\n", pdev->name);
457
458         if (reg != new_ctrl)
459                 rtc_write(new_ctrl, OMAP_RTC_CTRL_REG);
460
461         return 0;
462
463 fail1:
464         free_irq(omap_rtc_timer, NULL);
465 fail0:
466         rtc_device_unregister(rtc);
467 fail:
468         release_resource(mem);
469         return -EIO;
470 }
471
472 static int __devexit omap_rtc_remove(struct platform_device *pdev)
473 {
474         struct rtc_device       *rtc = platform_get_drvdata(pdev);;
475
476         device_init_wakeup(&pdev->dev, 0);
477
478         /* leave rtc running, but disable irqs */
479         rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
480
481         free_irq(omap_rtc_timer, rtc);
482         free_irq(omap_rtc_alarm, rtc);
483
484         release_resource(class_get_devdata(&rtc->class_dev));
485         rtc_device_unregister(rtc);
486         return 0;
487 }
488
489 #ifdef CONFIG_PM
490
491 static struct timespec rtc_delta;
492 static u8 irqstat;
493
494 static int omap_rtc_suspend(struct platform_device *pdev, pm_message_t state)
495 {
496         struct rtc_time rtc_tm;
497         struct timespec time;
498
499         time.tv_nsec = 0;
500         omap_rtc_read_time(NULL, &rtc_tm);
501         rtc_tm_to_time(&rtc_tm, &time.tv_sec);
502
503         save_time_delta(&rtc_delta, &time);
504         irqstat = rtc_read(OMAP_RTC_INTERRUPTS_REG);
505
506         /* FIXME the RTC alarm is not currently acting as a wakeup event
507          * source, and in fact this enable() call is just saving a flag
508          * that's never used...
509          */
510         if (device_may_wakeup(&pdev->dev))
511                 enable_irq_wake(omap_rtc_alarm);
512         else
513                 rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
514
515         return 0;
516 }
517
518 static int omap_rtc_resume(struct platform_device *pdev)
519 {
520         struct rtc_time rtc_tm;
521         struct timespec time;
522
523         time.tv_nsec = 0;
524         omap_rtc_read_time(NULL, &rtc_tm);
525         rtc_tm_to_time(&rtc_tm, &time.tv_sec);
526
527         restore_time_delta(&rtc_delta, &time);
528         if (device_may_wakeup(&pdev->dev))
529                 disable_irq_wake(omap_rtc_alarm);
530         else
531                 rtc_write(irqstat, OMAP_RTC_INTERRUPTS_REG);
532         return 0;
533 }
534
535 #else
536 #define omap_rtc_suspend NULL
537 #define omap_rtc_resume  NULL
538 #endif
539
540 static void omap_rtc_shutdown(struct platform_device *pdev)
541 {
542         rtc_write(0, OMAP_RTC_INTERRUPTS_REG);
543 }
544
545 MODULE_ALIAS("omap_rtc");
546 static struct platform_driver omap_rtc_driver = {
547         .probe          = omap_rtc_probe,
548         .remove         = __devexit_p(omap_rtc_remove),
549         .suspend        = omap_rtc_suspend,
550         .resume         = omap_rtc_resume,
551         .shutdown       = omap_rtc_shutdown,
552         .driver         = {
553                 .name   = "omap_rtc",
554                 .owner  = THIS_MODULE,
555         },
556 };
557
558 static int __init rtc_init(void)
559 {
560         return platform_driver_register(&omap_rtc_driver);
561 }
562 module_init(rtc_init);
563
564 static void __exit rtc_exit(void)
565 {
566         platform_driver_unregister(&omap_rtc_driver);
567 }
568 module_exit(rtc_exit);
569
570 MODULE_AUTHOR("George G. Davis (and others)");
571 MODULE_LICENSE("GPL");