drivers/rtc/rtc-brcmstb-waketimer.c

   1 /*
   2  * Copyright © 2014-2017 Broadcom
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
  15
  16 #include <linux/clk.h>
  17 #include <linux/device.h>
  18 #include <linux/err.h>
  19 #include <linux/init.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/io.h>
  22 #include <linux/irqreturn.h>
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/of.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/pm.h>
  28 #include <linux/pm_wakeup.h>
  29 #include <linux/reboot.h>
  30 #include <linux/rtc.h>
  31 #include <linux/stat.h>
  32 #include <linux/suspend.h>
  33
  34 struct brcmstb_waketmr {
  35         struct rtc_device *rtc;
  36         struct device *dev;
  37         void __iomem *base;
  38         int irq;
  39         struct notifier_block reboot_notifier;
  40         struct clk *clk;
  41         u32 rate;
  42 };
  43
  44 #define BRCMSTB_WKTMR_EVENT             0x00
  45 #define BRCMSTB_WKTMR_COUNTER           0x04
  46 #define BRCMSTB_WKTMR_ALARM             0x08
  47 #define BRCMSTB_WKTMR_PRESCALER         0x0C
  48 #define BRCMSTB_WKTMR_PRESCALER_VAL     0x10
  49
  50 #define BRCMSTB_WKTMR_DEFAULT_FREQ      27000000
  51
  52 static inline void brcmstb_waketmr_clear_alarm(struct brcmstb_waketmr *timer)
  53 {
  54         writel_relaxed(1, timer->base + BRCMSTB_WKTMR_EVENT);
  55         (void)readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
  56 }
  57
  58 static void brcmstb_waketmr_set_alarm(struct brcmstb_waketmr *timer,
  59                                       unsigned int secs)
  60 {
  61         brcmstb_waketmr_clear_alarm(timer);
  62
  63         /* Make sure we are actually counting in seconds */
  64         writel_relaxed(timer->rate, timer->base + BRCMSTB_WKTMR_PRESCALER);
  65
  66         writel_relaxed(secs + 1, timer->base + BRCMSTB_WKTMR_ALARM);
  67 }
  68
  69 static irqreturn_t brcmstb_waketmr_irq(int irq, void *data)
  70 {
  71         struct brcmstb_waketmr *timer = data;
  72
  73         pm_wakeup_event(timer->dev, 0);
  74
  75         return IRQ_HANDLED;
  76 }
  77
  78 struct wktmr_time {
  79         u32 sec;
  80         u32 pre;
  81 };
  82
  83 static void wktmr_read(struct brcmstb_waketmr *timer,
  84                        struct wktmr_time *t)
  85 {
  86         u32 tmp;
  87
  88         do {
  89                 t->sec = readl_relaxed(timer->base + BRCMSTB_WKTMR_COUNTER);
  90                 tmp = readl_relaxed(timer->base + BRCMSTB_WKTMR_PRESCALER_VAL);
  91         } while (tmp >= timer->rate);
  92
  93         t->pre = timer->rate - tmp;
  94 }
  95
  96 static int brcmstb_waketmr_prepare_suspend(struct brcmstb_waketmr *timer)
  97 {
  98         struct device *dev = timer->dev;
  99         int ret = 0;
 100
 101         if (device_may_wakeup(dev)) {
 102                 ret = enable_irq_wake(timer->irq);
 103                 if (ret) {
 104                         dev_err(dev, "failed to enable wake-up interrupt\n");
 105                         return ret;
 106                 }
 107         }
 108
 109         return ret;
 110 }
 111
 112 /* If enabled as a wakeup-source, arm the timer when powering off */
 113 static int brcmstb_waketmr_reboot(struct notifier_block *nb,
 114                 unsigned long action, void *data)
 115 {
 116         struct brcmstb_waketmr *timer;
 117
 118         timer = container_of(nb, struct brcmstb_waketmr, reboot_notifier);
 119
 120         /* Set timer for cold boot */
 121         if (action == SYS_POWER_OFF)
 122                 brcmstb_waketmr_prepare_suspend(timer);
 123
 124         return NOTIFY_DONE;
 125 }
 126
 127 static int brcmstb_waketmr_gettime(struct device *dev,
 128                                    struct rtc_time *tm)
 129 {
 130         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 131         struct wktmr_time now;
 132
 133         wktmr_read(timer, &now);
 134
 135         rtc_time_to_tm(now.sec, tm);
 136
 137         return 0;
 138 }
 139
 140 static int brcmstb_waketmr_settime(struct device *dev,
 141                                    struct rtc_time *tm)
 142 {
 143         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 144         time64_t sec;
 145
 146         sec = rtc_tm_to_time64(tm);
 147
 148         writel_relaxed(sec, timer->base + BRCMSTB_WKTMR_COUNTER);
 149
 150         return 0;
 151 }
 152
 153 static int brcmstb_waketmr_getalarm(struct device *dev,
 154                                     struct rtc_wkalrm *alarm)
 155 {
 156         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 157         time64_t sec;
 158         u32 reg;
 159
 160         sec = readl_relaxed(timer->base + BRCMSTB_WKTMR_ALARM);
 161         if (sec != 0) {
 162                 /* Alarm is enabled */
 163                 alarm->enabled = 1;
 164                 rtc_time64_to_tm(sec, &alarm->time);
 165         }
 166
 167         reg = readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT);
 168         alarm->pending = !!(reg & 1);
 169
 170         return 0;
 171 }
 172
 173 static int brcmstb_waketmr_setalarm(struct device *dev,
 174                                      struct rtc_wkalrm *alarm)
 175 {
 176         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 177         time64_t sec;
 178
 179         if (alarm->enabled)
 180                 sec = rtc_tm_to_time64(&alarm->time);
 181         else
 182                 sec = 0;
 183
 184         brcmstb_waketmr_set_alarm(timer, sec);
 185
 186         return 0;
 187 }
 188
 189 /*
 190  * Does not do much but keep the RTC class happy. We always support
 191  * alarms.
 192  */
 193 static int brcmstb_waketmr_alarm_enable(struct device *dev,
 194                                         unsigned int enabled)
 195 {
 196         return 0;
 197 }
 198
 199 static const struct rtc_class_ops brcmstb_waketmr_ops = {
 200         .read_time      = brcmstb_waketmr_gettime,
 201         .set_time       = brcmstb_waketmr_settime,
 202         .read_alarm     = brcmstb_waketmr_getalarm,
 203         .set_alarm      = brcmstb_waketmr_setalarm,
 204         .alarm_irq_enable = brcmstb_waketmr_alarm_enable,
 205 };
 206
 207 static int brcmstb_waketmr_probe(struct platform_device *pdev)
 208 {
 209         struct device *dev = &pdev->dev;
 210         struct brcmstb_waketmr *timer;
 211         struct resource *res;
 212         int ret;
 213
 214         timer = devm_kzalloc(dev, sizeof(*timer), GFP_KERNEL);
 215         if (!timer)
 216                 return -ENOMEM;
 217
 218         platform_set_drvdata(pdev, timer);
 219         timer->dev = dev;
 220
 221         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 222         timer->base = devm_ioremap_resource(dev, res);
 223         if (IS_ERR(timer->base))
 224                 return PTR_ERR(timer->base);
 225
 226         timer->rtc = devm_rtc_allocate_device(dev);
 227         if (IS_ERR(timer->rtc))
 228                 return PTR_ERR(timer->rtc);
 229
 230         /*
 231          * Set wakeup capability before requesting wakeup interrupt, so we can
 232          * process boot-time "wakeups" (e.g., from S5 soft-off)
 233          */
 234         device_set_wakeup_capable(dev, true);
 235         device_wakeup_enable(dev);
 236
 237         timer->irq = platform_get_irq(pdev, 0);
 238         if (timer->irq < 0)
 239                 return -ENODEV;
 240
 241         timer->clk = devm_clk_get(dev, NULL);
 242         if (!IS_ERR(timer->clk)) {
 243                 ret = clk_prepare_enable(timer->clk);
 244                 if (ret)
 245                         return ret;
 246                 timer->rate = clk_get_rate(timer->clk);
 247                 if (!timer->rate)
 248                         timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
 249         } else {
 250                 timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ;
 251                 timer->clk = NULL;
 252         }
 253
 254         ret = devm_request_irq(dev, timer->irq, brcmstb_waketmr_irq, 0,
 255                                "brcmstb-waketimer", timer);
 256         if (ret < 0)
 257                 goto err_clk;
 258
 259         timer->reboot_notifier.notifier_call = brcmstb_waketmr_reboot;
 260         register_reboot_notifier(&timer->reboot_notifier);
 261
 262         timer->rtc->ops = &brcmstb_waketmr_ops;
 263         timer->rtc->range_max = U32_MAX;
 264
 265         ret = rtc_register_device(timer->rtc);
 266         if (ret) {
 267                 dev_err(dev, "unable to register device\n");
 268                 goto err_notifier;
 269         }
 270
 271         dev_info(dev, "registered, with irq %d\n", timer->irq);
 272
 273         return 0;
 274
 275 err_notifier:
 276         unregister_reboot_notifier(&timer->reboot_notifier);
 277
 278 err_clk:
 279         if (timer->clk)
 280                 clk_disable_unprepare(timer->clk);
 281
 282         return ret;
 283 }
 284
 285 static int brcmstb_waketmr_remove(struct platform_device *pdev)
 286 {
 287         struct brcmstb_waketmr *timer = dev_get_drvdata(&pdev->dev);
 288
 289         unregister_reboot_notifier(&timer->reboot_notifier);
 290
 291         return 0;
 292 }
 293
 294 #ifdef CONFIG_PM_SLEEP
 295 static int brcmstb_waketmr_suspend(struct device *dev)
 296 {
 297         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 298
 299         return brcmstb_waketmr_prepare_suspend(timer);
 300 }
 301
 302 static int brcmstb_waketmr_resume(struct device *dev)
 303 {
 304         struct brcmstb_waketmr *timer = dev_get_drvdata(dev);
 305         int ret;
 306
 307         if (!device_may_wakeup(dev))
 308                 return 0;
 309
 310         ret = disable_irq_wake(timer->irq);
 311
 312         brcmstb_waketmr_clear_alarm(timer);
 313
 314         return ret;
 315 }
 316 #endif /* CONFIG_PM_SLEEP */
 317
 318 static SIMPLE_DEV_PM_OPS(brcmstb_waketmr_pm_ops,
 319                          brcmstb_waketmr_suspend, brcmstb_waketmr_resume);
 320
 321 static const struct of_device_id brcmstb_waketmr_of_match[] = {
 322         { .compatible = "brcm,brcmstb-waketimer" },
 323         { /* sentinel */ },
 324 };
 325
 326 static struct platform_driver brcmstb_waketmr_driver = {
 327         .probe                  = brcmstb_waketmr_probe,
 328         .remove                 = brcmstb_waketmr_remove,
 329         .driver = {
 330                 .name           = "brcmstb-waketimer",
 331                 .pm             = &brcmstb_waketmr_pm_ops,
 332                 .of_match_table = of_match_ptr(brcmstb_waketmr_of_match),
 333         }
 334 };
 335 module_platform_driver(brcmstb_waketmr_driver);
 336
 337 MODULE_LICENSE("GPL v2");
 338 MODULE_AUTHOR("Brian Norris");
 339 MODULE_AUTHOR("Markus Mayer");
 340 MODULE_DESCRIPTION("Wake-up timer driver for STB chips");