URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [rtc/] [rtc-pcf8583.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 *  drivers/rtc/rtc-pcf8583.c
 *
 *  Copyright (C) 2000 Russell King
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 *  Driver for PCF8583 RTC & RAM chip
 *
 *  Converted to the generic RTC susbsystem by G. Liakhovetski (2006)
 */
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/mc146818rtc.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/bcd.h>
 
struct rtc_mem {
        unsigned int    loc;
        unsigned int    nr;
        unsigned char   *data;
};
 
struct pcf8583 {
        struct i2c_client client;
        struct rtc_device *rtc;
        unsigned char ctrl;
};
 
#define CTRL_STOP       0x80
#define CTRL_HOLD       0x40
#define CTRL_32KHZ      0x00
#define CTRL_MASK       0x08
#define CTRL_ALARMEN    0x04
#define CTRL_ALARM      0x02
#define CTRL_TIMER      0x01
 
static unsigned short normal_i2c[] = { 0x50, I2C_CLIENT_END };
 
/* Module parameters */
I2C_CLIENT_INSMOD;
 
static struct i2c_driver pcf8583_driver;
 
#define get_ctrl(x)    ((struct pcf8583 *)i2c_get_clientdata(x))->ctrl
#define set_ctrl(x, v) get_ctrl(x) = v
 
#define CMOS_YEAR       (64 + 128)
#define CMOS_CHECKSUM   (63)
 
static int pcf8583_get_datetime(struct i2c_client *client, struct rtc_time *dt)
{
        unsigned char buf[8], addr[1] = { 1 };
        struct i2c_msg msgs[2] = {
                {
                        .addr = client->addr,
                        .flags = 0,
                        .len = 1,
                        .buf = addr,
                }, {
                        .addr = client->addr,
                        .flags = I2C_M_RD,
                        .len = 6,
                        .buf = buf,
                }
        };
        int ret;
 
        memset(buf, 0, sizeof(buf));
 
        ret = i2c_transfer(client->adapter, msgs, 2);
        if (ret == 2) {
                dt->tm_year = buf[4] >> 6;
                dt->tm_wday = buf[5] >> 5;
 
                buf[4] &= 0x3f;
                buf[5] &= 0x1f;
 
                dt->tm_sec = BCD2BIN(buf[1]);
                dt->tm_min = BCD2BIN(buf[2]);
                dt->tm_hour = BCD2BIN(buf[3]);
                dt->tm_mday = BCD2BIN(buf[4]);
                dt->tm_mon = BCD2BIN(buf[5]) - 1;
        }
 
        return ret == 2 ? 0 : -EIO;
}
 
static int pcf8583_set_datetime(struct i2c_client *client, struct rtc_time *dt, int datetoo)
{
        unsigned char buf[8];
        int ret, len = 6;
 
        buf[0] = 0;
        buf[1] = get_ctrl(client) | 0x80;
        buf[2] = 0;
        buf[3] = BIN2BCD(dt->tm_sec);
        buf[4] = BIN2BCD(dt->tm_min);
        buf[5] = BIN2BCD(dt->tm_hour);
 
        if (datetoo) {
                len = 8;
                buf[6] = BIN2BCD(dt->tm_mday) | (dt->tm_year << 6);
                buf[7] = BIN2BCD(dt->tm_mon + 1)  | (dt->tm_wday << 5);
        }
 
        ret = i2c_master_send(client, (char *)buf, len);
        if (ret != len)
                return -EIO;
 
        buf[1] = get_ctrl(client);
        ret = i2c_master_send(client, (char *)buf, 2);
 
        return ret == 2 ? 0 : -EIO;
}
 
static int pcf8583_get_ctrl(struct i2c_client *client, unsigned char *ctrl)
{
        *ctrl = get_ctrl(client);
        return 0;
}
 
static int pcf8583_set_ctrl(struct i2c_client *client, unsigned char *ctrl)
{
        unsigned char buf[2];
 
        buf[0] = 0;
        buf[1] = *ctrl;
        set_ctrl(client, *ctrl);
 
        return i2c_master_send(client, (char *)buf, 2);
}
 
static int pcf8583_read_mem(struct i2c_client *client, struct rtc_mem *mem)
{
        unsigned char addr[1];
        struct i2c_msg msgs[2] = {
                {
                        .addr = client->addr,
                        .flags = 0,
                        .len = 1,
                        .buf = addr,
                }, {
                        .addr = client->addr,
                        .flags = I2C_M_RD,
                        .len = mem->nr,
                        .buf = mem->data,
                }
        };
 
        if (mem->loc < 8)
                return -EINVAL;
 
        addr[0] = mem->loc;
 
        return i2c_transfer(client->adapter, msgs, 2) == 2 ? 0 : -EIO;
}
 
static int pcf8583_write_mem(struct i2c_client *client, struct rtc_mem *mem)
{
        unsigned char addr[1];
        struct i2c_msg msgs[2] = {
                {
                        .addr = client->addr,
                        .flags = 0,
                        .len = 1,
                        .buf = addr,
                }, {
                        .addr = client->addr,
                        .flags = I2C_M_NOSTART,
                        .len = mem->nr,
                        .buf = mem->data,
                }
        };
 
        if (mem->loc < 8)
                return -EINVAL;
 
        addr[0] = mem->loc;
 
        return i2c_transfer(client->adapter, msgs, 2) == 2 ? 0 : -EIO;
}
 
static int pcf8583_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
        struct i2c_client *client = to_i2c_client(dev);
        unsigned char ctrl, year[2];
        struct rtc_mem mem = { CMOS_YEAR, sizeof(year), year };
        int real_year, year_offset, err;
 
        /*
         * Ensure that the RTC is running.
         */
        pcf8583_get_ctrl(client, &ctrl);
        if (ctrl & (CTRL_STOP | CTRL_HOLD)) {
                unsigned char new_ctrl = ctrl & ~(CTRL_STOP | CTRL_HOLD);
 
                printk(KERN_WARNING "RTC: resetting control %02x -> %02x\n",
                       ctrl, new_ctrl);
 
                if ((err = pcf8583_set_ctrl(client, &new_ctrl)) < 0)
                        return err;
        }
 
        if (pcf8583_get_datetime(client, tm) ||
            pcf8583_read_mem(client, &mem))
                return -EIO;
 
        real_year = year[0];
 
        /*
         * The RTC year holds the LSB two bits of the current
         * year, which should reflect the LSB two bits of the
         * CMOS copy of the year.  Any difference indicates
         * that we have to correct the CMOS version.
         */
        year_offset = tm->tm_year - (real_year & 3);
        if (year_offset < 0)
                /*
                 * RTC year wrapped.  Adjust it appropriately.
                 */
                year_offset += 4;
 
        tm->tm_year = (real_year + year_offset + year[1] * 100) - 1900;
 
        return 0;
}
 
static int pcf8583_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
        struct i2c_client *client = to_i2c_client(dev);
        unsigned char year[2], chk;
        struct rtc_mem cmos_year  = { CMOS_YEAR, sizeof(year), year };
        struct rtc_mem cmos_check = { CMOS_CHECKSUM, 1, &chk };
        unsigned int proper_year = tm->tm_year + 1900;
        int ret;
 
        /*
         * The RTC's own 2-bit year must reflect the least
         * significant two bits of the CMOS year.
         */
 
        ret = pcf8583_set_datetime(client, tm, 1);
        if (ret)
                return ret;
 
        ret = pcf8583_read_mem(client, &cmos_check);
        if (ret)
                return ret;
 
        ret = pcf8583_read_mem(client, &cmos_year);
        if (ret)
                return ret;
 
        chk -= year[1] + year[0];
 
        year[1] = proper_year / 100;
        year[0] = proper_year % 100;
 
        chk += year[1] + year[0];
 
        ret = pcf8583_write_mem(client, &cmos_year);
 
        if (ret)
                return ret;
 
        ret = pcf8583_write_mem(client, &cmos_check);
 
        return ret;
}
 
static const struct rtc_class_ops pcf8583_rtc_ops = {
        .read_time      = pcf8583_rtc_read_time,
        .set_time       = pcf8583_rtc_set_time,
};
 
static int pcf8583_probe(struct i2c_adapter *adap, int addr, int kind);
 
static int pcf8583_attach(struct i2c_adapter *adap)
{
        return i2c_probe(adap, &addr_data, pcf8583_probe);
}
 
static int pcf8583_detach(struct i2c_client *client)
{
        int err;
        struct pcf8583 *pcf = i2c_get_clientdata(client);
        struct rtc_device *rtc = pcf->rtc;
 
        if (rtc)
                rtc_device_unregister(rtc);
 
        if ((err = i2c_detach_client(client)))
                return err;
 
        kfree(pcf);
        return 0;
}
 
static struct i2c_driver pcf8583_driver = {
        .driver = {
                .name   = "pcf8583",
        },
        .id             = I2C_DRIVERID_PCF8583,
        .attach_adapter = pcf8583_attach,
        .detach_client  = pcf8583_detach,
};
 
static int pcf8583_probe(struct i2c_adapter *adap, int addr, int kind)
{
        struct pcf8583 *pcf;
        struct i2c_client *client;
        struct rtc_device *rtc;
        unsigned char buf[1], ad[1] = { 0 };
        int err;
        struct i2c_msg msgs[2] = {
                {
                        .addr = addr,
                        .flags = 0,
                        .len = 1,
                        .buf = ad,
                }, {
                        .addr = addr,
                        .flags = I2C_M_RD,
                        .len = 1,
                        .buf = buf,
                }
        };
 
        if (!i2c_check_functionality(adap, I2C_FUNC_I2C))
                return 0;
 
        pcf = kzalloc(sizeof(*pcf), GFP_KERNEL);
        if (!pcf)
                return -ENOMEM;
 
        client = &pcf->client;
 
        client->addr            = addr;
        client->adapter = adap;
        client->driver  = &pcf8583_driver;
 
        strlcpy(client->name, pcf8583_driver.driver.name, I2C_NAME_SIZE);
 
        if (i2c_transfer(client->adapter, msgs, 2) != 2) {
                err = -EIO;
                goto exit_kfree;
        }
 
        err = i2c_attach_client(client);
 
        if (err)
                goto exit_kfree;
 
        rtc = rtc_device_register(pcf8583_driver.driver.name, &client->dev,
                                  &pcf8583_rtc_ops, THIS_MODULE);
 
        if (IS_ERR(rtc)) {
                err = PTR_ERR(rtc);
                goto exit_detach;
        }
 
        pcf->rtc = rtc;
        i2c_set_clientdata(client, pcf);
        set_ctrl(client, buf[0]);
 
        return 0;
 
exit_detach:
        i2c_detach_client(client);
 
exit_kfree:
        kfree(pcf);
 
        return err;
}
 
static __init int pcf8583_init(void)
{
        return i2c_add_driver(&pcf8583_driver);
}
 
static __exit void pcf8583_exit(void)
{
        i2c_del_driver(&pcf8583_driver);
}
 
module_init(pcf8583_init);
module_exit(pcf8583_exit);
 
MODULE_AUTHOR("Russell King");
MODULE_DESCRIPTION("PCF8583 I2C RTC driver");
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [rtc/] [rtc-pcf8583.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* drivers/rtc/rtc-pcf8583.c`
3			`*`
4			`* Copyright (C) 2000 Russell King`
5			`*`
6			`* This program is free software; you can redistribute it and/or modify`
7			`* it under the terms of the GNU General Public License version 2 as`
8			`* published by the Free Software Foundation.`
9			`*`
10			`* Driver for PCF8583 RTC & RAM chip`
11			`*`
12			`* Converted to the generic RTC susbsystem by G. Liakhovetski (2006)`
13			`*/`
14			`#include <linux/module.h>`
15			`#include <linux/i2c.h>`
16			`#include <linux/slab.h>`
17			`#include <linux/string.h>`
18			`#include <linux/mc146818rtc.h>`
19			`#include <linux/init.h>`
20			`#include <linux/errno.h>`
21			`#include <linux/bcd.h>`
22
23			`struct rtc_mem {`
24			`unsigned int loc;`
25			`unsigned int nr;`
26			`unsigned char *data;`
27			`};`
28
29			`struct pcf8583 {`
30			`struct i2c_client client;`
31			`struct rtc_device *rtc;`
32			`unsigned char ctrl;`
33			`};`
34
35			`#define CTRL_STOP 0x80`
36			`#define CTRL_HOLD 0x40`
37			`#define CTRL_32KHZ 0x00`
38			`#define CTRL_MASK 0x08`
39			`#define CTRL_ALARMEN 0x04`
40			`#define CTRL_ALARM 0x02`
41			`#define CTRL_TIMER 0x01`
42
43			`static unsigned short normal_i2c[] = { 0x50, I2C_CLIENT_END };`
44
45			`/* Module parameters */`
46			`I2C_CLIENT_INSMOD;`
47
48			`static struct i2c_driver pcf8583_driver;`
49
50			`#define get_ctrl(x) ((struct pcf8583 *)i2c_get_clientdata(x))->ctrl`
51			`#define set_ctrl(x, v) get_ctrl(x) = v`
52
53			`#define CMOS_YEAR (64 + 128)`
54			`#define CMOS_CHECKSUM (63)`
55
56			`static int pcf8583_get_datetime(struct i2c_client client, struct rtc_time dt)`
57			`{`
58			`unsigned char buf[8], addr[1] = { 1 };`
59			`struct i2c_msg msgs[2] = {`
60			`{`
61			`.addr = client->addr,`
62			`.flags = 0,`
63			`.len = 1,`
64			`.buf = addr,`
65			`}, {`
66			`.addr = client->addr,`
67			`.flags = I2C_M_RD,`
68			`.len = 6,`
69			`.buf = buf,`
70			`}`
71			`};`
72			`int ret;`
73
74			`memset(buf, 0, sizeof(buf));`
75
76			`ret = i2c_transfer(client->adapter, msgs, 2);`
77			`if (ret == 2) {`
78			`dt->tm_year = buf[4] >> 6;`
79			`dt->tm_wday = buf[5] >> 5;`
80
81			`buf[4] &= 0x3f;`
82			`buf[5] &= 0x1f;`
83
84			`dt->tm_sec = BCD2BIN(buf[1]);`
85			`dt->tm_min = BCD2BIN(buf[2]);`
86			`dt->tm_hour = BCD2BIN(buf[3]);`
87			`dt->tm_mday = BCD2BIN(buf[4]);`
88			`dt->tm_mon = BCD2BIN(buf[5]) - 1;`
89			`}`
90
91			`return ret == 2 ? 0 : -EIO;`
92			`}`
93
94			`static int pcf8583_set_datetime(struct i2c_client client, struct rtc_time dt, int datetoo)`
95			`{`
96			`unsigned char buf[8];`
97			`int ret, len = 6;`
98
99			`buf[0] = 0;`
100			`buf[1] = get_ctrl(client) \| 0x80;`
101			`buf[2] = 0;`
102			`buf[3] = BIN2BCD(dt->tm_sec);`
103			`buf[4] = BIN2BCD(dt->tm_min);`
104			`buf[5] = BIN2BCD(dt->tm_hour);`
105
106			`if (datetoo) {`
107			`len = 8;`
108			`buf[6] = BIN2BCD(dt->tm_mday) \| (dt->tm_year << 6);`
109			`buf[7] = BIN2BCD(dt->tm_mon + 1) \| (dt->tm_wday << 5);`
110			`}`
111
112			`ret = i2c_master_send(client, (char *)buf, len);`
113			`if (ret != len)`
114			`return -EIO;`
115
116			`buf[1] = get_ctrl(client);`
117			`ret = i2c_master_send(client, (char *)buf, 2);`
118
119			`return ret == 2 ? 0 : -EIO;`
120			`}`
121
122			`static int pcf8583_get_ctrl(struct i2c_client client, unsigned char ctrl)`
123			`{`
124			`*ctrl = get_ctrl(client);`
125			`return 0;`
126			`}`
127
128			`static int pcf8583_set_ctrl(struct i2c_client client, unsigned char ctrl)`
129			`{`
130			`unsigned char buf[2];`
131
132			`buf[0] = 0;`
133			`buf[1] = *ctrl;`
134			`set_ctrl(client, *ctrl);`
135
136			`return i2c_master_send(client, (char *)buf, 2);`
137			`}`
138
139			`static int pcf8583_read_mem(struct i2c_client client, struct rtc_mem mem)`
140			`{`
141			`unsigned char addr[1];`
142			`struct i2c_msg msgs[2] = {`
143			`{`
144			`.addr = client->addr,`
145			`.flags = 0,`
146			`.len = 1,`
147			`.buf = addr,`
148			`}, {`
149			`.addr = client->addr,`
150			`.flags = I2C_M_RD,`
151			`.len = mem->nr,`
152			`.buf = mem->data,`
153			`}`
154			`};`
155
156			`if (mem->loc < 8)`
157			`return -EINVAL;`
158
159			`addr[0] = mem->loc;`
160
161			`return i2c_transfer(client->adapter, msgs, 2) == 2 ? 0 : -EIO;`
162			`}`
163
164			`static int pcf8583_write_mem(struct i2c_client client, struct rtc_mem mem)`
165			`{`
166			`unsigned char addr[1];`
167			`struct i2c_msg msgs[2] = {`
168			`{`
169			`.addr = client->addr,`
170			`.flags = 0,`
171			`.len = 1,`
172			`.buf = addr,`
173			`}, {`
174			`.addr = client->addr,`
175			`.flags = I2C_M_NOSTART,`
176			`.len = mem->nr,`
177			`.buf = mem->data,`
178			`}`
179			`};`
180
181			`if (mem->loc < 8)`
182			`return -EINVAL;`
183
184			`addr[0] = mem->loc;`
185
186			`return i2c_transfer(client->adapter, msgs, 2) == 2 ? 0 : -EIO;`
187			`}`
188
189			`static int pcf8583_rtc_read_time(struct device dev, struct rtc_time tm)`
190			`{`
191			`struct i2c_client *client = to_i2c_client(dev);`
192			`unsigned char ctrl, year[2];`
193			`struct rtc_mem mem = { CMOS_YEAR, sizeof(year), year };`
194			`int real_year, year_offset, err;`
195
196			`/*`
197			`* Ensure that the RTC is running.`
198			`*/`
199			`pcf8583_get_ctrl(client, &ctrl);`
200			`if (ctrl & (CTRL_STOP \| CTRL_HOLD)) {`
201			`unsigned char new_ctrl = ctrl & ~(CTRL_STOP \| CTRL_HOLD);`
202
203			`printk(KERN_WARNING "RTC: resetting control %02x -> %02x\n",`
204			`ctrl, new_ctrl);`
205
206			`if ((err = pcf8583_set_ctrl(client, &new_ctrl)) < 0)`
207			`return err;`
208			`}`
209
210			`if (pcf8583_get_datetime(client, tm) \|\|`
211			`pcf8583_read_mem(client, &mem))`
212			`return -EIO;`
213
214			`real_year = year[0];`
215
216			`/*`
217			`* The RTC year holds the LSB two bits of the current`
218			`* year, which should reflect the LSB two bits of the`
219			`* CMOS copy of the year. Any difference indicates`
220			`* that we have to correct the CMOS version.`
221			`*/`
222			`year_offset = tm->tm_year - (real_year & 3);`
223			`if (year_offset < 0)`
224			`/*`
225			`* RTC year wrapped. Adjust it appropriately.`
226			`*/`
227			`year_offset += 4;`
228
229			`tm->tm_year = (real_year + year_offset + year[1] * 100) - 1900;`
230
231			`return 0;`
232			`}`
233
234			`static int pcf8583_rtc_set_time(struct device dev, struct rtc_time tm)`
235			`{`
236			`struct i2c_client *client = to_i2c_client(dev);`
237			`unsigned char year[2], chk;`
238			`struct rtc_mem cmos_year = { CMOS_YEAR, sizeof(year), year };`
239			`struct rtc_mem cmos_check = { CMOS_CHECKSUM, 1, &chk };`
240			`unsigned int proper_year = tm->tm_year + 1900;`
241			`int ret;`
242
243			`/*`
244			`* The RTC's own 2-bit year must reflect the least`
245			`* significant two bits of the CMOS year.`
246			`*/`
247
248			`ret = pcf8583_set_datetime(client, tm, 1);`
249			`if (ret)`
250			`return ret;`
251
252			`ret = pcf8583_read_mem(client, &cmos_check);`
253			`if (ret)`
254			`return ret;`
255
256			`ret = pcf8583_read_mem(client, &cmos_year);`
257			`if (ret)`
258			`return ret;`
259
260			`chk -= year[1] + year[0];`
261
262			`year[1] = proper_year / 100;`
263			`year[0] = proper_year % 100;`
264
265			`chk += year[1] + year[0];`
266
267			`ret = pcf8583_write_mem(client, &cmos_year);`
268
269			`if (ret)`
270			`return ret;`
271
272			`ret = pcf8583_write_mem(client, &cmos_check);`
273
274			`return ret;`
275			`}`
276
277			`static const struct rtc_class_ops pcf8583_rtc_ops = {`
278			`.read_time = pcf8583_rtc_read_time,`
279			`.set_time = pcf8583_rtc_set_time,`
280			`};`
281
282			`static int pcf8583_probe(struct i2c_adapter *adap, int addr, int kind);`
283
284			`static int pcf8583_attach(struct i2c_adapter *adap)`
285			`{`
286			`return i2c_probe(adap, &addr_data, pcf8583_probe);`
287			`}`
288
289			`static int pcf8583_detach(struct i2c_client *client)`
290			`{`
291			`int err;`
292			`struct pcf8583 *pcf = i2c_get_clientdata(client);`
293			`struct rtc_device *rtc = pcf->rtc;`
294
295			`if (rtc)`
296			`rtc_device_unregister(rtc);`
297
298			`if ((err = i2c_detach_client(client)))`
299			`return err;`
300
301			`kfree(pcf);`
302			`return 0;`
303			`}`
304
305			`static struct i2c_driver pcf8583_driver = {`
306			`.driver = {`
307			`.name = "pcf8583",`
308			`},`
309			`.id = I2C_DRIVERID_PCF8583,`
310			`.attach_adapter = pcf8583_attach,`
311			`.detach_client = pcf8583_detach,`
312			`};`
313
314			`static int pcf8583_probe(struct i2c_adapter *adap, int addr, int kind)`
315			`{`
316			`struct pcf8583 *pcf;`
317			`struct i2c_client *client;`
318			`struct rtc_device *rtc;`
319			`unsigned char buf[1], ad[1] = { 0 };`
320			`int err;`
321			`struct i2c_msg msgs[2] = {`
322			`{`
323			`.addr = addr,`
324			`.flags = 0,`
325			`.len = 1,`
326			`.buf = ad,`
327			`}, {`
328			`.addr = addr,`
329			`.flags = I2C_M_RD,`
330			`.len = 1,`
331			`.buf = buf,`
332			`}`
333			`};`
334
335			`if (!i2c_check_functionality(adap, I2C_FUNC_I2C))`
336			`return 0;`
337
338			`pcf = kzalloc(sizeof(*pcf), GFP_KERNEL);`
339			`if (!pcf)`
340			`return -ENOMEM;`
341
342			`client = &pcf->client;`
343
344			`client->addr = addr;`
345			`client->adapter = adap;`
346			`client->driver = &pcf8583_driver;`
347
348			`strlcpy(client->name, pcf8583_driver.driver.name, I2C_NAME_SIZE);`
349
350			`if (i2c_transfer(client->adapter, msgs, 2) != 2) {`
351			`err = -EIO;`
352			`goto exit_kfree;`
353			`}`
354
355			`err = i2c_attach_client(client);`
356
357			`if (err)`
358			`goto exit_kfree;`
359
360			`rtc = rtc_device_register(pcf8583_driver.driver.name, &client->dev,`
361			`&pcf8583_rtc_ops, THIS_MODULE);`
362
363			`if (IS_ERR(rtc)) {`
364			`err = PTR_ERR(rtc);`
365			`goto exit_detach;`
366			`}`
367
368			`pcf->rtc = rtc;`
369			`i2c_set_clientdata(client, pcf);`
370			`set_ctrl(client, buf[0]);`
371
372			`return 0;`
373
374			`exit_detach:`
375			`i2c_detach_client(client);`
376
377			`exit_kfree:`
378			`kfree(pcf);`
379
380			`return err;`
381			`}`
382
383			`static __init int pcf8583_init(void)`
384			`{`
385			`return i2c_add_driver(&pcf8583_driver);`
386			`}`
387
388			`static __exit void pcf8583_exit(void)`
389			`{`
390			`i2c_del_driver(&pcf8583_driver);`
391			`}`
392
393			`module_init(pcf8583_init);`
394			`module_exit(pcf8583_exit);`
395
396			`MODULE_AUTHOR("Russell King");`
397			`MODULE_DESCRIPTION("PCF8583 I2C RTC driver");`
398			`MODULE_LICENSE("GPL");`