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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 16 17 #include <linux/slab.h> 18 #include <linux/rtc.h> 19 #include <linux/delay.h> 20 #include <linux/mutex.h> 21 #include <linux/module.h> 22 #include <linux/platform_device.h> 23 #include <linux/mfd/max77686-private.h> 24 #include <linux/irqdomain.h> 25 #include <linux/regmap.h> 26 27 /* RTC Control Register */ 28 #define BCD_EN_SHIFT 0 29 #define BCD_EN_MASK (1 << BCD_EN_SHIFT) 30 #define MODEL24_SHIFT 1 31 #define MODEL24_MASK (1 << MODEL24_SHIFT) 32 /* RTC Update Register1 */ 33 #define RTC_UDR_SHIFT 0 34 #define RTC_UDR_MASK (1 << RTC_UDR_SHIFT) 35 #define RTC_RBUDR_SHIFT 4 36 #define RTC_RBUDR_MASK (1 << RTC_RBUDR_SHIFT) 37 /* RTC Hour register */ 38 #define HOUR_PM_SHIFT 6 39 #define HOUR_PM_MASK (1 << HOUR_PM_SHIFT) 40 /* RTC Alarm Enable */ 41 #define ALARM_ENABLE_SHIFT 7 42 #define ALARM_ENABLE_MASK (1 << ALARM_ENABLE_SHIFT) 43 44 #define MAX77686_RTC_UPDATE_DELAY 16 45 46 enum { 47 RTC_SEC = 0, 48 RTC_MIN, 49 RTC_HOUR, 50 RTC_WEEKDAY, 51 RTC_MONTH, 52 RTC_YEAR, 53 RTC_DATE, 54 RTC_NR_TIME 55 }; 56 57 struct max77686_rtc_info { 58 struct device *dev; 59 struct max77686_dev *max77686; 60 struct i2c_client *rtc; 61 struct rtc_device *rtc_dev; 62 struct mutex lock; 63 64 struct regmap *regmap; 65 66 int virq; 67 int rtc_24hr_mode; 68 }; 69 70 enum MAX77686_RTC_OP { 71 MAX77686_RTC_WRITE, 72 MAX77686_RTC_READ, 73 }; 74 75 static void max77686_rtc_data_to_tm(u8 *data, struct rtc_time *tm, 76 int rtc_24hr_mode) 77 { 78 tm->tm_sec = data[RTC_SEC] & 0x7f; 79 tm->tm_min = data[RTC_MIN] & 0x7f; 80 if (rtc_24hr_mode) 81 tm->tm_hour = data[RTC_HOUR] & 0x1f; 82 else { 83 tm->tm_hour = data[RTC_HOUR] & 0x0f; 84 if (data[RTC_HOUR] & HOUR_PM_MASK) 85 tm->tm_hour += 12; 86 } 87 88 /* Only a single bit is set in data[], so fls() would be equivalent */ 89 tm->tm_wday = ffs(data[RTC_WEEKDAY] & 0x7f) - 1; 90 tm->tm_mday = data[RTC_DATE] & 0x1f; 91 tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1; 92 tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100; 93 tm->tm_yday = 0; 94 tm->tm_isdst = 0; 95 } 96 97 static int max77686_rtc_tm_to_data(struct rtc_time *tm, u8 *data) 98 { 99 data[RTC_SEC] = tm->tm_sec; 100 data[RTC_MIN] = tm->tm_min; 101 data[RTC_HOUR] = tm->tm_hour; 102 data[RTC_WEEKDAY] = 1 << tm->tm_wday; 103 data[RTC_DATE] = tm->tm_mday; 104 data[RTC_MONTH] = tm->tm_mon + 1; 105 data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0; 106 107 if (tm->tm_year < 100) { 108 pr_warn("RTC cannot handle the year %d. Assume it's 2000.\n", 109 1900 + tm->tm_year); 110 return -EINVAL; 111 } 112 return 0; 113 } 114 115 static int max77686_rtc_update(struct max77686_rtc_info *info, 116 enum MAX77686_RTC_OP op) 117 { 118 int ret; 119 unsigned int data; 120 121 if (op == MAX77686_RTC_WRITE) 122 data = 1 << RTC_UDR_SHIFT; 123 else 124 data = 1 << RTC_RBUDR_SHIFT; 125 126 ret = regmap_update_bits(info->max77686->rtc_regmap, 127 MAX77686_RTC_UPDATE0, data, data); 128 if (ret < 0) 129 dev_err(info->dev, "%s: fail to write update reg(ret=%d, data=0x%x)\n", 130 __func__, ret, data); 131 else { 132 /* Minimum 16ms delay required before RTC update. */ 133 msleep(MAX77686_RTC_UPDATE_DELAY); 134 } 135 136 return ret; 137 } 138 139 static int max77686_rtc_read_time(struct device *dev, struct rtc_time *tm) 140 { 141 struct max77686_rtc_info *info = dev_get_drvdata(dev); 142 u8 data[RTC_NR_TIME]; 143 int ret; 144 145 mutex_lock(&info->lock); 146 147 ret = max77686_rtc_update(info, MAX77686_RTC_READ); 148 if (ret < 0) 149 goto out; 150 151 ret = regmap_bulk_read(info->max77686->rtc_regmap, 152 MAX77686_RTC_SEC, data, RTC_NR_TIME); 153 if (ret < 0) { 154 dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__, ret); 155 goto out; 156 } 157 158 max77686_rtc_data_to_tm(data, tm, info->rtc_24hr_mode); 159 160 ret = rtc_valid_tm(tm); 161 162 out: 163 mutex_unlock(&info->lock); 164 return ret; 165 } 166 167 static int max77686_rtc_set_time(struct device *dev, struct rtc_time *tm) 168 { 169 struct max77686_rtc_info *info = dev_get_drvdata(dev); 170 u8 data[RTC_NR_TIME]; 171 int ret; 172 173 ret = max77686_rtc_tm_to_data(tm, data); 174 if (ret < 0) 175 return ret; 176 177 mutex_lock(&info->lock); 178 179 ret = regmap_bulk_write(info->max77686->rtc_regmap, 180 MAX77686_RTC_SEC, data, RTC_NR_TIME); 181 if (ret < 0) { 182 dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__, 183 ret); 184 goto out; 185 } 186 187 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 188 189 out: 190 mutex_unlock(&info->lock); 191 return ret; 192 } 193 194 static int max77686_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 195 { 196 struct max77686_rtc_info *info = dev_get_drvdata(dev); 197 u8 data[RTC_NR_TIME]; 198 unsigned int val; 199 int i, ret; 200 201 mutex_lock(&info->lock); 202 203 ret = max77686_rtc_update(info, MAX77686_RTC_READ); 204 if (ret < 0) 205 goto out; 206 207 ret = regmap_bulk_read(info->max77686->rtc_regmap, 208 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 209 if (ret < 0) { 210 dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n", 211 __func__, __LINE__, ret); 212 goto out; 213 } 214 215 max77686_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode); 216 217 alrm->enabled = 0; 218 for (i = 0; i < RTC_NR_TIME; i++) { 219 if (data[i] & ALARM_ENABLE_MASK) { 220 alrm->enabled = 1; 221 break; 222 } 223 } 224 225 alrm->pending = 0; 226 ret = regmap_read(info->max77686->regmap, MAX77686_REG_STATUS2, &val); 227 if (ret < 0) { 228 dev_err(info->dev, "%s:%d fail to read status2 reg(%d)\n", 229 __func__, __LINE__, ret); 230 goto out; 231 } 232 233 if (val & (1 << 4)) /* RTCA1 */ 234 alrm->pending = 1; 235 236 out: 237 mutex_unlock(&info->lock); 238 return 0; 239 } 240 241 static int max77686_rtc_stop_alarm(struct max77686_rtc_info *info) 242 { 243 u8 data[RTC_NR_TIME]; 244 int ret, i; 245 struct rtc_time tm; 246 247 if (!mutex_is_locked(&info->lock)) 248 dev_warn(info->dev, "%s: should have mutex locked\n", __func__); 249 250 ret = max77686_rtc_update(info, MAX77686_RTC_READ); 251 if (ret < 0) 252 goto out; 253 254 ret = regmap_bulk_read(info->max77686->rtc_regmap, 255 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 256 if (ret < 0) { 257 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n", 258 __func__, ret); 259 goto out; 260 } 261 262 max77686_rtc_data_to_tm(data, &tm, info->rtc_24hr_mode); 263 264 for (i = 0; i < RTC_NR_TIME; i++) 265 data[i] &= ~ALARM_ENABLE_MASK; 266 267 ret = regmap_bulk_write(info->max77686->rtc_regmap, 268 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 269 if (ret < 0) { 270 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n", 271 __func__, ret); 272 goto out; 273 } 274 275 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 276 out: 277 return ret; 278 } 279 280 static int max77686_rtc_start_alarm(struct max77686_rtc_info *info) 281 { 282 u8 data[RTC_NR_TIME]; 283 int ret; 284 struct rtc_time tm; 285 286 if (!mutex_is_locked(&info->lock)) 287 dev_warn(info->dev, "%s: should have mutex locked\n", __func__); 288 289 ret = max77686_rtc_update(info, MAX77686_RTC_READ); 290 if (ret < 0) 291 goto out; 292 293 ret = regmap_bulk_read(info->max77686->rtc_regmap, 294 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 295 if (ret < 0) { 296 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n", 297 __func__, ret); 298 goto out; 299 } 300 301 max77686_rtc_data_to_tm(data, &tm, info->rtc_24hr_mode); 302 303 data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT); 304 data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT); 305 data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT); 306 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK; 307 if (data[RTC_MONTH] & 0xf) 308 data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT); 309 if (data[RTC_YEAR] & 0x7f) 310 data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT); 311 if (data[RTC_DATE] & 0x1f) 312 data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT); 313 314 ret = regmap_bulk_write(info->max77686->rtc_regmap, 315 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 316 if (ret < 0) { 317 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n", 318 __func__, ret); 319 goto out; 320 } 321 322 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 323 out: 324 return ret; 325 } 326 327 static int max77686_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 328 { 329 struct max77686_rtc_info *info = dev_get_drvdata(dev); 330 u8 data[RTC_NR_TIME]; 331 int ret; 332 333 ret = max77686_rtc_tm_to_data(&alrm->time, data); 334 if (ret < 0) 335 return ret; 336 337 mutex_lock(&info->lock); 338 339 ret = max77686_rtc_stop_alarm(info); 340 if (ret < 0) 341 goto out; 342 343 ret = regmap_bulk_write(info->max77686->rtc_regmap, 344 MAX77686_ALARM1_SEC, data, RTC_NR_TIME); 345 346 if (ret < 0) { 347 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n", 348 __func__, ret); 349 goto out; 350 } 351 352 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 353 if (ret < 0) 354 goto out; 355 356 if (alrm->enabled) 357 ret = max77686_rtc_start_alarm(info); 358 out: 359 mutex_unlock(&info->lock); 360 return ret; 361 } 362 363 static int max77686_rtc_alarm_irq_enable(struct device *dev, 364 unsigned int enabled) 365 { 366 struct max77686_rtc_info *info = dev_get_drvdata(dev); 367 int ret; 368 369 mutex_lock(&info->lock); 370 if (enabled) 371 ret = max77686_rtc_start_alarm(info); 372 else 373 ret = max77686_rtc_stop_alarm(info); 374 mutex_unlock(&info->lock); 375 376 return ret; 377 } 378 379 static irqreturn_t max77686_rtc_alarm_irq(int irq, void *data) 380 { 381 struct max77686_rtc_info *info = data; 382 383 dev_info(info->dev, "%s:irq(%d)\n", __func__, irq); 384 385 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF); 386 387 return IRQ_HANDLED; 388 } 389 390 static const struct rtc_class_ops max77686_rtc_ops = { 391 .read_time = max77686_rtc_read_time, 392 .set_time = max77686_rtc_set_time, 393 .read_alarm = max77686_rtc_read_alarm, 394 .set_alarm = max77686_rtc_set_alarm, 395 .alarm_irq_enable = max77686_rtc_alarm_irq_enable, 396 }; 397 398 static int max77686_rtc_init_reg(struct max77686_rtc_info *info) 399 { 400 u8 data[2]; 401 int ret; 402 403 /* Set RTC control register : Binary mode, 24hour mdoe */ 404 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 405 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 406 407 info->rtc_24hr_mode = 1; 408 409 ret = regmap_bulk_write(info->max77686->rtc_regmap, MAX77686_RTC_CONTROLM, data, 2); 410 if (ret < 0) { 411 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n", 412 __func__, ret); 413 return ret; 414 } 415 416 ret = max77686_rtc_update(info, MAX77686_RTC_WRITE); 417 return ret; 418 } 419 420 static int max77686_rtc_probe(struct platform_device *pdev) 421 { 422 struct max77686_dev *max77686 = dev_get_drvdata(pdev->dev.parent); 423 struct max77686_rtc_info *info; 424 int ret; 425 426 dev_info(&pdev->dev, "%s\n", __func__); 427 428 info = devm_kzalloc(&pdev->dev, sizeof(struct max77686_rtc_info), 429 GFP_KERNEL); 430 if (!info) 431 return -ENOMEM; 432 433 mutex_init(&info->lock); 434 info->dev = &pdev->dev; 435 info->max77686 = max77686; 436 info->rtc = max77686->rtc; 437 438 platform_set_drvdata(pdev, info); 439 440 ret = max77686_rtc_init_reg(info); 441 442 if (ret < 0) { 443 dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret); 444 goto err_rtc; 445 } 446 447 device_init_wakeup(&pdev->dev, 1); 448 449 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max77686-rtc", 450 &max77686_rtc_ops, THIS_MODULE); 451 452 if (IS_ERR(info->rtc_dev)) { 453 ret = PTR_ERR(info->rtc_dev); 454 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret); 455 if (ret == 0) 456 ret = -EINVAL; 457 goto err_rtc; 458 } 459 460 if (!max77686->rtc_irq_data) { 461 ret = -EINVAL; 462 dev_err(&pdev->dev, "%s: no RTC regmap IRQ chip\n", __func__); 463 goto err_rtc; 464 } 465 466 info->virq = regmap_irq_get_virq(max77686->rtc_irq_data, 467 MAX77686_RTCIRQ_RTCA1); 468 if (!info->virq) { 469 ret = -ENXIO; 470 goto err_rtc; 471 } 472 473 ret = devm_request_threaded_irq(&pdev->dev, info->virq, NULL, 474 max77686_rtc_alarm_irq, 0, "rtc-alarm1", info); 475 if (ret < 0) 476 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n", 477 info->virq, ret); 478 479 err_rtc: 480 return ret; 481 } 482 483 #ifdef CONFIG_PM_SLEEP 484 static int max77686_rtc_suspend(struct device *dev) 485 { 486 if (device_may_wakeup(dev)) { 487 struct max77686_rtc_info *info = dev_get_drvdata(dev); 488 489 return enable_irq_wake(info->virq); 490 } 491 492 return 0; 493 } 494 495 static int max77686_rtc_resume(struct device *dev) 496 { 497 if (device_may_wakeup(dev)) { 498 struct max77686_rtc_info *info = dev_get_drvdata(dev); 499 500 return disable_irq_wake(info->virq); 501 } 502 503 return 0; 504 } 505 #endif 506 507 static SIMPLE_DEV_PM_OPS(max77686_rtc_pm_ops, 508 max77686_rtc_suspend, max77686_rtc_resume); 509 510 static const struct platform_device_id rtc_id[] = { 511 { "max77686-rtc", 0 }, 512 {}, 513 }; 514 MODULE_DEVICE_TABLE(platform, rtc_id); 515 516 static struct platform_driver max77686_rtc_driver = { 517 .driver = { 518 .name = "max77686-rtc", 519 .pm = &max77686_rtc_pm_ops, 520 }, 521 .probe = max77686_rtc_probe, 522 .id_table = rtc_id, 523 }; 524 525 module_platform_driver(max77686_rtc_driver); 526 527 MODULE_DESCRIPTION("Maxim MAX77686 RTC driver"); 528 MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>"); 529 MODULE_LICENSE("GPL"); 530