drivers/rtc/rtc-tps80031.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * rtc-tps80031.c -- TI TPS80031/TPS80032 RTC driver
   4  *
   5  * RTC driver for TI TPS80031/TPS80032 Fully Integrated
   6  * Power Management with Power Path and Battery Charger
   7  *
   8  * Copyright (c) 2012, NVIDIA Corporation.
   9  *
  10  * Author: Laxman Dewangan <ldewangan@nvidia.com>
  11  */
  12
  13 #include <linux/bcd.h>
  14 #include <linux/device.h>
  15 #include <linux/err.h>
  16 #include <linux/init.h>
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/mfd/tps80031.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/pm.h>
  22 #include <linux/rtc.h>
  23 #include <linux/slab.h>
  24
  25 #define ENABLE_ALARM_INT                        0x08
  26 #define ALARM_INT_STATUS                        0x40
  27
  28 /**
  29  * Setting bit to 1 in STOP_RTC will run the RTC and
  30  * setting this bit to 0 will freeze RTC.
  31  */
  32 #define STOP_RTC                                0x1
  33
  34 /* Power on reset Values of RTC registers */
  35 #define TPS80031_RTC_POR_YEAR                   0
  36 #define TPS80031_RTC_POR_MONTH                  1
  37 #define TPS80031_RTC_POR_DAY                    1
  38
  39 /* Numbers of registers for time and alarms */
  40 #define TPS80031_RTC_TIME_NUM_REGS              7
  41 #define TPS80031_RTC_ALARM_NUM_REGS             6
  42
  43 /**
  44  * PMU RTC have only 2 nibbles to store year information, so using an
  45  * offset of 100 to set the base year as 2000 for our driver.
  46  */
  47 #define RTC_YEAR_OFFSET 100
  48
  49 struct tps80031_rtc {
  50         struct rtc_device       *rtc;
  51         int                     irq;
  52 };
  53
  54 static int tps80031_rtc_read_time(struct device *dev, struct rtc_time *tm)
  55 {
  56         u8 buff[TPS80031_RTC_TIME_NUM_REGS];
  57         int ret;
  58
  59         ret = tps80031_reads(dev->parent, TPS80031_SLAVE_ID1,
  60                         TPS80031_SECONDS_REG, TPS80031_RTC_TIME_NUM_REGS, buff);
  61         if (ret < 0) {
  62                 dev_err(dev, "reading RTC_SECONDS_REG failed, err = %d\n", ret);
  63                 return ret;
  64         }
  65
  66         tm->tm_sec = bcd2bin(buff[0]);
  67         tm->tm_min = bcd2bin(buff[1]);
  68         tm->tm_hour = bcd2bin(buff[2]);
  69         tm->tm_mday = bcd2bin(buff[3]);
  70         tm->tm_mon = bcd2bin(buff[4]) - 1;
  71         tm->tm_year = bcd2bin(buff[5]) + RTC_YEAR_OFFSET;
  72         tm->tm_wday = bcd2bin(buff[6]);
  73         return 0;
  74 }
  75
  76 static int tps80031_rtc_set_time(struct device *dev, struct rtc_time *tm)
  77 {
  78         u8 buff[7];
  79         int ret;
  80
  81         buff[0] = bin2bcd(tm->tm_sec);
  82         buff[1] = bin2bcd(tm->tm_min);
  83         buff[2] = bin2bcd(tm->tm_hour);
  84         buff[3] = bin2bcd(tm->tm_mday);
  85         buff[4] = bin2bcd(tm->tm_mon + 1);
  86         buff[5] = bin2bcd(tm->tm_year % RTC_YEAR_OFFSET);
  87         buff[6] = bin2bcd(tm->tm_wday);
  88
  89         /* Stop RTC while updating the RTC time registers */
  90         ret = tps80031_clr_bits(dev->parent, TPS80031_SLAVE_ID1,
  91                                 TPS80031_RTC_CTRL_REG, STOP_RTC);
  92         if (ret < 0) {
  93                 dev_err(dev->parent, "Stop RTC failed, err = %d\n", ret);
  94                 return ret;
  95         }
  96
  97         ret = tps80031_writes(dev->parent, TPS80031_SLAVE_ID1,
  98                         TPS80031_SECONDS_REG,
  99                         TPS80031_RTC_TIME_NUM_REGS, buff);
 100         if (ret < 0) {
 101                 dev_err(dev, "writing RTC_SECONDS_REG failed, err %d\n", ret);
 102                 return ret;
 103         }
 104
 105         ret = tps80031_set_bits(dev->parent, TPS80031_SLAVE_ID1,
 106                                 TPS80031_RTC_CTRL_REG, STOP_RTC);
 107         if (ret < 0)
 108                 dev_err(dev->parent, "Start RTC failed, err = %d\n", ret);
 109         return ret;
 110 }
 111
 112 static int tps80031_rtc_alarm_irq_enable(struct device *dev,
 113                                          unsigned int enable)
 114 {
 115         int ret;
 116
 117         if (enable)
 118                 ret = tps80031_set_bits(dev->parent, TPS80031_SLAVE_ID1,
 119                                 TPS80031_RTC_INTERRUPTS_REG, ENABLE_ALARM_INT);
 120         else
 121                 ret = tps80031_clr_bits(dev->parent, TPS80031_SLAVE_ID1,
 122                                 TPS80031_RTC_INTERRUPTS_REG, ENABLE_ALARM_INT);
 123         if (ret < 0) {
 124                 dev_err(dev, "Update on RTC_INT failed, err = %d\n", ret);
 125                 return ret;
 126         }
 127         return 0;
 128 }
 129
 130 static int tps80031_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 131 {
 132         u8 buff[TPS80031_RTC_ALARM_NUM_REGS];
 133         int ret;
 134
 135         buff[0] = bin2bcd(alrm->time.tm_sec);
 136         buff[1] = bin2bcd(alrm->time.tm_min);
 137         buff[2] = bin2bcd(alrm->time.tm_hour);
 138         buff[3] = bin2bcd(alrm->time.tm_mday);
 139         buff[4] = bin2bcd(alrm->time.tm_mon + 1);
 140         buff[5] = bin2bcd(alrm->time.tm_year % RTC_YEAR_OFFSET);
 141         ret = tps80031_writes(dev->parent, TPS80031_SLAVE_ID1,
 142                         TPS80031_ALARM_SECONDS_REG,
 143                         TPS80031_RTC_ALARM_NUM_REGS, buff);
 144         if (ret < 0) {
 145                 dev_err(dev, "Writing RTC_ALARM failed, err %d\n", ret);
 146                 return ret;
 147         }
 148         return tps80031_rtc_alarm_irq_enable(dev, alrm->enabled);
 149 }
 150
 151 static int tps80031_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 152 {
 153         u8 buff[6];
 154         int ret;
 155
 156         ret = tps80031_reads(dev->parent, TPS80031_SLAVE_ID1,
 157                         TPS80031_ALARM_SECONDS_REG,
 158                         TPS80031_RTC_ALARM_NUM_REGS, buff);
 159         if (ret < 0) {
 160                 dev_err(dev->parent,
 161                         "reading RTC_ALARM failed, err = %d\n", ret);
 162                 return ret;
 163         }
 164
 165         alrm->time.tm_sec = bcd2bin(buff[0]);
 166         alrm->time.tm_min = bcd2bin(buff[1]);
 167         alrm->time.tm_hour = bcd2bin(buff[2]);
 168         alrm->time.tm_mday = bcd2bin(buff[3]);
 169         alrm->time.tm_mon = bcd2bin(buff[4]) - 1;
 170         alrm->time.tm_year = bcd2bin(buff[5]) + RTC_YEAR_OFFSET;
 171         return 0;
 172 }
 173
 174 static int clear_alarm_int_status(struct device *dev, struct tps80031_rtc *rtc)
 175 {
 176         int ret;
 177         u8 buf;
 178
 179         /**
 180          * As per datasheet, A dummy read of this  RTC_STATUS_REG register
 181          * is necessary before each I2C read in order to update the status
 182          * register value.
 183          */
 184         ret = tps80031_read(dev->parent, TPS80031_SLAVE_ID1,
 185                                 TPS80031_RTC_STATUS_REG, &buf);
 186         if (ret < 0) {
 187                 dev_err(dev, "reading RTC_STATUS failed. err = %d\n", ret);
 188                 return ret;
 189         }
 190
 191         /* clear Alarm status bits.*/
 192         ret = tps80031_set_bits(dev->parent, TPS80031_SLAVE_ID1,
 193                         TPS80031_RTC_STATUS_REG, ALARM_INT_STATUS);
 194         if (ret < 0) {
 195                 dev_err(dev, "clear Alarm INT failed, err = %d\n", ret);
 196                 return ret;
 197         }
 198         return 0;
 199 }
 200
 201 static irqreturn_t tps80031_rtc_irq(int irq, void *data)
 202 {
 203         struct device *dev = data;
 204         struct tps80031_rtc *rtc = dev_get_drvdata(dev);
 205         int ret;
 206
 207         ret = clear_alarm_int_status(dev, rtc);
 208         if (ret < 0)
 209                 return ret;
 210
 211         rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
 212         return IRQ_HANDLED;
 213 }
 214
 215 static const struct rtc_class_ops tps80031_rtc_ops = {
 216         .read_time = tps80031_rtc_read_time,
 217         .set_time = tps80031_rtc_set_time,
 218         .set_alarm = tps80031_rtc_set_alarm,
 219         .read_alarm = tps80031_rtc_read_alarm,
 220         .alarm_irq_enable = tps80031_rtc_alarm_irq_enable,
 221 };
 222
 223 static int tps80031_rtc_probe(struct platform_device *pdev)
 224 {
 225         struct tps80031_rtc *rtc;
 226         struct rtc_time tm;
 227         int ret;
 228
 229         rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
 230         if (!rtc)
 231                 return -ENOMEM;
 232
 233         rtc->irq = platform_get_irq(pdev, 0);
 234         platform_set_drvdata(pdev, rtc);
 235
 236         /* Start RTC */
 237         ret = tps80031_set_bits(pdev->dev.parent, TPS80031_SLAVE_ID1,
 238                         TPS80031_RTC_CTRL_REG, STOP_RTC);
 239         if (ret < 0) {
 240                 dev_err(&pdev->dev, "failed to start RTC. err = %d\n", ret);
 241                 return ret;
 242         }
 243
 244         /* If RTC have POR values, set time 01:01:2000 */
 245         tps80031_rtc_read_time(&pdev->dev, &tm);
 246         if ((tm.tm_year == RTC_YEAR_OFFSET + TPS80031_RTC_POR_YEAR) &&
 247                 (tm.tm_mon == (TPS80031_RTC_POR_MONTH - 1)) &&
 248                 (tm.tm_mday == TPS80031_RTC_POR_DAY)) {
 249                 tm.tm_year = 2000;
 250                 tm.tm_mday = 1;
 251                 tm.tm_mon = 1;
 252                 ret = tps80031_rtc_set_time(&pdev->dev, &tm);
 253                 if (ret < 0) {
 254                         dev_err(&pdev->dev,
 255                                 "RTC set time failed, err = %d\n", ret);
 256                         return ret;
 257                 }
 258         }
 259
 260         /* Clear alarm intretupt status if it is there */
 261         ret = clear_alarm_int_status(&pdev->dev, rtc);
 262         if (ret < 0) {
 263                 dev_err(&pdev->dev, "Clear alarm int failed, err = %d\n", ret);
 264                 return ret;
 265         }
 266
 267         rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
 268                                &tps80031_rtc_ops, THIS_MODULE);
 269         if (IS_ERR(rtc->rtc)) {
 270                 ret = PTR_ERR(rtc->rtc);
 271                 dev_err(&pdev->dev, "RTC registration failed, err %d\n", ret);
 272                 return ret;
 273         }
 274
 275         ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL,
 276                         tps80031_rtc_irq,
 277                         IRQF_ONESHOT,
 278                         dev_name(&pdev->dev), rtc);
 279         if (ret < 0) {
 280                 dev_err(&pdev->dev, "request IRQ:%d failed, err = %d\n",
 281                          rtc->irq, ret);
 282                 return ret;
 283         }
 284         device_set_wakeup_capable(&pdev->dev, 1);
 285         return 0;
 286 }
 287
 288 #ifdef CONFIG_PM_SLEEP
 289 static int tps80031_rtc_suspend(struct device *dev)
 290 {
 291         struct tps80031_rtc *rtc = dev_get_drvdata(dev);
 292
 293         if (device_may_wakeup(dev))
 294                 enable_irq_wake(rtc->irq);
 295         return 0;
 296 }
 297
 298 static int tps80031_rtc_resume(struct device *dev)
 299 {
 300         struct tps80031_rtc *rtc = dev_get_drvdata(dev);
 301
 302         if (device_may_wakeup(dev))
 303                 disable_irq_wake(rtc->irq);
 304         return 0;
 305 };
 306 #endif
 307
 308 static SIMPLE_DEV_PM_OPS(tps80031_pm_ops, tps80031_rtc_suspend,
 309                         tps80031_rtc_resume);
 310
 311 static struct platform_driver tps80031_rtc_driver = {
 312         .driver = {
 313                 .name   = "tps80031-rtc",
 314                 .pm     = &tps80031_pm_ops,
 315         },
 316         .probe  = tps80031_rtc_probe,
 317 };
 318
 319 module_platform_driver(tps80031_rtc_driver);
 320
 321 MODULE_ALIAS("platform:tps80031-rtc");
 322 MODULE_DESCRIPTION("TI TPS80031/TPS80032 RTC driver");
 323 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
 324 MODULE_LICENSE("GPL v2");