drivers/rtc/rtc-max77686.c

   1 /*
   2  * RTC driver for Maxim MAX77686 and MAX77802
   3  *
   4  * Copyright (C) 2012 Samsung Electronics Co.Ltd
   5  *
   6  *  based on rtc-max8997.c
   7  *
   8  *  This program is free software; you can redistribute  it and/or modify it
   9  *  under  the terms of  the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the  License, or (at your
  11  *  option) any later version.
  12  *
  13  */
  14
  15 #include <linux/slab.h>
  16 #include <linux/rtc.h>
  17 #include <linux/delay.h>
  18 #include <linux/mutex.h>
  19 #include <linux/module.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/mfd/max77686-private.h>
  22 #include <linux/irqdomain.h>
  23 #include <linux/regmap.h>
  24
  25 /* RTC Control Register */
  26 #define BCD_EN_SHIFT                    0
  27 #define BCD_EN_MASK                     (1 << BCD_EN_SHIFT)
  28 #define MODEL24_SHIFT                   1
  29 #define MODEL24_MASK                    (1 << MODEL24_SHIFT)
  30 /* RTC Update Register1 */
  31 #define RTC_UDR_SHIFT                   0
  32 #define RTC_UDR_MASK                    (1 << RTC_UDR_SHIFT)
  33 #define RTC_RBUDR_SHIFT                 4
  34 #define RTC_RBUDR_MASK                  (1 << RTC_RBUDR_SHIFT)
  35 /* RTC Hour register */
  36 #define HOUR_PM_SHIFT                   6
  37 #define HOUR_PM_MASK                    (1 << HOUR_PM_SHIFT)
  38 /* RTC Alarm Enable */
  39 #define ALARM_ENABLE_SHIFT              7
  40 #define ALARM_ENABLE_MASK               (1 << ALARM_ENABLE_SHIFT)
  41
  42 #define REG_RTC_NONE                    0xdeadbeef
  43
  44 /*
  45  * MAX77802 has separate register (RTCAE1) for alarm enable instead
  46  * using 1 bit from registers RTC{SEC,MIN,HOUR,DAY,MONTH,YEAR,DATE}
  47  * as in done in MAX77686.
  48  */
  49 #define MAX77802_ALARM_ENABLE_VALUE     0x77
  50
  51 enum {
  52         RTC_SEC = 0,
  53         RTC_MIN,
  54         RTC_HOUR,
  55         RTC_WEEKDAY,
  56         RTC_MONTH,
  57         RTC_YEAR,
  58         RTC_DATE,
  59         RTC_NR_TIME
  60 };
  61
  62 struct max77686_rtc_driver_data {
  63         /* Minimum usecs needed for a RTC update */
  64         unsigned long           delay;
  65         /* Mask used to read RTC registers value */
  66         u8                      mask;
  67         /* Registers offset to I2C addresses map */
  68         const unsigned int      *map;
  69         /* Has a separate alarm enable register? */
  70         bool                    alarm_enable_reg;
  71         /* Has a separate I2C regmap for the RTC? */
  72         bool                    separate_i2c_addr;
  73 };
  74
  75 struct max77686_rtc_info {
  76         struct device           *dev;
  77         struct max77686_dev     *max77686;
  78         struct i2c_client       *rtc;
  79         struct rtc_device       *rtc_dev;
  80         struct mutex            lock;
  81
  82         struct regmap           *regmap;
  83
  84         const struct max77686_rtc_driver_data *drv_data;
  85
  86         int virq;
  87         int rtc_24hr_mode;
  88 };
  89
  90 enum MAX77686_RTC_OP {
  91         MAX77686_RTC_WRITE,
  92         MAX77686_RTC_READ,
  93 };
  94
  95 /* These are not registers but just offsets that are mapped to addresses */
  96 enum max77686_rtc_reg_offset {
  97         REG_RTC_CONTROLM = 0,
  98         REG_RTC_CONTROL,
  99         REG_RTC_UPDATE0,
 100         REG_WTSR_SMPL_CNTL,
 101         REG_RTC_SEC,
 102         REG_RTC_MIN,
 103         REG_RTC_HOUR,
 104         REG_RTC_WEEKDAY,
 105         REG_RTC_MONTH,
 106         REG_RTC_YEAR,
 107         REG_RTC_DATE,
 108         REG_ALARM1_SEC,
 109         REG_ALARM1_MIN,
 110         REG_ALARM1_HOUR,
 111         REG_ALARM1_WEEKDAY,
 112         REG_ALARM1_MONTH,
 113         REG_ALARM1_YEAR,
 114         REG_ALARM1_DATE,
 115         REG_ALARM2_SEC,
 116         REG_ALARM2_MIN,
 117         REG_ALARM2_HOUR,
 118         REG_ALARM2_WEEKDAY,
 119         REG_ALARM2_MONTH,
 120         REG_ALARM2_YEAR,
 121         REG_ALARM2_DATE,
 122         REG_RTC_AE1,
 123         REG_RTC_END,
 124 };
 125
 126 /* Maps RTC registers offset to the MAX77686 register addresses */
 127 static const unsigned int max77686_map[REG_RTC_END] = {
 128         [REG_RTC_CONTROLM]   = MAX77686_RTC_CONTROLM,
 129         [REG_RTC_CONTROL]    = MAX77686_RTC_CONTROL,
 130         [REG_RTC_UPDATE0]    = MAX77686_RTC_UPDATE0,
 131         [REG_WTSR_SMPL_CNTL] = MAX77686_WTSR_SMPL_CNTL,
 132         [REG_RTC_SEC]        = MAX77686_RTC_SEC,
 133         [REG_RTC_MIN]        = MAX77686_RTC_MIN,
 134         [REG_RTC_HOUR]       = MAX77686_RTC_HOUR,
 135         [REG_RTC_WEEKDAY]    = MAX77686_RTC_WEEKDAY,
 136         [REG_RTC_MONTH]      = MAX77686_RTC_MONTH,
 137         [REG_RTC_YEAR]       = MAX77686_RTC_YEAR,
 138         [REG_RTC_DATE]       = MAX77686_RTC_DATE,
 139         [REG_ALARM1_SEC]     = MAX77686_ALARM1_SEC,
 140         [REG_ALARM1_MIN]     = MAX77686_ALARM1_MIN,
 141         [REG_ALARM1_HOUR]    = MAX77686_ALARM1_HOUR,
 142         [REG_ALARM1_WEEKDAY] = MAX77686_ALARM1_WEEKDAY,
 143         [REG_ALARM1_MONTH]   = MAX77686_ALARM1_MONTH,
 144         [REG_ALARM1_YEAR]    = MAX77686_ALARM1_YEAR,
 145         [REG_ALARM1_DATE]    = MAX77686_ALARM1_DATE,
 146         [REG_ALARM2_SEC]     = MAX77686_ALARM2_SEC,
 147         [REG_ALARM2_MIN]     = MAX77686_ALARM2_MIN,
 148         [REG_ALARM2_HOUR]    = MAX77686_ALARM2_HOUR,
 149         [REG_ALARM2_WEEKDAY] = MAX77686_ALARM2_WEEKDAY,
 150         [REG_ALARM2_MONTH]   = MAX77686_ALARM2_MONTH,
 151         [REG_ALARM2_YEAR]    = MAX77686_ALARM2_YEAR,
 152         [REG_ALARM2_DATE]    = MAX77686_ALARM2_DATE,
 153         [REG_RTC_AE1]        = REG_RTC_NONE,
 154 };
 155
 156 static const struct max77686_rtc_driver_data max77686_drv_data = {
 157         .delay = 16000,
 158         .mask  = 0x7f,
 159         .map   = max77686_map,
 160         .alarm_enable_reg  = false,
 161         .separate_i2c_addr = true,
 162 };
 163
 164 static const unsigned int max77802_map[REG_RTC_END] = {
 165         [REG_RTC_CONTROLM]   = MAX77802_RTC_CONTROLM,
 166         [REG_RTC_CONTROL]    = MAX77802_RTC_CONTROL,
 167         [REG_RTC_UPDATE0]    = MAX77802_RTC_UPDATE0,
 168         [REG_WTSR_SMPL_CNTL] = MAX77802_WTSR_SMPL_CNTL,
 169         [REG_RTC_SEC]        = MAX77802_RTC_SEC,
 170         [REG_RTC_MIN]        = MAX77802_RTC_MIN,
 171         [REG_RTC_HOUR]       = MAX77802_RTC_HOUR,
 172         [REG_RTC_WEEKDAY]    = MAX77802_RTC_WEEKDAY,
 173         [REG_RTC_MONTH]      = MAX77802_RTC_MONTH,
 174         [REG_RTC_YEAR]       = MAX77802_RTC_YEAR,
 175         [REG_RTC_DATE]       = MAX77802_RTC_DATE,
 176         [REG_ALARM1_SEC]     = MAX77802_ALARM1_SEC,
 177         [REG_ALARM1_MIN]     = MAX77802_ALARM1_MIN,
 178         [REG_ALARM1_HOUR]    = MAX77802_ALARM1_HOUR,
 179         [REG_ALARM1_WEEKDAY] = MAX77802_ALARM1_WEEKDAY,
 180         [REG_ALARM1_MONTH]   = MAX77802_ALARM1_MONTH,
 181         [REG_ALARM1_YEAR]    = MAX77802_ALARM1_YEAR,
 182         [REG_ALARM1_DATE]    = MAX77802_ALARM1_DATE,
 183         [REG_ALARM2_SEC]     = MAX77802_ALARM2_SEC,
 184         [REG_ALARM2_MIN]     = MAX77802_ALARM2_MIN,
 185         [REG_ALARM2_HOUR]    = MAX77802_ALARM2_HOUR,
 186         [REG_ALARM2_WEEKDAY] = MAX77802_ALARM2_WEEKDAY,
 187         [REG_ALARM2_MONTH]   = MAX77802_ALARM2_MONTH,
 188         [REG_ALARM2_YEAR]    = MAX77802_ALARM2_YEAR,
 189         [REG_ALARM2_DATE]    = MAX77802_ALARM2_DATE,
 190         [REG_RTC_AE1]        = MAX77802_RTC_AE1,
 191 };
 192
 193 static const struct max77686_rtc_driver_data max77802_drv_data = {
 194         .delay = 200,
 195         .mask  = 0xff,
 196         .map   = max77802_map,
 197         .alarm_enable_reg  = true,
 198         .separate_i2c_addr = false,
 199 };
 200
 201 static void max77686_rtc_data_to_tm(u8 *data, struct rtc_time *tm,
 202                                     struct max77686_rtc_info *info)
 203 {
 204         u8 mask = info->drv_data->mask;
 205
 206         tm->tm_sec = data[RTC_SEC] & mask;
 207         tm->tm_min = data[RTC_MIN] & mask;
 208         if (info->rtc_24hr_mode)
 209                 tm->tm_hour = data[RTC_HOUR] & 0x1f;
 210         else {
 211                 tm->tm_hour = data[RTC_HOUR] & 0x0f;
 212                 if (data[RTC_HOUR] & HOUR_PM_MASK)
 213                         tm->tm_hour += 12;
 214         }
 215
 216         /* Only a single bit is set in data[], so fls() would be equivalent */
 217         tm->tm_wday = ffs(data[RTC_WEEKDAY] & mask) - 1;
 218         tm->tm_mday = data[RTC_DATE] & 0x1f;
 219         tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
 220         tm->tm_year = data[RTC_YEAR] & mask;
 221         tm->tm_yday = 0;
 222         tm->tm_isdst = 0;
 223
 224         /*
 225          * MAX77686 uses 1 bit from sec/min/hour/etc RTC registers and the
 226          * year values are just 0..99 so add 100 to support up to 2099.
 227          */
 228         if (!info->drv_data->alarm_enable_reg)
 229                 tm->tm_year += 100;
 230 }
 231
 232 static int max77686_rtc_tm_to_data(struct rtc_time *tm, u8 *data,
 233                                    struct max77686_rtc_info *info)
 234 {
 235         data[RTC_SEC] = tm->tm_sec;
 236         data[RTC_MIN] = tm->tm_min;
 237         data[RTC_HOUR] = tm->tm_hour;
 238         data[RTC_WEEKDAY] = 1 << tm->tm_wday;
 239         data[RTC_DATE] = tm->tm_mday;
 240         data[RTC_MONTH] = tm->tm_mon + 1;
 241
 242         if (info->drv_data->alarm_enable_reg) {
 243                 data[RTC_YEAR] = tm->tm_year;
 244                 return 0;
 245         }
 246
 247         data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
 248
 249         if (tm->tm_year < 100) {
 250                 dev_err(info->dev, "RTC cannot handle the year %d.\n",
 251                         1900 + tm->tm_year);
 252                 return -EINVAL;
 253         }
 254
 255         return 0;
 256 }
 257
 258 static int max77686_rtc_update(struct max77686_rtc_info *info,
 259         enum MAX77686_RTC_OP op)
 260 {
 261         int ret;
 262         unsigned int data;
 263         unsigned long delay = info->drv_data->delay;
 264
 265         if (op == MAX77686_RTC_WRITE)
 266                 data = 1 << RTC_UDR_SHIFT;
 267         else
 268                 data = 1 << RTC_RBUDR_SHIFT;
 269
 270         ret = regmap_update_bits(info->max77686->rtc_regmap,
 271                                  info->drv_data->map[REG_RTC_UPDATE0],
 272                                  data, data);
 273         if (ret < 0)
 274                 dev_err(info->dev, "Fail to write update reg(ret=%d, data=0x%x)\n",
 275                         ret, data);
 276         else {
 277                 /* Minimum delay required before RTC update. */
 278                 usleep_range(delay, delay * 2);
 279         }
 280
 281         return ret;
 282 }
 283
 284 static int max77686_rtc_read_time(struct device *dev, struct rtc_time *tm)
 285 {
 286         struct max77686_rtc_info *info = dev_get_drvdata(dev);
 287         u8 data[RTC_NR_TIME];
 288         int ret;
 289
 290         mutex_lock(&info->lock);
 291
 292         ret = max77686_rtc_update(info, MAX77686_RTC_READ);
 293         if (ret < 0)
 294                 goto out;
 295
 296         ret = regmap_bulk_read(info->max77686->rtc_regmap,
 297                                info->drv_data->map[REG_RTC_SEC],
 298                                data, ARRAY_SIZE(data));
 299         if (ret < 0) {
 300                 dev_err(info->dev, "Fail to read time reg(%d)\n", ret);
 301                 goto out;
 302         }
 303
 304         max77686_rtc_data_to_tm(data, tm, info);
 305
 306         ret = rtc_valid_tm(tm);
 307
 308 out:
 309         mutex_unlock(&info->lock);
 310         return ret;
 311 }
 312
 313 static int max77686_rtc_set_time(struct device *dev, struct rtc_time *tm)
 314 {
 315         struct max77686_rtc_info *info = dev_get_drvdata(dev);
 316         u8 data[RTC_NR_TIME];
 317         int ret;
 318
 319         ret = max77686_rtc_tm_to_data(tm, data, info);
 320         if (ret < 0)
 321                 return ret;
 322
 323         mutex_lock(&info->lock);
 324
 325         ret = regmap_bulk_write(info->max77686->rtc_regmap,
 326                                 info->drv_data->map[REG_RTC_SEC],
 327                                 data, ARRAY_SIZE(data));
 328         if (ret < 0) {
 329                 dev_err(info->dev, "Fail to write time reg(%d)\n", ret);
 330                 goto out;
 331         }
 332
 333         ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
 334
 335 out:
 336         mutex_unlock(&info->lock);
 337         return ret;
 338 }
 339
 340 static int max77686_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 341 {
 342         struct max77686_rtc_info *info = dev_get_drvdata(dev);
 343         u8 data[RTC_NR_TIME];
 344         unsigned int val;
 345         const unsigned int *map = info->drv_data->map;
 346         int i, ret;
 347
 348         mutex_lock(&info->lock);
 349
 350         ret = max77686_rtc_update(info, MAX77686_RTC_READ);
 351         if (ret < 0)
 352                 goto out;
 353
 354         ret = regmap_bulk_read(info->max77686->rtc_regmap,
 355                                map[REG_ALARM1_SEC], data, ARRAY_SIZE(data));
 356         if (ret < 0) {
 357                 dev_err(info->dev, "Fail to read alarm reg(%d)\n", ret);
 358                 goto out;
 359         }
 360
 361         max77686_rtc_data_to_tm(data, &alrm->time, info);
 362
 363         alrm->enabled = 0;
 364
 365         if (info->drv_data->alarm_enable_reg) {
 366                 if (map[REG_RTC_AE1] == REG_RTC_NONE) {
 367                         ret = -EINVAL;
 368                         dev_err(info->dev,
 369                                 "alarm enable register not set(%d)\n", ret);
 370                         goto out;
 371                 }
 372
 373                 ret = regmap_read(info->max77686->regmap,
 374                                   map[REG_RTC_AE1], &val);
 375                 if (ret < 0) {
 376                         dev_err(info->dev,
 377                                 "fail to read alarm enable(%d)\n", ret);
 378                         goto out;
 379                 }
 380
 381                 if (val)
 382                         alrm->enabled = 1;
 383         } else {
 384                 for (i = 0; i < ARRAY_SIZE(data); i++) {
 385                         if (data[i] & ALARM_ENABLE_MASK) {
 386                                 alrm->enabled = 1;
 387                                 break;
 388                         }
 389                 }
 390         }
 391
 392         alrm->pending = 0;
 393         ret = regmap_read(info->max77686->regmap, MAX77686_REG_STATUS2, &val);
 394         if (ret < 0) {
 395                 dev_err(info->dev, "Fail to read status2 reg(%d)\n", ret);
 396                 goto out;
 397         }
 398
 399         if (val & (1 << 4)) /* RTCA1 */
 400                 alrm->pending = 1;
 401
 402 out:
 403         mutex_unlock(&info->lock);
 404         return ret;
 405 }
 406
 407 static int max77686_rtc_stop_alarm(struct max77686_rtc_info *info)
 408 {
 409         u8 data[RTC_NR_TIME];
 410         int ret, i;
 411         struct rtc_time tm;
 412         const unsigned int *map = info->drv_data->map;
 413
 414         if (!mutex_is_locked(&info->lock))
 415                 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
 416
 417         ret = max77686_rtc_update(info, MAX77686_RTC_READ);
 418         if (ret < 0)
 419                 goto out;
 420
 421         if (info->drv_data->alarm_enable_reg) {
 422                 if (map[REG_RTC_AE1] == REG_RTC_NONE) {
 423                         ret = -EINVAL;
 424                         dev_err(info->dev,
 425                                 "alarm enable register not set(%d)\n", ret);
 426                         goto out;
 427                 }
 428
 429                 ret = regmap_write(info->max77686->regmap, map[REG_RTC_AE1], 0);
 430         } else {
 431                 ret = regmap_bulk_read(info->max77686->rtc_regmap,
 432                                        map[REG_ALARM1_SEC], data,
 433                                        ARRAY_SIZE(data));
 434                 if (ret < 0) {
 435                         dev_err(info->dev, "Fail to read alarm reg(%d)\n", ret);
 436                         goto out;
 437                 }
 438
 439                 max77686_rtc_data_to_tm(data, &tm, info);
 440
 441                 for (i = 0; i < ARRAY_SIZE(data); i++)
 442                         data[i] &= ~ALARM_ENABLE_MASK;
 443
 444                 ret = regmap_bulk_write(info->max77686->rtc_regmap,
 445                                         map[REG_ALARM1_SEC], data,
 446                                         ARRAY_SIZE(data));
 447         }
 448
 449         if (ret < 0) {
 450                 dev_err(info->dev, "Fail to write alarm reg(%d)\n", ret);
 451                 goto out;
 452         }
 453
 454         ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
 455 out:
 456         return ret;
 457 }
 458
 459 static int max77686_rtc_start_alarm(struct max77686_rtc_info *info)
 460 {
 461         u8 data[RTC_NR_TIME];
 462         int ret;
 463         struct rtc_time tm;
 464         const unsigned int *map = info->drv_data->map;
 465
 466         if (!mutex_is_locked(&info->lock))
 467                 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
 468
 469         ret = max77686_rtc_update(info, MAX77686_RTC_READ);
 470         if (ret < 0)
 471                 goto out;
 472
 473         if (info->drv_data->alarm_enable_reg) {
 474                 ret = regmap_write(info->max77686->regmap, map[REG_RTC_AE1],
 475                                    MAX77802_ALARM_ENABLE_VALUE);
 476         } else {
 477                 ret = regmap_bulk_read(info->max77686->rtc_regmap,
 478                                        map[REG_ALARM1_SEC], data,
 479                                        ARRAY_SIZE(data));
 480                 if (ret < 0) {
 481                         dev_err(info->dev, "Fail to read alarm reg(%d)\n", ret);
 482                         goto out;
 483                 }
 484
 485                 max77686_rtc_data_to_tm(data, &tm, info);
 486
 487                 data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT);
 488                 data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT);
 489                 data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT);
 490                 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
 491                 if (data[RTC_MONTH] & 0xf)
 492                         data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT);
 493                 if (data[RTC_YEAR] & info->drv_data->mask)
 494                         data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT);
 495                 if (data[RTC_DATE] & 0x1f)
 496                         data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT);
 497
 498                 ret = regmap_bulk_write(info->max77686->rtc_regmap,
 499                                         map[REG_ALARM1_SEC], data,
 500                                         ARRAY_SIZE(data));
 501         }
 502
 503         if (ret < 0) {
 504                 dev_err(info->dev, "Fail to write alarm reg(%d)\n", ret);
 505                 goto out;
 506         }
 507
 508         ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
 509 out:
 510         return ret;
 511 }
 512
 513 static int max77686_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 514 {
 515         struct max77686_rtc_info *info = dev_get_drvdata(dev);
 516         u8 data[RTC_NR_TIME];
 517         int ret;
 518
 519         ret = max77686_rtc_tm_to_data(&alrm->time, data, info);
 520         if (ret < 0)
 521                 return ret;
 522
 523         mutex_lock(&info->lock);
 524
 525         ret = max77686_rtc_stop_alarm(info);
 526         if (ret < 0)
 527                 goto out;
 528
 529         ret = regmap_bulk_write(info->max77686->rtc_regmap,
 530                                 info->drv_data->map[REG_ALARM1_SEC],
 531                                 data, ARRAY_SIZE(data));
 532
 533         if (ret < 0) {
 534                 dev_err(info->dev, "Fail to write alarm reg(%d)\n", ret);
 535                 goto out;
 536         }
 537
 538         ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
 539         if (ret < 0)
 540                 goto out;
 541
 542         if (alrm->enabled)
 543                 ret = max77686_rtc_start_alarm(info);
 544 out:
 545         mutex_unlock(&info->lock);
 546         return ret;
 547 }
 548
 549 static int max77686_rtc_alarm_irq_enable(struct device *dev,
 550                                         unsigned int enabled)
 551 {
 552         struct max77686_rtc_info *info = dev_get_drvdata(dev);
 553         int ret;
 554
 555         mutex_lock(&info->lock);
 556         if (enabled)
 557                 ret = max77686_rtc_start_alarm(info);
 558         else
 559                 ret = max77686_rtc_stop_alarm(info);
 560         mutex_unlock(&info->lock);
 561
 562         return ret;
 563 }
 564
 565 static irqreturn_t max77686_rtc_alarm_irq(int irq, void *data)
 566 {
 567         struct max77686_rtc_info *info = data;
 568
 569         dev_dbg(info->dev, "RTC alarm IRQ: %d\n", irq);
 570
 571         rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
 572
 573         return IRQ_HANDLED;
 574 }
 575
 576 static const struct rtc_class_ops max77686_rtc_ops = {
 577         .read_time = max77686_rtc_read_time,
 578         .set_time = max77686_rtc_set_time,
 579         .read_alarm = max77686_rtc_read_alarm,
 580         .set_alarm = max77686_rtc_set_alarm,
 581         .alarm_irq_enable = max77686_rtc_alarm_irq_enable,
 582 };
 583
 584 static int max77686_rtc_init_reg(struct max77686_rtc_info *info)
 585 {
 586         u8 data[2];
 587         int ret;
 588
 589         /* Set RTC control register : Binary mode, 24hour mdoe */
 590         data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
 591         data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
 592
 593         info->rtc_24hr_mode = 1;
 594
 595         ret = regmap_bulk_write(info->max77686->rtc_regmap,
 596                                 info->drv_data->map[REG_RTC_CONTROLM],
 597                                 data, ARRAY_SIZE(data));
 598         if (ret < 0) {
 599                 dev_err(info->dev, "Fail to write controlm reg(%d)\n", ret);
 600                 return ret;
 601         }
 602
 603         ret = max77686_rtc_update(info, MAX77686_RTC_WRITE);
 604         return ret;
 605 }
 606
 607 static int max77686_rtc_probe(struct platform_device *pdev)
 608 {
 609         struct max77686_dev *max77686 = dev_get_drvdata(pdev->dev.parent);
 610         struct max77686_rtc_info *info;
 611         const struct platform_device_id *id = platform_get_device_id(pdev);
 612         int ret;
 613
 614         info = devm_kzalloc(&pdev->dev, sizeof(struct max77686_rtc_info),
 615                                 GFP_KERNEL);
 616         if (!info)
 617                 return -ENOMEM;
 618
 619         mutex_init(&info->lock);
 620         info->dev = &pdev->dev;
 621         info->max77686 = max77686;
 622         info->rtc = max77686->rtc;
 623         info->drv_data = (const struct max77686_rtc_driver_data *)
 624                 id->driver_data;
 625
 626         if (!info->drv_data->separate_i2c_addr)
 627                 info->max77686->rtc_regmap = info->max77686->regmap;
 628
 629         platform_set_drvdata(pdev, info);
 630
 631         ret = max77686_rtc_init_reg(info);
 632
 633         if (ret < 0) {
 634                 dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
 635                 goto err_rtc;
 636         }
 637
 638         device_init_wakeup(&pdev->dev, 1);
 639
 640         info->rtc_dev = devm_rtc_device_register(&pdev->dev, id->name,
 641                                         &max77686_rtc_ops, THIS_MODULE);
 642
 643         if (IS_ERR(info->rtc_dev)) {
 644                 ret = PTR_ERR(info->rtc_dev);
 645                 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
 646                 if (ret == 0)
 647                         ret = -EINVAL;
 648                 goto err_rtc;
 649         }
 650
 651         if (!max77686->rtc_irq_data) {
 652                 ret = -EINVAL;
 653                 dev_err(&pdev->dev, "No RTC regmap IRQ chip\n");
 654                 goto err_rtc;
 655         }
 656
 657         info->virq = regmap_irq_get_virq(max77686->rtc_irq_data,
 658                                          MAX77686_RTCIRQ_RTCA1);
 659         if (info->virq <= 0) {
 660                 ret = -ENXIO;
 661                 goto err_rtc;
 662         }
 663
 664         ret = devm_request_threaded_irq(&pdev->dev, info->virq, NULL,
 665                                 max77686_rtc_alarm_irq, 0, "rtc-alarm1", info);
 666         if (ret < 0)
 667                 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
 668                         info->virq, ret);
 669
 670 err_rtc:
 671         return ret;
 672 }
 673
 674 #ifdef CONFIG_PM_SLEEP
 675 static int max77686_rtc_suspend(struct device *dev)
 676 {
 677         if (device_may_wakeup(dev)) {
 678                 struct max77686_rtc_info *info = dev_get_drvdata(dev);
 679
 680                 return enable_irq_wake(info->virq);
 681         }
 682
 683         return 0;
 684 }
 685
 686 static int max77686_rtc_resume(struct device *dev)
 687 {
 688         if (device_may_wakeup(dev)) {
 689                 struct max77686_rtc_info *info = dev_get_drvdata(dev);
 690
 691                 return disable_irq_wake(info->virq);
 692         }
 693
 694         return 0;
 695 }
 696 #endif
 697
 698 static SIMPLE_DEV_PM_OPS(max77686_rtc_pm_ops,
 699                          max77686_rtc_suspend, max77686_rtc_resume);
 700
 701 static const struct platform_device_id rtc_id[] = {
 702         { "max77686-rtc", .driver_data = (kernel_ulong_t)&max77686_drv_data, },
 703         { "max77802-rtc", .driver_data = (kernel_ulong_t)&max77802_drv_data, },
 704         {},
 705 };
 706 MODULE_DEVICE_TABLE(platform, rtc_id);
 707
 708 static struct platform_driver max77686_rtc_driver = {
 709         .driver         = {
 710                 .name   = "max77686-rtc",
 711                 .pm     = &max77686_rtc_pm_ops,
 712         },
 713         .probe          = max77686_rtc_probe,
 714         .id_table       = rtc_id,
 715 };
 716
 717 module_platform_driver(max77686_rtc_driver);
 718
 719 MODULE_DESCRIPTION("Maxim MAX77686 RTC driver");
 720 MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
 721 MODULE_LICENSE("GPL");