1 /*
2 * TX4939 internal RTC driver
3 * Based on RBTX49xx patch from CELF patch archive.
4 *
5 * This file is subject to the terms and conditions of the GNU General Public
6 * License. See the file "COPYING" in the main directory of this archive
7 * for more details.
8 *
9 * (C) Copyright TOSHIBA CORPORATION 2005-2007
10 */
11 #include <linux/rtc.h>
12 #include <linux/platform_device.h>
13 #include <linux/interrupt.h>
14 #include <linux/module.h>
15 #include <linux/io.h>
16 #include <linux/gfp.h>
17
18 #define TX4939_RTCCTL_ALME 0x00000080
19 #define TX4939_RTCCTL_ALMD 0x00000040
20 #define TX4939_RTCCTL_BUSY 0x00000020
21
22 #define TX4939_RTCCTL_COMMAND 0x00000007
23 #define TX4939_RTCCTL_COMMAND_NOP 0x00000000
24 #define TX4939_RTCCTL_COMMAND_GETTIME 0x00000001
25 #define TX4939_RTCCTL_COMMAND_SETTIME 0x00000002
26 #define TX4939_RTCCTL_COMMAND_GETALARM 0x00000003
27 #define TX4939_RTCCTL_COMMAND_SETALARM 0x00000004
28
29 #define TX4939_RTCTBC_PM 0x00000080
30 #define TX4939_RTCTBC_COMP 0x0000007f
31
32 #define TX4939_RTC_REG_RAMSIZE 0x00000100
33 #define TX4939_RTC_REG_RWBSIZE 0x00000006
34
35 struct tx4939_rtc_reg {
36 __u32 ctl;
37 __u32 adr;
38 __u32 dat;
39 __u32 tbc;
40 };
41
42 struct tx4939rtc_plat_data {
43 struct rtc_device *rtc;
44 struct tx4939_rtc_reg __iomem *rtcreg;
45 spinlock_t lock;
46 };
47
get_tx4939rtc_plat_data(struct device * dev)48 static struct tx4939rtc_plat_data *get_tx4939rtc_plat_data(struct device *dev)
49 {
50 return platform_get_drvdata(to_platform_device(dev));
51 }
52
tx4939_rtc_cmd(struct tx4939_rtc_reg __iomem * rtcreg,int cmd)53 static int tx4939_rtc_cmd(struct tx4939_rtc_reg __iomem *rtcreg, int cmd)
54 {
55 int i = 0;
56
57 __raw_writel(cmd, &rtcreg->ctl);
58 /* This might take 30us (next 32.768KHz clock) */
59 while (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_BUSY) {
60 /* timeout on approx. 100us (@ GBUS200MHz) */
61 if (i++ > 200 * 100)
62 return -EBUSY;
63 cpu_relax();
64 }
65 return 0;
66 }
67
tx4939_rtc_set_mmss(struct device * dev,unsigned long secs)68 static int tx4939_rtc_set_mmss(struct device *dev, unsigned long secs)
69 {
70 struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
71 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
72 int i, ret;
73 unsigned char buf[6];
74
75 buf[0] = 0;
76 buf[1] = 0;
77 buf[2] = secs;
78 buf[3] = secs >> 8;
79 buf[4] = secs >> 16;
80 buf[5] = secs >> 24;
81 spin_lock_irq(&pdata->lock);
82 __raw_writel(0, &rtcreg->adr);
83 for (i = 0; i < 6; i++)
84 __raw_writel(buf[i], &rtcreg->dat);
85 ret = tx4939_rtc_cmd(rtcreg,
86 TX4939_RTCCTL_COMMAND_SETTIME |
87 (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
88 spin_unlock_irq(&pdata->lock);
89 return ret;
90 }
91
tx4939_rtc_read_time(struct device * dev,struct rtc_time * tm)92 static int tx4939_rtc_read_time(struct device *dev, struct rtc_time *tm)
93 {
94 struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
95 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
96 int i, ret;
97 unsigned long sec;
98 unsigned char buf[6];
99
100 spin_lock_irq(&pdata->lock);
101 ret = tx4939_rtc_cmd(rtcreg,
102 TX4939_RTCCTL_COMMAND_GETTIME |
103 (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
104 if (ret) {
105 spin_unlock_irq(&pdata->lock);
106 return ret;
107 }
108 __raw_writel(2, &rtcreg->adr);
109 for (i = 2; i < 6; i++)
110 buf[i] = __raw_readl(&rtcreg->dat);
111 spin_unlock_irq(&pdata->lock);
112 sec = ((unsigned long)buf[5] << 24) | (buf[4] << 16) |
113 (buf[3] << 8) | buf[2];
114 rtc_time_to_tm(sec, tm);
115 return 0;
116 }
117
tx4939_rtc_set_alarm(struct device * dev,struct rtc_wkalrm * alrm)118 static int tx4939_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
119 {
120 struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
121 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
122 int i, ret;
123 unsigned long sec;
124 unsigned char buf[6];
125
126 if (alrm->time.tm_sec < 0 ||
127 alrm->time.tm_min < 0 ||
128 alrm->time.tm_hour < 0 ||
129 alrm->time.tm_mday < 0 ||
130 alrm->time.tm_mon < 0 ||
131 alrm->time.tm_year < 0)
132 return -EINVAL;
133 rtc_tm_to_time(&alrm->time, &sec);
134 buf[0] = 0;
135 buf[1] = 0;
136 buf[2] = sec;
137 buf[3] = sec >> 8;
138 buf[4] = sec >> 16;
139 buf[5] = sec >> 24;
140 spin_lock_irq(&pdata->lock);
141 __raw_writel(0, &rtcreg->adr);
142 for (i = 0; i < 6; i++)
143 __raw_writel(buf[i], &rtcreg->dat);
144 ret = tx4939_rtc_cmd(rtcreg, TX4939_RTCCTL_COMMAND_SETALARM |
145 (alrm->enabled ? TX4939_RTCCTL_ALME : 0));
146 spin_unlock_irq(&pdata->lock);
147 return ret;
148 }
149
tx4939_rtc_read_alarm(struct device * dev,struct rtc_wkalrm * alrm)150 static int tx4939_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
151 {
152 struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
153 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
154 int i, ret;
155 unsigned long sec;
156 unsigned char buf[6];
157 u32 ctl;
158
159 spin_lock_irq(&pdata->lock);
160 ret = tx4939_rtc_cmd(rtcreg,
161 TX4939_RTCCTL_COMMAND_GETALARM |
162 (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALME));
163 if (ret) {
164 spin_unlock_irq(&pdata->lock);
165 return ret;
166 }
167 __raw_writel(2, &rtcreg->adr);
168 for (i = 2; i < 6; i++)
169 buf[i] = __raw_readl(&rtcreg->dat);
170 ctl = __raw_readl(&rtcreg->ctl);
171 alrm->enabled = (ctl & TX4939_RTCCTL_ALME) ? 1 : 0;
172 alrm->pending = (ctl & TX4939_RTCCTL_ALMD) ? 1 : 0;
173 spin_unlock_irq(&pdata->lock);
174 sec = ((unsigned long)buf[5] << 24) | (buf[4] << 16) |
175 (buf[3] << 8) | buf[2];
176 rtc_time_to_tm(sec, &alrm->time);
177 return rtc_valid_tm(&alrm->time);
178 }
179
tx4939_rtc_alarm_irq_enable(struct device * dev,unsigned int enabled)180 static int tx4939_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
181 {
182 struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev);
183
184 spin_lock_irq(&pdata->lock);
185 tx4939_rtc_cmd(pdata->rtcreg,
186 TX4939_RTCCTL_COMMAND_NOP |
187 (enabled ? TX4939_RTCCTL_ALME : 0));
188 spin_unlock_irq(&pdata->lock);
189 return 0;
190 }
191
tx4939_rtc_interrupt(int irq,void * dev_id)192 static irqreturn_t tx4939_rtc_interrupt(int irq, void *dev_id)
193 {
194 struct tx4939rtc_plat_data *pdata = get_tx4939rtc_plat_data(dev_id);
195 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
196 unsigned long events = RTC_IRQF;
197
198 spin_lock(&pdata->lock);
199 if (__raw_readl(&rtcreg->ctl) & TX4939_RTCCTL_ALMD) {
200 events |= RTC_AF;
201 tx4939_rtc_cmd(rtcreg, TX4939_RTCCTL_COMMAND_NOP);
202 }
203 spin_unlock(&pdata->lock);
204 rtc_update_irq(pdata->rtc, 1, events);
205
206 return IRQ_HANDLED;
207 }
208
209 static const struct rtc_class_ops tx4939_rtc_ops = {
210 .read_time = tx4939_rtc_read_time,
211 .read_alarm = tx4939_rtc_read_alarm,
212 .set_alarm = tx4939_rtc_set_alarm,
213 .set_mmss = tx4939_rtc_set_mmss,
214 .alarm_irq_enable = tx4939_rtc_alarm_irq_enable,
215 };
216
tx4939_nvram_read(void * priv,unsigned int pos,void * val,size_t bytes)217 static int tx4939_nvram_read(void *priv, unsigned int pos, void *val,
218 size_t bytes)
219 {
220 struct tx4939rtc_plat_data *pdata = priv;
221 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
222 u8 *buf = val;
223
224 spin_lock_irq(&pdata->lock);
225 for (; bytes; bytes--) {
226 __raw_writel(pos++, &rtcreg->adr);
227 *buf++ = __raw_readl(&rtcreg->dat);
228 }
229 spin_unlock_irq(&pdata->lock);
230 return 0;
231 }
232
tx4939_nvram_write(void * priv,unsigned int pos,void * val,size_t bytes)233 static int tx4939_nvram_write(void *priv, unsigned int pos, void *val,
234 size_t bytes)
235 {
236 struct tx4939rtc_plat_data *pdata = priv;
237 struct tx4939_rtc_reg __iomem *rtcreg = pdata->rtcreg;
238 u8 *buf = val;
239
240 spin_lock_irq(&pdata->lock);
241 for (; bytes; bytes--) {
242 __raw_writel(pos++, &rtcreg->adr);
243 __raw_writel(*buf++, &rtcreg->dat);
244 }
245 spin_unlock_irq(&pdata->lock);
246 return 0;
247 }
248
tx4939_rtc_probe(struct platform_device * pdev)249 static int __init tx4939_rtc_probe(struct platform_device *pdev)
250 {
251 struct rtc_device *rtc;
252 struct tx4939rtc_plat_data *pdata;
253 struct resource *res;
254 int irq, ret;
255 struct nvmem_config nvmem_cfg = {
256 .name = "tx4939_nvram",
257 .size = TX4939_RTC_REG_RAMSIZE,
258 .reg_read = tx4939_nvram_read,
259 .reg_write = tx4939_nvram_write,
260 };
261
262 irq = platform_get_irq(pdev, 0);
263 if (irq < 0)
264 return -ENODEV;
265 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
266 if (!pdata)
267 return -ENOMEM;
268 platform_set_drvdata(pdev, pdata);
269
270 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
271 pdata->rtcreg = devm_ioremap_resource(&pdev->dev, res);
272 if (IS_ERR(pdata->rtcreg))
273 return PTR_ERR(pdata->rtcreg);
274
275 spin_lock_init(&pdata->lock);
276 tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
277 if (devm_request_irq(&pdev->dev, irq, tx4939_rtc_interrupt,
278 0, pdev->name, &pdev->dev) < 0)
279 return -EBUSY;
280 rtc = devm_rtc_allocate_device(&pdev->dev);
281 if (IS_ERR(rtc))
282 return PTR_ERR(rtc);
283
284 rtc->ops = &tx4939_rtc_ops;
285 rtc->nvram_old_abi = true;
286
287 pdata->rtc = rtc;
288
289 nvmem_cfg.priv = pdata;
290 ret = rtc_nvmem_register(rtc, &nvmem_cfg);
291 if (ret)
292 return ret;
293
294 return rtc_register_device(rtc);
295 }
296
tx4939_rtc_remove(struct platform_device * pdev)297 static int __exit tx4939_rtc_remove(struct platform_device *pdev)
298 {
299 struct tx4939rtc_plat_data *pdata = platform_get_drvdata(pdev);
300
301 spin_lock_irq(&pdata->lock);
302 tx4939_rtc_cmd(pdata->rtcreg, TX4939_RTCCTL_COMMAND_NOP);
303 spin_unlock_irq(&pdata->lock);
304 return 0;
305 }
306
307 static struct platform_driver tx4939_rtc_driver = {
308 .remove = __exit_p(tx4939_rtc_remove),
309 .driver = {
310 .name = "tx4939rtc",
311 },
312 };
313
314 module_platform_driver_probe(tx4939_rtc_driver, tx4939_rtc_probe);
315
316 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
317 MODULE_DESCRIPTION("TX4939 internal RTC driver");
318 MODULE_LICENSE("GPL");
319 MODULE_ALIAS("platform:tx4939rtc");
320