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

Pull driver core updates from Greg KH:
 "Here's the big driver-core pull request for 3.17-rc1.

  Largest thing in here is the dma-buf rework and fence code, that
  touched many different subsystems so it was agreed it should go
  through this tree to handle merge issues.  There's also some firmware
  loading updates, as well as tests added, and a few other tiny changes,
  the changelog has the details.

  All have been in linux-next for a long time"

* tag 'driver-core-3.17-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core: (32 commits)
  ARM: imx: Remove references to platform_bus in mxc code
  firmware loader: Fix _request_firmware_load() return val for fw load abort
  platform: Remove most references to platform_bus device
  test: add firmware_class loader test
  doc: fix minor typos in firmware_class README
  staging: android: Cleanup style issues
  Documentation: devres: Sort managed interfaces
  Documentation: devres: Add devm_kmalloc() et al
  fs: debugfs: remove trailing whitespace
  kernfs: kernel-doc warning fix
  debugfs: Fix corrupted loop in debugfs_remove_recursive
  stable_kernel_rules: Add pointer to netdev-FAQ for network patches
  driver core: platform: add device binding path 'driver_override'
  driver core/platform: remove unused implicit padding in platform_object
  firmware loader: inform direct failure when udev loader is disabled
  firmware: replace ALIGN(PAGE_SIZE) by PAGE_ALIGN
  firmware: read firmware size using i_size_read()
  firmware loader: allow disabling of udev as firmware loader
  reservation: add suppport for read-only access using rcu
  reservation: update api and add some helpers
  ...

Conflicts:
	drivers/base/platform.c

7 files changed, 245 insertions, 847 deletions

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index 23b8726962af..88500fed3c7a 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -149,15 +149,21 @@ config EXTRA_FIRMWARE_DIR
           some other directory containing the firmware files.
 
 config FW_LOADER_USER_HELPER
+        bool
+
+config FW_LOADER_USER_HELPER_FALLBACK
         bool "Fallback user-helper invocation for firmware loading"
         depends on FW_LOADER
-        default y
+        select FW_LOADER_USER_HELPER
         help
           This option enables / disables the invocation of user-helper
           (e.g. udev) for loading firmware files as a fallback after the
           direct file loading in kernel fails.  The user-mode helper is
           no longer required unless you have a special firmware file that
-          resides in a non-standard path.
+          resides in a non-standard path. Moreover, the udev support has
+          been deprecated upstream.
+
+          If you are unsure about this, say N here.
 
 config DEBUG_DRIVER
         bool "Driver Core verbose debug messages"
@@ -208,6 +214,15 @@ config DMA_SHARED_BUFFER
           APIs extension; the file's descriptor can then be passed on to other
           driver.
 
+config FENCE_TRACE
+        bool "Enable verbose FENCE_TRACE messages"
+        depends on DMA_SHARED_BUFFER
+        help
+          Enable the FENCE_TRACE printks. This will add extra
+          spam to the console log, but will make it easier to diagnose
+          lockup related problems for dma-buffers shared across multiple
+          devices.
+
 config DMA_CMA
         bool "DMA Contiguous Memory Allocator"
         depends on HAVE_DMA_CONTIGUOUS && CMA
diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index 04b314e0fa51..4aab26ec0292 100644
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -10,7 +10,6 @@ obj-$(CONFIG_DMA_CMA) += dma-contiguous.o
 obj-y                   += power/
 obj-$(CONFIG_HAS_DMA)   += dma-mapping.o
 obj-$(CONFIG_HAVE_GENERIC_DMA_COHERENT) += dma-coherent.o
-obj-$(CONFIG_DMA_SHARED_BUFFER) += dma-buf.o reservation.o
 obj-$(CONFIG_ISA)       += isa.o
 obj-$(CONFIG_FW_LOADER) += firmware_class.o
 obj-$(CONFIG_NUMA)      += node.o
diff --git a/drivers/base/component.c b/drivers/base/component.c
index c4778995cd72..f748430bb654 100644
--- a/drivers/base/component.c
+++ b/drivers/base/component.c
@@ -18,6 +18,15 @@
 #include <linux/mutex.h>
 #include <linux/slab.h>
 
+struct component_match {
+        size_t alloc;
+        size_t num;
+        struct {
+                void *data;
+                int (*fn)(struct device *, void *);
+        } compare[0];
+};
+
 struct master {
         struct list_head node;
         struct list_head components;
@@ -25,6 +34,7 @@ struct master {
 
         const struct component_master_ops *ops;
         struct device *dev;
+        struct component_match *match;
 };
 
 struct component {
@@ -69,6 +79,11 @@ static void component_detach_master(struct master *master, struct component *c)
         c->master = NULL;
 }
 
+/*
+ * Add a component to a master, finding the component via the compare
+ * function and compare data.  This is safe to call for duplicate matches
+ * and will not result in the same component being added multiple times.
+ */
 int component_master_add_child(struct master *master,
         int (*compare)(struct device *, void *), void *compare_data)
 {
@@ -76,11 +91,12 @@ int component_master_add_child(struct master *master,
         int ret = -ENXIO;
 
         list_for_each_entry(c, &component_list, node) {
-                if (c->master)
+                if (c->master && c->master != master)
                         continue;
 
                 if (compare(c->dev, compare_data)) {
-                        component_attach_master(master, c);
+                        if (!c->master)
+                                component_attach_master(master, c);
                         ret = 0;
                         break;
                 }
@@ -90,6 +106,34 @@ int component_master_add_child(struct master *master,
 }
 EXPORT_SYMBOL_GPL(component_master_add_child);
 
+static int find_components(struct master *master)
+{
+        struct component_match *match = master->match;
+        size_t i;
+        int ret = 0;
+
+        if (!match) {
+                /*
+                 * Search the list of components, looking for components that
+                 * belong to this master, and attach them to the master.
+                 */
+                return master->ops->add_components(master->dev, master);
+        }
+
+        /*
+         * Scan the array of match functions and attach
+         * any components which are found to this master.
+         */
+        for (i = 0; i < match->num; i++) {
+                ret = component_master_add_child(master,
+                                                 match->compare[i].fn,
+                                                 match->compare[i].data);
+                if (ret)
+                        break;
+        }
+        return ret;
+}
+
 /* Detach all attached components from this master */
 static void master_remove_components(struct master *master)
 {
@@ -113,44 +157,44 @@ static void master_remove_components(struct master *master)
 static int try_to_bring_up_master(struct master *master,
         struct component *component)
 {
-        int ret = 0;
+        int ret;
 
-        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 (master->bound)
+                return 0;
 
-                if (component && component->master != master) {
-                        master_remove_components(master);
-                        ret = 0;
-                        goto out;
-                }
+        /*
+         * Search the list of components, looking for components that
+         * belong to this master, and attach them to the master.
+         */
+        if (find_components(master)) {
+                /* Failed to find all components */
+                ret = 0;
+                goto out;
+        }
 
-                if (!devres_open_group(master->dev, NULL, GFP_KERNEL)) {
-                        ret = -ENOMEM;
-                        goto out;
-                }
+        if (component && component->master != master) {
+                ret = 0;
+                goto out;
+        }
 
-                /* Found all components */
-                ret = master->ops->bind(master->dev);
-                if (ret < 0) {
-                        devres_release_group(master->dev, NULL);
-                        dev_info(master->dev, "master bind failed: %d\n", ret);
-                        master_remove_components(master);
-                        goto out;
-                }
+        if (!devres_open_group(master->dev, NULL, GFP_KERNEL)) {
+                ret = -ENOMEM;
+                goto out;
+        }
 
-                master->bound = true;
-                ret = 1;
+        /* Found all components */
+        ret = master->ops->bind(master->dev);
+        if (ret < 0) {
+                devres_release_group(master->dev, NULL);
+                dev_info(master->dev, "master bind failed: %d\n", ret);
+                goto out;
         }
+
+        master->bound = true;
+        return 1;
+
 out:
+        master_remove_components(master);
 
         return ret;
 }
@@ -180,18 +224,89 @@ static void take_down_master(struct master *master)
         master_remove_components(master);
 }
 
-int component_master_add(struct device *dev,
-        const struct component_master_ops *ops)
+static size_t component_match_size(size_t num)
+{
+        return offsetof(struct component_match, compare[num]);
+}
+
+static struct component_match *component_match_realloc(struct device *dev,
+        struct component_match *match, size_t num)
+{
+        struct component_match *new;
+
+        if (match && match->alloc == num)
+                return match;
+
+        new = devm_kmalloc(dev, component_match_size(num), GFP_KERNEL);
+        if (!new)
+                return ERR_PTR(-ENOMEM);
+
+        if (match) {
+                memcpy(new, match, component_match_size(min(match->num, num)));
+                devm_kfree(dev, match);
+        } else {
+                new->num = 0;
+        }
+
+        new->alloc = num;
+
+        return new;
+}
+
+/*
+ * Add a component to be matched.
+ *
+ * The match array is first created or extended if necessary.
+ */
+void component_match_add(struct device *dev, struct component_match **matchptr,
+        int (*compare)(struct device *, void *), void *compare_data)
+{
+        struct component_match *match = *matchptr;
+
+        if (IS_ERR(match))
+                return;
+
+        if (!match || match->num == match->alloc) {
+                size_t new_size = match ? match->alloc + 16 : 15;
+
+                match = component_match_realloc(dev, match, new_size);
+
+                *matchptr = match;
+
+                if (IS_ERR(match))
+                        return;
+        }
+
+        match->compare[match->num].fn = compare;
+        match->compare[match->num].data = compare_data;
+        match->num++;
+}
+EXPORT_SYMBOL(component_match_add);
+
+int component_master_add_with_match(struct device *dev,
+        const struct component_master_ops *ops,
+        struct component_match *match)
 {
         struct master *master;
         int ret;
 
+        if (ops->add_components && match)
+                return -EINVAL;
+
+        if (match) {
+                /* Reallocate the match array for its true size */
+                match = component_match_realloc(dev, match, match->num);
+                if (IS_ERR(match))
+                        return PTR_ERR(match);
+        }
+
         master = kzalloc(sizeof(*master), GFP_KERNEL);
         if (!master)
                 return -ENOMEM;
 
         master->dev = dev;
         master->ops = ops;
+        master->match = match;
         INIT_LIST_HEAD(&master->components);
 
         /* Add to the list of available masters. */
@@ -209,6 +324,13 @@ int component_master_add(struct device *dev,
 
         return ret < 0 ? ret : 0;
 }
+EXPORT_SYMBOL_GPL(component_master_add_with_match);
+
+int component_master_add(struct device *dev,
+        const struct component_master_ops *ops)
+{
+        return component_master_add_with_match(dev, ops, NULL);
+}
 EXPORT_SYMBOL_GPL(component_master_add);
 
 void component_master_del(struct device *dev,
diff --git a/drivers/base/dma-buf.c b/drivers/base/dma-buf.c
deleted file mode 100644
index 840c7fa80983..000000000000
--- a/drivers/base/dma-buf.c
+++ /dev/null
@@ -1,743 +0,0 @@
-/*
- * Framework for buffer objects that can be shared across devices/subsystems.
- *
- * Copyright(C) 2011 Linaro Limited. All rights reserved.
- * Author: Sumit Semwal <sumit.semwal@ti.com>
- *
- * Many thanks to linaro-mm-sig list, and specially
- * Arnd Bergmann <arnd@arndb.de>, Rob Clark <rob@ti.com> and
- * Daniel Vetter <daniel@ffwll.ch> for their support in creation and
- * refining of this idea.
- *
- * 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 program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/fs.h>
-#include <linux/slab.h>
-#include <linux/dma-buf.h>
-#include <linux/anon_inodes.h>
-#include <linux/export.h>
-#include <linux/debugfs.h>
-#include <linux/seq_file.h>
-
-static inline int is_dma_buf_file(struct file *);
-
-struct dma_buf_list {
-        struct list_head head;
-        struct mutex lock;
-};
-
-static struct dma_buf_list db_list;
-
-static int dma_buf_release(struct inode *inode, struct file *file)
-{
-        struct dma_buf *dmabuf;
-
-        if (!is_dma_buf_file(file))
-                return -EINVAL;
-
-        dmabuf = file->private_data;
-
-        BUG_ON(dmabuf->vmapping_counter);
-
-        dmabuf->ops->release(dmabuf);
-
-        mutex_lock(&db_list.lock);
-        list_del(&dmabuf->list_node);
-        mutex_unlock(&db_list.lock);
-
-        kfree(dmabuf);
-        return 0;
-}
-
-static int dma_buf_mmap_internal(struct file *file, struct vm_area_struct *vma)
-{
-        struct dma_buf *dmabuf;
-
-        if (!is_dma_buf_file(file))
-                return -EINVAL;
-
-        dmabuf = file->private_data;
-
-        /* check for overflowing the buffer's size */
-        if (vma->vm_pgoff + ((vma->vm_end - vma->vm_start) >> PAGE_SHIFT) >
-            dmabuf->size >> PAGE_SHIFT)
-                return -EINVAL;
-
-        return dmabuf->ops->mmap(dmabuf, vma);
-}
-
-static loff_t dma_buf_llseek(struct file *file, loff_t offset, int whence)
-{
-        struct dma_buf *dmabuf;
-        loff_t base;
-
-        if (!is_dma_buf_file(file))
-                return -EBADF;
-
-        dmabuf = file->private_data;
-
-        /* only support discovering the end of the buffer,
-           but also allow SEEK_SET to maintain the idiomatic
-           SEEK_END(0), SEEK_CUR(0) pattern */
-        if (whence == SEEK_END)
-                base = dmabuf->size;
-        else if (whence == SEEK_SET)
-                base = 0;
-        else
-                return -EINVAL;
-
-        if (offset != 0)
-                return -EINVAL;
-
-        return base + offset;
-}
-
-static const struct file_operations dma_buf_fops = {
-        .release        = dma_buf_release,
-        .mmap           = dma_buf_mmap_internal,
-        .llseek         = dma_buf_llseek,
-};
-
-/*
- * is_dma_buf_file - Check if struct file* is associated with dma_buf
- */
-static inline int is_dma_buf_file(struct file *file)
-{
-        return file->f_op == &dma_buf_fops;
-}
-
-/**
- * dma_buf_export_named - Creates a new dma_buf, and associates an anon file
- * with this buffer, so it can be exported.
- * Also connect the allocator specific data and ops to the buffer.
- * Additionally, provide a name string for exporter; useful in debugging.
- *
- * @priv:       [in]    Attach private data of allocator to this buffer
- * @ops:        [in]    Attach allocator-defined dma buf ops to the new buffer.
- * @size:       [in]    Size of the buffer
- * @flags:      [in]    mode flags for the file.
- * @exp_name:   [in]    name of the exporting module - useful for debugging.
- *
- * Returns, on success, a newly created dma_buf object, which wraps the
- * supplied private data and operations for dma_buf_ops. On either missing
- * ops, or error in allocating struct dma_buf, will return negative error.
- *
- */
-struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops,
-                                size_t size, int flags, const char *exp_name)
-{
-        struct dma_buf *dmabuf;
-        struct file *file;
-
-        if (WARN_ON(!priv || !ops
-                          || !ops->map_dma_buf
-                          || !ops->unmap_dma_buf
-                          || !ops->release
-                          || !ops->kmap_atomic
-                          || !ops->kmap
-                          || !ops->mmap)) {
-                return ERR_PTR(-EINVAL);
-        }
-
-        dmabuf = kzalloc(sizeof(struct dma_buf), GFP_KERNEL);
-        if (dmabuf == NULL)
-                return ERR_PTR(-ENOMEM);
-
-        dmabuf->priv = priv;
-        dmabuf->ops = ops;
-        dmabuf->size = size;
-        dmabuf->exp_name = exp_name;
-
-        file = anon_inode_getfile("dmabuf", &dma_buf_fops, dmabuf, flags);
-        if (IS_ERR(file)) {
-                kfree(dmabuf);
-                return ERR_CAST(file);
-        }
-
-        file->f_mode |= FMODE_LSEEK;
-        dmabuf->file = file;
-
-        mutex_init(&dmabuf->lock);
-        INIT_LIST_HEAD(&dmabuf->attachments);
-
-        mutex_lock(&db_list.lock);
-        list_add(&dmabuf->list_node, &db_list.head);
-        mutex_unlock(&db_list.lock);
-
-        return dmabuf;
-}
-EXPORT_SYMBOL_GPL(dma_buf_export_named);
-
-
-/**
- * dma_buf_fd - returns a file descriptor for the given dma_buf
- * @dmabuf:     [in]    pointer to dma_buf for which fd is required.
- * @flags:      [in]    flags to give to fd
- *
- * On success, returns an associated 'fd'. Else, returns error.
- */
-int dma_buf_fd(struct dma_buf *dmabuf, int flags)
-{
-        int fd;
-
-        if (!dmabuf || !dmabuf->file)
-                return -EINVAL;
-
-        fd = get_unused_fd_flags(flags);
-        if (fd < 0)
-                return fd;
-
-        fd_install(fd, dmabuf->file);
-
-        return fd;
-}
-EXPORT_SYMBOL_GPL(dma_buf_fd);
-
-/**
- * dma_buf_get - returns the dma_buf structure related to an fd
- * @fd: [in]    fd associated with the dma_buf to be returned
- *
- * On success, returns the dma_buf structure associated with an fd; uses
- * file's refcounting done by fget to increase refcount. returns ERR_PTR
- * otherwise.
- */
-struct dma_buf *dma_buf_get(int fd)
-{
-        struct file *file;
-
-        file = fget(fd);
-
-        if (!file)
-                return ERR_PTR(-EBADF);
-
-        if (!is_dma_buf_file(file)) {
-                fput(file);
-                return ERR_PTR(-EINVAL);
-        }
-
-        return file->private_data;
-}
-EXPORT_SYMBOL_GPL(dma_buf_get);
-
-/**
- * dma_buf_put - decreases refcount of the buffer
- * @dmabuf:     [in]    buffer to reduce refcount of
- *
- * Uses file's refcounting done implicitly by fput()
- */
-void dma_buf_put(struct dma_buf *dmabuf)
-{
-        if (WARN_ON(!dmabuf || !dmabuf->file))
-                return;
-
-        fput(dmabuf->file);
-}
-EXPORT_SYMBOL_GPL(dma_buf_put);
-
-/**
- * dma_buf_attach - Add the device to dma_buf's attachments list; optionally,
- * calls attach() of dma_buf_ops to allow device-specific attach functionality
- * @dmabuf:     [in]    buffer to attach device to.
- * @dev:        [in]    device to be attached.
- *
- * 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)
-{
-        struct dma_buf_attachment *attach;
-        int ret;
-
-        if (WARN_ON(!dmabuf || !dev))
-                return ERR_PTR(-EINVAL);
-
-        attach = kzalloc(sizeof(struct dma_buf_attachment), GFP_KERNEL);
-        if (attach == NULL)
-                return ERR_PTR(-ENOMEM);
-
-        attach->dev = dev;
-        attach->dmabuf = dmabuf;
-
-        mutex_lock(&dmabuf->lock);
-
-        if (dmabuf->ops->attach) {
-                ret = dmabuf->ops->attach(dmabuf, dev, attach);
-                if (ret)
-                        goto err_attach;
-        }
-        list_add(&attach->node, &dmabuf->attachments);
-
-        mutex_unlock(&dmabuf->lock);
-        return attach;
-
-err_attach:
-        kfree(attach);
-        mutex_unlock(&dmabuf->lock);
-        return ERR_PTR(ret);
-}
-EXPORT_SYMBOL_GPL(dma_buf_attach);
-
-/**
- * dma_buf_detach - Remove the given attachment from dmabuf's attachments list;
- * optionally calls detach() of dma_buf_ops for device-specific detach
- * @dmabuf:     [in]    buffer to detach from.
- * @attach:     [in]    attachment to be detached; is free'd after this call.
- *
- */
-void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach)
-{
-        if (WARN_ON(!dmabuf || !attach))
-                return;
-
-        mutex_lock(&dmabuf->lock);
-        list_del(&attach->node);
-        if (dmabuf->ops->detach)
-                dmabuf->ops->detach(dmabuf, attach);
-
-        mutex_unlock(&dmabuf->lock);
-        kfree(attach);
-}
-EXPORT_SYMBOL_GPL(dma_buf_detach);
-
-/**
- * dma_buf_map_attachment - Returns the scatterlist table of the attachment;
- * mapped into _device_ address space. Is a wrapper for map_dma_buf() of the
- * dma_buf_ops.
- * @attach:     [in]    attachment whose scatterlist is to be returned
- * @direction:  [in]    direction of DMA transfer
- *
- * 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)
-{
-        struct sg_table *sg_table = ERR_PTR(-EINVAL);
-
-        might_sleep();
-
-        if (WARN_ON(!attach || !attach->dmabuf))
-                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;
-}
-EXPORT_SYMBOL_GPL(dma_buf_map_attachment);
-
-/**
- * dma_buf_unmap_attachment - unmaps and decreases usecount of the buffer;might
- * deallocate the scatterlist associated. Is a wrapper for unmap_dma_buf() of
- * dma_buf_ops.
- * @attach:     [in]    attachment to unmap buffer from
- * @sg_table:   [in]    scatterlist info of the buffer to unmap
- * @direction:  [in]    direction of DMA transfer
- *
- */
-void dma_buf_unmap_attachment(struct dma_buf_attachment *attach,
-                                struct sg_table *sg_table,
-                                enum dma_data_direction direction)
-{
-        might_sleep();
-
-        if (WARN_ON(!attach || !attach->dmabuf || !sg_table))
-                return;
-
-        attach->dmabuf->ops->unmap_dma_buf(attach, sg_table,
-                                                direction);
-}
-EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment);
-
-
-/**
- * dma_buf_begin_cpu_access - Must be called before accessing a dma_buf from the
- * cpu in the kernel context. Calls begin_cpu_access to allow exporter-specific
- * preparations. Coherency is only guaranteed in the specified range for the
- * specified access direction.
- * @dmabuf:     [in]    buffer to prepare cpu access for.
- * @start:      [in]    start of range for cpu access.
- * @len:        [in]    length of range for cpu access.
- * @direction:  [in]    length of range for cpu access.
- *
- * Can return negative error values, returns 0 on success.
- */
-int dma_buf_begin_cpu_access(struct dma_buf *dmabuf, size_t start, size_t len,
-                             enum dma_data_direction direction)
-{
-        int ret = 0;
-
-        if (WARN_ON(!dmabuf))
-                return -EINVAL;
-
-        if (dmabuf->ops->begin_cpu_access)
-                ret = dmabuf->ops->begin_cpu_access(dmabuf, start, len, direction);
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(dma_buf_begin_cpu_access);
-
-/**
- * dma_buf_end_cpu_access - Must be called after accessing a dma_buf from the
- * cpu in the kernel context. Calls end_cpu_access to allow exporter-specific
- * actions. Coherency is only guaranteed in the specified range for the
- * specified access direction.
- * @dmabuf:     [in]    buffer to complete cpu access for.
- * @start:      [in]    start of range for cpu access.
- * @len:        [in]    length of range for cpu access.
- * @direction:  [in]    length of range for cpu access.
- *
- * This call must always succeed.
- */
-void dma_buf_end_cpu_access(struct dma_buf *dmabuf, size_t start, size_t len,
-                            enum dma_data_direction direction)
-{
-        WARN_ON(!dmabuf);
-
-        if (dmabuf->ops->end_cpu_access)
-                dmabuf->ops->end_cpu_access(dmabuf, start, len, direction);
-}
-EXPORT_SYMBOL_GPL(dma_buf_end_cpu_access);
-
-/**
- * dma_buf_kmap_atomic - Map a page of the buffer object into kernel address
- * space. The same restrictions as for kmap_atomic and friends apply.
- * @dmabuf:     [in]    buffer to map page from.
- * @page_num:   [in]    page in PAGE_SIZE units to map.
- *
- * This call must always succeed, any necessary preparations that might fail
- * need to be done in begin_cpu_access.
- */
-void *dma_buf_kmap_atomic(struct dma_buf *dmabuf, unsigned long page_num)
-{
-        WARN_ON(!dmabuf);
-
-        return dmabuf->ops->kmap_atomic(dmabuf, page_num);
-}
-EXPORT_SYMBOL_GPL(dma_buf_kmap_atomic);
-
-/**
- * dma_buf_kunmap_atomic - Unmap a page obtained by dma_buf_kmap_atomic.
- * @dmabuf:     [in]    buffer to unmap page from.
- * @page_num:   [in]    page in PAGE_SIZE units to unmap.
- * @vaddr:      [in]    kernel space pointer obtained from dma_buf_kmap_atomic.
- *
- * This call must always succeed.
- */
-void dma_buf_kunmap_atomic(struct dma_buf *dmabuf, unsigned long page_num,
-                           void *vaddr)
-{
-        WARN_ON(!dmabuf);
-
-        if (dmabuf->ops->kunmap_atomic)
-                dmabuf->ops->kunmap_atomic(dmabuf, page_num, vaddr);
-}
-EXPORT_SYMBOL_GPL(dma_buf_kunmap_atomic);
-
-/**
- * dma_buf_kmap - Map a page of the buffer object into kernel address space. The
- * same restrictions as for kmap and friends apply.
- * @dmabuf:     [in]    buffer to map page from.
- * @page_num:   [in]    page in PAGE_SIZE units to map.
- *
- * This call must always succeed, any necessary preparations that might fail
- * need to be done in begin_cpu_access.
- */
-void *dma_buf_kmap(struct dma_buf *dmabuf, unsigned long page_num)
-{
-        WARN_ON(!dmabuf);
-
-        return dmabuf->ops->kmap(dmabuf, page_num);
-}
-EXPORT_SYMBOL_GPL(dma_buf_kmap);
-
-/**
- * dma_buf_kunmap - Unmap a page obtained by dma_buf_kmap.
- * @dmabuf:     [in]    buffer to unmap page from.
- * @page_num:   [in]    page in PAGE_SIZE units to unmap.
- * @vaddr:      [in]    kernel space pointer obtained from dma_buf_kmap.
- *
- * This call must always succeed.
- */
-void dma_buf_kunmap(struct dma_buf *dmabuf, unsigned long page_num,
-                    void *vaddr)
-{
-        WARN_ON(!dmabuf);
-
-        if (dmabuf->ops->kunmap)
-                dmabuf->ops->kunmap(dmabuf, page_num, vaddr);
-}
-EXPORT_SYMBOL_GPL(dma_buf_kunmap);
-
-
-/**
- * dma_buf_mmap - Setup up a userspace mmap with the given vma
- * @dmabuf:     [in]    buffer that should back the vma
- * @vma:        [in]    vma for the mmap
- * @pgoff:      [in]    offset in pages where this mmap should start within the
- *                      dma-buf buffer.
- *
- * This function adjusts the passed in vma so that it points at the file of the
- * dma_buf operation. It also adjusts the starting pgoff and does bounds
- * checking on the size of the vma. Then it calls the exporters mmap function to
- * set up the mapping.
- *
- * Can return negative error values, returns 0 on success.
- */
-int dma_buf_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma,
-                 unsigned long pgoff)
-{
-        struct file *oldfile;
-        int ret;
-
-        if (WARN_ON(!dmabuf || !vma))
-                return -EINVAL;
-
-        /* check for offset overflow */
-        if (pgoff + ((vma->vm_end - vma->vm_start) >> PAGE_SHIFT) < pgoff)
-                return -EOVERFLOW;
-
-        /* check for overflowing the buffer's size */
-        if (pgoff + ((vma->vm_end - vma->vm_start) >> PAGE_SHIFT) >
-            dmabuf->size >> PAGE_SHIFT)
-                return -EINVAL;
-
-        /* readjust the vma */
-        get_file(dmabuf->file);
-        oldfile = vma->vm_file;
-        vma->vm_file = dmabuf->file;
-        vma->vm_pgoff = pgoff;
-
-        ret = dmabuf->ops->mmap(dmabuf, vma);
-        if (ret) {
-                /* restore old parameters on failure */
-                vma->vm_file = oldfile;
-                fput(dmabuf->file);
-        } else {
-                if (oldfile)
-                        fput(oldfile);
-        }
-        return ret;
-
-}
-EXPORT_SYMBOL_GPL(dma_buf_mmap);
-
-/**
- * dma_buf_vmap - Create virtual mapping for the buffer object into kernel
- * address space. Same restrictions as for vmap and friends apply.
- * @dmabuf:     [in]    buffer to vmap
- *
- * This call may fail due to lack of virtual mapping address space.
- * 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)
-{
-        void *ptr;
-
-        if (WARN_ON(!dmabuf))
-                return NULL;
-
-        if (!dmabuf->ops->vmap)
-                return NULL;
-
-        mutex_lock(&dmabuf->lock);
-        if (dmabuf->vmapping_counter) {
-                dmabuf->vmapping_counter++;
-                BUG_ON(!dmabuf->vmap_ptr);
-                ptr = dmabuf->vmap_ptr;
-                goto out_unlock;
-        }
-
-        BUG_ON(dmabuf->vmap_ptr);
-
-        ptr = dmabuf->ops->vmap(dmabuf);
-        if (WARN_ON_ONCE(IS_ERR(ptr)))
-                ptr = NULL;
-        if (!ptr)
-                goto out_unlock;
-
-        dmabuf->vmap_ptr = ptr;
-        dmabuf->vmapping_counter = 1;
-
-out_unlock:
-        mutex_unlock(&dmabuf->lock);
-        return ptr;
-}
-EXPORT_SYMBOL_GPL(dma_buf_vmap);
-
-/**
- * dma_buf_vunmap - Unmap a vmap obtained by dma_buf_vmap.
- * @dmabuf:     [in]    buffer to vunmap
- * @vaddr:      [in]    vmap to vunmap
- */
-void dma_buf_vunmap(struct dma_buf *dmabuf, void *vaddr)
-{
-        if (WARN_ON(!dmabuf))
-                return;
-
-        BUG_ON(!dmabuf->vmap_ptr);
-        BUG_ON(dmabuf->vmapping_counter == 0);
-        BUG_ON(dmabuf->vmap_ptr != vaddr);
-
-        mutex_lock(&dmabuf->lock);
-        if (--dmabuf->vmapping_counter == 0) {
-                if (dmabuf->ops->vunmap)
-                        dmabuf->ops->vunmap(dmabuf, vaddr);
-                dmabuf->vmap_ptr = NULL;
-        }
-        mutex_unlock(&dmabuf->lock);
-}
-EXPORT_SYMBOL_GPL(dma_buf_vunmap);
-
-#ifdef CONFIG_DEBUG_FS
-static int dma_buf_describe(struct seq_file *s)
-{
-        int ret;
-        struct dma_buf *buf_obj;
-        struct dma_buf_attachment *attach_obj;
-        int count = 0, attach_count;
-        size_t size = 0;
-
-        ret = mutex_lock_interruptible(&db_list.lock);
-
-        if (ret)
-                return ret;
-
-        seq_puts(s, "\nDma-buf Objects:\n");
-        seq_puts(s, "size\tflags\tmode\tcount\texp_name\n");
-
-        list_for_each_entry(buf_obj, &db_list.head, list_node) {
-                ret = mutex_lock_interruptible(&buf_obj->lock);
-
-                if (ret) {
-                        seq_puts(s,
-                                 "\tERROR locking buffer object: skipping\n");
-                        continue;
-                }
-
-                seq_printf(s, "%08zu\t%08x\t%08x\t%08ld\t%s\n",
-                                buf_obj->size,
-                                buf_obj->file->f_flags, buf_obj->file->f_mode,
-                                (long)(buf_obj->file->f_count.counter),
-                                buf_obj->exp_name);
-
-                seq_puts(s, "\tAttached Devices:\n");
-                attach_count = 0;
-
-                list_for_each_entry(attach_obj, &buf_obj->attachments, node) {
-                        seq_puts(s, "\t");
-
-                        seq_printf(s, "%s\n", dev_name(attach_obj->dev));
-                        attach_count++;
-                }
-
-                seq_printf(s, "Total %d devices attached\n\n",
-                                attach_count);
-
-                count++;
-                size += buf_obj->size;
-                mutex_unlock(&buf_obj->lock);
-        }
-
-        seq_printf(s, "\nTotal %d objects, %zu bytes\n", count, size);
-
-        mutex_unlock(&db_list.lock);
-        return 0;
-}
-
-static int dma_buf_show(struct seq_file *s, void *unused)
-{
-        void (*func)(struct seq_file *) = s->private;
-        func(s);
-        return 0;
-}
-
-static int dma_buf_debug_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, dma_buf_show, inode->i_private);
-}
-
-static const struct file_operations dma_buf_debug_fops = {
-        .open           = dma_buf_debug_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
-static struct dentry *dma_buf_debugfs_dir;
-
-static int dma_buf_init_debugfs(void)
-{
-        int err = 0;
-        dma_buf_debugfs_dir = debugfs_create_dir("dma_buf", NULL);
-        if (IS_ERR(dma_buf_debugfs_dir)) {
-                err = PTR_ERR(dma_buf_debugfs_dir);
-                dma_buf_debugfs_dir = NULL;
-                return err;
-        }
-
-        err = dma_buf_debugfs_create_file("bufinfo", dma_buf_describe);
-
-        if (err)
-                pr_debug("dma_buf: debugfs: failed to create node bufinfo\n");
-
-        return err;
-}
-
-static void dma_buf_uninit_debugfs(void)
-{
-        if (dma_buf_debugfs_dir)
-                debugfs_remove_recursive(dma_buf_debugfs_dir);
-}
-
-int dma_buf_debugfs_create_file(const char *name,
-                                int (*write)(struct seq_file *))
-{
-        struct dentry *d;
-
-        d = debugfs_create_file(name, S_IRUGO, dma_buf_debugfs_dir,
-                        write, &dma_buf_debug_fops);
-
-        return PTR_ERR_OR_ZERO(d);
-}
-#else
-static inline int dma_buf_init_debugfs(void)
-{
-        return 0;
-}
-static inline void dma_buf_uninit_debugfs(void)
-{
-}
-#endif
-
-static int __init dma_buf_init(void)
-{
-        mutex_init(&db_list.lock);
-        INIT_LIST_HEAD(&db_list.head);
-        dma_buf_init_debugfs();
-        return 0;
-}
-subsys_initcall(dma_buf_init);
-
-static void __exit dma_buf_deinit(void)
-{
-        dma_buf_uninit_debugfs();
-}
-__exitcall(dma_buf_deinit);
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index d276e33880be..da77791793f1 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -100,10 +100,16 @@ static inline long firmware_loading_timeout(void)
 #define FW_OPT_UEVENT   (1U << 0)
 #define FW_OPT_NOWAIT   (1U << 1)
 #ifdef CONFIG_FW_LOADER_USER_HELPER
-#define FW_OPT_FALLBACK (1U << 2)
+#define FW_OPT_USERHELPER       (1U << 2)
 #else
-#define FW_OPT_FALLBACK 0
+#define FW_OPT_USERHELPER       0
 #endif
+#ifdef CONFIG_FW_LOADER_USER_HELPER_FALLBACK
+#define FW_OPT_FALLBACK         FW_OPT_USERHELPER
+#else
+#define FW_OPT_FALLBACK         0
+#endif
+#define FW_OPT_NO_WARN  (1U << 3)
 
 struct firmware_cache {
         /* firmware_buf instance will be added into the below list */
@@ -279,26 +285,15 @@ static const char * const fw_path[] = {
 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 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 != (int)st.size)
-                return -1;
-        return st.size;
-}
-
 static int fw_read_file_contents(struct file *file, struct firmware_buf *fw_buf)
 {
         int size;
         char *buf;
         int rc;
 
-        size = fw_file_size(file);
+        if (!S_ISREG(file_inode(file)->i_mode))
+                return -EINVAL;
+        size = i_size_read(file_inode(file));
         if (size <= 0)
                 return -EINVAL;
         buf = vmalloc(size);
@@ -718,7 +713,7 @@ out:
 static int fw_realloc_buffer(struct firmware_priv *fw_priv, int min_size)
 {
         struct firmware_buf *buf = fw_priv->buf;
-        int pages_needed = ALIGN(min_size, PAGE_SIZE) >> PAGE_SHIFT;
+        int pages_needed = PAGE_ALIGN(min_size) >> PAGE_SHIFT;
 
         /* If the array of pages is too small, grow it... */
         if (buf->page_array_size < pages_needed) {
@@ -911,7 +906,9 @@ 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)
+        if (is_fw_load_aborted(buf))
+                retval = -EAGAIN;
+        else if (!buf->data)
                 retval = -ENOMEM;
 
         device_remove_file(f_dev, &dev_attr_loading);
@@ -1111,10 +1108,11 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
 
         ret = fw_get_filesystem_firmware(device, fw->priv);
         if (ret) {
-                if (opt_flags & FW_OPT_FALLBACK) {
+                if (!(opt_flags & FW_OPT_NO_WARN))
                         dev_warn(device,
-                                 "Direct firmware load failed with error %d\n",
-                                 ret);
+                                 "Direct firmware load for %s failed with error %d\n",
+                                 name, ret);
+                if (opt_flags & FW_OPT_USERHELPER) {
                         dev_warn(device, "Falling back to user helper\n");
                         ret = fw_load_from_user_helper(fw, name, device,
                                                        opt_flags, timeout);
@@ -1171,7 +1169,6 @@ request_firmware(const struct firmware **firmware_p, const char *name,
 }
 EXPORT_SYMBOL(request_firmware);
 
-#ifdef CONFIG_FW_LOADER_USER_HELPER
 /**
  * request_firmware: - load firmware directly without usermode helper
  * @firmware_p: pointer to firmware image
@@ -1188,12 +1185,12 @@ int request_firmware_direct(const struct firmware **firmware_p,
 {
         int ret;
         __module_get(THIS_MODULE);
-        ret = _request_firmware(firmware_p, name, device, FW_OPT_UEVENT);
+        ret = _request_firmware(firmware_p, name, device,
+                                FW_OPT_UEVENT | FW_OPT_NO_WARN);
         module_put(THIS_MODULE);
         return ret;
 }
 EXPORT_SYMBOL_GPL(request_firmware_direct);
-#endif
 
 /**
  * release_firmware: - release the resource associated with a firmware image
@@ -1277,7 +1274,7 @@ request_firmware_nowait(
         fw_work->context = context;
         fw_work->cont = cont;
         fw_work->opt_flags = FW_OPT_NOWAIT | FW_OPT_FALLBACK |
-                (uevent ? FW_OPT_UEVENT : 0);
+                (uevent ? FW_OPT_UEVENT : FW_OPT_USERHELPER);
 
         if (!try_module_get(module)) {
                 kfree(fw_work);
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 00f2208949d1..ab4f4ce02722 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -24,6 +24,7 @@
 #include <linux/idr.h>
 #include <linux/acpi.h>
 #include <linux/clk/clk-conf.h>
+#include <linux/limits.h>
 
 #include "base.h"
 #include "power/power.h"
@@ -176,7 +177,7 @@ EXPORT_SYMBOL_GPL(platform_add_devices);
 
 struct platform_object {
         struct platform_device pdev;
-        char name[1];
+        char name[];
 };
 
 /**
@@ -202,6 +203,7 @@ static void platform_device_release(struct device *dev)
         kfree(pa->pdev.dev.platform_data);
         kfree(pa->pdev.mfd_cell);
         kfree(pa->pdev.resource);
+        kfree(pa->pdev.driver_override);
         kfree(pa);
 }
 
@@ -217,7 +219,7 @@ struct platform_device *platform_device_alloc(const char *name, int id)
 {
         struct platform_object *pa;
 
-        pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);
+        pa = kzalloc(sizeof(*pa) + strlen(name) + 1, GFP_KERNEL);
         if (pa) {
                 strcpy(pa->name, name);
                 pa->pdev.name = pa->name;
@@ -713,8 +715,49 @@ static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 }
 static DEVICE_ATTR_RO(modalias);
 
+static ssize_t driver_override_store(struct device *dev,
+                                     struct device_attribute *attr,
+                                     const char *buf, size_t count)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        char *driver_override, *old = pdev->driver_override, *cp;
+
+        if (count > PATH_MAX)
+                return -EINVAL;
+
+        driver_override = kstrndup(buf, count, GFP_KERNEL);
+        if (!driver_override)
+                return -ENOMEM;
+
+        cp = strchr(driver_override, '\n');
+        if (cp)
+                *cp = '\0';
+
+        if (strlen(driver_override)) {
+                pdev->driver_override = driver_override;
+        } else {
+                kfree(driver_override);
+                pdev->driver_override = NULL;
+        }
+
+        kfree(old);
+
+        return count;
+}
+
+static ssize_t driver_override_show(struct device *dev,
+                                    struct device_attribute *attr, char *buf)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+
+        return sprintf(buf, "%s\n", pdev->driver_override);
+}
+static DEVICE_ATTR_RW(driver_override);
+
+
 static struct attribute *platform_dev_attrs[] = {
         &dev_attr_modalias.attr,
+        &dev_attr_driver_override.attr,
         NULL,
 };
 ATTRIBUTE_GROUPS(platform_dev);
@@ -770,6 +813,10 @@ static int platform_match(struct device *dev, struct device_driver *drv)
         struct platform_device *pdev = to_platform_device(dev);
         struct platform_driver *pdrv = to_platform_driver(drv);
 
+        /* When driver_override is set, only bind to the matching driver */
+        if (pdev->driver_override)
+                return !strcmp(pdev->driver_override, drv->name);
+
         /* Attempt an OF style match first */
         if (of_driver_match_device(dev, drv))
                 return 1;
diff --git a/drivers/base/reservation.c b/drivers/base/reservation.c
deleted file mode 100644
index a73fbf3b8e56..000000000000
--- a/drivers/base/reservation.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2012-2013 Canonical Ltd
- *
- * Based on bo.c which bears the following copyright notice,
- * but is dual licensed:
- *
- * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
- * USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-/*
- * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
- */
-
-#include <linux/reservation.h>
-#include <linux/export.h>
-
-DEFINE_WW_CLASS(reservation_ww_class);
-EXPORT_SYMBOL(reservation_ww_class);