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 static int w1_control_timeout = 1; 49 int w1_max_slave_count = 10; 50 int w1_max_slave_ttl = 10; 51 52 module_param_named(timeout, w1_timeout, int, 0); 53 module_param_named(control_timeout, w1_control_timeout, int, 0); 54 module_param_named(max_slave_count, w1_max_slave_count, int, 0); 55 module_param_named(slave_ttl, w1_max_slave_ttl, int, 0); 56 57 DEFINE_SPINLOCK(w1_mlock); 58 LIST_HEAD(w1_masters); 59 60 static pid_t control_thread; 61 static int control_needs_exit; 62 static DECLARE_COMPLETION(w1_control_complete); 63 64 static int w1_master_match(struct device *dev, struct device_driver *drv) 65 { 66 return 1; 67 } 68 69 static int w1_master_probe(struct device *dev) 70 { 71 return -ENODEV; 72 } 73 74 static void w1_master_release(struct device *dev) 75 { 76 struct w1_master *md = dev_to_w1_master(dev); 77 78 dev_dbg(dev, "%s: Releasing %s.\n", __func__, md->name); 79 80 dev_fini_netlink(md); 81 memset(md, 0, sizeof(struct w1_master) + sizeof(struct w1_bus_master)); 82 kfree(md); 83 } 84 85 static void w1_slave_release(struct device *dev) 86 { 87 struct w1_slave *sl = dev_to_w1_slave(dev); 88 89 dev_dbg(dev, "%s: Releasing %s.\n", __func__, sl->name); 90 91 while (atomic_read(&sl->refcnt)) { 92 dev_dbg(dev, "Waiting for %s to become free: refcnt=%d.\n", 93 sl->name, atomic_read(&sl->refcnt)); 94 if (msleep_interruptible(1000)) 95 flush_signals(current); 96 } 97 98 w1_family_put(sl->family); 99 sl->master->slave_count--; 100 101 complete(&sl->released); 102 } 103 104 static ssize_t w1_slave_read_name(struct device *dev, struct device_attribute *attr, char *buf) 105 { 106 struct w1_slave *sl = dev_to_w1_slave(dev); 107 108 return sprintf(buf, "%s\n", sl->name); 109 } 110 111 static ssize_t w1_slave_read_id(struct kobject *kobj, char *buf, loff_t off, size_t count) 112 { 113 struct w1_slave *sl = kobj_to_w1_slave(kobj); 114 115 atomic_inc(&sl->refcnt); 116 if (off > 8) { 117 count = 0; 118 } else { 119 if (off + count > 8) 120 count = 8 - off; 121 122 memcpy(buf, (u8 *)&sl->reg_num, count); 123 } 124 atomic_dec(&sl->refcnt); 125 126 return count; 127 } 128 129 static struct device_attribute w1_slave_attr_name = 130 __ATTR(name, S_IRUGO, w1_slave_read_name, NULL); 131 132 static struct bin_attribute w1_slave_attr_bin_id = { 133 .attr = { 134 .name = "id", 135 .mode = S_IRUGO, 136 .owner = THIS_MODULE, 137 }, 138 .size = 8, 139 .read = w1_slave_read_id, 140 }; 141 142 /* Default family */ 143 static struct w1_family w1_default_family; 144 145 static int w1_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size); 146 147 static struct bus_type w1_bus_type = { 148 .name = "w1", 149 .match = w1_master_match, 150 .hotplug = w1_hotplug, 151 }; 152 153 struct device_driver w1_master_driver = { 154 .name = "w1_master_driver", 155 .bus = &w1_bus_type, 156 .probe = w1_master_probe, 157 }; 158 159 struct device w1_master_device = { 160 .parent = NULL, 161 .bus = &w1_bus_type, 162 .bus_id = "w1 bus master", 163 .driver = &w1_master_driver, 164 .release = &w1_master_release 165 }; 166 167 struct device_driver w1_slave_driver = { 168 .name = "w1_slave_driver", 169 .bus = &w1_bus_type, 170 }; 171 172 struct device w1_slave_device = { 173 .parent = NULL, 174 .bus = &w1_bus_type, 175 .bus_id = "w1 bus slave", 176 .driver = &w1_slave_driver, 177 .release = &w1_slave_release 178 }; 179 180 static ssize_t w1_master_attribute_show_name(struct device *dev, struct device_attribute *attr, char *buf) 181 { 182 struct w1_master *md = dev_to_w1_master(dev); 183 ssize_t count; 184 185 if (down_interruptible (&md->mutex)) 186 return -EBUSY; 187 188 count = sprintf(buf, "%s\n", md->name); 189 190 up(&md->mutex); 191 192 return count; 193 } 194 195 static ssize_t w1_master_attribute_store_search(struct device * dev, 196 struct device_attribute *attr, 197 const char * buf, size_t count) 198 { 199 struct w1_master *md = dev_to_w1_master(dev); 200 201 if (down_interruptible (&md->mutex)) 202 return -EBUSY; 203 204 md->search_count = simple_strtol(buf, NULL, 0); 205 206 up(&md->mutex); 207 208 return count; 209 } 210 211 static ssize_t w1_master_attribute_show_search(struct device *dev, 212 struct device_attribute *attr, 213 char *buf) 214 { 215 struct w1_master *md = dev_to_w1_master(dev); 216 ssize_t count; 217 218 if (down_interruptible (&md->mutex)) 219 return -EBUSY; 220 221 count = sprintf(buf, "%d\n", md->search_count); 222 223 up(&md->mutex); 224 225 return count; 226 } 227 228 static ssize_t w1_master_attribute_show_pointer(struct device *dev, struct device_attribute *attr, char *buf) 229 { 230 struct w1_master *md = dev_to_w1_master(dev); 231 ssize_t count; 232 233 if (down_interruptible(&md->mutex)) 234 return -EBUSY; 235 236 count = sprintf(buf, "0x%p\n", md->bus_master); 237 238 up(&md->mutex); 239 return count; 240 } 241 242 static ssize_t w1_master_attribute_show_timeout(struct device *dev, struct device_attribute *attr, char *buf) 243 { 244 ssize_t count; 245 count = sprintf(buf, "%d\n", w1_timeout); 246 return count; 247 } 248 249 static ssize_t w1_master_attribute_show_max_slave_count(struct device *dev, struct device_attribute *attr, char *buf) 250 { 251 struct w1_master *md = dev_to_w1_master(dev); 252 ssize_t count; 253 254 if (down_interruptible(&md->mutex)) 255 return -EBUSY; 256 257 count = sprintf(buf, "%d\n", md->max_slave_count); 258 259 up(&md->mutex); 260 return count; 261 } 262 263 static ssize_t w1_master_attribute_show_attempts(struct device *dev, struct device_attribute *attr, char *buf) 264 { 265 struct w1_master *md = dev_to_w1_master(dev); 266 ssize_t count; 267 268 if (down_interruptible(&md->mutex)) 269 return -EBUSY; 270 271 count = sprintf(buf, "%lu\n", md->attempts); 272 273 up(&md->mutex); 274 return count; 275 } 276 277 static ssize_t w1_master_attribute_show_slave_count(struct device *dev, struct device_attribute *attr, char *buf) 278 { 279 struct w1_master *md = dev_to_w1_master(dev); 280 ssize_t count; 281 282 if (down_interruptible(&md->mutex)) 283 return -EBUSY; 284 285 count = sprintf(buf, "%d\n", md->slave_count); 286 287 up(&md->mutex); 288 return count; 289 } 290 291 static ssize_t w1_master_attribute_show_slaves(struct device *dev, struct device_attribute *attr, char *buf) 292 { 293 struct w1_master *md = dev_to_w1_master(dev); 294 int c = PAGE_SIZE; 295 296 if (down_interruptible(&md->mutex)) 297 return -EBUSY; 298 299 if (md->slave_count == 0) 300 c -= snprintf(buf + PAGE_SIZE - c, c, "not found.\n"); 301 else { 302 struct list_head *ent, *n; 303 struct w1_slave *sl; 304 305 list_for_each_safe(ent, n, &md->slist) { 306 sl = list_entry(ent, struct w1_slave, w1_slave_entry); 307 308 c -= snprintf(buf + PAGE_SIZE - c, c, "%s\n", sl->name); 309 } 310 } 311 312 up(&md->mutex); 313 314 return PAGE_SIZE - c; 315 } 316 317 #define W1_MASTER_ATTR_RO(_name, _mode) \ 318 struct device_attribute w1_master_attribute_##_name = \ 319 __ATTR(w1_master_##_name, _mode, \ 320 w1_master_attribute_show_##_name, NULL) 321 322 #define W1_MASTER_ATTR_RW(_name, _mode) \ 323 struct device_attribute w1_master_attribute_##_name = \ 324 __ATTR(w1_master_##_name, _mode, \ 325 w1_master_attribute_show_##_name, \ 326 w1_master_attribute_store_##_name) 327 328 static W1_MASTER_ATTR_RO(name, S_IRUGO); 329 static W1_MASTER_ATTR_RO(slaves, S_IRUGO); 330 static W1_MASTER_ATTR_RO(slave_count, S_IRUGO); 331 static W1_MASTER_ATTR_RO(max_slave_count, S_IRUGO); 332 static W1_MASTER_ATTR_RO(attempts, S_IRUGO); 333 static W1_MASTER_ATTR_RO(timeout, S_IRUGO); 334 static W1_MASTER_ATTR_RO(pointer, S_IRUGO); 335 static W1_MASTER_ATTR_RW(search, S_IRUGO | S_IWUGO); 336 337 static struct attribute *w1_master_default_attrs[] = { 338 &w1_master_attribute_name.attr, 339 &w1_master_attribute_slaves.attr, 340 &w1_master_attribute_slave_count.attr, 341 &w1_master_attribute_max_slave_count.attr, 342 &w1_master_attribute_attempts.attr, 343 &w1_master_attribute_timeout.attr, 344 &w1_master_attribute_pointer.attr, 345 &w1_master_attribute_search.attr, 346 NULL 347 }; 348 349 static struct attribute_group w1_master_defattr_group = { 350 .attrs = w1_master_default_attrs, 351 }; 352 353 int w1_create_master_attributes(struct w1_master *master) 354 { 355 return sysfs_create_group(&master->dev.kobj, &w1_master_defattr_group); 356 } 357 358 void w1_destroy_master_attributes(struct w1_master *master) 359 { 360 sysfs_remove_group(&master->dev.kobj, &w1_master_defattr_group); 361 } 362 363 #ifdef CONFIG_HOTPLUG 364 static int w1_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) 365 { 366 struct w1_master *md = NULL; 367 struct w1_slave *sl = NULL; 368 char *event_owner, *name; 369 int err, cur_index=0, cur_len=0; 370 371 if (dev->driver == &w1_master_driver) { 372 md = container_of(dev, struct w1_master, dev); 373 event_owner = "master"; 374 name = md->name; 375 } else if (dev->driver == &w1_slave_driver) { 376 sl = container_of(dev, struct w1_slave, dev); 377 event_owner = "slave"; 378 name = sl->name; 379 } else { 380 dev_dbg(dev, "Unknown hotplug event.\n"); 381 return -EINVAL; 382 } 383 384 dev_dbg(dev, "Hotplug event for %s %s, bus_id=%s.\n", event_owner, name, dev->bus_id); 385 386 if (dev->driver != &w1_slave_driver || !sl) 387 return 0; 388 389 err = add_hotplug_env_var(envp, num_envp, &cur_index, buffer, buffer_size, &cur_len, "W1_FID=%02X", sl->reg_num.family); 390 if (err) 391 return err; 392 393 err = add_hotplug_env_var(envp, num_envp, &cur_index, buffer, buffer_size, &cur_len, "W1_SLAVE_ID=%024LX", (u64)sl->reg_num.id); 394 if (err) 395 return err; 396 397 return 0; 398 }; 399 #else 400 static int w1_hotplug(struct device *dev, char **envp, int num_envp, char *buffer, int buffer_size) 401 { 402 return 0; 403 } 404 #endif 405 406 static int __w1_attach_slave_device(struct w1_slave *sl) 407 { 408 int err; 409 410 sl->dev.parent = &sl->master->dev; 411 sl->dev.driver = &w1_slave_driver; 412 sl->dev.bus = &w1_bus_type; 413 sl->dev.release = &w1_slave_release; 414 415 snprintf(&sl->dev.bus_id[0], sizeof(sl->dev.bus_id), 416 "%02x-%012llx", 417 (unsigned int) sl->reg_num.family, 418 (unsigned long long) sl->reg_num.id); 419 snprintf(&sl->name[0], sizeof(sl->name), 420 "%02x-%012llx", 421 (unsigned int) sl->reg_num.family, 422 (unsigned long long) sl->reg_num.id); 423 424 dev_dbg(&sl->dev, "%s: registering %s as %p.\n", __func__, &sl->dev.bus_id[0]); 425 426 err = device_register(&sl->dev); 427 if (err < 0) { 428 dev_err(&sl->dev, 429 "Device registration [%s] failed. err=%d\n", 430 sl->dev.bus_id, err); 431 return err; 432 } 433 434 /* Create "name" entry */ 435 err = device_create_file(&sl->dev, &w1_slave_attr_name); 436 if (err < 0) { 437 dev_err(&sl->dev, 438 "sysfs file creation for [%s] failed. err=%d\n", 439 sl->dev.bus_id, err); 440 goto out_unreg; 441 } 442 443 /* Create "id" entry */ 444 err = sysfs_create_bin_file(&sl->dev.kobj, &w1_slave_attr_bin_id); 445 if (err < 0) { 446 dev_err(&sl->dev, 447 "sysfs file creation for [%s] failed. err=%d\n", 448 sl->dev.bus_id, err); 449 goto out_rem1; 450 } 451 452 /* if the family driver needs to initialize something... */ 453 if (sl->family->fops && sl->family->fops->add_slave && 454 ((err = sl->family->fops->add_slave(sl)) < 0)) { 455 dev_err(&sl->dev, 456 "sysfs file creation for [%s] failed. err=%d\n", 457 sl->dev.bus_id, err); 458 goto out_rem2; 459 } 460 461 list_add_tail(&sl->w1_slave_entry, &sl->master->slist); 462 463 return 0; 464 465 out_rem2: 466 sysfs_remove_bin_file(&sl->dev.kobj, &w1_slave_attr_bin_id); 467 out_rem1: 468 device_remove_file(&sl->dev, &w1_slave_attr_name); 469 out_unreg: 470 device_unregister(&sl->dev); 471 return err; 472 } 473 474 static int w1_attach_slave_device(struct w1_master *dev, struct w1_reg_num *rn) 475 { 476 struct w1_slave *sl; 477 struct w1_family *f; 478 int err; 479 struct w1_netlink_msg msg; 480 481 sl = kmalloc(sizeof(struct w1_slave), GFP_KERNEL); 482 if (!sl) { 483 dev_err(&dev->dev, 484 "%s: failed to allocate new slave device.\n", 485 __func__); 486 return -ENOMEM; 487 } 488 489 memset(sl, 0, sizeof(*sl)); 490 491 sl->owner = THIS_MODULE; 492 sl->master = dev; 493 set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags); 494 495 memcpy(&sl->reg_num, rn, sizeof(sl->reg_num)); 496 atomic_set(&sl->refcnt, 0); 497 init_completion(&sl->released); 498 499 spin_lock(&w1_flock); 500 f = w1_family_registered(rn->family); 501 if (!f) { 502 f= &w1_default_family; 503 dev_info(&dev->dev, "Family %x for %02x.%012llx.%02x is not registered.\n", 504 rn->family, rn->family, 505 (unsigned long long)rn->id, rn->crc); 506 } 507 __w1_family_get(f); 508 spin_unlock(&w1_flock); 509 510 sl->family = f; 511 512 513 err = __w1_attach_slave_device(sl); 514 if (err < 0) { 515 dev_err(&dev->dev, "%s: Attaching %s failed.\n", __func__, 516 sl->name); 517 w1_family_put(sl->family); 518 kfree(sl); 519 return err; 520 } 521 522 sl->ttl = dev->slave_ttl; 523 dev->slave_count++; 524 525 memcpy(&msg.id.id, rn, sizeof(msg.id.id)); 526 msg.type = W1_SLAVE_ADD; 527 w1_netlink_send(dev, &msg); 528 529 return 0; 530 } 531 532 static void w1_slave_detach(struct w1_slave *sl) 533 { 534 struct w1_netlink_msg msg; 535 536 dev_dbg(&sl->dev, "%s: detaching %s [%p].\n", __func__, sl->name, sl); 537 538 list_del(&sl->w1_slave_entry); 539 540 if (sl->family->fops && sl->family->fops->remove_slave) 541 sl->family->fops->remove_slave(sl); 542 543 memcpy(&msg.id.id, &sl->reg_num, sizeof(msg.id.id)); 544 msg.type = W1_SLAVE_REMOVE; 545 w1_netlink_send(sl->master, &msg); 546 547 sysfs_remove_bin_file(&sl->dev.kobj, &w1_slave_attr_bin_id); 548 device_remove_file(&sl->dev, &w1_slave_attr_name); 549 device_unregister(&sl->dev); 550 551 wait_for_completion(&sl->released); 552 kfree(sl); 553 } 554 555 static struct w1_master *w1_search_master(unsigned long data) 556 { 557 struct w1_master *dev; 558 int found = 0; 559 560 spin_lock_bh(&w1_mlock); 561 list_for_each_entry(dev, &w1_masters, w1_master_entry) { 562 if (dev->bus_master->data == data) { 563 found = 1; 564 atomic_inc(&dev->refcnt); 565 break; 566 } 567 } 568 spin_unlock_bh(&w1_mlock); 569 570 return (found)?dev:NULL; 571 } 572 573 void w1_reconnect_slaves(struct w1_family *f) 574 { 575 struct w1_master *dev; 576 577 spin_lock_bh(&w1_mlock); 578 list_for_each_entry(dev, &w1_masters, w1_master_entry) { 579 dev_dbg(&dev->dev, "Reconnecting slaves in %s into new family %02x.\n", 580 dev->name, f->fid); 581 set_bit(W1_MASTER_NEED_RECONNECT, &dev->flags); 582 } 583 spin_unlock_bh(&w1_mlock); 584 } 585 586 static void w1_slave_found(unsigned long data, u64 rn) 587 { 588 int slave_count; 589 struct w1_slave *sl; 590 struct list_head *ent; 591 struct w1_reg_num *tmp; 592 int family_found = 0; 593 struct w1_master *dev; 594 u64 rn_le = cpu_to_le64(rn); 595 596 dev = w1_search_master(data); 597 if (!dev) { 598 printk(KERN_ERR "Failed to find w1 master device for data %08lx, it is impossible.\n", 599 data); 600 return; 601 } 602 603 tmp = (struct w1_reg_num *) &rn; 604 605 slave_count = 0; 606 list_for_each(ent, &dev->slist) { 607 608 sl = list_entry(ent, struct w1_slave, w1_slave_entry); 609 610 if (sl->reg_num.family == tmp->family && 611 sl->reg_num.id == tmp->id && 612 sl->reg_num.crc == tmp->crc) { 613 set_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags); 614 break; 615 } else if (sl->reg_num.family == tmp->family) { 616 family_found = 1; 617 break; 618 } 619 620 slave_count++; 621 } 622 623 if (slave_count == dev->slave_count && 624 rn && ((rn >> 56) & 0xff) == w1_calc_crc8((u8 *)&rn_le, 7)) { 625 w1_attach_slave_device(dev, tmp); 626 } 627 628 atomic_dec(&dev->refcnt); 629 } 630 631 /** 632 * Performs a ROM Search & registers any devices found. 633 * The 1-wire search is a simple binary tree search. 634 * For each bit of the address, we read two bits and write one bit. 635 * The bit written will put to sleep all devies that don't match that bit. 636 * When the two reads differ, the direction choice is obvious. 637 * When both bits are 0, we must choose a path to take. 638 * When we can scan all 64 bits without having to choose a path, we are done. 639 * 640 * See "Application note 187 1-wire search algorithm" at www.maxim-ic.com 641 * 642 * @dev The master device to search 643 * @cb Function to call when a device is found 644 */ 645 void w1_search(struct w1_master *dev, w1_slave_found_callback cb) 646 { 647 u64 last_rn, rn, tmp64; 648 int i, slave_count = 0; 649 int last_zero, last_device; 650 int search_bit, desc_bit; 651 u8 triplet_ret = 0; 652 653 search_bit = 0; 654 rn = last_rn = 0; 655 last_device = 0; 656 last_zero = -1; 657 658 desc_bit = 64; 659 660 while ( !last_device && (slave_count++ < dev->max_slave_count) ) { 661 last_rn = rn; 662 rn = 0; 663 664 /* 665 * Reset bus and all 1-wire device state machines 666 * so they can respond to our requests. 667 * 668 * Return 0 - device(s) present, 1 - no devices present. 669 */ 670 if (w1_reset_bus(dev)) { 671 dev_dbg(&dev->dev, "No devices present on the wire.\n"); 672 break; 673 } 674 675 /* Start the search */ 676 w1_write_8(dev, W1_SEARCH); 677 for (i = 0; i < 64; ++i) { 678 /* Determine the direction/search bit */ 679 if (i == desc_bit) 680 search_bit = 1; /* took the 0 path last time, so take the 1 path */ 681 else if (i > desc_bit) 682 search_bit = 0; /* take the 0 path on the next branch */ 683 else 684 search_bit = ((last_rn >> i) & 0x1); 685 686 /** Read two bits and write one bit */ 687 triplet_ret = w1_triplet(dev, search_bit); 688 689 /* quit if no device responded */ 690 if ( (triplet_ret & 0x03) == 0x03 ) 691 break; 692 693 /* If both directions were valid, and we took the 0 path... */ 694 if (triplet_ret == 0) 695 last_zero = i; 696 697 /* extract the direction taken & update the device number */ 698 tmp64 = (triplet_ret >> 2); 699 rn |= (tmp64 << i); 700 } 701 702 if ( (triplet_ret & 0x03) != 0x03 ) { 703 if ( (desc_bit == last_zero) || (last_zero < 0)) 704 last_device = 1; 705 desc_bit = last_zero; 706 cb(dev->bus_master->data, rn); 707 } 708 } 709 } 710 711 static int w1_control(void *data) 712 { 713 struct w1_slave *sl, *sln; 714 struct w1_master *dev, *n; 715 int err, have_to_wait = 0; 716 717 daemonize("w1_control"); 718 allow_signal(SIGTERM); 719 720 while (!control_needs_exit || have_to_wait) { 721 have_to_wait = 0; 722 723 try_to_freeze(); 724 msleep_interruptible(w1_control_timeout * 1000); 725 726 if (signal_pending(current)) 727 flush_signals(current); 728 729 list_for_each_entry_safe(dev, n, &w1_masters, w1_master_entry) { 730 if (!control_needs_exit && !dev->flags) 731 continue; 732 /* 733 * Little race: we can create thread but not set the flag. 734 * Get a chance for external process to set flag up. 735 */ 736 if (!dev->initialized) { 737 have_to_wait = 1; 738 continue; 739 } 740 741 if (control_needs_exit) { 742 set_bit(W1_MASTER_NEED_EXIT, &dev->flags); 743 744 err = kill_proc(dev->kpid, SIGTERM, 1); 745 if (err) 746 dev_err(&dev->dev, 747 "Failed to send signal to w1 kernel thread %d.\n", 748 dev->kpid); 749 } 750 751 if (test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) { 752 wait_for_completion(&dev->dev_exited); 753 spin_lock_bh(&w1_mlock); 754 list_del(&dev->w1_master_entry); 755 spin_unlock_bh(&w1_mlock); 756 757 down(&dev->mutex); 758 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) { 759 w1_slave_detach(sl); 760 } 761 w1_destroy_master_attributes(dev); 762 up(&dev->mutex); 763 atomic_dec(&dev->refcnt); 764 continue; 765 } 766 767 if (test_bit(W1_MASTER_NEED_RECONNECT, &dev->flags)) { 768 dev_dbg(&dev->dev, "Reconnecting slaves in device %s.\n", dev->name); 769 down(&dev->mutex); 770 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) { 771 if (sl->family->fid == W1_FAMILY_DEFAULT) { 772 struct w1_reg_num rn; 773 774 memcpy(&rn, &sl->reg_num, sizeof(rn)); 775 w1_slave_detach(sl); 776 777 w1_attach_slave_device(dev, &rn); 778 } 779 } 780 dev_dbg(&dev->dev, "Reconnecting slaves in device %s has been finished.\n", dev->name); 781 clear_bit(W1_MASTER_NEED_RECONNECT, &dev->flags); 782 up(&dev->mutex); 783 } 784 } 785 } 786 787 complete_and_exit(&w1_control_complete, 0); 788 } 789 790 int w1_process(void *data) 791 { 792 struct w1_master *dev = (struct w1_master *) data; 793 struct w1_slave *sl, *sln; 794 795 daemonize("%s", dev->name); 796 allow_signal(SIGTERM); 797 798 while (!test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) { 799 try_to_freeze(); 800 msleep_interruptible(w1_timeout * 1000); 801 802 if (signal_pending(current)) 803 flush_signals(current); 804 805 if (test_bit(W1_MASTER_NEED_EXIT, &dev->flags)) 806 break; 807 808 if (!dev->initialized) 809 continue; 810 811 if (dev->search_count == 0) 812 continue; 813 814 if (down_interruptible(&dev->mutex)) 815 continue; 816 817 list_for_each_entry(sl, &dev->slist, w1_slave_entry) 818 clear_bit(W1_SLAVE_ACTIVE, (long *)&sl->flags); 819 820 w1_search_devices(dev, w1_slave_found); 821 822 list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry) { 823 if (!test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags) && !--sl->ttl) { 824 w1_slave_detach(sl); 825 826 dev->slave_count--; 827 } else if (test_bit(W1_SLAVE_ACTIVE, (unsigned long *)&sl->flags)) 828 sl->ttl = dev->slave_ttl; 829 } 830 831 if (dev->search_count > 0) 832 dev->search_count--; 833 834 up(&dev->mutex); 835 } 836 837 atomic_dec(&dev->refcnt); 838 complete_and_exit(&dev->dev_exited, 0); 839 840 return 0; 841 } 842 843 static int w1_init(void) 844 { 845 int retval; 846 847 printk(KERN_INFO "Driver for 1-wire Dallas network protocol.\n"); 848 849 retval = bus_register(&w1_bus_type); 850 if (retval) { 851 printk(KERN_ERR "Failed to register bus. err=%d.\n", retval); 852 goto err_out_exit_init; 853 } 854 855 retval = driver_register(&w1_master_driver); 856 if (retval) { 857 printk(KERN_ERR 858 "Failed to register master driver. err=%d.\n", 859 retval); 860 goto err_out_bus_unregister; 861 } 862 863 retval = driver_register(&w1_slave_driver); 864 if (retval) { 865 printk(KERN_ERR 866 "Failed to register master driver. err=%d.\n", 867 retval); 868 goto err_out_master_unregister; 869 } 870 871 control_thread = kernel_thread(&w1_control, NULL, 0); 872 if (control_thread < 0) { 873 printk(KERN_ERR "Failed to create control thread. err=%d\n", 874 control_thread); 875 retval = control_thread; 876 goto err_out_slave_unregister; 877 } 878 879 return 0; 880 881 err_out_slave_unregister: 882 driver_unregister(&w1_slave_driver); 883 884 err_out_master_unregister: 885 driver_unregister(&w1_master_driver); 886 887 err_out_bus_unregister: 888 bus_unregister(&w1_bus_type); 889 890 err_out_exit_init: 891 return retval; 892 } 893 894 static void w1_fini(void) 895 { 896 struct w1_master *dev; 897 898 list_for_each_entry(dev, &w1_masters, w1_master_entry) 899 __w1_remove_master_device(dev); 900 901 control_needs_exit = 1; 902 wait_for_completion(&w1_control_complete); 903 904 driver_unregister(&w1_slave_driver); 905 driver_unregister(&w1_master_driver); 906 bus_unregister(&w1_bus_type); 907 } 908 909 module_init(w1_init); 910 module_exit(w1_fini); 911