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