1 /* 2 * RTC driver for Maxim MAX77686 3 * 4 * Copyright (C) 2012 Samsung Electronics Co.Ltd 5 * 6 * based on rtc-max8997.c 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 * 13 */ 14 15 #include <linux/slab.h> 16 #include <linux/rtc.h> 17 #include <linux/delay.h> 18 #include <linux/mutex.h> 19 #include <linux/module.h> 20 #include <linux/platform_device.h> 21 #include <linux/mfd/max77686-private.h> 22 #include <linux/irqdomain.h> 23 #include <linux/regmap.h> 24 25 /* RTC Control Register */ 26 #define BCD_EN_SHIFT 0 27 #define BCD_EN_MASK (1 << BCD_EN_SHIFT) 28 #define MODEL24_SHIFT 1 29 #define MODEL24_MASK (1 << MODEL24_SHIFT) 30 /* RTC Update Register1 */ 31 #define RTC_UDR_SHIFT 0 32 #define RTC_UDR_MASK (1 << RTC_UDR_SHIFT) 33 #define RTC_RBUDR_SHIFT 4 34 #define RTC_RBUDR_MASK (1 << RTC_RBUDR_SHIFT) 35 /* WTSR and SMPL Register */ 36 #define WTSRT_SHIFT 0 37 #define SMPLT_SHIFT 2 38 #define WTSR_EN_SHIFT 6 39 #define SMPL_EN_SHIFT 7 40 #define WTSRT_MASK (3 << WTSRT_SHIFT) 41 #define SMPLT_MASK (3 << SMPLT_SHIFT) 42 #define WTSR_EN_MASK (1 << WTSR_EN_SHIFT) 43 #define SMPL_EN_MASK (1 << SMPL_EN_SHIFT) 44 /* RTC Hour register */ 45 #define HOUR_PM_SHIFT 6 46 #define HOUR_PM_MASK (1 << HOUR_PM_SHIFT) 47 /* RTC Alarm Enable */ 48 #define ALARM_ENABLE_SHIFT 7 49 #define ALARM_ENABLE_MASK (1 << ALARM_ENABLE_SHIFT) 50 51 #define MAX77686_RTC_UPDATE_DELAY 16 52 #undef MAX77686_RTC_WTSR_SMPL 53 54 enum { 55 RTC_SEC = 0, 56 RTC_MIN, 57 RTC_HOUR, 58 RTC_WEEKDAY, 59 RTC_MONTH, 60 RTC_YEAR, 61 RTC_DATE, 62 RTC_NR_TIME 63 }; 64 65 struct max77686_rtc_info { 66 struct device *dev; 67 struct max77686_dev *max77686; 68 struct i2c_client *rtc; 69 struct rtc_device *rtc_dev; 70 struct mutex lock; 71 72 struct regmap *regmap; 73 74 int virq; 75 int rtc_24hr_mode; 76 }; 77 78 enum MAX77686_RTC_OP { 79 MAX77686_RTC_WRITE, 80 MAX77686_RTC_READ, 81 }; 82 83 static inline int max77686_rtc_calculate_wday(u8 shifted) 84 { 85 int counter = -1; 86 while (shifted) { 87 shifted >>= 1; 88 counter++; 89 } 90 return counter; 91 } 92 93 static void max77686_rtc_data_to_tm(u8 *data, struct rtc_time *tm, 94 int rtc_24hr_mode) 95 { 96 tm->tm_sec = data[RTC_SEC] & 0x7f; 97 tm->tm_min = data[RTC_MIN] & 0x7f; 98 if (rtc_24hr_mode) 99 tm->tm_hour = data[RTC_HOUR] & 0x1f; 100 else { 101 tm->tm_hour = data[RTC_HOUR] & 0x0f; 102 if (data[RTC_HOUR] & HOUR_PM_MASK) 103 tm->tm_hour += 12; 104 } 105 106 tm->tm_wday = max77686_rtc_calculate_wday(data[RTC_WEEKDAY] & 0x7f); 107 tm->tm_mday = data[RTC_DATE] & 0x1f; 108 tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1; 109 tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100; 110 tm->tm_yday = 0; 111 tm->tm_isdst = 0; 112 } 113 114 static int max77686_rtc_tm_to_data(struct rtc_time *tm, u8 *data) 115 { 116 data[RTC_SEC] = tm->tm_sec; 117 data[RTC_MIN] = tm->tm_min; 118 data[RTC_HOUR] = tm->tm_hour; 119 data[RTC_WEEKDAY] = 1 << tm->tm_wday; 120 data[RTC_DATE] = tm->tm_mday; 121 data[RTC_MONTH] = tm->tm_mon + 1; 122 data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0; 123 124 if (tm->tm_year < 100) { 125 pr_warn("%s: MAX77686 RTC cannot handle the year %d." 126 "Assume it's 2000.\n", __func__, 1900 + tm->tm_year); 127 return -EINVAL; 128 } 129 return 0; 130 } 131 132 static int max77686_rtc_update(struct max77686_rtc_info *info, 133 enum MAX77686_RTC_OP op) 134 { 135 int ret; 136 unsigned int data; 137 138 if (op == MAX77686_RTC_WRITE) 139 data = 1 << RTC_UDR_SHIFT; 140 else 141 data = 1 << RTC_RBUDR_SHIFT; 142 143 ret = regmap_update_bits(info->max77686->rtc_regmap, 144 MAX77686_RTC_UPDATE0, data, data); 145 if (ret < 0) 146 dev_err(info->dev, "%s: fail to write update reg(ret=%d, data=0x%x)\n", 147 __func__, ret, data); 148 else { 149 /* Minimum 16ms delay required before RTC update. */ 150 msleep(MAX77686_RTC_UPDATE_DELAY); 151 } 152 153 return ret; 154 } 155 156 static int max77686_rtc_read_time(struct device *dev, struct rtc_time *tm) 157 { 158 struct max77686_rtc_info *info = dev_get_drvdata(dev); 159 u8 data[RTC_NR_TIME]; 160 int ret; 161 162 mutex_lock(&info->lock); 163 164 ret = max77686_rtc_update(info, MAX77686_RTC_READ); 165 if (ret < 0) 166 goto out; 167 168 ret = regmap_bulk_read(info->max77686->rtc_regmap, 169 MAX77686_RTC_SEC, data, RTC_NR_TIME); 170 if (ret < 0) { 171 dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__, ret); 172 goto out; 173 } 174 175 max77686_rtc_data_to_tm(data, tm, info->rtc_24hr_mode); 176 177 ret = rtc_valid_tm(tm); 178 179 out: 180 mutex_unlock(&info->lock); 181 return ret; 182 } 183 184 static int max77686_rtc_set_time(struct device *dev, struct rtc_time *tm) 185 { 186 struct max77686_rtc_info *info = dev_get_drvdata(dev); 187 u8 data[RTC_NR_TIME]; 188 int ret; 189 190 ret = max77686_rtc_tm_to_data(tm, data); 191 if (ret < 0) 192 return ret; 193 194 mutex_lock(&info->lock); 195 196 ret = regmap_bulk_write(info->max77686->rtc_regmap, 197 MAX77686_RTC_SEC, data, RTC_NR_TIME); 198 if (ret < 0) { 199 dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__, 200 ret); 201 goto out; 202 } 203 204 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 205 206 out: 207 mutex_unlock(&info->lock); 208 return ret; 209 } 210 211 static int max77686_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 212 { 213 struct max77686_rtc_info *info = dev_get_drvdata(dev); 214 u8 data[RTC_NR_TIME]; 215 unsigned int val; 216 int i, ret; 217 218 mutex_lock(&info->lock); 219 220 ret = max77686_rtc_update(info, MAX77686_RTC_READ); 221 if (ret < 0) 222 goto out; 223 224 ret = regmap_bulk_read(info->max77686->rtc_regmap, 225 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 226 if (ret < 0) { 227 dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n", 228 __func__, __LINE__, ret); 229 goto out; 230 } 231 232 max77686_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode); 233 234 alrm->enabled = 0; 235 for (i = 0; i < RTC_NR_TIME; i++) { 236 if (data[i] & ALARM_ENABLE_MASK) { 237 alrm->enabled = 1; 238 break; 239 } 240 } 241 242 alrm->pending = 0; 243 ret = regmap_read(info->max77686->regmap, MAX77686_REG_STATUS2, &val); 244 if (ret < 0) { 245 dev_err(info->dev, "%s:%d fail to read status2 reg(%d)\n", 246 __func__, __LINE__, ret); 247 goto out; 248 } 249 250 if (val & (1 << 4)) /* RTCA1 */ 251 alrm->pending = 1; 252 253 out: 254 mutex_unlock(&info->lock); 255 return 0; 256 } 257 258 static int max77686_rtc_stop_alarm(struct max77686_rtc_info *info) 259 { 260 u8 data[RTC_NR_TIME]; 261 int ret, i; 262 struct rtc_time tm; 263 264 if (!mutex_is_locked(&info->lock)) 265 dev_warn(info->dev, "%s: should have mutex locked\n", __func__); 266 267 ret = max77686_rtc_update(info, MAX77686_RTC_READ); 268 if (ret < 0) 269 goto out; 270 271 ret = regmap_bulk_read(info->max77686->rtc_regmap, 272 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 273 if (ret < 0) { 274 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n", 275 __func__, ret); 276 goto out; 277 } 278 279 max77686_rtc_data_to_tm(data, &tm, info->rtc_24hr_mode); 280 281 for (i = 0; i < RTC_NR_TIME; i++) 282 data[i] &= ~ALARM_ENABLE_MASK; 283 284 ret = regmap_bulk_write(info->max77686->rtc_regmap, 285 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 286 if (ret < 0) { 287 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n", 288 __func__, ret); 289 goto out; 290 } 291 292 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 293 out: 294 return ret; 295 } 296 297 static int max77686_rtc_start_alarm(struct max77686_rtc_info *info) 298 { 299 u8 data[RTC_NR_TIME]; 300 int ret; 301 struct rtc_time tm; 302 303 if (!mutex_is_locked(&info->lock)) 304 dev_warn(info->dev, "%s: should have mutex locked\n", __func__); 305 306 ret = max77686_rtc_update(info, MAX77686_RTC_READ); 307 if (ret < 0) 308 goto out; 309 310 ret = regmap_bulk_read(info->max77686->rtc_regmap, 311 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 312 if (ret < 0) { 313 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n", 314 __func__, ret); 315 goto out; 316 } 317 318 max77686_rtc_data_to_tm(data, &tm, info->rtc_24hr_mode); 319 320 data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT); 321 data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT); 322 data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT); 323 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK; 324 if (data[RTC_MONTH] & 0xf) 325 data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT); 326 if (data[RTC_YEAR] & 0x7f) 327 data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT); 328 if (data[RTC_DATE] & 0x1f) 329 data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT); 330 331 ret = regmap_bulk_write(info->max77686->rtc_regmap, 332 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 333 if (ret < 0) { 334 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n", 335 __func__, ret); 336 goto out; 337 } 338 339 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 340 out: 341 return ret; 342 } 343 344 static int max77686_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 345 { 346 struct max77686_rtc_info *info = dev_get_drvdata(dev); 347 u8 data[RTC_NR_TIME]; 348 int ret; 349 350 ret = max77686_rtc_tm_to_data(&alrm->time, data); 351 if (ret < 0) 352 return ret; 353 354 mutex_lock(&info->lock); 355 356 ret = max77686_rtc_stop_alarm(info); 357 if (ret < 0) 358 goto out; 359 360 ret = regmap_bulk_write(info->max77686->rtc_regmap, 361 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 362 363 if (ret < 0) { 364 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n", 365 __func__, ret); 366 goto out; 367 } 368 369 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 370 if (ret < 0) 371 goto out; 372 373 if (alrm->enabled) 374 ret = max77686_rtc_start_alarm(info); 375 out: 376 mutex_unlock(&info->lock); 377 return ret; 378 } 379 380 static int max77686_rtc_alarm_irq_enable(struct device *dev, 381 unsigned int enabled) 382 { 383 struct max77686_rtc_info *info = dev_get_drvdata(dev); 384 int ret; 385 386 mutex_lock(&info->lock); 387 if (enabled) 388 ret = max77686_rtc_start_alarm(info); 389 else 390 ret = max77686_rtc_stop_alarm(info); 391 mutex_unlock(&info->lock); 392 393 return ret; 394 } 395 396 static irqreturn_t max77686_rtc_alarm_irq(int irq, void *data) 397 { 398 struct max77686_rtc_info *info = data; 399 400 dev_info(info->dev, "%s:irq(%d)\n", __func__, irq); 401 402 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF); 403 404 return IRQ_HANDLED; 405 } 406 407 static const struct rtc_class_ops max77686_rtc_ops = { 408 .read_time = max77686_rtc_read_time, 409 .set_time = max77686_rtc_set_time, 410 .read_alarm = max77686_rtc_read_alarm, 411 .set_alarm = max77686_rtc_set_alarm, 412 .alarm_irq_enable = max77686_rtc_alarm_irq_enable, 413 }; 414 415 #ifdef MAX77686_RTC_WTSR_SMPL 416 static void max77686_rtc_enable_wtsr(struct max77686_rtc_info *info, bool enable) 417 { 418 int ret; 419 unsigned int val, mask; 420 421 if (enable) 422 val = (1 << WTSR_EN_SHIFT) | (3 << WTSRT_SHIFT); 423 else 424 val = 0; 425 426 mask = WTSR_EN_MASK | WTSRT_MASK; 427 428 dev_info(info->dev, "%s: %s WTSR\n", __func__, 429 enable ? "enable" : "disable"); 430 431 ret = regmap_update_bits(info->max77686->rtc_regmap, 432 MAX77686_WTSR_SMPL_CNTL, mask, val); 433 if (ret < 0) { 434 dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n", 435 __func__, ret); 436 return; 437 } 438 439 max77686_rtc_update(info, MAX77686_RTC_WRITE); 440 } 441 442 static void max77686_rtc_enable_smpl(struct max77686_rtc_info *info, bool enable) 443 { 444 int ret; 445 unsigned int val, mask; 446 447 if (enable) 448 val = (1 << SMPL_EN_SHIFT) | (0 << SMPLT_SHIFT); 449 else 450 val = 0; 451 452 mask = SMPL_EN_MASK | SMPLT_MASK; 453 454 dev_info(info->dev, "%s: %s SMPL\n", __func__, 455 enable ? "enable" : "disable"); 456 457 ret = regmap_update_bits(info->max77686->rtc_regmap, 458 MAX77686_WTSR_SMPL_CNTL, mask, val); 459 if (ret < 0) { 460 dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n", 461 __func__, ret); 462 return; 463 } 464 465 max77686_rtc_update(info, MAX77686_RTC_WRITE); 466 467 val = 0; 468 regmap_read(info->max77686->rtc_regmap, MAX77686_WTSR_SMPL_CNTL, &val); 469 dev_info(info->dev, "%s: WTSR_SMPL(0x%02x)\n", __func__, val); 470 } 471 #endif /* MAX77686_RTC_WTSR_SMPL */ 472 473 static int max77686_rtc_init_reg(struct max77686_rtc_info *info) 474 { 475 u8 data[2]; 476 int ret; 477 478 /* Set RTC control register : Binary mode, 24hour mdoe */ 479 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 480 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 481 482 info->rtc_24hr_mode = 1; 483 484 ret = regmap_bulk_write(info->max77686->rtc_regmap, MAX77686_RTC_CONTROLM, data, 2); 485 if (ret < 0) { 486 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n", 487 __func__, ret); 488 return ret; 489 } 490 491 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 492 return ret; 493 } 494 495 static struct regmap_config max77686_rtc_regmap_config = { 496 .reg_bits = 8, 497 .val_bits = 8, 498 }; 499 500 static int max77686_rtc_probe(struct platform_device *pdev) 501 { 502 struct max77686_dev *max77686 = dev_get_drvdata(pdev->dev.parent); 503 struct max77686_rtc_info *info; 504 int ret, virq; 505 506 dev_info(&pdev->dev, "%s\n", __func__); 507 508 info = devm_kzalloc(&pdev->dev, sizeof(struct max77686_rtc_info), 509 GFP_KERNEL); 510 if (!info) 511 return -ENOMEM; 512 513 mutex_init(&info->lock); 514 info->dev = &pdev->dev; 515 info->max77686 = max77686; 516 info->rtc = max77686->rtc; 517 info->max77686->rtc_regmap = devm_regmap_init_i2c(info->max77686->rtc, 518 &max77686_rtc_regmap_config); 519 if (IS_ERR(info->max77686->rtc_regmap)) { 520 ret = PTR_ERR(info->max77686->rtc_regmap); 521 dev_err(info->max77686->dev, "Failed to allocate register map: %d\n", 522 ret); 523 return ret; 524 } 525 platform_set_drvdata(pdev, info); 526 527 ret = max77686_rtc_init_reg(info); 528 529 if (ret < 0) { 530 dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret); 531 goto err_rtc; 532 } 533 534 #ifdef MAX77686_RTC_WTSR_SMPL 535 max77686_rtc_enable_wtsr(info, true); 536 max77686_rtc_enable_smpl(info, true); 537 #endif 538 539 device_init_wakeup(&pdev->dev, 1); 540 541 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max77686-rtc", 542 &max77686_rtc_ops, THIS_MODULE); 543 544 if (IS_ERR(info->rtc_dev)) { 545 dev_info(&pdev->dev, "%s: fail\n", __func__); 546 547 ret = PTR_ERR(info->rtc_dev); 548 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret); 549 if (ret == 0) 550 ret = -EINVAL; 551 goto err_rtc; 552 } 553 virq = irq_create_mapping(max77686->irq_domain, MAX77686_RTCIRQ_RTCA1); 554 if (!virq) { 555 ret = -ENXIO; 556 goto err_rtc; 557 } 558 info->virq = virq; 559 560 ret = devm_request_threaded_irq(&pdev->dev, virq, NULL, 561 max77686_rtc_alarm_irq, 0, "rtc-alarm0", info); 562 if (ret < 0) 563 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n", 564 info->virq, ret); 565 566 err_rtc: 567 return ret; 568 } 569 570 static void max77686_rtc_shutdown(struct platform_device *pdev) 571 { 572 #ifdef MAX77686_RTC_WTSR_SMPL 573 struct max77686_rtc_info *info = platform_get_drvdata(pdev); 574 int i; 575 u8 val = 0; 576 577 for (i = 0; i < 3; i++) { 578 max77686_rtc_enable_wtsr(info, false); 579 regmap_read(info->max77686->rtc_regmap, MAX77686_WTSR_SMPL_CNTL, &val); 580 dev_info(info->dev, "%s: WTSR_SMPL reg(0x%02x)\n", __func__, 581 val); 582 if (val & WTSR_EN_MASK) { 583 dev_emerg(info->dev, "%s: fail to disable WTSR\n", 584 __func__); 585 } else { 586 dev_info(info->dev, "%s: success to disable WTSR\n", 587 __func__); 588 break; 589 } 590 } 591 592 /* Disable SMPL when power off */ 593 max77686_rtc_enable_smpl(info, false); 594 #endif /* MAX77686_RTC_WTSR_SMPL */ 595 } 596 597 static const struct platform_device_id rtc_id[] = { 598 { "max77686-rtc", 0 }, 599 {}, 600 }; 601 602 static struct platform_driver max77686_rtc_driver = { 603 .driver = { 604 .name = "max77686-rtc", 605 .owner = THIS_MODULE, 606 }, 607 .probe = max77686_rtc_probe, 608 .shutdown = max77686_rtc_shutdown, 609 .id_table = rtc_id, 610 }; 611 612 module_platform_driver(max77686_rtc_driver); 613 614 MODULE_DESCRIPTION("Maxim MAX77686 RTC driver"); 615 MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>"); 616 MODULE_LICENSE("GPL"); 617