drivers/rtc/rtc-ds1307.c

   1 /*
   2  * rtc-ds1307.c - RTC driver for some mostly-compatible I2C chips.
   3  *
   4  *  Copyright (C) 2005 James Chapman (ds1337 core)
   5  *  Copyright (C) 2006 David Brownell
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/slab.h>
  15 #include <linux/i2c.h>
  16 #include <linux/string.h>
  17 #include <linux/rtc.h>
  18 #include <linux/bcd.h>
  19
  20
  21
  22 /* We can't determine type by probing, but if we expect pre-Linux code
  23  * to have set the chip up as a clock (turning on the oscillator and
  24  * setting the date and time), Linux can ignore the non-clock features.
  25  * That's a natural job for a factory or repair bench.
  26  */
  27 enum ds_type {
  28         ds_1307,
  29         ds_1337,
  30         ds_1338,
  31         ds_1339,
  32         ds_1340,
  33         m41t00,
  34         // rs5c372 too?  different address...
  35 };
  36
  37
  38 /* RTC registers don't differ much, except for the century flag */
  39 #define DS1307_REG_SECS         0x00    /* 00-59 */
  40 #       define DS1307_BIT_CH            0x80
  41 #       define DS1340_BIT_nEOSC         0x80
  42 #define DS1307_REG_MIN          0x01    /* 00-59 */
  43 #define DS1307_REG_HOUR         0x02    /* 00-23, or 1-12{am,pm} */
  44 #       define DS1307_BIT_12HR          0x40    /* in REG_HOUR */
  45 #       define DS1307_BIT_PM            0x20    /* in REG_HOUR */
  46 #       define DS1340_BIT_CENTURY_EN    0x80    /* in REG_HOUR */
  47 #       define DS1340_BIT_CENTURY       0x40    /* in REG_HOUR */
  48 #define DS1307_REG_WDAY         0x03    /* 01-07 */
  49 #define DS1307_REG_MDAY         0x04    /* 01-31 */
  50 #define DS1307_REG_MONTH        0x05    /* 01-12 */
  51 #       define DS1337_BIT_CENTURY       0x80    /* in REG_MONTH */
  52 #define DS1307_REG_YEAR         0x06    /* 00-99 */
  53
  54 /* Other registers (control, status, alarms, trickle charge, NVRAM, etc)
  55  * start at 7, and they differ a LOT. Only control and status matter for
  56  * basic RTC date and time functionality; be careful using them.
  57  */
  58 #define DS1307_REG_CONTROL      0x07            /* or ds1338 */
  59 #       define DS1307_BIT_OUT           0x80
  60 #       define DS1338_BIT_OSF           0x20
  61 #       define DS1307_BIT_SQWE          0x10
  62 #       define DS1307_BIT_RS1           0x02
  63 #       define DS1307_BIT_RS0           0x01
  64 #define DS1337_REG_CONTROL      0x0e
  65 #       define DS1337_BIT_nEOSC         0x80
  66 #       define DS1339_BIT_BBSQI         0x20
  67 #       define DS1337_BIT_RS2           0x10
  68 #       define DS1337_BIT_RS1           0x08
  69 #       define DS1337_BIT_INTCN         0x04
  70 #       define DS1337_BIT_A2IE          0x02
  71 #       define DS1337_BIT_A1IE          0x01
  72 #define DS1340_REG_CONTROL      0x07
  73 #       define DS1340_BIT_OUT           0x80
  74 #       define DS1340_BIT_FT            0x40
  75 #       define DS1340_BIT_CALIB_SIGN    0x20
  76 #       define DS1340_M_CALIBRATION     0x1f
  77 #define DS1340_REG_FLAG         0x09
  78 #       define DS1340_BIT_OSF           0x80
  79 #define DS1337_REG_STATUS       0x0f
  80 #       define DS1337_BIT_OSF           0x80
  81 #       define DS1337_BIT_A2I           0x02
  82 #       define DS1337_BIT_A1I           0x01
  83 #define DS1339_REG_ALARM1_SECS  0x07
  84 #define DS1339_REG_TRICKLE      0x10
  85
  86
  87
  88 struct ds1307 {
  89         u8                      reg_addr;
  90         u8                      regs[11];
  91         enum ds_type            type;
  92         unsigned long           flags;
  93 #define HAS_NVRAM       0               /* bit 0 == sysfs file active */
  94 #define HAS_ALARM       1               /* bit 1 == irq claimed */
  95         struct i2c_msg          msg[2];
  96         struct i2c_client       *client;
  97         struct rtc_device       *rtc;
  98         struct work_struct      work;
  99 };
 100
 101 struct chip_desc {
 102         unsigned                nvram56:1;
 103         unsigned                alarm:1;
 104 };
 105
 106 static const struct chip_desc chips[] = {
 107 [ds_1307] = {
 108         .nvram56        = 1,
 109 },
 110 [ds_1337] = {
 111         .alarm          = 1,
 112 },
 113 [ds_1338] = {
 114         .nvram56        = 1,
 115 },
 116 [ds_1339] = {
 117         .alarm          = 1,
 118 },
 119 [ds_1340] = {
 120 },
 121 [m41t00] = {
 122 }, };
 123
 124 static const struct i2c_device_id ds1307_id[] = {
 125         { "ds1307", ds_1307 },
 126         { "ds1337", ds_1337 },
 127         { "ds1338", ds_1338 },
 128         { "ds1339", ds_1339 },
 129         { "ds1340", ds_1340 },
 130         { "m41t00", m41t00 },
 131         { }
 132 };
 133 MODULE_DEVICE_TABLE(i2c, ds1307_id);
 134
 135 /*----------------------------------------------------------------------*/
 136
 137 /*
 138  * The IRQ logic includes a "real" handler running in IRQ context just
 139  * long enough to schedule this workqueue entry.   We need a task context
 140  * to talk to the RTC, since I2C I/O calls require that; and disable the
 141  * IRQ until we clear its status on the chip, so that this handler can
 142  * work with any type of triggering (not just falling edge).
 143  *
 144  * The ds1337 and ds1339 both have two alarms, but we only use the first
 145  * one (with a "seconds" field).  For ds1337 we expect nINTA is our alarm
 146  * signal; ds1339 chips have only one alarm signal.
 147  */
 148 static void ds1307_work(struct work_struct *work)
 149 {
 150         struct ds1307           *ds1307;
 151         struct i2c_client       *client;
 152         struct mutex            *lock;
 153         int                     stat, control;
 154
 155         ds1307 = container_of(work, struct ds1307, work);
 156         client = ds1307->client;
 157         lock = &ds1307->rtc->ops_lock;
 158
 159         mutex_lock(lock);
 160         stat = i2c_smbus_read_byte_data(client, DS1337_REG_STATUS);
 161         if (stat < 0)
 162                 goto out;
 163
 164         if (stat & DS1337_BIT_A1I) {
 165                 stat &= ~DS1337_BIT_A1I;
 166                 i2c_smbus_write_byte_data(client, DS1337_REG_STATUS, stat);
 167
 168                 control = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
 169                 if (control < 0)
 170                         goto out;
 171
 172                 control &= ~DS1337_BIT_A1IE;
 173                 i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL, control);
 174
 175                 /* rtc_update_irq() assumes that it is called
 176                  * from IRQ-disabled context.
 177                  */
 178                 local_irq_disable();
 179                 rtc_update_irq(ds1307->rtc, 1, RTC_AF | RTC_IRQF);
 180                 local_irq_enable();
 181         }
 182
 183 out:
 184         if (test_bit(HAS_ALARM, &ds1307->flags))
 185                 enable_irq(client->irq);
 186         mutex_unlock(lock);
 187 }
 188
 189 static irqreturn_t ds1307_irq(int irq, void *dev_id)
 190 {
 191         struct i2c_client       *client = dev_id;
 192         struct ds1307           *ds1307 = i2c_get_clientdata(client);
 193
 194         disable_irq_nosync(irq);
 195         schedule_work(&ds1307->work);
 196         return IRQ_HANDLED;
 197 }
 198
 199 /*----------------------------------------------------------------------*/
 200
 201 static int ds1307_get_time(struct device *dev, struct rtc_time *t)
 202 {
 203         struct ds1307   *ds1307 = dev_get_drvdata(dev);
 204         int             tmp;
 205
 206         /* read the RTC date and time registers all at once */
 207         ds1307->reg_addr = 0;
 208         ds1307->msg[1].flags = I2C_M_RD;
 209         ds1307->msg[1].len = 7;
 210
 211         tmp = i2c_transfer(to_i2c_adapter(ds1307->client->dev.parent),
 212                         ds1307->msg, 2);
 213         if (tmp != 2) {
 214                 dev_err(dev, "%s error %d\n", "read", tmp);
 215                 return -EIO;
 216         }
 217
 218         dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x\n",
 219                         "read",
 220                         ds1307->regs[0], ds1307->regs[1],
 221                         ds1307->regs[2], ds1307->regs[3],
 222                         ds1307->regs[4], ds1307->regs[5],
 223                         ds1307->regs[6]);
 224
 225         t->tm_sec = BCD2BIN(ds1307->regs[DS1307_REG_SECS] & 0x7f);
 226         t->tm_min = BCD2BIN(ds1307->regs[DS1307_REG_MIN] & 0x7f);
 227         tmp = ds1307->regs[DS1307_REG_HOUR] & 0x3f;
 228         t->tm_hour = BCD2BIN(tmp);
 229         t->tm_wday = BCD2BIN(ds1307->regs[DS1307_REG_WDAY] & 0x07) - 1;
 230         t->tm_mday = BCD2BIN(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
 231         tmp = ds1307->regs[DS1307_REG_MONTH] & 0x1f;
 232         t->tm_mon = BCD2BIN(tmp) - 1;
 233
 234         /* assume 20YY not 19YY, and ignore DS1337_BIT_CENTURY */
 235         t->tm_year = BCD2BIN(ds1307->regs[DS1307_REG_YEAR]) + 100;
 236
 237         dev_dbg(dev, "%s secs=%d, mins=%d, "
 238                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
 239                 "read", t->tm_sec, t->tm_min,
 240                 t->tm_hour, t->tm_mday,
 241                 t->tm_mon, t->tm_year, t->tm_wday);
 242
 243         /* initial clock setting can be undefined */
 244         return rtc_valid_tm(t);
 245 }
 246
 247 static int ds1307_set_time(struct device *dev, struct rtc_time *t)
 248 {
 249         struct ds1307   *ds1307 = dev_get_drvdata(dev);
 250         int             result;
 251         int             tmp;
 252         u8              *buf = ds1307->regs;
 253
 254         dev_dbg(dev, "%s secs=%d, mins=%d, "
 255                 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
 256                 "write", t->tm_sec, t->tm_min,
 257                 t->tm_hour, t->tm_mday,
 258                 t->tm_mon, t->tm_year, t->tm_wday);
 259
 260         *buf++ = 0;             /* first register addr */
 261         buf[DS1307_REG_SECS] = BIN2BCD(t->tm_sec);
 262         buf[DS1307_REG_MIN] = BIN2BCD(t->tm_min);
 263         buf[DS1307_REG_HOUR] = BIN2BCD(t->tm_hour);
 264         buf[DS1307_REG_WDAY] = BIN2BCD(t->tm_wday + 1);
 265         buf[DS1307_REG_MDAY] = BIN2BCD(t->tm_mday);
 266         buf[DS1307_REG_MONTH] = BIN2BCD(t->tm_mon + 1);
 267
 268         /* assume 20YY not 19YY */
 269         tmp = t->tm_year - 100;
 270         buf[DS1307_REG_YEAR] = BIN2BCD(tmp);
 271
 272         switch (ds1307->type) {
 273         case ds_1337:
 274         case ds_1339:
 275                 buf[DS1307_REG_MONTH] |= DS1337_BIT_CENTURY;
 276                 break;
 277         case ds_1340:
 278                 buf[DS1307_REG_HOUR] |= DS1340_BIT_CENTURY_EN
 279                                 | DS1340_BIT_CENTURY;
 280                 break;
 281         default:
 282                 break;
 283         }
 284
 285         ds1307->msg[1].flags = 0;
 286         ds1307->msg[1].len = 8;
 287
 288         dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x\n",
 289                 "write", buf[0], buf[1], buf[2], buf[3],
 290                 buf[4], buf[5], buf[6]);
 291
 292         result = i2c_transfer(to_i2c_adapter(ds1307->client->dev.parent),
 293                         &ds1307->msg[1], 1);
 294         if (result != 1) {
 295                 dev_err(dev, "%s error %d\n", "write", tmp);
 296                 return -EIO;
 297         }
 298         return 0;
 299 }
 300
 301 static int ds1307_read_alarm(struct device *dev, struct rtc_wkalrm *t)
 302 {
 303         struct i2c_client       *client = to_i2c_client(dev);
 304         struct ds1307           *ds1307 = i2c_get_clientdata(client);
 305         int                     ret;
 306
 307         if (!test_bit(HAS_ALARM, &ds1307->flags))
 308                 return -EINVAL;
 309
 310         /* read all ALARM1, ALARM2, and status registers at once */
 311         ds1307->reg_addr = DS1339_REG_ALARM1_SECS;
 312         ds1307->msg[1].flags = I2C_M_RD;
 313         ds1307->msg[1].len = 9;
 314
 315         ret = i2c_transfer(to_i2c_adapter(client->dev.parent),
 316                         ds1307->msg, 2);
 317         if (ret != 2) {
 318                 dev_err(dev, "%s error %d\n", "alarm read", ret);
 319                 return -EIO;
 320         }
 321
 322         dev_dbg(dev, "%s: %02x %02x %02x %02x, %02x %02x %02x, %02x %02x\n",
 323                         "alarm read",
 324                         ds1307->regs[0], ds1307->regs[1],
 325                         ds1307->regs[2], ds1307->regs[3],
 326                         ds1307->regs[4], ds1307->regs[5],
 327                         ds1307->regs[6], ds1307->regs[7],
 328                         ds1307->regs[8]);
 329
 330         /* report alarm time (ALARM1); assume 24 hour and day-of-month modes,
 331          * and that all four fields are checked matches
 332          */
 333         t->time.tm_sec = bcd2bin(ds1307->regs[0] & 0x7f);
 334         t->time.tm_min = bcd2bin(ds1307->regs[1] & 0x7f);
 335         t->time.tm_hour = bcd2bin(ds1307->regs[2] & 0x3f);
 336         t->time.tm_mday = bcd2bin(ds1307->regs[3] & 0x3f);
 337         t->time.tm_mon = -1;
 338         t->time.tm_year = -1;
 339         t->time.tm_wday = -1;
 340         t->time.tm_yday = -1;
 341         t->time.tm_isdst = -1;
 342
 343         /* ... and status */
 344         t->enabled = !!(ds1307->regs[7] & DS1337_BIT_A1IE);
 345         t->pending = !!(ds1307->regs[8] & DS1337_BIT_A1I);
 346
 347         dev_dbg(dev, "%s secs=%d, mins=%d, "
 348                 "hours=%d, mday=%d, enabled=%d, pending=%d\n",
 349                 "alarm read", t->time.tm_sec, t->time.tm_min,
 350                 t->time.tm_hour, t->time.tm_mday,
 351                 t->enabled, t->pending);
 352
 353         return 0;
 354 }
 355
 356 static int ds1307_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 357 {
 358         struct i2c_client       *client = to_i2c_client(dev);
 359         struct ds1307           *ds1307 = i2c_get_clientdata(client);
 360         unsigned char           *buf = ds1307->regs;
 361         u8                      control, status;
 362         int                     ret;
 363
 364         if (!test_bit(HAS_ALARM, &ds1307->flags))
 365                 return -EINVAL;
 366
 367         dev_dbg(dev, "%s secs=%d, mins=%d, "
 368                 "hours=%d, mday=%d, enabled=%d, pending=%d\n",
 369                 "alarm set", t->time.tm_sec, t->time.tm_min,
 370                 t->time.tm_hour, t->time.tm_mday,
 371                 t->enabled, t->pending);
 372
 373         /* read current status of both alarms and the chip */
 374         ds1307->reg_addr = DS1339_REG_ALARM1_SECS;
 375         ds1307->msg[1].flags = I2C_M_RD;
 376         ds1307->msg[1].len = 9;
 377
 378         ret = i2c_transfer(to_i2c_adapter(client->dev.parent),
 379                         ds1307->msg, 2);
 380         if (ret != 2) {
 381                 dev_err(dev, "%s error %d\n", "alarm write", ret);
 382                 return -EIO;
 383         }
 384         control = ds1307->regs[7];
 385         status = ds1307->regs[8];
 386
 387         dev_dbg(dev, "%s: %02x %02x %02x %02x, %02x %02x %02x, %02x %02x\n",
 388                         "alarm set (old status)",
 389                         ds1307->regs[0], ds1307->regs[1],
 390                         ds1307->regs[2], ds1307->regs[3],
 391                         ds1307->regs[4], ds1307->regs[5],
 392                         ds1307->regs[6], control, status);
 393
 394         /* set ALARM1, using 24 hour and day-of-month modes */
 395         *buf++ = DS1339_REG_ALARM1_SECS;        /* first register addr */
 396         buf[0] = bin2bcd(t->time.tm_sec);
 397         buf[1] = bin2bcd(t->time.tm_min);
 398         buf[2] = bin2bcd(t->time.tm_hour);
 399         buf[3] = bin2bcd(t->time.tm_mday);
 400
 401         /* set ALARM2 to non-garbage */
 402         buf[4] = 0;
 403         buf[5] = 0;
 404         buf[6] = 0;
 405
 406         /* optionally enable ALARM1 */
 407         buf[7] = control & ~(DS1337_BIT_A1IE | DS1337_BIT_A2IE);
 408         if (t->enabled) {
 409                 dev_dbg(dev, "alarm IRQ armed\n");
 410                 buf[7] |= DS1337_BIT_A1IE;      /* only ALARM1 is used */
 411         }
 412         buf[8] = status & ~(DS1337_BIT_A1I | DS1337_BIT_A2I);
 413
 414         ds1307->msg[1].flags = 0;
 415         ds1307->msg[1].len = 10;
 416
 417         ret = i2c_transfer(to_i2c_adapter(client->dev.parent),
 418                         &ds1307->msg[1], 1);
 419         if (ret != 1) {
 420                 dev_err(dev, "can't set alarm time\n");
 421                 return -EIO;
 422         }
 423
 424         return 0;
 425 }
 426
 427 static int ds1307_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 428 {
 429         struct i2c_client       *client = to_i2c_client(dev);
 430         struct ds1307           *ds1307 = i2c_get_clientdata(client);
 431         int                     ret;
 432
 433         switch (cmd) {
 434         case RTC_AIE_OFF:
 435                 if (!test_bit(HAS_ALARM, &ds1307->flags))
 436                         return -ENOTTY;
 437
 438                 ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
 439                 if (ret < 0)
 440                         return ret;
 441
 442                 ret &= ~DS1337_BIT_A1IE;
 443
 444                 ret = i2c_smbus_write_byte_data(client,
 445                                                 DS1337_REG_CONTROL, ret);
 446                 if (ret < 0)
 447                         return ret;
 448
 449                 break;
 450
 451         case RTC_AIE_ON:
 452                 if (!test_bit(HAS_ALARM, &ds1307->flags))
 453                         return -ENOTTY;
 454
 455                 ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
 456                 if (ret < 0)
 457                         return ret;
 458
 459                 ret |= DS1337_BIT_A1IE;
 460
 461                 ret = i2c_smbus_write_byte_data(client,
 462                                                 DS1337_REG_CONTROL, ret);
 463                 if (ret < 0)
 464                         return ret;
 465
 466                 break;
 467
 468         default:
 469                 return -ENOIOCTLCMD;
 470         }
 471
 472         return 0;
 473 }
 474
 475 static const struct rtc_class_ops ds13xx_rtc_ops = {
 476         .read_time      = ds1307_get_time,
 477         .set_time       = ds1307_set_time,
 478         .read_alarm     = ds1307_read_alarm,
 479         .set_alarm      = ds1307_set_alarm,
 480         .ioctl          = ds1307_ioctl,
 481 };
 482
 483 /*----------------------------------------------------------------------*/
 484
 485 #define NVRAM_SIZE      56
 486
 487 static ssize_t
 488 ds1307_nvram_read(struct kobject *kobj, struct bin_attribute *attr,
 489                 char *buf, loff_t off, size_t count)
 490 {
 491         struct i2c_client       *client;
 492         struct ds1307           *ds1307;
 493         struct i2c_msg          msg[2];
 494         int                     result;
 495
 496         client = kobj_to_i2c_client(kobj);
 497         ds1307 = i2c_get_clientdata(client);
 498
 499         if (unlikely(off >= NVRAM_SIZE))
 500                 return 0;
 501         if ((off + count) > NVRAM_SIZE)
 502                 count = NVRAM_SIZE - off;
 503         if (unlikely(!count))
 504                 return count;
 505
 506         msg[0].addr = client->addr;
 507         msg[0].flags = 0;
 508         msg[0].len = 1;
 509         msg[0].buf = buf;
 510
 511         buf[0] = 8 + off;
 512
 513         msg[1].addr = client->addr;
 514         msg[1].flags = I2C_M_RD;
 515         msg[1].len = count;
 516         msg[1].buf = buf;
 517
 518         result = i2c_transfer(to_i2c_adapter(client->dev.parent), msg, 2);
 519         if (result != 2) {
 520                 dev_err(&client->dev, "%s error %d\n", "nvram read", result);
 521                 return -EIO;
 522         }
 523         return count;
 524 }
 525
 526 static ssize_t
 527 ds1307_nvram_write(struct kobject *kobj, struct bin_attribute *attr,
 528                 char *buf, loff_t off, size_t count)
 529 {
 530         struct i2c_client       *client;
 531         u8                      buffer[NVRAM_SIZE + 1];
 532         int                     ret;
 533
 534         client = kobj_to_i2c_client(kobj);
 535
 536         if (unlikely(off >= NVRAM_SIZE))
 537                 return -EFBIG;
 538         if ((off + count) > NVRAM_SIZE)
 539                 count = NVRAM_SIZE - off;
 540         if (unlikely(!count))
 541                 return count;
 542
 543         buffer[0] = 8 + off;
 544         memcpy(buffer + 1, buf, count);
 545
 546         ret = i2c_master_send(client, buffer, count + 1);
 547         return (ret < 0) ? ret : (ret - 1);
 548 }
 549
 550 static struct bin_attribute nvram = {
 551         .attr = {
 552                 .name   = "nvram",
 553                 .mode   = S_IRUGO | S_IWUSR,
 554                 .owner  = THIS_MODULE,
 555         },
 556
 557         .read   = ds1307_nvram_read,
 558         .write  = ds1307_nvram_write,
 559         .size   = NVRAM_SIZE,
 560 };
 561
 562 /*----------------------------------------------------------------------*/
 563
 564 static struct i2c_driver ds1307_driver;
 565
 566 static int __devinit ds1307_probe(struct i2c_client *client,
 567                                   const struct i2c_device_id *id)
 568 {
 569         struct ds1307           *ds1307;
 570         int                     err = -ENODEV;
 571         int                     tmp;
 572         const struct chip_desc  *chip = &chips[id->driver_data];
 573         struct i2c_adapter      *adapter = to_i2c_adapter(client->dev.parent);
 574         int                     want_irq = false;
 575
 576         if (!i2c_check_functionality(adapter,
 577                         I2C_FUNC_I2C | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
 578                 return -EIO;
 579
 580         if (!(ds1307 = kzalloc(sizeof(struct ds1307), GFP_KERNEL)))
 581                 return -ENOMEM;
 582
 583         ds1307->client = client;
 584         i2c_set_clientdata(client, ds1307);
 585
 586         ds1307->msg[0].addr = client->addr;
 587         ds1307->msg[0].flags = 0;
 588         ds1307->msg[0].len = 1;
 589         ds1307->msg[0].buf = &ds1307->reg_addr;
 590
 591         ds1307->msg[1].addr = client->addr;
 592         ds1307->msg[1].flags = I2C_M_RD;
 593         ds1307->msg[1].len = sizeof(ds1307->regs);
 594         ds1307->msg[1].buf = ds1307->regs;
 595
 596         ds1307->type = id->driver_data;
 597
 598         switch (ds1307->type) {
 599         case ds_1337:
 600         case ds_1339:
 601                 /* has IRQ? */
 602                 if (ds1307->client->irq > 0 && chip->alarm) {
 603                         INIT_WORK(&ds1307->work, ds1307_work);
 604                         want_irq = true;
 605                 }
 606
 607                 ds1307->reg_addr = DS1337_REG_CONTROL;
 608                 ds1307->msg[1].len = 2;
 609
 610                 /* get registers that the "rtc" read below won't read... */
 611                 tmp = i2c_transfer(adapter, ds1307->msg, 2);
 612                 if (tmp != 2) {
 613                         pr_debug("read error %d\n", tmp);
 614                         err = -EIO;
 615                         goto exit_free;
 616                 }
 617
 618                 ds1307->reg_addr = 0;
 619                 ds1307->msg[1].len = sizeof(ds1307->regs);
 620
 621                 /* oscillator off?  turn it on, so clock can tick. */
 622                 if (ds1307->regs[0] & DS1337_BIT_nEOSC)
 623                         ds1307->regs[0] &= ~DS1337_BIT_nEOSC;
 624
 625                 /* Using IRQ?  Disable the square wave and both alarms.
 626                  * For ds1339, be sure alarms can trigger when we're
 627                  * running on Vbackup (BBSQI); we assume ds1337 will
 628                  * ignore that bit
 629                  */
 630                 if (want_irq) {
 631                         ds1307->regs[0] |= DS1337_BIT_INTCN | DS1339_BIT_BBSQI;
 632                         ds1307->regs[0] &= ~(DS1337_BIT_A2IE | DS1337_BIT_A1IE);
 633                 }
 634
 635                 i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL,
 636                                                         ds1307->regs[0]);
 637
 638                 /* oscillator fault?  clear flag, and warn */
 639                 if (ds1307->regs[1] & DS1337_BIT_OSF) {
 640                         i2c_smbus_write_byte_data(client, DS1337_REG_STATUS,
 641                                 ds1307->regs[1] & ~DS1337_BIT_OSF);
 642                         dev_warn(&client->dev, "SET TIME!\n");
 643                 }
 644                 break;
 645         default:
 646                 break;
 647         }
 648
 649 read_rtc:
 650         /* read RTC registers */
 651
 652         tmp = i2c_transfer(adapter, ds1307->msg, 2);
 653         if (tmp != 2) {
 654                 pr_debug("read error %d\n", tmp);
 655                 err = -EIO;
 656                 goto exit_free;
 657         }
 658
 659         /* minimal sanity checking; some chips (like DS1340) don't
 660          * specify the extra bits as must-be-zero, but there are
 661          * still a few values that are clearly out-of-range.
 662          */
 663         tmp = ds1307->regs[DS1307_REG_SECS];
 664         switch (ds1307->type) {
 665         case ds_1307:
 666         case m41t00:
 667                 /* clock halted?  turn it on, so clock can tick. */
 668                 if (tmp & DS1307_BIT_CH) {
 669                         i2c_smbus_write_byte_data(client, DS1307_REG_SECS, 0);
 670                         dev_warn(&client->dev, "SET TIME!\n");
 671                         goto read_rtc;
 672                 }
 673                 break;
 674         case ds_1338:
 675                 /* clock halted?  turn it on, so clock can tick. */
 676                 if (tmp & DS1307_BIT_CH)
 677                         i2c_smbus_write_byte_data(client, DS1307_REG_SECS, 0);
 678
 679                 /* oscillator fault?  clear flag, and warn */
 680                 if (ds1307->regs[DS1307_REG_CONTROL] & DS1338_BIT_OSF) {
 681                         i2c_smbus_write_byte_data(client, DS1307_REG_CONTROL,
 682                                         ds1307->regs[DS1307_REG_CONTROL]
 683                                         & ~DS1338_BIT_OSF);
 684                         dev_warn(&client->dev, "SET TIME!\n");
 685                         goto read_rtc;
 686                 }
 687                 break;
 688         case ds_1340:
 689                 /* clock halted?  turn it on, so clock can tick. */
 690                 if (tmp & DS1340_BIT_nEOSC)
 691                         i2c_smbus_write_byte_data(client, DS1307_REG_SECS, 0);
 692
 693                 tmp = i2c_smbus_read_byte_data(client, DS1340_REG_FLAG);
 694                 if (tmp < 0) {
 695                         pr_debug("read error %d\n", tmp);
 696                         err = -EIO;
 697                         goto exit_free;
 698                 }
 699
 700                 /* oscillator fault?  clear flag, and warn */
 701                 if (tmp & DS1340_BIT_OSF) {
 702                         i2c_smbus_write_byte_data(client, DS1340_REG_FLAG, 0);
 703                         dev_warn(&client->dev, "SET TIME!\n");
 704                 }
 705                 break;
 706         case ds_1337:
 707         case ds_1339:
 708                 break;
 709         }
 710
 711         tmp = ds1307->regs[DS1307_REG_SECS];
 712         tmp = BCD2BIN(tmp & 0x7f);
 713         if (tmp > 60)
 714                 goto exit_bad;
 715         tmp = BCD2BIN(ds1307->regs[DS1307_REG_MIN] & 0x7f);
 716         if (tmp > 60)
 717                 goto exit_bad;
 718
 719         tmp = BCD2BIN(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
 720         if (tmp == 0 || tmp > 31)
 721                 goto exit_bad;
 722
 723         tmp = BCD2BIN(ds1307->regs[DS1307_REG_MONTH] & 0x1f);
 724         if (tmp == 0 || tmp > 12)
 725                 goto exit_bad;
 726
 727         tmp = ds1307->regs[DS1307_REG_HOUR];
 728         switch (ds1307->type) {
 729         case ds_1340:
 730         case m41t00:
 731                 /* NOTE: ignores century bits; fix before deploying
 732                  * systems that will run through year 2100.
 733                  */
 734                 break;
 735         default:
 736                 if (!(tmp & DS1307_BIT_12HR))
 737                         break;
 738
 739                 /* Be sure we're in 24 hour mode.  Multi-master systems
 740                  * take note...
 741                  */
 742                 tmp = BCD2BIN(tmp & 0x1f);
 743                 if (tmp == 12)
 744                         tmp = 0;
 745                 if (ds1307->regs[DS1307_REG_HOUR] & DS1307_BIT_PM)
 746                         tmp += 12;
 747                 i2c_smbus_write_byte_data(client,
 748                                 DS1307_REG_HOUR,
 749                                 BIN2BCD(tmp));
 750         }
 751
 752         ds1307->rtc = rtc_device_register(client->name, &client->dev,
 753                                 &ds13xx_rtc_ops, THIS_MODULE);
 754         if (IS_ERR(ds1307->rtc)) {
 755                 err = PTR_ERR(ds1307->rtc);
 756                 dev_err(&client->dev,
 757                         "unable to register the class device\n");
 758                 goto exit_free;
 759         }
 760
 761         if (want_irq) {
 762                 err = request_irq(client->irq, ds1307_irq, 0,
 763                           ds1307->rtc->name, client);
 764                 if (err) {
 765                         dev_err(&client->dev,
 766                                 "unable to request IRQ!\n");
 767                         goto exit_irq;
 768                 }
 769                 set_bit(HAS_ALARM, &ds1307->flags);
 770                 dev_dbg(&client->dev, "got IRQ %d\n", client->irq);
 771         }
 772
 773         if (chip->nvram56) {
 774                 err = sysfs_create_bin_file(&client->dev.kobj, &nvram);
 775                 if (err == 0) {
 776                         set_bit(HAS_NVRAM, &ds1307->flags);
 777                         dev_info(&client->dev, "56 bytes nvram\n");
 778                 }
 779         }
 780
 781         return 0;
 782
 783 exit_bad:
 784         dev_dbg(&client->dev, "%s: %02x %02x %02x %02x %02x %02x %02x\n",
 785                         "bogus register",
 786                         ds1307->regs[0], ds1307->regs[1],
 787                         ds1307->regs[2], ds1307->regs[3],
 788                         ds1307->regs[4], ds1307->regs[5],
 789                         ds1307->regs[6]);
 790 exit_irq:
 791         if (ds1307->rtc)
 792                 rtc_device_unregister(ds1307->rtc);
 793 exit_free:
 794         kfree(ds1307);
 795         return err;
 796 }
 797
 798 static int __devexit ds1307_remove(struct i2c_client *client)
 799 {
 800         struct ds1307           *ds1307 = i2c_get_clientdata(client);
 801
 802         if (test_and_clear_bit(HAS_ALARM, &ds1307->flags)) {
 803                 free_irq(client->irq, client);
 804                 cancel_work_sync(&ds1307->work);
 805         }
 806
 807         if (test_and_clear_bit(HAS_NVRAM, &ds1307->flags))
 808                 sysfs_remove_bin_file(&client->dev.kobj, &nvram);
 809
 810         rtc_device_unregister(ds1307->rtc);
 811         kfree(ds1307);
 812         return 0;
 813 }
 814
 815 static struct i2c_driver ds1307_driver = {
 816         .driver = {
 817                 .name   = "rtc-ds1307",
 818                 .owner  = THIS_MODULE,
 819         },
 820         .probe          = ds1307_probe,
 821         .remove         = __devexit_p(ds1307_remove),
 822         .id_table       = ds1307_id,
 823 };
 824
 825 static int __init ds1307_init(void)
 826 {
 827         return i2c_add_driver(&ds1307_driver);
 828 }
 829 module_init(ds1307_init);
 830
 831 static void __exit ds1307_exit(void)
 832 {
 833         i2c_del_driver(&ds1307_driver);
 834 }
 835 module_exit(ds1307_exit);
 836
 837 MODULE_DESCRIPTION("RTC driver for DS1307 and similar chips");
 838 MODULE_LICENSE("GPL");