648 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Copyright (C) 2017 Spreadtrum Communications Inc.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 0x017#define SPRD_RTC_MIN_CNT_VALUE 0x418#define SPRD_RTC_HOUR_CNT_VALUE 0x819#define SPRD_RTC_DAY_CNT_VALUE 0xc20#define SPRD_RTC_SEC_CNT_UPD 0x1021#define SPRD_RTC_MIN_CNT_UPD 0x1422#define SPRD_RTC_HOUR_CNT_UPD 0x1823#define SPRD_RTC_DAY_CNT_UPD 0x1c24#define SPRD_RTC_SEC_ALM_UPD 0x2025#define SPRD_RTC_MIN_ALM_UPD 0x2426#define SPRD_RTC_HOUR_ALM_UPD 0x2827#define SPRD_RTC_DAY_ALM_UPD 0x2c28#define SPRD_RTC_INT_EN 0x3029#define SPRD_RTC_INT_RAW_STS 0x3430#define SPRD_RTC_INT_CLR 0x3831#define SPRD_RTC_INT_MASK_STS 0x3C32#define SPRD_RTC_SEC_ALM_VALUE 0x4033#define SPRD_RTC_MIN_ALM_VALUE 0x4434#define SPRD_RTC_HOUR_ALM_VALUE 0x4835#define SPRD_RTC_DAY_ALM_VALUE 0x4c36#define SPRD_RTC_SPG_VALUE 0x5037#define SPRD_RTC_SPG_UPD 0x5438#define SPRD_RTC_PWR_CTRL 0x5839#define SPRD_RTC_PWR_STS 0x5c40#define SPRD_RTC_SEC_AUXALM_UPD 0x6041#define SPRD_RTC_MIN_AUXALM_UPD 0x6442#define SPRD_RTC_HOUR_AUXALM_UPD 0x6843#define SPRD_RTC_DAY_AUXALM_UPD 0x6c44 45/* BIT & MASK definition for SPRD_RTC_INT_* registers */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/* second/minute/hour/day values mask definition */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/* alarm lock definition for SPRD_RTC_SPG_UPD register */84#define SPRD_RTC_ALMLOCK_MASK GENMASK(7, 0)85#define SPRD_RTC_ALM_UNLOCK 0xa586#define SPRD_RTC_ALM_LOCK (~SPRD_RTC_ALM_UNLOCK & \87 SPRD_RTC_ALMLOCK_MASK)88 89/* SPG values definition for SPRD_RTC_SPG_UPD register */90#define SPRD_RTC_POWEROFF_ALM_FLAG BIT(8)91 92/* power control/status definition */93#define SPRD_RTC_POWER_RESET_VALUE 0x9694#define SPRD_RTC_POWER_STS_CLEAR GENMASK(7, 0)95#define SPRD_RTC_POWER_STS_SHIFT 896#define SPRD_RTC_POWER_STS_VALID \97 (~SPRD_RTC_POWER_RESET_VALUE << SPRD_RTC_POWER_STS_SHIFT)98 99/* timeout of synchronizing time and alarm registers (us) */100#define SPRD_RTC_POLL_TIMEOUT 200000101#define SPRD_RTC_POLL_DELAY_US 20000102 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 * The Spreadtrum RTC controller has 3 groups registers, including time, normal114 * alarm and auxiliary alarm. The time group registers are used to set RTC time,115 * the normal alarm registers are used to set normal alarm, and the auxiliary116 * alarm registers are used to set auxiliary alarm. Both alarm event and117 * auxiliary alarm event can wake up system from deep sleep, but only alarm118 * event can power up system from power down status.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_lock_alarm(struct sprd_rtc *rtc, bool lock)133{134 int ret;135 u32 val;136 137 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_SPG_VALUE, &val);138 if (ret)139 return ret;140 141 val &= ~SPRD_RTC_ALMLOCK_MASK;142 if (lock)143 val |= SPRD_RTC_ALM_LOCK;144 else145 val |= SPRD_RTC_ALM_UNLOCK | SPRD_RTC_POWEROFF_ALM_FLAG;146 147 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_SPG_UPD, val);148 if (ret)149 return ret;150 151 /* wait until the SPG value is updated successfully */152 ret = regmap_read_poll_timeout(rtc->regmap,153 rtc->base + SPRD_RTC_INT_RAW_STS, val,154 (val & SPRD_RTC_SPG_UPD_EN),155 SPRD_RTC_POLL_DELAY_US,156 SPRD_RTC_POLL_TIMEOUT);157 if (ret) {158 dev_err(rtc->dev, "failed to update SPG value:%d\n", ret);159 return ret;160 }161 162 return regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,163 SPRD_RTC_SPG_UPD_EN);164}165 166static int sprd_rtc_get_secs(struct sprd_rtc *rtc, enum sprd_rtc_reg_types type,167 time64_t *secs)168{169 u32 sec_reg, min_reg, hour_reg, day_reg;170 u32 val, sec, min, hour, day;171 int ret;172 173 switch (type) {174 case SPRD_RTC_TIME:175 sec_reg = SPRD_RTC_SEC_CNT_VALUE;176 min_reg = SPRD_RTC_MIN_CNT_VALUE;177 hour_reg = SPRD_RTC_HOUR_CNT_VALUE;178 day_reg = SPRD_RTC_DAY_CNT_VALUE;179 break;180 case SPRD_RTC_ALARM:181 sec_reg = SPRD_RTC_SEC_ALM_VALUE;182 min_reg = SPRD_RTC_MIN_ALM_VALUE;183 hour_reg = SPRD_RTC_HOUR_ALM_VALUE;184 day_reg = SPRD_RTC_DAY_ALM_VALUE;185 break;186 case SPRD_RTC_AUX_ALARM:187 sec_reg = SPRD_RTC_SEC_AUXALM_UPD;188 min_reg = SPRD_RTC_MIN_AUXALM_UPD;189 hour_reg = SPRD_RTC_HOUR_AUXALM_UPD;190 day_reg = SPRD_RTC_DAY_AUXALM_UPD;191 break;192 default:193 return -EINVAL;194 }195 196 ret = regmap_read(rtc->regmap, rtc->base + sec_reg, &val);197 if (ret)198 return ret;199 200 sec = val & SPRD_RTC_SEC_MASK;201 202 ret = regmap_read(rtc->regmap, rtc->base + min_reg, &val);203 if (ret)204 return ret;205 206 min = val & SPRD_RTC_MIN_MASK;207 208 ret = regmap_read(rtc->regmap, rtc->base + hour_reg, &val);209 if (ret)210 return ret;211 212 hour = val & SPRD_RTC_HOUR_MASK;213 214 ret = regmap_read(rtc->regmap, rtc->base + day_reg, &val);215 if (ret)216 return ret;217 218 day = val & SPRD_RTC_DAY_MASK;219 *secs = (((time64_t)(day * 24) + hour) * 60 + min) * 60 + sec;220 return 0;221}222 223static int sprd_rtc_set_secs(struct sprd_rtc *rtc, enum sprd_rtc_reg_types type,224 time64_t secs)225{226 u32 sec_reg, min_reg, hour_reg, day_reg, sts_mask;227 u32 sec, min, hour, day, val;228 int ret, rem;229 230 /* convert seconds to RTC time format */231 day = div_s64_rem(secs, 86400, &rem);232 hour = rem / 3600;233 rem -= hour * 3600;234 min = rem / 60;235 sec = rem - min * 60;236 237 switch (type) {238 case SPRD_RTC_TIME:239 sec_reg = SPRD_RTC_SEC_CNT_UPD;240 min_reg = SPRD_RTC_MIN_CNT_UPD;241 hour_reg = SPRD_RTC_HOUR_CNT_UPD;242 day_reg = SPRD_RTC_DAY_CNT_UPD;243 sts_mask = SPRD_RTC_TIME_INT_MASK;244 break;245 case SPRD_RTC_ALARM:246 sec_reg = SPRD_RTC_SEC_ALM_UPD;247 min_reg = SPRD_RTC_MIN_ALM_UPD;248 hour_reg = SPRD_RTC_HOUR_ALM_UPD;249 day_reg = SPRD_RTC_DAY_ALM_UPD;250 sts_mask = SPRD_RTC_ALMTIME_INT_MASK;251 break;252 case SPRD_RTC_AUX_ALARM:253 sec_reg = SPRD_RTC_SEC_AUXALM_UPD;254 min_reg = SPRD_RTC_MIN_AUXALM_UPD;255 hour_reg = SPRD_RTC_HOUR_AUXALM_UPD;256 day_reg = SPRD_RTC_DAY_AUXALM_UPD;257 sts_mask = 0;258 break;259 default:260 return -EINVAL;261 }262 263 ret = regmap_write(rtc->regmap, rtc->base + sec_reg, sec);264 if (ret)265 return ret;266 267 ret = regmap_write(rtc->regmap, rtc->base + min_reg, min);268 if (ret)269 return ret;270 271 ret = regmap_write(rtc->regmap, rtc->base + hour_reg, hour);272 if (ret)273 return ret;274 275 ret = regmap_write(rtc->regmap, rtc->base + day_reg, day);276 if (ret)277 return ret;278 279 if (type == SPRD_RTC_AUX_ALARM)280 return 0;281 282 /*283 * Since the time and normal alarm registers are put in always-power-on284 * region supplied by VDDRTC, then these registers changing time will285 * be very long, about 125ms. Thus here we should wait until all286 * values are updated successfully.287 */288 ret = regmap_read_poll_timeout(rtc->regmap,289 rtc->base + SPRD_RTC_INT_RAW_STS, val,290 ((val & sts_mask) == sts_mask),291 SPRD_RTC_POLL_DELAY_US,292 SPRD_RTC_POLL_TIMEOUT);293 if (ret < 0) {294 dev_err(rtc->dev, "set time/alarm values timeout\n");295 return ret;296 }297 298 return regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,299 sts_mask);300}301 302static int sprd_rtc_set_aux_alarm(struct device *dev, struct rtc_wkalrm *alrm)303{304 struct sprd_rtc *rtc = dev_get_drvdata(dev);305 time64_t secs = rtc_tm_to_time64(&alrm->time);306 int ret;307 308 /* clear the auxiliary alarm interrupt status */309 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,310 SPRD_RTC_AUXALM_EN);311 if (ret)312 return ret;313 314 ret = sprd_rtc_set_secs(rtc, SPRD_RTC_AUX_ALARM, secs);315 if (ret)316 return ret;317 318 if (alrm->enabled) {319 ret = regmap_update_bits(rtc->regmap,320 rtc->base + SPRD_RTC_INT_EN,321 SPRD_RTC_AUXALM_EN,322 SPRD_RTC_AUXALM_EN);323 } else {324 ret = regmap_update_bits(rtc->regmap,325 rtc->base + SPRD_RTC_INT_EN,326 SPRD_RTC_AUXALM_EN, 0);327 }328 329 return ret;330}331 332static int sprd_rtc_read_time(struct device *dev, struct rtc_time *tm)333{334 struct sprd_rtc *rtc = dev_get_drvdata(dev);335 time64_t secs;336 int ret;337 338 if (!rtc->valid) {339 dev_warn(dev, "RTC values are invalid\n");340 return -EINVAL;341 }342 343 ret = sprd_rtc_get_secs(rtc, SPRD_RTC_TIME, &secs);344 if (ret)345 return ret;346 347 rtc_time64_to_tm(secs, tm);348 return 0;349}350 351static int sprd_rtc_set_time(struct device *dev, struct rtc_time *tm)352{353 struct sprd_rtc *rtc = dev_get_drvdata(dev);354 time64_t secs = rtc_tm_to_time64(tm);355 int ret;356 357 ret = sprd_rtc_set_secs(rtc, SPRD_RTC_TIME, secs);358 if (ret)359 return ret;360 361 if (!rtc->valid) {362 /* Clear RTC power status firstly */363 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_PWR_CTRL,364 SPRD_RTC_POWER_STS_CLEAR);365 if (ret)366 return ret;367 368 /*369 * Set RTC power status to indicate now RTC has valid time370 * values.371 */372 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_PWR_CTRL,373 SPRD_RTC_POWER_STS_VALID);374 if (ret)375 return ret;376 377 rtc->valid = true;378 }379 380 return 0;381}382 383static int sprd_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)384{385 struct sprd_rtc *rtc = dev_get_drvdata(dev);386 time64_t secs;387 int ret;388 u32 val;389 390 /*391 * The RTC core checks to see if there is an alarm already set in RTC392 * hardware, and we always read the normal alarm at this time.393 */394 ret = sprd_rtc_get_secs(rtc, SPRD_RTC_ALARM, &secs);395 if (ret)396 return ret;397 398 rtc_time64_to_tm(secs, &alrm->time);399 400 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_EN, &val);401 if (ret)402 return ret;403 404 alrm->enabled = !!(val & SPRD_RTC_ALARM_EN);405 406 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_RAW_STS, &val);407 if (ret)408 return ret;409 410 alrm->pending = !!(val & SPRD_RTC_ALARM_EN);411 return 0;412}413 414static int sprd_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)415{416 struct sprd_rtc *rtc = dev_get_drvdata(dev);417 time64_t secs = rtc_tm_to_time64(&alrm->time);418 struct rtc_time aie_time =419 rtc_ktime_to_tm(rtc->rtc->aie_timer.node.expires);420 int ret;421 422 /*423 * We have 2 groups alarms: normal alarm and auxiliary alarm. Since424 * both normal alarm event and auxiliary alarm event can wake up system425 * from deep sleep, but only alarm event can power up system from power426 * down status. Moreover we do not need to poll about 125ms when427 * updating auxiliary alarm registers. Thus we usually set auxiliary428 * alarm when wake up system from deep sleep, and for other scenarios,429 * we should set normal alarm with polling status.430 *431 * So here we check if the alarm time is set by aie_timer, if yes, we432 * should set normal alarm, if not, we should set auxiliary alarm which433 * means it is just a wake event.434 */435 if (!rtc->rtc->aie_timer.enabled || rtc_tm_sub(&aie_time, &alrm->time))436 return sprd_rtc_set_aux_alarm(dev, alrm);437 438 /* clear the alarm interrupt status firstly */439 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,440 SPRD_RTC_ALARM_EN);441 if (ret)442 return ret;443 444 ret = sprd_rtc_set_secs(rtc, SPRD_RTC_ALARM, secs);445 if (ret)446 return ret;447 448 if (alrm->enabled) {449 ret = regmap_update_bits(rtc->regmap,450 rtc->base + SPRD_RTC_INT_EN,451 SPRD_RTC_ALARM_EN,452 SPRD_RTC_ALARM_EN);453 if (ret)454 return ret;455 456 /* unlock the alarm to enable the alarm function. */457 ret = sprd_rtc_lock_alarm(rtc, false);458 } else {459 regmap_update_bits(rtc->regmap,460 rtc->base + SPRD_RTC_INT_EN,461 SPRD_RTC_ALARM_EN, 0);462 463 /*464 * Lock the alarm function in case fake alarm event will power465 * up systems.466 */467 ret = sprd_rtc_lock_alarm(rtc, true);468 }469 470 return ret;471}472 473static int sprd_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)474{475 struct sprd_rtc *rtc = dev_get_drvdata(dev);476 int ret;477 478 if (enabled) {479 ret = regmap_update_bits(rtc->regmap,480 rtc->base + SPRD_RTC_INT_EN,481 SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN,482 SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN);483 if (ret)484 return ret;485 486 ret = sprd_rtc_lock_alarm(rtc, false);487 } else {488 regmap_update_bits(rtc->regmap, rtc->base + SPRD_RTC_INT_EN,489 SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN, 0);490 491 ret = sprd_rtc_lock_alarm(rtc, true);492 }493 494 return ret;495}496 497static const struct rtc_class_ops sprd_rtc_ops = {498 .read_time = sprd_rtc_read_time,499 .set_time = sprd_rtc_set_time,500 .read_alarm = sprd_rtc_read_alarm,501 .set_alarm = sprd_rtc_set_alarm,502 .alarm_irq_enable = sprd_rtc_alarm_irq_enable,503};504 505static irqreturn_t sprd_rtc_handler(int irq, void *dev_id)506{507 struct sprd_rtc *rtc = dev_id;508 int ret;509 510 ret = sprd_rtc_clear_alarm_ints(rtc);511 if (ret)512 return IRQ_RETVAL(ret);513 514 rtc_update_irq(rtc->rtc, 1, RTC_AF | RTC_IRQF);515 return IRQ_HANDLED;516}517 518static int sprd_rtc_check_power_down(struct sprd_rtc *rtc)519{520 u32 val;521 int ret;522 523 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_PWR_STS, &val);524 if (ret)525 return ret;526 527 /*528 * If the RTC power status value is SPRD_RTC_POWER_RESET_VALUE, which529 * means the RTC has been powered down, so the RTC time values are530 * invalid.531 */532 rtc->valid = val != SPRD_RTC_POWER_RESET_VALUE;533 return 0;534}535 536static int sprd_rtc_check_alarm_int(struct sprd_rtc *rtc)537{538 u32 val;539 int ret;540 541 ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_SPG_VALUE, &val);542 if (ret)543 return ret;544 545 /*546 * The SPRD_RTC_INT_EN register is not put in always-power-on region547 * supplied by VDDRTC, so we should check if we need enable the alarm548 * interrupt when system booting.549 *550 * If we have set SPRD_RTC_POWEROFF_ALM_FLAG which is saved in551 * always-power-on region, that means we have set one alarm last time,552 * so we should enable the alarm interrupt to help RTC core to see if553 * there is an alarm already set in RTC hardware.554 */555 if (!(val & SPRD_RTC_POWEROFF_ALM_FLAG))556 return 0;557 558 return regmap_update_bits(rtc->regmap, rtc->base + SPRD_RTC_INT_EN,559 SPRD_RTC_ALARM_EN, SPRD_RTC_ALARM_EN);560}561 562static int sprd_rtc_probe(struct platform_device *pdev)563{564 struct device_node *node = pdev->dev.of_node;565 struct sprd_rtc *rtc;566 int ret;567 568 rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);569 if (!rtc)570 return -ENOMEM;571 572 rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL);573 if (!rtc->regmap)574 return -ENODEV;575 576 ret = of_property_read_u32(node, "reg", &rtc->base);577 if (ret) {578 dev_err(&pdev->dev, "failed to get RTC base address\n");579 return ret;580 }581 582 rtc->irq = platform_get_irq(pdev, 0);583 if (rtc->irq < 0)584 return rtc->irq;585 586 rtc->rtc = devm_rtc_allocate_device(&pdev->dev);587 if (IS_ERR(rtc->rtc))588 return PTR_ERR(rtc->rtc);589 590 rtc->dev = &pdev->dev;591 platform_set_drvdata(pdev, rtc);592 593 /* check if we need set the alarm interrupt */594 ret = sprd_rtc_check_alarm_int(rtc);595 if (ret) {596 dev_err(&pdev->dev, "failed to check RTC alarm interrupt\n");597 return ret;598 }599 600 /* check if RTC time values are valid */601 ret = sprd_rtc_check_power_down(rtc);602 if (ret) {603 dev_err(&pdev->dev, "failed to check RTC time values\n");604 return ret;605 }606 607 ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,608 sprd_rtc_handler,609 IRQF_ONESHOT | IRQF_EARLY_RESUME,610 pdev->name, rtc);611 if (ret < 0) {612 dev_err(&pdev->dev, "failed to request RTC irq\n");613 return ret;614 }615 616 device_init_wakeup(&pdev->dev, 1);617 618 rtc->rtc->ops = &sprd_rtc_ops;619 rtc->rtc->range_min = 0;620 rtc->rtc->range_max = 5662310399LL;621 ret = devm_rtc_register_device(rtc->rtc);622 if (ret) {623 device_init_wakeup(&pdev->dev, 0);624 return ret;625 }626 627 return 0;628}629 630static const struct of_device_id sprd_rtc_of_match[] = {631 { .compatible = "sprd,sc2731-rtc", },632 { },633};634MODULE_DEVICE_TABLE(of, sprd_rtc_of_match);635 636static struct platform_driver sprd_rtc_driver = {637 .driver = {638 .name = "sprd-rtc",639 .of_match_table = sprd_rtc_of_match,640 },641 .probe = sprd_rtc_probe,642};643module_platform_driver(sprd_rtc_driver);644 645MODULE_LICENSE("GPL v2");646MODULE_DESCRIPTION("Spreadtrum RTC Device Driver");647MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");648