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;