2 * x1205.c - An i2c driver for the Xicor X1205 RTC
3 * Copyright 2004 Karen Spearel
4 * Copyright 2005 Alessandro Zummo
6 * please send all reports to:
7 * kas11 at tampabay dot rr dot com
8 * a dot zummo at towertech dot it
10 * based on the other drivers in this same directory.
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/i2c.h>
22 #include <linux/string.h>
23 #include <linux/bcd.h>
24 #include <linux/rtc.h>
25 #include <linux/list.h>
27 #include <linux/x1205.h>
29 #define DRV_VERSION "0.9.9"
31 /* Addresses to scan: none. This chip is located at
32 * 0x6f and uses a two bytes register addressing.
33 * Two bytes need to be written to read a single register,
34 * while most other chips just require one and take the second
35 * one as the data to be written. To prevent corrupting
36 * unknown chips, the user must explicitely set the probe parameter.
39 static unsigned short normal_i2c
[] = { I2C_CLIENT_END
};
41 /* Insmod parameters */
43 I2C_CLIENT_MODULE_PARM(hctosys
,
44 "Set the system time from the hardware clock upon initialization");
46 /* offsets into CCR area */
57 #define X1205_REG_SR 0x3F /* status register */
58 #define X1205_REG_Y2K 0x37
59 #define X1205_REG_DW 0x36
60 #define X1205_REG_YR 0x35
61 #define X1205_REG_MO 0x34
62 #define X1205_REG_DT 0x33
63 #define X1205_REG_HR 0x32
64 #define X1205_REG_MN 0x31
65 #define X1205_REG_SC 0x30
66 #define X1205_REG_DTR 0x13
67 #define X1205_REG_ATR 0x12
68 #define X1205_REG_INT 0x11
69 #define X1205_REG_0 0x10
70 #define X1205_REG_Y2K1 0x0F
71 #define X1205_REG_DWA1 0x0E
72 #define X1205_REG_YRA1 0x0D
73 #define X1205_REG_MOA1 0x0C
74 #define X1205_REG_DTA1 0x0B
75 #define X1205_REG_HRA1 0x0A
76 #define X1205_REG_MNA1 0x09
77 #define X1205_REG_SCA1 0x08
78 #define X1205_REG_Y2K0 0x07
79 #define X1205_REG_DWA0 0x06
80 #define X1205_REG_YRA0 0x05
81 #define X1205_REG_MOA0 0x04
82 #define X1205_REG_DTA0 0x03
83 #define X1205_REG_HRA0 0x02
84 #define X1205_REG_MNA0 0x01
85 #define X1205_REG_SCA0 0x00
87 #define X1205_CCR_BASE 0x30 /* Base address of CCR */
88 #define X1205_ALM0_BASE 0x00 /* Base address of ALARM0 */
90 #define X1205_SR_RTCF 0x01 /* Clock failure */
91 #define X1205_SR_WEL 0x02 /* Write Enable Latch */
92 #define X1205_SR_RWEL 0x04 /* Register Write Enable */
94 #define X1205_DTR_DTR0 0x01
95 #define X1205_DTR_DTR1 0x02
96 #define X1205_DTR_DTR2 0x04
98 #define X1205_HR_MIL 0x80 /* Set in ccr.hour for 24 hr mode */
101 static int x1205_attach(struct i2c_adapter
*adapter
);
102 static int x1205_detach(struct i2c_client
*client
);
103 static int x1205_probe(struct i2c_adapter
*adapter
, int address
, int kind
);
104 static int x1205_command(struct i2c_client
*client
, unsigned int cmd
,
107 static struct i2c_driver x1205_driver
= {
109 .owner
= THIS_MODULE
,
112 .attach_adapter
= &x1205_attach
,
113 .detach_client
= &x1205_detach
,
117 struct i2c_client client
;
118 struct list_head list
;
122 static const unsigned char days_in_mo
[] =
123 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
125 static LIST_HEAD(x1205_clients
);
127 /* Workaround until the I2C subsytem will allow to send
128 * commands to a specific client. This function will send the command
129 * to the first client.
131 int x1205_do_command(unsigned int cmd
, void *arg
)
133 struct list_head
*walk
;
134 struct list_head
*tmp
;
135 struct x1205_data
*data
;
137 list_for_each_safe(walk
, tmp
, &x1205_clients
) {
138 data
= list_entry(walk
, struct x1205_data
, list
);
139 return x1205_command(&data
->client
, cmd
, arg
);
145 #define is_leap(year) \
146 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
148 /* make sure the rtc_time values are in bounds */
149 static int x1205_validate_tm(struct rtc_time
*tm
)
151 int year
= tm
->tm_year
+ 1900;
153 if ((tm
->tm_year
< 70) || (tm
->tm_year
> 255))
156 if ((tm
->tm_mon
> 11) || (tm
->tm_mday
== 0))
159 if (tm
->tm_mday
> days_in_mo
[tm
->tm_mon
]
160 + ((tm
->tm_mon
== 1) && is_leap(year
)))
163 if ((tm
->tm_hour
>= 24) || (tm
->tm_min
>= 60) || (tm
->tm_sec
>= 60))
170 * In the routines that deal directly with the x1205 hardware, we use
171 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
172 * Epoch is initialized as 2000. Time is set to UTC.
174 static int x1205_get_datetime(struct i2c_client
*client
, struct rtc_time
*tm
,
177 unsigned char dt_addr
[2] = { 0, reg_base
};
178 static unsigned char sr_addr
[2] = { 0, X1205_REG_SR
};
180 unsigned char buf
[8], sr
;
182 struct i2c_msg msgs
[] = {
183 { client
->addr
, 0, 2, sr_addr
}, /* setup read ptr */
184 { client
->addr
, I2C_M_RD
, 1, &sr
}, /* read status */
185 { client
->addr
, 0, 2, dt_addr
}, /* setup read ptr */
186 { client
->addr
, I2C_M_RD
, 8, buf
}, /* read date */
189 struct x1205_data
*data
= i2c_get_clientdata(client
);
191 /* read status register */
192 if ((i2c_transfer(client
->adapter
, &msgs
[0], 2)) != 2) {
193 dev_err(&client
->dev
, "%s: read error\n", __FUNCTION__
);
197 /* check for battery failure */
198 if (sr
& X1205_SR_RTCF
) {
199 dev_warn(&client
->dev
,
200 "Clock had a power failure, you must set the date.\n");
204 /* read date registers */
205 if ((i2c_transfer(client
->adapter
, &msgs
[2], 2)) != 2) {
206 dev_err(&client
->dev
, "%s: read error\n", __FUNCTION__
);
210 dev_dbg(&client
->dev
,
211 "%s: raw read data - sec=%02x, min=%02x, hr=%02x, "
212 "mday=%02x, mon=%02x, year=%02x, wday=%02x, y2k=%02x\n",
214 buf
[0], buf
[1], buf
[2], buf
[3],
215 buf
[4], buf
[5], buf
[6], buf
[7]);
217 tm
->tm_sec
= BCD2BIN(buf
[CCR_SEC
]);
218 tm
->tm_min
= BCD2BIN(buf
[CCR_MIN
]);
219 tm
->tm_hour
= BCD2BIN(buf
[CCR_HOUR
] & 0x3F); /* hr is 0-23 */
220 tm
->tm_mday
= BCD2BIN(buf
[CCR_MDAY
]);
221 tm
->tm_mon
= BCD2BIN(buf
[CCR_MONTH
]);
222 data
->epoch
= BCD2BIN(buf
[CCR_Y2K
]) * 100;
223 tm
->tm_year
= BCD2BIN(buf
[CCR_YEAR
]) + data
->epoch
- 1900;
224 tm
->tm_wday
= buf
[CCR_WDAY
];
226 dev_dbg(&client
->dev
, "%s: tm is secs=%d, mins=%d, hours=%d, "
227 "mday=%d, mon=%d, year=%d, wday=%d\n",
229 tm
->tm_sec
, tm
->tm_min
, tm
->tm_hour
,
230 tm
->tm_mday
, tm
->tm_mon
, tm
->tm_year
, tm
->tm_wday
);
235 static int x1205_set_datetime(struct i2c_client
*client
, struct rtc_time
*tm
,
236 int datetoo
, u8 reg_base
)
240 unsigned char buf
[8];
242 static const unsigned char wel
[3] = { 0, X1205_REG_SR
,
245 static const unsigned char rwel
[3] = { 0, X1205_REG_SR
,
246 X1205_SR_WEL
| X1205_SR_RWEL
};
248 static const unsigned char diswe
[3] = { 0, X1205_REG_SR
, 0 };
250 struct x1205_data
*data
= i2c_get_clientdata(client
);
252 /* check if all values in the tm struct are correct */
253 if ((err
= x1205_validate_tm(tm
)) < 0)
256 dev_dbg(&client
->dev
, "%s: secs=%d, mins=%d, hours=%d, "
257 "mday=%d, mon=%d, year=%d, wday=%d\n",
259 tm
->tm_sec
, tm
->tm_min
, tm
->tm_hour
,
260 tm
->tm_mday
, tm
->tm_mon
, tm
->tm_year
, tm
->tm_wday
);
262 buf
[CCR_SEC
] = BIN2BCD(tm
->tm_sec
);
263 buf
[CCR_MIN
] = BIN2BCD(tm
->tm_min
);
265 /* set hour and 24hr bit */
266 buf
[CCR_HOUR
] = BIN2BCD(tm
->tm_hour
) | X1205_HR_MIL
;
268 /* should we also set the date? */
270 buf
[CCR_MDAY
] = BIN2BCD(tm
->tm_mday
);
273 buf
[CCR_MONTH
] = BIN2BCD(tm
->tm_mon
);
275 /* year, since 1900 */
276 buf
[CCR_YEAR
] = BIN2BCD(tm
->tm_year
+ 1900 - data
->epoch
);
277 buf
[CCR_WDAY
] = tm
->tm_wday
& 0x07;
278 buf
[CCR_Y2K
] = BIN2BCD(data
->epoch
/ 100);
281 /* this sequence is required to unlock the chip */
282 xfer
= i2c_master_send(client
, wel
, 3);
284 dev_err(&client
->dev
, "%s: wel - %d\n", __FUNCTION__
, xfer
);
288 xfer
= i2c_master_send(client
, rwel
, 3);
290 dev_err(&client
->dev
, "%s: rwel - %d\n", __FUNCTION__
, xfer
);
294 /* write register's data */
295 for (i
= 0; i
< (datetoo
? 8 : 3); i
++) {
296 unsigned char rdata
[3] = { 0, reg_base
+ i
, buf
[i
] };
298 xfer
= i2c_master_send(client
, rdata
, 3);
300 dev_err(&client
->dev
,
301 "%s: xfer=%d addr=%02x, data=%02x\n",
303 xfer
, rdata
[1], rdata
[2]);
308 /* disable further writes */
309 xfer
= i2c_master_send(client
, diswe
, 3);
311 dev_err(&client
->dev
, "%s: diswe - %d\n", __FUNCTION__
, xfer
);
318 static int x1205_get_dtrim(struct i2c_client
*client
, int *trim
)
321 static unsigned char dtr_addr
[2] = { 0, X1205_REG_DTR
};
323 struct i2c_msg msgs
[] = {
324 { client
->addr
, 0, 2, dtr_addr
}, /* setup read ptr */
325 { client
->addr
, I2C_M_RD
, 1, &dtr
}, /* read dtr */
328 /* read dtr register */
329 if ((i2c_transfer(client
->adapter
, &msgs
[0], 2)) != 2) {
330 dev_err(&client
->dev
, "%s: read error\n", __FUNCTION__
);
334 dev_dbg(&client
->dev
, "%s: raw dtr=%x\n", __FUNCTION__
, dtr
);
338 if (dtr
& X1205_DTR_DTR0
)
341 if (dtr
& X1205_DTR_DTR1
)
344 if (dtr
& X1205_DTR_DTR2
)
350 static int x1205_get_atrim(struct i2c_client
*client
, int *trim
)
353 static unsigned char atr_addr
[2] = { 0, X1205_REG_ATR
};
355 struct i2c_msg msgs
[] = {
356 { client
->addr
, 0, 2, atr_addr
}, /* setup read ptr */
357 { client
->addr
, I2C_M_RD
, 1, &atr
}, /* read atr */
360 /* read atr register */
361 if ((i2c_transfer(client
->adapter
, &msgs
[0], 2)) != 2) {
362 dev_err(&client
->dev
, "%s: read error\n", __FUNCTION__
);
366 dev_dbg(&client
->dev
, "%s: raw atr=%x\n", __FUNCTION__
, atr
);
368 /* atr is a two's complement value on 6 bits,
369 * perform sign extension. The formula is
370 * Catr = (atr * 0.25pF) + 11.00pF.
375 dev_dbg(&client
->dev
, "%s: raw atr=%x (%d)\n", __FUNCTION__
, atr
, atr
);
377 *trim
= (atr
* 250) + 11000;
379 dev_dbg(&client
->dev
, "%s: real=%d\n", __FUNCTION__
, *trim
);
384 static int x1205_hctosys(struct i2c_client
*client
)
391 err
= x1205_command(client
, X1205_CMD_GETDATETIME
, &tm
);
394 dev_err(&client
->dev
,
395 "Unable to set the system clock\n");
399 /* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
400 * whether it stores the most close value or the value with partial
401 * seconds truncated. However, it is important that we use it to store
402 * the truncated value. This is because otherwise it is necessary,
403 * in an rtc sync function, to read both xtime.tv_sec and
404 * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
405 * of >32bits is not possible. So storing the most close value would
406 * slow down the sync API. So here we have the truncated value and
407 * the best guess is to add 0.5s.
410 tv
.tv_nsec
= NSEC_PER_SEC
>> 1;
412 /* WARNING: this is not the C library 'mktime' call, it is a built in
413 * inline function from include/linux/time.h. It expects (requires)
414 * the month to be in the range 1-12
417 tv
.tv_sec
= mktime(tm
.tm_year
+ 1900, tm
.tm_mon
+ 1,
418 tm
.tm_mday
, tm
.tm_hour
,
419 tm
.tm_min
, tm
.tm_sec
);
421 do_settimeofday(&tv
);
423 dev_info(&client
->dev
,
424 "setting the system clock to %d-%d-%d %d:%d:%d\n",
425 tm
.tm_year
+ 1900, tm
.tm_mon
+ 1,
426 tm
.tm_mday
, tm
.tm_hour
, tm
.tm_min
,
440 static int x1205_validate_client(struct i2c_client
*client
)
444 /* Probe array. We will read the register at the specified
445 * address and check if the given bits are zero.
447 static const unsigned char probe_zero_pattern
[] = {
456 static const struct x1205_limit probe_limits_pattern
[] = {
457 /* register, mask, min, max */
458 { X1205_REG_Y2K
, 0xFF, 19, 20 },
459 { X1205_REG_DW
, 0xFF, 0, 6 },
460 { X1205_REG_YR
, 0xFF, 0, 99 },
461 { X1205_REG_MO
, 0xFF, 0, 12 },
462 { X1205_REG_DT
, 0xFF, 0, 31 },
463 { X1205_REG_HR
, 0x7F, 0, 23 },
464 { X1205_REG_MN
, 0xFF, 0, 59 },
465 { X1205_REG_SC
, 0xFF, 0, 59 },
466 { X1205_REG_Y2K1
, 0xFF, 19, 20 },
467 { X1205_REG_Y2K0
, 0xFF, 19, 20 },
470 /* check that registers have bits a 0 where expected */
471 for (i
= 0; i
< ARRAY_SIZE(probe_zero_pattern
); i
+= 2) {
474 unsigned char addr
[2] = { 0, probe_zero_pattern
[i
] };
476 struct i2c_msg msgs
[2] = {
477 { client
->addr
, 0, 2, addr
},
478 { client
->addr
, I2C_M_RD
, 1, &buf
},
481 xfer
= i2c_transfer(client
->adapter
, msgs
, 2);
483 dev_err(&client
->adapter
->dev
,
484 "%s: could not read register %x\n",
485 __FUNCTION__
, addr
[1]);
490 if ((buf
& probe_zero_pattern
[i
+1]) != 0) {
491 dev_err(&client
->adapter
->dev
,
492 "%s: register=%02x, zero pattern=%d, value=%x\n",
493 __FUNCTION__
, addr
[1], i
, buf
);
499 /* check limits (only registers with bcd values) */
500 for (i
= 0; i
< ARRAY_SIZE(probe_limits_pattern
); i
++) {
501 unsigned char reg
, value
;
503 unsigned char addr
[2] = { 0, probe_limits_pattern
[i
].reg
};
505 struct i2c_msg msgs
[2] = {
506 { client
->addr
, 0, 2, addr
},
507 { client
->addr
, I2C_M_RD
, 1, ®
},
510 xfer
= i2c_transfer(client
->adapter
, msgs
, 2);
513 dev_err(&client
->adapter
->dev
,
514 "%s: could not read register %x\n",
515 __FUNCTION__
, addr
[1]);
520 value
= BCD2BIN(reg
& probe_limits_pattern
[i
].mask
);
522 if (value
> probe_limits_pattern
[i
].max
||
523 value
< probe_limits_pattern
[i
].min
) {
524 dev_dbg(&client
->adapter
->dev
,
525 "%s: register=%x, lim pattern=%d, value=%d\n",
526 __FUNCTION__
, addr
[1], i
, value
);
535 static int x1205_attach(struct i2c_adapter
*adapter
)
537 dev_dbg(&adapter
->dev
, "%s\n", __FUNCTION__
);
539 return i2c_probe(adapter
, &addr_data
, x1205_probe
);
542 int x1205_direct_attach(int adapter_id
,
543 struct i2c_client_address_data
*address_data
)
546 struct i2c_adapter
*adapter
= i2c_get_adapter(adapter_id
);
549 err
= i2c_probe(adapter
,
550 address_data
, x1205_probe
);
552 i2c_put_adapter(adapter
);
560 static int x1205_probe(struct i2c_adapter
*adapter
, int address
, int kind
)
562 struct i2c_client
*client
;
563 struct x1205_data
*data
;
567 dev_dbg(&adapter
->dev
, "%s\n", __FUNCTION__
);
569 if (!i2c_check_functionality(adapter
, I2C_FUNC_I2C
)) {
574 if (!(data
= kzalloc(sizeof(struct x1205_data
), GFP_KERNEL
))) {
579 /* Initialize our structures */
582 client
= &data
->client
;
583 client
->addr
= address
;
584 client
->driver
= &x1205_driver
;
585 client
->adapter
= adapter
;
587 strlcpy(client
->name
, "x1205", I2C_NAME_SIZE
);
589 i2c_set_clientdata(client
, data
);
591 /* Verify the chip is really an X1205 */
593 if (x1205_validate_client(client
) < 0) {
599 /* Inform the i2c layer */
600 if ((err
= i2c_attach_client(client
)))
603 list_add(&data
->list
, &x1205_clients
);
605 dev_info(&client
->dev
, "chip found, driver version " DRV_VERSION
"\n");
607 /* If requested, set the system time */
609 x1205_hctosys(client
);
620 static int x1205_detach(struct i2c_client
*client
)
623 struct x1205_data
*data
= i2c_get_clientdata(client
);
625 dev_dbg(&client
->dev
, "%s\n", __FUNCTION__
);
627 if ((err
= i2c_detach_client(client
)))
630 list_del(&data
->list
);
637 static int x1205_command(struct i2c_client
*client
, unsigned int cmd
,
643 if (!capable(CAP_SYS_TIME
))
646 dev_dbg(&client
->dev
, "%s: cmd=%d\n", __FUNCTION__
, cmd
);
649 case X1205_CMD_GETDATETIME
:
650 return x1205_get_datetime(client
, param
, X1205_CCR_BASE
);
652 case X1205_CMD_SETTIME
:
653 return x1205_set_datetime(client
, param
, 0,
656 case X1205_CMD_SETDATETIME
:
657 return x1205_set_datetime(client
, param
, 1,
660 case X1205_CMD_GETALARM
:
661 return x1205_get_datetime(client
, param
, X1205_ALM0_BASE
);
663 case X1205_CMD_SETALARM
:
664 return x1205_set_datetime(client
, param
, 1,
667 case X1205_CMD_GETDTRIM
:
668 return x1205_get_dtrim(client
, param
);
670 case X1205_CMD_GETATRIM
:
671 return x1205_get_atrim(client
, param
);
678 static int __init
x1205_init(void)
680 return i2c_add_driver(&x1205_driver
);
683 static void __exit
x1205_exit(void)
685 i2c_del_driver(&x1205_driver
);
689 "Karen Spearel <kas11@tampabay.rr.com>, "
690 "Alessandro Zummo <a.zummo@towertech.it>");
691 MODULE_DESCRIPTION("Xicor X1205 RTC driver");
692 MODULE_LICENSE("GPL");
693 MODULE_VERSION(DRV_VERSION
);
695 EXPORT_SYMBOL_GPL(x1205_do_command
);
696 EXPORT_SYMBOL_GPL(x1205_direct_attach
);
698 module_init(x1205_init
);
699 module_exit(x1205_exit
);