drivers/rtc/rtc-lpc32xx.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2010 NXP Semiconductors
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/init.h>
   9 #include <linux/platform_device.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/rtc.h>
  12 #include <linux/slab.h>
  13 #include <linux/io.h>
  14 #include <linux/of.h>
  15
  16 /*
  17  * Clock and Power control register offsets
  18  */
  19 #define LPC32XX_RTC_UCOUNT              0x00
  20 #define LPC32XX_RTC_DCOUNT              0x04
  21 #define LPC32XX_RTC_MATCH0              0x08
  22 #define LPC32XX_RTC_MATCH1              0x0C
  23 #define LPC32XX_RTC_CTRL                0x10
  24 #define LPC32XX_RTC_INTSTAT             0x14
  25 #define LPC32XX_RTC_KEY                 0x18
  26 #define LPC32XX_RTC_SRAM                0x80
  27
  28 #define LPC32XX_RTC_CTRL_MATCH0         (1 << 0)
  29 #define LPC32XX_RTC_CTRL_MATCH1         (1 << 1)
  30 #define LPC32XX_RTC_CTRL_ONSW_MATCH0    (1 << 2)
  31 #define LPC32XX_RTC_CTRL_ONSW_MATCH1    (1 << 3)
  32 #define LPC32XX_RTC_CTRL_SW_RESET       (1 << 4)
  33 #define LPC32XX_RTC_CTRL_CNTR_DIS       (1 << 6)
  34 #define LPC32XX_RTC_CTRL_ONSW_FORCE_HI  (1 << 7)
  35
  36 #define LPC32XX_RTC_INTSTAT_MATCH0      (1 << 0)
  37 #define LPC32XX_RTC_INTSTAT_MATCH1      (1 << 1)
  38 #define LPC32XX_RTC_INTSTAT_ONSW        (1 << 2)
  39
  40 #define LPC32XX_RTC_KEY_ONSW_LOADVAL    0xB5C13F27
  41
  42 #define rtc_readl(dev, reg) \
  43         __raw_readl((dev)->rtc_base + (reg))
  44 #define rtc_writel(dev, reg, val) \
  45         __raw_writel((val), (dev)->rtc_base + (reg))
  46
  47 struct lpc32xx_rtc {
  48         void __iomem *rtc_base;
  49         int irq;
  50         unsigned char alarm_enabled;
  51         struct rtc_device *rtc;
  52         spinlock_t lock;
  53 };
  54
  55 static int lpc32xx_rtc_read_time(struct device *dev, struct rtc_time *time)
  56 {
  57         unsigned long elapsed_sec;
  58         struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
  59
  60         elapsed_sec = rtc_readl(rtc, LPC32XX_RTC_UCOUNT);
  61         rtc_time64_to_tm(elapsed_sec, time);
  62
  63         return 0;
  64 }
  65
  66 static int lpc32xx_rtc_set_time(struct device *dev, struct rtc_time *time)
  67 {
  68         struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
  69         u32 secs = rtc_tm_to_time64(time);
  70         u32 tmp;
  71
  72         spin_lock_irq(&rtc->lock);
  73
  74         /* RTC must be disabled during count update */
  75         tmp = rtc_readl(rtc, LPC32XX_RTC_CTRL);
  76         rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp | LPC32XX_RTC_CTRL_CNTR_DIS);
  77         rtc_writel(rtc, LPC32XX_RTC_UCOUNT, secs);
  78         rtc_writel(rtc, LPC32XX_RTC_DCOUNT, 0xFFFFFFFF - secs);
  79         rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp &= ~LPC32XX_RTC_CTRL_CNTR_DIS);
  80
  81         spin_unlock_irq(&rtc->lock);
  82
  83         return 0;
  84 }
  85
  86 static int lpc32xx_rtc_read_alarm(struct device *dev,
  87         struct rtc_wkalrm *wkalrm)
  88 {
  89         struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
  90
  91         rtc_time64_to_tm(rtc_readl(rtc, LPC32XX_RTC_MATCH0), &wkalrm->time);
  92         wkalrm->enabled = rtc->alarm_enabled;
  93         wkalrm->pending = !!(rtc_readl(rtc, LPC32XX_RTC_INTSTAT) &
  94                 LPC32XX_RTC_INTSTAT_MATCH0);
  95
  96         return rtc_valid_tm(&wkalrm->time);
  97 }
  98
  99 static int lpc32xx_rtc_set_alarm(struct device *dev,
 100         struct rtc_wkalrm *wkalrm)
 101 {
 102         struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
 103         unsigned long alarmsecs;
 104         u32 tmp;
 105
 106         alarmsecs = rtc_tm_to_time64(&wkalrm->time);
 107
 108         spin_lock_irq(&rtc->lock);
 109
 110         /* Disable alarm during update */
 111         tmp = rtc_readl(rtc, LPC32XX_RTC_CTRL);
 112         rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp & ~LPC32XX_RTC_CTRL_MATCH0);
 113
 114         rtc_writel(rtc, LPC32XX_RTC_MATCH0, alarmsecs);
 115
 116         rtc->alarm_enabled = wkalrm->enabled;
 117         if (wkalrm->enabled) {
 118                 rtc_writel(rtc, LPC32XX_RTC_INTSTAT,
 119                            LPC32XX_RTC_INTSTAT_MATCH0);
 120                 rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp |
 121                            LPC32XX_RTC_CTRL_MATCH0);
 122         }
 123
 124         spin_unlock_irq(&rtc->lock);
 125
 126         return 0;
 127 }
 128
 129 static int lpc32xx_rtc_alarm_irq_enable(struct device *dev,
 130         unsigned int enabled)
 131 {
 132         struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
 133         u32 tmp;
 134
 135         spin_lock_irq(&rtc->lock);
 136         tmp = rtc_readl(rtc, LPC32XX_RTC_CTRL);
 137
 138         if (enabled) {
 139                 rtc->alarm_enabled = 1;
 140                 tmp |= LPC32XX_RTC_CTRL_MATCH0;
 141         } else {
 142                 rtc->alarm_enabled = 0;
 143                 tmp &= ~LPC32XX_RTC_CTRL_MATCH0;
 144         }
 145
 146         rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp);
 147         spin_unlock_irq(&rtc->lock);
 148
 149         return 0;
 150 }
 151
 152 static irqreturn_t lpc32xx_rtc_alarm_interrupt(int irq, void *dev)
 153 {
 154         struct lpc32xx_rtc *rtc = dev;
 155
 156         spin_lock(&rtc->lock);
 157
 158         /* Disable alarm interrupt */
 159         rtc_writel(rtc, LPC32XX_RTC_CTRL,
 160                 rtc_readl(rtc, LPC32XX_RTC_CTRL) &
 161                           ~LPC32XX_RTC_CTRL_MATCH0);
 162         rtc->alarm_enabled = 0;
 163
 164         /*
 165          * Write a large value to the match value so the RTC won't
 166          * keep firing the match status
 167          */
 168         rtc_writel(rtc, LPC32XX_RTC_MATCH0, 0xFFFFFFFF);
 169         rtc_writel(rtc, LPC32XX_RTC_INTSTAT, LPC32XX_RTC_INTSTAT_MATCH0);
 170
 171         spin_unlock(&rtc->lock);
 172
 173         rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
 174
 175         return IRQ_HANDLED;
 176 }
 177
 178 static const struct rtc_class_ops lpc32xx_rtc_ops = {
 179         .read_time              = lpc32xx_rtc_read_time,
 180         .set_time               = lpc32xx_rtc_set_time,
 181         .read_alarm             = lpc32xx_rtc_read_alarm,
 182         .set_alarm              = lpc32xx_rtc_set_alarm,
 183         .alarm_irq_enable       = lpc32xx_rtc_alarm_irq_enable,
 184 };
 185
 186 static int lpc32xx_rtc_probe(struct platform_device *pdev)
 187 {
 188         struct resource *res;
 189         struct lpc32xx_rtc *rtc;
 190         int err;
 191         u32 tmp;
 192
 193         rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
 194         if (unlikely(!rtc))
 195                 return -ENOMEM;
 196
 197         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 198         rtc->rtc_base = devm_ioremap_resource(&pdev->dev, res);
 199         if (IS_ERR(rtc->rtc_base))
 200                 return PTR_ERR(rtc->rtc_base);
 201
 202         spin_lock_init(&rtc->lock);
 203
 204         /*
 205          * The RTC is on a separate power domain and can keep it's state
 206          * across a chip power cycle. If the RTC has never been previously
 207          * setup, then set it up now for the first time.
 208          */
 209         tmp = rtc_readl(rtc, LPC32XX_RTC_CTRL);
 210         if (rtc_readl(rtc, LPC32XX_RTC_KEY) != LPC32XX_RTC_KEY_ONSW_LOADVAL) {
 211                 tmp &= ~(LPC32XX_RTC_CTRL_SW_RESET |
 212                         LPC32XX_RTC_CTRL_CNTR_DIS |
 213                         LPC32XX_RTC_CTRL_MATCH0 |
 214                         LPC32XX_RTC_CTRL_MATCH1 |
 215                         LPC32XX_RTC_CTRL_ONSW_MATCH0 |
 216                         LPC32XX_RTC_CTRL_ONSW_MATCH1 |
 217                         LPC32XX_RTC_CTRL_ONSW_FORCE_HI);
 218                 rtc_writel(rtc, LPC32XX_RTC_CTRL, tmp);
 219
 220                 /* Clear latched interrupt states */
 221                 rtc_writel(rtc, LPC32XX_RTC_MATCH0, 0xFFFFFFFF);
 222                 rtc_writel(rtc, LPC32XX_RTC_INTSTAT,
 223                            LPC32XX_RTC_INTSTAT_MATCH0 |
 224                            LPC32XX_RTC_INTSTAT_MATCH1 |
 225                            LPC32XX_RTC_INTSTAT_ONSW);
 226
 227                 /* Write key value to RTC so it won't reload on reset */
 228                 rtc_writel(rtc, LPC32XX_RTC_KEY,
 229                            LPC32XX_RTC_KEY_ONSW_LOADVAL);
 230         } else {
 231                 rtc_writel(rtc, LPC32XX_RTC_CTRL,
 232                            tmp & ~LPC32XX_RTC_CTRL_MATCH0);
 233         }
 234
 235         platform_set_drvdata(pdev, rtc);
 236
 237         rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
 238         if (IS_ERR(rtc->rtc))
 239                 return PTR_ERR(rtc->rtc);
 240
 241         rtc->rtc->ops = &lpc32xx_rtc_ops;
 242         rtc->rtc->range_max = U32_MAX;
 243
 244         err = rtc_register_device(rtc->rtc);
 245         if (err)
 246                 return err;
 247
 248         /*
 249          * IRQ is enabled after device registration in case alarm IRQ
 250          * is pending upon suspend exit.
 251          */
 252         rtc->irq = platform_get_irq(pdev, 0);
 253         if (rtc->irq < 0) {
 254                 dev_warn(&pdev->dev, "Can't get interrupt resource\n");
 255         } else {
 256                 if (devm_request_irq(&pdev->dev, rtc->irq,
 257                                      lpc32xx_rtc_alarm_interrupt,
 258                                      0, pdev->name, rtc) < 0) {
 259                         dev_warn(&pdev->dev, "Can't request interrupt.\n");
 260                         rtc->irq = -1;
 261                 } else {
 262                         device_init_wakeup(&pdev->dev, 1);
 263                 }
 264         }
 265
 266         return 0;
 267 }
 268
 269 static int lpc32xx_rtc_remove(struct platform_device *pdev)
 270 {
 271         struct lpc32xx_rtc *rtc = platform_get_drvdata(pdev);
 272
 273         if (rtc->irq >= 0)
 274                 device_init_wakeup(&pdev->dev, 0);
 275
 276         return 0;
 277 }
 278
 279 #ifdef CONFIG_PM
 280 static int lpc32xx_rtc_suspend(struct device *dev)
 281 {
 282         struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
 283
 284         if (rtc->irq >= 0) {
 285                 if (device_may_wakeup(dev))
 286                         enable_irq_wake(rtc->irq);
 287                 else
 288                         disable_irq_wake(rtc->irq);
 289         }
 290
 291         return 0;
 292 }
 293
 294 static int lpc32xx_rtc_resume(struct device *dev)
 295 {
 296         struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
 297
 298         if (rtc->irq >= 0 && device_may_wakeup(dev))
 299                 disable_irq_wake(rtc->irq);
 300
 301         return 0;
 302 }
 303
 304 /* Unconditionally disable the alarm */
 305 static int lpc32xx_rtc_freeze(struct device *dev)
 306 {
 307         struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
 308
 309         spin_lock_irq(&rtc->lock);
 310
 311         rtc_writel(rtc, LPC32XX_RTC_CTRL,
 312                 rtc_readl(rtc, LPC32XX_RTC_CTRL) &
 313                           ~LPC32XX_RTC_CTRL_MATCH0);
 314
 315         spin_unlock_irq(&rtc->lock);
 316
 317         return 0;
 318 }
 319
 320 static int lpc32xx_rtc_thaw(struct device *dev)
 321 {
 322         struct lpc32xx_rtc *rtc = dev_get_drvdata(dev);
 323
 324         if (rtc->alarm_enabled) {
 325                 spin_lock_irq(&rtc->lock);
 326
 327                 rtc_writel(rtc, LPC32XX_RTC_CTRL,
 328                            rtc_readl(rtc, LPC32XX_RTC_CTRL) |
 329                            LPC32XX_RTC_CTRL_MATCH0);
 330
 331                 spin_unlock_irq(&rtc->lock);
 332         }
 333
 334         return 0;
 335 }
 336
 337 static const struct dev_pm_ops lpc32xx_rtc_pm_ops = {
 338         .suspend = lpc32xx_rtc_suspend,
 339         .resume = lpc32xx_rtc_resume,
 340         .freeze = lpc32xx_rtc_freeze,
 341         .thaw = lpc32xx_rtc_thaw,
 342         .restore = lpc32xx_rtc_resume
 343 };
 344
 345 #define LPC32XX_RTC_PM_OPS (&lpc32xx_rtc_pm_ops)
 346 #else
 347 #define LPC32XX_RTC_PM_OPS NULL
 348 #endif
 349
 350 #ifdef CONFIG_OF
 351 static const struct of_device_id lpc32xx_rtc_match[] = {
 352         { .compatible = "nxp,lpc3220-rtc" },
 353         { }
 354 };
 355 MODULE_DEVICE_TABLE(of, lpc32xx_rtc_match);
 356 #endif
 357
 358 static struct platform_driver lpc32xx_rtc_driver = {
 359         .probe          = lpc32xx_rtc_probe,
 360         .remove         = lpc32xx_rtc_remove,
 361         .driver = {
 362                 .name   = "rtc-lpc32xx",
 363                 .pm     = LPC32XX_RTC_PM_OPS,
 364                 .of_match_table = of_match_ptr(lpc32xx_rtc_match),
 365         },
 366 };
 367
 368 module_platform_driver(lpc32xx_rtc_driver);
 369
 370 MODULE_AUTHOR("Kevin Wells <wellsk40@gmail.com");
 371 MODULE_DESCRIPTION("RTC driver for the LPC32xx SoC");
 372 MODULE_LICENSE("GPL");
 373 MODULE_ALIAS("platform:rtc-lpc32xx");