Merge branch 'upstream' of git://electric-eye.fr.zoreil.com/home/romieu/linux-2.6...
[linux-2.6] / drivers / i2c / chips / m41t00.c
1 /*
2  * I2C client/driver for the ST M41T00 family of i2c rtc chips.
3  *
4  * Author: Mark A. Greer <mgreer@mvista.com>
5  *
6  * 2005, 2006 (c) MontaVista Software, Inc. This file is licensed under
7  * the terms of the GNU General Public License version 2. This program
8  * is licensed "as is" without any warranty of any kind, whether express
9  * or implied.
10  */
11 /*
12  * This i2c client/driver wedges between the drivers/char/genrtc.c RTC
13  * interface and the SMBus interface of the i2c subsystem.
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/interrupt.h>
19 #include <linux/i2c.h>
20 #include <linux/rtc.h>
21 #include <linux/bcd.h>
22 #include <linux/workqueue.h>
23 #include <linux/platform_device.h>
24 #include <linux/m41t00.h>
25 #include <asm/time.h>
26 #include <asm/rtc.h>
27
28 static struct i2c_driver m41t00_driver;
29 static struct i2c_client *save_client;
30
31 static unsigned short ignore[] = { I2C_CLIENT_END };
32 static unsigned short normal_addr[] = { I2C_CLIENT_END, I2C_CLIENT_END };
33
34 static struct i2c_client_address_data addr_data = {
35         .normal_i2c     = normal_addr,
36         .probe          = ignore,
37         .ignore         = ignore,
38 };
39
40 struct m41t00_chip_info {
41         u8      type;
42         char    *name;
43         u8      read_limit;
44         u8      sec;            /* Offsets for chip regs */
45         u8      min;
46         u8      hour;
47         u8      day;
48         u8      mon;
49         u8      year;
50         u8      alarm_mon;
51         u8      alarm_hour;
52         u8      sqw;
53         u8      sqw_freq;
54 };
55
56 static struct m41t00_chip_info m41t00_chip_info_tbl[] = {
57         {
58                 .type           = M41T00_TYPE_M41T00,
59                 .name           = "m41t00",
60                 .read_limit     = 5,
61                 .sec            = 0,
62                 .min            = 1,
63                 .hour           = 2,
64                 .day            = 4,
65                 .mon            = 5,
66                 .year           = 6,
67         },
68         {
69                 .type           = M41T00_TYPE_M41T81,
70                 .name           = "m41t81",
71                 .read_limit     = 1,
72                 .sec            = 1,
73                 .min            = 2,
74                 .hour           = 3,
75                 .day            = 5,
76                 .mon            = 6,
77                 .year           = 7,
78                 .alarm_mon      = 0xa,
79                 .alarm_hour     = 0xc,
80                 .sqw            = 0x13,
81         },
82         {
83                 .type           = M41T00_TYPE_M41T85,
84                 .name           = "m41t85",
85                 .read_limit     = 1,
86                 .sec            = 1,
87                 .min            = 2,
88                 .hour           = 3,
89                 .day            = 5,
90                 .mon            = 6,
91                 .year           = 7,
92                 .alarm_mon      = 0xa,
93                 .alarm_hour     = 0xc,
94                 .sqw            = 0x13,
95         },
96 };
97 static struct m41t00_chip_info *m41t00_chip;
98
99 ulong
100 m41t00_get_rtc_time(void)
101 {
102         s32 sec, min, hour, day, mon, year;
103         s32 sec1, min1, hour1, day1, mon1, year1;
104         u8 reads = 0;
105         u8 buf[8], msgbuf[1] = { 0 }; /* offset into rtc's regs */
106         struct i2c_msg msgs[] = {
107                 {
108                         .addr   = save_client->addr,
109                         .flags  = 0,
110                         .len    = 1,
111                         .buf    = msgbuf,
112                 },
113                 {
114                         .addr   = save_client->addr,
115                         .flags  = I2C_M_RD,
116                         .len    = 8,
117                         .buf    = buf,
118                 },
119         };
120
121         sec = min = hour = day = mon = year = 0;
122
123         do {
124                 if (i2c_transfer(save_client->adapter, msgs, 2) < 0)
125                         goto read_err;
126
127                 sec1 = sec;
128                 min1 = min;
129                 hour1 = hour;
130                 day1 = day;
131                 mon1 = mon;
132                 year1 = year;
133
134                 sec = buf[m41t00_chip->sec] & 0x7f;
135                 min = buf[m41t00_chip->min] & 0x7f;
136                 hour = buf[m41t00_chip->hour] & 0x3f;
137                 day = buf[m41t00_chip->day] & 0x3f;
138                 mon = buf[m41t00_chip->mon] & 0x1f;
139                 year = buf[m41t00_chip->year];
140         } while ((++reads < m41t00_chip->read_limit) && ((sec != sec1)
141                         || (min != min1) || (hour != hour1) || (day != day1)
142                         || (mon != mon1) || (year != year1)));
143
144         if ((m41t00_chip->read_limit > 1) && ((sec != sec1) || (min != min1)
145                         || (hour != hour1) || (day != day1) || (mon != mon1)
146                         || (year != year1)))
147                 goto read_err;
148
149         sec = BCD2BIN(sec);
150         min = BCD2BIN(min);
151         hour = BCD2BIN(hour);
152         day = BCD2BIN(day);
153         mon = BCD2BIN(mon);
154         year = BCD2BIN(year);
155
156         year += 1900;
157         if (year < 1970)
158                 year += 100;
159
160         return mktime(year, mon, day, hour, min, sec);
161
162 read_err:
163         dev_err(&save_client->dev, "m41t00_get_rtc_time: Read error\n");
164         return 0;
165 }
166 EXPORT_SYMBOL_GPL(m41t00_get_rtc_time);
167
168 static void
169 m41t00_set(void *arg)
170 {
171         struct rtc_time tm;
172         int nowtime = *(int *)arg;
173         s32 sec, min, hour, day, mon, year;
174         u8 wbuf[9], *buf = &wbuf[1], msgbuf[1] = { 0 };
175         struct i2c_msg msgs[] = {
176                 {
177                         .addr   = save_client->addr,
178                         .flags  = 0,
179                         .len    = 1,
180                         .buf    = msgbuf,
181                 },
182                 {
183                         .addr   = save_client->addr,
184                         .flags  = I2C_M_RD,
185                         .len    = 8,
186                         .buf    = buf,
187                 },
188         };
189
190         to_tm(nowtime, &tm);
191         tm.tm_year = (tm.tm_year - 1900) % 100;
192
193         sec = BIN2BCD(tm.tm_sec);
194         min = BIN2BCD(tm.tm_min);
195         hour = BIN2BCD(tm.tm_hour);
196         day = BIN2BCD(tm.tm_mday);
197         mon = BIN2BCD(tm.tm_mon);
198         year = BIN2BCD(tm.tm_year);
199
200         /* Read reg values into buf[0..7]/wbuf[1..8] */
201         if (i2c_transfer(save_client->adapter, msgs, 2) < 0) {
202                 dev_err(&save_client->dev, "m41t00_set: Read error\n");
203                 return;
204         }
205
206         wbuf[0] = 0; /* offset into rtc's regs */
207         buf[m41t00_chip->sec] = (buf[m41t00_chip->sec] & ~0x7f) | (sec & 0x7f);
208         buf[m41t00_chip->min] = (buf[m41t00_chip->min] & ~0x7f) | (min & 0x7f);
209         buf[m41t00_chip->hour] = (buf[m41t00_chip->hour] & ~0x3f) | (hour& 0x3f);
210         buf[m41t00_chip->day] = (buf[m41t00_chip->day] & ~0x3f) | (day & 0x3f);
211         buf[m41t00_chip->mon] = (buf[m41t00_chip->mon] & ~0x1f) | (mon & 0x1f);
212
213         if (i2c_master_send(save_client, wbuf, 9) < 0)
214                 dev_err(&save_client->dev, "m41t00_set: Write error\n");
215 }
216
217 static ulong new_time;
218 static struct workqueue_struct *m41t00_wq;
219 static DECLARE_WORK(m41t00_work, m41t00_set, &new_time);
220
221 int
222 m41t00_set_rtc_time(ulong nowtime)
223 {
224         new_time = nowtime;
225
226         if (in_interrupt())
227                 queue_work(m41t00_wq, &m41t00_work);
228         else
229                 m41t00_set(&new_time);
230
231         return 0;
232 }
233 EXPORT_SYMBOL_GPL(m41t00_set_rtc_time);
234
235 /*
236  *****************************************************************************
237  *
238  *      platform_data Driver Interface
239  *
240  *****************************************************************************
241  */
242 static int __init
243 m41t00_platform_probe(struct platform_device *pdev)
244 {
245         struct m41t00_platform_data *pdata;
246         int i;
247
248         if (pdev && (pdata = pdev->dev.platform_data)) {
249                 normal_addr[0] = pdata->i2c_addr;
250
251                 for (i=0; i<ARRAY_SIZE(m41t00_chip_info_tbl); i++)
252                         if (m41t00_chip_info_tbl[i].type == pdata->type) {
253                                 m41t00_chip = &m41t00_chip_info_tbl[i];
254                                 m41t00_chip->sqw_freq = pdata->sqw_freq;
255                                 return 0;
256                         }
257         }
258         return -ENODEV;
259 }
260
261 static int __exit
262 m41t00_platform_remove(struct platform_device *pdev)
263 {
264         return 0;
265 }
266
267 static struct platform_driver m41t00_platform_driver = {
268         .probe  = m41t00_platform_probe,
269         .remove = m41t00_platform_remove,
270         .driver = {
271                 .owner = THIS_MODULE,
272                 .name  = M41T00_DRV_NAME,
273         },
274 };
275
276 /*
277  *****************************************************************************
278  *
279  *      Driver Interface
280  *
281  *****************************************************************************
282  */
283 static int
284 m41t00_probe(struct i2c_adapter *adap, int addr, int kind)
285 {
286         struct i2c_client *client;
287         int rc;
288
289         if (!i2c_check_functionality(adap, I2C_FUNC_I2C
290                         | I2C_FUNC_SMBUS_BYTE_DATA))
291                 return 0;
292
293         client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
294         if (!client)
295                 return -ENOMEM;
296
297         strlcpy(client->name, m41t00_chip->name, I2C_NAME_SIZE);
298         client->addr = addr;
299         client->adapter = adap;
300         client->driver = &m41t00_driver;
301
302         if ((rc = i2c_attach_client(client)))
303                 goto attach_err;
304
305         if (m41t00_chip->type != M41T00_TYPE_M41T00) {
306                 /* If asked, disable SQW, set SQW frequency & re-enable */
307                 if (m41t00_chip->sqw_freq)
308                         if (((rc = i2c_smbus_read_byte_data(client,
309                                         m41t00_chip->alarm_mon)) < 0)
310                          || ((rc = i2c_smbus_write_byte_data(client,
311                                         m41t00_chip->alarm_mon, rc & ~0x40)) <0)
312                          || ((rc = i2c_smbus_write_byte_data(client,
313                                         m41t00_chip->sqw,
314                                         m41t00_chip->sqw_freq)) < 0)
315                          || ((rc = i2c_smbus_write_byte_data(client,
316                                         m41t00_chip->alarm_mon, rc | 0x40)) <0))
317                                 goto sqw_err;
318
319                 /* Make sure HT (Halt Update) bit is cleared */
320                 if ((rc = i2c_smbus_read_byte_data(client,
321                                 m41t00_chip->alarm_hour)) < 0)
322                         goto ht_err;
323
324                 if (rc & 0x40)
325                         if ((rc = i2c_smbus_write_byte_data(client,
326                                         m41t00_chip->alarm_hour, rc & ~0x40))<0)
327                                 goto ht_err;
328         }
329
330         /* Make sure ST (stop) bit is cleared */
331         if ((rc = i2c_smbus_read_byte_data(client, m41t00_chip->sec)) < 0)
332                 goto st_err;
333
334         if (rc & 0x80)
335                 if ((rc = i2c_smbus_write_byte_data(client, m41t00_chip->sec,
336                                 rc & ~0x80)) < 0)
337                         goto st_err;
338
339         m41t00_wq = create_singlethread_workqueue(m41t00_chip->name);
340         save_client = client;
341         return 0;
342
343 st_err:
344         dev_err(&client->dev, "m41t00_probe: Can't clear ST bit\n");
345         goto attach_err;
346 ht_err:
347         dev_err(&client->dev, "m41t00_probe: Can't clear HT bit\n");
348         goto attach_err;
349 sqw_err:
350         dev_err(&client->dev, "m41t00_probe: Can't set SQW Frequency\n");
351 attach_err:
352         kfree(client);
353         return rc;
354 }
355
356 static int
357 m41t00_attach(struct i2c_adapter *adap)
358 {
359         return i2c_probe(adap, &addr_data, m41t00_probe);
360 }
361
362 static int
363 m41t00_detach(struct i2c_client *client)
364 {
365         int rc;
366
367         if ((rc = i2c_detach_client(client)) == 0) {
368                 kfree(client);
369                 destroy_workqueue(m41t00_wq);
370         }
371         return rc;
372 }
373
374 static struct i2c_driver m41t00_driver = {
375         .driver = {
376                 .name   = M41T00_DRV_NAME,
377         },
378         .id             = I2C_DRIVERID_STM41T00,
379         .attach_adapter = m41t00_attach,
380         .detach_client  = m41t00_detach,
381 };
382
383 static int __init
384 m41t00_init(void)
385 {
386         int rc;
387
388         if (!(rc = platform_driver_register(&m41t00_platform_driver)))
389                 rc = i2c_add_driver(&m41t00_driver);
390         return rc;
391 }
392
393 static void __exit
394 m41t00_exit(void)
395 {
396         i2c_del_driver(&m41t00_driver);
397         platform_driver_unregister(&m41t00_platform_driver);
398 }
399
400 module_init(m41t00_init);
401 module_exit(m41t00_exit);
402
403 MODULE_AUTHOR("Mark A. Greer <mgreer@mvista.com>");
404 MODULE_DESCRIPTION("ST Microelectronics M41T00 RTC I2C Client Driver");
405 MODULE_LICENSE("GPL");