drivers/rtc/rtc-sc27xx.c

   1 /*
   2  * Copyright (C) 2017 Spreadtrum Communications Inc.
   3  *
   4  * SPDX-License-Identifier: GPL-2.0
   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
 103 struct 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  */
 120 enum sprd_rtc_reg_types {
 121         SPRD_RTC_TIME,
 122         SPRD_RTC_ALARM,
 123         SPRD_RTC_AUX_ALARM,
 124 };
 125
 126 static 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
 132 static 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 | SPRD_RTC_POWEROFF_ALM_FLAG);
 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
 166 static 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
 223 static 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
 302 static int sprd_rtc_read_aux_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 303 {
 304         struct sprd_rtc *rtc = dev_get_drvdata(dev);
 305         time64_t secs;
 306         u32 val;
 307         int ret;
 308
 309         ret = sprd_rtc_get_secs(rtc, SPRD_RTC_AUX_ALARM, &secs);
 310         if (ret)
 311                 return ret;
 312
 313         rtc_time64_to_tm(secs, &alrm->time);
 314
 315         ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_EN, &val);
 316         if (ret)
 317                 return ret;
 318
 319         alrm->enabled = !!(val & SPRD_RTC_AUXALM_EN);
 320
 321         ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_RAW_STS, &val);
 322         if (ret)
 323                 return ret;
 324
 325         alrm->pending = !!(val & SPRD_RTC_AUXALM_EN);
 326         return 0;
 327 }
 328
 329 static int sprd_rtc_set_aux_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 330 {
 331         struct sprd_rtc *rtc = dev_get_drvdata(dev);
 332         time64_t secs = rtc_tm_to_time64(&alrm->time);
 333         int ret;
 334
 335         /* clear the auxiliary alarm interrupt status */
 336         ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
 337                            SPRD_RTC_AUXALM_EN);
 338         if (ret)
 339                 return ret;
 340
 341         ret = sprd_rtc_set_secs(rtc, SPRD_RTC_AUX_ALARM, secs);
 342         if (ret)
 343                 return ret;
 344
 345         if (alrm->enabled) {
 346                 ret = regmap_update_bits(rtc->regmap,
 347                                          rtc->base + SPRD_RTC_INT_EN,
 348                                          SPRD_RTC_AUXALM_EN,
 349                                          SPRD_RTC_AUXALM_EN);
 350         } else {
 351                 ret = regmap_update_bits(rtc->regmap,
 352                                          rtc->base + SPRD_RTC_INT_EN,
 353                                          SPRD_RTC_AUXALM_EN, 0);
 354         }
 355
 356         return ret;
 357 }
 358
 359 static int sprd_rtc_read_time(struct device *dev, struct rtc_time *tm)
 360 {
 361         struct sprd_rtc *rtc = dev_get_drvdata(dev);
 362         time64_t secs;
 363         int ret;
 364
 365         if (!rtc->valid) {
 366                 dev_warn(dev, "RTC values are invalid\n");
 367                 return -EINVAL;
 368         }
 369
 370         ret = sprd_rtc_get_secs(rtc, SPRD_RTC_TIME, &secs);
 371         if (ret)
 372                 return ret;
 373
 374         rtc_time64_to_tm(secs, tm);
 375         return 0;
 376 }
 377
 378 static int sprd_rtc_set_time(struct device *dev, struct rtc_time *tm)
 379 {
 380         struct sprd_rtc *rtc = dev_get_drvdata(dev);
 381         time64_t secs = rtc_tm_to_time64(tm);
 382         int ret;
 383
 384         ret = sprd_rtc_set_secs(rtc, SPRD_RTC_TIME, secs);
 385         if (ret)
 386                 return ret;
 387
 388         if (!rtc->valid) {
 389                 /* Clear RTC power status firstly */
 390                 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_PWR_CTRL,
 391                                    SPRD_RTC_POWER_STS_CLEAR);
 392                 if (ret)
 393                         return ret;
 394
 395                 /*
 396                  * Set RTC power status to indicate now RTC has valid time
 397                  * values.
 398                  */
 399                 ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_PWR_CTRL,
 400                                    SPRD_RTC_POWER_STS_VALID);
 401                 if (ret)
 402                         return ret;
 403
 404                 rtc->valid = true;
 405         }
 406
 407         return 0;
 408 }
 409
 410 static int sprd_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 411 {
 412         struct sprd_rtc *rtc = dev_get_drvdata(dev);
 413         time64_t secs;
 414         int ret;
 415         u32 val;
 416
 417         /*
 418          * If aie_timer is enabled, we should get the normal alarm time.
 419          * Otherwise we should get auxiliary alarm time.
 420          */
 421         if (rtc->rtc && rtc->rtc->aie_timer.enabled == 0)
 422                 return sprd_rtc_read_aux_alarm(dev, alrm);
 423
 424         ret = sprd_rtc_get_secs(rtc, SPRD_RTC_ALARM, &secs);
 425         if (ret)
 426                 return ret;
 427
 428         rtc_time64_to_tm(secs, &alrm->time);
 429
 430         ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_EN, &val);
 431         if (ret)
 432                 return ret;
 433
 434         alrm->enabled = !!(val & SPRD_RTC_ALARM_EN);
 435
 436         ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_INT_RAW_STS, &val);
 437         if (ret)
 438                 return ret;
 439
 440         alrm->pending = !!(val & SPRD_RTC_ALARM_EN);
 441         return 0;
 442 }
 443
 444 static int sprd_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 445 {
 446         struct sprd_rtc *rtc = dev_get_drvdata(dev);
 447         time64_t secs = rtc_tm_to_time64(&alrm->time);
 448         struct rtc_time aie_time =
 449                 rtc_ktime_to_tm(rtc->rtc->aie_timer.node.expires);
 450         int ret;
 451
 452         /*
 453          * We have 2 groups alarms: normal alarm and auxiliary alarm. Since
 454          * both normal alarm event and auxiliary alarm event can wake up system
 455          * from deep sleep, but only alarm event can power up system from power
 456          * down status. Moreover we do not need to poll about 125ms when
 457          * updating auxiliary alarm registers. Thus we usually set auxiliary
 458          * alarm when wake up system from deep sleep, and for other scenarios,
 459          * we should set normal alarm with polling status.
 460          *
 461          * So here we check if the alarm time is set by aie_timer, if yes, we
 462          * should set normal alarm, if not, we should set auxiliary alarm which
 463          * means it is just a wake event.
 464          */
 465         if (!rtc->rtc->aie_timer.enabled || rtc_tm_sub(&aie_time, &alrm->time))
 466                 return sprd_rtc_set_aux_alarm(dev, alrm);
 467
 468         /* clear the alarm interrupt status firstly */
 469         ret = regmap_write(rtc->regmap, rtc->base + SPRD_RTC_INT_CLR,
 470                            SPRD_RTC_ALARM_EN);
 471         if (ret)
 472                 return ret;
 473
 474         ret = sprd_rtc_set_secs(rtc, SPRD_RTC_ALARM, secs);
 475         if (ret)
 476                 return ret;
 477
 478         if (alrm->enabled) {
 479                 ret = regmap_update_bits(rtc->regmap,
 480                                          rtc->base + SPRD_RTC_INT_EN,
 481                                          SPRD_RTC_ALARM_EN,
 482                                          SPRD_RTC_ALARM_EN);
 483                 if (ret)
 484                         return ret;
 485
 486                 /* unlock the alarm to enable the alarm function. */
 487                 ret = sprd_rtc_lock_alarm(rtc, false);
 488         } else {
 489                 regmap_update_bits(rtc->regmap,
 490                                    rtc->base + SPRD_RTC_INT_EN,
 491                                    SPRD_RTC_ALARM_EN, 0);
 492
 493                 /*
 494                  * Lock the alarm function in case fake alarm event will power
 495                  * up systems.
 496                  */
 497                 ret = sprd_rtc_lock_alarm(rtc, true);
 498         }
 499
 500         return ret;
 501 }
 502
 503 static int sprd_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
 504 {
 505         struct sprd_rtc *rtc = dev_get_drvdata(dev);
 506         int ret;
 507
 508         if (enabled) {
 509                 ret = regmap_update_bits(rtc->regmap,
 510                                          rtc->base + SPRD_RTC_INT_EN,
 511                                          SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN,
 512                                          SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN);
 513                 if (ret)
 514                         return ret;
 515
 516                 ret = sprd_rtc_lock_alarm(rtc, false);
 517         } else {
 518                 regmap_update_bits(rtc->regmap, rtc->base + SPRD_RTC_INT_EN,
 519                                    SPRD_RTC_ALARM_EN | SPRD_RTC_AUXALM_EN, 0);
 520
 521                 ret = sprd_rtc_lock_alarm(rtc, true);
 522         }
 523
 524         return ret;
 525 }
 526
 527 static const struct rtc_class_ops sprd_rtc_ops = {
 528         .read_time = sprd_rtc_read_time,
 529         .set_time = sprd_rtc_set_time,
 530         .read_alarm = sprd_rtc_read_alarm,
 531         .set_alarm = sprd_rtc_set_alarm,
 532         .alarm_irq_enable = sprd_rtc_alarm_irq_enable,
 533 };
 534
 535 static irqreturn_t sprd_rtc_handler(int irq, void *dev_id)
 536 {
 537         struct sprd_rtc *rtc = dev_id;
 538         int ret;
 539
 540         ret = sprd_rtc_clear_alarm_ints(rtc);
 541         if (ret)
 542                 return IRQ_RETVAL(ret);
 543
 544         rtc_update_irq(rtc->rtc, 1, RTC_AF | RTC_IRQF);
 545         return IRQ_HANDLED;
 546 }
 547
 548 static int sprd_rtc_check_power_down(struct sprd_rtc *rtc)
 549 {
 550         u32 val;
 551         int ret;
 552
 553         ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_PWR_STS, &val);
 554         if (ret)
 555                 return ret;
 556
 557         /*
 558          * If the RTC power status value is SPRD_RTC_POWER_RESET_VALUE, which
 559          * means the RTC has been powered down, so the RTC time values are
 560          * invalid.
 561          */
 562         rtc->valid = val == SPRD_RTC_POWER_RESET_VALUE ? false : true;
 563         return 0;
 564 }
 565
 566 static int sprd_rtc_check_alarm_int(struct sprd_rtc *rtc)
 567 {
 568         u32 val;
 569         int ret;
 570
 571         ret = regmap_read(rtc->regmap, rtc->base + SPRD_RTC_SPG_VALUE, &val);
 572         if (ret)
 573                 return ret;
 574
 575         /*
 576          * The SPRD_RTC_INT_EN register is not put in always-power-on region
 577          * supplied by VDDRTC, so we should check if we need enable the alarm
 578          * interrupt when system booting.
 579          *
 580          * If we have set SPRD_RTC_POWEROFF_ALM_FLAG which is saved in
 581          * always-power-on region, that means we have set one alarm last time,
 582          * so we should enable the alarm interrupt to help RTC core to see if
 583          * there is an alarm already set in RTC hardware.
 584          */
 585         if (!(val & SPRD_RTC_POWEROFF_ALM_FLAG))
 586                 return 0;
 587
 588         return regmap_update_bits(rtc->regmap, rtc->base + SPRD_RTC_INT_EN,
 589                                   SPRD_RTC_ALARM_EN, SPRD_RTC_ALARM_EN);
 590 }
 591
 592 static int sprd_rtc_probe(struct platform_device *pdev)
 593 {
 594         struct device_node *node = pdev->dev.of_node;
 595         struct sprd_rtc *rtc;
 596         int ret;
 597
 598         rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
 599         if (!rtc)
 600                 return -ENOMEM;
 601
 602         rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL);
 603         if (!rtc->regmap)
 604                 return -ENODEV;
 605
 606         ret = of_property_read_u32(node, "reg", &rtc->base);
 607         if (ret) {
 608                 dev_err(&pdev->dev, "failed to get RTC base address\n");
 609                 return ret;
 610         }
 611
 612         rtc->irq = platform_get_irq(pdev, 0);
 613         if (rtc->irq < 0) {
 614                 dev_err(&pdev->dev, "failed to get RTC irq number\n");
 615                 return rtc->irq;
 616         }
 617
 618         rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
 619         if (IS_ERR(rtc->rtc))
 620                 return PTR_ERR(rtc->rtc);
 621
 622         rtc->dev = &pdev->dev;
 623         platform_set_drvdata(pdev, rtc);
 624
 625         /* check if we need set the alarm interrupt */
 626         ret = sprd_rtc_check_alarm_int(rtc);
 627         if (ret) {
 628                 dev_err(&pdev->dev, "failed to check RTC alarm interrupt\n");
 629                 return ret;
 630         }
 631
 632         /* check if RTC time values are valid */
 633         ret = sprd_rtc_check_power_down(rtc);
 634         if (ret) {
 635                 dev_err(&pdev->dev, "failed to check RTC time values\n");
 636                 return ret;
 637         }
 638
 639         ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
 640                                         sprd_rtc_handler,
 641                                         IRQF_ONESHOT | IRQF_EARLY_RESUME,
 642                                         pdev->name, rtc);
 643         if (ret < 0) {
 644                 dev_err(&pdev->dev, "failed to request RTC irq\n");
 645                 return ret;
 646         }
 647
 648         device_init_wakeup(&pdev->dev, 1);
 649
 650         rtc->rtc->ops = &sprd_rtc_ops;
 651         rtc->rtc->range_min = 0;
 652         rtc->rtc->range_max = 5662310399LL;
 653         ret = rtc_register_device(rtc->rtc);
 654         if (ret) {
 655                 dev_err(&pdev->dev, "failed to register rtc device\n");
 656                 device_init_wakeup(&pdev->dev, 0);
 657                 return ret;
 658         }
 659
 660         return 0;
 661 }
 662
 663 static int sprd_rtc_remove(struct platform_device *pdev)
 664 {
 665         device_init_wakeup(&pdev->dev, 0);
 666         return 0;
 667 }
 668
 669 static const struct of_device_id sprd_rtc_of_match[] = {
 670         { .compatible = "sprd,sc2731-rtc", },
 671         { },
 672 };
 673 MODULE_DEVICE_TABLE(of, sprd_rtc_of_match);
 674
 675 static struct platform_driver sprd_rtc_driver = {
 676         .driver = {
 677                 .name = "sprd-rtc",
 678                 .of_match_table = sprd_rtc_of_match,
 679         },
 680         .probe  = sprd_rtc_probe,
 681         .remove = sprd_rtc_remove,
 682 };
 683 module_platform_driver(sprd_rtc_driver);
 684
 685 MODULE_LICENSE("GPL v2");
 686 MODULE_DESCRIPTION("Spreadtrum RTC Device Driver");
 687 MODULE_AUTHOR("Baolin Wang <baolin.wang@spreadtrum.com>");