1 /* 2 * Copyright (c) 2013-2014 Samsung Electronics Co., Ltd 3 * http://www.samsung.com 4 * 5 * Copyright (C) 2013 Google, Inc 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 */ 17 18 #include <linux/module.h> 19 #include <linux/i2c.h> 20 #include <linux/bcd.h> 21 #include <linux/regmap.h> 22 #include <linux/rtc.h> 23 #include <linux/platform_device.h> 24 #include <linux/mfd/samsung/core.h> 25 #include <linux/mfd/samsung/irq.h> 26 #include <linux/mfd/samsung/rtc.h> 27 #include <linux/mfd/samsung/s2mps14.h> 28 29 /* 30 * Maximum number of retries for checking changes in UDR field 31 * of S5M_RTC_UDR_CON register (to limit possible endless loop). 32 * 33 * After writing to RTC registers (setting time or alarm) read the UDR field 34 * in S5M_RTC_UDR_CON register. UDR is auto-cleared when data have 35 * been transferred. 36 */ 37 #define UDR_READ_RETRY_CNT 5 38 39 /* Registers used by the driver which are different between chipsets. */ 40 struct s5m_rtc_reg_config { 41 /* Number of registers used for setting time/alarm0/alarm1 */ 42 unsigned int regs_count; 43 /* First register for time, seconds */ 44 unsigned int time; 45 /* RTC control register */ 46 unsigned int ctrl; 47 /* First register for alarm 0, seconds */ 48 unsigned int alarm0; 49 /* First register for alarm 1, seconds */ 50 unsigned int alarm1; 51 /* 52 * Register for update flag (UDR). Typically setting UDR field to 1 53 * will enable update of time or alarm register. Then it will be 54 * auto-cleared after successful update. 55 */ 56 unsigned int rtc_udr_update; 57 /* Mask for UDR field in 'rtc_udr_update' register */ 58 unsigned int rtc_udr_mask; 59 }; 60 61 /* Register map for S5M8763 and S5M8767 */ 62 static const struct s5m_rtc_reg_config s5m_rtc_regs = { 63 .regs_count = 8, 64 .time = S5M_RTC_SEC, 65 .ctrl = S5M_ALARM1_CONF, 66 .alarm0 = S5M_ALARM0_SEC, 67 .alarm1 = S5M_ALARM1_SEC, 68 .rtc_udr_update = S5M_RTC_UDR_CON, 69 .rtc_udr_mask = S5M_RTC_UDR_MASK, 70 }; 71 72 /* 73 * Register map for S2MPS14. 74 * It may be also suitable for S2MPS11 but this was not tested. 75 */ 76 static const struct s5m_rtc_reg_config s2mps_rtc_regs = { 77 .regs_count = 7, 78 .time = S2MPS_RTC_SEC, 79 .ctrl = S2MPS_RTC_CTRL, 80 .alarm0 = S2MPS_ALARM0_SEC, 81 .alarm1 = S2MPS_ALARM1_SEC, 82 .rtc_udr_update = S2MPS_RTC_UDR_CON, 83 .rtc_udr_mask = S2MPS_RTC_WUDR_MASK, 84 }; 85 86 struct s5m_rtc_info { 87 struct device *dev; 88 struct i2c_client *i2c; 89 struct sec_pmic_dev *s5m87xx; 90 struct regmap *regmap; 91 struct rtc_device *rtc_dev; 92 int irq; 93 int device_type; 94 int rtc_24hr_mode; 95 const struct s5m_rtc_reg_config *regs; 96 }; 97 98 static const struct regmap_config s5m_rtc_regmap_config = { 99 .reg_bits = 8, 100 .val_bits = 8, 101 102 .max_register = S5M_RTC_REG_MAX, 103 }; 104 105 static const struct regmap_config s2mps14_rtc_regmap_config = { 106 .reg_bits = 8, 107 .val_bits = 8, 108 109 .max_register = S2MPS_RTC_REG_MAX, 110 }; 111 112 static void s5m8767_data_to_tm(u8 *data, struct rtc_time *tm, 113 int rtc_24hr_mode) 114 { 115 tm->tm_sec = data[RTC_SEC] & 0x7f; 116 tm->tm_min = data[RTC_MIN] & 0x7f; 117 if (rtc_24hr_mode) { 118 tm->tm_hour = data[RTC_HOUR] & 0x1f; 119 } else { 120 tm->tm_hour = data[RTC_HOUR] & 0x0f; 121 if (data[RTC_HOUR] & HOUR_PM_MASK) 122 tm->tm_hour += 12; 123 } 124 125 tm->tm_wday = ffs(data[RTC_WEEKDAY] & 0x7f); 126 tm->tm_mday = data[RTC_DATE] & 0x1f; 127 tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1; 128 tm->tm_year = (data[RTC_YEAR1] & 0x7f) + 100; 129 tm->tm_yday = 0; 130 tm->tm_isdst = 0; 131 } 132 133 static int s5m8767_tm_to_data(struct rtc_time *tm, u8 *data) 134 { 135 data[RTC_SEC] = tm->tm_sec; 136 data[RTC_MIN] = tm->tm_min; 137 138 if (tm->tm_hour >= 12) 139 data[RTC_HOUR] = tm->tm_hour | HOUR_PM_MASK; 140 else 141 data[RTC_HOUR] = tm->tm_hour & ~HOUR_PM_MASK; 142 143 data[RTC_WEEKDAY] = 1 << tm->tm_wday; 144 data[RTC_DATE] = tm->tm_mday; 145 data[RTC_MONTH] = tm->tm_mon + 1; 146 data[RTC_YEAR1] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0; 147 148 if (tm->tm_year < 100) { 149 pr_err("s5m8767 RTC cannot handle the year %d.\n", 150 1900 + tm->tm_year); 151 return -EINVAL; 152 } else { 153 return 0; 154 } 155 } 156 157 /* 158 * Read RTC_UDR_CON register and wait till UDR field is cleared. 159 * This indicates that time/alarm update ended. 160 */ 161 static inline int s5m8767_wait_for_udr_update(struct s5m_rtc_info *info) 162 { 163 int ret, retry = UDR_READ_RETRY_CNT; 164 unsigned int data; 165 166 do { 167 ret = regmap_read(info->regmap, info->regs->rtc_udr_update, 168 &data); 169 } while (--retry && (data & info->regs->rtc_udr_mask) && !ret); 170 171 if (!retry) 172 dev_err(info->dev, "waiting for UDR update, reached max number of retries\n"); 173 174 return ret; 175 } 176 177 static inline int s5m_check_peding_alarm_interrupt(struct s5m_rtc_info *info, 178 struct rtc_wkalrm *alarm) 179 { 180 int ret; 181 unsigned int val; 182 183 switch (info->device_type) { 184 case S5M8767X: 185 case S5M8763X: 186 ret = regmap_read(info->regmap, S5M_RTC_STATUS, &val); 187 val &= S5M_ALARM0_STATUS; 188 break; 189 case S2MPS14X: 190 ret = regmap_read(info->s5m87xx->regmap_pmic, S2MPS14_REG_ST2, 191 &val); 192 val &= S2MPS_ALARM0_STATUS; 193 break; 194 default: 195 return -EINVAL; 196 } 197 if (ret < 0) 198 return ret; 199 200 if (val) 201 alarm->pending = 1; 202 else 203 alarm->pending = 0; 204 205 return 0; 206 } 207 208 static inline int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info) 209 { 210 int ret; 211 unsigned int data; 212 213 ret = regmap_read(info->regmap, info->regs->rtc_udr_update, &data); 214 if (ret < 0) { 215 dev_err(info->dev, "failed to read update reg(%d)\n", ret); 216 return ret; 217 } 218 219 data |= info->regs->rtc_udr_mask; 220 if (info->device_type == S5M8763X || info->device_type == S5M8767X) 221 data |= S5M_RTC_TIME_EN_MASK; 222 223 ret = regmap_write(info->regmap, info->regs->rtc_udr_update, data); 224 if (ret < 0) { 225 dev_err(info->dev, "failed to write update reg(%d)\n", ret); 226 return ret; 227 } 228 229 ret = s5m8767_wait_for_udr_update(info); 230 231 return ret; 232 } 233 234 static inline int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info) 235 { 236 int ret; 237 unsigned int data; 238 239 ret = regmap_read(info->regmap, info->regs->rtc_udr_update, &data); 240 if (ret < 0) { 241 dev_err(info->dev, "%s: fail to read update reg(%d)\n", 242 __func__, ret); 243 return ret; 244 } 245 246 data |= info->regs->rtc_udr_mask; 247 switch (info->device_type) { 248 case S5M8763X: 249 case S5M8767X: 250 data &= ~S5M_RTC_TIME_EN_MASK; 251 break; 252 case S2MPS14X: 253 data |= S2MPS_RTC_RUDR_MASK; 254 break; 255 default: 256 return -EINVAL; 257 } 258 259 ret = regmap_write(info->regmap, info->regs->rtc_udr_update, data); 260 if (ret < 0) { 261 dev_err(info->dev, "%s: fail to write update reg(%d)\n", 262 __func__, ret); 263 return ret; 264 } 265 266 ret = s5m8767_wait_for_udr_update(info); 267 268 return ret; 269 } 270 271 static void s5m8763_data_to_tm(u8 *data, struct rtc_time *tm) 272 { 273 tm->tm_sec = bcd2bin(data[RTC_SEC]); 274 tm->tm_min = bcd2bin(data[RTC_MIN]); 275 276 if (data[RTC_HOUR] & HOUR_12) { 277 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x1f); 278 if (data[RTC_HOUR] & HOUR_PM) 279 tm->tm_hour += 12; 280 } else { 281 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f); 282 } 283 284 tm->tm_wday = data[RTC_WEEKDAY] & 0x07; 285 tm->tm_mday = bcd2bin(data[RTC_DATE]); 286 tm->tm_mon = bcd2bin(data[RTC_MONTH]); 287 tm->tm_year = bcd2bin(data[RTC_YEAR1]) + bcd2bin(data[RTC_YEAR2]) * 100; 288 tm->tm_year -= 1900; 289 } 290 291 static void s5m8763_tm_to_data(struct rtc_time *tm, u8 *data) 292 { 293 data[RTC_SEC] = bin2bcd(tm->tm_sec); 294 data[RTC_MIN] = bin2bcd(tm->tm_min); 295 data[RTC_HOUR] = bin2bcd(tm->tm_hour); 296 data[RTC_WEEKDAY] = tm->tm_wday; 297 data[RTC_DATE] = bin2bcd(tm->tm_mday); 298 data[RTC_MONTH] = bin2bcd(tm->tm_mon); 299 data[RTC_YEAR1] = bin2bcd(tm->tm_year % 100); 300 data[RTC_YEAR2] = bin2bcd((tm->tm_year + 1900) / 100); 301 } 302 303 static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm) 304 { 305 struct s5m_rtc_info *info = dev_get_drvdata(dev); 306 u8 data[info->regs->regs_count]; 307 int ret; 308 309 if (info->device_type == S2MPS14X) { 310 ret = regmap_update_bits(info->regmap, 311 info->regs->rtc_udr_update, 312 S2MPS_RTC_RUDR_MASK, S2MPS_RTC_RUDR_MASK); 313 if (ret) { 314 dev_err(dev, 315 "Failed to prepare registers for time reading: %d\n", 316 ret); 317 return ret; 318 } 319 } 320 ret = regmap_bulk_read(info->regmap, info->regs->time, data, 321 info->regs->regs_count); 322 if (ret < 0) 323 return ret; 324 325 switch (info->device_type) { 326 case S5M8763X: 327 s5m8763_data_to_tm(data, tm); 328 break; 329 330 case S5M8767X: 331 case S2MPS14X: 332 s5m8767_data_to_tm(data, tm, info->rtc_24hr_mode); 333 break; 334 335 default: 336 return -EINVAL; 337 } 338 339 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__, 340 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday, 341 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday); 342 343 return rtc_valid_tm(tm); 344 } 345 346 static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm) 347 { 348 struct s5m_rtc_info *info = dev_get_drvdata(dev); 349 u8 data[info->regs->regs_count]; 350 int ret = 0; 351 352 switch (info->device_type) { 353 case S5M8763X: 354 s5m8763_tm_to_data(tm, data); 355 break; 356 case S5M8767X: 357 case S2MPS14X: 358 ret = s5m8767_tm_to_data(tm, data); 359 break; 360 default: 361 return -EINVAL; 362 } 363 364 if (ret < 0) 365 return ret; 366 367 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__, 368 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday, 369 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday); 370 371 ret = regmap_raw_write(info->regmap, info->regs->time, data, 372 info->regs->regs_count); 373 if (ret < 0) 374 return ret; 375 376 ret = s5m8767_rtc_set_time_reg(info); 377 378 return ret; 379 } 380 381 static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) 382 { 383 struct s5m_rtc_info *info = dev_get_drvdata(dev); 384 u8 data[info->regs->regs_count]; 385 unsigned int val; 386 int ret, i; 387 388 ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data, 389 info->regs->regs_count); 390 if (ret < 0) 391 return ret; 392 393 switch (info->device_type) { 394 case S5M8763X: 395 s5m8763_data_to_tm(data, &alrm->time); 396 ret = regmap_read(info->regmap, S5M_ALARM0_CONF, &val); 397 if (ret < 0) 398 return ret; 399 400 alrm->enabled = !!val; 401 break; 402 403 case S5M8767X: 404 case S2MPS14X: 405 s5m8767_data_to_tm(data, &alrm->time, info->rtc_24hr_mode); 406 alrm->enabled = 0; 407 for (i = 0; i < info->regs->regs_count; i++) { 408 if (data[i] & ALARM_ENABLE_MASK) { 409 alrm->enabled = 1; 410 break; 411 } 412 } 413 break; 414 415 default: 416 return -EINVAL; 417 } 418 419 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__, 420 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon, 421 alrm->time.tm_mday, alrm->time.tm_hour, 422 alrm->time.tm_min, alrm->time.tm_sec, 423 alrm->time.tm_wday); 424 425 ret = s5m_check_peding_alarm_interrupt(info, alrm); 426 427 return 0; 428 } 429 430 static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info) 431 { 432 u8 data[info->regs->regs_count]; 433 int ret, i; 434 struct rtc_time tm; 435 436 ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data, 437 info->regs->regs_count); 438 if (ret < 0) 439 return ret; 440 441 s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode); 442 dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__, 443 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday, 444 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday); 445 446 switch (info->device_type) { 447 case S5M8763X: 448 ret = regmap_write(info->regmap, S5M_ALARM0_CONF, 0); 449 break; 450 451 case S5M8767X: 452 case S2MPS14X: 453 for (i = 0; i < info->regs->regs_count; i++) 454 data[i] &= ~ALARM_ENABLE_MASK; 455 456 ret = regmap_raw_write(info->regmap, info->regs->alarm0, data, 457 info->regs->regs_count); 458 if (ret < 0) 459 return ret; 460 461 ret = s5m8767_rtc_set_alarm_reg(info); 462 463 break; 464 465 default: 466 return -EINVAL; 467 } 468 469 return ret; 470 } 471 472 static int s5m_rtc_start_alarm(struct s5m_rtc_info *info) 473 { 474 int ret; 475 u8 data[info->regs->regs_count]; 476 u8 alarm0_conf; 477 struct rtc_time tm; 478 479 ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data, 480 info->regs->regs_count); 481 if (ret < 0) 482 return ret; 483 484 s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode); 485 dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__, 486 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday, 487 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday); 488 489 switch (info->device_type) { 490 case S5M8763X: 491 alarm0_conf = 0x77; 492 ret = regmap_write(info->regmap, S5M_ALARM0_CONF, alarm0_conf); 493 break; 494 495 case S5M8767X: 496 case S2MPS14X: 497 data[RTC_SEC] |= ALARM_ENABLE_MASK; 498 data[RTC_MIN] |= ALARM_ENABLE_MASK; 499 data[RTC_HOUR] |= ALARM_ENABLE_MASK; 500 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK; 501 if (data[RTC_DATE] & 0x1f) 502 data[RTC_DATE] |= ALARM_ENABLE_MASK; 503 if (data[RTC_MONTH] & 0xf) 504 data[RTC_MONTH] |= ALARM_ENABLE_MASK; 505 if (data[RTC_YEAR1] & 0x7f) 506 data[RTC_YEAR1] |= ALARM_ENABLE_MASK; 507 508 ret = regmap_raw_write(info->regmap, info->regs->alarm0, data, 509 info->regs->regs_count); 510 if (ret < 0) 511 return ret; 512 ret = s5m8767_rtc_set_alarm_reg(info); 513 514 break; 515 516 default: 517 return -EINVAL; 518 } 519 520 return ret; 521 } 522 523 static int s5m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 524 { 525 struct s5m_rtc_info *info = dev_get_drvdata(dev); 526 u8 data[info->regs->regs_count]; 527 int ret; 528 529 switch (info->device_type) { 530 case S5M8763X: 531 s5m8763_tm_to_data(&alrm->time, data); 532 break; 533 534 case S5M8767X: 535 case S2MPS14X: 536 s5m8767_tm_to_data(&alrm->time, data); 537 break; 538 539 default: 540 return -EINVAL; 541 } 542 543 dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__, 544 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon, 545 alrm->time.tm_mday, alrm->time.tm_hour, alrm->time.tm_min, 546 alrm->time.tm_sec, alrm->time.tm_wday); 547 548 ret = s5m_rtc_stop_alarm(info); 549 if (ret < 0) 550 return ret; 551 552 ret = regmap_raw_write(info->regmap, info->regs->alarm0, data, 553 info->regs->regs_count); 554 if (ret < 0) 555 return ret; 556 557 ret = s5m8767_rtc_set_alarm_reg(info); 558 if (ret < 0) 559 return ret; 560 561 if (alrm->enabled) 562 ret = s5m_rtc_start_alarm(info); 563 564 return ret; 565 } 566 567 static int s5m_rtc_alarm_irq_enable(struct device *dev, 568 unsigned int enabled) 569 { 570 struct s5m_rtc_info *info = dev_get_drvdata(dev); 571 572 if (enabled) 573 return s5m_rtc_start_alarm(info); 574 else 575 return s5m_rtc_stop_alarm(info); 576 } 577 578 static irqreturn_t s5m_rtc_alarm_irq(int irq, void *data) 579 { 580 struct s5m_rtc_info *info = data; 581 582 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF); 583 584 return IRQ_HANDLED; 585 } 586 587 static const struct rtc_class_ops s5m_rtc_ops = { 588 .read_time = s5m_rtc_read_time, 589 .set_time = s5m_rtc_set_time, 590 .read_alarm = s5m_rtc_read_alarm, 591 .set_alarm = s5m_rtc_set_alarm, 592 .alarm_irq_enable = s5m_rtc_alarm_irq_enable, 593 }; 594 595 static int s5m8767_rtc_init_reg(struct s5m_rtc_info *info) 596 { 597 u8 data[2]; 598 int ret; 599 600 switch (info->device_type) { 601 case S5M8763X: 602 case S5M8767X: 603 /* UDR update time. Default of 7.32 ms is too long. */ 604 ret = regmap_update_bits(info->regmap, S5M_RTC_UDR_CON, 605 S5M_RTC_UDR_T_MASK, S5M_RTC_UDR_T_450_US); 606 if (ret < 0) 607 dev_err(info->dev, "%s: fail to change UDR time: %d\n", 608 __func__, ret); 609 610 /* Set RTC control register : Binary mode, 24hour mode */ 611 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 612 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 613 614 ret = regmap_raw_write(info->regmap, S5M_ALARM0_CONF, data, 2); 615 break; 616 617 case S2MPS14X: 618 data[0] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT); 619 ret = regmap_write(info->regmap, info->regs->ctrl, data[0]); 620 break; 621 622 default: 623 return -EINVAL; 624 } 625 626 info->rtc_24hr_mode = 1; 627 if (ret < 0) { 628 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n", 629 __func__, ret); 630 return ret; 631 } 632 633 return ret; 634 } 635 636 static int s5m_rtc_probe(struct platform_device *pdev) 637 { 638 struct sec_pmic_dev *s5m87xx = dev_get_drvdata(pdev->dev.parent); 639 struct sec_platform_data *pdata = s5m87xx->pdata; 640 struct s5m_rtc_info *info; 641 const struct regmap_config *regmap_cfg; 642 int ret, alarm_irq; 643 644 if (!pdata) { 645 dev_err(pdev->dev.parent, "Platform data not supplied\n"); 646 return -ENODEV; 647 } 648 649 info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL); 650 if (!info) 651 return -ENOMEM; 652 653 switch (pdata->device_type) { 654 case S2MPS14X: 655 regmap_cfg = &s2mps14_rtc_regmap_config; 656 info->regs = &s2mps_rtc_regs; 657 alarm_irq = S2MPS14_IRQ_RTCA0; 658 break; 659 case S5M8763X: 660 regmap_cfg = &s5m_rtc_regmap_config; 661 info->regs = &s5m_rtc_regs; 662 alarm_irq = S5M8763_IRQ_ALARM0; 663 break; 664 case S5M8767X: 665 regmap_cfg = &s5m_rtc_regmap_config; 666 info->regs = &s5m_rtc_regs; 667 alarm_irq = S5M8767_IRQ_RTCA1; 668 break; 669 default: 670 dev_err(&pdev->dev, "Device type is not supported by RTC driver\n"); 671 return -ENODEV; 672 } 673 674 info->i2c = i2c_new_dummy(s5m87xx->i2c->adapter, RTC_I2C_ADDR); 675 if (!info->i2c) { 676 dev_err(&pdev->dev, "Failed to allocate I2C for RTC\n"); 677 return -ENODEV; 678 } 679 680 info->regmap = devm_regmap_init_i2c(info->i2c, regmap_cfg); 681 if (IS_ERR(info->regmap)) { 682 ret = PTR_ERR(info->regmap); 683 dev_err(&pdev->dev, "Failed to allocate RTC register map: %d\n", 684 ret); 685 goto err; 686 } 687 688 info->dev = &pdev->dev; 689 info->s5m87xx = s5m87xx; 690 info->device_type = s5m87xx->device_type; 691 692 if (s5m87xx->irq_data) { 693 info->irq = regmap_irq_get_virq(s5m87xx->irq_data, alarm_irq); 694 if (info->irq <= 0) { 695 ret = -EINVAL; 696 dev_err(&pdev->dev, "Failed to get virtual IRQ %d\n", 697 alarm_irq); 698 goto err; 699 } 700 } 701 702 platform_set_drvdata(pdev, info); 703 704 ret = s5m8767_rtc_init_reg(info); 705 706 device_init_wakeup(&pdev->dev, 1); 707 708 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "s5m-rtc", 709 &s5m_rtc_ops, THIS_MODULE); 710 711 if (IS_ERR(info->rtc_dev)) { 712 ret = PTR_ERR(info->rtc_dev); 713 goto err; 714 } 715 716 if (!info->irq) { 717 dev_info(&pdev->dev, "Alarm IRQ not available\n"); 718 return 0; 719 } 720 721 ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL, 722 s5m_rtc_alarm_irq, 0, "rtc-alarm0", 723 info); 724 if (ret < 0) { 725 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n", 726 info->irq, ret); 727 goto err; 728 } 729 730 return 0; 731 732 err: 733 i2c_unregister_device(info->i2c); 734 735 return ret; 736 } 737 738 static int s5m_rtc_remove(struct platform_device *pdev) 739 { 740 struct s5m_rtc_info *info = platform_get_drvdata(pdev); 741 742 i2c_unregister_device(info->i2c); 743 744 return 0; 745 } 746 747 #ifdef CONFIG_PM_SLEEP 748 static int s5m_rtc_resume(struct device *dev) 749 { 750 struct s5m_rtc_info *info = dev_get_drvdata(dev); 751 int ret = 0; 752 753 if (info->irq && device_may_wakeup(dev)) 754 ret = disable_irq_wake(info->irq); 755 756 return ret; 757 } 758 759 static int s5m_rtc_suspend(struct device *dev) 760 { 761 struct s5m_rtc_info *info = dev_get_drvdata(dev); 762 int ret = 0; 763 764 if (info->irq && device_may_wakeup(dev)) 765 ret = enable_irq_wake(info->irq); 766 767 return ret; 768 } 769 #endif /* CONFIG_PM_SLEEP */ 770 771 static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops, s5m_rtc_suspend, s5m_rtc_resume); 772 773 static const struct platform_device_id s5m_rtc_id[] = { 774 { "s5m-rtc", S5M8767X }, 775 { "s2mps14-rtc", S2MPS14X }, 776 { }, 777 }; 778 779 static struct platform_driver s5m_rtc_driver = { 780 .driver = { 781 .name = "s5m-rtc", 782 .pm = &s5m_rtc_pm_ops, 783 }, 784 .probe = s5m_rtc_probe, 785 .remove = s5m_rtc_remove, 786 .id_table = s5m_rtc_id, 787 }; 788 789 module_platform_driver(s5m_rtc_driver); 790 791 /* Module information */ 792 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>"); 793 MODULE_DESCRIPTION("Samsung S5M/S2MPS14 RTC driver"); 794 MODULE_LICENSE("GPL"); 795 MODULE_ALIAS("platform:s5m-rtc"); 796