forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-09 95099d4622f8cb224d94e314c7a8e0df60b13f87 
 kernel/drivers/w1/slaves/w1_therm.c
....@@ -1,22 +1,8 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /*
23  *	w1_therm.c
34  *
45  * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
5
- *
6
- *
7
- * This program is free software; you can redistribute it and/or modify
8
- * it under the therms of the GNU General Public License as published by
9
- * the Free Software Foundation; either version 2 of the License, or
10
- * (at your option) any later version.
11
- *
12
- * This program is distributed in the hope that it will be useful,
13
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
- * GNU General Public License for more details.
16
- *
17
- * You should have received a copy of the GNU General Public License
18
- * along with this program; if not, write to the Free Software
19
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
206  */
217 
228 #include <asm/types.h>
....@@ -30,6 +16,8 @@
3016 #include <linux/slab.h>
3117 #include <linux/delay.h>
3218 #include <linux/hwmon.h>
19
+#include <linux/string.h>
20
+#include <linux/jiffies.h>
3321 
3422 #include <linux/w1.h>
3523 
....@@ -39,7 +27,8 @@
3927 #define W1_THERM_DS1825		0x3B
4028 #define W1_THERM_DS28EA00	0x42
4129 
42
-/* Allow the strong pullup to be disabled, but default to enabled.
30
+/*
31
+ * Allow the strong pullup to be disabled, but default to enabled.
4332  * If it was disabled a parasite powered device might not get the require
4433  * current to do a temperature conversion.  If it is enabled parasite powered
4534  * devices have a better chance of getting the current required.
....@@ -55,42 +44,255 @@
5544 static int w1_strong_pullup = 1;
5645 module_param_named(strong_pullup, w1_strong_pullup, int, 0);
5746 
47
+/* Counter for devices supporting bulk reading */
48
+static u16 bulk_read_device_counter; /* =0 as per C standard */
49
+
50
+/* This command should be in public header w1.h but is not */
51
+#define W1_RECALL_EEPROM	0xB8
52
+
53
+/* Nb of try for an operation */
54
+#define W1_THERM_MAX_TRY		5
55
+
56
+/* ms delay to retry bus mutex */
57
+#define W1_THERM_RETRY_DELAY		20
58
+
59
+/* delay in ms to write in EEPROM */
60
+#define W1_THERM_EEPROM_WRITE_DELAY	10
61
+
62
+#define EEPROM_CMD_WRITE    "save"	/* cmd for write eeprom sysfs */
63
+#define EEPROM_CMD_READ     "restore"	/* cmd for read eeprom sysfs */
64
+#define BULK_TRIGGER_CMD    "trigger"	/* cmd to trigger a bulk read */
65
+
66
+#define MIN_TEMP	-55	/* min temperature that can be mesured */
67
+#define MAX_TEMP	125	/* max temperature that can be mesured */
68
+
69
+/* Allowed values for sysfs conv_time attribute */
70
+#define CONV_TIME_DEFAULT 0
71
+#define CONV_TIME_MEASURE 1
72
+
73
+/* Bits in sysfs "features" value */
74
+#define W1_THERM_CHECK_RESULT 1	/* Enable conversion success check */
75
+#define W1_THERM_POLL_COMPLETION 2	/* Poll for conversion completion */
76
+#define W1_THERM_FEATURES_MASK 3		/* All values mask */
77
+
78
+/* Poll period in milliseconds. Should be less then a shortest operation on the device */
79
+#define W1_POLL_PERIOD 32
80
+#define W1_POLL_CONVERT_TEMP 2000	/* Timeout for W1_CONVERT_TEMP, ms */
81
+#define W1_POLL_RECALL_EEPROM 500	/* Timeout for W1_RECALL_EEPROM, ms*/
82
+
83
+/* Masks for resolution functions, work with all devices */
84
+/* Bit mask for config register for all devices, bits 7,6,5 */
85
+#define W1_THERM_RESOLUTION_MASK 0xE0
86
+/* Bit offset of resolution in config register for all devices */
87
+#define W1_THERM_RESOLUTION_SHIFT 5
88
+/* Bit offset of resolution in config register for all devices */
89
+#define W1_THERM_RESOLUTION_SHIFT 5
90
+/* Add this to bit value to get resolution */
91
+#define W1_THERM_RESOLUTION_MIN 9
92
+/* Maximum allowed value */
93
+#define W1_THERM_RESOLUTION_MAX 14
94
+
95
+/* Helpers Macros */
96
+
97
+/*
98
+ * return a pointer on the slave w1_therm_family_converter struct:
99
+ * always test family data existence before using this macro
100
+ */
101
+#define SLAVE_SPECIFIC_FUNC(sl) \
102
+	(((struct w1_therm_family_data *)(sl->family_data))->specific_functions)
103
+
104
+/*
105
+ * return the power mode of the sl slave : 1-ext, 0-parasite, <0 unknown
106
+ * always test family data existence before using this macro
107
+ */
108
+#define SLAVE_POWERMODE(sl) \
109
+	(((struct w1_therm_family_data *)(sl->family_data))->external_powered)
110
+
111
+/*
112
+ * return the resolution in bit of the sl slave : <0 unknown
113
+ * always test family data existence before using this macro
114
+ */
115
+#define SLAVE_RESOLUTION(sl) \
116
+	(((struct w1_therm_family_data *)(sl->family_data))->resolution)
117
+
118
+/*
119
+ * return the conv_time_override of the sl slave
120
+ * always test family data existence before using this macro
121
+ */
122
+ #define SLAVE_CONV_TIME_OVERRIDE(sl) \
123
+	(((struct w1_therm_family_data *)(sl->family_data))->conv_time_override)
124
+
125
+/*
126
+ * return the features of the sl slave
127
+ * always test family data existence before using this macro
128
+ */
129
+ #define SLAVE_FEATURES(sl) \
130
+	(((struct w1_therm_family_data *)(sl->family_data))->features)
131
+
132
+/*
133
+ * return whether or not a converT command has been issued to the slave
134
+ * * 0: no bulk read is pending
135
+ * * -1: conversion is in progress
136
+ * * 1: conversion done, result to be read
137
+ */
138
+#define SLAVE_CONVERT_TRIGGERED(sl) \
139
+	(((struct w1_therm_family_data *)(sl->family_data))->convert_triggered)
140
+
141
+/* return the address of the refcnt in the family data */
142
+#define THERM_REFCNT(family_data) \
143
+	(&((struct w1_therm_family_data *)family_data)->refcnt)
144
+
145
+/* Structs definition */
146
+
147
+/**
148
+ * struct w1_therm_family_converter - bind device specific functions
149
+ * @broken: flag for non-registred families
150
+ * @reserved: not used here
151
+ * @f: pointer to the device binding structure
152
+ * @convert: pointer to the device conversion function
153
+ * @get_conversion_time: pointer to the device conversion time function
154
+ * @set_resolution: pointer to the device set_resolution function
155
+ * @get_resolution: pointer to the device get_resolution function
156
+ * @write_data: pointer to the device writing function (2 or 3 bytes)
157
+ * @bulk_read: true if device family support bulk read, false otherwise
158
+ */
159
+struct w1_therm_family_converter {
160
+	u8		broken;
161
+	u16		reserved;
162
+	struct w1_family	*f;
163
+	int		(*convert)(u8 rom[9]);
164
+	int		(*get_conversion_time)(struct w1_slave *sl);
165
+	int		(*set_resolution)(struct w1_slave *sl, int val);
166
+	int		(*get_resolution)(struct w1_slave *sl);
167
+	int		(*write_data)(struct w1_slave *sl, const u8 *data);
168
+	bool		bulk_read;
169
+};
170
+
171
+/**
172
+ * struct w1_therm_family_data - device data
173
+ * @rom: ROM device id (64bit Lasered ROM code + 1 CRC byte)
174
+ * @refcnt: ref count
175
+ * @external_powered:	1 device powered externally,
176
+ *				0 device parasite powered,
177
+ *				-x error or undefined
178
+ * @resolution: current device resolution
179
+ * @convert_triggered: conversion state of the device
180
+ * @conv_time_override: user selected conversion time or CONV_TIME_DEFAULT
181
+ * @features: bit mask - enable temperature validity check, poll for completion
182
+ * @specific_functions: pointer to struct of device specific function
183
+ */
58184 struct w1_therm_family_data {
59185 	uint8_t rom[9];
60186 	atomic_t refcnt;
187
+	int external_powered;
188
+	int resolution;
189
+	int convert_triggered;
190
+	int conv_time_override;
191
+	unsigned int features;
192
+	struct w1_therm_family_converter *specific_functions;
61193 };
62194 
195
+/**
196
+ * struct therm_info - store temperature reading
197
+ * @rom: read device data (8 data bytes + 1 CRC byte)
198
+ * @crc: computed crc from rom
199
+ * @verdict: 1 crc checked, 0 crc not matching
200
+ */
63201 struct therm_info {
64202 	u8 rom[9];
65203 	u8 crc;
66204 	u8 verdict;
67205 };
68206 
69
-/* return the address of the refcnt in the family data */
70
-#define THERM_REFCNT(family_data) \
71
-	(&((struct w1_therm_family_data *)family_data)->refcnt)
207
+/* Hardware Functions declaration */
72208 
73
-static int w1_therm_add_slave(struct w1_slave *sl)
74
-{
75
-	sl->family_data = kzalloc(sizeof(struct w1_therm_family_data),
76
-		GFP_KERNEL);
77
-	if (!sl->family_data)
78
-		return -ENOMEM;
79
-	atomic_set(THERM_REFCNT(sl->family_data), 1);
80
-	return 0;
81
-}
209
+/**
210
+ * reset_select_slave() - reset and select a slave
211
+ * @sl: the slave to select
212
+ *
213
+ * Resets the bus and select the slave by sending a ROM MATCH cmd
214
+ * w1_reset_select_slave() from w1_io.c could not be used here because
215
+ * it sent a SKIP ROM command if only one device is on the line.
216
+ * At the beginning of the such process, sl->master->slave_count is 1 even if
217
+ * more devices are on the line, causing collision on the line.
218
+ *
219
+ * Context: The w1 master lock must be held.
220
+ *
221
+ * Return: 0 if success, negative kernel error code otherwise.
222
+ */
223
+static int reset_select_slave(struct w1_slave *sl);
82224 
83
-static void w1_therm_remove_slave(struct w1_slave *sl)
84
-{
85
-	int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data));
225
+/**
226
+ * convert_t() - Query the device for temperature conversion and read
227
+ * @sl: pointer to the slave to read
228
+ * @info: pointer to a structure to store the read results
229
+ *
230
+ * Return: 0 if success, -kernel error code otherwise
231
+ */
232
+static int convert_t(struct w1_slave *sl, struct therm_info *info);
86233 
87
-	while (refcnt) {
88
-		msleep(1000);
89
-		refcnt = atomic_read(THERM_REFCNT(sl->family_data));
90
-	}
91
-	kfree(sl->family_data);
92
-	sl->family_data = NULL;
93
-}
234
+/**
235
+ * read_scratchpad() - read the data in device RAM
236
+ * @sl: pointer to the slave to read
237
+ * @info: pointer to a structure to store the read results
238
+ *
239
+ * Return: 0 if success, -kernel error code otherwise
240
+ */
241
+static int read_scratchpad(struct w1_slave *sl, struct therm_info *info);
242
+
243
+/**
244
+ * write_scratchpad() - write nb_bytes in the device RAM
245
+ * @sl: pointer to the slave to write in
246
+ * @data: pointer to an array of 3 bytes, as 3 bytes MUST be written
247
+ * @nb_bytes: number of bytes to be written (2 for DS18S20, 3 otherwise)
248
+ *
249
+ * Return: 0 if success, -kernel error code otherwise
250
+ */
251
+static int write_scratchpad(struct w1_slave *sl, const u8 *data, u8 nb_bytes);
252
+
253
+/**
254
+ * copy_scratchpad() - Copy the content of scratchpad in device EEPROM
255
+ * @sl: slave involved
256
+ *
257
+ * Return: 0 if success, -kernel error code otherwise
258
+ */
259
+static int copy_scratchpad(struct w1_slave *sl);
260
+
261
+/**
262
+ * recall_eeprom() - Restore EEPROM data to device RAM
263
+ * @sl: slave involved
264
+ *
265
+ * Return: 0 if success, -kernel error code otherwise
266
+ */
267
+static int recall_eeprom(struct w1_slave *sl);
268
+
269
+/**
270
+ * read_powermode() - Query the power mode of the slave
271
+ * @sl: slave to retrieve the power mode
272
+ *
273
+ * Ask the device to get its power mode (external or parasite)
274
+ * and store the power status in the &struct w1_therm_family_data.
275
+ *
276
+ * Return:
277
+ * * 0 parasite powered device
278
+ * * 1 externally powered device
279
+ * * <0 kernel error code
280
+ */
281
+static int read_powermode(struct w1_slave *sl);
282
+
283
+/**
284
+ * trigger_bulk_read() - function to trigger a bulk read on the bus
285
+ * @dev_master: the device master of the bus
286
+ *
287
+ * Send a SKIP ROM follow by a CONVERT T commmand on the bus.
288
+ * It also set the status flag in each slave &struct w1_therm_family_data
289
+ * to signal that a conversion is in progress.
290
+ *
291
+ * Return: 0 if success, -kernel error code otherwise
292
+ */
293
+static int trigger_bulk_read(struct w1_master *dev_master);
294
+
295
+/* Sysfs interface declaration */
94296 
95297 static ssize_t w1_slave_show(struct device *device,
96298 	struct device_attribute *attr, char *buf);
....@@ -101,21 +303,124 @@
101303 static ssize_t w1_seq_show(struct device *device,
102304 	struct device_attribute *attr, char *buf);
103305 
306
+static ssize_t temperature_show(struct device *device,
307
+	struct device_attribute *attr, char *buf);
308
+
309
+static ssize_t ext_power_show(struct device *device,
310
+	struct device_attribute *attr, char *buf);
311
+
312
+static ssize_t resolution_show(struct device *device,
313
+	struct device_attribute *attr, char *buf);
314
+
315
+static ssize_t resolution_store(struct device *device,
316
+	struct device_attribute *attr, const char *buf, size_t size);
317
+
318
+static ssize_t eeprom_store(struct device *device,
319
+	struct device_attribute *attr, const char *buf, size_t size);
320
+
321
+static ssize_t alarms_store(struct device *device,
322
+	struct device_attribute *attr, const char *buf, size_t size);
323
+
324
+static ssize_t alarms_show(struct device *device,
325
+	struct device_attribute *attr, char *buf);
326
+
327
+static ssize_t therm_bulk_read_store(struct device *device,
328
+	struct device_attribute *attr, const char *buf, size_t size);
329
+
330
+static ssize_t therm_bulk_read_show(struct device *device,
331
+	struct device_attribute *attr, char *buf);
332
+
333
+static ssize_t conv_time_show(struct device *device,
334
+			      struct device_attribute *attr, char *buf);
335
+
336
+static ssize_t conv_time_store(struct device *device,
337
+			       struct device_attribute *attr, const char *buf,
338
+			       size_t size);
339
+
340
+static ssize_t features_show(struct device *device,
341
+			      struct device_attribute *attr, char *buf);
342
+
343
+static ssize_t features_store(struct device *device,
344
+			       struct device_attribute *attr, const char *buf,
345
+			       size_t size);
346
+/* Attributes declarations */
347
+
104348 static DEVICE_ATTR_RW(w1_slave);
105349 static DEVICE_ATTR_RO(w1_seq);
350
+static DEVICE_ATTR_RO(temperature);
351
+static DEVICE_ATTR_RO(ext_power);
352
+static DEVICE_ATTR_RW(resolution);
353
+static DEVICE_ATTR_WO(eeprom);
354
+static DEVICE_ATTR_RW(alarms);
355
+static DEVICE_ATTR_RW(conv_time);
356
+static DEVICE_ATTR_RW(features);
357
+
358
+static DEVICE_ATTR_RW(therm_bulk_read); /* attribut at master level */
359
+
360
+/* Interface Functions declaration */
361
+
362
+/**
363
+ * w1_therm_add_slave() - Called when a new slave is discovered
364
+ * @sl: slave just discovered by the master.
365
+ *
366
+ * Called by the master when the slave is discovered on the bus. Used to
367
+ * initialize slave state before the beginning of any communication.
368
+ *
369
+ * Return: 0 - If success, negative kernel code otherwise
370
+ */
371
+static int w1_therm_add_slave(struct w1_slave *sl);
372
+
373
+/**
374
+ * w1_therm_remove_slave() - Called when a slave is removed
375
+ * @sl: slave to be removed.
376
+ *
377
+ * Called by the master when the slave is considered not to be on the bus
378
+ * anymore. Used to free memory.
379
+ */
380
+static void w1_therm_remove_slave(struct w1_slave *sl);
381
+
382
+/* Family attributes */
106383 
107384 static struct attribute *w1_therm_attrs[] = {
108385 	&dev_attr_w1_slave.attr,
386
+	&dev_attr_temperature.attr,
387
+	&dev_attr_ext_power.attr,
388
+	&dev_attr_resolution.attr,
389
+	&dev_attr_eeprom.attr,
390
+	&dev_attr_alarms.attr,
391
+	&dev_attr_conv_time.attr,
392
+	&dev_attr_features.attr,
393
+	NULL,
394
+};
395
+
396
+static struct attribute *w1_ds18s20_attrs[] = {
397
+	&dev_attr_w1_slave.attr,
398
+	&dev_attr_temperature.attr,
399
+	&dev_attr_ext_power.attr,
400
+	&dev_attr_eeprom.attr,
401
+	&dev_attr_alarms.attr,
402
+	&dev_attr_conv_time.attr,
403
+	&dev_attr_features.attr,
109404 	NULL,
110405 };
111406 
112407 static struct attribute *w1_ds28ea00_attrs[] = {
113408 	&dev_attr_w1_slave.attr,
114409 	&dev_attr_w1_seq.attr,
410
+	&dev_attr_temperature.attr,
411
+	&dev_attr_ext_power.attr,
412
+	&dev_attr_resolution.attr,
413
+	&dev_attr_eeprom.attr,
414
+	&dev_attr_alarms.attr,
415
+	&dev_attr_conv_time.attr,
416
+	&dev_attr_features.attr,
115417 	NULL,
116418 };
117419 
420
+/* Attribute groups */
421
+
118422 ATTRIBUTE_GROUPS(w1_therm);
423
+ATTRIBUTE_GROUPS(w1_ds18s20);
119424 ATTRIBUTE_GROUPS(w1_ds28ea00);
120425 
121426 #if IS_REACHABLE(CONFIG_HWMON)
....@@ -168,23 +473,34 @@
168473 #define W1_CHIPINFO	NULL
169474 #endif
170475 
171
-static struct w1_family_ops w1_therm_fops = {
476
+/* Family operations */
477
+
478
+static const struct w1_family_ops w1_therm_fops = {
172479 	.add_slave	= w1_therm_add_slave,
173480 	.remove_slave	= w1_therm_remove_slave,
174481 	.groups		= w1_therm_groups,
175482 	.chip_info	= W1_CHIPINFO,
176483 };
177484 
178
-static struct w1_family_ops w1_ds28ea00_fops = {
485
+static const struct w1_family_ops w1_ds18s20_fops = {
486
+	.add_slave	= w1_therm_add_slave,
487
+	.remove_slave	= w1_therm_remove_slave,
488
+	.groups		= w1_ds18s20_groups,
489
+	.chip_info	= W1_CHIPINFO,
490
+};
491
+
492
+static const struct w1_family_ops w1_ds28ea00_fops = {
179493 	.add_slave	= w1_therm_add_slave,
180494 	.remove_slave	= w1_therm_remove_slave,
181495 	.groups		= w1_ds28ea00_groups,
182496 	.chip_info	= W1_CHIPINFO,
183497 };
184498 
499
+/* Family binding operations struct */
500
+
185501 static struct w1_family w1_therm_family_DS18S20 = {
186502 	.fid = W1_THERM_DS18S20,
187
-	.fops = &w1_therm_fops,
503
+	.fops = &w1_ds18s20_fops,
188504 };
189505 
190506 static struct w1_family w1_therm_family_DS18B20 = {
....@@ -207,233 +523,184 @@
207523 	.fops = &w1_therm_fops,
208524 };
209525 
210
-struct w1_therm_family_converter {
211
-	u8			broken;
212
-	u16			reserved;
213
-	struct w1_family	*f;
214
-	int			(*convert)(u8 rom[9]);
215
-	int			(*precision)(struct device *device, int val);
216
-	int			(*eeprom)(struct device *device);
217
-};
526
+/* Device dependent func */
218527 
219
-/* write configuration to eeprom */
220
-static inline int w1_therm_eeprom(struct device *device);
221
-
222
-/* Set precision for conversion */
223
-static inline int w1_DS18B20_precision(struct device *device, int val);
224
-static inline int w1_DS18S20_precision(struct device *device, int val);
225
-
226
-/* The return value is millidegrees Centigrade. */
227
-static inline int w1_DS18B20_convert_temp(u8 rom[9]);
228
-static inline int w1_DS18S20_convert_temp(u8 rom[9]);
229
-
230
-static struct w1_therm_family_converter w1_therm_families[] = {
231
-	{
232
-		.f		= &w1_therm_family_DS18S20,
233
-		.convert	= w1_DS18S20_convert_temp,
234
-		.precision	= w1_DS18S20_precision,
235
-		.eeprom		= w1_therm_eeprom
236
-	},
237
-	{
238
-		.f		= &w1_therm_family_DS1822,
239
-		.convert	= w1_DS18B20_convert_temp,
240
-		.precision	= w1_DS18S20_precision,
241
-		.eeprom		= w1_therm_eeprom
242
-	},
243
-	{
244
-		.f		= &w1_therm_family_DS18B20,
245
-		.convert	= w1_DS18B20_convert_temp,
246
-		.precision	= w1_DS18B20_precision,
247
-		.eeprom		= w1_therm_eeprom
248
-	},
249
-	{
250
-		.f		= &w1_therm_family_DS28EA00,
251
-		.convert	= w1_DS18B20_convert_temp,
252
-		.precision	= w1_DS18S20_precision,
253
-		.eeprom		= w1_therm_eeprom
254
-	},
255
-	{
256
-		.f		= &w1_therm_family_DS1825,
257
-		.convert	= w1_DS18B20_convert_temp,
258
-		.precision	= w1_DS18S20_precision,
259
-		.eeprom		= w1_therm_eeprom
260
-	}
261
-};
262
-
263
-static inline int w1_therm_eeprom(struct device *device)
528
+static inline int w1_DS18B20_convert_time(struct w1_slave *sl)
264529 {
265
-	struct w1_slave *sl = dev_to_w1_slave(device);
266
-	struct w1_master *dev = sl->master;
267
-	u8 rom[9], external_power;
268
-	int ret, max_trying = 10;
269
-	u8 *family_data = sl->family_data;
530
+	int ret;
270531 
271
-	if (!sl->family_data) {
272
-		ret = -ENODEV;
273
-		goto error;
274
-	}
532
+	if (!sl->family_data)
533
+		return -ENODEV;	/* device unknown */
275534 
276
-	/* prevent the slave from going away in sleep */
277
-	atomic_inc(THERM_REFCNT(family_data));
535
+	if (SLAVE_CONV_TIME_OVERRIDE(sl) != CONV_TIME_DEFAULT)
536
+		return SLAVE_CONV_TIME_OVERRIDE(sl);
278537 
279
-	ret = mutex_lock_interruptible(&dev->bus_mutex);
280
-	if (ret != 0)
281
-		goto dec_refcnt;
282
-
283
-	memset(rom, 0, sizeof(rom));
284
-
285
-	while (max_trying--) {
286
-		if (!w1_reset_select_slave(sl)) {
287
-			unsigned int tm = 10;
288
-			unsigned long sleep_rem;
289
-
290
-			/* check if in parasite mode */
291
-			w1_write_8(dev, W1_READ_PSUPPLY);
292
-			external_power = w1_read_8(dev);
293
-
294
-			if (w1_reset_select_slave(sl))
295
-				continue;
296
-
297
-			/* 10ms strong pullup/delay after the copy command */
298
-			if (w1_strong_pullup == 2 ||
299
-			    (!external_power && w1_strong_pullup))
300
-				w1_next_pullup(dev, tm);
301
-
302
-			w1_write_8(dev, W1_COPY_SCRATCHPAD);
303
-
304
-			if (external_power) {
305
-				mutex_unlock(&dev->bus_mutex);
306
-
307
-				sleep_rem = msleep_interruptible(tm);
308
-				if (sleep_rem != 0) {
309
-					ret = -EINTR;
310
-					goto dec_refcnt;
311
-				}
312
-
313
-				ret = mutex_lock_interruptible(&dev->bus_mutex);
314
-				if (ret != 0)
315
-					goto dec_refcnt;
316
-			} else if (!w1_strong_pullup) {
317
-				sleep_rem = msleep_interruptible(tm);
318
-				if (sleep_rem != 0) {
319
-					ret = -EINTR;
320
-					goto mt_unlock;
321
-				}
322
-			}
323
-
324
-			break;
325
-		}
326
-	}
327
-
328
-mt_unlock:
329
-	mutex_unlock(&dev->bus_mutex);
330
-dec_refcnt:
331
-	atomic_dec(THERM_REFCNT(family_data));
332
-error:
333
-	return ret;
334
-}
335
-
336
-/* DS18S20 does not feature configuration register */
337
-static inline int w1_DS18S20_precision(struct device *device, int val)
338
-{
339
-	return 0;
340
-}
341
-
342
-static inline int w1_DS18B20_precision(struct device *device, int val)
343
-{
344
-	struct w1_slave *sl = dev_to_w1_slave(device);
345
-	struct w1_master *dev = sl->master;
346
-	u8 rom[9], crc;
347
-	int ret, max_trying = 10;
348
-	u8 *family_data = sl->family_data;
349
-	uint8_t precision_bits;
350
-	uint8_t mask = 0x60;
351
-
352
-	if (val > 12 || val < 9) {
353
-		pr_warn("Unsupported precision\n");
354
-		ret = -EINVAL;
355
-		goto error;
356
-	}
357
-
358
-	if (!sl->family_data) {
359
-		ret = -ENODEV;
360
-		goto error;
361
-	}
362
-
363
-	/* prevent the slave from going away in sleep */
364
-	atomic_inc(THERM_REFCNT(family_data));
365
-
366
-	ret = mutex_lock_interruptible(&dev->bus_mutex);
367
-	if (ret != 0)
368
-		goto dec_refcnt;
369
-
370
-	memset(rom, 0, sizeof(rom));
371
-
372
-	/* translate precision to bitmask (see datasheet page 9) */
373
-	switch (val) {
538
+	/* Return the conversion time, depending on resolution,
539
+	 * select maximum conversion time among all compatible devices
540
+	 */
541
+	switch (SLAVE_RESOLUTION(sl)) {
374542 	case 9:
375
-		precision_bits = 0x00;
543
+		ret = 95;
376544 		break;
377545 	case 10:
378
-		precision_bits = 0x20;
546
+		ret = 190;
379547 		break;
380548 	case 11:
381
-		precision_bits = 0x40;
549
+		ret = 375;
382550 		break;
383551 	case 12:
384
-	default:
385
-		precision_bits = 0x60;
552
+		ret = 750;
386553 		break;
554
+	case 13:
555
+		ret = 850;  /* GX20MH01 only. Datasheet says 500ms, but that's not enough. */
556
+		break;
557
+	case 14:
558
+		ret = 1600; /* GX20MH01 only. Datasheet says 1000ms - not enough */
559
+		break;
560
+	default:
561
+		ret = 750;
387562 	}
388
-
389
-	while (max_trying--) {
390
-		crc = 0;
391
-
392
-		if (!w1_reset_select_slave(sl)) {
393
-			int count = 0;
394
-
395
-			/* read values to only alter precision bits */
396
-			w1_write_8(dev, W1_READ_SCRATCHPAD);
397
-			count = w1_read_block(dev, rom, 9);
398
-			if (count != 9)
399
-				dev_warn(device, "w1_read_block() returned %u instead of 9.\n",	count);
400
-
401
-			crc = w1_calc_crc8(rom, 8);
402
-			if (rom[8] == crc) {
403
-				rom[4] = (rom[4] & ~mask) | (precision_bits & mask);
404
-
405
-				if (!w1_reset_select_slave(sl)) {
406
-					w1_write_8(dev, W1_WRITE_SCRATCHPAD);
407
-					w1_write_8(dev, rom[2]);
408
-					w1_write_8(dev, rom[3]);
409
-					w1_write_8(dev, rom[4]);
410
-
411
-					break;
412
-				}
413
-			}
414
-		}
415
-	}
416
-
417
-	mutex_unlock(&dev->bus_mutex);
418
-dec_refcnt:
419
-	atomic_dec(THERM_REFCNT(family_data));
420
-error:
421563 	return ret;
422564 }
423565 
424
-static inline int w1_DS18B20_convert_temp(u8 rom[9])
566
+static inline int w1_DS18S20_convert_time(struct w1_slave *sl)
425567 {
426
-	s16 t = le16_to_cpup((__le16 *)rom);
568
+	if (!sl->family_data)
569
+		return -ENODEV;	/* device unknown */
427570 
428
-	return t*1000/16;
571
+	if (SLAVE_CONV_TIME_OVERRIDE(sl) == CONV_TIME_DEFAULT)
572
+		return 750; /* default for DS18S20 */
573
+	else
574
+		return SLAVE_CONV_TIME_OVERRIDE(sl);
429575 }
430576 
577
+static inline int w1_DS18B20_write_data(struct w1_slave *sl,
578
+				const u8 *data)
579
+{
580
+	return write_scratchpad(sl, data, 3);
581
+}
582
+
583
+static inline int w1_DS18S20_write_data(struct w1_slave *sl,
584
+				const u8 *data)
585
+{
586
+	/* No config register */
587
+	return write_scratchpad(sl, data, 2);
588
+}
589
+
590
+static inline int w1_DS18B20_set_resolution(struct w1_slave *sl, int val)
591
+{
592
+	int ret;
593
+	struct therm_info info, info2;
594
+
595
+	/* DS18B20 resolution is 9 to 12 bits */
596
+	/* GX20MH01 resolution is 9 to 14 bits */
597
+	if (val < W1_THERM_RESOLUTION_MIN || val > W1_THERM_RESOLUTION_MAX)
598
+		return -EINVAL;
599
+
600
+	/* Calc bit value from resolution */
601
+	val = (val - W1_THERM_RESOLUTION_MIN) << W1_THERM_RESOLUTION_SHIFT;
602
+
603
+	/*
604
+	 * Read the scratchpad to change only the required bits
605
+	 * (bit5 & bit 6 from byte 4)
606
+	 */
607
+	ret = read_scratchpad(sl, &info);
608
+
609
+	if (ret)
610
+		return ret;
611
+
612
+
613
+	info.rom[4] &= ~W1_THERM_RESOLUTION_MASK;
614
+	info.rom[4] |= val;
615
+
616
+	/* Write data in the device RAM */
617
+	ret = w1_DS18B20_write_data(sl, info.rom + 2);
618
+	if (ret)
619
+		return ret;
620
+
621
+	/* Have to read back the resolution to verify an actual value
622
+	 * GX20MH01 and DS18B20 are indistinguishable by family number, but resolutions differ
623
+	 * Some DS18B20 clones don't support resolution change
624
+	 */
625
+	ret = read_scratchpad(sl, &info2);
626
+	if (ret)
627
+		/* Scratchpad read fail */
628
+		return ret;
629
+
630
+	if ((info2.rom[4] & W1_THERM_RESOLUTION_MASK) == (info.rom[4] & W1_THERM_RESOLUTION_MASK))
631
+		return 0;
632
+
633
+	/* Resolution verify error */
634
+	return -EIO;
635
+}
636
+
637
+static inline int w1_DS18B20_get_resolution(struct w1_slave *sl)
638
+{
639
+	int ret;
640
+	int resolution;
641
+	struct therm_info info;
642
+
643
+	ret = read_scratchpad(sl, &info);
644
+
645
+	if (ret)
646
+		return ret;
647
+
648
+	resolution = ((info.rom[4] & W1_THERM_RESOLUTION_MASK) >> W1_THERM_RESOLUTION_SHIFT)
649
+		+ W1_THERM_RESOLUTION_MIN;
650
+	/* GX20MH01 has one special case:
651
+	 *   >=14 means 14 bits when getting resolution from bit value.
652
+	 * Other devices have no more then 12 bits.
653
+	 */
654
+	if (resolution > W1_THERM_RESOLUTION_MAX)
655
+		resolution = W1_THERM_RESOLUTION_MAX;
656
+
657
+	return resolution;
658
+}
659
+
660
+/**
661
+ * w1_DS18B20_convert_temp() - temperature computation for DS18B20
662
+ * @rom: data read from device RAM (8 data bytes + 1 CRC byte)
663
+ *
664
+ * Can be called for any DS18B20 compliant device.
665
+ *
666
+ * Return: value in millidegrees Celsius.
667
+ */
668
+static inline int w1_DS18B20_convert_temp(u8 rom[9])
669
+{
670
+	u16 bv;
671
+	s16 t;
672
+
673
+	/* Signed 16-bit value to unsigned, cpu order */
674
+	bv = le16_to_cpup((__le16 *)rom);
675
+
676
+	/* Config register bit R2 = 1 - GX20MH01 in 13 or 14 bit resolution mode */
677
+	if (rom[4] & 0x80) {
678
+		/* Insert two temperature bits from config register */
679
+		/* Avoid arithmetic shift of signed value */
680
+		bv = (bv << 2) | (rom[4] & 3);
681
+		t = (s16) bv;	/* Degrees, lowest bit is 2^-6 */
682
+		return (int)t * 1000 / 64;	/* Sign-extend to int; millidegrees */
683
+	}
684
+	t = (s16)bv;	/* Degrees, lowest bit is 2^-4 */
685
+	return (int)t * 1000 / 16;	/* Sign-extend to int; millidegrees */
686
+}
687
+
688
+/**
689
+ * w1_DS18S20_convert_temp() - temperature computation for DS18S20
690
+ * @rom: data read from device RAM (8 data bytes + 1 CRC byte)
691
+ *
692
+ * Can be called for any DS18S20 compliant device.
693
+ *
694
+ * Return: value in millidegrees Celsius.
695
+ */
431696 static inline int w1_DS18S20_convert_temp(u8 rom[9])
432697 {
433698 	int t, h;
434699 
435
-	if (!rom[7])
700
+	if (!rom[7]) {
701
+		pr_debug("%s: Invalid argument for conversion\n", __func__);
436702 		return 0;
703
+	}
437704 
438705 	if (rom[1] == 0)
439706 		t = ((s32)rom[0] >> 1)*1000;
....@@ -448,135 +715,813 @@
448715 	return t;
449716 }
450717 
451
-static inline int w1_convert_temp(u8 rom[9], u8 fid)
718
+/* Device capability description */
719
+/* GX20MH01 device shares family number and structure with DS18B20 */
720
+
721
+static struct w1_therm_family_converter w1_therm_families[] = {
722
+	{
723
+		.f				= &w1_therm_family_DS18S20,
724
+		.convert			= w1_DS18S20_convert_temp,
725
+		.get_conversion_time	= w1_DS18S20_convert_time,
726
+		.set_resolution		= NULL,	/* no config register */
727
+		.get_resolution		= NULL,	/* no config register */
728
+		.write_data			= w1_DS18S20_write_data,
729
+		.bulk_read			= true
730
+	},
731
+	{
732
+		.f				= &w1_therm_family_DS1822,
733
+		.convert			= w1_DS18B20_convert_temp,
734
+		.get_conversion_time	= w1_DS18B20_convert_time,
735
+		.set_resolution		= w1_DS18B20_set_resolution,
736
+		.get_resolution		= w1_DS18B20_get_resolution,
737
+		.write_data			= w1_DS18B20_write_data,
738
+		.bulk_read			= true
739
+	},
740
+	{
741
+		/* Also used for GX20MH01 */
742
+		.f				= &w1_therm_family_DS18B20,
743
+		.convert			= w1_DS18B20_convert_temp,
744
+		.get_conversion_time	= w1_DS18B20_convert_time,
745
+		.set_resolution		= w1_DS18B20_set_resolution,
746
+		.get_resolution		= w1_DS18B20_get_resolution,
747
+		.write_data			= w1_DS18B20_write_data,
748
+		.bulk_read			= true
749
+	},
750
+	{
751
+		.f				= &w1_therm_family_DS28EA00,
752
+		.convert			= w1_DS18B20_convert_temp,
753
+		.get_conversion_time	= w1_DS18B20_convert_time,
754
+		.set_resolution		= w1_DS18B20_set_resolution,
755
+		.get_resolution		= w1_DS18B20_get_resolution,
756
+		.write_data			= w1_DS18B20_write_data,
757
+		.bulk_read			= false
758
+	},
759
+	{
760
+		.f				= &w1_therm_family_DS1825,
761
+		.convert			= w1_DS18B20_convert_temp,
762
+		.get_conversion_time	= w1_DS18B20_convert_time,
763
+		.set_resolution		= w1_DS18B20_set_resolution,
764
+		.get_resolution		= w1_DS18B20_get_resolution,
765
+		.write_data			= w1_DS18B20_write_data,
766
+		.bulk_read			= true
767
+	}
768
+};
769
+
770
+/* Helpers Functions */
771
+
772
+/**
773
+ * device_family() - Retrieve a pointer on &struct w1_therm_family_converter
774
+ * @sl: slave to retrieve the device specific structure
775
+ *
776
+ * Return: pointer to the slaves's family converter, NULL if not known
777
+ */
778
+static struct w1_therm_family_converter *device_family(struct w1_slave *sl)
452779 {
780
+	struct w1_therm_family_converter *ret = NULL;
453781 	int i;
454782 
455
-	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
456
-		if (w1_therm_families[i].f->fid == fid)
457
-			return w1_therm_families[i].convert(rom);
783
+	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
784
+		if (w1_therm_families[i].f->fid == sl->family->fid) {
785
+			ret = &w1_therm_families[i];
786
+			break;
787
+		}
788
+	}
789
+	return ret;
790
+}
791
+
792
+/**
793
+ * bus_mutex_lock() - Acquire the mutex
794
+ * @lock: w1 bus mutex to acquire
795
+ *
796
+ * It try to acquire the mutex W1_THERM_MAX_TRY times and wait
797
+ * W1_THERM_RETRY_DELAY between 2 attempts.
798
+ *
799
+ * Return: true is mutex is acquired and lock, false otherwise
800
+ */
801
+static inline bool bus_mutex_lock(struct mutex *lock)
802
+{
803
+	int max_trying = W1_THERM_MAX_TRY;
804
+
805
+	/* try to acquire the mutex, if not, sleep retry_delay before retry) */
806
+	while (mutex_lock_interruptible(lock) != 0 && max_trying > 0) {
807
+		unsigned long sleep_rem;
808
+
809
+		sleep_rem = msleep_interruptible(W1_THERM_RETRY_DELAY);
810
+		if (!sleep_rem)
811
+			max_trying--;
812
+	}
813
+
814
+	if (!max_trying)
815
+		return false;	/* Didn't acquire the bus mutex */
816
+
817
+	return true;
818
+}
819
+
820
+/**
821
+ * check_family_data() - Check if family data and specific functions are present
822
+ * @sl: W1 device data
823
+ *
824
+ * Return: 0 - OK, negative value - error
825
+ */
826
+static int check_family_data(struct w1_slave *sl)
827
+{
828
+	if ((!sl->family_data) || (!SLAVE_SPECIFIC_FUNC(sl))) {
829
+		dev_info(&sl->dev,
830
+			 "%s: Device is not supported by the driver\n", __func__);
831
+		return -EINVAL;  /* No device family */
832
+	}
833
+	return 0;
834
+}
835
+
836
+/**
837
+ * support_bulk_read() - check if slave support bulk read
838
+ * @sl: device to check the ability
839
+ *
840
+ * Return: true if bulk read is supported, false if not or error
841
+ */
842
+static inline bool bulk_read_support(struct w1_slave *sl)
843
+{
844
+	if (SLAVE_SPECIFIC_FUNC(sl))
845
+		return SLAVE_SPECIFIC_FUNC(sl)->bulk_read;
846
+
847
+	dev_info(&sl->dev,
848
+		"%s: Device not supported by the driver\n", __func__);
849
+
850
+	return false;  /* No device family */
851
+}
852
+
853
+/**
854
+ * conversion_time() - get the Tconv for the slave
855
+ * @sl: device to get the conversion time
856
+ *
857
+ * On device supporting resolution settings, conversion time depend
858
+ * on the resolution setting. This helper function get the slave timing,
859
+ * depending on its current setting.
860
+ *
861
+ * Return: conversion time in ms, negative values are kernel error code
862
+ */
863
+static inline int conversion_time(struct w1_slave *sl)
864
+{
865
+	if (SLAVE_SPECIFIC_FUNC(sl))
866
+		return SLAVE_SPECIFIC_FUNC(sl)->get_conversion_time(sl);
867
+
868
+	dev_info(&sl->dev,
869
+		"%s: Device not supported by the driver\n", __func__);
870
+
871
+	return -ENODEV;  /* No device family */
872
+}
873
+
874
+/**
875
+ * temperature_from_RAM() - Convert the read info to temperature
876
+ * @sl: device that sent the RAM data
877
+ * @rom: read value on the slave device RAM
878
+ *
879
+ * Device dependent, the function bind the correct computation method.
880
+ *
881
+ * Return: temperature in 1/1000degC, 0 on error.
882
+ */
883
+static inline int temperature_from_RAM(struct w1_slave *sl, u8 rom[9])
884
+{
885
+	if (SLAVE_SPECIFIC_FUNC(sl))
886
+		return SLAVE_SPECIFIC_FUNC(sl)->convert(rom);
887
+
888
+	dev_info(&sl->dev,
889
+		"%s: Device not supported by the driver\n", __func__);
890
+
891
+	return 0;  /* No device family */
892
+}
893
+
894
+/**
895
+ * int_to_short() - Safe casting of int to short
896
+ *
897
+ * @i: integer to be converted to short
898
+ *
899
+ * Device register use 1 byte to store signed integer.
900
+ * This helper function convert the int in a signed short,
901
+ * using the min/max values that device can measure as limits.
902
+ * min/max values are defined by macro.
903
+ *
904
+ * Return: a short in the range of min/max value
905
+ */
906
+static inline s8 int_to_short(int i)
907
+{
908
+	/* Prepare to cast to short by eliminating out of range values */
909
+	i = i > MAX_TEMP ? MAX_TEMP : i;
910
+	i = i < MIN_TEMP ? MIN_TEMP : i;
911
+	return (s8) i;
912
+}
913
+
914
+/* Interface Functions */
915
+
916
+static int w1_therm_add_slave(struct w1_slave *sl)
917
+{
918
+	struct w1_therm_family_converter *sl_family_conv;
919
+
920
+	/* Allocate memory */
921
+	sl->family_data = kzalloc(sizeof(struct w1_therm_family_data),
922
+		GFP_KERNEL);
923
+	if (!sl->family_data)
924
+		return -ENOMEM;
925
+
926
+	atomic_set(THERM_REFCNT(sl->family_data), 1);
927
+
928
+	/* Get a pointer to the device specific function struct */
929
+	sl_family_conv = device_family(sl);
930
+	if (!sl_family_conv) {
931
+		kfree(sl->family_data);
932
+		return -ENODEV;
933
+	}
934
+	/* save this pointer to the device structure */
935
+	SLAVE_SPECIFIC_FUNC(sl) = sl_family_conv;
936
+
937
+	if (bulk_read_support(sl)) {
938
+		/*
939
+		 * add the sys entry to trigger bulk_read
940
+		 * at master level only the 1st time
941
+		 */
942
+		if (!bulk_read_device_counter) {
943
+			int err = device_create_file(&sl->master->dev,
944
+				&dev_attr_therm_bulk_read);
945
+
946
+			if (err)
947
+				dev_warn(&sl->dev,
948
+				"%s: Device has been added, but bulk read is unavailable. err=%d\n",
949
+				__func__, err);
950
+		}
951
+		/* Increment the counter */
952
+		bulk_read_device_counter++;
953
+	}
954
+
955
+	/* Getting the power mode of the device {external, parasite} */
956
+	SLAVE_POWERMODE(sl) = read_powermode(sl);
957
+
958
+	if (SLAVE_POWERMODE(sl) < 0) {
959
+		/* no error returned as device has been added */
960
+		dev_warn(&sl->dev,
961
+			"%s: Device has been added, but power_mode may be corrupted. err=%d\n",
962
+			 __func__, SLAVE_POWERMODE(sl));
963
+	}
964
+
965
+	/* Getting the resolution of the device */
966
+	if (SLAVE_SPECIFIC_FUNC(sl)->get_resolution) {
967
+		SLAVE_RESOLUTION(sl) =
968
+			SLAVE_SPECIFIC_FUNC(sl)->get_resolution(sl);
969
+		if (SLAVE_RESOLUTION(sl) < 0) {
970
+			/* no error returned as device has been added */
971
+			dev_warn(&sl->dev,
972
+				"%s:Device has been added, but resolution may be corrupted. err=%d\n",
973
+				__func__, SLAVE_RESOLUTION(sl));
974
+		}
975
+	}
976
+
977
+	/* Finally initialize convert_triggered flag */
978
+	SLAVE_CONVERT_TRIGGERED(sl) = 0;
458979 
459980 	return 0;
460981 }
461982 
462
-static ssize_t w1_slave_store(struct device *device,
463
-			      struct device_attribute *attr, const char *buf,
464
-			      size_t size)
983
+static void w1_therm_remove_slave(struct w1_slave *sl)
465984 {
466
-	int val, ret;
467
-	struct w1_slave *sl = dev_to_w1_slave(device);
468
-	int i;
985
+	int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data));
469986 
470
-	ret = kstrtoint(buf, 0, &val);
471
-	if (ret)
472
-		return ret;
473
-
474
-	for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
475
-		if (w1_therm_families[i].f->fid == sl->family->fid) {
476
-			/* zero value indicates to write current configuration to eeprom */
477
-			if (val == 0)
478
-				ret = w1_therm_families[i].eeprom(device);
479
-			else
480
-				ret = w1_therm_families[i].precision(device, val);
481
-			break;
482
-		}
987
+	if (bulk_read_support(sl)) {
988
+		bulk_read_device_counter--;
989
+		/* Delete the entry if no more device support the feature */
990
+		if (!bulk_read_device_counter)
991
+			device_remove_file(&sl->master->dev,
992
+				&dev_attr_therm_bulk_read);
483993 	}
484
-	return ret ? : size;
994
+
995
+	while (refcnt) {
996
+		msleep(1000);
997
+		refcnt = atomic_read(THERM_REFCNT(sl->family_data));
998
+	}
999
+	kfree(sl->family_data);
1000
+	sl->family_data = NULL;
4851001 }
4861002 
487
-static ssize_t read_therm(struct device *device,
488
-			  struct w1_slave *sl, struct therm_info *info)
489
-{
490
-	struct w1_master *dev = sl->master;
491
-	u8 external_power;
492
-	int ret, max_trying = 10;
493
-	u8 *family_data = sl->family_data;
1003
+/* Hardware Functions */
4941004 
495
-	if (!family_data) {
496
-		ret = -ENODEV;
1005
+/* Safe version of reset_select_slave - avoid using the one in w_io.c */
1006
+static int reset_select_slave(struct w1_slave *sl)
1007
+{
1008
+	u8 match[9] = { W1_MATCH_ROM, };
1009
+	u64 rn = le64_to_cpu(*((u64 *)&sl->reg_num));
1010
+
1011
+	if (w1_reset_bus(sl->master))
1012
+		return -ENODEV;
1013
+
1014
+	memcpy(&match[1], &rn, 8);
1015
+	w1_write_block(sl->master, match, 9);
1016
+
1017
+	return 0;
1018
+}
1019
+
1020
+/**
1021
+ * w1_poll_completion - Poll for operation completion, with timeout
1022
+ * @dev_master: the device master of the bus
1023
+ * @tout_ms: timeout in milliseconds
1024
+ *
1025
+ * The device is answering 0's while an operation is in progress and 1's after it completes
1026
+ * Timeout may happen if the previous command was not recognised due to a line noise
1027
+ *
1028
+ * Return: 0 - OK, negative error - timeout
1029
+ */
1030
+static int w1_poll_completion(struct w1_master *dev_master, int tout_ms)
1031
+{
1032
+	int i;
1033
+
1034
+	for (i = 0; i < tout_ms/W1_POLL_PERIOD; i++) {
1035
+		/* Delay is before poll, for device to recognize a command */
1036
+		msleep(W1_POLL_PERIOD);
1037
+
1038
+		/* Compare all 8 bits to mitigate a noise on the bus */
1039
+		if (w1_read_8(dev_master) == 0xFF)
1040
+			break;
1041
+	}
1042
+	if (i == tout_ms/W1_POLL_PERIOD)
1043
+		return -EIO;
1044
+
1045
+	return 0;
1046
+}
1047
+
1048
+static int convert_t(struct w1_slave *sl, struct therm_info *info)
1049
+{
1050
+	struct w1_master *dev_master = sl->master;
1051
+	int max_trying = W1_THERM_MAX_TRY;
1052
+	int t_conv;
1053
+	int ret = -ENODEV;
1054
+	bool strong_pullup;
1055
+
1056
+	if (!sl->family_data)
4971057 		goto error;
1058
+
1059
+	strong_pullup = (w1_strong_pullup == 2 ||
1060
+					(!SLAVE_POWERMODE(sl) &&
1061
+					w1_strong_pullup));
1062
+
1063
+	if (strong_pullup && SLAVE_FEATURES(sl) & W1_THERM_POLL_COMPLETION) {
1064
+		dev_warn(&sl->dev,
1065
+			"%s: Disabling W1_THERM_POLL_COMPLETION in parasite power mode.\n",
1066
+			__func__);
1067
+		SLAVE_FEATURES(sl) &= ~W1_THERM_POLL_COMPLETION;
4981068 	}
4991069 
500
-	/* prevent the slave from going away in sleep */
501
-	atomic_inc(THERM_REFCNT(family_data));
502
-
503
-	ret = mutex_lock_interruptible(&dev->bus_mutex);
504
-	if (ret != 0)
505
-		goto dec_refcnt;
1070
+	/* get conversion duration device and id dependent */
1071
+	t_conv = conversion_time(sl);
5061072 
5071073 	memset(info->rom, 0, sizeof(info->rom));
5081074 
509
-	while (max_trying--) {
1075
+	/* prevent the slave from going away in sleep */
1076
+	atomic_inc(THERM_REFCNT(sl->family_data));
1077
+
1078
+	if (!bus_mutex_lock(&dev_master->bus_mutex)) {
1079
+		ret = -EAGAIN;	/* Didn't acquire the mutex */
1080
+		goto dec_refcnt;
1081
+	}
1082
+
1083
+	while (max_trying-- && ret) { /* ret should be 0 */
5101084 
5111085 		info->verdict = 0;
5121086 		info->crc = 0;
513
-
514
-		if (!w1_reset_select_slave(sl)) {
515
-			int count = 0;
516
-			unsigned int tm = 750;
1087
+		/* safe version to select slave */
1088
+		if (!reset_select_slave(sl)) {
5171089 			unsigned long sleep_rem;
5181090 
519
-			w1_write_8(dev, W1_READ_PSUPPLY);
520
-			external_power = w1_read_8(dev);
521
-
522
-			if (w1_reset_select_slave(sl))
523
-				continue;
524
-
5251091 			/* 750ms strong pullup (or delay) after the convert */
526
-			if (w1_strong_pullup == 2 ||
527
-					(!external_power && w1_strong_pullup))
528
-				w1_next_pullup(dev, tm);
1092
+			if (strong_pullup)
1093
+				w1_next_pullup(dev_master, t_conv);
5291094 
530
-			w1_write_8(dev, W1_CONVERT_TEMP);
1095
+			w1_write_8(dev_master, W1_CONVERT_TEMP);
5311096 
532
-			if (external_power) {
533
-				mutex_unlock(&dev->bus_mutex);
534
-
535
-				sleep_rem = msleep_interruptible(tm);
1097
+			if (strong_pullup) { /*some device need pullup */
1098
+				sleep_rem = msleep_interruptible(t_conv);
5361099 				if (sleep_rem != 0) {
5371100 					ret = -EINTR;
538
-					goto dec_refcnt;
1101
+					goto mt_unlock;
5391102 				}
1103
+				mutex_unlock(&dev_master->bus_mutex);
1104
+			} else { /*no device need pullup */
1105
+				if (SLAVE_FEATURES(sl) & W1_THERM_POLL_COMPLETION) {
1106
+					ret = w1_poll_completion(dev_master, W1_POLL_CONVERT_TEMP);
1107
+					if (ret) {
1108
+						dev_dbg(&sl->dev, "%s: Timeout\n", __func__);
1109
+						goto mt_unlock;
1110
+					}
1111
+					mutex_unlock(&dev_master->bus_mutex);
1112
+				} else {
1113
+					/* Fixed delay */
1114
+					mutex_unlock(&dev_master->bus_mutex);
1115
+					sleep_rem = msleep_interruptible(t_conv);
1116
+					if (sleep_rem != 0) {
1117
+						ret = -EINTR;
1118
+						goto dec_refcnt;
1119
+					}
1120
+				}
1121
+			}
1122
+			ret = read_scratchpad(sl, info);
5401123 
541
-				ret = mutex_lock_interruptible(&dev->bus_mutex);
542
-				if (ret != 0)
543
-					goto dec_refcnt;
544
-			} else if (!w1_strong_pullup) {
545
-				sleep_rem = msleep_interruptible(tm);
1124
+			/* If enabled, check for conversion success */
1125
+			if ((SLAVE_FEATURES(sl) & W1_THERM_CHECK_RESULT) &&
1126
+				(info->rom[6] == 0xC) &&
1127
+				((info->rom[1] == 0x5 && info->rom[0] == 0x50) ||
1128
+				(info->rom[1] == 0x7 && info->rom[0] == 0xFF))
1129
+			) {
1130
+				/* Invalid reading (scratchpad byte 6 = 0xC)
1131
+				 * due to insufficient conversion time
1132
+				 * or power failure.
1133
+				 */
1134
+				ret = -EIO;
1135
+			}
1136
+
1137
+			goto dec_refcnt;
1138
+		}
1139
+
1140
+	}
1141
+
1142
+mt_unlock:
1143
+	mutex_unlock(&dev_master->bus_mutex);
1144
+dec_refcnt:
1145
+	atomic_dec(THERM_REFCNT(sl->family_data));
1146
+error:
1147
+	return ret;
1148
+}
1149
+
1150
+static int conv_time_measure(struct w1_slave *sl, int *conv_time)
1151
+{
1152
+	struct therm_info inf,
1153
+		*info = &inf;
1154
+	struct w1_master *dev_master = sl->master;
1155
+	int max_trying = W1_THERM_MAX_TRY;
1156
+	int ret = -ENODEV;
1157
+	bool strong_pullup;
1158
+
1159
+	if (!sl->family_data)
1160
+		goto error;
1161
+
1162
+	strong_pullup = (w1_strong_pullup == 2 ||
1163
+		(!SLAVE_POWERMODE(sl) &&
1164
+		w1_strong_pullup));
1165
+
1166
+	if (strong_pullup) {
1167
+		pr_info("%s: Measure with strong_pullup is not supported.\n", __func__);
1168
+		return -EINVAL;
1169
+	}
1170
+
1171
+	memset(info->rom, 0, sizeof(info->rom));
1172
+
1173
+	/* prevent the slave from going away in sleep */
1174
+	atomic_inc(THERM_REFCNT(sl->family_data));
1175
+
1176
+	if (!bus_mutex_lock(&dev_master->bus_mutex)) {
1177
+		ret = -EAGAIN;	/* Didn't acquire the mutex */
1178
+		goto dec_refcnt;
1179
+	}
1180
+
1181
+	while (max_trying-- && ret) { /* ret should be 0 */
1182
+		info->verdict = 0;
1183
+		info->crc = 0;
1184
+		/* safe version to select slave */
1185
+		if (!reset_select_slave(sl)) {
1186
+			int j_start, j_end;
1187
+
1188
+			/*no device need pullup */
1189
+			w1_write_8(dev_master, W1_CONVERT_TEMP);
1190
+
1191
+			j_start = jiffies;
1192
+			ret = w1_poll_completion(dev_master, W1_POLL_CONVERT_TEMP);
1193
+			if (ret) {
1194
+				dev_dbg(&sl->dev, "%s: Timeout\n", __func__);
1195
+				goto mt_unlock;
1196
+			}
1197
+			j_end = jiffies;
1198
+			/* 1.2x increase for variation and changes over temperature range */
1199
+			*conv_time = jiffies_to_msecs(j_end-j_start)*12/10;
1200
+			pr_debug("W1 Measure complete, conv_time = %d, HZ=%d.\n",
1201
+				*conv_time, HZ);
1202
+			if (*conv_time <= CONV_TIME_MEASURE) {
1203
+				ret = -EIO;
1204
+				goto mt_unlock;
1205
+			}
1206
+			mutex_unlock(&dev_master->bus_mutex);
1207
+			ret = read_scratchpad(sl, info);
1208
+			goto dec_refcnt;
1209
+		}
1210
+
1211
+	}
1212
+mt_unlock:
1213
+	mutex_unlock(&dev_master->bus_mutex);
1214
+dec_refcnt:
1215
+	atomic_dec(THERM_REFCNT(sl->family_data));
1216
+error:
1217
+	return ret;
1218
+}
1219
+
1220
+static int read_scratchpad(struct w1_slave *sl, struct therm_info *info)
1221
+{
1222
+	struct w1_master *dev_master = sl->master;
1223
+	int max_trying = W1_THERM_MAX_TRY;
1224
+	int ret = -ENODEV;
1225
+
1226
+	info->verdict = 0;
1227
+
1228
+	if (!sl->family_data)
1229
+		goto error;
1230
+
1231
+	memset(info->rom, 0, sizeof(info->rom));
1232
+
1233
+	/* prevent the slave from going away in sleep */
1234
+	atomic_inc(THERM_REFCNT(sl->family_data));
1235
+
1236
+	if (!bus_mutex_lock(&dev_master->bus_mutex)) {
1237
+		ret = -EAGAIN;	/* Didn't acquire the mutex */
1238
+		goto dec_refcnt;
1239
+	}
1240
+
1241
+	while (max_trying-- && ret) { /* ret should be 0 */
1242
+		/* safe version to select slave */
1243
+		if (!reset_select_slave(sl)) {
1244
+			u8 nb_bytes_read;
1245
+
1246
+			w1_write_8(dev_master, W1_READ_SCRATCHPAD);
1247
+
1248
+			nb_bytes_read = w1_read_block(dev_master, info->rom, 9);
1249
+			if (nb_bytes_read != 9) {
1250
+				dev_warn(&sl->dev,
1251
+					"w1_read_block(): returned %u instead of 9.\n",
1252
+					nb_bytes_read);
1253
+				ret = -EIO;
1254
+			}
1255
+
1256
+			info->crc = w1_calc_crc8(info->rom, 8);
1257
+
1258
+			if (info->rom[8] == info->crc) {
1259
+				info->verdict = 1;
1260
+				ret = 0;
1261
+			} else
1262
+				ret = -EIO; /* CRC not checked */
1263
+		}
1264
+
1265
+	}
1266
+	mutex_unlock(&dev_master->bus_mutex);
1267
+
1268
+dec_refcnt:
1269
+	atomic_dec(THERM_REFCNT(sl->family_data));
1270
+error:
1271
+	return ret;
1272
+}
1273
+
1274
+static int write_scratchpad(struct w1_slave *sl, const u8 *data, u8 nb_bytes)
1275
+{
1276
+	struct w1_master *dev_master = sl->master;
1277
+	int max_trying = W1_THERM_MAX_TRY;
1278
+	int ret = -ENODEV;
1279
+
1280
+	if (!sl->family_data)
1281
+		goto error;
1282
+
1283
+	/* prevent the slave from going away in sleep */
1284
+	atomic_inc(THERM_REFCNT(sl->family_data));
1285
+
1286
+	if (!bus_mutex_lock(&dev_master->bus_mutex)) {
1287
+		ret = -EAGAIN;	/* Didn't acquire the mutex */
1288
+		goto dec_refcnt;
1289
+	}
1290
+
1291
+	while (max_trying-- && ret) { /* ret should be 0 */
1292
+		/* safe version to select slave */
1293
+		if (!reset_select_slave(sl)) {
1294
+			w1_write_8(dev_master, W1_WRITE_SCRATCHPAD);
1295
+			w1_write_block(dev_master, data, nb_bytes);
1296
+			ret = 0;
1297
+		}
1298
+	}
1299
+	mutex_unlock(&dev_master->bus_mutex);
1300
+
1301
+dec_refcnt:
1302
+	atomic_dec(THERM_REFCNT(sl->family_data));
1303
+error:
1304
+	return ret;
1305
+}
1306
+
1307
+static int copy_scratchpad(struct w1_slave *sl)
1308
+{
1309
+	struct w1_master *dev_master = sl->master;
1310
+	int max_trying = W1_THERM_MAX_TRY;
1311
+	int t_write, ret = -ENODEV;
1312
+	bool strong_pullup;
1313
+
1314
+	if (!sl->family_data)
1315
+		goto error;
1316
+
1317
+	t_write = W1_THERM_EEPROM_WRITE_DELAY;
1318
+	strong_pullup = (w1_strong_pullup == 2 ||
1319
+					(!SLAVE_POWERMODE(sl) &&
1320
+					w1_strong_pullup));
1321
+
1322
+	/* prevent the slave from going away in sleep */
1323
+	atomic_inc(THERM_REFCNT(sl->family_data));
1324
+
1325
+	if (!bus_mutex_lock(&dev_master->bus_mutex)) {
1326
+		ret = -EAGAIN;	/* Didn't acquire the mutex */
1327
+		goto dec_refcnt;
1328
+	}
1329
+
1330
+	while (max_trying-- && ret) { /* ret should be 0 */
1331
+		/* safe version to select slave */
1332
+		if (!reset_select_slave(sl)) {
1333
+			unsigned long sleep_rem;
1334
+
1335
+			/* 10ms strong pullup (or delay) after the convert */
1336
+			if (strong_pullup)
1337
+				w1_next_pullup(dev_master, t_write);
1338
+
1339
+			w1_write_8(dev_master, W1_COPY_SCRATCHPAD);
1340
+
1341
+			if (strong_pullup) {
1342
+				sleep_rem = msleep_interruptible(t_write);
5461343 				if (sleep_rem != 0) {
5471344 					ret = -EINTR;
5481345 					goto mt_unlock;
5491346 				}
5501347 			}
551
-
552
-			if (!w1_reset_select_slave(sl)) {
553
-
554
-				w1_write_8(dev, W1_READ_SCRATCHPAD);
555
-				count = w1_read_block(dev, info->rom, 9);
556
-				if (count != 9) {
557
-					dev_warn(device, "w1_read_block() "
558
-						"returned %u instead of 9.\n",
559
-						count);
560
-				}
561
-
562
-				info->crc = w1_calc_crc8(info->rom, 8);
563
-
564
-				if (info->rom[8] == info->crc)
565
-					info->verdict = 1;
566
-			}
1348
+			ret = 0;
5671349 		}
5681350 
569
-		if (info->verdict)
570
-			break;
5711351 	}
5721352 
5731353 mt_unlock:
574
-	mutex_unlock(&dev->bus_mutex);
1354
+	mutex_unlock(&dev_master->bus_mutex);
5751355 dec_refcnt:
576
-	atomic_dec(THERM_REFCNT(family_data));
1356
+	atomic_dec(THERM_REFCNT(sl->family_data));
5771357 error:
5781358 	return ret;
5791359 }
1360
+
1361
+static int recall_eeprom(struct w1_slave *sl)
1362
+{
1363
+	struct w1_master *dev_master = sl->master;
1364
+	int max_trying = W1_THERM_MAX_TRY;
1365
+	int ret = -ENODEV;
1366
+
1367
+	if (!sl->family_data)
1368
+		goto error;
1369
+
1370
+	/* prevent the slave from going away in sleep */
1371
+	atomic_inc(THERM_REFCNT(sl->family_data));
1372
+
1373
+	if (!bus_mutex_lock(&dev_master->bus_mutex)) {
1374
+		ret = -EAGAIN;	/* Didn't acquire the mutex */
1375
+		goto dec_refcnt;
1376
+	}
1377
+
1378
+	while (max_trying-- && ret) { /* ret should be 0 */
1379
+		/* safe version to select slave */
1380
+		if (!reset_select_slave(sl)) {
1381
+
1382
+			w1_write_8(dev_master, W1_RECALL_EEPROM);
1383
+			ret = w1_poll_completion(dev_master, W1_POLL_RECALL_EEPROM);
1384
+		}
1385
+
1386
+	}
1387
+
1388
+	mutex_unlock(&dev_master->bus_mutex);
1389
+
1390
+dec_refcnt:
1391
+	atomic_dec(THERM_REFCNT(sl->family_data));
1392
+error:
1393
+	return ret;
1394
+}
1395
+
1396
+static int read_powermode(struct w1_slave *sl)
1397
+{
1398
+	struct w1_master *dev_master = sl->master;
1399
+	int max_trying = W1_THERM_MAX_TRY;
1400
+	int  ret = -ENODEV;
1401
+
1402
+	if (!sl->family_data)
1403
+		goto error;
1404
+
1405
+	/* prevent the slave from going away in sleep */
1406
+	atomic_inc(THERM_REFCNT(sl->family_data));
1407
+
1408
+	if (!bus_mutex_lock(&dev_master->bus_mutex)) {
1409
+		ret = -EAGAIN;	/* Didn't acquire the mutex */
1410
+		goto dec_refcnt;
1411
+	}
1412
+
1413
+	while ((max_trying--) && (ret < 0)) {
1414
+		/* safe version to select slave */
1415
+		if (!reset_select_slave(sl)) {
1416
+			w1_write_8(dev_master, W1_READ_PSUPPLY);
1417
+			/*
1418
+			 * Emit a read time slot and read only one bit,
1419
+			 * 1 is externally powered,
1420
+			 * 0 is parasite powered
1421
+			 */
1422
+			ret = w1_touch_bit(dev_master, 1);
1423
+			/* ret should be either 1 either 0 */
1424
+		}
1425
+	}
1426
+	mutex_unlock(&dev_master->bus_mutex);
1427
+
1428
+dec_refcnt:
1429
+	atomic_dec(THERM_REFCNT(sl->family_data));
1430
+error:
1431
+	return ret;
1432
+}
1433
+
1434
+static int trigger_bulk_read(struct w1_master *dev_master)
1435
+{
1436
+	struct w1_slave *sl = NULL; /* used to iterate through slaves */
1437
+	int max_trying = W1_THERM_MAX_TRY;
1438
+	int t_conv = 0;
1439
+	int ret = -ENODEV;
1440
+	bool strong_pullup = false;
1441
+
1442
+	/*
1443
+	 * Check whether there are parasite powered device on the bus,
1444
+	 * and compute duration of conversion for these devices
1445
+	 * so we can apply a strong pullup if required
1446
+	 */
1447
+	list_for_each_entry(sl, &dev_master->slist, w1_slave_entry) {
1448
+		if (!sl->family_data)
1449
+			goto error;
1450
+		if (bulk_read_support(sl)) {
1451
+			int t_cur = conversion_time(sl);
1452
+
1453
+			t_conv = t_cur > t_conv ? t_cur : t_conv;
1454
+			strong_pullup = strong_pullup ||
1455
+					(w1_strong_pullup == 2 ||
1456
+					(!SLAVE_POWERMODE(sl) &&
1457
+					w1_strong_pullup));
1458
+		}
1459
+	}
1460
+
1461
+	/*
1462
+	 * t_conv is the max conversion time required on the bus
1463
+	 * If its 0, no device support the bulk read feature
1464
+	 */
1465
+	if (!t_conv)
1466
+		goto error;
1467
+
1468
+	if (!bus_mutex_lock(&dev_master->bus_mutex)) {
1469
+		ret = -EAGAIN;	/* Didn't acquire the mutex */
1470
+		goto error;
1471
+	}
1472
+
1473
+	while ((max_trying--) && (ret < 0)) { /* ret should be either 0 */
1474
+
1475
+		if (!w1_reset_bus(dev_master)) {	/* Just reset the bus */
1476
+			unsigned long sleep_rem;
1477
+
1478
+			w1_write_8(dev_master, W1_SKIP_ROM);
1479
+
1480
+			if (strong_pullup)	/* Apply pullup if required */
1481
+				w1_next_pullup(dev_master, t_conv);
1482
+
1483
+			w1_write_8(dev_master, W1_CONVERT_TEMP);
1484
+
1485
+			/* set a flag to instruct that converT pending */
1486
+			list_for_each_entry(sl,
1487
+				&dev_master->slist, w1_slave_entry) {
1488
+				if (bulk_read_support(sl))
1489
+					SLAVE_CONVERT_TRIGGERED(sl) = -1;
1490
+			}
1491
+
1492
+			if (strong_pullup) { /* some device need pullup */
1493
+				sleep_rem = msleep_interruptible(t_conv);
1494
+				if (sleep_rem != 0) {
1495
+					ret = -EINTR;
1496
+					goto mt_unlock;
1497
+				}
1498
+				mutex_unlock(&dev_master->bus_mutex);
1499
+			} else {
1500
+				mutex_unlock(&dev_master->bus_mutex);
1501
+				sleep_rem = msleep_interruptible(t_conv);
1502
+				if (sleep_rem != 0) {
1503
+					ret = -EINTR;
1504
+					goto set_flag;
1505
+				}
1506
+			}
1507
+			ret = 0;
1508
+			goto set_flag;
1509
+		}
1510
+	}
1511
+
1512
+mt_unlock:
1513
+	mutex_unlock(&dev_master->bus_mutex);
1514
+set_flag:
1515
+	/* set a flag to register convsersion is done */
1516
+	list_for_each_entry(sl, &dev_master->slist, w1_slave_entry) {
1517
+		if (bulk_read_support(sl))
1518
+			SLAVE_CONVERT_TRIGGERED(sl) = 1;
1519
+	}
1520
+error:
1521
+	return ret;
1522
+}
1523
+
1524
+/* Sysfs Interface definition */
5801525 
5811526 static ssize_t w1_slave_show(struct device *device,
5821527 			     struct device_attribute *attr, char *buf)
....@@ -586,29 +1531,484 @@
5861531 	u8 *family_data = sl->family_data;
5871532 	int ret, i;
5881533 	ssize_t c = PAGE_SIZE;
589
-	u8 fid = sl->family->fid;
5901534 
591
-	ret = read_therm(device, sl, &info);
592
-	if (ret)
593
-		return ret;
1535
+	if (bulk_read_support(sl)) {
1536
+		if (SLAVE_CONVERT_TRIGGERED(sl) < 0) {
1537
+			dev_dbg(device,
1538
+				"%s: Conversion in progress, retry later\n",
1539
+				__func__);
1540
+			return 0;
1541
+		} else if (SLAVE_CONVERT_TRIGGERED(sl) > 0) {
1542
+			/* A bulk read has been issued, read the device RAM */
1543
+			ret = read_scratchpad(sl, &info);
1544
+			SLAVE_CONVERT_TRIGGERED(sl) = 0;
1545
+		} else
1546
+			ret = convert_t(sl, &info);
1547
+	} else
1548
+		ret = convert_t(sl, &info);
1549
+
1550
+	if (ret < 0) {
1551
+		dev_dbg(device,
1552
+			"%s: Temperature data may be corrupted. err=%d\n",
1553
+			__func__, ret);
1554
+		return 0;
1555
+	}
5941556 
5951557 	for (i = 0; i < 9; ++i)
5961558 		c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", info.rom[i]);
5971559 	c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
5981560 		      info.crc, (info.verdict) ? "YES" : "NO");
1561
+
5991562 	if (info.verdict)
6001563 		memcpy(family_data, info.rom, sizeof(info.rom));
6011564 	else
602
-		dev_warn(device, "Read failed CRC check\n");
1565
+		dev_warn(device, "%s:Read failed CRC check\n", __func__);
6031566 
6041567 	for (i = 0; i < 9; ++i)
6051568 		c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ",
6061569 			      ((u8 *)family_data)[i]);
6071570 
6081571 	c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
609
-			w1_convert_temp(info.rom, fid));
1572
+			temperature_from_RAM(sl, info.rom));
1573
+
6101574 	ret = PAGE_SIZE - c;
6111575 	return ret;
1576
+}
1577
+
1578
+static ssize_t w1_slave_store(struct device *device,
1579
+			      struct device_attribute *attr, const char *buf,
1580
+			      size_t size)
1581
+{
1582
+	int val, ret = 0;
1583
+	struct w1_slave *sl = dev_to_w1_slave(device);
1584
+
1585
+	ret = kstrtoint(buf, 10, &val); /* converting user entry to int */
1586
+
1587
+	if (ret) {	/* conversion error */
1588
+		dev_info(device,
1589
+			"%s: conversion error. err= %d\n", __func__, ret);
1590
+		return size;	/* return size to avoid call back again */
1591
+	}
1592
+
1593
+	if ((!sl->family_data) || (!SLAVE_SPECIFIC_FUNC(sl))) {
1594
+		dev_info(device,
1595
+			"%s: Device not supported by the driver\n", __func__);
1596
+		return size;  /* No device family */
1597
+	}
1598
+
1599
+	if (val == 0)	/* val=0 : trigger a EEPROM save */
1600
+		ret = copy_scratchpad(sl);
1601
+	else {
1602
+		if (SLAVE_SPECIFIC_FUNC(sl)->set_resolution)
1603
+			ret = SLAVE_SPECIFIC_FUNC(sl)->set_resolution(sl, val);
1604
+	}
1605
+
1606
+	if (ret) {
1607
+		dev_warn(device, "%s: Set resolution - error %d\n", __func__, ret);
1608
+		/* Propagate error to userspace */
1609
+		return ret;
1610
+	}
1611
+	SLAVE_RESOLUTION(sl) = val;
1612
+	/* Reset the conversion time to default - it depends on resolution */
1613
+	SLAVE_CONV_TIME_OVERRIDE(sl) = CONV_TIME_DEFAULT;
1614
+
1615
+	return size; /* always return size to avoid infinite calling */
1616
+}
1617
+
1618
+static ssize_t temperature_show(struct device *device,
1619
+	struct device_attribute *attr, char *buf)
1620
+{
1621
+	struct w1_slave *sl = dev_to_w1_slave(device);
1622
+	struct therm_info info;
1623
+	int ret = 0;
1624
+
1625
+	if ((!sl->family_data) || (!SLAVE_SPECIFIC_FUNC(sl))) {
1626
+		dev_info(device,
1627
+			"%s: Device not supported by the driver\n", __func__);
1628
+		return 0;  /* No device family */
1629
+	}
1630
+
1631
+	if (bulk_read_support(sl)) {
1632
+		if (SLAVE_CONVERT_TRIGGERED(sl) < 0) {
1633
+			dev_dbg(device,
1634
+				"%s: Conversion in progress, retry later\n",
1635
+				__func__);
1636
+			return 0;
1637
+		} else if (SLAVE_CONVERT_TRIGGERED(sl) > 0) {
1638
+			/* A bulk read has been issued, read the device RAM */
1639
+			ret = read_scratchpad(sl, &info);
1640
+			SLAVE_CONVERT_TRIGGERED(sl) = 0;
1641
+		} else
1642
+			ret = convert_t(sl, &info);
1643
+	} else
1644
+		ret = convert_t(sl, &info);
1645
+
1646
+	if (ret < 0) {
1647
+		dev_dbg(device,
1648
+			"%s: Temperature data may be corrupted. err=%d\n",
1649
+			__func__, ret);
1650
+		return 0;
1651
+	}
1652
+
1653
+	return sprintf(buf, "%d\n", temperature_from_RAM(sl, info.rom));
1654
+}
1655
+
1656
+static ssize_t ext_power_show(struct device *device,
1657
+	struct device_attribute *attr, char *buf)
1658
+{
1659
+	struct w1_slave *sl = dev_to_w1_slave(device);
1660
+
1661
+	if (!sl->family_data) {
1662
+		dev_info(device,
1663
+			"%s: Device not supported by the driver\n", __func__);
1664
+		return 0;  /* No device family */
1665
+	}
1666
+
1667
+	/* Getting the power mode of the device {external, parasite} */
1668
+	SLAVE_POWERMODE(sl) = read_powermode(sl);
1669
+
1670
+	if (SLAVE_POWERMODE(sl) < 0) {
1671
+		dev_dbg(device,
1672
+			"%s: Power_mode may be corrupted. err=%d\n",
1673
+			__func__, SLAVE_POWERMODE(sl));
1674
+	}
1675
+	return sprintf(buf, "%d\n", SLAVE_POWERMODE(sl));
1676
+}
1677
+
1678
+static ssize_t resolution_show(struct device *device,
1679
+	struct device_attribute *attr, char *buf)
1680
+{
1681
+	struct w1_slave *sl = dev_to_w1_slave(device);
1682
+
1683
+	if ((!sl->family_data) || (!SLAVE_SPECIFIC_FUNC(sl))) {
1684
+		dev_info(device,
1685
+			"%s: Device not supported by the driver\n", __func__);
1686
+		return 0;  /* No device family */
1687
+	}
1688
+
1689
+	/* get the correct function depending on the device */
1690
+	SLAVE_RESOLUTION(sl) = SLAVE_SPECIFIC_FUNC(sl)->get_resolution(sl);
1691
+	if (SLAVE_RESOLUTION(sl) < 0) {
1692
+		dev_dbg(device,
1693
+			"%s: Resolution may be corrupted. err=%d\n",
1694
+			__func__, SLAVE_RESOLUTION(sl));
1695
+	}
1696
+
1697
+	return sprintf(buf, "%d\n", SLAVE_RESOLUTION(sl));
1698
+}
1699
+
1700
+static ssize_t resolution_store(struct device *device,
1701
+	struct device_attribute *attr, const char *buf, size_t size)
1702
+{
1703
+	struct w1_slave *sl = dev_to_w1_slave(device);
1704
+	int val;
1705
+	int ret = 0;
1706
+
1707
+	ret = kstrtoint(buf, 10, &val); /* converting user entry to int */
1708
+
1709
+	if (ret) {	/* conversion error */
1710
+		dev_info(device,
1711
+			"%s: conversion error. err= %d\n", __func__, ret);
1712
+		return size;	/* return size to avoid call back again */
1713
+	}
1714
+
1715
+	if ((!sl->family_data) || (!SLAVE_SPECIFIC_FUNC(sl))) {
1716
+		dev_info(device,
1717
+			"%s: Device not supported by the driver\n", __func__);
1718
+		return size;  /* No device family */
1719
+	}
1720
+
1721
+	/*
1722
+	 * Don't deal with the val enterd by user,
1723
+	 * only device knows what is correct or not
1724
+	 */
1725
+
1726
+	/* get the correct function depending on the device */
1727
+	ret = SLAVE_SPECIFIC_FUNC(sl)->set_resolution(sl, val);
1728
+
1729
+	if (ret)
1730
+		return ret;
1731
+
1732
+	SLAVE_RESOLUTION(sl) = val;
1733
+	/* Reset the conversion time to default because it depends on resolution */
1734
+	SLAVE_CONV_TIME_OVERRIDE(sl) = CONV_TIME_DEFAULT;
1735
+
1736
+	return size;
1737
+}
1738
+
1739
+static ssize_t eeprom_store(struct device *device,
1740
+	struct device_attribute *attr, const char *buf, size_t size)
1741
+{
1742
+	struct w1_slave *sl = dev_to_w1_slave(device);
1743
+	int ret = -EINVAL; /* Invalid argument */
1744
+
1745
+	if (size == sizeof(EEPROM_CMD_WRITE)) {
1746
+		if (!strncmp(buf, EEPROM_CMD_WRITE, sizeof(EEPROM_CMD_WRITE)-1))
1747
+			ret = copy_scratchpad(sl);
1748
+	} else if (size == sizeof(EEPROM_CMD_READ)) {
1749
+		if (!strncmp(buf, EEPROM_CMD_READ, sizeof(EEPROM_CMD_READ)-1))
1750
+			ret = recall_eeprom(sl);
1751
+	}
1752
+
1753
+	if (ret)
1754
+		dev_info(device, "%s: error in process %d\n", __func__, ret);
1755
+
1756
+	return size;
1757
+}
1758
+
1759
+static ssize_t alarms_show(struct device *device,
1760
+	struct device_attribute *attr, char *buf)
1761
+{
1762
+	struct w1_slave *sl = dev_to_w1_slave(device);
1763
+	int ret;
1764
+	s8 th = 0, tl = 0;
1765
+	struct therm_info scratchpad;
1766
+
1767
+	ret = read_scratchpad(sl, &scratchpad);
1768
+
1769
+	if (!ret)	{
1770
+		th = scratchpad.rom[2]; /* TH is byte 2 */
1771
+		tl = scratchpad.rom[3]; /* TL is byte 3 */
1772
+	} else {
1773
+		dev_info(device,
1774
+			"%s: error reading alarms register %d\n",
1775
+			__func__, ret);
1776
+	}
1777
+
1778
+	return sprintf(buf, "%hd %hd\n", tl, th);
1779
+}
1780
+
1781
+static ssize_t alarms_store(struct device *device,
1782
+	struct device_attribute *attr, const char *buf, size_t size)
1783
+{
1784
+	struct w1_slave *sl = dev_to_w1_slave(device);
1785
+	struct therm_info info;
1786
+	u8 new_config_register[3];	/* array of data to be written */
1787
+	int temp, ret;
1788
+	char *token = NULL;
1789
+	s8 tl, th, tt;	/* 1 byte per value + temp ring order */
1790
+	char *p_args, *orig;
1791
+
1792
+	p_args = orig = kmalloc(size, GFP_KERNEL);
1793
+	/* Safe string copys as buf is const */
1794
+	if (!p_args) {
1795
+		dev_warn(device,
1796
+			"%s: error unable to allocate memory %d\n",
1797
+			__func__, -ENOMEM);
1798
+		return size;
1799
+	}
1800
+	strcpy(p_args, buf);
1801
+
1802
+	/* Split string using space char */
1803
+	token = strsep(&p_args, " ");
1804
+
1805
+	if (!token)	{
1806
+		dev_info(device,
1807
+			"%s: error parsing args %d\n", __func__, -EINVAL);
1808
+		goto free_m;
1809
+	}
1810
+
1811
+	/* Convert 1st entry to int */
1812
+	ret = kstrtoint (token, 10, &temp);
1813
+	if (ret) {
1814
+		dev_info(device,
1815
+			"%s: error parsing args %d\n", __func__, ret);
1816
+		goto free_m;
1817
+	}
1818
+
1819
+	tl = int_to_short(temp);
1820
+
1821
+	/* Split string using space char */
1822
+	token = strsep(&p_args, " ");
1823
+	if (!token)	{
1824
+		dev_info(device,
1825
+			"%s: error parsing args %d\n", __func__, -EINVAL);
1826
+		goto free_m;
1827
+	}
1828
+	/* Convert 2nd entry to int */
1829
+	ret = kstrtoint (token, 10, &temp);
1830
+	if (ret) {
1831
+		dev_info(device,
1832
+			"%s: error parsing args %d\n", __func__, ret);
1833
+		goto free_m;
1834
+	}
1835
+
1836
+	/* Prepare to cast to short by eliminating out of range values */
1837
+	th = int_to_short(temp);
1838
+
1839
+	/* Reorder if required th and tl */
1840
+	if (tl > th) {
1841
+		tt = tl; tl = th; th = tt;
1842
+	}
1843
+
1844
+	/*
1845
+	 * Read the scratchpad to change only the required bits
1846
+	 * (th : byte 2 - tl: byte 3)
1847
+	 */
1848
+	ret = read_scratchpad(sl, &info);
1849
+	if (!ret) {
1850
+		new_config_register[0] = th;	/* Byte 2 */
1851
+		new_config_register[1] = tl;	/* Byte 3 */
1852
+		new_config_register[2] = info.rom[4];/* Byte 4 */
1853
+	} else {
1854
+		dev_info(device,
1855
+			"%s: error reading from the slave device %d\n",
1856
+			__func__, ret);
1857
+		goto free_m;
1858
+	}
1859
+
1860
+	/* Write data in the device RAM */
1861
+	if (!SLAVE_SPECIFIC_FUNC(sl)) {
1862
+		dev_info(device,
1863
+			"%s: Device not supported by the driver %d\n",
1864
+			__func__, -ENODEV);
1865
+		goto free_m;
1866
+	}
1867
+
1868
+	ret = SLAVE_SPECIFIC_FUNC(sl)->write_data(sl, new_config_register);
1869
+	if (ret)
1870
+		dev_info(device,
1871
+			"%s: error writing to the slave device %d\n",
1872
+			__func__, ret);
1873
+
1874
+free_m:
1875
+	/* free allocated memory */
1876
+	kfree(orig);
1877
+
1878
+	return size;
1879
+}
1880
+
1881
+static ssize_t therm_bulk_read_store(struct device *device,
1882
+	struct device_attribute *attr, const char *buf, size_t size)
1883
+{
1884
+	struct w1_master *dev_master = dev_to_w1_master(device);
1885
+	int ret = -EINVAL; /* Invalid argument */
1886
+
1887
+	if (size == sizeof(BULK_TRIGGER_CMD))
1888
+		if (!strncmp(buf, BULK_TRIGGER_CMD,
1889
+				sizeof(BULK_TRIGGER_CMD)-1))
1890
+			ret = trigger_bulk_read(dev_master);
1891
+
1892
+	if (ret)
1893
+		dev_info(device,
1894
+			"%s: unable to trigger a bulk read on the bus. err=%d\n",
1895
+			__func__, ret);
1896
+
1897
+	return size;
1898
+}
1899
+
1900
+static ssize_t therm_bulk_read_show(struct device *device,
1901
+	struct device_attribute *attr, char *buf)
1902
+{
1903
+	struct w1_master *dev_master = dev_to_w1_master(device);
1904
+	struct w1_slave *sl = NULL;
1905
+	int ret = 0;
1906
+
1907
+	list_for_each_entry(sl, &dev_master->slist, w1_slave_entry) {
1908
+		if (sl->family_data) {
1909
+			if (bulk_read_support(sl)) {
1910
+				if (SLAVE_CONVERT_TRIGGERED(sl) == -1) {
1911
+					ret = -1;
1912
+					goto show_result;
1913
+				}
1914
+				if (SLAVE_CONVERT_TRIGGERED(sl) == 1)
1915
+					/* continue to check other slaves */
1916
+					ret = 1;
1917
+			}
1918
+		}
1919
+	}
1920
+show_result:
1921
+	return sprintf(buf, "%d\n", ret);
1922
+}
1923
+
1924
+static ssize_t conv_time_show(struct device *device,
1925
+	struct device_attribute *attr, char *buf)
1926
+{
1927
+	struct w1_slave *sl = dev_to_w1_slave(device);
1928
+
1929
+	if ((!sl->family_data) || (!SLAVE_SPECIFIC_FUNC(sl))) {
1930
+		dev_info(device,
1931
+			"%s: Device is not supported by the driver\n", __func__);
1932
+		return 0;  /* No device family */
1933
+	}
1934
+	return sprintf(buf, "%d\n", conversion_time(sl));
1935
+}
1936
+
1937
+static ssize_t conv_time_store(struct device *device,
1938
+	struct device_attribute *attr, const char *buf, size_t size)
1939
+{
1940
+	int val, ret = 0;
1941
+	struct w1_slave *sl = dev_to_w1_slave(device);
1942
+
1943
+	if (kstrtoint(buf, 10, &val)) /* converting user entry to int */
1944
+		return -EINVAL;
1945
+
1946
+	if (check_family_data(sl))
1947
+		return -ENODEV;
1948
+
1949
+	if (val != CONV_TIME_MEASURE) {
1950
+		if (val >= CONV_TIME_DEFAULT)
1951
+			SLAVE_CONV_TIME_OVERRIDE(sl) = val;
1952
+		else
1953
+			return -EINVAL;
1954
+
1955
+	} else {
1956
+		int conv_time;
1957
+
1958
+		ret = conv_time_measure(sl, &conv_time);
1959
+		if (ret)
1960
+			return -EIO;
1961
+		SLAVE_CONV_TIME_OVERRIDE(sl) = conv_time;
1962
+	}
1963
+	return size;
1964
+}
1965
+
1966
+static ssize_t features_show(struct device *device,
1967
+			     struct device_attribute *attr, char *buf)
1968
+{
1969
+	struct w1_slave *sl = dev_to_w1_slave(device);
1970
+
1971
+	if ((!sl->family_data) || (!SLAVE_SPECIFIC_FUNC(sl))) {
1972
+		dev_info(device,
1973
+			 "%s: Device not supported by the driver\n", __func__);
1974
+		return 0;  /* No device family */
1975
+	}
1976
+	return sprintf(buf, "%u\n", SLAVE_FEATURES(sl));
1977
+}
1978
+
1979
+static ssize_t features_store(struct device *device,
1980
+			      struct device_attribute *attr, const char *buf, size_t size)
1981
+{
1982
+	int val, ret = 0;
1983
+	bool strong_pullup;
1984
+	struct w1_slave *sl = dev_to_w1_slave(device);
1985
+
1986
+	ret = kstrtouint(buf, 10, &val); /* converting user entry to int */
1987
+	if (ret)
1988
+		return -EINVAL;  /* invalid number */
1989
+
1990
+	if ((!sl->family_data) || (!SLAVE_SPECIFIC_FUNC(sl))) {
1991
+		dev_info(device, "%s: Device not supported by the driver\n", __func__);
1992
+		return -ENODEV;
1993
+	}
1994
+
1995
+	if ((val & W1_THERM_FEATURES_MASK) != val)
1996
+		return -EINVAL;
1997
+
1998
+	SLAVE_FEATURES(sl) = val;
1999
+
2000
+	strong_pullup = (w1_strong_pullup == 2 ||
2001
+			 (!SLAVE_POWERMODE(sl) &&
2002
+			  w1_strong_pullup));
2003
+
2004
+	if (strong_pullup && SLAVE_FEATURES(sl) & W1_THERM_POLL_COMPLETION) {
2005
+		dev_warn(&sl->dev,
2006
+			 "%s: W1_THERM_POLL_COMPLETION disabled in parasite power mode.\n",
2007
+			 __func__);
2008
+		SLAVE_FEATURES(sl) &= ~W1_THERM_POLL_COMPLETION;
2009
+	}
2010
+
2011
+	return size;
6122012 }
6132013 
6142014 #if IS_REACHABLE(CONFIG_HWMON)
....@@ -617,12 +2017,11 @@
6172017 {
6182018 	struct w1_slave *sl = dev_get_drvdata(device);
6192019 	struct therm_info info;
620
-	u8 fid = sl->family->fid;
6212020 	int ret;
6222021 
6232022 	switch (attr) {
6242023 	case hwmon_temp_input:
625
-		ret = read_therm(device, sl, &info);
2024
+		ret = convert_t(sl, &info);
6262025 		if (ret)
6272026 			return ret;
6282027 
....@@ -631,7 +2030,7 @@
6312030 			return ret;
6322031 		}
6332032 
634
-		*val = w1_convert_temp(info.rom, fid);
2033
+		*val = temperature_from_RAM(sl, info.rom);
6352034 		ret = 0;
6362035 		break;
6372036 	default:
....@@ -680,7 +2079,7 @@
6802079 	if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
6812080 		goto error;
6822081 
683
-	/* In case the bus fails to send 0xFF, limit*/
2082
+	/* In case the bus fails to send 0xFF, limit */
6842083 	for (i = 0; i <= 64; i++) {
6852084 		if (w1_reset_bus(sl->master))
6862085 			goto error;
....@@ -693,16 +2092,20 @@
6932092 		if (sl->reg_num.id == reg_num->id)
6942093 			seq = i;
6952094 
2095
+		if (w1_reset_bus(sl->master))
2096
+			goto error;
2097
+
2098
+		/* Put the device into chain DONE state */
2099
+		w1_write_8(sl->master, W1_MATCH_ROM);
2100
+		w1_write_block(sl->master, (u8 *)&rn, 8);
6962101 		w1_write_8(sl->master, W1_42_CHAIN);
6972102 		w1_write_8(sl->master, W1_42_CHAIN_DONE);
6982103 		w1_write_8(sl->master, W1_42_CHAIN_DONE_INV);
699
-		w1_read_block(sl->master, &ack, sizeof(ack));
7002104 
7012105 		/* check for acknowledgment */
7022106 		ack = w1_read_8(sl->master);
7032107 		if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
7042108 			goto error;
705
-
7062109 	}
7072110 
7082111 	/* Exit from CHAIN state */