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