Merge branch 'iommu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'iommu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (61 commits)
  amd-iommu: remove unnecessary "AMD IOMMU: " prefix
  amd-iommu: detach device explicitly before attaching it to a new domain
  amd-iommu: remove BUS_NOTIFY_BOUND_DRIVER handling
  dma-debug: simplify logic in driver_filter()
  dma-debug: disable/enable irqs only once in device_dma_allocations
  dma-debug: use pr_* instead of printk(KERN_* ...)
  dma-debug: code style fixes
  dma-debug: comment style fixes
  dma-debug: change hash_bucket_find from first-fit to best-fit
  x86: enable GART-IOMMU only after setting up protection methods
  amd_iommu: fix lock imbalance
  dma-debug: add documentation for the driver filter
  dma-debug: add dma_debug_driver kernel command line
  dma-debug: add debugfs file for driver filter
  dma-debug: add variables and checks for driver filter
  dma-debug: fix debug_dma_sync_sg_for_cpu and debug_dma_sync_sg_for_device
  dma-debug: use sg_dma_len accessor
  dma-debug: use sg_dma_address accessor instead of using dma_address directly
  amd-iommu: don't free dma adresses below 512MB with CONFIG_IOMMU_STRESS
  amd-iommu: don't preallocate page tables with CONFIG_IOMMU_STRESS
  ...

2 files changed, 449 insertions, 102 deletions

diff --git a/lib/dma-debug.c b/lib/dma-debug.c
index 69da09a085a1..ad65fc0317d9 100644
--- a/lib/dma-debug.c
+++ b/lib/dma-debug.c
@@ -23,9 +23,11 @@
 #include <linux/dma-debug.h>
 #include <linux/spinlock.h>
 #include <linux/debugfs.h>
+#include <linux/uaccess.h>
 #include <linux/device.h>
 #include <linux/types.h>
 #include <linux/sched.h>
+#include <linux/ctype.h>
 #include <linux/list.h>
 #include <linux/slab.h>
 
@@ -85,6 +87,7 @@ static u32 show_num_errors = 1;
 
 static u32 num_free_entries;
 static u32 min_free_entries;
+static u32 nr_total_entries;
 
 /* number of preallocated entries requested by kernel cmdline */
 static u32 req_entries;
@@ -97,6 +100,16 @@ static struct dentry *show_all_errors_dent  __read_mostly;
 static struct dentry *show_num_errors_dent  __read_mostly;
 static struct dentry *num_free_entries_dent __read_mostly;
 static struct dentry *min_free_entries_dent __read_mostly;
+static struct dentry *filter_dent           __read_mostly;
+
+/* per-driver filter related state */
+
+#define NAME_MAX_LEN    64
+
+static char                  current_driver_name[NAME_MAX_LEN] __read_mostly;
+static struct device_driver *current_driver                    __read_mostly;
+
+static DEFINE_RWLOCK(driver_name_lock);
 
 static const char *type2name[4] = { "single", "page",
                                     "scather-gather", "coherent" };
@@ -104,6 +117,11 @@ static const char *type2name[4] = { "single", "page",
 static const char *dir2name[4] = { "DMA_BIDIRECTIONAL", "DMA_TO_DEVICE",
                                    "DMA_FROM_DEVICE", "DMA_NONE" };
 
+/* little merge helper - remove it after the merge window */
+#ifndef BUS_NOTIFY_UNBOUND_DRIVER
+#define BUS_NOTIFY_UNBOUND_DRIVER 0x0005
+#endif
+
 /*
  * The access to some variables in this macro is racy. We can't use atomic_t
  * here because all these variables are exported to debugfs. Some of them even
@@ -121,15 +139,54 @@ static inline void dump_entry_trace(struct dma_debug_entry *entry)
 {
 #ifdef CONFIG_STACKTRACE
         if (entry) {
-                printk(KERN_WARNING "Mapped at:\n");
+                pr_warning("Mapped at:\n");
                 print_stack_trace(&entry->stacktrace, 0);
         }
 #endif
 }
 
+static bool driver_filter(struct device *dev)
+{
+        struct device_driver *drv;
+        unsigned long flags;
+        bool ret;
+
+        /* driver filter off */
+        if (likely(!current_driver_name[0]))
+                return true;
+
+        /* driver filter on and initialized */
+        if (current_driver && dev->driver == current_driver)
+                return true;
+
+        if (current_driver || !current_driver_name[0])
+                return false;
+
+        /* driver filter on but not yet initialized */
+        drv = get_driver(dev->driver);
+        if (!drv)
+                return false;
+
+        /* lock to protect against change of current_driver_name */
+        read_lock_irqsave(&driver_name_lock, flags);
+
+        ret = false;
+        if (drv->name &&
+            strncmp(current_driver_name, drv->name, NAME_MAX_LEN - 1) == 0) {
+                current_driver = drv;
+                ret = true;
+        }
+
+        read_unlock_irqrestore(&driver_name_lock, flags);
+        put_driver(drv);
+
+        return ret;
+}
+
 #define err_printk(dev, entry, format, arg...) do {             \
                 error_count += 1;                               \
-                if (show_all_errors || show_num_errors > 0) {   \
+                if (driver_filter(dev) &&                       \
+                    (show_all_errors || show_num_errors > 0)) { \
                         WARN(1, "%s %s: " format,               \
                              dev_driver_string(dev),            \
                              dev_name(dev) , ## arg);           \
@@ -185,15 +242,50 @@ static void put_hash_bucket(struct hash_bucket *bucket,
 static struct dma_debug_entry *hash_bucket_find(struct hash_bucket *bucket,
                                                 struct dma_debug_entry *ref)
 {
-        struct dma_debug_entry *entry;
+        struct dma_debug_entry *entry, *ret = NULL;
+        int matches = 0, match_lvl, last_lvl = 0;
 
         list_for_each_entry(entry, &bucket->list, list) {
-                if ((entry->dev_addr == ref->dev_addr) &&
-                    (entry->dev == ref->dev))
+                if ((entry->dev_addr != ref->dev_addr) ||
+                    (entry->dev != ref->dev))
+                        continue;
+
+                /*
+                 * Some drivers map the same physical address multiple
+                 * times. Without a hardware IOMMU this results in the
+                 * same device addresses being put into the dma-debug
+                 * hash multiple times too. This can result in false
+                 * positives being reported. Therfore we implement a
+                 * best-fit algorithm here which returns the entry from
+                 * the hash which fits best to the reference value
+                 * instead of the first-fit.
+                 */
+                matches += 1;
+                match_lvl = 0;
+                entry->size      == ref->size      ? ++match_lvl : match_lvl;
+                entry->type      == ref->type      ? ++match_lvl : match_lvl;
+                entry->direction == ref->direction ? ++match_lvl : match_lvl;
+
+                if (match_lvl == 3) {
+                        /* perfect-fit - return the result */
                         return entry;
+                } else if (match_lvl > last_lvl) {
+                        /*
+                         * We found an entry that fits better then the
+                         * previous one
+                         */
+                        last_lvl = match_lvl;
+                        ret      = entry;
+                }
         }
 
-        return NULL;
+        /*
+         * If we have multiple matches but no perfect-fit, just return
+         * NULL.
+         */
+        ret = (matches == 1) ? ret : NULL;
+
+        return ret;
 }
 
 /*
@@ -257,6 +349,21 @@ static void add_dma_entry(struct dma_debug_entry *entry)
         put_hash_bucket(bucket, &flags);
 }
 
+static struct dma_debug_entry *__dma_entry_alloc(void)
+{
+        struct dma_debug_entry *entry;
+
+        entry = list_entry(free_entries.next, struct dma_debug_entry, list);
+        list_del(&entry->list);
+        memset(entry, 0, sizeof(*entry));
+
+        num_free_entries -= 1;
+        if (num_free_entries < min_free_entries)
+                min_free_entries = num_free_entries;
+
+        return entry;
+}
+
 /* struct dma_entry allocator
  *
  * The next two functions implement the allocator for
@@ -270,15 +377,12 @@ static struct dma_debug_entry *dma_entry_alloc(void)
         spin_lock_irqsave(&free_entries_lock, flags);
 
         if (list_empty(&free_entries)) {
-                printk(KERN_ERR "DMA-API: debugging out of memory "
-                                "- disabling\n");
+                pr_err("DMA-API: debugging out of memory - disabling\n");
                 global_disable = true;
                 goto out;
         }
 
-        entry = list_entry(free_entries.next, struct dma_debug_entry, list);
-        list_del(&entry->list);
-        memset(entry, 0, sizeof(*entry));
+        entry = __dma_entry_alloc();
 
 #ifdef CONFIG_STACKTRACE
         entry->stacktrace.max_entries = DMA_DEBUG_STACKTRACE_ENTRIES;
@@ -286,9 +390,6 @@ static struct dma_debug_entry *dma_entry_alloc(void)
         entry->stacktrace.skip = 2;
         save_stack_trace(&entry->stacktrace);
 #endif
-        num_free_entries -= 1;
-        if (num_free_entries < min_free_entries)
-                min_free_entries = num_free_entries;
 
 out:
         spin_unlock_irqrestore(&free_entries_lock, flags);
@@ -310,6 +411,53 @@ static void dma_entry_free(struct dma_debug_entry *entry)
         spin_unlock_irqrestore(&free_entries_lock, flags);
 }
 
+int dma_debug_resize_entries(u32 num_entries)
+{
+        int i, delta, ret = 0;
+        unsigned long flags;
+        struct dma_debug_entry *entry;
+        LIST_HEAD(tmp);
+
+        spin_lock_irqsave(&free_entries_lock, flags);
+
+        if (nr_total_entries < num_entries) {
+                delta = num_entries - nr_total_entries;
+
+                spin_unlock_irqrestore(&free_entries_lock, flags);
+
+                for (i = 0; i < delta; i++) {
+                        entry = kzalloc(sizeof(*entry), GFP_KERNEL);
+                        if (!entry)
+                                break;
+
+                        list_add_tail(&entry->list, &tmp);
+                }
+
+                spin_lock_irqsave(&free_entries_lock, flags);
+
+                list_splice(&tmp, &free_entries);
+                nr_total_entries += i;
+                num_free_entries += i;
+        } else {
+                delta = nr_total_entries - num_entries;
+
+                for (i = 0; i < delta && !list_empty(&free_entries); i++) {
+                        entry = __dma_entry_alloc();
+                        kfree(entry);
+                }
+
+                nr_total_entries -= i;
+        }
+
+        if (nr_total_entries != num_entries)
+                ret = 1;
+
+        spin_unlock_irqrestore(&free_entries_lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL(dma_debug_resize_entries);
+
 /*
  * DMA-API debugging init code
  *
@@ -334,8 +482,7 @@ static int prealloc_memory(u32 num_entries)
         num_free_entries = num_entries;
         min_free_entries = num_entries;
 
-        printk(KERN_INFO "DMA-API: preallocated %d debug entries\n",
-                        num_entries);
+        pr_info("DMA-API: preallocated %d debug entries\n", num_entries);
 
         return 0;
 
@@ -349,11 +496,102 @@ out_err:
         return -ENOMEM;
 }
 
+static ssize_t filter_read(struct file *file, char __user *user_buf,
+                           size_t count, loff_t *ppos)
+{
+        char buf[NAME_MAX_LEN + 1];
+        unsigned long flags;
+        int len;
+
+        if (!current_driver_name[0])
+                return 0;
+
+        /*
+         * We can't copy to userspace directly because current_driver_name can
+         * only be read under the driver_name_lock with irqs disabled. So
+         * create a temporary copy first.
+         */
+        read_lock_irqsave(&driver_name_lock, flags);
+        len = scnprintf(buf, NAME_MAX_LEN + 1, "%s\n", current_driver_name);
+        read_unlock_irqrestore(&driver_name_lock, flags);
+
+        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
+}
+
+static ssize_t filter_write(struct file *file, const char __user *userbuf,
+                            size_t count, loff_t *ppos)
+{
+        char buf[NAME_MAX_LEN];
+        unsigned long flags;
+        size_t len;
+        int i;
+
+        /*
+         * We can't copy from userspace directly. Access to
+         * current_driver_name is protected with a write_lock with irqs
+         * disabled. Since copy_from_user can fault and may sleep we
+         * need to copy to temporary buffer first
+         */
+        len = min(count, (size_t)(NAME_MAX_LEN - 1));
+        if (copy_from_user(buf, userbuf, len))
+                return -EFAULT;
+
+        buf[len] = 0;
+
+        write_lock_irqsave(&driver_name_lock, flags);
+
+        /*
+         * Now handle the string we got from userspace very carefully.
+         * The rules are:
+         *         - only use the first token we got
+         *         - token delimiter is everything looking like a space
+         *           character (' ', '\n', '\t' ...)
+         *
+         */
+        if (!isalnum(buf[0])) {
+                /*
+                 * If the first character userspace gave us is not
+                 * alphanumerical then assume the filter should be
+                 * switched off.
+                 */
+                if (current_driver_name[0])
+                        pr_info("DMA-API: switching off dma-debug driver filter\n");
+                current_driver_name[0] = 0;
+                current_driver = NULL;
+                goto out_unlock;
+        }
+
+        /*
+         * Now parse out the first token and use it as the name for the
+         * driver to filter for.
+         */
+        for (i = 0; i < NAME_MAX_LEN; ++i) {
+                current_driver_name[i] = buf[i];
+                if (isspace(buf[i]) || buf[i] == ' ' || buf[i] == 0)
+                        break;
+        }
+        current_driver_name[i] = 0;
+        current_driver = NULL;
+
+        pr_info("DMA-API: enable driver filter for driver [%s]\n",
+                current_driver_name);
+
+out_unlock:
+        write_unlock_irqrestore(&driver_name_lock, flags);
+
+        return count;
+}
+
+const struct file_operations filter_fops = {
+        .read  = filter_read,
+        .write = filter_write,
+};
+
 static int dma_debug_fs_init(void)
 {
         dma_debug_dent = debugfs_create_dir("dma-api", NULL);
         if (!dma_debug_dent) {
-                printk(KERN_ERR "DMA-API: can not create debugfs directory\n");
+                pr_err("DMA-API: can not create debugfs directory\n");
                 return -ENOMEM;
         }
 
@@ -392,6 +630,11 @@ static int dma_debug_fs_init(void)
         if (!min_free_entries_dent)
                 goto out_err;
 
+        filter_dent = debugfs_create_file("driver_filter", 0644,
+                                          dma_debug_dent, NULL, &filter_fops);
+        if (!filter_dent)
+                goto out_err;
+
         return 0;
 
 out_err:
@@ -400,9 +643,64 @@ out_err:
         return -ENOMEM;
 }
 
+static int device_dma_allocations(struct device *dev)
+{
+        struct dma_debug_entry *entry;
+        unsigned long flags;
+        int count = 0, i;
+
+        local_irq_save(flags);
+
+        for (i = 0; i < HASH_SIZE; ++i) {
+                spin_lock(&dma_entry_hash[i].lock);
+                list_for_each_entry(entry, &dma_entry_hash[i].list, list) {
+                        if (entry->dev == dev)
+                                count += 1;
+                }
+                spin_unlock(&dma_entry_hash[i].lock);
+        }
+
+        local_irq_restore(flags);
+
+        return count;
+}
+
+static int dma_debug_device_change(struct notifier_block *nb,
+                                    unsigned long action, void *data)
+{
+        struct device *dev = data;
+        int count;
+
+
+        switch (action) {
+        case BUS_NOTIFY_UNBOUND_DRIVER:
+                count = device_dma_allocations(dev);
+                if (count == 0)
+                        break;
+                err_printk(dev, NULL, "DMA-API: device driver has pending "
+                                "DMA allocations while released from device "
+                                "[count=%d]\n", count);
+                break;
+        default:
+                break;
+        }
+
+        return 0;
+}
+
 void dma_debug_add_bus(struct bus_type *bus)
 {
-        /* FIXME: register notifier */
+        struct notifier_block *nb;
+
+        nb = kzalloc(sizeof(struct notifier_block), GFP_KERNEL);
+        if (nb == NULL) {
+                pr_err("dma_debug_add_bus: out of memory\n");
+                return;
+        }
+
+        nb->notifier_call = dma_debug_device_change;
+
+        bus_register_notifier(bus, nb);
 }
 
 /*
@@ -421,8 +719,7 @@ void dma_debug_init(u32 num_entries)
         }
 
         if (dma_debug_fs_init() != 0) {
-                printk(KERN_ERR "DMA-API: error creating debugfs entries "
-                                "- disabling\n");
+                pr_err("DMA-API: error creating debugfs entries - disabling\n");
                 global_disable = true;
 
                 return;
@@ -432,14 +729,15 @@ void dma_debug_init(u32 num_entries)
                 num_entries = req_entries;
 
         if (prealloc_memory(num_entries) != 0) {
-                printk(KERN_ERR "DMA-API: debugging out of memory error "
-                                "- disabled\n");
+                pr_err("DMA-API: debugging out of memory error - disabled\n");
                 global_disable = true;
 
                 return;
         }
 
-        printk(KERN_INFO "DMA-API: debugging enabled by kernel config\n");
+        nr_total_entries = num_free_entries;
+
+        pr_info("DMA-API: debugging enabled by kernel config\n");
 }
 
 static __init int dma_debug_cmdline(char *str)
@@ -448,8 +746,7 @@ static __init int dma_debug_cmdline(char *str)
                 return -EINVAL;
 
         if (strncmp(str, "off", 3) == 0) {
-                printk(KERN_INFO "DMA-API: debugging disabled on kernel "
-                                 "command line\n");
+                pr_info("DMA-API: debugging disabled on kernel command line\n");
                 global_disable = true;
         }
 
@@ -723,15 +1020,15 @@ void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
                 entry->type           = dma_debug_sg;
                 entry->dev            = dev;
                 entry->paddr          = sg_phys(s);
-                entry->size           = s->length;
-                entry->dev_addr       = s->dma_address;
+                entry->size           = sg_dma_len(s);
+                entry->dev_addr       = sg_dma_address(s);
                 entry->direction      = direction;
                 entry->sg_call_ents   = nents;
                 entry->sg_mapped_ents = mapped_ents;
 
                 if (!PageHighMem(sg_page(s))) {
                         check_for_stack(dev, sg_virt(s));
-                        check_for_illegal_area(dev, sg_virt(s), s->length);
+                        check_for_illegal_area(dev, sg_virt(s), sg_dma_len(s));
                 }
 
                 add_dma_entry(entry);
@@ -739,13 +1036,33 @@ void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
 }
 EXPORT_SYMBOL(debug_dma_map_sg);
 
+static int get_nr_mapped_entries(struct device *dev, struct scatterlist *s)
+{
+        struct dma_debug_entry *entry, ref;
+        struct hash_bucket *bucket;
+        unsigned long flags;
+        int mapped_ents;
+
+        ref.dev      = dev;
+        ref.dev_addr = sg_dma_address(s);
+        ref.size     = sg_dma_len(s),
+
+        bucket       = get_hash_bucket(&ref, &flags);
+        entry        = hash_bucket_find(bucket, &ref);
+        mapped_ents  = 0;
+
+        if (entry)
+                mapped_ents = entry->sg_mapped_ents;
+        put_hash_bucket(bucket, &flags);
+
+        return mapped_ents;
+}
+
 void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
                         int nelems, int dir)
 {
-        struct dma_debug_entry *entry;
         struct scatterlist *s;
         int mapped_ents = 0, i;
-        unsigned long flags;
 
         if (unlikely(global_disable))
                 return;
@@ -756,8 +1073,8 @@ void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
                         .type           = dma_debug_sg,
                         .dev            = dev,
                         .paddr          = sg_phys(s),
-                        .dev_addr       = s->dma_address,
-                        .size           = s->length,
+                        .dev_addr       = sg_dma_address(s),
+                        .size           = sg_dma_len(s),
                         .direction      = dir,
                         .sg_call_ents   = 0,
                 };
@@ -765,14 +1082,9 @@ void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
                 if (mapped_ents && i >= mapped_ents)
                         break;
 
-                if (mapped_ents == 0) {
-                        struct hash_bucket *bucket;
+                if (!i) {
                         ref.sg_call_ents = nelems;
-                        bucket = get_hash_bucket(&ref, &flags);
-                        entry = hash_bucket_find(bucket, &ref);
-                        if (entry)
-                                mapped_ents = entry->sg_mapped_ents;
-                        put_hash_bucket(bucket, &flags);
+                        mapped_ents = get_nr_mapped_entries(dev, s);
                 }
 
                 check_unmap(&ref);
@@ -874,14 +1186,20 @@ void debug_dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
                                int nelems, int direction)
 {
         struct scatterlist *s;
-        int i;
+        int mapped_ents = 0, i;
 
         if (unlikely(global_disable))
                 return;
 
         for_each_sg(sg, s, nelems, i) {
-                check_sync(dev, s->dma_address, s->dma_length, 0,
-                                direction, true);
+                if (!i)
+                        mapped_ents = get_nr_mapped_entries(dev, s);
+
+                if (i >= mapped_ents)
+                        break;
+
+                check_sync(dev, sg_dma_address(s), sg_dma_len(s), 0,
+                           direction, true);
         }
 }
 EXPORT_SYMBOL(debug_dma_sync_sg_for_cpu);
@@ -890,15 +1208,39 @@ void debug_dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
                                   int nelems, int direction)
 {
         struct scatterlist *s;
-        int i;
+        int mapped_ents = 0, i;
 
         if (unlikely(global_disable))
                 return;
 
         for_each_sg(sg, s, nelems, i) {
-                check_sync(dev, s->dma_address, s->dma_length, 0,
-                                direction, false);
+                if (!i)
+                        mapped_ents = get_nr_mapped_entries(dev, s);
+
+                if (i >= mapped_ents)
+                        break;
+
+                check_sync(dev, sg_dma_address(s), sg_dma_len(s), 0,
+                           direction, false);
         }
 }
 EXPORT_SYMBOL(debug_dma_sync_sg_for_device);
 
+static int __init dma_debug_driver_setup(char *str)
+{
+        int i;
+
+        for (i = 0; i < NAME_MAX_LEN - 1; ++i, ++str) {
+                current_driver_name[i] = *str;
+                if (*str == 0)
+                        break;
+        }
+
+        if (current_driver_name[0])
+                pr_info("DMA-API: enable driver filter for driver [%s]\n",
+                        current_driver_name);
+
+
+        return 1;
+}
+__setup("dma_debug_driver=", dma_debug_driver_setup);
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index 2b0b5a7d2ced..bffe6d7ef9d9 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -60,8 +60,8 @@ enum dma_sync_target {
 int swiotlb_force;
 
 /*
- * Used to do a quick range check in swiotlb_unmap_single and
- * swiotlb_sync_single_*, to see if the memory was in fact allocated by this
+ * Used to do a quick range check in unmap_single and
+ * sync_single_*, to see if the memory was in fact allocated by this
  * API.
  */
 static char *io_tlb_start, *io_tlb_end;
@@ -129,7 +129,7 @@ dma_addr_t __weak swiotlb_phys_to_bus(struct device *hwdev, phys_addr_t paddr)
         return paddr;
 }
 
-phys_addr_t __weak swiotlb_bus_to_phys(dma_addr_t baddr)
+phys_addr_t __weak swiotlb_bus_to_phys(struct device *hwdev, dma_addr_t baddr)
 {
         return baddr;
 }
@@ -140,9 +140,15 @@ static dma_addr_t swiotlb_virt_to_bus(struct device *hwdev,
         return swiotlb_phys_to_bus(hwdev, virt_to_phys(address));
 }
 
-static void *swiotlb_bus_to_virt(dma_addr_t address)
+void * __weak swiotlb_bus_to_virt(struct device *hwdev, dma_addr_t address)
 {
-        return phys_to_virt(swiotlb_bus_to_phys(address));
+        return phys_to_virt(swiotlb_bus_to_phys(hwdev, address));
+}
+
+int __weak swiotlb_arch_address_needs_mapping(struct device *hwdev,
+                                               dma_addr_t addr, size_t size)
+{
+        return !is_buffer_dma_capable(dma_get_mask(hwdev), addr, size);
 }
 
 int __weak swiotlb_arch_range_needs_mapping(phys_addr_t paddr, size_t size)
@@ -309,10 +315,10 @@ cleanup1:
         return -ENOMEM;
 }
 
-static int
+static inline int
 address_needs_mapping(struct device *hwdev, dma_addr_t addr, size_t size)
 {
-        return !is_buffer_dma_capable(dma_get_mask(hwdev), addr, size);
+        return swiotlb_arch_address_needs_mapping(hwdev, addr, size);
 }
 
 static inline int range_needs_mapping(phys_addr_t paddr, size_t size)
@@ -341,7 +347,7 @@ static void swiotlb_bounce(phys_addr_t phys, char *dma_addr, size_t size,
                 unsigned long flags;
 
                 while (size) {
-                        sz = min(PAGE_SIZE - offset, size);
+                        sz = min_t(size_t, PAGE_SIZE - offset, size);
 
                         local_irq_save(flags);
                         buffer = kmap_atomic(pfn_to_page(pfn),
@@ -476,7 +482,7 @@ found:
  * dma_addr is the kernel virtual address of the bounce buffer to unmap.
  */
 static void
-unmap_single(struct device *hwdev, char *dma_addr, size_t size, int dir)
+do_unmap_single(struct device *hwdev, char *dma_addr, size_t size, int dir)
 {
         unsigned long flags;
         int i, count, nslots = ALIGN(size, 1 << IO_TLB_SHIFT) >> IO_TLB_SHIFT;
@@ -560,7 +566,6 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                                    size)) {
                 /*
                  * The allocated memory isn't reachable by the device.
-                 * Fall back on swiotlb_map_single().
                  */
                 free_pages((unsigned long) ret, order);
                 ret = NULL;
@@ -568,9 +573,8 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
         if (!ret) {
                 /*
                  * We are either out of memory or the device can't DMA
-                 * to GFP_DMA memory; fall back on
-                 * swiotlb_map_single(), which will grab memory from
-                 * the lowest available address range.
+                 * to GFP_DMA memory; fall back on map_single(), which
+                 * will grab memory from the lowest available address range.
                  */
                 ret = map_single(hwdev, 0, size, DMA_FROM_DEVICE);
                 if (!ret)
@@ -587,7 +591,7 @@ swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                        (unsigned long long)dev_addr);
 
                 /* DMA_TO_DEVICE to avoid memcpy in unmap_single */
-                unmap_single(hwdev, ret, size, DMA_TO_DEVICE);
+                do_unmap_single(hwdev, ret, size, DMA_TO_DEVICE);
                 return NULL;
         }
         *dma_handle = dev_addr;
@@ -604,7 +608,7 @@ swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
                 free_pages((unsigned long) vaddr, get_order(size));
         else
                 /* DMA_TO_DEVICE to avoid memcpy in unmap_single */
-                unmap_single(hwdev, vaddr, size, DMA_TO_DEVICE);
+                do_unmap_single(hwdev, vaddr, size, DMA_TO_DEVICE);
 }
 EXPORT_SYMBOL(swiotlb_free_coherent);
 
@@ -634,7 +638,7 @@ swiotlb_full(struct device *dev, size_t size, int dir, int do_panic)
  * physical address to use is returned.
  *
  * Once the device is given the dma address, the device owns this memory until
- * either swiotlb_unmap_single or swiotlb_dma_sync_single is performed.
+ * either swiotlb_unmap_page or swiotlb_dma_sync_single is performed.
  */
 dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
                             unsigned long offset, size_t size,
@@ -642,18 +646,17 @@ dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
                             struct dma_attrs *attrs)
 {
         phys_addr_t phys = page_to_phys(page) + offset;
-        void *ptr = page_address(page) + offset;
         dma_addr_t dev_addr = swiotlb_phys_to_bus(dev, phys);
         void *map;
 
         BUG_ON(dir == DMA_NONE);
         /*
-         * If the pointer passed in happens to be in the device's DMA window,
+         * If the address happens to be in the device's DMA window,
          * we can safely return the device addr and not worry about bounce
          * buffering it.
          */
         if (!address_needs_mapping(dev, dev_addr, size) &&
-            !range_needs_mapping(virt_to_phys(ptr), size))
+            !range_needs_mapping(phys, size))
                 return dev_addr;
 
         /*
@@ -679,23 +682,35 @@ EXPORT_SYMBOL_GPL(swiotlb_map_page);
 
 /*
  * Unmap a single streaming mode DMA translation.  The dma_addr and size must
- * match what was provided for in a previous swiotlb_map_single call.  All
+ * match what was provided for in a previous swiotlb_map_page call.  All
  * other usages are undefined.
  *
  * After this call, reads by the cpu to the buffer are guaranteed to see
  * whatever the device wrote there.
  */
+static void unmap_single(struct device *hwdev, dma_addr_t dev_addr,
+                         size_t size, int dir)
+{
+        char *dma_addr = swiotlb_bus_to_virt(hwdev, dev_addr);
+
+        BUG_ON(dir == DMA_NONE);
+
+        if (is_swiotlb_buffer(dma_addr)) {
+                do_unmap_single(hwdev, dma_addr, size, dir);
+                return;
+        }
+
+        if (dir != DMA_FROM_DEVICE)
+                return;
+
+        dma_mark_clean(dma_addr, size);
+}
+
 void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
                         size_t size, enum dma_data_direction dir,
                         struct dma_attrs *attrs)
 {
-        char *dma_addr = swiotlb_bus_to_virt(dev_addr);
-
-        BUG_ON(dir == DMA_NONE);
-        if (is_swiotlb_buffer(dma_addr))
-                unmap_single(hwdev, dma_addr, size, dir);
-        else if (dir == DMA_FROM_DEVICE)
-                dma_mark_clean(dma_addr, size);
+        unmap_single(hwdev, dev_addr, size, dir);
 }
 EXPORT_SYMBOL_GPL(swiotlb_unmap_page);
 
@@ -703,7 +718,7 @@ EXPORT_SYMBOL_GPL(swiotlb_unmap_page);
  * Make physical memory consistent for a single streaming mode DMA translation
  * after a transfer.
  *
- * If you perform a swiotlb_map_single() but wish to interrogate the buffer
+ * If you perform a swiotlb_map_page() but wish to interrogate the buffer
  * using the cpu, yet do not wish to teardown the dma mapping, you must
  * call this function before doing so.  At the next point you give the dma
  * address back to the card, you must first perform a
@@ -713,13 +728,19 @@ static void
 swiotlb_sync_single(struct device *hwdev, dma_addr_t dev_addr,
                     size_t size, int dir, int target)
 {
-        char *dma_addr = swiotlb_bus_to_virt(dev_addr);
+        char *dma_addr = swiotlb_bus_to_virt(hwdev, dev_addr);
 
         BUG_ON(dir == DMA_NONE);
-        if (is_swiotlb_buffer(dma_addr))
+
+        if (is_swiotlb_buffer(dma_addr)) {
                 sync_single(hwdev, dma_addr, size, dir, target);
-        else if (dir == DMA_FROM_DEVICE)
-                dma_mark_clean(dma_addr, size);
+                return;
+        }
+
+        if (dir != DMA_FROM_DEVICE)
+                return;
+
+        dma_mark_clean(dma_addr, size);
 }
 
 void
@@ -746,13 +767,7 @@ swiotlb_sync_single_range(struct device *hwdev, dma_addr_t dev_addr,
                           unsigned long offset, size_t size,
                           int dir, int target)
 {
-        char *dma_addr = swiotlb_bus_to_virt(dev_addr) + offset;
-
-        BUG_ON(dir == DMA_NONE);
-        if (is_swiotlb_buffer(dma_addr))
-                sync_single(hwdev, dma_addr, size, dir, target);
-        else if (dir == DMA_FROM_DEVICE)
-                dma_mark_clean(dma_addr, size);
+        swiotlb_sync_single(hwdev, dev_addr + offset, size, dir, target);
 }
 
 void
@@ -777,7 +792,7 @@ EXPORT_SYMBOL_GPL(swiotlb_sync_single_range_for_device);
 
 /*
  * Map a set of buffers described by scatterlist in streaming mode for DMA.
- * This is the scatter-gather version of the above swiotlb_map_single
+ * This is the scatter-gather version of the above swiotlb_map_page
  * interface.  Here the scatter gather list elements are each tagged with the
  * appropriate dma address and length.  They are obtained via
  * sg_dma_{address,length}(SG).
@@ -788,7 +803,7 @@ EXPORT_SYMBOL_GPL(swiotlb_sync_single_range_for_device);
  *       The routine returns the number of addr/length pairs actually
  *       used, at most nents.
  *
- * Device ownership issues as mentioned above for swiotlb_map_single are the
+ * Device ownership issues as mentioned above for swiotlb_map_page are the
  * same here.
  */
 int
@@ -836,7 +851,7 @@ EXPORT_SYMBOL(swiotlb_map_sg);
 
 /*
  * Unmap a set of streaming mode DMA translations.  Again, cpu read rules
- * concerning calls here are the same as for swiotlb_unmap_single() above.
+ * concerning calls here are the same as for swiotlb_unmap_page() above.
  */
 void
 swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
@@ -847,13 +862,9 @@ swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
 
         BUG_ON(dir == DMA_NONE);
 
-        for_each_sg(sgl, sg, nelems, i) {
-                if (sg->dma_address != swiotlb_phys_to_bus(hwdev, sg_phys(sg)))
-                        unmap_single(hwdev, swiotlb_bus_to_virt(sg->dma_address),
-                                     sg->dma_length, dir);
-                else if (dir == DMA_FROM_DEVICE)
-                        dma_mark_clean(swiotlb_bus_to_virt(sg->dma_address), sg->dma_length);
-        }
+        for_each_sg(sgl, sg, nelems, i)
+                unmap_single(hwdev, sg->dma_address, sg->dma_length, dir);
+
 }
 EXPORT_SYMBOL(swiotlb_unmap_sg_attrs);
 
@@ -879,15 +890,9 @@ swiotlb_sync_sg(struct device *hwdev, struct scatterlist *sgl,
         struct scatterlist *sg;
         int i;
 
-        BUG_ON(dir == DMA_NONE);
-
-        for_each_sg(sgl, sg, nelems, i) {
-                if (sg->dma_address != swiotlb_phys_to_bus(hwdev, sg_phys(sg)))
-                        sync_single(hwdev, swiotlb_bus_to_virt(sg->dma_address),
+        for_each_sg(sgl, sg, nelems, i)
+                swiotlb_sync_single(hwdev, sg->dma_address,
                                     sg->dma_length, dir, target);
-                else if (dir == DMA_FROM_DEVICE)
-                        dma_mark_clean(swiotlb_bus_to_virt(sg->dma_address), sg->dma_length);
-        }
 }
 
 void