10 files changed, 180 insertions, 120 deletions

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index 934149c1512b..f0eff3dac58d 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -19,11 +19,11 @@ config PREVENT_FIRMWARE_BUILD
           If unsure say Y here.
 
 config FW_LOADER
-        tristate "Hotplug firmware loading support"
+        tristate "Userspace firmware loading support"
         select HOTPLUG
         ---help---
           This option is provided for the case where no in-kernel-tree modules
-          require hotplug firmware loading support, but a module built outside
+          require userspace firmware loading support, but a module built outside
           the kernel tree does.
 
 config DEBUG_DRIVER
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index fa601b085eba..29f6af554e71 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -152,7 +152,11 @@ static ssize_t driver_unbind(struct device_driver *drv,
 
         dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
         if (dev && dev->driver == drv) {
+                if (dev->parent)        /* Needed for USB */
+                        down(&dev->parent->sem);
                 device_release_driver(dev);
+                if (dev->parent)
+                        up(&dev->parent->sem);
                 err = count;
         }
         put_device(dev);
@@ -175,9 +179,13 @@ static ssize_t driver_bind(struct device_driver *drv,
 
         dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
         if (dev && dev->driver == NULL) {
+                if (dev->parent)        /* Needed for USB */
+                        down(&dev->parent->sem);
                 down(&dev->sem);
                 err = driver_probe_device(drv, dev);
                 up(&dev->sem);
+                if (dev->parent)
+                        up(&dev->parent->sem);
         }
         put_device(dev);
         put_bus(bus);
@@ -420,6 +428,26 @@ static void driver_remove_attrs(struct bus_type * bus, struct device_driver * dr
         }
 }
 
+#ifdef CONFIG_HOTPLUG
+/*
+ * Thanks to drivers making their tables __devinit, we can't allow manual
+ * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
+ */
+static void add_bind_files(struct device_driver *drv)
+{
+        driver_create_file(drv, &driver_attr_unbind);
+        driver_create_file(drv, &driver_attr_bind);
+}
+
+static void remove_bind_files(struct device_driver *drv)
+{
+        driver_remove_file(drv, &driver_attr_bind);
+        driver_remove_file(drv, &driver_attr_unbind);
+}
+#else
+static inline void add_bind_files(struct device_driver *drv) {}
+static inline void remove_bind_files(struct device_driver *drv) {}
+#endif
 
 /**
  *      bus_add_driver - Add a driver to the bus.
@@ -449,8 +477,7 @@ int bus_add_driver(struct device_driver * drv)
                 module_add_driver(drv->owner, drv);
 
                 driver_add_attrs(bus, drv);
-                driver_create_file(drv, &driver_attr_unbind);
-                driver_create_file(drv, &driver_attr_bind);
+                add_bind_files(drv);
         }
         return error;
 }
@@ -468,8 +495,7 @@ int bus_add_driver(struct device_driver * drv)
 void bus_remove_driver(struct device_driver * drv)
 {
         if (drv->bus) {
-                driver_remove_file(drv, &driver_attr_bind);
-                driver_remove_file(drv, &driver_attr_unbind);
+                remove_bind_files(drv);
                 driver_remove_attrs(drv->bus, drv);
                 klist_remove(&drv->knode_bus);
                 pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
@@ -484,8 +510,13 @@ void bus_remove_driver(struct device_driver * drv)
 /* Helper for bus_rescan_devices's iter */
 static int bus_rescan_devices_helper(struct device *dev, void *data)
 {
-        if (!dev->driver)
+        if (!dev->driver) {
+                if (dev->parent)        /* Needed for USB */
+                        down(&dev->parent->sem);
                 device_attach(dev);
+                if (dev->parent)
+                        up(&dev->parent->sem);
+        }
         return 0;
 }
 
diff --git a/drivers/base/class.c b/drivers/base/class.c
index db65fd0babe9..df7fdabd0730 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -178,7 +178,7 @@ static void class_device_create_release(struct class_device *class_dev)
 }
 
 /* needed to allow these devices to have parent class devices */
-static int class_device_create_hotplug(struct class_device *class_dev,
+static int class_device_create_uevent(struct class_device *class_dev,
                                        char **envp, int num_envp,
                                        char *buffer, int buffer_size)
 {
@@ -331,7 +331,7 @@ static struct kobj_type ktype_class_device = {
         .release        = class_dev_release,
 };
 
-static int class_hotplug_filter(struct kset *kset, struct kobject *kobj)
+static int class_uevent_filter(struct kset *kset, struct kobject *kobj)
 {
         struct kobj_type *ktype = get_ktype(kobj);
 
@@ -343,14 +343,14 @@ static int class_hotplug_filter(struct kset *kset, struct kobject *kobj)
         return 0;
 }
 
-static const char *class_hotplug_name(struct kset *kset, struct kobject *kobj)
+static const char *class_uevent_name(struct kset *kset, struct kobject *kobj)
 {
         struct class_device *class_dev = to_class_dev(kobj);
 
         return class_dev->class->name;
 }
 
-static int class_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
+static int class_uevent(struct kset *kset, struct kobject *kobj, char **envp,
                          int num_envp, char *buffer, int buffer_size)
 {
         struct class_device *class_dev = to_class_dev(kobj);
@@ -365,29 +365,29 @@ static int class_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
                 struct device *dev = class_dev->dev;
                 char *path = kobject_get_path(&dev->kobj, GFP_KERNEL);
 
-                add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size,
-                                    &length, "PHYSDEVPATH=%s", path);
+                add_uevent_var(envp, num_envp, &i, buffer, buffer_size,
+                               &length, "PHYSDEVPATH=%s", path);
                 kfree(path);
 
                 if (dev->bus)
-                        add_hotplug_env_var(envp, num_envp, &i,
-                                            buffer, buffer_size, &length,
-                                            "PHYSDEVBUS=%s", dev->bus->name);
+                        add_uevent_var(envp, num_envp, &i,
+                                       buffer, buffer_size, &length,
+                                       "PHYSDEVBUS=%s", dev->bus->name);
 
                 if (dev->driver)
-                        add_hotplug_env_var(envp, num_envp, &i,
-                                            buffer, buffer_size, &length,
-                                            "PHYSDEVDRIVER=%s", dev->driver->name);
+                        add_uevent_var(envp, num_envp, &i,
+                                       buffer, buffer_size, &length,
+                                       "PHYSDEVDRIVER=%s", dev->driver->name);
         }
 
         if (MAJOR(class_dev->devt)) {
-                add_hotplug_env_var(envp, num_envp, &i,
-                                    buffer, buffer_size, &length,
-                                    "MAJOR=%u", MAJOR(class_dev->devt));
+                add_uevent_var(envp, num_envp, &i,
+                               buffer, buffer_size, &length,
+                               "MAJOR=%u", MAJOR(class_dev->devt));
 
-                add_hotplug_env_var(envp, num_envp, &i,
-                                    buffer, buffer_size, &length,
-                                    "MINOR=%u", MINOR(class_dev->devt));
+                add_uevent_var(envp, num_envp, &i,
+                               buffer, buffer_size, &length,
+                               "MINOR=%u", MINOR(class_dev->devt));
         }
 
         /* terminate, set to next free slot, shrink available space */
@@ -397,30 +397,30 @@ static int class_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
         buffer = &buffer[length];
         buffer_size -= length;
 
-        if (class_dev->hotplug) {
+        if (class_dev->uevent) {
                 /* have the class device specific function add its stuff */
-                retval = class_dev->hotplug(class_dev, envp, num_envp,
+                retval = class_dev->uevent(class_dev, envp, num_envp,
                                             buffer, buffer_size);
                 if (retval)
-                        pr_debug("class_dev->hotplug() returned %d\n", retval);
-        } else if (class_dev->class->hotplug) {
+                        pr_debug("class_dev->uevent() returned %d\n", retval);
+        } else if (class_dev->class->uevent) {
                 /* have the class specific function add its stuff */
-                retval = class_dev->class->hotplug(class_dev, envp, num_envp,
+                retval = class_dev->class->uevent(class_dev, envp, num_envp,
                                                    buffer, buffer_size);
                 if (retval)
-                        pr_debug("class->hotplug() returned %d\n", retval);
+                        pr_debug("class->uevent() returned %d\n", retval);
         }
 
         return retval;
 }
 
-static struct kset_hotplug_ops class_hotplug_ops = {
-        .filter =       class_hotplug_filter,
-        .name =         class_hotplug_name,
-        .hotplug =      class_hotplug,
+static struct kset_uevent_ops class_uevent_ops = {
+        .filter =       class_uevent_filter,
+        .name =         class_uevent_name,
+        .uevent =       class_uevent,
 };
 
-static decl_subsys(class_obj, &ktype_class_device, &class_hotplug_ops);
+static decl_subsys(class_obj, &ktype_class_device, &class_uevent_ops);
 
 
 static int class_device_add_attrs(struct class_device * cd)
@@ -464,7 +464,7 @@ static ssize_t show_dev(struct class_device *class_dev, char *buf)
 static ssize_t store_uevent(struct class_device *class_dev,
                             const char *buf, size_t count)
 {
-        kobject_hotplug(&class_dev->kobj, KOBJ_ADD);
+        kobject_uevent(&class_dev->kobj, KOBJ_ADD);
         return count;
 }
 
@@ -559,7 +559,7 @@ int class_device_add(struct class_device *class_dev)
                                   class_name);
         }
 
-        kobject_hotplug(&class_dev->kobj, KOBJ_ADD);
+        kobject_uevent(&class_dev->kobj, KOBJ_ADD);
 
         /* notify any interfaces this device is now here */
         if (parent_class) {
@@ -632,7 +632,7 @@ struct class_device *class_device_create(struct class *cls,
         class_dev->class = cls;
         class_dev->parent = parent;
         class_dev->release = class_device_create_release;
-        class_dev->hotplug = class_device_create_hotplug;
+        class_dev->uevent = class_device_create_uevent;
 
         va_start(args, fmt);
         vsnprintf(class_dev->class_id, BUS_ID_SIZE, fmt, args);
@@ -674,7 +674,7 @@ void class_device_del(struct class_device *class_dev)
                 class_device_remove_file(class_dev, class_dev->devt_attr);
         class_device_remove_attrs(class_dev);
 
-        kobject_hotplug(&class_dev->kobj, KOBJ_REMOVE);
+        kobject_uevent(&class_dev->kobj, KOBJ_REMOVE);
         kobject_del(&class_dev->kobj);
 
         class_device_put(parent_device);
diff --git a/drivers/base/core.c b/drivers/base/core.c
index 8615b42b517a..fd8059920dbf 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -90,7 +90,7 @@ static struct kobj_type ktype_device = {
 };
 
 
-static int dev_hotplug_filter(struct kset *kset, struct kobject *kobj)
+static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
 {
         struct kobj_type *ktype = get_ktype(kobj);
 
@@ -102,14 +102,14 @@ static int dev_hotplug_filter(struct kset *kset, struct kobject *kobj)
         return 0;
 }
 
-static const char *dev_hotplug_name(struct kset *kset, struct kobject *kobj)
+static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
 {
         struct device *dev = to_dev(kobj);
 
         return dev->bus->name;
 }
 
-static int dev_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
+static int dev_uevent(struct kset *kset, struct kobject *kobj, char **envp,
                         int num_envp, char *buffer, int buffer_size)
 {
         struct device *dev = to_dev(kobj);
@@ -119,15 +119,15 @@ static int dev_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
 
         /* add bus name of physical device */
         if (dev->bus)
-                add_hotplug_env_var(envp, num_envp, &i,
-                                    buffer, buffer_size, &length,
-                                    "PHYSDEVBUS=%s", dev->bus->name);
+                add_uevent_var(envp, num_envp, &i,
+                               buffer, buffer_size, &length,
+                               "PHYSDEVBUS=%s", dev->bus->name);
 
         /* add driver name of physical device */
         if (dev->driver)
-                add_hotplug_env_var(envp, num_envp, &i,
-                                    buffer, buffer_size, &length,
-                                    "PHYSDEVDRIVER=%s", dev->driver->name);
+                add_uevent_var(envp, num_envp, &i,
+                               buffer, buffer_size, &length,
+                               "PHYSDEVDRIVER=%s", dev->driver->name);
 
         /* terminate, set to next free slot, shrink available space */
         envp[i] = NULL;
@@ -136,11 +136,11 @@ static int dev_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
         buffer = &buffer[length];
         buffer_size -= length;
 
-        if (dev->bus && dev->bus->hotplug) {
+        if (dev->bus && dev->bus->uevent) {
                 /* have the bus specific function add its stuff */
-                retval = dev->bus->hotplug (dev, envp, num_envp, buffer, buffer_size);
+                retval = dev->bus->uevent(dev, envp, num_envp, buffer, buffer_size);
                         if (retval) {
-                        pr_debug ("%s - hotplug() returned %d\n",
+                        pr_debug ("%s - uevent() returned %d\n",
                                   __FUNCTION__, retval);
                 }
         }
@@ -148,16 +148,16 @@ static int dev_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
         return retval;
 }
 
-static struct kset_hotplug_ops device_hotplug_ops = {
-        .filter =       dev_hotplug_filter,
-        .name =         dev_hotplug_name,
-        .hotplug =      dev_hotplug,
+static struct kset_uevent_ops device_uevent_ops = {
+        .filter =       dev_uevent_filter,
+        .name =         dev_uevent_name,
+        .uevent =       dev_uevent,
 };
 
 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
                             const char *buf, size_t count)
 {
-        kobject_hotplug(&dev->kobj, KOBJ_ADD);
+        kobject_uevent(&dev->kobj, KOBJ_ADD);
         return count;
 }
 
@@ -165,7 +165,7 @@ static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
  *      device_subsys - structure to be registered with kobject core.
  */
 
-decl_subsys(devices, &ktype_device, &device_hotplug_ops);
+decl_subsys(devices, &ktype_device, &device_uevent_ops);
 
 
 /**
@@ -274,7 +274,7 @@ int device_add(struct device *dev)
         dev->uevent_attr.store = store_uevent;
         device_create_file(dev, &dev->uevent_attr);
 
-        kobject_hotplug(&dev->kobj, KOBJ_ADD);
+        kobject_uevent(&dev->kobj, KOBJ_ADD);
         if ((error = device_pm_add(dev)))
                 goto PMError;
         if ((error = bus_add_device(dev)))
@@ -291,7 +291,7 @@ int device_add(struct device *dev)
  BusError:
         device_pm_remove(dev);
  PMError:
-        kobject_hotplug(&dev->kobj, KOBJ_REMOVE);
+        kobject_uevent(&dev->kobj, KOBJ_REMOVE);
         kobject_del(&dev->kobj);
  Error:
         if (parent)
@@ -374,7 +374,7 @@ void device_del(struct device * dev)
                 platform_notify_remove(dev);
         bus_remove_device(dev);
         device_pm_remove(dev);
-        kobject_hotplug(&dev->kobj, KOBJ_REMOVE);
+        kobject_uevent(&dev->kobj, KOBJ_REMOVE);
         kobject_del(&dev->kobj);
         if (parent)
                 put_device(parent);
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index a95844790f7b..281d26784d25 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -41,14 +41,14 @@ static ssize_t store_online(struct sys_device *dev, const char *buf,
         case '0':
                 ret = cpu_down(cpu->sysdev.id);
                 if (!ret)
-                        kobject_hotplug(&dev->kobj, KOBJ_OFFLINE);
+                        kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
                 break;
         case '1':
                 ret = smp_prepare_cpu(cpu->sysdev.id);
                 if (!ret)
                         ret = cpu_up(cpu->sysdev.id);
                 if (!ret)
-                        kobject_hotplug(&dev->kobj, KOBJ_ONLINE);
+                        kobject_uevent(&dev->kobj, KOBJ_ONLINE);
                 break;
         default:
                 ret = -EINVAL;
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 3b419c9a1e7e..2b905016664d 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -65,7 +65,8 @@ void device_bind_driver(struct device * dev)
  *      This function returns 1 if a match is found, an error if one
  *      occurs (that is not -ENODEV or -ENXIO), and 0 otherwise.
  *
- *      This function must be called with @dev->sem held.
+ *      This function must be called with @dev->sem held.  When called
+ *      for a USB interface, @dev->parent->sem must be held as well.
  */
 int driver_probe_device(struct device_driver * drv, struct device * dev)
 {
@@ -123,6 +124,8 @@ static int __device_attach(struct device_driver * drv, void * data)
  *
  *      Returns 1 if the device was bound to a driver;
  *      0 if no matching device was found; error code otherwise.
+ *
+ *      When called for a USB interface, @dev->parent->sem must be held.
  */
 int device_attach(struct device * dev)
 {
@@ -152,10 +155,14 @@ static int __driver_attach(struct device * dev, void * data)
          * is an error.
          */
 
+        if (dev->parent)        /* Needed for USB */
+                down(&dev->parent->sem);
         down(&dev->sem);
         if (!dev->driver)
                 driver_probe_device(drv, dev);
         up(&dev->sem);
+        if (dev->parent)
+                up(&dev->parent->sem);
 
         return 0;
 }
@@ -181,6 +188,8 @@ void driver_attach(struct device_driver * drv)
  *      Manually detach device from driver.
  *
  *      __device_release_driver() must be called with @dev->sem held.
+ *      When called for a USB interface, @dev->parent->sem must be held
+ *      as well.
  */
 
 static void __device_release_driver(struct device * dev)
@@ -233,10 +242,14 @@ void driver_detach(struct device_driver * drv)
                 get_device(dev);
                 spin_unlock(&drv->klist_devices.k_lock);
 
+                if (dev->parent)        /* Needed for USB */
+                        down(&dev->parent->sem);
                 down(&dev->sem);
                 if (dev->driver == drv)
                         __device_release_driver(dev);
                 up(&dev->sem);
+                if (dev->parent)
+                        up(&dev->parent->sem);
                 put_device(dev);
         }
 }
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 59dacb6552c0..5b3d5e9ddcb6 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -85,17 +85,17 @@ firmware_timeout_store(struct class *class, const char *buf, size_t count)
 static CLASS_ATTR(timeout, 0644, firmware_timeout_show, firmware_timeout_store);
 
 static void  fw_class_dev_release(struct class_device *class_dev);
-int firmware_class_hotplug(struct class_device *dev, char **envp,
+int firmware_class_uevent(struct class_device *dev, char **envp,
                            int num_envp, char *buffer, int buffer_size);
 
 static struct class firmware_class = {
         .name           = "firmware",
-        .hotplug        = firmware_class_hotplug,
+        .uevent = firmware_class_uevent,
         .release        = fw_class_dev_release,
 };
 
 int
-firmware_class_hotplug(struct class_device *class_dev, char **envp,
+firmware_class_uevent(struct class_device *class_dev, char **envp,
                        int num_envp, char *buffer, int buffer_size)
 {
         struct firmware_priv *fw_priv = class_get_devdata(class_dev);
@@ -104,13 +104,12 @@ firmware_class_hotplug(struct class_device *class_dev, char **envp,
         if (!test_bit(FW_STATUS_READY, &fw_priv->status))
                 return -ENODEV;
 
-        if (add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                        "FIRMWARE=%s", fw_priv->fw_id))
+        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
+                           "FIRMWARE=%s", fw_priv->fw_id))
                 return -ENOMEM;
-        if (add_hotplug_env_var(envp, num_envp, &i, buffer, buffer_size, &len,
-                        "TIMEOUT=%i", loading_timeout))
+        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &len,
+                           "TIMEOUT=%i", loading_timeout))
                 return -ENOMEM;
-
         envp[i] = NULL;
 
         return 0;
@@ -352,7 +351,7 @@ error_kfree:
 
 static int
 fw_setup_class_device(struct firmware *fw, struct class_device **class_dev_p,
-                      const char *fw_name, struct device *device, int hotplug)
+                      const char *fw_name, struct device *device, int uevent)
 {
         struct class_device *class_dev;
         struct firmware_priv *fw_priv;
@@ -384,7 +383,7 @@ fw_setup_class_device(struct firmware *fw, struct class_device **class_dev_p,
                 goto error_unreg;
         }
 
-        if (hotplug)
+        if (uevent)
                 set_bit(FW_STATUS_READY, &fw_priv->status);
         else
                 set_bit(FW_STATUS_READY_NOHOTPLUG, &fw_priv->status);
@@ -399,7 +398,7 @@ out:
 
 static int
 _request_firmware(const struct firmware **firmware_p, const char *name,
-                 struct device *device, int hotplug)
+                 struct device *device, int uevent)
 {
         struct class_device *class_dev;
         struct firmware_priv *fw_priv;
@@ -418,19 +417,19 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
         }
 
         retval = fw_setup_class_device(firmware, &class_dev, name, device,
-                hotplug);
+                                       uevent);
         if (retval)
                 goto error_kfree_fw;
 
         fw_priv = class_get_devdata(class_dev);
 
-        if (hotplug) {
+        if (uevent) {
                 if (loading_timeout > 0) {
                         fw_priv->timeout.expires = jiffies + loading_timeout * HZ;
                         add_timer(&fw_priv->timeout);
                 }
 
-                kobject_hotplug(&class_dev->kobj, KOBJ_ADD);
+                kobject_uevent(&class_dev->kobj, KOBJ_ADD);
                 wait_for_completion(&fw_priv->completion);
                 set_bit(FW_STATUS_DONE, &fw_priv->status);
                 del_timer_sync(&fw_priv->timeout);
@@ -456,7 +455,7 @@ out:
 }
 
 /**
- * request_firmware: - request firmware to hotplug and wait for it
+ * request_firmware: - send firmware request and wait for it
  * @firmware_p: pointer to firmware image
  * @name: name of firmware file
  * @device: device for which firmware is being loaded
@@ -466,7 +465,7 @@ out:
  *
  *      Should be called from user context where sleeping is allowed.
  *
- *      @name will be used as $FIRMWARE in the hotplug environment and
+ *      @name will be used as $FIRMWARE in the uevent environment and
  *      should be distinctive enough not to be confused with any other
  *      firmware image for this or any other device.
  **/
@@ -474,8 +473,8 @@ int
 request_firmware(const struct firmware **firmware_p, const char *name,
                  struct device *device)
 {
-        int hotplug = 1;
-        return _request_firmware(firmware_p, name, device, hotplug);
+        int uevent = 1;
+        return _request_firmware(firmware_p, name, device, uevent);
 }
 
 /**
@@ -518,7 +517,7 @@ struct firmware_work {
         struct device *device;
         void *context;
         void (*cont)(const struct firmware *fw, void *context);
-        int hotplug;
+        int uevent;
 };
 
 static int
@@ -533,7 +532,7 @@ request_firmware_work_func(void *arg)
         }
         daemonize("%s/%s", "firmware", fw_work->name);
         ret = _request_firmware(&fw, fw_work->name, fw_work->device,
-                fw_work->hotplug);
+                fw_work->uevent);
         if (ret < 0)
                 fw_work->cont(NULL, fw_work->context);
         else {
@@ -548,7 +547,7 @@ request_firmware_work_func(void *arg)
 /**
  * request_firmware_nowait: asynchronous version of request_firmware
  * @module: module requesting the firmware
- * @hotplug: invokes hotplug event to copy the firmware image if this flag
+ * @uevent: sends uevent to copy the firmware image if this flag
  *      is non-zero else the firmware copy must be done manually.
  * @name: name of firmware file
  * @device: device for which firmware is being loaded
@@ -562,7 +561,7 @@ request_firmware_work_func(void *arg)
  **/
 int
 request_firmware_nowait(
-        struct module *module, int hotplug,
+        struct module *module, int uevent,
         const char *name, struct device *device, void *context,
         void (*cont)(const struct firmware *fw, void *context))
 {
@@ -583,7 +582,7 @@ request_firmware_nowait(
                 .device = device,
                 .context = context,
                 .cont = cont,
-                .hotplug = hotplug,
+                .uevent = uevent,
         };
 
         ret = kernel_thread(request_firmware_work_func, fw_work,
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index bc3ca6a656b2..7e1d077874df 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -29,12 +29,12 @@ static struct sysdev_class memory_sysdev_class = {
         set_kset_name(MEMORY_CLASS_NAME),
 };
 
-static char *memory_hotplug_name(struct kset *kset, struct kobject *kobj)
+static const char *memory_uevent_name(struct kset *kset, struct kobject *kobj)
 {
         return MEMORY_CLASS_NAME;
 }
 
-static int memory_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
+static int memory_uevent(struct kset *kset, struct kobject *kobj, char **envp,
                         int num_envp, char *buffer, int buffer_size)
 {
         int retval = 0;
@@ -42,9 +42,9 @@ static int memory_hotplug(struct kset *kset, struct kobject *kobj, char **envp,
         return retval;
 }
 
-static struct kset_hotplug_ops memory_hotplug_ops = {
-        .name           = memory_hotplug_name,
-        .hotplug        = memory_hotplug,
+static struct kset_uevent_ops memory_uevent_ops = {
+        .name           = memory_uevent_name,
+        .uevent         = memory_uevent,
 };
 
 static struct notifier_block *memory_chain;
@@ -431,7 +431,7 @@ int __init memory_dev_init(void)
         unsigned int i;
         int ret;
 
-        memory_sysdev_class.kset.hotplug_ops = &memory_hotplug_ops;
+        memory_sysdev_class.kset.uevent_ops = &memory_uevent_ops;
         ret = sysdev_class_register(&memory_sysdev_class);
 
         /*
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 8827dafba945..0f81731bdfa8 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -25,6 +25,7 @@
 struct device platform_bus = {
         .bus_id         = "platform",
 };
+EXPORT_SYMBOL_GPL(platform_bus);
 
 /**
  *      platform_get_resource - get a resource for a device
@@ -49,6 +50,7 @@ platform_get_resource(struct platform_device *dev, unsigned int type,
         }
         return NULL;
 }
+EXPORT_SYMBOL_GPL(platform_get_resource);
 
 /**
  *      platform_get_irq - get an IRQ for a device
@@ -61,6 +63,7 @@ int platform_get_irq(struct platform_device *dev, unsigned int num)
 
         return r ? r->start : 0;
 }
+EXPORT_SYMBOL_GPL(platform_get_irq);
 
 /**
  *      platform_get_resource_byname - get a resource for a device by name
@@ -84,6 +87,7 @@ platform_get_resource_byname(struct platform_device *dev, unsigned int type,
         }
         return NULL;
 }
+EXPORT_SYMBOL_GPL(platform_get_resource_byname);
 
 /**
  *      platform_get_irq - get an IRQ for a device
@@ -96,6 +100,7 @@ int platform_get_irq_byname(struct platform_device *dev, char *name)
 
         return r ? r->start : 0;
 }
+EXPORT_SYMBOL_GPL(platform_get_irq_byname);
 
 /**
  *      platform_add_devices - add a numbers of platform devices
@@ -117,6 +122,7 @@ int platform_add_devices(struct platform_device **devs, int num)
 
         return ret;
 }
+EXPORT_SYMBOL_GPL(platform_add_devices);
 
 struct platform_object {
         struct platform_device pdev;
@@ -168,7 +174,7 @@ struct platform_device *platform_device_alloc(const char *name, unsigned int id)
                 pa->pdev.dev.release = platform_device_release;
         }
 
-        return pa ? &pa->pdev : NULL;   
+        return pa ? &pa->pdev : NULL;
 }
 EXPORT_SYMBOL_GPL(platform_device_alloc);
 
@@ -257,7 +263,7 @@ int platform_device_add(struct platform_device *pdev)
                                 p = &ioport_resource;
                 }
 
-                if (p && request_resource(p, r)) {
+                if (p && insert_resource(p, r)) {
                         printk(KERN_ERR
                                "%s: failed to claim resource %d\n",
                                pdev->dev.bus_id, i);
@@ -282,24 +288,13 @@ int platform_device_add(struct platform_device *pdev)
 EXPORT_SYMBOL_GPL(platform_device_add);
 
 /**
- *      platform_device_register - add a platform-level device
- *      @pdev:  platform device we're adding
- *
- */
-int platform_device_register(struct platform_device * pdev)
-{
-        device_initialize(&pdev->dev);
-        return platform_device_add(pdev);
-}
-
-/**
- *      platform_device_unregister - remove a platform-level device
+ *      platform_device_del - remove a platform-level device
  *      @pdev:  platform device we're removing
  *
  *      Note that this function will also release all memory- and port-based
  *      resources owned by the device (@dev->resource).
  */
-void platform_device_unregister(struct platform_device * pdev)
+void platform_device_del(struct platform_device *pdev)
 {
         int i;
 
@@ -310,9 +305,37 @@ void platform_device_unregister(struct platform_device * pdev)
                                 release_resource(r);
                 }
 
-                device_unregister(&pdev->dev);
+                device_del(&pdev->dev);
         }
 }
+EXPORT_SYMBOL_GPL(platform_device_del);
+
+/**
+ *      platform_device_register - add a platform-level device
+ *      @pdev:  platform device we're adding
+ *
+ */
+int platform_device_register(struct platform_device * pdev)
+{
+        device_initialize(&pdev->dev);
+        return platform_device_add(pdev);
+}
+EXPORT_SYMBOL_GPL(platform_device_register);
+
+/**
+ *      platform_device_unregister - unregister a platform-level device
+ *      @pdev:  platform device we're unregistering
+ *
+ *      Unregistration is done in 2 steps. Fisrt we release all resources
+ *      and remove it from the sybsystem, then we drop reference count by
+ *      calling platform_device_put().
+ */
+void platform_device_unregister(struct platform_device * pdev)
+{
+        platform_device_del(pdev);
+        platform_device_put(pdev);
+}
+EXPORT_SYMBOL_GPL(platform_device_unregister);
 
 /**
  *      platform_device_register_simple
@@ -355,6 +378,7 @@ error:
         platform_device_put(pdev);
         return ERR_PTR(retval);
 }
+EXPORT_SYMBOL_GPL(platform_device_register_simple);
 
 static int platform_drv_probe(struct device *_dev)
 {
@@ -476,6 +500,7 @@ struct bus_type platform_bus_type = {
         .suspend        = platform_suspend,
         .resume         = platform_resume,
 };
+EXPORT_SYMBOL_GPL(platform_bus_type);
 
 int __init platform_bus_init(void)
 {
@@ -504,14 +529,3 @@ u64 dma_get_required_mask(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(dma_get_required_mask);
 #endif
-
-EXPORT_SYMBOL_GPL(platform_bus);
-EXPORT_SYMBOL_GPL(platform_bus_type);
-EXPORT_SYMBOL_GPL(platform_add_devices);
-EXPORT_SYMBOL_GPL(platform_device_register);
-EXPORT_SYMBOL_GPL(platform_device_register_simple);
-EXPORT_SYMBOL_GPL(platform_device_unregister);
-EXPORT_SYMBOL_GPL(platform_get_irq);
-EXPORT_SYMBOL_GPL(platform_get_resource);
-EXPORT_SYMBOL_GPL(platform_get_irq_byname);
-EXPORT_SYMBOL_GPL(platform_get_resource_byname);
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index adbc3148c039..96370ec1d673 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -62,8 +62,10 @@ int dpm_runtime_suspend(struct device * dev, pm_message_t state)
         up(&dpm_sem);
         return error;
 }
+EXPORT_SYMBOL(dpm_runtime_suspend);
 
 
+#if 0
 /**
  *      dpm_set_power_state - Update power_state field.
  *      @dev:   Device.
@@ -80,3 +82,4 @@ void dpm_set_power_state(struct device * dev, pm_message_t state)
         dev->power.power_state = state;
         up(&dpm_sem);
 }
+#endif  /*  0  */