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