1 // SPDX-License-Identifier: GPL-2.0-or-later 2 // 3 // Copyright (C) 2018 ROHM Semiconductors 4 // 5 // RTC driver for ROHM BD70528 PMIC 6 7 #include <linux/bcd.h> 8 #include <linux/mfd/rohm-bd70528.h> 9 #include <linux/mfd/rohm-bd71815.h> 10 #include <linux/mfd/rohm-bd71828.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/platform_device.h> 14 #include <linux/regmap.h> 15 #include <linux/rtc.h> 16 17 /* 18 * On BD71828 and BD71815 the ALM0 MASK is 14 bytes after the ALM0 19 * block start 20 */ 21 #define BD718XX_ALM_EN_OFFSET 14 22 23 /* 24 * We read regs RTC_SEC => RTC_YEAR 25 * this struct is ordered according to chip registers. 26 * Keep it u8 only (or packed) to avoid padding issues. 27 */ 28 struct bd70528_rtc_day { 29 u8 sec; 30 u8 min; 31 u8 hour; 32 } __packed; 33 34 struct bd70528_rtc_data { 35 struct bd70528_rtc_day time; 36 u8 week; 37 u8 day; 38 u8 month; 39 u8 year; 40 } __packed; 41 42 struct bd70528_rtc_wake { 43 struct bd70528_rtc_day time; 44 u8 ctrl; 45 } __packed; 46 47 struct bd71828_rtc_alm { 48 struct bd70528_rtc_data alm0; 49 struct bd70528_rtc_data alm1; 50 u8 alm_mask; 51 u8 alm1_mask; 52 } __packed; 53 54 struct bd70528_rtc_alm { 55 struct bd70528_rtc_data data; 56 u8 alm_mask; 57 u8 alm_repeat; 58 } __packed; 59 60 struct bd70528_rtc { 61 struct rohm_regmap_dev *parent; 62 struct regmap *regmap; 63 struct device *dev; 64 u8 reg_time_start; 65 u8 bd718xx_alm_block_start; 66 bool has_rtc_timers; 67 }; 68 69 static int bd70528_set_wake(struct rohm_regmap_dev *bd70528, 70 int enable, int *old_state) 71 { 72 int ret; 73 unsigned int ctrl_reg; 74 75 ret = regmap_read(bd70528->regmap, BD70528_REG_WAKE_EN, &ctrl_reg); 76 if (ret) 77 return ret; 78 79 if (old_state) { 80 if (ctrl_reg & BD70528_MASK_WAKE_EN) 81 *old_state |= BD70528_WAKE_STATE_BIT; 82 else 83 *old_state &= ~BD70528_WAKE_STATE_BIT; 84 85 if (!enable == !(*old_state & BD70528_WAKE_STATE_BIT)) 86 return 0; 87 } 88 89 if (enable) 90 ctrl_reg |= BD70528_MASK_WAKE_EN; 91 else 92 ctrl_reg &= ~BD70528_MASK_WAKE_EN; 93 94 return regmap_write(bd70528->regmap, BD70528_REG_WAKE_EN, 95 ctrl_reg); 96 } 97 98 static int bd70528_set_elapsed_tmr(struct rohm_regmap_dev *bd70528, 99 int enable, int *old_state) 100 { 101 int ret; 102 unsigned int ctrl_reg; 103 104 /* 105 * TBD 106 * What is the purpose of elapsed timer ? 107 * Is the timeout registers counting down, or is the disable - re-enable 108 * going to restart the elapsed-time counting? If counting is restarted 109 * the timeout should be decreased by the amount of time that has 110 * elapsed since starting the timer. Maybe we should store the monotonic 111 * clock value when timer is started so that if RTC is set while timer 112 * is armed we could do the compensation. This is a hack if RTC/system 113 * clk are drifting. OTOH, RTC controlled via I2C is in any case 114 * inaccurate... 115 */ 116 ret = regmap_read(bd70528->regmap, BD70528_REG_ELAPSED_TIMER_EN, 117 &ctrl_reg); 118 if (ret) 119 return ret; 120 121 if (old_state) { 122 if (ctrl_reg & BD70528_MASK_ELAPSED_TIMER_EN) 123 *old_state |= BD70528_ELAPSED_STATE_BIT; 124 else 125 *old_state &= ~BD70528_ELAPSED_STATE_BIT; 126 127 if ((!enable) == (!(*old_state & BD70528_ELAPSED_STATE_BIT))) 128 return 0; 129 } 130 131 if (enable) 132 ctrl_reg |= BD70528_MASK_ELAPSED_TIMER_EN; 133 else 134 ctrl_reg &= ~BD70528_MASK_ELAPSED_TIMER_EN; 135 136 return regmap_write(bd70528->regmap, BD70528_REG_ELAPSED_TIMER_EN, 137 ctrl_reg); 138 } 139 140 static int bd70528_set_rtc_based_timers(struct bd70528_rtc *r, int new_state, 141 int *old_state) 142 { 143 int ret; 144 145 ret = bd70528_wdt_set(r->parent, new_state & BD70528_WDT_STATE_BIT, 146 old_state); 147 if (ret) { 148 dev_err(r->dev, 149 "Failed to disable WDG for RTC setting (%d)\n", ret); 150 return ret; 151 } 152 ret = bd70528_set_elapsed_tmr(r->parent, 153 new_state & BD70528_ELAPSED_STATE_BIT, 154 old_state); 155 if (ret) { 156 dev_err(r->dev, 157 "Failed to disable 'elapsed timer' for RTC setting\n"); 158 return ret; 159 } 160 ret = bd70528_set_wake(r->parent, new_state & BD70528_WAKE_STATE_BIT, 161 old_state); 162 if (ret) { 163 dev_err(r->dev, 164 "Failed to disable 'wake timer' for RTC setting\n"); 165 return ret; 166 } 167 168 return ret; 169 } 170 171 static int bd70528_re_enable_rtc_based_timers(struct bd70528_rtc *r, 172 int old_state) 173 { 174 if (!r->has_rtc_timers) 175 return 0; 176 177 return bd70528_set_rtc_based_timers(r, old_state, NULL); 178 } 179 180 static int bd70528_disable_rtc_based_timers(struct bd70528_rtc *r, 181 int *old_state) 182 { 183 if (!r->has_rtc_timers) 184 return 0; 185 186 return bd70528_set_rtc_based_timers(r, 0, old_state); 187 } 188 189 static inline void tmday2rtc(struct rtc_time *t, struct bd70528_rtc_day *d) 190 { 191 d->sec &= ~BD70528_MASK_RTC_SEC; 192 d->min &= ~BD70528_MASK_RTC_MINUTE; 193 d->hour &= ~BD70528_MASK_RTC_HOUR; 194 d->sec |= bin2bcd(t->tm_sec); 195 d->min |= bin2bcd(t->tm_min); 196 d->hour |= bin2bcd(t->tm_hour); 197 } 198 199 static inline void tm2rtc(struct rtc_time *t, struct bd70528_rtc_data *r) 200 { 201 r->day &= ~BD70528_MASK_RTC_DAY; 202 r->week &= ~BD70528_MASK_RTC_WEEK; 203 r->month &= ~BD70528_MASK_RTC_MONTH; 204 /* 205 * PM and 24H bits are not used by Wake - thus we clear them 206 * here and not in tmday2rtc() which is also used by wake. 207 */ 208 r->time.hour &= ~(BD70528_MASK_RTC_HOUR_PM | BD70528_MASK_RTC_HOUR_24H); 209 210 tmday2rtc(t, &r->time); 211 /* 212 * We do always set time in 24H mode. 213 */ 214 r->time.hour |= BD70528_MASK_RTC_HOUR_24H; 215 r->day |= bin2bcd(t->tm_mday); 216 r->week |= bin2bcd(t->tm_wday); 217 r->month |= bin2bcd(t->tm_mon + 1); 218 r->year = bin2bcd(t->tm_year - 100); 219 } 220 221 static inline void rtc2tm(struct bd70528_rtc_data *r, struct rtc_time *t) 222 { 223 t->tm_sec = bcd2bin(r->time.sec & BD70528_MASK_RTC_SEC); 224 t->tm_min = bcd2bin(r->time.min & BD70528_MASK_RTC_MINUTE); 225 t->tm_hour = bcd2bin(r->time.hour & BD70528_MASK_RTC_HOUR); 226 /* 227 * If RTC is in 12H mode, then bit BD70528_MASK_RTC_HOUR_PM 228 * is not BCD value but tells whether it is AM or PM 229 */ 230 if (!(r->time.hour & BD70528_MASK_RTC_HOUR_24H)) { 231 t->tm_hour %= 12; 232 if (r->time.hour & BD70528_MASK_RTC_HOUR_PM) 233 t->tm_hour += 12; 234 } 235 t->tm_mday = bcd2bin(r->day & BD70528_MASK_RTC_DAY); 236 t->tm_mon = bcd2bin(r->month & BD70528_MASK_RTC_MONTH) - 1; 237 t->tm_year = 100 + bcd2bin(r->year & BD70528_MASK_RTC_YEAR); 238 t->tm_wday = bcd2bin(r->week & BD70528_MASK_RTC_WEEK); 239 } 240 241 static int bd71828_set_alarm(struct device *dev, struct rtc_wkalrm *a) 242 { 243 int ret; 244 struct bd71828_rtc_alm alm; 245 struct bd70528_rtc *r = dev_get_drvdata(dev); 246 247 ret = regmap_bulk_read(r->regmap, r->bd718xx_alm_block_start, &alm, 248 sizeof(alm)); 249 if (ret) { 250 dev_err(dev, "Failed to read alarm regs\n"); 251 return ret; 252 } 253 254 tm2rtc(&a->time, &alm.alm0); 255 256 if (!a->enabled) 257 alm.alm_mask &= ~BD70528_MASK_ALM_EN; 258 else 259 alm.alm_mask |= BD70528_MASK_ALM_EN; 260 261 ret = regmap_bulk_write(r->regmap, r->bd718xx_alm_block_start, &alm, 262 sizeof(alm)); 263 if (ret) 264 dev_err(dev, "Failed to set alarm time\n"); 265 266 return ret; 267 268 } 269 270 static int bd70528_set_alarm(struct device *dev, struct rtc_wkalrm *a) 271 { 272 struct bd70528_rtc_wake wake; 273 struct bd70528_rtc_alm alm; 274 int ret; 275 struct bd70528_rtc *r = dev_get_drvdata(dev); 276 277 ret = regmap_bulk_read(r->regmap, BD70528_REG_RTC_WAKE_START, &wake, 278 sizeof(wake)); 279 if (ret) { 280 dev_err(dev, "Failed to read wake regs\n"); 281 return ret; 282 } 283 284 ret = regmap_bulk_read(r->regmap, BD70528_REG_RTC_ALM_START, &alm, 285 sizeof(alm)); 286 if (ret) { 287 dev_err(dev, "Failed to read alarm regs\n"); 288 return ret; 289 } 290 291 tm2rtc(&a->time, &alm.data); 292 tmday2rtc(&a->time, &wake.time); 293 294 if (a->enabled) { 295 alm.alm_mask &= ~BD70528_MASK_ALM_EN; 296 wake.ctrl |= BD70528_MASK_WAKE_EN; 297 } else { 298 alm.alm_mask |= BD70528_MASK_ALM_EN; 299 wake.ctrl &= ~BD70528_MASK_WAKE_EN; 300 } 301 302 ret = regmap_bulk_write(r->regmap, BD70528_REG_RTC_WAKE_START, &wake, 303 sizeof(wake)); 304 if (ret) { 305 dev_err(dev, "Failed to set wake time\n"); 306 return ret; 307 } 308 ret = regmap_bulk_write(r->regmap, BD70528_REG_RTC_ALM_START, &alm, 309 sizeof(alm)); 310 if (ret) 311 dev_err(dev, "Failed to set alarm time\n"); 312 313 return ret; 314 } 315 316 static int bd71828_read_alarm(struct device *dev, struct rtc_wkalrm *a) 317 { 318 int ret; 319 struct bd71828_rtc_alm alm; 320 struct bd70528_rtc *r = dev_get_drvdata(dev); 321 322 ret = regmap_bulk_read(r->regmap, r->bd718xx_alm_block_start, &alm, 323 sizeof(alm)); 324 if (ret) { 325 dev_err(dev, "Failed to read alarm regs\n"); 326 return ret; 327 } 328 329 rtc2tm(&alm.alm0, &a->time); 330 a->time.tm_mday = -1; 331 a->time.tm_mon = -1; 332 a->time.tm_year = -1; 333 a->enabled = !!(alm.alm_mask & BD70528_MASK_ALM_EN); 334 a->pending = 0; 335 336 return 0; 337 } 338 339 static int bd70528_read_alarm(struct device *dev, struct rtc_wkalrm *a) 340 { 341 struct bd70528_rtc_alm alm; 342 int ret; 343 struct bd70528_rtc *r = dev_get_drvdata(dev); 344 345 ret = regmap_bulk_read(r->regmap, BD70528_REG_RTC_ALM_START, &alm, 346 sizeof(alm)); 347 if (ret) { 348 dev_err(dev, "Failed to read alarm regs\n"); 349 return ret; 350 } 351 352 rtc2tm(&alm.data, &a->time); 353 a->time.tm_mday = -1; 354 a->time.tm_mon = -1; 355 a->time.tm_year = -1; 356 a->enabled = !(alm.alm_mask & BD70528_MASK_ALM_EN); 357 a->pending = 0; 358 359 return 0; 360 } 361 362 static int bd70528_set_time_locked(struct device *dev, struct rtc_time *t) 363 { 364 int ret, tmpret, old_states; 365 struct bd70528_rtc_data rtc_data; 366 struct bd70528_rtc *r = dev_get_drvdata(dev); 367 368 ret = bd70528_disable_rtc_based_timers(r, &old_states); 369 if (ret) 370 return ret; 371 372 tmpret = regmap_bulk_read(r->regmap, r->reg_time_start, &rtc_data, 373 sizeof(rtc_data)); 374 if (tmpret) { 375 dev_err(dev, "Failed to read RTC time registers\n"); 376 goto renable_out; 377 } 378 tm2rtc(t, &rtc_data); 379 380 tmpret = regmap_bulk_write(r->regmap, r->reg_time_start, &rtc_data, 381 sizeof(rtc_data)); 382 if (tmpret) { 383 dev_err(dev, "Failed to set RTC time\n"); 384 goto renable_out; 385 } 386 387 renable_out: 388 ret = bd70528_re_enable_rtc_based_timers(r, old_states); 389 if (tmpret) 390 ret = tmpret; 391 392 return ret; 393 } 394 395 static int bd71828_set_time(struct device *dev, struct rtc_time *t) 396 { 397 return bd70528_set_time_locked(dev, t); 398 } 399 400 static int bd70528_set_time(struct device *dev, struct rtc_time *t) 401 { 402 int ret; 403 struct bd70528_rtc *r = dev_get_drvdata(dev); 404 405 bd70528_wdt_lock(r->parent); 406 ret = bd70528_set_time_locked(dev, t); 407 bd70528_wdt_unlock(r->parent); 408 return ret; 409 } 410 411 static int bd70528_get_time(struct device *dev, struct rtc_time *t) 412 { 413 struct bd70528_rtc *r = dev_get_drvdata(dev); 414 struct bd70528_rtc_data rtc_data; 415 int ret; 416 417 /* read the RTC date and time registers all at once */ 418 ret = regmap_bulk_read(r->regmap, r->reg_time_start, &rtc_data, 419 sizeof(rtc_data)); 420 if (ret) { 421 dev_err(dev, "Failed to read RTC time (err %d)\n", ret); 422 return ret; 423 } 424 425 rtc2tm(&rtc_data, t); 426 427 return 0; 428 } 429 430 static int bd70528_alm_enable(struct device *dev, unsigned int enabled) 431 { 432 int ret; 433 unsigned int enableval = BD70528_MASK_ALM_EN; 434 struct bd70528_rtc *r = dev_get_drvdata(dev); 435 436 if (enabled) 437 enableval = 0; 438 439 bd70528_wdt_lock(r->parent); 440 ret = bd70528_set_wake(r->parent, enabled, NULL); 441 if (ret) { 442 dev_err(dev, "Failed to change wake state\n"); 443 goto out_unlock; 444 } 445 ret = regmap_update_bits(r->regmap, BD70528_REG_RTC_ALM_MASK, 446 BD70528_MASK_ALM_EN, enableval); 447 if (ret) 448 dev_err(dev, "Failed to change alarm state\n"); 449 450 out_unlock: 451 bd70528_wdt_unlock(r->parent); 452 return ret; 453 } 454 455 static int bd71828_alm_enable(struct device *dev, unsigned int enabled) 456 { 457 int ret; 458 struct bd70528_rtc *r = dev_get_drvdata(dev); 459 unsigned int enableval = BD70528_MASK_ALM_EN; 460 461 if (!enabled) 462 enableval = 0; 463 464 ret = regmap_update_bits(r->regmap, r->bd718xx_alm_block_start + 465 BD718XX_ALM_EN_OFFSET, BD70528_MASK_ALM_EN, 466 enableval); 467 if (ret) 468 dev_err(dev, "Failed to change alarm state\n"); 469 470 return ret; 471 } 472 473 static const struct rtc_class_ops bd70528_rtc_ops = { 474 .read_time = bd70528_get_time, 475 .set_time = bd70528_set_time, 476 .read_alarm = bd70528_read_alarm, 477 .set_alarm = bd70528_set_alarm, 478 .alarm_irq_enable = bd70528_alm_enable, 479 }; 480 481 static const struct rtc_class_ops bd71828_rtc_ops = { 482 .read_time = bd70528_get_time, 483 .set_time = bd71828_set_time, 484 .read_alarm = bd71828_read_alarm, 485 .set_alarm = bd71828_set_alarm, 486 .alarm_irq_enable = bd71828_alm_enable, 487 }; 488 489 static irqreturn_t alm_hndlr(int irq, void *data) 490 { 491 struct rtc_device *rtc = data; 492 493 rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF | RTC_PF); 494 return IRQ_HANDLED; 495 } 496 497 static int bd70528_probe(struct platform_device *pdev) 498 { 499 struct bd70528_rtc *bd_rtc; 500 const struct rtc_class_ops *rtc_ops; 501 const char *irq_name; 502 int ret; 503 struct rtc_device *rtc; 504 int irq; 505 unsigned int hr; 506 bool enable_main_irq = false; 507 u8 hour_reg; 508 enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data; 509 510 bd_rtc = devm_kzalloc(&pdev->dev, sizeof(*bd_rtc), GFP_KERNEL); 511 if (!bd_rtc) 512 return -ENOMEM; 513 514 bd_rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL); 515 if (!bd_rtc->regmap) { 516 dev_err(&pdev->dev, "No regmap\n"); 517 return -EINVAL; 518 } 519 520 bd_rtc->dev = &pdev->dev; 521 522 switch (chip) { 523 case ROHM_CHIP_TYPE_BD70528: 524 bd_rtc->parent = dev_get_drvdata(pdev->dev.parent); 525 if (!bd_rtc->parent) { 526 dev_err(&pdev->dev, "No MFD data\n"); 527 return -EINVAL; 528 } 529 irq_name = "bd70528-rtc-alm"; 530 bd_rtc->has_rtc_timers = true; 531 bd_rtc->reg_time_start = BD70528_REG_RTC_START; 532 hour_reg = BD70528_REG_RTC_HOUR; 533 enable_main_irq = true; 534 rtc_ops = &bd70528_rtc_ops; 535 break; 536 case ROHM_CHIP_TYPE_BD71815: 537 irq_name = "bd71815-rtc-alm-0"; 538 bd_rtc->reg_time_start = BD71815_REG_RTC_START; 539 540 /* 541 * See also BD718XX_ALM_EN_OFFSET: 542 * This works for BD71828 and BD71815 as they have same offset 543 * between ALM0 start and ALM0_MASK. If new ICs are to be 544 * added this requires proper check as ALM0_MASK is not located 545 * at the end of ALM0 block - but after all ALM blocks so if 546 * amount of ALMs differ the offset to enable/disable is likely 547 * to be incorrect and enable/disable must be given as own 548 * reg address here. 549 */ 550 bd_rtc->bd718xx_alm_block_start = BD71815_REG_RTC_ALM_START; 551 hour_reg = BD71815_REG_HOUR; 552 rtc_ops = &bd71828_rtc_ops; 553 break; 554 case ROHM_CHIP_TYPE_BD71828: 555 irq_name = "bd71828-rtc-alm-0"; 556 bd_rtc->reg_time_start = BD71828_REG_RTC_START; 557 bd_rtc->bd718xx_alm_block_start = BD71828_REG_RTC_ALM_START; 558 hour_reg = BD71828_REG_RTC_HOUR; 559 rtc_ops = &bd71828_rtc_ops; 560 break; 561 default: 562 dev_err(&pdev->dev, "Unknown chip\n"); 563 return -ENOENT; 564 } 565 566 irq = platform_get_irq_byname(pdev, irq_name); 567 568 if (irq < 0) 569 return irq; 570 571 platform_set_drvdata(pdev, bd_rtc); 572 573 ret = regmap_read(bd_rtc->regmap, hour_reg, &hr); 574 575 if (ret) { 576 dev_err(&pdev->dev, "Failed to reag RTC clock\n"); 577 return ret; 578 } 579 580 if (!(hr & BD70528_MASK_RTC_HOUR_24H)) { 581 struct rtc_time t; 582 583 ret = rtc_ops->read_time(&pdev->dev, &t); 584 585 if (!ret) 586 ret = rtc_ops->set_time(&pdev->dev, &t); 587 588 if (ret) { 589 dev_err(&pdev->dev, 590 "Setting 24H clock for RTC failed\n"); 591 return ret; 592 } 593 } 594 595 device_set_wakeup_capable(&pdev->dev, true); 596 device_wakeup_enable(&pdev->dev); 597 598 rtc = devm_rtc_allocate_device(&pdev->dev); 599 if (IS_ERR(rtc)) { 600 dev_err(&pdev->dev, "RTC device creation failed\n"); 601 return PTR_ERR(rtc); 602 } 603 604 rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 605 rtc->range_max = RTC_TIMESTAMP_END_2099; 606 rtc->ops = rtc_ops; 607 608 /* Request alarm IRQ prior to registerig the RTC */ 609 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, &alm_hndlr, 610 IRQF_ONESHOT, "bd70528-rtc", rtc); 611 if (ret) 612 return ret; 613 614 /* 615 * BD70528 irq controller is not touching the main mask register. 616 * So enable the RTC block interrupts at main level. We can just 617 * leave them enabled as irq-controller should disable irqs 618 * from sub-registers when IRQ is disabled or freed. 619 */ 620 if (enable_main_irq) { 621 ret = regmap_update_bits(bd_rtc->regmap, 622 BD70528_REG_INT_MAIN_MASK, 623 BD70528_INT_RTC_MASK, 0); 624 if (ret) { 625 dev_err(&pdev->dev, "Failed to enable RTC interrupts\n"); 626 return ret; 627 } 628 } 629 630 return devm_rtc_register_device(rtc); 631 } 632 633 static const struct platform_device_id bd718x7_rtc_id[] = { 634 { "bd70528-rtc", ROHM_CHIP_TYPE_BD70528 }, 635 { "bd71828-rtc", ROHM_CHIP_TYPE_BD71828 }, 636 { "bd71815-rtc", ROHM_CHIP_TYPE_BD71815 }, 637 { }, 638 }; 639 MODULE_DEVICE_TABLE(platform, bd718x7_rtc_id); 640 641 static struct platform_driver bd70528_rtc = { 642 .driver = { 643 .name = "bd70528-rtc" 644 }, 645 .probe = bd70528_probe, 646 .id_table = bd718x7_rtc_id, 647 }; 648 649 module_platform_driver(bd70528_rtc); 650 651 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>"); 652 MODULE_DESCRIPTION("ROHM BD70528 and BD71828 PMIC RTC driver"); 653 MODULE_LICENSE("GPL"); 654 MODULE_ALIAS("platform:bd70528-rtc"); 655