blob: a99c28992d21658a25663e5e01c7110116ea5bdb [file] [log] [blame]
Daniel Ribeirod3c7a3f2009-09-22 16:46:27 -07001/*
2 * pcap rtc code for Motorola EZX phones
3 *
4 * Copyright (c) 2008 guiming zhuo <gmzhuo@gmail.com>
5 * Copyright (c) 2009 Daniel Ribeiro <drwyrm@gmail.com>
6 *
7 * Based on Motorola's rtc.c Copyright (c) 2003-2005 Motorola
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 */
14
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/init.h>
18#include <linux/mfd/ezx-pcap.h>
19#include <linux/rtc.h>
20#include <linux/platform_device.h>
21
22struct pcap_rtc {
23 struct pcap_chip *pcap;
24 struct rtc_device *rtc;
25};
26
27static irqreturn_t pcap_rtc_irq(int irq, void *_pcap_rtc)
28{
29 struct pcap_rtc *pcap_rtc = _pcap_rtc;
30 unsigned long rtc_events;
31
32 if (irq == pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ))
33 rtc_events = RTC_IRQF | RTC_UF;
34 else if (irq == pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA))
35 rtc_events = RTC_IRQF | RTC_AF;
36 else
37 rtc_events = 0;
38
39 rtc_update_irq(pcap_rtc->rtc, 1, rtc_events);
40 return IRQ_HANDLED;
41}
42
43static int pcap_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
44{
45 struct platform_device *pdev = to_platform_device(dev);
46 struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
47 struct rtc_time *tm = &alrm->time;
48 unsigned long secs;
49 u32 tod; /* time of day, seconds since midnight */
50 u32 days; /* days since 1/1/1970 */
51
52 ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_TODA, &tod);
53 secs = tod & PCAP_RTC_TOD_MASK;
54
55 ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_DAYA, &days);
56 secs += (days & PCAP_RTC_DAY_MASK) * SEC_PER_DAY;
57
58 rtc_time_to_tm(secs, tm);
59
60 return 0;
61}
62
63static int pcap_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
64{
65 struct platform_device *pdev = to_platform_device(dev);
66 struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
67 struct rtc_time *tm = &alrm->time;
68 unsigned long secs;
69 u32 tod, days;
70
71 rtc_tm_to_time(tm, &secs);
72
73 tod = secs % SEC_PER_DAY;
74 ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_TODA, tod);
75
76 days = secs / SEC_PER_DAY;
77 ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_DAYA, days);
78
79 return 0;
80}
81
82static int pcap_rtc_read_time(struct device *dev, struct rtc_time *tm)
83{
84 struct platform_device *pdev = to_platform_device(dev);
85 struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
86 unsigned long secs;
87 u32 tod, days;
88
89 ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_TOD, &tod);
90 secs = tod & PCAP_RTC_TOD_MASK;
91
92 ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_DAY, &days);
93 secs += (days & PCAP_RTC_DAY_MASK) * SEC_PER_DAY;
94
95 rtc_time_to_tm(secs, tm);
96
97 return rtc_valid_tm(tm);
98}
99
100static int pcap_rtc_set_mmss(struct device *dev, unsigned long secs)
101{
102 struct platform_device *pdev = to_platform_device(dev);
103 struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
104 u32 tod, days;
105
106 tod = secs % SEC_PER_DAY;
107 ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_TOD, tod);
108
109 days = secs / SEC_PER_DAY;
110 ezx_pcap_write(pcap_rtc->pcap, PCAP_REG_RTC_DAY, days);
111
112 return 0;
113}
114
115static int pcap_rtc_irq_enable(struct device *dev, int pirq, unsigned int en)
116{
117 struct platform_device *pdev = to_platform_device(dev);
118 struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
119
120 if (en)
121 enable_irq(pcap_to_irq(pcap_rtc->pcap, pirq));
122 else
123 disable_irq(pcap_to_irq(pcap_rtc->pcap, pirq));
124
125 return 0;
126}
127
128static int pcap_rtc_alarm_irq_enable(struct device *dev, unsigned int en)
129{
130 return pcap_rtc_irq_enable(dev, PCAP_IRQ_TODA, en);
131}
132
133static int pcap_rtc_update_irq_enable(struct device *dev, unsigned int en)
134{
135 return pcap_rtc_irq_enable(dev, PCAP_IRQ_1HZ, en);
136}
137
138static const struct rtc_class_ops pcap_rtc_ops = {
139 .read_time = pcap_rtc_read_time,
140 .read_alarm = pcap_rtc_read_alarm,
141 .set_alarm = pcap_rtc_set_alarm,
142 .set_mmss = pcap_rtc_set_mmss,
143 .alarm_irq_enable = pcap_rtc_alarm_irq_enable,
144 .update_irq_enable = pcap_rtc_update_irq_enable,
145};
146
147static int __devinit pcap_rtc_probe(struct platform_device *pdev)
148{
149 struct pcap_rtc *pcap_rtc;
150 int timer_irq, alarm_irq;
151 int err = -ENOMEM;
152
153 pcap_rtc = kmalloc(sizeof(struct pcap_rtc), GFP_KERNEL);
154 if (!pcap_rtc)
155 return err;
156
157 pcap_rtc->pcap = dev_get_drvdata(pdev->dev.parent);
158
159 pcap_rtc->rtc = rtc_device_register("pcap", &pdev->dev,
160 &pcap_rtc_ops, THIS_MODULE);
161 if (IS_ERR(pcap_rtc->rtc)) {
162 err = PTR_ERR(pcap_rtc->rtc);
163 goto fail_rtc;
164 }
165
166 platform_set_drvdata(pdev, pcap_rtc);
167
168 timer_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ);
169 alarm_irq = pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA);
170
171 err = request_irq(timer_irq, pcap_rtc_irq, 0, "RTC Timer", pcap_rtc);
172 if (err)
173 goto fail_timer;
174
175 err = request_irq(alarm_irq, pcap_rtc_irq, 0, "RTC Alarm", pcap_rtc);
176 if (err)
177 goto fail_alarm;
178
179 return 0;
180fail_alarm:
181 free_irq(timer_irq, pcap_rtc);
182fail_timer:
183 rtc_device_unregister(pcap_rtc->rtc);
184fail_rtc:
185 kfree(pcap_rtc);
186 return err;
187}
188
189static int __devexit pcap_rtc_remove(struct platform_device *pdev)
190{
191 struct pcap_rtc *pcap_rtc = platform_get_drvdata(pdev);
192
193 free_irq(pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_1HZ), pcap_rtc);
194 free_irq(pcap_to_irq(pcap_rtc->pcap, PCAP_IRQ_TODA), pcap_rtc);
195 rtc_device_unregister(pcap_rtc->rtc);
196 kfree(pcap_rtc);
197
198 return 0;
199}
200
201static struct platform_driver pcap_rtc_driver = {
202 .remove = __devexit_p(pcap_rtc_remove),
203 .driver = {
204 .name = "pcap-rtc",
205 .owner = THIS_MODULE,
206 },
207};
208
209static int __init rtc_pcap_init(void)
210{
211 return platform_driver_probe(&pcap_rtc_driver, pcap_rtc_probe);
212}
213
214static void __exit rtc_pcap_exit(void)
215{
216 platform_driver_unregister(&pcap_rtc_driver);
217}
218
219module_init(rtc_pcap_init);
220module_exit(rtc_pcap_exit);
221
222MODULE_DESCRIPTION("Motorola pcap rtc driver");
223MODULE_AUTHOR("guiming zhuo <gmzhuo@gmail.com>");
224MODULE_LICENSE("GPL");