]>
Commit | Line | Data |
---|---|---|
0942a71e RK |
1 | /* |
2 | * drivers/rtc/rtc-spear.c | |
3 | * | |
4 | * Copyright (C) 2010 ST Microelectronics | |
5 | * Rajeev Kumar<rajeev-dlh.kumar@st.com> | |
6 | * | |
7 | * This file is licensed under the terms of the GNU General Public | |
8 | * License version 2. This program is licensed "as is" without any | |
9 | * warranty of any kind, whether express or implied. | |
10 | */ | |
11 | ||
12 | #include <linux/bcd.h> | |
13 | #include <linux/clk.h> | |
14 | #include <linux/delay.h> | |
15 | #include <linux/init.h> | |
16 | #include <linux/io.h> | |
17 | #include <linux/irq.h> | |
18 | #include <linux/module.h> | |
0108c4ff | 19 | #include <linux/of.h> |
0942a71e RK |
20 | #include <linux/platform_device.h> |
21 | #include <linux/rtc.h> | |
22 | #include <linux/slab.h> | |
23 | #include <linux/spinlock.h> | |
24 | ||
25 | /* RTC registers */ | |
26 | #define TIME_REG 0x00 | |
27 | #define DATE_REG 0x04 | |
28 | #define ALARM_TIME_REG 0x08 | |
29 | #define ALARM_DATE_REG 0x0C | |
30 | #define CTRL_REG 0x10 | |
31 | #define STATUS_REG 0x14 | |
32 | ||
33 | /* TIME_REG & ALARM_TIME_REG */ | |
34 | #define SECONDS_UNITS (0xf<<0) /* seconds units position */ | |
35 | #define SECONDS_TENS (0x7<<4) /* seconds tens position */ | |
36 | #define MINUTES_UNITS (0xf<<8) /* minutes units position */ | |
37 | #define MINUTES_TENS (0x7<<12) /* minutes tens position */ | |
38 | #define HOURS_UNITS (0xf<<16) /* hours units position */ | |
39 | #define HOURS_TENS (0x3<<20) /* hours tens position */ | |
40 | ||
41 | /* DATE_REG & ALARM_DATE_REG */ | |
42 | #define DAYS_UNITS (0xf<<0) /* days units position */ | |
43 | #define DAYS_TENS (0x3<<4) /* days tens position */ | |
44 | #define MONTHS_UNITS (0xf<<8) /* months units position */ | |
45 | #define MONTHS_TENS (0x1<<12) /* months tens position */ | |
46 | #define YEARS_UNITS (0xf<<16) /* years units position */ | |
47 | #define YEARS_TENS (0xf<<20) /* years tens position */ | |
48 | #define YEARS_HUNDREDS (0xf<<24) /* years hundereds position */ | |
49 | #define YEARS_MILLENIUMS (0xf<<28) /* years millenium position */ | |
50 | ||
51 | /* MASK SHIFT TIME_REG & ALARM_TIME_REG*/ | |
52 | #define SECOND_SHIFT 0x00 /* seconds units */ | |
53 | #define MINUTE_SHIFT 0x08 /* minutes units position */ | |
54 | #define HOUR_SHIFT 0x10 /* hours units position */ | |
55 | #define MDAY_SHIFT 0x00 /* Month day shift */ | |
56 | #define MONTH_SHIFT 0x08 /* Month shift */ | |
57 | #define YEAR_SHIFT 0x10 /* Year shift */ | |
58 | ||
59 | #define SECOND_MASK 0x7F | |
60 | #define MIN_MASK 0x7F | |
61 | #define HOUR_MASK 0x3F | |
62 | #define DAY_MASK 0x3F | |
63 | #define MONTH_MASK 0x7F | |
64 | #define YEAR_MASK 0xFFFF | |
65 | ||
66 | /* date reg equal to time reg, for debug only */ | |
67 | #define TIME_BYP (1<<9) | |
68 | #define INT_ENABLE (1<<31) /* interrupt enable */ | |
69 | ||
70 | /* STATUS_REG */ | |
71 | #define CLK_UNCONNECTED (1<<0) | |
72 | #define PEND_WR_TIME (1<<2) | |
73 | #define PEND_WR_DATE (1<<3) | |
74 | #define LOST_WR_TIME (1<<4) | |
75 | #define LOST_WR_DATE (1<<5) | |
76 | #define RTC_INT_MASK (1<<31) | |
77 | #define STATUS_BUSY (PEND_WR_TIME | PEND_WR_DATE) | |
78 | #define STATUS_FAIL (LOST_WR_TIME | LOST_WR_DATE) | |
79 | ||
80 | struct spear_rtc_config { | |
ee6c54ca | 81 | struct rtc_device *rtc; |
0942a71e RK |
82 | struct clk *clk; |
83 | spinlock_t lock; | |
84 | void __iomem *ioaddr; | |
cd0e08a8 | 85 | unsigned int irq_wake; |
0942a71e RK |
86 | }; |
87 | ||
88 | static inline void spear_rtc_clear_interrupt(struct spear_rtc_config *config) | |
89 | { | |
90 | unsigned int val; | |
91 | unsigned long flags; | |
92 | ||
93 | spin_lock_irqsave(&config->lock, flags); | |
94 | val = readl(config->ioaddr + STATUS_REG); | |
95 | val |= RTC_INT_MASK; | |
96 | writel(val, config->ioaddr + STATUS_REG); | |
97 | spin_unlock_irqrestore(&config->lock, flags); | |
98 | } | |
99 | ||
100 | static inline void spear_rtc_enable_interrupt(struct spear_rtc_config *config) | |
101 | { | |
102 | unsigned int val; | |
103 | ||
104 | val = readl(config->ioaddr + CTRL_REG); | |
105 | if (!(val & INT_ENABLE)) { | |
106 | spear_rtc_clear_interrupt(config); | |
107 | val |= INT_ENABLE; | |
108 | writel(val, config->ioaddr + CTRL_REG); | |
109 | } | |
110 | } | |
111 | ||
112 | static inline void spear_rtc_disable_interrupt(struct spear_rtc_config *config) | |
113 | { | |
114 | unsigned int val; | |
115 | ||
116 | val = readl(config->ioaddr + CTRL_REG); | |
117 | if (val & INT_ENABLE) { | |
118 | val &= ~INT_ENABLE; | |
119 | writel(val, config->ioaddr + CTRL_REG); | |
120 | } | |
121 | } | |
122 | ||
123 | static inline int is_write_complete(struct spear_rtc_config *config) | |
124 | { | |
125 | int ret = 0; | |
126 | unsigned long flags; | |
127 | ||
128 | spin_lock_irqsave(&config->lock, flags); | |
129 | if ((readl(config->ioaddr + STATUS_REG)) & STATUS_FAIL) | |
130 | ret = -EIO; | |
131 | spin_unlock_irqrestore(&config->lock, flags); | |
132 | ||
133 | return ret; | |
134 | } | |
135 | ||
136 | static void rtc_wait_not_busy(struct spear_rtc_config *config) | |
137 | { | |
138 | int status, count = 0; | |
139 | unsigned long flags; | |
140 | ||
141 | /* Assuming BUSY may stay active for 80 msec) */ | |
142 | for (count = 0; count < 80; count++) { | |
143 | spin_lock_irqsave(&config->lock, flags); | |
144 | status = readl(config->ioaddr + STATUS_REG); | |
145 | spin_unlock_irqrestore(&config->lock, flags); | |
146 | if ((status & STATUS_BUSY) == 0) | |
147 | break; | |
148 | /* check status busy, after each msec */ | |
149 | msleep(1); | |
150 | } | |
151 | } | |
152 | ||
153 | static irqreturn_t spear_rtc_irq(int irq, void *dev_id) | |
154 | { | |
ee6c54ca | 155 | struct spear_rtc_config *config = dev_id; |
0942a71e RK |
156 | unsigned long flags, events = 0; |
157 | unsigned int irq_data; | |
158 | ||
159 | spin_lock_irqsave(&config->lock, flags); | |
160 | irq_data = readl(config->ioaddr + STATUS_REG); | |
161 | spin_unlock_irqrestore(&config->lock, flags); | |
162 | ||
163 | if ((irq_data & RTC_INT_MASK)) { | |
164 | spear_rtc_clear_interrupt(config); | |
165 | events = RTC_IRQF | RTC_AF; | |
ee6c54ca | 166 | rtc_update_irq(config->rtc, 1, events); |
0942a71e RK |
167 | return IRQ_HANDLED; |
168 | } else | |
169 | return IRQ_NONE; | |
170 | ||
171 | } | |
172 | ||
173 | static int tm2bcd(struct rtc_time *tm) | |
174 | { | |
175 | if (rtc_valid_tm(tm) != 0) | |
176 | return -EINVAL; | |
177 | tm->tm_sec = bin2bcd(tm->tm_sec); | |
178 | tm->tm_min = bin2bcd(tm->tm_min); | |
179 | tm->tm_hour = bin2bcd(tm->tm_hour); | |
180 | tm->tm_mday = bin2bcd(tm->tm_mday); | |
181 | tm->tm_mon = bin2bcd(tm->tm_mon + 1); | |
182 | tm->tm_year = bin2bcd(tm->tm_year); | |
183 | ||
184 | return 0; | |
185 | } | |
186 | ||
187 | static void bcd2tm(struct rtc_time *tm) | |
188 | { | |
189 | tm->tm_sec = bcd2bin(tm->tm_sec); | |
190 | tm->tm_min = bcd2bin(tm->tm_min); | |
191 | tm->tm_hour = bcd2bin(tm->tm_hour); | |
192 | tm->tm_mday = bcd2bin(tm->tm_mday); | |
193 | tm->tm_mon = bcd2bin(tm->tm_mon) - 1; | |
194 | /* epoch == 1900 */ | |
195 | tm->tm_year = bcd2bin(tm->tm_year); | |
196 | } | |
197 | ||
198 | /* | |
199 | * spear_rtc_read_time - set the time | |
200 | * @dev: rtc device in use | |
201 | * @tm: holds date and time | |
202 | * | |
203 | * This function read time and date. On success it will return 0 | |
204 | * otherwise -ve error is returned. | |
205 | */ | |
206 | static int spear_rtc_read_time(struct device *dev, struct rtc_time *tm) | |
207 | { | |
ee6c54ca | 208 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
0942a71e RK |
209 | unsigned int time, date; |
210 | ||
211 | /* we don't report wday/yday/isdst ... */ | |
212 | rtc_wait_not_busy(config); | |
213 | ||
214 | time = readl(config->ioaddr + TIME_REG); | |
215 | date = readl(config->ioaddr + DATE_REG); | |
216 | tm->tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK; | |
217 | tm->tm_min = (time >> MINUTE_SHIFT) & MIN_MASK; | |
218 | tm->tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK; | |
219 | tm->tm_mday = (date >> MDAY_SHIFT) & DAY_MASK; | |
220 | tm->tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK; | |
221 | tm->tm_year = (date >> YEAR_SHIFT) & YEAR_MASK; | |
222 | ||
223 | bcd2tm(tm); | |
224 | return 0; | |
225 | } | |
226 | ||
227 | /* | |
228 | * spear_rtc_set_time - set the time | |
229 | * @dev: rtc device in use | |
230 | * @tm: holds date and time | |
231 | * | |
232 | * This function set time and date. On success it will return 0 | |
233 | * otherwise -ve error is returned. | |
234 | */ | |
235 | static int spear_rtc_set_time(struct device *dev, struct rtc_time *tm) | |
236 | { | |
ee6c54ca | 237 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
a16e8393 | 238 | unsigned int time, date; |
0942a71e RK |
239 | |
240 | if (tm2bcd(tm) < 0) | |
241 | return -EINVAL; | |
242 | ||
243 | rtc_wait_not_busy(config); | |
244 | time = (tm->tm_sec << SECOND_SHIFT) | (tm->tm_min << MINUTE_SHIFT) | | |
245 | (tm->tm_hour << HOUR_SHIFT); | |
246 | date = (tm->tm_mday << MDAY_SHIFT) | (tm->tm_mon << MONTH_SHIFT) | | |
247 | (tm->tm_year << YEAR_SHIFT); | |
248 | writel(time, config->ioaddr + TIME_REG); | |
249 | writel(date, config->ioaddr + DATE_REG); | |
0942a71e | 250 | |
a16e8393 | 251 | return is_write_complete(config); |
0942a71e RK |
252 | } |
253 | ||
254 | /* | |
255 | * spear_rtc_read_alarm - read the alarm time | |
256 | * @dev: rtc device in use | |
257 | * @alm: holds alarm date and time | |
258 | * | |
259 | * This function read alarm time and date. On success it will return 0 | |
260 | * otherwise -ve error is returned. | |
261 | */ | |
262 | static int spear_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm) | |
263 | { | |
ee6c54ca | 264 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
0942a71e RK |
265 | unsigned int time, date; |
266 | ||
267 | rtc_wait_not_busy(config); | |
268 | ||
269 | time = readl(config->ioaddr + ALARM_TIME_REG); | |
270 | date = readl(config->ioaddr + ALARM_DATE_REG); | |
271 | alm->time.tm_sec = (time >> SECOND_SHIFT) & SECOND_MASK; | |
272 | alm->time.tm_min = (time >> MINUTE_SHIFT) & MIN_MASK; | |
273 | alm->time.tm_hour = (time >> HOUR_SHIFT) & HOUR_MASK; | |
274 | alm->time.tm_mday = (date >> MDAY_SHIFT) & DAY_MASK; | |
275 | alm->time.tm_mon = (date >> MONTH_SHIFT) & MONTH_MASK; | |
276 | alm->time.tm_year = (date >> YEAR_SHIFT) & YEAR_MASK; | |
277 | ||
278 | bcd2tm(&alm->time); | |
279 | alm->enabled = readl(config->ioaddr + CTRL_REG) & INT_ENABLE; | |
280 | ||
281 | return 0; | |
282 | } | |
283 | ||
284 | /* | |
285 | * spear_rtc_set_alarm - set the alarm time | |
286 | * @dev: rtc device in use | |
287 | * @alm: holds alarm date and time | |
288 | * | |
289 | * This function set alarm time and date. On success it will return 0 | |
290 | * otherwise -ve error is returned. | |
291 | */ | |
292 | static int spear_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm) | |
293 | { | |
ee6c54ca | 294 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
a16e8393 LPC |
295 | unsigned int time, date; |
296 | int err; | |
0942a71e RK |
297 | |
298 | if (tm2bcd(&alm->time) < 0) | |
299 | return -EINVAL; | |
300 | ||
301 | rtc_wait_not_busy(config); | |
302 | ||
303 | time = (alm->time.tm_sec << SECOND_SHIFT) | (alm->time.tm_min << | |
304 | MINUTE_SHIFT) | (alm->time.tm_hour << HOUR_SHIFT); | |
305 | date = (alm->time.tm_mday << MDAY_SHIFT) | (alm->time.tm_mon << | |
306 | MONTH_SHIFT) | (alm->time.tm_year << YEAR_SHIFT); | |
307 | ||
308 | writel(time, config->ioaddr + ALARM_TIME_REG); | |
309 | writel(date, config->ioaddr + ALARM_DATE_REG); | |
310 | err = is_write_complete(config); | |
311 | if (err < 0) | |
312 | return err; | |
313 | ||
314 | if (alm->enabled) | |
315 | spear_rtc_enable_interrupt(config); | |
316 | else | |
317 | spear_rtc_disable_interrupt(config); | |
318 | ||
319 | return 0; | |
320 | } | |
131f8b75 SH |
321 | |
322 | static int spear_alarm_irq_enable(struct device *dev, unsigned int enabled) | |
323 | { | |
ee6c54ca | 324 | struct spear_rtc_config *config = dev_get_drvdata(dev); |
131f8b75 SH |
325 | int ret = 0; |
326 | ||
327 | spear_rtc_clear_interrupt(config); | |
328 | ||
329 | switch (enabled) { | |
330 | case 0: | |
331 | /* alarm off */ | |
332 | spear_rtc_disable_interrupt(config); | |
333 | break; | |
334 | case 1: | |
335 | /* alarm on */ | |
336 | spear_rtc_enable_interrupt(config); | |
337 | break; | |
338 | default: | |
339 | ret = -EINVAL; | |
340 | break; | |
341 | } | |
342 | ||
343 | return ret; | |
344 | } | |
345 | ||
0942a71e RK |
346 | static struct rtc_class_ops spear_rtc_ops = { |
347 | .read_time = spear_rtc_read_time, | |
348 | .set_time = spear_rtc_set_time, | |
349 | .read_alarm = spear_rtc_read_alarm, | |
350 | .set_alarm = spear_rtc_set_alarm, | |
131f8b75 | 351 | .alarm_irq_enable = spear_alarm_irq_enable, |
0942a71e RK |
352 | }; |
353 | ||
5a167f45 | 354 | static int spear_rtc_probe(struct platform_device *pdev) |
0942a71e RK |
355 | { |
356 | struct resource *res; | |
0942a71e | 357 | struct spear_rtc_config *config; |
a16e8393 | 358 | int status = 0; |
0942a71e RK |
359 | int irq; |
360 | ||
bdaa2c63 | 361 | config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL); |
681acc9f | 362 | if (!config) |
bdaa2c63 | 363 | return -ENOMEM; |
0942a71e | 364 | |
bdaa2c63 VK |
365 | /* alarm irqs */ |
366 | irq = platform_get_irq(pdev, 0); | |
367 | if (irq < 0) { | |
368 | dev_err(&pdev->dev, "no update irq?\n"); | |
369 | return irq; | |
0942a71e RK |
370 | } |
371 | ||
bdaa2c63 VK |
372 | status = devm_request_irq(&pdev->dev, irq, spear_rtc_irq, 0, pdev->name, |
373 | config); | |
374 | if (status) { | |
375 | dev_err(&pdev->dev, "Alarm interrupt IRQ%d already claimed\n", | |
376 | irq); | |
377 | return status; | |
378 | } | |
0942a71e | 379 | |
e044253b | 380 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); |
8cbce1e5 TR |
381 | config->ioaddr = devm_ioremap_resource(&pdev->dev, res); |
382 | if (IS_ERR(config->ioaddr)) | |
383 | return PTR_ERR(config->ioaddr); | |
0942a71e | 384 | |
bdaa2c63 VK |
385 | config->clk = devm_clk_get(&pdev->dev, NULL); |
386 | if (IS_ERR(config->clk)) | |
387 | return PTR_ERR(config->clk); | |
388 | ||
93d78394 | 389 | status = clk_prepare_enable(config->clk); |
bdaa2c63 VK |
390 | if (status < 0) |
391 | return status; | |
392 | ||
0942a71e | 393 | spin_lock_init(&config->lock); |
ee6c54ca | 394 | platform_set_drvdata(pdev, config); |
0942a71e | 395 | |
246b1a99 JH |
396 | config->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, |
397 | &spear_rtc_ops, THIS_MODULE); | |
ee6c54ca | 398 | if (IS_ERR(config->rtc)) { |
0942a71e | 399 | dev_err(&pdev->dev, "can't register RTC device, err %ld\n", |
ee6c54ca VK |
400 | PTR_ERR(config->rtc)); |
401 | status = PTR_ERR(config->rtc); | |
bdaa2c63 | 402 | goto err_disable_clock; |
0942a71e RK |
403 | } |
404 | ||
c9f5c7e7 DS |
405 | config->rtc->uie_unsupported = 1; |
406 | ||
0942a71e RK |
407 | if (!device_can_wakeup(&pdev->dev)) |
408 | device_init_wakeup(&pdev->dev, 1); | |
409 | ||
410 | return 0; | |
411 | ||
0942a71e | 412 | err_disable_clock: |
93d78394 | 413 | clk_disable_unprepare(config->clk); |
0942a71e RK |
414 | |
415 | return status; | |
416 | } | |
417 | ||
5a167f45 | 418 | static int spear_rtc_remove(struct platform_device *pdev) |
0942a71e | 419 | { |
ee6c54ca | 420 | struct spear_rtc_config *config = platform_get_drvdata(pdev); |
0942a71e | 421 | |
0942a71e | 422 | spear_rtc_disable_interrupt(config); |
93d78394 | 423 | clk_disable_unprepare(config->clk); |
bdaa2c63 | 424 | device_init_wakeup(&pdev->dev, 0); |
0942a71e RK |
425 | |
426 | return 0; | |
427 | } | |
428 | ||
b086e392 JH |
429 | #ifdef CONFIG_PM_SLEEP |
430 | static int spear_rtc_suspend(struct device *dev) | |
0942a71e | 431 | { |
b086e392 | 432 | struct platform_device *pdev = to_platform_device(dev); |
ee6c54ca | 433 | struct spear_rtc_config *config = platform_get_drvdata(pdev); |
0942a71e RK |
434 | int irq; |
435 | ||
436 | irq = platform_get_irq(pdev, 0); | |
cd0e08a8 DS |
437 | if (device_may_wakeup(&pdev->dev)) { |
438 | if (!enable_irq_wake(irq)) | |
439 | config->irq_wake = 1; | |
440 | } else { | |
0942a71e RK |
441 | spear_rtc_disable_interrupt(config); |
442 | clk_disable(config->clk); | |
443 | } | |
444 | ||
445 | return 0; | |
446 | } | |
447 | ||
b086e392 | 448 | static int spear_rtc_resume(struct device *dev) |
0942a71e | 449 | { |
b086e392 | 450 | struct platform_device *pdev = to_platform_device(dev); |
ee6c54ca | 451 | struct spear_rtc_config *config = platform_get_drvdata(pdev); |
0942a71e RK |
452 | int irq; |
453 | ||
454 | irq = platform_get_irq(pdev, 0); | |
455 | ||
cd0e08a8 DS |
456 | if (device_may_wakeup(&pdev->dev)) { |
457 | if (config->irq_wake) { | |
458 | disable_irq_wake(irq); | |
459 | config->irq_wake = 0; | |
460 | } | |
461 | } else { | |
0942a71e RK |
462 | clk_enable(config->clk); |
463 | spear_rtc_enable_interrupt(config); | |
464 | } | |
465 | ||
466 | return 0; | |
467 | } | |
0942a71e RK |
468 | #endif |
469 | ||
b086e392 JH |
470 | static SIMPLE_DEV_PM_OPS(spear_rtc_pm_ops, spear_rtc_suspend, spear_rtc_resume); |
471 | ||
0942a71e RK |
472 | static void spear_rtc_shutdown(struct platform_device *pdev) |
473 | { | |
ee6c54ca | 474 | struct spear_rtc_config *config = platform_get_drvdata(pdev); |
0942a71e RK |
475 | |
476 | spear_rtc_disable_interrupt(config); | |
477 | clk_disable(config->clk); | |
478 | } | |
479 | ||
0108c4ff VK |
480 | #ifdef CONFIG_OF |
481 | static const struct of_device_id spear_rtc_id_table[] = { | |
482 | { .compatible = "st,spear600-rtc" }, | |
483 | {} | |
484 | }; | |
485 | MODULE_DEVICE_TABLE(of, spear_rtc_id_table); | |
486 | #endif | |
487 | ||
0942a71e RK |
488 | static struct platform_driver spear_rtc_driver = { |
489 | .probe = spear_rtc_probe, | |
5a167f45 | 490 | .remove = spear_rtc_remove, |
0942a71e RK |
491 | .shutdown = spear_rtc_shutdown, |
492 | .driver = { | |
493 | .name = "rtc-spear", | |
b086e392 | 494 | .pm = &spear_rtc_pm_ops, |
0108c4ff | 495 | .of_match_table = of_match_ptr(spear_rtc_id_table), |
0942a71e RK |
496 | }, |
497 | }; | |
498 | ||
0c4eae66 | 499 | module_platform_driver(spear_rtc_driver); |
0942a71e RK |
500 | |
501 | MODULE_ALIAS("platform:rtc-spear"); | |
502 | MODULE_AUTHOR("Rajeev Kumar <rajeev-dlh.kumar@st.com>"); | |
503 | MODULE_DESCRIPTION("ST SPEAr Realtime Clock Driver (RTC)"); | |
504 | MODULE_LICENSE("GPL"); |