1
2
3
4
5
6
7#include <linux/bitops.h>
8#include <linux/delay.h>
9#include <linux/err.h>
10#include <linux/module.h>
11#include <linux/of.h>
12#include <linux/platform_device.h>
13#include <linux/regmap.h>
14#include <linux/rtc.h>
15
16#define SPRD_RTC_SEC_CNT_VALUE 0x0
17#define SPRD_RTC_MIN_CNT_VALUE 0x4
18#define SPRD_RTC_HOUR_CNT_VALUE 0x8
19#define SPRD_RTC_DAY_CNT_VALUE 0xc
20#define SPRD_RTC_SEC_CNT_UPD 0x10
21#define SPRD_RTC_MIN_CNT_UPD 0x14
22#define SPRD_RTC_HOUR_CNT_UPD 0x18
23#define SPRD_RTC_DAY_CNT_UPD 0x1c
24#define SPRD_RTC_SEC_ALM_UPD 0x20
25#define SPRD_RTC_MIN_ALM_UPD 0x24
26#define SPRD_RTC_HOUR_ALM_UPD 0x28
27#define SPRD_RTC_DAY_ALM_UPD 0x2c
28#define SPRD_RTC_INT_EN 0x30
29#define SPRD_RTC_INT_RAW_STS 0x34
30#define SPRD_RTC_INT_CLR 0x38
31#define SPRD_RTC_INT_MASK_STS 0x3C
32#define SPRD_RTC_SEC_ALM_VALUE 0x40
33#define SPRD_RTC_MIN_ALM_VALUE 0x44
34#define SPRD_RTC_HOUR_ALM_VALUE 0x48
35#define SPRD_RTC_DAY_ALM_VALUE 0x4c
36#define SPRD_RTC_SPG_VALUE 0x50
37#define SPRD_RTC_SPG_UPD 0x54
38#define SPRD_RTC_PWR_CTRL 0x58
39#define SPRD_RTC_PWR_STS 0x5c
40#define SPRD_RTC_SEC_AUXALM_UPD 0x60
41#define SPRD_RTC_MIN_AUXALM_UPD 0x64
42#define SPRD_RTC_HOUR_AUXALM_UPD 0x68
43#define SPRD_RTC_DAY_AUXALM_UPD 0x6c
44
45
46#define SPRD_RTC_SEC_EN BIT(0)
47#define SPRD_RTC_MIN_EN BIT(1)
48#define SPRD_RTC_HOUR_EN BIT(2)
49#define SPRD_RTC_DAY_EN BIT(3)
50#define SPRD_RTC_ALARM_EN BIT(4)
51#define SPRD_RTC_HRS_FORMAT_EN BIT(5)
52#define SPRD_RTC_AUXALM_EN BIT(6)
53#define SPRD_RTC_SPG_UPD_EN BIT(7)
54#define SPRD_RTC_SEC_UPD_EN BIT(8)
55#define SPRD_RTC_MIN_UPD_EN BIT(9)
56#define SPRD_RTC_HOUR_UPD_EN BIT(10)
57#define SPRD_RTC_DAY_UPD_EN BIT(11)
58#define SPRD_RTC_ALMSEC_UPD_EN BIT(12)
59#define SPRD_RTC_ALMMIN_UPD_EN BIT(13)
60#define SPRD_RTC_ALMHOUR_UPD_EN BIT(14)
61#define SPRD_RTC_ALMDAY_UPD_EN BIT(15)
62#define SPRD_RTC_INT_MASK GENMASK(15, 0)
63
64#define SPRD_RTC_TIME_INT_MASK \
65 (SPRD_RTC_SEC_UPD_EN | SPRD_RTC_MIN_UPD_EN | \
66 SPRD_RTC_HOUR_UPD_EN | SPRD_RTC_DAY_UPD_EN)
67
68#define SPRD_RTC_ALMTIME_INT_MASK \
69 (SPRD_RTC_ALMSEC_UPD_EN | SPRD_RTC_ALMMIN_UPD_EN | \
70 SPRD_RTC_ALMHOUR_UPD_EN | SPRD_RTC_ALMDAY_UPD_EN)
71
72#define SPRD_RTC_ALM_INT_MASK \
73 (SPRD_RTC_SEC_EN | SPRD_RTC_MIN_EN | \
74 SPRD_RTC_HOUR_EN | SPRD_RTC_DAY_EN | \
75 SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN)
76
77
78#define SPRD_RTC_SEC_MASK GENMASK(5, 0)
79#define SPRD_RTC_MIN_MASK GENMASK(5, 0)
80#define SPRD_RTC_HOUR_MASK GENMASK(4, 0)
81#define SPRD_RTC_DAY_MASK GENMASK(15, 0)
82
83
84#define SPRD_RTC_ALMLOCK_MASK GENMASK(7, 0)
85#define SPRD_RTC_ALM_UNLOCK 0xa5
86#define SPRD_RTC_ALM_LOCK (~SPRD_RTC_ALM_UNLOCK & \
87 SPRD_RTC_ALMLOCK_MASK)
88
89
90#define SPRD_RTC_POWEROFF_ALM_FLAG BIT(8)
91
92
93#define SPRD_RTC_POWER_RESET_VALUE 0x96
94#define SPRD_RTC_POWER_STS_CLEAR GENMASK(7, 0)
95#define SPRD_RTC_POWER_STS_SHIFT 8
96#define SPRD_RTC_POWER_STS_VALID \
97 (~SPRD_RTC_POWER_RESET_VALUE << SPRD_RTC_POWER_STS_SHIFT)
98
99
100#define SPRD_RTC_POLL_TIMEOUT 200000
101#define SPRD_RTC_POLL_DELAY_US 20000
102
103struct sprd_rtc {
104 struct rtc_device *rtc;
105 struct regmap *regmap;
106 struct device *dev;
107 u32 base;
108 int irq;
109 bool valid;
110};
111
112
113
114
115
116
117
118
119
120enum sprd_rtc_reg_types {
121 SPRD_RTC_TIME,
122 SPRD_RTC_ALARM,
123 SPRD_RTC_AUX_ALARM,
124};
125
126static int sprd_rtc_clear_alarm_ints(struct sprd_rtc *rtc)
127{
128 return regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
129 SPRD_RTC_ALM_INT_MASK);
130}
131
132static int sprd_rtc_disable_ints(struct sprd_rtc *rtc)
133{
134 int ret;
135
136 ret = regmap_update_bits(rtc->regmap, rtc->base + SPRD_RTC_INT_EN,
137 SPRD_RTC_INT_MASK, 0);
138 if (ret)
139 return ret;
140
141 return regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
142 SPRD_RTC_INT_MASK);
143}
144
145static int sprd_rtc_lock_alarm(struct sprd_rtc *rtc, bool lock)
146{
147 int ret;
148 u32 val;
149
150 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_SPG_VALUE, &val);
151 if (ret)
152 return ret;
153
154 val &= ~(SPRD_RTC_ALMLOCK_MASK | SPRD_RTC_POWEROFF_ALM_FLAG);
155 if (lock)
156 val |= SPRD_RTC_ALM_LOCK;
157 else
158 val |= SPRD_RTC_ALM_UNLOCK | SPRD_RTC_POWEROFF_ALM_FLAG;
159
160 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_SPG_UPD, val);
161 if (ret)
162 return ret;
163
164
165 ret = regmap_read_poll_timeout(rtc->regmap,
166 rtc->base + SPRD_RTC_INT_RAW_STS, val,
167 (val & SPRD_RTC_SPG_UPD_EN),
168 SPRD_RTC_POLL_DELAY_US,
169 SPRD_RTC_POLL_TIMEOUT);
170 if (ret) {
171 dev_err(rtc->dev, "failed to update SPG value:%d\n", ret);
172 return ret;
173 }
174
175 return 0;
176}
177
178static int sprd_rtc_get_secs(struct sprd_rtc *rtc, enum sprd_rtc_reg_types type,
179 time64_t *secs)
180{
181 u32 sec_reg, min_reg, hour_reg, day_reg;
182 u32 val, sec, min, hour, day;
183 int ret;
184
185 switch (type) {
186 case SPRD_RTC_TIME:
187 sec_reg = SPRD_RTC_SEC_CNT_VALUE;
188 min_reg = SPRD_RTC_MIN_CNT_VALUE;
189 hour_reg = SPRD_RTC_HOUR_CNT_VALUE;
190 day_reg = SPRD_RTC_DAY_CNT_VALUE;
191 break;
192 case SPRD_RTC_ALARM:
193 sec_reg = SPRD_RTC_SEC_ALM_VALUE;
194 min_reg = SPRD_RTC_MIN_ALM_VALUE;
195 hour_reg = SPRD_RTC_HOUR_ALM_VALUE;
196 day_reg = SPRD_RTC_DAY_ALM_VALUE;
197 break;
198 case SPRD_RTC_AUX_ALARM:
199 sec_reg = SPRD_RTC_SEC_AUXALM_UPD;
200 min_reg = SPRD_RTC_MIN_AUXALM_UPD;
201 hour_reg = SPRD_RTC_HOUR_AUXALM_UPD;
202 day_reg = SPRD_RTC_DAY_AUXALM_UPD;
203 break;
204 default:
205 return -EINVAL;
206 }
207
208 ret = regmap_read(rtc->regmap, rtc->base + sec_reg, &val);
209 if (ret)
210 return ret;
211
212 sec = val & SPRD_RTC_SEC_MASK;
213
214 ret = regmap_read(rtc->regmap, rtc->base + min_reg, &val);
215 if (ret)
216 return ret;
217
218 min = val & SPRD_RTC_MIN_MASK;
219
220 ret = regmap_read(rtc->regmap, rtc->base + hour_reg, &val);
221 if (ret)
222 return ret;
223
224 hour = val & SPRD_RTC_HOUR_MASK;
225
226 ret = regmap_read(rtc->regmap, rtc->base + day_reg, &val);
227 if (ret)
228 return ret;
229
230 day = val & SPRD_RTC_DAY_MASK;
231 *secs = (((time64_t)(day * 24) + hour) * 60 + min) * 60 + sec;
232 return 0;
233}
234
235static int sprd_rtc_set_secs(struct sprd_rtc *rtc, enum sprd_rtc_reg_types type,
236 time64_t secs)
237{
238 u32 sec_reg, min_reg, hour_reg, day_reg, sts_mask;
239 u32 sec, min, hour, day, val;
240 int ret, rem;
241
242
243 day = div_s64_rem(secs, 86400, &rem);
244 hour = rem / 3600;
245 rem -= hour * 3600;
246 min = rem / 60;
247 sec = rem - min * 60;
248
249 switch (type) {
250 case SPRD_RTC_TIME:
251 sec_reg = SPRD_RTC_SEC_CNT_UPD;
252 min_reg = SPRD_RTC_MIN_CNT_UPD;
253 hour_reg = SPRD_RTC_HOUR_CNT_UPD;
254 day_reg = SPRD_RTC_DAY_CNT_UPD;
255 sts_mask = SPRD_RTC_TIME_INT_MASK;
256 break;
257 case SPRD_RTC_ALARM:
258 sec_reg = SPRD_RTC_SEC_ALM_UPD;
259 min_reg = SPRD_RTC_MIN_ALM_UPD;
260 hour_reg = SPRD_RTC_HOUR_ALM_UPD;
261 day_reg = SPRD_RTC_DAY_ALM_UPD;
262 sts_mask = SPRD_RTC_ALMTIME_INT_MASK;
263 break;
264 case SPRD_RTC_AUX_ALARM:
265 sec_reg = SPRD_RTC_SEC_AUXALM_UPD;
266 min_reg = SPRD_RTC_MIN_AUXALM_UPD;
267 hour_reg = SPRD_RTC_HOUR_AUXALM_UPD;
268 day_reg = SPRD_RTC_DAY_AUXALM_UPD;
269 sts_mask = 0;
270 break;
271 default:
272 return -EINVAL;
273 }
274
275 ret = regmap_write(rtc->regmap, rtc->base + sec_reg, sec);
276 if (ret)
277 return ret;
278
279 ret = regmap_write(rtc->regmap, rtc->base + min_reg, min);
280 if (ret)
281 return ret;
282
283 ret = regmap_write(rtc->regmap, rtc->base + hour_reg, hour);
284 if (ret)
285 return ret;
286
287 ret = regmap_write(rtc->regmap, rtc->base + day_reg, day);
288 if (ret)
289 return ret;
290
291 if (type == SPRD_RTC_AUX_ALARM)
292 return 0;
293
294
295
296
297
298
299
300 ret = regmap_read_poll_timeout(rtc->regmap,
301 rtc->base + SPRD_RTC_INT_RAW_STS, val,
302 ((val & sts_mask) == sts_mask),
303 SPRD_RTC_POLL_DELAY_US,
304 SPRD_RTC_POLL_TIMEOUT);
305 if (ret < 0) {
306 dev_err(rtc->dev, "set time/alarm values timeout\n");
307 return ret;
308 }
309
310 return regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
311 sts_mask);
312}
313
314static int sprd_rtc_read_aux_alarm(struct device *dev, struct rtc_wkalrm *alrm)
315{
316 struct sprd_rtc *rtc = dev_get_drvdata(dev);
317 time64_t secs;
318 u32 val;
319 int ret;
320
321 ret = sprd_rtc_get_secs(rtc, SPRD_RTC_AUX_ALARM, &secs);
322 if (ret)
323 return ret;
324
325 rtc_time64_to_tm(secs, &alrm->time);
326
327 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_EN, &val);
328 if (ret)
329 return ret;
330
331 alrm->enabled = !!(val & SPRD_RTC_AUXALM_EN);
332
333 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_RAW_STS, &val);
334 if (ret)
335 return ret;
336
337 alrm->pending = !!(val & SPRD_RTC_AUXALM_EN);
338 return 0;
339}
340
341static int sprd_rtc_set_aux_alarm(struct device *dev, struct rtc_wkalrm *alrm)
342{
343 struct sprd_rtc *rtc = dev_get_drvdata(dev);
344 time64_t secs = rtc_tm_to_time64(&alrm->time);
345 int ret;
346
347
348 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
349 SPRD_RTC_AUXALM_EN);
350 if (ret)
351 return ret;
352
353 ret = sprd_rtc_set_secs(rtc, SPRD_RTC_AUX_ALARM, secs);
354 if (ret)
355 return ret;
356
357 if (alrm->enabled) {
358 ret = regmap_update_bits(rtc->regmap,
359 rtc->base + SPRD_RTC_INT_EN,
360 SPRD_RTC_AUXALM_EN,
361 SPRD_RTC_AUXALM_EN);
362 } else {
363 ret = regmap_update_bits(rtc->regmap,
364 rtc->base + SPRD_RTC_INT_EN,
365 SPRD_RTC_AUXALM_EN, 0);
366 }
367
368 return ret;
369}
370
371static int sprd_rtc_read_time(struct device *dev, struct rtc_time *tm)
372{
373 struct sprd_rtc *rtc = dev_get_drvdata(dev);
374 time64_t secs;
375 int ret;
376
377 if (!rtc->valid) {
378 dev_warn(dev, "RTC values are invalid\n");
379 return -EINVAL;
380 }
381
382 ret = sprd_rtc_get_secs(rtc, SPRD_RTC_TIME, &secs);
383 if (ret)
384 return ret;
385
386 rtc_time64_to_tm(secs, tm);
387 return 0;
388}
389
390static int sprd_rtc_set_time(struct device *dev, struct rtc_time *tm)
391{
392 struct sprd_rtc *rtc = dev_get_drvdata(dev);
393 time64_t secs = rtc_tm_to_time64(tm);
394 int ret;
395
396 ret = sprd_rtc_set_secs(rtc, SPRD_RTC_TIME, secs);
397 if (ret)
398 return ret;
399
400 if (!rtc->valid) {
401
402 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_PWR_CTRL,
403 SPRD_RTC_POWER_STS_CLEAR);
404 if (ret)
405 return ret;
406
407
408
409
410
411 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_PWR_CTRL,
412 SPRD_RTC_POWER_STS_VALID);
413 if (ret)
414 return ret;
415
416 rtc->valid = true;
417 }
418
419 return 0;
420}
421
422static int sprd_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
423{
424 struct sprd_rtc *rtc = dev_get_drvdata(dev);
425 time64_t secs;
426 int ret;
427 u32 val;
428
429
430
431
432
433 if (rtc->rtc && rtc->rtc->aie_timer.enabled == 0)
434 return sprd_rtc_read_aux_alarm(dev, alrm);
435
436 ret = sprd_rtc_get_secs(rtc, SPRD_RTC_ALARM, &secs);
437 if (ret)
438 return ret;
439
440 rtc_time64_to_tm(secs, &alrm->time);
441
442 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_EN, &val);
443 if (ret)
444 return ret;
445
446 alrm->enabled = !!(val & SPRD_RTC_ALARM_EN);
447
448 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_RAW_STS, &val);
449 if (ret)
450 return ret;
451
452 alrm->pending = !!(val & SPRD_RTC_ALARM_EN);
453 return 0;
454}
455
456static int sprd_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
457{
458 struct sprd_rtc *rtc = dev_get_drvdata(dev);
459 time64_t secs = rtc_tm_to_time64(&alrm->time);
460 struct rtc_time aie_time =
461 rtc_ktime_to_tm(rtc->rtc->aie_timer.node.expires);
462 int ret;
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477 if (!rtc->rtc->aie_timer.enabled || rtc_tm_sub(&aie_time, &alrm->time))
478 return sprd_rtc_set_aux_alarm(dev, alrm);
479
480
481 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
482 SPRD_RTC_ALARM_EN);
483 if (ret)
484 return ret;
485
486 ret = sprd_rtc_set_secs(rtc, SPRD_RTC_ALARM, secs);
487 if (ret)
488 return ret;
489
490 if (alrm->enabled) {
491 ret = regmap_update_bits(rtc->regmap,
492 rtc->base + SPRD_RTC_INT_EN,
493 SPRD_RTC_ALARM_EN,
494 SPRD_RTC_ALARM_EN);
495 if (ret)
496 return ret;
497
498
499 ret = sprd_rtc_lock_alarm(rtc, false);
500 } else {
501 regmap_update_bits(rtc->regmap,
502 rtc->base + SPRD_RTC_INT_EN,
503 SPRD_RTC_ALARM_EN, 0);
504
505
506
507
508
509 ret = sprd_rtc_lock_alarm(rtc, true);
510 }
511
512 return ret;
513}
514
515static int sprd_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
516{
517 struct sprd_rtc *rtc = dev_get_drvdata(dev);
518 int ret;
519
520 if (enabled) {
521 ret = regmap_update_bits(rtc->regmap,
522 rtc->base + SPRD_RTC_INT_EN,
523 SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN,
524 SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN);
525 if (ret)
526 return ret;
527
528 ret = sprd_rtc_lock_alarm(rtc, false);
529 } else {
530 regmap_update_bits(rtc->regmap, rtc->base + SPRD_RTC_INT_EN,
531 SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN, 0);
532
533 ret = sprd_rtc_lock_alarm(rtc, true);
534 }
535
536 return ret;
537}
538
539static const struct rtc_class_ops sprd_rtc_ops = {
540 .read_time = sprd_rtc_read_time,
541 .set_time = sprd_rtc_set_time,
542 .read_alarm = sprd_rtc_read_alarm,
543 .set_alarm = sprd_rtc_set_alarm,
544 .alarm_irq_enable = sprd_rtc_alarm_irq_enable,
545};
546
547static irqreturn_t sprd_rtc_handler(int irq, void *dev_id)
548{
549 struct sprd_rtc *rtc = dev_id;
550 int ret;
551
552 ret = sprd_rtc_clear_alarm_ints(rtc);
553 if (ret)
554 return IRQ_RETVAL(ret);
555
556 rtc_update_irq(rtc->rtc, 1, RTC_AF | RTC_IRQF);
557 return IRQ_HANDLED;
558}
559
560static int sprd_rtc_check_power_down(struct sprd_rtc *rtc)
561{
562 u32 val;
563 int ret;
564
565 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_PWR_STS, &val);
566 if (ret)
567 return ret;
568
569
570
571
572
573
574 rtc->valid = val == SPRD_RTC_POWER_RESET_VALUE ? false : true;
575 return 0;
576}
577
578static int sprd_rtc_probe(struct platform_device *pdev)
579{
580 struct device_node *node = pdev->dev.of_node;
581 struct sprd_rtc *rtc;
582 int ret;
583
584 rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
585 if (!rtc)
586 return -ENOMEM;
587
588 rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL);
589 if (!rtc->regmap)
590 return -ENODEV;
591
592 ret = of_property_read_u32(node, "reg", &rtc->base);
593 if (ret) {
594 dev_err(&pdev->dev, "failed to get RTC base address\n");
595 return ret;
596 }
597
598 rtc->irq = platform_get_irq(pdev, 0);
599 if (rtc->irq < 0) {
600 dev_err(&pdev->dev, "failed to get RTC irq number\n");
601 return rtc->irq;
602 }
603
604 rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
605 if (IS_ERR(rtc->rtc))
606 return PTR_ERR(rtc->rtc);
607
608 rtc->dev = &pdev->dev;
609 platform_set_drvdata(pdev, rtc);
610
611
612 ret = sprd_rtc_disable_ints(rtc);
613 if (ret) {
614 dev_err(&pdev->dev, "failed to disable RTC interrupts\n");
615 return ret;
616 }
617
618
619 ret = sprd_rtc_check_power_down(rtc);
620 if (ret) {
621 dev_err(&pdev->dev, "failed to check RTC time values\n");
622 return ret;
623 }
624
625 ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
626 sprd_rtc_handler,
627 IRQF_ONESHOT | IRQF_EARLY_RESUME,
628 pdev->name, rtc);
629 if (ret < 0) {
630 dev_err(&pdev->dev, "failed to request RTC irq\n");
631 return ret;
632 }
633
634 rtc->rtc->ops = &sprd_rtc_ops;
635 rtc->rtc->range_min = 0;
636 rtc->rtc->range_max = 5662310399LL;
637 ret = rtc_register_device(rtc->rtc);
638 if (ret) {
639 dev_err(&pdev->dev, "failed to register rtc device\n");
640 return ret;
641 }
642
643 device_init_wakeup(&pdev->dev, 1);
644 return 0;
645}
646
647static int sprd_rtc_remove(struct platform_device *pdev)
648{
649 device_init_wakeup(&pdev->dev, 0);
650 return 0;
651}
652
653static const struct of_device_id sprd_rtc_of_match[] = {
654 { .compatible = "sprd,sc2731-rtc", },
655 { },
656};
657MODULE_DEVICE_TABLE(of, sprd_rtc_of_match);
658
659static struct platform_driver sprd_rtc_driver = {
660 .driver = {
661 .name = "sprd-rtc",
662 .of_match_table = sprd_rtc_of_match,
663 },
664 .probe = sprd_rtc_probe,
665 .remove = sprd_rtc_remove,
666};
667module_platform_driver(sprd_rtc_driver);
668
669MODULE_LICENSE("GPL v2");
670MODULE_DESCRIPTION("Spreadtrum RTC Device Driver");
671MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");
672
