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"); 341