[PATCH] I2C: Kill address ranges in non-sensors i2c chip drivers
[linux-2.6] / drivers / i2c / chips / m41t00.c
1 /*
2  * drivers/i2c/chips/m41t00.c
3  *
4  * I2C client/driver for the ST M41T00 Real-Time Clock chip.
5  *
6  * Author: Mark A. Greer <mgreer@mvista.com>
7  *
8  * 2005 (c) MontaVista Software, Inc. This file is licensed under
9  * the terms of the GNU General Public License version 2. This program
10  * is licensed "as is" without any warranty of any kind, whether express
11  * or implied.
12  */
13 /*
14  * This i2c client/driver wedges between the drivers/char/genrtc.c RTC
15  * interface and the SMBus interface of the i2c subsystem.
16  * It would be more efficient to use i2c msgs/i2c_transfer directly but, as
17  * recommened in .../Documentation/i2c/writing-clients section
18  * "Sending and receiving", using SMBus level communication is preferred.
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/interrupt.h>
24 #include <linux/i2c.h>
25 #include <linux/rtc.h>
26 #include <linux/bcd.h>
27
28 #include <asm/time.h>
29 #include <asm/rtc.h>
30
31 #define M41T00_DRV_NAME         "m41t00"
32
33 static DECLARE_MUTEX(m41t00_mutex);
34
35 static struct i2c_driver m41t00_driver;
36 static struct i2c_client *save_client;
37
38 static unsigned short ignore[] = { I2C_CLIENT_END };
39 static unsigned short normal_addr[] = { 0x68, I2C_CLIENT_END };
40
41 static struct i2c_client_address_data addr_data = {
42         .normal_i2c             = normal_addr,
43         .probe                  = ignore,
44         .ignore                 = ignore,
45         .force                  = ignore,
46 };
47
48 ulong
49 m41t00_get_rtc_time(void)
50 {
51         s32     sec, min, hour, day, mon, year;
52         s32     sec1, min1, hour1, day1, mon1, year1;
53         ulong   limit = 10;
54
55         sec = min = hour = day = mon = year = 0;
56         sec1 = min1 = hour1 = day1 = mon1 = year1 = 0;
57
58         down(&m41t00_mutex);
59         do {
60                 if (((sec = i2c_smbus_read_byte_data(save_client, 0)) >= 0)
61                         && ((min = i2c_smbus_read_byte_data(save_client, 1))
62                                 >= 0)
63                         && ((hour = i2c_smbus_read_byte_data(save_client, 2))
64                                 >= 0)
65                         && ((day = i2c_smbus_read_byte_data(save_client, 4))
66                                 >= 0)
67                         && ((mon = i2c_smbus_read_byte_data(save_client, 5))
68                                 >= 0)
69                         && ((year = i2c_smbus_read_byte_data(save_client, 6))
70                                 >= 0)
71                         && ((sec == sec1) && (min == min1) && (hour == hour1)
72                                 && (day == day1) && (mon == mon1)
73                                 && (year == year1)))
74
75                                 break;
76
77                 sec1 = sec;
78                 min1 = min;
79                 hour1 = hour;
80                 day1 = day;
81                 mon1 = mon;
82                 year1 = year;
83         } while (--limit > 0);
84         up(&m41t00_mutex);
85
86         if (limit == 0) {
87                 dev_warn(&save_client->dev,
88                         "m41t00: can't read rtc chip\n");
89                 sec = min = hour = day = mon = year = 0;
90         }
91
92         sec &= 0x7f;
93         min &= 0x7f;
94         hour &= 0x3f;
95         day &= 0x3f;
96         mon &= 0x1f;
97         year &= 0xff;
98
99         BCD_TO_BIN(sec);
100         BCD_TO_BIN(min);
101         BCD_TO_BIN(hour);
102         BCD_TO_BIN(day);
103         BCD_TO_BIN(mon);
104         BCD_TO_BIN(year);
105
106         year += 1900;
107         if (year < 1970)
108                 year += 100;
109
110         return mktime(year, mon, day, hour, min, sec);
111 }
112
113 static void
114 m41t00_set_tlet(ulong arg)
115 {
116         struct rtc_time tm;
117         ulong   nowtime = *(ulong *)arg;
118
119         to_tm(nowtime, &tm);
120         tm.tm_year = (tm.tm_year - 1900) % 100;
121
122         BIN_TO_BCD(tm.tm_sec);
123         BIN_TO_BCD(tm.tm_min);
124         BIN_TO_BCD(tm.tm_hour);
125         BIN_TO_BCD(tm.tm_mon);
126         BIN_TO_BCD(tm.tm_mday);
127         BIN_TO_BCD(tm.tm_year);
128
129         down(&m41t00_mutex);
130         if ((i2c_smbus_write_byte_data(save_client, 0, tm.tm_sec & 0x7f) < 0)
131                 || (i2c_smbus_write_byte_data(save_client, 1, tm.tm_min & 0x7f)
132                         < 0)
133                 || (i2c_smbus_write_byte_data(save_client, 2, tm.tm_hour & 0x7f)
134                         < 0)
135                 || (i2c_smbus_write_byte_data(save_client, 4, tm.tm_mday & 0x7f)
136                         < 0)
137                 || (i2c_smbus_write_byte_data(save_client, 5, tm.tm_mon & 0x7f)
138                         < 0)
139                 || (i2c_smbus_write_byte_data(save_client, 6, tm.tm_year & 0x7f)
140                         < 0))
141
142                 dev_warn(&save_client->dev,"m41t00: can't write to rtc chip\n");
143
144         up(&m41t00_mutex);
145         return;
146 }
147
148 ulong   new_time;
149
150 DECLARE_TASKLET_DISABLED(m41t00_tasklet, m41t00_set_tlet, (ulong)&new_time);
151
152 int
153 m41t00_set_rtc_time(ulong nowtime)
154 {
155         new_time = nowtime;
156
157         if (in_interrupt())
158                 tasklet_schedule(&m41t00_tasklet);
159         else
160                 m41t00_set_tlet((ulong)&new_time);
161
162         return 0;
163 }
164
165 /*
166  *****************************************************************************
167  *
168  *      Driver Interface
169  *
170  *****************************************************************************
171  */
172 static int
173 m41t00_probe(struct i2c_adapter *adap, int addr, int kind)
174 {
175         struct i2c_client *client;
176         int rc;
177
178         client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
179         if (!client)
180                 return -ENOMEM;
181
182         memset(client, 0, sizeof(struct i2c_client));
183         strncpy(client->name, M41T00_DRV_NAME, I2C_NAME_SIZE);
184         client->flags = I2C_DF_NOTIFY;
185         client->addr = addr;
186         client->adapter = adap;
187         client->driver = &m41t00_driver;
188
189         if ((rc = i2c_attach_client(client)) != 0) {
190                 kfree(client);
191                 return rc;
192         }
193
194         save_client = client;
195         return 0;
196 }
197
198 static int
199 m41t00_attach(struct i2c_adapter *adap)
200 {
201         return i2c_probe(adap, &addr_data, m41t00_probe);
202 }
203
204 static int
205 m41t00_detach(struct i2c_client *client)
206 {
207         int     rc;
208
209         if ((rc = i2c_detach_client(client)) == 0) {
210                 kfree(i2c_get_clientdata(client));
211                 tasklet_kill(&m41t00_tasklet);
212         }
213         return rc;
214 }
215
216 static struct i2c_driver m41t00_driver = {
217         .owner          = THIS_MODULE,
218         .name           = M41T00_DRV_NAME,
219         .id             = I2C_DRIVERID_STM41T00,
220         .flags          = I2C_DF_NOTIFY,
221         .attach_adapter = m41t00_attach,
222         .detach_client  = m41t00_detach,
223 };
224
225 static int __init
226 m41t00_init(void)
227 {
228         return i2c_add_driver(&m41t00_driver);
229 }
230
231 static void __exit
232 m41t00_exit(void)
233 {
234         i2c_del_driver(&m41t00_driver);
235         return;
236 }
237
238 module_init(m41t00_init);
239 module_exit(m41t00_exit);
240
241 MODULE_AUTHOR("Mark A. Greer <mgreer@mvista.com>");
242 MODULE_DESCRIPTION("ST Microelectronics M41T00 RTC I2C Client Driver");
243 MODULE_LICENSE("GPL");