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 }, 555 556 .read = ds1307_nvram_read, 557 .write = ds1307_nvram_write, 558 .size = NVRAM_SIZE, 559 }; 560 561 /*----------------------------------------------------------------------*/ 562 563 static struct i2c_driver ds1307_driver; 564 565 static int __devinit ds1307_probe(struct i2c_client *client, 566 const struct i2c_device_id *id) 567 { 568 struct ds1307 *ds1307; 569 int err = -ENODEV; 570 int tmp; 571 const struct chip_desc *chip = &chips[id->driver_data]; 572 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); 573 int want_irq = false; 574 575 if (!i2c_check_functionality(adapter, 576 I2C_FUNC_I2C | I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) 577 return -EIO; 578 579 if (!(ds1307 = kzalloc(sizeof(struct ds1307), GFP_KERNEL))) 580 return -ENOMEM; 581 582 ds1307->client = client; 583 i2c_set_clientdata(client, ds1307); 584 585 ds1307->msg[0].addr = client->addr; 586 ds1307->msg[0].flags = 0; 587 ds1307->msg[0].len = 1; 588 ds1307->msg[0].buf = &ds1307->reg_addr; 589 590 ds1307->msg[1].addr = client->addr; 591 ds1307->msg[1].flags = I2C_M_RD; 592 ds1307->msg[1].len = sizeof(ds1307->regs); 593 ds1307->msg[1].buf = ds1307->regs; 594 595 ds1307->type = id->driver_data; 596 597 switch (ds1307->type) { 598 case ds_1337: 599 case ds_1339: 600 /* has IRQ? */ 601 if (ds1307->client->irq > 0 && chip->alarm) { 602 INIT_WORK(&ds1307->work, ds1307_work); 603 want_irq = true; 604 } 605 606 ds1307->reg_addr = DS1337_REG_CONTROL; 607 ds1307->msg[1].len = 2; 608 609 /* get registers that the "rtc" read below won't read... */ 610 tmp = i2c_transfer(adapter, ds1307->msg, 2); 611 if (tmp != 2) { 612 pr_debug("read error %d\n", tmp); 613 err = -EIO; 614 goto exit_free; 615 } 616 617 ds1307->reg_addr = 0; 618 ds1307->msg[1].len = sizeof(ds1307->regs); 619 620 /* oscillator off? turn it on, so clock can tick. */ 621 if (ds1307->regs[0] & DS1337_BIT_nEOSC) 622 ds1307->regs[0] &= ~DS1337_BIT_nEOSC; 623 624 /* Using IRQ? Disable the square wave and both alarms. 625 * For ds1339, be sure alarms can trigger when we're 626 * running on Vbackup (BBSQI); we assume ds1337 will 627 * ignore that bit 628 */ 629 if (want_irq) { 630 ds1307->regs[0] |= DS1337_BIT_INTCN | DS1339_BIT_BBSQI; 631 ds1307->regs[0] &= ~(DS1337_BIT_A2IE | DS1337_BIT_A1IE); 632 } 633 634 i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL, 635 ds1307->regs[0]); 636 637 /* oscillator fault? clear flag, and warn */ 638 if (ds1307->regs[1] & DS1337_BIT_OSF) { 639 i2c_smbus_write_byte_data(client, DS1337_REG_STATUS, 640 ds1307->regs[1] & ~DS1337_BIT_OSF); 641 dev_warn(&client->dev, "SET TIME!\n"); 642 } 643 break; 644 default: 645 break; 646 } 647 648 read_rtc: 649 /* read RTC registers */ 650 651 tmp = i2c_transfer(adapter, ds1307->msg, 2); 652 if (tmp != 2) { 653 pr_debug("read error %d\n", tmp); 654 err = -EIO; 655 goto exit_free; 656 } 657 658 /* minimal sanity checking; some chips (like DS1340) don't 659 * specify the extra bits as must-be-zero, but there are 660 * still a few values that are clearly out-of-range. 661 */ 662 tmp = ds1307->regs[DS1307_REG_SECS]; 663 switch (ds1307->type) { 664 case ds_1307: 665 case m41t00: 666 /* clock halted? turn it on, so clock can tick. */ 667 if (tmp & DS1307_BIT_CH) { 668 i2c_smbus_write_byte_data(client, DS1307_REG_SECS, 0); 669 dev_warn(&client->dev, "SET TIME!\n"); 670 goto read_rtc; 671 } 672 break; 673 case ds_1338: 674 /* clock halted? turn it on, so clock can tick. */ 675 if (tmp & DS1307_BIT_CH) 676 i2c_smbus_write_byte_data(client, DS1307_REG_SECS, 0); 677 678 /* oscillator fault? clear flag, and warn */ 679 if (ds1307->regs[DS1307_REG_CONTROL] & DS1338_BIT_OSF) { 680 i2c_smbus_write_byte_data(client, DS1307_REG_CONTROL, 681 ds1307->regs[DS1307_REG_CONTROL] 682 & ~DS1338_BIT_OSF); 683 dev_warn(&client->dev, "SET TIME!\n"); 684 goto read_rtc; 685 } 686 break; 687 case ds_1340: 688 /* clock halted? turn it on, so clock can tick. */ 689 if (tmp & DS1340_BIT_nEOSC) 690 i2c_smbus_write_byte_data(client, DS1307_REG_SECS, 0); 691 692 tmp = i2c_smbus_read_byte_data(client, DS1340_REG_FLAG); 693 if (tmp < 0) { 694 pr_debug("read error %d\n", tmp); 695 err = -EIO; 696 goto exit_free; 697 } 698 699 /* oscillator fault? clear flag, and warn */ 700 if (tmp & DS1340_BIT_OSF) { 701 i2c_smbus_write_byte_data(client, DS1340_REG_FLAG, 0); 702 dev_warn(&client->dev, "SET TIME!\n"); 703 } 704 break; 705 case ds_1337: 706 case ds_1339: 707 break; 708 } 709 710 tmp = ds1307->regs[DS1307_REG_SECS]; 711 tmp = bcd2bin(tmp & 0x7f); 712 if (tmp > 60) 713 goto exit_bad; 714 tmp = bcd2bin(ds1307->regs[DS1307_REG_MIN] & 0x7f); 715 if (tmp > 60) 716 goto exit_bad; 717 718 tmp = bcd2bin(ds1307->regs[DS1307_REG_MDAY] & 0x3f); 719 if (tmp == 0 || tmp > 31) 720 goto exit_bad; 721 722 tmp = bcd2bin(ds1307->regs[DS1307_REG_MONTH] & 0x1f); 723 if (tmp == 0 || tmp > 12) 724 goto exit_bad; 725 726 tmp = ds1307->regs[DS1307_REG_HOUR]; 727 switch (ds1307->type) { 728 case ds_1340: 729 case m41t00: 730 /* NOTE: ignores century bits; fix before deploying 731 * systems that will run through year 2100. 732 */ 733 break; 734 default: 735 if (!(tmp & DS1307_BIT_12HR)) 736 break; 737 738 /* Be sure we're in 24 hour mode. Multi-master systems 739 * take note... 740 */ 741 tmp = bcd2bin(tmp & 0x1f); 742 if (tmp == 12) 743 tmp = 0; 744 if (ds1307->regs[DS1307_REG_HOUR] & DS1307_BIT_PM) 745 tmp += 12; 746 i2c_smbus_write_byte_data(client, 747 DS1307_REG_HOUR, 748 bin2bcd(tmp)); 749 } 750 751 ds1307->rtc = rtc_device_register(client->name, &client->dev, 752 &ds13xx_rtc_ops, THIS_MODULE); 753 if (IS_ERR(ds1307->rtc)) { 754 err = PTR_ERR(ds1307->rtc); 755 dev_err(&client->dev, 756 "unable to register the class device\n"); 757 goto exit_free; 758 } 759 760 if (want_irq) { 761 err = request_irq(client->irq, ds1307_irq, 0, 762 ds1307->rtc->name, client); 763 if (err) { 764 dev_err(&client->dev, 765 "unable to request IRQ!\n"); 766 goto exit_irq; 767 } 768 set_bit(HAS_ALARM, &ds1307->flags); 769 dev_dbg(&client->dev, "got IRQ %d\n", client->irq); 770 } 771 772 if (chip->nvram56) { 773 err = sysfs_create_bin_file(&client->dev.kobj, &nvram); 774 if (err == 0) { 775 set_bit(HAS_NVRAM, &ds1307->flags); 776 dev_info(&client->dev, "56 bytes nvram\n"); 777 } 778 } 779 780 return 0; 781 782 exit_bad: 783 dev_dbg(&client->dev, "%s: %02x %02x %02x %02x %02x %02x %02x\n", 784 "bogus register", 785 ds1307->regs[0], ds1307->regs[1], 786 ds1307->regs[2], ds1307->regs[3], 787 ds1307->regs[4], ds1307->regs[5], 788 ds1307->regs[6]); 789 exit_irq: 790 if (ds1307->rtc) 791 rtc_device_unregister(ds1307->rtc); 792 exit_free: 793 kfree(ds1307); 794 return err; 795 } 796 797 static int __devexit ds1307_remove(struct i2c_client *client) 798 { 799 struct ds1307 *ds1307 = i2c_get_clientdata(client); 800 801 if (test_and_clear_bit(HAS_ALARM, &ds1307->flags)) { 802 free_irq(client->irq, client); 803 cancel_work_sync(&ds1307->work); 804 } 805 806 if (test_and_clear_bit(HAS_NVRAM, &ds1307->flags)) 807 sysfs_remove_bin_file(&client->dev.kobj, &nvram); 808 809 rtc_device_unregister(ds1307->rtc); 810 kfree(ds1307); 811 return 0; 812 } 813 814 static struct i2c_driver ds1307_driver = { 815 .driver = { 816 .name = "rtc-ds1307", 817 .owner = THIS_MODULE, 818 }, 819 .probe = ds1307_probe, 820 .remove = __devexit_p(ds1307_remove), 821 .id_table = ds1307_id, 822 }; 823 824 static int __init ds1307_init(void) 825 { 826 return i2c_add_driver(&ds1307_driver); 827 } 828 module_init(ds1307_init); 829 830 static void __exit ds1307_exit(void) 831 { 832 i2c_del_driver(&ds1307_driver); 833 } 834 module_exit(ds1307_exit); 835 836 MODULE_DESCRIPTION("RTC driver for DS1307 and similar chips"); 837 MODULE_LICENSE("GPL"); 838