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