Merge tag 'driver-core-3.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core

Pull driver core / sysfs patches from Greg KH:
 "Here's the big driver core and sysfs patch set for 3.14-rc1.

  There's a lot of work here moving sysfs logic out into a "kernfs" to
  allow other subsystems to also have a virtual filesystem with the same
  attributes of sysfs (handle device disconnect, dynamic creation /
  removal as needed / unneeded, etc)

  This is primarily being done for the cgroups filesystem, but the goal
  is to also move debugfs to it when it is ready, solving all of the
  known issues in that filesystem as well.  The code isn't completed
  yet, but all should be stable now (there is a big section that was
  reverted due to problems found when testing)

  There's also some other smaller fixes, and a driver core addition that
  allows for a "collection" of objects, that the DRM people will be
  using soon (it's in this tree to make merges after -rc1 easier)

  All of this has been in linux-next with no reported issues"

* tag 'driver-core-3.14-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core: (113 commits)
  kernfs: associate a new kernfs_node with its parent on creation
  kernfs: add struct dentry declaration in kernfs.h
  kernfs: fix get_active failure handling in kernfs_seq_*()
  Revert "kernfs: fix get_active failure handling in kernfs_seq_*()"
  Revert "kernfs: replace kernfs_node->u.completion with kernfs_root->deactivate_waitq"
  Revert "kernfs: remove KERNFS_ACTIVE_REF and add kernfs_lockdep()"
  Revert "kernfs: remove KERNFS_REMOVED"
  Revert "kernfs: restructure removal path to fix possible premature return"
  Revert "kernfs: invoke kernfs_unmap_bin_file() directly from __kernfs_remove()"
  Revert "kernfs: remove kernfs_addrm_cxt"
  Revert "kernfs: make kernfs_get_active() block if the node is deactivated but not removed"
  Revert "kernfs: implement kernfs_{de|re}activate[_self]()"
  Revert "kernfs, sysfs, driver-core: implement kernfs_remove_self() and its wrappers"
  Revert "pci: use device_remove_file_self() instead of device_schedule_callback()"
  Revert "scsi: use device_remove_file_self() instead of device_schedule_callback()"
  Revert "s390: use device_remove_file_self() instead of device_schedule_callback()"
  Revert "sysfs, driver-core: remove unused {sysfs|device}_schedule_callback_owner()"
  Revert "kernfs: remove unnecessary NULL check in __kernfs_remove()"
  kernfs: remove unnecessary NULL check in __kernfs_remove()
  drivers/base: provide an infrastructure for componentised subsystems
  ...

12 files changed, 478 insertions, 44 deletions

diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index 94e8a80e87f8..870ecfd503af 100644
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -1,6 +1,6 @@
 # Makefile for the Linux device tree
 
-obj-y                   := core.o bus.o dd.o syscore.o \
+obj-y                   := component.o core.o bus.o dd.o syscore.o \
                            driver.o class.o platform.o \
                            cpu.o firmware.o init.o map.o devres.o \
                            attribute_container.o transport_class.o \
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 73f6c2925281..59dc8086e4fa 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -146,8 +146,19 @@ void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
 }
 EXPORT_SYMBOL_GPL(bus_remove_file);
 
+static void bus_release(struct kobject *kobj)
+{
+        struct subsys_private *priv =
+                container_of(kobj, typeof(*priv), subsys.kobj);
+        struct bus_type *bus = priv->bus;
+
+        kfree(priv);
+        bus->p = NULL;
+}
+
 static struct kobj_type bus_ktype = {
         .sysfs_ops      = &bus_sysfs_ops,
+        .release        = bus_release,
 };
 
 static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
@@ -953,8 +964,6 @@ void bus_unregister(struct bus_type *bus)
         kset_unregister(bus->p->devices_kset);
         bus_remove_file(bus, &bus_attr_uevent);
         kset_unregister(&bus->p->subsys);
-        kfree(bus->p);
-        bus->p = NULL;
 }
 EXPORT_SYMBOL_GPL(bus_unregister);
 
diff --git a/drivers/base/component.c b/drivers/base/component.c
new file mode 100644
index 000000000000..c53efe6c6d8e
--- /dev/null
+++ b/drivers/base/component.c
@@ -0,0 +1,382 @@
+/*
+ * Componentized device handling.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This is work in progress.  We gather up the component devices into a list,
+ * and bind them when instructed.  At the moment, we're specific to the DRM
+ * subsystem, and only handles one master device, but this doesn't have to be
+ * the case.
+ */
+#include <linux/component.h>
+#include <linux/device.h>
+#include <linux/kref.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+
+struct master {
+        struct list_head node;
+        struct list_head components;
+        bool bound;
+
+        const struct component_master_ops *ops;
+        struct device *dev;
+};
+
+struct component {
+        struct list_head node;
+        struct list_head master_node;
+        struct master *master;
+        bool bound;
+
+        const struct component_ops *ops;
+        struct device *dev;
+};
+
+static DEFINE_MUTEX(component_mutex);
+static LIST_HEAD(component_list);
+static LIST_HEAD(masters);
+
+static struct master *__master_find(struct device *dev,
+        const struct component_master_ops *ops)
+{
+        struct master *m;
+
+        list_for_each_entry(m, &masters, node)
+                if (m->dev == dev && (!ops || m->ops == ops))
+                        return m;
+
+        return NULL;
+}
+
+/* Attach an unattached component to a master. */
+static void component_attach_master(struct master *master, struct component *c)
+{
+        c->master = master;
+
+        list_add_tail(&c->master_node, &master->components);
+}
+
+/* Detach a component from a master. */
+static void component_detach_master(struct master *master, struct component *c)
+{
+        list_del(&c->master_node);
+
+        c->master = NULL;
+}
+
+int component_master_add_child(struct master *master,
+        int (*compare)(struct device *, void *), void *compare_data)
+{
+        struct component *c;
+        int ret = -ENXIO;
+
+        list_for_each_entry(c, &component_list, node) {
+                if (c->master)
+                        continue;
+
+                if (compare(c->dev, compare_data)) {
+                        component_attach_master(master, c);
+                        ret = 0;
+                        break;
+                }
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(component_master_add_child);
+
+/* Detach all attached components from this master */
+static void master_remove_components(struct master *master)
+{
+        while (!list_empty(&master->components)) {
+                struct component *c = list_first_entry(&master->components,
+                                        struct component, master_node);
+
+                WARN_ON(c->master != master);
+
+                component_detach_master(master, c);
+        }
+}
+
+/*
+ * Try to bring up a master.  If component is NULL, we're interested in
+ * this master, otherwise it's a component which must be present to try
+ * and bring up the master.
+ *
+ * Returns 1 for successful bringup, 0 if not ready, or -ve errno.
+ */
+static int try_to_bring_up_master(struct master *master,
+        struct component *component)
+{
+        int ret = 0;
+
+        if (!master->bound) {
+                /*
+                 * Search the list of components, looking for components that
+                 * belong to this master, and attach them to the master.
+                 */
+                if (master->ops->add_components(master->dev, master)) {
+                        /* Failed to find all components */
+                        master_remove_components(master);
+                        ret = 0;
+                        goto out;
+                }
+
+                if (component && component->master != master) {
+                        master_remove_components(master);
+                        ret = 0;
+                        goto out;
+                }
+
+                /* Found all components */
+                ret = master->ops->bind(master->dev);
+                if (ret < 0) {
+                        master_remove_components(master);
+                        goto out;
+                }
+
+                master->bound = true;
+                ret = 1;
+        }
+out:
+
+        return ret;
+}
+
+static int try_to_bring_up_masters(struct component *component)
+{
+        struct master *m;
+        int ret = 0;
+
+        list_for_each_entry(m, &masters, node) {
+                ret = try_to_bring_up_master(m, component);
+                if (ret != 0)
+                        break;
+        }
+
+        return ret;
+}
+
+static void take_down_master(struct master *master)
+{
+        if (master->bound) {
+                master->ops->unbind(master->dev);
+                master->bound = false;
+        }
+
+        master_remove_components(master);
+}
+
+int component_master_add(struct device *dev,
+        const struct component_master_ops *ops)
+{
+        struct master *master;
+        int ret;
+
+        master = kzalloc(sizeof(*master), GFP_KERNEL);
+        if (!master)
+                return -ENOMEM;
+
+        master->dev = dev;
+        master->ops = ops;
+        INIT_LIST_HEAD(&master->components);
+
+        /* Add to the list of available masters. */
+        mutex_lock(&component_mutex);
+        list_add(&master->node, &masters);
+
+        ret = try_to_bring_up_master(master, NULL);
+
+        if (ret < 0) {
+                /* Delete off the list if we weren't successful */
+                list_del(&master->node);
+                kfree(master);
+        }
+        mutex_unlock(&component_mutex);
+
+        return ret < 0 ? ret : 0;
+}
+EXPORT_SYMBOL_GPL(component_master_add);
+
+void component_master_del(struct device *dev,
+        const struct component_master_ops *ops)
+{
+        struct master *master;
+
+        mutex_lock(&component_mutex);
+        master = __master_find(dev, ops);
+        if (master) {
+                take_down_master(master);
+
+                list_del(&master->node);
+                kfree(master);
+        }
+        mutex_unlock(&component_mutex);
+}
+EXPORT_SYMBOL_GPL(component_master_del);
+
+static void component_unbind(struct component *component,
+        struct master *master, void *data)
+{
+        WARN_ON(!component->bound);
+
+        component->ops->unbind(component->dev, master->dev, data);
+        component->bound = false;
+
+        /* Release all resources claimed in the binding of this component */
+        devres_release_group(component->dev, component);
+}
+
+void component_unbind_all(struct device *master_dev, void *data)
+{
+        struct master *master;
+        struct component *c;
+
+        WARN_ON(!mutex_is_locked(&component_mutex));
+
+        master = __master_find(master_dev, NULL);
+        if (!master)
+                return;
+
+        list_for_each_entry_reverse(c, &master->components, master_node)
+                component_unbind(c, master, data);
+}
+EXPORT_SYMBOL_GPL(component_unbind_all);
+
+static int component_bind(struct component *component, struct master *master,
+        void *data)
+{
+        int ret;
+
+        /*
+         * Each component initialises inside its own devres group.
+         * This allows us to roll-back a failed component without
+         * affecting anything else.
+         */
+        if (!devres_open_group(master->dev, NULL, GFP_KERNEL))
+                return -ENOMEM;
+
+        /*
+         * Also open a group for the device itself: this allows us
+         * to release the resources claimed against the sub-device
+         * at the appropriate moment.
+         */
+        if (!devres_open_group(component->dev, component, GFP_KERNEL)) {
+                devres_release_group(master->dev, NULL);
+                return -ENOMEM;
+        }
+
+        dev_dbg(master->dev, "binding %s (ops %ps)\n",
+                dev_name(component->dev), component->ops);
+
+        ret = component->ops->bind(component->dev, master->dev, data);
+        if (!ret) {
+                component->bound = true;
+
+                /*
+                 * Close the component device's group so that resources
+                 * allocated in the binding are encapsulated for removal
+                 * at unbind.  Remove the group on the DRM device as we
+                 * can clean those resources up independently.
+                 */
+                devres_close_group(component->dev, NULL);
+                devres_remove_group(master->dev, NULL);
+
+                dev_info(master->dev, "bound %s (ops %ps)\n",
+                         dev_name(component->dev), component->ops);
+        } else {
+                devres_release_group(component->dev, NULL);
+                devres_release_group(master->dev, NULL);
+
+                dev_err(master->dev, "failed to bind %s (ops %ps): %d\n",
+                        dev_name(component->dev), component->ops, ret);
+        }
+
+        return ret;
+}
+
+int component_bind_all(struct device *master_dev, void *data)
+{
+        struct master *master;
+        struct component *c;
+        int ret = 0;
+
+        WARN_ON(!mutex_is_locked(&component_mutex));
+
+        master = __master_find(master_dev, NULL);
+        if (!master)
+                return -EINVAL;
+
+        list_for_each_entry(c, &master->components, master_node) {
+                ret = component_bind(c, master, data);
+                if (ret)
+                        break;
+        }
+
+        if (ret != 0) {
+                list_for_each_entry_continue_reverse(c, &master->components,
+                                                     master_node)
+                        component_unbind(c, master, data);
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(component_bind_all);
+
+int component_add(struct device *dev, const struct component_ops *ops)
+{
+        struct component *component;
+        int ret;
+
+        component = kzalloc(sizeof(*component), GFP_KERNEL);
+        if (!component)
+                return -ENOMEM;
+
+        component->ops = ops;
+        component->dev = dev;
+
+        dev_dbg(dev, "adding component (ops %ps)\n", ops);
+
+        mutex_lock(&component_mutex);
+        list_add_tail(&component->node, &component_list);
+
+        ret = try_to_bring_up_masters(component);
+        if (ret < 0) {
+                list_del(&component->node);
+
+                kfree(component);
+        }
+        mutex_unlock(&component_mutex);
+
+        return ret < 0 ? ret : 0;
+}
+EXPORT_SYMBOL_GPL(component_add);
+
+void component_del(struct device *dev, const struct component_ops *ops)
+{
+        struct component *c, *component = NULL;
+
+        mutex_lock(&component_mutex);
+        list_for_each_entry(c, &component_list, node)
+                if (c->dev == dev && c->ops == ops) {
+                        list_del(&c->node);
+                        component = c;
+                        break;
+                }
+
+        if (component && component->master)
+                take_down_master(component->master);
+
+        mutex_unlock(&component_mutex);
+
+        WARN_ON(!component);
+        kfree(component);
+}
+EXPORT_SYMBOL_GPL(component_del);
+
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/base/core.c b/drivers/base/core.c
index 67b180d855b2..2b567177ef78 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -491,11 +491,13 @@ static int device_add_attrs(struct device *dev)
         if (device_supports_offline(dev) && !dev->offline_disabled) {
                 error = device_create_file(dev, &dev_attr_online);
                 if (error)
-                        goto err_remove_type_groups;
+                        goto err_remove_dev_groups;
         }
 
         return 0;
 
+ err_remove_dev_groups:
+        device_remove_groups(dev, dev->groups);
  err_remove_type_groups:
         if (type)
                 device_remove_groups(dev, type->groups);
@@ -1603,6 +1605,7 @@ device_create_groups_vargs(struct class *class, struct device *parent,
                 goto error;
         }
 
+        device_initialize(dev);
         dev->devt = devt;
         dev->class = class;
         dev->parent = parent;
@@ -1614,7 +1617,7 @@ device_create_groups_vargs(struct class *class, struct device *parent,
         if (retval)
                 goto error;
 
-        retval = device_register(dev);
+        retval = device_add(dev);
         if (retval)
                 goto error;
 
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 0f3820121e02..25798db14553 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -299,7 +299,7 @@ static int handle_remove(const char *nodename, struct device *dev)
 {
         struct path parent;
         struct dentry *dentry;
-        int deleted = 1;
+        int deleted = 0;
         int err;
 
         dentry = kern_path_locked(nodename, &parent);
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index eb8fb94ae2c5..8a97ddfa6122 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -96,6 +96,15 @@ static inline long firmware_loading_timeout(void)
         return loading_timeout > 0 ? loading_timeout * HZ : MAX_SCHEDULE_TIMEOUT;
 }
 
+/* firmware behavior options */
+#define FW_OPT_UEVENT   (1U << 0)
+#define FW_OPT_NOWAIT   (1U << 1)
+#ifdef CONFIG_FW_LOADER_USER_HELPER
+#define FW_OPT_FALLBACK (1U << 2)
+#else
+#define FW_OPT_FALLBACK 0
+#endif
+
 struct firmware_cache {
         /* firmware_buf instance will be added into the below list */
         spinlock_t lock;
@@ -219,6 +228,7 @@ static int fw_lookup_and_allocate_buf(const char *fw_name,
 }
 
 static void __fw_free_buf(struct kref *ref)
+        __releases(&fwc->lock)
 {
         struct firmware_buf *buf = to_fwbuf(ref);
         struct firmware_cache *fwc = buf->fwc;
@@ -270,21 +280,21 @@ module_param_string(path, fw_path_para, sizeof(fw_path_para), 0644);
 MODULE_PARM_DESC(path, "customized firmware image search path with a higher priority than default path");
 
 /* Don't inline this: 'struct kstat' is biggish */
-static noinline_for_stack long fw_file_size(struct file *file)
+static noinline_for_stack int fw_file_size(struct file *file)
 {
         struct kstat st;
         if (vfs_getattr(&file->f_path, &st))
                 return -1;
         if (!S_ISREG(st.mode))
                 return -1;
-        if (st.size != (long)st.size)
+        if (st.size != (int)st.size)
                 return -1;
         return st.size;
 }
 
 static int fw_read_file_contents(struct file *file, struct firmware_buf *fw_buf)
 {
-        long size;
+        int size;
         char *buf;
         int rc;
 
@@ -820,7 +830,7 @@ static void firmware_class_timeout_work(struct work_struct *work)
 
 static struct firmware_priv *
 fw_create_instance(struct firmware *firmware, const char *fw_name,
-                   struct device *device, bool uevent, bool nowait)
+                   struct device *device, unsigned int opt_flags)
 {
         struct firmware_priv *fw_priv;
         struct device *f_dev;
@@ -832,7 +842,7 @@ fw_create_instance(struct firmware *firmware, const char *fw_name,
                 goto exit;
         }
 
-        fw_priv->nowait = nowait;
+        fw_priv->nowait = !!(opt_flags & FW_OPT_NOWAIT);
         fw_priv->fw = firmware;
         INIT_DELAYED_WORK(&fw_priv->timeout_work,
                 firmware_class_timeout_work);
@@ -848,8 +858,8 @@ exit:
 }
 
 /* load a firmware via user helper */
-static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
-                                  long timeout)
+static int _request_firmware_load(struct firmware_priv *fw_priv,
+                                  unsigned int opt_flags, long timeout)
 {
         int retval = 0;
         struct device *f_dev = &fw_priv->dev;
@@ -885,7 +895,7 @@ static int _request_firmware_load(struct firmware_priv *fw_priv, bool uevent,
                 goto err_del_bin_attr;
         }
 
-        if (uevent) {
+        if (opt_flags & FW_OPT_UEVENT) {
                 buf->need_uevent = true;
                 dev_set_uevent_suppress(f_dev, false);
                 dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id);
@@ -911,16 +921,16 @@ err_put_dev:
 
 static int fw_load_from_user_helper(struct firmware *firmware,
                                     const char *name, struct device *device,
-                                    bool uevent, bool nowait, long timeout)
+                                    unsigned int opt_flags, long timeout)
 {
         struct firmware_priv *fw_priv;
 
-        fw_priv = fw_create_instance(firmware, name, device, uevent, nowait);
+        fw_priv = fw_create_instance(firmware, name, device, opt_flags);
         if (IS_ERR(fw_priv))
                 return PTR_ERR(fw_priv);
 
         fw_priv->buf = firmware->priv;
-        return _request_firmware_load(fw_priv, uevent, timeout);
+        return _request_firmware_load(fw_priv, opt_flags, timeout);
 }
 
 #ifdef CONFIG_PM_SLEEP
@@ -942,7 +952,7 @@ static void kill_requests_without_uevent(void)
 #else /* CONFIG_FW_LOADER_USER_HELPER */
 static inline int
 fw_load_from_user_helper(struct firmware *firmware, const char *name,
-                         struct device *device, bool uevent, bool nowait,
+                         struct device *device, unsigned int opt_flags,
                          long timeout)
 {
         return -ENOENT;
@@ -1023,7 +1033,7 @@ _request_firmware_prepare(struct firmware **firmware_p, const char *name,
 }
 
 static int assign_firmware_buf(struct firmware *fw, struct device *device,
-                                bool skip_cache)
+                               unsigned int opt_flags)
 {
         struct firmware_buf *buf = fw->priv;
 
@@ -1040,7 +1050,8 @@ 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 && !skip_cache)
+        /* don't cache firmware handled without uevent */
+        if (device && (opt_flags & FW_OPT_UEVENT))
                 fw_add_devm_name(device, buf->fw_id);
 
         /*
@@ -1061,7 +1072,7 @@ static int assign_firmware_buf(struct firmware *fw, struct device *device,
 /* called from request_firmware() and request_firmware_work_func() */
 static int
 _request_firmware(const struct firmware **firmware_p, const char *name,
-                  struct device *device, bool uevent, bool nowait)
+                  struct device *device, unsigned int opt_flags)
 {
         struct firmware *fw;
         long timeout;
@@ -1076,7 +1087,7 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
 
         ret = 0;
         timeout = firmware_loading_timeout();
-        if (nowait) {
+        if (opt_flags & FW_OPT_NOWAIT) {
                 timeout = usermodehelper_read_lock_wait(timeout);
                 if (!timeout) {
                         dev_dbg(device, "firmware: %s loading timed out\n",
@@ -1095,16 +1106,18 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
 
         ret = fw_get_filesystem_firmware(device, fw->priv);
         if (ret) {
-                dev_warn(device, "Direct firmware load failed with error %d\n",
-                         ret);
-                dev_warn(device, "Falling back to user helper\n");
-                ret = fw_load_from_user_helper(fw, name, device,
-                                               uevent, nowait, timeout);
+                if (opt_flags & FW_OPT_FALLBACK) {
+                        dev_warn(device,
+                                 "Direct firmware load failed with error %d\n",
+                                 ret);
+                        dev_warn(device, "Falling back to user helper\n");
+                        ret = fw_load_from_user_helper(fw, name, device,
+                                                       opt_flags, timeout);
+                }
         }
 
-        /* don't cache firmware handled without uevent */
         if (!ret)
-                ret = assign_firmware_buf(fw, device, !uevent);
+                ret = assign_firmware_buf(fw, device, opt_flags);
 
         usermodehelper_read_unlock();
 
@@ -1146,12 +1159,37 @@ request_firmware(const struct firmware **firmware_p, const char *name,
 
         /* Need to pin this module until return */
         __module_get(THIS_MODULE);
-        ret = _request_firmware(firmware_p, name, device, true, false);
+        ret = _request_firmware(firmware_p, name, device,
+                                FW_OPT_UEVENT | FW_OPT_FALLBACK);
         module_put(THIS_MODULE);
         return ret;
 }
 EXPORT_SYMBOL(request_firmware);
 
+#ifdef CONFIG_FW_LOADER_USER_HELPER
+/**
+ * request_firmware: - load firmware directly without usermode helper
+ * @firmware_p: pointer to firmware image
+ * @name: name of firmware file
+ * @device: device for which firmware is being loaded
+ *
+ * This function works pretty much like request_firmware(), but this doesn't
+ * fall back to usermode helper even if the firmware couldn't be loaded
+ * directly from fs.  Hence it's useful for loading optional firmwares, which
+ * aren't always present, without extra long timeouts of udev.
+ **/
+int request_firmware_direct(const struct firmware **firmware_p,
+                            const char *name, struct device *device)
+{
+        int ret;
+        __module_get(THIS_MODULE);
+        ret = _request_firmware(firmware_p, name, device, FW_OPT_UEVENT);
+        module_put(THIS_MODULE);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(request_firmware_direct);
+#endif
+
 /**
  * release_firmware: - release the resource associated with a firmware image
  * @fw: firmware resource to release
@@ -1174,7 +1212,7 @@ struct firmware_work {
         struct device *device;
         void *context;
         void (*cont)(const struct firmware *fw, void *context);
-        bool uevent;
+        unsigned int opt_flags;
 };
 
 static void request_firmware_work_func(struct work_struct *work)
@@ -1185,7 +1223,7 @@ static void request_firmware_work_func(struct work_struct *work)
         fw_work = container_of(work, struct firmware_work, work);
 
         _request_firmware(&fw, fw_work->name, fw_work->device,
-                          fw_work->uevent, true);
+                          fw_work->opt_flags);
         fw_work->cont(fw, fw_work->context);
         put_device(fw_work->device); /* taken in request_firmware_nowait() */
 
@@ -1233,7 +1271,8 @@ request_firmware_nowait(
         fw_work->device = device;
         fw_work->context = context;
         fw_work->cont = cont;
-        fw_work->uevent = uevent;
+        fw_work->opt_flags = FW_OPT_NOWAIT | FW_OPT_FALLBACK |
+                (uevent ? FW_OPT_UEVENT : 0);
 
         if (!try_module_get(module)) {
                 kfree(fw_work);
diff --git a/drivers/firmware/dmi-sysfs.c b/drivers/firmware/dmi-sysfs.c
index eb26d62e5188..e0f1cb3d3598 100644
--- a/drivers/firmware/dmi-sysfs.c
+++ b/drivers/firmware/dmi-sysfs.c
@@ -553,7 +553,7 @@ static const struct bin_attribute dmi_entry_raw_attr = {
 static void dmi_sysfs_entry_release(struct kobject *kobj)
 {
         struct dmi_sysfs_entry *entry = to_entry(kobj);
-        sysfs_remove_bin_file(&entry->kobj, &dmi_entry_raw_attr);
+
         spin_lock(&entry_list_lock);
         list_del(&entry->list);
         spin_unlock(&entry_list_lock);
@@ -685,6 +685,7 @@ static void __exit dmi_sysfs_exit(void)
         pr_debug("dmi-sysfs: unloading.\n");
         cleanup_entry_list();
         kset_unregister(dmi_kset);
+        kobject_del(dmi_kobj);
         kobject_put(dmi_kobj);
 }
 
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 85f772c0b26a..c8a7c810bade 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -393,7 +393,7 @@ static const DEVICE_ATTR(value, 0644,
 
 static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
 {
-        struct sysfs_dirent     *value_sd = priv;
+        struct kernfs_node      *value_sd = priv;
 
         sysfs_notify_dirent(value_sd);
         return IRQ_HANDLED;
@@ -402,7 +402,7 @@ static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
 static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
                 unsigned long gpio_flags)
 {
-        struct sysfs_dirent     *value_sd;
+        struct kernfs_node      *value_sd;
         unsigned long           irq_flags;
         int                     ret, irq, id;
 
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 12dc29ba7399..4195a01b1535 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -1635,7 +1635,7 @@ int bitmap_create(struct mddev *mddev)
         sector_t blocks = mddev->resync_max_sectors;
         struct file *file = mddev->bitmap_info.file;
         int err;
-        struct sysfs_dirent *bm = NULL;
+        struct kernfs_node *bm = NULL;
 
         BUILD_BUG_ON(sizeof(bitmap_super_t) != 256);
 
diff --git a/drivers/md/bitmap.h b/drivers/md/bitmap.h
index df4aeb6ac6f0..30210b9c4ef9 100644
--- a/drivers/md/bitmap.h
+++ b/drivers/md/bitmap.h
@@ -225,7 +225,7 @@ struct bitmap {
         wait_queue_head_t overflow_wait;
         wait_queue_head_t behind_wait;
 
-        struct sysfs_dirent *sysfs_can_clear;
+        struct kernfs_node *sysfs_can_clear;
 };
 
 /* the bitmap API */
diff --git a/drivers/md/md.h b/drivers/md/md.h
index 0095ec84ffc7..07bba96de260 100644
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -106,7 +106,7 @@ struct md_rdev {
                                            */
         struct work_struct del_work;    /* used for delayed sysfs removal */
 
-        struct sysfs_dirent *sysfs_state; /* handle for 'state'
+        struct kernfs_node *sysfs_state; /* handle for 'state'
                                            * sysfs entry */
 
         struct badblocks {
@@ -379,10 +379,10 @@ struct mddev {
         sector_t                        resync_max;     /* resync should pause
                                                          * when it gets here */
 
-        struct sysfs_dirent             *sysfs_state;   /* handle for 'array_state'
+        struct kernfs_node              *sysfs_state;   /* handle for 'array_state'
                                                          * file in sysfs.
                                                          */
-        struct sysfs_dirent             *sysfs_action;  /* handle for 'sync_action' */
+        struct kernfs_node              *sysfs_action;  /* handle for 'sync_action' */
 
         struct work_struct del_work;    /* used for delayed sysfs removal */
 
@@ -501,13 +501,13 @@ struct md_sysfs_entry {
 };
 extern struct attribute_group md_bitmap_group;
 
-static inline struct sysfs_dirent *sysfs_get_dirent_safe(struct sysfs_dirent *sd, char *name)
+static inline struct kernfs_node *sysfs_get_dirent_safe(struct kernfs_node *sd, char *name)
 {
         if (sd)
                 return sysfs_get_dirent(sd, name);
         return sd;
 }
-static inline void sysfs_notify_dirent_safe(struct sysfs_dirent *sd)
+static inline void sysfs_notify_dirent_safe(struct kernfs_node *sd)
 {
         if (sd)
                 sysfs_notify_dirent(sd);
diff --git a/drivers/misc/mic/host/mic_device.h b/drivers/misc/mic/host/mic_device.h
index b2da289320c9..1a6edce2ecde 100644
--- a/drivers/misc/mic/host/mic_device.h
+++ b/drivers/misc/mic/host/mic_device.h
@@ -112,7 +112,7 @@ struct mic_device {
         struct work_struct shutdown_work;
         u8 state;
         u8 shutdown_status;
-        struct sysfs_dirent *state_sysfs;
+        struct kernfs_node *state_sysfs;
         struct completion reset_wait;
         void *log_buf_addr;
         int *log_buf_len;