16 files changed, 219 insertions, 157 deletions

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index 07abd9d76f7f..5daa2599ed48 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -2,7 +2,6 @@ menu "Generic Driver Options"
 
 config UEVENT_HELPER_PATH
         string "path to uevent helper"
-        depends on HOTPLUG
         default ""
         help
           Path to uevent helper program forked by the kernel for
@@ -23,7 +22,6 @@ config UEVENT_HELPER_PATH
 
 config DEVTMPFS
         bool "Maintain a devtmpfs filesystem to mount at /dev"
-        depends on HOTPLUG
         help
           This creates a tmpfs/ramfs filesystem instance early at bootup.
           In this filesystem, the kernel driver core maintains device
diff --git a/drivers/base/core.c b/drivers/base/core.c
index 2499cefdcdf2..6fdc53d46fa0 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -193,12 +193,12 @@ ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
 EXPORT_SYMBOL_GPL(device_show_bool);
 
 /**
- *      device_release - free device structure.
- *      @kobj:  device's kobject.
+ * device_release - free device structure.
+ * @kobj: device's kobject.
  *
- *      This is called once the reference count for the object
- *      reaches 0. We forward the call to the device's release
- *      method, which should handle actually freeing the structure.
+ * This is called once the reference count for the object
+ * reaches 0. We forward the call to the device's release
+ * method, which should handle actually freeing the structure.
  */
 static void device_release(struct kobject *kobj)
 {
@@ -1334,8 +1334,8 @@ const char *device_get_devnode(struct device *dev,
 /**
  * device_for_each_child - device child iterator.
  * @parent: parent struct device.
- * @data: data for the callback.
  * @fn: function to be called for each device.
+ * @data: data for the callback.
  *
  * Iterate over @parent's child devices, and call @fn for each,
  * passing it @data.
@@ -1363,8 +1363,8 @@ int device_for_each_child(struct device *parent, void *data,
 /**
  * device_find_child - device iterator for locating a particular device.
  * @parent: parent struct device
- * @data: Data to pass to match function
  * @match: Callback function to check device
+ * @data: Data to pass to match function
  *
  * This is similar to the device_for_each_child() function above, but it
  * returns a reference to a device that is 'found' for later use, as
@@ -1374,6 +1374,8 @@ int device_for_each_child(struct device *parent, void *data,
  * if it does.  If the callback returns non-zero and a reference to the
  * current device can be obtained, this function will return to the caller
  * and not iterate over any more devices.
+ *
+ * NOTE: you will need to drop the reference with put_device() after use.
  */
 struct device *device_find_child(struct device *parent, void *data,
                                  int (*match)(struct device *dev, void *data))
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 3d48fc887ef4..c377673320ed 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -85,18 +85,21 @@ static ssize_t __ref store_online(struct device *dev,
 }
 static DEVICE_ATTR(online, 0644, show_online, store_online);
 
-static void __cpuinit register_cpu_control(struct cpu *cpu)
-{
-        device_create_file(&cpu->dev, &dev_attr_online);
-}
+static struct attribute *hotplug_cpu_attrs[] = {
+        &dev_attr_online.attr,
+        NULL
+};
+
+static struct attribute_group hotplug_cpu_attr_group = {
+        .attrs = hotplug_cpu_attrs,
+};
+
 void unregister_cpu(struct cpu *cpu)
 {
         int logical_cpu = cpu->dev.id;
 
         unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
 
-        device_remove_file(&cpu->dev, &dev_attr_online);
-
         device_unregister(&cpu->dev);
         per_cpu(cpu_sys_devices, logical_cpu) = NULL;
         return;
@@ -122,11 +125,6 @@ static ssize_t cpu_release_store(struct device *dev,
 static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
 static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
-
-#else /* ... !CONFIG_HOTPLUG_CPU */
-static inline void register_cpu_control(struct cpu *cpu)
-{
-}
 #endif /* CONFIG_HOTPLUG_CPU */
 
 #ifdef CONFIG_KEXEC
@@ -164,8 +162,35 @@ static ssize_t show_crash_notes_size(struct device *dev,
         return rc;
 }
 static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
+
+static struct attribute *crash_note_cpu_attrs[] = {
+        &dev_attr_crash_notes.attr,
+        &dev_attr_crash_notes_size.attr,
+        NULL
+};
+
+static struct attribute_group crash_note_cpu_attr_group = {
+        .attrs = crash_note_cpu_attrs,
+};
 #endif
 
+static const struct attribute_group *common_cpu_attr_groups[] = {
+#ifdef CONFIG_KEXEC
+        &crash_note_cpu_attr_group,
+#endif
+        NULL
+};
+
+static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
+#ifdef CONFIG_KEXEC
+        &crash_note_cpu_attr_group,
+#endif
+#ifdef CONFIG_HOTPLUG_CPU
+        &hotplug_cpu_attr_group,
+#endif
+        NULL
+};
+
 /*
  * Print cpu online, possible, present, and system maps
  */
@@ -280,21 +305,15 @@ int __cpuinit register_cpu(struct cpu *cpu, int num)
 #ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
         cpu->dev.bus->uevent = arch_cpu_uevent;
 #endif
+        cpu->dev.groups = common_cpu_attr_groups;
+        if (cpu->hotpluggable)
+                cpu->dev.groups = hotplugable_cpu_attr_groups;
         error = device_register(&cpu->dev);
-        if (!error && cpu->hotpluggable)
-                register_cpu_control(cpu);
         if (!error)
                 per_cpu(cpu_sys_devices, num) = &cpu->dev;
         if (!error)
                 register_cpu_under_node(num, cpu_to_node(num));
 
-#ifdef CONFIG_KEXEC
-        if (!error)
-                error = device_create_file(&cpu->dev, &dev_attr_crash_notes);
-        if (!error)
-                error = device_create_file(&cpu->dev,
-                                           &dev_attr_crash_notes_size);
-#endif
         return error;
 }
 
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 01e21037d8fe..a439602ea919 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -27,6 +27,7 @@
 #include <linux/pm.h>
 #include <linux/suspend.h>
 #include <linux/syscore_ops.h>
+#include <linux/reboot.h>
 
 #include <generated/utsrelease.h>
 
@@ -127,9 +128,11 @@ struct firmware_buf {
         size_t size;
 #ifdef CONFIG_FW_LOADER_USER_HELPER
         bool is_paged_buf;
+        bool need_uevent;
         struct page **pages;
         int nr_pages;
         int page_array_size;
+        struct list_head pending_list;
 #endif
         char fw_id[];
 };
@@ -171,6 +174,9 @@ static struct firmware_buf *__allocate_fw_buf(const char *fw_name,
         strcpy(buf->fw_id, fw_name);
         buf->fwc = fwc;
         init_completion(&buf->completion);
+#ifdef CONFIG_FW_LOADER_USER_HELPER
+        INIT_LIST_HEAD(&buf->pending_list);
+#endif
 
         pr_debug("%s: fw-%s buf=%p\n", __func__, fw_name, buf);
 
@@ -212,18 +218,6 @@ static int fw_lookup_and_allocate_buf(const char *fw_name,
         return tmp ? 0 : -ENOMEM;
 }
 
-static struct firmware_buf *fw_lookup_buf(const char *fw_name)
-{
-        struct firmware_buf *tmp;
-        struct firmware_cache *fwc = &fw_cache;
-
-        spin_lock(&fwc->lock);
-        tmp = __fw_lookup_buf(fw_name);
-        spin_unlock(&fwc->lock);
-
-        return tmp;
-}
-
 static void __fw_free_buf(struct kref *ref)
 {
         struct firmware_buf *buf = to_fwbuf(ref);
@@ -446,10 +440,8 @@ static struct firmware_priv *to_firmware_priv(struct device *dev)
         return container_of(dev, struct firmware_priv, dev);
 }
 
-static void fw_load_abort(struct firmware_priv *fw_priv)
+static void __fw_load_abort(struct firmware_buf *buf)
 {
-        struct firmware_buf *buf = fw_priv->buf;
-
         /*
          * There is a small window in which user can write to 'loading'
          * between loading done and disappearance of 'loading'
@@ -457,8 +449,16 @@ static void fw_load_abort(struct firmware_priv *fw_priv)
         if (test_bit(FW_STATUS_DONE, &buf->status))
                 return;
 
+        list_del_init(&buf->pending_list);
         set_bit(FW_STATUS_ABORT, &buf->status);
         complete_all(&buf->completion);
+}
+
+static void fw_load_abort(struct firmware_priv *fw_priv)
+{
+        struct firmware_buf *buf = fw_priv->buf;
+
+        __fw_load_abort(buf);
 
         /* avoid user action after loading abort */
         fw_priv->buf = NULL;
@@ -467,6 +467,25 @@ static void fw_load_abort(struct firmware_priv *fw_priv)
 #define is_fw_load_aborted(buf) \
         test_bit(FW_STATUS_ABORT, &(buf)->status)
 
+static LIST_HEAD(pending_fw_head);
+
+/* reboot notifier for avoid deadlock with usermode_lock */
+static int fw_shutdown_notify(struct notifier_block *unused1,
+                              unsigned long unused2, void *unused3)
+{
+        mutex_lock(&fw_lock);
+        while (!list_empty(&pending_fw_head))
+                __fw_load_abort(list_first_entry(&pending_fw_head,
+                                               struct firmware_buf,
+                                               pending_list));
+        mutex_unlock(&fw_lock);
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block fw_shutdown_nb = {
+        .notifier_call = fw_shutdown_notify,
+};
+
 static ssize_t firmware_timeout_show(struct class *class,
                                      struct class_attribute *attr,
                                      char *buf)
@@ -509,8 +528,6 @@ static void fw_dev_release(struct device *dev)
         struct firmware_priv *fw_priv = to_firmware_priv(dev);
 
         kfree(fw_priv);
-
-        module_put(THIS_MODULE);
 }
 
 static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env)
@@ -619,6 +636,7 @@ static ssize_t firmware_loading_store(struct device *dev,
                          * is completed.
                          * */
                         fw_map_pages_buf(fw_buf);
+                        list_del_init(&fw_buf->pending_list);
                         complete_all(&fw_buf->completion);
                         break;
                 }
@@ -838,9 +856,6 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
 
         dev_set_uevent_suppress(f_dev, true);
 
-        /* Need to pin this module until class device is destroyed */
-        __module_get(THIS_MODULE);
-
         retval = device_add(f_dev);
         if (retval) {
                 dev_err(f_dev, "%s: device_register failed\n", __func__);
@@ -860,6 +875,7 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
         }
 
         if (uevent) {
+                buf->need_uevent = true;
                 dev_set_uevent_suppress(f_dev, false);
                 dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id);
                 if (timeout != MAX_SCHEDULE_TIMEOUT)
@@ -868,6 +884,10 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
                 kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
         }
 
+        mutex_lock(&fw_lock);
+        list_add(&buf->pending_list, &pending_fw_head);
+        mutex_unlock(&fw_lock);
+
         wait_for_completion(&buf->completion);
 
         cancel_delayed_work_sync(&fw_priv->timeout_work);
@@ -895,6 +915,23 @@ static int fw_load_from_user_helper(struct firmware *firmware,
         fw_priv->buf = firmware->priv;
         return _request_firmware_load(fw_priv, uevent, timeout);
 }
+
+#ifdef CONFIG_PM_SLEEP
+/* kill pending requests without uevent to avoid blocking suspend */
+static void kill_requests_without_uevent(void)
+{
+        struct firmware_buf *buf;
+        struct firmware_buf *next;
+
+        mutex_lock(&fw_lock);
+        list_for_each_entry_safe(buf, next, &pending_fw_head, pending_list) {
+                if (!buf->need_uevent)
+                         __fw_load_abort(buf);
+        }
+        mutex_unlock(&fw_lock);
+}
+#endif
+
 #else /* CONFIG_FW_LOADER_USER_HELPER */
 static inline int
 fw_load_from_user_helper(struct firmware *firmware, const char *name,
@@ -907,6 +944,10 @@ fw_load_from_user_helper(struct firmware *firmware, const char *name,
 /* No abort during direct loading */
 #define is_fw_load_aborted(buf) false
 
+#ifdef CONFIG_PM_SLEEP
+static inline void kill_requests_without_uevent(void) { }
+#endif
+
 #endif /* CONFIG_FW_LOADER_USER_HELPER */
 
 
@@ -974,7 +1015,8 @@ _request_firmware_prepare(struct firmware **firmware_p, const char *name,
         return 1; /* need to load */
 }
 
-static int assign_firmware_buf(struct firmware *fw, struct device *device)
+static int assign_firmware_buf(struct firmware *fw, struct device *device,
+                                bool skip_cache)
 {
         struct firmware_buf *buf = fw->priv;
 
@@ -991,7 +1033,7 @@ static int assign_firmware_buf(struct firmware *fw, struct device *device)
          * device may has been deleted already, but the problem
          * should be fixed in devres or driver core.
          */
-        if (device)
+        if (device && !skip_cache)
                 fw_add_devm_name(device, buf->fw_id);
 
         /*
@@ -1047,8 +1089,10 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
         if (!fw_get_filesystem_firmware(device, fw->priv))
                 ret = fw_load_from_user_helper(fw, name, device,
                                                uevent, nowait, timeout);
+
+        /* don't cache firmware handled without uevent */
         if (!ret)
-                ret = assign_firmware_buf(fw, device);
+                ret = assign_firmware_buf(fw, device, !uevent);
 
         usermodehelper_read_unlock();
 
@@ -1086,8 +1130,15 @@ int
 request_firmware(const struct firmware **firmware_p, const char *name,
                  struct device *device)
 {
-        return _request_firmware(firmware_p, name, device, true, false);
+        int ret;
+
+        /* Need to pin this module until return */
+        __module_get(THIS_MODULE);
+        ret = _request_firmware(firmware_p, name, device, true, false);
+        module_put(THIS_MODULE);
+        return ret;
 }
+EXPORT_SYMBOL(request_firmware);
 
 /**
  * release_firmware: - release the resource associated with a firmware image
@@ -1101,6 +1152,7 @@ void release_firmware(const struct firmware *fw)
                 kfree(fw);
         }
 }
+EXPORT_SYMBOL(release_firmware);
 
 /* Async support */
 struct firmware_work {
@@ -1181,6 +1233,10 @@ request_firmware_nowait(
         schedule_work(&fw_work->work);
         return 0;
 }
+EXPORT_SYMBOL(request_firmware_nowait);
+
+#ifdef CONFIG_PM_SLEEP
+static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain);
 
 /**
  * cache_firmware - cache one firmware image in kernel memory space
@@ -1196,7 +1252,7 @@ request_firmware_nowait(
  * Return !0 otherwise
  *
  */
-int cache_firmware(const char *fw_name)
+static int cache_firmware(const char *fw_name)
 {
         int ret;
         const struct firmware *fw;
@@ -1212,6 +1268,18 @@ int cache_firmware(const char *fw_name)
         return ret;
 }
 
+static struct firmware_buf *fw_lookup_buf(const char *fw_name)
+{
+        struct firmware_buf *tmp;
+        struct firmware_cache *fwc = &fw_cache;
+
+        spin_lock(&fwc->lock);
+        tmp = __fw_lookup_buf(fw_name);
+        spin_unlock(&fwc->lock);
+
+        return tmp;
+}
+
 /**
  * uncache_firmware - remove one cached firmware image
  * @fw_name: the firmware image name
@@ -1223,7 +1291,7 @@ int cache_firmware(const char *fw_name)
  * Return !0 otherwise
  *
  */
-int uncache_firmware(const char *fw_name)
+static int uncache_firmware(const char *fw_name)
 {
         struct firmware_buf *buf;
         struct firmware fw;
@@ -1242,9 +1310,6 @@ int uncache_firmware(const char *fw_name)
         return -EINVAL;
 }
 
-#ifdef CONFIG_PM_SLEEP
-static ASYNC_DOMAIN_EXCLUSIVE(fw_cache_domain);
-
 static struct fw_cache_entry *alloc_fw_cache_entry(const char *name)
 {
         struct fw_cache_entry *fce;
@@ -1464,6 +1529,7 @@ static int fw_pm_notify(struct notifier_block *notify_block,
         switch (mode) {
         case PM_HIBERNATION_PREPARE:
         case PM_SUSPEND_PREPARE:
+                kill_requests_without_uevent();
                 device_cache_fw_images();
                 break;
 
@@ -1526,6 +1592,7 @@ static int __init firmware_class_init(void)
 {
         fw_cache_init();
 #ifdef CONFIG_FW_LOADER_USER_HELPER
+        register_reboot_notifier(&fw_shutdown_nb);
         return class_register(&firmware_class);
 #else
         return 0;
@@ -1539,15 +1606,10 @@ static void __exit firmware_class_exit(void)
         unregister_pm_notifier(&fw_cache.pm_notify);
 #endif
 #ifdef CONFIG_FW_LOADER_USER_HELPER
+        unregister_reboot_notifier(&fw_shutdown_nb);
         class_unregister(&firmware_class);
 #endif
 }
 
 fs_initcall(firmware_class_init);
 module_exit(firmware_class_exit);
-
-EXPORT_SYMBOL(release_firmware);
-EXPORT_SYMBOL(request_firmware);
-EXPORT_SYMBOL(request_firmware_nowait);
-EXPORT_SYMBOL_GPL(cache_firmware);
-EXPORT_SYMBOL_GPL(uncache_firmware);
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index 14f8a6954da0..e315051cfeeb 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -77,22 +77,6 @@ static void memory_block_release(struct device *dev)
         kfree(mem);
 }
 
-/*
- * register_memory - Setup a sysfs device for a memory block
- */
-static
-int register_memory(struct memory_block *memory)
-{
-        int error;
-
-        memory->dev.bus = &memory_subsys;
-        memory->dev.id = memory->start_section_nr / sections_per_block;
-        memory->dev.release = memory_block_release;
-
-        error = device_register(&memory->dev);
-        return error;
-}
-
 unsigned long __weak memory_block_size_bytes(void)
 {
         return MIN_MEMORY_BLOCK_SIZE;
@@ -371,11 +355,6 @@ static DEVICE_ATTR(state, 0644, show_mem_state, store_mem_state);
 static DEVICE_ATTR(phys_device, 0444, show_phys_device, NULL);
 static DEVICE_ATTR(removable, 0444, show_mem_removable, NULL);
 
-#define mem_create_simple_file(mem, attr_name)  \
-        device_create_file(&mem->dev, &dev_attr_##attr_name)
-#define mem_remove_simple_file(mem, attr_name)  \
-        device_remove_file(&mem->dev, &dev_attr_##attr_name)
-
 /*
  * Block size attribute stuff
  */
@@ -388,12 +367,6 @@ print_block_size(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(block_size_bytes, 0444, print_block_size, NULL);
 
-static int block_size_init(void)
-{
-        return device_create_file(memory_subsys.dev_root,
-                                  &dev_attr_block_size_bytes);
-}
-
 /*
  * Some architectures will have custom drivers to do this, and
  * will not need to do it from userspace.  The fake hot-add code
@@ -429,17 +402,8 @@ memory_probe_store(struct device *dev, struct device_attribute *attr,
 out:
         return ret;
 }
-static DEVICE_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
 
-static int memory_probe_init(void)
-{
-        return device_create_file(memory_subsys.dev_root, &dev_attr_probe);
-}
-#else
-static inline int memory_probe_init(void)
-{
-        return 0;
-}
+static DEVICE_ATTR(probe, S_IWUSR, NULL, memory_probe_store);
 #endif
 
 #ifdef CONFIG_MEMORY_FAILURE
@@ -485,23 +449,6 @@ store_hard_offline_page(struct device *dev,
 
 static DEVICE_ATTR(soft_offline_page, S_IWUSR, NULL, store_soft_offline_page);
 static DEVICE_ATTR(hard_offline_page, S_IWUSR, NULL, store_hard_offline_page);
-
-static __init int memory_fail_init(void)
-{
-        int err;
-
-        err = device_create_file(memory_subsys.dev_root,
-                                &dev_attr_soft_offline_page);
-        if (!err)
-                err = device_create_file(memory_subsys.dev_root,
-                                &dev_attr_hard_offline_page);
-        return err;
-}
-#else
-static inline int memory_fail_init(void)
-{
-        return 0;
-}
 #endif
 
 /*
@@ -546,6 +493,41 @@ struct memory_block *find_memory_block(struct mem_section *section)
         return find_memory_block_hinted(section, NULL);
 }
 
+static struct attribute *memory_memblk_attrs[] = {
+        &dev_attr_phys_index.attr,
+        &dev_attr_end_phys_index.attr,
+        &dev_attr_state.attr,
+        &dev_attr_phys_device.attr,
+        &dev_attr_removable.attr,
+        NULL
+};
+
+static struct attribute_group memory_memblk_attr_group = {
+        .attrs = memory_memblk_attrs,
+};
+
+static const struct attribute_group *memory_memblk_attr_groups[] = {
+        &memory_memblk_attr_group,
+        NULL,
+};
+
+/*
+ * register_memory - Setup a sysfs device for a memory block
+ */
+static
+int register_memory(struct memory_block *memory)
+{
+        int error;
+
+        memory->dev.bus = &memory_subsys;
+        memory->dev.id = memory->start_section_nr / sections_per_block;
+        memory->dev.release = memory_block_release;
+        memory->dev.groups = memory_memblk_attr_groups;
+
+        error = device_register(&memory->dev);
+        return error;
+}
+
 static int init_memory_block(struct memory_block **memory,
                              struct mem_section *section, unsigned long state)
 {
@@ -569,16 +551,6 @@ static int init_memory_block(struct memory_block **memory,
         mem->phys_device = arch_get_memory_phys_device(start_pfn);
 
         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;
@@ -656,14 +628,9 @@ static int remove_memory_block(unsigned long node_id,
         unregister_mem_sect_under_nodes(mem, __section_nr(section));
 
         mem->section_count--;
-        if (mem->section_count == 0) {
-                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);
+        if (mem->section_count == 0)
                 unregister_memory(mem);
-        } else
+        else
                 kobject_put(&mem->dev.kobj);
 
         mutex_unlock(&mem_sysfs_mutex);
@@ -700,6 +667,29 @@ bool is_memblock_offlined(struct memory_block *mem)
         return mem->state == MEM_OFFLINE;
 }
 
+static struct attribute *memory_root_attrs[] = {
+#ifdef CONFIG_ARCH_MEMORY_PROBE
+        &dev_attr_probe.attr,
+#endif
+
+#ifdef CONFIG_MEMORY_FAILURE
+        &dev_attr_soft_offline_page.attr,
+        &dev_attr_hard_offline_page.attr,
+#endif
+
+        &dev_attr_block_size_bytes.attr,
+        NULL
+};
+
+static struct attribute_group memory_root_attr_group = {
+        .attrs = memory_root_attrs,
+};
+
+static const struct attribute_group *memory_root_attr_groups[] = {
+        &memory_root_attr_group,
+        NULL,
+};
+
 /*
  * Initialize the sysfs support for memory devices...
  */
@@ -711,7 +701,7 @@ int __init memory_dev_init(void)
         unsigned long block_sz;
         struct memory_block *mem = NULL;
 
-        ret = subsys_system_register(&memory_subsys, NULL);
+        ret = subsys_system_register(&memory_subsys, memory_root_attr_groups);
         if (ret)
                 goto out;
 
@@ -734,15 +724,6 @@ int __init memory_dev_init(void)
                         ret = err;
         }
 
-        err = memory_probe_init();
-        if (!ret)
-                ret = err;
-        err = memory_fail_init();
-        if (!ret)
-                ret = err;
-        err = block_size_init();
-        if (!ret)
-                ret = err;
 out:
         if (ret)
                 printk(KERN_ERR "%s() failed: %d\n", __func__, ret);
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 9eda84246ffd..ed75cf6ef9c9 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -523,11 +523,13 @@ static void platform_drv_shutdown(struct device *_dev)
 }
 
 /**
- * platform_driver_register - register a driver for platform-level devices
+ * __platform_driver_register - register a driver for platform-level devices
  * @drv: platform driver structure
  */
-int platform_driver_register(struct platform_driver *drv)
+int __platform_driver_register(struct platform_driver *drv,
+                                struct module *owner)
 {
+        drv->driver.owner = owner;
         drv->driver.bus = &platform_bus_type;
         if (drv->probe)
                 drv->driver.probe = platform_drv_probe;
@@ -538,7 +540,7 @@ int platform_driver_register(struct platform_driver *drv)
 
         return driver_register(&drv->driver);
 }
-EXPORT_SYMBOL_GPL(platform_driver_register);
+EXPORT_SYMBOL_GPL(__platform_driver_register);
 
 /**
  * platform_driver_unregister - unregister a driver for platform-level devices
diff --git a/drivers/char/pcmcia/Kconfig b/drivers/char/pcmcia/Kconfig
index 2a166d56738a..b27f5342fe76 100644
--- a/drivers/char/pcmcia/Kconfig
+++ b/drivers/char/pcmcia/Kconfig
@@ -3,7 +3,7 @@
 #
 
 menu "PCMCIA character devices"
-        depends on HOTPLUG && PCMCIA!=n
+        depends on PCMCIA!=n
 
 config SYNCLINK_CS
         tristate "SyncLink PC Card support"
diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig
index e443f2c1dfd1..a697a64d5383 100644
--- a/drivers/edac/Kconfig
+++ b/drivers/edac/Kconfig
@@ -145,7 +145,7 @@ config EDAC_E7XXX
 
 config EDAC_E752X
         tristate "Intel e752x (e7520, e7525, e7320) and 3100"
-        depends on EDAC_MM_EDAC && PCI && X86 && HOTPLUG
+        depends on EDAC_MM_EDAC && PCI && X86
         help
           Support for error detection and correction on the Intel
           E7520, E7525, E7320 server chipsets.
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 93876302fb2e..074787281c94 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -64,6 +64,7 @@ config DELL_RBU
         tristate "BIOS update support for DELL systems via sysfs"
         depends on X86
         select FW_LOADER
+        select FW_LOADER_USER_HELPER
         help
          Say m if you want to have the option of updating the BIOS for your
          DELL system. Note you need a Dell OpenManage or Dell Update package (DUP)
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 80889d5f95f5..8dacd4c9ee87 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -135,7 +135,7 @@ config PHANTOM
 
 config INTEL_MID_PTI
         tristate "Parallel Trace Interface for MIPI P1149.7 cJTAG standard"
-        depends on PCI && TTY
+        depends on PCI && TTY && (X86_INTEL_MID || COMPILE_TEST)
         default n
         help
           The PTI (Parallel Trace Interface) driver directs
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 6d51aa68ec7a..77497f140d68 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -55,7 +55,6 @@ config PCI_STUB
 config XEN_PCIDEV_FRONTEND
         tristate "Xen PCI Frontend"
         depends on PCI && X86 && XEN
-        select HOTPLUG
         select PCI_XEN
         select XEN_XENBUS_FRONTEND
         default y
@@ -113,7 +112,6 @@ config PCI_IOAPIC
         tristate "PCI IO-APIC hotplug support" if X86
         depends on PCI
         depends on ACPI
-        depends on HOTPLUG
         default !X86
 
 config PCI_LABEL
diff --git a/drivers/pci/hotplug/Kconfig b/drivers/pci/hotplug/Kconfig
index 9fcb87f353d4..bb7ebb22db01 100644
--- a/drivers/pci/hotplug/Kconfig
+++ b/drivers/pci/hotplug/Kconfig
@@ -4,7 +4,7 @@
 
 menuconfig HOTPLUG_PCI
         tristate "Support for PCI Hotplug"
-        depends on PCI && HOTPLUG && SYSFS
+        depends on PCI && SYSFS
         ---help---
           Say Y here if you have a motherboard with a PCI Hotplug controller.
           This allows you to add and remove PCI cards while the machine is
diff --git a/drivers/pcmcia/Kconfig b/drivers/pcmcia/Kconfig
index 6f6193168281..0c657d6af03d 100644
--- a/drivers/pcmcia/Kconfig
+++ b/drivers/pcmcia/Kconfig
@@ -4,7 +4,6 @@
 
 menuconfig PCCARD
         tristate "PCCard (PCMCIA/CardBus) support"
-        depends on HOTPLUG
         ---help---
           Say Y here if you want to attach PCMCIA- or PC-cards to your Linux
           computer.  These are credit-card size devices such as network cards,
diff --git a/drivers/ptp/Kconfig b/drivers/ptp/Kconfig
index 1ea6f1dbbedd..5be73ba0519a 100644
--- a/drivers/ptp/Kconfig
+++ b/drivers/ptp/Kconfig
@@ -72,6 +72,7 @@ config DP83640_PHY
 
 config PTP_1588_CLOCK_PCH
         tristate "Intel PCH EG20T as PTP clock"
+        depends on X86 || COMPILE_TEST
         select PTP_1588_CLOCK
         help
           This driver adds support for using the PCH EG20T as a PTP
diff --git a/drivers/staging/media/go7007/go7007.txt b/drivers/staging/media/go7007/go7007.txt
index fcb3e235abbf..dc0026cff9f6 100644
--- a/drivers/staging/media/go7007/go7007.txt
+++ b/drivers/staging/media/go7007/go7007.txt
@@ -78,7 +78,6 @@ All vendor-built kernels should already be configured properly.  However,
 for custom-built kernels, the following options need to be enabled in the
 kernel as built-in or modules:
 
-        CONFIG_HOTPLUG           - Support for hot-pluggable devices
         CONFIG_MODULES           - Enable loadable module support
         CONFIG_KMOD              - Automatic kernel module loading
         CONFIG_FW_LOADER         - Hotplug firmware loading support
diff --git a/drivers/video/geode/Kconfig b/drivers/video/geode/Kconfig
index 21e351a14593..1e8555284786 100644
--- a/drivers/video/geode/Kconfig
+++ b/drivers/video/geode/Kconfig
@@ -3,7 +3,7 @@
 #
 config FB_GEODE
         bool "AMD Geode family framebuffer support"
-        depends on FB && PCI && X86
+        depends on FB && PCI && (X86_32 || (X86 && COMPILE_TEST))
         ---help---
           Say 'Y' here to allow you to select framebuffer drivers for
           the AMD Geode family of processors.