blob: 9b9870ba01cd6f52ee5268b145a484b537b01083 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Evgeniy Polyakov77859252005-05-20 22:33:25 +04002 * w1_therm.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Evgeniy Polyakova8018762011-08-25 15:59:06 -07004 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
Evgeniy Polyakov77859252005-05-20 22:33:25 +04005 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
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
20 */
21
22#include <asm/types.h>
23
24#include <linux/kernel.h>
25#include <linux/module.h>
26#include <linux/moduleparam.h>
Al Virof6a57032006-10-18 01:47:25 -040027#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/device.h>
29#include <linux/types.h>
David Frieseb2c0da2014-01-15 22:29:24 -060030#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/delay.h>
Jaghathiswari Rankappagounder Natarajana97db882017-08-30 16:34:35 -070032#include <linux/hwmon.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Andrew F. Davisde0d6db2017-06-05 08:52:08 -050034#include <linux/w1.h>
35
36#define W1_THERM_DS18S20 0x10
37#define W1_THERM_DS1822 0x22
38#define W1_THERM_DS18B20 0x28
39#define W1_THERM_DS1825 0x3B
40#define W1_THERM_DS28EA00 0x42
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
David Fries6cd15972008-10-15 22:04:43 -070042/* Allow the strong pullup to be disabled, but default to enabled.
43 * If it was disabled a parasite powered device might not get the require
44 * current to do a temperature conversion. If it is enabled parasite powered
45 * devices have a better chance of getting the current required.
Michael Arndt29e55072013-02-17 20:51:20 +010046 * In case the parasite power-detection is not working (seems to be the case
47 * for some DS18S20) the strong pullup can also be forced, regardless of the
48 * power state of the devices.
49 *
50 * Summary of options:
51 * - strong_pullup = 0 Disable strong pullup completely
52 * - strong_pullup = 1 Enable automatic strong pullup detection
53 * - strong_pullup = 2 Force strong pullup
David Fries6cd15972008-10-15 22:04:43 -070054 */
55static int w1_strong_pullup = 1;
56module_param_named(strong_pullup, w1_strong_pullup, int, 0);
57
David Friesf7134ee2015-05-08 19:51:50 -050058struct w1_therm_family_data {
59 uint8_t rom[9];
60 atomic_t refcnt;
61};
62
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -070063struct therm_info {
64 u8 rom[9];
65 u8 crc;
66 u8 verdict;
67};
68
David Friesf7134ee2015-05-08 19:51:50 -050069/* return the address of the refcnt in the family data */
70#define THERM_REFCNT(family_data) \
Ben Werbowyj368451e2016-07-22 14:33:35 +100071 (&((struct w1_therm_family_data *)family_data)->refcnt)
David Friesf7134ee2015-05-08 19:51:50 -050072
David Frieseb2c0da2014-01-15 22:29:24 -060073static int w1_therm_add_slave(struct w1_slave *sl)
74{
David Friesf7134ee2015-05-08 19:51:50 -050075 sl->family_data = kzalloc(sizeof(struct w1_therm_family_data),
76 GFP_KERNEL);
David Frieseb2c0da2014-01-15 22:29:24 -060077 if (!sl->family_data)
78 return -ENOMEM;
David Friesf7134ee2015-05-08 19:51:50 -050079 atomic_set(THERM_REFCNT(sl->family_data), 1);
David Frieseb2c0da2014-01-15 22:29:24 -060080 return 0;
81}
82
83static void w1_therm_remove_slave(struct w1_slave *sl)
84{
David Friesf7134ee2015-05-08 19:51:50 -050085 int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data));
Ben Werbowyj368451e2016-07-22 14:33:35 +100086
Ben Werbowyjd4c3f972016-07-22 14:33:33 +100087 while (refcnt) {
David Friesf7134ee2015-05-08 19:51:50 -050088 msleep(1000);
89 refcnt = atomic_read(THERM_REFCNT(sl->family_data));
90 }
David Frieseb2c0da2014-01-15 22:29:24 -060091 kfree(sl->family_data);
92 sl->family_data = NULL;
93}
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -070095static ssize_t w1_slave_show(struct device *device,
David Fries347ba8a2008-10-15 22:04:51 -070096 struct device_attribute *attr, char *buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
Ben Sen0a19f122016-05-01 23:23:33 +020098static ssize_t w1_slave_store(struct device *device,
99 struct device_attribute *attr, const char *buf, size_t size);
100
Matt Campbelld9411e52015-04-28 07:44:17 -0400101static ssize_t w1_seq_show(struct device *device,
102 struct device_attribute *attr, char *buf);
103
Ben Sen0a19f122016-05-01 23:23:33 +0200104static DEVICE_ATTR_RW(w1_slave);
Matt Campbelld9411e52015-04-28 07:44:17 -0400105static DEVICE_ATTR_RO(w1_seq);
Evgeniy Polyakovd2a4ef62005-08-11 17:27:50 +0400106
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -0700107static struct attribute *w1_therm_attrs[] = {
108 &dev_attr_w1_slave.attr,
109 NULL,
110};
Matt Campbelld9411e52015-04-28 07:44:17 -0400111
112static struct attribute *w1_ds28ea00_attrs[] = {
113 &dev_attr_w1_slave.attr,
114 &dev_attr_w1_seq.attr,
115 NULL,
116};
Jaghathiswari Rankappagounder Natarajana97db882017-08-30 16:34:35 -0700117
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -0700118ATTRIBUTE_GROUPS(w1_therm);
Matt Campbelld9411e52015-04-28 07:44:17 -0400119ATTRIBUTE_GROUPS(w1_ds28ea00);
Evgeniy Polyakovd2a4ef62005-08-11 17:27:50 +0400120
Jaghathiswari Rankappagounder Natarajana97db882017-08-30 16:34:35 -0700121#if IS_REACHABLE(CONFIG_HWMON)
122static int w1_read_temp(struct device *dev, u32 attr, int channel,
123 long *val);
124
125static umode_t w1_is_visible(const void *_data, enum hwmon_sensor_types type,
126 u32 attr, int channel)
127{
128 return attr == hwmon_temp_input ? 0444 : 0;
129}
130
131static int w1_read(struct device *dev, enum hwmon_sensor_types type,
132 u32 attr, int channel, long *val)
133{
134 switch (type) {
135 case hwmon_temp:
136 return w1_read_temp(dev, attr, channel, val);
137 default:
138 return -EOPNOTSUPP;
139 }
140}
141
142static const u32 w1_temp_config[] = {
143 HWMON_T_INPUT,
144 0
145};
146
147static const struct hwmon_channel_info w1_temp = {
148 .type = hwmon_temp,
149 .config = w1_temp_config,
150};
151
152static const struct hwmon_channel_info *w1_info[] = {
153 &w1_temp,
154 NULL
155};
156
157static const struct hwmon_ops w1_hwmon_ops = {
158 .is_visible = w1_is_visible,
159 .read = w1_read,
160};
161
162static const struct hwmon_chip_info w1_chip_info = {
163 .ops = &w1_hwmon_ops,
164 .info = w1_info,
165};
166#define W1_CHIPINFO (&w1_chip_info)
167#else
168#define W1_CHIPINFO NULL
169#endif
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171static struct w1_family_ops w1_therm_fops = {
David Frieseb2c0da2014-01-15 22:29:24 -0600172 .add_slave = w1_therm_add_slave,
173 .remove_slave = w1_therm_remove_slave,
Greg Kroah-Hartmanb8a9f442013-08-21 15:44:56 -0700174 .groups = w1_therm_groups,
Jaghathiswari Rankappagounder Natarajana97db882017-08-30 16:34:35 -0700175 .chip_info = W1_CHIPINFO,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176};
177
Matt Campbelld9411e52015-04-28 07:44:17 -0400178static struct w1_family_ops w1_ds28ea00_fops = {
179 .add_slave = w1_therm_add_slave,
180 .remove_slave = w1_therm_remove_slave,
181 .groups = w1_ds28ea00_groups,
Jaghathiswari Rankappagounder Natarajana97db882017-08-30 16:34:35 -0700182 .chip_info = W1_CHIPINFO,
Matt Campbelld9411e52015-04-28 07:44:17 -0400183};
184
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400185static struct w1_family w1_therm_family_DS18S20 = {
186 .fid = W1_THERM_DS18S20,
187 .fops = &w1_therm_fops,
188};
189
190static struct w1_family w1_therm_family_DS18B20 = {
191 .fid = W1_THERM_DS18B20,
192 .fops = &w1_therm_fops,
193};
Evgeniy Polyakovd2a4ef62005-08-11 17:27:50 +0400194
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400195static struct w1_family w1_therm_family_DS1822 = {
196 .fid = W1_THERM_DS1822,
197 .fops = &w1_therm_fops,
198};
199
Christian Glindkampf7b13712011-07-26 16:08:55 -0700200static struct w1_family w1_therm_family_DS28EA00 = {
201 .fid = W1_THERM_DS28EA00,
Matt Campbelld9411e52015-04-28 07:44:17 -0400202 .fops = &w1_ds28ea00_fops,
Christian Glindkampf7b13712011-07-26 16:08:55 -0700203};
204
Raphael Assenatf3261df2012-08-16 12:56:40 -0400205static struct w1_family w1_therm_family_DS1825 = {
206 .fid = W1_THERM_DS1825,
207 .fops = &w1_therm_fops,
208};
209
Ben Werbowyjd4c3f972016-07-22 14:33:33 +1000210struct w1_therm_family_converter {
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400211 u8 broken;
212 u16 reserved;
213 struct w1_family *f;
214 int (*convert)(u8 rom[9]);
Ben Sen0a19f122016-05-01 23:23:33 +0200215 int (*precision)(struct device *device, int val);
216 int (*eeprom)(struct device *device);
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400217};
218
Ben Sen0a19f122016-05-01 23:23:33 +0200219/* write configuration to eeprom */
220static inline int w1_therm_eeprom(struct device *device);
221
222/* Set precision for conversion */
223static inline int w1_DS18B20_precision(struct device *device, int val);
224static inline int w1_DS18S20_precision(struct device *device, int val);
225
David Fries7129b122008-02-06 01:38:09 -0800226/* The return value is millidegrees Centigrade. */
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400227static inline int w1_DS18B20_convert_temp(u8 rom[9]);
228static inline int w1_DS18S20_convert_temp(u8 rom[9]);
229
230static struct w1_therm_family_converter w1_therm_families[] = {
231 {
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400232 .f = &w1_therm_family_DS18S20,
Ben Sen0a19f122016-05-01 23:23:33 +0200233 .convert = w1_DS18S20_convert_temp,
234 .precision = w1_DS18S20_precision,
235 .eeprom = w1_therm_eeprom
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400236 },
237 {
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400238 .f = &w1_therm_family_DS1822,
Ben Sen0a19f122016-05-01 23:23:33 +0200239 .convert = w1_DS18B20_convert_temp,
240 .precision = w1_DS18S20_precision,
241 .eeprom = w1_therm_eeprom
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400242 },
243 {
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400244 .f = &w1_therm_family_DS18B20,
Ben Sen0a19f122016-05-01 23:23:33 +0200245 .convert = w1_DS18B20_convert_temp,
246 .precision = w1_DS18B20_precision,
247 .eeprom = w1_therm_eeprom
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400248 },
Christian Glindkampf7b13712011-07-26 16:08:55 -0700249 {
250 .f = &w1_therm_family_DS28EA00,
Ben Sen0a19f122016-05-01 23:23:33 +0200251 .convert = w1_DS18B20_convert_temp,
252 .precision = w1_DS18S20_precision,
253 .eeprom = w1_therm_eeprom
Christian Glindkampf7b13712011-07-26 16:08:55 -0700254 },
Raphael Assenatf3261df2012-08-16 12:56:40 -0400255 {
256 .f = &w1_therm_family_DS1825,
Ben Sen0a19f122016-05-01 23:23:33 +0200257 .convert = w1_DS18B20_convert_temp,
258 .precision = w1_DS18S20_precision,
259 .eeprom = w1_therm_eeprom
Raphael Assenatf3261df2012-08-16 12:56:40 -0400260 }
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400261};
262
Ben Sen0a19f122016-05-01 23:23:33 +0200263static inline int w1_therm_eeprom(struct device *device)
264{
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;
270
271 ret = mutex_lock_interruptible(&dev->bus_mutex);
272 if (ret != 0)
273 goto post_unlock;
274
275 if (!sl->family_data) {
276 ret = -ENODEV;
277 goto pre_unlock;
278 }
279
280 /* prevent the slave from going away in sleep */
281 atomic_inc(THERM_REFCNT(family_data));
282 memset(rom, 0, sizeof(rom));
283
284 while (max_trying--) {
285 if (!w1_reset_select_slave(sl)) {
286 unsigned int tm = 10;
287 unsigned long sleep_rem;
288
289 /* check if in parasite mode */
290 w1_write_8(dev, W1_READ_PSUPPLY);
291 external_power = w1_read_8(dev);
292
293 if (w1_reset_select_slave(sl))
294 continue;
295
296 /* 10ms strong pullup/delay after the copy command */
297 if (w1_strong_pullup == 2 ||
298 (!external_power && w1_strong_pullup))
299 w1_next_pullup(dev, tm);
300
301 w1_write_8(dev, W1_COPY_SCRATCHPAD);
302
303 if (external_power) {
304 mutex_unlock(&dev->bus_mutex);
305
306 sleep_rem = msleep_interruptible(tm);
307 if (sleep_rem != 0) {
308 ret = -EINTR;
309 goto post_unlock;
310 }
311
312 ret = mutex_lock_interruptible(&dev->bus_mutex);
313 if (ret != 0)
314 goto post_unlock;
315 } else if (!w1_strong_pullup) {
316 sleep_rem = msleep_interruptible(tm);
317 if (sleep_rem != 0) {
318 ret = -EINTR;
319 goto pre_unlock;
320 }
321 }
322
323 break;
324 }
325 }
326
327pre_unlock:
328 mutex_unlock(&dev->bus_mutex);
329
330post_unlock:
331 atomic_dec(THERM_REFCNT(family_data));
332 return ret;
333}
334
335/* DS18S20 does not feature configuration register */
336static inline int w1_DS18S20_precision(struct device *device, int val)
337{
338 return 0;
339}
340
341static inline int w1_DS18B20_precision(struct device *device, int val)
342{
343 struct w1_slave *sl = dev_to_w1_slave(device);
344 struct w1_master *dev = sl->master;
345 u8 rom[9], crc;
346 int ret, max_trying = 10;
347 u8 *family_data = sl->family_data;
348 uint8_t precision_bits;
349 uint8_t mask = 0x60;
350
Ben Werbowyjd4c3f972016-07-22 14:33:33 +1000351 if (val > 12 || val < 9) {
Ben Sen0a19f122016-05-01 23:23:33 +0200352 pr_warn("Unsupported precision\n");
353 return -1;
354 }
355
356 ret = mutex_lock_interruptible(&dev->bus_mutex);
357 if (ret != 0)
358 goto post_unlock;
359
360 if (!sl->family_data) {
361 ret = -ENODEV;
362 goto pre_unlock;
363 }
364
365 /* prevent the slave from going away in sleep */
366 atomic_inc(THERM_REFCNT(family_data));
367 memset(rom, 0, sizeof(rom));
368
369 /* translate precision to bitmask (see datasheet page 9) */
370 switch (val) {
371 case 9:
372 precision_bits = 0x00;
373 break;
374 case 10:
375 precision_bits = 0x20;
376 break;
377 case 11:
378 precision_bits = 0x40;
379 break;
380 case 12:
381 default:
382 precision_bits = 0x60;
383 break;
384 }
385
386 while (max_trying--) {
387 crc = 0;
388
389 if (!w1_reset_select_slave(sl)) {
390 int count = 0;
391
392 /* read values to only alter precision bits */
393 w1_write_8(dev, W1_READ_SCRATCHPAD);
Ben Werbowyjaaf16f72016-07-22 14:33:34 +1000394 count = w1_read_block(dev, rom, 9);
395 if (count != 9)
Ben Sen0a19f122016-05-01 23:23:33 +0200396 dev_warn(device, "w1_read_block() returned %u instead of 9.\n", count);
397
398 crc = w1_calc_crc8(rom, 8);
399 if (rom[8] == crc) {
400 rom[4] = (rom[4] & ~mask) | (precision_bits & mask);
401
402 if (!w1_reset_select_slave(sl)) {
403 w1_write_8(dev, W1_WRITE_SCRATCHPAD);
404 w1_write_8(dev, rom[2]);
405 w1_write_8(dev, rom[3]);
406 w1_write_8(dev, rom[4]);
407
408 break;
409 }
410 }
411 }
412 }
413
414pre_unlock:
415 mutex_unlock(&dev->bus_mutex);
416
417post_unlock:
418 atomic_dec(THERM_REFCNT(family_data));
419 return ret;
420}
421
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400422static inline int w1_DS18B20_convert_temp(u8 rom[9])
423{
Ian Dall9a6a1ec2010-04-23 13:17:53 -0400424 s16 t = le16_to_cpup((__le16 *)rom);
Ben Werbowyj368451e2016-07-22 14:33:35 +1000425
Ian Dall9a6a1ec2010-04-23 13:17:53 -0400426 return t*1000/16;
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400427}
428
429static inline int w1_DS18S20_convert_temp(u8 rom[9])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430{
431 int t, h;
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400432
433 if (!rom[7])
434 return 0;
Evgeniy Polyakovbd529cf2005-12-06 13:38:28 +0300435
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 if (rom[1] == 0)
437 t = ((s32)rom[0] >> 1)*1000;
438 else
439 t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);
Evgeniy Polyakovbd529cf2005-12-06 13:38:28 +0300440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 t -= 250;
442 h = 1000*((s32)rom[7] - (s32)rom[6]);
443 h /= (s32)rom[7];
444 t += h;
445
446 return t;
447}
448
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400449static inline int w1_convert_temp(u8 rom[9], u8 fid)
450{
451 int i;
452
Ahmed S. Darwish9d0094d2007-02-12 00:52:05 -0800453 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
Evgeniy Polyakov4e470aa2005-05-20 22:50:33 +0400454 if (w1_therm_families[i].f->fid == fid)
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400455 return w1_therm_families[i].convert(rom);
456
457 return 0;
458}
459
Ben Sen0a19f122016-05-01 23:23:33 +0200460static ssize_t w1_slave_store(struct device *device,
461 struct device_attribute *attr, const char *buf,
462 size_t size)
463{
464 int val, ret;
465 struct w1_slave *sl = dev_to_w1_slave(device);
466 int i;
467
468 ret = kstrtoint(buf, 0, &val);
469 if (ret)
470 return ret;
471
472 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
473 if (w1_therm_families[i].f->fid == sl->family->fid) {
474 /* zero value indicates to write current configuration to eeprom */
Ben Werbowyj368451e2016-07-22 14:33:35 +1000475 if (val == 0)
Ben Sen0a19f122016-05-01 23:23:33 +0200476 ret = w1_therm_families[i].eeprom(device);
477 else
478 ret = w1_therm_families[i].precision(device, val);
479 break;
480 }
481 }
482 return ret ? : size;
483}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700485static ssize_t read_therm(struct device *device,
486 struct w1_slave *sl, struct therm_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 struct w1_master *dev = sl->master;
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700489 u8 external_power;
490 int ret, max_trying = 10;
David Friesf7134ee2015-05-08 19:51:50 -0500491 u8 *family_data = sl->family_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
David Friesf7134ee2015-05-08 19:51:50 -0500493 ret = mutex_lock_interruptible(&dev->bus_mutex);
494 if (ret != 0)
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700495 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700497 if (!family_data) {
David Friesf7134ee2015-05-08 19:51:50 -0500498 ret = -ENODEV;
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700499 goto mt_unlock;
David Friesf7134ee2015-05-08 19:51:50 -0500500 }
501
502 /* prevent the slave from going away in sleep */
503 atomic_inc(THERM_REFCNT(family_data));
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700504 memset(info->rom, 0, sizeof(info->rom));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 while (max_trying--) {
David Stevenson867ff982012-12-18 01:37:56 +0000507
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700508 info->verdict = 0;
509 info->crc = 0;
David Stevenson867ff982012-12-18 01:37:56 +0000510
Evgeniy Polyakovea7d8f62005-08-11 17:27:49 +0400511 if (!w1_reset_select_slave(sl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 int count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 unsigned int tm = 750;
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100514 unsigned long sleep_rem;
515
516 w1_write_8(dev, W1_READ_PSUPPLY);
517 external_power = w1_read_8(dev);
518
519 if (w1_reset_select_slave(sl))
520 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
David Fries6cd15972008-10-15 22:04:43 -0700522 /* 750ms strong pullup (or delay) after the convert */
Michael Arndt29e55072013-02-17 20:51:20 +0100523 if (w1_strong_pullup == 2 ||
524 (!external_power && w1_strong_pullup))
David Fries6cd15972008-10-15 22:04:43 -0700525 w1_next_pullup(dev, tm);
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 w1_write_8(dev, W1_CONVERT_TEMP);
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100528
529 if (external_power) {
NeilBrownb02f8be2012-05-18 15:59:52 +1000530 mutex_unlock(&dev->bus_mutex);
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100531
532 sleep_rem = msleep_interruptible(tm);
David Friesf7134ee2015-05-08 19:51:50 -0500533 if (sleep_rem != 0) {
534 ret = -EINTR;
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700535 goto dec_refcnt;
David Friesf7134ee2015-05-08 19:51:50 -0500536 }
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100537
David Friesf7134ee2015-05-08 19:51:50 -0500538 ret = mutex_lock_interruptible(&dev->bus_mutex);
539 if (ret != 0)
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700540 goto dec_refcnt;
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100541 } else if (!w1_strong_pullup) {
542 sleep_rem = msleep_interruptible(tm);
543 if (sleep_rem != 0) {
David Friesf7134ee2015-05-08 19:51:50 -0500544 ret = -EINTR;
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700545 goto dec_refcnt;
Maciej Szmigiero377195c2011-11-16 00:43:16 +0100546 }
547 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
Evgeniy Polyakovea7d8f62005-08-11 17:27:49 +0400549 if (!w1_reset_select_slave(sl)) {
Evgeniy Polyakov77859252005-05-20 22:33:25 +0400550
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 w1_write_8(dev, W1_READ_SCRATCHPAD);
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700552 count = w1_read_block(dev, info->rom, 9);
Ben Werbowyjaaf16f72016-07-22 14:33:34 +1000553 if (count != 9) {
David Fries347ba8a2008-10-15 22:04:51 -0700554 dev_warn(device, "w1_read_block() "
555 "returned %u instead of 9.\n",
556 count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 }
558
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700559 info->crc = w1_calc_crc8(info->rom, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700561 if (info->rom[8] == info->crc)
562 info->verdict = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 }
564 }
565
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700566 if (info->verdict)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 break;
568 }
569
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700570dec_refcnt:
571 atomic_dec(THERM_REFCNT(family_data));
572mt_unlock:
573 mutex_unlock(&dev->bus_mutex);
574error:
575 return ret;
576}
577
578static ssize_t w1_slave_show(struct device *device,
579 struct device_attribute *attr, char *buf)
580{
581 struct w1_slave *sl = dev_to_w1_slave(device);
582 struct therm_info info;
583 u8 *family_data = sl->family_data;
584 int ret, i;
585 ssize_t c = PAGE_SIZE;
586 u8 fid = sl->family->fid;
587
588 ret = read_therm(device, sl, &info);
589 if (ret)
590 return ret;
591
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 for (i = 0; i < 9; ++i)
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700593 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", info.rom[i]);
David Fries347ba8a2008-10-15 22:04:51 -0700594 c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700595 info.crc, (info.verdict) ? "YES" : "NO");
596 if (info.verdict)
597 memcpy(family_data, info.rom, sizeof(info.rom));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 else
David Stevenson867ff982012-12-18 01:37:56 +0000599 dev_warn(device, "Read failed CRC check\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601 for (i = 0; i < 9; ++i)
David Frieseb2c0da2014-01-15 22:29:24 -0600602 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ",
David Friesf7134ee2015-05-08 19:51:50 -0500603 ((u8 *)family_data)[i]);
Evgeniy Polyakovbd529cf2005-12-06 13:38:28 +0300604
David Fries347ba8a2008-10-15 22:04:51 -0700605 c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
Jaghathiswari Rankappagounder Natarajanb78165f2017-08-30 16:34:34 -0700606 w1_convert_temp(info.rom, fid));
David Friesf7134ee2015-05-08 19:51:50 -0500607 ret = PAGE_SIZE - c;
David Friesf7134ee2015-05-08 19:51:50 -0500608 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609}
610
Jaghathiswari Rankappagounder Natarajana97db882017-08-30 16:34:35 -0700611#if IS_REACHABLE(CONFIG_HWMON)
612static int w1_read_temp(struct device *device, u32 attr, int channel,
613 long *val)
614{
615 struct w1_slave *sl = dev_get_drvdata(device);
616 struct therm_info info;
617 u8 fid = sl->family->fid;
618 int ret;
619
620 switch (attr) {
621 case hwmon_temp_input:
622 ret = read_therm(device, sl, &info);
623 if (ret)
624 return ret;
625
626 if (!info.verdict) {
627 ret = -EIO;
628 return ret;
629 }
630
631 *val = w1_convert_temp(info.rom, fid);
632 ret = 0;
633 break;
634 default:
635 ret = -EOPNOTSUPP;
636 break;
637 }
638
639 return ret;
640}
641#endif
642
Matt Campbelld9411e52015-04-28 07:44:17 -0400643#define W1_42_CHAIN 0x99
644#define W1_42_CHAIN_OFF 0x3C
645#define W1_42_CHAIN_OFF_INV 0xC3
646#define W1_42_CHAIN_ON 0x5A
647#define W1_42_CHAIN_ON_INV 0xA5
648#define W1_42_CHAIN_DONE 0x96
649#define W1_42_CHAIN_DONE_INV 0x69
650#define W1_42_COND_READ 0x0F
651#define W1_42_SUCCESS_CONFIRM_BYTE 0xAA
652#define W1_42_FINISHED_BYTE 0xFF
653static ssize_t w1_seq_show(struct device *device,
654 struct device_attribute *attr, char *buf)
655{
656 struct w1_slave *sl = dev_to_w1_slave(device);
657 ssize_t c = PAGE_SIZE;
658 int rv;
659 int i;
660 u8 ack;
661 u64 rn;
662 struct w1_reg_num *reg_num;
663 int seq = 0;
664
Dan Carpenter0c6d5c82015-06-04 12:04:12 +0300665 mutex_lock(&sl->master->bus_mutex);
Matt Campbelld9411e52015-04-28 07:44:17 -0400666 /* Place all devices in CHAIN state */
667 if (w1_reset_bus(sl->master))
668 goto error;
669 w1_write_8(sl->master, W1_SKIP_ROM);
670 w1_write_8(sl->master, W1_42_CHAIN);
671 w1_write_8(sl->master, W1_42_CHAIN_ON);
672 w1_write_8(sl->master, W1_42_CHAIN_ON_INV);
673 msleep(sl->master->pullup_duration);
674
675 /* check for acknowledgment */
676 ack = w1_read_8(sl->master);
677 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
678 goto error;
679
680 /* In case the bus fails to send 0xFF, limit*/
681 for (i = 0; i <= 64; i++) {
682 if (w1_reset_bus(sl->master))
683 goto error;
684
685 w1_write_8(sl->master, W1_42_COND_READ);
686 rv = w1_read_block(sl->master, (u8 *)&rn, 8);
687 reg_num = (struct w1_reg_num *) &rn;
Dan Carpentera14ef242015-06-01 12:55:37 +0300688 if (reg_num->family == W1_42_FINISHED_BYTE)
Matt Campbelld9411e52015-04-28 07:44:17 -0400689 break;
690 if (sl->reg_num.id == reg_num->id)
691 seq = i;
692
Lucas Denefleaba111d2022-02-23 11:35:55 +0000693 if (w1_reset_bus(sl->master))
694 goto error;
695
696 /* Put the device into chain DONE state */
697 w1_write_8(sl->master, W1_MATCH_ROM);
698 w1_write_block(sl->master, (u8 *)&rn, 8);
Matt Campbelld9411e52015-04-28 07:44:17 -0400699 w1_write_8(sl->master, W1_42_CHAIN);
700 w1_write_8(sl->master, W1_42_CHAIN_DONE);
701 w1_write_8(sl->master, W1_42_CHAIN_DONE_INV);
Matt Campbelld9411e52015-04-28 07:44:17 -0400702
703 /* check for acknowledgment */
704 ack = w1_read_8(sl->master);
705 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
706 goto error;
Matt Campbelld9411e52015-04-28 07:44:17 -0400707 }
708
709 /* Exit from CHAIN state */
710 if (w1_reset_bus(sl->master))
711 goto error;
712 w1_write_8(sl->master, W1_SKIP_ROM);
713 w1_write_8(sl->master, W1_42_CHAIN);
714 w1_write_8(sl->master, W1_42_CHAIN_OFF);
715 w1_write_8(sl->master, W1_42_CHAIN_OFF_INV);
716
717 /* check for acknowledgment */
718 ack = w1_read_8(sl->master);
719 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
720 goto error;
Dan Carpenter0c6d5c82015-06-04 12:04:12 +0300721 mutex_unlock(&sl->master->bus_mutex);
Matt Campbelld9411e52015-04-28 07:44:17 -0400722
723 c -= snprintf(buf + PAGE_SIZE - c, c, "%d\n", seq);
724 return PAGE_SIZE - c;
725error:
726 mutex_unlock(&sl->master->bus_mutex);
727 return -EIO;
728}
729
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730static int __init w1_therm_init(void)
731{
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400732 int err, i;
733
Ahmed S. Darwish9d0094d2007-02-12 00:52:05 -0800734 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400735 err = w1_register_family(w1_therm_families[i].f);
736 if (err)
737 w1_therm_families[i].broken = 1;
738 }
739
740 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741}
742
743static void __exit w1_therm_fini(void)
744{
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400745 int i;
746
Ahmed S. Darwish9d0094d2007-02-12 00:52:05 -0800747 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
Evgeniy Polyakov718a5382005-04-17 22:58:14 +0400748 if (!w1_therm_families[i].broken)
749 w1_unregister_family(w1_therm_families[i].f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750}
751
752module_init(w1_therm_init);
753module_exit(w1_therm_fini);
Andrew F. Davis50fa2952017-05-16 15:02:12 -0500754
755MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
756MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
757MODULE_LICENSE("GPL");
758MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20));
759MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822));
760MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20));
761MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825));
762MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00));