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)); 762