Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
36struct rtc8564_data {
37 struct i2c_client client;
38 u16 ctrl;
39};
40
41static inline u8 _rtc8564_ctrl1(struct i2c_client *client)
42{
43 struct rtc8564_data *data = i2c_get_clientdata(client);
44 return data->ctrl & 0xff;
45}
46static 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
58static int debug;;
59module_param(debug, int, S_IRUGO | S_IWUSR);
60
61static struct i2c_driver rtc8564_driver;
62
63static unsigned short ignore[] = { I2C_CLIENT_END };
64static unsigned short normal_addr[] = { 0x51, I2C_CLIENT_END };
65
66static struct i2c_client_address_data addr_data = {
67 .normal_i2c = normal_addr,
68 .probe = ignore,
69 .ignore = ignore,
70};
71
72static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem);
73static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem);
74
75static 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
97done:
98 return ret;
99}
100
101static 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
132done:
133 return ret;
134}
135
136static 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 = kzalloc(sizeof(struct rtc8564_data), GFP_KERNEL);
152 if (!d) {
153 ret = -ENOMEM;
154 goto done;
155 }
156 new_client = &d->client;
157
158 strlcpy(new_client->name, "RTC8564", I2C_NAME_SIZE);
159 i2c_set_clientdata(new_client, d);
160 new_client->flags = I2C_CLIENT_ALLOW_USE;
161 new_client->addr = addr;
162 new_client->adapter = adap;
163 new_client->driver = &rtc8564_driver;
164
165 _DBG(1, "client=%p", new_client);
166
167 /* init ctrl1 reg */
168 data[0] = 0;
169 data[1] = 0;
170 ret = i2c_transfer(new_client->adapter, ctrl_wr, 1);
171 if (ret != 1) {
172 printk(KERN_INFO "rtc8564: cant init ctrl1\n");
173 ret = -ENODEV;
174 goto done;
175 }
176
177 /* read back ctrl1 and ctrl2 */
178 ret = i2c_transfer(new_client->adapter, ctrl_rd, 2);
179 if (ret != 2) {
180 printk(KERN_INFO "rtc8564: cant read ctrl\n");
181 ret = -ENODEV;
182 goto done;
183 }
184
185 d->ctrl = data[0] | (data[1] << 8);
186
187 _DBG(1, "RTC8564_REG_CTRL1=%02x, RTC8564_REG_CTRL2=%02x",
188 data[0], data[1]);
189
190 ret = i2c_attach_client(new_client);
191done:
192 if (ret) {
193 kfree(d);
194 }
195 return ret;
196}
197
198static int rtc8564_probe(struct i2c_adapter *adap)
199{
200 return i2c_probe(adap, &addr_data, rtc8564_attach);
201}
202
203static int rtc8564_detach(struct i2c_client *client)
204{
205 i2c_detach_client(client);
206 kfree(i2c_get_clientdata(client));
207 return 0;
208}
209
210static int rtc8564_get_datetime(struct i2c_client *client, struct rtc_tm *dt)
211{
212 int ret = -EIO;
213 unsigned char buf[15];
214
215 _DBG(1, "client=%p, dt=%p", client, dt);
216
217 if (!dt)
218 return -EINVAL;
219
220 memset(buf, 0, sizeof(buf));
221
222 ret = rtc8564_read(client, 0, buf, 15);
223 if (ret)
224 return ret;
225
226 /* century stored in minute alarm reg */
227 dt->year = BCD_TO_BIN(buf[RTC8564_REG_YEAR]);
228 dt->year += 100 * BCD_TO_BIN(buf[RTC8564_REG_AL_MIN] & 0x3f);
229 dt->mday = BCD_TO_BIN(buf[RTC8564_REG_DAY] & 0x3f);
230 dt->wday = BCD_TO_BIN(buf[RTC8564_REG_WDAY] & 7);
231 dt->mon = BCD_TO_BIN(buf[RTC8564_REG_MON_CENT] & 0x1f);
232
233 dt->secs = BCD_TO_BIN(buf[RTC8564_REG_SEC] & 0x7f);
234 dt->vl = (buf[RTC8564_REG_SEC] & 0x80) == 0x80;
235 dt->mins = BCD_TO_BIN(buf[RTC8564_REG_MIN] & 0x7f);
236 dt->hours = BCD_TO_BIN(buf[RTC8564_REG_HR] & 0x3f);
237
238 _DBGRTCTM(2, *dt);
239
240 return 0;
241}
242
243static int
244rtc8564_set_datetime(struct i2c_client *client, struct rtc_tm *dt, int datetoo)
245{
246 int ret, len = 5;
247 unsigned char buf[15];
248
249 _DBG(1, "client=%p, dt=%p", client, dt);
250
251 if (!dt)
252 return -EINVAL;
253
254 _DBGRTCTM(2, *dt);
255
256 buf[RTC8564_REG_CTRL1] = CTRL1(client) | RTC8564_CTRL1_STOP;
257 buf[RTC8564_REG_CTRL2] = CTRL2(client);
258 buf[RTC8564_REG_SEC] = BIN_TO_BCD(dt->secs);
259 buf[RTC8564_REG_MIN] = BIN_TO_BCD(dt->mins);
260 buf[RTC8564_REG_HR] = BIN_TO_BCD(dt->hours);
261
262 if (datetoo) {
263 len += 5;
264 buf[RTC8564_REG_DAY] = BIN_TO_BCD(dt->mday);
265 buf[RTC8564_REG_WDAY] = BIN_TO_BCD(dt->wday);
266 buf[RTC8564_REG_MON_CENT] = BIN_TO_BCD(dt->mon) & 0x1f;
267 /* century stored in minute alarm reg */
268 buf[RTC8564_REG_YEAR] = BIN_TO_BCD(dt->year % 100);
269 buf[RTC8564_REG_AL_MIN] = BIN_TO_BCD(dt->year / 100);
270 }
271
272 ret = rtc8564_write(client, 0, buf, len);
273 if (ret) {
274 _DBG(1, "error writing data! %d", ret);
275 }
276
277 buf[RTC8564_REG_CTRL1] = CTRL1(client);
278 ret = rtc8564_write(client, 0, buf, 1);
279 if (ret) {
280 _DBG(1, "error writing data! %d", ret);
281 }
282
283 return ret;
284}
285
286static int rtc8564_get_ctrl(struct i2c_client *client, unsigned int *ctrl)
287{
288 struct rtc8564_data *data = i2c_get_clientdata(client);
289
290 if (!ctrl)
291 return -1;
292
293 *ctrl = data->ctrl;
294 return 0;
295}
296
297static int rtc8564_set_ctrl(struct i2c_client *client, unsigned int *ctrl)
298{
299 struct rtc8564_data *data = i2c_get_clientdata(client);
300 unsigned char buf[2];
301
302 if (!ctrl)
303 return -1;
304
305 buf[0] = *ctrl & 0xff;
306 buf[1] = (*ctrl & 0xff00) >> 8;
307 data->ctrl = *ctrl;
308
309 return rtc8564_write(client, 0, buf, 2);
310}
311
312static int rtc8564_read_mem(struct i2c_client *client, struct mem *mem)
313{
314
315 if (!mem)
316 return -EINVAL;
317
318 return rtc8564_read(client, mem->loc, mem->data, mem->nr);
319}
320
321static int rtc8564_write_mem(struct i2c_client *client, struct mem *mem)
322{
323
324 if (!mem)
325 return -EINVAL;
326
327 return rtc8564_write(client, mem->loc, mem->data, mem->nr);
328}
329
330static int
331rtc8564_command(struct i2c_client *client, unsigned int cmd, void *arg)
332{
333
334 _DBG(1, "cmd=%d", cmd);
335
336 switch (cmd) {
337 case RTC_GETDATETIME:
338 return rtc8564_get_datetime(client, arg);
339
340 case RTC_SETTIME:
341 return rtc8564_set_datetime(client, arg, 0);
342
343 case RTC_SETDATETIME:
344 return rtc8564_set_datetime(client, arg, 1);
345
346 case RTC_GETCTRL:
347 return rtc8564_get_ctrl(client, arg);
348
349 case RTC_SETCTRL:
350 return rtc8564_set_ctrl(client, arg);
351
352 case MEM_READ:
353 return rtc8564_read_mem(client, arg);
354
355 case MEM_WRITE:
356 return rtc8564_write_mem(client, arg);
357
358 default:
359 return -EINVAL;
360 }
361}
362
363static struct i2c_driver rtc8564_driver = {
364 .owner = THIS_MODULE,
365 .name = "RTC8564",
366 .id = I2C_DRIVERID_RTC8564,
367 .flags = I2C_DF_NOTIFY,
368 .attach_adapter = rtc8564_probe,
369 .detach_client = rtc8564_detach,
370 .command = rtc8564_command
371};
372
373static __init int rtc8564_init(void)
374{
375 return i2c_add_driver(&rtc8564_driver);
376}
377
378static __exit void rtc8564_exit(void)
379{
380 i2c_del_driver(&rtc8564_driver);
381}
382
383MODULE_AUTHOR("Stefan Eletzhofer <Stefan.Eletzhofer@eletztrick.de>");
384MODULE_DESCRIPTION("EPSON RTC8564 Driver");
385MODULE_LICENSE("GPL");
386
387module_init(rtc8564_init);
388module_exit(rtc8564_exit);