2 * rtc-mrst.c: Driver for Moorestown virtual RTC
4 * (C) Copyright 2009 Intel Corporation
5 * Author: Jacob Pan (jacob.jun.pan@intel.com)
6 * Feng Tang (feng.tang@intel.com)
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; version 2
14 * VRTC is emulated by system controller firmware, the real HW
15 * RTC is located in the PMIC device. SCU FW shadows PMIC RTC
16 * in a memory mapped IO space that is visible to the host IA
19 * This driver is based upon drivers/rtc/rtc-cmos.c
24 * * vRTC only supports binary mode and 24H mode
25 * * vRTC only support PIE and AIE, no UIE, and its PIE only happens
26 * at 23:59:59pm everyday, no support for adjustable frequency
27 * * Alarm function is also limited to hr/min/sec.
30 #include <linux/mod_devicetable.h>
31 #include <linux/platform_device.h>
32 #include <linux/interrupt.h>
33 #include <linux/spinlock.h>
34 #include <linux/kernel.h>
35 #include <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/sfi.h>
39 #include <asm-generic/rtc.h>
40 #include <asm/intel_scu_ipc.h>
42 #include <asm/mrst-vrtc.h>
45 struct rtc_device
*rtc
;
48 struct resource
*iomem
;
54 static const char driver_name
[] = "rtc_mrst";
56 #define RTC_IRQMASK (RTC_PF | RTC_AF)
58 static inline int is_intr(u8 rtc_intr
)
60 if (!(rtc_intr
& RTC_IRQF
))
62 return rtc_intr
& RTC_IRQMASK
;
66 * rtc_time's year contains the increment over 1900, but vRTC's YEAR
67 * register can't be programmed to value larger than 0x64, so vRTC
68 * driver chose to use 1960 (1970 is UNIX time start point) as the base,
69 * and does the translation at read/write time
71 static int mrst_read_time(struct device
*dev
, struct rtc_time
*time
)
75 if (rtc_is_updating())
78 spin_lock_irqsave(&rtc_lock
, flags
);
79 time
->tm_sec
= vrtc_cmos_read(RTC_SECONDS
);
80 time
->tm_min
= vrtc_cmos_read(RTC_MINUTES
);
81 time
->tm_hour
= vrtc_cmos_read(RTC_HOURS
);
82 time
->tm_mday
= vrtc_cmos_read(RTC_DAY_OF_MONTH
);
83 time
->tm_mon
= vrtc_cmos_read(RTC_MONTH
);
84 time
->tm_year
= vrtc_cmos_read(RTC_YEAR
);
85 spin_unlock_irqrestore(&rtc_lock
, flags
);
87 /* Adjust for the 1960/1900 */
93 static int mrst_set_time(struct device
*dev
, struct rtc_time
*time
)
97 unsigned char mon
, day
, hrs
, min
, sec
;
101 mon
= time
->tm_mon
+ 1; /* tm_mon starts at zero */
107 if (yrs
< 70 || yrs
> 138)
111 spin_lock_irqsave(&rtc_lock
, flags
);
113 vrtc_cmos_write(yrs
, RTC_YEAR
);
114 vrtc_cmos_write(mon
, RTC_MONTH
);
115 vrtc_cmos_write(day
, RTC_DAY_OF_MONTH
);
116 vrtc_cmos_write(hrs
, RTC_HOURS
);
117 vrtc_cmos_write(min
, RTC_MINUTES
);
118 vrtc_cmos_write(sec
, RTC_SECONDS
);
120 spin_unlock_irqrestore(&rtc_lock
, flags
);
122 ret
= intel_scu_ipc_simple_command(IPCMSG_VRTC
, IPC_CMD_VRTC_SETTIME
);
126 static int mrst_read_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
128 struct mrst_rtc
*mrst
= dev_get_drvdata(dev
);
129 unsigned char rtc_control
;
134 /* Basic alarms only support hour, minute, and seconds fields.
135 * Some also support day and month, for alarms up to a year in
138 t
->time
.tm_mday
= -1;
140 t
->time
.tm_year
= -1;
142 /* vRTC only supports binary mode */
143 spin_lock_irq(&rtc_lock
);
144 t
->time
.tm_sec
= vrtc_cmos_read(RTC_SECONDS_ALARM
);
145 t
->time
.tm_min
= vrtc_cmos_read(RTC_MINUTES_ALARM
);
146 t
->time
.tm_hour
= vrtc_cmos_read(RTC_HOURS_ALARM
);
148 rtc_control
= vrtc_cmos_read(RTC_CONTROL
);
149 spin_unlock_irq(&rtc_lock
);
151 t
->enabled
= !!(rtc_control
& RTC_AIE
);
157 static void mrst_checkintr(struct mrst_rtc
*mrst
, unsigned char rtc_control
)
159 unsigned char rtc_intr
;
162 * NOTE after changing RTC_xIE bits we always read INTR_FLAGS;
163 * allegedly some older rtcs need that to handle irqs properly
165 rtc_intr
= vrtc_cmos_read(RTC_INTR_FLAGS
);
166 rtc_intr
&= (rtc_control
& RTC_IRQMASK
) | RTC_IRQF
;
167 if (is_intr(rtc_intr
))
168 rtc_update_irq(mrst
->rtc
, 1, rtc_intr
);
171 static void mrst_irq_enable(struct mrst_rtc
*mrst
, unsigned char mask
)
173 unsigned char rtc_control
;
176 * Flush any pending IRQ status, notably for update irqs,
177 * before we enable new IRQs
179 rtc_control
= vrtc_cmos_read(RTC_CONTROL
);
180 mrst_checkintr(mrst
, rtc_control
);
183 vrtc_cmos_write(rtc_control
, RTC_CONTROL
);
185 mrst_checkintr(mrst
, rtc_control
);
188 static void mrst_irq_disable(struct mrst_rtc
*mrst
, unsigned char mask
)
190 unsigned char rtc_control
;
192 rtc_control
= vrtc_cmos_read(RTC_CONTROL
);
193 rtc_control
&= ~mask
;
194 vrtc_cmos_write(rtc_control
, RTC_CONTROL
);
195 mrst_checkintr(mrst
, rtc_control
);
198 static int mrst_set_alarm(struct device
*dev
, struct rtc_wkalrm
*t
)
200 struct mrst_rtc
*mrst
= dev_get_drvdata(dev
);
201 unsigned char hrs
, min
, sec
;
207 hrs
= t
->time
.tm_hour
;
208 min
= t
->time
.tm_min
;
209 sec
= t
->time
.tm_sec
;
211 spin_lock_irq(&rtc_lock
);
212 /* Next rtc irq must not be from previous alarm setting */
213 mrst_irq_disable(mrst
, RTC_AIE
);
216 vrtc_cmos_write(hrs
, RTC_HOURS_ALARM
);
217 vrtc_cmos_write(min
, RTC_MINUTES_ALARM
);
218 vrtc_cmos_write(sec
, RTC_SECONDS_ALARM
);
220 spin_unlock_irq(&rtc_lock
);
222 ret
= intel_scu_ipc_simple_command(IPCMSG_VRTC
, IPC_CMD_VRTC_SETALARM
);
226 spin_lock_irq(&rtc_lock
);
228 mrst_irq_enable(mrst
, RTC_AIE
);
230 spin_unlock_irq(&rtc_lock
);
235 static int mrst_irq_set_state(struct device
*dev
, int enabled
)
237 struct mrst_rtc
*mrst
= dev_get_drvdata(dev
);
243 spin_lock_irqsave(&rtc_lock
, flags
);
246 mrst_irq_enable(mrst
, RTC_PIE
);
248 mrst_irq_disable(mrst
, RTC_PIE
);
250 spin_unlock_irqrestore(&rtc_lock
, flags
);
254 #if defined(CONFIG_RTC_INTF_DEV) || defined(CONFIG_RTC_INTF_DEV_MODULE)
256 /* Currently, the vRTC doesn't support UIE ON/OFF */
258 mrst_rtc_ioctl(struct device
*dev
, unsigned int cmd
, unsigned long arg
)
260 struct mrst_rtc
*mrst
= dev_get_drvdata(dev
);
270 /* PIE ON/OFF is handled by mrst_irq_set_state() */
274 spin_lock_irqsave(&rtc_lock
, flags
);
276 case RTC_AIE_OFF
: /* alarm off */
277 mrst_irq_disable(mrst
, RTC_AIE
);
279 case RTC_AIE_ON
: /* alarm on */
280 mrst_irq_enable(mrst
, RTC_AIE
);
283 spin_unlock_irqrestore(&rtc_lock
, flags
);
288 #define mrst_rtc_ioctl NULL
291 #if defined(CONFIG_RTC_INTF_PROC) || defined(CONFIG_RTC_INTF_PROC_MODULE)
293 static int mrst_procfs(struct device
*dev
, struct seq_file
*seq
)
295 unsigned char rtc_control
, valid
;
297 spin_lock_irq(&rtc_lock
);
298 rtc_control
= vrtc_cmos_read(RTC_CONTROL
);
299 valid
= vrtc_cmos_read(RTC_VALID
);
300 spin_unlock_irq(&rtc_lock
);
302 return seq_printf(seq
,
303 "periodic_IRQ\t: %s\n"
306 "periodic_freq\t: daily (not adjustable)\n",
307 (rtc_control
& RTC_PIE
) ? "on" : "off",
308 (rtc_control
& RTC_AIE
) ? "on" : "off");
312 #define mrst_procfs NULL
315 static const struct rtc_class_ops mrst_rtc_ops
= {
316 .ioctl
= mrst_rtc_ioctl
,
317 .read_time
= mrst_read_time
,
318 .set_time
= mrst_set_time
,
319 .read_alarm
= mrst_read_alarm
,
320 .set_alarm
= mrst_set_alarm
,
322 .irq_set_state
= mrst_irq_set_state
,
325 static struct mrst_rtc mrst_rtc
;
328 * When vRTC IRQ is captured by SCU FW, FW will clear the AIE bit in
329 * Reg B, so no need for this driver to clear it
331 static irqreturn_t
mrst_rtc_irq(int irq
, void *p
)
335 spin_lock(&rtc_lock
);
336 /* This read will clear all IRQ flags inside Reg C */
337 irqstat
= vrtc_cmos_read(RTC_INTR_FLAGS
);
338 spin_unlock(&rtc_lock
);
340 irqstat
&= RTC_IRQMASK
| RTC_IRQF
;
341 if (is_intr(irqstat
)) {
342 rtc_update_irq(p
, 1, irqstat
);
349 vrtc_mrst_do_probe(struct device
*dev
, struct resource
*iomem
, int rtc_irq
)
352 unsigned char rtc_control
;
354 /* There can be only one ... */
361 iomem
= request_mem_region(iomem
->start
,
362 iomem
->end
+ 1 - iomem
->start
,
365 dev_dbg(dev
, "i/o mem already in use.\n");
369 mrst_rtc
.irq
= rtc_irq
;
370 mrst_rtc
.iomem
= iomem
;
372 mrst_rtc
.rtc
= rtc_device_register(driver_name
, dev
,
373 &mrst_rtc_ops
, THIS_MODULE
);
374 if (IS_ERR(mrst_rtc
.rtc
)) {
375 retval
= PTR_ERR(mrst_rtc
.rtc
);
380 dev_set_drvdata(dev
, &mrst_rtc
);
381 rename_region(iomem
, dev_name(&mrst_rtc
.rtc
->dev
));
383 spin_lock_irq(&rtc_lock
);
384 mrst_irq_disable(&mrst_rtc
, RTC_PIE
| RTC_AIE
);
385 rtc_control
= vrtc_cmos_read(RTC_CONTROL
);
386 spin_unlock_irq(&rtc_lock
);
388 if (!(rtc_control
& RTC_24H
) || (rtc_control
& (RTC_DM_BINARY
)))
389 dev_dbg(dev
, "TODO: support more than 24-hr BCD mode\n");
392 retval
= request_irq(rtc_irq
, mrst_rtc_irq
,
393 IRQF_DISABLED
, dev_name(&mrst_rtc
.rtc
->dev
),
396 dev_dbg(dev
, "IRQ %d is already in use, err %d\n",
401 dev_dbg(dev
, "initialised\n");
406 rtc_device_unregister(mrst_rtc
.rtc
);
408 release_region(iomem
->start
, iomem
->end
+ 1 - iomem
->start
);
409 dev_err(dev
, "rtc-mrst: unable to initialise\n");
413 static void rtc_mrst_do_shutdown(void)
415 spin_lock_irq(&rtc_lock
);
416 mrst_irq_disable(&mrst_rtc
, RTC_IRQMASK
);
417 spin_unlock_irq(&rtc_lock
);
420 static void __exit
rtc_mrst_do_remove(struct device
*dev
)
422 struct mrst_rtc
*mrst
= dev_get_drvdata(dev
);
423 struct resource
*iomem
;
425 rtc_mrst_do_shutdown();
428 free_irq(mrst
->irq
, mrst
->rtc
);
430 rtc_device_unregister(mrst
->rtc
);
434 release_region(iomem
->start
, iomem
->end
+ 1 - iomem
->start
);
438 dev_set_drvdata(dev
, NULL
);
442 static int mrst_suspend(struct device
*dev
, pm_message_t mesg
)
444 struct mrst_rtc
*mrst
= dev_get_drvdata(dev
);
447 /* Only the alarm might be a wakeup event source */
448 spin_lock_irq(&rtc_lock
);
449 mrst
->suspend_ctrl
= tmp
= vrtc_cmos_read(RTC_CONTROL
);
450 if (tmp
& (RTC_PIE
| RTC_AIE
)) {
453 if (device_may_wakeup(dev
))
454 mask
= RTC_IRQMASK
& ~RTC_AIE
;
458 vrtc_cmos_write(tmp
, RTC_CONTROL
);
460 mrst_checkintr(mrst
, tmp
);
462 spin_unlock_irq(&rtc_lock
);
465 mrst
->enabled_wake
= 1;
466 enable_irq_wake(mrst
->irq
);
469 dev_dbg(&mrst_rtc
.rtc
->dev
, "suspend%s, ctrl %02x\n",
470 (tmp
& RTC_AIE
) ? ", alarm may wake" : "",
477 * We want RTC alarms to wake us from the deep power saving state
479 static inline int mrst_poweroff(struct device
*dev
)
481 return mrst_suspend(dev
, PMSG_HIBERNATE
);
484 static int mrst_resume(struct device
*dev
)
486 struct mrst_rtc
*mrst
= dev_get_drvdata(dev
);
487 unsigned char tmp
= mrst
->suspend_ctrl
;
489 /* Re-enable any irqs previously active */
490 if (tmp
& RTC_IRQMASK
) {
493 if (mrst
->enabled_wake
) {
494 disable_irq_wake(mrst
->irq
);
495 mrst
->enabled_wake
= 0;
498 spin_lock_irq(&rtc_lock
);
500 vrtc_cmos_write(tmp
, RTC_CONTROL
);
502 mask
= vrtc_cmos_read(RTC_INTR_FLAGS
);
503 mask
&= (tmp
& RTC_IRQMASK
) | RTC_IRQF
;
507 rtc_update_irq(mrst
->rtc
, 1, mask
);
509 } while (mask
& RTC_AIE
);
510 spin_unlock_irq(&rtc_lock
);
513 dev_dbg(&mrst_rtc
.rtc
->dev
, "resume, ctrl %02x\n", tmp
);
519 #define mrst_suspend NULL
520 #define mrst_resume NULL
522 static inline int mrst_poweroff(struct device
*dev
)
529 static int __init
vrtc_mrst_platform_probe(struct platform_device
*pdev
)
531 return vrtc_mrst_do_probe(&pdev
->dev
,
532 platform_get_resource(pdev
, IORESOURCE_MEM
, 0),
533 platform_get_irq(pdev
, 0));
536 static int __exit
vrtc_mrst_platform_remove(struct platform_device
*pdev
)
538 rtc_mrst_do_remove(&pdev
->dev
);
542 static void vrtc_mrst_platform_shutdown(struct platform_device
*pdev
)
544 if (system_state
== SYSTEM_POWER_OFF
&& !mrst_poweroff(&pdev
->dev
))
547 rtc_mrst_do_shutdown();
550 MODULE_ALIAS("platform:vrtc_mrst");
552 static struct platform_driver vrtc_mrst_platform_driver
= {
553 .probe
= vrtc_mrst_platform_probe
,
554 .remove
= __exit_p(vrtc_mrst_platform_remove
),
555 .shutdown
= vrtc_mrst_platform_shutdown
,
557 .name
= (char *) driver_name
,
558 .suspend
= mrst_suspend
,
559 .resume
= mrst_resume
,
563 static int __init
vrtc_mrst_init(void)
565 return platform_driver_register(&vrtc_mrst_platform_driver
);
568 static void __exit
vrtc_mrst_exit(void)
570 platform_driver_unregister(&vrtc_mrst_platform_driver
);
573 module_init(vrtc_mrst_init
);
574 module_exit(vrtc_mrst_exit
);
576 MODULE_AUTHOR("Jacob Pan; Feng Tang");
577 MODULE_DESCRIPTION("Driver for Moorestown virtual RTC");
578 MODULE_LICENSE("GPL");