Merge branch 'akpm' (patches from Andrew)

Merge even more updates from Andrew Morton:

 - dma-mapping API cleanup

 - a few cleanups and misc things

 - use jump labels in dynamic-debug

* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
  dynamic_debug: add jump label support
  jump_label: remove bug.h, atomic.h dependencies for HAVE_JUMP_LABEL
  arm: jump label may reference text in __exit
  tile: support static_key usage in non-module __exit sections
  sparc: support static_key usage in non-module __exit sections
  powerpc: add explicit #include <asm/asm-compat.h> for jump label
  drivers/media/dvb-frontends/cxd2841er.c: avoid misleading gcc warning
  MAINTAINERS: update email and list of Samsung HW driver maintainers
  block: remove BLK_DEV_DAX config option
  samples/kretprobe: fix the wrong type
  samples/kretprobe: convert the printk to pr_info/pr_err
  samples/jprobe: convert the printk to pr_info/pr_err
  samples/kprobe: convert the printk to pr_info/pr_err
  dma-mapping: use unsigned long for dma_attrs
  media: mtk-vcodec: remove unused dma_attrs
  include/linux/bitmap.h: cleanup
  tree-wide: replace config_enabled() with IS_ENABLED()
  drivers/fpga/Kconfig: fix build failure

177 files changed, 1040 insertions, 1029 deletions

diff --git a/Documentation/DMA-API.txt b/Documentation/DMA-API.txt
index 45ef3f279c3b..1d26eeb6b5f6 100644
--- a/Documentation/DMA-API.txt
+++ b/Documentation/DMA-API.txt
@@ -369,35 +369,32 @@ See also dma_map_single().
 dma_addr_t
 dma_map_single_attrs(struct device *dev, void *cpu_addr, size_t size,
                      enum dma_data_direction dir,
-                     struct dma_attrs *attrs)
+                     unsigned long attrs)
 
 void
 dma_unmap_single_attrs(struct device *dev, dma_addr_t dma_addr,
                        size_t size, enum dma_data_direction dir,
-                       struct dma_attrs *attrs)
+                       unsigned long attrs)
 
 int
 dma_map_sg_attrs(struct device *dev, struct scatterlist *sgl,
                  int nents, enum dma_data_direction dir,
-                 struct dma_attrs *attrs)
+                 unsigned long attrs)
 
 void
 dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sgl,
                    int nents, enum dma_data_direction dir,
-                   struct dma_attrs *attrs)
+                   unsigned long attrs)
 
 The four functions above are just like the counterpart functions
 without the _attrs suffixes, except that they pass an optional
-struct dma_attrs*.
-
-struct dma_attrs encapsulates a set of "DMA attributes". For the
-definition of struct dma_attrs see linux/dma-attrs.h.
+dma_attrs.
 
 The interpretation of DMA attributes is architecture-specific, and
 each attribute should be documented in Documentation/DMA-attributes.txt.
 
-If struct dma_attrs* is NULL, the semantics of each of these
-functions is identical to those of the corresponding function
+If dma_attrs are 0, the semantics of each of these functions
+is identical to those of the corresponding function
 without the _attrs suffix. As a result dma_map_single_attrs()
 can generally replace dma_map_single(), etc.
 
@@ -405,15 +402,15 @@ As an example of the use of the *_attrs functions, here's how
 you could pass an attribute DMA_ATTR_FOO when mapping memory
 for DMA:
 
-#include <linux/dma-attrs.h>
-/* DMA_ATTR_FOO should be defined in linux/dma-attrs.h and
+#include <linux/dma-mapping.h>
+/* DMA_ATTR_FOO should be defined in linux/dma-mapping.h and
  * documented in Documentation/DMA-attributes.txt */
 ...
 
-        DEFINE_DMA_ATTRS(attrs);
-        dma_set_attr(DMA_ATTR_FOO, &attrs);
+        unsigned long attr;
+        attr |= DMA_ATTR_FOO;
         ....
-        n = dma_map_sg_attrs(dev, sg, nents, DMA_TO_DEVICE, &attr);
+        n = dma_map_sg_attrs(dev, sg, nents, DMA_TO_DEVICE, attr);
         ....
 
 Architectures that care about DMA_ATTR_FOO would check for its
@@ -422,12 +419,10 @@ routines, e.g.:
 
 void whizco_dma_map_sg_attrs(struct device *dev, dma_addr_t dma_addr,
                              size_t size, enum dma_data_direction dir,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
         ....
-        int foo =  dma_get_attr(DMA_ATTR_FOO, attrs);
-        ....
-        if (foo)
+        if (attrs & DMA_ATTR_FOO)
                 /* twizzle the frobnozzle */
         ....
 
diff --git a/Documentation/DMA-attributes.txt b/Documentation/DMA-attributes.txt
index e8cf9cf873b3..2d455a5cf671 100644
--- a/Documentation/DMA-attributes.txt
+++ b/Documentation/DMA-attributes.txt
@@ -2,7 +2,7 @@
                         ==============
 
 This document describes the semantics of the DMA attributes that are
-defined in linux/dma-attrs.h.
+defined in linux/dma-mapping.h.
 
 DMA_ATTR_WRITE_BARRIER
 ----------------------
diff --git a/MAINTAINERS b/MAINTAINERS
index 429fc61bee81..bafc8043d4f0 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1648,7 +1648,8 @@ F:	arch/arm/mach-s5pv210/
 
 ARM/SAMSUNG S5P SERIES 2D GRAPHICS ACCELERATION (G2D) SUPPORT
 M:      Kyungmin Park <kyungmin.park@samsung.com>
-M:      Kamil Debski <k.debski@samsung.com>
+M:      Kamil Debski <kamil@wypas.org>
+M:      Andrzej Hajda <a.hajda@samsung.com>
 L:      linux-arm-kernel@lists.infradead.org
 L:      linux-media@vger.kernel.org
 S:      Maintained
@@ -1656,8 +1657,9 @@ F:	drivers/media/platform/s5p-g2d/
 
 ARM/SAMSUNG S5P SERIES Multi Format Codec (MFC) SUPPORT
 M:      Kyungmin Park <kyungmin.park@samsung.com>
-M:      Kamil Debski <k.debski@samsung.com>
+M:      Kamil Debski <kamil@wypas.org>
 M:      Jeongtae Park <jtp.park@samsung.com>
+M:      Andrzej Hajda <a.hajda@samsung.com>
 L:      linux-arm-kernel@lists.infradead.org
 L:      linux-media@vger.kernel.org
 S:      Maintained
@@ -9470,7 +9472,8 @@ S:	Odd Fixes
 F:      drivers/media/usb/pwc/*
 
 PWM FAN DRIVER
-M:      Kamil Debski <k.debski@samsung.com>
+M:      Kamil Debski <kamil@wypas.org>
+M:      Lukasz Majewski <l.majewski@samsung.com>
 L:      linux-hwmon@vger.kernel.org
 S:      Supported
 F:      Documentation/devicetree/bindings/hwmon/pwm-fan.txt
@@ -10218,7 +10221,8 @@ T:	git https://github.com/lmajewski/linux-samsung-thermal.git
 F:      drivers/thermal/samsung/
 
 SAMSUNG USB2 PHY DRIVER
-M:      Kamil Debski <k.debski@samsung.com>
+M:      Kamil Debski <kamil@wypas.org>
+M:      Sylwester Nawrocki <s.nawrocki@samsung.com>
 L:      linux-kernel@vger.kernel.org
 S:      Supported
 F:      Documentation/devicetree/bindings/phy/samsung-phy.txt
diff --git a/arch/alpha/include/asm/dma-mapping.h b/arch/alpha/include/asm/dma-mapping.h
index 3c3451f58ff4..c63b6ac19ee5 100644
--- a/arch/alpha/include/asm/dma-mapping.h
+++ b/arch/alpha/include/asm/dma-mapping.h
@@ -1,8 +1,6 @@
 #ifndef _ALPHA_DMA_MAPPING_H
 #define _ALPHA_DMA_MAPPING_H
 
-#include <linux/dma-attrs.h>
-
 extern struct dma_map_ops *dma_ops;
 
 static inline struct dma_map_ops *get_dma_ops(struct device *dev)
diff --git a/arch/alpha/kernel/pci-noop.c b/arch/alpha/kernel/pci-noop.c
index 8e735b5e56bd..bb152e21e5ae 100644
--- a/arch/alpha/kernel/pci-noop.c
+++ b/arch/alpha/kernel/pci-noop.c
@@ -109,7 +109,7 @@ sys_pciconfig_write(unsigned long bus, unsigned long dfn,
 
 static void *alpha_noop_alloc_coherent(struct device *dev, size_t size,
                                        dma_addr_t *dma_handle, gfp_t gfp,
-                                       struct dma_attrs *attrs)
+                                       unsigned long attrs)
 {
         void *ret;
 
diff --git a/arch/alpha/kernel/pci_iommu.c b/arch/alpha/kernel/pci_iommu.c
index 8969bf2dfe3a..451fc9cdd323 100644
--- a/arch/alpha/kernel/pci_iommu.c
+++ b/arch/alpha/kernel/pci_iommu.c
@@ -349,7 +349,7 @@ static struct pci_dev *alpha_gendev_to_pci(struct device *dev)
 static dma_addr_t alpha_pci_map_page(struct device *dev, struct page *page,
                                      unsigned long offset, size_t size,
                                      enum dma_data_direction dir,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
         int dac_allowed;
@@ -369,7 +369,7 @@ static dma_addr_t alpha_pci_map_page(struct device *dev, struct page *page,
 
 static void alpha_pci_unmap_page(struct device *dev, dma_addr_t dma_addr,
                                  size_t size, enum dma_data_direction dir,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         unsigned long flags;
         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
@@ -433,7 +433,7 @@ static void alpha_pci_unmap_page(struct device *dev, dma_addr_t dma_addr,
 
 static void *alpha_pci_alloc_coherent(struct device *dev, size_t size,
                                       dma_addr_t *dma_addrp, gfp_t gfp,
-                                      struct dma_attrs *attrs)
+                                      unsigned long attrs)
 {
         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
         void *cpu_addr;
@@ -478,7 +478,7 @@ try_again:
 
 static void alpha_pci_free_coherent(struct device *dev, size_t size,
                                     void *cpu_addr, dma_addr_t dma_addr,
-                                    struct dma_attrs *attrs)
+                                    unsigned long attrs)
 {
         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
         pci_unmap_single(pdev, dma_addr, size, PCI_DMA_BIDIRECTIONAL);
@@ -651,7 +651,7 @@ sg_fill(struct device *dev, struct scatterlist *leader, struct scatterlist *end,
 
 static int alpha_pci_map_sg(struct device *dev, struct scatterlist *sg,
                             int nents, enum dma_data_direction dir,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
         struct scatterlist *start, *end, *out;
@@ -729,7 +729,7 @@ static int alpha_pci_map_sg(struct device *dev, struct scatterlist *sg,
 
 static void alpha_pci_unmap_sg(struct device *dev, struct scatterlist *sg,
                                int nents, enum dma_data_direction dir,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
         unsigned long flags;
diff --git a/arch/arc/mm/dma.c b/arch/arc/mm/dma.c
index ab74b5d9186c..20afc65e22dc 100644
--- a/arch/arc/mm/dma.c
+++ b/arch/arc/mm/dma.c
@@ -22,7 +22,7 @@
 
 
 static void *arc_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t gfp, struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         unsigned long order = get_order(size);
         struct page *page;
@@ -46,7 +46,7 @@ static void *arc_dma_alloc(struct device *dev, size_t size,
          *   (vs. always going to memory - thus are faster)
          */
         if ((is_isa_arcv2() && ioc_exists) ||
-            dma_get_attr(DMA_ATTR_NON_CONSISTENT, attrs))
+            (attrs & DMA_ATTR_NON_CONSISTENT))
                 need_coh = 0;
 
         /*
@@ -90,13 +90,13 @@ static void *arc_dma_alloc(struct device *dev, size_t size,
 }
 
 static void arc_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         phys_addr_t paddr = plat_dma_to_phys(dev, dma_handle);
         struct page *page = virt_to_page(paddr);
         int is_non_coh = 1;
 
-        is_non_coh = dma_get_attr(DMA_ATTR_NON_CONSISTENT, attrs) ||
+        is_non_coh = (attrs & DMA_ATTR_NON_CONSISTENT) ||
                         (is_isa_arcv2() && ioc_exists);
 
         if (PageHighMem(page) || !is_non_coh)
@@ -130,7 +130,7 @@ static void _dma_cache_sync(phys_addr_t paddr, size_t size,
 
 static dma_addr_t arc_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         phys_addr_t paddr = page_to_phys(page) + offset;
         _dma_cache_sync(paddr, size, dir);
@@ -138,7 +138,7 @@ static dma_addr_t arc_dma_map_page(struct device *dev, struct page *page,
 }
 
 static int arc_dma_map_sg(struct device *dev, struct scatterlist *sg,
-           int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
+           int nents, enum dma_data_direction dir, unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
diff --git a/arch/arm/common/dmabounce.c b/arch/arm/common/dmabounce.c
index 1143c4d5c567..301281645d08 100644
--- a/arch/arm/common/dmabounce.c
+++ b/arch/arm/common/dmabounce.c
@@ -310,7 +310,7 @@ static inline void unmap_single(struct device *dev, struct safe_buffer *buf,
  */
 static dma_addr_t dmabounce_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         dma_addr_t dma_addr;
         int ret;
@@ -344,7 +344,7 @@ static dma_addr_t dmabounce_map_page(struct device *dev, struct page *page,
  * should be)
  */
 static void dmabounce_unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size,
-                enum dma_data_direction dir, struct dma_attrs *attrs)
+                enum dma_data_direction dir, unsigned long attrs)
 {
         struct safe_buffer *buf;
 
diff --git a/arch/arm/include/asm/dma-mapping.h b/arch/arm/include/asm/dma-mapping.h
index a83570f10124..d009f7911ffc 100644
--- a/arch/arm/include/asm/dma-mapping.h
+++ b/arch/arm/include/asm/dma-mapping.h
@@ -5,7 +5,6 @@
 
 #include <linux/mm_types.h>
 #include <linux/scatterlist.h>
-#include <linux/dma-attrs.h>
 #include <linux/dma-debug.h>
 
 #include <asm/memory.h>
@@ -174,7 +173,7 @@ static inline void dma_mark_clean(void *addr, size_t size) { }
  * to be the device-viewed address.
  */
 extern void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
-                           gfp_t gfp, struct dma_attrs *attrs);
+                           gfp_t gfp, unsigned long attrs);
 
 /**
  * arm_dma_free - free memory allocated by arm_dma_alloc
@@ -191,7 +190,7 @@ extern void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
  * during and after this call executing are illegal.
  */
 extern void arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
-                         dma_addr_t handle, struct dma_attrs *attrs);
+                         dma_addr_t handle, unsigned long attrs);
 
 /**
  * arm_dma_mmap - map a coherent DMA allocation into user space
@@ -208,7 +207,7 @@ extern void arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
  */
 extern int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,
                         void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                        struct dma_attrs *attrs);
+                        unsigned long attrs);
 
 /*
  * This can be called during early boot to increase the size of the atomic
@@ -262,16 +261,16 @@ extern void dmabounce_unregister_dev(struct device *);
  * The scatter list versions of the above methods.
  */
 extern int arm_dma_map_sg(struct device *, struct scatterlist *, int,
-                enum dma_data_direction, struct dma_attrs *attrs);
+                enum dma_data_direction, unsigned long attrs);
 extern void arm_dma_unmap_sg(struct device *, struct scatterlist *, int,
-                enum dma_data_direction, struct dma_attrs *attrs);
+                enum dma_data_direction, unsigned long attrs);
 extern void arm_dma_sync_sg_for_cpu(struct device *, struct scatterlist *, int,
                 enum dma_data_direction);
 extern void arm_dma_sync_sg_for_device(struct device *, struct scatterlist *, int,
                 enum dma_data_direction);
 extern int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt,
                 void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                struct dma_attrs *attrs);
+                unsigned long attrs);
 
 #endif /* __KERNEL__ */
 #endif
diff --git a/arch/arm/include/asm/xen/page-coherent.h b/arch/arm/include/asm/xen/page-coherent.h
index 9408a994cc91..95ce6ac3a971 100644
--- a/arch/arm/include/asm/xen/page-coherent.h
+++ b/arch/arm/include/asm/xen/page-coherent.h
@@ -2,15 +2,14 @@
 #define _ASM_ARM_XEN_PAGE_COHERENT_H
 
 #include <asm/page.h>
-#include <linux/dma-attrs.h>
 #include <linux/dma-mapping.h>
 
 void __xen_dma_map_page(struct device *hwdev, struct page *page,
              dma_addr_t dev_addr, unsigned long offset, size_t size,
-             enum dma_data_direction dir, struct dma_attrs *attrs);
+             enum dma_data_direction dir, unsigned long attrs);
 void __xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle,
                 size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs);
+                unsigned long attrs);
 void __xen_dma_sync_single_for_cpu(struct device *hwdev,
                 dma_addr_t handle, size_t size, enum dma_data_direction dir);
 
@@ -18,22 +17,20 @@ void __xen_dma_sync_single_for_device(struct device *hwdev,
                 dma_addr_t handle, size_t size, enum dma_data_direction dir);
 
 static inline void *xen_alloc_coherent_pages(struct device *hwdev, size_t size,
-                dma_addr_t *dma_handle, gfp_t flags,
-                struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t flags, unsigned long attrs)
 {
         return __generic_dma_ops(hwdev)->alloc(hwdev, size, dma_handle, flags, attrs);
 }
 
 static inline void xen_free_coherent_pages(struct device *hwdev, size_t size,
-                void *cpu_addr, dma_addr_t dma_handle,
-                struct dma_attrs *attrs)
+                void *cpu_addr, dma_addr_t dma_handle, unsigned long attrs)
 {
         __generic_dma_ops(hwdev)->free(hwdev, size, cpu_addr, dma_handle, attrs);
 }
 
 static inline void xen_dma_map_page(struct device *hwdev, struct page *page,
              dma_addr_t dev_addr, unsigned long offset, size_t size,
-             enum dma_data_direction dir, struct dma_attrs *attrs)
+             enum dma_data_direction dir, unsigned long attrs)
 {
         unsigned long page_pfn = page_to_xen_pfn(page);
         unsigned long dev_pfn = XEN_PFN_DOWN(dev_addr);
@@ -58,8 +55,7 @@ static inline void xen_dma_map_page(struct device *hwdev, struct page *page,
 }
 
 static inline void xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle,
-                size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                size_t size, enum dma_data_direction dir, unsigned long attrs)
 {
         unsigned long pfn = PFN_DOWN(handle);
         /*
diff --git a/arch/arm/kernel/vmlinux.lds.S b/arch/arm/kernel/vmlinux.lds.S
index 99420fc1f066..d24e5dd2aa7a 100644
--- a/arch/arm/kernel/vmlinux.lds.S
+++ b/arch/arm/kernel/vmlinux.lds.S
@@ -44,7 +44,7 @@
 #endif
 
 #if (defined(CONFIG_SMP_ON_UP) && !defined(CONFIG_DEBUG_SPINLOCK)) || \
-        defined(CONFIG_GENERIC_BUG)
+        defined(CONFIG_GENERIC_BUG) || defined(CONFIG_JUMP_LABEL)
 #define ARM_EXIT_KEEP(x)        x
 #define ARM_EXIT_DISCARD(x)
 #else
diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c
index b7eed75960fe..c6834c0cfd1c 100644
--- a/arch/arm/mm/dma-mapping.c
+++ b/arch/arm/mm/dma-mapping.c
@@ -128,16 +128,16 @@ static void __dma_page_dev_to_cpu(struct page *, unsigned long,
  */
 static dma_addr_t arm_dma_map_page(struct device *dev, struct page *page,
              unsigned long offset, size_t size, enum dma_data_direction dir,
-             struct dma_attrs *attrs)
+             unsigned long attrs)
 {
-        if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+        if ((attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                 __dma_page_cpu_to_dev(page, offset, size, dir);
         return pfn_to_dma(dev, page_to_pfn(page)) + offset;
 }
 
 static dma_addr_t arm_coherent_dma_map_page(struct device *dev, struct page *page,
              unsigned long offset, size_t size, enum dma_data_direction dir,
-             struct dma_attrs *attrs)
+             unsigned long attrs)
 {
         return pfn_to_dma(dev, page_to_pfn(page)) + offset;
 }
@@ -157,10 +157,9 @@ static dma_addr_t arm_coherent_dma_map_page(struct device *dev, struct page *pag
  * whatever the device wrote there.
  */
 static void arm_dma_unmap_page(struct device *dev, dma_addr_t handle,
-                size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                size_t size, enum dma_data_direction dir, unsigned long attrs)
 {
-        if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+        if ((attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                 __dma_page_dev_to_cpu(pfn_to_page(dma_to_pfn(dev, handle)),
                                       handle & ~PAGE_MASK, size, dir);
 }
@@ -198,12 +197,12 @@ struct dma_map_ops arm_dma_ops = {
 EXPORT_SYMBOL(arm_dma_ops);
 
 static void *arm_coherent_dma_alloc(struct device *dev, size_t size,
-        dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs);
+        dma_addr_t *handle, gfp_t gfp, unsigned long attrs);
 static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr,
-                                  dma_addr_t handle, struct dma_attrs *attrs);
+                                  dma_addr_t handle, unsigned long attrs);
 static int arm_coherent_dma_mmap(struct device *dev, struct vm_area_struct *vma,
                  void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                 struct dma_attrs *attrs);
+                 unsigned long attrs);
 
 struct dma_map_ops arm_coherent_dma_ops = {
         .alloc                  = arm_coherent_dma_alloc,
@@ -639,11 +638,11 @@ static void __free_from_contiguous(struct device *dev, struct page *page,
         dma_release_from_contiguous(dev, page, size >> PAGE_SHIFT);
 }
 
-static inline pgprot_t __get_dma_pgprot(struct dma_attrs *attrs, pgprot_t prot)
+static inline pgprot_t __get_dma_pgprot(unsigned long attrs, pgprot_t prot)
 {
-        prot = dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs) ?
-                            pgprot_writecombine(prot) :
-                            pgprot_dmacoherent(prot);
+        prot = (attrs & DMA_ATTR_WRITE_COMBINE) ?
+                        pgprot_writecombine(prot) :
+                        pgprot_dmacoherent(prot);
         return prot;
 }
 
@@ -751,7 +750,7 @@ static struct arm_dma_allocator remap_allocator = {
 
 static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
                          gfp_t gfp, pgprot_t prot, bool is_coherent,
-                         struct dma_attrs *attrs, const void *caller)
+                         unsigned long attrs, const void *caller)
 {
         u64 mask = get_coherent_dma_mask(dev);
         struct page *page = NULL;
@@ -764,7 +763,7 @@ static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
                 .gfp = gfp,
                 .prot = prot,
                 .caller = caller,
-                .want_vaddr = !dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs),
+                .want_vaddr = ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0),
                 .coherent_flag = is_coherent ? COHERENT : NORMAL,
         };
 
@@ -834,7 +833,7 @@ static void *__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
  * virtual and bus address for that space.
  */
 void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
-                    gfp_t gfp, struct dma_attrs *attrs)
+                    gfp_t gfp, unsigned long attrs)
 {
         pgprot_t prot = __get_dma_pgprot(attrs, PAGE_KERNEL);
 
@@ -843,7 +842,7 @@ void *arm_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
 }
 
 static void *arm_coherent_dma_alloc(struct device *dev, size_t size,
-        dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs)
+        dma_addr_t *handle, gfp_t gfp, unsigned long attrs)
 {
         return __dma_alloc(dev, size, handle, gfp, PAGE_KERNEL, true,
                            attrs, __builtin_return_address(0));
@@ -851,7 +850,7 @@ static void *arm_coherent_dma_alloc(struct device *dev, size_t size,
 
 static int __arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,
                  void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                 struct dma_attrs *attrs)
+                 unsigned long attrs)
 {
         int ret = -ENXIO;
 #ifdef CONFIG_MMU
@@ -879,14 +878,14 @@ static int __arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,
  */
 static int arm_coherent_dma_mmap(struct device *dev, struct vm_area_struct *vma,
                  void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                 struct dma_attrs *attrs)
+                 unsigned long attrs)
 {
         return __arm_dma_mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
 }
 
 int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,
                  void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                 struct dma_attrs *attrs)
+                 unsigned long attrs)
 {
 #ifdef CONFIG_MMU
         vma->vm_page_prot = __get_dma_pgprot(attrs, vma->vm_page_prot);
@@ -898,7 +897,7 @@ int arm_dma_mmap(struct device *dev, struct vm_area_struct *vma,
  * Free a buffer as defined by the above mapping.
  */
 static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
-                           dma_addr_t handle, struct dma_attrs *attrs,
+                           dma_addr_t handle, unsigned long attrs,
                            bool is_coherent)
 {
         struct page *page = pfn_to_page(dma_to_pfn(dev, handle));
@@ -908,7 +907,7 @@ static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
                 .size = PAGE_ALIGN(size),
                 .cpu_addr = cpu_addr,
                 .page = page,
-                .want_vaddr = !dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs),
+                .want_vaddr = ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0),
         };
 
         buf = arm_dma_buffer_find(cpu_addr);
@@ -920,20 +919,20 @@ static void __arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
 }
 
 void arm_dma_free(struct device *dev, size_t size, void *cpu_addr,
-                  dma_addr_t handle, struct dma_attrs *attrs)
+                  dma_addr_t handle, unsigned long attrs)
 {
         __arm_dma_free(dev, size, cpu_addr, handle, attrs, false);
 }
 
 static void arm_coherent_dma_free(struct device *dev, size_t size, void *cpu_addr,
-                                  dma_addr_t handle, struct dma_attrs *attrs)
+                                  dma_addr_t handle, unsigned long attrs)
 {
         __arm_dma_free(dev, size, cpu_addr, handle, attrs, true);
 }
 
 int arm_dma_get_sgtable(struct device *dev, struct sg_table *sgt,
                  void *cpu_addr, dma_addr_t handle, size_t size,
-                 struct dma_attrs *attrs)
+                 unsigned long attrs)
 {
         struct page *page = pfn_to_page(dma_to_pfn(dev, handle));
         int ret;
@@ -1066,7 +1065,7 @@ static void __dma_page_dev_to_cpu(struct page *page, unsigned long off,
  * here.
  */
 int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
-                enum dma_data_direction dir, struct dma_attrs *attrs)
+                enum dma_data_direction dir, unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
         struct scatterlist *s;
@@ -1100,7 +1099,7 @@ int arm_dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
  * rules concerning calls here are the same as for dma_unmap_single().
  */
 void arm_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
-                enum dma_data_direction dir, struct dma_attrs *attrs)
+                enum dma_data_direction dir, unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
         struct scatterlist *s;
@@ -1273,7 +1272,7 @@ static inline void __free_iova(struct dma_iommu_mapping *mapping,
 static const int iommu_order_array[] = { 9, 8, 4, 0 };
 
 static struct page **__iommu_alloc_buffer(struct device *dev, size_t size,
-                                          gfp_t gfp, struct dma_attrs *attrs,
+                                          gfp_t gfp, unsigned long attrs,
                                           int coherent_flag)
 {
         struct page **pages;
@@ -1289,7 +1288,7 @@ static struct page **__iommu_alloc_buffer(struct device *dev, size_t size,
         if (!pages)
                 return NULL;
 
-        if (dma_get_attr(DMA_ATTR_FORCE_CONTIGUOUS, attrs))
+        if (attrs & DMA_ATTR_FORCE_CONTIGUOUS)
         {
                 unsigned long order = get_order(size);
                 struct page *page;
@@ -1307,7 +1306,7 @@ static struct page **__iommu_alloc_buffer(struct device *dev, size_t size,
         }
 
         /* Go straight to 4K chunks if caller says it's OK. */
-        if (dma_get_attr(DMA_ATTR_ALLOC_SINGLE_PAGES, attrs))
+        if (attrs & DMA_ATTR_ALLOC_SINGLE_PAGES)
                 order_idx = ARRAY_SIZE(iommu_order_array) - 1;
 
         /*
@@ -1363,12 +1362,12 @@ error:
 }
 
 static int __iommu_free_buffer(struct device *dev, struct page **pages,
-                               size_t size, struct dma_attrs *attrs)
+                               size_t size, unsigned long attrs)
 {
         int count = size >> PAGE_SHIFT;
         int i;
 
-        if (dma_get_attr(DMA_ATTR_FORCE_CONTIGUOUS, attrs)) {
+        if (attrs & DMA_ATTR_FORCE_CONTIGUOUS) {
                 dma_release_from_contiguous(dev, pages[0], count);
         } else {
                 for (i = 0; i < count; i++)
@@ -1460,14 +1459,14 @@ static struct page **__atomic_get_pages(void *addr)
         return (struct page **)page;
 }
 
-static struct page **__iommu_get_pages(void *cpu_addr, struct dma_attrs *attrs)
+static struct page **__iommu_get_pages(void *cpu_addr, unsigned long attrs)
 {
         struct vm_struct *area;
 
         if (__in_atomic_pool(cpu_addr, PAGE_SIZE))
                 return __atomic_get_pages(cpu_addr);
 
-        if (dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs))
+        if (attrs & DMA_ATTR_NO_KERNEL_MAPPING)
                 return cpu_addr;
 
         area = find_vm_area(cpu_addr);
@@ -1511,7 +1510,7 @@ static void __iommu_free_atomic(struct device *dev, void *cpu_addr,
 }
 
 static void *__arm_iommu_alloc_attrs(struct device *dev, size_t size,
-            dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs,
+            dma_addr_t *handle, gfp_t gfp, unsigned long attrs,
             int coherent_flag)
 {
         pgprot_t prot = __get_dma_pgprot(attrs, PAGE_KERNEL);
@@ -1542,7 +1541,7 @@ static void *__arm_iommu_alloc_attrs(struct device *dev, size_t size,
         if (*handle == DMA_ERROR_CODE)
                 goto err_buffer;
 
-        if (dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs))
+        if (attrs & DMA_ATTR_NO_KERNEL_MAPPING)
                 return pages;
 
         addr = __iommu_alloc_remap(pages, size, gfp, prot,
@@ -1560,20 +1559,20 @@ err_buffer:
 }
 
 static void *arm_iommu_alloc_attrs(struct device *dev, size_t size,
-                    dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs)
+            dma_addr_t *handle, gfp_t gfp, unsigned long attrs)
 {
         return __arm_iommu_alloc_attrs(dev, size, handle, gfp, attrs, NORMAL);
 }
 
 static void *arm_coherent_iommu_alloc_attrs(struct device *dev, size_t size,
-                    dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs)
+                    dma_addr_t *handle, gfp_t gfp, unsigned long attrs)
 {
         return __arm_iommu_alloc_attrs(dev, size, handle, gfp, attrs, COHERENT);
 }
 
 static int __arm_iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
                     void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                    struct dma_attrs *attrs)
+                    unsigned long attrs)
 {
         unsigned long uaddr = vma->vm_start;
         unsigned long usize = vma->vm_end - vma->vm_start;
@@ -1603,7 +1602,7 @@ static int __arm_iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma
 }
 static int arm_iommu_mmap_attrs(struct device *dev,
                 struct vm_area_struct *vma, void *cpu_addr,
-                dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
+                dma_addr_t dma_addr, size_t size, unsigned long attrs)
 {
         vma->vm_page_prot = __get_dma_pgprot(attrs, vma->vm_page_prot);
 
@@ -1612,7 +1611,7 @@ static int arm_iommu_mmap_attrs(struct device *dev,
 
 static int arm_coherent_iommu_mmap_attrs(struct device *dev,
                 struct vm_area_struct *vma, void *cpu_addr,
-                dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
+                dma_addr_t dma_addr, size_t size, unsigned long attrs)
 {
         return __arm_iommu_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, attrs);
 }
@@ -1622,7 +1621,7 @@ static int arm_coherent_iommu_mmap_attrs(struct device *dev,
  * Must not be called with IRQs disabled.
  */
 void __arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr,
-        dma_addr_t handle, struct dma_attrs *attrs, int coherent_flag)
+        dma_addr_t handle, unsigned long attrs, int coherent_flag)
 {
         struct page **pages;
         size = PAGE_ALIGN(size);
@@ -1638,7 +1637,7 @@ void __arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr,
                 return;
         }
 
-        if (!dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, attrs)) {
+        if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0) {
                 dma_common_free_remap(cpu_addr, size,
                         VM_ARM_DMA_CONSISTENT | VM_USERMAP);
         }
@@ -1648,20 +1647,20 @@ void __arm_iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr,
 }
 
 void arm_iommu_free_attrs(struct device *dev, size_t size,
-                    void *cpu_addr, dma_addr_t handle, struct dma_attrs *attrs)
+                    void *cpu_addr, dma_addr_t handle, unsigned long attrs)
 {
         __arm_iommu_free_attrs(dev, size, cpu_addr, handle, attrs, NORMAL);
 }
 
 void arm_coherent_iommu_free_attrs(struct device *dev, size_t size,
-                    void *cpu_addr, dma_addr_t handle, struct dma_attrs *attrs)
+                    void *cpu_addr, dma_addr_t handle, unsigned long attrs)
 {
         __arm_iommu_free_attrs(dev, size, cpu_addr, handle, attrs, COHERENT);
 }
 
 static int arm_iommu_get_sgtable(struct device *dev, struct sg_table *sgt,
                                  void *cpu_addr, dma_addr_t dma_addr,
-                                 size_t size, struct dma_attrs *attrs)
+                                 size_t size, unsigned long attrs)
 {
         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
         struct page **pages = __iommu_get_pages(cpu_addr, attrs);
@@ -1699,7 +1698,7 @@ static int __dma_direction_to_prot(enum dma_data_direction dir)
  */
 static int __map_sg_chunk(struct device *dev, struct scatterlist *sg,
                           size_t size, dma_addr_t *handle,
-                          enum dma_data_direction dir, struct dma_attrs *attrs,
+                          enum dma_data_direction dir, unsigned long attrs,
                           bool is_coherent)
 {
         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
@@ -1720,8 +1719,7 @@ static int __map_sg_chunk(struct device *dev, struct scatterlist *sg,
                 phys_addr_t phys = page_to_phys(sg_page(s));
                 unsigned int len = PAGE_ALIGN(s->offset + s->length);
 
-                if (!is_coherent &&
-                        !dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+                if (!is_coherent && (attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                         __dma_page_cpu_to_dev(sg_page(s), s->offset, s->length, dir);
 
                 prot = __dma_direction_to_prot(dir);
@@ -1742,7 +1740,7 @@ fail:
 }
 
 static int __iommu_map_sg(struct device *dev, struct scatterlist *sg, int nents,
-                     enum dma_data_direction dir, struct dma_attrs *attrs,
+                     enum dma_data_direction dir, unsigned long attrs,
                      bool is_coherent)
 {
         struct scatterlist *s = sg, *dma = sg, *start = sg;
@@ -1800,7 +1798,7 @@ bad_mapping:
  * obtained via sg_dma_{address,length}.
  */
 int arm_coherent_iommu_map_sg(struct device *dev, struct scatterlist *sg,
-                int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
+                int nents, enum dma_data_direction dir, unsigned long attrs)
 {
         return __iommu_map_sg(dev, sg, nents, dir, attrs, true);
 }
@@ -1818,14 +1816,14 @@ int arm_coherent_iommu_map_sg(struct device *dev, struct scatterlist *sg,
  * sg_dma_{address,length}.
  */
 int arm_iommu_map_sg(struct device *dev, struct scatterlist *sg,
-                int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
+                int nents, enum dma_data_direction dir, unsigned long attrs)
 {
         return __iommu_map_sg(dev, sg, nents, dir, attrs, false);
 }
 
 static void __iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
-                int nents, enum dma_data_direction dir, struct dma_attrs *attrs,
-                bool is_coherent)
+                int nents, enum dma_data_direction dir,
+                unsigned long attrs, bool is_coherent)
 {
         struct scatterlist *s;
         int i;
@@ -1834,8 +1832,7 @@ static void __iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
                 if (sg_dma_len(s))
                         __iommu_remove_mapping(dev, sg_dma_address(s),
                                                sg_dma_len(s));
-                if (!is_coherent &&
-                    !dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+                if (!is_coherent && (attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                         __dma_page_dev_to_cpu(sg_page(s), s->offset,
                                               s->length, dir);
         }
@@ -1852,7 +1849,8 @@ static void __iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
  * rules concerning calls here are the same as for dma_unmap_single().
  */
 void arm_coherent_iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
-                int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
+                int nents, enum dma_data_direction dir,
+                unsigned long attrs)
 {
         __iommu_unmap_sg(dev, sg, nents, dir, attrs, true);
 }
@@ -1868,7 +1866,8 @@ void arm_coherent_iommu_unmap_sg(struct device *dev, struct scatterlist *sg,
  * rules concerning calls here are the same as for dma_unmap_single().
  */
 void arm_iommu_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
-                        enum dma_data_direction dir, struct dma_attrs *attrs)
+                        enum dma_data_direction dir,
+                        unsigned long attrs)
 {
         __iommu_unmap_sg(dev, sg, nents, dir, attrs, false);
 }
@@ -1921,7 +1920,7 @@ void arm_iommu_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
  */
 static dma_addr_t arm_coherent_iommu_map_page(struct device *dev, struct page *page,
              unsigned long offset, size_t size, enum dma_data_direction dir,
-             struct dma_attrs *attrs)
+             unsigned long attrs)
 {
         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
         dma_addr_t dma_addr;
@@ -1955,9 +1954,9 @@ fail:
  */
 static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page,
              unsigned long offset, size_t size, enum dma_data_direction dir,
-             struct dma_attrs *attrs)
+             unsigned long attrs)
 {
-        if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+        if ((attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                 __dma_page_cpu_to_dev(page, offset, size, dir);
 
         return arm_coherent_iommu_map_page(dev, page, offset, size, dir, attrs);
@@ -1973,8 +1972,7 @@ static dma_addr_t arm_iommu_map_page(struct device *dev, struct page *page,
  * Coherent IOMMU aware version of arm_dma_unmap_page()
  */
 static void arm_coherent_iommu_unmap_page(struct device *dev, dma_addr_t handle,
-                size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                size_t size, enum dma_data_direction dir, unsigned long attrs)
 {
         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
         dma_addr_t iova = handle & PAGE_MASK;
@@ -1998,8 +1996,7 @@ static void arm_coherent_iommu_unmap_page(struct device *dev, dma_addr_t handle,
  * IOMMU aware version of arm_dma_unmap_page()
  */
 static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle,
-                size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                size_t size, enum dma_data_direction dir, unsigned long attrs)
 {
         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(dev);
         dma_addr_t iova = handle & PAGE_MASK;
@@ -2010,7 +2007,7 @@ static void arm_iommu_unmap_page(struct device *dev, dma_addr_t handle,
         if (!iova)
                 return;
 
-        if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+        if ((attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                 __dma_page_dev_to_cpu(page, offset, size, dir);
 
         iommu_unmap(mapping->domain, iova, len);
diff --git a/arch/arm/xen/mm.c b/arch/arm/xen/mm.c
index c5f9a9e3d1f3..d062f08f5020 100644
--- a/arch/arm/xen/mm.c
+++ b/arch/arm/xen/mm.c
@@ -98,11 +98,11 @@ static void __xen_dma_page_cpu_to_dev(struct device *hwdev, dma_addr_t handle,
 
 void __xen_dma_map_page(struct device *hwdev, struct page *page,
              dma_addr_t dev_addr, unsigned long offset, size_t size,
-             enum dma_data_direction dir, struct dma_attrs *attrs)
+             enum dma_data_direction dir, unsigned long attrs)
 {
         if (is_device_dma_coherent(hwdev))
                 return;
-        if (dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+        if (attrs & DMA_ATTR_SKIP_CPU_SYNC)
                 return;
 
         __xen_dma_page_cpu_to_dev(hwdev, dev_addr, size, dir);
@@ -110,12 +110,12 @@ void __xen_dma_map_page(struct device *hwdev, struct page *page,
 
 void __xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle,
                 size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 
 {
         if (is_device_dma_coherent(hwdev))
                 return;
-        if (dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+        if (attrs & DMA_ATTR_SKIP_CPU_SYNC)
                 return;
 
         __xen_dma_page_dev_to_cpu(hwdev, handle, size, dir);
diff --git a/arch/arm64/mm/dma-mapping.c b/arch/arm64/mm/dma-mapping.c
index f6c55afab3e2..c4284c432ae8 100644
--- a/arch/arm64/mm/dma-mapping.c
+++ b/arch/arm64/mm/dma-mapping.c
@@ -32,10 +32,10 @@
 
 static int swiotlb __read_mostly;
 
-static pgprot_t __get_dma_pgprot(struct dma_attrs *attrs, pgprot_t prot,
+static pgprot_t __get_dma_pgprot(unsigned long attrs, pgprot_t prot,
                                  bool coherent)
 {
-        if (!coherent || dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs))
+        if (!coherent || (attrs & DMA_ATTR_WRITE_COMBINE))
                 return pgprot_writecombine(prot);
         return prot;
 }
@@ -91,7 +91,7 @@ static int __free_from_pool(void *start, size_t size)
 
 static void *__dma_alloc_coherent(struct device *dev, size_t size,
                                   dma_addr_t *dma_handle, gfp_t flags,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         if (dev == NULL) {
                 WARN_ONCE(1, "Use an actual device structure for DMA allocation\n");
@@ -121,7 +121,7 @@ static void *__dma_alloc_coherent(struct device *dev, size_t size,
 
 static void __dma_free_coherent(struct device *dev, size_t size,
                                 void *vaddr, dma_addr_t dma_handle,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         bool freed;
         phys_addr_t paddr = dma_to_phys(dev, dma_handle);
@@ -140,7 +140,7 @@ static void __dma_free_coherent(struct device *dev, size_t size,
 
 static void *__dma_alloc(struct device *dev, size_t size,
                          dma_addr_t *dma_handle, gfp_t flags,
-                         struct dma_attrs *attrs)
+                         unsigned long attrs)
 {
         struct page *page;
         void *ptr, *coherent_ptr;
@@ -188,7 +188,7 @@ no_mem:
 
 static void __dma_free(struct device *dev, size_t size,
                        void *vaddr, dma_addr_t dma_handle,
-                       struct dma_attrs *attrs)
+                       unsigned long attrs)
 {
         void *swiotlb_addr = phys_to_virt(dma_to_phys(dev, dma_handle));
 
@@ -205,7 +205,7 @@ static void __dma_free(struct device *dev, size_t size,
 static dma_addr_t __swiotlb_map_page(struct device *dev, struct page *page,
                                      unsigned long offset, size_t size,
                                      enum dma_data_direction dir,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         dma_addr_t dev_addr;
 
@@ -219,7 +219,7 @@ static dma_addr_t __swiotlb_map_page(struct device *dev, struct page *page,
 
 static void __swiotlb_unmap_page(struct device *dev, dma_addr_t dev_addr,
                                  size_t size, enum dma_data_direction dir,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         if (!is_device_dma_coherent(dev))
                 __dma_unmap_area(phys_to_virt(dma_to_phys(dev, dev_addr)), size, dir);
@@ -228,7 +228,7 @@ static void __swiotlb_unmap_page(struct device *dev, dma_addr_t dev_addr,
 
 static int __swiotlb_map_sg_attrs(struct device *dev, struct scatterlist *sgl,
                                   int nelems, enum dma_data_direction dir,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         struct scatterlist *sg;
         int i, ret;
@@ -245,7 +245,7 @@ static int __swiotlb_map_sg_attrs(struct device *dev, struct scatterlist *sgl,
 static void __swiotlb_unmap_sg_attrs(struct device *dev,
                                      struct scatterlist *sgl, int nelems,
                                      enum dma_data_direction dir,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -306,7 +306,7 @@ static void __swiotlb_sync_sg_for_device(struct device *dev,
 static int __swiotlb_mmap(struct device *dev,
                           struct vm_area_struct *vma,
                           void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         int ret = -ENXIO;
         unsigned long nr_vma_pages = (vma->vm_end - vma->vm_start) >>
@@ -333,7 +333,7 @@ static int __swiotlb_mmap(struct device *dev,
 
 static int __swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt,
                                  void *cpu_addr, dma_addr_t handle, size_t size,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         int ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
 
@@ -435,21 +435,21 @@ out:
 
 static void *__dummy_alloc(struct device *dev, size_t size,
                            dma_addr_t *dma_handle, gfp_t flags,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         return NULL;
 }
 
 static void __dummy_free(struct device *dev, size_t size,
                          void *vaddr, dma_addr_t dma_handle,
-                         struct dma_attrs *attrs)
+                         unsigned long attrs)
 {
 }
 
 static int __dummy_mmap(struct device *dev,
                         struct vm_area_struct *vma,
                         void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                        struct dma_attrs *attrs)
+                        unsigned long attrs)
 {
         return -ENXIO;
 }
@@ -457,20 +457,20 @@ static int __dummy_mmap(struct device *dev,
 static dma_addr_t __dummy_map_page(struct device *dev, struct page *page,
                                    unsigned long offset, size_t size,
                                    enum dma_data_direction dir,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         return DMA_ERROR_CODE;
 }
 
 static void __dummy_unmap_page(struct device *dev, dma_addr_t dev_addr,
                                size_t size, enum dma_data_direction dir,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
 }
 
 static int __dummy_map_sg(struct device *dev, struct scatterlist *sgl,
                           int nelems, enum dma_data_direction dir,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         return 0;
 }
@@ -478,7 +478,7 @@ static int __dummy_map_sg(struct device *dev, struct scatterlist *sgl,
 static void __dummy_unmap_sg(struct device *dev,
                              struct scatterlist *sgl, int nelems,
                              enum dma_data_direction dir,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
 }
 
@@ -553,7 +553,7 @@ static void flush_page(struct device *dev, const void *virt, phys_addr_t phys)
 
 static void *__iommu_alloc_attrs(struct device *dev, size_t size,
                                  dma_addr_t *handle, gfp_t gfp,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         bool coherent = is_device_dma_coherent(dev);
         int ioprot = dma_direction_to_prot(DMA_BIDIRECTIONAL, coherent);
@@ -613,7 +613,7 @@ static void *__iommu_alloc_attrs(struct device *dev, size_t size,
 }
 
 static void __iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr,
-                               dma_addr_t handle, struct dma_attrs *attrs)
+                               dma_addr_t handle, unsigned long attrs)
 {
         size_t iosize = size;
 
@@ -629,7 +629,7 @@ static void __iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr,
          * Hence how dodgy the below logic looks...
          */
         if (__in_atomic_pool(cpu_addr, size)) {
-                iommu_dma_unmap_page(dev, handle, iosize, 0, NULL);
+                iommu_dma_unmap_page(dev, handle, iosize, 0, 0);
                 __free_from_pool(cpu_addr, size);
         } else if (is_vmalloc_addr(cpu_addr)){
                 struct vm_struct *area = find_vm_area(cpu_addr);
@@ -639,14 +639,14 @@ static void __iommu_free_attrs(struct device *dev, size_t size, void *cpu_addr,
                 iommu_dma_free(dev, area->pages, iosize, &handle);
                 dma_common_free_remap(cpu_addr, size, VM_USERMAP);
         } else {
-                iommu_dma_unmap_page(dev, handle, iosize, 0, NULL);
+                iommu_dma_unmap_page(dev, handle, iosize, 0, 0);
                 __free_pages(virt_to_page(cpu_addr), get_order(size));
         }
 }
 
 static int __iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
                               void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         struct vm_struct *area;
         int ret;
@@ -666,7 +666,7 @@ static int __iommu_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
 
 static int __iommu_get_sgtable(struct device *dev, struct sg_table *sgt,
                                void *cpu_addr, dma_addr_t dma_addr,
-                               size_t size, struct dma_attrs *attrs)
+                               size_t size, unsigned long attrs)
 {
         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
         struct vm_struct *area = find_vm_area(cpu_addr);
@@ -707,14 +707,14 @@ static void __iommu_sync_single_for_device(struct device *dev,
 static dma_addr_t __iommu_map_page(struct device *dev, struct page *page,
                                    unsigned long offset, size_t size,
                                    enum dma_data_direction dir,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         bool coherent = is_device_dma_coherent(dev);
         int prot = dma_direction_to_prot(dir, coherent);
         dma_addr_t dev_addr = iommu_dma_map_page(dev, page, offset, size, prot);
 
         if (!iommu_dma_mapping_error(dev, dev_addr) &&
-            !dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+            (attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                 __iommu_sync_single_for_device(dev, dev_addr, size, dir);
 
         return dev_addr;
@@ -722,9 +722,9 @@ static dma_addr_t __iommu_map_page(struct device *dev, struct page *page,
 
 static void __iommu_unmap_page(struct device *dev, dma_addr_t dev_addr,
                                size_t size, enum dma_data_direction dir,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
-        if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+        if ((attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                 __iommu_sync_single_for_cpu(dev, dev_addr, size, dir);
 
         iommu_dma_unmap_page(dev, dev_addr, size, dir, attrs);
@@ -760,11 +760,11 @@ static void __iommu_sync_sg_for_device(struct device *dev,
 
 static int __iommu_map_sg_attrs(struct device *dev, struct scatterlist *sgl,
                                 int nelems, enum dma_data_direction dir,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         bool coherent = is_device_dma_coherent(dev);
 
-        if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+        if ((attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                 __iommu_sync_sg_for_device(dev, sgl, nelems, dir);
 
         return iommu_dma_map_sg(dev, sgl, nelems,
@@ -774,9 +774,9 @@ static int __iommu_map_sg_attrs(struct device *dev, struct scatterlist *sgl,
 static void __iommu_unmap_sg_attrs(struct device *dev,
                                    struct scatterlist *sgl, int nelems,
                                    enum dma_data_direction dir,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
-        if (!dma_get_attr(DMA_ATTR_SKIP_CPU_SYNC, attrs))
+        if ((attrs & DMA_ATTR_SKIP_CPU_SYNC) == 0)
                 __iommu_sync_sg_for_cpu(dev, sgl, nelems, dir);
 
         iommu_dma_unmap_sg(dev, sgl, nelems, dir, attrs);
diff --git a/arch/avr32/mm/dma-coherent.c b/arch/avr32/mm/dma-coherent.c
index 92cf1fb2b3e6..58610d0df7ed 100644
--- a/arch/avr32/mm/dma-coherent.c
+++ b/arch/avr32/mm/dma-coherent.c
@@ -99,7 +99,7 @@ static void __dma_free(struct device *dev, size_t size,
 }
 
 static void *avr32_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs)
+                dma_addr_t *handle, gfp_t gfp, unsigned long attrs)
 {
         struct page *page;
         dma_addr_t phys;
@@ -109,7 +109,7 @@ static void *avr32_dma_alloc(struct device *dev, size_t size,
                 return NULL;
         phys = page_to_phys(page);
 
-        if (dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs)) {
+        if (attrs & DMA_ATTR_WRITE_COMBINE) {
                 /* Now, map the page into P3 with write-combining turned on */
                 *handle = phys;
                 return __ioremap(phys, size, _PAGE_BUFFER);
@@ -119,11 +119,11 @@ static void *avr32_dma_alloc(struct device *dev, size_t size,
 }
 
 static void avr32_dma_free(struct device *dev, size_t size,
-                void *cpu_addr, dma_addr_t handle, struct dma_attrs *attrs)
+                void *cpu_addr, dma_addr_t handle, unsigned long attrs)
 {
         struct page *page;
 
-        if (dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs)) {
+        if (attrs & DMA_ATTR_WRITE_COMBINE) {
                 iounmap(cpu_addr);
 
                 page = phys_to_page(handle);
@@ -142,7 +142,7 @@ static void avr32_dma_free(struct device *dev, size_t size,
 
 static dma_addr_t avr32_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size,
-                enum dma_data_direction direction, struct dma_attrs *attrs)
+                enum dma_data_direction direction, unsigned long attrs)
 {
         void *cpu_addr = page_address(page) + offset;
 
@@ -152,7 +152,7 @@ static dma_addr_t avr32_dma_map_page(struct device *dev, struct page *page,
 
 static int avr32_dma_map_sg(struct device *dev, struct scatterlist *sglist,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         int i;
         struct scatterlist *sg;
diff --git a/arch/blackfin/kernel/dma-mapping.c b/arch/blackfin/kernel/dma-mapping.c
index 771afe6e4264..53fbbb61aa86 100644
--- a/arch/blackfin/kernel/dma-mapping.c
+++ b/arch/blackfin/kernel/dma-mapping.c
@@ -79,7 +79,7 @@ static void __free_dma_pages(unsigned long addr, unsigned int pages)
 }
 
 static void *bfin_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t gfp, struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         void *ret;
 
@@ -94,7 +94,7 @@ static void *bfin_dma_alloc(struct device *dev, size_t size,
 }
 
 static void bfin_dma_free(struct device *dev, size_t size, void *vaddr,
-                  dma_addr_t dma_handle, struct dma_attrs *attrs)
+                  dma_addr_t dma_handle, unsigned long attrs)
 {
         __free_dma_pages((unsigned long)vaddr, get_pages(size));
 }
@@ -111,7 +111,7 @@ EXPORT_SYMBOL(__dma_sync);
 
 static int bfin_dma_map_sg(struct device *dev, struct scatterlist *sg_list,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -139,7 +139,7 @@ static void bfin_dma_sync_sg_for_device(struct device *dev,
 
 static dma_addr_t bfin_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         dma_addr_t handle = (dma_addr_t)(page_address(page) + offset);
 
diff --git a/arch/c6x/include/asm/dma-mapping.h b/arch/c6x/include/asm/dma-mapping.h
index 6b5cd7b0cf32..5717b1e52d96 100644
--- a/arch/c6x/include/asm/dma-mapping.h
+++ b/arch/c6x/include/asm/dma-mapping.h
@@ -26,8 +26,8 @@ static inline struct dma_map_ops *get_dma_ops(struct device *dev)
 
 extern void coherent_mem_init(u32 start, u32 size);
 void *c6x_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
-                gfp_t gfp, struct dma_attrs *attrs);
+                gfp_t gfp, unsigned long attrs);
 void c6x_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs);
+                dma_addr_t dma_handle, unsigned long attrs);
 
 #endif  /* _ASM_C6X_DMA_MAPPING_H */
diff --git a/arch/c6x/kernel/dma.c b/arch/c6x/kernel/dma.c
index 8a80f3a250c0..db4a6a301f5e 100644
--- a/arch/c6x/kernel/dma.c
+++ b/arch/c6x/kernel/dma.c
@@ -38,7 +38,7 @@ static void c6x_dma_sync(dma_addr_t handle, size_t size,
 
 static dma_addr_t c6x_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         dma_addr_t handle = virt_to_phys(page_address(page) + offset);
 
@@ -47,13 +47,13 @@ static dma_addr_t c6x_dma_map_page(struct device *dev, struct page *page,
 }
 
 static void c6x_dma_unmap_page(struct device *dev, dma_addr_t handle,
-                size_t size, enum dma_data_direction dir, struct dma_attrs *attrs)
+                size_t size, enum dma_data_direction dir, unsigned long attrs)
 {
         c6x_dma_sync(handle, size, dir);
 }
 
 static int c6x_dma_map_sg(struct device *dev, struct scatterlist *sglist,
-                int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
+                int nents, enum dma_data_direction dir, unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -67,8 +67,7 @@ static int c6x_dma_map_sg(struct device *dev, struct scatterlist *sglist,
 }
 
 static void c6x_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
-                  int nents, enum dma_data_direction dir,
-                  struct dma_attrs *attrs)
+                  int nents, enum dma_data_direction dir, unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
diff --git a/arch/c6x/mm/dma-coherent.c b/arch/c6x/mm/dma-coherent.c
index f7ee63af2541..95e38ad27c69 100644
--- a/arch/c6x/mm/dma-coherent.c
+++ b/arch/c6x/mm/dma-coherent.c
@@ -74,7 +74,7 @@ static void __free_dma_pages(u32 addr, int order)
  * virtual and DMA address for that space.
  */
 void *c6x_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
-                gfp_t gfp, struct dma_attrs *attrs)
+                gfp_t gfp, unsigned long attrs)
 {
         u32 paddr;
         int order;
@@ -99,7 +99,7 @@ void *c6x_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
  * Free DMA coherent memory as defined by the above mapping.
  */
 void c6x_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         int order;
 
diff --git a/arch/cris/arch-v32/drivers/pci/dma.c b/arch/cris/arch-v32/drivers/pci/dma.c
index 8d5efa58cce1..1f0636793f0c 100644
--- a/arch/cris/arch-v32/drivers/pci/dma.c
+++ b/arch/cris/arch-v32/drivers/pci/dma.c
@@ -17,7 +17,7 @@
 #include <asm/io.h>
 
 static void *v32_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t gfp,  struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         void *ret;
 
@@ -37,22 +37,21 @@ static void *v32_dma_alloc(struct device *dev, size_t size,
 }
 
 static void v32_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         free_pages((unsigned long)vaddr, get_order(size));
 }
 
 static inline dma_addr_t v32_dma_map_page(struct device *dev,
                 struct page *page, unsigned long offset, size_t size,
-                enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                enum dma_data_direction direction, unsigned long attrs)
 {
         return page_to_phys(page) + offset;
 }
 
 static inline int v32_dma_map_sg(struct device *dev, struct scatterlist *sg,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         printk("Map sg\n");
         return nents;
diff --git a/arch/frv/mb93090-mb00/pci-dma-nommu.c b/arch/frv/mb93090-mb00/pci-dma-nommu.c
index 082be49b5df0..90f2e4cb33d6 100644
--- a/arch/frv/mb93090-mb00/pci-dma-nommu.c
+++ b/arch/frv/mb93090-mb00/pci-dma-nommu.c
@@ -35,7 +35,7 @@ static DEFINE_SPINLOCK(dma_alloc_lock);
 static LIST_HEAD(dma_alloc_list);
 
 static void *frv_dma_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_handle,
-                gfp_t gfp, struct dma_attrs *attrs)
+                gfp_t gfp, unsigned long attrs)
 {
         struct dma_alloc_record *new;
         struct list_head *this = &dma_alloc_list;
@@ -86,7 +86,7 @@ static void *frv_dma_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_ha
 }
 
 static void frv_dma_free(struct device *hwdev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         struct dma_alloc_record *rec;
         unsigned long flags;
@@ -107,7 +107,7 @@ static void frv_dma_free(struct device *hwdev, size_t size, void *vaddr,
 
 static int frv_dma_map_sg(struct device *dev, struct scatterlist *sglist,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         int i;
         struct scatterlist *sg;
@@ -124,7 +124,7 @@ static int frv_dma_map_sg(struct device *dev, struct scatterlist *sglist,
 
 static dma_addr_t frv_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size,
-                enum dma_data_direction direction, struct dma_attrs *attrs)
+                enum dma_data_direction direction, unsigned long attrs)
 {
         BUG_ON(direction == DMA_NONE);
         flush_dcache_page(page);
diff --git a/arch/frv/mb93090-mb00/pci-dma.c b/arch/frv/mb93090-mb00/pci-dma.c
index 316b7b65348d..f585745b1abc 100644
--- a/arch/frv/mb93090-mb00/pci-dma.c
+++ b/arch/frv/mb93090-mb00/pci-dma.c
@@ -19,8 +19,7 @@
 #include <asm/io.h>
 
 static void *frv_dma_alloc(struct device *hwdev, size_t size,
-                dma_addr_t *dma_handle, gfp_t gfp,
-                struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         void *ret;
 
@@ -32,14 +31,14 @@ static void *frv_dma_alloc(struct device *hwdev, size_t size,
 }
 
 static void frv_dma_free(struct device *hwdev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         consistent_free(vaddr);
 }
 
 static int frv_dma_map_sg(struct device *dev, struct scatterlist *sglist,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         unsigned long dampr2;
         void *vaddr;
@@ -69,7 +68,7 @@ static int frv_dma_map_sg(struct device *dev, struct scatterlist *sglist,
 
 static dma_addr_t frv_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size,
-                enum dma_data_direction direction, struct dma_attrs *attrs)
+                enum dma_data_direction direction, unsigned long attrs)
 {
         flush_dcache_page(page);
         return (dma_addr_t) page_to_phys(page) + offset;
diff --git a/arch/h8300/kernel/dma.c b/arch/h8300/kernel/dma.c
index eeb13d3f2424..3651da045806 100644
--- a/arch/h8300/kernel/dma.c
+++ b/arch/h8300/kernel/dma.c
@@ -12,7 +12,7 @@
 
 static void *dma_alloc(struct device *dev, size_t size,
                        dma_addr_t *dma_handle, gfp_t gfp,
-                       struct dma_attrs *attrs)
+                       unsigned long attrs)
 {
         void *ret;
 
@@ -32,7 +32,7 @@ static void *dma_alloc(struct device *dev, size_t size,
 
 static void dma_free(struct device *dev, size_t size,
                      void *vaddr, dma_addr_t dma_handle,
-                     struct dma_attrs *attrs)
+                     unsigned long attrs)
 
 {
         free_pages((unsigned long)vaddr, get_order(size));
@@ -41,14 +41,14 @@ static void dma_free(struct device *dev, size_t size,
 static dma_addr_t map_page(struct device *dev, struct page *page,
                                   unsigned long offset, size_t size,
                                   enum dma_data_direction direction,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         return page_to_phys(page) + offset;
 }
 
 static int map_sg(struct device *dev, struct scatterlist *sgl,
                   int nents, enum dma_data_direction direction,
-                  struct dma_attrs *attrs)
+                  unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
diff --git a/arch/hexagon/include/asm/dma-mapping.h b/arch/hexagon/include/asm/dma-mapping.h
index aa6203464520..7ef58df909fc 100644
--- a/arch/hexagon/include/asm/dma-mapping.h
+++ b/arch/hexagon/include/asm/dma-mapping.h
@@ -26,7 +26,6 @@
 #include <linux/mm.h>
 #include <linux/scatterlist.h>
 #include <linux/dma-debug.h>
-#include <linux/dma-attrs.h>
 #include <asm/io.h>
 
 struct device;
diff --git a/arch/hexagon/kernel/dma.c b/arch/hexagon/kernel/dma.c
index 9e3ddf792bd3..b9017785fb71 100644
--- a/arch/hexagon/kernel/dma.c
+++ b/arch/hexagon/kernel/dma.c
@@ -51,7 +51,7 @@ static struct gen_pool *coherent_pool;
 
 static void *hexagon_dma_alloc_coherent(struct device *dev, size_t size,
                                  dma_addr_t *dma_addr, gfp_t flag,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         void *ret;
 
@@ -84,7 +84,7 @@ static void *hexagon_dma_alloc_coherent(struct device *dev, size_t size,
 }
 
 static void hexagon_free_coherent(struct device *dev, size_t size, void *vaddr,
-                                  dma_addr_t dma_addr, struct dma_attrs *attrs)
+                                  dma_addr_t dma_addr, unsigned long attrs)
 {
         gen_pool_free(coherent_pool, (unsigned long) vaddr, size);
 }
@@ -105,7 +105,7 @@ static int check_addr(const char *name, struct device *hwdev,
 
 static int hexagon_map_sg(struct device *hwdev, struct scatterlist *sg,
                           int nents, enum dma_data_direction dir,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
@@ -172,7 +172,7 @@ static inline void dma_sync(void *addr, size_t size,
 static dma_addr_t hexagon_map_page(struct device *dev, struct page *page,
                                    unsigned long offset, size_t size,
                                    enum dma_data_direction dir,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         dma_addr_t bus = page_to_phys(page) + offset;
         WARN_ON(size == 0);
diff --git a/arch/ia64/hp/common/sba_iommu.c b/arch/ia64/hp/common/sba_iommu.c
index a6d6190c9d24..630ee8073899 100644
--- a/arch/ia64/hp/common/sba_iommu.c
+++ b/arch/ia64/hp/common/sba_iommu.c
@@ -919,7 +919,7 @@ sba_mark_invalid(struct ioc *ioc, dma_addr_t iova, size_t byte_cnt)
 static dma_addr_t sba_map_page(struct device *dev, struct page *page,
                                unsigned long poff, size_t size,
                                enum dma_data_direction dir,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
         struct ioc *ioc;
         void *addr = page_address(page) + poff;
@@ -1005,7 +1005,7 @@ static dma_addr_t sba_map_page(struct device *dev, struct page *page,
 
 static dma_addr_t sba_map_single_attrs(struct device *dev, void *addr,
                                        size_t size, enum dma_data_direction dir,
-                                       struct dma_attrs *attrs)
+                                       unsigned long attrs)
 {
         return sba_map_page(dev, virt_to_page(addr),
                             (unsigned long)addr & ~PAGE_MASK, size, dir, attrs);
@@ -1046,7 +1046,7 @@ sba_mark_clean(struct ioc *ioc, dma_addr_t iova, size_t size)
  * See Documentation/DMA-API-HOWTO.txt
  */
 static void sba_unmap_page(struct device *dev, dma_addr_t iova, size_t size,
-                           enum dma_data_direction dir, struct dma_attrs *attrs)
+                           enum dma_data_direction dir, unsigned long attrs)
 {
         struct ioc *ioc;
 #if DELAYED_RESOURCE_CNT > 0
@@ -1115,7 +1115,7 @@ static void sba_unmap_page(struct device *dev, dma_addr_t iova, size_t size,
 }
 
 void sba_unmap_single_attrs(struct device *dev, dma_addr_t iova, size_t size,
-                            enum dma_data_direction dir, struct dma_attrs *attrs)
+                            enum dma_data_direction dir, unsigned long attrs)
 {
         sba_unmap_page(dev, iova, size, dir, attrs);
 }
@@ -1130,7 +1130,7 @@ void sba_unmap_single_attrs(struct device *dev, dma_addr_t iova, size_t size,
  */
 static void *
 sba_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
-                   gfp_t flags, struct dma_attrs *attrs)
+                   gfp_t flags, unsigned long attrs)
 {
         struct ioc *ioc;
         void *addr;
@@ -1175,7 +1175,7 @@ sba_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
          * device to map single to get an iova mapping.
          */
         *dma_handle = sba_map_single_attrs(&ioc->sac_only_dev->dev, addr,
-                                           size, 0, NULL);
+                                           size, 0, 0);
 
         return addr;
 }
@@ -1191,9 +1191,9 @@ sba_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
  * See Documentation/DMA-API-HOWTO.txt
  */
 static void sba_free_coherent(struct device *dev, size_t size, void *vaddr,
-                              dma_addr_t dma_handle, struct dma_attrs *attrs)
+                              dma_addr_t dma_handle, unsigned long attrs)
 {
-        sba_unmap_single_attrs(dev, dma_handle, size, 0, NULL);
+        sba_unmap_single_attrs(dev, dma_handle, size, 0, 0);
         free_pages((unsigned long) vaddr, get_order(size));
 }
 
@@ -1442,7 +1442,7 @@ sba_coalesce_chunks(struct ioc *ioc, struct device *dev,
 
 static void sba_unmap_sg_attrs(struct device *dev, struct scatterlist *sglist,
                                int nents, enum dma_data_direction dir,
-                               struct dma_attrs *attrs);
+                               unsigned long attrs);
 /**
  * sba_map_sg - map Scatter/Gather list
  * @dev: instance of PCI owned by the driver that's asking.
@@ -1455,7 +1455,7 @@ static void sba_unmap_sg_attrs(struct device *dev, struct scatterlist *sglist,
  */
 static int sba_map_sg_attrs(struct device *dev, struct scatterlist *sglist,
                             int nents, enum dma_data_direction dir,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         struct ioc *ioc;
         int coalesced, filled = 0;
@@ -1551,7 +1551,7 @@ static int sba_map_sg_attrs(struct device *dev, struct scatterlist *sglist,
  */
 static void sba_unmap_sg_attrs(struct device *dev, struct scatterlist *sglist,
                                int nents, enum dma_data_direction dir,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
 #ifdef ASSERT_PDIR_SANITY
         struct ioc *ioc;
diff --git a/arch/ia64/include/asm/machvec.h b/arch/ia64/include/asm/machvec.h
index 9c39bdfc2da8..ed7f09089f12 100644
--- a/arch/ia64/include/asm/machvec.h
+++ b/arch/ia64/include/asm/machvec.h
@@ -22,7 +22,6 @@ struct pci_bus;
 struct task_struct;
 struct pci_dev;
 struct msi_desc;
-struct dma_attrs;
 
 typedef void ia64_mv_setup_t (char **);
 typedef void ia64_mv_cpu_init_t (void);
diff --git a/arch/ia64/kernel/pci-swiotlb.c b/arch/ia64/kernel/pci-swiotlb.c
index 939260aeac98..2933208c0285 100644
--- a/arch/ia64/kernel/pci-swiotlb.c
+++ b/arch/ia64/kernel/pci-swiotlb.c
@@ -16,7 +16,7 @@ EXPORT_SYMBOL(swiotlb);
 
 static void *ia64_swiotlb_alloc_coherent(struct device *dev, size_t size,
                                          dma_addr_t *dma_handle, gfp_t gfp,
-                                         struct dma_attrs *attrs)
+                                         unsigned long attrs)
 {
         if (dev->coherent_dma_mask != DMA_BIT_MASK(64))
                 gfp |= GFP_DMA;
@@ -25,7 +25,7 @@ static void *ia64_swiotlb_alloc_coherent(struct device *dev, size_t size,
 
 static void ia64_swiotlb_free_coherent(struct device *dev, size_t size,
                                        void *vaddr, dma_addr_t dma_addr,
-                                       struct dma_attrs *attrs)
+                                       unsigned long attrs)
 {
         swiotlb_free_coherent(dev, size, vaddr, dma_addr);
 }
diff --git a/arch/ia64/sn/pci/pci_dma.c b/arch/ia64/sn/pci/pci_dma.c
index 8f59907007cb..74c934a997bb 100644
--- a/arch/ia64/sn/pci/pci_dma.c
+++ b/arch/ia64/sn/pci/pci_dma.c
@@ -77,7 +77,7 @@ EXPORT_SYMBOL(sn_dma_set_mask);
  */
 static void *sn_dma_alloc_coherent(struct device *dev, size_t size,
                                    dma_addr_t * dma_handle, gfp_t flags,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         void *cpuaddr;
         unsigned long phys_addr;
@@ -138,7 +138,7 @@ static void *sn_dma_alloc_coherent(struct device *dev, size_t size,
  * any associated IOMMU mappings.
  */
 static void sn_dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
-                                 dma_addr_t dma_handle, struct dma_attrs *attrs)
+                                 dma_addr_t dma_handle, unsigned long attrs)
 {
         struct pci_dev *pdev = to_pci_dev(dev);
         struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
@@ -176,21 +176,18 @@ static void sn_dma_free_coherent(struct device *dev, size_t size, void *cpu_addr
 static dma_addr_t sn_dma_map_page(struct device *dev, struct page *page,
                                   unsigned long offset, size_t size,
                                   enum dma_data_direction dir,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         void *cpu_addr = page_address(page) + offset;
         dma_addr_t dma_addr;
         unsigned long phys_addr;
         struct pci_dev *pdev = to_pci_dev(dev);
         struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
-        int dmabarr;
-
-        dmabarr = dma_get_attr(DMA_ATTR_WRITE_BARRIER, attrs);
 
         BUG_ON(!dev_is_pci(dev));
 
         phys_addr = __pa(cpu_addr);
-        if (dmabarr)
+        if (attrs & DMA_ATTR_WRITE_BARRIER)
                 dma_addr = provider->dma_map_consistent(pdev, phys_addr,
                                                         size, SN_DMA_ADDR_PHYS);
         else
@@ -218,7 +215,7 @@ static dma_addr_t sn_dma_map_page(struct device *dev, struct page *page,
  */
 static void sn_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
                               size_t size, enum dma_data_direction dir,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         struct pci_dev *pdev = to_pci_dev(dev);
         struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
@@ -240,7 +237,7 @@ static void sn_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
  */
 static void sn_dma_unmap_sg(struct device *dev, struct scatterlist *sgl,
                             int nhwentries, enum dma_data_direction dir,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         int i;
         struct pci_dev *pdev = to_pci_dev(dev);
@@ -273,16 +270,13 @@ static void sn_dma_unmap_sg(struct device *dev, struct scatterlist *sgl,
  */
 static int sn_dma_map_sg(struct device *dev, struct scatterlist *sgl,
                          int nhwentries, enum dma_data_direction dir,
-                         struct dma_attrs *attrs)
+                         unsigned long attrs)
 {
         unsigned long phys_addr;
         struct scatterlist *saved_sg = sgl, *sg;
         struct pci_dev *pdev = to_pci_dev(dev);
         struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
         int i;
-        int dmabarr;
-
-        dmabarr = dma_get_attr(DMA_ATTR_WRITE_BARRIER, attrs);
 
         BUG_ON(!dev_is_pci(dev));
 
@@ -292,7 +286,7 @@ static int sn_dma_map_sg(struct device *dev, struct scatterlist *sgl,
         for_each_sg(sgl, sg, nhwentries, i) {
                 dma_addr_t dma_addr;
                 phys_addr = SG_ENT_PHYS_ADDRESS(sg);
-                if (dmabarr)
+                if (attrs & DMA_ATTR_WRITE_BARRIER)
                         dma_addr = provider->dma_map_consistent(pdev,
                                                                 phys_addr,
                                                                 sg->length,
diff --git a/arch/m68k/kernel/dma.c b/arch/m68k/kernel/dma.c
index cbc78b4117b5..8cf97cbadc91 100644
--- a/arch/m68k/kernel/dma.c
+++ b/arch/m68k/kernel/dma.c
@@ -19,7 +19,7 @@
 #if defined(CONFIG_MMU) && !defined(CONFIG_COLDFIRE)
 
 static void *m68k_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
-                gfp_t flag, struct dma_attrs *attrs)
+                gfp_t flag, unsigned long attrs)
 {
         struct page *page, **map;
         pgprot_t pgprot;
@@ -62,7 +62,7 @@ static void *m68k_dma_alloc(struct device *dev, size_t size, dma_addr_t *handle,
 }
 
 static void m68k_dma_free(struct device *dev, size_t size, void *addr,
-                dma_addr_t handle, struct dma_attrs *attrs)
+                dma_addr_t handle, unsigned long attrs)
 {
         pr_debug("dma_free_coherent: %p, %x\n", addr, handle);
         vfree(addr);
@@ -73,7 +73,7 @@ static void m68k_dma_free(struct device *dev, size_t size, void *addr,
 #include <asm/cacheflush.h>
 
 static void *m68k_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t gfp, struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         void *ret;
         /* ignore region specifiers */
@@ -91,7 +91,7 @@ static void *m68k_dma_alloc(struct device *dev, size_t size,
 }
 
 static void m68k_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         free_pages((unsigned long)vaddr, get_order(size));
 }
@@ -130,7 +130,7 @@ static void m68k_dma_sync_sg_for_device(struct device *dev,
 
 static dma_addr_t m68k_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         dma_addr_t handle = page_to_phys(page) + offset;
 
@@ -139,7 +139,7 @@ static dma_addr_t m68k_dma_map_page(struct device *dev, struct page *page,
 }
 
 static int m68k_dma_map_sg(struct device *dev, struct scatterlist *sglist,
-                int nents, enum dma_data_direction dir, struct dma_attrs *attrs)
+                int nents, enum dma_data_direction dir, unsigned long attrs)
 {
         int i;
         struct scatterlist *sg;
diff --git a/arch/metag/kernel/dma.c b/arch/metag/kernel/dma.c
index e12368d02155..0db31e24c541 100644
--- a/arch/metag/kernel/dma.c
+++ b/arch/metag/kernel/dma.c
@@ -172,7 +172,7 @@ out:
  * virtual and bus address for that space.
  */
 static void *metag_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *handle, gfp_t gfp, struct dma_attrs *attrs)
+                dma_addr_t *handle, gfp_t gfp, unsigned long attrs)
 {
         struct page *page;
         struct metag_vm_region *c;
@@ -268,7 +268,7 @@ no_page:
  * free a page as defined by the above mapping.
  */
 static void metag_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         struct metag_vm_region *c;
         unsigned long flags, addr;
@@ -331,13 +331,13 @@ no_area:
 
 static int metag_dma_mmap(struct device *dev, struct vm_area_struct *vma,
                 void *cpu_addr, dma_addr_t dma_addr, size_t size,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         unsigned long flags, user_size, kern_size;
         struct metag_vm_region *c;
         int ret = -ENXIO;
 
-        if (dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs))
+        if (attrs & DMA_ATTR_WRITE_COMBINE)
                 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
         else
                 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
@@ -482,7 +482,7 @@ static void dma_sync_for_cpu(void *vaddr, size_t size, int dma_direction)
 
 static dma_addr_t metag_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size,
-                enum dma_data_direction direction, struct dma_attrs *attrs)
+                enum dma_data_direction direction, unsigned long attrs)
 {
         dma_sync_for_device((void *)(page_to_phys(page) + offset), size,
                             direction);
@@ -491,14 +491,14 @@ static dma_addr_t metag_dma_map_page(struct device *dev, struct page *page,
 
 static void metag_dma_unmap_page(struct device *dev, dma_addr_t dma_address,
                 size_t size, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         dma_sync_for_cpu(phys_to_virt(dma_address), size, direction);
 }
 
 static int metag_dma_map_sg(struct device *dev, struct scatterlist *sglist,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -516,7 +516,7 @@ static int metag_dma_map_sg(struct device *dev, struct scatterlist *sglist,
 
 static void metag_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
                 int nhwentries, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
diff --git a/arch/microblaze/include/asm/dma-mapping.h b/arch/microblaze/include/asm/dma-mapping.h
index 1884783d15c0..1768d4bdc8d3 100644
--- a/arch/microblaze/include/asm/dma-mapping.h
+++ b/arch/microblaze/include/asm/dma-mapping.h
@@ -25,7 +25,6 @@
 #include <linux/mm.h>
 #include <linux/scatterlist.h>
 #include <linux/dma-debug.h>
-#include <linux/dma-attrs.h>
 #include <asm/io.h>
 #include <asm/cacheflush.h>
 
diff --git a/arch/microblaze/kernel/dma.c b/arch/microblaze/kernel/dma.c
index bf4dec229437..ec04dc1e2527 100644
--- a/arch/microblaze/kernel/dma.c
+++ b/arch/microblaze/kernel/dma.c
@@ -17,7 +17,7 @@
 
 static void *dma_direct_alloc_coherent(struct device *dev, size_t size,
                                        dma_addr_t *dma_handle, gfp_t flag,
-                                       struct dma_attrs *attrs)
+                                       unsigned long attrs)
 {
 #ifdef NOT_COHERENT_CACHE
         return consistent_alloc(flag, size, dma_handle);
@@ -42,7 +42,7 @@ static void *dma_direct_alloc_coherent(struct device *dev, size_t size,
 
 static void dma_direct_free_coherent(struct device *dev, size_t size,
                                      void *vaddr, dma_addr_t dma_handle,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
 #ifdef NOT_COHERENT_CACHE
         consistent_free(size, vaddr);
@@ -53,7 +53,7 @@ static void dma_direct_free_coherent(struct device *dev, size_t size,
 
 static int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl,
                              int nents, enum dma_data_direction direction,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -78,7 +78,7 @@ static inline dma_addr_t dma_direct_map_page(struct device *dev,
                                              unsigned long offset,
                                              size_t size,
                                              enum dma_data_direction direction,
-                                             struct dma_attrs *attrs)
+                                             unsigned long attrs)
 {
         __dma_sync(page_to_phys(page) + offset, size, direction);
         return page_to_phys(page) + offset;
@@ -88,7 +88,7 @@ static inline void dma_direct_unmap_page(struct device *dev,
                                          dma_addr_t dma_address,
                                          size_t size,
                                          enum dma_data_direction direction,
-                                         struct dma_attrs *attrs)
+                                         unsigned long attrs)
 {
 /* There is not necessary to do cache cleanup
  *
@@ -157,7 +157,7 @@ dma_direct_sync_sg_for_device(struct device *dev,
 static
 int dma_direct_mmap_coherent(struct device *dev, struct vm_area_struct *vma,
                              void *cpu_addr, dma_addr_t handle, size_t size,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
 #ifdef CONFIG_MMU
         unsigned long user_count = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
diff --git a/arch/mips/cavium-octeon/dma-octeon.c b/arch/mips/cavium-octeon/dma-octeon.c
index 2cd45f5f9481..fd69528b24fb 100644
--- a/arch/mips/cavium-octeon/dma-octeon.c
+++ b/arch/mips/cavium-octeon/dma-octeon.c
@@ -125,7 +125,7 @@ static phys_addr_t octeon_small_dma_to_phys(struct device *dev,
 
 static dma_addr_t octeon_dma_map_page(struct device *dev, struct page *page,
         unsigned long offset, size_t size, enum dma_data_direction direction,
-        struct dma_attrs *attrs)
+        unsigned long attrs)
 {
         dma_addr_t daddr = swiotlb_map_page(dev, page, offset, size,
                                             direction, attrs);
@@ -135,7 +135,7 @@ static dma_addr_t octeon_dma_map_page(struct device *dev, struct page *page,
 }
 
 static int octeon_dma_map_sg(struct device *dev, struct scatterlist *sg,
-        int nents, enum dma_data_direction direction, struct dma_attrs *attrs)
+        int nents, enum dma_data_direction direction, unsigned long attrs)
 {
         int r = swiotlb_map_sg_attrs(dev, sg, nents, direction, attrs);
         mb();
@@ -157,7 +157,7 @@ static void octeon_dma_sync_sg_for_device(struct device *dev,
 }
 
 static void *octeon_dma_alloc_coherent(struct device *dev, size_t size,
-        dma_addr_t *dma_handle, gfp_t gfp, struct dma_attrs *attrs)
+        dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         void *ret;
 
@@ -189,7 +189,7 @@ static void *octeon_dma_alloc_coherent(struct device *dev, size_t size,
 }
 
 static void octeon_dma_free_coherent(struct device *dev, size_t size,
-        void *vaddr, dma_addr_t dma_handle, struct dma_attrs *attrs)
+        void *vaddr, dma_addr_t dma_handle, unsigned long attrs)
 {
         swiotlb_free_coherent(dev, size, vaddr, dma_handle);
 }
diff --git a/arch/mips/include/asm/mips-cm.h b/arch/mips/include/asm/mips-cm.h
index 9411a4c0bdad..58e7874e9347 100644
--- a/arch/mips/include/asm/mips-cm.h
+++ b/arch/mips/include/asm/mips-cm.h
@@ -462,7 +462,7 @@ static inline unsigned int mips_cm_max_vp_width(void)
         if (mips_cm_revision() >= CM_REV_CM3)
                 return read_gcr_sys_config2() & CM_GCR_SYS_CONFIG2_MAXVPW_MSK;
 
-        if (config_enabled(CONFIG_SMP))
+        if (IS_ENABLED(CONFIG_SMP))
                 return smp_num_siblings;
 
         return 1;
diff --git a/arch/mips/include/asm/pgtable.h b/arch/mips/include/asm/pgtable.h
index 7d44e888134f..70128d3f770a 100644
--- a/arch/mips/include/asm/pgtable.h
+++ b/arch/mips/include/asm/pgtable.h
@@ -159,7 +159,7 @@ static inline void set_pte(pte_t *ptep, pte_t pte)
                  * it better already be global)
                  */
                 if (pte_none(*buddy)) {
-                        if (!config_enabled(CONFIG_XPA))
+                        if (!IS_ENABLED(CONFIG_XPA))
                                 buddy->pte_low |= _PAGE_GLOBAL;
                         buddy->pte_high |= _PAGE_GLOBAL;
                 }
@@ -172,7 +172,7 @@ static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *pt
 
         htw_stop();
         /* Preserve global status for the pair */
-        if (config_enabled(CONFIG_XPA)) {
+        if (IS_ENABLED(CONFIG_XPA)) {
                 if (ptep_buddy(ptep)->pte_high & _PAGE_GLOBAL)
                         null.pte_high = _PAGE_GLOBAL;
         } else {
@@ -319,7 +319,7 @@ static inline int pte_young(pte_t pte)	{ return pte.pte_low & _PAGE_ACCESSED; }
 static inline pte_t pte_wrprotect(pte_t pte)
 {
         pte.pte_low  &= ~_PAGE_WRITE;
-        if (!config_enabled(CONFIG_XPA))
+        if (!IS_ENABLED(CONFIG_XPA))
                 pte.pte_low &= ~_PAGE_SILENT_WRITE;
         pte.pte_high &= ~_PAGE_SILENT_WRITE;
         return pte;
@@ -328,7 +328,7 @@ static inline pte_t pte_wrprotect(pte_t pte)
 static inline pte_t pte_mkclean(pte_t pte)
 {
         pte.pte_low  &= ~_PAGE_MODIFIED;
-        if (!config_enabled(CONFIG_XPA))
+        if (!IS_ENABLED(CONFIG_XPA))
                 pte.pte_low &= ~_PAGE_SILENT_WRITE;
         pte.pte_high &= ~_PAGE_SILENT_WRITE;
         return pte;
@@ -337,7 +337,7 @@ static inline pte_t pte_mkclean(pte_t pte)
 static inline pte_t pte_mkold(pte_t pte)
 {
         pte.pte_low  &= ~_PAGE_ACCESSED;
-        if (!config_enabled(CONFIG_XPA))
+        if (!IS_ENABLED(CONFIG_XPA))
                 pte.pte_low &= ~_PAGE_SILENT_READ;
         pte.pte_high &= ~_PAGE_SILENT_READ;
         return pte;
@@ -347,7 +347,7 @@ static inline pte_t pte_mkwrite(pte_t pte)
 {
         pte.pte_low |= _PAGE_WRITE;
         if (pte.pte_low & _PAGE_MODIFIED) {
-                if (!config_enabled(CONFIG_XPA))
+                if (!IS_ENABLED(CONFIG_XPA))
                         pte.pte_low |= _PAGE_SILENT_WRITE;
                 pte.pte_high |= _PAGE_SILENT_WRITE;
         }
@@ -358,7 +358,7 @@ static inline pte_t pte_mkdirty(pte_t pte)
 {
         pte.pte_low |= _PAGE_MODIFIED;
         if (pte.pte_low & _PAGE_WRITE) {
-                if (!config_enabled(CONFIG_XPA))
+                if (!IS_ENABLED(CONFIG_XPA))
                         pte.pte_low |= _PAGE_SILENT_WRITE;
                 pte.pte_high |= _PAGE_SILENT_WRITE;
         }
@@ -369,7 +369,7 @@ static inline pte_t pte_mkyoung(pte_t pte)
 {
         pte.pte_low |= _PAGE_ACCESSED;
         if (!(pte.pte_low & _PAGE_NO_READ)) {
-                if (!config_enabled(CONFIG_XPA))
+                if (!IS_ENABLED(CONFIG_XPA))
                         pte.pte_low |= _PAGE_SILENT_READ;
                 pte.pte_high |= _PAGE_SILENT_READ;
         }
diff --git a/arch/mips/include/asm/seccomp.h b/arch/mips/include/asm/seccomp.h
index 684fb3a12ed3..d886d6f7687a 100644
--- a/arch/mips/include/asm/seccomp.h
+++ b/arch/mips/include/asm/seccomp.h
@@ -16,10 +16,10 @@ static inline const int *get_compat_mode1_syscalls(void)
                 0, /* null terminated */
         };
 
-        if (config_enabled(CONFIG_MIPS32_O32) && test_thread_flag(TIF_32BIT_REGS))
+        if (IS_ENABLED(CONFIG_MIPS32_O32) && test_thread_flag(TIF_32BIT_REGS))
                 return syscalls_O32;
 
-        if (config_enabled(CONFIG_MIPS32_N32))
+        if (IS_ENABLED(CONFIG_MIPS32_N32))
                 return syscalls_N32;
 
         BUG();
diff --git a/arch/mips/include/asm/signal.h b/arch/mips/include/asm/signal.h
index 2292373ff11a..82eae1583bcf 100644
--- a/arch/mips/include/asm/signal.h
+++ b/arch/mips/include/asm/signal.h
@@ -19,8 +19,8 @@ extern struct mips_abi mips_abi_32;
                 ((ka)->sa.sa_flags & SA_SIGINFO))
 #else
 #define sig_uses_siginfo(ka, abi)                               \
-        (config_enabled(CONFIG_64BIT) ? 1 :                     \
-                (config_enabled(CONFIG_TRAD_SIGNALS) ?          \
+        (IS_ENABLED(CONFIG_64BIT) ? 1 :                     \
+                (IS_ENABLED(CONFIG_TRAD_SIGNALS) ?          \
                         ((ka)->sa.sa_flags & SA_SIGINFO) : 1) )
 #endif
 
diff --git a/arch/mips/include/asm/syscall.h b/arch/mips/include/asm/syscall.h
index 47bc45a67e9b..d87882513ee3 100644
--- a/arch/mips/include/asm/syscall.h
+++ b/arch/mips/include/asm/syscall.h
@@ -99,7 +99,7 @@ static inline void syscall_get_arguments(struct task_struct *task,
 {
         int ret;
         /* O32 ABI syscall() - Either 64-bit with O32 or 32-bit */
-        if ((config_enabled(CONFIG_32BIT) ||
+        if ((IS_ENABLED(CONFIG_32BIT) ||
             test_tsk_thread_flag(task, TIF_32BIT_REGS)) &&
             (regs->regs[2] == __NR_syscall))
                 i++;
diff --git a/arch/mips/include/asm/uaccess.h b/arch/mips/include/asm/uaccess.h
index 7f109d4f64a4..11b965f98d95 100644
--- a/arch/mips/include/asm/uaccess.h
+++ b/arch/mips/include/asm/uaccess.h
@@ -88,7 +88,7 @@ extern u64 __ua_limit;
  */
 static inline bool eva_kernel_access(void)
 {
-        if (!config_enabled(CONFIG_EVA))
+        if (!IS_ENABLED(CONFIG_EVA))
                 return false;
 
         return segment_eq(get_fs(), get_ds());
diff --git a/arch/mips/jz4740/setup.c b/arch/mips/jz4740/setup.c
index 0914ef775b5f..6d0152321819 100644
--- a/arch/mips/jz4740/setup.c
+++ b/arch/mips/jz4740/setup.c
@@ -75,7 +75,7 @@ void __init device_tree_init(void)
 
 const char *get_system_type(void)
 {
-        if (config_enabled(CONFIG_MACH_JZ4780))
+        if (IS_ENABLED(CONFIG_MACH_JZ4780))
                 return "JZ4780";
 
         return "JZ4740";
diff --git a/arch/mips/kernel/cpu-bugs64.c b/arch/mips/kernel/cpu-bugs64.c
index 6392dbe504fb..a378e44688f5 100644
--- a/arch/mips/kernel/cpu-bugs64.c
+++ b/arch/mips/kernel/cpu-bugs64.c
@@ -244,7 +244,7 @@ static inline void check_daddi(void)
         panic(bug64hit, !DADDI_WAR ? daddiwar : nowar);
 }
 
-int daddiu_bug  = config_enabled(CONFIG_CPU_MIPSR6) ? 0 : -1;
+int daddiu_bug  = IS_ENABLED(CONFIG_CPU_MIPSR6) ? 0 : -1;
 
 static inline void check_daddiu(void)
 {
@@ -314,7 +314,7 @@ static inline void check_daddiu(void)
 
 void __init check_bugs64_early(void)
 {
-        if (!config_enabled(CONFIG_CPU_MIPSR6)) {
+        if (!IS_ENABLED(CONFIG_CPU_MIPSR6)) {
                 check_mult_sh();
                 check_daddiu();
         }
@@ -322,6 +322,6 @@ void __init check_bugs64_early(void)
 
 void __init check_bugs64(void)
 {
-        if (!config_enabled(CONFIG_CPU_MIPSR6))
+        if (!IS_ENABLED(CONFIG_CPU_MIPSR6))
                 check_daddi();
 }
diff --git a/arch/mips/kernel/elf.c b/arch/mips/kernel/elf.c
index 891f5ee63983..e6eb7f1f7723 100644
--- a/arch/mips/kernel/elf.c
+++ b/arch/mips/kernel/elf.c
@@ -179,7 +179,7 @@ int arch_check_elf(void *_ehdr, bool has_interpreter, void *_interp_ehdr,
                         return -ELIBBAD;
         }
 
-        if (!config_enabled(CONFIG_MIPS_O32_FP64_SUPPORT))
+        if (!IS_ENABLED(CONFIG_MIPS_O32_FP64_SUPPORT))
                 return 0;
 
         fp_abi = state->fp_abi;
@@ -285,7 +285,7 @@ void mips_set_personality_fp(struct arch_elf_state *state)
          * not be worried about N32/N64 binaries.
          */
 
-        if (!config_enabled(CONFIG_MIPS_O32_FP64_SUPPORT))
+        if (!IS_ENABLED(CONFIG_MIPS_O32_FP64_SUPPORT))
                 return;
 
         switch (state->overall_fp_mode) {
diff --git a/arch/mips/kernel/mips-cm.c b/arch/mips/kernel/mips-cm.c
index 760217bbb2fa..659e6d3ae335 100644
--- a/arch/mips/kernel/mips-cm.c
+++ b/arch/mips/kernel/mips-cm.c
@@ -251,7 +251,7 @@ int mips_cm_probe(void)
         mips_cm_probe_l2sync();
 
         /* determine register width for this CM */
-        mips_cm_is64 = config_enabled(CONFIG_64BIT) && (mips_cm_revision() >= CM_REV_CM3);
+        mips_cm_is64 = IS_ENABLED(CONFIG_64BIT) && (mips_cm_revision() >= CM_REV_CM3);
 
         for_each_possible_cpu(cpu)
                 spin_lock_init(&per_cpu(cm_core_lock, cpu));
diff --git a/arch/mips/kernel/mips-r2-to-r6-emul.c b/arch/mips/kernel/mips-r2-to-r6-emul.c
index 7ff2a557f4aa..43fbadc78d0a 100644
--- a/arch/mips/kernel/mips-r2-to-r6-emul.c
+++ b/arch/mips/kernel/mips-r2-to-r6-emul.c
@@ -84,7 +84,7 @@ static inline int mipsr6_emul(struct pt_regs *regs, u32 ir)
                                 (s32)MIPSInst_SIMM(ir);
                 return 0;
         case daddiu_op:
-                if (config_enabled(CONFIG_32BIT))
+                if (IS_ENABLED(CONFIG_32BIT))
                         break;
 
                 if (MIPSInst_RT(ir))
@@ -143,7 +143,7 @@ static inline int mipsr6_emul(struct pt_regs *regs, u32 ir)
                                               (u32)regs->regs[MIPSInst_RT(ir)]);
                         return 0;
                 case dsll_op:
-                        if (config_enabled(CONFIG_32BIT) || MIPSInst_RS(ir))
+                        if (IS_ENABLED(CONFIG_32BIT) || MIPSInst_RS(ir))
                                 break;
 
                         if (MIPSInst_RD(ir))
@@ -152,7 +152,7 @@ static inline int mipsr6_emul(struct pt_regs *regs, u32 ir)
                                                 MIPSInst_FD(ir));
                         return 0;
                 case dsrl_op:
-                        if (config_enabled(CONFIG_32BIT) || MIPSInst_RS(ir))
+                        if (IS_ENABLED(CONFIG_32BIT) || MIPSInst_RS(ir))
                                 break;
 
                         if (MIPSInst_RD(ir))
@@ -161,7 +161,7 @@ static inline int mipsr6_emul(struct pt_regs *regs, u32 ir)
                                                 MIPSInst_FD(ir));
                         return 0;
                 case daddu_op:
-                        if (config_enabled(CONFIG_32BIT) || MIPSInst_FD(ir))
+                        if (IS_ENABLED(CONFIG_32BIT) || MIPSInst_FD(ir))
                                 break;
 
                         if (MIPSInst_RD(ir))
@@ -170,7 +170,7 @@ static inline int mipsr6_emul(struct pt_regs *regs, u32 ir)
                                         (u64)regs->regs[MIPSInst_RT(ir)];
                         return 0;
                 case dsubu_op:
-                        if (config_enabled(CONFIG_32BIT) || MIPSInst_FD(ir))
+                        if (IS_ENABLED(CONFIG_32BIT) || MIPSInst_FD(ir))
                                 break;
 
                         if (MIPSInst_RD(ir))
@@ -498,7 +498,7 @@ static int dmult_func(struct pt_regs *regs, u32 ir)
         s64 res;
         s64 rt, rs;
 
-        if (config_enabled(CONFIG_32BIT))
+        if (IS_ENABLED(CONFIG_32BIT))
                 return SIGILL;
 
         rt = regs->regs[MIPSInst_RT(ir)];
@@ -530,7 +530,7 @@ static int dmultu_func(struct pt_regs *regs, u32 ir)
         u64 res;
         u64 rt, rs;
 
-        if (config_enabled(CONFIG_32BIT))
+        if (IS_ENABLED(CONFIG_32BIT))
                 return SIGILL;
 
         rt = regs->regs[MIPSInst_RT(ir)];
@@ -561,7 +561,7 @@ static int ddiv_func(struct pt_regs *regs, u32 ir)
 {
         s64 rt, rs;
 
-        if (config_enabled(CONFIG_32BIT))
+        if (IS_ENABLED(CONFIG_32BIT))
                 return SIGILL;
 
         rt = regs->regs[MIPSInst_RT(ir)];
@@ -586,7 +586,7 @@ static int ddivu_func(struct pt_regs *regs, u32 ir)
 {
         u64 rt, rs;
 
-        if (config_enabled(CONFIG_32BIT))
+        if (IS_ENABLED(CONFIG_32BIT))
                 return SIGILL;
 
         rt = regs->regs[MIPSInst_RT(ir)];
@@ -825,7 +825,7 @@ static int dclz_func(struct pt_regs *regs, u32 ir)
         u64 res;
         u64 rs;
 
-        if (config_enabled(CONFIG_32BIT))
+        if (IS_ENABLED(CONFIG_32BIT))
                 return SIGILL;
 
         if (!MIPSInst_RD(ir))
@@ -852,7 +852,7 @@ static int dclo_func(struct pt_regs *regs, u32 ir)
         u64 res;
         u64 rs;
 
-        if (config_enabled(CONFIG_32BIT))
+        if (IS_ENABLED(CONFIG_32BIT))
                 return SIGILL;
 
         if (!MIPSInst_RD(ir))
@@ -1484,7 +1484,7 @@ fpu_emul:
                 break;
 
         case ldl_op:
-                if (config_enabled(CONFIG_32BIT)) {
+                if (IS_ENABLED(CONFIG_32BIT)) {
                     err = SIGILL;
                     break;
                 }
@@ -1603,7 +1603,7 @@ fpu_emul:
                 break;
 
         case ldr_op:
-                if (config_enabled(CONFIG_32BIT)) {
+                if (IS_ENABLED(CONFIG_32BIT)) {
                     err = SIGILL;
                     break;
                 }
@@ -1722,7 +1722,7 @@ fpu_emul:
                 break;
 
         case sdl_op:
-                if (config_enabled(CONFIG_32BIT)) {
+                if (IS_ENABLED(CONFIG_32BIT)) {
                     err = SIGILL;
                     break;
                 }
@@ -1840,7 +1840,7 @@ fpu_emul:
                 break;
 
         case sdr_op:
-                if (config_enabled(CONFIG_32BIT)) {
+                if (IS_ENABLED(CONFIG_32BIT)) {
                     err = SIGILL;
                     break;
                 }
@@ -2072,7 +2072,7 @@ fpu_emul:
                 break;
 
         case lld_op:
-                if (config_enabled(CONFIG_32BIT)) {
+                if (IS_ENABLED(CONFIG_32BIT)) {
                     err = SIGILL;
                     break;
                 }
@@ -2133,7 +2133,7 @@ fpu_emul:
                 break;
 
         case scd_op:
-                if (config_enabled(CONFIG_32BIT)) {
+                if (IS_ENABLED(CONFIG_32BIT)) {
                     err = SIGILL;
                     break;
                 }
diff --git a/arch/mips/kernel/pm-cps.c b/arch/mips/kernel/pm-cps.c
index adda3ffb9b78..5b31a9405ebc 100644
--- a/arch/mips/kernel/pm-cps.c
+++ b/arch/mips/kernel/pm-cps.c
@@ -148,7 +148,7 @@ int cps_pm_enter_state(enum cps_pm_state state)
         }
 
         /* Setup the VPE to run mips_cps_pm_restore when started again */
-        if (config_enabled(CONFIG_CPU_PM) && state == CPS_PM_POWER_GATED) {
+        if (IS_ENABLED(CONFIG_CPU_PM) && state == CPS_PM_POWER_GATED) {
                 /* Power gating relies upon CPS SMP */
                 if (!mips_cps_smp_in_use())
                         return -EINVAL;
@@ -387,7 +387,7 @@ static void * __init cps_gen_entry_code(unsigned cpu, enum cps_pm_state state)
         memset(labels, 0, sizeof(labels));
         memset(relocs, 0, sizeof(relocs));
 
-        if (config_enabled(CONFIG_CPU_PM) && state == CPS_PM_POWER_GATED) {
+        if (IS_ENABLED(CONFIG_CPU_PM) && state == CPS_PM_POWER_GATED) {
                 /* Power gating relies upon CPS SMP */
                 if (!mips_cps_smp_in_use())
                         goto out_err;
diff --git a/arch/mips/kernel/signal.c b/arch/mips/kernel/signal.c
index ae4231452115..1975cd2f7de6 100644
--- a/arch/mips/kernel/signal.c
+++ b/arch/mips/kernel/signal.c
@@ -165,7 +165,7 @@ static int save_msa_extcontext(void __user *buf)
                  * should already have been done when handling scalar FP
                  * context.
                  */
-                BUG_ON(config_enabled(CONFIG_EVA));
+                BUG_ON(IS_ENABLED(CONFIG_EVA));
 
                 err = __put_user(read_msa_csr(), &msa->csr);
                 err |= _save_msa_all_upper(&msa->wr);
@@ -195,7 +195,7 @@ static int restore_msa_extcontext(void __user *buf, unsigned int size)
         unsigned int csr;
         int i, err;
 
-        if (!config_enabled(CONFIG_CPU_HAS_MSA))
+        if (!IS_ENABLED(CONFIG_CPU_HAS_MSA))
                 return SIGSYS;
 
         if (size != sizeof(*msa))
@@ -215,7 +215,7 @@ static int restore_msa_extcontext(void __user *buf, unsigned int size)
                  * scalar FP context, so FPU & MSA should have already been
                  * disabled whilst handling scalar FP context.
                  */
-                BUG_ON(config_enabled(CONFIG_EVA));
+                BUG_ON(IS_ENABLED(CONFIG_EVA));
 
                 write_msa_csr(csr);
                 err |= _restore_msa_all_upper(&msa->wr);
@@ -315,7 +315,7 @@ int protected_save_fp_context(void __user *sc)
          * EVA does not have userland equivalents of ldc1 or sdc1, so
          * save to the kernel FP context & copy that to userland below.
          */
-        if (config_enabled(CONFIG_EVA))
+        if (IS_ENABLED(CONFIG_EVA))
                 lose_fpu(1);
 
         while (1) {
@@ -378,7 +378,7 @@ int protected_restore_fp_context(void __user *sc)
          * disable the FPU here such that the code below simply copies to
          * the kernel FP context.
          */
-        if (config_enabled(CONFIG_EVA))
+        if (IS_ENABLED(CONFIG_EVA))
                 lose_fpu(0);
 
         while (1) {
diff --git a/arch/mips/kernel/smp-cps.c b/arch/mips/kernel/smp-cps.c
index 4ed36f288d64..05b3201271b4 100644
--- a/arch/mips/kernel/smp-cps.c
+++ b/arch/mips/kernel/smp-cps.c
@@ -46,8 +46,8 @@ static unsigned core_vpe_count(unsigned core)
         if (threads_disabled)
                 return 1;
 
-        if ((!config_enabled(CONFIG_MIPS_MT_SMP) || !cpu_has_mipsmt)
-                && (!config_enabled(CONFIG_CPU_MIPSR6) || !cpu_has_vp))
+        if ((!IS_ENABLED(CONFIG_MIPS_MT_SMP) || !cpu_has_mipsmt)
+                && (!IS_ENABLED(CONFIG_CPU_MIPSR6) || !cpu_has_vp))
                 return 1;
 
         mips_cm_lock_other(core, 0);
diff --git a/arch/mips/kernel/unaligned.c b/arch/mips/kernel/unaligned.c
index 28b3af73a17b..f1c308dbbc4a 100644
--- a/arch/mips/kernel/unaligned.c
+++ b/arch/mips/kernel/unaligned.c
@@ -1025,7 +1025,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                 if (!access_ok(VERIFY_READ, addr, 2))
                         goto sigbus;
 
-                if (config_enabled(CONFIG_EVA)) {
+                if (IS_ENABLED(CONFIG_EVA)) {
                         if (segment_eq(get_fs(), get_ds()))
                                 LoadHW(addr, value, res);
                         else
@@ -1044,7 +1044,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                 if (!access_ok(VERIFY_READ, addr, 4))
                         goto sigbus;
 
-                if (config_enabled(CONFIG_EVA)) {
+                if (IS_ENABLED(CONFIG_EVA)) {
                         if (segment_eq(get_fs(), get_ds()))
                                 LoadW(addr, value, res);
                         else
@@ -1063,7 +1063,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                 if (!access_ok(VERIFY_READ, addr, 2))
                         goto sigbus;
 
-                if (config_enabled(CONFIG_EVA)) {
+                if (IS_ENABLED(CONFIG_EVA)) {
                         if (segment_eq(get_fs(), get_ds()))
                                 LoadHWU(addr, value, res);
                         else
@@ -1131,7 +1131,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                 compute_return_epc(regs);
                 value = regs->regs[insn.i_format.rt];
 
-                if (config_enabled(CONFIG_EVA)) {
+                if (IS_ENABLED(CONFIG_EVA)) {
                         if (segment_eq(get_fs(), get_ds()))
                                 StoreHW(addr, value, res);
                         else
@@ -1151,7 +1151,7 @@ static void emulate_load_store_insn(struct pt_regs *regs,
                 compute_return_epc(regs);
                 value = regs->regs[insn.i_format.rt];
 
-                if (config_enabled(CONFIG_EVA)) {
+                if (IS_ENABLED(CONFIG_EVA)) {
                         if (segment_eq(get_fs(), get_ds()))
                                 StoreW(addr, value, res);
                         else
diff --git a/arch/mips/loongson64/common/dma-swiotlb.c b/arch/mips/loongson64/common/dma-swiotlb.c
index 4ffa6fc81c8f..1a80b6f73ab2 100644
--- a/arch/mips/loongson64/common/dma-swiotlb.c
+++ b/arch/mips/loongson64/common/dma-swiotlb.c
@@ -10,7 +10,7 @@
 #include <dma-coherence.h>
 
 static void *loongson_dma_alloc_coherent(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t gfp, struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         void *ret;
 
@@ -41,7 +41,7 @@ static void *loongson_dma_alloc_coherent(struct device *dev, size_t size,
 }
 
 static void loongson_dma_free_coherent(struct device *dev, size_t size,
-                void *vaddr, dma_addr_t dma_handle, struct dma_attrs *attrs)
+                void *vaddr, dma_addr_t dma_handle, unsigned long attrs)
 {
         swiotlb_free_coherent(dev, size, vaddr, dma_handle);
 }
@@ -49,7 +49,7 @@ static void loongson_dma_free_coherent(struct device *dev, size_t size,
 static dma_addr_t loongson_dma_map_page(struct device *dev, struct page *page,
                                 unsigned long offset, size_t size,
                                 enum dma_data_direction dir,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         dma_addr_t daddr = swiotlb_map_page(dev, page, offset, size,
                                         dir, attrs);
@@ -59,9 +59,9 @@ static dma_addr_t loongson_dma_map_page(struct device *dev, struct page *page,
 
 static int loongson_dma_map_sg(struct device *dev, struct scatterlist *sg,
                                 int nents, enum dma_data_direction dir,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
-        int r = swiotlb_map_sg_attrs(dev, sg, nents, dir, NULL);
+        int r = swiotlb_map_sg_attrs(dev, sg, nents, dir, 0);
         mb();
 
         return r;
diff --git a/arch/mips/math-emu/cp1emu.c b/arch/mips/math-emu/cp1emu.c
index 6dc07fba187f..92d15e68abb6 100644
--- a/arch/mips/math-emu/cp1emu.c
+++ b/arch/mips/math-emu/cp1emu.c
@@ -784,10 +784,10 @@ static int isBranchInstr(struct pt_regs *regs, struct mm_decoded_insn dec_insn,
  */
 static inline int cop1_64bit(struct pt_regs *xcp)
 {
-        if (config_enabled(CONFIG_64BIT) && !config_enabled(CONFIG_MIPS32_O32))
+        if (IS_ENABLED(CONFIG_64BIT) && !IS_ENABLED(CONFIG_MIPS32_O32))
                 return 1;
-        else if (config_enabled(CONFIG_32BIT) &&
-                 !config_enabled(CONFIG_MIPS_O32_FP64_SUPPORT))
+        else if (IS_ENABLED(CONFIG_32BIT) &&
+                 !IS_ENABLED(CONFIG_MIPS_O32_FP64_SUPPORT))
                 return 0;
 
         return !test_thread_flag(TIF_32BIT_FPREGS);
diff --git a/arch/mips/mm/dma-default.c b/arch/mips/mm/dma-default.c
index cb557d28cb21..b2eadd6fa9a1 100644
--- a/arch/mips/mm/dma-default.c
+++ b/arch/mips/mm/dma-default.c
@@ -131,7 +131,7 @@ static void *mips_dma_alloc_noncoherent(struct device *dev, size_t size,
 }
 
 static void *mips_dma_alloc_coherent(struct device *dev, size_t size,
-        dma_addr_t * dma_handle, gfp_t gfp, struct dma_attrs *attrs)
+        dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         void *ret;
         struct page *page = NULL;
@@ -141,7 +141,7 @@ static void *mips_dma_alloc_coherent(struct device *dev, size_t size,
          * XXX: seems like the coherent and non-coherent implementations could
          * be consolidated.
          */
-        if (dma_get_attr(DMA_ATTR_NON_CONSISTENT, attrs))
+        if (attrs & DMA_ATTR_NON_CONSISTENT)
                 return mips_dma_alloc_noncoherent(dev, size, dma_handle, gfp);
 
         gfp = massage_gfp_flags(dev, gfp);
@@ -176,13 +176,13 @@ static void mips_dma_free_noncoherent(struct device *dev, size_t size,
 }
 
 static void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
-        dma_addr_t dma_handle, struct dma_attrs *attrs)
+        dma_addr_t dma_handle, unsigned long attrs)
 {
         unsigned long addr = (unsigned long) vaddr;
         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
         struct page *page = NULL;
 
-        if (dma_get_attr(DMA_ATTR_NON_CONSISTENT, attrs)) {
+        if (attrs & DMA_ATTR_NON_CONSISTENT) {
                 mips_dma_free_noncoherent(dev, size, vaddr, dma_handle);
                 return;
         }
@@ -200,7 +200,7 @@ static void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
 
 static int mips_dma_mmap(struct device *dev, struct vm_area_struct *vma,
         void *cpu_addr, dma_addr_t dma_addr, size_t size,
-        struct dma_attrs *attrs)
+        unsigned long attrs)
 {
         unsigned long user_count = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
         unsigned long count = PAGE_ALIGN(size) >> PAGE_SHIFT;
@@ -214,7 +214,7 @@ static int mips_dma_mmap(struct device *dev, struct vm_area_struct *vma,
 
         pfn = page_to_pfn(virt_to_page((void *)addr));
 
-        if (dma_get_attr(DMA_ATTR_WRITE_COMBINE, attrs))
+        if (attrs & DMA_ATTR_WRITE_COMBINE)
                 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
         else
                 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
@@ -291,7 +291,7 @@ static inline void __dma_sync(struct page *page,
 }
 
 static void mips_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
-        size_t size, enum dma_data_direction direction, struct dma_attrs *attrs)
+        size_t size, enum dma_data_direction direction, unsigned long attrs)
 {
         if (cpu_needs_post_dma_flush(dev))
                 __dma_sync(dma_addr_to_page(dev, dma_addr),
@@ -301,7 +301,7 @@ static void mips_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
 }
 
 static int mips_dma_map_sg(struct device *dev, struct scatterlist *sglist,
-        int nents, enum dma_data_direction direction, struct dma_attrs *attrs)
+        int nents, enum dma_data_direction direction, unsigned long attrs)
 {
         int i;
         struct scatterlist *sg;
@@ -322,7 +322,7 @@ static int mips_dma_map_sg(struct device *dev, struct scatterlist *sglist,
 
 static dma_addr_t mips_dma_map_page(struct device *dev, struct page *page,
         unsigned long offset, size_t size, enum dma_data_direction direction,
-        struct dma_attrs *attrs)
+        unsigned long attrs)
 {
         if (!plat_device_is_coherent(dev))
                 __dma_sync(page, offset, size, direction);
@@ -332,7 +332,7 @@ static dma_addr_t mips_dma_map_page(struct device *dev, struct page *page,
 
 static void mips_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
         int nhwentries, enum dma_data_direction direction,
-        struct dma_attrs *attrs)
+        unsigned long attrs)
 {
         int i;
         struct scatterlist *sg;
diff --git a/arch/mips/mm/tlbex.c b/arch/mips/mm/tlbex.c
index 4004b659ce50..ff49b29c2d16 100644
--- a/arch/mips/mm/tlbex.c
+++ b/arch/mips/mm/tlbex.c
@@ -1025,7 +1025,7 @@ static void build_update_entries(u32 **p, unsigned int tmp, unsigned int ptep)
         pte_off_odd += offsetof(pte_t, pte_high);
 #endif
 
-        if (config_enabled(CONFIG_XPA)) {
+        if (IS_ENABLED(CONFIG_XPA)) {
                 uasm_i_lw(p, tmp, pte_off_even, ptep); /* even pte */
                 UASM_i_ROTR(p, tmp, tmp, ilog2(_PAGE_GLOBAL));
                 UASM_i_MTC0(p, tmp, C0_ENTRYLO0);
@@ -1643,7 +1643,7 @@ iPTE_SW(u32 **p, struct uasm_reloc **r, unsigned int pte, unsigned int ptr,
         unsigned int hwmode = mode & (_PAGE_VALID | _PAGE_DIRTY);
         unsigned int swmode = mode & ~hwmode;
 
-        if (config_enabled(CONFIG_XPA) && !cpu_has_64bits) {
+        if (IS_ENABLED(CONFIG_XPA) && !cpu_has_64bits) {
                 uasm_i_lui(p, scratch, swmode >> 16);
                 uasm_i_or(p, pte, pte, scratch);
                 BUG_ON(swmode & 0xffff);
@@ -2432,7 +2432,7 @@ static void config_htw_params(void)
                 pwsize |= ilog2(PTRS_PER_PMD) << MIPS_PWSIZE_MDW_SHIFT;
 
         /* Set pointer size to size of directory pointers */
-        if (config_enabled(CONFIG_64BIT))
+        if (IS_ENABLED(CONFIG_64BIT))
                 pwsize |= MIPS_PWSIZE_PS_MASK;
         /* PTEs may be multiple pointers long (e.g. with XPA) */
         pwsize |= ((PTE_T_LOG2 - PGD_T_LOG2) << MIPS_PWSIZE_PTEW_SHIFT)
@@ -2448,7 +2448,7 @@ static void config_htw_params(void)
          * the pwctl fields.
          */
         config = 1 << MIPS_PWCTL_PWEN_SHIFT;
-        if (config_enabled(CONFIG_64BIT))
+        if (IS_ENABLED(CONFIG_64BIT))
                 config |= MIPS_PWCTL_XU_MASK;
         write_c0_pwctl(config);
         pr_info("Hardware Page Table Walker enabled\n");
@@ -2522,7 +2522,7 @@ void build_tlb_refill_handler(void)
          */
         static int run_once = 0;
 
-        if (config_enabled(CONFIG_XPA) && !cpu_has_rixi)
+        if (IS_ENABLED(CONFIG_XPA) && !cpu_has_rixi)
                 panic("Kernels supporting XPA currently require CPUs with RIXI");
 
         output_pgtable_bits_defines();
diff --git a/arch/mips/mti-malta/malta-dtshim.c b/arch/mips/mti-malta/malta-dtshim.c
index f7133efc5843..151f4882ec8a 100644
--- a/arch/mips/mti-malta/malta-dtshim.c
+++ b/arch/mips/mti-malta/malta-dtshim.c
@@ -31,7 +31,7 @@ static unsigned __init gen_fdt_mem_array(__be32 *mem_array, unsigned long size)
 
         entries = 1;
         mem_array[0] = cpu_to_be32(PHYS_OFFSET);
-        if (config_enabled(CONFIG_EVA)) {
+        if (IS_ENABLED(CONFIG_EVA)) {
                 /*
                  * The current Malta EVA configuration is "special" in that it
                  * always makes use of addresses in the upper half of the 32 bit
@@ -82,7 +82,7 @@ static void __init append_memory(void *fdt, int root_off)
                 physical_memsize = 32 << 20;
         }
 
-        if (config_enabled(CONFIG_CPU_BIG_ENDIAN)) {
+        if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN)) {
                 /*
                  * SOC-it swaps, or perhaps doesn't swap, when DMA'ing
                  * the last word of physical memory.
diff --git a/arch/mips/mti-malta/malta-memory.c b/arch/mips/mti-malta/malta-memory.c
index d5f8dae6a797..a47556723b85 100644
--- a/arch/mips/mti-malta/malta-memory.c
+++ b/arch/mips/mti-malta/malta-memory.c
@@ -32,7 +32,7 @@ static void free_init_pages_eva_malta(void *begin, void *end)
 
 void __init fw_meminit(void)
 {
-        bool eva = config_enabled(CONFIG_EVA);
+        bool eva = IS_ENABLED(CONFIG_EVA);
 
         free_init_pages_eva = eva ? free_init_pages_eva_malta : NULL;
 }
diff --git a/arch/mips/mti-malta/malta-setup.c b/arch/mips/mti-malta/malta-setup.c
index 33d5ff5069e5..ec5b21678fad 100644
--- a/arch/mips/mti-malta/malta-setup.c
+++ b/arch/mips/mti-malta/malta-setup.c
@@ -261,7 +261,7 @@ void __init plat_mem_setup(void)
         fdt = malta_dt_shim(fdt);
         __dt_setup_arch(fdt);
 
-        if (config_enabled(CONFIG_EVA))
+        if (IS_ENABLED(CONFIG_EVA))
                 /* EVA has already been configured in mach-malta/kernel-init.h */
                 pr_info("Enhanced Virtual Addressing (EVA) activated\n");
 
diff --git a/arch/mips/net/bpf_jit.c b/arch/mips/net/bpf_jit.c
index 1a8c96035716..d1b7bd09253a 100644
--- a/arch/mips/net/bpf_jit.c
+++ b/arch/mips/net/bpf_jit.c
@@ -426,7 +426,7 @@ static inline void emit_load_ptr(unsigned int dst, unsigned int src,
 static inline void emit_load_func(unsigned int reg, ptr imm,
                                   struct jit_ctx *ctx)
 {
-        if (config_enabled(CONFIG_64BIT)) {
+        if (IS_ENABLED(CONFIG_64BIT)) {
                 /* At this point imm is always 64-bit */
                 emit_load_imm(r_tmp, (u64)imm >> 32, ctx);
                 emit_dsll(r_tmp_imm, r_tmp, 16, ctx); /* left shift by 16 */
@@ -516,7 +516,7 @@ static inline void emit_jr(unsigned int reg, struct jit_ctx *ctx)
 static inline u16 align_sp(unsigned int num)
 {
         /* Double word alignment for 32-bit, quadword for 64-bit */
-        unsigned int align = config_enabled(CONFIG_64BIT) ? 16 : 8;
+        unsigned int align = IS_ENABLED(CONFIG_64BIT) ? 16 : 8;
         num = (num + (align - 1)) & -align;
         return num;
 }
diff --git a/arch/mips/netlogic/common/nlm-dma.c b/arch/mips/netlogic/common/nlm-dma.c
index 3758715d4ab6..0630693bec2a 100644
--- a/arch/mips/netlogic/common/nlm-dma.c
+++ b/arch/mips/netlogic/common/nlm-dma.c
@@ -45,7 +45,7 @@
 static char *nlm_swiotlb;
 
 static void *nlm_dma_alloc_coherent(struct device *dev, size_t size,
-        dma_addr_t *dma_handle, gfp_t gfp, struct dma_attrs *attrs)
+        dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         /* ignore region specifiers */
         gfp &= ~(__GFP_DMA | __GFP_DMA32 | __GFP_HIGHMEM);
@@ -62,7 +62,7 @@ static void *nlm_dma_alloc_coherent(struct device *dev, size_t size,
 }
 
 static void nlm_dma_free_coherent(struct device *dev, size_t size,
-        void *vaddr, dma_addr_t dma_handle, struct dma_attrs *attrs)
+        void *vaddr, dma_addr_t dma_handle, unsigned long attrs)
 {
         swiotlb_free_coherent(dev, size, vaddr, dma_handle);
 }
diff --git a/arch/mn10300/mm/dma-alloc.c b/arch/mn10300/mm/dma-alloc.c
index 8842394cb49a..4f4b9029f0ea 100644
--- a/arch/mn10300/mm/dma-alloc.c
+++ b/arch/mn10300/mm/dma-alloc.c
@@ -21,7 +21,7 @@
 static unsigned long pci_sram_allocated = 0xbc000000;
 
 static void *mn10300_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t gfp, struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         unsigned long addr;
         void *ret;
@@ -63,7 +63,7 @@ done:
 }
 
 static void mn10300_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         unsigned long addr = (unsigned long) vaddr & ~0x20000000;
 
@@ -75,7 +75,7 @@ static void mn10300_dma_free(struct device *dev, size_t size, void *vaddr,
 
 static int mn10300_dma_map_sg(struct device *dev, struct scatterlist *sglist,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -92,7 +92,7 @@ static int mn10300_dma_map_sg(struct device *dev, struct scatterlist *sglist,
 
 static dma_addr_t mn10300_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size,
-                enum dma_data_direction direction, struct dma_attrs *attrs)
+                enum dma_data_direction direction, unsigned long attrs)
 {
         return page_to_bus(page) + offset;
 }
diff --git a/arch/nios2/mm/dma-mapping.c b/arch/nios2/mm/dma-mapping.c
index 90422c367ed3..d800fad87896 100644
--- a/arch/nios2/mm/dma-mapping.c
+++ b/arch/nios2/mm/dma-mapping.c
@@ -59,7 +59,7 @@ static inline void __dma_sync_for_cpu(void *vaddr, size_t size,
 }
 
 static void *nios2_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t gfp, struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 {
         void *ret;
 
@@ -84,7 +84,7 @@ static void *nios2_dma_alloc(struct device *dev, size_t size,
 }
 
 static void nios2_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         unsigned long addr = (unsigned long) CAC_ADDR((unsigned long) vaddr);
 
@@ -93,7 +93,7 @@ static void nios2_dma_free(struct device *dev, size_t size, void *vaddr,
 
 static int nios2_dma_map_sg(struct device *dev, struct scatterlist *sg,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         int i;
 
@@ -113,7 +113,7 @@ static int nios2_dma_map_sg(struct device *dev, struct scatterlist *sg,
 static dma_addr_t nios2_dma_map_page(struct device *dev, struct page *page,
                         unsigned long offset, size_t size,
                         enum dma_data_direction direction,
-                        struct dma_attrs *attrs)
+                        unsigned long attrs)
 {
         void *addr = page_address(page) + offset;
 
@@ -123,14 +123,14 @@ static dma_addr_t nios2_dma_map_page(struct device *dev, struct page *page,
 
 static void nios2_dma_unmap_page(struct device *dev, dma_addr_t dma_address,
                 size_t size, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         __dma_sync_for_cpu(phys_to_virt(dma_address), size, direction);
 }
 
 static void nios2_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
                 int nhwentries, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         void *addr;
         int i;
diff --git a/arch/openrisc/kernel/dma.c b/arch/openrisc/kernel/dma.c
index 0b77ddb1ee07..140c99140649 100644
--- a/arch/openrisc/kernel/dma.c
+++ b/arch/openrisc/kernel/dma.c
@@ -22,7 +22,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/dma-debug.h>
 #include <linux/export.h>
-#include <linux/dma-attrs.h>
 
 #include <asm/cpuinfo.h>
 #include <asm/spr_defs.h>
@@ -83,7 +82,7 @@ page_clear_nocache(pte_t *pte, unsigned long addr,
 static void *
 or1k_dma_alloc(struct device *dev, size_t size,
                dma_addr_t *dma_handle, gfp_t gfp,
-               struct dma_attrs *attrs)
+               unsigned long attrs)
 {
         unsigned long va;
         void *page;
@@ -101,7 +100,7 @@ or1k_dma_alloc(struct device *dev, size_t size,
 
         va = (unsigned long)page;
 
-        if (!dma_get_attr(DMA_ATTR_NON_CONSISTENT, attrs)) {
+        if ((attrs & DMA_ATTR_NON_CONSISTENT) == 0) {
                 /*
                  * We need to iterate through the pages, clearing the dcache for
                  * them and setting the cache-inhibit bit.
@@ -117,7 +116,7 @@ or1k_dma_alloc(struct device *dev, size_t size,
 
 static void
 or1k_dma_free(struct device *dev, size_t size, void *vaddr,
-              dma_addr_t dma_handle, struct dma_attrs *attrs)
+              dma_addr_t dma_handle, unsigned long attrs)
 {
         unsigned long va = (unsigned long)vaddr;
         struct mm_walk walk = {
@@ -125,7 +124,7 @@ or1k_dma_free(struct device *dev, size_t size, void *vaddr,
                 .mm = &init_mm
         };
 
-        if (!dma_get_attr(DMA_ATTR_NON_CONSISTENT, attrs)) {
+        if ((attrs & DMA_ATTR_NON_CONSISTENT) == 0) {
                 /* walk_page_range shouldn't be able to fail here */
                 WARN_ON(walk_page_range(va, va + size, &walk));
         }
@@ -137,7 +136,7 @@ static dma_addr_t
 or1k_map_page(struct device *dev, struct page *page,
               unsigned long offset, size_t size,
               enum dma_data_direction dir,
-              struct dma_attrs *attrs)
+              unsigned long attrs)
 {
         unsigned long cl;
         dma_addr_t addr = page_to_phys(page) + offset;
@@ -170,7 +169,7 @@ or1k_map_page(struct device *dev, struct page *page,
 static void
 or1k_unmap_page(struct device *dev, dma_addr_t dma_handle,
                 size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         /* Nothing special to do here... */
 }
@@ -178,14 +177,14 @@ or1k_unmap_page(struct device *dev, dma_addr_t dma_handle,
 static int
 or1k_map_sg(struct device *dev, struct scatterlist *sg,
             int nents, enum dma_data_direction dir,
-            struct dma_attrs *attrs)
+            unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
 
         for_each_sg(sg, s, nents, i) {
                 s->dma_address = or1k_map_page(dev, sg_page(s), s->offset,
-                                               s->length, dir, NULL);
+                                               s->length, dir, 0);
         }
 
         return nents;
@@ -194,13 +193,13 @@ or1k_map_sg(struct device *dev, struct scatterlist *sg,
 static void
 or1k_unmap_sg(struct device *dev, struct scatterlist *sg,
               int nents, enum dma_data_direction dir,
-              struct dma_attrs *attrs)
+              unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
 
         for_each_sg(sg, s, nents, i) {
-                or1k_unmap_page(dev, sg_dma_address(s), sg_dma_len(s), dir, NULL);
+                or1k_unmap_page(dev, sg_dma_address(s), sg_dma_len(s), dir, 0);
         }
 }
 
diff --git a/arch/parisc/kernel/pci-dma.c b/arch/parisc/kernel/pci-dma.c
index a27e4928bf73..02d9ed0f3949 100644
--- a/arch/parisc/kernel/pci-dma.c
+++ b/arch/parisc/kernel/pci-dma.c
@@ -414,7 +414,7 @@ pcxl_dma_init(void)
 __initcall(pcxl_dma_init);
 
 static void *pa11_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t flag, struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t flag, unsigned long attrs)
 {
         unsigned long vaddr;
         unsigned long paddr;
@@ -441,7 +441,7 @@ static void *pa11_dma_alloc(struct device *dev, size_t size,
 }
 
 static void pa11_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
         int order;
 
@@ -454,7 +454,7 @@ static void pa11_dma_free(struct device *dev, size_t size, void *vaddr,
 
 static dma_addr_t pa11_dma_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size,
-                enum dma_data_direction direction, struct dma_attrs *attrs)
+                enum dma_data_direction direction, unsigned long attrs)
 {
         void *addr = page_address(page) + offset;
         BUG_ON(direction == DMA_NONE);
@@ -465,7 +465,7 @@ static dma_addr_t pa11_dma_map_page(struct device *dev, struct page *page,
 
 static void pa11_dma_unmap_page(struct device *dev, dma_addr_t dma_handle,
                 size_t size, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         BUG_ON(direction == DMA_NONE);
 
@@ -484,7 +484,7 @@ static void pa11_dma_unmap_page(struct device *dev, dma_addr_t dma_handle,
 
 static int pa11_dma_map_sg(struct device *dev, struct scatterlist *sglist,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         int i;
         struct scatterlist *sg;
@@ -503,7 +503,7 @@ static int pa11_dma_map_sg(struct device *dev, struct scatterlist *sglist,
 
 static void pa11_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
                 int nents, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         int i;
         struct scatterlist *sg;
@@ -577,11 +577,11 @@ struct dma_map_ops pcxl_dma_ops = {
 };
 
 static void *pcx_dma_alloc(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t flag, struct dma_attrs *attrs)
+                dma_addr_t *dma_handle, gfp_t flag, unsigned long attrs)
 {
         void *addr;
 
-        if (!dma_get_attr(DMA_ATTR_NON_CONSISTENT, attrs))
+        if ((attrs & DMA_ATTR_NON_CONSISTENT) == 0)
                 return NULL;
 
         addr = (void *)__get_free_pages(flag, get_order(size));
@@ -592,7 +592,7 @@ static void *pcx_dma_alloc(struct device *dev, size_t size,
 }
 
 static void pcx_dma_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t iova, struct dma_attrs *attrs)
+                dma_addr_t iova, unsigned long attrs)
 {
         free_pages((unsigned long)vaddr, get_order(size));
         return;
diff --git a/arch/powerpc/include/asm/dma-mapping.h b/arch/powerpc/include/asm/dma-mapping.h
index 77816acd4fd9..84e3f8dd5e4f 100644
--- a/arch/powerpc/include/asm/dma-mapping.h
+++ b/arch/powerpc/include/asm/dma-mapping.h
@@ -13,7 +13,6 @@
 /* need struct page definitions */
 #include <linux/mm.h>
 #include <linux/scatterlist.h>
-#include <linux/dma-attrs.h>
 #include <linux/dma-debug.h>
 #include <asm/io.h>
 #include <asm/swiotlb.h>
@@ -25,14 +24,14 @@
 /* Some dma direct funcs must be visible for use in other dma_ops */
 extern void *__dma_direct_alloc_coherent(struct device *dev, size_t size,
                                          dma_addr_t *dma_handle, gfp_t flag,
-                                         struct dma_attrs *attrs);
+                                         unsigned long attrs);
 extern void __dma_direct_free_coherent(struct device *dev, size_t size,
                                        void *vaddr, dma_addr_t dma_handle,
-                                       struct dma_attrs *attrs);
+                                       unsigned long attrs);
 extern int dma_direct_mmap_coherent(struct device *dev,
                                     struct vm_area_struct *vma,
                                     void *cpu_addr, dma_addr_t handle,
-                                    size_t size, struct dma_attrs *attrs);
+                                    size_t size, unsigned long attrs);
 
 #ifdef CONFIG_NOT_COHERENT_CACHE
 /*
diff --git a/arch/powerpc/include/asm/iommu.h b/arch/powerpc/include/asm/iommu.h
index f49a72a9062d..2c1d50792944 100644
--- a/arch/powerpc/include/asm/iommu.h
+++ b/arch/powerpc/include/asm/iommu.h
@@ -53,7 +53,7 @@ struct iommu_table_ops {
                         long index, long npages,
                         unsigned long uaddr,
                         enum dma_data_direction direction,
-                        struct dma_attrs *attrs);
+                        unsigned long attrs);
 #ifdef CONFIG_IOMMU_API
         /*
          * Exchanges existing TCE with new TCE plus direction bits;
@@ -248,12 +248,12 @@ extern int ppc_iommu_map_sg(struct device *dev, struct iommu_table *tbl,
                             struct scatterlist *sglist, int nelems,
                             unsigned long mask,
                             enum dma_data_direction direction,
-                            struct dma_attrs *attrs);
+                            unsigned long attrs);
 extern void ppc_iommu_unmap_sg(struct iommu_table *tbl,
                                struct scatterlist *sglist,
                                int nelems,
                                enum dma_data_direction direction,
-                               struct dma_attrs *attrs);
+                               unsigned long attrs);
 
 extern void *iommu_alloc_coherent(struct device *dev, struct iommu_table *tbl,
                                   size_t size, dma_addr_t *dma_handle,
@@ -264,10 +264,10 @@ extern dma_addr_t iommu_map_page(struct device *dev, struct iommu_table *tbl,
                                  struct page *page, unsigned long offset,
                                  size_t size, unsigned long mask,
                                  enum dma_data_direction direction,
-                                 struct dma_attrs *attrs);
+                                 unsigned long attrs);
 extern void iommu_unmap_page(struct iommu_table *tbl, dma_addr_t dma_handle,
                              size_t size, enum dma_data_direction direction,
-                             struct dma_attrs *attrs);
+                             unsigned long attrs);
 
 extern void iommu_init_early_pSeries(void);
 extern void iommu_init_early_dart(struct pci_controller_ops *controller_ops);
diff --git a/arch/powerpc/include/asm/jump_label.h b/arch/powerpc/include/asm/jump_label.h
index 47e155f15433..9af103a23975 100644
--- a/arch/powerpc/include/asm/jump_label.h
+++ b/arch/powerpc/include/asm/jump_label.h
@@ -14,6 +14,7 @@
 #include <linux/types.h>
 
 #include <asm/feature-fixups.h>
+#include <asm/asm-compat.h>
 
 #define JUMP_ENTRY_TYPE         stringify_in_c(FTR_ENTRY_LONG)
 #define JUMP_LABEL_NOP_SIZE     4
diff --git a/arch/powerpc/kernel/dma-iommu.c b/arch/powerpc/kernel/dma-iommu.c
index 41a7d9d49a5a..fb7cbaa37658 100644
--- a/arch/powerpc/kernel/dma-iommu.c
+++ b/arch/powerpc/kernel/dma-iommu.c
@@ -18,7 +18,7 @@
  */
 static void *dma_iommu_alloc_coherent(struct device *dev, size_t size,
                                       dma_addr_t *dma_handle, gfp_t flag,
-                                      struct dma_attrs *attrs)
+                                      unsigned long attrs)
 {
         return iommu_alloc_coherent(dev, get_iommu_table_base(dev), size,
                                     dma_handle, dev->coherent_dma_mask, flag,
@@ -27,7 +27,7 @@ static void *dma_iommu_alloc_coherent(struct device *dev, size_t size,
 
 static void dma_iommu_free_coherent(struct device *dev, size_t size,
                                     void *vaddr, dma_addr_t dma_handle,
-                                    struct dma_attrs *attrs)
+                                    unsigned long attrs)
 {
         iommu_free_coherent(get_iommu_table_base(dev), size, vaddr, dma_handle);
 }
@@ -40,7 +40,7 @@ static void dma_iommu_free_coherent(struct device *dev, size_t size,
 static dma_addr_t dma_iommu_map_page(struct device *dev, struct page *page,
                                      unsigned long offset, size_t size,
                                      enum dma_data_direction direction,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         return iommu_map_page(dev, get_iommu_table_base(dev), page, offset,
                               size, device_to_mask(dev), direction, attrs);
@@ -49,7 +49,7 @@ static dma_addr_t dma_iommu_map_page(struct device *dev, struct page *page,
 
 static void dma_iommu_unmap_page(struct device *dev, dma_addr_t dma_handle,
                                  size_t size, enum dma_data_direction direction,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         iommu_unmap_page(get_iommu_table_base(dev), dma_handle, size, direction,
                          attrs);
@@ -58,7 +58,7 @@ static void dma_iommu_unmap_page(struct device *dev, dma_addr_t dma_handle,
 
 static int dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist,
                             int nelems, enum dma_data_direction direction,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         return ppc_iommu_map_sg(dev, get_iommu_table_base(dev), sglist, nelems,
                                 device_to_mask(dev), direction, attrs);
@@ -66,7 +66,7 @@ static int dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist,
 
 static void dma_iommu_unmap_sg(struct device *dev, struct scatterlist *sglist,
                 int nelems, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         ppc_iommu_unmap_sg(get_iommu_table_base(dev), sglist, nelems,
                            direction, attrs);
diff --git a/arch/powerpc/kernel/dma.c b/arch/powerpc/kernel/dma.c
index 3f1472a78f39..e64a6016fba7 100644
--- a/arch/powerpc/kernel/dma.c
+++ b/arch/powerpc/kernel/dma.c
@@ -64,7 +64,7 @@ static int dma_direct_dma_supported(struct device *dev, u64 mask)
 
 void *__dma_direct_alloc_coherent(struct device *dev, size_t size,
                                   dma_addr_t *dma_handle, gfp_t flag,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         void *ret;
 #ifdef CONFIG_NOT_COHERENT_CACHE
@@ -121,7 +121,7 @@ void *__dma_direct_alloc_coherent(struct device *dev, size_t size,
 
 void __dma_direct_free_coherent(struct device *dev, size_t size,
                                 void *vaddr, dma_addr_t dma_handle,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
 #ifdef CONFIG_NOT_COHERENT_CACHE
         __dma_free_coherent(size, vaddr);
@@ -132,7 +132,7 @@ void __dma_direct_free_coherent(struct device *dev, size_t size,
 
 static void *dma_direct_alloc_coherent(struct device *dev, size_t size,
                                        dma_addr_t *dma_handle, gfp_t flag,
-                                       struct dma_attrs *attrs)
+                                       unsigned long attrs)
 {
         struct iommu_table *iommu;
 
@@ -156,7 +156,7 @@ static void *dma_direct_alloc_coherent(struct device *dev, size_t size,
 
 static void dma_direct_free_coherent(struct device *dev, size_t size,
                                      void *vaddr, dma_addr_t dma_handle,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         struct iommu_table *iommu;
 
@@ -177,7 +177,7 @@ static void dma_direct_free_coherent(struct device *dev, size_t size,
 
 int dma_direct_mmap_coherent(struct device *dev, struct vm_area_struct *vma,
                              void *cpu_addr, dma_addr_t handle, size_t size,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
         unsigned long pfn;
 
@@ -195,7 +195,7 @@ int dma_direct_mmap_coherent(struct device *dev, struct vm_area_struct *vma,
 
 static int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl,
                              int nents, enum dma_data_direction direction,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -211,7 +211,7 @@ static int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl,
 
 static void dma_direct_unmap_sg(struct device *dev, struct scatterlist *sg,
                                 int nents, enum dma_data_direction direction,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
 }
 
@@ -232,7 +232,7 @@ static inline dma_addr_t dma_direct_map_page(struct device *dev,
                                              unsigned long offset,
                                              size_t size,
                                              enum dma_data_direction dir,
-                                             struct dma_attrs *attrs)
+                                             unsigned long attrs)
 {
         BUG_ON(dir == DMA_NONE);
         __dma_sync_page(page, offset, size, dir);
@@ -243,7 +243,7 @@ static inline void dma_direct_unmap_page(struct device *dev,
                                          dma_addr_t dma_address,
                                          size_t size,
                                          enum dma_data_direction direction,
-                                         struct dma_attrs *attrs)
+                                         unsigned long attrs)
 {
 }
 
diff --git a/arch/powerpc/kernel/ibmebus.c b/arch/powerpc/kernel/ibmebus.c
index a89f4f7a66bd..c1ca9282f4a0 100644
--- a/arch/powerpc/kernel/ibmebus.c
+++ b/arch/powerpc/kernel/ibmebus.c
@@ -65,7 +65,7 @@ static void *ibmebus_alloc_coherent(struct device *dev,
                                     size_t size,
                                     dma_addr_t *dma_handle,
                                     gfp_t flag,
-                                    struct dma_attrs *attrs)
+                                    unsigned long attrs)
 {
         void *mem;
 
@@ -78,7 +78,7 @@ static void *ibmebus_alloc_coherent(struct device *dev,
 static void ibmebus_free_coherent(struct device *dev,
                                   size_t size, void *vaddr,
                                   dma_addr_t dma_handle,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         kfree(vaddr);
 }
@@ -88,7 +88,7 @@ static dma_addr_t ibmebus_map_page(struct device *dev,
                                    unsigned long offset,
                                    size_t size,
                                    enum dma_data_direction direction,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         return (dma_addr_t)(page_address(page) + offset);
 }
@@ -97,7 +97,7 @@ static void ibmebus_unmap_page(struct device *dev,
                                dma_addr_t dma_addr,
                                size_t size,
                                enum dma_data_direction direction,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
         return;
 }
@@ -105,7 +105,7 @@ static void ibmebus_unmap_page(struct device *dev,
 static int ibmebus_map_sg(struct device *dev,
                           struct scatterlist *sgl,
                           int nents, enum dma_data_direction direction,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -121,7 +121,7 @@ static int ibmebus_map_sg(struct device *dev,
 static void ibmebus_unmap_sg(struct device *dev,
                              struct scatterlist *sg,
                              int nents, enum dma_data_direction direction,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
         return;
 }
diff --git a/arch/powerpc/kernel/iommu.c b/arch/powerpc/kernel/iommu.c
index a8e3490b54e3..37d6e741be82 100644
--- a/arch/powerpc/kernel/iommu.c
+++ b/arch/powerpc/kernel/iommu.c
@@ -307,7 +307,7 @@ static dma_addr_t iommu_alloc(struct device *dev, struct iommu_table *tbl,
                               void *page, unsigned int npages,
                               enum dma_data_direction direction,
                               unsigned long mask, unsigned int align_order,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         unsigned long entry;
         dma_addr_t ret = DMA_ERROR_CODE;
@@ -431,7 +431,7 @@ static void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
 int ppc_iommu_map_sg(struct device *dev, struct iommu_table *tbl,
                      struct scatterlist *sglist, int nelems,
                      unsigned long mask, enum dma_data_direction direction,
-                     struct dma_attrs *attrs)
+                     unsigned long attrs)
 {
         dma_addr_t dma_next = 0, dma_addr;
         struct scatterlist *s, *outs, *segstart;
@@ -574,7 +574,7 @@ int ppc_iommu_map_sg(struct device *dev, struct iommu_table *tbl,
 
 void ppc_iommu_unmap_sg(struct iommu_table *tbl, struct scatterlist *sglist,
                         int nelems, enum dma_data_direction direction,
-                        struct dma_attrs *attrs)
+                        unsigned long attrs)
 {
         struct scatterlist *sg;
 
@@ -753,7 +753,7 @@ void iommu_free_table(struct iommu_table *tbl, const char *node_name)
 dma_addr_t iommu_map_page(struct device *dev, struct iommu_table *tbl,
                           struct page *page, unsigned long offset, size_t size,
                           unsigned long mask, enum dma_data_direction direction,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         dma_addr_t dma_handle = DMA_ERROR_CODE;
         void *vaddr;
@@ -790,7 +790,7 @@ dma_addr_t iommu_map_page(struct device *dev, struct iommu_table *tbl,
 
 void iommu_unmap_page(struct iommu_table *tbl, dma_addr_t dma_handle,
                       size_t size, enum dma_data_direction direction,
-                      struct dma_attrs *attrs)
+                      unsigned long attrs)
 {
         unsigned int npages;
 
@@ -845,7 +845,7 @@ void *iommu_alloc_coherent(struct device *dev, struct iommu_table *tbl,
         nio_pages = size >> tbl->it_page_shift;
         io_order = get_iommu_order(size, tbl);
         mapping = iommu_alloc(dev, tbl, ret, nio_pages, DMA_BIDIRECTIONAL,
-                              mask >> tbl->it_page_shift, io_order, NULL);
+                              mask >> tbl->it_page_shift, io_order, 0);
         if (mapping == DMA_ERROR_CODE) {
                 free_pages((unsigned long)ret, order);
                 return NULL;
diff --git a/arch/powerpc/kernel/vio.c b/arch/powerpc/kernel/vio.c
index 8d7358f3a273..b3813ddb2fb4 100644
--- a/arch/powerpc/kernel/vio.c
+++ b/arch/powerpc/kernel/vio.c
@@ -482,7 +482,7 @@ static void vio_cmo_balance(struct work_struct *work)
 
 static void *vio_dma_iommu_alloc_coherent(struct device *dev, size_t size,
                                           dma_addr_t *dma_handle, gfp_t flag,
-                                          struct dma_attrs *attrs)
+                                          unsigned long attrs)
 {
         struct vio_dev *viodev = to_vio_dev(dev);
         void *ret;
@@ -503,7 +503,7 @@ static void *vio_dma_iommu_alloc_coherent(struct device *dev, size_t size,
 
 static void vio_dma_iommu_free_coherent(struct device *dev, size_t size,
                                         void *vaddr, dma_addr_t dma_handle,
-                                        struct dma_attrs *attrs)
+                                        unsigned long attrs)
 {
         struct vio_dev *viodev = to_vio_dev(dev);
 
@@ -515,7 +515,7 @@ static void vio_dma_iommu_free_coherent(struct device *dev, size_t size,
 static dma_addr_t vio_dma_iommu_map_page(struct device *dev, struct page *page,
                                          unsigned long offset, size_t size,
                                          enum dma_data_direction direction,
-                                         struct dma_attrs *attrs)
+                                         unsigned long attrs)
 {
         struct vio_dev *viodev = to_vio_dev(dev);
         struct iommu_table *tbl;
@@ -539,7 +539,7 @@ static dma_addr_t vio_dma_iommu_map_page(struct device *dev, struct page *page,
 static void vio_dma_iommu_unmap_page(struct device *dev, dma_addr_t dma_handle,
                                      size_t size,
                                      enum dma_data_direction direction,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         struct vio_dev *viodev = to_vio_dev(dev);
         struct iommu_table *tbl;
@@ -552,7 +552,7 @@ static void vio_dma_iommu_unmap_page(struct device *dev, dma_addr_t dma_handle,
 
 static int vio_dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist,
                                 int nelems, enum dma_data_direction direction,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         struct vio_dev *viodev = to_vio_dev(dev);
         struct iommu_table *tbl;
@@ -588,7 +588,7 @@ static int vio_dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist,
 static void vio_dma_iommu_unmap_sg(struct device *dev,
                 struct scatterlist *sglist, int nelems,
                 enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         struct vio_dev *viodev = to_vio_dev(dev);
         struct iommu_table *tbl;
diff --git a/arch/powerpc/platforms/cell/iommu.c b/arch/powerpc/platforms/cell/iommu.c
index 9027d7c48507..f7d1a4953ea0 100644
--- a/arch/powerpc/platforms/cell/iommu.c
+++ b/arch/powerpc/platforms/cell/iommu.c
@@ -166,7 +166,7 @@ static void invalidate_tce_cache(struct cbe_iommu *iommu, unsigned long *pte,
 
 static int tce_build_cell(struct iommu_table *tbl, long index, long npages,
                 unsigned long uaddr, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         int i;
         unsigned long *io_pte, base_pte;
@@ -193,7 +193,7 @@ static int tce_build_cell(struct iommu_table *tbl, long index, long npages,
         base_pte = CBE_IOPTE_PP_W | CBE_IOPTE_PP_R | CBE_IOPTE_M |
                 CBE_IOPTE_SO_RW | (window->ioid & CBE_IOPTE_IOID_Mask);
 #endif
-        if (unlikely(dma_get_attr(DMA_ATTR_WEAK_ORDERING, attrs)))
+        if (unlikely(attrs & DMA_ATTR_WEAK_ORDERING))
                 base_pte &= ~CBE_IOPTE_SO_RW;
 
         io_pte = (unsigned long *)tbl->it_base + (index - tbl->it_offset);
@@ -526,7 +526,7 @@ cell_iommu_setup_window(struct cbe_iommu *iommu, struct device_node *np,
 
         __set_bit(0, window->table.it_map);
         tce_build_cell(&window->table, window->table.it_offset, 1,
-                       (unsigned long)iommu->pad_page, DMA_TO_DEVICE, NULL);
+                       (unsigned long)iommu->pad_page, DMA_TO_DEVICE, 0);
 
         return window;
 }
@@ -572,7 +572,7 @@ static struct iommu_table *cell_get_iommu_table(struct device *dev)
 
 static void *dma_fixed_alloc_coherent(struct device *dev, size_t size,
                                       dma_addr_t *dma_handle, gfp_t flag,
-                                      struct dma_attrs *attrs)
+                                      unsigned long attrs)
 {
         if (iommu_fixed_is_weak)
                 return iommu_alloc_coherent(dev, cell_get_iommu_table(dev),
@@ -586,7 +586,7 @@ static void *dma_fixed_alloc_coherent(struct device *dev, size_t size,
 
 static void dma_fixed_free_coherent(struct device *dev, size_t size,
                                     void *vaddr, dma_addr_t dma_handle,
-                                    struct dma_attrs *attrs)
+                                    unsigned long attrs)
 {
         if (iommu_fixed_is_weak)
                 iommu_free_coherent(cell_get_iommu_table(dev), size, vaddr,
@@ -598,9 +598,9 @@ static void dma_fixed_free_coherent(struct device *dev, size_t size,
 static dma_addr_t dma_fixed_map_page(struct device *dev, struct page *page,
                                      unsigned long offset, size_t size,
                                      enum dma_data_direction direction,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
-        if (iommu_fixed_is_weak == dma_get_attr(DMA_ATTR_WEAK_ORDERING, attrs))
+        if (iommu_fixed_is_weak == (attrs & DMA_ATTR_WEAK_ORDERING))
                 return dma_direct_ops.map_page(dev, page, offset, size,
                                                direction, attrs);
         else
@@ -611,9 +611,9 @@ static dma_addr_t dma_fixed_map_page(struct device *dev, struct page *page,
 
 static void dma_fixed_unmap_page(struct device *dev, dma_addr_t dma_addr,
                                  size_t size, enum dma_data_direction direction,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
-        if (iommu_fixed_is_weak == dma_get_attr(DMA_ATTR_WEAK_ORDERING, attrs))
+        if (iommu_fixed_is_weak == (attrs & DMA_ATTR_WEAK_ORDERING))
                 dma_direct_ops.unmap_page(dev, dma_addr, size, direction,
                                           attrs);
         else
@@ -623,9 +623,9 @@ static void dma_fixed_unmap_page(struct device *dev, dma_addr_t dma_addr,
 
 static int dma_fixed_map_sg(struct device *dev, struct scatterlist *sg,
                            int nents, enum dma_data_direction direction,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
-        if (iommu_fixed_is_weak == dma_get_attr(DMA_ATTR_WEAK_ORDERING, attrs))
+        if (iommu_fixed_is_weak == (attrs & DMA_ATTR_WEAK_ORDERING))
                 return dma_direct_ops.map_sg(dev, sg, nents, direction, attrs);
         else
                 return ppc_iommu_map_sg(dev, cell_get_iommu_table(dev), sg,
@@ -635,9 +635,9 @@ static int dma_fixed_map_sg(struct device *dev, struct scatterlist *sg,
 
 static void dma_fixed_unmap_sg(struct device *dev, struct scatterlist *sg,
                                int nents, enum dma_data_direction direction,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
-        if (iommu_fixed_is_weak == dma_get_attr(DMA_ATTR_WEAK_ORDERING, attrs))
+        if (iommu_fixed_is_weak == (attrs & DMA_ATTR_WEAK_ORDERING))
                 dma_direct_ops.unmap_sg(dev, sg, nents, direction, attrs);
         else
                 ppc_iommu_unmap_sg(cell_get_iommu_table(dev), sg, nents,
@@ -1162,7 +1162,7 @@ static int __init setup_iommu_fixed(char *str)
         pciep = of_find_node_by_type(NULL, "pcie-endpoint");
 
         if (strcmp(str, "weak") == 0 || (pciep && strcmp(str, "strong") != 0))
-                iommu_fixed_is_weak = 1;
+                iommu_fixed_is_weak = DMA_ATTR_WEAK_ORDERING;
 
         of_node_put(pciep);
 
diff --git a/arch/powerpc/platforms/pasemi/iommu.c b/arch/powerpc/platforms/pasemi/iommu.c
index 43dd3fb514e0..309d9ccccd50 100644
--- a/arch/powerpc/platforms/pasemi/iommu.c
+++ b/arch/powerpc/platforms/pasemi/iommu.c
@@ -88,7 +88,7 @@ static int iommu_table_iobmap_inited;
 static int iobmap_build(struct iommu_table *tbl, long index,
                          long npages, unsigned long uaddr,
                          enum dma_data_direction direction,
-                         struct dma_attrs *attrs)
+                         unsigned long attrs)
 {
         u32 *ip;
         u32 rpn;
diff --git a/arch/powerpc/platforms/powernv/npu-dma.c b/arch/powerpc/platforms/powernv/npu-dma.c
index 4383a5ff82ba..00e1a0195c78 100644
--- a/arch/powerpc/platforms/powernv/npu-dma.c
+++ b/arch/powerpc/platforms/powernv/npu-dma.c
@@ -73,7 +73,7 @@ EXPORT_SYMBOL(pnv_pci_get_npu_dev);
 
 static void *dma_npu_alloc(struct device *dev, size_t size,
                            dma_addr_t *dma_handle, gfp_t flag,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         NPU_DMA_OP_UNSUPPORTED();
         return NULL;
@@ -81,7 +81,7 @@ static void *dma_npu_alloc(struct device *dev, size_t size,
 
 static void dma_npu_free(struct device *dev, size_t size,
                          void *vaddr, dma_addr_t dma_handle,
-                         struct dma_attrs *attrs)
+                         unsigned long attrs)
 {
         NPU_DMA_OP_UNSUPPORTED();
 }
@@ -89,7 +89,7 @@ static void dma_npu_free(struct device *dev, size_t size,
 static dma_addr_t dma_npu_map_page(struct device *dev, struct page *page,
                                    unsigned long offset, size_t size,
                                    enum dma_data_direction direction,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         NPU_DMA_OP_UNSUPPORTED();
         return 0;
@@ -97,7 +97,7 @@ static dma_addr_t dma_npu_map_page(struct device *dev, struct page *page,
 
 static int dma_npu_map_sg(struct device *dev, struct scatterlist *sglist,
                           int nelems, enum dma_data_direction direction,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         NPU_DMA_OP_UNSUPPORTED();
         return 0;
diff --git a/arch/powerpc/platforms/powernv/pci-ioda.c b/arch/powerpc/platforms/powernv/pci-ioda.c
index 891fc4a453df..6b9528307f62 100644
--- a/arch/powerpc/platforms/powernv/pci-ioda.c
+++ b/arch/powerpc/platforms/powernv/pci-ioda.c
@@ -1806,7 +1806,7 @@ static void pnv_pci_p7ioc_tce_invalidate(struct iommu_table *tbl,
 static int pnv_ioda1_tce_build(struct iommu_table *tbl, long index,
                 long npages, unsigned long uaddr,
                 enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         int ret = pnv_tce_build(tbl, index, npages, uaddr, direction,
                         attrs);
@@ -1950,7 +1950,7 @@ static void pnv_pci_ioda2_tce_invalidate(struct iommu_table *tbl,
 static int pnv_ioda2_tce_build(struct iommu_table *tbl, long index,
                 long npages, unsigned long uaddr,
                 enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         int ret = pnv_tce_build(tbl, index, npages, uaddr, direction,
                         attrs);
diff --git a/arch/powerpc/platforms/powernv/pci.c b/arch/powerpc/platforms/powernv/pci.c
index 6701dd5ded20..a21d831c1114 100644
--- a/arch/powerpc/platforms/powernv/pci.c
+++ b/arch/powerpc/platforms/powernv/pci.c
@@ -704,7 +704,7 @@ static __be64 *pnv_tce(struct iommu_table *tbl, long idx)
 
 int pnv_tce_build(struct iommu_table *tbl, long index, long npages,
                 unsigned long uaddr, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         u64 proto_tce = iommu_direction_to_tce_perm(direction);
         u64 rpn = __pa(uaddr) >> tbl->it_page_shift;
diff --git a/arch/powerpc/platforms/powernv/pci.h b/arch/powerpc/platforms/powernv/pci.h
index d088d4f06116..e64df7894d6e 100644
--- a/arch/powerpc/platforms/powernv/pci.h
+++ b/arch/powerpc/platforms/powernv/pci.h
@@ -181,7 +181,7 @@ struct pnv_phb {
 extern struct pci_ops pnv_pci_ops;
 extern int pnv_tce_build(struct iommu_table *tbl, long index, long npages,
                 unsigned long uaddr, enum dma_data_direction direction,
-                struct dma_attrs *attrs);
+                unsigned long attrs);
 extern void pnv_tce_free(struct iommu_table *tbl, long index, long npages);
 extern int pnv_tce_xchg(struct iommu_table *tbl, long index,
                 unsigned long *hpa, enum dma_data_direction *direction);
diff --git a/arch/powerpc/platforms/ps3/system-bus.c b/arch/powerpc/platforms/ps3/system-bus.c
index 5606fe36faf2..8af1c15aef85 100644
--- a/arch/powerpc/platforms/ps3/system-bus.c
+++ b/arch/powerpc/platforms/ps3/system-bus.c
@@ -516,7 +516,7 @@ core_initcall(ps3_system_bus_init);
  */
 static void * ps3_alloc_coherent(struct device *_dev, size_t size,
                                  dma_addr_t *dma_handle, gfp_t flag,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         int result;
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
@@ -553,7 +553,7 @@ clean_none:
 }
 
 static void ps3_free_coherent(struct device *_dev, size_t size, void *vaddr,
-                              dma_addr_t dma_handle, struct dma_attrs *attrs)
+                              dma_addr_t dma_handle, unsigned long attrs)
 {
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
 
@@ -569,7 +569,7 @@ static void ps3_free_coherent(struct device *_dev, size_t size, void *vaddr,
 
 static dma_addr_t ps3_sb_map_page(struct device *_dev, struct page *page,
         unsigned long offset, size_t size, enum dma_data_direction direction,
-        struct dma_attrs *attrs)
+        unsigned long attrs)
 {
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
         int result;
@@ -592,7 +592,7 @@ static dma_addr_t ps3_sb_map_page(struct device *_dev, struct page *page,
 static dma_addr_t ps3_ioc0_map_page(struct device *_dev, struct page *page,
                                     unsigned long offset, size_t size,
                                     enum dma_data_direction direction,
-                                    struct dma_attrs *attrs)
+                                    unsigned long attrs)
 {
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
         int result;
@@ -626,7 +626,7 @@ static dma_addr_t ps3_ioc0_map_page(struct device *_dev, struct page *page,
 }
 
 static void ps3_unmap_page(struct device *_dev, dma_addr_t dma_addr,
-        size_t size, enum dma_data_direction direction, struct dma_attrs *attrs)
+        size_t size, enum dma_data_direction direction, unsigned long attrs)
 {
         struct ps3_system_bus_device *dev = ps3_dev_to_system_bus_dev(_dev);
         int result;
@@ -640,7 +640,7 @@ static void ps3_unmap_page(struct device *_dev, dma_addr_t dma_addr,
 }
 
 static int ps3_sb_map_sg(struct device *_dev, struct scatterlist *sgl,
-        int nents, enum dma_data_direction direction, struct dma_attrs *attrs)
+        int nents, enum dma_data_direction direction, unsigned long attrs)
 {
 #if defined(CONFIG_PS3_DYNAMIC_DMA)
         BUG_ON("do");
@@ -670,14 +670,14 @@ static int ps3_sb_map_sg(struct device *_dev, struct scatterlist *sgl,
 static int ps3_ioc0_map_sg(struct device *_dev, struct scatterlist *sg,
                            int nents,
                            enum dma_data_direction direction,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         BUG();
         return 0;
 }
 
 static void ps3_sb_unmap_sg(struct device *_dev, struct scatterlist *sg,
-        int nents, enum dma_data_direction direction, struct dma_attrs *attrs)
+        int nents, enum dma_data_direction direction, unsigned long attrs)
 {
 #if defined(CONFIG_PS3_DYNAMIC_DMA)
         BUG_ON("do");
@@ -686,7 +686,7 @@ static void ps3_sb_unmap_sg(struct device *_dev, struct scatterlist *sg,
 
 static void ps3_ioc0_unmap_sg(struct device *_dev, struct scatterlist *sg,
                             int nents, enum dma_data_direction direction,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         BUG();
 }
diff --git a/arch/powerpc/platforms/pseries/iommu.c b/arch/powerpc/platforms/pseries/iommu.c
index 770a753b52c9..0024e451bb36 100644
--- a/arch/powerpc/platforms/pseries/iommu.c
+++ b/arch/powerpc/platforms/pseries/iommu.c
@@ -123,7 +123,7 @@ static void iommu_pseries_free_group(struct iommu_table_group *table_group,
 static int tce_build_pSeries(struct iommu_table *tbl, long index,
                               long npages, unsigned long uaddr,
                               enum dma_data_direction direction,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         u64 proto_tce;
         __be64 *tcep, *tces;
@@ -173,7 +173,7 @@ static void tce_freemulti_pSeriesLP(struct iommu_table*, long, long);
 static int tce_build_pSeriesLP(struct iommu_table *tbl, long tcenum,
                                 long npages, unsigned long uaddr,
                                 enum dma_data_direction direction,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         u64 rc = 0;
         u64 proto_tce, tce;
@@ -216,7 +216,7 @@ static DEFINE_PER_CPU(__be64 *, tce_page);
 static int tce_buildmulti_pSeriesLP(struct iommu_table *tbl, long tcenum,
                                      long npages, unsigned long uaddr,
                                      enum dma_data_direction direction,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         u64 rc = 0;
         u64 proto_tce;
diff --git a/arch/powerpc/sysdev/dart_iommu.c b/arch/powerpc/sysdev/dart_iommu.c
index 26904f4879ec..3573d54b2770 100644
--- a/arch/powerpc/sysdev/dart_iommu.c
+++ b/arch/powerpc/sysdev/dart_iommu.c
@@ -185,7 +185,7 @@ static void dart_flush(struct iommu_table *tbl)
 static int dart_build(struct iommu_table *tbl, long index,
                        long npages, unsigned long uaddr,
                        enum dma_data_direction direction,
-                       struct dma_attrs *attrs)
+                       unsigned long attrs)
 {
         unsigned int *dp, *orig_dp;
         unsigned int rpn;
diff --git a/arch/s390/include/asm/dma-mapping.h b/arch/s390/include/asm/dma-mapping.h
index 3249b7464889..ffaba07f50ab 100644
--- a/arch/s390/include/asm/dma-mapping.h
+++ b/arch/s390/include/asm/dma-mapping.h
@@ -5,7 +5,6 @@
 #include <linux/types.h>
 #include <linux/mm.h>
 #include <linux/scatterlist.h>
-#include <linux/dma-attrs.h>
 #include <linux/dma-debug.h>
 #include <linux/io.h>
 
diff --git a/arch/s390/pci/pci_dma.c b/arch/s390/pci/pci_dma.c
index 070f1ae5cfad..7297fce9bf80 100644
--- a/arch/s390/pci/pci_dma.c
+++ b/arch/s390/pci/pci_dma.c
@@ -286,7 +286,7 @@ static inline void zpci_err_dma(unsigned long rc, unsigned long addr)
 static dma_addr_t s390_dma_map_pages(struct device *dev, struct page *page,
                                      unsigned long offset, size_t size,
                                      enum dma_data_direction direction,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         struct zpci_dev *zdev = to_zpci(to_pci_dev(dev));
         unsigned long nr_pages, iommu_page_index;
@@ -332,7 +332,7 @@ out_err:
 
 static void s390_dma_unmap_pages(struct device *dev, dma_addr_t dma_addr,
                                  size_t size, enum dma_data_direction direction,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         struct zpci_dev *zdev = to_zpci(to_pci_dev(dev));
         unsigned long iommu_page_index;
@@ -355,7 +355,7 @@ static void s390_dma_unmap_pages(struct device *dev, dma_addr_t dma_addr,
 
 static void *s390_dma_alloc(struct device *dev, size_t size,
                             dma_addr_t *dma_handle, gfp_t flag,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         struct zpci_dev *zdev = to_zpci(to_pci_dev(dev));
         struct page *page;
@@ -370,7 +370,7 @@ static void *s390_dma_alloc(struct device *dev, size_t size,
         pa = page_to_phys(page);
         memset((void *) pa, 0, size);
 
-        map = s390_dma_map_pages(dev, page, 0, size, DMA_BIDIRECTIONAL, NULL);
+        map = s390_dma_map_pages(dev, page, 0, size, DMA_BIDIRECTIONAL, 0);
         if (dma_mapping_error(dev, map)) {
                 free_pages(pa, get_order(size));
                 return NULL;
@@ -384,19 +384,19 @@ static void *s390_dma_alloc(struct device *dev, size_t size,
 
 static void s390_dma_free(struct device *dev, size_t size,
                           void *pa, dma_addr_t dma_handle,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         struct zpci_dev *zdev = to_zpci(to_pci_dev(dev));
 
         size = PAGE_ALIGN(size);
         atomic64_sub(size / PAGE_SIZE, &zdev->allocated_pages);
-        s390_dma_unmap_pages(dev, dma_handle, size, DMA_BIDIRECTIONAL, NULL);
+        s390_dma_unmap_pages(dev, dma_handle, size, DMA_BIDIRECTIONAL, 0);
         free_pages((unsigned long) pa, get_order(size));
 }
 
 static int s390_dma_map_sg(struct device *dev, struct scatterlist *sg,
                            int nr_elements, enum dma_data_direction dir,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         int mapped_elements = 0;
         struct scatterlist *s;
@@ -405,7 +405,7 @@ static int s390_dma_map_sg(struct device *dev, struct scatterlist *sg,
         for_each_sg(sg, s, nr_elements, i) {
                 struct page *page = sg_page(s);
                 s->dma_address = s390_dma_map_pages(dev, page, s->offset,
-                                                    s->length, dir, NULL);
+                                                    s->length, dir, 0);
                 if (!dma_mapping_error(dev, s->dma_address)) {
                         s->dma_length = s->length;
                         mapped_elements++;
@@ -419,7 +419,7 @@ unmap:
         for_each_sg(sg, s, mapped_elements, i) {
                 if (s->dma_address)
                         s390_dma_unmap_pages(dev, s->dma_address, s->dma_length,
-                                             dir, NULL);
+                                             dir, 0);
                 s->dma_address = 0;
                 s->dma_length = 0;
         }
@@ -429,13 +429,14 @@ unmap:
 
 static void s390_dma_unmap_sg(struct device *dev, struct scatterlist *sg,
                               int nr_elements, enum dma_data_direction dir,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
 
         for_each_sg(sg, s, nr_elements, i) {
-                s390_dma_unmap_pages(dev, s->dma_address, s->dma_length, dir, NULL);
+                s390_dma_unmap_pages(dev, s->dma_address, s->dma_length, dir,
+                                     0);
                 s->dma_address = 0;
                 s->dma_length = 0;
         }
diff --git a/arch/sh/include/asm/dma-mapping.h b/arch/sh/include/asm/dma-mapping.h
index e11cf0c8206b..0052ad40e86d 100644
--- a/arch/sh/include/asm/dma-mapping.h
+++ b/arch/sh/include/asm/dma-mapping.h
@@ -17,9 +17,9 @@ void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
 /* arch/sh/mm/consistent.c */
 extern void *dma_generic_alloc_coherent(struct device *dev, size_t size,
                                         dma_addr_t *dma_addr, gfp_t flag,
-                                        struct dma_attrs *attrs);
+                                        unsigned long attrs);
 extern void dma_generic_free_coherent(struct device *dev, size_t size,
                                       void *vaddr, dma_addr_t dma_handle,
-                                      struct dma_attrs *attrs);
+                                      unsigned long attrs);
 
 #endif /* __ASM_SH_DMA_MAPPING_H */
diff --git a/arch/sh/kernel/dma-nommu.c b/arch/sh/kernel/dma-nommu.c
index 5b0bfcda6d0b..eadb669a7329 100644
--- a/arch/sh/kernel/dma-nommu.c
+++ b/arch/sh/kernel/dma-nommu.c
@@ -13,7 +13,7 @@
 static dma_addr_t nommu_map_page(struct device *dev, struct page *page,
                                  unsigned long offset, size_t size,
                                  enum dma_data_direction dir,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         dma_addr_t addr = page_to_phys(page) + offset;
 
@@ -25,7 +25,7 @@ static dma_addr_t nommu_map_page(struct device *dev, struct page *page,
 
 static int nommu_map_sg(struct device *dev, struct scatterlist *sg,
                         int nents, enum dma_data_direction dir,
-                        struct dma_attrs *attrs)
+                        unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
diff --git a/arch/sh/mm/consistent.c b/arch/sh/mm/consistent.c
index b81d9dbf9fef..92b6976fde59 100644
--- a/arch/sh/mm/consistent.c
+++ b/arch/sh/mm/consistent.c
@@ -34,7 +34,7 @@ fs_initcall(dma_init);
 
 void *dma_generic_alloc_coherent(struct device *dev, size_t size,
                                  dma_addr_t *dma_handle, gfp_t gfp,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         void *ret, *ret_nocache;
         int order = get_order(size);
@@ -66,7 +66,7 @@ void *dma_generic_alloc_coherent(struct device *dev, size_t size,
 
 void dma_generic_free_coherent(struct device *dev, size_t size,
                                void *vaddr, dma_addr_t dma_handle,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
         int order = get_order(size);
         unsigned long pfn = dma_handle >> PAGE_SHIFT;
diff --git a/arch/sparc/kernel/iommu.c b/arch/sparc/kernel/iommu.c
index 37686828c3d9..5c615abff030 100644
--- a/arch/sparc/kernel/iommu.c
+++ b/arch/sparc/kernel/iommu.c
@@ -196,7 +196,7 @@ static inline void iommu_free_ctx(struct iommu *iommu, int ctx)
 
 static void *dma_4u_alloc_coherent(struct device *dev, size_t size,
                                    dma_addr_t *dma_addrp, gfp_t gfp,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         unsigned long order, first_page;
         struct iommu *iommu;
@@ -245,7 +245,7 @@ static void *dma_4u_alloc_coherent(struct device *dev, size_t size,
 
 static void dma_4u_free_coherent(struct device *dev, size_t size,
                                  void *cpu, dma_addr_t dvma,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         struct iommu *iommu;
         unsigned long order, npages;
@@ -263,7 +263,7 @@ static void dma_4u_free_coherent(struct device *dev, size_t size,
 static dma_addr_t dma_4u_map_page(struct device *dev, struct page *page,
                                   unsigned long offset, size_t sz,
                                   enum dma_data_direction direction,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         struct iommu *iommu;
         struct strbuf *strbuf;
@@ -385,7 +385,7 @@ do_flush_sync:
 
 static void dma_4u_unmap_page(struct device *dev, dma_addr_t bus_addr,
                               size_t sz, enum dma_data_direction direction,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         struct iommu *iommu;
         struct strbuf *strbuf;
@@ -431,7 +431,7 @@ static void dma_4u_unmap_page(struct device *dev, dma_addr_t bus_addr,
 
 static int dma_4u_map_sg(struct device *dev, struct scatterlist *sglist,
                          int nelems, enum dma_data_direction direction,
-                         struct dma_attrs *attrs)
+                         unsigned long attrs)
 {
         struct scatterlist *s, *outs, *segstart;
         unsigned long flags, handle, prot, ctx;
@@ -607,7 +607,7 @@ static unsigned long fetch_sg_ctx(struct iommu *iommu, struct scatterlist *sg)
 
 static void dma_4u_unmap_sg(struct device *dev, struct scatterlist *sglist,
                             int nelems, enum dma_data_direction direction,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         unsigned long flags, ctx;
         struct scatterlist *sg;
diff --git a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c
index ffd5ff4678cf..2344103414d1 100644
--- a/arch/sparc/kernel/ioport.c
+++ b/arch/sparc/kernel/ioport.c
@@ -260,7 +260,7 @@ EXPORT_SYMBOL(sbus_set_sbus64);
  */
 static void *sbus_alloc_coherent(struct device *dev, size_t len,
                                  dma_addr_t *dma_addrp, gfp_t gfp,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         struct platform_device *op = to_platform_device(dev);
         unsigned long len_total = PAGE_ALIGN(len);
@@ -315,7 +315,7 @@ err_nopages:
 }
 
 static void sbus_free_coherent(struct device *dev, size_t n, void *p,
-                               dma_addr_t ba, struct dma_attrs *attrs)
+                               dma_addr_t ba, unsigned long attrs)
 {
         struct resource *res;
         struct page *pgv;
@@ -355,7 +355,7 @@ static void sbus_free_coherent(struct device *dev, size_t n, void *p,
 static dma_addr_t sbus_map_page(struct device *dev, struct page *page,
                                 unsigned long offset, size_t len,
                                 enum dma_data_direction dir,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         void *va = page_address(page) + offset;
 
@@ -371,20 +371,20 @@ static dma_addr_t sbus_map_page(struct device *dev, struct page *page,
 }
 
 static void sbus_unmap_page(struct device *dev, dma_addr_t ba, size_t n,
-                            enum dma_data_direction dir, struct dma_attrs *attrs)
+                            enum dma_data_direction dir, unsigned long attrs)
 {
         mmu_release_scsi_one(dev, ba, n);
 }
 
 static int sbus_map_sg(struct device *dev, struct scatterlist *sg, int n,
-                       enum dma_data_direction dir, struct dma_attrs *attrs)
+                       enum dma_data_direction dir, unsigned long attrs)
 {
         mmu_get_scsi_sgl(dev, sg, n);
         return n;
 }
 
 static void sbus_unmap_sg(struct device *dev, struct scatterlist *sg, int n,
-                          enum dma_data_direction dir, struct dma_attrs *attrs)
+                          enum dma_data_direction dir, unsigned long attrs)
 {
         mmu_release_scsi_sgl(dev, sg, n);
 }
@@ -429,7 +429,7 @@ arch_initcall(sparc_register_ioport);
  */
 static void *pci32_alloc_coherent(struct device *dev, size_t len,
                                   dma_addr_t *pba, gfp_t gfp,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         unsigned long len_total = PAGE_ALIGN(len);
         void *va;
@@ -482,7 +482,7 @@ err_nopages:
  * past this call are illegal.
  */
 static void pci32_free_coherent(struct device *dev, size_t n, void *p,
-                                dma_addr_t ba, struct dma_attrs *attrs)
+                                dma_addr_t ba, unsigned long attrs)
 {
         struct resource *res;
 
@@ -518,14 +518,14 @@ static void pci32_free_coherent(struct device *dev, size_t n, void *p,
 static dma_addr_t pci32_map_page(struct device *dev, struct page *page,
                                  unsigned long offset, size_t size,
                                  enum dma_data_direction dir,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         /* IIep is write-through, not flushing. */
         return page_to_phys(page) + offset;
 }
 
 static void pci32_unmap_page(struct device *dev, dma_addr_t ba, size_t size,
-                             enum dma_data_direction dir, struct dma_attrs *attrs)
+                             enum dma_data_direction dir, unsigned long attrs)
 {
         if (dir != PCI_DMA_TODEVICE)
                 dma_make_coherent(ba, PAGE_ALIGN(size));
@@ -548,7 +548,7 @@ static void pci32_unmap_page(struct device *dev, dma_addr_t ba, size_t size,
  */
 static int pci32_map_sg(struct device *device, struct scatterlist *sgl,
                         int nents, enum dma_data_direction dir,
-                        struct dma_attrs *attrs)
+                        unsigned long attrs)
 {
         struct scatterlist *sg;
         int n;
@@ -567,7 +567,7 @@ static int pci32_map_sg(struct device *device, struct scatterlist *sgl,
  */
 static void pci32_unmap_sg(struct device *dev, struct scatterlist *sgl,
                            int nents, enum dma_data_direction dir,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         struct scatterlist *sg;
         int n;
diff --git a/arch/sparc/kernel/pci_sun4v.c b/arch/sparc/kernel/pci_sun4v.c
index 836e8cef47e2..61c6f935accc 100644
--- a/arch/sparc/kernel/pci_sun4v.c
+++ b/arch/sparc/kernel/pci_sun4v.c
@@ -130,7 +130,7 @@ static inline long iommu_batch_end(void)
 
 static void *dma_4v_alloc_coherent(struct device *dev, size_t size,
                                    dma_addr_t *dma_addrp, gfp_t gfp,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         unsigned long flags, order, first_page, npages, n;
         struct iommu *iommu;
@@ -213,7 +213,7 @@ static void dma_4v_iommu_demap(void *demap_arg, unsigned long entry,
 }
 
 static void dma_4v_free_coherent(struct device *dev, size_t size, void *cpu,
-                                 dma_addr_t dvma, struct dma_attrs *attrs)
+                                 dma_addr_t dvma, unsigned long attrs)
 {
         struct pci_pbm_info *pbm;
         struct iommu *iommu;
@@ -235,7 +235,7 @@ static void dma_4v_free_coherent(struct device *dev, size_t size, void *cpu,
 static dma_addr_t dma_4v_map_page(struct device *dev, struct page *page,
                                   unsigned long offset, size_t sz,
                                   enum dma_data_direction direction,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         struct iommu *iommu;
         unsigned long flags, npages, oaddr;
@@ -294,7 +294,7 @@ iommu_map_fail:
 
 static void dma_4v_unmap_page(struct device *dev, dma_addr_t bus_addr,
                               size_t sz, enum dma_data_direction direction,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         struct pci_pbm_info *pbm;
         struct iommu *iommu;
@@ -322,7 +322,7 @@ static void dma_4v_unmap_page(struct device *dev, dma_addr_t bus_addr,
 
 static int dma_4v_map_sg(struct device *dev, struct scatterlist *sglist,
                          int nelems, enum dma_data_direction direction,
-                         struct dma_attrs *attrs)
+                         unsigned long attrs)
 {
         struct scatterlist *s, *outs, *segstart;
         unsigned long flags, handle, prot;
@@ -466,7 +466,7 @@ iommu_map_failed:
 
 static void dma_4v_unmap_sg(struct device *dev, struct scatterlist *sglist,
                             int nelems, enum dma_data_direction direction,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         struct pci_pbm_info *pbm;
         struct scatterlist *sg;
diff --git a/arch/sparc/kernel/vmlinux.lds.S b/arch/sparc/kernel/vmlinux.lds.S
index 7d02b1fef025..d79b3b734245 100644
--- a/arch/sparc/kernel/vmlinux.lds.S
+++ b/arch/sparc/kernel/vmlinux.lds.S
@@ -150,6 +150,13 @@ SECTIONS
         }
         PERCPU_SECTION(SMP_CACHE_BYTES)
 
+#ifdef CONFIG_JUMP_LABEL
+        . = ALIGN(PAGE_SIZE);
+        .exit.text : {
+                EXIT_TEXT
+        }
+#endif
+
         . = ALIGN(PAGE_SIZE);
         __init_end = .;
         BSS_SECTION(0, 0, 0)
diff --git a/arch/tile/kernel/pci-dma.c b/arch/tile/kernel/pci-dma.c
index b6bc0547a4f6..09bb774b39cd 100644
--- a/arch/tile/kernel/pci-dma.c
+++ b/arch/tile/kernel/pci-dma.c
@@ -34,7 +34,7 @@
 
 static void *tile_dma_alloc_coherent(struct device *dev, size_t size,
                                      dma_addr_t *dma_handle, gfp_t gfp,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         u64 dma_mask = (dev && dev->coherent_dma_mask) ?
                 dev->coherent_dma_mask : DMA_BIT_MASK(32);
@@ -78,7 +78,7 @@ static void *tile_dma_alloc_coherent(struct device *dev, size_t size,
  */
 static void tile_dma_free_coherent(struct device *dev, size_t size,
                                    void *vaddr, dma_addr_t dma_handle,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         homecache_free_pages((unsigned long)vaddr, get_order(size));
 }
@@ -202,7 +202,7 @@ static void __dma_complete_pa_range(dma_addr_t dma_addr, size_t size,
 
 static int tile_dma_map_sg(struct device *dev, struct scatterlist *sglist,
                            int nents, enum dma_data_direction direction,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -224,7 +224,7 @@ static int tile_dma_map_sg(struct device *dev, struct scatterlist *sglist,
 
 static void tile_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
                               int nents, enum dma_data_direction direction,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -240,7 +240,7 @@ static void tile_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
 static dma_addr_t tile_dma_map_page(struct device *dev, struct page *page,
                                     unsigned long offset, size_t size,
                                     enum dma_data_direction direction,
-                                    struct dma_attrs *attrs)
+                                    unsigned long attrs)
 {
         BUG_ON(!valid_dma_direction(direction));
 
@@ -252,7 +252,7 @@ static dma_addr_t tile_dma_map_page(struct device *dev, struct page *page,
 
 static void tile_dma_unmap_page(struct device *dev, dma_addr_t dma_address,
                                 size_t size, enum dma_data_direction direction,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         BUG_ON(!valid_dma_direction(direction));
 
@@ -343,7 +343,7 @@ EXPORT_SYMBOL(tile_dma_map_ops);
 
 static void *tile_pci_dma_alloc_coherent(struct device *dev, size_t size,
                                          dma_addr_t *dma_handle, gfp_t gfp,
-                                         struct dma_attrs *attrs)
+                                         unsigned long attrs)
 {
         int node = dev_to_node(dev);
         int order = get_order(size);
@@ -368,14 +368,14 @@ static void *tile_pci_dma_alloc_coherent(struct device *dev, size_t size,
  */
 static void tile_pci_dma_free_coherent(struct device *dev, size_t size,
                                        void *vaddr, dma_addr_t dma_handle,
-                                       struct dma_attrs *attrs)
+                                       unsigned long attrs)
 {
         homecache_free_pages((unsigned long)vaddr, get_order(size));
 }
 
 static int tile_pci_dma_map_sg(struct device *dev, struct scatterlist *sglist,
                                int nents, enum dma_data_direction direction,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -400,7 +400,7 @@ static int tile_pci_dma_map_sg(struct device *dev, struct scatterlist *sglist,
 static void tile_pci_dma_unmap_sg(struct device *dev,
                                   struct scatterlist *sglist, int nents,
                                   enum dma_data_direction direction,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -416,7 +416,7 @@ static void tile_pci_dma_unmap_sg(struct device *dev,
 static dma_addr_t tile_pci_dma_map_page(struct device *dev, struct page *page,
                                         unsigned long offset, size_t size,
                                         enum dma_data_direction direction,
-                                        struct dma_attrs *attrs)
+                                        unsigned long attrs)
 {
         BUG_ON(!valid_dma_direction(direction));
 
@@ -429,7 +429,7 @@ static dma_addr_t tile_pci_dma_map_page(struct device *dev, struct page *page,
 static void tile_pci_dma_unmap_page(struct device *dev, dma_addr_t dma_address,
                                     size_t size,
                                     enum dma_data_direction direction,
-                                    struct dma_attrs *attrs)
+                                    unsigned long attrs)
 {
         BUG_ON(!valid_dma_direction(direction));
 
@@ -531,7 +531,7 @@ EXPORT_SYMBOL(gx_pci_dma_map_ops);
 #ifdef CONFIG_SWIOTLB
 static void *tile_swiotlb_alloc_coherent(struct device *dev, size_t size,
                                          dma_addr_t *dma_handle, gfp_t gfp,
-                                         struct dma_attrs *attrs)
+                                         unsigned long attrs)
 {
         gfp |= GFP_DMA;
         return swiotlb_alloc_coherent(dev, size, dma_handle, gfp);
@@ -539,7 +539,7 @@ static void *tile_swiotlb_alloc_coherent(struct device *dev, size_t size,
 
 static void tile_swiotlb_free_coherent(struct device *dev, size_t size,
                                        void *vaddr, dma_addr_t dma_addr,
-                                       struct dma_attrs *attrs)
+                                       unsigned long attrs)
 {
         swiotlb_free_coherent(dev, size, vaddr, dma_addr);
 }
diff --git a/arch/tile/kernel/vmlinux.lds.S b/arch/tile/kernel/vmlinux.lds.S
index 378f5d8d1ec8..9d449caf8910 100644
--- a/arch/tile/kernel/vmlinux.lds.S
+++ b/arch/tile/kernel/vmlinux.lds.S
@@ -60,6 +60,18 @@ SECTIONS
   /* "Init" is divided into two areas with very different virtual addresses. */
   INIT_TEXT_SECTION(PAGE_SIZE)
 
+  /*
+   * Some things, like the __jump_table, may contain symbol references
+   * to __exit text, so include such text in the final image if so.
+   * In that case we also override the _einittext from INIT_TEXT_SECTION.
+   */
+#ifdef CONFIG_JUMP_LABEL
+  .exit.text : {
+    EXIT_TEXT
+    _einittext = .;
+  }
+#endif
+
   /* Now we skip back to PAGE_OFFSET for the data. */
   . = (. - TEXT_OFFSET + PAGE_OFFSET);
   #undef LOAD_OFFSET
diff --git a/arch/unicore32/mm/dma-swiotlb.c b/arch/unicore32/mm/dma-swiotlb.c
index 16c08b2143a7..3e9f6489ba38 100644
--- a/arch/unicore32/mm/dma-swiotlb.c
+++ b/arch/unicore32/mm/dma-swiotlb.c
@@ -19,14 +19,14 @@
 
 static void *unicore_swiotlb_alloc_coherent(struct device *dev, size_t size,
                                             dma_addr_t *dma_handle, gfp_t flags,
-                                            struct dma_attrs *attrs)
+                                            unsigned long attrs)
 {
         return swiotlb_alloc_coherent(dev, size, dma_handle, flags);
 }
 
 static void unicore_swiotlb_free_coherent(struct device *dev, size_t size,
                                           void *vaddr, dma_addr_t dma_addr,
-                                          struct dma_attrs *attrs)
+                                          unsigned long attrs)
 {
         swiotlb_free_coherent(dev, size, vaddr, dma_addr);
 }
diff --git a/arch/x86/include/asm/dma-mapping.h b/arch/x86/include/asm/dma-mapping.h
index 3a27b93e6261..44461626830e 100644
--- a/arch/x86/include/asm/dma-mapping.h
+++ b/arch/x86/include/asm/dma-mapping.h
@@ -9,7 +9,6 @@
 #include <linux/kmemcheck.h>
 #include <linux/scatterlist.h>
 #include <linux/dma-debug.h>
-#include <linux/dma-attrs.h>
 #include <asm/io.h>
 #include <asm/swiotlb.h>
 #include <linux/dma-contiguous.h>
@@ -48,11 +47,11 @@ extern int dma_supported(struct device *hwdev, u64 mask);
 
 extern void *dma_generic_alloc_coherent(struct device *dev, size_t size,
                                         dma_addr_t *dma_addr, gfp_t flag,
-                                        struct dma_attrs *attrs);
+                                        unsigned long attrs);
 
 extern void dma_generic_free_coherent(struct device *dev, size_t size,
                                       void *vaddr, dma_addr_t dma_addr,
-                                      struct dma_attrs *attrs);
+                                      unsigned long attrs);
 
 #ifdef CONFIG_X86_DMA_REMAP /* Platform code defines bridge-specific code */
 extern bool dma_capable(struct device *dev, dma_addr_t addr, size_t size);
diff --git a/arch/x86/include/asm/elf.h b/arch/x86/include/asm/elf.h
index fea7724141a0..e7f155c3045e 100644
--- a/arch/x86/include/asm/elf.h
+++ b/arch/x86/include/asm/elf.h
@@ -344,8 +344,8 @@ extern int compat_arch_setup_additional_pages(struct linux_binprm *bprm,
  */
 static inline int mmap_is_ia32(void)
 {
-        return config_enabled(CONFIG_X86_32) ||
-               (config_enabled(CONFIG_COMPAT) &&
+        return IS_ENABLED(CONFIG_X86_32) ||
+               (IS_ENABLED(CONFIG_COMPAT) &&
                 test_thread_flag(TIF_ADDR32));
 }
 
diff --git a/arch/x86/include/asm/fpu/internal.h b/arch/x86/include/asm/fpu/internal.h
index 116b58347501..2737366ea583 100644
--- a/arch/x86/include/asm/fpu/internal.h
+++ b/arch/x86/include/asm/fpu/internal.h
@@ -137,9 +137,9 @@ static inline int copy_fregs_to_user(struct fregs_state __user *fx)
 
 static inline int copy_fxregs_to_user(struct fxregs_state __user *fx)
 {
-        if (config_enabled(CONFIG_X86_32))
+        if (IS_ENABLED(CONFIG_X86_32))
                 return user_insn(fxsave %[fx], [fx] "=m" (*fx), "m" (*fx));
-        else if (config_enabled(CONFIG_AS_FXSAVEQ))
+        else if (IS_ENABLED(CONFIG_AS_FXSAVEQ))
                 return user_insn(fxsaveq %[fx], [fx] "=m" (*fx), "m" (*fx));
 
         /* See comment in copy_fxregs_to_kernel() below. */
@@ -150,10 +150,10 @@ static inline void copy_kernel_to_fxregs(struct fxregs_state *fx)
 {
         int err;
 
-        if (config_enabled(CONFIG_X86_32)) {
+        if (IS_ENABLED(CONFIG_X86_32)) {
                 err = check_insn(fxrstor %[fx], "=m" (*fx), [fx] "m" (*fx));
         } else {
-                if (config_enabled(CONFIG_AS_FXSAVEQ)) {
+                if (IS_ENABLED(CONFIG_AS_FXSAVEQ)) {
                         err = check_insn(fxrstorq %[fx], "=m" (*fx), [fx] "m" (*fx));
                 } else {
                         /* See comment in copy_fxregs_to_kernel() below. */
@@ -166,9 +166,9 @@ static inline void copy_kernel_to_fxregs(struct fxregs_state *fx)
 
 static inline int copy_user_to_fxregs(struct fxregs_state __user *fx)
 {
-        if (config_enabled(CONFIG_X86_32))
+        if (IS_ENABLED(CONFIG_X86_32))
                 return user_insn(fxrstor %[fx], "=m" (*fx), [fx] "m" (*fx));
-        else if (config_enabled(CONFIG_AS_FXSAVEQ))
+        else if (IS_ENABLED(CONFIG_AS_FXSAVEQ))
                 return user_insn(fxrstorq %[fx], "=m" (*fx), [fx] "m" (*fx));
 
         /* See comment in copy_fxregs_to_kernel() below. */
@@ -190,9 +190,9 @@ static inline int copy_user_to_fregs(struct fregs_state __user *fx)
 
 static inline void copy_fxregs_to_kernel(struct fpu *fpu)
 {
-        if (config_enabled(CONFIG_X86_32))
+        if (IS_ENABLED(CONFIG_X86_32))
                 asm volatile( "fxsave %[fx]" : [fx] "=m" (fpu->state.fxsave));
-        else if (config_enabled(CONFIG_AS_FXSAVEQ))
+        else if (IS_ENABLED(CONFIG_AS_FXSAVEQ))
                 asm volatile("fxsaveq %[fx]" : [fx] "=m" (fpu->state.fxsave));
         else {
                 /* Using "rex64; fxsave %0" is broken because, if the memory
diff --git a/arch/x86/include/asm/mmu_context.h b/arch/x86/include/asm/mmu_context.h
index 396348196aa7..d8abfcf524d1 100644
--- a/arch/x86/include/asm/mmu_context.h
+++ b/arch/x86/include/asm/mmu_context.h
@@ -155,7 +155,7 @@ static inline void arch_exit_mmap(struct mm_struct *mm)
 #ifdef CONFIG_X86_64
 static inline bool is_64bit_mm(struct mm_struct *mm)
 {
-        return  !config_enabled(CONFIG_IA32_EMULATION) ||
+        return  !IS_ENABLED(CONFIG_IA32_EMULATION) ||
                 !(mm->context.ia32_compat == TIF_IA32);
 }
 #else
diff --git a/arch/x86/include/asm/swiotlb.h b/arch/x86/include/asm/swiotlb.h
index ab05d73e2bb7..d2f69b9ff732 100644
--- a/arch/x86/include/asm/swiotlb.h
+++ b/arch/x86/include/asm/swiotlb.h
@@ -31,9 +31,9 @@ static inline void dma_mark_clean(void *addr, size_t size) {}
 
 extern void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                                         dma_addr_t *dma_handle, gfp_t flags,
-                                        struct dma_attrs *attrs);
+                                        unsigned long attrs);
 extern void x86_swiotlb_free_coherent(struct device *dev, size_t size,
                                         void *vaddr, dma_addr_t dma_addr,
-                                        struct dma_attrs *attrs);
+                                        unsigned long attrs);
 
 #endif /* _ASM_X86_SWIOTLB_H */
diff --git a/arch/x86/include/asm/xen/page-coherent.h b/arch/x86/include/asm/xen/page-coherent.h
index acd844c017d3..f02f025ff988 100644
--- a/arch/x86/include/asm/xen/page-coherent.h
+++ b/arch/x86/include/asm/xen/page-coherent.h
@@ -2,12 +2,11 @@
 #define _ASM_X86_XEN_PAGE_COHERENT_H
 
 #include <asm/page.h>
-#include <linux/dma-attrs.h>
 #include <linux/dma-mapping.h>
 
 static inline void *xen_alloc_coherent_pages(struct device *hwdev, size_t size,
                 dma_addr_t *dma_handle, gfp_t flags,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         void *vstart = (void*)__get_free_pages(flags, get_order(size));
         *dma_handle = virt_to_phys(vstart);
@@ -16,18 +15,18 @@ static inline void *xen_alloc_coherent_pages(struct device *hwdev, size_t size,
 
 static inline void xen_free_coherent_pages(struct device *hwdev, size_t size,
                 void *cpu_addr, dma_addr_t dma_handle,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         free_pages((unsigned long) cpu_addr, get_order(size));
 }
 
 static inline void xen_dma_map_page(struct device *hwdev, struct page *page,
              dma_addr_t dev_addr, unsigned long offset, size_t size,
-             enum dma_data_direction dir, struct dma_attrs *attrs) { }
+             enum dma_data_direction dir, unsigned long attrs) { }
 
 static inline void xen_dma_unmap_page(struct device *hwdev, dma_addr_t handle,
                 size_t size, enum dma_data_direction dir,
-                struct dma_attrs *attrs) { }
+                unsigned long attrs) { }
 
 static inline void xen_dma_sync_single_for_cpu(struct device *hwdev,
                 dma_addr_t handle, size_t size, enum dma_data_direction dir) { }
diff --git a/arch/x86/kernel/amd_gart_64.c b/arch/x86/kernel/amd_gart_64.c
index 42d27a62a404..63ff468a7986 100644
--- a/arch/x86/kernel/amd_gart_64.c
+++ b/arch/x86/kernel/amd_gart_64.c
@@ -241,7 +241,7 @@ static dma_addr_t dma_map_area(struct device *dev, dma_addr_t phys_mem,
 static dma_addr_t gart_map_page(struct device *dev, struct page *page,
                                 unsigned long offset, size_t size,
                                 enum dma_data_direction dir,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         unsigned long bus;
         phys_addr_t paddr = page_to_phys(page) + offset;
@@ -263,7 +263,7 @@ static dma_addr_t gart_map_page(struct device *dev, struct page *page,
  */
 static void gart_unmap_page(struct device *dev, dma_addr_t dma_addr,
                             size_t size, enum dma_data_direction dir,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         unsigned long iommu_page;
         int npages;
@@ -285,7 +285,7 @@ static void gart_unmap_page(struct device *dev, dma_addr_t dma_addr,
  * Wrapper for pci_unmap_single working with scatterlists.
  */
 static void gart_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
-                          enum dma_data_direction dir, struct dma_attrs *attrs)
+                          enum dma_data_direction dir, unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
@@ -293,7 +293,7 @@ static void gart_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
         for_each_sg(sg, s, nents, i) {
                 if (!s->dma_length || !s->length)
                         break;
-                gart_unmap_page(dev, s->dma_address, s->dma_length, dir, NULL);
+                gart_unmap_page(dev, s->dma_address, s->dma_length, dir, 0);
         }
 }
 
@@ -315,7 +315,7 @@ static int dma_map_sg_nonforce(struct device *dev, struct scatterlist *sg,
                         addr = dma_map_area(dev, addr, s->length, dir, 0);
                         if (addr == bad_dma_addr) {
                                 if (i > 0)
-                                        gart_unmap_sg(dev, sg, i, dir, NULL);
+                                        gart_unmap_sg(dev, sg, i, dir, 0);
                                 nents = 0;
                                 sg[0].dma_length = 0;
                                 break;
@@ -386,7 +386,7 @@ dma_map_cont(struct device *dev, struct scatterlist *start, int nelems,
  * Merge chunks that have page aligned sizes into a continuous mapping.
  */
 static int gart_map_sg(struct device *dev, struct scatterlist *sg, int nents,
-                       enum dma_data_direction dir, struct dma_attrs *attrs)
+                       enum dma_data_direction dir, unsigned long attrs)
 {
         struct scatterlist *s, *ps, *start_sg, *sgmap;
         int need = 0, nextneed, i, out, start;
@@ -456,7 +456,7 @@ static int gart_map_sg(struct device *dev, struct scatterlist *sg, int nents,
 
 error:
         flush_gart();
-        gart_unmap_sg(dev, sg, out, dir, NULL);
+        gart_unmap_sg(dev, sg, out, dir, 0);
 
         /* When it was forced or merged try again in a dumb way */
         if (force_iommu || iommu_merge) {
@@ -476,7 +476,7 @@ error:
 /* allocate and map a coherent mapping */
 static void *
 gart_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_addr,
-                    gfp_t flag, struct dma_attrs *attrs)
+                    gfp_t flag, unsigned long attrs)
 {
         dma_addr_t paddr;
         unsigned long align_mask;
@@ -508,9 +508,9 @@ gart_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_addr,
 /* free a coherent mapping */
 static void
 gart_free_coherent(struct device *dev, size_t size, void *vaddr,
-                   dma_addr_t dma_addr, struct dma_attrs *attrs)
+                   dma_addr_t dma_addr, unsigned long attrs)
 {
-        gart_unmap_page(dev, dma_addr, size, DMA_BIDIRECTIONAL, NULL);
+        gart_unmap_page(dev, dma_addr, size, DMA_BIDIRECTIONAL, 0);
         dma_generic_free_coherent(dev, size, vaddr, dma_addr, attrs);
 }
 
diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c
index 7943d38c57ca..20abd912f0e4 100644
--- a/arch/x86/kernel/apic/apic.c
+++ b/arch/x86/kernel/apic/apic.c
@@ -147,7 +147,7 @@ static int force_enable_local_apic __initdata;
  */
 static int __init parse_lapic(char *arg)
 {
-        if (config_enabled(CONFIG_X86_32) && !arg)
+        if (IS_ENABLED(CONFIG_X86_32) && !arg)
                 force_enable_local_apic = 1;
         else if (arg && !strncmp(arg, "notscdeadline", 13))
                 setup_clear_cpu_cap(X86_FEATURE_TSC_DEADLINE_TIMER);
diff --git a/arch/x86/kernel/apic/vector.c b/arch/x86/kernel/apic/vector.c
index a5e400afc563..6066d945c40e 100644
--- a/arch/x86/kernel/apic/vector.c
+++ b/arch/x86/kernel/apic/vector.c
@@ -523,7 +523,7 @@ static int apic_set_affinity(struct irq_data *irq_data,
         struct apic_chip_data *data = irq_data->chip_data;
         int err, irq = irq_data->irq;
 
-        if (!config_enabled(CONFIG_SMP))
+        if (!IS_ENABLED(CONFIG_SMP))
                 return -EPERM;
 
         if (!cpumask_intersects(dest, cpu_online_mask))
diff --git a/arch/x86/kernel/fpu/signal.c b/arch/x86/kernel/fpu/signal.c
index 9e231d88bb33..a184c210efba 100644
--- a/arch/x86/kernel/fpu/signal.c
+++ b/arch/x86/kernel/fpu/signal.c
@@ -159,8 +159,8 @@ int copy_fpstate_to_sigframe(void __user *buf, void __user *buf_fx, int size)
         struct task_struct *tsk = current;
         int ia32_fxstate = (buf != buf_fx);
 
-        ia32_fxstate &= (config_enabled(CONFIG_X86_32) ||
-                         config_enabled(CONFIG_IA32_EMULATION));
+        ia32_fxstate &= (IS_ENABLED(CONFIG_X86_32) ||
+                         IS_ENABLED(CONFIG_IA32_EMULATION));
 
         if (!access_ok(VERIFY_WRITE, buf, size))
                 return -EACCES;
@@ -268,8 +268,8 @@ static int __fpu__restore_sig(void __user *buf, void __user *buf_fx, int size)
         u64 xfeatures = 0;
         int fx_only = 0;
 
-        ia32_fxstate &= (config_enabled(CONFIG_X86_32) ||
-                         config_enabled(CONFIG_IA32_EMULATION));
+        ia32_fxstate &= (IS_ENABLED(CONFIG_X86_32) ||
+                         IS_ENABLED(CONFIG_IA32_EMULATION));
 
         if (!buf) {
                 fpu__clear(fpu);
@@ -416,8 +416,8 @@ void fpu__init_prepare_fx_sw_frame(void)
         fx_sw_reserved.xfeatures = xfeatures_mask;
         fx_sw_reserved.xstate_size = fpu_user_xstate_size;
 
-        if (config_enabled(CONFIG_IA32_EMULATION) ||
-            config_enabled(CONFIG_X86_32)) {
+        if (IS_ENABLED(CONFIG_IA32_EMULATION) ||
+            IS_ENABLED(CONFIG_X86_32)) {
                 int fsave_header_size = sizeof(struct fregs_state);
 
                 fx_sw_reserved_ia32 = fx_sw_reserved;
diff --git a/arch/x86/kernel/pci-calgary_64.c b/arch/x86/kernel/pci-calgary_64.c
index 833b1d329c47..5d400ba1349d 100644
--- a/arch/x86/kernel/pci-calgary_64.c
+++ b/arch/x86/kernel/pci-calgary_64.c
@@ -340,7 +340,7 @@ static inline struct iommu_table *find_iommu_table(struct device *dev)
 
 static void calgary_unmap_sg(struct device *dev, struct scatterlist *sglist,
                              int nelems,enum dma_data_direction dir,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
         struct iommu_table *tbl = find_iommu_table(dev);
         struct scatterlist *s;
@@ -364,7 +364,7 @@ static void calgary_unmap_sg(struct device *dev, struct scatterlist *sglist,
 
 static int calgary_map_sg(struct device *dev, struct scatterlist *sg,
                           int nelems, enum dma_data_direction dir,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         struct iommu_table *tbl = find_iommu_table(dev);
         struct scatterlist *s;
@@ -396,7 +396,7 @@ static int calgary_map_sg(struct device *dev, struct scatterlist *sg,
 
         return nelems;
 error:
-        calgary_unmap_sg(dev, sg, nelems, dir, NULL);
+        calgary_unmap_sg(dev, sg, nelems, dir, 0);
         for_each_sg(sg, s, nelems, i) {
                 sg->dma_address = DMA_ERROR_CODE;
                 sg->dma_length = 0;
@@ -407,7 +407,7 @@ error:
 static dma_addr_t calgary_map_page(struct device *dev, struct page *page,
                                    unsigned long offset, size_t size,
                                    enum dma_data_direction dir,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         void *vaddr = page_address(page) + offset;
         unsigned long uaddr;
@@ -422,7 +422,7 @@ static dma_addr_t calgary_map_page(struct device *dev, struct page *page,
 
 static void calgary_unmap_page(struct device *dev, dma_addr_t dma_addr,
                                size_t size, enum dma_data_direction dir,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
         struct iommu_table *tbl = find_iommu_table(dev);
         unsigned int npages;
@@ -432,7 +432,7 @@ static void calgary_unmap_page(struct device *dev, dma_addr_t dma_addr,
 }
 
 static void* calgary_alloc_coherent(struct device *dev, size_t size,
-        dma_addr_t *dma_handle, gfp_t flag, struct dma_attrs *attrs)
+        dma_addr_t *dma_handle, gfp_t flag, unsigned long attrs)
 {
         void *ret = NULL;
         dma_addr_t mapping;
@@ -466,7 +466,7 @@ error:
 
 static void calgary_free_coherent(struct device *dev, size_t size,
                                   void *vaddr, dma_addr_t dma_handle,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         unsigned int npages;
         struct iommu_table *tbl = find_iommu_table(dev);
diff --git a/arch/x86/kernel/pci-dma.c b/arch/x86/kernel/pci-dma.c
index 6ba014c61d62..d30c37750765 100644
--- a/arch/x86/kernel/pci-dma.c
+++ b/arch/x86/kernel/pci-dma.c
@@ -77,7 +77,7 @@ void __init pci_iommu_alloc(void)
 }
 void *dma_generic_alloc_coherent(struct device *dev, size_t size,
                                  dma_addr_t *dma_addr, gfp_t flag,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         unsigned long dma_mask;
         struct page *page;
@@ -120,7 +120,7 @@ again:
 }
 
 void dma_generic_free_coherent(struct device *dev, size_t size, void *vaddr,
-                               dma_addr_t dma_addr, struct dma_attrs *attrs)
+                               dma_addr_t dma_addr, unsigned long attrs)
 {
         unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
         struct page *page = virt_to_page(vaddr);
diff --git a/arch/x86/kernel/pci-nommu.c b/arch/x86/kernel/pci-nommu.c
index da15918d1c81..00e71ce396a8 100644
--- a/arch/x86/kernel/pci-nommu.c
+++ b/arch/x86/kernel/pci-nommu.c
@@ -28,7 +28,7 @@ check_addr(char *name, struct device *hwdev, dma_addr_t bus, size_t size)
 static dma_addr_t nommu_map_page(struct device *dev, struct page *page,
                                  unsigned long offset, size_t size,
                                  enum dma_data_direction dir,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         dma_addr_t bus = page_to_phys(page) + offset;
         WARN_ON(size == 0);
@@ -55,7 +55,7 @@ static dma_addr_t nommu_map_page(struct device *dev, struct page *page,
  */
 static int nommu_map_sg(struct device *hwdev, struct scatterlist *sg,
                         int nents, enum dma_data_direction dir,
-                        struct dma_attrs *attrs)
+                        unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
diff --git a/arch/x86/kernel/pci-swiotlb.c b/arch/x86/kernel/pci-swiotlb.c
index 5069ef560d83..b47edb8f5256 100644
--- a/arch/x86/kernel/pci-swiotlb.c
+++ b/arch/x86/kernel/pci-swiotlb.c
@@ -16,7 +16,7 @@ int swiotlb __read_mostly;
 
 void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                                         dma_addr_t *dma_handle, gfp_t flags,
-                                        struct dma_attrs *attrs)
+                                        unsigned long attrs)
 {
         void *vaddr;
 
@@ -37,7 +37,7 @@ void *x86_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
 
 void x86_swiotlb_free_coherent(struct device *dev, size_t size,
                                       void *vaddr, dma_addr_t dma_addr,
-                                      struct dma_attrs *attrs)
+                                      unsigned long attrs)
 {
         if (is_swiotlb_buffer(dma_to_phys(dev, dma_addr)))
                 swiotlb_free_coherent(dev, size, vaddr, dma_addr);
diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c
index 22cc2f9f8aec..99f285b512db 100644
--- a/arch/x86/kernel/signal.c
+++ b/arch/x86/kernel/signal.c
@@ -146,7 +146,7 @@ static int restore_sigcontext(struct pt_regs *regs,
                 buf = (void __user *)buf_val;
         } get_user_catch(err);
 
-        err |= fpu__restore_sig(buf, config_enabled(CONFIG_X86_32));
+        err |= fpu__restore_sig(buf, IS_ENABLED(CONFIG_X86_32));
 
         force_iret();
 
@@ -245,14 +245,14 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size,
         struct fpu *fpu = &current->thread.fpu;
 
         /* redzone */
-        if (config_enabled(CONFIG_X86_64))
+        if (IS_ENABLED(CONFIG_X86_64))
                 sp -= 128;
 
         /* This is the X/Open sanctioned signal stack switching.  */
         if (ka->sa.sa_flags & SA_ONSTACK) {
                 if (sas_ss_flags(sp) == 0)
                         sp = current->sas_ss_sp + current->sas_ss_size;
-        } else if (config_enabled(CONFIG_X86_32) &&
+        } else if (IS_ENABLED(CONFIG_X86_32) &&
                    !onsigstack &&
                    (regs->ss & 0xffff) != __USER_DS &&
                    !(ka->sa.sa_flags & SA_RESTORER) &&
@@ -262,7 +262,7 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size,
         }
 
         if (fpu->fpstate_active) {
-                sp = fpu__alloc_mathframe(sp, config_enabled(CONFIG_X86_32),
+                sp = fpu__alloc_mathframe(sp, IS_ENABLED(CONFIG_X86_32),
                                           &buf_fx, &math_size);
                 *fpstate = (void __user *)sp;
         }
@@ -662,18 +662,18 @@ badframe:
 
 static inline int is_ia32_compat_frame(void)
 {
-        return config_enabled(CONFIG_IA32_EMULATION) &&
+        return IS_ENABLED(CONFIG_IA32_EMULATION) &&
                test_thread_flag(TIF_IA32);
 }
 
 static inline int is_ia32_frame(void)
 {
-        return config_enabled(CONFIG_X86_32) || is_ia32_compat_frame();
+        return IS_ENABLED(CONFIG_X86_32) || is_ia32_compat_frame();
 }
 
 static inline int is_x32_frame(void)
 {
-        return config_enabled(CONFIG_X86_X32_ABI) && test_thread_flag(TIF_X32);
+        return IS_ENABLED(CONFIG_X86_X32_ABI) && test_thread_flag(TIF_X32);
 }
 
 static int
diff --git a/arch/x86/pci/sta2x11-fixup.c b/arch/x86/pci/sta2x11-fixup.c
index 5ceda85b8687..052c1cb76305 100644
--- a/arch/x86/pci/sta2x11-fixup.c
+++ b/arch/x86/pci/sta2x11-fixup.c
@@ -169,7 +169,7 @@ static void *sta2x11_swiotlb_alloc_coherent(struct device *dev,
                                             size_t size,
                                             dma_addr_t *dma_handle,
                                             gfp_t flags,
-                                            struct dma_attrs *attrs)
+                                            unsigned long attrs)
 {
         void *vaddr;
 
diff --git a/arch/x86/pci/vmd.c b/arch/x86/pci/vmd.c
index e88b4176260f..b814ca675131 100644
--- a/arch/x86/pci/vmd.c
+++ b/arch/x86/pci/vmd.c
@@ -274,14 +274,14 @@ static struct dma_map_ops *vmd_dma_ops(struct device *dev)
 }
 
 static void *vmd_alloc(struct device *dev, size_t size, dma_addr_t *addr,
-                       gfp_t flag, struct dma_attrs *attrs)
+                       gfp_t flag, unsigned long attrs)
 {
         return vmd_dma_ops(dev)->alloc(to_vmd_dev(dev), size, addr, flag,
                                        attrs);
 }
 
 static void vmd_free(struct device *dev, size_t size, void *vaddr,
-                     dma_addr_t addr, struct dma_attrs *attrs)
+                     dma_addr_t addr, unsigned long attrs)
 {
         return vmd_dma_ops(dev)->free(to_vmd_dev(dev), size, vaddr, addr,
                                       attrs);
@@ -289,7 +289,7 @@ static void vmd_free(struct device *dev, size_t size, void *vaddr,
 
 static int vmd_mmap(struct device *dev, struct vm_area_struct *vma,
                     void *cpu_addr, dma_addr_t addr, size_t size,
-                    struct dma_attrs *attrs)
+                    unsigned long attrs)
 {
         return vmd_dma_ops(dev)->mmap(to_vmd_dev(dev), vma, cpu_addr, addr,
                                       size, attrs);
@@ -297,7 +297,7 @@ static int vmd_mmap(struct device *dev, struct vm_area_struct *vma,
 
 static int vmd_get_sgtable(struct device *dev, struct sg_table *sgt,
                            void *cpu_addr, dma_addr_t addr, size_t size,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         return vmd_dma_ops(dev)->get_sgtable(to_vmd_dev(dev), sgt, cpu_addr,
                                              addr, size, attrs);
@@ -306,26 +306,26 @@ static int vmd_get_sgtable(struct device *dev, struct sg_table *sgt,
 static dma_addr_t vmd_map_page(struct device *dev, struct page *page,
                                unsigned long offset, size_t size,
                                enum dma_data_direction dir,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
         return vmd_dma_ops(dev)->map_page(to_vmd_dev(dev), page, offset, size,
                                           dir, attrs);
 }
 
 static void vmd_unmap_page(struct device *dev, dma_addr_t addr, size_t size,
-                           enum dma_data_direction dir, struct dma_attrs *attrs)
+                           enum dma_data_direction dir, unsigned long attrs)
 {
         vmd_dma_ops(dev)->unmap_page(to_vmd_dev(dev), addr, size, dir, attrs);
 }
 
 static int vmd_map_sg(struct device *dev, struct scatterlist *sg, int nents,
-                      enum dma_data_direction dir, struct dma_attrs *attrs)
+                      enum dma_data_direction dir, unsigned long attrs)
 {
         return vmd_dma_ops(dev)->map_sg(to_vmd_dev(dev), sg, nents, dir, attrs);
 }
 
 static void vmd_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
-                         enum dma_data_direction dir, struct dma_attrs *attrs)
+                         enum dma_data_direction dir, unsigned long attrs)
 {
         vmd_dma_ops(dev)->unmap_sg(to_vmd_dev(dev), sg, nents, dir, attrs);
 }
diff --git a/arch/xtensa/kernel/pci-dma.c b/arch/xtensa/kernel/pci-dma.c
index cd66698348ca..1e68806d6695 100644
--- a/arch/xtensa/kernel/pci-dma.c
+++ b/arch/xtensa/kernel/pci-dma.c
@@ -142,7 +142,7 @@ static void xtensa_sync_sg_for_device(struct device *dev,
 
 static void *xtensa_dma_alloc(struct device *dev, size_t size,
                               dma_addr_t *handle, gfp_t flag,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         unsigned long ret;
         unsigned long uncached = 0;
@@ -171,7 +171,7 @@ static void *xtensa_dma_alloc(struct device *dev, size_t size,
 }
 
 static void xtensa_dma_free(struct device *hwdev, size_t size, void *vaddr,
-                            dma_addr_t dma_handle, struct dma_attrs *attrs)
+                            dma_addr_t dma_handle, unsigned long attrs)
 {
         unsigned long addr = (unsigned long)vaddr +
                 XCHAL_KSEG_CACHED_VADDR - XCHAL_KSEG_BYPASS_VADDR;
@@ -185,7 +185,7 @@ static void xtensa_dma_free(struct device *hwdev, size_t size, void *vaddr,
 static dma_addr_t xtensa_map_page(struct device *dev, struct page *page,
                                   unsigned long offset, size_t size,
                                   enum dma_data_direction dir,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         dma_addr_t dma_handle = page_to_phys(page) + offset;
 
@@ -195,14 +195,14 @@ static dma_addr_t xtensa_map_page(struct device *dev, struct page *page,
 
 static void xtensa_unmap_page(struct device *dev, dma_addr_t dma_handle,
                               size_t size, enum dma_data_direction dir,
-                              struct dma_attrs *attrs)
+                              unsigned long attrs)
 {
         xtensa_sync_single_for_cpu(dev, dma_handle, size, dir);
 }
 
 static int xtensa_map_sg(struct device *dev, struct scatterlist *sg,
                          int nents, enum dma_data_direction dir,
-                         struct dma_attrs *attrs)
+                         unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
@@ -217,7 +217,7 @@ static int xtensa_map_sg(struct device *dev, struct scatterlist *sg,
 static void xtensa_unmap_sg(struct device *dev,
                             struct scatterlist *sg, int nents,
                             enum dma_data_direction dir,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         struct scatterlist *s;
         int i;
diff --git a/block/Kconfig b/block/Kconfig
index 0363cd731320..161491d0a879 100644
--- a/block/Kconfig
+++ b/block/Kconfig
@@ -88,19 +88,6 @@ config BLK_DEV_INTEGRITY
         T10/SCSI Data Integrity Field or the T13/ATA External Path
         Protection.  If in doubt, say N.
 
-config BLK_DEV_DAX
-        bool "Block device DAX support"
-        depends on FS_DAX
-        depends on BROKEN
-        help
-          When DAX support is available (CONFIG_FS_DAX) raw block
-          devices can also support direct userspace access to the
-          storage capacity via MMAP(2) similar to a file on a
-          DAX-enabled filesystem.  However, the DAX I/O-path disables
-          some standard I/O-statistics, and the MMAP(2) path has some
-          operational differences due to bypassing the page
-          cache.  If in doubt, say N.
-
 config BLK_DEV_THROTTLING
         bool "Block layer bio throttling support"
         depends on BLK_CGROUP=y
diff --git a/drivers/firmware/broadcom/bcm47xx_sprom.c b/drivers/firmware/broadcom/bcm47xx_sprom.c
index b6eb875d4af3..62aa3cf09b4d 100644
--- a/drivers/firmware/broadcom/bcm47xx_sprom.c
+++ b/drivers/firmware/broadcom/bcm47xx_sprom.c
@@ -669,7 +669,7 @@ static int bcm47xx_get_sprom_bcma(struct bcma_bus *bus, struct ssb_sprom *out)
         case BCMA_HOSTTYPE_PCI:
                 memset(out, 0, sizeof(struct ssb_sprom));
                 /* On BCM47XX all PCI buses share the same domain */
-                if (config_enabled(CONFIG_BCM47XX))
+                if (IS_ENABLED(CONFIG_BCM47XX))
                         snprintf(buf, sizeof(buf), "pci/%u/%u/",
                                  bus->host_pci->bus->number + 1,
                                  PCI_SLOT(bus->host_pci->devfn));
diff --git a/drivers/fpga/Kconfig b/drivers/fpga/Kconfig
index c9b9fdf6cfbb..d61410299ec0 100644
--- a/drivers/fpga/Kconfig
+++ b/drivers/fpga/Kconfig
@@ -21,6 +21,7 @@ config FPGA_MGR_SOCFPGA
 
 config FPGA_MGR_ZYNQ_FPGA
         tristate "Xilinx Zynq FPGA"
+        depends on HAS_DMA
         help
           FPGA manager driver support for Xilinx Zynq FPGAs.
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
index fb49443bfd32..4cfb39d543b4 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
@@ -52,7 +52,7 @@ static int exynos_drm_fb_mmap(struct fb_info *info,
 
         ret = dma_mmap_attrs(to_dma_dev(helper->dev), vma, exynos_gem->cookie,
                              exynos_gem->dma_addr, exynos_gem->size,
-                             &exynos_gem->dma_attrs);
+                             exynos_gem->dma_attrs);
         if (ret < 0) {
                 DRM_ERROR("failed to mmap.\n");
                 return ret;
diff --git a/drivers/gpu/drm/exynos/exynos_drm_g2d.c b/drivers/gpu/drm/exynos/exynos_drm_g2d.c
index 8564c3da0d22..4bf00f57ffe8 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_g2d.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_g2d.c
@@ -17,7 +17,6 @@
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <linux/dma-mapping.h>
-#include <linux/dma-attrs.h>
 #include <linux/of.h>
 
 #include <drm/drmP.h>
@@ -235,7 +234,7 @@ struct g2d_data {
         struct mutex                    cmdlist_mutex;
         dma_addr_t                      cmdlist_pool;
         void                            *cmdlist_pool_virt;
-        struct dma_attrs                cmdlist_dma_attrs;
+        unsigned long                   cmdlist_dma_attrs;
 
         /* runqueue*/
         struct g2d_runqueue_node        *runqueue_node;
@@ -256,13 +255,12 @@ static int g2d_init_cmdlist(struct g2d_data *g2d)
         int ret;
         struct g2d_buf_info *buf_info;
 
-        init_dma_attrs(&g2d->cmdlist_dma_attrs);
-        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &g2d->cmdlist_dma_attrs);
+        g2d->cmdlist_dma_attrs = DMA_ATTR_WRITE_COMBINE;
 
         g2d->cmdlist_pool_virt = dma_alloc_attrs(to_dma_dev(subdrv->drm_dev),
                                                 G2D_CMDLIST_POOL_SIZE,
                                                 &g2d->cmdlist_pool, GFP_KERNEL,
-                                                &g2d->cmdlist_dma_attrs);
+                                                g2d->cmdlist_dma_attrs);
         if (!g2d->cmdlist_pool_virt) {
                 dev_err(dev, "failed to allocate dma memory\n");
                 return -ENOMEM;
@@ -295,7 +293,7 @@ static int g2d_init_cmdlist(struct g2d_data *g2d)
 err:
         dma_free_attrs(to_dma_dev(subdrv->drm_dev), G2D_CMDLIST_POOL_SIZE,
                         g2d->cmdlist_pool_virt,
-                        g2d->cmdlist_pool, &g2d->cmdlist_dma_attrs);
+                        g2d->cmdlist_pool, g2d->cmdlist_dma_attrs);
         return ret;
 }
 
@@ -309,7 +307,7 @@ static void g2d_fini_cmdlist(struct g2d_data *g2d)
                 dma_free_attrs(to_dma_dev(subdrv->drm_dev),
                                 G2D_CMDLIST_POOL_SIZE,
                                 g2d->cmdlist_pool_virt,
-                                g2d->cmdlist_pool, &g2d->cmdlist_dma_attrs);
+                                g2d->cmdlist_pool, g2d->cmdlist_dma_attrs);
         }
 }
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_gem.c b/drivers/gpu/drm/exynos/exynos_drm_gem.c
index cdf9f1af4347..f2ae72ba7d5a 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_gem.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_gem.c
@@ -24,7 +24,7 @@
 static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem)
 {
         struct drm_device *dev = exynos_gem->base.dev;
-        enum dma_attr attr;
+        unsigned long attr;
         unsigned int nr_pages;
         struct sg_table sgt;
         int ret = -ENOMEM;
@@ -34,7 +34,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem)
                 return 0;
         }
 
-        init_dma_attrs(&exynos_gem->dma_attrs);
+        exynos_gem->dma_attrs = 0;
 
         /*
          * if EXYNOS_BO_CONTIG, fully physically contiguous memory
@@ -42,7 +42,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem)
          * as possible.
          */
         if (!(exynos_gem->flags & EXYNOS_BO_NONCONTIG))
-                dma_set_attr(DMA_ATTR_FORCE_CONTIGUOUS, &exynos_gem->dma_attrs);
+                exynos_gem->dma_attrs |= DMA_ATTR_FORCE_CONTIGUOUS;
 
         /*
          * if EXYNOS_BO_WC or EXYNOS_BO_NONCACHABLE, writecombine mapping
@@ -54,8 +54,8 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem)
         else
                 attr = DMA_ATTR_NON_CONSISTENT;
 
-        dma_set_attr(attr, &exynos_gem->dma_attrs);
-        dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &exynos_gem->dma_attrs);
+        exynos_gem->dma_attrs |= attr;
+        exynos_gem->dma_attrs |= DMA_ATTR_NO_KERNEL_MAPPING;
 
         nr_pages = exynos_gem->size >> PAGE_SHIFT;
 
@@ -67,7 +67,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem)
 
         exynos_gem->cookie = dma_alloc_attrs(to_dma_dev(dev), exynos_gem->size,
                                              &exynos_gem->dma_addr, GFP_KERNEL,
-                                             &exynos_gem->dma_attrs);
+                                             exynos_gem->dma_attrs);
         if (!exynos_gem->cookie) {
                 DRM_ERROR("failed to allocate buffer.\n");
                 goto err_free;
@@ -75,7 +75,7 @@ static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem)
 
         ret = dma_get_sgtable_attrs(to_dma_dev(dev), &sgt, exynos_gem->cookie,
                                     exynos_gem->dma_addr, exynos_gem->size,
-                                    &exynos_gem->dma_attrs);
+                                    exynos_gem->dma_attrs);
         if (ret < 0) {
                 DRM_ERROR("failed to get sgtable.\n");
                 goto err_dma_free;
@@ -99,7 +99,7 @@ err_sgt_free:
         sg_free_table(&sgt);
 err_dma_free:
         dma_free_attrs(to_dma_dev(dev), exynos_gem->size, exynos_gem->cookie,
-                       exynos_gem->dma_addr, &exynos_gem->dma_attrs);
+                       exynos_gem->dma_addr, exynos_gem->dma_attrs);
 err_free:
         drm_free_large(exynos_gem->pages);
 
@@ -120,7 +120,7 @@ static void exynos_drm_free_buf(struct exynos_drm_gem *exynos_gem)
 
         dma_free_attrs(to_dma_dev(dev), exynos_gem->size, exynos_gem->cookie,
                         (dma_addr_t)exynos_gem->dma_addr,
-                        &exynos_gem->dma_attrs);
+                        exynos_gem->dma_attrs);
 
         drm_free_large(exynos_gem->pages);
 }
@@ -346,7 +346,7 @@ static int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem *exynos_gem,
 
         ret = dma_mmap_attrs(to_dma_dev(drm_dev), vma, exynos_gem->cookie,
                              exynos_gem->dma_addr, exynos_gem->size,
-                             &exynos_gem->dma_attrs);
+                             exynos_gem->dma_attrs);
         if (ret < 0) {
                 DRM_ERROR("failed to mmap.\n");
                 return ret;
diff --git a/drivers/gpu/drm/exynos/exynos_drm_gem.h b/drivers/gpu/drm/exynos/exynos_drm_gem.h
index 78100742281d..df7c543d6558 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_gem.h
+++ b/drivers/gpu/drm/exynos/exynos_drm_gem.h
@@ -50,7 +50,7 @@ struct exynos_drm_gem {
         void                    *cookie;
         void __iomem            *kvaddr;
         dma_addr_t              dma_addr;
-        struct dma_attrs        dma_attrs;
+        unsigned long           dma_attrs;
         struct page             **pages;
         struct sg_table         *sgt;
 };
diff --git a/drivers/gpu/drm/mediatek/mtk_drm_gem.c b/drivers/gpu/drm/mediatek/mtk_drm_gem.c
index fa2ec0cd00e8..7abc550ebc00 100644
--- a/drivers/gpu/drm/mediatek/mtk_drm_gem.c
+++ b/drivers/gpu/drm/mediatek/mtk_drm_gem.c
@@ -54,15 +54,14 @@ struct mtk_drm_gem_obj *mtk_drm_gem_create(struct drm_device *dev,
 
         obj = &mtk_gem->base;
 
-        init_dma_attrs(&mtk_gem->dma_attrs);
-        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &mtk_gem->dma_attrs);
+        mtk_gem->dma_attrs = DMA_ATTR_WRITE_COMBINE;
 
         if (!alloc_kmap)
-                dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &mtk_gem->dma_attrs);
+                mtk_gem->dma_attrs |= DMA_ATTR_NO_KERNEL_MAPPING;
 
         mtk_gem->cookie = dma_alloc_attrs(priv->dma_dev, obj->size,
                                           &mtk_gem->dma_addr, GFP_KERNEL,
-                                          &mtk_gem->dma_attrs);
+                                          mtk_gem->dma_attrs);
         if (!mtk_gem->cookie) {
                 DRM_ERROR("failed to allocate %zx byte dma buffer", obj->size);
                 ret = -ENOMEM;
@@ -93,7 +92,7 @@ void mtk_drm_gem_free_object(struct drm_gem_object *obj)
                 drm_prime_gem_destroy(obj, mtk_gem->sg);
         else
                 dma_free_attrs(priv->dma_dev, obj->size, mtk_gem->cookie,
-                               mtk_gem->dma_addr, &mtk_gem->dma_attrs);
+                               mtk_gem->dma_addr, mtk_gem->dma_attrs);
 
         /* release file pointer to gem object. */
         drm_gem_object_release(obj);
@@ -173,7 +172,7 @@ static int mtk_drm_gem_object_mmap(struct drm_gem_object *obj,
         vma->vm_pgoff = 0;
 
         ret = dma_mmap_attrs(priv->dma_dev, vma, mtk_gem->cookie,
-                             mtk_gem->dma_addr, obj->size, &mtk_gem->dma_attrs);
+                             mtk_gem->dma_addr, obj->size, mtk_gem->dma_attrs);
         if (ret)
                 drm_gem_vm_close(vma);
 
@@ -224,7 +223,7 @@ struct sg_table *mtk_gem_prime_get_sg_table(struct drm_gem_object *obj)
 
         ret = dma_get_sgtable_attrs(priv->dma_dev, sgt, mtk_gem->cookie,
                                     mtk_gem->dma_addr, obj->size,
-                                    &mtk_gem->dma_attrs);
+                                    mtk_gem->dma_attrs);
         if (ret) {
                 DRM_ERROR("failed to allocate sgt, %d\n", ret);
                 kfree(sgt);
diff --git a/drivers/gpu/drm/mediatek/mtk_drm_gem.h b/drivers/gpu/drm/mediatek/mtk_drm_gem.h
index 3a2a5624a1cb..2752718fa5b2 100644
--- a/drivers/gpu/drm/mediatek/mtk_drm_gem.h
+++ b/drivers/gpu/drm/mediatek/mtk_drm_gem.h
@@ -35,7 +35,7 @@ struct mtk_drm_gem_obj {
         void                    *cookie;
         void                    *kvaddr;
         dma_addr_t              dma_addr;
-        struct dma_attrs        dma_attrs;
+        unsigned long           dma_attrs;
         struct sg_table         *sg;
 };
 
diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c
index 26f859ec24b3..8a0237008f74 100644
--- a/drivers/gpu/drm/msm/msm_drv.c
+++ b/drivers/gpu/drm/msm/msm_drv.c
@@ -238,11 +238,10 @@ static int msm_drm_uninit(struct device *dev)
         }
 
         if (priv->vram.paddr) {
-                DEFINE_DMA_ATTRS(attrs);
-                dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &attrs);
+                unsigned long attrs = DMA_ATTR_NO_KERNEL_MAPPING;
                 drm_mm_takedown(&priv->vram.mm);
                 dma_free_attrs(dev, priv->vram.size, NULL,
-                               priv->vram.paddr, &attrs);
+                               priv->vram.paddr, attrs);
         }
 
         component_unbind_all(dev, ddev);
@@ -310,21 +309,21 @@ static int msm_init_vram(struct drm_device *dev)
         }
 
         if (size) {
-                DEFINE_DMA_ATTRS(attrs);
+                unsigned long attrs = 0;
                 void *p;
 
                 priv->vram.size = size;
 
                 drm_mm_init(&priv->vram.mm, 0, (size >> PAGE_SHIFT) - 1);
 
-                dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &attrs);
-                dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
+                attrs |= DMA_ATTR_NO_KERNEL_MAPPING;
+                attrs |= DMA_ATTR_WRITE_COMBINE;
 
                 /* note that for no-kernel-mapping, the vaddr returned
                  * is bogus, but non-null if allocation succeeded:
                  */
                 p = dma_alloc_attrs(dev->dev, size,
-                                &priv->vram.paddr, GFP_KERNEL, &attrs);
+                                &priv->vram.paddr, GFP_KERNEL, attrs);
                 if (!p) {
                         dev_err(dev->dev, "failed to allocate VRAM\n");
                         priv->vram.paddr = 0;
diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/gk20a.c b/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/gk20a.c
index 6b8f2a19b2d9..a6a7fa0d7679 100644
--- a/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/gk20a.c
+++ b/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/gk20a.c
@@ -109,7 +109,7 @@ struct gk20a_instmem {
         u16 iommu_bit;
 
         /* Only used by DMA API */
-        struct dma_attrs attrs;
+        unsigned long attrs;
 };
 #define gk20a_instmem(p) container_of((p), struct gk20a_instmem, base)
 
@@ -293,7 +293,7 @@ gk20a_instobj_dtor_dma(struct nvkm_memory *memory)
                 goto out;
 
         dma_free_attrs(dev, node->base.mem.size << PAGE_SHIFT, node->base.vaddr,
-                       node->handle, &imem->attrs);
+                       node->handle, imem->attrs);
 
 out:
         return node;
@@ -386,7 +386,7 @@ gk20a_instobj_ctor_dma(struct gk20a_instmem *imem, u32 npages, u32 align,
 
         node->base.vaddr = dma_alloc_attrs(dev, npages << PAGE_SHIFT,
                                            &node->handle, GFP_KERNEL,
-                                           &imem->attrs);
+                                           imem->attrs);
         if (!node->base.vaddr) {
                 nvkm_error(subdev, "cannot allocate DMA memory\n");
                 return -ENOMEM;
@@ -597,10 +597,9 @@ gk20a_instmem_new(struct nvkm_device *device, int index,
 
                 nvkm_info(&imem->base.subdev, "using IOMMU\n");
         } else {
-                init_dma_attrs(&imem->attrs);
-                dma_set_attr(DMA_ATTR_NON_CONSISTENT, &imem->attrs);
-                dma_set_attr(DMA_ATTR_WEAK_ORDERING, &imem->attrs);
-                dma_set_attr(DMA_ATTR_WRITE_COMBINE, &imem->attrs);
+                imem->attrs = DMA_ATTR_NON_CONSISTENT |
+                              DMA_ATTR_WEAK_ORDERING |
+                              DMA_ATTR_WRITE_COMBINE;
 
                 nvkm_info(&imem->base.subdev, "using DMA API\n");
         }
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_gem.c b/drivers/gpu/drm/rockchip/rockchip_drm_gem.c
index 059e902f872d..b70f9423379c 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_gem.c
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_gem.c
@@ -17,8 +17,6 @@
 #include <drm/drm_gem.h>
 #include <drm/drm_vma_manager.h>
 
-#include <linux/dma-attrs.h>
-
 #include "rockchip_drm_drv.h"
 #include "rockchip_drm_gem.h"
 
@@ -28,15 +26,14 @@ static int rockchip_gem_alloc_buf(struct rockchip_gem_object *rk_obj,
         struct drm_gem_object *obj = &rk_obj->base;
         struct drm_device *drm = obj->dev;
 
-        init_dma_attrs(&rk_obj->dma_attrs);
-        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &rk_obj->dma_attrs);
+        rk_obj->dma_attrs = DMA_ATTR_WRITE_COMBINE;
 
         if (!alloc_kmap)
-                dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &rk_obj->dma_attrs);
+                rk_obj->dma_attrs |= DMA_ATTR_NO_KERNEL_MAPPING;
 
         rk_obj->kvaddr = dma_alloc_attrs(drm->dev, obj->size,
                                          &rk_obj->dma_addr, GFP_KERNEL,
-                                         &rk_obj->dma_attrs);
+                                         rk_obj->dma_attrs);
         if (!rk_obj->kvaddr) {
                 DRM_ERROR("failed to allocate %zu byte dma buffer", obj->size);
                 return -ENOMEM;
@@ -51,7 +48,7 @@ static void rockchip_gem_free_buf(struct rockchip_gem_object *rk_obj)
         struct drm_device *drm = obj->dev;
 
         dma_free_attrs(drm->dev, obj->size, rk_obj->kvaddr, rk_obj->dma_addr,
-                       &rk_obj->dma_attrs);
+                       rk_obj->dma_attrs);
 }
 
 static int rockchip_drm_gem_object_mmap(struct drm_gem_object *obj,
@@ -70,7 +67,7 @@ static int rockchip_drm_gem_object_mmap(struct drm_gem_object *obj,
         vma->vm_pgoff = 0;
 
         ret = dma_mmap_attrs(drm->dev, vma, rk_obj->kvaddr, rk_obj->dma_addr,
-                             obj->size, &rk_obj->dma_attrs);
+                             obj->size, rk_obj->dma_attrs);
         if (ret)
                 drm_gem_vm_close(vma);
 
@@ -262,7 +259,7 @@ struct sg_table *rockchip_gem_prime_get_sg_table(struct drm_gem_object *obj)
 
         ret = dma_get_sgtable_attrs(drm->dev, sgt, rk_obj->kvaddr,
                                     rk_obj->dma_addr, obj->size,
-                                    &rk_obj->dma_attrs);
+                                    rk_obj->dma_attrs);
         if (ret) {
                 DRM_ERROR("failed to allocate sgt, %d\n", ret);
                 kfree(sgt);
@@ -276,7 +273,7 @@ void *rockchip_gem_prime_vmap(struct drm_gem_object *obj)
 {
         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 
-        if (dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, &rk_obj->dma_attrs))
+        if (rk_obj->dma_attrs & DMA_ATTR_NO_KERNEL_MAPPING)
                 return NULL;
 
         return rk_obj->kvaddr;
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_gem.h b/drivers/gpu/drm/rockchip/rockchip_drm_gem.h
index ad22618473a4..18b3488db4ec 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_gem.h
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_gem.h
@@ -23,7 +23,7 @@ struct rockchip_gem_object {
 
         void *kvaddr;
         dma_addr_t dma_addr;
-        struct dma_attrs dma_attrs;
+        unsigned long dma_attrs;
 };
 
 struct sg_table *rockchip_gem_prime_get_sg_table(struct drm_gem_object *obj);
diff --git a/drivers/infiniband/core/umem.c b/drivers/infiniband/core/umem.c
index fe4d2e1a8b58..c68746ce6624 100644
--- a/drivers/infiniband/core/umem.c
+++ b/drivers/infiniband/core/umem.c
@@ -37,7 +37,6 @@
 #include <linux/sched.h>
 #include <linux/export.h>
 #include <linux/hugetlb.h>
-#include <linux/dma-attrs.h>
 #include <linux/slab.h>
 #include <rdma/ib_umem_odp.h>
 
@@ -92,12 +91,12 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
         unsigned long npages;
         int ret;
         int i;
-        DEFINE_DMA_ATTRS(attrs);
+        unsigned long dma_attrs = 0;
         struct scatterlist *sg, *sg_list_start;
         int need_release = 0;
 
         if (dmasync)
-                dma_set_attr(DMA_ATTR_WRITE_BARRIER, &attrs);
+                dma_attrs |= DMA_ATTR_WRITE_BARRIER;
 
         if (!size)
                 return ERR_PTR(-EINVAL);
@@ -215,7 +214,7 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
                                   umem->sg_head.sgl,
                                   umem->npages,
                                   DMA_BIDIRECTIONAL,
-                                  &attrs);
+                                  dma_attrs);
 
         if (umem->nmap <= 0) {
                 ret = -ENOMEM;
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index 33c177ba93be..96de97a46079 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -2375,7 +2375,7 @@ static void __unmap_single(struct dma_ops_domain *dma_dom,
 static dma_addr_t map_page(struct device *dev, struct page *page,
                            unsigned long offset, size_t size,
                            enum dma_data_direction dir,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         phys_addr_t paddr = page_to_phys(page) + offset;
         struct protection_domain *domain;
@@ -2398,7 +2398,7 @@ static dma_addr_t map_page(struct device *dev, struct page *page,
  * The exported unmap_single function for dma_ops.
  */
 static void unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size,
-                       enum dma_data_direction dir, struct dma_attrs *attrs)
+                       enum dma_data_direction dir, unsigned long attrs)
 {
         struct protection_domain *domain;
         struct dma_ops_domain *dma_dom;
@@ -2444,7 +2444,7 @@ static int sg_num_pages(struct device *dev,
  */
 static int map_sg(struct device *dev, struct scatterlist *sglist,
                   int nelems, enum dma_data_direction direction,
-                  struct dma_attrs *attrs)
+                  unsigned long attrs)
 {
         int mapped_pages = 0, npages = 0, prot = 0, i;
         struct protection_domain *domain;
@@ -2525,7 +2525,7 @@ out_err:
  */
 static void unmap_sg(struct device *dev, struct scatterlist *sglist,
                      int nelems, enum dma_data_direction dir,
-                     struct dma_attrs *attrs)
+                     unsigned long attrs)
 {
         struct protection_domain *domain;
         struct dma_ops_domain *dma_dom;
@@ -2548,7 +2548,7 @@ static void unmap_sg(struct device *dev, struct scatterlist *sglist,
  */
 static void *alloc_coherent(struct device *dev, size_t size,
                             dma_addr_t *dma_addr, gfp_t flag,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         u64 dma_mask = dev->coherent_dma_mask;
         struct protection_domain *domain;
@@ -2604,7 +2604,7 @@ out_free:
  */
 static void free_coherent(struct device *dev, size_t size,
                           void *virt_addr, dma_addr_t dma_addr,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         struct protection_domain *domain;
         struct dma_ops_domain *dma_dom;
diff --git a/drivers/iommu/dma-iommu.c b/drivers/iommu/dma-iommu.c
index ea5a9ebf0f78..08a1e2f3690f 100644
--- a/drivers/iommu/dma-iommu.c
+++ b/drivers/iommu/dma-iommu.c
@@ -286,7 +286,7 @@ void iommu_dma_free(struct device *dev, struct page **pages, size_t size,
  *         or NULL on failure.
  */
 struct page **iommu_dma_alloc(struct device *dev, size_t size, gfp_t gfp,
-                struct dma_attrs *attrs, int prot, dma_addr_t *handle,
+                unsigned long attrs, int prot, dma_addr_t *handle,
                 void (*flush_page)(struct device *, const void *, phys_addr_t))
 {
         struct iommu_domain *domain = iommu_get_domain_for_dev(dev);
@@ -306,7 +306,7 @@ struct page **iommu_dma_alloc(struct device *dev, size_t size, gfp_t gfp,
         } else {
                 size = ALIGN(size, min_size);
         }
-        if (dma_get_attr(DMA_ATTR_ALLOC_SINGLE_PAGES, attrs))
+        if (attrs & DMA_ATTR_ALLOC_SINGLE_PAGES)
                 alloc_sizes = min_size;
 
         count = PAGE_ALIGN(size) >> PAGE_SHIFT;
@@ -400,7 +400,7 @@ dma_addr_t iommu_dma_map_page(struct device *dev, struct page *page,
 }
 
 void iommu_dma_unmap_page(struct device *dev, dma_addr_t handle, size_t size,
-                enum dma_data_direction dir, struct dma_attrs *attrs)
+                enum dma_data_direction dir, unsigned long attrs)
 {
         __iommu_dma_unmap(iommu_get_domain_for_dev(dev), handle);
 }
@@ -560,7 +560,7 @@ out_restore_sg:
 }
 
 void iommu_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
-                enum dma_data_direction dir, struct dma_attrs *attrs)
+                enum dma_data_direction dir, unsigned long attrs)
 {
         /*
          * The scatterlist segments are mapped into a single
diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
index afbaa2c69a59..ebb5bf3ddbd9 100644
--- a/drivers/iommu/intel-iommu.c
+++ b/drivers/iommu/intel-iommu.c
@@ -3552,7 +3552,7 @@ error:
 static dma_addr_t intel_map_page(struct device *dev, struct page *page,
                                  unsigned long offset, size_t size,
                                  enum dma_data_direction dir,
-                                 struct dma_attrs *attrs)
+                                 unsigned long attrs)
 {
         return __intel_map_single(dev, page_to_phys(page) + offset, size,
                                   dir, *dev->dma_mask);
@@ -3711,14 +3711,14 @@ static void intel_unmap(struct device *dev, dma_addr_t dev_addr, size_t size)
 
 static void intel_unmap_page(struct device *dev, dma_addr_t dev_addr,
                              size_t size, enum dma_data_direction dir,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
         intel_unmap(dev, dev_addr, size);
 }
 
 static void *intel_alloc_coherent(struct device *dev, size_t size,
                                   dma_addr_t *dma_handle, gfp_t flags,
-                                  struct dma_attrs *attrs)
+                                  unsigned long attrs)
 {
         struct page *page = NULL;
         int order;
@@ -3764,7 +3764,7 @@ static void *intel_alloc_coherent(struct device *dev, size_t size,
 }
 
 static void intel_free_coherent(struct device *dev, size_t size, void *vaddr,
-                                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                                dma_addr_t dma_handle, unsigned long attrs)
 {
         int order;
         struct page *page = virt_to_page(vaddr);
@@ -3779,7 +3779,7 @@ static void intel_free_coherent(struct device *dev, size_t size, void *vaddr,
 
 static void intel_unmap_sg(struct device *dev, struct scatterlist *sglist,
                            int nelems, enum dma_data_direction dir,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         dma_addr_t startaddr = sg_dma_address(sglist) & PAGE_MASK;
         unsigned long nrpages = 0;
@@ -3808,7 +3808,7 @@ static int intel_nontranslate_map_sg(struct device *hddev,
 }
 
 static int intel_map_sg(struct device *dev, struct scatterlist *sglist, int nelems,
-                        enum dma_data_direction dir, struct dma_attrs *attrs)
+                        enum dma_data_direction dir, unsigned long attrs)
 {
         int i;
         struct dmar_domain *domain;
diff --git a/drivers/irqchip/irq-mips-gic.c b/drivers/irqchip/irq-mips-gic.c
index 3786d0f21972..c5f33c3bd228 100644
--- a/drivers/irqchip/irq-mips-gic.c
+++ b/drivers/irqchip/irq-mips-gic.c
@@ -359,7 +359,7 @@ static void gic_handle_shared_int(bool chained)
                 pending_reg += gic_reg_step;
                 intrmask_reg += gic_reg_step;
 
-                if (!config_enabled(CONFIG_64BIT) || mips_cm_is64)
+                if (!IS_ENABLED(CONFIG_64BIT) || mips_cm_is64)
                         continue;
 
                 pending[i] |= (u64)gic_read(pending_reg) << 32;
diff --git a/drivers/media/dvb-frontends/cxd2841er.c b/drivers/media/dvb-frontends/cxd2841er.c
index 09c39346167f..ffe88bc6b813 100644
--- a/drivers/media/dvb-frontends/cxd2841er.c
+++ b/drivers/media/dvb-frontends/cxd2841er.c
@@ -3378,20 +3378,28 @@ static int cxd2841er_tune_tc(struct dvb_frontend *fe,
                                 ret = cxd2841er_get_carrier_offset_i(
                                                 priv, p->bandwidth_hz,
                                                 &carrier_offset);
+                                if (ret)
+                                        return ret;
                                 break;
                         case SYS_DVBT:
                                 ret = cxd2841er_get_carrier_offset_t(
                                         priv, p->bandwidth_hz,
                                         &carrier_offset);
+                                if (ret)
+                                        return ret;
                                 break;
                         case SYS_DVBT2:
                                 ret = cxd2841er_get_carrier_offset_t2(
                                         priv, p->bandwidth_hz,
                                         &carrier_offset);
+                                if (ret)
+                                        return ret;
                                 break;
                         case SYS_DVBC_ANNEX_A:
                                 ret = cxd2841er_get_carrier_offset_c(
                                         priv, &carrier_offset);
+                                if (ret)
+                                        return ret;
                                 break;
                         default:
                                 dev_dbg(&priv->i2c->dev,
@@ -3399,8 +3407,6 @@ static int cxd2841er_tune_tc(struct dvb_frontend *fe,
                                         __func__, priv->system);
                                 return -EINVAL;
                         }
-                        if (ret)
-                                return ret;
                         dev_dbg(&priv->i2c->dev, "%s(): carrier offset %d\n",
                                 __func__, carrier_offset);
                         p->frequency += carrier_offset;
diff --git a/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc_drv.c b/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc_drv.c
index e277b7c23516..c7806ecda2dd 100644
--- a/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc_drv.c
+++ b/drivers/media/platform/mtk-vcodec/mtk_vcodec_enc_drv.c
@@ -246,7 +246,6 @@ static int mtk_vcodec_probe(struct platform_device *pdev)
         struct video_device *vfd_enc;
         struct resource *res;
         int i, j, ret;
-        DEFINE_DMA_ATTRS(attrs);
 
         dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
         if (!dev)
@@ -378,9 +377,6 @@ static int mtk_vcodec_probe(struct platform_device *pdev)
                 goto err_enc_reg;
         }
 
-        /* Avoid the iommu eat big hunks */
-        dma_set_attr(DMA_ATTR_ALLOC_SINGLE_PAGES, &attrs);
-
         mtk_v4l2_debug(0, "encoder registered as /dev/video%d",
                         vfd_enc->num);
 
diff --git a/drivers/media/platform/sti/bdisp/bdisp-hw.c b/drivers/media/platform/sti/bdisp/bdisp-hw.c
index 3df66d11c795..b7892f3efd98 100644
--- a/drivers/media/platform/sti/bdisp/bdisp-hw.c
+++ b/drivers/media/platform/sti/bdisp/bdisp-hw.c
@@ -430,14 +430,11 @@ int bdisp_hw_get_and_clear_irq(struct bdisp_dev *bdisp)
  */
 void bdisp_hw_free_nodes(struct bdisp_ctx *ctx)
 {
-        if (ctx && ctx->node[0]) {
-                DEFINE_DMA_ATTRS(attrs);
-
-                dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
+        if (ctx && ctx->node[0])
                 dma_free_attrs(ctx->bdisp_dev->dev,
                                sizeof(struct bdisp_node) * MAX_NB_NODE,
-                               ctx->node[0], ctx->node_paddr[0], &attrs);
-        }
+                               ctx->node[0], ctx->node_paddr[0],
+                               DMA_ATTR_WRITE_COMBINE);
 }
 
 /**
@@ -455,12 +452,10 @@ int bdisp_hw_alloc_nodes(struct bdisp_ctx *ctx)
         unsigned int i, node_size = sizeof(struct bdisp_node);
         void *base;
         dma_addr_t paddr;
-        DEFINE_DMA_ATTRS(attrs);
 
         /* Allocate all the nodes within a single memory page */
-        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
         base = dma_alloc_attrs(dev, node_size * MAX_NB_NODE, &paddr,
-                               GFP_KERNEL | GFP_DMA, &attrs);
+                               GFP_KERNEL | GFP_DMA, DMA_ATTR_WRITE_COMBINE);
         if (!base) {
                 dev_err(dev, "%s no mem\n", __func__);
                 return -ENOMEM;
@@ -493,13 +488,9 @@ void bdisp_hw_free_filters(struct device *dev)
 {
         int size = (BDISP_HF_NB * NB_H_FILTER) + (BDISP_VF_NB * NB_V_FILTER);
 
-        if (bdisp_h_filter[0].virt) {
-                DEFINE_DMA_ATTRS(attrs);
-
-                dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
+        if (bdisp_h_filter[0].virt)
                 dma_free_attrs(dev, size, bdisp_h_filter[0].virt,
-                               bdisp_h_filter[0].paddr, &attrs);
-        }
+                               bdisp_h_filter[0].paddr, DMA_ATTR_WRITE_COMBINE);
 }
 
 /**
@@ -516,12 +507,11 @@ int bdisp_hw_alloc_filters(struct device *dev)
         unsigned int i, size;
         void *base;
         dma_addr_t paddr;
-        DEFINE_DMA_ATTRS(attrs);
 
         /* Allocate all the filters within a single memory page */
         size = (BDISP_HF_NB * NB_H_FILTER) + (BDISP_VF_NB * NB_V_FILTER);
-        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
-        base = dma_alloc_attrs(dev, size, &paddr, GFP_KERNEL | GFP_DMA, &attrs);
+        base = dma_alloc_attrs(dev, size, &paddr, GFP_KERNEL | GFP_DMA,
+                               DMA_ATTR_WRITE_COMBINE);
         if (!base)
                 return -ENOMEM;
 
diff --git a/drivers/media/v4l2-core/videobuf2-dma-contig.c b/drivers/media/v4l2-core/videobuf2-dma-contig.c
index 863f658a3fa1..b09b2c9b6b63 100644
--- a/drivers/media/v4l2-core/videobuf2-dma-contig.c
+++ b/drivers/media/v4l2-core/videobuf2-dma-contig.c
@@ -27,7 +27,7 @@ struct vb2_dc_buf {
         unsigned long                   size;
         void                            *cookie;
         dma_addr_t                      dma_addr;
-        struct dma_attrs                attrs;
+        unsigned long                   attrs;
         enum dma_data_direction         dma_dir;
         struct sg_table                 *dma_sgt;
         struct frame_vector             *vec;
@@ -130,12 +130,12 @@ static void vb2_dc_put(void *buf_priv)
                 kfree(buf->sgt_base);
         }
         dma_free_attrs(buf->dev, buf->size, buf->cookie, buf->dma_addr,
-                        &buf->attrs);
+                       buf->attrs);
         put_device(buf->dev);
         kfree(buf);
 }
 
-static void *vb2_dc_alloc(struct device *dev, const struct dma_attrs *attrs,
+static void *vb2_dc_alloc(struct device *dev, unsigned long attrs,
                           unsigned long size, enum dma_data_direction dma_dir,
                           gfp_t gfp_flags)
 {
@@ -146,16 +146,16 @@ static void *vb2_dc_alloc(struct device *dev, const struct dma_attrs *attrs,
                 return ERR_PTR(-ENOMEM);
 
         if (attrs)
-                buf->attrs = *attrs;
+                buf->attrs = attrs;
         buf->cookie = dma_alloc_attrs(dev, size, &buf->dma_addr,
-                                        GFP_KERNEL | gfp_flags, &buf->attrs);
+                                        GFP_KERNEL | gfp_flags, buf->attrs);
         if (!buf->cookie) {
                 dev_err(dev, "dma_alloc_coherent of size %ld failed\n", size);
                 kfree(buf);
                 return ERR_PTR(-ENOMEM);
         }
 
-        if (!dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, &buf->attrs))
+        if ((buf->attrs & DMA_ATTR_NO_KERNEL_MAPPING) == 0)
                 buf->vaddr = buf->cookie;
 
         /* Prevent the device from being released while the buffer is used */
@@ -189,7 +189,7 @@ static int vb2_dc_mmap(void *buf_priv, struct vm_area_struct *vma)
         vma->vm_pgoff = 0;
 
         ret = dma_mmap_attrs(buf->dev, vma, buf->cookie,
-                buf->dma_addr, buf->size, &buf->attrs);
+                buf->dma_addr, buf->size, buf->attrs);
 
         if (ret) {
                 pr_err("Remapping memory failed, error: %d\n", ret);
@@ -372,7 +372,7 @@ static struct sg_table *vb2_dc_get_base_sgt(struct vb2_dc_buf *buf)
         }
 
         ret = dma_get_sgtable_attrs(buf->dev, sgt, buf->cookie, buf->dma_addr,
-                buf->size, &buf->attrs);
+                buf->size, buf->attrs);
         if (ret < 0) {
                 dev_err(buf->dev, "failed to get scatterlist from DMA API\n");
                 kfree(sgt);
@@ -421,15 +421,12 @@ static void vb2_dc_put_userptr(void *buf_priv)
         struct page **pages;
 
         if (sgt) {
-                DEFINE_DMA_ATTRS(attrs);
-
-                dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
                 /*
                  * No need to sync to CPU, it's already synced to the CPU
                  * since the finish() memop will have been called before this.
                  */
                 dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
-                                   buf->dma_dir, &attrs);
+                                   buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
                 pages = frame_vector_pages(buf->vec);
                 /* sgt should exist only if vector contains pages... */
                 BUG_ON(IS_ERR(pages));
@@ -484,9 +481,6 @@ static void *vb2_dc_get_userptr(struct device *dev, unsigned long vaddr,
         struct sg_table *sgt;
         unsigned long contig_size;
         unsigned long dma_align = dma_get_cache_alignment();
-        DEFINE_DMA_ATTRS(attrs);
-
-        dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
 
         /* Only cache aligned DMA transfers are reliable */
         if (!IS_ALIGNED(vaddr | size, dma_align)) {
@@ -548,7 +542,7 @@ static void *vb2_dc_get_userptr(struct device *dev, unsigned long vaddr,
          * prepare() memop is called.
          */
         sgt->nents = dma_map_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
-                                      buf->dma_dir, &attrs);
+                                      buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
         if (sgt->nents <= 0) {
                 pr_err("failed to map scatterlist\n");
                 ret = -EIO;
@@ -572,7 +566,7 @@ out:
 
 fail_map_sg:
         dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
-                           buf->dma_dir, &attrs);
+                           buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
 
 fail_sgt_init:
         sg_free_table(sgt);
diff --git a/drivers/media/v4l2-core/videobuf2-dma-sg.c b/drivers/media/v4l2-core/videobuf2-dma-sg.c
index a39db8a6db7a..bd82d709ee82 100644
--- a/drivers/media/v4l2-core/videobuf2-dma-sg.c
+++ b/drivers/media/v4l2-core/videobuf2-dma-sg.c
@@ -95,7 +95,7 @@ static int vb2_dma_sg_alloc_compacted(struct vb2_dma_sg_buf *buf,
         return 0;
 }
 
-static void *vb2_dma_sg_alloc(struct device *dev, const struct dma_attrs *dma_attrs,
+static void *vb2_dma_sg_alloc(struct device *dev, unsigned long dma_attrs,
                               unsigned long size, enum dma_data_direction dma_dir,
                               gfp_t gfp_flags)
 {
@@ -103,9 +103,6 @@ static void *vb2_dma_sg_alloc(struct device *dev, const struct dma_attrs *dma_at
         struct sg_table *sgt;
         int ret;
         int num_pages;
-        DEFINE_DMA_ATTRS(attrs);
-
-        dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
 
         if (WARN_ON(dev == NULL))
                 return NULL;
@@ -144,7 +141,7 @@ static void *vb2_dma_sg_alloc(struct device *dev, const struct dma_attrs *dma_at
          * prepare() memop is called.
          */
         sgt->nents = dma_map_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
-                                      buf->dma_dir, &attrs);
+                                      buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
         if (!sgt->nents)
                 goto fail_map;
 
@@ -179,13 +176,10 @@ static void vb2_dma_sg_put(void *buf_priv)
         int i = buf->num_pages;
 
         if (atomic_dec_and_test(&buf->refcount)) {
-                DEFINE_DMA_ATTRS(attrs);
-
-                dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
                 dprintk(1, "%s: Freeing buffer of %d pages\n", __func__,
                         buf->num_pages);
                 dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
-                                   buf->dma_dir, &attrs);
+                                   buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
                 if (buf->vaddr)
                         vm_unmap_ram(buf->vaddr, buf->num_pages);
                 sg_free_table(buf->dma_sgt);
@@ -228,10 +222,8 @@ static void *vb2_dma_sg_get_userptr(struct device *dev, unsigned long vaddr,
 {
         struct vb2_dma_sg_buf *buf;
         struct sg_table *sgt;
-        DEFINE_DMA_ATTRS(attrs);
         struct frame_vector *vec;
 
-        dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
         buf = kzalloc(sizeof *buf, GFP_KERNEL);
         if (!buf)
                 return NULL;
@@ -262,7 +254,7 @@ static void *vb2_dma_sg_get_userptr(struct device *dev, unsigned long vaddr,
          * prepare() memop is called.
          */
         sgt->nents = dma_map_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents,
-                                      buf->dma_dir, &attrs);
+                                      buf->dma_dir, DMA_ATTR_SKIP_CPU_SYNC);
         if (!sgt->nents)
                 goto userptr_fail_map;
 
@@ -286,14 +278,11 @@ static void vb2_dma_sg_put_userptr(void *buf_priv)
         struct vb2_dma_sg_buf *buf = buf_priv;
         struct sg_table *sgt = &buf->sg_table;
         int i = buf->num_pages;
-        DEFINE_DMA_ATTRS(attrs);
-
-        dma_set_attr(DMA_ATTR_SKIP_CPU_SYNC, &attrs);
 
         dprintk(1, "%s: Releasing userspace buffer of %d pages\n",
                __func__, buf->num_pages);
         dma_unmap_sg_attrs(buf->dev, sgt->sgl, sgt->orig_nents, buf->dma_dir,
-                           &attrs);
+                           DMA_ATTR_SKIP_CPU_SYNC);
         if (buf->vaddr)
                 vm_unmap_ram(buf->vaddr, buf->num_pages);
         sg_free_table(buf->dma_sgt);
diff --git a/drivers/media/v4l2-core/videobuf2-vmalloc.c b/drivers/media/v4l2-core/videobuf2-vmalloc.c
index 7e8a07ed8d82..c2820a6e164d 100644
--- a/drivers/media/v4l2-core/videobuf2-vmalloc.c
+++ b/drivers/media/v4l2-core/videobuf2-vmalloc.c
@@ -33,7 +33,7 @@ struct vb2_vmalloc_buf {
 
 static void vb2_vmalloc_put(void *buf_priv);
 
-static void *vb2_vmalloc_alloc(struct device *dev, const struct dma_attrs *attrs,
+static void *vb2_vmalloc_alloc(struct device *dev, unsigned long attrs,
                                unsigned long size, enum dma_data_direction dma_dir,
                                gfp_t gfp_flags)
 {
diff --git a/drivers/misc/mic/host/mic_boot.c b/drivers/misc/mic/host/mic_boot.c
index e047efd83f57..9599d732aff3 100644
--- a/drivers/misc/mic/host/mic_boot.c
+++ b/drivers/misc/mic/host/mic_boot.c
@@ -38,7 +38,7 @@ static inline struct mic_device *vpdev_to_mdev(struct device *dev)
 static dma_addr_t
 _mic_dma_map_page(struct device *dev, struct page *page,
                   unsigned long offset, size_t size,
-                  enum dma_data_direction dir, struct dma_attrs *attrs)
+                  enum dma_data_direction dir, unsigned long attrs)
 {
         void *va = phys_to_virt(page_to_phys(page)) + offset;
         struct mic_device *mdev = vpdev_to_mdev(dev);
@@ -48,7 +48,7 @@ _mic_dma_map_page(struct device *dev, struct page *page,
 
 static void _mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
                                 size_t size, enum dma_data_direction dir,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         struct mic_device *mdev = vpdev_to_mdev(dev);
 
@@ -144,7 +144,7 @@ static inline struct mic_device *scdev_to_mdev(struct scif_hw_dev *scdev)
 
 static void *__mic_dma_alloc(struct device *dev, size_t size,
                              dma_addr_t *dma_handle, gfp_t gfp,
-                             struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
         struct scif_hw_dev *scdev = dev_get_drvdata(dev);
         struct mic_device *mdev = scdev_to_mdev(scdev);
@@ -164,7 +164,7 @@ static void *__mic_dma_alloc(struct device *dev, size_t size,
 }
 
 static void __mic_dma_free(struct device *dev, size_t size, void *vaddr,
-                           dma_addr_t dma_handle, struct dma_attrs *attrs)
+                           dma_addr_t dma_handle, unsigned long attrs)
 {
         struct scif_hw_dev *scdev = dev_get_drvdata(dev);
         struct mic_device *mdev = scdev_to_mdev(scdev);
@@ -176,7 +176,7 @@ static void __mic_dma_free(struct device *dev, size_t size, void *vaddr,
 static dma_addr_t
 __mic_dma_map_page(struct device *dev, struct page *page, unsigned long offset,
                    size_t size, enum dma_data_direction dir,
-                   struct dma_attrs *attrs)
+                   unsigned long attrs)
 {
         void *va = phys_to_virt(page_to_phys(page)) + offset;
         struct scif_hw_dev *scdev = dev_get_drvdata(dev);
@@ -188,7 +188,7 @@ __mic_dma_map_page(struct device *dev, struct page *page, unsigned long offset,
 static void
 __mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
                      size_t size, enum dma_data_direction dir,
-                     struct dma_attrs *attrs)
+                     unsigned long attrs)
 {
         struct scif_hw_dev *scdev = dev_get_drvdata(dev);
         struct mic_device *mdev = scdev_to_mdev(scdev);
@@ -198,7 +198,7 @@ __mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
 
 static int __mic_dma_map_sg(struct device *dev, struct scatterlist *sg,
                             int nents, enum dma_data_direction dir,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         struct scif_hw_dev *scdev = dev_get_drvdata(dev);
         struct mic_device *mdev = scdev_to_mdev(scdev);
@@ -229,7 +229,7 @@ err:
 static void __mic_dma_unmap_sg(struct device *dev,
                                struct scatterlist *sg, int nents,
                                enum dma_data_direction dir,
-                               struct dma_attrs *attrs)
+                               unsigned long attrs)
 {
         struct scif_hw_dev *scdev = dev_get_drvdata(dev);
         struct mic_device *mdev = scdev_to_mdev(scdev);
@@ -327,7 +327,7 @@ static inline struct mic_device *mbdev_to_mdev(struct mbus_device *mbdev)
 static dma_addr_t
 mic_dma_map_page(struct device *dev, struct page *page,
                  unsigned long offset, size_t size, enum dma_data_direction dir,
-                 struct dma_attrs *attrs)
+                 unsigned long attrs)
 {
         void *va = phys_to_virt(page_to_phys(page)) + offset;
         struct mic_device *mdev = dev_get_drvdata(dev->parent);
@@ -338,7 +338,7 @@ mic_dma_map_page(struct device *dev, struct page *page,
 static void
 mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
                    size_t size, enum dma_data_direction dir,
-                   struct dma_attrs *attrs)
+                   unsigned long attrs)
 {
         struct mic_device *mdev = dev_get_drvdata(dev->parent);
         mic_unmap_single(mdev, dma_addr, size);
diff --git a/drivers/mtd/bcm47xxpart.c b/drivers/mtd/bcm47xxpart.c
index 845dd27d9f41..377947580203 100644
--- a/drivers/mtd/bcm47xxpart.c
+++ b/drivers/mtd/bcm47xxpart.c
@@ -122,7 +122,7 @@ static int bcm47xxpart_parse(struct mtd_info *master,
         for (offset = 0; offset <= master->size - blocksize;
              offset += blocksize) {
                 /* Nothing more in higher memory on BCM47XX (MIPS) */
-                if (config_enabled(CONFIG_BCM47XX) && offset >= 0x2000000)
+                if (IS_ENABLED(CONFIG_BCM47XX) && offset >= 0x2000000)
                         break;
 
                 if (curr_part >= BCM47XXPART_MAX_PARTS) {
diff --git a/drivers/net/wireless/ath/ath10k/debug.c b/drivers/net/wireless/ath/ath10k/debug.c
index 355e1ae665f9..8f0fd41dfd4b 100644
--- a/drivers/net/wireless/ath/ath10k/debug.c
+++ b/drivers/net/wireless/ath/ath10k/debug.c
@@ -139,11 +139,11 @@ void ath10k_debug_print_hwfw_info(struct ath10k *ar)
                     ar->id.subsystem_vendor, ar->id.subsystem_device);
 
         ath10k_info(ar, "kconfig debug %d debugfs %d tracing %d dfs %d testmode %d\n",
-                    config_enabled(CONFIG_ATH10K_DEBUG),
-                    config_enabled(CONFIG_ATH10K_DEBUGFS),
-                    config_enabled(CONFIG_ATH10K_TRACING),
-                    config_enabled(CONFIG_ATH10K_DFS_CERTIFIED),
-                    config_enabled(CONFIG_NL80211_TESTMODE));
+                    IS_ENABLED(CONFIG_ATH10K_DEBUG),
+                    IS_ENABLED(CONFIG_ATH10K_DEBUGFS),
+                    IS_ENABLED(CONFIG_ATH10K_TRACING),
+                    IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED),
+                    IS_ENABLED(CONFIG_NL80211_TESTMODE));
 
         firmware = ar->normal_mode_fw.fw_file.firmware;
         if (firmware)
@@ -2424,7 +2424,7 @@ int ath10k_debug_register(struct ath10k *ar)
         debugfs_create_file("nf_cal_period", S_IRUSR | S_IWUSR,
                             ar->debug.debugfs_phy, ar, &fops_nf_cal_period);
 
-        if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
+        if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) {
                 debugfs_create_file("dfs_simulate_radar", S_IWUSR,
                                     ar->debug.debugfs_phy, ar,
                                     &fops_simulate_radar);
diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index fb8e38df9446..0bbd0a00edcc 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
@@ -3039,7 +3039,7 @@ static void ath10k_regd_update(struct ath10k *ar)
 
         regpair = ar->ath_common.regulatory.regpair;
 
-        if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
+        if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
                 nl_dfs_reg = ar->dfs_detector->region;
                 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
         } else {
@@ -3068,7 +3068,7 @@ static void ath10k_reg_notifier(struct wiphy *wiphy,
 
         ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
 
-        if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
+        if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
                 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
                            request->dfs_region);
                 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
@@ -7955,7 +7955,7 @@ int ath10k_mac_register(struct ath10k *ar)
         if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
                 ar->hw->netdev_features = NETIF_F_HW_CSUM;
 
-        if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
+        if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) {
                 /* Init ath dfs pattern detector */
                 ar->ath_common.debug_mask = ATH_DBG_DFS;
                 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
@@ -8003,7 +8003,7 @@ err_unregister:
         ieee80211_unregister_hw(ar->hw);
 
 err_dfs_detector_exit:
-        if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
+        if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
                 ar->dfs_detector->exit(ar->dfs_detector);
 
 err_free:
@@ -8018,7 +8018,7 @@ void ath10k_mac_unregister(struct ath10k *ar)
 {
         ieee80211_unregister_hw(ar->hw);
 
-        if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
+        if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
                 ar->dfs_detector->exit(ar->dfs_detector);
 
         kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
diff --git a/drivers/net/wireless/ath/ath10k/wmi.c b/drivers/net/wireless/ath/ath10k/wmi.c
index 169cd2e783eb..d2462886b75c 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.c
+++ b/drivers/net/wireless/ath/ath10k/wmi.c
@@ -3704,7 +3704,7 @@ void ath10k_wmi_event_dfs(struct ath10k *ar,
                    phyerr->tsf_timestamp, tsf, buf_len);
 
         /* Skip event if DFS disabled */
-        if (!config_enabled(CONFIG_ATH10K_DFS_CERTIFIED))
+        if (!IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED))
                 return;
 
         ATH10K_DFS_STAT_INC(ar, pulses_total);
diff --git a/drivers/net/wireless/ath/ath6kl/cfg80211.c b/drivers/net/wireless/ath/ath6kl/cfg80211.c
index 4ad6284fc37d..72e2ec67768d 100644
--- a/drivers/net/wireless/ath/ath6kl/cfg80211.c
+++ b/drivers/net/wireless/ath/ath6kl/cfg80211.c
@@ -3881,7 +3881,7 @@ int ath6kl_cfg80211_init(struct ath6kl *ar)
                                           BIT(NL80211_IFTYPE_P2P_CLIENT);
         }
 
-        if (config_enabled(CONFIG_ATH6KL_REGDOMAIN) &&
+        if (IS_ENABLED(CONFIG_ATH6KL_REGDOMAIN) &&
             test_bit(ATH6KL_FW_CAPABILITY_REGDOMAIN, ar->fw_capabilities)) {
                 wiphy->reg_notifier = ath6kl_cfg80211_reg_notify;
                 ar->wiphy->features |= NL80211_FEATURE_CELL_BASE_REG_HINTS;
diff --git a/drivers/net/wireless/ath/ath9k/common-spectral.c b/drivers/net/wireless/ath/ath9k/common-spectral.c
index a8762711ad74..e2512d5bc0e1 100644
--- a/drivers/net/wireless/ath/ath9k/common-spectral.c
+++ b/drivers/net/wireless/ath/ath9k/common-spectral.c
@@ -731,7 +731,7 @@ void ath9k_cmn_spectral_scan_trigger(struct ath_common *common,
         struct ath_hw *ah = spec_priv->ah;
         u32 rxfilter;
 
-        if (config_enabled(CONFIG_ATH9K_TX99))
+        if (IS_ENABLED(CONFIG_ATH9K_TX99))
                 return;
 
         if (!ath9k_hw_ops(ah)->spectral_scan_trigger) {
@@ -806,7 +806,7 @@ static ssize_t write_file_spec_scan_ctl(struct file *file,
         char buf[32];
         ssize_t len;
 
-        if (config_enabled(CONFIG_ATH9K_TX99))
+        if (IS_ENABLED(CONFIG_ATH9K_TX99))
                 return -EOPNOTSUPP;
 
         len = min(count, sizeof(buf) - 1);
@@ -1072,7 +1072,7 @@ static struct rchan_callbacks rfs_spec_scan_cb = {
 
 void ath9k_cmn_spectral_deinit_debug(struct ath_spec_scan_priv *spec_priv)
 {
-        if (config_enabled(CONFIG_ATH9K_DEBUGFS)) {
+        if (IS_ENABLED(CONFIG_ATH9K_DEBUGFS)) {
                 relay_close(spec_priv->rfs_chan_spec_scan);
                 spec_priv->rfs_chan_spec_scan = NULL;
         }
diff --git a/drivers/net/wireless/ath/ath9k/init.c b/drivers/net/wireless/ath/ath9k/init.c
index edc74fca60aa..cfa3fe82ade3 100644
--- a/drivers/net/wireless/ath/ath9k/init.c
+++ b/drivers/net/wireless/ath/ath9k/init.c
@@ -843,7 +843,7 @@ static void ath9k_set_hw_capab(struct ath_softc *sc, struct ieee80211_hw *hw)
                                NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
                                NL80211_FEATURE_P2P_GO_CTWIN;
 
-        if (!config_enabled(CONFIG_ATH9K_TX99)) {
+        if (!IS_ENABLED(CONFIG_ATH9K_TX99)) {
                 hw->wiphy->interface_modes =
                         BIT(NL80211_IFTYPE_P2P_GO) |
                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index 7594650f214f..a394622c9022 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -1250,7 +1250,7 @@ static int ath9k_add_interface(struct ieee80211_hw *hw,
 
         mutex_lock(&sc->mutex);
 
-        if (config_enabled(CONFIG_ATH9K_TX99)) {
+        if (IS_ENABLED(CONFIG_ATH9K_TX99)) {
                 if (sc->cur_chan->nvifs >= 1) {
                         mutex_unlock(&sc->mutex);
                         return -EOPNOTSUPP;
@@ -1300,7 +1300,7 @@ static int ath9k_change_interface(struct ieee80211_hw *hw,
 
         mutex_lock(&sc->mutex);
 
-        if (config_enabled(CONFIG_ATH9K_TX99)) {
+        if (IS_ENABLED(CONFIG_ATH9K_TX99)) {
                 mutex_unlock(&sc->mutex);
                 return -EOPNOTSUPP;
         }
@@ -1360,7 +1360,7 @@ static void ath9k_enable_ps(struct ath_softc *sc)
         struct ath_hw *ah = sc->sc_ah;
         struct ath_common *common = ath9k_hw_common(ah);
 
-        if (config_enabled(CONFIG_ATH9K_TX99))
+        if (IS_ENABLED(CONFIG_ATH9K_TX99))
                 return;
 
         sc->ps_enabled = true;
@@ -1379,7 +1379,7 @@ static void ath9k_disable_ps(struct ath_softc *sc)
         struct ath_hw *ah = sc->sc_ah;
         struct ath_common *common = ath9k_hw_common(ah);
 
-        if (config_enabled(CONFIG_ATH9K_TX99))
+        if (IS_ENABLED(CONFIG_ATH9K_TX99))
                 return;
 
         sc->ps_enabled = false;
@@ -1953,7 +1953,7 @@ static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
         struct ieee80211_channel *chan;
         int pos;
 
-        if (config_enabled(CONFIG_ATH9K_TX99))
+        if (IS_ENABLED(CONFIG_ATH9K_TX99))
                 return -EOPNOTSUPP;
 
         spin_lock_bh(&common->cc_lock);
@@ -2003,7 +2003,7 @@ static void ath9k_set_coverage_class(struct ieee80211_hw *hw,
         struct ath_softc *sc = hw->priv;
         struct ath_hw *ah = sc->sc_ah;
 
-        if (config_enabled(CONFIG_ATH9K_TX99))
+        if (IS_ENABLED(CONFIG_ATH9K_TX99))
                 return;
 
         mutex_lock(&sc->mutex);
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index 32160fca876a..669734252664 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -377,7 +377,7 @@ u32 ath_calcrxfilter(struct ath_softc *sc)
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
         u32 rfilt;
 
-        if (config_enabled(CONFIG_ATH9K_TX99))
+        if (IS_ENABLED(CONFIG_ATH9K_TX99))
                 return 0;
 
         rfilt = ATH9K_RX_FILTER_UCAST | ATH9K_RX_FILTER_BCAST
diff --git a/drivers/net/wireless/ath/dfs_pattern_detector.c b/drivers/net/wireless/ath/dfs_pattern_detector.c
index 2303ef96299d..2f8136d50f78 100644
--- a/drivers/net/wireless/ath/dfs_pattern_detector.c
+++ b/drivers/net/wireless/ath/dfs_pattern_detector.c
@@ -352,7 +352,7 @@ dfs_pattern_detector_init(struct ath_common *common,
 {
         struct dfs_pattern_detector *dpd;
 
-        if (!config_enabled(CONFIG_CFG80211_CERTIFICATION_ONUS))
+        if (!IS_ENABLED(CONFIG_CFG80211_CERTIFICATION_ONUS))
                 return NULL;
 
         dpd = kmalloc(sizeof(*dpd), GFP_KERNEL);
diff --git a/drivers/net/wireless/ath/regd.c b/drivers/net/wireless/ath/regd.c
index 7e15ed9ed31f..f8506037736f 100644
--- a/drivers/net/wireless/ath/regd.c
+++ b/drivers/net/wireless/ath/regd.c
@@ -116,7 +116,7 @@ static const struct ieee80211_regdomain ath_world_regdom_67_68_6A_6C = {
 
 static bool dynamic_country_user_possible(struct ath_regulatory *reg)
 {
-        if (config_enabled(CONFIG_ATH_REG_DYNAMIC_USER_CERT_TESTING))
+        if (IS_ENABLED(CONFIG_ATH_REG_DYNAMIC_USER_CERT_TESTING))
                 return true;
 
         switch (reg->country_code) {
@@ -188,7 +188,7 @@ static bool dynamic_country_user_possible(struct ath_regulatory *reg)
 
 static bool ath_reg_dyn_country_user_allow(struct ath_regulatory *reg)
 {
-        if (!config_enabled(CONFIG_ATH_REG_DYNAMIC_USER_REG_HINTS))
+        if (!IS_ENABLED(CONFIG_ATH_REG_DYNAMIC_USER_REG_HINTS))
                 return false;
         if (!dynamic_country_user_possible(reg))
                 return false;
diff --git a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
index e24b05996a1b..3ed6238f8f6e 100644
--- a/drivers/parisc/ccio-dma.c
+++ b/drivers/parisc/ccio-dma.c
@@ -790,7 +790,7 @@ ccio_map_single(struct device *dev, void *addr, size_t size,
 static dma_addr_t
 ccio_map_page(struct device *dev, struct page *page, unsigned long offset,
                 size_t size, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         return ccio_map_single(dev, page_address(page) + offset, size,
                         direction);
@@ -806,7 +806,7 @@ ccio_map_page(struct device *dev, struct page *page, unsigned long offset,
  */
 static void 
 ccio_unmap_page(struct device *dev, dma_addr_t iova, size_t size,
-                enum dma_data_direction direction, struct dma_attrs *attrs)
+                enum dma_data_direction direction, unsigned long attrs)
 {
         struct ioc *ioc;
         unsigned long flags; 
@@ -844,7 +844,7 @@ ccio_unmap_page(struct device *dev, dma_addr_t iova, size_t size,
  */
 static void * 
 ccio_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t flag,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
       void *ret;
 #if 0
@@ -878,9 +878,9 @@ ccio_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t flag,
  */
 static void 
 ccio_free(struct device *dev, size_t size, void *cpu_addr,
-                dma_addr_t dma_handle, struct dma_attrs *attrs)
+                dma_addr_t dma_handle, unsigned long attrs)
 {
-        ccio_unmap_page(dev, dma_handle, size, 0, NULL);
+        ccio_unmap_page(dev, dma_handle, size, 0, 0);
         free_pages((unsigned long)cpu_addr, get_order(size));
 }
 
@@ -907,7 +907,7 @@ ccio_free(struct device *dev, size_t size, void *cpu_addr,
  */
 static int
 ccio_map_sg(struct device *dev, struct scatterlist *sglist, int nents, 
-            enum dma_data_direction direction, struct dma_attrs *attrs)
+            enum dma_data_direction direction, unsigned long attrs)
 {
         struct ioc *ioc;
         int coalesced, filled = 0;
@@ -984,7 +984,7 @@ ccio_map_sg(struct device *dev, struct scatterlist *sglist, int nents,
  */
 static void 
 ccio_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents, 
-              enum dma_data_direction direction, struct dma_attrs *attrs)
+              enum dma_data_direction direction, unsigned long attrs)
 {
         struct ioc *ioc;
 
@@ -1004,7 +1004,7 @@ ccio_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents,
                 ioc->usg_pages += sg_dma_len(sglist) >> PAGE_SHIFT;
 #endif
                 ccio_unmap_page(dev, sg_dma_address(sglist),
-                                  sg_dma_len(sglist), direction, NULL);
+                                  sg_dma_len(sglist), direction, 0);
                 ++sglist;
         }
 
diff --git a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
index 42ec4600b7e4..151b86b6d2e2 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -783,7 +783,7 @@ sba_map_single(struct device *dev, void *addr, size_t size,
 static dma_addr_t
 sba_map_page(struct device *dev, struct page *page, unsigned long offset,
                 size_t size, enum dma_data_direction direction,
-                struct dma_attrs *attrs)
+                unsigned long attrs)
 {
         return sba_map_single(dev, page_address(page) + offset, size,
                         direction);
@@ -801,7 +801,7 @@ sba_map_page(struct device *dev, struct page *page, unsigned long offset,
  */
 static void
 sba_unmap_page(struct device *dev, dma_addr_t iova, size_t size,
-                enum dma_data_direction direction, struct dma_attrs *attrs)
+                enum dma_data_direction direction, unsigned long attrs)
 {
         struct ioc *ioc;
 #if DELAYED_RESOURCE_CNT > 0
@@ -876,7 +876,7 @@ sba_unmap_page(struct device *dev, dma_addr_t iova, size_t size,
  * See Documentation/DMA-API-HOWTO.txt
  */
 static void *sba_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_handle,
-                gfp_t gfp, struct dma_attrs *attrs)
+                gfp_t gfp, unsigned long attrs)
 {
         void *ret;
 
@@ -908,9 +908,9 @@ static void *sba_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_handle
  */
 static void
 sba_free(struct device *hwdev, size_t size, void *vaddr,
-                    dma_addr_t dma_handle, struct dma_attrs *attrs)
+                    dma_addr_t dma_handle, unsigned long attrs)
 {
-        sba_unmap_page(hwdev, dma_handle, size, 0, NULL);
+        sba_unmap_page(hwdev, dma_handle, size, 0, 0);
         free_pages((unsigned long) vaddr, get_order(size));
 }
 
@@ -943,7 +943,7 @@ int dump_run_sg = 0;
  */
 static int
 sba_map_sg(struct device *dev, struct scatterlist *sglist, int nents,
-           enum dma_data_direction direction, struct dma_attrs *attrs)
+           enum dma_data_direction direction, unsigned long attrs)
 {
         struct ioc *ioc;
         int coalesced, filled = 0;
@@ -1026,7 +1026,7 @@ sba_map_sg(struct device *dev, struct scatterlist *sglist, int nents,
  */
 static void 
 sba_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents,
-             enum dma_data_direction direction, struct dma_attrs *attrs)
+             enum dma_data_direction direction, unsigned long attrs)
 {
         struct ioc *ioc;
 #ifdef ASSERT_PDIR_SANITY
@@ -1051,7 +1051,7 @@ sba_unmap_sg(struct device *dev, struct scatterlist *sglist, int nents,
         while (sg_dma_len(sglist) && nents--) {
 
                 sba_unmap_page(dev, sg_dma_address(sglist), sg_dma_len(sglist),
-                                direction, NULL);
+                                direction, 0);
 #ifdef SBA_COLLECT_STATS
                 ioc->usg_pages += ((sg_dma_address(sglist) & ~IOVP_MASK) + sg_dma_len(sglist) + IOVP_SIZE - 1) >> PAGE_SHIFT;
                 ioc->usingle_calls--;   /* kluge since call is unmap_sg() */
diff --git a/drivers/pci/ecam.c b/drivers/pci/ecam.c
index 66e0d718472f..43ed08dd8b01 100644
--- a/drivers/pci/ecam.c
+++ b/drivers/pci/ecam.c
@@ -27,7 +27,7 @@
  * since we have enough virtual address range available.  On 32-bit, we
  * ioremap the config space for each bus individually.
  */
-static const bool per_bus_mapping = !config_enabled(CONFIG_64BIT);
+static const bool per_bus_mapping = !IS_ENABLED(CONFIG_64BIT);
 
 /*
  * Create a PCI config space window
diff --git a/drivers/remoteproc/qcom_q6v5_pil.c b/drivers/remoteproc/qcom_q6v5_pil.c
index 24791886219a..2a1b2c7d8f2c 100644
--- a/drivers/remoteproc/qcom_q6v5_pil.c
+++ b/drivers/remoteproc/qcom_q6v5_pil.c
@@ -349,13 +349,12 @@ static void q6v5proc_halt_axi_port(struct q6v5 *qproc,
 
 static int q6v5_mpss_init_image(struct q6v5 *qproc, const struct firmware *fw)
 {
-        DEFINE_DMA_ATTRS(attrs);
+        unsigned long dma_attrs = DMA_ATTR_FORCE_CONTIGUOUS;
         dma_addr_t phys;
         void *ptr;
         int ret;
 
-        dma_set_attr(DMA_ATTR_FORCE_CONTIGUOUS, &attrs);
-        ptr = dma_alloc_attrs(qproc->dev, fw->size, &phys, GFP_KERNEL, &attrs);
+        ptr = dma_alloc_attrs(qproc->dev, fw->size, &phys, GFP_KERNEL, dma_attrs);
         if (!ptr) {
                 dev_err(qproc->dev, "failed to allocate mdt buffer\n");
                 return -ENOMEM;
@@ -372,7 +371,7 @@ static int q6v5_mpss_init_image(struct q6v5 *qproc, const struct firmware *fw)
         else if (ret < 0)
                 dev_err(qproc->dev, "MPSS header authentication failed: %d\n", ret);
 
-        dma_free_attrs(qproc->dev, fw->size, ptr, phys, &attrs);
+        dma_free_attrs(qproc->dev, fw->size, ptr, phys, dma_attrs);
 
         return ret < 0 ? ret : 0;
 }
diff --git a/drivers/tty/serial/ar933x_uart.c b/drivers/tty/serial/ar933x_uart.c
index 1519d2ca7705..73137f4aac20 100644
--- a/drivers/tty/serial/ar933x_uart.c
+++ b/drivers/tty/serial/ar933x_uart.c
@@ -54,7 +54,7 @@ struct ar933x_uart_port {
 
 static inline bool ar933x_uart_console_enabled(void)
 {
-        return config_enabled(CONFIG_SERIAL_AR933X_CONSOLE);
+        return IS_ENABLED(CONFIG_SERIAL_AR933X_CONSOLE);
 }
 
 static inline unsigned int ar933x_uart_read(struct ar933x_uart_port *up,
@@ -636,7 +636,7 @@ static int ar933x_uart_probe(struct platform_device *pdev)
         int ret;
 
         np = pdev->dev.of_node;
-        if (config_enabled(CONFIG_OF) && np) {
+        if (IS_ENABLED(CONFIG_OF) && np) {
                 id = of_alias_get_id(np, "serial");
                 if (id < 0) {
                         dev_err(&pdev->dev, "unable to get alias id, err=%d\n",
diff --git a/drivers/video/fbdev/omap2/omapfb/omapfb-main.c b/drivers/video/fbdev/omap2/omapfb/omapfb-main.c
index 2fb90cb6803f..1d7c012f09db 100644
--- a/drivers/video/fbdev/omap2/omapfb/omapfb-main.c
+++ b/drivers/video/fbdev/omap2/omapfb/omapfb-main.c
@@ -1332,7 +1332,7 @@ static void omapfb_free_fbmem(struct fb_info *fbi)
         }
 
         dma_free_attrs(fbdev->dev, rg->size, rg->token, rg->dma_handle,
-                        &rg->attrs);
+                        rg->attrs);
 
         rg->token = NULL;
         rg->vaddr = NULL;
@@ -1370,7 +1370,7 @@ static int omapfb_alloc_fbmem(struct fb_info *fbi, unsigned long size,
         struct omapfb2_device *fbdev = ofbi->fbdev;
         struct omapfb2_mem_region *rg;
         void *token;
-        DEFINE_DMA_ATTRS(attrs);
+        unsigned long attrs;
         dma_addr_t dma_handle;
         int r;
 
@@ -1386,15 +1386,15 @@ static int omapfb_alloc_fbmem(struct fb_info *fbi, unsigned long size,
 
         size = PAGE_ALIGN(size);
 
-        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
+        attrs = DMA_ATTR_WRITE_COMBINE;
 
         if (ofbi->rotation_type == OMAP_DSS_ROT_VRFB)
-                dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &attrs);
+                attrs |= DMA_ATTR_NO_KERNEL_MAPPING;
 
         DBG("allocating %lu bytes for fb %d\n", size, ofbi->id);
 
         token = dma_alloc_attrs(fbdev->dev, size, &dma_handle,
-                        GFP_KERNEL, &attrs);
+                        GFP_KERNEL, attrs);
 
         if (token == NULL) {
                 dev_err(fbdev->dev, "failed to allocate framebuffer\n");
@@ -1408,7 +1408,7 @@ static int omapfb_alloc_fbmem(struct fb_info *fbi, unsigned long size,
                 r = omap_vrfb_request_ctx(&rg->vrfb);
                 if (r) {
                         dma_free_attrs(fbdev->dev, size, token, dma_handle,
-                                        &attrs);
+                                        attrs);
                         dev_err(fbdev->dev, "vrfb create ctx failed\n");
                         return r;
                 }
diff --git a/drivers/video/fbdev/omap2/omapfb/omapfb.h b/drivers/video/fbdev/omap2/omapfb/omapfb.h
index bcb9ff4a607d..555487d6dbea 100644
--- a/drivers/video/fbdev/omap2/omapfb/omapfb.h
+++ b/drivers/video/fbdev/omap2/omapfb/omapfb.h
@@ -28,7 +28,6 @@
 #endif
 
 #include <linux/rwsem.h>
-#include <linux/dma-attrs.h>
 #include <linux/dma-mapping.h>
 
 #include <video/omapfb_dss.h>
@@ -51,7 +50,7 @@ extern bool omapfb_debug;
 
 struct omapfb2_mem_region {
         int             id;
-        struct dma_attrs attrs;
+        unsigned long   attrs;
         void            *token;
         dma_addr_t      dma_handle;
         u32             paddr;
diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c
index 7399782c0998..87e6035c9e81 100644
--- a/drivers/xen/swiotlb-xen.c
+++ b/drivers/xen/swiotlb-xen.c
@@ -294,7 +294,7 @@ error:
 void *
 xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                            dma_addr_t *dma_handle, gfp_t flags,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         void *ret;
         int order = get_order(size);
@@ -346,7 +346,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_alloc_coherent);
 
 void
 xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
-                          dma_addr_t dev_addr, struct dma_attrs *attrs)
+                          dma_addr_t dev_addr, unsigned long attrs)
 {
         int order = get_order(size);
         phys_addr_t phys;
@@ -378,7 +378,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent);
 dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,
                                 unsigned long offset, size_t size,
                                 enum dma_data_direction dir,
-                                struct dma_attrs *attrs)
+                                unsigned long attrs)
 {
         phys_addr_t map, phys = page_to_phys(page) + offset;
         dma_addr_t dev_addr = xen_phys_to_bus(phys);
@@ -434,7 +434,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_map_page);
  */
 static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr,
                              size_t size, enum dma_data_direction dir,
-                                 struct dma_attrs *attrs)
+                             unsigned long attrs)
 {
         phys_addr_t paddr = xen_bus_to_phys(dev_addr);
 
@@ -462,7 +462,7 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr,
 
 void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
                             size_t size, enum dma_data_direction dir,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         xen_unmap_single(hwdev, dev_addr, size, dir, attrs);
 }
@@ -538,7 +538,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_sync_single_for_device);
 int
 xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
                          int nelems, enum dma_data_direction dir,
-                         struct dma_attrs *attrs)
+                         unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -599,7 +599,7 @@ EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg_attrs);
 void
 xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
                            int nelems, enum dma_data_direction dir,
-                           struct dma_attrs *attrs)
+                           unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
diff --git a/fs/block_dev.c b/fs/block_dev.c
index ada42cf42d06..2033a3f91d58 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -1275,11 +1275,7 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
                 bdev->bd_disk = disk;
                 bdev->bd_queue = disk->queue;
                 bdev->bd_contains = bdev;
-                if (IS_ENABLED(CONFIG_BLK_DEV_DAX) &&
-                    blk_queue_dax(disk->queue))
-                        bdev->bd_inode->i_flags = S_DAX;
-                else
-                        bdev->bd_inode->i_flags = 0;
+                bdev->bd_inode->i_flags = 0;
 
                 if (!partno) {
                         ret = -ENXIO;
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 27bfc0b631a9..598bc999f4c2 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -266,13 +266,12 @@ static inline int bitmap_equal(const unsigned long *src1,
                         const unsigned long *src2, unsigned int nbits)
 {
         if (small_const_nbits(nbits))
-                return ! ((*src1 ^ *src2) & BITMAP_LAST_WORD_MASK(nbits));
+                return !((*src1 ^ *src2) & BITMAP_LAST_WORD_MASK(nbits));
 #ifdef CONFIG_S390
-        else if (__builtin_constant_p(nbits) && (nbits % BITS_PER_LONG) == 0)
+        if (__builtin_constant_p(nbits) && (nbits % BITS_PER_LONG) == 0)
                 return !memcmp(src1, src2, nbits / 8);
 #endif
-        else
-                return __bitmap_equal(src1, src2, nbits);
+        return __bitmap_equal(src1, src2, nbits);
 }
 
 static inline int bitmap_intersects(const unsigned long *src1,
diff --git a/include/linux/dma-attrs.h b/include/linux/dma-attrs.h
deleted file mode 100644
index 5246239a4953..000000000000
--- a/include/linux/dma-attrs.h
+++ /dev/null
@@ -1,71 +0,0 @@
-#ifndef _DMA_ATTR_H
-#define _DMA_ATTR_H
-
-#include <linux/bitmap.h>
-#include <linux/bitops.h>
-#include <linux/bug.h>
-
-/**
- * an enum dma_attr represents an attribute associated with a DMA
- * mapping. The semantics of each attribute should be defined in
- * Documentation/DMA-attributes.txt.
- */
-enum dma_attr {
-        DMA_ATTR_WRITE_BARRIER,
-        DMA_ATTR_WEAK_ORDERING,
-        DMA_ATTR_WRITE_COMBINE,
-        DMA_ATTR_NON_CONSISTENT,
-        DMA_ATTR_NO_KERNEL_MAPPING,
-        DMA_ATTR_SKIP_CPU_SYNC,
-        DMA_ATTR_FORCE_CONTIGUOUS,
-        DMA_ATTR_ALLOC_SINGLE_PAGES,
-        DMA_ATTR_MAX,
-};
-
-#define __DMA_ATTRS_LONGS BITS_TO_LONGS(DMA_ATTR_MAX)
-
-/**
- * struct dma_attrs - an opaque container for DMA attributes
- * @flags - bitmask representing a collection of enum dma_attr
- */
-struct dma_attrs {
-        unsigned long flags[__DMA_ATTRS_LONGS];
-};
-
-#define DEFINE_DMA_ATTRS(x)                                     \
-        struct dma_attrs x = {                                  \
-                .flags = { [0 ... __DMA_ATTRS_LONGS-1] = 0 },   \
-        }
-
-static inline void init_dma_attrs(struct dma_attrs *attrs)
-{
-        bitmap_zero(attrs->flags, __DMA_ATTRS_LONGS);
-}
-
-/**
- * dma_set_attr - set a specific attribute
- * @attr: attribute to set
- * @attrs: struct dma_attrs (may be NULL)
- */
-static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs)
-{
-        if (attrs == NULL)
-                return;
-        BUG_ON(attr >= DMA_ATTR_MAX);
-        __set_bit(attr, attrs->flags);
-}
-
-/**
- * dma_get_attr - check for a specific attribute
- * @attr: attribute to set
- * @attrs: struct dma_attrs (may be NULL)
- */
-static inline int dma_get_attr(enum dma_attr attr, struct dma_attrs *attrs)
-{
-        if (attrs == NULL)
-                return 0;
-        BUG_ON(attr >= DMA_ATTR_MAX);
-        return test_bit(attr, attrs->flags);
-}
-
-#endif /* _DMA_ATTR_H */
diff --git a/include/linux/dma-iommu.h b/include/linux/dma-iommu.h
index 8443bbb5c071..81c5c8d167ad 100644
--- a/include/linux/dma-iommu.h
+++ b/include/linux/dma-iommu.h
@@ -39,7 +39,7 @@ int dma_direction_to_prot(enum dma_data_direction dir, bool coherent);
  * the arch code to take care of attributes and cache maintenance
  */
 struct page **iommu_dma_alloc(struct device *dev, size_t size, gfp_t gfp,
-                struct dma_attrs *attrs, int prot, dma_addr_t *handle,
+                unsigned long attrs, int prot, dma_addr_t *handle,
                 void (*flush_page)(struct device *, const void *, phys_addr_t));
 void iommu_dma_free(struct device *dev, struct page **pages, size_t size,
                 dma_addr_t *handle);
@@ -56,9 +56,9 @@ int iommu_dma_map_sg(struct device *dev, struct scatterlist *sg,
  * directly as DMA mapping callbacks for simplicity
  */
 void iommu_dma_unmap_page(struct device *dev, dma_addr_t handle, size_t size,
-                enum dma_data_direction dir, struct dma_attrs *attrs);
+                enum dma_data_direction dir, unsigned long attrs);
 void iommu_dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nents,
-                enum dma_data_direction dir, struct dma_attrs *attrs);
+                enum dma_data_direction dir, unsigned long attrs);
 int iommu_dma_supported(struct device *dev, u64 mask);
 int iommu_dma_mapping_error(struct device *dev, dma_addr_t dma_addr);
 
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 71c1b215ef66..66533e18276c 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -5,13 +5,58 @@
 #include <linux/string.h>
 #include <linux/device.h>
 #include <linux/err.h>
-#include <linux/dma-attrs.h>
 #include <linux/dma-debug.h>
 #include <linux/dma-direction.h>
 #include <linux/scatterlist.h>
 #include <linux/kmemcheck.h>
 #include <linux/bug.h>
 
+/**
+ * List of possible attributes associated with a DMA mapping. The semantics
+ * of each attribute should be defined in Documentation/DMA-attributes.txt.
+ *
+ * DMA_ATTR_WRITE_BARRIER: DMA to a memory region with this attribute
+ * forces all pending DMA writes to complete.
+ */
+#define DMA_ATTR_WRITE_BARRIER          (1UL << 0)
+/*
+ * DMA_ATTR_WEAK_ORDERING: Specifies that reads and writes to the mapping
+ * may be weakly ordered, that is that reads and writes may pass each other.
+ */
+#define DMA_ATTR_WEAK_ORDERING          (1UL << 1)
+/*
+ * DMA_ATTR_WRITE_COMBINE: Specifies that writes to the mapping may be
+ * buffered to improve performance.
+ */
+#define DMA_ATTR_WRITE_COMBINE          (1UL << 2)
+/*
+ * DMA_ATTR_NON_CONSISTENT: Lets the platform to choose to return either
+ * consistent or non-consistent memory as it sees fit.
+ */
+#define DMA_ATTR_NON_CONSISTENT         (1UL << 3)
+/*
+ * DMA_ATTR_NO_KERNEL_MAPPING: Lets the platform to avoid creating a kernel
+ * virtual mapping for the allocated buffer.
+ */
+#define DMA_ATTR_NO_KERNEL_MAPPING      (1UL << 4)
+/*
+ * DMA_ATTR_SKIP_CPU_SYNC: Allows platform code to skip synchronization of
+ * the CPU cache for the given buffer assuming that it has been already
+ * transferred to 'device' domain.
+ */
+#define DMA_ATTR_SKIP_CPU_SYNC          (1UL << 5)
+/*
+ * DMA_ATTR_FORCE_CONTIGUOUS: Forces contiguous allocation of the buffer
+ * in physical memory.
+ */
+#define DMA_ATTR_FORCE_CONTIGUOUS       (1UL << 6)
+/*
+ * DMA_ATTR_ALLOC_SINGLE_PAGES: This is a hint to the DMA-mapping subsystem
+ * that it's probably not worth the time to try to allocate memory to in a way
+ * that gives better TLB efficiency.
+ */
+#define DMA_ATTR_ALLOC_SINGLE_PAGES     (1UL << 7)
+
 /*
  * A dma_addr_t can hold any valid DMA or bus address for the platform.
  * It can be given to a device to use as a DMA source or target.  A CPU cannot
@@ -21,34 +66,35 @@
 struct dma_map_ops {
         void* (*alloc)(struct device *dev, size_t size,
                                 dma_addr_t *dma_handle, gfp_t gfp,
-                                struct dma_attrs *attrs);
+                                unsigned long attrs);
         void (*free)(struct device *dev, size_t size,
                               void *vaddr, dma_addr_t dma_handle,
-                              struct dma_attrs *attrs);
+                              unsigned long attrs);
         int (*mmap)(struct device *, struct vm_area_struct *,
-                          void *, dma_addr_t, size_t, struct dma_attrs *attrs);
+                          void *, dma_addr_t, size_t,
+                          unsigned long attrs);
 
         int (*get_sgtable)(struct device *dev, struct sg_table *sgt, void *,
-                           dma_addr_t, size_t, struct dma_attrs *attrs);
+                           dma_addr_t, size_t, unsigned long attrs);
 
         dma_addr_t (*map_page)(struct device *dev, struct page *page,
                                unsigned long offset, size_t size,
                                enum dma_data_direction dir,
-                               struct dma_attrs *attrs);
+                               unsigned long attrs);
         void (*unmap_page)(struct device *dev, dma_addr_t dma_handle,
                            size_t size, enum dma_data_direction dir,
-                           struct dma_attrs *attrs);
+                           unsigned long attrs);
         /*
          * map_sg returns 0 on error and a value > 0 on success.
          * It should never return a value < 0.
          */
         int (*map_sg)(struct device *dev, struct scatterlist *sg,
                       int nents, enum dma_data_direction dir,
-                      struct dma_attrs *attrs);
+                      unsigned long attrs);
         void (*unmap_sg)(struct device *dev,
                          struct scatterlist *sg, int nents,
                          enum dma_data_direction dir,
-                         struct dma_attrs *attrs);
+                         unsigned long attrs);
         void (*sync_single_for_cpu)(struct device *dev,
                                     dma_addr_t dma_handle, size_t size,
                                     enum dma_data_direction dir);
@@ -123,7 +169,7 @@ static inline struct dma_map_ops *get_dma_ops(struct device *dev)
 static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
                                               size_t size,
                                               enum dma_data_direction dir,
-                                              struct dma_attrs *attrs)
+                                              unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
         dma_addr_t addr;
@@ -142,7 +188,7 @@ static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
 static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
                                           size_t size,
                                           enum dma_data_direction dir,
-                                          struct dma_attrs *attrs)
+                                          unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
 
@@ -158,7 +204,7 @@ static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
  */
 static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
                                    int nents, enum dma_data_direction dir,
-                                   struct dma_attrs *attrs)
+                                   unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
         int i, ents;
@@ -176,7 +222,7 @@ static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
 
 static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
                                       int nents, enum dma_data_direction dir,
-                                      struct dma_attrs *attrs)
+                                      unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
 
@@ -195,7 +241,7 @@ static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
 
         kmemcheck_mark_initialized(page_address(page) + offset, size);
         BUG_ON(!valid_dma_direction(dir));
-        addr = ops->map_page(dev, page, offset, size, dir, NULL);
+        addr = ops->map_page(dev, page, offset, size, dir, 0);
         debug_dma_map_page(dev, page, offset, size, dir, addr, false);
 
         return addr;
@@ -208,7 +254,7 @@ static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
 
         BUG_ON(!valid_dma_direction(dir));
         if (ops->unmap_page)
-                ops->unmap_page(dev, addr, size, dir, NULL);
+                ops->unmap_page(dev, addr, size, dir, 0);
         debug_dma_unmap_page(dev, addr, size, dir, false);
 }
 
@@ -289,10 +335,10 @@ dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
 
 }
 
-#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
-#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL)
-#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL)
-#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL)
+#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, 0)
+#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, 0)
+#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, 0)
+#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, 0)
 
 extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
                            void *cpu_addr, dma_addr_t dma_addr, size_t size);
@@ -321,7 +367,7 @@ void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags);
  */
 static inline int
 dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr,
-               dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
+               dma_addr_t dma_addr, size_t size, unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
         BUG_ON(!ops);
@@ -330,7 +376,7 @@ dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr,
         return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size);
 }
 
-#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, NULL)
+#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0)
 
 int
 dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
@@ -338,7 +384,8 @@ dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
 
 static inline int
 dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
-                      dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
+                      dma_addr_t dma_addr, size_t size,
+                      unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
         BUG_ON(!ops);
@@ -348,7 +395,7 @@ dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
         return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size);
 }
 
-#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, NULL)
+#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0)
 
 #ifndef arch_dma_alloc_attrs
 #define arch_dma_alloc_attrs(dev, flag) (true)
@@ -356,7 +403,7 @@ dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
 
 static inline void *dma_alloc_attrs(struct device *dev, size_t size,
                                        dma_addr_t *dma_handle, gfp_t flag,
-                                       struct dma_attrs *attrs)
+                                       unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
         void *cpu_addr;
@@ -378,7 +425,7 @@ static inline void *dma_alloc_attrs(struct device *dev, size_t size,
 
 static inline void dma_free_attrs(struct device *dev, size_t size,
                                      void *cpu_addr, dma_addr_t dma_handle,
-                                     struct dma_attrs *attrs)
+                                     unsigned long attrs)
 {
         struct dma_map_ops *ops = get_dma_ops(dev);
 
@@ -398,31 +445,27 @@ static inline void dma_free_attrs(struct device *dev, size_t size,
 static inline void *dma_alloc_coherent(struct device *dev, size_t size,
                 dma_addr_t *dma_handle, gfp_t flag)
 {
-        return dma_alloc_attrs(dev, size, dma_handle, flag, NULL);
+        return dma_alloc_attrs(dev, size, dma_handle, flag, 0);
 }
 
 static inline void dma_free_coherent(struct device *dev, size_t size,
                 void *cpu_addr, dma_addr_t dma_handle)
 {
-        return dma_free_attrs(dev, size, cpu_addr, dma_handle, NULL);
+        return dma_free_attrs(dev, size, cpu_addr, dma_handle, 0);
 }
 
 static inline void *dma_alloc_noncoherent(struct device *dev, size_t size,
                 dma_addr_t *dma_handle, gfp_t gfp)
 {
-        DEFINE_DMA_ATTRS(attrs);
-
-        dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs);
-        return dma_alloc_attrs(dev, size, dma_handle, gfp, &attrs);
+        return dma_alloc_attrs(dev, size, dma_handle, gfp,
+                               DMA_ATTR_NON_CONSISTENT);
 }
 
 static inline void dma_free_noncoherent(struct device *dev, size_t size,
                 void *cpu_addr, dma_addr_t dma_handle)
 {
-        DEFINE_DMA_ATTRS(attrs);
-
-        dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs);
-        dma_free_attrs(dev, size, cpu_addr, dma_handle, &attrs);
+        dma_free_attrs(dev, size, cpu_addr, dma_handle,
+                       DMA_ATTR_NON_CONSISTENT);
 }
 
 static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
@@ -646,9 +689,8 @@ static inline void dmam_release_declared_memory(struct device *dev)
 static inline void *dma_alloc_wc(struct device *dev, size_t size,
                                  dma_addr_t *dma_addr, gfp_t gfp)
 {
-        DEFINE_DMA_ATTRS(attrs);
-        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
-        return dma_alloc_attrs(dev, size, dma_addr, gfp, &attrs);
+        return dma_alloc_attrs(dev, size, dma_addr, gfp,
+                               DMA_ATTR_WRITE_COMBINE);
 }
 #ifndef dma_alloc_writecombine
 #define dma_alloc_writecombine dma_alloc_wc
@@ -657,9 +699,8 @@ static inline void *dma_alloc_wc(struct device *dev, size_t size,
 static inline void dma_free_wc(struct device *dev, size_t size,
                                void *cpu_addr, dma_addr_t dma_addr)
 {
-        DEFINE_DMA_ATTRS(attrs);
-        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
-        return dma_free_attrs(dev, size, cpu_addr, dma_addr, &attrs);
+        return dma_free_attrs(dev, size, cpu_addr, dma_addr,
+                              DMA_ATTR_WRITE_COMBINE);
 }
 #ifndef dma_free_writecombine
 #define dma_free_writecombine dma_free_wc
@@ -670,9 +711,8 @@ static inline int dma_mmap_wc(struct device *dev,
                               void *cpu_addr, dma_addr_t dma_addr,
                               size_t size)
 {
-        DEFINE_DMA_ATTRS(attrs);
-        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
-        return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, &attrs);
+        return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size,
+                              DMA_ATTR_WRITE_COMBINE);
 }
 #ifndef dma_mmap_writecombine
 #define dma_mmap_writecombine dma_mmap_wc
diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
index 4f1bbc68cd1b..546d68057e3b 100644
--- a/include/linux/dynamic_debug.h
+++ b/include/linux/dynamic_debug.h
@@ -1,6 +1,10 @@
 #ifndef _DYNAMIC_DEBUG_H
 #define _DYNAMIC_DEBUG_H
 
+#if defined(CC_HAVE_ASM_GOTO) && defined(CONFIG_JUMP_LABEL)
+#include <linux/jump_label.h>
+#endif
+
 /*
  * An instance of this structure is created in a special
  * ELF section at every dynamic debug callsite.  At runtime,
@@ -33,6 +37,12 @@ struct _ddebug {
 #define _DPRINTK_FLAGS_DEFAULT 0
 #endif
         unsigned int flags:8;
+#ifdef HAVE_JUMP_LABEL
+        union {
+                struct static_key_true dd_key_true;
+                struct static_key_false dd_key_false;
+        } key;
+#endif
 } __attribute__((aligned(8)));
 
 
@@ -60,7 +70,7 @@ void __dynamic_netdev_dbg(struct _ddebug *descriptor,
                           const struct net_device *dev,
                           const char *fmt, ...);
 
-#define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt)                \
+#define DEFINE_DYNAMIC_DEBUG_METADATA_KEY(name, fmt, key, init) \
         static struct _ddebug  __aligned(8)                     \
         __attribute__((section("__verbose"))) name = {          \
                 .modname = KBUILD_MODNAME,                      \
@@ -68,13 +78,51 @@ void __dynamic_netdev_dbg(struct _ddebug *descriptor,
                 .filename = __FILE__,                           \
                 .format = (fmt),                                \
                 .lineno = __LINE__,                             \
-                .flags =  _DPRINTK_FLAGS_DEFAULT,               \
+                .flags = _DPRINTK_FLAGS_DEFAULT,                \
+                dd_key_init(key, init)                          \
         }
 
+#ifdef HAVE_JUMP_LABEL
+
+#define dd_key_init(key, init) key = (init)
+
+#ifdef DEBUG
+#define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt) \
+        DEFINE_DYNAMIC_DEBUG_METADATA_KEY(name, fmt, .key.dd_key_true, \
+                                          (STATIC_KEY_TRUE_INIT))
+
+#define DYNAMIC_DEBUG_BRANCH(descriptor) \
+        static_branch_likely(&descriptor.key.dd_key_true)
+#else
+#define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt) \
+        DEFINE_DYNAMIC_DEBUG_METADATA_KEY(name, fmt, .key.dd_key_false, \
+                                          (STATIC_KEY_FALSE_INIT))
+
+#define DYNAMIC_DEBUG_BRANCH(descriptor) \
+        static_branch_unlikely(&descriptor.key.dd_key_false)
+#endif
+
+#else
+
+#define dd_key_init(key, init)
+
+#define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt) \
+        DEFINE_DYNAMIC_DEBUG_METADATA_KEY(name, fmt, 0, 0)
+
+#ifdef DEBUG
+#define DYNAMIC_DEBUG_BRANCH(descriptor) \
+        likely(descriptor.flags & _DPRINTK_FLAGS_PRINT)
+#else
+#define DYNAMIC_DEBUG_BRANCH(descriptor) \
+        unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT)
+#endif
+
+#endif
+
 #define dynamic_pr_debug(fmt, ...)                              \
 do {                                                            \
         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         \
-        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  \
+        if (DYNAMIC_DEBUG_BRANCH(descriptor))                   \
                 __dynamic_pr_debug(&descriptor, pr_fmt(fmt),    \
                                    ##__VA_ARGS__);              \
 } while (0)
@@ -82,7 +130,7 @@ do {								\
 #define dynamic_dev_dbg(dev, fmt, ...)                          \
 do {                                                            \
         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         \
-        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  \
+        if (DYNAMIC_DEBUG_BRANCH(descriptor))                   \
                 __dynamic_dev_dbg(&descriptor, dev, fmt,        \
                                   ##__VA_ARGS__);               \
 } while (0)
@@ -90,7 +138,7 @@ do {								\
 #define dynamic_netdev_dbg(dev, fmt, ...)                       \
 do {                                                            \
         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);         \
-        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  \
+        if (DYNAMIC_DEBUG_BRANCH(descriptor))                   \
                 __dynamic_netdev_dbg(&descriptor, dev, fmt,     \
                                      ##__VA_ARGS__);            \
 } while (0)
@@ -100,7 +148,7 @@ do {								\
 do {                                                            \
         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor,               \
                 __builtin_constant_p(prefix_str) ? prefix_str : "hexdump");\
-        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  \
+        if (DYNAMIC_DEBUG_BRANCH(descriptor))                   \
                 print_hex_dump(KERN_DEBUG, prefix_str,          \
                                prefix_type, rowsize, groupsize, \
                                buf, len, ascii);                \
diff --git a/include/linux/fence.h b/include/linux/fence.h
index 523ea3fbbddd..8cc719a63728 100644
--- a/include/linux/fence.h
+++ b/include/linux/fence.h
@@ -358,7 +358,7 @@ u64 fence_context_alloc(unsigned num);
 #define FENCE_TRACE(f, fmt, args...) \
         do {                                                            \
                 struct fence *__ff = (f);                               \
-                if (config_enabled(CONFIG_FENCE_TRACE))                 \
+                if (IS_ENABLED(CONFIG_FENCE_TRACE))                     \
                         pr_info("f %llu#%u: " fmt,                      \
                                 __ff->context, __ff->seqno, ##args);    \
         } while (0)
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index 68904469fba1..661af564fae8 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -76,7 +76,6 @@
 
 #include <linux/types.h>
 #include <linux/compiler.h>
-#include <linux/bug.h>
 
 extern bool static_key_initialized;
 
@@ -115,20 +114,8 @@ enum jump_label_type {
 
 struct module;
 
-#include <linux/atomic.h>
-
 #ifdef HAVE_JUMP_LABEL
 
-static inline int static_key_count(struct static_key *key)
-{
-        /*
-         * -1 means the first static_key_slow_inc() is in progress.
-         *  static_key_enabled() must return true, so return 1 here.
-         */
-        int n = atomic_read(&key->enabled);
-        return n >= 0 ? n : 1;
-}
-
 #define JUMP_TYPE_FALSE 0UL
 #define JUMP_TYPE_TRUE  1UL
 #define JUMP_TYPE_MASK  1UL
@@ -157,16 +144,29 @@ extern int jump_label_text_reserved(void *start, void *end);
 extern void static_key_slow_inc(struct static_key *key);
 extern void static_key_slow_dec(struct static_key *key);
 extern void jump_label_apply_nops(struct module *mod);
+extern int static_key_count(struct static_key *key);
+extern void static_key_enable(struct static_key *key);
+extern void static_key_disable(struct static_key *key);
 
+/*
+ * We should be using ATOMIC_INIT() for initializing .enabled, but
+ * the inclusion of atomic.h is problematic for inclusion of jump_label.h
+ * in 'low-level' headers. Thus, we are initializing .enabled with a
+ * raw value, but have added a BUILD_BUG_ON() to catch any issues in
+ * jump_label_init() see: kernel/jump_label.c.
+ */
 #define STATIC_KEY_INIT_TRUE                                    \
-        { .enabled = ATOMIC_INIT(1),                            \
+        { .enabled = { 1 },                                     \
           .entries = (void *)JUMP_TYPE_TRUE }
 #define STATIC_KEY_INIT_FALSE                                   \
-        { .enabled = ATOMIC_INIT(0),                            \
+        { .enabled = { 0 },                                     \
           .entries = (void *)JUMP_TYPE_FALSE }
 
 #else  /* !HAVE_JUMP_LABEL */
 
+#include <linux/atomic.h>
+#include <linux/bug.h>
+
 static inline int static_key_count(struct static_key *key)
 {
         return atomic_read(&key->enabled);
@@ -216,14 +216,6 @@ static inline int jump_label_apply_nops(struct module *mod)
         return 0;
 }
 
-#define STATIC_KEY_INIT_TRUE    { .enabled = ATOMIC_INIT(1) }
-#define STATIC_KEY_INIT_FALSE   { .enabled = ATOMIC_INIT(0) }
-
-#endif  /* HAVE_JUMP_LABEL */
-
-#define STATIC_KEY_INIT STATIC_KEY_INIT_FALSE
-#define jump_label_enabled static_key_enabled
-
 static inline void static_key_enable(struct static_key *key)
 {
         int count = static_key_count(key);
@@ -244,6 +236,14 @@ static inline void static_key_disable(struct static_key *key)
                 static_key_slow_dec(key);
 }
 
+#define STATIC_KEY_INIT_TRUE    { .enabled = ATOMIC_INIT(1) }
+#define STATIC_KEY_INIT_FALSE   { .enabled = ATOMIC_INIT(0) }
+
+#endif  /* HAVE_JUMP_LABEL */
+
+#define STATIC_KEY_INIT STATIC_KEY_INIT_FALSE
+#define jump_label_enabled static_key_enabled
+
 /* -------------------------------------------------------------------------- */
 
 /*
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index 017fced60242..5f81f8a187f2 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -6,7 +6,6 @@
 #include <linux/types.h>
 
 struct device;
-struct dma_attrs;
 struct page;
 struct scatterlist;
 
@@ -68,10 +67,10 @@ swiotlb_free_coherent(struct device *hwdev, size_t size,
 extern dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
                                    unsigned long offset, size_t size,
                                    enum dma_data_direction dir,
-                                   struct dma_attrs *attrs);
+                                   unsigned long attrs);
 extern void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
                                size_t size, enum dma_data_direction dir,
-                               struct dma_attrs *attrs);
+                               unsigned long attrs);
 
 extern int
 swiotlb_map_sg(struct device *hwdev, struct scatterlist *sg, int nents,
@@ -83,12 +82,13 @@ swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sg, int nents,
 
 extern int
 swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems,
-                     enum dma_data_direction dir, struct dma_attrs *attrs);
+                     enum dma_data_direction dir,
+                     unsigned long attrs);
 
 extern void
 swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
                        int nelems, enum dma_data_direction dir,
-                       struct dma_attrs *attrs);
+                       unsigned long attrs);
 
 extern void
 swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
diff --git a/include/linux/ww_mutex.h b/include/linux/ww_mutex.h
index 760399a470bd..2bb5deb0012e 100644
--- a/include/linux/ww_mutex.h
+++ b/include/linux/ww_mutex.h
@@ -173,14 +173,14 @@ static inline void ww_acquire_fini(struct ww_acquire_ctx *ctx)
         mutex_release(&ctx->dep_map, 0, _THIS_IP_);
 
         DEBUG_LOCKS_WARN_ON(ctx->acquired);
-        if (!config_enabled(CONFIG_PROVE_LOCKING))
+        if (!IS_ENABLED(CONFIG_PROVE_LOCKING))
                 /*
                  * lockdep will normally handle this,
                  * but fail without anyway
                  */
                 ctx->done_acquire = 1;
 
-        if (!config_enabled(CONFIG_DEBUG_LOCK_ALLOC))
+        if (!IS_ENABLED(CONFIG_DEBUG_LOCK_ALLOC))
                 /* ensure ww_acquire_fini will still fail if called twice */
                 ctx->acquired = ~0U;
 #endif
diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h
index 946340ce7701..a4a9a55a0c42 100644
--- a/include/media/videobuf2-core.h
+++ b/include/media/videobuf2-core.h
@@ -98,7 +98,7 @@ struct vb2_threadio_data;
  *    #) Required ops for DMABUF types: attach_dmabuf, detach_dmabuf, map_dmabuf, unmap_dmabuf.
  */
 struct vb2_mem_ops {
-        void            *(*alloc)(struct device *dev, const struct dma_attrs *attrs,
+        void            *(*alloc)(struct device *dev, unsigned long attrs,
                                   unsigned long size, enum dma_data_direction dma_dir,
                                   gfp_t gfp_flags);
         void            (*put)(void *buf_priv);
@@ -408,7 +408,7 @@ struct vb2_buf_ops {
  * @io_modes:   supported io methods (see vb2_io_modes enum)
  * @dev:        device to use for the default allocation context if the driver
  *              doesn't fill in the @alloc_devs array.
- * @dma_attrs:  DMA attributes to use for the DMA. May be NULL.
+ * @dma_attrs:  DMA attributes to use for the DMA.
  * @fileio_read_once:           report EOF after reading the first buffer
  * @fileio_write_immediately:   queue buffer after each write() call
  * @allow_zero_bytesused:       allow bytesused == 0 to be passed to the driver
@@ -476,7 +476,7 @@ struct vb2_queue {
         unsigned int                    type;
         unsigned int                    io_modes;
         struct device                   *dev;
-        const struct dma_attrs          *dma_attrs;
+        unsigned long                   dma_attrs;
         unsigned                        fileio_read_once:1;
         unsigned                        fileio_write_immediately:1;
         unsigned                        allow_zero_bytesused:1;
diff --git a/include/media/videobuf2-dma-contig.h b/include/media/videobuf2-dma-contig.h
index df2aabee3401..5604818d137e 100644
--- a/include/media/videobuf2-dma-contig.h
+++ b/include/media/videobuf2-dma-contig.h
@@ -16,8 +16,6 @@
 #include <media/videobuf2-v4l2.h>
 #include <linux/dma-mapping.h>
 
-struct dma_attrs;
-
 static inline dma_addr_t
 vb2_dma_contig_plane_dma_addr(struct vb2_buffer *vb, unsigned int plane_no)
 {
diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h
index 7e440d41487a..a8137dcf5a00 100644
--- a/include/rdma/ib_verbs.h
+++ b/include/rdma/ib_verbs.h
@@ -2819,19 +2819,19 @@ static inline void ib_dma_unmap_single(struct ib_device *dev,
 static inline u64 ib_dma_map_single_attrs(struct ib_device *dev,
                                           void *cpu_addr, size_t size,
                                           enum dma_data_direction direction,
-                                          struct dma_attrs *attrs)
+                                          unsigned long dma_attrs)
 {
         return dma_map_single_attrs(dev->dma_device, cpu_addr, size,
-                                    direction, attrs);
+                                    direction, dma_attrs);
 }
 
 static inline void ib_dma_unmap_single_attrs(struct ib_device *dev,
                                              u64 addr, size_t size,
                                              enum dma_data_direction direction,
-                                             struct dma_attrs *attrs)
+                                             unsigned long dma_attrs)
 {
         return dma_unmap_single_attrs(dev->dma_device, addr, size,
-                                      direction, attrs);
+                                      direction, dma_attrs);
 }
 
 /**
@@ -2906,17 +2906,18 @@ static inline void ib_dma_unmap_sg(struct ib_device *dev,
 static inline int ib_dma_map_sg_attrs(struct ib_device *dev,
                                       struct scatterlist *sg, int nents,
                                       enum dma_data_direction direction,
-                                      struct dma_attrs *attrs)
+                                      unsigned long dma_attrs)
 {
-        return dma_map_sg_attrs(dev->dma_device, sg, nents, direction, attrs);
+        return dma_map_sg_attrs(dev->dma_device, sg, nents, direction,
+                                dma_attrs);
 }
 
 static inline void ib_dma_unmap_sg_attrs(struct ib_device *dev,
                                          struct scatterlist *sg, int nents,
                                          enum dma_data_direction direction,
-                                         struct dma_attrs *attrs)
+                                         unsigned long dma_attrs)
 {
-        dma_unmap_sg_attrs(dev->dma_device, sg, nents, direction, attrs);
+        dma_unmap_sg_attrs(dev->dma_device, sg, nents, direction, dma_attrs);
 }
 /**
  * ib_sg_dma_address - Return the DMA address from a scatter/gather entry
diff --git a/include/xen/swiotlb-xen.h b/include/xen/swiotlb-xen.h
index 8b2eb93ae8ba..7c35e279d1e3 100644
--- a/include/xen/swiotlb-xen.h
+++ b/include/xen/swiotlb-xen.h
@@ -9,30 +9,30 @@ extern int xen_swiotlb_init(int verbose, bool early);
 extern void
 *xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                             dma_addr_t *dma_handle, gfp_t flags,
-                            struct dma_attrs *attrs);
+                            unsigned long attrs);
 
 extern void
 xen_swiotlb_free_coherent(struct device *hwdev, size_t size,
                           void *vaddr, dma_addr_t dma_handle,
-                          struct dma_attrs *attrs);
+                          unsigned long attrs);
 
 extern dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,
                                        unsigned long offset, size_t size,
                                        enum dma_data_direction dir,
-                                       struct dma_attrs *attrs);
+                                       unsigned long attrs);
 
 extern void xen_swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
                                    size_t size, enum dma_data_direction dir,
-                                   struct dma_attrs *attrs);
+                                   unsigned long attrs);
 extern int
 xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
                          int nelems, enum dma_data_direction dir,
-                         struct dma_attrs *attrs);
+                         unsigned long attrs);
 
 extern void
 xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
                            int nelems, enum dma_data_direction dir,
-                           struct dma_attrs *attrs);
+                           unsigned long attrs);
 
 extern void
 xen_swiotlb_sync_single_for_cpu(struct device *hwdev, dma_addr_t dev_addr,
diff --git a/kernel/jump_label.c b/kernel/jump_label.c
index 0dbea887d625..f19aa02a8f48 100644
--- a/kernel/jump_label.c
+++ b/kernel/jump_label.c
@@ -14,6 +14,7 @@
 #include <linux/err.h>
 #include <linux/static_key.h>
 #include <linux/jump_label_ratelimit.h>
+#include <linux/bug.h>
 
 #ifdef HAVE_JUMP_LABEL
 
@@ -56,6 +57,49 @@ jump_label_sort_entries(struct jump_entry *start, struct jump_entry *stop)
 
 static void jump_label_update(struct static_key *key);
 
+/*
+ * There are similar definitions for the !HAVE_JUMP_LABEL case in jump_label.h.
+ * The use of 'atomic_read()' requires atomic.h and its problematic for some
+ * kernel headers such as kernel.h and others. Since static_key_count() is not
+ * used in the branch statements as it is for the !HAVE_JUMP_LABEL case its ok
+ * to have it be a function here. Similarly, for 'static_key_enable()' and
+ * 'static_key_disable()', which require bug.h. This should allow jump_label.h
+ * to be included from most/all places for HAVE_JUMP_LABEL.
+ */
+int static_key_count(struct static_key *key)
+{
+        /*
+         * -1 means the first static_key_slow_inc() is in progress.
+         *  static_key_enabled() must return true, so return 1 here.
+         */
+        int n = atomic_read(&key->enabled);
+
+        return n >= 0 ? n : 1;
+}
+EXPORT_SYMBOL_GPL(static_key_count);
+
+void static_key_enable(struct static_key *key)
+{
+        int count = static_key_count(key);
+
+        WARN_ON_ONCE(count < 0 || count > 1);
+
+        if (!count)
+                static_key_slow_inc(key);
+}
+EXPORT_SYMBOL_GPL(static_key_enable);
+
+void static_key_disable(struct static_key *key)
+{
+        int count = static_key_count(key);
+
+        WARN_ON_ONCE(count < 0 || count > 1);
+
+        if (count)
+                static_key_slow_dec(key);
+}
+EXPORT_SYMBOL_GPL(static_key_disable);
+
 void static_key_slow_inc(struct static_key *key)
 {
         int v, v1;
@@ -235,6 +279,15 @@ void __init jump_label_init(void)
         struct static_key *key = NULL;
         struct jump_entry *iter;
 
+        /*
+         * Since we are initializing the static_key.enabled field with
+         * with the 'raw' int values (to avoid pulling in atomic.h) in
+         * jump_label.h, let's make sure that is safe. There are only two
+         * cases to check since we initialize to 0 or 1.
+         */
+        BUILD_BUG_ON((int)ATOMIC_INIT(0) != 0);
+        BUILD_BUG_ON((int)ATOMIC_INIT(1) != 1);
+
         jump_label_lock();
         jump_label_sort_entries(iter_start, iter_stop);
 
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index d49bfa1e53e6..1d3b7665d0be 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -585,8 +585,8 @@ static int ptrace_setoptions(struct task_struct *child, unsigned long data)
                 return -EINVAL;
 
         if (unlikely(data & PTRACE_O_SUSPEND_SECCOMP)) {
-                if (!config_enabled(CONFIG_CHECKPOINT_RESTORE) ||
-                    !config_enabled(CONFIG_SECCOMP))
+                if (!IS_ENABLED(CONFIG_CHECKPOINT_RESTORE) ||
+                    !IS_ENABLED(CONFIG_SECCOMP))
                         return -EINVAL;
 
                 if (!capable(CAP_SYS_ADMIN))
diff --git a/kernel/seccomp.c b/kernel/seccomp.c
index 54d15eb2b701..ef6c6c3f9d8a 100644
--- a/kernel/seccomp.c
+++ b/kernel/seccomp.c
@@ -347,7 +347,7 @@ static struct seccomp_filter *seccomp_prepare_filter(struct sock_fprog *fprog)
 {
         struct seccomp_filter *sfilter;
         int ret;
-        const bool save_orig = config_enabled(CONFIG_CHECKPOINT_RESTORE);
+        const bool save_orig = IS_ENABLED(CONFIG_CHECKPOINT_RESTORE);
 
         if (fprog->len == 0 || fprog->len > BPF_MAXINSNS)
                 return ERR_PTR(-EINVAL);
@@ -542,7 +542,7 @@ void secure_computing_strict(int this_syscall)
 {
         int mode = current->seccomp.mode;
 
-        if (config_enabled(CONFIG_CHECKPOINT_RESTORE) &&
+        if (IS_ENABLED(CONFIG_CHECKPOINT_RESTORE) &&
             unlikely(current->ptrace & PT_SUSPEND_SECCOMP))
                 return;
 
@@ -655,7 +655,7 @@ int __secure_computing(const struct seccomp_data *sd)
         int mode = current->seccomp.mode;
         int this_syscall;
 
-        if (config_enabled(CONFIG_CHECKPOINT_RESTORE) &&
+        if (IS_ENABLED(CONFIG_CHECKPOINT_RESTORE) &&
             unlikely(current->ptrace & PT_SUSPEND_SECCOMP))
                 return 0;
 
diff --git a/lib/dma-noop.c b/lib/dma-noop.c
index 72145646857e..3d766e78fbe2 100644
--- a/lib/dma-noop.c
+++ b/lib/dma-noop.c
@@ -10,7 +10,7 @@
 
 static void *dma_noop_alloc(struct device *dev, size_t size,
                             dma_addr_t *dma_handle, gfp_t gfp,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         void *ret;
 
@@ -22,7 +22,7 @@ static void *dma_noop_alloc(struct device *dev, size_t size,
 
 static void dma_noop_free(struct device *dev, size_t size,
                           void *cpu_addr, dma_addr_t dma_addr,
-                          struct dma_attrs *attrs)
+                          unsigned long attrs)
 {
         free_pages((unsigned long)cpu_addr, get_order(size));
 }
@@ -30,13 +30,14 @@ static void dma_noop_free(struct device *dev, size_t size,
 static dma_addr_t dma_noop_map_page(struct device *dev, struct page *page,
                                       unsigned long offset, size_t size,
                                       enum dma_data_direction dir,
-                                      struct dma_attrs *attrs)
+                                      unsigned long attrs)
 {
         return page_to_phys(page) + offset;
 }
 
 static int dma_noop_map_sg(struct device *dev, struct scatterlist *sgl, int nents,
-                             enum dma_data_direction dir, struct dma_attrs *attrs)
+                             enum dma_data_direction dir,
+                             unsigned long attrs)
 {
         int i;
         struct scatterlist *sg;
diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
index fe42b6ec3f0c..da796e2dc4f5 100644
--- a/lib/dynamic_debug.c
+++ b/lib/dynamic_debug.c
@@ -188,6 +188,13 @@ static int ddebug_change(const struct ddebug_query *query,
                         newflags = (dp->flags & mask) | flags;
                         if (newflags == dp->flags)
                                 continue;
+#ifdef HAVE_JUMP_LABEL
+                        if (dp->flags & _DPRINTK_FLAGS_PRINT) {
+                                if (!(flags & _DPRINTK_FLAGS_PRINT))
+                                        static_branch_disable(&dp->key.dd_key_true);
+                        } else if (flags & _DPRINTK_FLAGS_PRINT)
+                                static_branch_enable(&dp->key.dd_key_true);
+#endif
                         dp->flags = newflags;
                         vpr_info("changed %s:%d [%s]%s =%s\n",
                                  trim_prefix(dp->filename), dp->lineno,
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index 76f29ecba8f4..22e13a0e19d7 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -738,7 +738,7 @@ swiotlb_full(struct device *dev, size_t size, enum dma_data_direction dir,
 dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
                             unsigned long offset, size_t size,
                             enum dma_data_direction dir,
-                            struct dma_attrs *attrs)
+                            unsigned long attrs)
 {
         phys_addr_t map, phys = page_to_phys(page) + offset;
         dma_addr_t dev_addr = phys_to_dma(dev, phys);
@@ -807,7 +807,7 @@ static void unmap_single(struct device *hwdev, dma_addr_t dev_addr,
 
 void swiotlb_unmap_page(struct device *hwdev, dma_addr_t dev_addr,
                         size_t size, enum dma_data_direction dir,
-                        struct dma_attrs *attrs)
+                        unsigned long attrs)
 {
         unmap_single(hwdev, dev_addr, size, dir);
 }
@@ -877,7 +877,7 @@ EXPORT_SYMBOL(swiotlb_sync_single_for_device);
  */
 int
 swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl, int nelems,
-                     enum dma_data_direction dir, struct dma_attrs *attrs)
+                     enum dma_data_direction dir, unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -914,7 +914,7 @@ int
 swiotlb_map_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,
                enum dma_data_direction dir)
 {
-        return swiotlb_map_sg_attrs(hwdev, sgl, nelems, dir, NULL);
+        return swiotlb_map_sg_attrs(hwdev, sgl, nelems, dir, 0);
 }
 EXPORT_SYMBOL(swiotlb_map_sg);
 
@@ -924,7 +924,8 @@ EXPORT_SYMBOL(swiotlb_map_sg);
  */
 void
 swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
-                       int nelems, enum dma_data_direction dir, struct dma_attrs *attrs)
+                       int nelems, enum dma_data_direction dir,
+                       unsigned long attrs)
 {
         struct scatterlist *sg;
         int i;
@@ -941,7 +942,7 @@ void
 swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,
                  enum dma_data_direction dir)
 {
-        return swiotlb_unmap_sg_attrs(hwdev, sgl, nelems, dir, NULL);
+        return swiotlb_unmap_sg_attrs(hwdev, sgl, nelems, dir, 0);
 }
 EXPORT_SYMBOL(swiotlb_unmap_sg);
 
diff --git a/net/wireless/chan.c b/net/wireless/chan.c
index da49c0b1fd32..b0e11b6dc994 100644
--- a/net/wireless/chan.c
+++ b/net/wireless/chan.c
@@ -715,7 +715,7 @@ static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
 
         ASSERT_RTNL();
 
-        if (!config_enabled(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
+        if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
             !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
                 return false;
 
diff --git a/samples/kprobes/jprobe_example.c b/samples/kprobes/jprobe_example.c
index c3108bb15789..e3c0a40909f7 100644
--- a/samples/kprobes/jprobe_example.c
+++ b/samples/kprobes/jprobe_example.c
@@ -48,10 +48,10 @@ static int __init jprobe_init(void)
 
         ret = register_jprobe(&my_jprobe);
         if (ret < 0) {
-                printk(KERN_INFO "register_jprobe failed, returned %d\n", ret);
+                pr_err("register_jprobe failed, returned %d\n", ret);
                 return -1;
         }
-        printk(KERN_INFO "Planted jprobe at %p, handler addr %p\n",
+        pr_info("Planted jprobe at %p, handler addr %p\n",
                my_jprobe.kp.addr, my_jprobe.entry);
         return 0;
 }
@@ -59,7 +59,7 @@ static int __init jprobe_init(void)
 static void __exit jprobe_exit(void)
 {
         unregister_jprobe(&my_jprobe);
-        printk(KERN_INFO "jprobe at %p unregistered\n", my_jprobe.kp.addr);
+        pr_info("jprobe at %p unregistered\n", my_jprobe.kp.addr);
 }
 
 module_init(jprobe_init)
diff --git a/samples/kprobes/kprobe_example.c b/samples/kprobes/kprobe_example.c
index f3b61b4ee09c..88b3e2d227ae 100644
--- a/samples/kprobes/kprobe_example.c
+++ b/samples/kprobes/kprobe_example.c
@@ -27,23 +27,19 @@ static struct kprobe kp = {
 static int handler_pre(struct kprobe *p, struct pt_regs *regs)
 {
 #ifdef CONFIG_X86
-        printk(KERN_INFO "<%s> pre_handler: p->addr = 0x%p, ip = %lx,"
-                        " flags = 0x%lx\n",
+        pr_info("<%s> pre_handler: p->addr = 0x%p, ip = %lx, flags = 0x%lx\n",
                 p->symbol_name, p->addr, regs->ip, regs->flags);
 #endif
 #ifdef CONFIG_PPC
-        printk(KERN_INFO "<%s> pre_handler: p->addr = 0x%p, nip = 0x%lx,"
-                        " msr = 0x%lx\n",
+        pr_info("<%s> pre_handler: p->addr = 0x%p, nip = 0x%lx, msr = 0x%lx\n",
                 p->symbol_name, p->addr, regs->nip, regs->msr);
 #endif
 #ifdef CONFIG_MIPS
-        printk(KERN_INFO "<%s> pre_handler: p->addr = 0x%p, epc = 0x%lx,"
-                        " status = 0x%lx\n",
+        pr_info("<%s> pre_handler: p->addr = 0x%p, epc = 0x%lx, status = 0x%lx\n",
                 p->symbol_name, p->addr, regs->cp0_epc, regs->cp0_status);
 #endif
 #ifdef CONFIG_TILEGX
-        printk(KERN_INFO "<%s> pre_handler: p->addr = 0x%p, pc = 0x%lx,"
-                        " ex1 = 0x%lx\n",
+        pr_info("<%s> pre_handler: p->addr = 0x%p, pc = 0x%lx, ex1 = 0x%lx\n",
                 p->symbol_name, p->addr, regs->pc, regs->ex1);
 #endif
 #ifdef CONFIG_ARM64
@@ -61,19 +57,19 @@ static void handler_post(struct kprobe *p, struct pt_regs *regs,
                                 unsigned long flags)
 {
 #ifdef CONFIG_X86
-        printk(KERN_INFO "<%s> post_handler: p->addr = 0x%p, flags = 0x%lx\n",
+        pr_info("<%s> post_handler: p->addr = 0x%p, flags = 0x%lx\n",
                 p->symbol_name, p->addr, regs->flags);
 #endif
 #ifdef CONFIG_PPC
-        printk(KERN_INFO "<%s> post_handler: p->addr = 0x%p, msr = 0x%lx\n",
+        pr_info("<%s> post_handler: p->addr = 0x%p, msr = 0x%lx\n",
                 p->symbol_name, p->addr, regs->msr);
 #endif
 #ifdef CONFIG_MIPS
-        printk(KERN_INFO "<%s> post_handler: p->addr = 0x%p, status = 0x%lx\n",
+        pr_info("<%s> post_handler: p->addr = 0x%p, status = 0x%lx\n",
                 p->symbol_name, p->addr, regs->cp0_status);
 #endif
 #ifdef CONFIG_TILEGX
-        printk(KERN_INFO "<%s> post_handler: p->addr = 0x%p, ex1 = 0x%lx\n",
+        pr_info("<%s> post_handler: p->addr = 0x%p, ex1 = 0x%lx\n",
                 p->symbol_name, p->addr, regs->ex1);
 #endif
 #ifdef CONFIG_ARM64
@@ -89,8 +85,7 @@ static void handler_post(struct kprobe *p, struct pt_regs *regs,
  */
 static int handler_fault(struct kprobe *p, struct pt_regs *regs, int trapnr)
 {
-        printk(KERN_INFO "fault_handler: p->addr = 0x%p, trap #%dn",
-                p->addr, trapnr);
+        pr_info("fault_handler: p->addr = 0x%p, trap #%dn", p->addr, trapnr);
         /* Return 0 because we don't handle the fault. */
         return 0;
 }
@@ -104,17 +99,17 @@ static int __init kprobe_init(void)
 
         ret = register_kprobe(&kp);
         if (ret < 0) {
-                printk(KERN_INFO "register_kprobe failed, returned %d\n", ret);
+                pr_err("register_kprobe failed, returned %d\n", ret);
                 return ret;
         }
-        printk(KERN_INFO "Planted kprobe at %p\n", kp.addr);
+        pr_info("Planted kprobe at %p\n", kp.addr);
         return 0;
 }
 
 static void __exit kprobe_exit(void)
 {
         unregister_kprobe(&kp);
-        printk(KERN_INFO "kprobe at %p unregistered\n", kp.addr);
+        pr_info("kprobe at %p unregistered\n", kp.addr);
 }
 
 module_init(kprobe_init)
diff --git a/samples/kprobes/kretprobe_example.c b/samples/kprobes/kretprobe_example.c
index ebb1d1aed547..7f9060f435cd 100644
--- a/samples/kprobes/kretprobe_example.c
+++ b/samples/kprobes/kretprobe_example.c
@@ -55,14 +55,14 @@ static int entry_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
  */
 static int ret_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
 {
-        int retval = regs_return_value(regs);
+        unsigned long retval = regs_return_value(regs);
         struct my_data *data = (struct my_data *)ri->data;
         s64 delta;
         ktime_t now;
 
         now = ktime_get();
         delta = ktime_to_ns(ktime_sub(now, data->entry_stamp));
-        printk(KERN_INFO "%s returned %d and took %lld ns to execute\n",
+        pr_info("%s returned %lu and took %lld ns to execute\n",
                         func_name, retval, (long long)delta);
         return 0;
 }
@@ -82,11 +82,10 @@ static int __init kretprobe_init(void)
         my_kretprobe.kp.symbol_name = func_name;
         ret = register_kretprobe(&my_kretprobe);
         if (ret < 0) {
-                printk(KERN_INFO "register_kretprobe failed, returned %d\n",
-                                ret);
+                pr_err("register_kretprobe failed, returned %d\n", ret);
                 return -1;
         }
-        printk(KERN_INFO "Planted return probe at %s: %p\n",
+        pr_info("Planted return probe at %s: %p\n",
                         my_kretprobe.kp.symbol_name, my_kretprobe.kp.addr);
         return 0;
 }
@@ -94,11 +93,10 @@ static int __init kretprobe_init(void)
 static void __exit kretprobe_exit(void)
 {
         unregister_kretprobe(&my_kretprobe);
-        printk(KERN_INFO "kretprobe at %p unregistered\n",
-                        my_kretprobe.kp.addr);
+        pr_info("kretprobe at %p unregistered\n", my_kretprobe.kp.addr);
 
         /* nmissed > 0 suggests that maxactive was set too low. */
-        printk(KERN_INFO "Missed probing %d instances of %s\n",
+        pr_info("Missed probing %d instances of %s\n",
                 my_kretprobe.nmissed, my_kretprobe.kp.symbol_name);
 }