?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.18.10
[linux/fpc-iii.git] / drivers / w1 / slaves / w1_therm.c
blob3c350dfbcd0be40ef3c300e43117a2229aa6929b
1 /*
2 * w1_therm.c
3 *
4 * 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
20 */
21
22 #include <asm/types.h>
23
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/sched.h>
28 #include <linux/device.h>
29 #include <linux/types.h>
30 #include <linux/slab.h>
31 #include <linux/delay.h>
32 #include <linux/hwmon.h>
33
34 #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
41
42 /* 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.
46 * 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
54 */
55 static int w1_strong_pullup = 1;
56 module_param_named(strong_pullup, w1_strong_pullup, int, 0);
57
58 struct w1_therm_family_data {
59 uint8_t rom[9];
60 atomic_t refcnt;
61 };
62
63 struct therm_info {
64 u8 rom[9];
65 u8 crc;
66 u8 verdict;
67 };
68
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)
72
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 }
82
83 static void w1_therm_remove_slave(struct w1_slave *sl)
84 {
85 int refcnt = atomic_sub_return(1, THERM_REFCNT(sl->family_data));
86
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 }
94
95 static ssize_t w1_slave_show(struct device *device,
96 struct device_attribute *attr, char *buf);
97
98 static ssize_t w1_slave_store(struct device *device,
99 struct device_attribute *attr, const char *buf, size_t size);
100
101 static ssize_t w1_seq_show(struct device *device,
102 struct device_attribute *attr, char *buf);
103
104 static DEVICE_ATTR_RW(w1_slave);
105 static DEVICE_ATTR_RO(w1_seq);
106
107 static struct attribute *w1_therm_attrs[] = {
108 &dev_attr_w1_slave.attr,
109 NULL,
110 };
111
112 static struct attribute *w1_ds28ea00_attrs[] = {
113 &dev_attr_w1_slave.attr,
114 &dev_attr_w1_seq.attr,
115 NULL,
116 };
117
118 ATTRIBUTE_GROUPS(w1_therm);
119 ATTRIBUTE_GROUPS(w1_ds28ea00);
120
121 #if IS_REACHABLE(CONFIG_HWMON)
122 static int w1_read_temp(struct device *dev, u32 attr, int channel,
123 long *val);
124
125 static 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
131 static 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
142 static const u32 w1_temp_config[] = {
143 HWMON_T_INPUT,
144 0
145 };
146
147 static const struct hwmon_channel_info w1_temp = {
148 .type = hwmon_temp,
149 .config = w1_temp_config,
150 };
151
152 static const struct hwmon_channel_info *w1_info[] = {
153 &w1_temp,
154 NULL
155 };
156
157 static const struct hwmon_ops w1_hwmon_ops = {
158 .is_visible = w1_is_visible,
159 .read = w1_read,
160 };
161
162 static 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
171 static struct w1_family_ops w1_therm_fops = {
172 .add_slave = w1_therm_add_slave,
173 .remove_slave = w1_therm_remove_slave,
174 .groups = w1_therm_groups,
175 .chip_info = W1_CHIPINFO,
176 };
177
178 static 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,
182 .chip_info = W1_CHIPINFO,
183 };
184
185 static struct w1_family w1_therm_family_DS18S20 = {
186 .fid = W1_THERM_DS18S20,
187 .fops = &w1_therm_fops,
188 };
189
190 static struct w1_family w1_therm_family_DS18B20 = {
191 .fid = W1_THERM_DS18B20,
192 .fops = &w1_therm_fops,
193 };
194
195 static struct w1_family w1_therm_family_DS1822 = {
196 .fid = W1_THERM_DS1822,
197 .fops = &w1_therm_fops,
198 };
199
200 static struct w1_family w1_therm_family_DS28EA00 = {
201 .fid = W1_THERM_DS28EA00,
202 .fops = &w1_ds28ea00_fops,
203 };
204
205 static struct w1_family w1_therm_family_DS1825 = {
206 .fid = W1_THERM_DS1825,
207 .fops = &w1_therm_fops,
208 };
209
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 };
218
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)
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 if (!sl->family_data) {
272 ret = -ENODEV;
273 goto error;
274 }
275
276 /* prevent the slave from going away in sleep */
277 atomic_inc(THERM_REFCNT(family_data));
278
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) {
374 case 9:
375 precision_bits = 0x00;
376 break;
377 case 10:
378 precision_bits = 0x20;
379 break;
380 case 11:
381 precision_bits = 0x40;
382 break;
383 case 12:
384 default:
385 precision_bits = 0x60;
386 break;
387 }
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:
421 return ret;
422 }
423
424 static inline int w1_DS18B20_convert_temp(u8 rom[9])
425 {
426 s16 t = le16_to_cpup((__le16 *)rom);
427
428 return t*1000/16;
429 }
430
431 static inline int w1_DS18S20_convert_temp(u8 rom[9])
432 {
433 int t, h;
434
435 if (!rom[7])
436 return 0;
437
438 if (rom[1] == 0)
439 t = ((s32)rom[0] >> 1)*1000;
440 else
441 t = 1000*(-1*(s32)(0x100-rom[0]) >> 1);
442
443 t -= 250;
444 h = 1000*((s32)rom[7] - (s32)rom[6]);
445 h /= (s32)rom[7];
446 t += h;
447
448 return t;
449 }
450
451 static inline int w1_convert_temp(u8 rom[9], u8 fid)
452 {
453 int i;
454
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);
458
459 return 0;
460 }
461
462 static ssize_t w1_slave_store(struct device *device,
463 struct device_attribute *attr, const char *buf,
464 size_t size)
465 {
466 int val, ret;
467 struct w1_slave *sl = dev_to_w1_slave(device);
468 int i;
469
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 }
483 }
484 return ret ? : size;
485 }
486
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;
494
495 if (!family_data) {
496 ret = -ENODEV;
497 goto error;
498 }
499
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;
506
507 memset(info->rom, 0, sizeof(info->rom));
508
509 while (max_trying--) {
510
511 info->verdict = 0;
512 info->crc = 0;
513
514 if (!w1_reset_select_slave(sl)) {
515 int count = 0;
516 unsigned int tm = 750;
517 unsigned long sleep_rem;
518
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
525 /* 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);
529
530 w1_write_8(dev, W1_CONVERT_TEMP);
531
532 if (external_power) {
533 mutex_unlock(&dev->bus_mutex);
534
535 sleep_rem = msleep_interruptible(tm);
536 if (sleep_rem != 0) {
537 ret = -EINTR;
538 goto dec_refcnt;
539 }
540
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);
546 if (sleep_rem != 0) {
547 ret = -EINTR;
548 goto mt_unlock;
549 }
550 }
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 }
567 }
568
569 if (info->verdict)
570 break;
571 }
572
573 mt_unlock:
574 mutex_unlock(&dev->bus_mutex);
575 dec_refcnt:
576 atomic_dec(THERM_REFCNT(family_data));
577 error:
578 return ret;
579 }
580
581 static ssize_t w1_slave_show(struct device *device,
582 struct device_attribute *attr, char *buf)
583 {
584 struct w1_slave *sl = dev_to_w1_slave(device);
585 struct therm_info info;
586 u8 *family_data = sl->family_data;
587 int ret, i;
588 ssize_t c = PAGE_SIZE;
589 u8 fid = sl->family->fid;
590
591 ret = read_therm(device, sl, &info);
592 if (ret)
593 return ret;
594
595 for (i = 0; i < 9; ++i)
596 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", info.rom[i]);
597 c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n",
598 info.crc, (info.verdict) ? "YES" : "NO");
599 if (info.verdict)
600 memcpy(family_data, info.rom, sizeof(info.rom));
601 else
602 dev_warn(device, "Read failed CRC check\n");
603
604 for (i = 0; i < 9; ++i)
605 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ",
606 ((u8 *)family_data)[i]);
607
608 c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n",
609 w1_convert_temp(info.rom, fid));
610 ret = PAGE_SIZE - c;
611 return ret;
612 }
613
614 #if IS_REACHABLE(CONFIG_HWMON)
615 static int w1_read_temp(struct device *device, u32 attr, int channel,
616 long *val)
617 {
618 struct w1_slave *sl = dev_get_drvdata(device);
619 struct therm_info info;
620 u8 fid = sl->family->fid;
621 int ret;
622
623 switch (attr) {
624 case hwmon_temp_input:
625 ret = read_therm(device, sl, &info);
626 if (ret)
627 return ret;
628
629 if (!info.verdict) {
630 ret = -EIO;
631 return ret;
632 }
633
634 *val = w1_convert_temp(info.rom, fid);
635 ret = 0;
636 break;
637 default:
638 ret = -EOPNOTSUPP;
639 break;
640 }
641
642 return ret;
643 }
644 #endif
645
646 #define W1_42_CHAIN 0x99
647 #define W1_42_CHAIN_OFF 0x3C
648 #define W1_42_CHAIN_OFF_INV 0xC3
649 #define W1_42_CHAIN_ON 0x5A
650 #define W1_42_CHAIN_ON_INV 0xA5
651 #define W1_42_CHAIN_DONE 0x96
652 #define W1_42_CHAIN_DONE_INV 0x69
653 #define W1_42_COND_READ 0x0F
654 #define W1_42_SUCCESS_CONFIRM_BYTE 0xAA
655 #define W1_42_FINISHED_BYTE 0xFF
656 static ssize_t w1_seq_show(struct device *device,
657 struct device_attribute *attr, char *buf)
658 {
659 struct w1_slave *sl = dev_to_w1_slave(device);
660 ssize_t c = PAGE_SIZE;
661 int rv;
662 int i;
663 u8 ack;
664 u64 rn;
665 struct w1_reg_num *reg_num;
666 int seq = 0;
667
668 mutex_lock(&sl->master->bus_mutex);
669 /* Place all devices in CHAIN state */
670 if (w1_reset_bus(sl->master))
671 goto error;
672 w1_write_8(sl->master, W1_SKIP_ROM);
673 w1_write_8(sl->master, W1_42_CHAIN);
674 w1_write_8(sl->master, W1_42_CHAIN_ON);
675 w1_write_8(sl->master, W1_42_CHAIN_ON_INV);
676 msleep(sl->master->pullup_duration);
677
678 /* check for acknowledgment */
679 ack = w1_read_8(sl->master);
680 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
681 goto error;
682
683 /* In case the bus fails to send 0xFF, limit*/
684 for (i = 0; i <= 64; i++) {
685 if (w1_reset_bus(sl->master))
686 goto error;
687
688 w1_write_8(sl->master, W1_42_COND_READ);
689 rv = w1_read_block(sl->master, (u8 *)&rn, 8);
690 reg_num = (struct w1_reg_num *) &rn;
691 if (reg_num->family == W1_42_FINISHED_BYTE)
692 break;
693 if (sl->reg_num.id == reg_num->id)
694 seq = i;
695
696 w1_write_8(sl->master, W1_42_CHAIN);
697 w1_write_8(sl->master, W1_42_CHAIN_DONE);
698 w1_write_8(sl->master, W1_42_CHAIN_DONE_INV);
699 w1_read_block(sl->master, &ack, sizeof(ack));
700
701 /* check for acknowledgment */
702 ack = w1_read_8(sl->master);
703 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
704 goto error;
705
706 }
707
708 /* Exit from CHAIN state */
709 if (w1_reset_bus(sl->master))
710 goto error;
711 w1_write_8(sl->master, W1_SKIP_ROM);
712 w1_write_8(sl->master, W1_42_CHAIN);
713 w1_write_8(sl->master, W1_42_CHAIN_OFF);
714 w1_write_8(sl->master, W1_42_CHAIN_OFF_INV);
715
716 /* check for acknowledgment */
717 ack = w1_read_8(sl->master);
718 if (ack != W1_42_SUCCESS_CONFIRM_BYTE)
719 goto error;
720 mutex_unlock(&sl->master->bus_mutex);
721
722 c -= snprintf(buf + PAGE_SIZE - c, c, "%d\n", seq);
723 return PAGE_SIZE - c;
724 error:
725 mutex_unlock(&sl->master->bus_mutex);
726 return -EIO;
727 }
728
729 static int __init w1_therm_init(void)
730 {
731 int err, i;
732
733 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) {
734 err = w1_register_family(w1_therm_families[i].f);
735 if (err)
736 w1_therm_families[i].broken = 1;
737 }
738
739 return 0;
740 }
741
742 static void __exit w1_therm_fini(void)
743 {
744 int i;
745
746 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i)
747 if (!w1_therm_families[i].broken)
748 w1_unregister_family(w1_therm_families[i].f);
749 }
750
751 module_init(w1_therm_init);
752 module_exit(w1_therm_fini);
753
754 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
755 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family.");
756 MODULE_LICENSE("GPL");
757 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20));
758 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822));
759 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20));
760 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825));
761 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00));
Linux with added FPC-III support