?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: rcar: Fix runtime PM imbalance on error
[linux/fpc-iii.git] / drivers / w1 / slaves / w1_therm.c
blobe028e00927991cd6aa1e91dcca6ce7fb9d5b79a1
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * w1_therm.c
4 *
5 * Copyright (c) 2004 Evgeniy Polyakov <zbr@ioremap.net>
6 */
7
8 #include <asm/types.h>
9
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/moduleparam.h>
13 #include <linux/sched.h>
14 #include <linux/device.h>
15 #include <linux/types.h>
16 #include <linux/slab.h>
17 #include <linux/delay.h>
18 #include <linux/hwmon.h>
19
20 #include <linux/w1.h>
21
22 #define W1_THERM_DS18S20 0x10
23 #define W1_THERM_DS1822 0x22
24 #define W1_THERM_DS18B20 0x28
25 #define W1_THERM_DS1825 0x3B
26 #define W1_THERM_DS28EA00 0x42
27
28 /* Allow the strong pullup to be disabled, but default to enabled.
29 * If it was disabled a parasite powered device might not get the require
30 * current to do a temperature conversion. If it is enabled parasite powered
31 * devices have a better chance of getting the current required.
32 * In case the parasite power-detection is not working (seems to be the case
33 * for some DS18S20) the strong pullup can also be forced, regardless of the
34 * power state of the devices.
35 *
36 * Summary of options:
37 * - strong_pullup = 0 Disable strong pullup completely
38 * - strong_pullup = 1 Enable automatic strong pullup detection
39 * - strong_pullup = 2 Force strong pullup
40 */
41 static int w1_strong_pullup = 1;
42 module_param_named(strong_pullup, w1_strong_pullup, int, 0);
43
44 struct w1_therm_family_data {
45 uint8_t rom[9];
46 atomic_t refcnt;
47 };
48
49 struct therm_info {
50 u8 rom[9];
51 u8 crc;
52 u8 verdict;
53 };
54
55 /* return the address of the refcnt in the family data */
56 #define THERM_REFCNT(family_data) \
57 (&((struct w1_therm_family_data *)family_data)->refcnt)
58
59 static int w1_therm_add_slave(struct w1_slave *sl)
60 {
61 sl->family_data = kzalloc(sizeof(struct w1_therm_family_data),
62 GFP_KERNEL);
63 if (!sl->family_data)
64 return -ENOMEM;
65 atomic_set(THERM_REFCNT(sl->family_data), 1);
66 return 0;
67 }
68
69 static void w1_therm_remove_slave(struct w1_slave *sl)
70 {
71 int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data));
72
73 while (refcnt) {
74 msleep(1000);
75 refcnt = atomic_read(THERM_REFCNT(sl->family_data));
76 }
77 kfree(sl->family_data);
78 sl->family_data = NULL;
79 }
80
81 static ssize_t w1_slave_show(struct device *device,
82 struct device_attribute *attr, char *buf);
83
84 static ssize_t w1_slave_store(struct device *device,
85 struct device_attribute *attr, const char *buf, size_t size);
86
87 static ssize_t w1_seq_show(struct device *device,
88 struct device_attribute *attr, char *buf);
89
90 static DEVICE_ATTR_RW(w1_slave);
91 static DEVICE_ATTR_RO(w1_seq);
92
93 static struct attribute *w1_therm_attrs[] = {
94 &dev_attr_w1_slave.attr,
95 NULL,
96 };
97
98 static struct attribute *w1_ds28ea00_attrs[] = {
99 &dev_attr_w1_slave.attr,
100 &dev_attr_w1_seq.attr,
101 NULL,
102 };
103
104 ATTRIBUTE_GROUPS(w1_therm);
105 ATTRIBUTE_GROUPS(w1_ds28ea00);
106
107 #if IS_REACHABLE(CONFIG_HWMON)
108 static int w1_read_temp(struct device *dev, u32 attr, int channel,
109 long *val);
110
111 static umode_t w1_is_visible(const void *_data, enum hwmon_sensor_types type,
112 u32 attr, int channel)
113 {
114 return attr == hwmon_temp_input ? 0444 : 0;
115 }
116
117 static int w1_read(struct device *dev, enum hwmon_sensor_types type,
118 u32 attr, int channel, long *val)
119 {
120 switch (type) {
121 case hwmon_temp:
122 return w1_read_temp(dev, attr, channel, val);
123 default:
124 return -EOPNOTSUPP;
125 }
126 }
127
128 static const u32 w1_temp_config[] = {
129 HWMON_T_INPUT,
130 0
131 };
132
133 static const struct hwmon_channel_info w1_temp = {
134 .type = hwmon_temp,
135 .config = w1_temp_config,
136 };
137
138 static const struct hwmon_channel_info *w1_info[] = {
139 &w1_temp,
140 NULL
141 };
142
143 static const struct hwmon_ops w1_hwmon_ops = {
144 .is_visible = w1_is_visible,
145 .read = w1_read,
146 };
147
148 static const struct hwmon_chip_info w1_chip_info = {
149 .ops = &w1_hwmon_ops,
150 .info = w1_info,
151 };
152 #define W1_CHIPINFO (&w1_chip_info)
153 #else
154 #define W1_CHIPINFO NULL
155 #endif
156
157 static struct w1_family_ops w1_therm_fops = {
158 .add_slave = w1_therm_add_slave,
159 .remove_slave = w1_therm_remove_slave,
160 .groups = w1_therm_groups,
161 .chip_info = W1_CHIPINFO,
162 };
163
164 static struct w1_family_ops w1_ds28ea00_fops = {
165 .add_slave = w1_therm_add_slave,
166 .remove_slave = w1_therm_remove_slave,
167 .groups = w1_ds28ea00_groups,
168 .chip_info = W1_CHIPINFO,
169 };
170
171 static struct w1_family w1_therm_family_DS18S20 = {
172 .fid = W1_THERM_DS18S20,
173 .fops = &w1_therm_fops,
174 };
175
176 static struct w1_family w1_therm_family_DS18B20 = {
177 .fid = W1_THERM_DS18B20,
178 .fops = &w1_therm_fops,
179 };
180
181 static struct w1_family w1_therm_family_DS1822 = {
182 .fid = W1_THERM_DS1822,
183 .fops = &w1_therm_fops,
184 };
185
186 static struct w1_family w1_therm_family_DS28EA00 = {
187 .fid = W1_THERM_DS28EA00,
188 .fops = &w1_ds28ea00_fops,
189 };
190
191 static struct w1_family w1_therm_family_DS1825 = {
192 .fid = W1_THERM_DS1825,
193 .fops = &w1_therm_fops,
194 };
195
196 struct w1_therm_family_converter {
197 u8 broken;
198 u16 reserved;
199 struct w1_family *f;
200 int (*convert)(u8 rom[9]);
201 int (*precision)(struct device *device, int val);
202 int (*eeprom)(struct device *device);
203 };
204
205 /* write configuration to eeprom */
206 static inline int w1_therm_eeprom(struct device *device);
207
208 /* Set precision for conversion */
209 static inline int w1_DS18B20_precision(struct device *device, int val);
210 static inline int w1_DS18S20_precision(struct device *device, int val);
211
212 /* The return value is millidegrees Centigrade. */
213 static inline int w1_DS18B20_convert_temp(u8 rom[9]);
214 static inline int w1_DS18S20_convert_temp(u8 rom[9]);
215
216 static struct w1_therm_family_converter w1_therm_families[] = {
217 {
218 .f = &w1_therm_family_DS18S20,
219 .convert = w1_DS18S20_convert_temp,
220 .precision = w1_DS18S20_precision,
221 .eeprom = w1_therm_eeprom
222 },
223 {
224 .f = &w1_therm_family_DS1822,
225 .convert = w1_DS18B20_convert_temp,
226 .precision = w1_DS18S20_precision,
227 .eeprom = w1_therm_eeprom
228 },
229 {
230 .f = &w1_therm_family_DS18B20,
231 .convert = w1_DS18B20_convert_temp,
232 .precision = w1_DS18B20_precision,
233 .eeprom = w1_therm_eeprom
234 },
235 {
236 .f = &w1_therm_family_DS28EA00,
237 .convert = w1_DS18B20_convert_temp,
238 .precision = w1_DS18S20_precision,
239 .eeprom = w1_therm_eeprom
240 },
241 {
242 .f = &w1_therm_family_DS1825,
243 .convert = w1_DS18B20_convert_temp,
244 .precision = w1_DS18S20_precision,
245 .eeprom = w1_therm_eeprom
246 }
247 };
248
249 static inline int w1_therm_eeprom(struct device *device)
250 {
251 struct w1_slave *sl = dev_to_w1_slave(device);
252 struct w1_master *dev = sl->master;
253 u8 rom[9], external_power;
254 int ret, max_trying = 10;
255 u8 *family_data = sl->family_data;
256
257 if (!sl->family_data) {
258 ret = -ENODEV;
259 goto error;
260 }
261
262 /* prevent the slave from going away in sleep */
263 atomic_inc(THERM_REFCNT(family_data));
264
265 ret = mutex_lock_interruptible(&dev->bus_mutex);
266 if (ret != 0)
267 goto dec_refcnt;
268
269 memset(rom, 0, sizeof(rom));
270
271 while (max_trying--) {
272 if (!w1_reset_select_slave(sl)) {
273 unsigned int tm = 10;
274 unsigned long sleep_rem;
275
276 /* check if in parasite mode */
277 w1_write_8(dev, W1_READ_PSUPPLY);
278 external_power = w1_read_8(dev);
279
280 if (w1_reset_select_slave(sl))
281 continue;
282
283 /* 10ms strong pullup/delay after the copy command */
284 if (w1_strong_pullup == 2 ||
285 (!external_power && w1_strong_pullup))
286 w1_next_pullup(dev, tm);
287
288 w1_write_8(dev, W1_COPY_SCRATCHPAD);
289
290 if (external_power) {
291 mutex_unlock(&dev->bus_mutex);
292
293 sleep_rem = msleep_interruptible(tm);
294 if (sleep_rem != 0) {
295 ret = -EINTR;
296 goto dec_refcnt;
297 }
298
299 ret = mutex_lock_interruptible(&dev->bus_mutex);
300 if (ret != 0)
301 goto dec_refcnt;
302 } else if (!w1_strong_pullup) {
303 sleep_rem = msleep_interruptible(tm);
304 if (sleep_rem != 0) {
305 ret = -EINTR;
306 goto mt_unlock;
307 }
308 }
309
310 break;
311 }
312 }
313
314 mt_unlock:
315 mutex_unlock(&dev->bus_mutex);
316 dec_refcnt:
317 atomic_dec(THERM_REFCNT(family_data));
318 error:
319 return ret;
320 }
321
322 /* DS18S20 does not feature configuration register */
323 static inline int w1_DS18S20_precision(struct device *device, int val)
324 {
325 return 0;
326 }
327
328 static inline int w1_DS18B20_precision(struct device *device, int val)
329 {
330 struct w1_slave *sl = dev_to_w1_slave(device);
331 struct w1_master *dev = sl->master;
332 u8 rom[9], crc;
333 int ret, max_trying = 10;
334 u8 *family_data = sl->family_data;
335 uint8_t precision_bits;
336 uint8_t mask = 0x60;
337
338 if (val > 12 || val < 9) {
339 pr_warn("Unsupported precision\n");
340 ret = -EINVAL;
341 goto error;
342 }
343
344 if (!sl->family_data) {
345 ret = -ENODEV;
346 goto error;
347 }
348
349 /* prevent the slave from going away in sleep */
350 atomic_inc(THERM_REFCNT(family_data));
351
352 ret = mutex_lock_interruptible(&dev->bus_mutex);
353 if (ret != 0)
354 goto dec_refcnt;
355
356 memset(rom, 0, sizeof(rom));
357
358 /* translate precision to bitmask (see datasheet page 9) */
359 switch (val) {
360 case 9:
361 precision_bits = 0x00;
362 break;
363 case 10:
364 precision_bits = 0x20;
365 break;
366 case 11:
367 precision_bits = 0x40;
368 break;
369 case 12:
370 default:
371 precision_bits = 0x60;
372 break;
373 }
374
375 while (max_trying--) {
376 crc = 0;
377
378 if (!w1_reset_select_slave(sl)) {
379 int count = 0;
380
381 /* read values to only alter precision bits */
382 w1_write_8(dev, W1_READ_SCRATCHPAD);
383 count = w1_read_block(dev, rom, 9);
384 if (count != 9)
385 dev_warn(device, "w1_read_block() returned %u instead of 9.\n", count);
386
387 crc = w1_calc_crc8(rom, 8);
388 if (rom[8] == crc) {
389 rom[4] = (rom[4] & ~mask) | (precision_bits & mask);
390
391 if (!w1_reset_select_slave(sl)) {
392 w1_write_8(dev, W1_WRITE_SCRATCHPAD);
393 w1_write_8(dev, rom[2]);
394 w1_write_8(dev, rom[3]);
395 w1_write_8(dev, rom[4]);
396
397 break;
398 }
399 }
400 }
401 }
402
403 mutex_unlock(&dev->bus_mutex);
404 dec_refcnt:
405 atomic_dec(THERM_REFCNT(family_data));
406 error:
407 return ret;
408 }
409
410 static inline int w1_DS18B20_convert_temp(u8 rom[9])
411 {
412 s16 t = le16_to_cpup((__le16 *)rom);
413
414 return t*1000/16;
415 }
416
417 static inline int w1_DS18S20_convert_temp(u8 rom[9])
418 {
419 int t, h;
420
421 if (!rom[7])
422 return 0;
423
424 if (rom[1] == 0)
425 t = ((s32)rom[0] >> 1)*1000;
426 else
427 t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);
428
429 t -= 250;
430 h = 1000*((s32)rom[7] - (s32)rom[6]);
431 h /= (s32)rom[7];
432 t += h;
433
434 return t;
435 }
436
437 static inline int w1_convert_temp(u8 rom[9], u8 fid)
438 {
439 int i;
440
441 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
442 if (w1_therm_families[i].f->fid == fid)
443 return w1_therm_families[i].convert(rom);
444
445 return 0;
446 }
447
448 static ssize_t w1_slave_store(struct device *device,
449 struct device_attribute *attr, const char *buf,
450 size_t size)
451 {
452 int val, ret;
453 struct w1_slave *sl = dev_to_w1_slave(device);
454 int i;
455
456 ret = kstrtoint(buf, 0, &val);
457 if (ret)
458 return ret;
459
460 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
461 if (w1_therm_families[i].f->fid == sl->family->fid) {
462 /* zero value indicates to write current configuration to eeprom */
463 if (val == 0)
464 ret = w1_therm_families[i].eeprom(device);
465 else
466 ret = w1_therm_families[i].precision(device, val);
467 break;
468 }
469 }
470 return ret ? : size;
471 }
472
473 static ssize_t read_therm(struct device *device,
474 struct w1_slave *sl, struct therm_info *info)
475 {
476 struct w1_master *dev = sl->master;
477 u8 external_power;
478 int ret, max_trying = 10;
479 u8 *family_data = sl->family_data;
480
481 if (!family_data) {
482 ret = -ENODEV;
483 goto error;
484 }
485
486 /* prevent the slave from going away in sleep */
487 atomic_inc(THERM_REFCNT(family_data));
488
489 ret = mutex_lock_interruptible(&dev->bus_mutex);
490 if (ret != 0)
491 goto dec_refcnt;
492
493 memset(info->rom, 0, sizeof(info->rom));
494
495 while (max_trying--) {
496
497 info->verdict = 0;
498 info->crc = 0;
499
500 if (!w1_reset_select_slave(sl)) {
501 int count = 0;
502 unsigned int tm = 750;
503 unsigned long sleep_rem;
504
505 w1_write_8(dev, W1_READ_PSUPPLY);
506 external_power = w1_read_8(dev);
507
508 if (w1_reset_select_slave(sl))
509 continue;
510
511 /* 750ms strong pullup (or delay) after the convert */
512 if (w1_strong_pullup == 2 ||
513 (!external_power && w1_strong_pullup))
514 w1_next_pullup(dev, tm);
515
516 w1_write_8(dev, W1_CONVERT_TEMP);
517
518 if (external_power) {
519 mutex_unlock(&dev->bus_mutex);
520
521 sleep_rem = msleep_interruptible(tm);
522 if (sleep_rem != 0) {
523 ret = -EINTR;
524 goto dec_refcnt;
525 }
526
527 ret = mutex_lock_interruptible(&dev->bus_mutex);
528 if (ret != 0)
529 goto dec_refcnt;
530 } else if (!w1_strong_pullup) {
531 sleep_rem = msleep_interruptible(tm);
532 if (sleep_rem != 0) {
533 ret = -EINTR;
534 goto mt_unlock;
535 }
536 }
537
538 if (!w1_reset_select_slave(sl)) {
539
540 w1_write_8(dev, W1_READ_SCRATCHPAD);
541 count = w1_read_block(dev, info->rom, 9);
542 if (count != 9) {
543 dev_warn(device, "w1_read_block() "
544 "returned %u instead of 9.\n",
545 count);
546 }
547
548 info->crc = w1_calc_crc8(info->rom, 8);
549
550 if (info->rom[8] == info->crc)
551 info->verdict = 1;
552 }
553 }
554
555 if (info->verdict)
556 break;
557 }
558
559 mt_unlock:
560 mutex_unlock(&dev->bus_mutex);
561 dec_refcnt:
562 atomic_dec(THERM_REFCNT(family_data));
563 error:
564 return ret;
565 }
566
567 static ssize_t w1_slave_show(struct device *device,
568 struct device_attribute *attr, char *buf)
569 {
570 struct w1_slave *sl = dev_to_w1_slave(device);
571 struct therm_info info;
572 u8 *family_data = sl->family_data;
573 int ret, i;
574 ssize_t c = PAGE_SIZE;
575 u8 fid = sl->family->fid;
576
577 ret = read_therm(device, sl, &info);
578 if (ret)
579 return ret;
580
581 for (i = 0; i < 9; ++i)
582 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", info.rom[i]);
583 c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
584 info.crc, (info.verdict) ? "YES" : "NO");
585 if (info.verdict)
586 memcpy(family_data, info.rom, sizeof(info.rom));
587 else
588 dev_warn(device, "Read failed CRC check\n");
589
590 for (i = 0; i < 9; ++i)
591 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ",
592 ((u8 *)family_data)[i]);
593
594 c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
595 w1_convert_temp(info.rom, fid));
596 ret = PAGE_SIZE - c;
597 return ret;
598 }
599
600 #if IS_REACHABLE(CONFIG_HWMON)
601 static int w1_read_temp(struct device *device, u32 attr, int channel,
602 long *val)
603 {
604 struct w1_slave *sl = dev_get_drvdata(device);
605 struct therm_info info;
606 u8 fid = sl->family->fid;
607 int ret;
608
609 switch (attr) {
610 case hwmon_temp_input:
611 ret = read_therm(device, sl, &info);
612 if (ret)
613 return ret;
614
615 if (!info.verdict) {
616 ret = -EIO;
617 return ret;
618 }
619
620 *val = w1_convert_temp(info.rom, fid);
621 ret = 0;
622 break;
623 default:
624 ret = -EOPNOTSUPP;
625 break;
626 }
627
628 return ret;
629 }
630 #endif
631
632 #define W1_42_CHAIN 0x99
633 #define W1_42_CHAIN_OFF 0x3C
634 #define W1_42_CHAIN_OFF_INV 0xC3
635 #define W1_42_CHAIN_ON 0x5A
636 #define W1_42_CHAIN_ON_INV 0xA5
637 #define W1_42_CHAIN_DONE 0x96
638 #define W1_42_CHAIN_DONE_INV 0x69
639 #define W1_42_COND_READ 0x0F
640 #define W1_42_SUCCESS_CONFIRM_BYTE 0xAA
641 #define W1_42_FINISHED_BYTE 0xFF
642 static ssize_t w1_seq_show(struct device *device,
643 struct device_attribute *attr, char *buf)
644 {
645 struct w1_slave *sl = dev_to_w1_slave(device);
646 ssize_t c = PAGE_SIZE;
647 int rv;
648 int i;
649 u8 ack;
650 u64 rn;
651 struct w1_reg_num *reg_num;
652 int seq = 0;
653
654 mutex_lock(&sl->master->bus_mutex);
655 /* Place all devices in CHAIN state */
656 if (w1_reset_bus(sl->master))
657 goto error;
658 w1_write_8(sl->master, W1_SKIP_ROM);
659 w1_write_8(sl->master, W1_42_CHAIN);
660 w1_write_8(sl->master, W1_42_CHAIN_ON);
661 w1_write_8(sl->master, W1_42_CHAIN_ON_INV);
662 msleep(sl->master->pullup_duration);
663
664 /* check for acknowledgment */
665 ack = w1_read_8(sl->master);
666 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
667 goto error;
668
669 /* In case the bus fails to send 0xFF, limit*/
670 for (i = 0; i <= 64; i++) {
671 if (w1_reset_bus(sl->master))
672 goto error;
673
674 w1_write_8(sl->master, W1_42_COND_READ);
675 rv = w1_read_block(sl->master, (u8 *)&rn, 8);
676 reg_num = (struct w1_reg_num *) &rn;
677 if (reg_num->family == W1_42_FINISHED_BYTE)
678 break;
679 if (sl->reg_num.id == reg_num->id)
680 seq = i;
681
682 w1_write_8(sl->master, W1_42_CHAIN);
683 w1_write_8(sl->master, W1_42_CHAIN_DONE);
684 w1_write_8(sl->master, W1_42_CHAIN_DONE_INV);
685 w1_read_block(sl->master, &ack, sizeof(ack));
686
687 /* check for acknowledgment */
688 ack = w1_read_8(sl->master);
689 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
690 goto error;
691
692 }
693
694 /* Exit from CHAIN state */
695 if (w1_reset_bus(sl->master))
696 goto error;
697 w1_write_8(sl->master, W1_SKIP_ROM);
698 w1_write_8(sl->master, W1_42_CHAIN);
699 w1_write_8(sl->master, W1_42_CHAIN_OFF);
700 w1_write_8(sl->master, W1_42_CHAIN_OFF_INV);
701
702 /* check for acknowledgment */
703 ack = w1_read_8(sl->master);
704 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
705 goto error;
706 mutex_unlock(&sl->master->bus_mutex);
707
708 c -= snprintf(buf + PAGE_SIZE - c, c, "%d\n", seq);
709 return PAGE_SIZE - c;
710 error:
711 mutex_unlock(&sl->master->bus_mutex);
712 return -EIO;
713 }
714
715 static int __init w1_therm_init(void)
716 {
717 int err, i;
718
719 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
720 err = w1_register_family(w1_therm_families[i].f);
721 if (err)
722 w1_therm_families[i].broken = 1;
723 }
724
725 return 0;
726 }
727
728 static void __exit w1_therm_fini(void)
729 {
730 int i;
731
732 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
733 if (!w1_therm_families[i].broken)
734 w1_unregister_family(w1_therm_families[i].f);
735 }
736
737 module_init(w1_therm_init);
738 module_exit(w1_therm_fini);
739
740 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
741 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
742 MODULE_LICENSE("GPL");
743 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20));
744 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822));
745 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20));
746 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825));
747 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00));
Linux with added FPC-III support