Merge branch 'driver-core-next' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6

* 'driver-core-next' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core-2.6: (50 commits)
  printk: do not mangle valid userspace syslog prefixes
  efivars: Add Documentation
  efivars: Expose efivars functionality to external drivers.
  efivars: Parameterize operations.
  efivars: Split out variable registration
  efivars: parameterize efivars
  efivars: Make efivars bin_attributes dynamic
  efivars: move efivars globals into struct efivars
  drivers:misc: ti-st: fix debugging code
  kref: Fix typo in kref documentation
  UIO: add PRUSS UIO driver support
  Fix spelling mistakes in Documentation/zh_CN/SubmittingPatches
  firmware: Fix unaligned memory accesses in dmi-sysfs
  firmware: Add documentation for /sys/firmware/dmi
  firmware: Expose DMI type 15 System Event Log
  firmware: Break out system_event_log in dmi-sysfs
  firmware: Basic dmi-sysfs support
  firmware: Add DMI entry types to the headers
  Driver core: convert platform_{get,set}_drvdata to static inline functions
  Translate linux-2.6/Documentation/magic-number.txt into Chinese
  ...

5 files changed, 232 insertions, 83 deletions

diff --git a/drivers/base/core.c b/drivers/base/core.c
index 080e9ca11017..81b78ede37c4 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -1320,7 +1320,10 @@ struct root_device
         struct module *owner;
 };
 
-#define to_root_device(dev) container_of(dev, struct root_device, dev)
+inline struct root_device *to_root_device(struct device *d)
+{
+        return container_of(d, struct root_device, dev);
+}
 
 static void root_device_release(struct device *dev)
 {
@@ -1551,7 +1554,34 @@ EXPORT_SYMBOL_GPL(device_destroy);
  * on the same device to ensure that new_name is valid and
  * won't conflict with other devices.
  *
- * "Never use this function, bad things will happen" - gregkh
+ * Note: Don't call this function.  Currently, the networking layer calls this
+ * function, but that will change.  The following text from Kay Sievers offers
+ * some insight:
+ *
+ * Renaming devices is racy at many levels, symlinks and other stuff are not
+ * replaced atomically, and you get a "move" uevent, but it's not easy to
+ * connect the event to the old and new device. Device nodes are not renamed at
+ * all, there isn't even support for that in the kernel now.
+ *
+ * In the meantime, during renaming, your target name might be taken by another
+ * driver, creating conflicts. Or the old name is taken directly after you
+ * renamed it -- then you get events for the same DEVPATH, before you even see
+ * the "move" event. It's just a mess, and nothing new should ever rely on
+ * kernel device renaming. Besides that, it's not even implemented now for
+ * other things than (driver-core wise very simple) network devices.
+ *
+ * We are currently about to change network renaming in udev to completely
+ * disallow renaming of devices in the same namespace as the kernel uses,
+ * because we can't solve the problems properly, that arise with swapping names
+ * of multiple interfaces without races. Means, renaming of eth[0-9]* will only
+ * be allowed to some other name than eth[0-9]*, for the aforementioned
+ * reasons.
+ *
+ * Make up a "real" name in the driver before you register anything, or add
+ * some other attributes for userspace to find the device, or use udev to add
+ * symlinks -- but never rename kernel devices later, it's a complete mess. We
+ * don't even want to get into that and try to implement the missing pieces in
+ * the core. We really have other pieces to fix in the driver core mess. :)
  */
 int device_rename(struct device *dev, const char *new_name)
 {
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 40af43ebd92d..8c798ef7f13f 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -593,8 +593,7 @@ int
 request_firmware(const struct firmware **firmware_p, const char *name,
                  struct device *device)
 {
-        int uevent = 1;
-        return _request_firmware(firmware_p, name, device, uevent, false);
+        return _request_firmware(firmware_p, name, device, true, false);
 }
 
 /**
@@ -618,7 +617,7 @@ struct firmware_work {
         struct device *device;
         void *context;
         void (*cont)(const struct firmware *fw, void *context);
-        int uevent;
+        bool uevent;
 };
 
 static int request_firmware_work_func(void *arg)
@@ -661,7 +660,7 @@ static int request_firmware_work_func(void *arg)
  **/
 int
 request_firmware_nowait(
-        struct module *module, int uevent,
+        struct module *module, bool uevent,
         const char *name, struct device *device, gfp_t gfp, void *context,
         void (*cont)(const struct firmware *fw, void *context))
 {
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index cafeaaf0428f..3da6a43b7756 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -30,6 +30,14 @@
 static DEFINE_MUTEX(mem_sysfs_mutex);
 
 #define MEMORY_CLASS_NAME       "memory"
+#define MIN_MEMORY_BLOCK_SIZE   (1 << SECTION_SIZE_BITS)
+
+static int sections_per_block;
+
+static inline int base_memory_block_id(int section_nr)
+{
+        return section_nr / sections_per_block;
+}
 
 static struct sysdev_class memory_sysdev_class = {
         .name = MEMORY_CLASS_NAME,
@@ -84,39 +92,72 @@ EXPORT_SYMBOL(unregister_memory_isolate_notifier);
  * register_memory - Setup a sysfs device for a memory block
  */
 static
-int register_memory(struct memory_block *memory, struct mem_section *section)
+int register_memory(struct memory_block *memory)
 {
         int error;
 
         memory->sysdev.cls = &memory_sysdev_class;
-        memory->sysdev.id = __section_nr(section);
+        memory->sysdev.id = memory->start_section_nr / sections_per_block;
 
         error = sysdev_register(&memory->sysdev);
         return error;
 }
 
 static void
-unregister_memory(struct memory_block *memory, struct mem_section *section)
+unregister_memory(struct memory_block *memory)
 {
         BUG_ON(memory->sysdev.cls != &memory_sysdev_class);
-        BUG_ON(memory->sysdev.id != __section_nr(section));
 
         /* drop the ref. we got in remove_memory_block() */
         kobject_put(&memory->sysdev.kobj);
         sysdev_unregister(&memory->sysdev);
 }
 
+unsigned long __weak memory_block_size_bytes(void)
+{
+        return MIN_MEMORY_BLOCK_SIZE;
+}
+
+static unsigned long get_memory_block_size(void)
+{
+        unsigned long block_sz;
+
+        block_sz = memory_block_size_bytes();
+
+        /* Validate blk_sz is a power of 2 and not less than section size */
+        if ((block_sz & (block_sz - 1)) || (block_sz < MIN_MEMORY_BLOCK_SIZE)) {
+                WARN_ON(1);
+                block_sz = MIN_MEMORY_BLOCK_SIZE;
+        }
+
+        return block_sz;
+}
+
 /*
  * use this as the physical section index that this memsection
  * uses.
  */
 
-static ssize_t show_mem_phys_index(struct sys_device *dev,
+static ssize_t show_mem_start_phys_index(struct sys_device *dev,
                         struct sysdev_attribute *attr, char *buf)
 {
         struct memory_block *mem =
                 container_of(dev, struct memory_block, sysdev);
-        return sprintf(buf, "%08lx\n", mem->phys_index);
+        unsigned long phys_index;
+
+        phys_index = mem->start_section_nr / sections_per_block;
+        return sprintf(buf, "%08lx\n", phys_index);
+}
+
+static ssize_t show_mem_end_phys_index(struct sys_device *dev,
+                        struct sysdev_attribute *attr, char *buf)
+{
+        struct memory_block *mem =
+                container_of(dev, struct memory_block, sysdev);
+        unsigned long phys_index;
+
+        phys_index = mem->end_section_nr / sections_per_block;
+        return sprintf(buf, "%08lx\n", phys_index);
 }
 
 /*
@@ -125,13 +166,16 @@ static ssize_t show_mem_phys_index(struct sys_device *dev,
 static ssize_t show_mem_removable(struct sys_device *dev,
                         struct sysdev_attribute *attr, char *buf)
 {
-        unsigned long start_pfn;
-        int ret;
+        unsigned long i, pfn;
+        int ret = 1;
         struct memory_block *mem =
                 container_of(dev, struct memory_block, sysdev);
 
-        start_pfn = section_nr_to_pfn(mem->phys_index);
-        ret = is_mem_section_removable(start_pfn, PAGES_PER_SECTION);
+        for (i = 0; i < sections_per_block; i++) {
+                pfn = section_nr_to_pfn(mem->start_section_nr + i);
+                ret &= is_mem_section_removable(pfn, PAGES_PER_SECTION);
+        }
+
         return sprintf(buf, "%d\n", ret);
 }
 
@@ -184,17 +228,14 @@ int memory_isolate_notify(unsigned long val, void *v)
  * OK to have direct references to sparsemem variables in here.
  */
 static int
-memory_block_action(struct memory_block *mem, unsigned long action)
+memory_section_action(unsigned long phys_index, unsigned long action)
 {
         int i;
-        unsigned long psection;
         unsigned long start_pfn, start_paddr;
         struct page *first_page;
         int ret;
-        int old_state = mem->state;
 
-        psection = mem->phys_index;
-        first_page = pfn_to_page(psection << PFN_SECTION_SHIFT);
+        first_page = pfn_to_page(phys_index << PFN_SECTION_SHIFT);
 
         /*
          * The probe routines leave the pages reserved, just
@@ -207,8 +248,8 @@ memory_block_action(struct memory_block *mem, unsigned long action)
                                 continue;
 
                         printk(KERN_WARNING "section number %ld page number %d "
-                                "not reserved, was it already online? \n",
-                                psection, i);
+                                "not reserved, was it already online?\n",
+                                phys_index, i);
                         return -EBUSY;
                 }
         }
@@ -219,18 +260,13 @@ memory_block_action(struct memory_block *mem, unsigned long action)
                         ret = online_pages(start_pfn, PAGES_PER_SECTION);
                         break;
                 case MEM_OFFLINE:
-                        mem->state = MEM_GOING_OFFLINE;
                         start_paddr = page_to_pfn(first_page) << PAGE_SHIFT;
                         ret = remove_memory(start_paddr,
                                             PAGES_PER_SECTION << PAGE_SHIFT);
-                        if (ret) {
-                                mem->state = old_state;
-                                break;
-                        }
                         break;
                 default:
-                        WARN(1, KERN_WARNING "%s(%p, %ld) unknown action: %ld\n",
-                                        __func__, mem, action, action);
+                        WARN(1, KERN_WARNING "%s(%ld, %ld) unknown action: "
+                             "%ld\n", __func__, phys_index, action, action);
                         ret = -EINVAL;
         }
 
@@ -240,7 +276,8 @@ memory_block_action(struct memory_block *mem, unsigned long action)
 static int memory_block_change_state(struct memory_block *mem,
                 unsigned long to_state, unsigned long from_state_req)
 {
-        int ret = 0;
+        int i, ret = 0;
+
         mutex_lock(&mem->state_mutex);
 
         if (mem->state != from_state_req) {
@@ -248,8 +285,23 @@ static int memory_block_change_state(struct memory_block *mem,
                 goto out;
         }
 
-        ret = memory_block_action(mem, to_state);
-        if (!ret)
+        if (to_state == MEM_OFFLINE)
+                mem->state = MEM_GOING_OFFLINE;
+
+        for (i = 0; i < sections_per_block; i++) {
+                ret = memory_section_action(mem->start_section_nr + i,
+                                            to_state);
+                if (ret)
+                        break;
+        }
+
+        if (ret) {
+                for (i = 0; i < sections_per_block; i++)
+                        memory_section_action(mem->start_section_nr + i,
+                                              from_state_req);
+
+                mem->state = from_state_req;
+        } else
                 mem->state = to_state;
 
 out:
@@ -262,20 +314,15 @@ store_mem_state(struct sys_device *dev,
                 struct sysdev_attribute *attr, const char *buf, size_t count)
 {
         struct memory_block *mem;
-        unsigned int phys_section_nr;
         int ret = -EINVAL;
 
         mem = container_of(dev, struct memory_block, sysdev);
-        phys_section_nr = mem->phys_index;
-
-        if (!present_section_nr(phys_section_nr))
-                goto out;
 
         if (!strncmp(buf, "online", min((int)count, 6)))
                 ret = memory_block_change_state(mem, MEM_ONLINE, MEM_OFFLINE);
         else if(!strncmp(buf, "offline", min((int)count, 7)))
                 ret = memory_block_change_state(mem, MEM_OFFLINE, MEM_ONLINE);
-out:
+
         if (ret)
                 return ret;
         return count;
@@ -298,7 +345,8 @@ static ssize_t show_phys_device(struct sys_device *dev,
         return sprintf(buf, "%d\n", mem->phys_device);
 }
 
-static SYSDEV_ATTR(phys_index, 0444, show_mem_phys_index, NULL);
+static SYSDEV_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL);
+static SYSDEV_ATTR(end_phys_index, 0444, show_mem_end_phys_index, NULL);
 static SYSDEV_ATTR(state, 0644, show_mem_state, store_mem_state);
 static SYSDEV_ATTR(phys_device, 0444, show_phys_device, NULL);
 static SYSDEV_ATTR(removable, 0444, show_mem_removable, NULL);
@@ -315,7 +363,7 @@ static ssize_t
 print_block_size(struct sysdev_class *class, struct sysdev_class_attribute *attr,
                  char *buf)
 {
-        return sprintf(buf, "%lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE);
+        return sprintf(buf, "%lx\n", get_memory_block_size());
 }
 
 static SYSDEV_CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
@@ -339,12 +387,19 @@ memory_probe_store(struct class *class, struct class_attribute *attr,
 {
         u64 phys_addr;
         int nid;
-        int ret;
+        int i, ret;
 
         phys_addr = simple_strtoull(buf, NULL, 0);
 
-        nid = memory_add_physaddr_to_nid(phys_addr);
-        ret = add_memory(nid, phys_addr, PAGES_PER_SECTION << PAGE_SHIFT);
+        for (i = 0; i < sections_per_block; i++) {
+                nid = memory_add_physaddr_to_nid(phys_addr);
+                ret = add_memory(nid, phys_addr,
+                                 PAGES_PER_SECTION << PAGE_SHIFT);
+                if (ret)
+                        break;
+
+                phys_addr += MIN_MEMORY_BLOCK_SIZE;
+        }
 
         if (ret)
                 count = ret;
@@ -444,6 +499,7 @@ struct memory_block *find_memory_block_hinted(struct mem_section *section,
         struct sys_device *sysdev;
         struct memory_block *mem;
         char name[sizeof(MEMORY_CLASS_NAME) + 9 + 1];
+        int block_id = base_memory_block_id(__section_nr(section));
 
         kobj = hint ? &hint->sysdev.kobj : NULL;
 
@@ -451,7 +507,7 @@ struct memory_block *find_memory_block_hinted(struct mem_section *section,
          * This only works because we know that section == sysdev->id
          * slightly redundant with sysdev_register()
          */
-        sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, __section_nr(section));
+        sprintf(&name[0], "%s%d", MEMORY_CLASS_NAME, block_id);
 
         kobj = kset_find_obj_hinted(&memory_sysdev_class.kset, name, kobj);
         if (!kobj)
@@ -476,36 +532,62 @@ struct memory_block *find_memory_block(struct mem_section *section)
         return find_memory_block_hinted(section, NULL);
 }
 
-static int add_memory_block(int nid, struct mem_section *section,
-                        unsigned long state, enum mem_add_context context)
+static int init_memory_block(struct memory_block **memory,
+                             struct mem_section *section, unsigned long state)
 {
-        struct memory_block *mem = kzalloc(sizeof(*mem), GFP_KERNEL);
+        struct memory_block *mem;
         unsigned long start_pfn;
+        int scn_nr;
         int ret = 0;
 
+        mem = kzalloc(sizeof(*mem), GFP_KERNEL);
         if (!mem)
                 return -ENOMEM;
 
-        mutex_lock(&mem_sysfs_mutex);
-
-        mem->phys_index = __section_nr(section);
+        scn_nr = __section_nr(section);
+        mem->start_section_nr =
+                        base_memory_block_id(scn_nr) * sections_per_block;
+        mem->end_section_nr = mem->start_section_nr + sections_per_block - 1;
         mem->state = state;
         mem->section_count++;
         mutex_init(&mem->state_mutex);
-        start_pfn = section_nr_to_pfn(mem->phys_index);
+        start_pfn = section_nr_to_pfn(mem->start_section_nr);
         mem->phys_device = arch_get_memory_phys_device(start_pfn);
 
-        ret = register_memory(mem, section);
+        ret = register_memory(mem);
         if (!ret)
                 ret = mem_create_simple_file(mem, phys_index);
         if (!ret)
+                ret = mem_create_simple_file(mem, end_phys_index);
+        if (!ret)
                 ret = mem_create_simple_file(mem, state);
         if (!ret)
                 ret = mem_create_simple_file(mem, phys_device);
         if (!ret)
                 ret = mem_create_simple_file(mem, removable);
+
+        *memory = mem;
+        return ret;
+}
+
+static int add_memory_section(int nid, struct mem_section *section,
+                        unsigned long state, enum mem_add_context context)
+{
+        struct memory_block *mem;
+        int ret = 0;
+
+        mutex_lock(&mem_sysfs_mutex);
+
+        mem = find_memory_block(section);
+        if (mem) {
+                mem->section_count++;
+                kobject_put(&mem->sysdev.kobj);
+        } else
+                ret = init_memory_block(&mem, section, state);
+
         if (!ret) {
-                if (context == HOTPLUG)
+                if (context == HOTPLUG &&
+                    mem->section_count == sections_per_block)
                         ret = register_mem_sect_under_node(mem, nid);
         }
 
@@ -520,16 +602,19 @@ int remove_memory_block(unsigned long node_id, struct mem_section *section,
 
         mutex_lock(&mem_sysfs_mutex);
         mem = find_memory_block(section);
+        unregister_mem_sect_under_nodes(mem, __section_nr(section));
 
         mem->section_count--;
         if (mem->section_count == 0) {
-                unregister_mem_sect_under_nodes(mem);
                 mem_remove_simple_file(mem, phys_index);
+                mem_remove_simple_file(mem, end_phys_index);
                 mem_remove_simple_file(mem, state);
                 mem_remove_simple_file(mem, phys_device);
                 mem_remove_simple_file(mem, removable);
-                unregister_memory(mem, section);
-        }
+                unregister_memory(mem);
+                kfree(mem);
+        } else
+                kobject_put(&mem->sysdev.kobj);
 
         mutex_unlock(&mem_sysfs_mutex);
         return 0;
@@ -541,7 +626,7 @@ int remove_memory_block(unsigned long node_id, struct mem_section *section,
  */
 int register_new_memory(int nid, struct mem_section *section)
 {
-        return add_memory_block(nid, section, MEM_OFFLINE, HOTPLUG);
+        return add_memory_section(nid, section, MEM_OFFLINE, HOTPLUG);
 }
 
 int unregister_memory_section(struct mem_section *section)
@@ -560,12 +645,16 @@ int __init memory_dev_init(void)
         unsigned int i;
         int ret;
         int err;
+        unsigned long block_sz;
 
         memory_sysdev_class.kset.uevent_ops = &memory_uevent_ops;
         ret = sysdev_class_register(&memory_sysdev_class);
         if (ret)
                 goto out;
 
+        block_sz = get_memory_block_size();
+        sections_per_block = block_sz / MIN_MEMORY_BLOCK_SIZE;
+
         /*
          * Create entries for memory sections that were found
          * during boot and have been initialized
@@ -573,8 +662,8 @@ int __init memory_dev_init(void)
         for (i = 0; i < NR_MEM_SECTIONS; i++) {
                 if (!present_section_nr(i))
                         continue;
-                err = add_memory_block(0, __nr_to_section(i), MEM_ONLINE,
-                                       BOOT);
+                err = add_memory_section(0, __nr_to_section(i), MEM_ONLINE,
+                                         BOOT);
                 if (!ret)
                         ret = err;
         }
diff --git a/drivers/base/node.c b/drivers/base/node.c
index 36b43052001d..b3b72d64e805 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -375,8 +375,10 @@ int register_mem_sect_under_node(struct memory_block *mem_blk, int nid)
                 return -EFAULT;
         if (!node_online(nid))
                 return 0;
-        sect_start_pfn = section_nr_to_pfn(mem_blk->phys_index);
-        sect_end_pfn = sect_start_pfn + PAGES_PER_SECTION - 1;
+
+        sect_start_pfn = section_nr_to_pfn(mem_blk->start_section_nr);
+        sect_end_pfn = section_nr_to_pfn(mem_blk->end_section_nr);
+        sect_end_pfn += PAGES_PER_SECTION - 1;
         for (pfn = sect_start_pfn; pfn <= sect_end_pfn; pfn++) {
                 int page_nid;
 
@@ -400,7 +402,8 @@ int register_mem_sect_under_node(struct memory_block *mem_blk, int nid)
 }
 
 /* unregister memory section under all nodes that it spans */
-int unregister_mem_sect_under_nodes(struct memory_block *mem_blk)
+int unregister_mem_sect_under_nodes(struct memory_block *mem_blk,
+                                    unsigned long phys_index)
 {
         NODEMASK_ALLOC(nodemask_t, unlinked_nodes, GFP_KERNEL);
         unsigned long pfn, sect_start_pfn, sect_end_pfn;
@@ -412,7 +415,8 @@ int unregister_mem_sect_under_nodes(struct memory_block *mem_blk)
         if (!unlinked_nodes)
                 return -ENOMEM;
         nodes_clear(*unlinked_nodes);
-        sect_start_pfn = section_nr_to_pfn(mem_blk->phys_index);
+
+        sect_start_pfn = section_nr_to_pfn(phys_index);
         sect_end_pfn = sect_start_pfn + PAGES_PER_SECTION - 1;
         for (pfn = sect_start_pfn; pfn <= sect_end_pfn; pfn++) {
                 int nid;
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 1667aaf4fde6..f6fb54741602 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -166,6 +166,36 @@ EXPORT_SYMBOL_GPL(sysdev_class_unregister);
 
 static DEFINE_MUTEX(sysdev_drivers_lock);
 
+/*
+ * @dev != NULL means that we're unwinding because some drv->add()
+ * failed for some reason. You need to grab sysdev_drivers_lock before
+ * calling this.
+ */
+static void __sysdev_driver_remove(struct sysdev_class *cls,
+                                   struct sysdev_driver *drv,
+                                   struct sys_device *from_dev)
+{
+        struct sys_device *dev = from_dev;
+
+        list_del_init(&drv->entry);
+        if (!cls)
+                return;
+
+        if (!drv->remove)
+                goto kset_put;
+
+        if (dev)
+                list_for_each_entry_continue_reverse(dev, &cls->kset.list,
+                                                     kobj.entry)
+                        drv->remove(dev);
+        else
+                list_for_each_entry(dev, &cls->kset.list, kobj.entry)
+                        drv->remove(dev);
+
+kset_put:
+        kset_put(&cls->kset);
+}
+
 /**
  *      sysdev_driver_register - Register auxillary driver
  *      @cls:   Device class driver belongs to.
@@ -175,14 +205,14 @@ static DEFINE_MUTEX(sysdev_drivers_lock);
  *      called on each operation on devices of that class. The refcount
  *      of @cls is incremented.
  */
-
 int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
 {
+        struct sys_device *dev = NULL;
         int err = 0;
 
         if (!cls) {
-                WARN(1, KERN_WARNING "sysdev: invalid class passed to "
-                        "sysdev_driver_register!\n");
+                WARN(1, KERN_WARNING "sysdev: invalid class passed to %s!\n",
+                        __func__);
                 return -EINVAL;
         }
 
@@ -198,19 +228,27 @@ int sysdev_driver_register(struct sysdev_class *cls, struct sysdev_driver *drv)
 
                 /* If devices of this class already exist, tell the driver */
                 if (drv->add) {
-                        struct sys_device *dev;
-                        list_for_each_entry(dev, &cls->kset.list, kobj.entry)
-                                drv->add(dev);
+                        list_for_each_entry(dev, &cls->kset.list, kobj.entry) {
+                                err = drv->add(dev);
+                                if (err)
+                                        goto unwind;
+                        }
                 }
         } else {
                 err = -EINVAL;
                 WARN(1, KERN_ERR "%s: invalid device class\n", __func__);
         }
+
+        goto unlock;
+
+unwind:
+        __sysdev_driver_remove(cls, drv, dev);
+
+unlock:
         mutex_unlock(&sysdev_drivers_lock);
         return err;
 }
 
-
 /**
  *      sysdev_driver_unregister - Remove an auxillary driver.
  *      @cls:   Class driver belongs to.
@@ -220,23 +258,12 @@ void sysdev_driver_unregister(struct sysdev_class *cls,
                               struct sysdev_driver *drv)
 {
         mutex_lock(&sysdev_drivers_lock);
-        list_del_init(&drv->entry);
-        if (cls) {
-                if (drv->remove) {
-                        struct sys_device *dev;
-                        list_for_each_entry(dev, &cls->kset.list, kobj.entry)
-                                drv->remove(dev);
-                }
-                kset_put(&cls->kset);
-        }
+        __sysdev_driver_remove(cls, drv, NULL);
         mutex_unlock(&sysdev_drivers_lock);
 }
-
 EXPORT_SYMBOL_GPL(sysdev_driver_register);
 EXPORT_SYMBOL_GPL(sysdev_driver_unregister);
 
-
-
 /**
  *      sysdev_register - add a system device to the tree
  *      @sysdev:        device in question