4 * Copyright (c) 2007 Wind River Systems, Inc.
6 * Author: Mark Zhan <rongkai.zhan@windriver.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
17 #include <linux/device.h>
18 #include <linux/platform_device.h>
19 #include <linux/rtc.h>
20 #include <linux/rtc/m48t59.h>
21 #include <linux/bcd.h>
22 #include <linux/slab.h>
28 #define M48T59_READ(reg) (pdata->read_byte(dev, pdata->offset + reg))
29 #define M48T59_WRITE(val, reg) \
30 (pdata->write_byte(dev, pdata->offset + reg, val))
32 #define M48T59_SET_BITS(mask, reg) \
33 M48T59_WRITE((M48T59_READ(reg) | (mask)), (reg))
34 #define M48T59_CLEAR_BITS(mask, reg) \
35 M48T59_WRITE((M48T59_READ(reg) & ~(mask)), (reg))
37 struct m48t59_private
{
40 struct rtc_device
*rtc
;
41 spinlock_t lock
; /* serialize the NVRAM and RTC access */
45 * This is the generic access method when the chip is memory-mapped
48 m48t59_mem_writeb(struct device
*dev
, u32 ofs
, u8 val
)
50 struct m48t59_private
*m48t59
= dev_get_drvdata(dev
);
52 writeb(val
, m48t59
->ioaddr
+ofs
);
56 m48t59_mem_readb(struct device
*dev
, u32 ofs
)
58 struct m48t59_private
*m48t59
= dev_get_drvdata(dev
);
60 return readb(m48t59
->ioaddr
+ofs
);
64 * NOTE: M48T59 only uses BCD mode
66 static int m48t59_rtc_read_time(struct device
*dev
, struct rtc_time
*tm
)
68 struct m48t59_plat_data
*pdata
= dev_get_platdata(dev
);
69 struct m48t59_private
*m48t59
= dev_get_drvdata(dev
);
73 spin_lock_irqsave(&m48t59
->lock
, flags
);
74 /* Issue the READ command */
75 M48T59_SET_BITS(M48T59_CNTL_READ
, M48T59_CNTL
);
77 tm
->tm_year
= bcd2bin(M48T59_READ(M48T59_YEAR
));
79 tm
->tm_mon
= bcd2bin(M48T59_READ(M48T59_MONTH
)) - 1;
80 tm
->tm_mday
= bcd2bin(M48T59_READ(M48T59_MDAY
));
82 val
= M48T59_READ(M48T59_WDAY
);
83 if ((pdata
->type
== M48T59RTC_TYPE_M48T59
) &&
84 (val
& M48T59_WDAY_CEB
) && (val
& M48T59_WDAY_CB
)) {
85 dev_dbg(dev
, "Century bit is enabled\n");
86 tm
->tm_year
+= 100; /* one century */
89 /* Sun SPARC machines count years since 1968 */
93 tm
->tm_wday
= bcd2bin(val
& 0x07);
94 tm
->tm_hour
= bcd2bin(M48T59_READ(M48T59_HOUR
) & 0x3F);
95 tm
->tm_min
= bcd2bin(M48T59_READ(M48T59_MIN
) & 0x7F);
96 tm
->tm_sec
= bcd2bin(M48T59_READ(M48T59_SEC
) & 0x7F);
98 /* Clear the READ bit */
99 M48T59_CLEAR_BITS(M48T59_CNTL_READ
, M48T59_CNTL
);
100 spin_unlock_irqrestore(&m48t59
->lock
, flags
);
102 dev_dbg(dev
, "RTC read time %ptR\n", tm
);
106 static int m48t59_rtc_set_time(struct device
*dev
, struct rtc_time
*tm
)
108 struct m48t59_plat_data
*pdata
= dev_get_platdata(dev
);
109 struct m48t59_private
*m48t59
= dev_get_drvdata(dev
);
112 int year
= tm
->tm_year
;
115 /* Sun SPARC machines count years since 1968 */
119 dev_dbg(dev
, "RTC set time %04d-%02d-%02d %02d/%02d/%02d\n",
120 year
+ 1900, tm
->tm_mon
, tm
->tm_mday
,
121 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
126 spin_lock_irqsave(&m48t59
->lock
, flags
);
127 /* Issue the WRITE command */
128 M48T59_SET_BITS(M48T59_CNTL_WRITE
, M48T59_CNTL
);
130 M48T59_WRITE((bin2bcd(tm
->tm_sec
) & 0x7F), M48T59_SEC
);
131 M48T59_WRITE((bin2bcd(tm
->tm_min
) & 0x7F), M48T59_MIN
);
132 M48T59_WRITE((bin2bcd(tm
->tm_hour
) & 0x3F), M48T59_HOUR
);
133 M48T59_WRITE((bin2bcd(tm
->tm_mday
) & 0x3F), M48T59_MDAY
);
135 M48T59_WRITE((bin2bcd(tm
->tm_mon
+ 1) & 0x1F), M48T59_MONTH
);
136 M48T59_WRITE(bin2bcd(year
% 100), M48T59_YEAR
);
138 if (pdata
->type
== M48T59RTC_TYPE_M48T59
&& (year
/ 100))
139 val
= (M48T59_WDAY_CEB
| M48T59_WDAY_CB
);
140 val
|= (bin2bcd(tm
->tm_wday
) & 0x07);
141 M48T59_WRITE(val
, M48T59_WDAY
);
143 /* Clear the WRITE bit */
144 M48T59_CLEAR_BITS(M48T59_CNTL_WRITE
, M48T59_CNTL
);
145 spin_unlock_irqrestore(&m48t59
->lock
, flags
);
150 * Read alarm time and date in RTC
152 static int m48t59_rtc_readalarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
154 struct m48t59_plat_data
*pdata
= dev_get_platdata(dev
);
155 struct m48t59_private
*m48t59
= dev_get_drvdata(dev
);
156 struct rtc_time
*tm
= &alrm
->time
;
160 /* If no irq, we don't support ALARM */
161 if (m48t59
->irq
== NO_IRQ
)
164 spin_lock_irqsave(&m48t59
->lock
, flags
);
165 /* Issue the READ command */
166 M48T59_SET_BITS(M48T59_CNTL_READ
, M48T59_CNTL
);
168 tm
->tm_year
= bcd2bin(M48T59_READ(M48T59_YEAR
));
170 /* Sun SPARC machines count years since 1968 */
174 tm
->tm_mon
= bcd2bin(M48T59_READ(M48T59_MONTH
)) - 1;
176 val
= M48T59_READ(M48T59_WDAY
);
177 if ((val
& M48T59_WDAY_CEB
) && (val
& M48T59_WDAY_CB
))
178 tm
->tm_year
+= 100; /* one century */
180 tm
->tm_mday
= bcd2bin(M48T59_READ(M48T59_ALARM_DATE
));
181 tm
->tm_hour
= bcd2bin(M48T59_READ(M48T59_ALARM_HOUR
));
182 tm
->tm_min
= bcd2bin(M48T59_READ(M48T59_ALARM_MIN
));
183 tm
->tm_sec
= bcd2bin(M48T59_READ(M48T59_ALARM_SEC
));
185 /* Clear the READ bit */
186 M48T59_CLEAR_BITS(M48T59_CNTL_READ
, M48T59_CNTL
);
187 spin_unlock_irqrestore(&m48t59
->lock
, flags
);
189 dev_dbg(dev
, "RTC read alarm time %ptR\n", tm
);
190 return rtc_valid_tm(tm
);
194 * Set alarm time and date in RTC
196 static int m48t59_rtc_setalarm(struct device
*dev
, struct rtc_wkalrm
*alrm
)
198 struct m48t59_plat_data
*pdata
= dev_get_platdata(dev
);
199 struct m48t59_private
*m48t59
= dev_get_drvdata(dev
);
200 struct rtc_time
*tm
= &alrm
->time
;
201 u8 mday
, hour
, min
, sec
;
203 int year
= tm
->tm_year
;
206 /* Sun SPARC machines count years since 1968 */
210 /* If no irq, we don't support ALARM */
211 if (m48t59
->irq
== NO_IRQ
)
218 * 0xff means "always match"
221 mday
= (mday
>= 1 && mday
<= 31) ? bin2bcd(mday
) : 0xff;
223 mday
= M48T59_READ(M48T59_MDAY
);
226 hour
= (hour
< 24) ? bin2bcd(hour
) : 0x00;
229 min
= (min
< 60) ? bin2bcd(min
) : 0x00;
232 sec
= (sec
< 60) ? bin2bcd(sec
) : 0x00;
234 spin_lock_irqsave(&m48t59
->lock
, flags
);
235 /* Issue the WRITE command */
236 M48T59_SET_BITS(M48T59_CNTL_WRITE
, M48T59_CNTL
);
238 M48T59_WRITE(mday
, M48T59_ALARM_DATE
);
239 M48T59_WRITE(hour
, M48T59_ALARM_HOUR
);
240 M48T59_WRITE(min
, M48T59_ALARM_MIN
);
241 M48T59_WRITE(sec
, M48T59_ALARM_SEC
);
243 /* Clear the WRITE bit */
244 M48T59_CLEAR_BITS(M48T59_CNTL_WRITE
, M48T59_CNTL
);
245 spin_unlock_irqrestore(&m48t59
->lock
, flags
);
247 dev_dbg(dev
, "RTC set alarm time %04d-%02d-%02d %02d/%02d/%02d\n",
248 year
+ 1900, tm
->tm_mon
, tm
->tm_mday
,
249 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
254 * Handle commands from user-space
256 static int m48t59_rtc_alarm_irq_enable(struct device
*dev
, unsigned int enabled
)
258 struct m48t59_plat_data
*pdata
= dev_get_platdata(dev
);
259 struct m48t59_private
*m48t59
= dev_get_drvdata(dev
);
262 spin_lock_irqsave(&m48t59
->lock
, flags
);
264 M48T59_WRITE(M48T59_INTR_AFE
, M48T59_INTR
);
266 M48T59_WRITE(0x00, M48T59_INTR
);
267 spin_unlock_irqrestore(&m48t59
->lock
, flags
);
272 static int m48t59_rtc_proc(struct device
*dev
, struct seq_file
*seq
)
274 struct m48t59_plat_data
*pdata
= dev_get_platdata(dev
);
275 struct m48t59_private
*m48t59
= dev_get_drvdata(dev
);
279 spin_lock_irqsave(&m48t59
->lock
, flags
);
280 val
= M48T59_READ(M48T59_FLAGS
);
281 spin_unlock_irqrestore(&m48t59
->lock
, flags
);
283 seq_printf(seq
, "battery\t\t: %s\n",
284 (val
& M48T59_FLAGS_BF
) ? "low" : "normal");
289 * IRQ handler for the RTC
291 static irqreturn_t
m48t59_rtc_interrupt(int irq
, void *dev_id
)
293 struct device
*dev
= (struct device
*)dev_id
;
294 struct m48t59_plat_data
*pdata
= dev_get_platdata(dev
);
295 struct m48t59_private
*m48t59
= dev_get_drvdata(dev
);
298 spin_lock(&m48t59
->lock
);
299 event
= M48T59_READ(M48T59_FLAGS
);
300 spin_unlock(&m48t59
->lock
);
302 if (event
& M48T59_FLAGS_AF
) {
303 rtc_update_irq(m48t59
->rtc
, 1, (RTC_AF
| RTC_IRQF
));
310 static const struct rtc_class_ops m48t59_rtc_ops
= {
311 .read_time
= m48t59_rtc_read_time
,
312 .set_time
= m48t59_rtc_set_time
,
313 .read_alarm
= m48t59_rtc_readalarm
,
314 .set_alarm
= m48t59_rtc_setalarm
,
315 .proc
= m48t59_rtc_proc
,
316 .alarm_irq_enable
= m48t59_rtc_alarm_irq_enable
,
319 static const struct rtc_class_ops m48t02_rtc_ops
= {
320 .read_time
= m48t59_rtc_read_time
,
321 .set_time
= m48t59_rtc_set_time
,
324 static int m48t59_nvram_read(void *priv
, unsigned int offset
, void *val
,
327 struct platform_device
*pdev
= priv
;
328 struct device
*dev
= &pdev
->dev
;
329 struct m48t59_plat_data
*pdata
= dev_get_platdata(&pdev
->dev
);
330 struct m48t59_private
*m48t59
= platform_get_drvdata(pdev
);
335 spin_lock_irqsave(&m48t59
->lock
, flags
);
337 for (; cnt
< size
; cnt
++)
338 *buf
++ = M48T59_READ(cnt
);
340 spin_unlock_irqrestore(&m48t59
->lock
, flags
);
345 static int m48t59_nvram_write(void *priv
, unsigned int offset
, void *val
,
348 struct platform_device
*pdev
= priv
;
349 struct device
*dev
= &pdev
->dev
;
350 struct m48t59_plat_data
*pdata
= dev_get_platdata(&pdev
->dev
);
351 struct m48t59_private
*m48t59
= platform_get_drvdata(pdev
);
356 spin_lock_irqsave(&m48t59
->lock
, flags
);
358 for (; cnt
< size
; cnt
++)
359 M48T59_WRITE(*buf
++, cnt
);
361 spin_unlock_irqrestore(&m48t59
->lock
, flags
);
366 static int m48t59_rtc_probe(struct platform_device
*pdev
)
368 struct m48t59_plat_data
*pdata
= dev_get_platdata(&pdev
->dev
);
369 struct m48t59_private
*m48t59
= NULL
;
370 struct resource
*res
;
372 const struct rtc_class_ops
*ops
;
373 struct nvmem_config nvmem_cfg
= {
377 .reg_read
= m48t59_nvram_read
,
378 .reg_write
= m48t59_nvram_write
,
382 /* This chip could be memory-mapped or I/O-mapped */
383 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
385 res
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
390 if (res
->flags
& IORESOURCE_IO
) {
391 /* If we are I/O-mapped, the platform should provide
392 * the operations accessing chip registers.
394 if (!pdata
|| !pdata
->write_byte
|| !pdata
->read_byte
)
396 } else if (res
->flags
& IORESOURCE_MEM
) {
397 /* we are memory-mapped */
399 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
),
403 /* Ensure we only kmalloc platform data once */
404 pdev
->dev
.platform_data
= pdata
;
407 pdata
->type
= M48T59RTC_TYPE_M48T59
;
409 /* Try to use the generic memory read/write ops */
410 if (!pdata
->write_byte
)
411 pdata
->write_byte
= m48t59_mem_writeb
;
412 if (!pdata
->read_byte
)
413 pdata
->read_byte
= m48t59_mem_readb
;
416 m48t59
= devm_kzalloc(&pdev
->dev
, sizeof(*m48t59
), GFP_KERNEL
);
420 m48t59
->ioaddr
= pdata
->ioaddr
;
422 if (!m48t59
->ioaddr
) {
423 /* ioaddr not mapped externally */
424 m48t59
->ioaddr
= devm_ioremap(&pdev
->dev
, res
->start
,
430 /* Try to get irq number. We also can work in
431 * the mode without IRQ.
433 m48t59
->irq
= platform_get_irq(pdev
, 0);
434 if (m48t59
->irq
<= 0)
435 m48t59
->irq
= NO_IRQ
;
437 if (m48t59
->irq
!= NO_IRQ
) {
438 ret
= devm_request_irq(&pdev
->dev
, m48t59
->irq
,
439 m48t59_rtc_interrupt
, IRQF_SHARED
,
440 "rtc-m48t59", &pdev
->dev
);
444 switch (pdata
->type
) {
445 case M48T59RTC_TYPE_M48T59
:
446 ops
= &m48t59_rtc_ops
;
447 pdata
->offset
= 0x1ff0;
449 case M48T59RTC_TYPE_M48T02
:
450 ops
= &m48t02_rtc_ops
;
451 pdata
->offset
= 0x7f0;
453 case M48T59RTC_TYPE_M48T08
:
454 ops
= &m48t02_rtc_ops
;
455 pdata
->offset
= 0x1ff0;
458 dev_err(&pdev
->dev
, "Unknown RTC type\n");
462 spin_lock_init(&m48t59
->lock
);
463 platform_set_drvdata(pdev
, m48t59
);
465 m48t59
->rtc
= devm_rtc_allocate_device(&pdev
->dev
);
466 if (IS_ERR(m48t59
->rtc
))
467 return PTR_ERR(m48t59
->rtc
);
469 m48t59
->rtc
->nvram_old_abi
= true;
470 m48t59
->rtc
->ops
= ops
;
472 nvmem_cfg
.size
= pdata
->offset
;
473 ret
= rtc_nvmem_register(m48t59
->rtc
, &nvmem_cfg
);
477 ret
= rtc_register_device(m48t59
->rtc
);
484 /* work with hotplug and coldplug */
485 MODULE_ALIAS("platform:rtc-m48t59");
487 static struct platform_driver m48t59_rtc_driver
= {
489 .name
= "rtc-m48t59",
491 .probe
= m48t59_rtc_probe
,
494 module_platform_driver(m48t59_rtc_driver
);
496 MODULE_AUTHOR("Mark Zhan <rongkai.zhan@windriver.com>");
497 MODULE_DESCRIPTION("M48T59/M48T02/M48T08 RTC driver");
498 MODULE_LICENSE("GPL");