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 if (sec > U32_MAX || sec < 0) 149 return -EINVAL; 150 151 writel_relaxed(sec, timer->base + BRCMSTB_WKTMR_COUNTER); 152 153 return 0; 154 } 155 156 static int brcmstb_waketmr_getalarm(struct device *dev, 157 struct rtc_wkalrm *alarm) 158 { 159 struct brcmstb_waketmr *timer = dev_get_drvdata(dev); 160 time64_t sec; 161 u32 reg; 162 163 sec = readl_relaxed(timer->base + BRCMSTB_WKTMR_ALARM); 164 if (sec != 0) { 165 /* Alarm is enabled */ 166 alarm->enabled = 1; 167 rtc_time64_to_tm(sec, &alarm->time); 168 } 169 170 reg = readl_relaxed(timer->base + BRCMSTB_WKTMR_EVENT); 171 alarm->pending = !!(reg & 1); 172 173 return 0; 174 } 175 176 static int brcmstb_waketmr_setalarm(struct device *dev, 177 struct rtc_wkalrm *alarm) 178 { 179 struct brcmstb_waketmr *timer = dev_get_drvdata(dev); 180 time64_t sec; 181 182 if (alarm->enabled) 183 sec = rtc_tm_to_time64(&alarm->time); 184 else 185 sec = 0; 186 187 if (sec > U32_MAX || sec < 0) 188 return -EINVAL; 189 190 brcmstb_waketmr_set_alarm(timer, sec); 191 192 return 0; 193 } 194 195 /* 196 * Does not do much but keep the RTC class happy. We always support 197 * alarms. 198 */ 199 static int brcmstb_waketmr_alarm_enable(struct device *dev, 200 unsigned int enabled) 201 { 202 return 0; 203 } 204 205 static const struct rtc_class_ops brcmstb_waketmr_ops = { 206 .read_time = brcmstb_waketmr_gettime, 207 .set_time = brcmstb_waketmr_settime, 208 .read_alarm = brcmstb_waketmr_getalarm, 209 .set_alarm = brcmstb_waketmr_setalarm, 210 .alarm_irq_enable = brcmstb_waketmr_alarm_enable, 211 }; 212 213 static int brcmstb_waketmr_probe(struct platform_device *pdev) 214 { 215 struct device *dev = &pdev->dev; 216 struct brcmstb_waketmr *timer; 217 struct resource *res; 218 int ret; 219 220 timer = devm_kzalloc(dev, sizeof(*timer), GFP_KERNEL); 221 if (!timer) 222 return -ENOMEM; 223 224 platform_set_drvdata(pdev, timer); 225 timer->dev = dev; 226 227 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 228 timer->base = devm_ioremap_resource(dev, res); 229 if (IS_ERR(timer->base)) 230 return PTR_ERR(timer->base); 231 232 /* 233 * Set wakeup capability before requesting wakeup interrupt, so we can 234 * process boot-time "wakeups" (e.g., from S5 soft-off) 235 */ 236 device_set_wakeup_capable(dev, true); 237 device_wakeup_enable(dev); 238 239 timer->irq = platform_get_irq(pdev, 0); 240 if (timer->irq < 0) 241 return -ENODEV; 242 243 timer->clk = devm_clk_get(dev, NULL); 244 if (!IS_ERR(timer->clk)) { 245 ret = clk_prepare_enable(timer->clk); 246 if (ret) 247 return ret; 248 timer->rate = clk_get_rate(timer->clk); 249 if (!timer->rate) 250 timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ; 251 } else { 252 timer->rate = BRCMSTB_WKTMR_DEFAULT_FREQ; 253 timer->clk = NULL; 254 } 255 256 ret = devm_request_irq(dev, timer->irq, brcmstb_waketmr_irq, 0, 257 "brcmstb-waketimer", timer); 258 if (ret < 0) 259 goto err_clk; 260 261 timer->reboot_notifier.notifier_call = brcmstb_waketmr_reboot; 262 register_reboot_notifier(&timer->reboot_notifier); 263 264 timer->rtc = rtc_device_register("brcmstb-waketmr", dev, 265 &brcmstb_waketmr_ops, THIS_MODULE); 266 if (IS_ERR(timer->rtc)) { 267 dev_err(dev, "unable to register device\n"); 268 ret = PTR_ERR(timer->rtc); 269 goto err_notifier; 270 } 271 272 dev_info(dev, "registered, with irq %d\n", timer->irq); 273 274 return 0; 275 276 err_notifier: 277 unregister_reboot_notifier(&timer->reboot_notifier); 278 279 err_clk: 280 if (timer->clk) 281 clk_disable_unprepare(timer->clk); 282 283 return ret; 284 } 285 286 static int brcmstb_waketmr_remove(struct platform_device *pdev) 287 { 288 struct brcmstb_waketmr *timer = dev_get_drvdata(&pdev->dev); 289 290 unregister_reboot_notifier(&timer->reboot_notifier); 291 rtc_device_unregister(timer->rtc); 292 293 return 0; 294 } 295 296 #ifdef CONFIG_PM_SLEEP 297 static int brcmstb_waketmr_suspend(struct device *dev) 298 { 299 struct brcmstb_waketmr *timer = dev_get_drvdata(dev); 300 301 return brcmstb_waketmr_prepare_suspend(timer); 302 } 303 304 static int brcmstb_waketmr_resume(struct device *dev) 305 { 306 struct brcmstb_waketmr *timer = dev_get_drvdata(dev); 307 int ret; 308 309 if (!device_may_wakeup(dev)) 310 return 0; 311 312 ret = disable_irq_wake(timer->irq); 313 314 brcmstb_waketmr_clear_alarm(timer); 315 316 return ret; 317 } 318 #endif /* CONFIG_PM_SLEEP */ 319 320 static SIMPLE_DEV_PM_OPS(brcmstb_waketmr_pm_ops, 321 brcmstb_waketmr_suspend, brcmstb_waketmr_resume); 322 323 static const struct of_device_id brcmstb_waketmr_of_match[] = { 324 { .compatible = "brcm,brcmstb-waketimer" }, 325 { /* sentinel */ }, 326 }; 327 328 static struct platform_driver brcmstb_waketmr_driver = { 329 .probe = brcmstb_waketmr_probe, 330 .remove = brcmstb_waketmr_remove, 331 .driver = { 332 .name = "brcmstb-waketimer", 333 .pm = &brcmstb_waketmr_pm_ops, 334 .of_match_table = of_match_ptr(brcmstb_waketmr_of_match), 335 } 336 }; 337 module_platform_driver(brcmstb_waketmr_driver); 338 339 MODULE_LICENSE("GPL v2"); 340 MODULE_AUTHOR("Brian Norris"); 341 MODULE_AUTHOR("Markus Mayer"); 342 MODULE_DESCRIPTION("Wake-up timer driver for STB chips"); 343