Commit | Line | Data |
---|---|---|
c124a78d RV |
1 | /* |
2 | * drivers/i2c/chips/ds1374.c | |
3 | * | |
4 | * I2C client/driver for the Maxim/Dallas DS1374 Real-Time Clock | |
5 | * | |
6 | * Author: Randy Vinson <rvinson@mvista.com> | |
7 | * | |
8 | * Based on the m41t00.c by Mark Greer <mgreer@mvista.com> | |
9 | * | |
10 | * 2005 (c) MontaVista Software, Inc. This file is licensed under | |
11 | * the terms of the GNU General Public License version 2. This program | |
12 | * is licensed "as is" without any warranty of any kind, whether express | |
13 | * or implied. | |
14 | */ | |
15 | /* | |
16 | * This i2c client/driver wedges between the drivers/char/genrtc.c RTC | |
17 | * interface and the SMBus interface of the i2c subsystem. | |
18 | * It would be more efficient to use i2c msgs/i2c_transfer directly but, as | |
19 | * recommened in .../Documentation/i2c/writing-clients section | |
20 | * "Sending and receiving", using SMBus level communication is preferred. | |
21 | */ | |
22 | ||
23 | #include <linux/kernel.h> | |
24 | #include <linux/module.h> | |
25 | #include <linux/interrupt.h> | |
26 | #include <linux/i2c.h> | |
27 | #include <linux/rtc.h> | |
28 | #include <linux/bcd.h> | |
29 | ||
c124a78d RV |
30 | #define DS1374_REG_TOD0 0x00 |
31 | #define DS1374_REG_TOD1 0x01 | |
32 | #define DS1374_REG_TOD2 0x02 | |
33 | #define DS1374_REG_TOD3 0x03 | |
34 | #define DS1374_REG_WDALM0 0x04 | |
35 | #define DS1374_REG_WDALM1 0x05 | |
36 | #define DS1374_REG_WDALM2 0x06 | |
37 | #define DS1374_REG_CR 0x07 | |
38 | #define DS1374_REG_SR 0x08 | |
39 | #define DS1374_REG_SR_OSF 0x80 | |
40 | #define DS1374_REG_TCR 0x09 | |
41 | ||
42 | #define DS1374_DRV_NAME "ds1374" | |
43 | ||
44 | static DECLARE_MUTEX(ds1374_mutex); | |
45 | ||
46 | static struct i2c_driver ds1374_driver; | |
47 | static struct i2c_client *save_client; | |
48 | ||
49 | static unsigned short ignore[] = { I2C_CLIENT_END }; | |
50 | static unsigned short normal_addr[] = { 0x68, I2C_CLIENT_END }; | |
51 | ||
52 | static struct i2c_client_address_data addr_data = { | |
53 | .normal_i2c = normal_addr, | |
c124a78d | 54 | .probe = ignore, |
c124a78d | 55 | .ignore = ignore, |
c124a78d RV |
56 | }; |
57 | ||
58 | static ulong ds1374_read_rtc(void) | |
59 | { | |
60 | ulong time = 0; | |
61 | int reg = DS1374_REG_WDALM0; | |
62 | ||
63 | while (reg--) { | |
64 | s32 tmp; | |
65 | if ((tmp = i2c_smbus_read_byte_data(save_client, reg)) < 0) { | |
66 | dev_warn(&save_client->dev, | |
67 | "can't read from rtc chip\n"); | |
68 | return 0; | |
69 | } | |
70 | time = (time << 8) | (tmp & 0xff); | |
71 | } | |
72 | return time; | |
73 | } | |
74 | ||
75 | static void ds1374_write_rtc(ulong time) | |
76 | { | |
77 | int reg; | |
78 | ||
79 | for (reg = DS1374_REG_TOD0; reg < DS1374_REG_WDALM0; reg++) { | |
80 | if (i2c_smbus_write_byte_data(save_client, reg, time & 0xff) | |
81 | < 0) { | |
82 | dev_warn(&save_client->dev, | |
83 | "can't write to rtc chip\n"); | |
84 | break; | |
85 | } | |
86 | time = time >> 8; | |
87 | } | |
88 | } | |
89 | ||
90 | static void ds1374_check_rtc_status(void) | |
91 | { | |
92 | s32 tmp; | |
93 | ||
94 | tmp = i2c_smbus_read_byte_data(save_client, DS1374_REG_SR); | |
95 | if (tmp < 0) { | |
96 | dev_warn(&save_client->dev, | |
97 | "can't read status from rtc chip\n"); | |
98 | return; | |
99 | } | |
100 | if (tmp & DS1374_REG_SR_OSF) { | |
101 | dev_warn(&save_client->dev, | |
102 | "oscillator discontinuity flagged, time unreliable\n"); | |
103 | tmp &= ~DS1374_REG_SR_OSF; | |
104 | tmp = i2c_smbus_write_byte_data(save_client, DS1374_REG_SR, | |
105 | tmp & 0xff); | |
106 | if (tmp < 0) | |
107 | dev_warn(&save_client->dev, | |
108 | "can't clear discontinuity notification\n"); | |
109 | } | |
110 | } | |
111 | ||
112 | ulong ds1374_get_rtc_time(void) | |
113 | { | |
114 | ulong t1, t2; | |
115 | int limit = 10; /* arbitrary retry limit */ | |
116 | ||
117 | down(&ds1374_mutex); | |
118 | ||
119 | /* | |
120 | * Since the reads are being performed one byte at a time using | |
121 | * the SMBus vs a 4-byte i2c transfer, there is a chance that a | |
122 | * carry will occur during the read. To detect this, 2 reads are | |
123 | * performed and compared. | |
124 | */ | |
125 | do { | |
126 | t1 = ds1374_read_rtc(); | |
127 | t2 = ds1374_read_rtc(); | |
128 | } while (t1 != t2 && limit--); | |
129 | ||
130 | up(&ds1374_mutex); | |
131 | ||
132 | if (t1 != t2) { | |
133 | dev_warn(&save_client->dev, | |
134 | "can't get consistent time from rtc chip\n"); | |
135 | t1 = 0; | |
136 | } | |
137 | ||
138 | return t1; | |
139 | } | |
140 | ||
141 | static void ds1374_set_tlet(ulong arg) | |
142 | { | |
143 | ulong t1, t2; | |
144 | int limit = 10; /* arbitrary retry limit */ | |
145 | ||
146 | t1 = *(ulong *) arg; | |
147 | ||
148 | down(&ds1374_mutex); | |
149 | ||
150 | /* | |
151 | * Since the writes are being performed one byte at a time using | |
152 | * the SMBus vs a 4-byte i2c transfer, there is a chance that a | |
153 | * carry will occur during the write. To detect this, the write | |
154 | * value is read back and compared. | |
155 | */ | |
156 | do { | |
157 | ds1374_write_rtc(t1); | |
158 | t2 = ds1374_read_rtc(); | |
159 | } while (t1 != t2 && limit--); | |
160 | ||
161 | up(&ds1374_mutex); | |
162 | ||
163 | if (t1 != t2) | |
164 | dev_warn(&save_client->dev, | |
165 | "can't confirm time set from rtc chip\n"); | |
166 | } | |
167 | ||
8e14d6c1 | 168 | static ulong new_time; |
c124a78d | 169 | |
6344a8ec BD |
170 | static DECLARE_TASKLET_DISABLED(ds1374_tasklet, ds1374_set_tlet, |
171 | (ulong) & new_time); | |
c124a78d RV |
172 | |
173 | int ds1374_set_rtc_time(ulong nowtime) | |
174 | { | |
175 | new_time = nowtime; | |
176 | ||
177 | if (in_interrupt()) | |
178 | tasklet_schedule(&ds1374_tasklet); | |
179 | else | |
180 | ds1374_set_tlet((ulong) & new_time); | |
181 | ||
182 | return 0; | |
183 | } | |
184 | ||
185 | /* | |
186 | ***************************************************************************** | |
187 | * | |
188 | * Driver Interface | |
189 | * | |
190 | ***************************************************************************** | |
191 | */ | |
192 | static int ds1374_probe(struct i2c_adapter *adap, int addr, int kind) | |
193 | { | |
194 | struct i2c_client *client; | |
195 | int rc; | |
196 | ||
5263ebb5 | 197 | client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL); |
c124a78d RV |
198 | if (!client) |
199 | return -ENOMEM; | |
200 | ||
c124a78d | 201 | strncpy(client->name, DS1374_DRV_NAME, I2C_NAME_SIZE); |
c124a78d RV |
202 | client->addr = addr; |
203 | client->adapter = adap; | |
204 | client->driver = &ds1374_driver; | |
205 | ||
206 | if ((rc = i2c_attach_client(client)) != 0) { | |
207 | kfree(client); | |
208 | return rc; | |
209 | } | |
210 | ||
211 | save_client = client; | |
212 | ||
213 | ds1374_check_rtc_status(); | |
214 | ||
215 | return 0; | |
216 | } | |
217 | ||
218 | static int ds1374_attach(struct i2c_adapter *adap) | |
219 | { | |
220 | return i2c_probe(adap, &addr_data, ds1374_probe); | |
221 | } | |
222 | ||
223 | static int ds1374_detach(struct i2c_client *client) | |
224 | { | |
225 | int rc; | |
226 | ||
227 | if ((rc = i2c_detach_client(client)) == 0) { | |
228 | kfree(i2c_get_clientdata(client)); | |
229 | tasklet_kill(&ds1374_tasklet); | |
230 | } | |
231 | return rc; | |
232 | } | |
233 | ||
234 | static struct i2c_driver ds1374_driver = { | |
235 | .owner = THIS_MODULE, | |
236 | .name = DS1374_DRV_NAME, | |
237 | .id = I2C_DRIVERID_DS1374, | |
c124a78d RV |
238 | .attach_adapter = ds1374_attach, |
239 | .detach_client = ds1374_detach, | |
240 | }; | |
241 | ||
242 | static int __init ds1374_init(void) | |
243 | { | |
244 | return i2c_add_driver(&ds1374_driver); | |
245 | } | |
246 | ||
247 | static void __exit ds1374_exit(void) | |
248 | { | |
249 | i2c_del_driver(&ds1374_driver); | |
250 | } | |
251 | ||
252 | module_init(ds1374_init); | |
253 | module_exit(ds1374_exit); | |
254 | ||
255 | MODULE_AUTHOR("Randy Vinson <rvinson@mvista.com>"); | |
256 | MODULE_DESCRIPTION("Maxim/Dallas DS1374 RTC I2C Client Driver"); | |
257 | MODULE_LICENSE("GPL"); |