2 * An rtc driver for the Dallas DS1553
4 * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <linux/bcd.h>
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/gfp.h>
15 #include <linux/delay.h>
16 #include <linux/jiffies.h>
17 #include <linux/interrupt.h>
18 #include <linux/rtc.h>
19 #include <linux/platform_device.h>
21 #include <linux/module.h>
23 #define RTC_REG_SIZE 0x2000
24 #define RTC_OFFSET 0x1ff0
26 #define RTC_FLAGS (RTC_OFFSET + 0)
27 #define RTC_SECONDS_ALARM (RTC_OFFSET + 2)
28 #define RTC_MINUTES_ALARM (RTC_OFFSET + 3)
29 #define RTC_HOURS_ALARM (RTC_OFFSET + 4)
30 #define RTC_DATE_ALARM (RTC_OFFSET + 5)
31 #define RTC_INTERRUPTS (RTC_OFFSET + 6)
32 #define RTC_WATCHDOG (RTC_OFFSET + 7)
33 #define RTC_CONTROL (RTC_OFFSET + 8)
34 #define RTC_CENTURY (RTC_OFFSET + 8)
35 #define RTC_SECONDS (RTC_OFFSET + 9)
36 #define RTC_MINUTES (RTC_OFFSET + 10)
37 #define RTC_HOURS (RTC_OFFSET + 11)
38 #define RTC_DAY (RTC_OFFSET + 12)
39 #define RTC_DATE (RTC_OFFSET + 13)
40 #define RTC_MONTH (RTC_OFFSET + 14)
41 #define RTC_YEAR (RTC_OFFSET + 15)
43 #define RTC_CENTURY_MASK 0x3f
44 #define RTC_SECONDS_MASK 0x7f
45 #define RTC_DAY_MASK 0x07
47 /* Bits in the Control/Century register */
48 #define RTC_WRITE 0x80
51 /* Bits in the Seconds register */
54 /* Bits in the Flags register */
55 #define RTC_FLAGS_AF 0x40
56 #define RTC_FLAGS_BLF 0x10
58 /* Bits in the Interrupts register */
59 #define RTC_INTS_AE 0x80
61 struct rtc_plat_data
{
62 struct rtc_device
*rtc
;
64 unsigned long last_jiffies
;
74 static int ds1553_rtc_set_time(struct device
*dev
, struct rtc_time
*tm
)
76 struct platform_device
*pdev
= to_platform_device(dev
);
77 struct rtc_plat_data
*pdata
= platform_get_drvdata(pdev
);
78 void __iomem
*ioaddr
= pdata
->ioaddr
;
81 century
= bin2bcd((tm
->tm_year
+ 1900) / 100);
83 writeb(RTC_WRITE
, pdata
->ioaddr
+ RTC_CONTROL
);
85 writeb(bin2bcd(tm
->tm_year
% 100), ioaddr
+ RTC_YEAR
);
86 writeb(bin2bcd(tm
->tm_mon
+ 1), ioaddr
+ RTC_MONTH
);
87 writeb(bin2bcd(tm
->tm_wday
) & RTC_DAY_MASK
, ioaddr
+ RTC_DAY
);
88 writeb(bin2bcd(tm
->tm_mday
), ioaddr
+ RTC_DATE
);
89 writeb(bin2bcd(tm
->tm_hour
), ioaddr
+ RTC_HOURS
);
90 writeb(bin2bcd(tm
->tm_min
), ioaddr
+ RTC_MINUTES
);
91 writeb(bin2bcd(tm
->tm_sec
) & RTC_SECONDS_MASK
, ioaddr
+ RTC_SECONDS
);
93 /* RTC_CENTURY and RTC_CONTROL share same register */
94 writeb(RTC_WRITE
| (century
& RTC_CENTURY_MASK
), ioaddr
+ RTC_CENTURY
);
95 writeb(century
& RTC_CENTURY_MASK
, ioaddr
+ RTC_CONTROL
);
99 static int ds1553_rtc_read_time(struct device
*dev
, struct rtc_time
*tm
)
101 struct platform_device
*pdev
= to_platform_device(dev
);
102 struct rtc_plat_data
*pdata
= platform_get_drvdata(pdev
);
103 void __iomem
*ioaddr
= pdata
->ioaddr
;
104 unsigned int year
, month
, day
, hour
, minute
, second
, week
;
105 unsigned int century
;
107 /* give enough time to update RTC in case of continuous read */
108 if (pdata
->last_jiffies
== jiffies
)
110 pdata
->last_jiffies
= jiffies
;
111 writeb(RTC_READ
, ioaddr
+ RTC_CONTROL
);
112 second
= readb(ioaddr
+ RTC_SECONDS
) & RTC_SECONDS_MASK
;
113 minute
= readb(ioaddr
+ RTC_MINUTES
);
114 hour
= readb(ioaddr
+ RTC_HOURS
);
115 day
= readb(ioaddr
+ RTC_DATE
);
116 week
= readb(ioaddr
+ RTC_DAY
) & RTC_DAY_MASK
;
117 month
= readb(ioaddr
+ RTC_MONTH
);
118 year
= readb(ioaddr
+ RTC_YEAR
);
119 century
= readb(ioaddr
+ RTC_CENTURY
) & RTC_CENTURY_MASK
;
120 writeb(0, ioaddr
+ RTC_CONTROL
);
121 tm
->tm_sec
= bcd2bin(second
);
122 tm
->tm_min
= bcd2bin(minute
);
123 tm
->tm_hour
= bcd2bin(hour
);
124 tm
->tm_mday
= bcd2bin(day
);
125 tm
->tm_wday
= bcd2bin(week
);
126 tm
->tm_mon
= bcd2bin(month
) - 1;
127 /* year is 1900 + tm->tm_year */
128 tm
->tm_year
= bcd2bin(year
) + bcd2bin(century
) * 100 - 1900;
130 if (rtc_valid_tm(tm
) < 0) {
131 dev_err(dev
, "retrieved date/time is not valid.\n");
132 rtc_time_to_tm(0, tm
);
137 static void ds1553_rtc_update_alarm(struct rtc_plat_data
*pdata
)
139 void __iomem
*ioaddr
= pdata
->ioaddr
;
142 spin_lock_irqsave(&pdata
->lock
, flags
);
143 writeb(pdata
->alrm_mday
< 0 || (pdata
->irqen
& RTC_UF
) ?
144 0x80 : bin2bcd(pdata
->alrm_mday
),
145 ioaddr
+ RTC_DATE_ALARM
);
146 writeb(pdata
->alrm_hour
< 0 || (pdata
->irqen
& RTC_UF
) ?
147 0x80 : bin2bcd(pdata
->alrm_hour
),
148 ioaddr
+ RTC_HOURS_ALARM
);
149 writeb(pdata
->alrm_min
< 0 || (pdata
->irqen
& RTC_UF
) ?
150 0x80 : bin2bcd(pdata
->alrm_min
),
151 ioaddr
+ RTC_MINUTES_ALARM
);
152 writeb(pdata
->alrm_sec
< 0 || (pdata
->irqen
& RTC_UF
) ?
153 0x80 : bin2bcd(pdata
->alrm_sec
),
154 ioaddr
+ RTC_SECONDS_ALARM
);
155 writeb(pdata
->irqen
? RTC_INTS_AE
: 0, ioaddr
+ RTC_INTERRUPTS
);
156 readb(ioaddr
+ RTC_FLAGS
); /* clear interrupts */
157 spin_unlock_irqrestore(&pdata
->lock
, flags
);
160 static int ds1553_rtc_set_alarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
162 struct platform_device
*pdev
= to_platform_device(dev
);
163 struct rtc_plat_data
*pdata
= platform_get_drvdata(pdev
);
167 pdata
->alrm_mday
= alrm
->time
.tm_mday
;
168 pdata
->alrm_hour
= alrm
->time
.tm_hour
;
169 pdata
->alrm_min
= alrm
->time
.tm_min
;
170 pdata
->alrm_sec
= alrm
->time
.tm_sec
;
172 pdata
->irqen
|= RTC_AF
;
173 ds1553_rtc_update_alarm(pdata
);
177 static int ds1553_rtc_read_alarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
179 struct platform_device
*pdev
= to_platform_device(dev
);
180 struct rtc_plat_data
*pdata
= platform_get_drvdata(pdev
);
184 alrm
->time
.tm_mday
= pdata
->alrm_mday
< 0 ? 0 : pdata
->alrm_mday
;
185 alrm
->time
.tm_hour
= pdata
->alrm_hour
< 0 ? 0 : pdata
->alrm_hour
;
186 alrm
->time
.tm_min
= pdata
->alrm_min
< 0 ? 0 : pdata
->alrm_min
;
187 alrm
->time
.tm_sec
= pdata
->alrm_sec
< 0 ? 0 : pdata
->alrm_sec
;
188 alrm
->enabled
= (pdata
->irqen
& RTC_AF
) ? 1 : 0;
192 static irqreturn_t
ds1553_rtc_interrupt(int irq
, void *dev_id
)
194 struct platform_device
*pdev
= dev_id
;
195 struct rtc_plat_data
*pdata
= platform_get_drvdata(pdev
);
196 void __iomem
*ioaddr
= pdata
->ioaddr
;
197 unsigned long events
= 0;
199 spin_lock(&pdata
->lock
);
200 /* read and clear interrupt */
201 if (readb(ioaddr
+ RTC_FLAGS
) & RTC_FLAGS_AF
) {
203 if (readb(ioaddr
+ RTC_SECONDS_ALARM
) & 0x80)
207 rtc_update_irq(pdata
->rtc
, 1, events
);
209 spin_unlock(&pdata
->lock
);
210 return events
? IRQ_HANDLED
: IRQ_NONE
;
213 static int ds1553_rtc_alarm_irq_enable(struct device
*dev
, unsigned int enabled
)
215 struct platform_device
*pdev
= to_platform_device(dev
);
216 struct rtc_plat_data
*pdata
= platform_get_drvdata(pdev
);
221 pdata
->irqen
|= RTC_AF
;
223 pdata
->irqen
&= ~RTC_AF
;
224 ds1553_rtc_update_alarm(pdata
);
228 static const struct rtc_class_ops ds1553_rtc_ops
= {
229 .read_time
= ds1553_rtc_read_time
,
230 .set_time
= ds1553_rtc_set_time
,
231 .read_alarm
= ds1553_rtc_read_alarm
,
232 .set_alarm
= ds1553_rtc_set_alarm
,
233 .alarm_irq_enable
= ds1553_rtc_alarm_irq_enable
,
236 static ssize_t
ds1553_nvram_read(struct file
*filp
, struct kobject
*kobj
,
237 struct bin_attribute
*bin_attr
,
238 char *buf
, loff_t pos
, size_t size
)
240 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
241 struct platform_device
*pdev
= to_platform_device(dev
);
242 struct rtc_plat_data
*pdata
= platform_get_drvdata(pdev
);
243 void __iomem
*ioaddr
= pdata
->ioaddr
;
246 for (count
= 0; count
< size
; count
++)
247 *buf
++ = readb(ioaddr
+ pos
++);
251 static ssize_t
ds1553_nvram_write(struct file
*filp
, struct kobject
*kobj
,
252 struct bin_attribute
*bin_attr
,
253 char *buf
, loff_t pos
, size_t size
)
255 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
256 struct platform_device
*pdev
= to_platform_device(dev
);
257 struct rtc_plat_data
*pdata
= platform_get_drvdata(pdev
);
258 void __iomem
*ioaddr
= pdata
->ioaddr
;
261 for (count
= 0; count
< size
; count
++)
262 writeb(*buf
++, ioaddr
+ pos
++);
266 static struct bin_attribute ds1553_nvram_attr
= {
269 .mode
= S_IRUGO
| S_IWUSR
,
272 .read
= ds1553_nvram_read
,
273 .write
= ds1553_nvram_write
,
276 static int ds1553_rtc_probe(struct platform_device
*pdev
)
278 struct resource
*res
;
279 unsigned int cen
, sec
;
280 struct rtc_plat_data
*pdata
;
281 void __iomem
*ioaddr
;
284 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
288 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
289 ioaddr
= devm_ioremap_resource(&pdev
->dev
, res
);
291 return PTR_ERR(ioaddr
);
292 pdata
->ioaddr
= ioaddr
;
293 pdata
->irq
= platform_get_irq(pdev
, 0);
295 /* turn RTC on if it was not on */
296 sec
= readb(ioaddr
+ RTC_SECONDS
);
297 if (sec
& RTC_STOP
) {
298 sec
&= RTC_SECONDS_MASK
;
299 cen
= readb(ioaddr
+ RTC_CENTURY
) & RTC_CENTURY_MASK
;
300 writeb(RTC_WRITE
, ioaddr
+ RTC_CONTROL
);
301 writeb(sec
, ioaddr
+ RTC_SECONDS
);
302 writeb(cen
& RTC_CENTURY_MASK
, ioaddr
+ RTC_CONTROL
);
304 if (readb(ioaddr
+ RTC_FLAGS
) & RTC_FLAGS_BLF
)
305 dev_warn(&pdev
->dev
, "voltage-low detected.\n");
307 spin_lock_init(&pdata
->lock
);
308 pdata
->last_jiffies
= jiffies
;
309 platform_set_drvdata(pdev
, pdata
);
311 pdata
->rtc
= devm_rtc_device_register(&pdev
->dev
, pdev
->name
,
312 &ds1553_rtc_ops
, THIS_MODULE
);
313 if (IS_ERR(pdata
->rtc
))
314 return PTR_ERR(pdata
->rtc
);
316 if (pdata
->irq
> 0) {
317 writeb(0, ioaddr
+ RTC_INTERRUPTS
);
318 if (devm_request_irq(&pdev
->dev
, pdata
->irq
,
319 ds1553_rtc_interrupt
,
320 0, pdev
->name
, pdev
) < 0) {
321 dev_warn(&pdev
->dev
, "interrupt not available.\n");
326 ret
= sysfs_create_bin_file(&pdev
->dev
.kobj
, &ds1553_nvram_attr
);
328 dev_err(&pdev
->dev
, "unable to create sysfs file: %s\n",
329 ds1553_nvram_attr
.attr
.name
);
334 static int ds1553_rtc_remove(struct platform_device
*pdev
)
336 struct rtc_plat_data
*pdata
= platform_get_drvdata(pdev
);
338 sysfs_remove_bin_file(&pdev
->dev
.kobj
, &ds1553_nvram_attr
);
340 writeb(0, pdata
->ioaddr
+ RTC_INTERRUPTS
);
344 /* work with hotplug and coldplug */
345 MODULE_ALIAS("platform:rtc-ds1553");
347 static struct platform_driver ds1553_rtc_driver
= {
348 .probe
= ds1553_rtc_probe
,
349 .remove
= ds1553_rtc_remove
,
351 .name
= "rtc-ds1553",
355 module_platform_driver(ds1553_rtc_driver
);
357 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
358 MODULE_DESCRIPTION("Dallas DS1553 RTC driver");
359 MODULE_LICENSE("GPL");