drivers/rtc/rtc-s5m.c

   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");