drivers/rtc/rtc-max8998.c

   1 /*
   2  * RTC driver for Maxim MAX8998
   3  *
   4  * Copyright (C) 2010 Samsung Electronics Co.Ltd
   5  * Author: Minkyu Kang <mk7.kang@samsung.com>
   6  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
   7  *
   8  * This program is not provided / owned by Maxim Integrated Products.
   9  *
  10  *  This program is free software; you can redistribute  it and/or modify it
  11  *  under  the terms of  the GNU General  Public License as published by the
  12  *  Free Software Foundation;  either version 2 of the  License, or (at your
  13  *  option) any later version.
  14  *
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/i2c.h>
  19 #include <linux/slab.h>
  20 #include <linux/bcd.h>
  21 #include <linux/rtc.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/mfd/max8998.h>
  24 #include <linux/mfd/max8998-private.h>
  25 #include <linux/delay.h>
  26
  27 #define MAX8998_RTC_SEC                 0x00
  28 #define MAX8998_RTC_MIN                 0x01
  29 #define MAX8998_RTC_HOUR                0x02
  30 #define MAX8998_RTC_WEEKDAY             0x03
  31 #define MAX8998_RTC_DATE                0x04
  32 #define MAX8998_RTC_MONTH               0x05
  33 #define MAX8998_RTC_YEAR1               0x06
  34 #define MAX8998_RTC_YEAR2               0x07
  35 #define MAX8998_ALARM0_SEC              0x08
  36 #define MAX8998_ALARM0_MIN              0x09
  37 #define MAX8998_ALARM0_HOUR             0x0a
  38 #define MAX8998_ALARM0_WEEKDAY          0x0b
  39 #define MAX8998_ALARM0_DATE             0x0c
  40 #define MAX8998_ALARM0_MONTH            0x0d
  41 #define MAX8998_ALARM0_YEAR1            0x0e
  42 #define MAX8998_ALARM0_YEAR2            0x0f
  43 #define MAX8998_ALARM1_SEC              0x10
  44 #define MAX8998_ALARM1_MIN              0x11
  45 #define MAX8998_ALARM1_HOUR             0x12
  46 #define MAX8998_ALARM1_WEEKDAY          0x13
  47 #define MAX8998_ALARM1_DATE             0x14
  48 #define MAX8998_ALARM1_MONTH            0x15
  49 #define MAX8998_ALARM1_YEAR1            0x16
  50 #define MAX8998_ALARM1_YEAR2            0x17
  51 #define MAX8998_ALARM0_CONF             0x18
  52 #define MAX8998_ALARM1_CONF             0x19
  53 #define MAX8998_RTC_STATUS              0x1a
  54 #define MAX8998_WTSR_SMPL_CNTL          0x1b
  55 #define MAX8998_TEST                    0x1f
  56
  57 #define HOUR_12                         (1 << 7)
  58 #define HOUR_PM                         (1 << 5)
  59 #define ALARM0_STATUS                   (1 << 1)
  60 #define ALARM1_STATUS                   (1 << 2)
  61
  62 enum {
  63         RTC_SEC = 0,
  64         RTC_MIN,
  65         RTC_HOUR,
  66         RTC_WEEKDAY,
  67         RTC_DATE,
  68         RTC_MONTH,
  69         RTC_YEAR1,
  70         RTC_YEAR2,
  71 };
  72
  73 struct max8998_rtc_info {
  74         struct device           *dev;
  75         struct max8998_dev      *max8998;
  76         struct i2c_client       *rtc;
  77         struct rtc_device       *rtc_dev;
  78         int irq;
  79         bool lp3974_bug_workaround;
  80 };
  81
  82 static void max8998_data_to_tm(u8 *data, struct rtc_time *tm)
  83 {
  84         tm->tm_sec = bcd2bin(data[RTC_SEC]);
  85         tm->tm_min = bcd2bin(data[RTC_MIN]);
  86         if (data[RTC_HOUR] & HOUR_12) {
  87                 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x1f);
  88                 if (data[RTC_HOUR] & HOUR_PM)
  89                         tm->tm_hour += 12;
  90         } else
  91                 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f);
  92
  93         tm->tm_wday = data[RTC_WEEKDAY] & 0x07;
  94         tm->tm_mday = bcd2bin(data[RTC_DATE]);
  95         tm->tm_mon = bcd2bin(data[RTC_MONTH]);
  96         tm->tm_year = bcd2bin(data[RTC_YEAR1]) + bcd2bin(data[RTC_YEAR2]) * 100;
  97         tm->tm_year -= 1900;
  98 }
  99
 100 static void max8998_tm_to_data(struct rtc_time *tm, u8 *data)
 101 {
 102         data[RTC_SEC] = bin2bcd(tm->tm_sec);
 103         data[RTC_MIN] = bin2bcd(tm->tm_min);
 104         data[RTC_HOUR] = bin2bcd(tm->tm_hour);
 105         data[RTC_WEEKDAY] = tm->tm_wday;
 106         data[RTC_DATE] = bin2bcd(tm->tm_mday);
 107         data[RTC_MONTH] = bin2bcd(tm->tm_mon);
 108         data[RTC_YEAR1] = bin2bcd(tm->tm_year % 100);
 109         data[RTC_YEAR2] = bin2bcd((tm->tm_year + 1900) / 100);
 110 }
 111
 112 static int max8998_rtc_read_time(struct device *dev, struct rtc_time *tm)
 113 {
 114         struct max8998_rtc_info *info = dev_get_drvdata(dev);
 115         u8 data[8];
 116         int ret;
 117
 118         ret = max8998_bulk_read(info->rtc, MAX8998_RTC_SEC, 8, data);
 119         if (ret < 0)
 120                 return ret;
 121
 122         max8998_data_to_tm(data, tm);
 123
 124         return rtc_valid_tm(tm);
 125 }
 126
 127 static int max8998_rtc_set_time(struct device *dev, struct rtc_time *tm)
 128 {
 129         struct max8998_rtc_info *info = dev_get_drvdata(dev);
 130         u8 data[8];
 131         int ret;
 132
 133         max8998_tm_to_data(tm, data);
 134
 135         ret = max8998_bulk_write(info->rtc, MAX8998_RTC_SEC, 8, data);
 136
 137         if (info->lp3974_bug_workaround)
 138                 msleep(2000);
 139
 140         return ret;
 141 }
 142
 143 static int max8998_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 144 {
 145         struct max8998_rtc_info *info = dev_get_drvdata(dev);
 146         u8 data[8];
 147         u8 val;
 148         int ret;
 149
 150         ret = max8998_bulk_read(info->rtc, MAX8998_ALARM0_SEC, 8, data);
 151         if (ret < 0)
 152                 return ret;
 153
 154         max8998_data_to_tm(data, &alrm->time);
 155
 156         ret = max8998_read_reg(info->rtc, MAX8998_ALARM0_CONF, &val);
 157         if (ret < 0)
 158                 return ret;
 159
 160         alrm->enabled = !!val;
 161
 162         ret = max8998_read_reg(info->rtc, MAX8998_RTC_STATUS, &val);
 163         if (ret < 0)
 164                 return ret;
 165
 166         if (val & ALARM0_STATUS)
 167                 alrm->pending = 1;
 168         else
 169                 alrm->pending = 0;
 170
 171         return 0;
 172 }
 173
 174 static int max8998_rtc_stop_alarm(struct max8998_rtc_info *info)
 175 {
 176         int ret = max8998_write_reg(info->rtc, MAX8998_ALARM0_CONF, 0);
 177
 178         if (info->lp3974_bug_workaround)
 179                 msleep(2000);
 180
 181         return ret;
 182 }
 183
 184 static int max8998_rtc_start_alarm(struct max8998_rtc_info *info)
 185 {
 186         int ret;
 187         u8 alarm0_conf = 0x77;
 188
 189         /* LP3974 with delay bug chips has rtc alarm bugs with "MONTH" field */
 190         if (info->lp3974_bug_workaround)
 191                 alarm0_conf = 0x57;
 192
 193         ret = max8998_write_reg(info->rtc, MAX8998_ALARM0_CONF, alarm0_conf);
 194
 195         if (info->lp3974_bug_workaround)
 196                 msleep(2000);
 197
 198         return ret;
 199 }
 200
 201 static int max8998_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
 202 {
 203         struct max8998_rtc_info *info = dev_get_drvdata(dev);
 204         u8 data[8];
 205         int ret;
 206
 207         max8998_tm_to_data(&alrm->time, data);
 208
 209         ret = max8998_rtc_stop_alarm(info);
 210         if (ret < 0)
 211                 return ret;
 212
 213         ret = max8998_bulk_write(info->rtc, MAX8998_ALARM0_SEC, 8, data);
 214         if (ret < 0)
 215                 return ret;
 216
 217         if (info->lp3974_bug_workaround)
 218                 msleep(2000);
 219
 220         if (alrm->enabled)
 221                 ret = max8998_rtc_start_alarm(info);
 222
 223         return ret;
 224 }
 225
 226 static int max8998_rtc_alarm_irq_enable(struct device *dev,
 227                                         unsigned int enabled)
 228 {
 229         struct max8998_rtc_info *info = dev_get_drvdata(dev);
 230
 231         if (enabled)
 232                 return max8998_rtc_start_alarm(info);
 233         else
 234                 return max8998_rtc_stop_alarm(info);
 235 }
 236
 237 static irqreturn_t max8998_rtc_alarm_irq(int irq, void *data)
 238 {
 239         struct max8998_rtc_info *info = data;
 240
 241         rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
 242
 243         return IRQ_HANDLED;
 244 }
 245
 246 static const struct rtc_class_ops max8998_rtc_ops = {
 247         .read_time = max8998_rtc_read_time,
 248         .set_time = max8998_rtc_set_time,
 249         .read_alarm = max8998_rtc_read_alarm,
 250         .set_alarm = max8998_rtc_set_alarm,
 251         .alarm_irq_enable = max8998_rtc_alarm_irq_enable,
 252 };
 253
 254 static int __devinit max8998_rtc_probe(struct platform_device *pdev)
 255 {
 256         struct max8998_dev *max8998 = dev_get_drvdata(pdev->dev.parent);
 257         struct max8998_rtc_info *info;
 258         int ret;
 259
 260         info = kzalloc(sizeof(struct max8998_rtc_info), GFP_KERNEL);
 261         if (!info)
 262                 return -ENOMEM;
 263
 264         info->dev = &pdev->dev;
 265         info->max8998 = max8998;
 266         info->rtc = max8998->rtc;
 267         info->irq = max8998->irq_base + MAX8998_IRQ_ALARM0;
 268
 269         info->rtc_dev = rtc_device_register("max8998-rtc", &pdev->dev,
 270                         &max8998_rtc_ops, THIS_MODULE);
 271
 272         if (IS_ERR(info->rtc_dev)) {
 273                 ret = PTR_ERR(info->rtc_dev);
 274                 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
 275                 goto out_rtc;
 276         }
 277
 278         platform_set_drvdata(pdev, info);
 279
 280         ret = request_threaded_irq(info->irq, NULL, max8998_rtc_alarm_irq, 0,
 281                         "rtc-alarm0", info);
 282
 283         if (ret < 0)
 284                 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
 285                         info->irq, ret);
 286
 287         dev_info(&pdev->dev, "RTC CHIP NAME: %s\n", pdev->id_entry->name);
 288         if (pdev->id_entry->driver_data == TYPE_LP3974_REGERR) {
 289                 info->lp3974_bug_workaround = true;
 290                 dev_warn(&pdev->dev, "LP3974 with RTC REGERR option."
 291                                 " RTC updates will be extremely slow.\n");
 292         }
 293
 294         return 0;
 295
 296 out_rtc:
 297         kfree(info);
 298         return ret;
 299 }
 300
 301 static int __devexit max8998_rtc_remove(struct platform_device *pdev)
 302 {
 303         struct max8998_rtc_info *info = platform_get_drvdata(pdev);
 304
 305         if (info) {
 306                 free_irq(info->irq, info);
 307                 rtc_device_unregister(info->rtc_dev);
 308                 kfree(info);
 309         }
 310
 311         return 0;
 312 }
 313
 314 static const struct platform_device_id max8998_rtc_id[] = {
 315         { "max8998-rtc", TYPE_MAX8998 },
 316         { "lp3974-rtc", TYPE_LP3974 },
 317         /* REGERR: requires 1 ~ 2 s of delay after writing to RTC registers */
 318         { "lp3974-rtc-regerr", TYPE_LP3974_REGERR },
 319         { }
 320 };
 321
 322 static struct platform_driver max8998_rtc_driver = {
 323         .driver         = {
 324                 .name   = "max8998-rtc",
 325                 .owner  = THIS_MODULE,
 326         },
 327         .probe          = max8998_rtc_probe,
 328         .remove         = __devexit_p(max8998_rtc_remove),
 329         .id_table       = max8998_rtc_id,
 330 };
 331
 332 static int __init max8998_rtc_init(void)
 333 {
 334         return platform_driver_register(&max8998_rtc_driver);
 335 }
 336 module_init(max8998_rtc_init);
 337
 338 static void __exit max8998_rtc_exit(void)
 339 {
 340         platform_driver_unregister(&max8998_rtc_driver);
 341 }
 342 module_exit(max8998_rtc_exit);
 343
 344 MODULE_AUTHOR("Minkyu Kang <mk7.kang@samsung.com>");
 345 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
 346 MODULE_DESCRIPTION("Maxim MAX8998 RTC driver");
 347 MODULE_LICENSE("GPL");