2 * SuperH On-Chip RTC Support
4 * Copyright (C) 2006, 2007, 2008 Paul Mundt
5 * Copyright (C) 2006 Jamie Lenehan
6 * Copyright (C) 2008 Angelo Castello
8 * Based on the old arch/sh/kernel/cpu/rtc.c by:
10 * Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org>
11 * Copyright (C) 1999 Tetsuya Okada & Niibe Yutaka
13 * This file is subject to the terms and conditions of the GNU General Public
14 * License. See the file "COPYING" in the main directory of this archive
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/bcd.h>
20 #include <linux/rtc.h>
21 #include <linux/init.h>
22 #include <linux/platform_device.h>
23 #include <linux/seq_file.h>
24 #include <linux/interrupt.h>
25 #include <linux/spinlock.h>
29 #define DRV_NAME "sh-rtc"
30 #define DRV_VERSION "0.2.0"
32 #define RTC_REG(r) ((r) * rtc_reg_size)
34 #define R64CNT RTC_REG(0)
36 #define RSECCNT RTC_REG(1) /* RTC sec */
37 #define RMINCNT RTC_REG(2) /* RTC min */
38 #define RHRCNT RTC_REG(3) /* RTC hour */
39 #define RWKCNT RTC_REG(4) /* RTC week */
40 #define RDAYCNT RTC_REG(5) /* RTC day */
41 #define RMONCNT RTC_REG(6) /* RTC month */
42 #define RYRCNT RTC_REG(7) /* RTC year */
43 #define RSECAR RTC_REG(8) /* ALARM sec */
44 #define RMINAR RTC_REG(9) /* ALARM min */
45 #define RHRAR RTC_REG(10) /* ALARM hour */
46 #define RWKAR RTC_REG(11) /* ALARM week */
47 #define RDAYAR RTC_REG(12) /* ALARM day */
48 #define RMONAR RTC_REG(13) /* ALARM month */
49 #define RCR1 RTC_REG(14) /* Control */
50 #define RCR2 RTC_REG(15) /* Control */
53 * Note on RYRAR and RCR3: Up until this point most of the register
54 * definitions are consistent across all of the available parts. However,
55 * the placement of the optional RYRAR and RCR3 (the RYRAR control
56 * register used to control RYRCNT/RYRAR compare) varies considerably
57 * across various parts, occasionally being mapped in to a completely
58 * unrelated address space. For proper RYRAR support a separate resource
59 * would have to be handed off, but as this is purely optional in
60 * practice, we simply opt not to support it, thereby keeping the code
61 * quite a bit more simplified.
64 /* ALARM Bits - or with BCD encoded value */
65 #define AR_ENB 0x80 /* Enable for alarm cmp */
68 #define PF_HP 0x100 /* Enable Half Period to support 8,32,128Hz */
69 #define PF_COUNT 0x200 /* Half periodic counter */
70 #define PF_OXS 0x400 /* Periodic One x Second */
71 #define PF_KOU 0x800 /* Kernel or User periodic request 1=kernel */
75 #define RCR1_CF 0x80 /* Carry Flag */
76 #define RCR1_CIE 0x10 /* Carry Interrupt Enable */
77 #define RCR1_AIE 0x08 /* Alarm Interrupt Enable */
78 #define RCR1_AF 0x01 /* Alarm Flag */
81 #define RCR2_PEF 0x80 /* PEriodic interrupt Flag */
82 #define RCR2_PESMASK 0x70 /* Periodic interrupt Set */
83 #define RCR2_RTCEN 0x08 /* ENable RTC */
84 #define RCR2_ADJ 0x04 /* ADJustment (30-second) */
85 #define RCR2_RESET 0x02 /* Reset bit */
86 #define RCR2_START 0x01 /* Start bit */
89 void __iomem
*regbase
;
90 unsigned long regsize
;
92 unsigned int alarm_irq
, periodic_irq
, carry_irq
;
93 struct rtc_device
*rtc_dev
;
95 unsigned long capabilities
; /* See asm-sh/rtc.h for cap bits */
96 unsigned short periodic_freq
;
99 static irqreturn_t
sh_rtc_interrupt(int irq
, void *dev_id
)
101 struct sh_rtc
*rtc
= dev_id
;
104 spin_lock(&rtc
->lock
);
106 tmp
= readb(rtc
->regbase
+ RCR1
);
108 writeb(tmp
, rtc
->regbase
+ RCR1
);
110 /* Users have requested One x Second IRQ */
111 if (rtc
->periodic_freq
& PF_OXS
)
112 rtc_update_irq(rtc
->rtc_dev
, 1, RTC_UF
| RTC_IRQF
);
114 spin_unlock(&rtc
->lock
);
119 static irqreturn_t
sh_rtc_alarm(int irq
, void *dev_id
)
121 struct sh_rtc
*rtc
= dev_id
;
124 spin_lock(&rtc
->lock
);
126 tmp
= readb(rtc
->regbase
+ RCR1
);
127 tmp
&= ~(RCR1_AF
| RCR1_AIE
);
128 writeb(tmp
, rtc
->regbase
+ RCR1
);
130 rtc_update_irq(rtc
->rtc_dev
, 1, RTC_AF
| RTC_IRQF
);
132 spin_unlock(&rtc
->lock
);
137 static irqreturn_t
sh_rtc_periodic(int irq
, void *dev_id
)
139 struct sh_rtc
*rtc
= dev_id
;
140 struct rtc_device
*rtc_dev
= rtc
->rtc_dev
;
143 spin_lock(&rtc
->lock
);
145 tmp
= readb(rtc
->regbase
+ RCR2
);
147 writeb(tmp
, rtc
->regbase
+ RCR2
);
149 /* Half period enabled than one skipped and the next notified */
150 if ((rtc
->periodic_freq
& PF_HP
) && (rtc
->periodic_freq
& PF_COUNT
))
151 rtc
->periodic_freq
&= ~PF_COUNT
;
153 if (rtc
->periodic_freq
& PF_HP
)
154 rtc
->periodic_freq
|= PF_COUNT
;
155 if (rtc
->periodic_freq
& PF_KOU
) {
156 spin_lock(&rtc_dev
->irq_task_lock
);
157 if (rtc_dev
->irq_task
)
158 rtc_dev
->irq_task
->func(rtc_dev
->irq_task
->private_data
);
159 spin_unlock(&rtc_dev
->irq_task_lock
);
161 rtc_update_irq(rtc
->rtc_dev
, 1, RTC_PF
| RTC_IRQF
);
164 spin_unlock(&rtc
->lock
);
169 static inline void sh_rtc_setpie(struct device
*dev
, unsigned int enable
)
171 struct sh_rtc
*rtc
= dev_get_drvdata(dev
);
174 spin_lock_irq(&rtc
->lock
);
176 tmp
= readb(rtc
->regbase
+ RCR2
);
179 tmp
&= ~RCR2_PEF
; /* Clear PES bit */
180 tmp
|= (rtc
->periodic_freq
& ~PF_HP
); /* Set PES2-0 */
182 tmp
&= ~(RCR2_PESMASK
| RCR2_PEF
);
184 writeb(tmp
, rtc
->regbase
+ RCR2
);
186 spin_unlock_irq(&rtc
->lock
);
189 static inline int sh_rtc_setfreq(struct device
*dev
, unsigned int freq
)
191 struct sh_rtc
*rtc
= dev_get_drvdata(dev
);
194 spin_lock_irq(&rtc
->lock
);
195 tmp
= rtc
->periodic_freq
& PF_MASK
;
199 rtc
->periodic_freq
= 0x00;
202 rtc
->periodic_freq
= 0x60;
205 rtc
->periodic_freq
= 0x50;
208 rtc
->periodic_freq
= 0x40;
211 rtc
->periodic_freq
= 0x30 | PF_HP
;
214 rtc
->periodic_freq
= 0x30;
217 rtc
->periodic_freq
= 0x20 | PF_HP
;
220 rtc
->periodic_freq
= 0x20;
223 rtc
->periodic_freq
= 0x10 | PF_HP
;
226 rtc
->periodic_freq
= 0x10;
233 rtc
->periodic_freq
|= tmp
;
234 rtc
->rtc_dev
->irq_freq
= freq
;
237 spin_unlock_irq(&rtc
->lock
);
241 static inline void sh_rtc_setaie(struct device
*dev
, unsigned int enable
)
243 struct sh_rtc
*rtc
= dev_get_drvdata(dev
);
246 spin_lock_irq(&rtc
->lock
);
248 tmp
= readb(rtc
->regbase
+ RCR1
);
255 writeb(tmp
, rtc
->regbase
+ RCR1
);
257 spin_unlock_irq(&rtc
->lock
);
260 static int sh_rtc_proc(struct device
*dev
, struct seq_file
*seq
)
262 struct sh_rtc
*rtc
= dev_get_drvdata(dev
);
265 tmp
= readb(rtc
->regbase
+ RCR1
);
266 seq_printf(seq
, "carry_IRQ\t: %s\n", (tmp
& RCR1_CIE
) ? "yes" : "no");
268 tmp
= readb(rtc
->regbase
+ RCR2
);
269 seq_printf(seq
, "periodic_IRQ\t: %s\n",
270 (tmp
& RCR2_PESMASK
) ? "yes" : "no");
275 static int sh_rtc_ioctl(struct device
*dev
, unsigned int cmd
, unsigned long arg
)
277 struct sh_rtc
*rtc
= dev_get_drvdata(dev
);
278 unsigned int ret
= 0;
283 sh_rtc_setpie(dev
, cmd
== RTC_PIE_ON
);
287 sh_rtc_setaie(dev
, cmd
== RTC_AIE_ON
);
290 rtc
->periodic_freq
&= ~PF_OXS
;
293 rtc
->periodic_freq
|= PF_OXS
;
296 ret
= put_user(rtc
->rtc_dev
->irq_freq
,
297 (unsigned long __user
*)arg
);
300 ret
= sh_rtc_setfreq(dev
, arg
);
309 static int sh_rtc_read_time(struct device
*dev
, struct rtc_time
*tm
)
311 struct platform_device
*pdev
= to_platform_device(dev
);
312 struct sh_rtc
*rtc
= platform_get_drvdata(pdev
);
313 unsigned int sec128
, sec2
, yr
, yr100
, cf_bit
;
318 spin_lock_irq(&rtc
->lock
);
320 tmp
= readb(rtc
->regbase
+ RCR1
);
321 tmp
&= ~RCR1_CF
; /* Clear CF-bit */
323 writeb(tmp
, rtc
->regbase
+ RCR1
);
325 sec128
= readb(rtc
->regbase
+ R64CNT
);
327 tm
->tm_sec
= bcd2bin(readb(rtc
->regbase
+ RSECCNT
));
328 tm
->tm_min
= bcd2bin(readb(rtc
->regbase
+ RMINCNT
));
329 tm
->tm_hour
= bcd2bin(readb(rtc
->regbase
+ RHRCNT
));
330 tm
->tm_wday
= bcd2bin(readb(rtc
->regbase
+ RWKCNT
));
331 tm
->tm_mday
= bcd2bin(readb(rtc
->regbase
+ RDAYCNT
));
332 tm
->tm_mon
= bcd2bin(readb(rtc
->regbase
+ RMONCNT
)) - 1;
334 if (rtc
->capabilities
& RTC_CAP_4_DIGIT_YEAR
) {
335 yr
= readw(rtc
->regbase
+ RYRCNT
);
336 yr100
= bcd2bin(yr
>> 8);
339 yr
= readb(rtc
->regbase
+ RYRCNT
);
340 yr100
= bcd2bin((yr
== 0x99) ? 0x19 : 0x20);
343 tm
->tm_year
= (yr100
* 100 + bcd2bin(yr
)) - 1900;
345 sec2
= readb(rtc
->regbase
+ R64CNT
);
346 cf_bit
= readb(rtc
->regbase
+ RCR1
) & RCR1_CF
;
348 spin_unlock_irq(&rtc
->lock
);
349 } while (cf_bit
!= 0 || ((sec128
^ sec2
) & RTC_BIT_INVERTED
) != 0);
351 #if RTC_BIT_INVERTED != 0
352 if ((sec128
& RTC_BIT_INVERTED
))
356 dev_dbg(dev
, "%s: tm is secs=%d, mins=%d, hours=%d, "
357 "mday=%d, mon=%d, year=%d, wday=%d\n",
359 tm
->tm_sec
, tm
->tm_min
, tm
->tm_hour
,
360 tm
->tm_mday
, tm
->tm_mon
+ 1, tm
->tm_year
, tm
->tm_wday
);
362 if (rtc_valid_tm(tm
) < 0) {
363 dev_err(dev
, "invalid date\n");
364 rtc_time_to_tm(0, tm
);
370 static int sh_rtc_set_time(struct device
*dev
, struct rtc_time
*tm
)
372 struct platform_device
*pdev
= to_platform_device(dev
);
373 struct sh_rtc
*rtc
= platform_get_drvdata(pdev
);
377 spin_lock_irq(&rtc
->lock
);
379 /* Reset pre-scaler & stop RTC */
380 tmp
= readb(rtc
->regbase
+ RCR2
);
383 writeb(tmp
, rtc
->regbase
+ RCR2
);
385 writeb(bin2bcd(tm
->tm_sec
), rtc
->regbase
+ RSECCNT
);
386 writeb(bin2bcd(tm
->tm_min
), rtc
->regbase
+ RMINCNT
);
387 writeb(bin2bcd(tm
->tm_hour
), rtc
->regbase
+ RHRCNT
);
388 writeb(bin2bcd(tm
->tm_wday
), rtc
->regbase
+ RWKCNT
);
389 writeb(bin2bcd(tm
->tm_mday
), rtc
->regbase
+ RDAYCNT
);
390 writeb(bin2bcd(tm
->tm_mon
+ 1), rtc
->regbase
+ RMONCNT
);
392 if (rtc
->capabilities
& RTC_CAP_4_DIGIT_YEAR
) {
393 year
= (bin2bcd((tm
->tm_year
+ 1900) / 100) << 8) |
394 bin2bcd(tm
->tm_year
% 100);
395 writew(year
, rtc
->regbase
+ RYRCNT
);
397 year
= tm
->tm_year
% 100;
398 writeb(bin2bcd(year
), rtc
->regbase
+ RYRCNT
);
402 tmp
= readb(rtc
->regbase
+ RCR2
);
404 tmp
|= RCR2_RTCEN
| RCR2_START
;
405 writeb(tmp
, rtc
->regbase
+ RCR2
);
407 spin_unlock_irq(&rtc
->lock
);
412 static inline int sh_rtc_read_alarm_value(struct sh_rtc
*rtc
, int reg_off
)
415 int value
= 0xff; /* return 0xff for ignored values */
417 byte
= readb(rtc
->regbase
+ reg_off
);
419 byte
&= ~AR_ENB
; /* strip the enable bit */
420 value
= bcd2bin(byte
);
426 static int sh_rtc_read_alarm(struct device
*dev
, struct rtc_wkalrm
*wkalrm
)
428 struct platform_device
*pdev
= to_platform_device(dev
);
429 struct sh_rtc
*rtc
= platform_get_drvdata(pdev
);
430 struct rtc_time
*tm
= &wkalrm
->time
;
432 spin_lock_irq(&rtc
->lock
);
434 tm
->tm_sec
= sh_rtc_read_alarm_value(rtc
, RSECAR
);
435 tm
->tm_min
= sh_rtc_read_alarm_value(rtc
, RMINAR
);
436 tm
->tm_hour
= sh_rtc_read_alarm_value(rtc
, RHRAR
);
437 tm
->tm_wday
= sh_rtc_read_alarm_value(rtc
, RWKAR
);
438 tm
->tm_mday
= sh_rtc_read_alarm_value(rtc
, RDAYAR
);
439 tm
->tm_mon
= sh_rtc_read_alarm_value(rtc
, RMONAR
);
441 tm
->tm_mon
-= 1; /* RTC is 1-12, tm_mon is 0-11 */
442 tm
->tm_year
= 0xffff;
444 wkalrm
->enabled
= (readb(rtc
->regbase
+ RCR1
) & RCR1_AIE
) ? 1 : 0;
446 spin_unlock_irq(&rtc
->lock
);
451 static inline void sh_rtc_write_alarm_value(struct sh_rtc
*rtc
,
452 int value
, int reg_off
)
454 /* < 0 for a value that is ignored */
456 writeb(0, rtc
->regbase
+ reg_off
);
458 writeb(bin2bcd(value
) | AR_ENB
, rtc
->regbase
+ reg_off
);
461 static int sh_rtc_check_alarm(struct rtc_time
*tm
)
464 * The original rtc says anything > 0xc0 is "don't care" or "match
465 * all" - most users use 0xff but rtc-dev uses -1 for the same thing.
466 * The original rtc doesn't support years - some things use -1 and
467 * some 0xffff. We use -1 to make out tests easier.
469 if (tm
->tm_year
== 0xffff)
471 if (tm
->tm_mon
>= 0xff)
473 if (tm
->tm_mday
>= 0xff)
475 if (tm
->tm_wday
>= 0xff)
477 if (tm
->tm_hour
>= 0xff)
479 if (tm
->tm_min
>= 0xff)
481 if (tm
->tm_sec
>= 0xff)
484 if (tm
->tm_year
> 9999 ||
486 tm
->tm_mday
== 0 || tm
->tm_mday
>= 32 ||
496 static int sh_rtc_set_alarm(struct device
*dev
, struct rtc_wkalrm
*wkalrm
)
498 struct platform_device
*pdev
= to_platform_device(dev
);
499 struct sh_rtc
*rtc
= platform_get_drvdata(pdev
);
501 struct rtc_time
*tm
= &wkalrm
->time
;
504 err
= sh_rtc_check_alarm(tm
);
505 if (unlikely(err
< 0))
508 spin_lock_irq(&rtc
->lock
);
510 /* disable alarm interrupt and clear the alarm flag */
511 rcr1
= readb(rtc
->regbase
+ RCR1
);
512 rcr1
&= ~(RCR1_AF
| RCR1_AIE
);
513 writeb(rcr1
, rtc
->regbase
+ RCR1
);
516 sh_rtc_write_alarm_value(rtc
, tm
->tm_sec
, RSECAR
);
517 sh_rtc_write_alarm_value(rtc
, tm
->tm_min
, RMINAR
);
518 sh_rtc_write_alarm_value(rtc
, tm
->tm_hour
, RHRAR
);
519 sh_rtc_write_alarm_value(rtc
, tm
->tm_wday
, RWKAR
);
520 sh_rtc_write_alarm_value(rtc
, tm
->tm_mday
, RDAYAR
);
524 sh_rtc_write_alarm_value(rtc
, mon
, RMONAR
);
526 if (wkalrm
->enabled
) {
528 writeb(rcr1
, rtc
->regbase
+ RCR1
);
531 spin_unlock_irq(&rtc
->lock
);
536 static int sh_rtc_irq_set_state(struct device
*dev
, int enabled
)
538 struct platform_device
*pdev
= to_platform_device(dev
);
539 struct sh_rtc
*rtc
= platform_get_drvdata(pdev
);
542 rtc
->periodic_freq
|= PF_KOU
;
543 return sh_rtc_ioctl(dev
, RTC_PIE_ON
, 0);
545 rtc
->periodic_freq
&= ~PF_KOU
;
546 return sh_rtc_ioctl(dev
, RTC_PIE_OFF
, 0);
550 static int sh_rtc_irq_set_freq(struct device
*dev
, int freq
)
552 return sh_rtc_ioctl(dev
, RTC_IRQP_SET
, freq
);
555 static struct rtc_class_ops sh_rtc_ops
= {
556 .ioctl
= sh_rtc_ioctl
,
557 .read_time
= sh_rtc_read_time
,
558 .set_time
= sh_rtc_set_time
,
559 .read_alarm
= sh_rtc_read_alarm
,
560 .set_alarm
= sh_rtc_set_alarm
,
561 .irq_set_state
= sh_rtc_irq_set_state
,
562 .irq_set_freq
= sh_rtc_irq_set_freq
,
566 static int __devinit
sh_rtc_probe(struct platform_device
*pdev
)
569 struct resource
*res
;
573 rtc
= kzalloc(sizeof(struct sh_rtc
), GFP_KERNEL
);
577 spin_lock_init(&rtc
->lock
);
579 /* get periodic/carry/alarm irqs */
580 ret
= platform_get_irq(pdev
, 0);
581 if (unlikely(ret
< 0)) {
583 dev_err(&pdev
->dev
, "No IRQ for period\n");
586 rtc
->periodic_irq
= ret
;
588 ret
= platform_get_irq(pdev
, 1);
589 if (unlikely(ret
< 0)) {
591 dev_err(&pdev
->dev
, "No IRQ for carry\n");
594 rtc
->carry_irq
= ret
;
596 ret
= platform_get_irq(pdev
, 2);
597 if (unlikely(ret
< 0)) {
599 dev_err(&pdev
->dev
, "No IRQ for alarm\n");
602 rtc
->alarm_irq
= ret
;
604 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
605 if (unlikely(res
== NULL
)) {
607 dev_err(&pdev
->dev
, "No IO resource\n");
611 rtc
->regsize
= res
->end
- res
->start
+ 1;
613 rtc
->res
= request_mem_region(res
->start
, rtc
->regsize
, pdev
->name
);
614 if (unlikely(!rtc
->res
)) {
619 rtc
->regbase
= ioremap_nocache(rtc
->res
->start
, rtc
->regsize
);
620 if (unlikely(!rtc
->regbase
)) {
625 rtc
->rtc_dev
= rtc_device_register("sh", &pdev
->dev
,
626 &sh_rtc_ops
, THIS_MODULE
);
627 if (IS_ERR(rtc
->rtc_dev
)) {
628 ret
= PTR_ERR(rtc
->rtc_dev
);
632 rtc
->capabilities
= RTC_DEF_CAPABILITIES
;
633 if (pdev
->dev
.platform_data
) {
634 struct sh_rtc_platform_info
*pinfo
= pdev
->dev
.platform_data
;
637 * Some CPUs have special capabilities in addition to the
638 * default set. Add those in here.
640 rtc
->capabilities
|= pinfo
->capabilities
;
643 rtc
->rtc_dev
->max_user_freq
= 256;
644 rtc
->rtc_dev
->irq_freq
= 1;
645 rtc
->periodic_freq
= 0x60;
647 platform_set_drvdata(pdev
, rtc
);
649 /* register periodic/carry/alarm irqs */
650 ret
= request_irq(rtc
->periodic_irq
, sh_rtc_periodic
, IRQF_DISABLED
,
651 "sh-rtc period", rtc
);
654 "request period IRQ failed with %d, IRQ %d\n", ret
,
659 ret
= request_irq(rtc
->carry_irq
, sh_rtc_interrupt
, IRQF_DISABLED
,
660 "sh-rtc carry", rtc
);
663 "request carry IRQ failed with %d, IRQ %d\n", ret
,
665 free_irq(rtc
->periodic_irq
, rtc
);
669 ret
= request_irq(rtc
->alarm_irq
, sh_rtc_alarm
, IRQF_DISABLED
,
670 "sh-rtc alarm", rtc
);
673 "request alarm IRQ failed with %d, IRQ %d\n", ret
,
675 free_irq(rtc
->carry_irq
, rtc
);
676 free_irq(rtc
->periodic_irq
, rtc
);
680 tmp
= readb(rtc
->regbase
+ RCR1
);
683 writeb(tmp
, rtc
->regbase
+ RCR1
);
688 iounmap(rtc
->regbase
);
690 release_resource(rtc
->res
);
697 static int __devexit
sh_rtc_remove(struct platform_device
*pdev
)
699 struct sh_rtc
*rtc
= platform_get_drvdata(pdev
);
701 if (likely(rtc
->rtc_dev
))
702 rtc_device_unregister(rtc
->rtc_dev
);
704 sh_rtc_setpie(&pdev
->dev
, 0);
705 sh_rtc_setaie(&pdev
->dev
, 0);
707 free_irq(rtc
->carry_irq
, rtc
);
708 free_irq(rtc
->periodic_irq
, rtc
);
709 free_irq(rtc
->alarm_irq
, rtc
);
711 release_resource(rtc
->res
);
713 iounmap(rtc
->regbase
);
715 platform_set_drvdata(pdev
, NULL
);
721 static struct platform_driver sh_rtc_platform_driver
= {
724 .owner
= THIS_MODULE
,
726 .probe
= sh_rtc_probe
,
727 .remove
= __devexit_p(sh_rtc_remove
),
730 static int __init
sh_rtc_init(void)
732 return platform_driver_register(&sh_rtc_platform_driver
);
735 static void __exit
sh_rtc_exit(void)
737 platform_driver_unregister(&sh_rtc_platform_driver
);
740 module_init(sh_rtc_init
);
741 module_exit(sh_rtc_exit
);
743 MODULE_DESCRIPTION("SuperH on-chip RTC driver");
744 MODULE_VERSION(DRV_VERSION
);
745 MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>, "
746 "Jamie Lenehan <lenehan@twibble.org>, "
747 "Angelo Castello <angelo.castello@st.com>");
748 MODULE_LICENSE("GPL");
749 MODULE_ALIAS("platform:" DRV_NAME
);