drivers/rtc/rtc-tps65910.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * rtc-tps65910.c -- TPS65910 Real Time Clock interface
   4  *
   5  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
   6  * Author: Venu Byravarasu <vbyravarasu@nvidia.com>
   7  *
   8  * Based on original TI driver rtc-twl.c
   9  *   Copyright (C) 2007 MontaVista Software, Inc
  10  *   Author: Alexandre Rusev <source@mvista.com>
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/errno.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/types.h>
  18 #include <linux/rtc.h>
  19 #include <linux/bcd.h>
  20 #include <linux/math64.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/mfd/tps65910.h>
  24
  25 struct tps65910_rtc {
  26         struct rtc_device       *rtc;
  27         int irq;
  28 };
  29
  30 /* Total number of RTC registers needed to set time*/
  31 #define NUM_TIME_REGS   (TPS65910_YEARS - TPS65910_SECONDS + 1)
  32
  33 /* Total number of RTC registers needed to set compensation registers */
  34 #define NUM_COMP_REGS   (TPS65910_RTC_COMP_MSB - TPS65910_RTC_COMP_LSB + 1)
  35
  36 /* Min and max values supported with 'offset' interface (swapped sign) */
  37 #define MIN_OFFSET      (-277761)
  38 #define MAX_OFFSET      (277778)
  39
  40 /* Number of ticks per hour */
  41 #define TICKS_PER_HOUR  (32768 * 3600)
  42
  43 /* Multiplier for ppb conversions */
  44 #define PPB_MULT        (1000000000LL)
  45
  46 static int tps65910_rtc_alarm_irq_enable(struct device *dev,
  47                                          unsigned int enabled)
  48 {
  49         struct tps65910 *tps = dev_get_drvdata(dev->parent);
  50         u8 val = 0;
  51
  52         if (enabled)
  53                 val = TPS65910_RTC_INTERRUPTS_IT_ALARM;
  54
  55         return regmap_write(tps->regmap, TPS65910_RTC_INTERRUPTS, val);
  56 }
  57
  58 /*
  59  * Gets current tps65910 RTC time and date parameters.
  60  *
  61  * The RTC's time/alarm representation is not what gmtime(3) requires
  62  * Linux to use:
  63  *
  64  *  - Months are 1..12 vs Linux 0-11
  65  *  - Years are 0..99 vs Linux 1900..N (we assume 21st century)
  66  */
  67 static int tps65910_rtc_read_time(struct device *dev, struct rtc_time *tm)
  68 {
  69         unsigned char rtc_data[NUM_TIME_REGS];
  70         struct tps65910 *tps = dev_get_drvdata(dev->parent);
  71         int ret;
  72
  73         /* Copy RTC counting registers to static registers or latches */
  74         ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
  75                 TPS65910_RTC_CTRL_GET_TIME, TPS65910_RTC_CTRL_GET_TIME);
  76         if (ret < 0) {
  77                 dev_err(dev, "RTC CTRL reg update failed with err:%d\n", ret);
  78                 return ret;
  79         }
  80
  81         ret = regmap_bulk_read(tps->regmap, TPS65910_SECONDS, rtc_data,
  82                 NUM_TIME_REGS);
  83         if (ret < 0) {
  84                 dev_err(dev, "reading from RTC failed with err:%d\n", ret);
  85                 return ret;
  86         }
  87
  88         tm->tm_sec = bcd2bin(rtc_data[0]);
  89         tm->tm_min = bcd2bin(rtc_data[1]);
  90         tm->tm_hour = bcd2bin(rtc_data[2]);
  91         tm->tm_mday = bcd2bin(rtc_data[3]);
  92         tm->tm_mon = bcd2bin(rtc_data[4]) - 1;
  93         tm->tm_year = bcd2bin(rtc_data[5]) + 100;
  94
  95         return ret;
  96 }
  97
  98 static int tps65910_rtc_set_time(struct device *dev, struct rtc_time *tm)
  99 {
 100         unsigned char rtc_data[NUM_TIME_REGS];
 101         struct tps65910 *tps = dev_get_drvdata(dev->parent);
 102         int ret;
 103
 104         rtc_data[0] = bin2bcd(tm->tm_sec);
 105         rtc_data[1] = bin2bcd(tm->tm_min);
 106         rtc_data[2] = bin2bcd(tm->tm_hour);
 107         rtc_data[3] = bin2bcd(tm->tm_mday);
 108         rtc_data[4] = bin2bcd(tm->tm_mon + 1);
 109         rtc_data[5] = bin2bcd(tm->tm_year - 100);
 110
 111         /* Stop RTC while updating the RTC time registers */
 112         ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
 113                 TPS65910_RTC_CTRL_STOP_RTC, 0);
 114         if (ret < 0) {
 115                 dev_err(dev, "RTC stop failed with err:%d\n", ret);
 116                 return ret;
 117         }
 118
 119         /* update all the time registers in one shot */
 120         ret = regmap_bulk_write(tps->regmap, TPS65910_SECONDS, rtc_data,
 121                 NUM_TIME_REGS);
 122         if (ret < 0) {
 123                 dev_err(dev, "rtc_set_time error %d\n", ret);
 124                 return ret;
 125         }
 126
 127         /* Start back RTC */
 128         ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
 129                 TPS65910_RTC_CTRL_STOP_RTC, 1);
 130         if (ret < 0)
 131                 dev_err(dev, "RTC start failed with err:%d\n", ret);
 132
 133         return ret;
 134 }
 135
 136 /*
 137  * Gets current tps65910 RTC alarm time.
 138  */
 139 static int tps65910_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
 140 {
 141         unsigned char alarm_data[NUM_TIME_REGS];
 142         u32 int_val;
 143         struct tps65910 *tps = dev_get_drvdata(dev->parent);
 144         int ret;
 145
 146         ret = regmap_bulk_read(tps->regmap, TPS65910_ALARM_SECONDS, alarm_data,
 147                 NUM_TIME_REGS);
 148         if (ret < 0) {
 149                 dev_err(dev, "rtc_read_alarm error %d\n", ret);
 150                 return ret;
 151         }
 152
 153         alm->time.tm_sec = bcd2bin(alarm_data[0]);
 154         alm->time.tm_min = bcd2bin(alarm_data[1]);
 155         alm->time.tm_hour = bcd2bin(alarm_data[2]);
 156         alm->time.tm_mday = bcd2bin(alarm_data[3]);
 157         alm->time.tm_mon = bcd2bin(alarm_data[4]) - 1;
 158         alm->time.tm_year = bcd2bin(alarm_data[5]) + 100;
 159
 160         ret = regmap_read(tps->regmap, TPS65910_RTC_INTERRUPTS, &int_val);
 161         if (ret < 0)
 162                 return ret;
 163
 164         if (int_val & TPS65910_RTC_INTERRUPTS_IT_ALARM)
 165                 alm->enabled = 1;
 166
 167         return ret;
 168 }
 169
 170 static int tps65910_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
 171 {
 172         unsigned char alarm_data[NUM_TIME_REGS];
 173         struct tps65910 *tps = dev_get_drvdata(dev->parent);
 174         int ret;
 175
 176         ret = tps65910_rtc_alarm_irq_enable(dev, 0);
 177         if (ret)
 178                 return ret;
 179
 180         alarm_data[0] = bin2bcd(alm->time.tm_sec);
 181         alarm_data[1] = bin2bcd(alm->time.tm_min);
 182         alarm_data[2] = bin2bcd(alm->time.tm_hour);
 183         alarm_data[3] = bin2bcd(alm->time.tm_mday);
 184         alarm_data[4] = bin2bcd(alm->time.tm_mon + 1);
 185         alarm_data[5] = bin2bcd(alm->time.tm_year - 100);
 186
 187         /* update all the alarm registers in one shot */
 188         ret = regmap_bulk_write(tps->regmap, TPS65910_ALARM_SECONDS,
 189                 alarm_data, NUM_TIME_REGS);
 190         if (ret) {
 191                 dev_err(dev, "rtc_set_alarm error %d\n", ret);
 192                 return ret;
 193         }
 194
 195         if (alm->enabled)
 196                 ret = tps65910_rtc_alarm_irq_enable(dev, 1);
 197
 198         return ret;
 199 }
 200
 201 static int tps65910_rtc_set_calibration(struct device *dev, int calibration)
 202 {
 203         unsigned char comp_data[NUM_COMP_REGS];
 204         struct tps65910 *tps = dev_get_drvdata(dev->parent);
 205         s16 value;
 206         int ret;
 207
 208         /*
 209          * TPS65910 uses two's complement 16 bit value for compensation for RTC
 210          * crystal inaccuracies. One time every hour when seconds counter
 211          * increments from 0 to 1 compensation value will be added to internal
 212          * RTC counter value.
 213          *
 214          * Compensation value 0x7FFF is prohibited value.
 215          *
 216          * Valid range for compensation value: [-32768 .. 32766]
 217          */
 218         if ((calibration < -32768) || (calibration > 32766)) {
 219                 dev_err(dev, "RTC calibration value out of range: %d\n",
 220                         calibration);
 221                 return -EINVAL;
 222         }
 223
 224         value = (s16)calibration;
 225
 226         comp_data[0] = (u16)value & 0xFF;
 227         comp_data[1] = ((u16)value >> 8) & 0xFF;
 228
 229         /* Update all the compensation registers in one shot */
 230         ret = regmap_bulk_write(tps->regmap, TPS65910_RTC_COMP_LSB,
 231                 comp_data, NUM_COMP_REGS);
 232         if (ret < 0) {
 233                 dev_err(dev, "rtc_set_calibration error: %d\n", ret);
 234                 return ret;
 235         }
 236
 237         /* Enable automatic compensation */
 238         ret = regmap_update_bits(tps->regmap, TPS65910_RTC_CTRL,
 239                 TPS65910_RTC_CTRL_AUTO_COMP, TPS65910_RTC_CTRL_AUTO_COMP);
 240         if (ret < 0)
 241                 dev_err(dev, "auto_comp enable failed with error: %d\n", ret);
 242
 243         return ret;
 244 }
 245
 246 static int tps65910_rtc_get_calibration(struct device *dev, int *calibration)
 247 {
 248         unsigned char comp_data[NUM_COMP_REGS];
 249         struct tps65910 *tps = dev_get_drvdata(dev->parent);
 250         unsigned int ctrl;
 251         u16 value;
 252         int ret;
 253
 254         ret = regmap_read(tps->regmap, TPS65910_RTC_CTRL, &ctrl);
 255         if (ret < 0)
 256                 return ret;
 257
 258         /* If automatic compensation is not enabled report back zero */
 259         if (!(ctrl & TPS65910_RTC_CTRL_AUTO_COMP)) {
 260                 *calibration = 0;
 261                 return 0;
 262         }
 263
 264         ret = regmap_bulk_read(tps->regmap, TPS65910_RTC_COMP_LSB, comp_data,
 265                 NUM_COMP_REGS);
 266         if (ret < 0) {
 267                 dev_err(dev, "rtc_get_calibration error: %d\n", ret);
 268                 return ret;
 269         }
 270
 271         value = (u16)comp_data[0] | ((u16)comp_data[1] << 8);
 272
 273         *calibration = (s16)value;
 274
 275         return 0;
 276 }
 277
 278 static int tps65910_read_offset(struct device *dev, long *offset)
 279 {
 280         int calibration;
 281         s64 tmp;
 282         int ret;
 283
 284         ret = tps65910_rtc_get_calibration(dev, &calibration);
 285         if (ret < 0)
 286                 return ret;
 287
 288         /* Convert from RTC calibration register format to ppb format */
 289         tmp = calibration * (s64)PPB_MULT;
 290         if (tmp < 0)
 291                 tmp -= TICKS_PER_HOUR / 2LL;
 292         else
 293                 tmp += TICKS_PER_HOUR / 2LL;
 294         tmp = div_s64(tmp, TICKS_PER_HOUR);
 295
 296         /* Offset value operates in negative way, so swap sign */
 297         *offset = (long)-tmp;
 298
 299         return 0;
 300 }
 301
 302 static int tps65910_set_offset(struct device *dev, long offset)
 303 {
 304         int calibration;
 305         s64 tmp;
 306         int ret;
 307
 308         /* Make sure offset value is within supported range */
 309         if (offset < MIN_OFFSET || offset > MAX_OFFSET)
 310                 return -ERANGE;
 311
 312         /* Convert from ppb format to RTC calibration register format */
 313         tmp = offset * (s64)TICKS_PER_HOUR;
 314         if (tmp < 0)
 315                 tmp -= PPB_MULT / 2LL;
 316         else
 317                 tmp += PPB_MULT / 2LL;
 318         tmp = div_s64(tmp, PPB_MULT);
 319
 320         /* Offset value operates in negative way, so swap sign */
 321         calibration = (int)-tmp;
 322
 323         ret = tps65910_rtc_set_calibration(dev, calibration);
 324
 325         return ret;
 326 }
 327
 328 static irqreturn_t tps65910_rtc_interrupt(int irq, void *rtc)
 329 {
 330         struct device *dev = rtc;
 331         unsigned long events = 0;
 332         struct tps65910 *tps = dev_get_drvdata(dev->parent);
 333         struct tps65910_rtc *tps_rtc = dev_get_drvdata(dev);
 334         int ret;
 335         u32 rtc_reg;
 336
 337         ret = regmap_read(tps->regmap, TPS65910_RTC_STATUS, &rtc_reg);
 338         if (ret)
 339                 return IRQ_NONE;
 340
 341         if (rtc_reg & TPS65910_RTC_STATUS_ALARM)
 342                 events = RTC_IRQF | RTC_AF;
 343
 344         ret = regmap_write(tps->regmap, TPS65910_RTC_STATUS, rtc_reg);
 345         if (ret)
 346                 return IRQ_NONE;
 347
 348         /* Notify RTC core on event */
 349         rtc_update_irq(tps_rtc->rtc, 1, events);
 350
 351         return IRQ_HANDLED;
 352 }
 353
 354 static const struct rtc_class_ops tps65910_rtc_ops = {
 355         .read_time      = tps65910_rtc_read_time,
 356         .set_time       = tps65910_rtc_set_time,
 357         .read_alarm     = tps65910_rtc_read_alarm,
 358         .set_alarm      = tps65910_rtc_set_alarm,
 359         .alarm_irq_enable = tps65910_rtc_alarm_irq_enable,
 360         .read_offset    = tps65910_read_offset,
 361         .set_offset     = tps65910_set_offset,
 362 };
 363
 364 static const struct rtc_class_ops tps65910_rtc_ops_noirq = {
 365         .read_time      = tps65910_rtc_read_time,
 366         .set_time       = tps65910_rtc_set_time,
 367         .read_offset    = tps65910_read_offset,
 368         .set_offset     = tps65910_set_offset,
 369 };
 370
 371 static int tps65910_rtc_probe(struct platform_device *pdev)
 372 {
 373         struct tps65910 *tps65910 = NULL;
 374         struct tps65910_rtc *tps_rtc = NULL;
 375         int ret;
 376         int irq;
 377         u32 rtc_reg;
 378
 379         tps65910 = dev_get_drvdata(pdev->dev.parent);
 380
 381         tps_rtc = devm_kzalloc(&pdev->dev, sizeof(struct tps65910_rtc),
 382                         GFP_KERNEL);
 383         if (!tps_rtc)
 384                 return -ENOMEM;
 385
 386         tps_rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
 387         if (IS_ERR(tps_rtc->rtc))
 388                 return PTR_ERR(tps_rtc->rtc);
 389
 390         /* Clear pending interrupts */
 391         ret = regmap_read(tps65910->regmap, TPS65910_RTC_STATUS, &rtc_reg);
 392         if (ret < 0)
 393                 return ret;
 394
 395         ret = regmap_write(tps65910->regmap, TPS65910_RTC_STATUS, rtc_reg);
 396         if (ret < 0)
 397                 return ret;
 398
 399         dev_dbg(&pdev->dev, "Enabling rtc-tps65910.\n");
 400
 401         /* Enable RTC digital power domain */
 402         ret = regmap_update_bits(tps65910->regmap, TPS65910_DEVCTRL,
 403                 DEVCTRL_RTC_PWDN_MASK, 0 << DEVCTRL_RTC_PWDN_SHIFT);
 404         if (ret < 0)
 405                 return ret;
 406
 407         rtc_reg = TPS65910_RTC_CTRL_STOP_RTC;
 408         ret = regmap_write(tps65910->regmap, TPS65910_RTC_CTRL, rtc_reg);
 409         if (ret < 0)
 410                 return ret;
 411
 412         platform_set_drvdata(pdev, tps_rtc);
 413
 414         irq  = platform_get_irq(pdev, 0);
 415         if (irq <= 0) {
 416                 dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n",
 417                         irq);
 418                 return -ENXIO;
 419         }
 420
 421         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
 422                 tps65910_rtc_interrupt, IRQF_TRIGGER_LOW,
 423                 dev_name(&pdev->dev), &pdev->dev);
 424         if (ret < 0)
 425                 irq = -1;
 426
 427         tps_rtc->irq = irq;
 428         if (irq != -1) {
 429                 device_set_wakeup_capable(&pdev->dev, 1);
 430                 tps_rtc->rtc->ops = &tps65910_rtc_ops;
 431         } else
 432                 tps_rtc->rtc->ops = &tps65910_rtc_ops_noirq;
 433
 434         tps_rtc->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
 435         tps_rtc->rtc->range_max = RTC_TIMESTAMP_END_2099;
 436
 437         return devm_rtc_register_device(tps_rtc->rtc);
 438 }
 439
 440 #ifdef CONFIG_PM_SLEEP
 441 static int tps65910_rtc_suspend(struct device *dev)
 442 {
 443         struct tps65910_rtc *tps_rtc = dev_get_drvdata(dev);
 444
 445         if (device_may_wakeup(dev))
 446                 enable_irq_wake(tps_rtc->irq);
 447         return 0;
 448 }
 449
 450 static int tps65910_rtc_resume(struct device *dev)
 451 {
 452         struct tps65910_rtc *tps_rtc = dev_get_drvdata(dev);
 453
 454         if (device_may_wakeup(dev))
 455                 disable_irq_wake(tps_rtc->irq);
 456         return 0;
 457 }
 458 #endif
 459
 460 static SIMPLE_DEV_PM_OPS(tps65910_rtc_pm_ops, tps65910_rtc_suspend,
 461                         tps65910_rtc_resume);
 462
 463 static struct platform_driver tps65910_rtc_driver = {
 464         .probe          = tps65910_rtc_probe,
 465         .driver         = {
 466                 .name   = "tps65910-rtc",
 467                 .pm     = &tps65910_rtc_pm_ops,
 468         },
 469 };
 470
 471 module_platform_driver(tps65910_rtc_driver);
 472 MODULE_ALIAS("platform:rtc-tps65910");
 473 MODULE_AUTHOR("Venu Byravarasu <vbyravarasu@nvidia.com>");
 474 MODULE_LICENSE("GPL");