Manual merge with Linus
[linux-2.6] / drivers / i2c / chips / rtc8564.c
1 /*
2  *  linux/drivers/i2c/chips/rtc8564.c
3  *
4  *  Copyright (C) 2002-2004 Stefan Eletzhofer
5  *
6  *      based on linux/drivers/acron/char/pcf8583.c
7  *  Copyright (C) 2000 Russell King
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  *
13  * Driver for system3's EPSON RTC 8564 chip
14  */
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/i2c.h>
18 #include <linux/slab.h>
19 #include <linux/string.h>
20 #include <linux/rtc.h>          /* get the user-level API */
21 #include <linux/init.h>
22
23 #include "rtc8564.h"
24
25 #ifdef DEBUG
26 # define _DBG(x, fmt, args...) do{ if (debug>=x) printk(KERN_DEBUG"%s: " fmt "\n", __FUNCTION__, ##args); } while(0);
27 #else
28 # define _DBG(x, fmt, args...) do { } while(0);
29 #endif
30
31 #define _DBGRTCTM(x, rtctm) if (debug>=x) printk("%s: secs=%d, mins=%d, hours=%d, mday=%d, " \
32                         "mon=%d, year=%d, wday=%d VL=%d\n", __FUNCTION__, \
33                         (rtctm).secs, (rtctm).mins, (rtctm).hours, (rtctm).mday, \
34                         (rtctm).mon, (rtctm).year, (rtctm).wday, (rtctm).vl);
35
36 struct rtc8564_data {
37         struct i2c_client client;
38         u16 ctrl;
39 };
40
41 static inline u8 _rtc8564_ctrl1(struct i2c_client *client)
42 {
43         struct rtc8564_data *data = i2c_get_clientdata(client);
44         return data->ctrl & 0xff;
45 }
46 static inline u8 _rtc8564_ctrl2(struct i2c_client *client)
47 {
48         struct rtc8564_data *data = i2c_get_clientdata(client);
49         return (data->ctrl & 0xff00) >> 8;
50 }
51
52 #define CTRL1(c) _rtc8564_ctrl1(c)
53 #define CTRL2(c) _rtc8564_ctrl2(c)
54
55 #define BCD_TO_BIN(val) (((val)&15) + ((val)>>4)*10)
56 #define BIN_TO_BCD(val) ((((val)/10)<<4) + (val)%10)
57
58 static int debug;;
59 module_param(debug, int, S_IRUGO | S_IWUSR);
60
61 static struct i2c_driver rtc8564_driver;
62
63 static unsigned short ignore[] = { I2C_CLIENT_END };
64 static unsigned short normal_addr[] = { 0x51, I2C_CLIENT_END };
65
66 static struct i2c_client_address_data addr_data = {
67         .normal_i2c             = normal_addr,
68         .probe                  = ignore,
69         .ignore                 = ignore,
70 };
71
72 static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem);
73 static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem);
74
75 static int rtc8564_read(struct i2c_client *client, unsigned char adr,
76                         unsigned char *buf, unsigned char len)
77 {
78         int ret = -EIO;
79         unsigned char addr[1] = { adr };
80         struct i2c_msg msgs[2] = {
81                 {client->addr, 0, 1, addr},
82                 {client->addr, I2C_M_RD, len, buf}
83         };
84
85         _DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, buf, len);
86
87         if (!buf) {
88                 ret = -EINVAL;
89                 goto done;
90         }
91
92         ret = i2c_transfer(client->adapter, msgs, 2);
93         if (ret == 2) {
94                 ret = 0;
95         }
96
97 done:
98         return ret;
99 }
100
101 static int rtc8564_write(struct i2c_client *client, unsigned char adr,
102                          unsigned char *data, unsigned char len)
103 {
104         int ret = 0;
105         unsigned char _data[16];
106         struct i2c_msg wr;
107         int i;
108
109         if (!data || len > 15) {
110                 ret = -EINVAL;
111                 goto done;
112         }
113
114         _DBG(1, "client=%p, adr=%d, buf=%p, len=%d", client, adr, data, len);
115
116         _data[0] = adr;
117         for (i = 0; i < len; i++) {
118                 _data[i + 1] = data[i];
119                 _DBG(5, "data[%d] = 0x%02x (%d)", i, data[i], data[i]);
120         }
121
122         wr.addr = client->addr;
123         wr.flags = 0;
124         wr.len = len + 1;
125         wr.buf = _data;
126
127         ret = i2c_transfer(client->adapter, &wr, 1);
128         if (ret == 1) {
129                 ret = 0;
130         }
131
132 done:
133         return ret;
134 }
135
136 static int rtc8564_attach(struct i2c_adapter *adap, int addr, int kind)
137 {
138         int ret;
139         struct i2c_client *new_client;
140         struct rtc8564_data *d;
141         unsigned char data[10];
142         unsigned char ad[1] = { 0 };
143         struct i2c_msg ctrl_wr[1] = {
144                 {addr, 0, 2, data}
145         };
146         struct i2c_msg ctrl_rd[2] = {
147                 {addr, 0, 1, ad},
148                 {addr, I2C_M_RD, 2, data}
149         };
150
151         d = kmalloc(sizeof(struct rtc8564_data), GFP_KERNEL);
152         if (!d) {
153                 ret = -ENOMEM;
154                 goto done;
155         }
156         memset(d, 0, sizeof(struct rtc8564_data));
157         new_client = &d->client;
158
159         strlcpy(new_client->name, "RTC8564", I2C_NAME_SIZE);
160         i2c_set_clientdata(new_client, d);
161         new_client->flags = I2C_CLIENT_ALLOW_USE | I2C_DF_NOTIFY;
162         new_client->addr = addr;
163         new_client->adapter = adap;
164         new_client->driver = &rtc8564_driver;
165
166         _DBG(1, "client=%p", new_client);
167
168         /* init ctrl1 reg */
169         data[0] = 0;
170         data[1] = 0;
171         ret = i2c_transfer(new_client->adapter, ctrl_wr, 1);
172         if (ret != 1) {
173                 printk(KERN_INFO "rtc8564: cant init ctrl1\n");
174                 ret = -ENODEV;
175                 goto done;
176         }
177
178         /* read back ctrl1 and ctrl2 */
179         ret = i2c_transfer(new_client->adapter, ctrl_rd, 2);
180         if (ret != 2) {
181                 printk(KERN_INFO "rtc8564: cant read ctrl\n");
182                 ret = -ENODEV;
183                 goto done;
184         }
185
186         d->ctrl = data[0] | (data[1] << 8);
187
188         _DBG(1, "RTC8564_REG_CTRL1=%02x, RTC8564_REG_CTRL2=%02x",
189              data[0], data[1]);
190
191         ret = i2c_attach_client(new_client);
192 done:
193         if (ret) {
194                 kfree(d);
195         }
196         return ret;
197 }
198
199 static int rtc8564_probe(struct i2c_adapter *adap)
200 {
201         return i2c_probe(adap, &addr_data, rtc8564_attach);
202 }
203
204 static int rtc8564_detach(struct i2c_client *client)
205 {
206         i2c_detach_client(client);
207         kfree(i2c_get_clientdata(client));
208         return 0;
209 }
210
211 static int rtc8564_get_datetime(struct i2c_client *client, struct rtc_tm *dt)
212 {
213         int ret = -EIO;
214         unsigned char buf[15];
215
216         _DBG(1, "client=%p, dt=%p", client, dt);
217
218         if (!dt)
219                 return -EINVAL;
220
221         memset(buf, 0, sizeof(buf));
222
223         ret = rtc8564_read(client, 0, buf, 15);
224         if (ret)
225                 return ret;
226
227         /* century stored in minute alarm reg */
228         dt->year = BCD_TO_BIN(buf[RTC8564_REG_YEAR]);
229         dt->year += 100 * BCD_TO_BIN(buf[RTC8564_REG_AL_MIN] & 0x3f);
230         dt->mday = BCD_TO_BIN(buf[RTC8564_REG_DAY] & 0x3f);
231         dt->wday = BCD_TO_BIN(buf[RTC8564_REG_WDAY] & 7);
232         dt->mon = BCD_TO_BIN(buf[RTC8564_REG_MON_CENT] & 0x1f);
233
234         dt->secs = BCD_TO_BIN(buf[RTC8564_REG_SEC] & 0x7f);
235         dt->vl = (buf[RTC8564_REG_SEC] & 0x80) == 0x80;
236         dt->mins = BCD_TO_BIN(buf[RTC8564_REG_MIN] & 0x7f);
237         dt->hours = BCD_TO_BIN(buf[RTC8564_REG_HR] & 0x3f);
238
239         _DBGRTCTM(2, *dt);
240
241         return 0;
242 }
243
244 static int
245 rtc8564_set_datetime(struct i2c_client *client, struct rtc_tm *dt, int datetoo)
246 {
247         int ret, len = 5;
248         unsigned char buf[15];
249
250         _DBG(1, "client=%p, dt=%p", client, dt);
251
252         if (!dt)
253                 return -EINVAL;
254
255         _DBGRTCTM(2, *dt);
256
257         buf[RTC8564_REG_CTRL1] = CTRL1(client) | RTC8564_CTRL1_STOP;
258         buf[RTC8564_REG_CTRL2] = CTRL2(client);
259         buf[RTC8564_REG_SEC] = BIN_TO_BCD(dt->secs);
260         buf[RTC8564_REG_MIN] = BIN_TO_BCD(dt->mins);
261         buf[RTC8564_REG_HR] = BIN_TO_BCD(dt->hours);
262
263         if (datetoo) {
264                 len += 5;
265                 buf[RTC8564_REG_DAY] = BIN_TO_BCD(dt->mday);
266                 buf[RTC8564_REG_WDAY] = BIN_TO_BCD(dt->wday);
267                 buf[RTC8564_REG_MON_CENT] = BIN_TO_BCD(dt->mon) & 0x1f;
268                 /* century stored in minute alarm reg */
269                 buf[RTC8564_REG_YEAR] = BIN_TO_BCD(dt->year % 100);
270                 buf[RTC8564_REG_AL_MIN] = BIN_TO_BCD(dt->year / 100);
271         }
272
273         ret = rtc8564_write(client, 0, buf, len);
274         if (ret) {
275                 _DBG(1, "error writing data! %d", ret);
276         }
277
278         buf[RTC8564_REG_CTRL1] = CTRL1(client);
279         ret = rtc8564_write(client, 0, buf, 1);
280         if (ret) {
281                 _DBG(1, "error writing data! %d", ret);
282         }
283
284         return ret;
285 }
286
287 static int rtc8564_get_ctrl(struct i2c_client *client, unsigned int *ctrl)
288 {
289         struct rtc8564_data *data = i2c_get_clientdata(client);
290
291         if (!ctrl)
292                 return -1;
293
294         *ctrl = data->ctrl;
295         return 0;
296 }
297
298 static int rtc8564_set_ctrl(struct i2c_client *client, unsigned int *ctrl)
299 {
300         struct rtc8564_data *data = i2c_get_clientdata(client);
301         unsigned char buf[2];
302
303         if (!ctrl)
304                 return -1;
305
306         buf[0] = *ctrl & 0xff;
307         buf[1] = (*ctrl & 0xff00) >> 8;
308         data->ctrl = *ctrl;
309
310         return rtc8564_write(client, 0, buf, 2);
311 }
312
313 static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem)
314 {
315
316         if (!mem)
317                 return -EINVAL;
318
319         return rtc8564_read(client, mem->loc, mem->data, mem->nr);
320 }
321
322 static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem)
323 {
324
325         if (!mem)
326                 return -EINVAL;
327
328         return rtc8564_write(client, mem->loc, mem->data, mem->nr);
329 }
330
331 static int
332 rtc8564_command(struct i2c_client *client, unsigned int cmd, void *arg)
333 {
334
335         _DBG(1, "cmd=%d", cmd);
336
337         switch (cmd) {
338         case RTC_GETDATETIME:
339                 return rtc8564_get_datetime(client, arg);
340
341         case RTC_SETTIME:
342                 return rtc8564_set_datetime(client, arg, 0);
343
344         case RTC_SETDATETIME:
345                 return rtc8564_set_datetime(client, arg, 1);
346
347         case RTC_GETCTRL:
348                 return rtc8564_get_ctrl(client, arg);
349
350         case RTC_SETCTRL:
351                 return rtc8564_set_ctrl(client, arg);
352
353         case MEM_READ:
354                 return rtc8564_read_mem(client, arg);
355
356         case MEM_WRITE:
357                 return rtc8564_write_mem(client, arg);
358
359         default:
360                 return -EINVAL;
361         }
362 }
363
364 static struct i2c_driver rtc8564_driver = {
365         .owner          = THIS_MODULE,
366         .name           = "RTC8564",
367         .id             = I2C_DRIVERID_RTC8564,
368         .flags          = I2C_DF_NOTIFY,
369         .attach_adapter = rtc8564_probe,
370         .detach_client  = rtc8564_detach,
371         .command        = rtc8564_command
372 };
373
374 static __init int rtc8564_init(void)
375 {
376         return i2c_add_driver(&rtc8564_driver);
377 }
378
379 static __exit void rtc8564_exit(void)
380 {
381         i2c_del_driver(&rtc8564_driver);
382 }
383
384 MODULE_AUTHOR("Stefan Eletzhofer <Stefan.Eletzhofer@eletztrick.de>");
385 MODULE_DESCRIPTION("EPSON RTC8564 Driver");
386 MODULE_LICENSE("GPL");
387
388 module_init(rtc8564_init);
389 module_exit(rtc8564_exit);