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 #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 S2MPS15X:
 192         case S2MPS14X:
 193         case S2MPS13X:
 194                 ret = regmap_read(info->s5m87xx->regmap_pmic, S2MPS14_REG_ST2,
 195                                 &val);
 196                 val &= S2MPS_ALARM0_STATUS;
 197                 break;
 198         default:
 199                 return -EINVAL;
 200         }
 201         if (ret < 0)
 202                 return ret;
 203
 204         if (val)
 205                 alarm->pending = 1;
 206         else
 207                 alarm->pending = 0;
 208
 209         return 0;
 210 }
 211
 212 static inline int s5m8767_rtc_set_time_reg(struct s5m_rtc_info *info)
 213 {
 214         int ret;
 215         unsigned int data;
 216
 217         ret = regmap_read(info->regmap, info->regs->rtc_udr_update, &data);
 218         if (ret < 0) {
 219                 dev_err(info->dev, "failed to read update reg(%d)\n", ret);
 220                 return ret;
 221         }
 222
 223         switch (info->device_type) {
 224         case S5M8763X:
 225         case S5M8767X:
 226                 data |= info->regs->rtc_udr_mask | S5M_RTC_TIME_EN_MASK;
 227         case S2MPS15X:
 228                 /* As per UM, for write time register, set WUDR bit to high */
 229                 data |= S2MPS15_RTC_WUDR_MASK;
 230                 break;
 231         case S2MPS14X:
 232         case S2MPS13X:
 233                 data |= info->regs->rtc_udr_mask;
 234                 break;
 235         default:
 236                 return -EINVAL;
 237         }
 238
 239
 240         ret = regmap_write(info->regmap, info->regs->rtc_udr_update, data);
 241         if (ret < 0) {
 242                 dev_err(info->dev, "failed to write update reg(%d)\n", ret);
 243                 return ret;
 244         }
 245
 246         ret = s5m8767_wait_for_udr_update(info);
 247
 248         return ret;
 249 }
 250
 251 static inline int s5m8767_rtc_set_alarm_reg(struct s5m_rtc_info *info)
 252 {
 253         int ret;
 254         unsigned int data;
 255
 256         ret = regmap_read(info->regmap, info->regs->rtc_udr_update, &data);
 257         if (ret < 0) {
 258                 dev_err(info->dev, "%s: fail to read update reg(%d)\n",
 259                         __func__, ret);
 260                 return ret;
 261         }
 262
 263         data |= info->regs->rtc_udr_mask;
 264         switch (info->device_type) {
 265         case S5M8763X:
 266         case S5M8767X:
 267                 data &= ~S5M_RTC_TIME_EN_MASK;
 268                 break;
 269         case S2MPS15X:
 270                 /* As per UM, for write alarm, set A_UDR(bit[4]) to high
 271                  * rtc_udr_mask above sets bit[4]
 272                  */
 273                 break;
 274         case S2MPS14X:
 275                 data |= S2MPS_RTC_RUDR_MASK;
 276                 break;
 277         case S2MPS13X:
 278                 data |= S2MPS13_RTC_AUDR_MASK;
 279                 break;
 280         default:
 281                 return -EINVAL;
 282         }
 283
 284         ret = regmap_write(info->regmap, info->regs->rtc_udr_update, data);
 285         if (ret < 0) {
 286                 dev_err(info->dev, "%s: fail to write update reg(%d)\n",
 287                         __func__, ret);
 288                 return ret;
 289         }
 290
 291         ret = s5m8767_wait_for_udr_update(info);
 292
 293         /* On S2MPS13 the AUDR is not auto-cleared */
 294         if (info->device_type == S2MPS13X)
 295                 regmap_update_bits(info->regmap, info->regs->rtc_udr_update,
 296                                    S2MPS13_RTC_AUDR_MASK, 0);
 297
 298         return ret;
 299 }
 300
 301 static void s5m8763_data_to_tm(u8 *data, struct rtc_time *tm)
 302 {
 303         tm->tm_sec = bcd2bin(data[RTC_SEC]);
 304         tm->tm_min = bcd2bin(data[RTC_MIN]);
 305
 306         if (data[RTC_HOUR] & HOUR_12) {
 307                 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x1f);
 308                 if (data[RTC_HOUR] & HOUR_PM)
 309                         tm->tm_hour += 12;
 310         } else {
 311                 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f);
 312         }
 313
 314         tm->tm_wday = data[RTC_WEEKDAY] & 0x07;
 315         tm->tm_mday = bcd2bin(data[RTC_DATE]);
 316         tm->tm_mon = bcd2bin(data[RTC_MONTH]);
 317         tm->tm_year = bcd2bin(data[RTC_YEAR1]) + bcd2bin(data[RTC_YEAR2]) * 100;
 318         tm->tm_year -= 1900;
 319 }
 320
 321 static void s5m8763_tm_to_data(struct rtc_time *tm, u8 *data)
 322 {
 323         data[RTC_SEC] = bin2bcd(tm->tm_sec);
 324         data[RTC_MIN] = bin2bcd(tm->tm_min);
 325         data[RTC_HOUR] = bin2bcd(tm->tm_hour);
 326         data[RTC_WEEKDAY] = tm->tm_wday;
 327         data[RTC_DATE] = bin2bcd(tm->tm_mday);
 328         data[RTC_MONTH] = bin2bcd(tm->tm_mon);
 329         data[RTC_YEAR1] = bin2bcd(tm->tm_year % 100);
 330         data[RTC_YEAR2] = bin2bcd((tm->tm_year + 1900) / 100);
 331 }
 332
 333 static int s5m_rtc_read_time(struct device *dev, struct rtc_time *tm)
 334 {
 335         struct s5m_rtc_info *info = dev_get_drvdata(dev);
 336         u8 data[info->regs->regs_count];
 337         int ret;
 338
 339         if (info->device_type == S2MPS15X || info->device_type == S2MPS14X ||
 340                         info->device_type == S2MPS13X) {
 341                 ret = regmap_update_bits(info->regmap,
 342                                 info->regs->rtc_udr_update,
 343                                 S2MPS_RTC_RUDR_MASK, S2MPS_RTC_RUDR_MASK);
 344                 if (ret) {
 345                         dev_err(dev,
 346                                 "Failed to prepare registers for time reading: %d\n",
 347                                 ret);
 348                         return ret;
 349                 }
 350         }
 351         ret = regmap_bulk_read(info->regmap, info->regs->time, data,
 352                         info->regs->regs_count);
 353         if (ret < 0)
 354                 return ret;
 355
 356         switch (info->device_type) {
 357         case S5M8763X:
 358                 s5m8763_data_to_tm(data, tm);
 359                 break;
 360
 361         case S5M8767X:
 362         case S2MPS15X:
 363         case S2MPS14X:
 364         case S2MPS13X:
 365                 s5m8767_data_to_tm(data, tm, info->rtc_24hr_mode);
 366                 break;
 367
 368         default:
 369                 return -EINVAL;
 370         }
 371
 372         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
 373                 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
 374                 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
 375
 376         return rtc_valid_tm(tm);
 377 }
 378
 379 static int s5m_rtc_set_time(struct device *dev, struct rtc_time *tm)
 380 {
 381         struct s5m_rtc_info *info = dev_get_drvdata(dev);
 382         u8 data[info->regs->regs_count];
 383         int ret = 0;
 384
 385         switch (info->device_type) {
 386         case S5M8763X:
 387                 s5m8763_tm_to_data(tm, data);
 388                 break;
 389         case S5M8767X:
 390         case S2MPS15X:
 391         case S2MPS14X:
 392         case S2MPS13X:
 393                 ret = s5m8767_tm_to_data(tm, data);
 394                 break;
 395         default:
 396                 return -EINVAL;
 397         }
 398
 399         if (ret < 0)
 400                 return ret;
 401
 402         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
 403                 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
 404                 tm->tm_hour, tm->tm_min, tm->tm_sec, tm->tm_wday);
 405
 406         ret = regmap_raw_write(info->regmap, info->regs->time, data,
 407                         info->regs->regs_count);
 408         if (ret < 0)
 409                 return ret;
 410
 411         ret = s5m8767_rtc_set_time_reg(info);
 412
 413         return ret;
 414 }
 415
 416 static int s5m_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 417 {
 418         struct s5m_rtc_info *info = dev_get_drvdata(dev);
 419         u8 data[info->regs->regs_count];
 420         unsigned int val;
 421         int ret, i;
 422
 423         ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data,
 424                         info->regs->regs_count);
 425         if (ret < 0)
 426                 return ret;
 427
 428         switch (info->device_type) {
 429         case S5M8763X:
 430                 s5m8763_data_to_tm(data, &alrm->time);
 431                 ret = regmap_read(info->regmap, S5M_ALARM0_CONF, &val);
 432                 if (ret < 0)
 433                         return ret;
 434
 435                 alrm->enabled = !!val;
 436                 break;
 437
 438         case S5M8767X:
 439         case S2MPS15X:
 440         case S2MPS14X:
 441         case S2MPS13X:
 442                 s5m8767_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
 443                 alrm->enabled = 0;
 444                 for (i = 0; i < info->regs->regs_count; i++) {
 445                         if (data[i] & ALARM_ENABLE_MASK) {
 446                                 alrm->enabled = 1;
 447                                 break;
 448                         }
 449                 }
 450                 break;
 451
 452         default:
 453                 return -EINVAL;
 454         }
 455
 456         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
 457                 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
 458                 alrm->time.tm_mday, alrm->time.tm_hour,
 459                 alrm->time.tm_min, alrm->time.tm_sec,
 460                 alrm->time.tm_wday);
 461
 462         ret = s5m_check_peding_alarm_interrupt(info, alrm);
 463
 464         return 0;
 465 }
 466
 467 static int s5m_rtc_stop_alarm(struct s5m_rtc_info *info)
 468 {
 469         u8 data[info->regs->regs_count];
 470         int ret, i;
 471         struct rtc_time tm;
 472
 473         ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data,
 474                         info->regs->regs_count);
 475         if (ret < 0)
 476                 return ret;
 477
 478         s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
 479         dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
 480                 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
 481                 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
 482
 483         switch (info->device_type) {
 484         case S5M8763X:
 485                 ret = regmap_write(info->regmap, S5M_ALARM0_CONF, 0);
 486                 break;
 487
 488         case S5M8767X:
 489         case S2MPS15X:
 490         case S2MPS14X:
 491         case S2MPS13X:
 492                 for (i = 0; i < info->regs->regs_count; i++)
 493                         data[i] &= ~ALARM_ENABLE_MASK;
 494
 495                 ret = regmap_raw_write(info->regmap, info->regs->alarm0, data,
 496                                 info->regs->regs_count);
 497                 if (ret < 0)
 498                         return ret;
 499
 500                 ret = s5m8767_rtc_set_alarm_reg(info);
 501
 502                 break;
 503
 504         default:
 505                 return -EINVAL;
 506         }
 507
 508         return ret;
 509 }
 510
 511 static int s5m_rtc_start_alarm(struct s5m_rtc_info *info)
 512 {
 513         int ret;
 514         u8 data[info->regs->regs_count];
 515         u8 alarm0_conf;
 516         struct rtc_time tm;
 517
 518         ret = regmap_bulk_read(info->regmap, info->regs->alarm0, data,
 519                         info->regs->regs_count);
 520         if (ret < 0)
 521                 return ret;
 522
 523         s5m8767_data_to_tm(data, &tm, info->rtc_24hr_mode);
 524         dev_dbg(info->dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
 525                 1900 + tm.tm_year, 1 + tm.tm_mon, tm.tm_mday,
 526                 tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_wday);
 527
 528         switch (info->device_type) {
 529         case S5M8763X:
 530                 alarm0_conf = 0x77;
 531                 ret = regmap_write(info->regmap, S5M_ALARM0_CONF, alarm0_conf);
 532                 break;
 533
 534         case S5M8767X:
 535         case S2MPS15X:
 536         case S2MPS14X:
 537         case S2MPS13X:
 538                 data[RTC_SEC] |= ALARM_ENABLE_MASK;
 539                 data[RTC_MIN] |= ALARM_ENABLE_MASK;
 540                 data[RTC_HOUR] |= ALARM_ENABLE_MASK;
 541                 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
 542                 if (data[RTC_DATE] & 0x1f)
 543                         data[RTC_DATE] |= ALARM_ENABLE_MASK;
 544                 if (data[RTC_MONTH] & 0xf)
 545                         data[RTC_MONTH] |= ALARM_ENABLE_MASK;
 546                 if (data[RTC_YEAR1] & 0x7f)
 547                         data[RTC_YEAR1] |= ALARM_ENABLE_MASK;
 548
 549                 ret = regmap_raw_write(info->regmap, info->regs->alarm0, data,
 550                                 info->regs->regs_count);
 551                 if (ret < 0)
 552                         return ret;
 553                 ret = s5m8767_rtc_set_alarm_reg(info);
 554
 555                 break;
 556
 557         default:
 558                 return -EINVAL;
 559         }
 560
 561         return ret;
 562 }
 563
 564 static int s5m_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 565 {
 566         struct s5m_rtc_info *info = dev_get_drvdata(dev);
 567         u8 data[info->regs->regs_count];
 568         int ret;
 569
 570         switch (info->device_type) {
 571         case S5M8763X:
 572                 s5m8763_tm_to_data(&alrm->time, data);
 573                 break;
 574
 575         case S5M8767X:
 576         case S2MPS15X:
 577         case S2MPS14X:
 578         case S2MPS13X:
 579                 s5m8767_tm_to_data(&alrm->time, data);
 580                 break;
 581
 582         default:
 583                 return -EINVAL;
 584         }
 585
 586         dev_dbg(dev, "%s: %d/%d/%d %d:%d:%d(%d)\n", __func__,
 587                 1900 + alrm->time.tm_year, 1 + alrm->time.tm_mon,
 588                 alrm->time.tm_mday, alrm->time.tm_hour, alrm->time.tm_min,
 589                 alrm->time.tm_sec, alrm->time.tm_wday);
 590
 591         ret = s5m_rtc_stop_alarm(info);
 592         if (ret < 0)
 593                 return ret;
 594
 595         ret = regmap_raw_write(info->regmap, info->regs->alarm0, data,
 596                         info->regs->regs_count);
 597         if (ret < 0)
 598                 return ret;
 599
 600         ret = s5m8767_rtc_set_alarm_reg(info);
 601         if (ret < 0)
 602                 return ret;
 603
 604         if (alrm->enabled)
 605                 ret = s5m_rtc_start_alarm(info);
 606
 607         return ret;
 608 }
 609
 610 static int s5m_rtc_alarm_irq_enable(struct device *dev,
 611                                     unsigned int enabled)
 612 {
 613         struct s5m_rtc_info *info = dev_get_drvdata(dev);
 614
 615         if (enabled)
 616                 return s5m_rtc_start_alarm(info);
 617         else
 618                 return s5m_rtc_stop_alarm(info);
 619 }
 620
 621 static irqreturn_t s5m_rtc_alarm_irq(int irq, void *data)
 622 {
 623         struct s5m_rtc_info *info = data;
 624
 625         rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
 626
 627         return IRQ_HANDLED;
 628 }
 629
 630 static const struct rtc_class_ops s5m_rtc_ops = {
 631         .read_time = s5m_rtc_read_time,
 632         .set_time = s5m_rtc_set_time,
 633         .read_alarm = s5m_rtc_read_alarm,
 634         .set_alarm = s5m_rtc_set_alarm,
 635         .alarm_irq_enable = s5m_rtc_alarm_irq_enable,
 636 };
 637
 638 static int s5m8767_rtc_init_reg(struct s5m_rtc_info *info)
 639 {
 640         u8 data[2];
 641         int ret;
 642
 643         switch (info->device_type) {
 644         case S5M8763X:
 645         case S5M8767X:
 646                 /* UDR update time. Default of 7.32 ms is too long. */
 647                 ret = regmap_update_bits(info->regmap, S5M_RTC_UDR_CON,
 648                                 S5M_RTC_UDR_T_MASK, S5M_RTC_UDR_T_450_US);
 649                 if (ret < 0)
 650                         dev_err(info->dev, "%s: fail to change UDR time: %d\n",
 651                                         __func__, ret);
 652
 653                 /* Set RTC control register : Binary mode, 24hour mode */
 654                 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
 655                 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
 656
 657                 ret = regmap_raw_write(info->regmap, S5M_ALARM0_CONF, data, 2);
 658                 break;
 659
 660         case S2MPS15X:
 661         case S2MPS14X:
 662         case S2MPS13X:
 663                 data[0] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
 664                 ret = regmap_write(info->regmap, info->regs->ctrl, data[0]);
 665                 if (ret < 0)
 666                         break;
 667
 668                 /*
 669                  * Should set WUDR & (RUDR or AUDR) bits to high after writing
 670                  * RTC_CTRL register like writing Alarm registers. We can't find
 671                  * the description from datasheet but vendor code does that
 672                  * really.
 673                  */
 674                 ret = s5m8767_rtc_set_alarm_reg(info);
 675                 break;
 676
 677         default:
 678                 return -EINVAL;
 679         }
 680
 681         info->rtc_24hr_mode = 1;
 682         if (ret < 0) {
 683                 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
 684                         __func__, ret);
 685                 return ret;
 686         }
 687
 688         return ret;
 689 }
 690
 691 static int s5m_rtc_probe(struct platform_device *pdev)
 692 {
 693         struct sec_pmic_dev *s5m87xx = dev_get_drvdata(pdev->dev.parent);
 694         struct sec_platform_data *pdata = s5m87xx->pdata;
 695         struct s5m_rtc_info *info;
 696         const struct regmap_config *regmap_cfg;
 697         int ret, alarm_irq;
 698
 699         if (!pdata) {
 700                 dev_err(pdev->dev.parent, "Platform data not supplied\n");
 701                 return -ENODEV;
 702         }
 703
 704         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
 705         if (!info)
 706                 return -ENOMEM;
 707
 708         switch (platform_get_device_id(pdev)->driver_data) {
 709         case S2MPS15X:
 710         case S2MPS14X:
 711         case S2MPS13X:
 712                 regmap_cfg = &s2mps14_rtc_regmap_config;
 713                 info->regs = &s2mps_rtc_regs;
 714                 alarm_irq = S2MPS14_IRQ_RTCA0;
 715                 break;
 716         case S5M8763X:
 717                 regmap_cfg = &s5m_rtc_regmap_config;
 718                 info->regs = &s5m_rtc_regs;
 719                 alarm_irq = S5M8763_IRQ_ALARM0;
 720                 break;
 721         case S5M8767X:
 722                 regmap_cfg = &s5m_rtc_regmap_config;
 723                 info->regs = &s5m_rtc_regs;
 724                 alarm_irq = S5M8767_IRQ_RTCA1;
 725                 break;
 726         default:
 727                 dev_err(&pdev->dev,
 728                                 "Device type %lu is not supported by RTC driver\n",
 729                                 platform_get_device_id(pdev)->driver_data);
 730                 return -ENODEV;
 731         }
 732
 733         info->i2c = i2c_new_dummy(s5m87xx->i2c->adapter, RTC_I2C_ADDR);
 734         if (!info->i2c) {
 735                 dev_err(&pdev->dev, "Failed to allocate I2C for RTC\n");
 736                 return -ENODEV;
 737         }
 738
 739         info->regmap = devm_regmap_init_i2c(info->i2c, regmap_cfg);
 740         if (IS_ERR(info->regmap)) {
 741                 ret = PTR_ERR(info->regmap);
 742                 dev_err(&pdev->dev, "Failed to allocate RTC register map: %d\n",
 743                                 ret);
 744                 goto err;
 745         }
 746
 747         info->dev = &pdev->dev;
 748         info->s5m87xx = s5m87xx;
 749         info->device_type = platform_get_device_id(pdev)->driver_data;
 750
 751         if (s5m87xx->irq_data) {
 752                 info->irq = regmap_irq_get_virq(s5m87xx->irq_data, alarm_irq);
 753                 if (info->irq <= 0) {
 754                         ret = -EINVAL;
 755                         dev_err(&pdev->dev, "Failed to get virtual IRQ %d\n",
 756                                 alarm_irq);
 757                         goto err;
 758                 }
 759         }
 760
 761         platform_set_drvdata(pdev, info);
 762
 763         ret = s5m8767_rtc_init_reg(info);
 764
 765         device_init_wakeup(&pdev->dev, 1);
 766
 767         info->rtc_dev = devm_rtc_device_register(&pdev->dev, "s5m-rtc",
 768                                                  &s5m_rtc_ops, THIS_MODULE);
 769
 770         if (IS_ERR(info->rtc_dev)) {
 771                 ret = PTR_ERR(info->rtc_dev);
 772                 goto err;
 773         }
 774
 775         if (!info->irq) {
 776                 dev_info(&pdev->dev, "Alarm IRQ not available\n");
 777                 return 0;
 778         }
 779
 780         ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL,
 781                                         s5m_rtc_alarm_irq, 0, "rtc-alarm0",
 782                                         info);
 783         if (ret < 0) {
 784                 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
 785                         info->irq, ret);
 786                 goto err;
 787         }
 788
 789         return 0;
 790
 791 err:
 792         i2c_unregister_device(info->i2c);
 793
 794         return ret;
 795 }
 796
 797 static int s5m_rtc_remove(struct platform_device *pdev)
 798 {
 799         struct s5m_rtc_info *info = platform_get_drvdata(pdev);
 800
 801         i2c_unregister_device(info->i2c);
 802
 803         return 0;
 804 }
 805
 806 #ifdef CONFIG_PM_SLEEP
 807 static int s5m_rtc_resume(struct device *dev)
 808 {
 809         struct s5m_rtc_info *info = dev_get_drvdata(dev);
 810         int ret = 0;
 811
 812         if (info->irq && device_may_wakeup(dev))
 813                 ret = disable_irq_wake(info->irq);
 814
 815         return ret;
 816 }
 817
 818 static int s5m_rtc_suspend(struct device *dev)
 819 {
 820         struct s5m_rtc_info *info = dev_get_drvdata(dev);
 821         int ret = 0;
 822
 823         if (info->irq && device_may_wakeup(dev))
 824                 ret = enable_irq_wake(info->irq);
 825
 826         return ret;
 827 }
 828 #endif /* CONFIG_PM_SLEEP */
 829
 830 static SIMPLE_DEV_PM_OPS(s5m_rtc_pm_ops, s5m_rtc_suspend, s5m_rtc_resume);
 831
 832 static const struct platform_device_id s5m_rtc_id[] = {
 833         { "s5m-rtc",            S5M8767X },
 834         { "s2mps13-rtc",        S2MPS13X },
 835         { "s2mps14-rtc",        S2MPS14X },
 836         { "s2mps15-rtc",        S2MPS15X },
 837         { },
 838 };
 839 MODULE_DEVICE_TABLE(platform, s5m_rtc_id);
 840
 841 static struct platform_driver s5m_rtc_driver = {
 842         .driver         = {
 843                 .name   = "s5m-rtc",
 844                 .pm     = &s5m_rtc_pm_ops,
 845         },
 846         .probe          = s5m_rtc_probe,
 847         .remove         = s5m_rtc_remove,
 848         .id_table       = s5m_rtc_id,
 849 };
 850
 851 module_platform_driver(s5m_rtc_driver);
 852
 853 /* Module information */
 854 MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
 855 MODULE_DESCRIPTION("Samsung S5M/S2MPS14 RTC driver");
 856 MODULE_LICENSE("GPL");
 857 MODULE_ALIAS("platform:s5m-rtc");