xref: /openbmc/linux/drivers/w1/slaves/w1_ds2433.c (revision 39bbfdac)
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