[PATCH] w1_ds2433: Added crc16 protection and read caching.
[linux-2.6.git] / drivers / w1 / w1_ds2433.c
1 /*
2  *      w1_ds2433.c - w1 family 23 (DS2433) driver
3  *
4  * Copyright (c) 2005 Ben Gardner <bgardner@wabtec.com>
5  *
6  * This source code is licensed under the GNU General Public License,
7  * Version 2. See the file COPYING for more details.
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/moduleparam.h>
13 #include <linux/device.h>
14 #include <linux/types.h>
15 #include <linux/delay.h>
16 #ifdef CONFIG_W1_F23_CRC
17 #include <linux/crc16.h>
18 #endif
19
20 #include "w1.h"
21 #include "w1_io.h"
22 #include "w1_int.h"
23 #include "w1_family.h"
24
25 MODULE_LICENSE("GPL");
26 MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>");
27 MODULE_DESCRIPTION("w1 family 23 driver for DS2433, 4kb EEPROM");
28
29 #define W1_EEPROM_SIZE          512
30 #define W1_PAGE_COUNT           16
31 #define W1_PAGE_SIZE            32
32 #define W1_PAGE_BITS            5
33 #define W1_PAGE_MASK            0x1F
34
35 #define W1_F23_TIME             300
36
37 #define W1_F23_READ_EEPROM      0xF0
38 #define W1_F23_WRITE_SCRATCH    0x0F
39 #define W1_F23_READ_SCRATCH     0xAA
40 #define W1_F23_COPY_SCRATCH     0x55
41
42 struct w1_f23_data {
43         u8      memory[W1_EEPROM_SIZE];
44         u32     validcrc;
45 };
46
47 /**
48  * Check the file size bounds and adjusts count as needed.
49  * This would not be needed if the file size didn't reset to 0 after a write.
50  */
51 static inline size_t w1_f23_fix_count(loff_t off, size_t count, size_t size)
52 {
53         if (off > size)
54                 return 0;
55
56         if ((off + count) > size)
57                 return (size - off);
58
59         return count;
60 }
61
62 #ifdef CONFIG_W1_F23_CRC
63 static int w1_f23_refresh_block(struct w1_slave *sl, struct w1_f23_data *data,
64                                 int block)
65 {
66         u8      wrbuf[3];
67         int     off = block * W1_PAGE_SIZE;
68
69         if (data->validcrc & (1 << block))
70                 return 0;
71
72         if (w1_reset_select_slave(sl)) {
73                 data->validcrc = 0;
74                 return -EIO;
75         }
76
77         wrbuf[0] = W1_F23_READ_EEPROM;
78         wrbuf[1] = off & 0xff;
79         wrbuf[2] = off >> 8;
80         w1_write_block(sl->master, wrbuf, 3);
81         w1_read_block(sl->master, &data->memory[off], W1_PAGE_SIZE);
82
83         /* cache the block if the CRC is valid */
84         if (crc16(CRC16_INIT, &data->memory[off], W1_PAGE_SIZE) == CRC16_VALID)
85                 data->validcrc |= (1 << block);
86
87         return 0;
88 }
89 #endif  /* CONFIG_W1_F23_CRC */
90
91 static ssize_t w1_f23_read_bin(struct kobject *kobj, char *buf, loff_t off,
92                                size_t count)
93 {
94         struct w1_slave *sl = kobj_to_w1_slave(kobj);
95 #ifdef CONFIG_W1_F23_CRC
96         struct w1_f23_data *data = sl->family_data;
97         int i, min_page, max_page;
98 #else
99         u8 wrbuf[3];
100 #endif
101
102         if ((count = w1_f23_fix_count(off, count, W1_EEPROM_SIZE)) == 0)
103                 return 0;
104
105         atomic_inc(&sl->refcnt);
106         if (down_interruptible(&sl->master->mutex)) {
107                 count = 0;
108                 goto out_dec;
109         }
110
111 #ifdef CONFIG_W1_F23_CRC
112
113         min_page = (off >> W1_PAGE_BITS);
114         max_page = (off + count - 1) >> W1_PAGE_BITS;
115         for (i = min_page; i <= max_page; i++) {
116                 if (w1_f23_refresh_block(sl, data, i)) {
117                         count = -EIO;
118                         goto out_up;
119                 }
120         }
121         memcpy(buf, &data->memory[off], count);
122
123 #else   /* CONFIG_W1_F23_CRC */
124
125         /* read directly from the EEPROM */
126         if (w1_reset_select_slave(sl)) {
127                 count = -EIO;
128                 goto out_up;
129         }
130
131         wrbuf[0] = W1_F23_READ_EEPROM;
132         wrbuf[1] = off & 0xff;
133         wrbuf[2] = off >> 8;
134         w1_write_block(sl->master, wrbuf, 3);
135         w1_read_block(sl->master, buf, count);
136
137 #endif  /* CONFIG_W1_F23_CRC */
138
139 out_up:
140         up(&sl->master->mutex);
141 out_dec:
142         atomic_dec(&sl->refcnt);
143
144         return count;
145 }
146
147 /**
148  * Writes to the scratchpad and reads it back for verification.
149  * Then copies the scratchpad to EEPROM.
150  * The data must be on one page.
151  * The master must be locked.
152  *
153  * @param sl    The slave structure
154  * @param addr  Address for the write
155  * @param len   length must be <= (W1_PAGE_SIZE - (addr & W1_PAGE_MASK))
156  * @param data  The data to write
157  * @return      0=Success -1=failure
158  */
159 static int w1_f23_write(struct w1_slave *sl, int addr, int len, const u8 *data)
160 {
161         u8 wrbuf[4];
162         u8 rdbuf[W1_PAGE_SIZE + 3];
163         u8 es = (addr + len - 1) & 0x1f;
164
165         /* Write the data to the scratchpad */
166         if (w1_reset_select_slave(sl))
167                 return -1;
168
169         wrbuf[0] = W1_F23_WRITE_SCRATCH;
170         wrbuf[1] = addr & 0xff;
171         wrbuf[2] = addr >> 8;
172
173         w1_write_block(sl->master, wrbuf, 3);
174         w1_write_block(sl->master, data, len);
175
176         /* Read the scratchpad and verify */
177         if (w1_reset_select_slave(sl))
178                 return -1;
179
180         w1_write_8(sl->master, W1_F23_READ_SCRATCH);
181         w1_read_block(sl->master, rdbuf, len + 3);
182
183         /* Compare what was read against the data written */
184         if ((rdbuf[0] != wrbuf[1]) || (rdbuf[1] != wrbuf[2]) ||
185             (rdbuf[2] != es) || (memcmp(data, &rdbuf[3], len) != 0))
186                 return -1;
187
188         /* Copy the scratchpad to EEPROM */
189         if (w1_reset_select_slave(sl))
190                 return -1;
191
192         wrbuf[0] = W1_F23_COPY_SCRATCH;
193         wrbuf[3] = es;
194         w1_write_block(sl->master, wrbuf, 4);
195
196         /* Sleep for 5 ms to wait for the write to complete */
197         msleep(5);
198
199         /* Reset the bus to wake up the EEPROM (this may not be needed) */
200         w1_reset_bus(sl->master);
201
202         return 0;
203 }
204
205 static ssize_t w1_f23_write_bin(struct kobject *kobj, char *buf, loff_t off,
206                                 size_t count)
207 {
208         struct w1_slave *sl = kobj_to_w1_slave(kobj);
209         int addr, len, idx;
210
211         if ((count = w1_f23_fix_count(off, count, W1_EEPROM_SIZE)) == 0)
212                 return 0;
213
214 #ifdef CONFIG_W1_F23_CRC
215         /* can only write full blocks in cached mode */
216         if ((off & W1_PAGE_MASK) || (count & W1_PAGE_MASK)) {
217                 dev_err(&sl->dev, "invalid offset/count off=%d cnt=%d\n",
218                         (int)off, count);
219                 return -EINVAL;
220         }
221
222         /* make sure the block CRCs are valid */
223         for (idx = 0; idx < count; idx += W1_PAGE_SIZE) {
224                 if (crc16(CRC16_INIT, &buf[idx], W1_PAGE_SIZE) != CRC16_VALID) {
225                         dev_err(&sl->dev, "bad CRC at offset %d\n", (int)off);
226                         return -EINVAL;
227                 }
228         }
229 #endif  /* CONFIG_W1_F23_CRC */
230
231         atomic_inc(&sl->refcnt);
232         if (down_interruptible(&sl->master->mutex)) {
233                 count = 0;
234                 goto out_dec;
235         }
236
237         /* Can only write data to one page at a time */
238         idx = 0;
239         while (idx < count) {
240                 addr = off + idx;
241                 len = W1_PAGE_SIZE - (addr & W1_PAGE_MASK);
242                 if (len > (count - idx))
243                         len = count - idx;
244
245                 if (w1_f23_write(sl, addr, len, &buf[idx]) < 0) {
246                         count = -EIO;
247                         goto out_up;
248                 }
249                 idx += len;
250         }
251
252 out_up:
253         up(&sl->master->mutex);
254 out_dec:
255         atomic_dec(&sl->refcnt);
256
257         return count;
258 }
259
260 static struct bin_attribute w1_f23_bin_attr = {
261         .attr = {
262                 .name = "eeprom",
263                 .mode = S_IRUGO | S_IWUSR,
264                 .owner = THIS_MODULE,
265         },
266         .size = W1_EEPROM_SIZE,
267         .read = w1_f23_read_bin,
268         .write = w1_f23_write_bin,
269 };
270
271 static int w1_f23_add_slave(struct w1_slave *sl)
272 {
273         int err;
274 #ifdef CONFIG_W1_F23_CRC
275         struct w1_f23_data *data;
276
277         data = kmalloc(sizeof(struct w1_f23_data), GFP_KERNEL);
278         if (!data)
279                 return -ENOMEM;
280         memset(data, 0, sizeof(struct w1_f23_data));
281         sl->family_data = data;
282
283 #endif  /* CONFIG_W1_F23_CRC */
284
285         err = sysfs_create_bin_file(&sl->dev.kobj, &w1_f23_bin_attr);
286
287 #ifdef CONFIG_W1_F23_CRC
288         if (err)
289                 kfree(data);
290 #endif  /* CONFIG_W1_F23_CRC */
291
292         return err;
293 }
294
295 static void w1_f23_remove_slave(struct w1_slave *sl)
296 {
297 #ifdef CONFIG_W1_F23_CRC
298         if (sl->family_data) {
299                 kfree(sl->family_data);
300                 sl->family_data = NULL;
301         }
302 #endif  /* CONFIG_W1_F23_CRC */
303         sysfs_remove_bin_file(&sl->dev.kobj, &w1_f23_bin_attr);
304 }
305
306 static struct w1_family_ops w1_f23_fops = {
307         .add_slave      = w1_f23_add_slave,
308         .remove_slave   = w1_f23_remove_slave,
309 };
310
311 static struct w1_family w1_family_23 = {
312         .fid = W1_EEPROM_DS2433,
313         .fops = &w1_f23_fops,
314 };
315
316 static int __init w1_f23_init(void)
317 {
318         return w1_register_family(&w1_family_23);
319 }
320
321 static void __exit w1_f23_fini(void)
322 {
323         w1_unregister_family(&w1_family_23);
324 }
325
326 module_init(w1_f23_init);
327 module_exit(w1_f23_fini);