1 /* 2 * RTC driver for Maxim MAX8997 3 * 4 * Copyright (C) 2013 Samsung Electronics Co.Ltd 5 * 6 * based on rtc-max8998.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/max8997-private.h> 22 #include <linux/irqdomain.h> 23 24 /* Module parameter for WTSR function control */ 25 static int wtsr_en = 1; 26 module_param(wtsr_en, int, 0444); 27 MODULE_PARM_DESC(wtsr_en, "Watchdog Timeout & Software Reset (default=on)"); 28 /* Module parameter for SMPL function control */ 29 static int smpl_en = 1; 30 module_param(smpl_en, int, 0444); 31 MODULE_PARM_DESC(smpl_en, "Sudden Momentary Power Loss (default=on)"); 32 33 /* RTC Control Register */ 34 #define BCD_EN_SHIFT 0 35 #define BCD_EN_MASK (1 << BCD_EN_SHIFT) 36 #define MODEL24_SHIFT 1 37 #define MODEL24_MASK (1 << MODEL24_SHIFT) 38 /* RTC Update Register1 */ 39 #define RTC_UDR_SHIFT 0 40 #define RTC_UDR_MASK (1 << RTC_UDR_SHIFT) 41 /* WTSR and SMPL Register */ 42 #define WTSRT_SHIFT 0 43 #define SMPLT_SHIFT 2 44 #define WTSR_EN_SHIFT 6 45 #define SMPL_EN_SHIFT 7 46 #define WTSRT_MASK (3 << WTSRT_SHIFT) 47 #define SMPLT_MASK (3 << SMPLT_SHIFT) 48 #define WTSR_EN_MASK (1 << WTSR_EN_SHIFT) 49 #define SMPL_EN_MASK (1 << SMPL_EN_SHIFT) 50 /* RTC Hour register */ 51 #define HOUR_PM_SHIFT 6 52 #define HOUR_PM_MASK (1 << HOUR_PM_SHIFT) 53 /* RTC Alarm Enable */ 54 #define ALARM_ENABLE_SHIFT 7 55 #define ALARM_ENABLE_MASK (1 << ALARM_ENABLE_SHIFT) 56 57 enum { 58 RTC_SEC = 0, 59 RTC_MIN, 60 RTC_HOUR, 61 RTC_WEEKDAY, 62 RTC_MONTH, 63 RTC_YEAR, 64 RTC_DATE, 65 RTC_NR_TIME 66 }; 67 68 struct max8997_rtc_info { 69 struct device *dev; 70 struct max8997_dev *max8997; 71 struct i2c_client *rtc; 72 struct rtc_device *rtc_dev; 73 struct mutex lock; 74 int virq; 75 int rtc_24hr_mode; 76 }; 77 78 static void max8997_rtc_data_to_tm(u8 *data, struct rtc_time *tm, 79 int rtc_24hr_mode) 80 { 81 tm->tm_sec = data[RTC_SEC] & 0x7f; 82 tm->tm_min = data[RTC_MIN] & 0x7f; 83 if (rtc_24hr_mode) 84 tm->tm_hour = data[RTC_HOUR] & 0x1f; 85 else { 86 tm->tm_hour = data[RTC_HOUR] & 0x0f; 87 if (data[RTC_HOUR] & HOUR_PM_MASK) 88 tm->tm_hour += 12; 89 } 90 91 tm->tm_wday = fls(data[RTC_WEEKDAY] & 0x7f) - 1; 92 tm->tm_mday = data[RTC_DATE] & 0x1f; 93 tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1; 94 tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100; 95 tm->tm_yday = 0; 96 tm->tm_isdst = 0; 97 } 98 99 static int max8997_rtc_tm_to_data(struct rtc_time *tm, u8 *data) 100 { 101 data[RTC_SEC] = tm->tm_sec; 102 data[RTC_MIN] = tm->tm_min; 103 data[RTC_HOUR] = tm->tm_hour; 104 data[RTC_WEEKDAY] = 1 << tm->tm_wday; 105 data[RTC_DATE] = tm->tm_mday; 106 data[RTC_MONTH] = tm->tm_mon + 1; 107 data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0; 108 109 if (tm->tm_year < 100) { 110 pr_warn("%s: MAX8997 RTC cannot handle the year %d." 111 "Assume it's 2000.\n", __func__, 1900 + tm->tm_year); 112 return -EINVAL; 113 } 114 return 0; 115 } 116 117 static inline int max8997_rtc_set_update_reg(struct max8997_rtc_info *info) 118 { 119 int ret; 120 121 ret = max8997_write_reg(info->rtc, MAX8997_RTC_UPDATE1, 122 RTC_UDR_MASK); 123 if (ret < 0) 124 dev_err(info->dev, "%s: fail to write update reg(%d)\n", 125 __func__, ret); 126 else { 127 /* Minimum 16ms delay required before RTC update. 128 * Otherwise, we may read and update based on out-of-date 129 * value */ 130 msleep(20); 131 } 132 133 return ret; 134 } 135 136 static int max8997_rtc_read_time(struct device *dev, struct rtc_time *tm) 137 { 138 struct max8997_rtc_info *info = dev_get_drvdata(dev); 139 u8 data[RTC_NR_TIME]; 140 int ret; 141 142 mutex_lock(&info->lock); 143 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data); 144 mutex_unlock(&info->lock); 145 146 if (ret < 0) { 147 dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__, 148 ret); 149 return ret; 150 } 151 152 max8997_rtc_data_to_tm(data, tm, info->rtc_24hr_mode); 153 154 return rtc_valid_tm(tm); 155 } 156 157 static int max8997_rtc_set_time(struct device *dev, struct rtc_time *tm) 158 { 159 struct max8997_rtc_info *info = dev_get_drvdata(dev); 160 u8 data[RTC_NR_TIME]; 161 int ret; 162 163 ret = max8997_rtc_tm_to_data(tm, data); 164 if (ret < 0) 165 return ret; 166 167 mutex_lock(&info->lock); 168 169 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data); 170 if (ret < 0) { 171 dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__, 172 ret); 173 goto out; 174 } 175 176 ret = max8997_rtc_set_update_reg(info); 177 out: 178 mutex_unlock(&info->lock); 179 return ret; 180 } 181 182 static int max8997_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 183 { 184 struct max8997_rtc_info *info = dev_get_drvdata(dev); 185 u8 data[RTC_NR_TIME]; 186 u8 val; 187 int i, ret; 188 189 mutex_lock(&info->lock); 190 191 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME, 192 data); 193 if (ret < 0) { 194 dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n", 195 __func__, __LINE__, ret); 196 goto out; 197 } 198 199 max8997_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode); 200 201 alrm->enabled = 0; 202 for (i = 0; i < RTC_NR_TIME; i++) { 203 if (data[i] & ALARM_ENABLE_MASK) { 204 alrm->enabled = 1; 205 break; 206 } 207 } 208 209 alrm->pending = 0; 210 ret = max8997_read_reg(info->max8997->i2c, MAX8997_REG_STATUS1, &val); 211 if (ret < 0) { 212 dev_err(info->dev, "%s:%d fail to read status1 reg(%d)\n", 213 __func__, __LINE__, ret); 214 goto out; 215 } 216 217 if (val & (1 << 4)) /* RTCA1 */ 218 alrm->pending = 1; 219 220 out: 221 mutex_unlock(&info->lock); 222 return 0; 223 } 224 225 static int max8997_rtc_stop_alarm(struct max8997_rtc_info *info) 226 { 227 u8 data[RTC_NR_TIME]; 228 int ret, i; 229 230 if (!mutex_is_locked(&info->lock)) 231 dev_warn(info->dev, "%s: should have mutex locked\n", __func__); 232 233 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME, 234 data); 235 if (ret < 0) { 236 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n", 237 __func__, ret); 238 goto out; 239 } 240 241 for (i = 0; i < RTC_NR_TIME; i++) 242 data[i] &= ~ALARM_ENABLE_MASK; 243 244 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME, 245 data); 246 if (ret < 0) { 247 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n", 248 __func__, ret); 249 goto out; 250 } 251 252 ret = max8997_rtc_set_update_reg(info); 253 out: 254 return ret; 255 } 256 257 static int max8997_rtc_start_alarm(struct max8997_rtc_info *info) 258 { 259 u8 data[RTC_NR_TIME]; 260 int ret; 261 262 if (!mutex_is_locked(&info->lock)) 263 dev_warn(info->dev, "%s: should have mutex locked\n", __func__); 264 265 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME, 266 data); 267 if (ret < 0) { 268 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n", 269 __func__, ret); 270 goto out; 271 } 272 273 data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT); 274 data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT); 275 data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT); 276 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK; 277 if (data[RTC_MONTH] & 0xf) 278 data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT); 279 if (data[RTC_YEAR] & 0x7f) 280 data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT); 281 if (data[RTC_DATE] & 0x1f) 282 data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT); 283 284 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME, 285 data); 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 = max8997_rtc_set_update_reg(info); 293 out: 294 return ret; 295 } 296 static int max8997_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 297 { 298 struct max8997_rtc_info *info = dev_get_drvdata(dev); 299 u8 data[RTC_NR_TIME]; 300 int ret; 301 302 ret = max8997_rtc_tm_to_data(&alrm->time, data); 303 if (ret < 0) 304 return ret; 305 306 dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d\n", __func__, 307 data[RTC_YEAR] + 2000, data[RTC_MONTH], data[RTC_DATE], 308 data[RTC_HOUR], data[RTC_MIN], data[RTC_SEC]); 309 310 mutex_lock(&info->lock); 311 312 ret = max8997_rtc_stop_alarm(info); 313 if (ret < 0) 314 goto out; 315 316 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME, 317 data); 318 if (ret < 0) { 319 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n", 320 __func__, ret); 321 goto out; 322 } 323 324 ret = max8997_rtc_set_update_reg(info); 325 if (ret < 0) 326 goto out; 327 328 if (alrm->enabled) 329 ret = max8997_rtc_start_alarm(info); 330 out: 331 mutex_unlock(&info->lock); 332 return ret; 333 } 334 335 static int max8997_rtc_alarm_irq_enable(struct device *dev, 336 unsigned int enabled) 337 { 338 struct max8997_rtc_info *info = dev_get_drvdata(dev); 339 int ret; 340 341 mutex_lock(&info->lock); 342 if (enabled) 343 ret = max8997_rtc_start_alarm(info); 344 else 345 ret = max8997_rtc_stop_alarm(info); 346 mutex_unlock(&info->lock); 347 348 return ret; 349 } 350 351 static irqreturn_t max8997_rtc_alarm_irq(int irq, void *data) 352 { 353 struct max8997_rtc_info *info = data; 354 355 dev_info(info->dev, "%s:irq(%d)\n", __func__, irq); 356 357 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF); 358 359 return IRQ_HANDLED; 360 } 361 362 static const struct rtc_class_ops max8997_rtc_ops = { 363 .read_time = max8997_rtc_read_time, 364 .set_time = max8997_rtc_set_time, 365 .read_alarm = max8997_rtc_read_alarm, 366 .set_alarm = max8997_rtc_set_alarm, 367 .alarm_irq_enable = max8997_rtc_alarm_irq_enable, 368 }; 369 370 static void max8997_rtc_enable_wtsr(struct max8997_rtc_info *info, bool enable) 371 { 372 int ret; 373 u8 val, mask; 374 375 if (!wtsr_en) 376 return; 377 378 if (enable) 379 val = (1 << WTSR_EN_SHIFT) | (3 << WTSRT_SHIFT); 380 else 381 val = 0; 382 383 mask = WTSR_EN_MASK | WTSRT_MASK; 384 385 dev_info(info->dev, "%s: %s WTSR\n", __func__, 386 enable ? "enable" : "disable"); 387 388 ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask); 389 if (ret < 0) { 390 dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n", 391 __func__, ret); 392 return; 393 } 394 395 max8997_rtc_set_update_reg(info); 396 } 397 398 static void max8997_rtc_enable_smpl(struct max8997_rtc_info *info, bool enable) 399 { 400 int ret; 401 u8 val, mask; 402 403 if (!smpl_en) 404 return; 405 406 if (enable) 407 val = (1 << SMPL_EN_SHIFT) | (0 << SMPLT_SHIFT); 408 else 409 val = 0; 410 411 mask = SMPL_EN_MASK | SMPLT_MASK; 412 413 dev_info(info->dev, "%s: %s SMPL\n", __func__, 414 enable ? "enable" : "disable"); 415 416 ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask); 417 if (ret < 0) { 418 dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n", 419 __func__, ret); 420 return; 421 } 422 423 max8997_rtc_set_update_reg(info); 424 425 val = 0; 426 max8997_read_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, &val); 427 pr_info("%s: WTSR_SMPL(0x%02x)\n", __func__, val); 428 } 429 430 static int max8997_rtc_init_reg(struct max8997_rtc_info *info) 431 { 432 u8 data[2]; 433 int ret; 434 435 /* Set RTC control register : Binary mode, 24hour mdoe */ 436 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 437 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 438 439 info->rtc_24hr_mode = 1; 440 441 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_CTRLMASK, 2, data); 442 if (ret < 0) { 443 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n", 444 __func__, ret); 445 return ret; 446 } 447 448 ret = max8997_rtc_set_update_reg(info); 449 return ret; 450 } 451 452 static int max8997_rtc_probe(struct platform_device *pdev) 453 { 454 struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent); 455 struct max8997_rtc_info *info; 456 int ret, virq; 457 458 info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_rtc_info), 459 GFP_KERNEL); 460 if (!info) 461 return -ENOMEM; 462 463 mutex_init(&info->lock); 464 info->dev = &pdev->dev; 465 info->max8997 = max8997; 466 info->rtc = max8997->rtc; 467 468 platform_set_drvdata(pdev, info); 469 470 ret = max8997_rtc_init_reg(info); 471 472 if (ret < 0) { 473 dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret); 474 return ret; 475 } 476 477 max8997_rtc_enable_wtsr(info, true); 478 max8997_rtc_enable_smpl(info, true); 479 480 device_init_wakeup(&pdev->dev, 1); 481 482 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc", 483 &max8997_rtc_ops, THIS_MODULE); 484 485 if (IS_ERR(info->rtc_dev)) { 486 ret = PTR_ERR(info->rtc_dev); 487 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret); 488 return ret; 489 } 490 491 virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1); 492 if (!virq) { 493 dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n"); 494 ret = -ENXIO; 495 goto err_out; 496 } 497 info->virq = virq; 498 499 ret = devm_request_threaded_irq(&pdev->dev, virq, NULL, 500 max8997_rtc_alarm_irq, 0, 501 "rtc-alarm0", info); 502 if (ret < 0) 503 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n", 504 info->virq, ret); 505 506 err_out: 507 return ret; 508 } 509 510 static void max8997_rtc_shutdown(struct platform_device *pdev) 511 { 512 struct max8997_rtc_info *info = platform_get_drvdata(pdev); 513 514 max8997_rtc_enable_wtsr(info, false); 515 max8997_rtc_enable_smpl(info, false); 516 } 517 518 static const struct platform_device_id rtc_id[] = { 519 { "max8997-rtc", 0 }, 520 {}, 521 }; 522 523 static struct platform_driver max8997_rtc_driver = { 524 .driver = { 525 .name = "max8997-rtc", 526 }, 527 .probe = max8997_rtc_probe, 528 .shutdown = max8997_rtc_shutdown, 529 .id_table = rtc_id, 530 }; 531 532 module_platform_driver(max8997_rtc_driver); 533 534 MODULE_DESCRIPTION("Maxim MAX8997 RTC driver"); 535 MODULE_AUTHOR("<ms925.kim@samsung.com>"); 536 MODULE_LICENSE("GPL"); 537