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