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