drivers/rtc/rtc-brcmstb-waketimer.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright © 2014-2023 Broadcom
   4  */
   5
   6 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
   7
   8 #include <linux/clk.h>
   9 #include <linux/device.h>
  10 #include <linux/err.h>
  11 #include <linux/init.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/io.h>
  14 #include <linux/irqreturn.h>
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/of.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/pm.h>
  20 #include <linux/reboot.h>
  21 #include <linux/rtc.h>
  22 #include <linux/stat.h>
  23 #include <linux/suspend.h>
  24
  25 struct brcmstb_waketmr {
  26         struct rtc_device *rtc;
  27         struct device *dev;
  28         void __iomem *base;
  29         unsigned int wake_irq;
  30         unsigned int alarm_irq;
  31         struct notifier_block reboot_notifier;
  32         struct clk *clk;
  33         u32 rate;
  34         unsigned long rtc_alarm;
  35         bool alarm_en;
  36         bool alarm_expired;
  37 };
  38
  39 #define BRCMSTB_WKTMR_EVENT             0x00
  40 #define  WKTMR_ALARM_EVENT              BIT(0)
  41 #define BRCMSTB_WKTMR_COUNTER           0x04
  42 #define BRCMSTB_WKTMR_ALARM             0x08
  43 #define BRCMSTB_WKTMR_PRESCALER         0x0C
  44 #define BRCMSTB_WKTMR_PRESCALER_VAL     0x10
  45
  46 #define BRCMSTB_WKTMR_DEFAULT_FREQ      27000000
  47
  48 static inline bool brcmstb_waketmr_is_pending(struct brcmstb_waketmr *timer)
  49 {
  50         u32 reg;
  51
  52         reg = readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
  53         return !!(reg & WKTMR_ALARM_EVENT);
  54 }
  55
  56 static inline void brcmstb_waketmr_clear_alarm(struct brcmstb_waketmr *timer)
  57 {
  58         u32 reg;
  59
  60         if (timer->alarm_en && timer->alarm_irq)
  61                 disable_irq(timer->alarm_irq);
  62         timer->alarm_en = false;
  63         reg = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
  64         writel_relaxed(reg - 1, timer->base + BRCMSTB_WKTMR_ALARM);
  65         writel_relaxed(WKTMR_ALARM_EVENT, timer->base + BRCMSTB_WKTMR_EVENT);
  66         (void)readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
  67         if (timer->alarm_expired) {
  68                 timer->alarm_expired = false;
  69                 /* maintain call balance */
  70                 enable_irq(timer->alarm_irq);
  71         }
  72 }
  73
  74 static void brcmstb_waketmr_set_alarm(struct brcmstb_waketmr *timer,
  75                                       unsigned int secs)
  76 {
  77         unsigned int now;
  78
  79         brcmstb_waketmr_clear_alarm(timer);
  80
  81         /* Make sure we are actually counting in seconds */
  82         writel_relaxed(timer->rate, timer->base + BRCMSTB_WKTMR_PRESCALER);
  83
  84         writel_relaxed(secs, timer->base + BRCMSTB_WKTMR_ALARM);
  85         now = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
  86
  87         while ((int)(secs - now) <= 0 &&
  88                 !brcmstb_waketmr_is_pending(timer)) {
  89                 secs = now + 1;
  90                 writel_relaxed(secs, timer->base + BRCMSTB_WKTMR_ALARM);
  91                 now = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
  92         }
  93 }
  94
  95 static irqreturn_t brcmstb_waketmr_irq(int irq, void *data)
  96 {
  97         struct brcmstb_waketmr *timer = data;
  98
  99         if (!timer->alarm_irq)
 100                 pm_wakeup_event(timer->dev, 0);
 101         return IRQ_HANDLED;
 102 }
 103
 104 static irqreturn_t brcmstb_alarm_irq(int irq, void *data)
 105 {
 106         struct brcmstb_waketmr *timer = data;
 107
 108         /* Ignore spurious interrupts */
 109         if (!brcmstb_waketmr_is_pending(timer))
 110                 return IRQ_HANDLED;
 111
 112         if (timer->alarm_en) {
 113                 if (device_may_wakeup(timer->dev)) {
 114                         disable_irq_nosync(irq);
 115                         timer->alarm_expired = true;
 116                 } else {
 117                         writel_relaxed(WKTMR_ALARM_EVENT,
 118                                        timer->base + BRCMSTB_WKTMR_EVENT);
 119                 }
 120                 rtc_update_irq(timer->rtc, 1, RTC_IRQF | RTC_AF);
 121         } else {
 122                 writel_relaxed(WKTMR_ALARM_EVENT,
 123                                timer->base + BRCMSTB_WKTMR_EVENT);
 124         }
 125
 126         return IRQ_HANDLED;
 127 }
 128
 129 struct wktmr_time {
 130         u32 sec;
 131         u32 pre;
 132 };
 133
 134 static void wktmr_read(struct brcmstb_waketmr *timer,
 135                        struct wktmr_time *t)
 136 {
 137         u32 tmp;
 138
 139         do {
 140                 t->sec = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
 141                 tmp = readl_relaxed(timer->base + BRCMSTB_WKTMR_PRESCALER_VAL);
 142         } while (tmp >= timer->rate);
 143
 144         t->pre = timer->rate - tmp;
 145 }
 146
 147 static int brcmstb_waketmr_prepare_suspend(struct brcmstb_waketmr *timer)
 148 {
 149         struct device *dev = timer->dev;
 150         int ret;
 151
 152         if (device_may_wakeup(dev)) {
 153                 ret = enable_irq_wake(timer->wake_irq);
 154                 if (ret) {
 155                         dev_err(dev, "failed to enable wake-up interrupt\n");
 156                         return ret;
 157                 }
 158                 if (timer->alarm_en && timer->alarm_irq) {
 159                         ret = enable_irq_wake(timer->alarm_irq);
 160                         if (ret) {
 161                                 dev_err(dev, "failed to enable rtc interrupt\n");
 162                                 disable_irq_wake(timer->wake_irq);
 163                                 return ret;
 164                         }
 165                 }
 166         }
 167
 168         return 0;
 169 }
 170
 171 /* If enabled as a wakeup-source, arm the timer when powering off */
 172 static int brcmstb_waketmr_reboot(struct notifier_block *nb,
 173                 unsigned long action, void *data)
 174 {
 175         struct brcmstb_waketmr *timer;
 176
 177         timer = container_of(nb, struct brcmstb_waketmr, reboot_notifier);
 178
 179         /* Set timer for cold boot */
 180         if (action == SYS_POWER_OFF)
 181                 brcmstb_waketmr_prepare_suspend(timer);
 182
 183         return NOTIFY_DONE;
 184 }
 185
 186 static int brcmstb_waketmr_gettime(struct device *dev,
 187                                    struct rtc_time *tm)
 188 {
 189         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 190         struct wktmr_time now;
 191
 192         wktmr_read(timer, &now);
 193
 194         rtc_time64_to_tm(now.sec, tm);
 195
 196         return 0;
 197 }
 198
 199 static int brcmstb_waketmr_settime(struct device *dev,
 200                                    struct rtc_time *tm)
 201 {
 202         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 203         time64_t sec;
 204
 205         sec = rtc_tm_to_time64(tm);
 206
 207         writel_relaxed(sec, timer->base + BRCMSTB_WKTMR_COUNTER);
 208
 209         return 0;
 210 }
 211
 212 static int brcmstb_waketmr_getalarm(struct device *dev,
 213                                     struct rtc_wkalrm *alarm)
 214 {
 215         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 216
 217         alarm->enabled = timer->alarm_en;
 218         rtc_time64_to_tm(timer->rtc_alarm, &alarm->time);
 219
 220         alarm->pending = brcmstb_waketmr_is_pending(timer);
 221
 222         return 0;
 223 }
 224
 225 static int brcmstb_waketmr_alarm_enable(struct device *dev,
 226                                         unsigned int enabled)
 227 {
 228         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 229
 230         if (enabled && !timer->alarm_en) {
 231                 if ((int)(readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER) -
 232                     readl_relaxed(timer->base + BRCMSTB_WKTMR_ALARM)) >= 0 &&
 233                     !brcmstb_waketmr_is_pending(timer))
 234                         return -EINVAL;
 235                 timer->alarm_en = true;
 236                 if (timer->alarm_irq) {
 237                         if (timer->alarm_expired) {
 238                                 timer->alarm_expired = false;
 239                                 /* maintain call balance */
 240                                 enable_irq(timer->alarm_irq);
 241                         }
 242                         enable_irq(timer->alarm_irq);
 243                 }
 244         } else if (!enabled && timer->alarm_en) {
 245                 if (timer->alarm_irq)
 246                         disable_irq(timer->alarm_irq);
 247                 timer->alarm_en = false;
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int brcmstb_waketmr_setalarm(struct device *dev,
 254                                      struct rtc_wkalrm *alarm)
 255 {
 256         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 257
 258         timer->rtc_alarm = rtc_tm_to_time64(&alarm->time);
 259
 260         brcmstb_waketmr_set_alarm(timer, timer->rtc_alarm);
 261
 262         return brcmstb_waketmr_alarm_enable(dev, alarm->enabled);
 263 }
 264
 265 static const struct rtc_class_ops brcmstb_waketmr_ops = {
 266         .read_time      = brcmstb_waketmr_gettime,
 267         .set_time       = brcmstb_waketmr_settime,
 268         .read_alarm     = brcmstb_waketmr_getalarm,
 269         .set_alarm      = brcmstb_waketmr_setalarm,
 270         .alarm_irq_enable = brcmstb_waketmr_alarm_enable,
 271 };
 272
 273 static int brcmstb_waketmr_probe(struct platform_device *pdev)
 274 {
 275         struct device *dev = &pdev->dev;
 276         struct brcmstb_waketmr *timer;
 277         int ret;
 278
 279         timer = devm_kzalloc(dev, sizeof(*timer), GFP_KERNEL);
 280         if (!timer)
 281                 return -ENOMEM;
 282
 283         platform_set_drvdata(pdev, timer);
 284         timer->dev = dev;
 285
 286         timer->base = devm_platform_ioremap_resource(pdev, 0);
 287         if (IS_ERR(timer->base))
 288                 return PTR_ERR(timer->base);
 289
 290         timer->rtc = devm_rtc_allocate_device(dev);
 291         if (IS_ERR(timer->rtc))
 292                 return PTR_ERR(timer->rtc);
 293
 294         /*
 295          * Set wakeup capability before requesting wakeup interrupt, so we can
 296          * process boot-time "wakeups" (e.g., from S5 soft-off)
 297          */
 298         device_init_wakeup(dev, true);
 299
 300         ret = platform_get_irq(pdev, 0);
 301         if (ret < 0)
 302                 return -ENODEV;
 303         timer->wake_irq = (unsigned int)ret;
 304
 305         timer->clk = devm_clk_get(dev, NULL);
 306         if (!IS_ERR(timer->clk)) {
 307                 ret = clk_prepare_enable(timer->clk);
 308                 if (ret)
 309                         return ret;
 310                 timer->rate = clk_get_rate(timer->clk);
 311                 if (!timer->rate)
 312                         timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
 313         } else {
 314                 timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
 315                 timer->clk = NULL;
 316         }
 317
 318         ret = devm_request_irq(dev, timer->wake_irq, brcmstb_waketmr_irq, 0,
 319                                "brcmstb-waketimer", timer);
 320         if (ret < 0)
 321                 goto err_clk;
 322
 323         brcmstb_waketmr_clear_alarm(timer);
 324
 325         /* Attempt to initialize non-wake irq */
 326         ret = platform_get_irq(pdev, 1);
 327         if (ret > 0) {
 328                 timer->alarm_irq = (unsigned int)ret;
 329                 ret = devm_request_irq(dev, timer->alarm_irq, brcmstb_alarm_irq,
 330                                        IRQF_NO_AUTOEN, "brcmstb-waketimer-rtc",
 331                                        timer);
 332                 if (ret < 0)
 333                         timer->alarm_irq = 0;
 334         }
 335
 336         timer->reboot_notifier.notifier_call = brcmstb_waketmr_reboot;
 337         register_reboot_notifier(&timer->reboot_notifier);
 338
 339         timer->rtc->ops = &brcmstb_waketmr_ops;
 340         timer->rtc->range_max = U32_MAX;
 341
 342         ret = devm_rtc_register_device(timer->rtc);
 343         if (ret)
 344                 goto err_notifier;
 345
 346         return 0;
 347
 348 err_notifier:
 349         unregister_reboot_notifier(&timer->reboot_notifier);
 350
 351 err_clk:
 352         clk_disable_unprepare(timer->clk);
 353
 354         return ret;
 355 }
 356
 357 static void brcmstb_waketmr_remove(struct platform_device *pdev)
 358 {
 359         struct brcmstb_waketmr *timer = dev_get_drvdata(&pdev->dev);
 360
 361         unregister_reboot_notifier(&timer->reboot_notifier);
 362         clk_disable_unprepare(timer->clk);
 363 }
 364
 365 #ifdef CONFIG_PM_SLEEP
 366 static int brcmstb_waketmr_suspend(struct device *dev)
 367 {
 368         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 369
 370         return brcmstb_waketmr_prepare_suspend(timer);
 371 }
 372
 373 static int brcmstb_waketmr_suspend_noirq(struct device *dev)
 374 {
 375         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 376
 377         /* Catch any alarms occurring prior to noirq */
 378         if (timer->alarm_expired && device_may_wakeup(dev))
 379                 return -EBUSY;
 380
 381         return 0;
 382 }
 383
 384 static int brcmstb_waketmr_resume(struct device *dev)
 385 {
 386         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 387         int ret;
 388
 389         if (!device_may_wakeup(dev))
 390                 return 0;
 391
 392         ret = disable_irq_wake(timer->wake_irq);
 393         if (timer->alarm_en && timer->alarm_irq)
 394                 disable_irq_wake(timer->alarm_irq);
 395
 396         brcmstb_waketmr_clear_alarm(timer);
 397
 398         return ret;
 399 }
 400 #else
 401 #define brcmstb_waketmr_suspend         NULL
 402 #define brcmstb_waketmr_suspend_noirq   NULL
 403 #define brcmstb_waketmr_resume          NULL
 404 #endif /* CONFIG_PM_SLEEP */
 405
 406 static const struct dev_pm_ops brcmstb_waketmr_pm_ops = {
 407         .suspend        = brcmstb_waketmr_suspend,
 408         .suspend_noirq  = brcmstb_waketmr_suspend_noirq,
 409         .resume         = brcmstb_waketmr_resume,
 410 };
 411
 412 static const __maybe_unused struct of_device_id brcmstb_waketmr_of_match[] = {
 413         { .compatible = "brcm,brcmstb-waketimer" },
 414         { /* sentinel */ },
 415 };
 416
 417 static struct platform_driver brcmstb_waketmr_driver = {
 418         .probe                  = brcmstb_waketmr_probe,
 419         .remove                 = brcmstb_waketmr_remove,
 420         .driver = {
 421                 .name           = "brcmstb-waketimer",
 422                 .pm             = &brcmstb_waketmr_pm_ops,
 423                 .of_match_table = of_match_ptr(brcmstb_waketmr_of_match),
 424         }
 425 };
 426 module_platform_driver(brcmstb_waketmr_driver);
 427
 428 MODULE_LICENSE("GPL v2");
 429 MODULE_AUTHOR("Brian Norris");
 430 MODULE_AUTHOR("Markus Mayer");
 431 MODULE_AUTHOR("Doug Berger");
 432 MODULE_DESCRIPTION("Wake-up timer driver for STB chips");