26 files changed, 146 insertions, 111 deletions

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index ec36e7772e57..8fa8deab6449 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -185,6 +185,9 @@ config GENERIC_CPU_DEVICES
         bool
         default n
 
+config GENERIC_CPU_AUTOPROBE
+        bool
+
 config SOC_BUS
         bool
 
diff --git a/drivers/base/attribute_container.c b/drivers/base/attribute_container.c
index ecc1929d7f6a..b84ca8f13f9e 100644
--- a/drivers/base/attribute_container.c
+++ b/drivers/base/attribute_container.c
@@ -12,7 +12,6 @@
  */
 
 #include <linux/attribute_container.h>
-#include <linux/init.h>
 #include <linux/device.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
diff --git a/drivers/base/core.c b/drivers/base/core.c
index 2b567177ef78..0dd65281cc65 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -23,7 +23,6 @@
 #include <linux/genhd.h>
 #include <linux/kallsyms.h>
 #include <linux/mutex.h>
-#include <linux/async.h>
 #include <linux/pm_runtime.h>
 #include <linux/netdevice.h>
 #include <linux/sysfs.h>
@@ -571,6 +570,23 @@ void device_remove_file(struct device *dev,
 EXPORT_SYMBOL_GPL(device_remove_file);
 
 /**
+ * device_remove_file_self - remove sysfs attribute file from its own method.
+ * @dev: device.
+ * @attr: device attribute descriptor.
+ *
+ * See kernfs_remove_self() for details.
+ */
+bool device_remove_file_self(struct device *dev,
+                             const struct device_attribute *attr)
+{
+        if (dev)
+                return sysfs_remove_file_self(&dev->kobj, &attr->attr);
+        else
+                return false;
+}
+EXPORT_SYMBOL_GPL(device_remove_file_self);
+
+/**
  * device_create_bin_file - create sysfs binary attribute file for device.
  * @dev: device.
  * @attr: device binary attribute descriptor.
@@ -2003,7 +2019,6 @@ void device_shutdown(void)
                 spin_lock(&devices_kset->list_lock);
         }
         spin_unlock(&devices_kset->list_lock);
-        async_synchronize_full();
 }
 
 /*
@@ -2058,7 +2073,6 @@ create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
 
         return pos;
 }
-EXPORT_SYMBOL(create_syslog_header);
 
 int dev_vprintk_emit(int level, const struct device *dev,
                      const char *fmt, va_list args)
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index f48370dfc908..006b1bc5297d 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -15,6 +15,7 @@
 #include <linux/percpu.h>
 #include <linux/acpi.h>
 #include <linux/of.h>
+#include <linux/cpufeature.h>
 
 #include "base.h"
 
@@ -286,6 +287,41 @@ static void cpu_device_release(struct device *dev)
          */
 }
 
+#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
+static ssize_t print_cpu_modalias(struct device *dev,
+                                  struct device_attribute *attr,
+                                  char *buf)
+{
+        ssize_t n;
+        u32 i;
+
+        n = sprintf(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
+                    CPU_FEATURE_TYPEVAL);
+
+        for (i = 0; i < MAX_CPU_FEATURES; i++)
+                if (cpu_have_feature(i)) {
+                        if (PAGE_SIZE < n + sizeof(",XXXX\n")) {
+                                WARN(1, "CPU features overflow page\n");
+                                break;
+                        }
+                        n += sprintf(&buf[n], ",%04X", i);
+                }
+        buf[n++] = '\n';
+        return n;
+}
+
+static int cpu_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+        char *buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
+        if (buf) {
+                print_cpu_modalias(NULL, NULL, buf);
+                add_uevent_var(env, "MODALIAS=%s", buf);
+                kfree(buf);
+        }
+        return 0;
+}
+#endif
+
 /*
  * register_cpu - Setup a sysfs device for a CPU.
  * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
@@ -306,8 +342,8 @@ int register_cpu(struct cpu *cpu, int num)
         cpu->dev.offline_disabled = !cpu->hotpluggable;
         cpu->dev.offline = !cpu_online(num);
         cpu->dev.of_node = of_get_cpu_node(num, NULL);
-#ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
-        cpu->dev.bus->uevent = arch_cpu_uevent;
+#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
+        cpu->dev.bus->uevent = cpu_uevent;
 #endif
         cpu->dev.groups = common_cpu_attr_groups;
         if (cpu->hotpluggable)
@@ -330,8 +366,8 @@ struct device *get_cpu_device(unsigned cpu)
 }
 EXPORT_SYMBOL_GPL(get_cpu_device);
 
-#ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
-static DEVICE_ATTR(modalias, 0444, arch_print_cpu_modalias, NULL);
+#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
+static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL);
 #endif
 
 static struct attribute *cpu_root_attrs[] = {
@@ -344,7 +380,7 @@ static struct attribute *cpu_root_attrs[] = {
         &cpu_attrs[2].attr.attr,
         &dev_attr_kernel_max.attr,
         &dev_attr_offline.attr,
-#ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
+#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
         &dev_attr_modalias.attr,
 #endif
         NULL
diff --git a/drivers/base/dma-buf.c b/drivers/base/dma-buf.c
index 61d6d62cc0d3..ea77701deda4 100644
--- a/drivers/base/dma-buf.c
+++ b/drivers/base/dma-buf.c
@@ -251,9 +251,8 @@ EXPORT_SYMBOL_GPL(dma_buf_put);
  * @dmabuf:     [in]    buffer to attach device to.
  * @dev:        [in]    device to be attached.
  *
- * Returns struct dma_buf_attachment * for this attachment; may return negative
- * error codes.
- *
+ * Returns struct dma_buf_attachment * for this attachment; returns ERR_PTR on
+ * error.
  */
 struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf,
                                           struct device *dev)
@@ -319,9 +318,8 @@ EXPORT_SYMBOL_GPL(dma_buf_detach);
  * @attach:     [in]    attachment whose scatterlist is to be returned
  * @direction:  [in]    direction of DMA transfer
  *
- * Returns sg_table containing the scatterlist to be returned; may return NULL
- * or ERR_PTR.
- *
+ * Returns sg_table containing the scatterlist to be returned; returns ERR_PTR
+ * on error.
  */
 struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach,
                                         enum dma_data_direction direction)
@@ -334,6 +332,8 @@ struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach,
                 return ERR_PTR(-EINVAL);
 
         sg_table = attach->dmabuf->ops->map_dma_buf(attach, direction);
+        if (!sg_table)
+                sg_table = ERR_PTR(-ENOMEM);
 
         return sg_table;
 }
@@ -544,6 +544,8 @@ EXPORT_SYMBOL_GPL(dma_buf_mmap);
  * These calls are optional in drivers. The intended use for them
  * is for mapping objects linear in kernel space for high use objects.
  * Please attempt to use kmap/kunmap before thinking about these interfaces.
+ *
+ * Returns NULL on error.
  */
 void *dma_buf_vmap(struct dma_buf *dmabuf)
 {
@@ -566,7 +568,9 @@ void *dma_buf_vmap(struct dma_buf *dmabuf)
         BUG_ON(dmabuf->vmap_ptr);
 
         ptr = dmabuf->ops->vmap(dmabuf);
-        if (IS_ERR_OR_NULL(ptr))
+        if (WARN_ON_ONCE(IS_ERR(ptr)))
+                ptr = NULL;
+        if (!ptr)
                 goto out_unlock;
 
         dmabuf->vmap_ptr = ptr;
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index c30df50e4440..d276e33880be 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -649,7 +649,9 @@ static ssize_t firmware_loading_store(struct device *dev,
                          * see the mapped 'buf->data' once the loading
                          * is completed.
                          * */
-                        fw_map_pages_buf(fw_buf);
+                        if (fw_map_pages_buf(fw_buf))
+                                dev_err(dev, "%s: map pages failed\n",
+                                        __func__);
                         list_del_init(&fw_buf->pending_list);
                         complete_all(&fw_buf->completion);
                         break;
@@ -900,7 +902,8 @@ static int _request_firmware_load(struct firmware_priv *fw_priv,
                 dev_set_uevent_suppress(f_dev, false);
                 dev_dbg(f_dev, "firmware: requesting %s\n", buf->fw_id);
                 if (timeout != MAX_SCHEDULE_TIMEOUT)
-                        schedule_delayed_work(&fw_priv->timeout_work, timeout);
+                        queue_delayed_work(system_power_efficient_wq,
+                                           &fw_priv->timeout_work, timeout);
 
                 kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
         }
@@ -908,6 +911,8 @@ static int _request_firmware_load(struct firmware_priv *fw_priv,
         wait_for_completion(&buf->completion);
 
         cancel_delayed_work_sync(&fw_priv->timeout_work);
+        if (!buf->data)
+                retval = -ENOMEM;
 
         device_remove_file(f_dev, &dev_attr_loading);
 err_del_bin_attr:
@@ -1570,8 +1575,8 @@ static void device_uncache_fw_images_work(struct work_struct *work)
  */
 static void device_uncache_fw_images_delay(unsigned long delay)
 {
-        schedule_delayed_work(&fw_cache.work,
-                        msecs_to_jiffies(delay));
+        queue_delayed_work(system_power_efficient_wq, &fw_cache.work,
+                           msecs_to_jiffies(delay));
 }
 
 static int fw_pm_notify(struct notifier_block *notify_block,
diff --git a/drivers/base/node.c b/drivers/base/node.c
index bc9f43bf7e29..8f7ed9933a7c 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -599,7 +599,11 @@ int register_one_node(int nid)
 
 void unregister_one_node(int nid)
 {
+        if (!node_devices[nid])
+                return;
+
         unregister_node(node_devices[nid]);
+        kfree(node_devices[nid]);
         node_devices[nid] = NULL;
 }
 
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index bc78848dd59a..e714709704e4 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -481,11 +481,10 @@ static int platform_drv_probe(struct device *_dev)
         struct platform_device *dev = to_platform_device(_dev);
         int ret;
 
-        if (ACPI_HANDLE(_dev))
-                acpi_dev_pm_attach(_dev, true);
+        acpi_dev_pm_attach(_dev, true);
 
         ret = drv->probe(dev);
-        if (ret && ACPI_HANDLE(_dev))
+        if (ret)
                 acpi_dev_pm_detach(_dev, true);
 
         if (drv->prevent_deferred_probe && ret == -EPROBE_DEFER) {
@@ -508,8 +507,7 @@ static int platform_drv_remove(struct device *_dev)
         int ret;
 
         ret = drv->remove(dev);
-        if (ACPI_HANDLE(_dev))
-                acpi_dev_pm_detach(_dev, true);
+        acpi_dev_pm_detach(_dev, true);
 
         return ret;
 }
@@ -520,8 +518,7 @@ static void platform_drv_shutdown(struct device *_dev)
         struct platform_device *dev = to_platform_device(_dev);
 
         drv->shutdown(dev);
-        if (ACPI_HANDLE(_dev))
-                acpi_dev_pm_detach(_dev, true);
+        acpi_dev_pm_detach(_dev, true);
 }
 
 /**
diff --git a/drivers/base/power/clock_ops.c b/drivers/base/power/clock_ops.c
index e870bbe9ec4e..b99e6c06ee67 100644
--- a/drivers/base/power/clock_ops.c
+++ b/drivers/base/power/clock_ops.c
@@ -6,7 +6,6 @@
  * This file is released under the GPLv2.
  */
 
-#include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <linux/io.h>
diff --git a/drivers/base/power/common.c b/drivers/base/power/common.c
index 5da914041305..df2e5eeaeb05 100644
--- a/drivers/base/power/common.c
+++ b/drivers/base/power/common.c
@@ -6,7 +6,6 @@
  * This file is released under the GPLv2.
  */
 
-#include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/device.h>
 #include <linux/export.h>
diff --git a/drivers/base/power/domain.c b/drivers/base/power/domain.c
index dc127e5dec4b..6f54962aae1d 100644
--- a/drivers/base/power/domain.c
+++ b/drivers/base/power/domain.c
@@ -6,7 +6,6 @@
  * This file is released under the GPLv2.
  */
 
-#include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/io.h>
 #include <linux/pm_runtime.h>
diff --git a/drivers/base/power/domain_governor.c b/drivers/base/power/domain_governor.c
index 28dee3053f1f..a089e3bcdfbc 100644
--- a/drivers/base/power/domain_governor.c
+++ b/drivers/base/power/domain_governor.c
@@ -6,7 +6,6 @@
  * This file is released under the GPLv2.
  */
 
-#include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/pm_domain.h>
 #include <linux/pm_qos.h>
diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
index fa4187418440..25538675d59e 100644
--- a/drivers/base/power/opp.c
+++ b/drivers/base/power/opp.c
@@ -14,7 +14,6 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/err.h>
-#include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/cpufreq.h>
 #include <linux/device.h>
diff --git a/drivers/base/regmap/regmap-i2c.c b/drivers/base/regmap/regmap-i2c.c
index fa6bf5279d28..ebd189529760 100644
--- a/drivers/base/regmap/regmap-i2c.c
+++ b/drivers/base/regmap/regmap-i2c.c
@@ -13,7 +13,6 @@
 #include <linux/regmap.h>
 #include <linux/i2c.h>
 #include <linux/module.h>
-#include <linux/init.h>
 
 static int regmap_i2c_write(void *context, const void *data, size_t count)
 {
diff --git a/drivers/base/regmap/regmap-mmio.c b/drivers/base/regmap/regmap-mmio.c
index de45a1e1548f..1e03e7f8bacb 100644
--- a/drivers/base/regmap/regmap-mmio.c
+++ b/drivers/base/regmap/regmap-mmio.c
@@ -18,7 +18,6 @@
 
 #include <linux/clk.h>
 #include <linux/err.h>
-#include <linux/init.h>
 #include <linux/io.h>
 #include <linux/module.h>
 #include <linux/regmap.h>
diff --git a/drivers/base/regmap/regmap-spi.c b/drivers/base/regmap/regmap-spi.c
index 37f12ae7aada..0eb3097c0d76 100644
--- a/drivers/base/regmap/regmap-spi.c
+++ b/drivers/base/regmap/regmap-spi.c
@@ -12,7 +12,6 @@
 
 #include <linux/regmap.h>
 #include <linux/spi/spi.h>
-#include <linux/init.h>
 #include <linux/module.h>
 
 #include "internal.h"
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
index 94ffee378f10..ad9d17762664 100644
--- a/drivers/base/topology.c
+++ b/drivers/base/topology.c
@@ -23,7 +23,6 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  */
-#include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/cpu.h>
 #include <linux/module.h>
diff --git a/drivers/firmware/google/gsmi.c b/drivers/firmware/google/gsmi.c
index e5a67b24587a..f1ab05ea56bb 100644
--- a/drivers/firmware/google/gsmi.c
+++ b/drivers/firmware/google/gsmi.c
@@ -892,13 +892,6 @@ static __init int gsmi_init(void)
                 goto out_remove_sysfs_files;
         }
 
-        ret = efivars_sysfs_init();
-        if (ret) {
-                printk(KERN_INFO "gsmi: Failed to create efivars files\n");
-                efivars_unregister(&efivars);
-                goto out_remove_sysfs_files;
-        }
-
         register_reboot_notifier(&gsmi_reboot_notifier);
         register_die_notifier(&gsmi_die_notifier);
         atomic_notifier_chain_register(&panic_notifier_list,
diff --git a/drivers/firmware/google/memconsole.c b/drivers/firmware/google/memconsole.c
index 2a90ba613613..2f569aaed4c7 100644
--- a/drivers/firmware/google/memconsole.c
+++ b/drivers/firmware/google/memconsole.c
@@ -15,6 +15,7 @@
 #include <linux/kobject.h>
 #include <linux/module.h>
 #include <linux/dmi.h>
+#include <linux/io.h>
 #include <asm/bios_ebda.h>
 
 #define BIOS_MEMCONSOLE_V1_MAGIC        0xDEADBABE
@@ -41,15 +42,25 @@ struct biosmemcon_ebda {
         };
 } __packed;
 
-static char *memconsole_baseaddr;
+static u32 memconsole_baseaddr;
 static size_t memconsole_length;
 
 static ssize_t memconsole_read(struct file *filp, struct kobject *kobp,
                                struct bin_attribute *bin_attr, char *buf,
                                loff_t pos, size_t count)
 {
-        return memory_read_from_buffer(buf, count, &pos, memconsole_baseaddr,
-                                       memconsole_length);
+        char *memconsole;
+        ssize_t ret;
+
+        memconsole = ioremap_cache(memconsole_baseaddr, memconsole_length);
+        if (!memconsole) {
+                pr_err("memconsole: ioremap_cache failed\n");
+                return -ENOMEM;
+        }
+        ret = memory_read_from_buffer(buf, count, &pos, memconsole,
+                                      memconsole_length);
+        iounmap(memconsole);
+        return ret;
 }
 
 static struct bin_attribute memconsole_bin_attr = {
@@ -58,43 +69,42 @@ static struct bin_attribute memconsole_bin_attr = {
 };
 
 
-static void found_v1_header(struct biosmemcon_ebda *hdr)
+static void __init found_v1_header(struct biosmemcon_ebda *hdr)
 {
-        printk(KERN_INFO "BIOS console v1 EBDA structure found at %p\n", hdr);
-        printk(KERN_INFO "BIOS console buffer at 0x%.8x, "
+        pr_info("BIOS console v1 EBDA structure found at %p\n", hdr);
+        pr_info("BIOS console buffer at 0x%.8x, "
                "start = %d, end = %d, num = %d\n",
                hdr->v1.buffer_addr, hdr->v1.start,
                hdr->v1.end, hdr->v1.num_chars);
 
         memconsole_length = hdr->v1.num_chars;
-        memconsole_baseaddr = phys_to_virt(hdr->v1.buffer_addr);
+        memconsole_baseaddr = hdr->v1.buffer_addr;
 }
 
-static void found_v2_header(struct biosmemcon_ebda *hdr)
+static void __init found_v2_header(struct biosmemcon_ebda *hdr)
 {
-        printk(KERN_INFO "BIOS console v2 EBDA structure found at %p\n", hdr);
-        printk(KERN_INFO "BIOS console buffer at 0x%.8x, "
+        pr_info("BIOS console v2 EBDA structure found at %p\n", hdr);
+        pr_info("BIOS console buffer at 0x%.8x, "
                "start = %d, end = %d, num_bytes = %d\n",
                hdr->v2.buffer_addr, hdr->v2.start,
                hdr->v2.end, hdr->v2.num_bytes);
 
         memconsole_length = hdr->v2.end - hdr->v2.start;
-        memconsole_baseaddr = phys_to_virt(hdr->v2.buffer_addr
-                                           + hdr->v2.start);
+        memconsole_baseaddr = hdr->v2.buffer_addr + hdr->v2.start;
 }
 
 /*
  * Search through the EBDA for the BIOS Memory Console, and
  * set the global variables to point to it.  Return true if found.
  */
-static bool found_memconsole(void)
+static bool __init found_memconsole(void)
 {
         unsigned int address;
         size_t length, cur;
 
         address = get_bios_ebda();
         if (!address) {
-                printk(KERN_INFO "BIOS EBDA non-existent.\n");
+                pr_info("BIOS EBDA non-existent.\n");
                 return false;
         }
 
@@ -122,7 +132,7 @@ static bool found_memconsole(void)
                 }
         }
 
-        printk(KERN_INFO "BIOS console EBDA structure not found!\n");
+        pr_info("BIOS console EBDA structure not found!\n");
         return false;
 }
 
@@ -139,8 +149,6 @@ MODULE_DEVICE_TABLE(dmi, memconsole_dmi_table);
 
 static int __init memconsole_init(void)
 {
-        int ret;
-
         if (!dmi_check_system(memconsole_dmi_table))
                 return -ENODEV;
 
@@ -148,10 +156,7 @@ static int __init memconsole_init(void)
                 return -ENODEV;
 
         memconsole_bin_attr.size = memconsole_length;
-
-        ret = sysfs_create_bin_file(firmware_kobj, &memconsole_bin_attr);
-
-        return ret;
+        return sysfs_create_bin_file(firmware_kobj, &memconsole_bin_attr);
 }
 
 static void __exit memconsole_exit(void)
diff --git a/drivers/gpu/drm/drm_prime.c b/drivers/gpu/drm/drm_prime.c
index 56805c39c906..bb516fdd195d 100644
--- a/drivers/gpu/drm/drm_prime.c
+++ b/drivers/gpu/drm/drm_prime.c
@@ -471,7 +471,7 @@ struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
         get_dma_buf(dma_buf);
 
         sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
-        if (IS_ERR_OR_NULL(sgt)) {
+        if (IS_ERR(sgt)) {
                 ret = PTR_ERR(sgt);
                 goto fail_detach;
         }
diff --git a/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c b/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c
index 59827cc5e770..c786cd4f457b 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_dmabuf.c
@@ -224,7 +224,7 @@ struct drm_gem_object *exynos_dmabuf_prime_import(struct drm_device *drm_dev,
         get_dma_buf(dma_buf);
 
         sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
-        if (IS_ERR_OR_NULL(sgt)) {
+        if (IS_ERR(sgt)) {
                 ret = PTR_ERR(sgt);
                 goto err_buf_detach;
         }
diff --git a/drivers/media/v4l2-core/videobuf2-dma-contig.c b/drivers/media/v4l2-core/videobuf2-dma-contig.c
index 33d3871d1e13..880be0782dd9 100644
--- a/drivers/media/v4l2-core/videobuf2-dma-contig.c
+++ b/drivers/media/v4l2-core/videobuf2-dma-contig.c
@@ -719,7 +719,7 @@ static int vb2_dc_map_dmabuf(void *mem_priv)
 
         /* get the associated scatterlist for this buffer */
         sgt = dma_buf_map_attachment(buf->db_attach, buf->dma_dir);
-        if (IS_ERR_OR_NULL(sgt)) {
+        if (IS_ERR(sgt)) {
                 pr_err("Error getting dmabuf scatterlist\n");
                 return -EINVAL;
         }
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 276ef9c18802..4e0acefb7565 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -351,28 +351,17 @@ static struct device_attribute dev_rescan_attr = __ATTR(rescan,
                                                         (S_IWUSR|S_IWGRP),
                                                         NULL, dev_rescan_store);
 
-static void remove_callback(struct device *dev)
-{
-        pci_stop_and_remove_bus_device_locked(to_pci_dev(dev));
-}
-
 static ssize_t
-remove_store(struct device *dev, struct device_attribute *dummy,
+remove_store(struct device *dev, struct device_attribute *attr,
              const char *buf, size_t count)
 {
-        int ret = 0;
         unsigned long val;
 
         if (kstrtoul(buf, 0, &val) < 0)
                 return -EINVAL;
 
-        /* An attribute cannot be unregistered by one of its own methods,
-         * so we have to use this roundabout approach.
-         */
-        if (val)
-                ret = device_schedule_callback(dev, remove_callback);
-        if (ret)
-                count = ret;
+        if (val && device_remove_file_self(dev, attr))
+                pci_stop_and_remove_bus_device_locked(to_pci_dev(dev));
         return count;
 }
 static struct device_attribute dev_remove_attr = __ATTR(remove,
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index ebf41e228e55..ee0e85abe1fd 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -304,12 +304,6 @@ dcssblk_load_segment(char *name, struct segment_info **seg_info)
         return rc;
 }
 
-static void dcssblk_unregister_callback(struct device *dev)
-{
-        device_unregister(dev);
-        put_device(dev);
-}
-
 /*
  * device attribute for switching shared/nonshared (exclusive)
  * operation (show + store)
@@ -397,7 +391,13 @@ removeseg:
         blk_cleanup_queue(dev_info->dcssblk_queue);
         dev_info->gd->queue = NULL;
         put_disk(dev_info->gd);
-        rc = device_schedule_callback(dev, dcssblk_unregister_callback);
+        up_write(&dcssblk_devices_sem);
+
+        if (device_remove_file_self(dev, attr)) {
+                device_unregister(dev);
+                put_device(dev);
+        }
+        return rc;
 out:
         up_write(&dcssblk_devices_sem);
         return rc;
diff --git a/drivers/s390/cio/ccwgroup.c b/drivers/s390/cio/ccwgroup.c
index fd3367a1dc7a..dfd7bc681c25 100644
--- a/drivers/s390/cio/ccwgroup.c
+++ b/drivers/s390/cio/ccwgroup.c
@@ -168,14 +168,12 @@ static ssize_t ccwgroup_online_show(struct device *dev,
  * Provide an 'ungroup' attribute so the user can remove group devices no
  * longer needed or accidentially created. Saves memory :)
  */
-static void ccwgroup_ungroup_callback(struct device *dev)
+static void ccwgroup_ungroup(struct ccwgroup_device *gdev)
 {
-        struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
-
         mutex_lock(&gdev->reg_mutex);
         if (device_is_registered(&gdev->dev)) {
                 __ccwgroup_remove_symlinks(gdev);
-                device_unregister(dev);
+                device_unregister(&gdev->dev);
                 __ccwgroup_remove_cdev_refs(gdev);
         }
         mutex_unlock(&gdev->reg_mutex);
@@ -195,10 +193,9 @@ static ssize_t ccwgroup_ungroup_store(struct device *dev,
                 rc = -EINVAL;
                 goto out;
         }
-        /* Note that we cannot unregister the device from one of its
-         * attribute methods, so we have to use this roundabout approach.
-         */
-        rc = device_schedule_callback(dev, ccwgroup_ungroup_callback);
+
+        if (device_remove_file_self(dev, attr))
+                ccwgroup_ungroup(gdev);
 out:
         if (rc) {
                 if (rc != -EAGAIN)
@@ -224,6 +221,14 @@ static const struct attribute_group *ccwgroup_attr_groups[] = {
         NULL,
 };
 
+static void ccwgroup_ungroup_workfn(struct work_struct *work)
+{
+        struct ccwgroup_device *gdev =
+                container_of(work, struct ccwgroup_device, ungroup_work);
+
+        ccwgroup_ungroup(gdev);
+}
+
 static void ccwgroup_release(struct device *dev)
 {
         kfree(to_ccwgroupdev(dev));
@@ -323,6 +328,7 @@ int ccwgroup_create_dev(struct device *parent, struct ccwgroup_driver *gdrv,
         atomic_set(&gdev->onoff, 0);
         mutex_init(&gdev->reg_mutex);
         mutex_lock(&gdev->reg_mutex);
+        INIT_WORK(&gdev->ungroup_work, ccwgroup_ungroup_workfn);
         gdev->count = num_devices;
         gdev->dev.bus = &ccwgroup_bus_type;
         gdev->dev.parent = parent;
@@ -404,10 +410,10 @@ EXPORT_SYMBOL(ccwgroup_create_dev);
 static int ccwgroup_notifier(struct notifier_block *nb, unsigned long action,
                              void *data)
 {
-        struct device *dev = data;
+        struct ccwgroup_device *gdev = to_ccwgroupdev(data);
 
         if (action == BUS_NOTIFY_UNBIND_DRIVER)
-                device_schedule_callback(dev, ccwgroup_ungroup_callback);
+                schedule_work(&gdev->ungroup_work);
 
         return NOTIFY_OK;
 }
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 9117d0bf408e..8ead24c3453a 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -649,23 +649,12 @@ store_rescan_field (struct device *dev, struct device_attribute *attr,
 }
 static DEVICE_ATTR(rescan, S_IWUSR, NULL, store_rescan_field);
 
-static void sdev_store_delete_callback(struct device *dev)
-{
-        scsi_remove_device(to_scsi_device(dev));
-}
-
 static ssize_t
 sdev_store_delete(struct device *dev, struct device_attribute *attr,
                   const char *buf, size_t count)
 {
-        int rc;
-
-        /* An attribute cannot be unregistered by one of its own methods,
-         * so we have to use this roundabout approach.
-         */
-        rc = device_schedule_callback(dev, sdev_store_delete_callback);
-        if (rc)
-                count = rc;
+        if (device_remove_file_self(dev, attr))
+                scsi_remove_device(to_scsi_device(dev));
         return count;
 };
 static DEVICE_ATTR(delete, S_IWUSR, NULL, sdev_store_delete);