blob: 7dcfba1bbfe131539af2aba38d361e53d036280e [file] [log] [blame]
Alessandro Zummo1fec7c62006-03-27 01:16:42 -08001/*
2 * An i2c driver for the Xicor/Intersil X1205 RTC
3 * Copyright 2004 Karen Spearel
4 * Copyright 2005 Alessandro Zummo
5 *
6 * please send all reports to:
7 * Karen Spearel <kas111 at gmail dot com>
8 * Alessandro Zummo <a.zummo@towertech.it>
9 *
10 * based on a lot of other RTC drivers.
11 *
Jean Delvare890e0372007-07-12 14:12:28 +020012 * Information and datasheet:
13 * http://www.intersil.com/cda/deviceinfo/0,1477,X1205,00.html
14 *
Alessandro Zummo1fec7c62006-03-27 01:16:42 -080015 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License version 2 as
17 * published by the Free Software Foundation.
18 */
19
20#include <linux/i2c.h>
21#include <linux/bcd.h>
22#include <linux/rtc.h>
23#include <linux/delay.h>
24
Alessandro Zummo4edac2b2008-04-28 02:11:54 -070025#define DRV_VERSION "1.0.8"
Alessandro Zummo1fec7c62006-03-27 01:16:42 -080026
27/* offsets into CCR area */
28
29#define CCR_SEC 0
30#define CCR_MIN 1
31#define CCR_HOUR 2
32#define CCR_MDAY 3
33#define CCR_MONTH 4
34#define CCR_YEAR 5
35#define CCR_WDAY 6
36#define CCR_Y2K 7
37
38#define X1205_REG_SR 0x3F /* status register */
39#define X1205_REG_Y2K 0x37
40#define X1205_REG_DW 0x36
41#define X1205_REG_YR 0x35
42#define X1205_REG_MO 0x34
43#define X1205_REG_DT 0x33
44#define X1205_REG_HR 0x32
45#define X1205_REG_MN 0x31
46#define X1205_REG_SC 0x30
47#define X1205_REG_DTR 0x13
48#define X1205_REG_ATR 0x12
49#define X1205_REG_INT 0x11
50#define X1205_REG_0 0x10
51#define X1205_REG_Y2K1 0x0F
52#define X1205_REG_DWA1 0x0E
53#define X1205_REG_YRA1 0x0D
54#define X1205_REG_MOA1 0x0C
55#define X1205_REG_DTA1 0x0B
56#define X1205_REG_HRA1 0x0A
57#define X1205_REG_MNA1 0x09
58#define X1205_REG_SCA1 0x08
59#define X1205_REG_Y2K0 0x07
60#define X1205_REG_DWA0 0x06
61#define X1205_REG_YRA0 0x05
62#define X1205_REG_MOA0 0x04
63#define X1205_REG_DTA0 0x03
64#define X1205_REG_HRA0 0x02
65#define X1205_REG_MNA0 0x01
66#define X1205_REG_SCA0 0x00
67
68#define X1205_CCR_BASE 0x30 /* Base address of CCR */
69#define X1205_ALM0_BASE 0x00 /* Base address of ALARM0 */
70
71#define X1205_SR_RTCF 0x01 /* Clock failure */
72#define X1205_SR_WEL 0x02 /* Write Enable Latch */
73#define X1205_SR_RWEL 0x04 /* Register Write Enable */
Michael Hamel471d47e2008-07-04 09:59:30 -070074#define X1205_SR_AL0 0x20 /* Alarm 0 match */
Alessandro Zummo1fec7c62006-03-27 01:16:42 -080075
76#define X1205_DTR_DTR0 0x01
77#define X1205_DTR_DTR1 0x02
78#define X1205_DTR_DTR2 0x04
79
80#define X1205_HR_MIL 0x80 /* Set in ccr.hour for 24 hr mode */
81
Michael Hamel471d47e2008-07-04 09:59:30 -070082#define X1205_INT_AL0E 0x20 /* Alarm 0 enable */
83
Alessandro Zummo4edac2b2008-04-28 02:11:54 -070084static struct i2c_driver x1205_driver;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -080085
86/*
87 * In the routines that deal directly with the x1205 hardware, we use
88 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
89 * Epoch is initialized as 2000. Time is set to UTC.
90 */
91static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
92 unsigned char reg_base)
93{
94 unsigned char dt_addr[2] = { 0, reg_base };
Alessandro Zummo1fec7c62006-03-27 01:16:42 -080095 unsigned char buf[8];
Michael Hamel471d47e2008-07-04 09:59:30 -070096 int i;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -080097
98 struct i2c_msg msgs[] = {
99 { client->addr, 0, 2, dt_addr }, /* setup read ptr */
100 { client->addr, I2C_M_RD, 8, buf }, /* read date */
101 };
102
103 /* read date registers */
Michael Hamel471d47e2008-07-04 09:59:30 -0700104 if (i2c_transfer(client->adapter, &msgs[0], 2) != 2) {
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700105 dev_err(&client->dev, "%s: read error\n", __func__);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800106 return -EIO;
107 }
108
109 dev_dbg(&client->dev,
110 "%s: raw read data - sec=%02x, min=%02x, hr=%02x, "
111 "mday=%02x, mon=%02x, year=%02x, wday=%02x, y2k=%02x\n",
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700112 __func__,
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800113 buf[0], buf[1], buf[2], buf[3],
114 buf[4], buf[5], buf[6], buf[7]);
115
Michael Hamel471d47e2008-07-04 09:59:30 -0700116 /* Mask out the enable bits if these are alarm registers */
117 if (reg_base < X1205_CCR_BASE)
118 for (i = 0; i <= 4; i++)
119 buf[i] &= 0x7F;
120
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800121 tm->tm_sec = BCD2BIN(buf[CCR_SEC]);
122 tm->tm_min = BCD2BIN(buf[CCR_MIN]);
123 tm->tm_hour = BCD2BIN(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
124 tm->tm_mday = BCD2BIN(buf[CCR_MDAY]);
125 tm->tm_mon = BCD2BIN(buf[CCR_MONTH]) - 1; /* mon is 0-11 */
126 tm->tm_year = BCD2BIN(buf[CCR_YEAR])
127 + (BCD2BIN(buf[CCR_Y2K]) * 100) - 1900;
128 tm->tm_wday = buf[CCR_WDAY];
129
130 dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
131 "mday=%d, mon=%d, year=%d, wday=%d\n",
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700132 __func__,
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800133 tm->tm_sec, tm->tm_min, tm->tm_hour,
134 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
135
136 return 0;
137}
138
139static int x1205_get_status(struct i2c_client *client, unsigned char *sr)
140{
141 static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
142
143 struct i2c_msg msgs[] = {
144 { client->addr, 0, 2, sr_addr }, /* setup read ptr */
145 { client->addr, I2C_M_RD, 1, sr }, /* read status */
146 };
147
148 /* read status register */
Michael Hamel471d47e2008-07-04 09:59:30 -0700149 if (i2c_transfer(client->adapter, &msgs[0], 2) != 2) {
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700150 dev_err(&client->dev, "%s: read error\n", __func__);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800151 return -EIO;
152 }
153
154 return 0;
155}
156
157static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
Michael Hamel471d47e2008-07-04 09:59:30 -0700158 int datetoo, u8 reg_base, unsigned char alm_enable)
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800159{
Michael Hamel471d47e2008-07-04 09:59:30 -0700160 int i, xfer, nbytes;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800161 unsigned char buf[8];
Michael Hamel471d47e2008-07-04 09:59:30 -0700162 unsigned char rdata[10] = { 0, reg_base };
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800163
164 static const unsigned char wel[3] = { 0, X1205_REG_SR,
165 X1205_SR_WEL };
166
167 static const unsigned char rwel[3] = { 0, X1205_REG_SR,
168 X1205_SR_WEL | X1205_SR_RWEL };
169
170 static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 };
171
172 dev_dbg(&client->dev,
173 "%s: secs=%d, mins=%d, hours=%d\n",
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700174 __func__,
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800175 tm->tm_sec, tm->tm_min, tm->tm_hour);
176
177 buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
178 buf[CCR_MIN] = BIN2BCD(tm->tm_min);
179
180 /* set hour and 24hr bit */
181 buf[CCR_HOUR] = BIN2BCD(tm->tm_hour) | X1205_HR_MIL;
182
183 /* should we also set the date? */
184 if (datetoo) {
185 dev_dbg(&client->dev,
186 "%s: mday=%d, mon=%d, year=%d, wday=%d\n",
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700187 __func__,
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800188 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
189
190 buf[CCR_MDAY] = BIN2BCD(tm->tm_mday);
191
192 /* month, 1 - 12 */
193 buf[CCR_MONTH] = BIN2BCD(tm->tm_mon + 1);
194
195 /* year, since the rtc epoch*/
196 buf[CCR_YEAR] = BIN2BCD(tm->tm_year % 100);
197 buf[CCR_WDAY] = tm->tm_wday & 0x07;
198 buf[CCR_Y2K] = BIN2BCD(tm->tm_year / 100);
199 }
200
Michael Hamel471d47e2008-07-04 09:59:30 -0700201 /* If writing alarm registers, set compare bits on registers 0-4 */
202 if (reg_base < X1205_CCR_BASE)
203 for (i = 0; i <= 4; i++)
204 buf[i] |= 0x80;
205
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800206 /* this sequence is required to unlock the chip */
207 if ((xfer = i2c_master_send(client, wel, 3)) != 3) {
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700208 dev_err(&client->dev, "%s: wel - %d\n", __func__, xfer);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800209 return -EIO;
210 }
211
212 if ((xfer = i2c_master_send(client, rwel, 3)) != 3) {
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700213 dev_err(&client->dev, "%s: rwel - %d\n", __func__, xfer);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800214 return -EIO;
215 }
216
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800217
Michael Hamel471d47e2008-07-04 09:59:30 -0700218 /* write register's data */
219 if (datetoo)
220 nbytes = 8;
221 else
222 nbytes = 3;
223 for (i = 0; i < nbytes; i++)
224 rdata[2+i] = buf[i];
225
226 xfer = i2c_master_send(client, rdata, nbytes+2);
227 if (xfer != nbytes+2) {
228 dev_err(&client->dev,
229 "%s: result=%d addr=%02x, data=%02x\n",
230 __func__,
231 xfer, rdata[1], rdata[2]);
232 return -EIO;
233 }
234
235 /* If we wrote to the nonvolatile region, wait 10msec for write cycle*/
236 if (reg_base < X1205_CCR_BASE) {
237 unsigned char al0e[3] = { 0, X1205_REG_INT, 0 };
238
239 msleep(10);
240
241 /* ...and set or clear the AL0E bit in the INT register */
242
243 /* Need to set RWEL again as the write has cleared it */
244 xfer = i2c_master_send(client, rwel, 3);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800245 if (xfer != 3) {
246 dev_err(&client->dev,
Michael Hamel471d47e2008-07-04 09:59:30 -0700247 "%s: aloe rwel - %d\n",
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700248 __func__,
Michael Hamel471d47e2008-07-04 09:59:30 -0700249 xfer);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800250 return -EIO;
251 }
Michael Hamel471d47e2008-07-04 09:59:30 -0700252
253 if (alm_enable)
254 al0e[2] = X1205_INT_AL0E;
255
256 xfer = i2c_master_send(client, al0e, 3);
257 if (xfer != 3) {
258 dev_err(&client->dev,
259 "%s: al0e - %d\n",
260 __func__,
261 xfer);
262 return -EIO;
263 }
264
265 /* and wait 10msec again for this write to complete */
266 msleep(10);
267 }
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800268
269 /* disable further writes */
270 if ((xfer = i2c_master_send(client, diswe, 3)) != 3) {
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700271 dev_err(&client->dev, "%s: diswe - %d\n", __func__, xfer);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800272 return -EIO;
273 }
274
275 return 0;
276}
277
278static int x1205_fix_osc(struct i2c_client *client)
279{
280 int err;
281 struct rtc_time tm;
282
283 tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
284
Michael Hamel471d47e2008-07-04 09:59:30 -0700285 err = x1205_set_datetime(client, &tm, 0, X1205_CCR_BASE, 0);
286 if (err < 0)
287 dev_err(&client->dev, "unable to restart the oscillator\n");
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800288
289 return err;
290}
291
292static int x1205_get_dtrim(struct i2c_client *client, int *trim)
293{
294 unsigned char dtr;
295 static unsigned char dtr_addr[2] = { 0, X1205_REG_DTR };
296
297 struct i2c_msg msgs[] = {
298 { client->addr, 0, 2, dtr_addr }, /* setup read ptr */
299 { client->addr, I2C_M_RD, 1, &dtr }, /* read dtr */
300 };
301
302 /* read dtr register */
Michael Hamel471d47e2008-07-04 09:59:30 -0700303 if (i2c_transfer(client->adapter, &msgs[0], 2) != 2) {
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700304 dev_err(&client->dev, "%s: read error\n", __func__);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800305 return -EIO;
306 }
307
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700308 dev_dbg(&client->dev, "%s: raw dtr=%x\n", __func__, dtr);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800309
310 *trim = 0;
311
312 if (dtr & X1205_DTR_DTR0)
313 *trim += 20;
314
315 if (dtr & X1205_DTR_DTR1)
316 *trim += 10;
317
318 if (dtr & X1205_DTR_DTR2)
319 *trim = -*trim;
320
321 return 0;
322}
323
324static int x1205_get_atrim(struct i2c_client *client, int *trim)
325{
326 s8 atr;
327 static unsigned char atr_addr[2] = { 0, X1205_REG_ATR };
328
329 struct i2c_msg msgs[] = {
330 { client->addr, 0, 2, atr_addr }, /* setup read ptr */
331 { client->addr, I2C_M_RD, 1, &atr }, /* read atr */
332 };
333
334 /* read atr register */
Michael Hamel471d47e2008-07-04 09:59:30 -0700335 if (i2c_transfer(client->adapter, &msgs[0], 2) != 2) {
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700336 dev_err(&client->dev, "%s: read error\n", __func__);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800337 return -EIO;
338 }
339
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700340 dev_dbg(&client->dev, "%s: raw atr=%x\n", __func__, atr);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800341
342 /* atr is a two's complement value on 6 bits,
343 * perform sign extension. The formula is
344 * Catr = (atr * 0.25pF) + 11.00pF.
345 */
346 if (atr & 0x20)
347 atr |= 0xC0;
348
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700349 dev_dbg(&client->dev, "%s: raw atr=%x (%d)\n", __func__, atr, atr);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800350
351 *trim = (atr * 250) + 11000;
352
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700353 dev_dbg(&client->dev, "%s: real=%d\n", __func__, *trim);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800354
355 return 0;
356}
357
358struct x1205_limit
359{
360 unsigned char reg, mask, min, max;
361};
362
363static int x1205_validate_client(struct i2c_client *client)
364{
365 int i, xfer;
366
367 /* Probe array. We will read the register at the specified
368 * address and check if the given bits are zero.
369 */
370 static const unsigned char probe_zero_pattern[] = {
371 /* register, mask */
372 X1205_REG_SR, 0x18,
373 X1205_REG_DTR, 0xF8,
374 X1205_REG_ATR, 0xC0,
375 X1205_REG_INT, 0x18,
376 X1205_REG_0, 0xFF,
377 };
378
379 static const struct x1205_limit probe_limits_pattern[] = {
380 /* register, mask, min, max */
381 { X1205_REG_Y2K, 0xFF, 19, 20 },
382 { X1205_REG_DW, 0xFF, 0, 6 },
383 { X1205_REG_YR, 0xFF, 0, 99 },
384 { X1205_REG_MO, 0xFF, 0, 12 },
385 { X1205_REG_DT, 0xFF, 0, 31 },
386 { X1205_REG_HR, 0x7F, 0, 23 },
387 { X1205_REG_MN, 0xFF, 0, 59 },
388 { X1205_REG_SC, 0xFF, 0, 59 },
389 { X1205_REG_Y2K1, 0xFF, 19, 20 },
390 { X1205_REG_Y2K0, 0xFF, 19, 20 },
391 };
392
393 /* check that registers have bits a 0 where expected */
394 for (i = 0; i < ARRAY_SIZE(probe_zero_pattern); i += 2) {
395 unsigned char buf;
396
397 unsigned char addr[2] = { 0, probe_zero_pattern[i] };
398
399 struct i2c_msg msgs[2] = {
400 { client->addr, 0, 2, addr },
401 { client->addr, I2C_M_RD, 1, &buf },
402 };
403
404 if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
David Brownella14e1892006-12-10 02:19:02 -0800405 dev_err(&client->dev,
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800406 "%s: could not read register %x\n",
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700407 __func__, probe_zero_pattern[i]);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800408
409 return -EIO;
410 }
411
412 if ((buf & probe_zero_pattern[i+1]) != 0) {
David Brownella14e1892006-12-10 02:19:02 -0800413 dev_err(&client->dev,
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800414 "%s: register=%02x, zero pattern=%d, value=%x\n",
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700415 __func__, probe_zero_pattern[i], i, buf);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800416
417 return -ENODEV;
418 }
419 }
420
421 /* check limits (only registers with bcd values) */
422 for (i = 0; i < ARRAY_SIZE(probe_limits_pattern); i++) {
423 unsigned char reg, value;
424
425 unsigned char addr[2] = { 0, probe_limits_pattern[i].reg };
426
427 struct i2c_msg msgs[2] = {
428 { client->addr, 0, 2, addr },
429 { client->addr, I2C_M_RD, 1, &reg },
430 };
431
432 if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
David Brownella14e1892006-12-10 02:19:02 -0800433 dev_err(&client->dev,
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800434 "%s: could not read register %x\n",
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700435 __func__, probe_limits_pattern[i].reg);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800436
437 return -EIO;
438 }
439
440 value = BCD2BIN(reg & probe_limits_pattern[i].mask);
441
442 if (value > probe_limits_pattern[i].max ||
443 value < probe_limits_pattern[i].min) {
David Brownella14e1892006-12-10 02:19:02 -0800444 dev_dbg(&client->dev,
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800445 "%s: register=%x, lim pattern=%d, value=%d\n",
Harvey Harrison2a4e2b82008-04-28 02:12:00 -0700446 __func__, probe_limits_pattern[i].reg,
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800447 i, value);
448
449 return -ENODEV;
450 }
451 }
452
453 return 0;
454}
455
456static int x1205_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
457{
Michael Hamel471d47e2008-07-04 09:59:30 -0700458 int err;
459 unsigned char intreg, status;
460 static unsigned char int_addr[2] = { 0, X1205_REG_INT };
461 struct i2c_client *client = to_i2c_client(dev);
462 struct i2c_msg msgs[] = {
463 { client->addr, 0, 2, int_addr }, /* setup read ptr */
464 { client->addr, I2C_M_RD, 1, &intreg }, /* read INT register */
465 };
466
467 /* read interrupt register and status register */
468 if (i2c_transfer(client->adapter, &msgs[0], 2) != 2) {
469 dev_err(&client->dev, "%s: read error\n", __func__);
470 return -EIO;
471 }
472 err = x1205_get_status(client, &status);
473 if (err == 0) {
474 alrm->pending = (status & X1205_SR_AL0) ? 1 : 0;
475 alrm->enabled = (intreg & X1205_INT_AL0E) ? 1 : 0;
476 err = x1205_get_datetime(client, &alrm->time, X1205_ALM0_BASE);
477 }
478 return err;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800479}
480
481static int x1205_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
482{
483 return x1205_set_datetime(to_i2c_client(dev),
Michael Hamel471d47e2008-07-04 09:59:30 -0700484 &alrm->time, 1, X1205_ALM0_BASE, alrm->enabled);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800485}
486
487static int x1205_rtc_read_time(struct device *dev, struct rtc_time *tm)
488{
489 return x1205_get_datetime(to_i2c_client(dev),
490 tm, X1205_CCR_BASE);
491}
492
493static int x1205_rtc_set_time(struct device *dev, struct rtc_time *tm)
494{
495 return x1205_set_datetime(to_i2c_client(dev),
Michael Hamel471d47e2008-07-04 09:59:30 -0700496 tm, 1, X1205_CCR_BASE, 0);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800497}
498
499static int x1205_rtc_proc(struct device *dev, struct seq_file *seq)
500{
501 int err, dtrim, atrim;
502
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800503 if ((err = x1205_get_dtrim(to_i2c_client(dev), &dtrim)) == 0)
504 seq_printf(seq, "digital_trim\t: %d ppm\n", dtrim);
505
506 if ((err = x1205_get_atrim(to_i2c_client(dev), &atrim)) == 0)
507 seq_printf(seq, "analog_trim\t: %d.%02d pF\n",
508 atrim / 1000, atrim % 1000);
509 return 0;
510}
511
David Brownellff8371a2006-09-30 23:28:17 -0700512static const struct rtc_class_ops x1205_rtc_ops = {
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800513 .proc = x1205_rtc_proc,
514 .read_time = x1205_rtc_read_time,
515 .set_time = x1205_rtc_set_time,
516 .read_alarm = x1205_rtc_read_alarm,
517 .set_alarm = x1205_rtc_set_alarm,
518};
519
520static ssize_t x1205_sysfs_show_atrim(struct device *dev,
521 struct device_attribute *attr, char *buf)
522{
Alessandro Zummo015aefb2006-04-10 22:54:42 -0700523 int err, atrim;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800524
Alessandro Zummo015aefb2006-04-10 22:54:42 -0700525 err = x1205_get_atrim(to_i2c_client(dev), &atrim);
526 if (err)
527 return err;
528
529 return sprintf(buf, "%d.%02d pF\n", atrim / 1000, atrim % 1000);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800530}
531static DEVICE_ATTR(atrim, S_IRUGO, x1205_sysfs_show_atrim, NULL);
532
533static ssize_t x1205_sysfs_show_dtrim(struct device *dev,
534 struct device_attribute *attr, char *buf)
535{
Alessandro Zummo015aefb2006-04-10 22:54:42 -0700536 int err, dtrim;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800537
Alessandro Zummo015aefb2006-04-10 22:54:42 -0700538 err = x1205_get_dtrim(to_i2c_client(dev), &dtrim);
539 if (err)
540 return err;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800541
Alessandro Zummo015aefb2006-04-10 22:54:42 -0700542 return sprintf(buf, "%d ppm\n", dtrim);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800543}
544static DEVICE_ATTR(dtrim, S_IRUGO, x1205_sysfs_show_dtrim, NULL);
545
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700546static int x1205_sysfs_register(struct device *dev)
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800547{
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700548 int err;
549
550 err = device_create_file(dev, &dev_attr_atrim);
551 if (err)
552 return err;
553
554 err = device_create_file(dev, &dev_attr_dtrim);
555 if (err)
556 device_remove_file(dev, &dev_attr_atrim);
557
558 return err;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800559}
560
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700561static void x1205_sysfs_unregister(struct device *dev)
562{
563 device_remove_file(dev, &dev_attr_atrim);
564 device_remove_file(dev, &dev_attr_dtrim);
565}
566
567
Jean Delvared2653e92008-04-29 23:11:39 +0200568static int x1205_probe(struct i2c_client *client,
569 const struct i2c_device_id *id)
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800570{
571 int err = 0;
572 unsigned char sr;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800573 struct rtc_device *rtc;
574
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700575 dev_dbg(&client->dev, "%s\n", __func__);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800576
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700577 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
578 return -ENODEV;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800579
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700580 if (x1205_validate_client(client) < 0)
581 return -ENODEV;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800582
583 dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
584
585 rtc = rtc_device_register(x1205_driver.driver.name, &client->dev,
586 &x1205_rtc_ops, THIS_MODULE);
587
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700588 if (IS_ERR(rtc))
589 return PTR_ERR(rtc);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800590
591 i2c_set_clientdata(client, rtc);
592
593 /* Check for power failures and eventualy enable the osc */
594 if ((err = x1205_get_status(client, &sr)) == 0) {
595 if (sr & X1205_SR_RTCF) {
596 dev_err(&client->dev,
597 "power failure detected, "
598 "please set the clock\n");
599 udelay(50);
600 x1205_fix_osc(client);
601 }
602 }
603 else
604 dev_err(&client->dev, "couldn't read status\n");
605
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700606 err = x1205_sysfs_register(&client->dev);
607 if (err)
608 goto exit_devreg;
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800609
610 return 0;
611
Jeff Garzik91046a82006-12-06 20:35:34 -0800612exit_devreg:
613 rtc_device_unregister(rtc);
614
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800615 return err;
616}
617
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700618static int x1205_remove(struct i2c_client *client)
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800619{
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800620 struct rtc_device *rtc = i2c_get_clientdata(client);
621
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700622 rtc_device_unregister(rtc);
623 x1205_sysfs_unregister(&client->dev);
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800624 return 0;
625}
626
Jean Delvare3760f732008-04-29 23:11:40 +0200627static const struct i2c_device_id x1205_id[] = {
628 { "x1205", 0 },
629 { }
630};
631MODULE_DEVICE_TABLE(i2c, x1205_id);
632
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700633static struct i2c_driver x1205_driver = {
634 .driver = {
635 .name = "rtc-x1205",
636 },
637 .probe = x1205_probe,
638 .remove = x1205_remove,
Jean Delvare3760f732008-04-29 23:11:40 +0200639 .id_table = x1205_id,
Alessandro Zummo4edac2b2008-04-28 02:11:54 -0700640};
641
Alessandro Zummo1fec7c62006-03-27 01:16:42 -0800642static int __init x1205_init(void)
643{
644 return i2c_add_driver(&x1205_driver);
645}
646
647static void __exit x1205_exit(void)
648{
649 i2c_del_driver(&x1205_driver);
650}
651
652MODULE_AUTHOR(
653 "Karen Spearel <kas111 at gmail dot com>, "
654 "Alessandro Zummo <a.zummo@towertech.it>");
655MODULE_DESCRIPTION("Xicor/Intersil X1205 RTC driver");
656MODULE_LICENSE("GPL");
657MODULE_VERSION(DRV_VERSION);
658
659module_init(x1205_init);
660module_exit(x1205_exit);