6 files changed, 86 insertions, 87 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/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/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);
 
         /*