xref: /openbmc/linux/drivers/w1/slaves/w1_ds2438.c (revision ee896c5b)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * 1-Wire implementation for the ds2438 chip
4  *
5  * Copyright (c) 2017 Mariusz Bialonczyk <manio@skyboo.net>
6  */
7 
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/device.h>
11 #include <linux/types.h>
12 #include <linux/delay.h>
13 
14 #include <linux/w1.h>
15 
16 #define W1_FAMILY_DS2438		0x26
17 
18 #define W1_DS2438_RETRIES		3
19 
20 /* Memory commands */
21 #define W1_DS2438_READ_SCRATCH		0xBE
22 #define W1_DS2438_WRITE_SCRATCH		0x4E
23 #define W1_DS2438_COPY_SCRATCH		0x48
24 #define W1_DS2438_RECALL_MEMORY		0xB8
25 /* Register commands */
26 #define W1_DS2438_CONVERT_TEMP		0x44
27 #define W1_DS2438_CONVERT_VOLTAGE	0xB4
28 
29 #define DS2438_PAGE_SIZE		8
30 #define DS2438_ADC_INPUT_VAD		0
31 #define DS2438_ADC_INPUT_VDD		1
32 #define DS2438_MAX_CONVERSION_TIME	10		/* ms */
33 
34 /* Page #0 definitions */
35 #define DS2438_STATUS_REG		0x00		/* Status/Configuration Register */
36 #define DS2438_STATUS_IAD		(1 << 0)	/* Current A/D Control Bit */
37 #define DS2438_STATUS_CA		(1 << 1)	/* Current Accumulator Configuration */
38 #define DS2438_STATUS_EE		(1 << 2)	/* Current Accumulator Shadow Selector bit */
39 #define DS2438_STATUS_AD		(1 << 3)	/* Voltage A/D Input Select Bit */
40 #define DS2438_STATUS_TB		(1 << 4)	/* Temperature Busy Flag */
41 #define DS2438_STATUS_NVB		(1 << 5)	/* Nonvolatile Memory Busy Flag */
42 #define DS2438_STATUS_ADB		(1 << 6)	/* A/D Converter Busy Flag */
43 
44 #define DS2438_TEMP_LSB			0x01
45 #define DS2438_TEMP_MSB			0x02
46 #define DS2438_VOLTAGE_LSB		0x03
47 #define DS2438_VOLTAGE_MSB		0x04
48 #define DS2438_CURRENT_LSB		0x05
49 #define DS2438_CURRENT_MSB		0x06
50 #define DS2438_THRESHOLD		0x07
51 
52 /* Page #1 definitions */
53 #define DS2438_ETM_0			0x00
54 #define DS2438_ETM_1			0x01
55 #define DS2438_ETM_2			0x02
56 #define DS2438_ETM_3			0x03
57 #define DS2438_ICA			0x04
58 #define DS2438_OFFSET_LSB		0x05
59 #define DS2438_OFFSET_MSB		0x06
60 
w1_ds2438_get_page(struct w1_slave * sl,int pageno,u8 * buf)61 static int w1_ds2438_get_page(struct w1_slave *sl, int pageno, u8 *buf)
62 {
63 	unsigned int retries = W1_DS2438_RETRIES;
64 	u8 w1_buf[2];
65 	u8 crc;
66 	size_t count;
67 
68 	while (retries--) {
69 		if (w1_reset_select_slave(sl))
70 			continue;
71 		w1_buf[0] = W1_DS2438_RECALL_MEMORY;
72 		w1_buf[1] = (u8)pageno;
73 		w1_write_block(sl->master, w1_buf, 2);
74 
75 		if (w1_reset_select_slave(sl))
76 			continue;
77 		w1_buf[0] = W1_DS2438_READ_SCRATCH;
78 		w1_buf[1] = (u8)pageno;
79 		w1_write_block(sl->master, w1_buf, 2);
80 
81 		count = w1_read_block(sl->master, buf, DS2438_PAGE_SIZE + 1);
82 		if (count == DS2438_PAGE_SIZE + 1) {
83 			crc = w1_calc_crc8(buf, DS2438_PAGE_SIZE);
84 
85 			/* check for correct CRC */
86 			if ((u8)buf[DS2438_PAGE_SIZE] == crc)
87 				return 0;
88 		}
89 	}
90 	return -1;
91 }
92 
w1_ds2438_get_temperature(struct w1_slave * sl,int16_t * temperature)93 static int w1_ds2438_get_temperature(struct w1_slave *sl, int16_t *temperature)
94 {
95 	unsigned int retries = W1_DS2438_RETRIES;
96 	u8 w1_buf[DS2438_PAGE_SIZE + 1 /*for CRC*/];
97 	unsigned int tm = DS2438_MAX_CONVERSION_TIME;
98 	unsigned long sleep_rem;
99 	int ret;
100 
101 	mutex_lock(&sl->master->bus_mutex);
102 
103 	while (retries--) {
104 		if (w1_reset_select_slave(sl))
105 			continue;
106 		w1_write_8(sl->master, W1_DS2438_CONVERT_TEMP);
107 
108 		mutex_unlock(&sl->master->bus_mutex);
109 		sleep_rem = msleep_interruptible(tm);
110 		if (sleep_rem != 0) {
111 			ret = -1;
112 			goto post_unlock;
113 		}
114 
115 		if (mutex_lock_interruptible(&sl->master->bus_mutex) != 0) {
116 			ret = -1;
117 			goto post_unlock;
118 		}
119 
120 		break;
121 	}
122 
123 	if (w1_ds2438_get_page(sl, 0, w1_buf) == 0) {
124 		*temperature = (((int16_t) w1_buf[DS2438_TEMP_MSB]) << 8) | ((uint16_t) w1_buf[DS2438_TEMP_LSB]);
125 		ret = 0;
126 	} else
127 		ret = -1;
128 
129 	mutex_unlock(&sl->master->bus_mutex);
130 
131 post_unlock:
132 	return ret;
133 }
134 
w1_ds2438_change_config_bit(struct w1_slave * sl,u8 mask,u8 value)135 static int w1_ds2438_change_config_bit(struct w1_slave *sl, u8 mask, u8 value)
136 {
137 	unsigned int retries = W1_DS2438_RETRIES;
138 	u8 w1_buf[3];
139 	u8 status;
140 	int perform_write = 0;
141 
142 	while (retries--) {
143 		if (w1_reset_select_slave(sl))
144 			continue;
145 		w1_buf[0] = W1_DS2438_RECALL_MEMORY;
146 		w1_buf[1] = 0x00;
147 		w1_write_block(sl->master, w1_buf, 2);
148 
149 		if (w1_reset_select_slave(sl))
150 			continue;
151 		w1_buf[0] = W1_DS2438_READ_SCRATCH;
152 		w1_buf[1] = 0x00;
153 		w1_write_block(sl->master, w1_buf, 2);
154 
155 		/* reading one byte of result */
156 		status = w1_read_8(sl->master);
157 
158 		/* if bit0=1, set a value to a mask for easy compare */
159 		if (value)
160 			value = mask;
161 
162 		if ((status & mask) == value)
163 			return 0;	/* already set as requested */
164 
165 		/* changing bit */
166 		status ^= mask;
167 		perform_write = 1;
168 
169 		break;
170 	}
171 
172 	if (perform_write) {
173 		retries = W1_DS2438_RETRIES;
174 		while (retries--) {
175 			if (w1_reset_select_slave(sl))
176 				continue;
177 			w1_buf[0] = W1_DS2438_WRITE_SCRATCH;
178 			w1_buf[1] = 0x00;
179 			w1_buf[2] = status;
180 			w1_write_block(sl->master, w1_buf, 3);
181 
182 			if (w1_reset_select_slave(sl))
183 				continue;
184 			w1_buf[0] = W1_DS2438_COPY_SCRATCH;
185 			w1_buf[1] = 0x00;
186 			w1_write_block(sl->master, w1_buf, 2);
187 
188 			return 0;
189 		}
190 	}
191 	return -1;
192 }
193 
w1_ds2438_change_offset_register(struct w1_slave * sl,u8 * value)194 static int w1_ds2438_change_offset_register(struct w1_slave *sl, u8 *value)
195 {
196 	unsigned int retries = W1_DS2438_RETRIES;
197 	u8 w1_buf[9];
198 	u8 w1_page1_buf[DS2438_PAGE_SIZE + 1 /*for CRC*/];
199 
200 	if (w1_ds2438_get_page(sl, 1, w1_page1_buf) == 0) {
201 		memcpy(&w1_buf[2], w1_page1_buf, DS2438_PAGE_SIZE - 1); /* last register reserved */
202 		w1_buf[7] = value[0]; /* change only offset register */
203 		w1_buf[8] = value[1];
204 		while (retries--) {
205 			if (w1_reset_select_slave(sl))
206 				continue;
207 			w1_buf[0] = W1_DS2438_WRITE_SCRATCH;
208 			w1_buf[1] = 0x01; /* write to page 1 */
209 			w1_write_block(sl->master, w1_buf, 9);
210 
211 			if (w1_reset_select_slave(sl))
212 				continue;
213 			w1_buf[0] = W1_DS2438_COPY_SCRATCH;
214 			w1_buf[1] = 0x01;
215 			w1_write_block(sl->master, w1_buf, 2);
216 			return 0;
217 		}
218 	}
219 	return -1;
220 }
221 
w1_ds2438_get_voltage(struct w1_slave * sl,int adc_input,uint16_t * voltage)222 static int w1_ds2438_get_voltage(struct w1_slave *sl,
223 				 int adc_input, uint16_t *voltage)
224 {
225 	unsigned int retries = W1_DS2438_RETRIES;
226 	u8 w1_buf[DS2438_PAGE_SIZE + 1 /*for CRC*/];
227 	unsigned int tm = DS2438_MAX_CONVERSION_TIME;
228 	unsigned long sleep_rem;
229 	int ret;
230 
231 	mutex_lock(&sl->master->bus_mutex);
232 
233 	if (w1_ds2438_change_config_bit(sl, DS2438_STATUS_AD, adc_input)) {
234 		ret = -1;
235 		goto pre_unlock;
236 	}
237 
238 	while (retries--) {
239 		if (w1_reset_select_slave(sl))
240 			continue;
241 		w1_write_8(sl->master, W1_DS2438_CONVERT_VOLTAGE);
242 
243 		mutex_unlock(&sl->master->bus_mutex);
244 		sleep_rem = msleep_interruptible(tm);
245 		if (sleep_rem != 0) {
246 			ret = -1;
247 			goto post_unlock;
248 		}
249 
250 		if (mutex_lock_interruptible(&sl->master->bus_mutex) != 0) {
251 			ret = -1;
252 			goto post_unlock;
253 		}
254 
255 		break;
256 	}
257 
258 	if (w1_ds2438_get_page(sl, 0, w1_buf) == 0) {
259 		*voltage = (((uint16_t) w1_buf[DS2438_VOLTAGE_MSB]) << 8) | ((uint16_t) w1_buf[DS2438_VOLTAGE_LSB]);
260 		ret = 0;
261 	} else
262 		ret = -1;
263 
264 pre_unlock:
265 	mutex_unlock(&sl->master->bus_mutex);
266 
267 post_unlock:
268 	return ret;
269 }
270 
w1_ds2438_get_current(struct w1_slave * sl,int16_t * voltage)271 static int w1_ds2438_get_current(struct w1_slave *sl, int16_t *voltage)
272 {
273 	u8 w1_buf[DS2438_PAGE_SIZE + 1 /*for CRC*/];
274 	int ret;
275 
276 	mutex_lock(&sl->master->bus_mutex);
277 
278 	if (w1_ds2438_get_page(sl, 0, w1_buf) == 0) {
279 		/* The voltage measured across current sense resistor RSENS. */
280 		*voltage = (((int16_t) w1_buf[DS2438_CURRENT_MSB]) << 8) | ((int16_t) w1_buf[DS2438_CURRENT_LSB]);
281 		ret = 0;
282 	} else
283 		ret = -1;
284 
285 	mutex_unlock(&sl->master->bus_mutex);
286 
287 	return ret;
288 }
289 
iad_write(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)290 static ssize_t iad_write(struct file *filp, struct kobject *kobj,
291 			 struct bin_attribute *bin_attr, char *buf,
292 			 loff_t off, size_t count)
293 {
294 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
295 	int ret;
296 
297 	if (count != 1 || off != 0)
298 		return -EFAULT;
299 
300 	mutex_lock(&sl->master->bus_mutex);
301 
302 	if (w1_ds2438_change_config_bit(sl, DS2438_STATUS_IAD, *buf & 0x01) == 0)
303 		ret = 1;
304 	else
305 		ret = -EIO;
306 
307 	mutex_unlock(&sl->master->bus_mutex);
308 
309 	return ret;
310 }
311 
iad_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)312 static ssize_t iad_read(struct file *filp, struct kobject *kobj,
313 			struct bin_attribute *bin_attr, char *buf,
314 			loff_t off, size_t count)
315 {
316 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
317 	int ret;
318 	int16_t voltage;
319 
320 	if (off != 0)
321 		return 0;
322 	if (!buf)
323 		return -EINVAL;
324 
325 	if (w1_ds2438_get_current(sl, &voltage) == 0)
326 		ret = snprintf(buf, count, "%i\n", voltage);
327 	else
328 		ret = -EIO;
329 
330 	return ret;
331 }
332 
page0_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)333 static ssize_t page0_read(struct file *filp, struct kobject *kobj,
334 			  struct bin_attribute *bin_attr, char *buf,
335 			  loff_t off, size_t count)
336 {
337 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
338 	int ret;
339 	u8 w1_buf[DS2438_PAGE_SIZE + 1 /*for CRC*/];
340 
341 	if (off != 0)
342 		return 0;
343 	if (!buf)
344 		return -EINVAL;
345 
346 	mutex_lock(&sl->master->bus_mutex);
347 
348 	/* Read no more than page0 size */
349 	if (count > DS2438_PAGE_SIZE)
350 		count = DS2438_PAGE_SIZE;
351 
352 	if (w1_ds2438_get_page(sl, 0, w1_buf) == 0) {
353 		memcpy(buf, &w1_buf, count);
354 		ret = count;
355 	} else
356 		ret = -EIO;
357 
358 	mutex_unlock(&sl->master->bus_mutex);
359 
360 	return ret;
361 }
362 
page1_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)363 static ssize_t page1_read(struct file *filp, struct kobject *kobj,
364 			  struct bin_attribute *bin_attr, char *buf,
365 			  loff_t off, size_t count)
366 {
367 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
368 	int ret;
369 	u8 w1_buf[DS2438_PAGE_SIZE + 1 /*for CRC*/];
370 
371 	if (off != 0)
372 		return 0;
373 	if (!buf)
374 		return -EINVAL;
375 
376 	mutex_lock(&sl->master->bus_mutex);
377 
378 	/* Read no more than page1 size */
379 	if (count > DS2438_PAGE_SIZE)
380 		count = DS2438_PAGE_SIZE;
381 
382 	if (w1_ds2438_get_page(sl, 1, w1_buf) == 0) {
383 		memcpy(buf, &w1_buf, count);
384 		ret = count;
385 	} else
386 		ret = -EIO;
387 
388 	mutex_unlock(&sl->master->bus_mutex);
389 
390 	return ret;
391 }
392 
offset_write(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)393 static ssize_t offset_write(struct file *filp, struct kobject *kobj,
394 			    struct bin_attribute *bin_attr, char *buf,
395 			    loff_t off, size_t count)
396 {
397 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
398 	int ret;
399 
400 	mutex_lock(&sl->master->bus_mutex);
401 
402 	if (w1_ds2438_change_offset_register(sl, buf) == 0)
403 		ret = count;
404 	else
405 		ret = -EIO;
406 
407 	mutex_unlock(&sl->master->bus_mutex);
408 
409 	return ret;
410 }
411 
temperature_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)412 static ssize_t temperature_read(struct file *filp, struct kobject *kobj,
413 				struct bin_attribute *bin_attr, char *buf,
414 				loff_t off, size_t count)
415 {
416 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
417 	int ret;
418 	int16_t temp;
419 
420 	if (off != 0)
421 		return 0;
422 	if (!buf)
423 		return -EINVAL;
424 
425 	if (w1_ds2438_get_temperature(sl, &temp) == 0)
426 		ret = snprintf(buf, count, "%i\n", temp);
427 	else
428 		ret = -EIO;
429 
430 	return ret;
431 }
432 
vad_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)433 static ssize_t vad_read(struct file *filp, struct kobject *kobj,
434 			struct bin_attribute *bin_attr, char *buf,
435 			loff_t off, size_t count)
436 {
437 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
438 	int ret;
439 	uint16_t voltage;
440 
441 	if (off != 0)
442 		return 0;
443 	if (!buf)
444 		return -EINVAL;
445 
446 	if (w1_ds2438_get_voltage(sl, DS2438_ADC_INPUT_VAD, &voltage) == 0)
447 		ret = snprintf(buf, count, "%u\n", voltage);
448 	else
449 		ret = -EIO;
450 
451 	return ret;
452 }
453 
vdd_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)454 static ssize_t vdd_read(struct file *filp, struct kobject *kobj,
455 			struct bin_attribute *bin_attr, char *buf,
456 			loff_t off, size_t count)
457 {
458 	struct w1_slave *sl = kobj_to_w1_slave(kobj);
459 	int ret;
460 	uint16_t voltage;
461 
462 	if (off != 0)
463 		return 0;
464 	if (!buf)
465 		return -EINVAL;
466 
467 	if (w1_ds2438_get_voltage(sl, DS2438_ADC_INPUT_VDD, &voltage) == 0)
468 		ret = snprintf(buf, count, "%u\n", voltage);
469 	else
470 		ret = -EIO;
471 
472 	return ret;
473 }
474 
475 static BIN_ATTR_RW(iad, 0);
476 static BIN_ATTR_RO(page0, DS2438_PAGE_SIZE);
477 static BIN_ATTR_RO(page1, DS2438_PAGE_SIZE);
478 static BIN_ATTR_WO(offset, 2);
479 static BIN_ATTR_RO(temperature, 0/* real length varies */);
480 static BIN_ATTR_RO(vad, 0/* real length varies */);
481 static BIN_ATTR_RO(vdd, 0/* real length varies */);
482 
483 static struct bin_attribute *w1_ds2438_bin_attrs[] = {
484 	&bin_attr_iad,
485 	&bin_attr_page0,
486 	&bin_attr_page1,
487 	&bin_attr_offset,
488 	&bin_attr_temperature,
489 	&bin_attr_vad,
490 	&bin_attr_vdd,
491 	NULL,
492 };
493 
494 static const struct attribute_group w1_ds2438_group = {
495 	.bin_attrs = w1_ds2438_bin_attrs,
496 };
497 
498 static const struct attribute_group *w1_ds2438_groups[] = {
499 	&w1_ds2438_group,
500 	NULL,
501 };
502 
503 static const struct w1_family_ops w1_ds2438_fops = {
504 	.groups		= w1_ds2438_groups,
505 };
506 
507 static struct w1_family w1_ds2438_family = {
508 	.fid = W1_FAMILY_DS2438,
509 	.fops = &w1_ds2438_fops,
510 };
511 module_w1_family(w1_ds2438_family);
512 
513 MODULE_LICENSE("GPL");
514 MODULE_AUTHOR("Mariusz Bialonczyk <manio@skyboo.net>");
515 MODULE_DESCRIPTION("1-wire driver for Maxim/Dallas DS2438 Smart Battery Monitor");
516 MODULE_ALIAS("w1-family-" __stringify(W1_FAMILY_DS2438));
517