drivers/rtc/rtc-max8997.c

   1 /*
   2  * RTC driver for Maxim MAX8997
   3  *
   4  * Copyright (C) 2013 Samsung Electronics Co.Ltd
   5  *
   6  *  based on rtc-max8998.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/max8997-private.h>
  22 #include <linux/irqdomain.h>
  23
  24 /* Module parameter for WTSR function control */
  25 static int wtsr_en = 1;
  26 module_param(wtsr_en, int, 0444);
  27 MODULE_PARM_DESC(wtsr_en, "Watchdog Timeout & Software Reset (default=on)");
  28 /* Module parameter for SMPL function control */
  29 static int smpl_en = 1;
  30 module_param(smpl_en, int, 0444);
  31 MODULE_PARM_DESC(smpl_en, "Sudden Momentary Power Loss (default=on)");
  32
  33 /* RTC Control Register */
  34 #define BCD_EN_SHIFT                    0
  35 #define BCD_EN_MASK                     (1 << BCD_EN_SHIFT)
  36 #define MODEL24_SHIFT                   1
  37 #define MODEL24_MASK                    (1 << MODEL24_SHIFT)
  38 /* RTC Update Register1 */
  39 #define RTC_UDR_SHIFT                   0
  40 #define RTC_UDR_MASK                    (1 << RTC_UDR_SHIFT)
  41 /* WTSR and SMPL Register */
  42 #define WTSRT_SHIFT                     0
  43 #define SMPLT_SHIFT                     2
  44 #define WTSR_EN_SHIFT                   6
  45 #define SMPL_EN_SHIFT                   7
  46 #define WTSRT_MASK                      (3 << WTSRT_SHIFT)
  47 #define SMPLT_MASK                      (3 << SMPLT_SHIFT)
  48 #define WTSR_EN_MASK                    (1 << WTSR_EN_SHIFT)
  49 #define SMPL_EN_MASK                    (1 << SMPL_EN_SHIFT)
  50 /* RTC Hour register */
  51 #define HOUR_PM_SHIFT                   6
  52 #define HOUR_PM_MASK                    (1 << HOUR_PM_SHIFT)
  53 /* RTC Alarm Enable */
  54 #define ALARM_ENABLE_SHIFT              7
  55 #define ALARM_ENABLE_MASK               (1 << ALARM_ENABLE_SHIFT)
  56
  57 enum {
  58         RTC_SEC = 0,
  59         RTC_MIN,
  60         RTC_HOUR,
  61         RTC_WEEKDAY,
  62         RTC_MONTH,
  63         RTC_YEAR,
  64         RTC_DATE,
  65         RTC_NR_TIME
  66 };
  67
  68 struct max8997_rtc_info {
  69         struct device           *dev;
  70         struct max8997_dev      *max8997;
  71         struct i2c_client       *rtc;
  72         struct rtc_device       *rtc_dev;
  73         struct mutex            lock;
  74         int virq;
  75         int rtc_24hr_mode;
  76 };
  77
  78 static void max8997_rtc_data_to_tm(u8 *data, struct rtc_time *tm,
  79                                    int rtc_24hr_mode)
  80 {
  81         tm->tm_sec = data[RTC_SEC] & 0x7f;
  82         tm->tm_min = data[RTC_MIN] & 0x7f;
  83         if (rtc_24hr_mode)
  84                 tm->tm_hour = data[RTC_HOUR] & 0x1f;
  85         else {
  86                 tm->tm_hour = data[RTC_HOUR] & 0x0f;
  87                 if (data[RTC_HOUR] & HOUR_PM_MASK)
  88                         tm->tm_hour += 12;
  89         }
  90
  91         tm->tm_wday = fls(data[RTC_WEEKDAY] & 0x7f) - 1;
  92         tm->tm_mday = data[RTC_DATE] & 0x1f;
  93         tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
  94         tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100;
  95         tm->tm_yday = 0;
  96         tm->tm_isdst = 0;
  97 }
  98
  99 static int max8997_rtc_tm_to_data(struct rtc_time *tm, u8 *data)
 100 {
 101         data[RTC_SEC] = tm->tm_sec;
 102         data[RTC_MIN] = tm->tm_min;
 103         data[RTC_HOUR] = tm->tm_hour;
 104         data[RTC_WEEKDAY] = 1 << tm->tm_wday;
 105         data[RTC_DATE] = tm->tm_mday;
 106         data[RTC_MONTH] = tm->tm_mon + 1;
 107         data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
 108
 109         if (tm->tm_year < 100) {
 110                 pr_warn("%s: MAX8997 RTC cannot handle the year %d."
 111                         "Assume it's 2000.\n", __func__, 1900 + tm->tm_year);
 112                 return -EINVAL;
 113         }
 114         return 0;
 115 }
 116
 117 static inline int max8997_rtc_set_update_reg(struct max8997_rtc_info *info)
 118 {
 119         int ret;
 120
 121         ret = max8997_write_reg(info->rtc, MAX8997_RTC_UPDATE1,
 122                                                 RTC_UDR_MASK);
 123         if (ret < 0)
 124                 dev_err(info->dev, "%s: fail to write update reg(%d)\n",
 125                                 __func__, ret);
 126         else {
 127                 /* Minimum 16ms delay required before RTC update.
 128                  * Otherwise, we may read and update based on out-of-date
 129                  * value */
 130                 msleep(20);
 131         }
 132
 133         return ret;
 134 }
 135
 136 static int max8997_rtc_read_time(struct device *dev, struct rtc_time *tm)
 137 {
 138         struct max8997_rtc_info *info = dev_get_drvdata(dev);
 139         u8 data[RTC_NR_TIME];
 140         int ret;
 141
 142         mutex_lock(&info->lock);
 143         ret = max8997_bulk_read(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
 144         mutex_unlock(&info->lock);
 145
 146         if (ret < 0) {
 147                 dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__,
 148                                 ret);
 149                 return ret;
 150         }
 151
 152         max8997_rtc_data_to_tm(data, tm, info->rtc_24hr_mode);
 153
 154         return rtc_valid_tm(tm);
 155 }
 156
 157 static int max8997_rtc_set_time(struct device *dev, struct rtc_time *tm)
 158 {
 159         struct max8997_rtc_info *info = dev_get_drvdata(dev);
 160         u8 data[RTC_NR_TIME];
 161         int ret;
 162
 163         ret = max8997_rtc_tm_to_data(tm, data);
 164         if (ret < 0)
 165                 return ret;
 166
 167         mutex_lock(&info->lock);
 168
 169         ret = max8997_bulk_write(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
 170         if (ret < 0) {
 171                 dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__,
 172                                 ret);
 173                 goto out;
 174         }
 175
 176         ret = max8997_rtc_set_update_reg(info);
 177 out:
 178         mutex_unlock(&info->lock);
 179         return ret;
 180 }
 181
 182 static int max8997_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 183 {
 184         struct max8997_rtc_info *info = dev_get_drvdata(dev);
 185         u8 data[RTC_NR_TIME];
 186         u8 val;
 187         int i, ret;
 188
 189         mutex_lock(&info->lock);
 190
 191         ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
 192                         data);
 193         if (ret < 0) {
 194                 dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n",
 195                                 __func__, __LINE__, ret);
 196                 goto out;
 197         }
 198
 199         max8997_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
 200
 201         alrm->enabled = 0;
 202         for (i = 0; i < RTC_NR_TIME; i++) {
 203                 if (data[i] & ALARM_ENABLE_MASK) {
 204                         alrm->enabled = 1;
 205                         break;
 206                 }
 207         }
 208
 209         alrm->pending = 0;
 210         ret = max8997_read_reg(info->max8997->i2c, MAX8997_REG_STATUS1, &val);
 211         if (ret < 0) {
 212                 dev_err(info->dev, "%s:%d fail to read status1 reg(%d)\n",
 213                                 __func__, __LINE__, ret);
 214                 goto out;
 215         }
 216
 217         if (val & (1 << 4)) /* RTCA1 */
 218                 alrm->pending = 1;
 219
 220 out:
 221         mutex_unlock(&info->lock);
 222         return 0;
 223 }
 224
 225 static int max8997_rtc_stop_alarm(struct max8997_rtc_info *info)
 226 {
 227         u8 data[RTC_NR_TIME];
 228         int ret, i;
 229
 230         if (!mutex_is_locked(&info->lock))
 231                 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
 232
 233         ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
 234                                 data);
 235         if (ret < 0) {
 236                 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
 237                                 __func__, ret);
 238                 goto out;
 239         }
 240
 241         for (i = 0; i < RTC_NR_TIME; i++)
 242                 data[i] &= ~ALARM_ENABLE_MASK;
 243
 244         ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
 245                                  data);
 246         if (ret < 0) {
 247                 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
 248                                 __func__, ret);
 249                 goto out;
 250         }
 251
 252         ret = max8997_rtc_set_update_reg(info);
 253 out:
 254         return ret;
 255 }
 256
 257 static int max8997_rtc_start_alarm(struct max8997_rtc_info *info)
 258 {
 259         u8 data[RTC_NR_TIME];
 260         int ret;
 261
 262         if (!mutex_is_locked(&info->lock))
 263                 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
 264
 265         ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
 266                                 data);
 267         if (ret < 0) {
 268                 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
 269                                 __func__, ret);
 270                 goto out;
 271         }
 272
 273         data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT);
 274         data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT);
 275         data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT);
 276         data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
 277         if (data[RTC_MONTH] & 0xf)
 278                 data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT);
 279         if (data[RTC_YEAR] & 0x7f)
 280                 data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT);
 281         if (data[RTC_DATE] & 0x1f)
 282                 data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT);
 283
 284         ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
 285                                  data);
 286         if (ret < 0) {
 287                 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
 288                                 __func__, ret);
 289                 goto out;
 290         }
 291
 292         ret = max8997_rtc_set_update_reg(info);
 293 out:
 294         return ret;
 295 }
 296 static int max8997_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 297 {
 298         struct max8997_rtc_info *info = dev_get_drvdata(dev);
 299         u8 data[RTC_NR_TIME];
 300         int ret;
 301
 302         ret = max8997_rtc_tm_to_data(&alrm->time, data);
 303         if (ret < 0)
 304                 return ret;
 305
 306         dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d\n", __func__,
 307                         data[RTC_YEAR] + 2000, data[RTC_MONTH], data[RTC_DATE],
 308                         data[RTC_HOUR], data[RTC_MIN], data[RTC_SEC]);
 309
 310         mutex_lock(&info->lock);
 311
 312         ret = max8997_rtc_stop_alarm(info);
 313         if (ret < 0)
 314                 goto out;
 315
 316         ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
 317                                 data);
 318         if (ret < 0) {
 319                 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
 320                                 __func__, ret);
 321                 goto out;
 322         }
 323
 324         ret = max8997_rtc_set_update_reg(info);
 325         if (ret < 0)
 326                 goto out;
 327
 328         if (alrm->enabled)
 329                 ret = max8997_rtc_start_alarm(info);
 330 out:
 331         mutex_unlock(&info->lock);
 332         return ret;
 333 }
 334
 335 static int max8997_rtc_alarm_irq_enable(struct device *dev,
 336                                         unsigned int enabled)
 337 {
 338         struct max8997_rtc_info *info = dev_get_drvdata(dev);
 339         int ret;
 340
 341         mutex_lock(&info->lock);
 342         if (enabled)
 343                 ret = max8997_rtc_start_alarm(info);
 344         else
 345                 ret = max8997_rtc_stop_alarm(info);
 346         mutex_unlock(&info->lock);
 347
 348         return ret;
 349 }
 350
 351 static irqreturn_t max8997_rtc_alarm_irq(int irq, void *data)
 352 {
 353         struct max8997_rtc_info *info = data;
 354
 355         dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);
 356
 357         rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
 358
 359         return IRQ_HANDLED;
 360 }
 361
 362 static const struct rtc_class_ops max8997_rtc_ops = {
 363         .read_time = max8997_rtc_read_time,
 364         .set_time = max8997_rtc_set_time,
 365         .read_alarm = max8997_rtc_read_alarm,
 366         .set_alarm = max8997_rtc_set_alarm,
 367         .alarm_irq_enable = max8997_rtc_alarm_irq_enable,
 368 };
 369
 370 static void max8997_rtc_enable_wtsr(struct max8997_rtc_info *info, bool enable)
 371 {
 372         int ret;
 373         u8 val, mask;
 374
 375         if (!wtsr_en)
 376                 return;
 377
 378         if (enable)
 379                 val = (1 << WTSR_EN_SHIFT) | (3 << WTSRT_SHIFT);
 380         else
 381                 val = 0;
 382
 383         mask = WTSR_EN_MASK | WTSRT_MASK;
 384
 385         dev_info(info->dev, "%s: %s WTSR\n", __func__,
 386                         enable ? "enable" : "disable");
 387
 388         ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
 389         if (ret < 0) {
 390                 dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
 391                                 __func__, ret);
 392                 return;
 393         }
 394
 395         max8997_rtc_set_update_reg(info);
 396 }
 397
 398 static void max8997_rtc_enable_smpl(struct max8997_rtc_info *info, bool enable)
 399 {
 400         int ret;
 401         u8 val, mask;
 402
 403         if (!smpl_en)
 404                 return;
 405
 406         if (enable)
 407                 val = (1 << SMPL_EN_SHIFT) | (0 << SMPLT_SHIFT);
 408         else
 409                 val = 0;
 410
 411         mask = SMPL_EN_MASK | SMPLT_MASK;
 412
 413         dev_info(info->dev, "%s: %s SMPL\n", __func__,
 414                         enable ? "enable" : "disable");
 415
 416         ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
 417         if (ret < 0) {
 418                 dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",
 419                                 __func__, ret);
 420                 return;
 421         }
 422
 423         max8997_rtc_set_update_reg(info);
 424
 425         val = 0;
 426         max8997_read_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, &val);
 427         pr_info("%s: WTSR_SMPL(0x%02x)\n", __func__, val);
 428 }
 429
 430 static int max8997_rtc_init_reg(struct max8997_rtc_info *info)
 431 {
 432         u8 data[2];
 433         int ret;
 434
 435         /* Set RTC control register : Binary mode, 24hour mdoe */
 436         data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
 437         data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
 438
 439         info->rtc_24hr_mode = 1;
 440
 441         ret = max8997_bulk_write(info->rtc, MAX8997_RTC_CTRLMASK, 2, data);
 442         if (ret < 0) {
 443                 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
 444                                 __func__, ret);
 445                 return ret;
 446         }
 447
 448         ret = max8997_rtc_set_update_reg(info);
 449         return ret;
 450 }
 451
 452 static int max8997_rtc_probe(struct platform_device *pdev)
 453 {
 454         struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent);
 455         struct max8997_rtc_info *info;
 456         int ret, virq;
 457
 458         info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_rtc_info),
 459                         GFP_KERNEL);
 460         if (!info)
 461                 return -ENOMEM;
 462
 463         mutex_init(&info->lock);
 464         info->dev = &pdev->dev;
 465         info->max8997 = max8997;
 466         info->rtc = max8997->rtc;
 467
 468         platform_set_drvdata(pdev, info);
 469
 470         ret = max8997_rtc_init_reg(info);
 471
 472         if (ret < 0) {
 473                 dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
 474                 return ret;
 475         }
 476
 477         max8997_rtc_enable_wtsr(info, true);
 478         max8997_rtc_enable_smpl(info, true);
 479
 480         device_init_wakeup(&pdev->dev, 1);
 481
 482         info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc",
 483                                         &max8997_rtc_ops, THIS_MODULE);
 484
 485         if (IS_ERR(info->rtc_dev)) {
 486                 ret = PTR_ERR(info->rtc_dev);
 487                 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
 488                 return ret;
 489         }
 490
 491         virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1);
 492         if (!virq) {
 493                 dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n");
 494                 ret = -ENXIO;
 495                 goto err_out;
 496         }
 497         info->virq = virq;
 498
 499         ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
 500                                 max8997_rtc_alarm_irq, 0,
 501                                 "rtc-alarm0", info);
 502         if (ret < 0)
 503                 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
 504                         info->virq, ret);
 505
 506 err_out:
 507         return ret;
 508 }
 509
 510 static void max8997_rtc_shutdown(struct platform_device *pdev)
 511 {
 512         struct max8997_rtc_info *info = platform_get_drvdata(pdev);
 513
 514         max8997_rtc_enable_wtsr(info, false);
 515         max8997_rtc_enable_smpl(info, false);
 516 }
 517
 518 static const struct platform_device_id rtc_id[] = {
 519         { "max8997-rtc", 0 },
 520         {},
 521 };
 522
 523 static struct platform_driver max8997_rtc_driver = {
 524         .driver         = {
 525                 .name   = "max8997-rtc",
 526                 .owner  = THIS_MODULE,
 527         },
 528         .probe          = max8997_rtc_probe,
 529         .shutdown       = max8997_rtc_shutdown,
 530         .id_table       = rtc_id,
 531 };
 532
 533 module_platform_driver(max8997_rtc_driver);
 534
 535 MODULE_DESCRIPTION("Maxim MAX8997 RTC driver");
 536 MODULE_AUTHOR("<ms925.kim@samsung.com>");
 537 MODULE_LICENSE("GPL");