1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Real Time Clock driver for Wolfson Microelectronics WM8350 4 * 5 * Copyright (C) 2007, 2008 Wolfson Microelectronics PLC. 6 * 7 * Author: Liam Girdwood 8 * linux@wolfsonmicro.com 9 */ 10 11 #include <linux/module.h> 12 #include <linux/kernel.h> 13 #include <linux/time.h> 14 #include <linux/rtc.h> 15 #include <linux/bcd.h> 16 #include <linux/interrupt.h> 17 #include <linux/ioctl.h> 18 #include <linux/completion.h> 19 #include <linux/mfd/wm8350/rtc.h> 20 #include <linux/mfd/wm8350/core.h> 21 #include <linux/delay.h> 22 #include <linux/platform_device.h> 23 24 #define WM8350_SET_ALM_RETRIES 5 25 #define WM8350_SET_TIME_RETRIES 5 26 #define WM8350_GET_TIME_RETRIES 5 27 28 /* 29 * Read current time and date in RTC 30 */ wm8350_rtc_readtime(struct device * dev,struct rtc_time * tm)31 static int wm8350_rtc_readtime(struct device *dev, struct rtc_time *tm) 32 { 33 struct wm8350 *wm8350 = dev_get_drvdata(dev); 34 u16 time1[4], time2[4]; 35 int retries = WM8350_GET_TIME_RETRIES, ret; 36 37 /* 38 * Read the time twice and compare. 39 * If time1 == time2, then time is valid else retry. 40 */ 41 do { 42 ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES, 43 4, time1); 44 if (ret < 0) 45 return ret; 46 ret = wm8350_block_read(wm8350, WM8350_RTC_SECONDS_MINUTES, 47 4, time2); 48 if (ret < 0) 49 return ret; 50 51 if (memcmp(time1, time2, sizeof(time1)) == 0) { 52 tm->tm_sec = time1[0] & WM8350_RTC_SECS_MASK; 53 54 tm->tm_min = (time1[0] & WM8350_RTC_MINS_MASK) 55 >> WM8350_RTC_MINS_SHIFT; 56 57 tm->tm_hour = time1[1] & WM8350_RTC_HRS_MASK; 58 59 tm->tm_wday = ((time1[1] >> WM8350_RTC_DAY_SHIFT) 60 & 0x7) - 1; 61 62 tm->tm_mon = ((time1[2] & WM8350_RTC_MTH_MASK) 63 >> WM8350_RTC_MTH_SHIFT) - 1; 64 65 tm->tm_mday = (time1[2] & WM8350_RTC_DATE_MASK); 66 67 tm->tm_year = ((time1[3] & WM8350_RTC_YHUNDREDS_MASK) 68 >> WM8350_RTC_YHUNDREDS_SHIFT) * 100; 69 tm->tm_year += time1[3] & WM8350_RTC_YUNITS_MASK; 70 71 tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, 72 tm->tm_year); 73 tm->tm_year -= 1900; 74 75 dev_dbg(dev, "Read (%d left): %04x %04x %04x %04x\n", 76 retries, 77 time1[0], time1[1], time1[2], time1[3]); 78 79 return 0; 80 } 81 } while (retries--); 82 83 dev_err(dev, "timed out reading RTC time\n"); 84 return -EIO; 85 } 86 87 /* 88 * Set current time and date in RTC 89 */ wm8350_rtc_settime(struct device * dev,struct rtc_time * tm)90 static int wm8350_rtc_settime(struct device *dev, struct rtc_time *tm) 91 { 92 struct wm8350 *wm8350 = dev_get_drvdata(dev); 93 u16 time[4]; 94 u16 rtc_ctrl; 95 int ret, retries = WM8350_SET_TIME_RETRIES; 96 97 time[0] = tm->tm_sec; 98 time[0] |= tm->tm_min << WM8350_RTC_MINS_SHIFT; 99 time[1] = tm->tm_hour; 100 time[1] |= (tm->tm_wday + 1) << WM8350_RTC_DAY_SHIFT; 101 time[2] = tm->tm_mday; 102 time[2] |= (tm->tm_mon + 1) << WM8350_RTC_MTH_SHIFT; 103 time[3] = ((tm->tm_year + 1900) / 100) << WM8350_RTC_YHUNDREDS_SHIFT; 104 time[3] |= (tm->tm_year + 1900) % 100; 105 106 dev_dbg(dev, "Setting: %04x %04x %04x %04x\n", 107 time[0], time[1], time[2], time[3]); 108 109 /* Set RTC_SET to stop the clock */ 110 ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, WM8350_RTC_SET); 111 if (ret < 0) 112 return ret; 113 114 /* Wait until confirmation of stopping */ 115 do { 116 rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); 117 schedule_timeout_uninterruptible(msecs_to_jiffies(1)); 118 } while (--retries && !(rtc_ctrl & WM8350_RTC_STS)); 119 120 if (!retries) { 121 dev_err(dev, "timed out on set confirmation\n"); 122 return -EIO; 123 } 124 125 /* Write time to RTC */ 126 ret = wm8350_block_write(wm8350, WM8350_RTC_SECONDS_MINUTES, 4, time); 127 if (ret < 0) 128 return ret; 129 130 /* Clear RTC_SET to start the clock */ 131 ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL, 132 WM8350_RTC_SET); 133 return ret; 134 } 135 136 /* 137 * Read alarm time and date in RTC 138 */ wm8350_rtc_readalarm(struct device * dev,struct rtc_wkalrm * alrm)139 static int wm8350_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm) 140 { 141 struct wm8350 *wm8350 = dev_get_drvdata(dev); 142 struct rtc_time *tm = &alrm->time; 143 u16 time[4]; 144 int ret; 145 146 ret = wm8350_block_read(wm8350, WM8350_ALARM_SECONDS_MINUTES, 4, time); 147 if (ret < 0) 148 return ret; 149 150 tm->tm_sec = time[0] & WM8350_RTC_ALMSECS_MASK; 151 if (tm->tm_sec == WM8350_RTC_ALMSECS_MASK) 152 tm->tm_sec = -1; 153 154 tm->tm_min = time[0] & WM8350_RTC_ALMMINS_MASK; 155 if (tm->tm_min == WM8350_RTC_ALMMINS_MASK) 156 tm->tm_min = -1; 157 else 158 tm->tm_min >>= WM8350_RTC_ALMMINS_SHIFT; 159 160 tm->tm_hour = time[1] & WM8350_RTC_ALMHRS_MASK; 161 if (tm->tm_hour == WM8350_RTC_ALMHRS_MASK) 162 tm->tm_hour = -1; 163 164 tm->tm_wday = ((time[1] >> WM8350_RTC_ALMDAY_SHIFT) & 0x7) - 1; 165 if (tm->tm_wday > 7) 166 tm->tm_wday = -1; 167 168 tm->tm_mon = time[2] & WM8350_RTC_ALMMTH_MASK; 169 if (tm->tm_mon == WM8350_RTC_ALMMTH_MASK) 170 tm->tm_mon = -1; 171 else 172 tm->tm_mon = (tm->tm_mon >> WM8350_RTC_ALMMTH_SHIFT) - 1; 173 174 tm->tm_mday = (time[2] & WM8350_RTC_ALMDATE_MASK); 175 if (tm->tm_mday == WM8350_RTC_ALMDATE_MASK) 176 tm->tm_mday = -1; 177 178 tm->tm_year = -1; 179 180 alrm->enabled = !(time[3] & WM8350_RTC_ALMSTS); 181 182 return 0; 183 } 184 wm8350_rtc_stop_alarm(struct wm8350 * wm8350)185 static int wm8350_rtc_stop_alarm(struct wm8350 *wm8350) 186 { 187 int retries = WM8350_SET_ALM_RETRIES; 188 u16 rtc_ctrl; 189 int ret; 190 191 /* Set RTC_SET to stop the clock */ 192 ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, 193 WM8350_RTC_ALMSET); 194 if (ret < 0) 195 return ret; 196 197 /* Wait until confirmation of stopping */ 198 do { 199 rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); 200 schedule_timeout_uninterruptible(msecs_to_jiffies(1)); 201 } while (retries-- && !(rtc_ctrl & WM8350_RTC_ALMSTS)); 202 203 if (!(rtc_ctrl & WM8350_RTC_ALMSTS)) 204 return -ETIMEDOUT; 205 206 return 0; 207 } 208 wm8350_rtc_start_alarm(struct wm8350 * wm8350)209 static int wm8350_rtc_start_alarm(struct wm8350 *wm8350) 210 { 211 int ret; 212 int retries = WM8350_SET_ALM_RETRIES; 213 u16 rtc_ctrl; 214 215 ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL, 216 WM8350_RTC_ALMSET); 217 if (ret < 0) 218 return ret; 219 220 /* Wait until confirmation */ 221 do { 222 rtc_ctrl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); 223 schedule_timeout_uninterruptible(msecs_to_jiffies(1)); 224 } while (retries-- && rtc_ctrl & WM8350_RTC_ALMSTS); 225 226 if (rtc_ctrl & WM8350_RTC_ALMSTS) 227 return -ETIMEDOUT; 228 229 return 0; 230 } 231 wm8350_rtc_alarm_irq_enable(struct device * dev,unsigned int enabled)232 static int wm8350_rtc_alarm_irq_enable(struct device *dev, 233 unsigned int enabled) 234 { 235 struct wm8350 *wm8350 = dev_get_drvdata(dev); 236 237 if (enabled) 238 return wm8350_rtc_start_alarm(wm8350); 239 else 240 return wm8350_rtc_stop_alarm(wm8350); 241 } 242 wm8350_rtc_setalarm(struct device * dev,struct rtc_wkalrm * alrm)243 static int wm8350_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm) 244 { 245 struct wm8350 *wm8350 = dev_get_drvdata(dev); 246 struct rtc_time *tm = &alrm->time; 247 u16 time[3]; 248 int ret; 249 250 memset(time, 0, sizeof(time)); 251 252 if (tm->tm_sec != -1) 253 time[0] |= tm->tm_sec; 254 else 255 time[0] |= WM8350_RTC_ALMSECS_MASK; 256 257 if (tm->tm_min != -1) 258 time[0] |= tm->tm_min << WM8350_RTC_ALMMINS_SHIFT; 259 else 260 time[0] |= WM8350_RTC_ALMMINS_MASK; 261 262 if (tm->tm_hour != -1) 263 time[1] |= tm->tm_hour; 264 else 265 time[1] |= WM8350_RTC_ALMHRS_MASK; 266 267 if (tm->tm_wday != -1) 268 time[1] |= (tm->tm_wday + 1) << WM8350_RTC_ALMDAY_SHIFT; 269 else 270 time[1] |= WM8350_RTC_ALMDAY_MASK; 271 272 if (tm->tm_mday != -1) 273 time[2] |= tm->tm_mday; 274 else 275 time[2] |= WM8350_RTC_ALMDATE_MASK; 276 277 if (tm->tm_mon != -1) 278 time[2] |= (tm->tm_mon + 1) << WM8350_RTC_ALMMTH_SHIFT; 279 else 280 time[2] |= WM8350_RTC_ALMMTH_MASK; 281 282 ret = wm8350_rtc_stop_alarm(wm8350); 283 if (ret < 0) 284 return ret; 285 286 /* Write time to RTC */ 287 ret = wm8350_block_write(wm8350, WM8350_ALARM_SECONDS_MINUTES, 288 3, time); 289 if (ret < 0) 290 return ret; 291 292 if (alrm->enabled) 293 ret = wm8350_rtc_start_alarm(wm8350); 294 295 return ret; 296 } 297 wm8350_rtc_alarm_handler(int irq,void * data)298 static irqreturn_t wm8350_rtc_alarm_handler(int irq, void *data) 299 { 300 struct wm8350 *wm8350 = data; 301 struct rtc_device *rtc = wm8350->rtc.rtc; 302 int ret; 303 304 rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF); 305 306 /* Make it one shot */ 307 ret = wm8350_set_bits(wm8350, WM8350_RTC_TIME_CONTROL, 308 WM8350_RTC_ALMSET); 309 if (ret != 0) { 310 dev_err(&(wm8350->rtc.pdev->dev), 311 "Failed to disable alarm: %d\n", ret); 312 } 313 314 return IRQ_HANDLED; 315 } 316 wm8350_rtc_update_handler(int irq,void * data)317 static irqreturn_t wm8350_rtc_update_handler(int irq, void *data) 318 { 319 struct wm8350 *wm8350 = data; 320 struct rtc_device *rtc = wm8350->rtc.rtc; 321 322 rtc_update_irq(rtc, 1, RTC_IRQF | RTC_UF); 323 324 return IRQ_HANDLED; 325 } 326 327 static const struct rtc_class_ops wm8350_rtc_ops = { 328 .read_time = wm8350_rtc_readtime, 329 .set_time = wm8350_rtc_settime, 330 .read_alarm = wm8350_rtc_readalarm, 331 .set_alarm = wm8350_rtc_setalarm, 332 .alarm_irq_enable = wm8350_rtc_alarm_irq_enable, 333 }; 334 335 #ifdef CONFIG_PM_SLEEP wm8350_rtc_suspend(struct device * dev)336 static int wm8350_rtc_suspend(struct device *dev) 337 { 338 struct wm8350 *wm8350 = dev_get_drvdata(dev); 339 int ret = 0; 340 u16 reg; 341 342 reg = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); 343 344 if (device_may_wakeup(&wm8350->rtc.pdev->dev) && 345 reg & WM8350_RTC_ALMSTS) { 346 ret = wm8350_rtc_stop_alarm(wm8350); 347 if (ret != 0) 348 dev_err(dev, "Failed to stop RTC alarm: %d\n", ret); 349 } 350 351 return ret; 352 } 353 wm8350_rtc_resume(struct device * dev)354 static int wm8350_rtc_resume(struct device *dev) 355 { 356 struct wm8350 *wm8350 = dev_get_drvdata(dev); 357 int ret; 358 359 if (wm8350->rtc.alarm_enabled) { 360 ret = wm8350_rtc_start_alarm(wm8350); 361 if (ret != 0) 362 dev_err(dev, "Failed to restart RTC alarm: %d\n", ret); 363 } 364 365 return 0; 366 } 367 #endif 368 wm8350_rtc_probe(struct platform_device * pdev)369 static int wm8350_rtc_probe(struct platform_device *pdev) 370 { 371 struct wm8350 *wm8350 = platform_get_drvdata(pdev); 372 struct wm8350_rtc *wm_rtc = &wm8350->rtc; 373 int ret = 0; 374 u16 timectl, power5; 375 376 timectl = wm8350_reg_read(wm8350, WM8350_RTC_TIME_CONTROL); 377 if (timectl & WM8350_RTC_BCD) { 378 dev_err(&pdev->dev, "RTC BCD mode not supported\n"); 379 return -EINVAL; 380 } 381 if (timectl & WM8350_RTC_12HR) { 382 dev_err(&pdev->dev, "RTC 12 hour mode not supported\n"); 383 return -EINVAL; 384 } 385 386 /* enable the RTC if it's not already enabled */ 387 power5 = wm8350_reg_read(wm8350, WM8350_POWER_MGMT_5); 388 if (!(power5 & WM8350_RTC_TICK_ENA)) { 389 wm8350_reg_unlock(wm8350); 390 391 ret = wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, 392 WM8350_RTC_TICK_ENA); 393 if (ret < 0) { 394 dev_err(&pdev->dev, "failed to enable RTC: %d\n", ret); 395 return ret; 396 } 397 398 wm8350_reg_lock(wm8350); 399 } 400 401 if (timectl & WM8350_RTC_STS) { 402 int retries; 403 404 ret = wm8350_clear_bits(wm8350, WM8350_RTC_TIME_CONTROL, 405 WM8350_RTC_SET); 406 if (ret < 0) { 407 dev_err(&pdev->dev, "failed to start: %d\n", ret); 408 return ret; 409 } 410 411 retries = WM8350_SET_TIME_RETRIES; 412 do { 413 timectl = wm8350_reg_read(wm8350, 414 WM8350_RTC_TIME_CONTROL); 415 } while (timectl & WM8350_RTC_STS && --retries); 416 417 if (retries == 0) { 418 dev_err(&pdev->dev, "failed to start: timeout\n"); 419 return -ENODEV; 420 } 421 } 422 423 device_init_wakeup(&pdev->dev, 1); 424 425 wm_rtc->rtc = devm_rtc_device_register(&pdev->dev, "wm8350", 426 &wm8350_rtc_ops, THIS_MODULE); 427 if (IS_ERR(wm_rtc->rtc)) 428 return PTR_ERR(wm_rtc->rtc); 429 430 ret = wm8350_register_irq(wm8350, WM8350_IRQ_RTC_SEC, 431 wm8350_rtc_update_handler, 0, 432 "RTC Seconds", wm8350); 433 if (ret) 434 return ret; 435 436 wm8350_mask_irq(wm8350, WM8350_IRQ_RTC_SEC); 437 438 ret = wm8350_register_irq(wm8350, WM8350_IRQ_RTC_ALM, 439 wm8350_rtc_alarm_handler, 0, 440 "RTC Alarm", wm8350); 441 if (ret) { 442 wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350); 443 return ret; 444 } 445 446 return 0; 447 } 448 wm8350_rtc_remove(struct platform_device * pdev)449 static void wm8350_rtc_remove(struct platform_device *pdev) 450 { 451 struct wm8350 *wm8350 = platform_get_drvdata(pdev); 452 453 wm8350_free_irq(wm8350, WM8350_IRQ_RTC_SEC, wm8350); 454 wm8350_free_irq(wm8350, WM8350_IRQ_RTC_ALM, wm8350); 455 } 456 457 static SIMPLE_DEV_PM_OPS(wm8350_rtc_pm_ops, wm8350_rtc_suspend, 458 wm8350_rtc_resume); 459 460 static struct platform_driver wm8350_rtc_driver = { 461 .probe = wm8350_rtc_probe, 462 .remove_new = wm8350_rtc_remove, 463 .driver = { 464 .name = "wm8350-rtc", 465 .pm = &wm8350_rtc_pm_ops, 466 }, 467 }; 468 469 module_platform_driver(wm8350_rtc_driver); 470 471 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 472 MODULE_DESCRIPTION("RTC driver for the WM8350"); 473 MODULE_LICENSE("GPL"); 474 MODULE_ALIAS("platform:wm8350-rtc"); 475