LXR linux/drivers/rtc/rtc-sc27xx.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   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          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/* 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             0xa5
  86#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      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/* timeout of synchronizing time and alarm registers (us) */
 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 * The Spreadtrum RTC controller has 3 groups registers, including time, normal
 114 * 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 auxiliary
 116 * alarm registers are used to set auxiliary alarm. Both alarm event and
 117 * auxiliary alarm event can wake up system from deep sleep, but only alarm
 118 * 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        else
 145                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-on
 284         * region supplied by VDDRTC, then these registers changing time will
 285         * be very long, about 125ms. Thus here we should wait until all
 286         * 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 time
 370                 * 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 RTC
 392         * 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. Since
 424         * both normal alarm event and auxiliary alarm event can wake up system
 425         * from deep sleep, but only alarm event can power up system from power
 426         * down status. Moreover we do not need to poll about 125ms when
 427         * updating auxiliary alarm registers. Thus we usually set auxiliary
 428         * 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, we
 432         * should set normal alarm, if not, we should set auxiliary alarm which
 433         * 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 power
 465                 * 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, which
 529         * means the RTC has been powered down, so the RTC time values are
 530         * 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 region
 547         * supplied by VDDRTC, so we should check if we need enable the alarm
 548         * interrupt when system booting.
 549         *
 550         * If we have set SPRD_RTC_POWEROFF_ALM_FLAG which is saved in
 551         * 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 if
 553         * 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