1 files changed, 72 insertions, 16 deletions

diff --git a/drivers/w1/w1_int.c b/drivers/w1/w1_int.c
index 6840dfebe4d4..a3a54567bfba 100644
--- a/drivers/w1/w1_int.c
+++ b/drivers/w1/w1_int.c
@@ -29,7 +29,11 @@
 #include "w1_netlink.h"
 #include "w1_int.h"
 
-static u32 w1_ids = 1;
+static int w1_search_count = -1; /* Default is continual scan */
+module_param_named(search_count, w1_search_count, int, 0);
+
+static int w1_enable_pullup = 1;
+module_param_named(enable_pullup, w1_enable_pullup, int, 0);
 
 static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
                                        struct device_driver *driver,
@@ -59,8 +63,12 @@ static struct w1_master * w1_alloc_dev(u32 id, int slave_count, int slave_ttl,
         dev->initialized        = 0;
         dev->id                 = id;
         dev->slave_ttl          = slave_ttl;
-        dev->search_count       = -1; /* continual scan */
+        dev->search_count       = w1_search_count;
+        dev->enable_pullup      = w1_enable_pullup;
 
+        /* 1 for w1_process to decrement
+         * 1 for __w1_remove_master_device to decrement
+         */
         atomic_set(&dev->refcnt, 2);
 
         INIT_LIST_HEAD(&dev->slist);
@@ -93,9 +101,10 @@ static void w1_free_dev(struct w1_master *dev)
 
 int w1_add_master_device(struct w1_bus_master *master)
 {
-        struct w1_master *dev;
+        struct w1_master *dev, *entry;
         int retval = 0;
         struct w1_netlink_msg msg;
+        int id, found;
 
         /* validate minimum functionality */
         if (!(master->touch_bit && master->reset_bus) &&
@@ -104,10 +113,50 @@ int w1_add_master_device(struct w1_bus_master *master)
                 printk(KERN_ERR "w1_add_master_device: invalid function set\n");
                 return(-EINVAL);
         }
+        /* While it would be electrically possible to make a device that
+         * generated a strong pullup in bit bang mode, only hardare that
+         * controls 1-wire time frames are even expected to support a strong
+         * pullup.  w1_io.c would need to support calling set_pullup before
+         * the last write_bit operation of a w1_write_8 which it currently
+         * doesn't.
+         */
+        if (!master->write_byte && !master->touch_bit && master->set_pullup) {
+                printk(KERN_ERR "w1_add_master_device: set_pullup requires "
+                        "write_byte or touch_bit, disabling\n");
+                master->set_pullup = NULL;
+        }
+
+        /* Lock until the device is added (or not) to w1_masters. */
+        mutex_lock(&w1_mlock);
+        /* Search for the first available id (starting at 1). */
+        id = 0;
+        do {
+                ++id;
+                found = 0;
+                list_for_each_entry(entry, &w1_masters, w1_master_entry) {
+                        if (entry->id == id) {
+                                found = 1;
+                                break;
+                        }
+                }
+        } while (found);
 
-        dev = w1_alloc_dev(w1_ids++, w1_max_slave_count, w1_max_slave_ttl, &w1_master_driver, &w1_master_device);
-        if (!dev)
+        dev = w1_alloc_dev(id, w1_max_slave_count, w1_max_slave_ttl,
+                &w1_master_driver, &w1_master_device);
+        if (!dev) {
+                mutex_unlock(&w1_mlock);
                 return -ENOMEM;
+        }
+
+        retval =  w1_create_master_attributes(dev);
+        if (retval) {
+                mutex_unlock(&w1_mlock);
+                goto err_out_free_dev;
+        }
+
+        memcpy(dev->bus_master, master, sizeof(struct w1_bus_master));
+
+        dev->initialized = 1;
 
         dev->thread = kthread_run(&w1_process, dev, "%s", dev->name);
         if (IS_ERR(dev->thread)) {
@@ -115,18 +164,10 @@ int w1_add_master_device(struct w1_bus_master *master)
                 dev_err(&dev->dev,
                          "Failed to create new kernel thread. err=%d\n",
                          retval);
-                goto err_out_free_dev;
+                mutex_unlock(&w1_mlock);
+                goto err_out_rm_attr;
         }
 
-        retval =  w1_create_master_attributes(dev);
-        if (retval)
-                goto err_out_kill_thread;
-
-        memcpy(dev->bus_master, master, sizeof(struct w1_bus_master));
-
-        dev->initialized = 1;
-
-        mutex_lock(&w1_mlock);
         list_add(&dev->w1_master_entry, &w1_masters);
         mutex_unlock(&w1_mlock);
 
@@ -137,8 +178,12 @@ int w1_add_master_device(struct w1_bus_master *master)
 
         return 0;
 
+#if 0 /* Thread cleanup code, not required currently. */
 err_out_kill_thread:
         kthread_stop(dev->thread);
+#endif
+err_out_rm_attr:
+        w1_destroy_master_attributes(dev);
 err_out_free_dev:
         w1_free_dev(dev);
 
@@ -148,10 +193,21 @@ err_out_free_dev:
 void __w1_remove_master_device(struct w1_master *dev)
 {
         struct w1_netlink_msg msg;
+        struct w1_slave *sl, *sln;
 
-        set_bit(W1_MASTER_NEED_EXIT, &dev->flags);
         kthread_stop(dev->thread);
 
+        mutex_lock(&w1_mlock);
+        list_del(&dev->w1_master_entry);
+        mutex_unlock(&w1_mlock);
+
+        mutex_lock(&dev->mutex);
+        list_for_each_entry_safe(sl, sln, &dev->slist, w1_slave_entry)
+                w1_slave_detach(sl);
+        w1_destroy_master_attributes(dev);
+        mutex_unlock(&dev->mutex);
+        atomic_dec(&dev->refcnt);
+
         while (atomic_read(&dev->refcnt)) {
                 dev_info(&dev->dev, "Waiting for %s to become free: refcnt=%d.\n",
                                 dev->name, atomic_read(&dev->refcnt));