drivers/rtc/rtc-ds3232.c

   1 /*
   2  * RTC client/driver for the Maxim/Dallas DS3232 Real-Time Clock over I2C
   3  *
   4  * Copyright (C) 2009-2011 Freescale Semiconductor.
   5  * Author: Jack Lan <jack.lan@freescale.com>
   6  *
   7  * This program is free software; you can redistribute  it and/or modify it
   8  * under  the terms of  the GNU General  Public License as published by the
   9  * Free Software Foundation;  either version 2 of the  License, or (at your
  10  * option) any later version.
  11  */
  12 /*
  13  * It would be more efficient to use i2c msgs/i2c_transfer directly but, as
  14  * recommened in .../Documentation/i2c/writing-clients section
  15  * "Sending and receiving", using SMBus level communication is preferred.
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/i2c.h>
  22 #include <linux/rtc.h>
  23 #include <linux/bcd.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/slab.h>
  26
  27 #define DS3232_REG_SECONDS      0x00
  28 #define DS3232_REG_MINUTES      0x01
  29 #define DS3232_REG_HOURS        0x02
  30 #define DS3232_REG_AMPM         0x02
  31 #define DS3232_REG_DAY          0x03
  32 #define DS3232_REG_DATE         0x04
  33 #define DS3232_REG_MONTH        0x05
  34 #define DS3232_REG_CENTURY      0x05
  35 #define DS3232_REG_YEAR         0x06
  36 #define DS3232_REG_ALARM1         0x07  /* Alarm 1 BASE */
  37 #define DS3232_REG_ALARM2         0x0B  /* Alarm 2 BASE */
  38 #define DS3232_REG_CR           0x0E    /* Control register */
  39 #       define DS3232_REG_CR_nEOSC        0x80
  40 #       define DS3232_REG_CR_INTCN        0x04
  41 #       define DS3232_REG_CR_A2IE        0x02
  42 #       define DS3232_REG_CR_A1IE        0x01
  43
  44 #define DS3232_REG_SR   0x0F    /* control/status register */
  45 #       define DS3232_REG_SR_OSF   0x80
  46 #       define DS3232_REG_SR_BSY   0x04
  47 #       define DS3232_REG_SR_A2F   0x02
  48 #       define DS3232_REG_SR_A1F   0x01
  49
  50 struct ds3232 {
  51         struct i2c_client *client;
  52         struct rtc_device *rtc;
  53         struct work_struct work;
  54
  55         /* The mutex protects alarm operations, and prevents a race
  56          * between the enable_irq() in the workqueue and the free_irq()
  57          * in the remove function.
  58          */
  59         struct mutex mutex;
  60         int exiting;
  61 };
  62
  63 static struct i2c_driver ds3232_driver;
  64
  65 static int ds3232_check_rtc_status(struct i2c_client *client)
  66 {
  67         int ret = 0;
  68         int control, stat;
  69
  70         stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
  71         if (stat < 0)
  72                 return stat;
  73
  74         if (stat & DS3232_REG_SR_OSF)
  75                 dev_warn(&client->dev,
  76                                 "oscillator discontinuity flagged, "
  77                                 "time unreliable\n");
  78
  79         stat &= ~(DS3232_REG_SR_OSF | DS3232_REG_SR_A1F | DS3232_REG_SR_A2F);
  80
  81         ret = i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
  82         if (ret < 0)
  83                 return ret;
  84
  85         /* If the alarm is pending, clear it before requesting
  86          * the interrupt, so an interrupt event isn't reported
  87          * before everything is initialized.
  88          */
  89
  90         control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
  91         if (control < 0)
  92                 return control;
  93
  94         control &= ~(DS3232_REG_CR_A1IE | DS3232_REG_CR_A2IE);
  95         control |= DS3232_REG_CR_INTCN;
  96
  97         return i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
  98 }
  99
 100 static int ds3232_read_time(struct device *dev, struct rtc_time *time)
 101 {
 102         struct i2c_client *client = to_i2c_client(dev);
 103         int ret;
 104         u8 buf[7];
 105         unsigned int year, month, day, hour, minute, second;
 106         unsigned int week, twelve_hr, am_pm;
 107         unsigned int century, add_century = 0;
 108
 109         ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_SECONDS, 7, buf);
 110
 111         if (ret < 0)
 112                 return ret;
 113         if (ret < 7)
 114                 return -EIO;
 115
 116         second = buf[0];
 117         minute = buf[1];
 118         hour = buf[2];
 119         week = buf[3];
 120         day = buf[4];
 121         month = buf[5];
 122         year = buf[6];
 123
 124         /* Extract additional information for AM/PM and century */
 125
 126         twelve_hr = hour & 0x40;
 127         am_pm = hour & 0x20;
 128         century = month & 0x80;
 129
 130         /* Write to rtc_time structure */
 131
 132         time->tm_sec = bcd2bin(second);
 133         time->tm_min = bcd2bin(minute);
 134         if (twelve_hr) {
 135                 /* Convert to 24 hr */
 136                 if (am_pm)
 137                         time->tm_hour = bcd2bin(hour & 0x1F) + 12;
 138                 else
 139                         time->tm_hour = bcd2bin(hour & 0x1F);
 140         } else {
 141                 time->tm_hour = bcd2bin(hour);
 142         }
 143
 144         /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */
 145         time->tm_wday = bcd2bin(week) - 1;
 146         time->tm_mday = bcd2bin(day);
 147         /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */
 148         time->tm_mon = bcd2bin(month & 0x7F) - 1;
 149         if (century)
 150                 add_century = 100;
 151
 152         time->tm_year = bcd2bin(year) + add_century;
 153
 154         return rtc_valid_tm(time);
 155 }
 156
 157 static int ds3232_set_time(struct device *dev, struct rtc_time *time)
 158 {
 159         struct i2c_client *client = to_i2c_client(dev);
 160         u8 buf[7];
 161
 162         /* Extract time from rtc_time and load into ds3232*/
 163
 164         buf[0] = bin2bcd(time->tm_sec);
 165         buf[1] = bin2bcd(time->tm_min);
 166         buf[2] = bin2bcd(time->tm_hour);
 167         /* Day of the week in linux range is 0~6 while 1~7 in RTC chip */
 168         buf[3] = bin2bcd(time->tm_wday + 1);
 169         buf[4] = bin2bcd(time->tm_mday); /* Date */
 170         /* linux tm_mon range:0~11, while month range is 1~12 in RTC chip */
 171         buf[5] = bin2bcd(time->tm_mon + 1);
 172         if (time->tm_year >= 100) {
 173                 buf[5] |= 0x80;
 174                 buf[6] = bin2bcd(time->tm_year - 100);
 175         } else {
 176                 buf[6] = bin2bcd(time->tm_year);
 177         }
 178
 179         return i2c_smbus_write_i2c_block_data(client,
 180                                               DS3232_REG_SECONDS, 7, buf);
 181 }
 182
 183 /*
 184  * DS3232 has two alarm, we only use alarm1
 185  * According to linux specification, only support one-shot alarm
 186  * no periodic alarm mode
 187  */
 188 static int ds3232_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 189 {
 190         struct i2c_client *client = to_i2c_client(dev);
 191         struct ds3232 *ds3232 = i2c_get_clientdata(client);
 192         int control, stat;
 193         int ret;
 194         u8 buf[4];
 195
 196         mutex_lock(&ds3232->mutex);
 197
 198         ret = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
 199         if (ret < 0)
 200                 goto out;
 201         stat = ret;
 202         ret = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
 203         if (ret < 0)
 204                 goto out;
 205         control = ret;
 206         ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
 207         if (ret < 0)
 208                 goto out;
 209
 210         alarm->time.tm_sec = bcd2bin(buf[0] & 0x7F);
 211         alarm->time.tm_min = bcd2bin(buf[1] & 0x7F);
 212         alarm->time.tm_hour = bcd2bin(buf[2] & 0x7F);
 213         alarm->time.tm_mday = bcd2bin(buf[3] & 0x7F);
 214
 215         alarm->time.tm_mon = -1;
 216         alarm->time.tm_year = -1;
 217         alarm->time.tm_wday = -1;
 218         alarm->time.tm_yday = -1;
 219         alarm->time.tm_isdst = -1;
 220
 221         alarm->enabled = !!(control & DS3232_REG_CR_A1IE);
 222         alarm->pending = !!(stat & DS3232_REG_SR_A1F);
 223
 224         ret = 0;
 225 out:
 226         mutex_unlock(&ds3232->mutex);
 227         return ret;
 228 }
 229
 230 /*
 231  * linux rtc-module does not support wday alarm
 232  * and only 24h time mode supported indeed
 233  */
 234 static int ds3232_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 235 {
 236         struct i2c_client *client = to_i2c_client(dev);
 237         struct ds3232 *ds3232 = i2c_get_clientdata(client);
 238         int control, stat;
 239         int ret;
 240         u8 buf[4];
 241
 242         if (client->irq <= 0)
 243                 return -EINVAL;
 244
 245         mutex_lock(&ds3232->mutex);
 246
 247         buf[0] = bin2bcd(alarm->time.tm_sec);
 248         buf[1] = bin2bcd(alarm->time.tm_min);
 249         buf[2] = bin2bcd(alarm->time.tm_hour);
 250         buf[3] = bin2bcd(alarm->time.tm_mday);
 251
 252         /* clear alarm interrupt enable bit */
 253         ret = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
 254         if (ret < 0)
 255                 goto out;
 256         control = ret;
 257         control &= ~(DS3232_REG_CR_A1IE | DS3232_REG_CR_A2IE);
 258         ret = i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
 259         if (ret < 0)
 260                 goto out;
 261
 262         /* clear any pending alarm flag */
 263         ret = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
 264         if (ret < 0)
 265                 goto out;
 266         stat = ret;
 267         stat &= ~(DS3232_REG_SR_A1F | DS3232_REG_SR_A2F);
 268         ret = i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
 269         if (ret < 0)
 270                 goto out;
 271
 272         ret = i2c_smbus_write_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
 273
 274         if (alarm->enabled) {
 275                 control |= DS3232_REG_CR_A1IE;
 276                 ret = i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
 277         }
 278 out:
 279         mutex_unlock(&ds3232->mutex);
 280         return ret;
 281 }
 282
 283 static void ds3232_update_alarm(struct i2c_client *client)
 284 {
 285         struct ds3232 *ds3232 = i2c_get_clientdata(client);
 286         int control;
 287         int ret;
 288         u8 buf[4];
 289
 290         mutex_lock(&ds3232->mutex);
 291
 292         ret = i2c_smbus_read_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
 293         if (ret < 0)
 294                 goto unlock;
 295
 296         buf[0] = bcd2bin(buf[0]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
 297                                                                 0x80 : buf[0];
 298         buf[1] = bcd2bin(buf[1]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
 299                                                                 0x80 : buf[1];
 300         buf[2] = bcd2bin(buf[2]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
 301                                                                 0x80 : buf[2];
 302         buf[3] = bcd2bin(buf[3]) < 0 || (ds3232->rtc->irq_data & RTC_UF) ?
 303                                                                 0x80 : buf[3];
 304
 305         ret = i2c_smbus_write_i2c_block_data(client, DS3232_REG_ALARM1, 4, buf);
 306         if (ret < 0)
 307                 goto unlock;
 308
 309         control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
 310         if (control < 0)
 311                 goto unlock;
 312
 313         if (ds3232->rtc->irq_data & (RTC_AF | RTC_UF))
 314                 /* enable alarm1 interrupt */
 315                 control |= DS3232_REG_CR_A1IE;
 316         else
 317                 /* disable alarm1 interrupt */
 318                 control &= ~(DS3232_REG_CR_A1IE);
 319         i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
 320
 321 unlock:
 322         mutex_unlock(&ds3232->mutex);
 323 }
 324
 325 static int ds3232_alarm_irq_enable(struct device *dev, unsigned int enabled)
 326 {
 327         struct i2c_client *client = to_i2c_client(dev);
 328         struct ds3232 *ds3232 = i2c_get_clientdata(client);
 329
 330         if (client->irq <= 0)
 331                 return -EINVAL;
 332
 333         if (enabled)
 334                 ds3232->rtc->irq_data |= RTC_AF;
 335         else
 336                 ds3232->rtc->irq_data &= ~RTC_AF;
 337
 338         ds3232_update_alarm(client);
 339         return 0;
 340 }
 341
 342 static int ds3232_update_irq_enable(struct device *dev, unsigned int enabled)
 343 {
 344         struct i2c_client *client = to_i2c_client(dev);
 345         struct ds3232 *ds3232 = i2c_get_clientdata(client);
 346
 347         if (client->irq <= 0)
 348                 return -EINVAL;
 349
 350         if (enabled)
 351                 ds3232->rtc->irq_data |= RTC_UF;
 352         else
 353                 ds3232->rtc->irq_data &= ~RTC_UF;
 354
 355         ds3232_update_alarm(client);
 356         return 0;
 357 }
 358
 359 static irqreturn_t ds3232_irq(int irq, void *dev_id)
 360 {
 361         struct i2c_client *client = dev_id;
 362         struct ds3232 *ds3232 = i2c_get_clientdata(client);
 363
 364         disable_irq_nosync(irq);
 365         schedule_work(&ds3232->work);
 366         return IRQ_HANDLED;
 367 }
 368
 369 static void ds3232_work(struct work_struct *work)
 370 {
 371         struct ds3232 *ds3232 = container_of(work, struct ds3232, work);
 372         struct i2c_client *client = ds3232->client;
 373         int stat, control;
 374
 375         mutex_lock(&ds3232->mutex);
 376
 377         stat = i2c_smbus_read_byte_data(client, DS3232_REG_SR);
 378         if (stat < 0)
 379                 goto unlock;
 380
 381         if (stat & DS3232_REG_SR_A1F) {
 382                 control = i2c_smbus_read_byte_data(client, DS3232_REG_CR);
 383                 if (control < 0)
 384                         goto out;
 385                 /* disable alarm1 interrupt */
 386                 control &= ~(DS3232_REG_CR_A1IE);
 387                 i2c_smbus_write_byte_data(client, DS3232_REG_CR, control);
 388
 389                 /* clear the alarm pend flag */
 390                 stat &= ~DS3232_REG_SR_A1F;
 391                 i2c_smbus_write_byte_data(client, DS3232_REG_SR, stat);
 392
 393                 rtc_update_irq(ds3232->rtc, 1, RTC_AF | RTC_IRQF);
 394         }
 395
 396 out:
 397         if (!ds3232->exiting)
 398                 enable_irq(client->irq);
 399 unlock:
 400         mutex_unlock(&ds3232->mutex);
 401 }
 402
 403 static const struct rtc_class_ops ds3232_rtc_ops = {
 404         .read_time = ds3232_read_time,
 405         .set_time = ds3232_set_time,
 406         .read_alarm = ds3232_read_alarm,
 407         .set_alarm = ds3232_set_alarm,
 408         .alarm_irq_enable = ds3232_alarm_irq_enable,
 409         .update_irq_enable = ds3232_update_irq_enable,
 410 };
 411
 412 static int __devinit ds3232_probe(struct i2c_client *client,
 413                 const struct i2c_device_id *id)
 414 {
 415         struct ds3232 *ds3232;
 416         int ret;
 417
 418         ds3232 = kzalloc(sizeof(struct ds3232), GFP_KERNEL);
 419         if (!ds3232)
 420                 return -ENOMEM;
 421
 422         ds3232->client = client;
 423         i2c_set_clientdata(client, ds3232);
 424
 425         INIT_WORK(&ds3232->work, ds3232_work);
 426         mutex_init(&ds3232->mutex);
 427
 428         ret = ds3232_check_rtc_status(client);
 429         if (ret)
 430                 goto out_free;
 431
 432         ds3232->rtc = rtc_device_register(client->name, &client->dev,
 433                                           &ds3232_rtc_ops, THIS_MODULE);
 434         if (IS_ERR(ds3232->rtc)) {
 435                 ret = PTR_ERR(ds3232->rtc);
 436                 dev_err(&client->dev, "unable to register the class device\n");
 437                 goto out_irq;
 438         }
 439
 440         if (client->irq >= 0) {
 441                 ret = request_irq(client->irq, ds3232_irq, 0,
 442                                  "ds3232", client);
 443                 if (ret) {
 444                         dev_err(&client->dev, "unable to request IRQ\n");
 445                         goto out_free;
 446                 }
 447         }
 448
 449         return 0;
 450
 451 out_irq:
 452         if (client->irq >= 0)
 453                 free_irq(client->irq, client);
 454
 455 out_free:
 456         kfree(ds3232);
 457         return ret;
 458 }
 459
 460 static int __devexit ds3232_remove(struct i2c_client *client)
 461 {
 462         struct ds3232 *ds3232 = i2c_get_clientdata(client);
 463
 464         if (client->irq >= 0) {
 465                 mutex_lock(&ds3232->mutex);
 466                 ds3232->exiting = 1;
 467                 mutex_unlock(&ds3232->mutex);
 468
 469                 free_irq(client->irq, client);
 470                 cancel_work_sync(&ds3232->work);
 471         }
 472
 473         rtc_device_unregister(ds3232->rtc);
 474         kfree(ds3232);
 475         return 0;
 476 }
 477
 478 static const struct i2c_device_id ds3232_id[] = {
 479         { "ds3232", 0 },
 480         { }
 481 };
 482 MODULE_DEVICE_TABLE(i2c, ds3232_id);
 483
 484 static struct i2c_driver ds3232_driver = {
 485         .driver = {
 486                 .name = "rtc-ds3232",
 487                 .owner = THIS_MODULE,
 488         },
 489         .probe = ds3232_probe,
 490         .remove = __devexit_p(ds3232_remove),
 491         .id_table = ds3232_id,
 492 };
 493
 494 static int __init ds3232_init(void)
 495 {
 496         return i2c_add_driver(&ds3232_driver);
 497 }
 498
 499 static void __exit ds3232_exit(void)
 500 {
 501         i2c_del_driver(&ds3232_driver);
 502 }
 503
 504 module_init(ds3232_init);
 505 module_exit(ds3232_exit);
 506
 507 MODULE_AUTHOR("Srikanth Srinivasan <srikanth.srinivasan@freescale.com>");
 508 MODULE_DESCRIPTION("Maxim/Dallas DS3232 RTC Driver");
 509 MODULE_LICENSE("GPL");