1 /* 2 * w1.c 3 * 4 * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru> 5 * 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms 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 <linux/delay.h> 23 #include <linux/kernel.h> 24 #include <linux/module.h> 25 #include <linux/moduleparam.h> 26 #include <linux/list.h> 27 #include <linux/interrupt.h> 28 #include <linux/spinlock.h> 29 #include <linux/timer.h> 30 #include <linux/device.h> 31 #include <linux/slab.h> 32 #include <linux/sched.h> 33 34 #include <asm/atomic.h> 35 36 #include "w1.h" 37 #include "w1_io.h" 38 #include "w1_log.h" 39 #include "w1_int.h" 40 #include "w1_family.h" 41 #include "w1_netlink.h" 42 43 MODULE_LICENSE("GPL"); 44 MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>"); 45 MODULE_DESCRIPTION("Driver for 1-wire Dallas network protocol."); 46 47 static int w1_timeout = 10; 48 int w1_max_slave_count = 10; 49 int w1_max_slave_ttl = 10; 50 51 module_param_named(timeout, w1_timeout, int, 0); 52 module_param_named(max_slave_count, w1_max_slave_count, int, 0); 53 module_param_named(slave_ttl, w1_max_slave_ttl, int, 0); 54 55 DEFINE_SPINLOCK(w1_mlock); 56 LIST_HEAD(w1_masters); 57 58 static pid_t control_thread; 59 static int control_needs_exit; 60 static DECLARE_COMPLETION(w1_control_complete); 61 62 static int w1_master_match(struct device *dev, struct device_driver *drv) 63 { 64 return 1; 65 } 66 67 static int w1_master_probe(struct device *dev) 68 { 69 return -ENODEV; 70 } 71 72 static int w1_master_remove(struct device *dev) 73 { 74 return 0; 75 } 76 77 static void w1_master_release(struct device *dev) 78 { 79 struct w1_master *md = container_of(dev, struct w1_master, dev); 80 81 complete(&md->dev_released); 82 } 83 84 static void w1_slave_release(struct device *dev) 85 { 86 struct w1_slave *sl = container_of(dev, struct w1_slave, dev); 87 88 complete(&sl->dev_released); 89 } 90 91 static ssize_t w1_default_read_name(struct device *dev, char *buf) 92 { 93 return sprintf(buf, "No family registered.\n"); 94 } 95 96 static ssize_t w1_default_read_bin(struct kobject *kobj, char *buf, loff_t off, 97 size_t count) 98 { 99 return sprintf(buf, "No family registered.\n"); 100 } 101 102 static struct bus_type w1_bus_type = { 103 .name = "w1", 104 .match = w1_master_match, 105 }; 106 107 struct device_driver w1_driver = { 108 .name = "w1_driver", 109 .bus = &w1_bus_type, 110 .probe = w1_master_probe, 111 .remove = w1_master_remove, 112 }; 113 114 struct device w1_device = { 115 .parent = NULL, 116 .bus = &w1_bus_type, 117 .bus_id = "w1 bus master", 118 .driver = &w1_driver, 119 .release = &w1_master_release 120 }; 121 122 static struct device_attribute w1_slave_attribute = { 123 .attr = { 124 .name = "name", 125 .mode = S_IRUGO, 126 .owner = THIS_MODULE 127 }, 128 .show = &w1_default_read_name, 129 }; 130 131 static struct device_attribute w1_slave_attribute_val = { 132 .attr = { 133 .name = "value", 134 .mode = S_IRUGO, 135 .owner = THIS_MODULE 136 }, 137 .show = &w1_default_read_name, 138 }; 139 140 static ssize_t w1_master_attribute_show_name(struct device *dev, char *buf) 141 { 142 struct w1_master *md = container_of (dev, struct w1_master, dev); 143 ssize_t count; 144 145 if (down_interruptible (&md->mutex)) 146 return -EBUSY; 147 148 count = sprintf(buf, "%s\n", md->name); 149 150 up(&md->mutex); 151 152 return count; 153 } 154 155 static ssize_t w1_master_attribute_show_pointer(struct device *dev, char *buf) 156 { 157 struct w1_master *md = container_of(dev, struct w1_master, dev); 158 ssize_t count; 159 160 if (down_interruptible(&md->mutex)) 161 return -EBUSY; 162 163 count = sprintf(buf, "0x%p\n", md->bus_master); 164 165 up(&md->mutex); 166 return count; 167 } 168 169 static ssize_t w1_master_attribute_show_timeout(struct device *dev, char *buf) 170 { 171 ssize_t count; 172 count = sprintf(buf, "%d\n", w1_timeout); 173 return count; 174 } 175 176 static ssize_t w1_master_attribute_show_max_slave_count(struct device *dev, char *buf) 177 { 178 struct w1_master *md = container_of(dev, struct w1_master, dev); 179 ssize_t count; 180 181 if (down_interruptible(&md->mutex)) 182 return -EBUSY; 183 184 count = sprintf(buf, "%d\n", md->max_slave_count); 185 186 up(&md->mutex); 187 return count; 188 } 189 190 static ssize_t w1_master_attribute_show_attempts(struct device *dev, char *buf) 191 { 192 struct w1_master *md = container_of(dev, struct w1_master, dev); 193 ssize_t count; 194 195 if (down_interruptible(&md->mutex)) 196 return -EBUSY; 197 198 count = sprintf(buf, "%lu\n", md->attempts); 199 200 up(&md->mutex); 201 return count; 202 } 203 204 static ssize_t w1_master_attribute_show_slave_count(struct device *dev, char *buf) 205 { 206 struct w1_master *md = container_of(dev, struct w1_master, dev); 207 ssize_t count; 208 209 if (down_interruptible(&md->mutex)) 210 return -EBUSY; 211 212 count = sprintf(buf, "%d\n", md->slave_count); 213 214 up(&md->mutex); 215 return count; 216 } 217 218 static ssize_t w1_master_attribute_show_slaves(struct device *dev, char *buf) 219 220 { 221 struct w1_master *md = container_of(dev, struct w1_master, dev); 222 int c = PAGE_SIZE; 223 224 if (down_interruptible(&md->mutex)) 225 return -EBUSY; 226 227 if (md->slave_count == 0) 228 c -= snprintf(buf + PAGE_SIZE - c, c, "not found.\n"); 229 else { 230 struct list_head *ent, *n; 231 struct w1_slave *sl; 232 233 list_for_each_safe(ent, n, &md->slist) { 234 sl = list_entry(ent, struct w1_slave, w1_slave_entry); 235 236 c -= snprintf(buf + PAGE_SIZE - c, c, "%s\n", sl->name); 237 } 238 } 239 240 up(&md->mutex); 241 242 return PAGE_SIZE - c; 243 } 244 245 static struct device_attribute w1_master_attribute_slaves = { 246 .attr = { 247 .name = "w1_master_slaves", 248 .mode = S_IRUGO, 249 .owner = THIS_MODULE, 250 }, 251 .show = &w1_master_attribute_show_slaves, 252 }; 253 static struct device_attribute w1_master_attribute_slave_count = { 254 .attr = { 255 .name = "w1_master_slave_count", 256 .mode = S_IRUGO, 257 .owner = THIS_MODULE 258 }, 259 .show = &w1_master_attribute_show_slave_count, 260 }; 261 static struct device_attribute w1_master_attribute_attempts = { 262 .attr = { 263 .name = "w1_master_attempts", 264 .mode = S_IRUGO, 265 .owner = THIS_MODULE 266 }, 267 .show = &w1_master_attribute_show_attempts, 268 }; 269 static struct device_attribute w1_master_attribute_max_slave_count = { 270 .attr = { 271 .name = "w1_master_max_slave_count", 272 .mode = S_IRUGO, 273 .owner = THIS_MODULE 274 }, 275 .show = &w1_master_attribute_show_max_slave_count, 276 }; 277 static struct device_attribute w1_master_attribute_timeout = { 278 .attr = { 279 .name = "w1_master_timeout", 280 .mode = S_IRUGO, 281 .owner = THIS_MODULE 282 }, 283 .show = &w1_master_attribute_show_timeout, 284 }; 285 static struct device_attribute w1_master_attribute_pointer = { 286 .attr = { 287 .name = "w1_master_pointer", 288 .mode = S_IRUGO, 289 .owner = THIS_MODULE 290 }, 291 .show = &w1_master_attribute_show_pointer, 292 }; 293 static struct device_attribute w1_master_attribute_name = { 294 .attr = { 295 .name = "w1_master_name", 296 .mode = S_IRUGO, 297 .owner = THIS_MODULE 298 }, 299 .show = &w1_master_attribute_show_name, 300 }; 301 302 static struct bin_attribute w1_slave_bin_attribute = { 303 .attr = { 304 .name = "w1_slave", 305 .mode = S_IRUGO, 306 .owner = THIS_MODULE, 307 }, 308 .size = W1_SLAVE_DATA_SIZE, 309 .read = &w1_default_read_bin, 310 }; 311 312 static int __w1_attach_slave_device(struct w1_slave *sl) 313 { 314 int err; 315 316 sl->dev.parent = &sl->master->dev; 317 sl->dev.driver = sl->master->driver; 318 sl->dev.bus = &w1_bus_type; 319 sl->dev.release = &w1_slave_release; 320 321 snprintf(&sl->dev.bus_id[0], sizeof(sl->dev.bus_id), 322 "%02x-%012llx", 323 (unsigned int) sl->reg_num.family, 324 (unsigned long long) sl->reg_num.id); 325 snprintf (&sl->name[0], sizeof(sl->name), 326 "%02x-%012llx", 327 (unsigned int) sl->reg_num.family, 328 (unsigned long long) sl->reg_num.id); 329 330 dev_dbg(&sl->dev, "%s: registering %s.\n", __func__, 331 &sl->dev.bus_id[0]); 332 333 err = device_register(&sl->dev); 334 if (err < 0) { 335 dev_err(&sl->dev, 336 "Device registration [%s] failed. err=%d\n", 337 sl->dev.bus_id, err); 338 return err; 339 } 340 341 memcpy(&sl->attr_bin, &w1_slave_bin_attribute, sizeof(sl->attr_bin)); 342 memcpy(&sl->attr_name, &w1_slave_attribute, sizeof(sl->attr_name)); 343 memcpy(&sl->attr_val, &w1_slave_attribute_val, sizeof(sl->attr_val)); 344 345 sl->attr_bin.read = sl->family->fops->rbin; 346 sl->attr_name.show = sl->family->fops->rname; 347 sl->attr_val.show = sl->family->fops->rval; 348 sl->attr_val.attr.name = sl->family->fops->rvalname; 349 350 err = device_create_file(&sl->dev, &sl->attr_name); 351 if (err < 0) { 352 dev_err(&sl->dev, 353 "sysfs file creation for [%s] failed. err=%d\n", 354 sl->dev.bus_id, err); 355 device_unregister(&sl->dev); 356 return err; 357 } 358 359 err = device_create_file(&sl->dev, &sl->attr_val); 360 if (err < 0) { 361 dev_err(&sl->dev, 362 "sysfs file creation for [%s] failed. err=%d\n", 363 sl->dev.bus_id, err); 364 device_remove_file(&sl->dev, &sl->attr_name); 365 device_unregister(&sl->dev); 366 return err; 367 } 368 369 err = sysfs_create_bin_file(&sl->dev.kobj, &sl->attr_bin); 370 if (err < 0) { 371 dev_err(&sl->dev, 372 "sysfs file creation for [%s] failed. err=%d\n", 373 sl->dev.bus_id, err); 374 device_remove_file(&sl->dev, &sl->attr_name); 375 device_remove_file(&sl->dev, &sl->attr_val); 376 device_unregister(&sl->dev); 377 return err; 378 } 379 380 list_add_tail(&sl->w1_slave_entry, &sl->master->slist); 381 382 return 0; 383 } 384 385 static int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn) 386 { 387 struct w1_slave *sl; 388 struct w1_family *f; 389 int err; 390 struct w1_netlink_msg msg; 391 392 sl = kmalloc(sizeof(struct w1_slave), GFP_KERNEL); 393 if (!sl) { 394 dev_err(&dev->dev, 395 "%s: failed to allocate new slave device.\n", 396 __func__); 397 return -ENOMEM; 398 } 399 400 memset(sl, 0, sizeof(*sl)); 401 402 sl->owner = THIS_MODULE; 403 sl->master = dev; 404 set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags); 405 406 memcpy(&sl->reg_num, rn, sizeof(sl->reg_num)); 407 atomic_set(&sl->refcnt, 0); 408 init_completion(&sl->dev_released); 409 410 spin_lock(&w1_flock); 411 f = w1_family_registered(rn->family); 412 if (!f) { 413 spin_unlock(&w1_flock); 414 dev_info(&dev->dev, "Family %x for %02x.%012llx.%02x is not registered.\n", 415 rn->family, rn->family, 416 (unsigned long long)rn->id, rn->crc); 417 kfree(sl); 418 return -ENODEV; 419 } 420 __w1_family_get(f); 421 spin_unlock(&w1_flock); 422 423 sl->family = f; 424 425 426 err = __w1_attach_slave_device(sl); 427 if (err < 0) { 428 dev_err(&dev->dev, "%s: Attaching %s failed.\n", __func__, 429 sl->name); 430 w1_family_put(sl->family); 431 kfree(sl); 432 return err; 433 } 434 435 sl->ttl = dev->slave_ttl; 436 dev->slave_count++; 437 438 memcpy(&msg.id.id, rn, sizeof(msg.id.id)); 439 msg.type = W1_SLAVE_ADD; 440 w1_netlink_send(dev, &msg); 441 442 return 0; 443 } 444 445 static void w1_slave_detach(struct w1_slave *sl) 446 { 447 struct w1_netlink_msg msg; 448 449 dev_info(&sl->dev, "%s: detaching %s.\n", __func__, sl->name); 450 451 while (atomic_read(&sl->refcnt)) { 452 printk(KERN_INFO "Waiting for %s to become free: refcnt=%d.\n", 453 sl->name, atomic_read(&sl->refcnt)); 454 455 if (msleep_interruptible(1000)) 456 flush_signals(current); 457 } 458 459 sysfs_remove_bin_file (&sl->dev.kobj, &sl->attr_bin); 460 device_remove_file(&sl->dev, &sl->attr_name); 461 device_remove_file(&sl->dev, &sl->attr_val); 462 device_unregister(&sl->dev); 463 w1_family_put(sl->family); 464 465 memcpy(&msg.id.id, &sl->reg_num, sizeof(msg.id.id)); 466 msg.type = W1_SLAVE_REMOVE; 467 w1_netlink_send(sl->master, &msg); 468 } 469 470 static struct w1_master *w1_search_master(unsigned long data) 471 { 472 struct w1_master *dev; 473 int found = 0; 474 475 spin_lock_irq(&w1_mlock); 476 list_for_each_entry(dev, &w1_masters, w1_master_entry) { 477 if (dev->bus_master->data == data) { 478 found = 1; 479 atomic_inc(&dev->refcnt); 480 break; 481 } 482 } 483 spin_unlock_irq(&w1_mlock); 484 485 return (found)?dev:NULL; 486 } 487 488 void w1_slave_found(unsigned long data, u64 rn) 489 { 490 int slave_count; 491 struct w1_slave *sl; 492 struct list_head *ent; 493 struct w1_reg_num *tmp; 494 int family_found = 0; 495 struct w1_master *dev; 496 497 dev = w1_search_master(data); 498 if (!dev) { 499 printk(KERN_ERR "Failed to find w1 master device for data %08lx, it is impossible.\n", 500 data); 501 return; 502 } 503 504 tmp = (struct w1_reg_num *) &rn; 505 506 slave_count = 0; 507 list_for_each(ent, &dev->slist) { 508 509 sl = list_entry(ent, struct w1_slave, w1_slave_entry); 510 511 if (sl->reg_num.family == tmp->family && 512 sl->reg_num.id == tmp->id && 513 sl->reg_num.crc == tmp->crc) { 514 set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags); 515 break; 516 } 517 else if (sl->reg_num.family == tmp->family) { 518 family_found = 1; 519 break; 520 } 521 522 slave_count++; 523 } 524 525 rn = cpu_to_le64(rn); 526 527 if (slave_count == dev->slave_count && 528 rn && ((le64_to_cpu(rn) >> 56) & 0xff) == w1_calc_crc8((u8 *)&rn, 7)) { 529 w1_attach_slave_device(dev, tmp); 530 } 531 532 atomic_dec(&dev->refcnt); 533 } 534 535 void w1_search(struct w1_master *dev) 536 { 537 u64 last, rn, tmp; 538 int i, count = 0; 539 int last_family_desc, last_zero, last_device; 540 int search_bit, id_bit, comp_bit, desc_bit; 541 542 search_bit = id_bit = comp_bit = 0; 543 rn = tmp = last = 0; 544 last_device = last_zero = last_family_desc = 0; 545 546 desc_bit = 64; 547 548 while (!(id_bit && comp_bit) && !last_device 549 && count++ < dev->max_slave_count) { 550 last = rn; 551 rn = 0; 552 553 last_family_desc = 0; 554 555 /* 556 * Reset bus and all 1-wire device state machines 557 * so they can respond to our requests. 558 * 559 * Return 0 - device(s) present, 1 - no devices present. 560 */ 561 if (w1_reset_bus(dev)) { 562 dev_info(&dev->dev, "No devices present on the wire.\n"); 563 break; 564 } 565 566 #if 1 567 w1_write_8(dev, W1_SEARCH); 568 for (i = 0; i < 64; ++i) { 569 /* 570 * Read 2 bits from bus. 571 * All who don't sleep must send ID bit and COMPLEMENT ID bit. 572 * They actually are ANDed between all senders. 573 */ 574 id_bit = w1_touch_bit(dev, 1); 575 comp_bit = w1_touch_bit(dev, 1); 576 577 if (id_bit && comp_bit) 578 break; 579 580 if (id_bit == 0 && comp_bit == 0) { 581 if (i == desc_bit) 582 search_bit = 1; 583 else if (i > desc_bit) 584 search_bit = 0; 585 else 586 search_bit = ((last >> i) & 0x1); 587 588 if (search_bit == 0) { 589 last_zero = i; 590 if (last_zero < 9) 591 last_family_desc = last_zero; 592 } 593 594 } 595 else 596 search_bit = id_bit; 597 598 tmp = search_bit; 599 rn |= (tmp << i); 600 601 /* 602 * Write 1 bit to bus 603 * and make all who don't have "search_bit" in "i"'th position 604 * in it's registration number sleep. 605 */ 606 if (dev->bus_master->touch_bit) 607 w1_touch_bit(dev, search_bit); 608 else 609 w1_write_bit(dev, search_bit); 610 611 } 612 #endif 613 614 if (desc_bit == last_zero) 615 last_device = 1; 616 617 desc_bit = last_zero; 618 619 w1_slave_found(dev->bus_master->data, rn); 620 } 621 } 622 623 int w1_create_master_attributes(struct w1_master *dev) 624 { 625 if ( device_create_file(&dev->dev, &w1_master_attribute_slaves) < 0 || 626 device_create_file(&dev->dev, &w1_master_attribute_slave_count) < 0 || 627 device_create_file(&dev->dev, &w1_master_attribute_attempts) < 0 || 628 device_create_file(&dev->dev, &w1_master_attribute_max_slave_count) < 0 || 629 device_create_file(&dev->dev, &w1_master_attribute_timeout) < 0|| 630 device_create_file(&dev->dev, &w1_master_attribute_pointer) < 0|| 631 device_create_file(&dev->dev, &w1_master_attribute_name) < 0) 632 return -EINVAL; 633 634 return 0; 635 } 636 637 void w1_destroy_master_attributes(struct w1_master *dev) 638 { 639 device_remove_file(&dev->dev, &w1_master_attribute_slaves); 640 device_remove_file(&dev->dev, &w1_master_attribute_slave_count); 641 device_remove_file(&dev->dev, &w1_master_attribute_attempts); 642 device_remove_file(&dev->dev, &w1_master_attribute_max_slave_count); 643 device_remove_file(&dev->dev, &w1_master_attribute_timeout); 644 device_remove_file(&dev->dev, &w1_master_attribute_pointer); 645 device_remove_file(&dev->dev, &w1_master_attribute_name); 646 } 647 648 649 int w1_control(void *data) 650 { 651 struct w1_slave *sl; 652 struct w1_master *dev; 653 struct list_head *ent, *ment, *n, *mn; 654 int err, have_to_wait = 0; 655 656 daemonize("w1_control"); 657 allow_signal(SIGTERM); 658 659 while (!control_needs_exit || have_to_wait) { 660 have_to_wait = 0; 661 662 try_to_freeze(PF_FREEZE); 663 msleep_interruptible(w1_timeout * 1000); 664 665 if (signal_pending(current)) 666 flush_signals(current); 667 668 list_for_each_safe(ment, mn, &w1_masters) { 669 dev = list_entry(ment, struct w1_master, w1_master_entry); 670 671 if (!control_needs_exit && !dev->need_exit) 672 continue; 673 /* 674 * Little race: we can create thread but not set the flag. 675 * Get a chance for external process to set flag up. 676 */ 677 if (!dev->initialized) { 678 have_to_wait = 1; 679 continue; 680 } 681 682 spin_lock(&w1_mlock); 683 list_del(&dev->w1_master_entry); 684 spin_unlock(&w1_mlock); 685 686 if (control_needs_exit) { 687 dev->need_exit = 1; 688 689 err = kill_proc(dev->kpid, SIGTERM, 1); 690 if (err) 691 dev_err(&dev->dev, 692 "Failed to send signal to w1 kernel thread %d.\n", 693 dev->kpid); 694 } 695 696 wait_for_completion(&dev->dev_exited); 697 698 list_for_each_safe(ent, n, &dev->slist) { 699 sl = list_entry(ent, struct w1_slave, w1_slave_entry); 700 701 if (!sl) 702 dev_warn(&dev->dev, 703 "%s: slave entry is NULL.\n", 704 __func__); 705 else { 706 list_del(&sl->w1_slave_entry); 707 708 w1_slave_detach(sl); 709 kfree(sl); 710 } 711 } 712 w1_destroy_master_attributes(dev); 713 atomic_dec(&dev->refcnt); 714 } 715 } 716 717 complete_and_exit(&w1_control_complete, 0); 718 } 719 720 int w1_process(void *data) 721 { 722 struct w1_master *dev = (struct w1_master *) data; 723 struct list_head *ent, *n; 724 struct w1_slave *sl; 725 726 daemonize("%s", dev->name); 727 allow_signal(SIGTERM); 728 729 while (!dev->need_exit) { 730 try_to_freeze(PF_FREEZE); 731 msleep_interruptible(w1_timeout * 1000); 732 733 if (signal_pending(current)) 734 flush_signals(current); 735 736 if (dev->need_exit) 737 break; 738 739 if (!dev->initialized) 740 continue; 741 742 if (down_interruptible(&dev->mutex)) 743 continue; 744 745 list_for_each_safe(ent, n, &dev->slist) { 746 sl = list_entry(ent, struct w1_slave, w1_slave_entry); 747 748 if (sl) 749 clear_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags); 750 } 751 752 w1_search_devices(dev, w1_slave_found); 753 754 list_for_each_safe(ent, n, &dev->slist) { 755 sl = list_entry(ent, struct w1_slave, w1_slave_entry); 756 757 if (sl && !test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl) { 758 list_del (&sl->w1_slave_entry); 759 760 w1_slave_detach (sl); 761 kfree (sl); 762 763 dev->slave_count--; 764 } 765 else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags)) 766 sl->ttl = dev->slave_ttl; 767 } 768 up(&dev->mutex); 769 } 770 771 atomic_dec(&dev->refcnt); 772 complete_and_exit(&dev->dev_exited, 0); 773 774 return 0; 775 } 776 777 int w1_init(void) 778 { 779 int retval; 780 781 printk(KERN_INFO "Driver for 1-wire Dallas network protocol.\n"); 782 783 retval = bus_register(&w1_bus_type); 784 if (retval) { 785 printk(KERN_ERR "Failed to register bus. err=%d.\n", retval); 786 goto err_out_exit_init; 787 } 788 789 retval = driver_register(&w1_driver); 790 if (retval) { 791 printk(KERN_ERR 792 "Failed to register master driver. err=%d.\n", 793 retval); 794 goto err_out_bus_unregister; 795 } 796 797 control_thread = kernel_thread(&w1_control, NULL, 0); 798 if (control_thread < 0) { 799 printk(KERN_ERR "Failed to create control thread. err=%d\n", 800 control_thread); 801 retval = control_thread; 802 goto err_out_driver_unregister; 803 } 804 805 return 0; 806 807 err_out_driver_unregister: 808 driver_unregister(&w1_driver); 809 810 err_out_bus_unregister: 811 bus_unregister(&w1_bus_type); 812 813 err_out_exit_init: 814 return retval; 815 } 816 817 void w1_fini(void) 818 { 819 struct w1_master *dev; 820 struct list_head *ent, *n; 821 822 list_for_each_safe(ent, n, &w1_masters) { 823 dev = list_entry(ent, struct w1_master, w1_master_entry); 824 __w1_remove_master_device(dev); 825 } 826 827 control_needs_exit = 1; 828 829 wait_for_completion(&w1_control_complete); 830 831 driver_unregister(&w1_driver); 832 bus_unregister(&w1_bus_type); 833 } 834 835 module_init(w1_init); 836 module_exit(w1_fini); 837