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 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 327 pre_unlock: 328 mutex_unlock(&dev->bus_mutex); 329 330 post_unlock: 331 atomic_dec(THERM_REFCNT(family_data)); 332 return ret; 333 } 334 335 /* DS18S20 does not feature configuration register */ 336 static inline int w1_DS18S20_precision(struct device *device, int val) 337 { 338 return 0; 339 } 340 341 static 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 351 if (val > 12 || val < 9) { 352 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); 394 count = w1_read_block(dev, rom, 9); 395 if (count != 9) 396 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 414 pre_unlock: 415 mutex_unlock(&dev->bus_mutex); 416 417 post_unlock: 418 atomic_dec(THERM_REFCNT(family_data)); 419 return ret; 420 } 421 422 static inline int w1_DS18B20_convert_temp(u8 rom[9]) 423 { 424 s16 t = le16_to_cpup((__le16 *)rom); 425 426 return t*1000/16; 427 } 428 429 static inline int w1_DS18S20_convert_temp(u8 rom[9]) 430 { 431 int t, h; 432 433 if (!rom[7]) 434 return 0; 435 436 if (rom[1] == 0) 437 t = ((s32)rom[0] >> 1)*1000; 438 else 439 t = 1000*(-1*(s32)(0x100-rom[0]) >> 1); 440 441 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 449 static inline int w1_convert_temp(u8 rom[9], u8 fid) 450 { 451 int i; 452 453 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) 454 if (w1_therm_families[i].f->fid == fid) 455 return w1_therm_families[i].convert(rom); 456 457 return 0; 458 } 459 460 static 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 */ 475 if (val == 0) 476 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 } 484 485 static ssize_t read_therm(struct device *device, 486 struct w1_slave *sl, struct therm_info *info) 487 { 488 struct w1_master *dev = sl->master; 489 u8 external_power; 490 int ret, max_trying = 10; 491 u8 *family_data = sl->family_data; 492 493 ret = mutex_lock_interruptible(&dev->bus_mutex); 494 if (ret != 0) 495 goto error; 496 497 if (!family_data) { 498 ret = -ENODEV; 499 goto mt_unlock; 500 } 501 502 /* prevent the slave from going away in sleep */ 503 atomic_inc(THERM_REFCNT(family_data)); 504 memset(info->rom, 0, sizeof(info->rom)); 505 506 while (max_trying--) { 507 508 info->verdict = 0; 509 info->crc = 0; 510 511 if (!w1_reset_select_slave(sl)) { 512 int count = 0; 513 unsigned int tm = 750; 514 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; 521 522 /* 750ms strong pullup (or delay) after the convert */ 523 if (w1_strong_pullup == 2 || 524 (!external_power && w1_strong_pullup)) 525 w1_next_pullup(dev, tm); 526 527 w1_write_8(dev, W1_CONVERT_TEMP); 528 529 if (external_power) { 530 mutex_unlock(&dev->bus_mutex); 531 532 sleep_rem = msleep_interruptible(tm); 533 if (sleep_rem != 0) { 534 ret = -EINTR; 535 goto dec_refcnt; 536 } 537 538 ret = mutex_lock_interruptible(&dev->bus_mutex); 539 if (ret != 0) 540 goto dec_refcnt; 541 } else if (!w1_strong_pullup) { 542 sleep_rem = msleep_interruptible(tm); 543 if (sleep_rem != 0) { 544 ret = -EINTR; 545 goto dec_refcnt; 546 } 547 } 548 549 if (!w1_reset_select_slave(sl)) { 550 551 w1_write_8(dev, W1_READ_SCRATCHPAD); 552 count = w1_read_block(dev, info->rom, 9); 553 if (count != 9) { 554 dev_warn(device, "w1_read_block() " 555 "returned %u instead of 9.\n", 556 count); 557 } 558 559 info->crc = w1_calc_crc8(info->rom, 8); 560 561 if (info->rom[8] == info->crc) 562 info->verdict = 1; 563 } 564 } 565 566 if (info->verdict) 567 break; 568 } 569 570 dec_refcnt: 571 atomic_dec(THERM_REFCNT(family_data)); 572 mt_unlock: 573 mutex_unlock(&dev->bus_mutex); 574 error: 575 return ret; 576 } 577 578 static 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 592 for (i = 0; i < 9; ++i) 593 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", info.rom[i]); 594 c -= snprintf(buf + PAGE_SIZE - c, c, ": crc=%02x %s\n", 595 info.crc, (info.verdict) ? "YES" : "NO"); 596 if (info.verdict) 597 memcpy(family_data, info.rom, sizeof(info.rom)); 598 else 599 dev_warn(device, "Read failed CRC check\n"); 600 601 for (i = 0; i < 9; ++i) 602 c -= snprintf(buf + PAGE_SIZE - c, c, "%02x ", 603 ((u8 *)family_data)[i]); 604 605 c -= snprintf(buf + PAGE_SIZE - c, c, "t=%d\n", 606 w1_convert_temp(info.rom, fid)); 607 ret = PAGE_SIZE - c; 608 return ret; 609 } 610 611 #if IS_REACHABLE(CONFIG_HWMON) 612 static 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 643 #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 653 static 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 665 mutex_lock(&sl->master->bus_mutex); 666 /* 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; 688 if (reg_num->family == W1_42_FINISHED_BYTE) 689 break; 690 if (sl->reg_num.id == reg_num->id) 691 seq = i; 692 693 w1_write_8(sl->master, W1_42_CHAIN); 694 w1_write_8(sl->master, W1_42_CHAIN_DONE); 695 w1_write_8(sl->master, W1_42_CHAIN_DONE_INV); 696 w1_read_block(sl->master, &ack, sizeof(ack)); 697 698 /* check for acknowledgment */ 699 ack = w1_read_8(sl->master); 700 if (ack != W1_42_SUCCESS_CONFIRM_BYTE) 701 goto error; 702 703 } 704 705 /* Exit from CHAIN state */ 706 if (w1_reset_bus(sl->master)) 707 goto error; 708 w1_write_8(sl->master, W1_SKIP_ROM); 709 w1_write_8(sl->master, W1_42_CHAIN); 710 w1_write_8(sl->master, W1_42_CHAIN_OFF); 711 w1_write_8(sl->master, W1_42_CHAIN_OFF_INV); 712 713 /* check for acknowledgment */ 714 ack = w1_read_8(sl->master); 715 if (ack != W1_42_SUCCESS_CONFIRM_BYTE) 716 goto error; 717 mutex_unlock(&sl->master->bus_mutex); 718 719 c -= snprintf(buf + PAGE_SIZE - c, c, "%d\n", seq); 720 return PAGE_SIZE - c; 721 error: 722 mutex_unlock(&sl->master->bus_mutex); 723 return -EIO; 724 } 725 726 static int __init w1_therm_init(void) 727 { 728 int err, i; 729 730 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) { 731 err = w1_register_family(w1_therm_families[i].f); 732 if (err) 733 w1_therm_families[i].broken = 1; 734 } 735 736 return 0; 737 } 738 739 static void __exit w1_therm_fini(void) 740 { 741 int i; 742 743 for (i = 0; i < ARRAY_SIZE(w1_therm_families); ++i) 744 if (!w1_therm_families[i].broken) 745 w1_unregister_family(w1_therm_families[i].f); 746 } 747 748 module_init(w1_therm_init); 749 module_exit(w1_therm_fini); 750 751 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>"); 752 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol, temperature family."); 753 MODULE_LICENSE("GPL"); 754 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18S20)); 755 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1822)); 756 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS18B20)); 757 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS1825)); 758 MODULE_ALIAS("w1-family-" __stringify(W1_THERM_DS28EA00)); 759