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