Merge tag 'v5.3-rc4' into patchwork

Linux 5.3-rc4

* tag 'v5.3-rc4': (750 commits)
  Linux 5.3-rc4
  Makefile: Convert -Wimplicit-fallthrough=3 to just -Wimplicit-fallthrough for clang
  ARM: ep93xx: Mark expected switch fall-through
  scsi: fas216: Mark expected switch fall-throughs
  pcmcia: db1xxx_ss: Mark expected switch fall-throughs
  video: fbdev: omapfb_main: Mark expected switch fall-throughs
  watchdog: riowd: Mark expected switch fall-through
  s390/net: Mark expected switch fall-throughs
  crypto: ux500/crypt: Mark expected switch fall-throughs
  watchdog: wdt977: Mark expected switch fall-through
  watchdog: scx200_wdt: Mark expected switch fall-through
  watchdog: Mark expected switch fall-throughs
  ARM: signal: Mark expected switch fall-through
  mfd: omap-usb-host: Mark expected switch fall-throughs
  mfd: db8500-prcmu: Mark expected switch fall-throughs
  ARM: OMAP: dma: Mark expected switch fall-throughs
  ARM: alignment: Mark expected switch fall-throughs
  ARM: tegra: Mark expected switch fall-through
  ARM/hw_breakpoint: Mark expected switch fall-throughs
  mm/memremap: Fix reuse of pgmap instances with internal references
  ...

11 files changed, 105 insertions, 20 deletions

diff --git a/arch/arm/include/asm/dma-mapping.h b/arch/arm/include/asm/dma-mapping.h
index 7e0486ad1318..dba9355e2484 100644
--- a/arch/arm/include/asm/dma-mapping.h
+++ b/arch/arm/include/asm/dma-mapping.h
@@ -18,7 +18,9 @@ extern const struct dma_map_ops arm_coherent_dma_ops;
 
 static inline const struct dma_map_ops *get_arch_dma_ops(struct bus_type *bus)
 {
-        return IS_ENABLED(CONFIG_MMU) ? &arm_dma_ops : NULL;
+        if (IS_ENABLED(CONFIG_MMU) && !IS_ENABLED(CONFIG_ARM_LPAE))
+                return &arm_dma_ops;
+        return NULL;
 }
 
 #ifdef __arch_page_to_dma
diff --git a/arch/arm/kernel/hw_breakpoint.c b/arch/arm/kernel/hw_breakpoint.c
index af8b8e15f589..b0c195e3a06d 100644
--- a/arch/arm/kernel/hw_breakpoint.c
+++ b/arch/arm/kernel/hw_breakpoint.c
@@ -544,6 +544,7 @@ static int arch_build_bp_info(struct perf_event *bp,
                 if ((hw->ctrl.type != ARM_BREAKPOINT_EXECUTE)
                         && max_watchpoint_len >= 8)
                         break;
+                /* Else, fall through */
         default:
                 return -EINVAL;
         }
@@ -608,10 +609,12 @@ int hw_breakpoint_arch_parse(struct perf_event *bp,
                 /* Allow halfword watchpoints and breakpoints. */
                 if (hw->ctrl.len == ARM_BREAKPOINT_LEN_2)
                         break;
+                /* Else, fall through */
         case 3:
                 /* Allow single byte watchpoint. */
                 if (hw->ctrl.len == ARM_BREAKPOINT_LEN_1)
                         break;
+                /* Else, fall through */
         default:
                 ret = -EINVAL;
                 goto out;
@@ -861,6 +864,7 @@ static int hw_breakpoint_pending(unsigned long addr, unsigned int fsr,
                 break;
         case ARM_ENTRY_ASYNC_WATCHPOINT:
                 WARN(1, "Asynchronous watchpoint exception taken. Debugging results may be unreliable\n");
+                /* Fall through */
         case ARM_ENTRY_SYNC_WATCHPOINT:
                 watchpoint_handler(addr, fsr, regs);
                 break;
@@ -909,6 +913,7 @@ static bool core_has_os_save_restore(void)
                 ARM_DBG_READ(c1, c1, 4, oslsr);
                 if (oslsr & ARM_OSLSR_OSLM0)
                         return true;
+                /* Else, fall through */
         default:
                 return false;
         }
diff --git a/arch/arm/kernel/signal.c b/arch/arm/kernel/signal.c
index 09f6fdd41974..ab2568996ddb 100644
--- a/arch/arm/kernel/signal.c
+++ b/arch/arm/kernel/signal.c
@@ -596,6 +596,7 @@ static int do_signal(struct pt_regs *regs, int syscall)
                 switch (retval) {
                 case -ERESTART_RESTARTBLOCK:
                         restart -= 2;
+                        /* Fall through */
                 case -ERESTARTNOHAND:
                 case -ERESTARTSYS:
                 case -ERESTARTNOINTR:
diff --git a/arch/arm/kvm/coproc.c b/arch/arm/kvm/coproc.c
index d2806bcff8bb..07745ee022a1 100644
--- a/arch/arm/kvm/coproc.c
+++ b/arch/arm/kvm/coproc.c
@@ -651,13 +651,22 @@ int kvm_handle_cp14_64(struct kvm_vcpu *vcpu, struct kvm_run *run)
 }
 
 static void reset_coproc_regs(struct kvm_vcpu *vcpu,
-                              const struct coproc_reg *table, size_t num)
+                              const struct coproc_reg *table, size_t num,
+                              unsigned long *bmap)
 {
         unsigned long i;
 
         for (i = 0; i < num; i++)
-                if (table[i].reset)
+                if (table[i].reset) {
+                        int reg = table[i].reg;
+
                         table[i].reset(vcpu, &table[i]);
+                        if (reg > 0 && reg < NR_CP15_REGS) {
+                                set_bit(reg, bmap);
+                                if (table[i].is_64bit)
+                                        set_bit(reg + 1, bmap);
+                        }
+                }
 }
 
 static struct coproc_params decode_32bit_hsr(struct kvm_vcpu *vcpu)
@@ -1432,17 +1441,15 @@ void kvm_reset_coprocs(struct kvm_vcpu *vcpu)
 {
         size_t num;
         const struct coproc_reg *table;
-
-        /* Catch someone adding a register without putting in reset entry. */
-        memset(vcpu->arch.ctxt.cp15, 0x42, sizeof(vcpu->arch.ctxt.cp15));
+        DECLARE_BITMAP(bmap, NR_CP15_REGS) = { 0, };
 
         /* Generic chip reset first (so target could override). */
-        reset_coproc_regs(vcpu, cp15_regs, ARRAY_SIZE(cp15_regs));
+        reset_coproc_regs(vcpu, cp15_regs, ARRAY_SIZE(cp15_regs), bmap);
 
         table = get_target_table(vcpu->arch.target, &num);
-        reset_coproc_regs(vcpu, table, num);
+        reset_coproc_regs(vcpu, table, num, bmap);
 
         for (num = 1; num < NR_CP15_REGS; num++)
-                WARN(vcpu_cp15(vcpu, num) == 0x42424242,
+                WARN(!test_bit(num, bmap),
                      "Didn't reset vcpu_cp15(vcpu, %zi)", num);
 }
diff --git a/arch/arm/mach-ep93xx/crunch.c b/arch/arm/mach-ep93xx/crunch.c
index 1c9a4be8b503..1c05c5bf7e5c 100644
--- a/arch/arm/mach-ep93xx/crunch.c
+++ b/arch/arm/mach-ep93xx/crunch.c
@@ -49,6 +49,7 @@ static int crunch_do(struct notifier_block *self, unsigned long cmd, void *t)
                  * FALLTHROUGH: Ensure we don't try to overwrite our newly
                  * initialised state information on the first fault.
                  */
+                /* Fall through */
 
         case THREAD_NOTIFY_EXIT:
                 crunch_task_release(thread);
diff --git a/arch/arm/mach-tegra/reset.c b/arch/arm/mach-tegra/reset.c
index 5a67a71f80cc..76a65df42d10 100644
--- a/arch/arm/mach-tegra/reset.c
+++ b/arch/arm/mach-tegra/reset.c
@@ -70,7 +70,7 @@ static void __init tegra_cpu_reset_handler_enable(void)
         switch (err) {
         case -ENOSYS:
                 tegra_cpu_reset_handler_set(reset_address);
-                /* pass-through */
+                /* fall through */
         case 0:
                 is_enabled = true;
                 break;
diff --git a/arch/arm/mm/Kconfig b/arch/arm/mm/Kconfig
index 820b60a50125..c54cd7ed90ba 100644
--- a/arch/arm/mm/Kconfig
+++ b/arch/arm/mm/Kconfig
@@ -663,6 +663,11 @@ config ARM_LPAE
         depends on MMU && CPU_32v7 && !CPU_32v6 && !CPU_32v5 && \
                 !CPU_32v4 && !CPU_32v3
         select PHYS_ADDR_T_64BIT
+        select SWIOTLB
+        select ARCH_HAS_DMA_COHERENT_TO_PFN
+        select ARCH_HAS_DMA_MMAP_PGPROT
+        select ARCH_HAS_SYNC_DMA_FOR_DEVICE
+        select ARCH_HAS_SYNC_DMA_FOR_CPU
         help
           Say Y if you have an ARMv7 processor supporting the LPAE page
           table format and you would like to access memory beyond the
diff --git a/arch/arm/mm/alignment.c b/arch/arm/mm/alignment.c
index 8cdb78642e93..04b36436cbc0 100644
--- a/arch/arm/mm/alignment.c
+++ b/arch/arm/mm/alignment.c
@@ -695,7 +695,7 @@ thumb2arm(u16 tinstr)
                         return subset[(L<<1) | ((tinstr & (1<<8)) >> 8)] |
                             (tinstr & 255);             /* register_list */
                 }
-                /* Else fall through for illegal instruction case */
+                /* Else, fall through - for illegal instruction case */
 
         default:
                 return BAD_INSTR;
@@ -751,6 +751,8 @@ do_alignment_t32_to_handler(unsigned long *pinstr, struct pt_regs *regs,
         case 0xe8e0:
         case 0xe9e0:
                 poffset->un = (tinst2 & 0xff) << 2;
+                /* Fall through */
+
         case 0xe940:
         case 0xe9c0:
                 return do_alignment_ldrdstrd;
diff --git a/arch/arm/mm/dma-mapping.c b/arch/arm/mm/dma-mapping.c
index 4789c60a86e3..6774b03aa405 100644
--- a/arch/arm/mm/dma-mapping.c
+++ b/arch/arm/mm/dma-mapping.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
+#include <linux/dma-noncoherent.h>
 #include <linux/dma-contiguous.h>
 #include <linux/highmem.h>
 #include <linux/memblock.h>
@@ -1125,6 +1126,19 @@ int arm_dma_supported(struct device *dev, u64 mask)
 
 static const struct dma_map_ops *arm_get_dma_map_ops(bool coherent)
 {
+        /*
+         * When CONFIG_ARM_LPAE is set, physical address can extend above
+         * 32-bits, which then can't be addressed by devices that only support
+         * 32-bit DMA.
+         * Use the generic dma-direct / swiotlb ops code in that case, as that
+         * handles bounce buffering for us.
+         *
+         * Note: this checks CONFIG_ARM_LPAE instead of CONFIG_SWIOTLB as the
+         * latter is also selected by the Xen code, but that code for now relies
+         * on non-NULL dev_dma_ops.  To be cleaned up later.
+         */
+        if (IS_ENABLED(CONFIG_ARM_LPAE))
+                return NULL;
         return coherent ? &arm_coherent_dma_ops : &arm_dma_ops;
 }
 
@@ -2329,6 +2343,9 @@ void arch_setup_dma_ops(struct device *dev, u64 dma_base, u64 size,
         const struct dma_map_ops *dma_ops;
 
         dev->archdata.dma_coherent = coherent;
+#ifdef CONFIG_SWIOTLB
+        dev->dma_coherent = coherent;
+#endif
 
         /*
          * Don't override the dma_ops if they have already been set. Ideally
@@ -2363,3 +2380,47 @@ void arch_teardown_dma_ops(struct device *dev)
         /* Let arch_setup_dma_ops() start again from scratch upon re-probe */
         set_dma_ops(dev, NULL);
 }
+
+#ifdef CONFIG_SWIOTLB
+void arch_sync_dma_for_device(struct device *dev, phys_addr_t paddr,
+                size_t size, enum dma_data_direction dir)
+{
+        __dma_page_cpu_to_dev(phys_to_page(paddr), paddr & (PAGE_SIZE - 1),
+                              size, dir);
+}
+
+void arch_sync_dma_for_cpu(struct device *dev, phys_addr_t paddr,
+                size_t size, enum dma_data_direction dir)
+{
+        __dma_page_dev_to_cpu(phys_to_page(paddr), paddr & (PAGE_SIZE - 1),
+                              size, dir);
+}
+
+long arch_dma_coherent_to_pfn(struct device *dev, void *cpu_addr,
+                dma_addr_t dma_addr)
+{
+        return dma_to_pfn(dev, dma_addr);
+}
+
+pgprot_t arch_dma_mmap_pgprot(struct device *dev, pgprot_t prot,
+                unsigned long attrs)
+{
+        if (!dev_is_dma_coherent(dev))
+                return __get_dma_pgprot(attrs, prot);
+        return prot;
+}
+
+void *arch_dma_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
+                gfp_t gfp, unsigned long attrs)
+{
+        return __dma_alloc(dev, size, dma_handle, gfp,
+                           __get_dma_pgprot(attrs, PAGE_KERNEL), false,
+                           attrs, __builtin_return_address(0));
+}
+
+void arch_dma_free(struct device *dev, size_t size, void *cpu_addr,
+                dma_addr_t dma_handle, unsigned long attrs)
+{
+        __arm_dma_free(dev, size, cpu_addr, dma_handle, attrs, false);
+}
+#endif /* CONFIG_SWIOTLB */
diff --git a/arch/arm/mm/init.c b/arch/arm/mm/init.c
index 4920a206dce9..16d373d587c4 100644
--- a/arch/arm/mm/init.c
+++ b/arch/arm/mm/init.c
@@ -21,6 +21,7 @@
 #include <linux/dma-contiguous.h>
 #include <linux/sizes.h>
 #include <linux/stop_machine.h>
+#include <linux/swiotlb.h>
 
 #include <asm/cp15.h>
 #include <asm/mach-types.h>
@@ -463,6 +464,10 @@ static void __init free_highpages(void)
  */
 void __init mem_init(void)
 {
+#ifdef CONFIG_ARM_LPAE
+        swiotlb_init(1);
+#endif
+
         set_max_mapnr(pfn_to_page(max_pfn) - mem_map);
 
         /* this will put all unused low memory onto the freelists */
diff --git a/arch/arm/plat-omap/dma.c b/arch/arm/plat-omap/dma.c
index 79f43acf9acb..08c99413d02c 100644
--- a/arch/arm/plat-omap/dma.c
+++ b/arch/arm/plat-omap/dma.c
@@ -388,17 +388,15 @@ void omap_set_dma_src_burst_mode(int lch, enum omap_dma_burst_mode burst_mode)
                 /*
                  * not supported by current hardware on OMAP1
                  * w |= (0x03 << 7);
-                 * fall through
                  */
+                /* fall through */
         case OMAP_DMA_DATA_BURST_16:
                 if (dma_omap2plus()) {
                         burst = 0x3;
                         break;
                 }
-                /*
-                 * OMAP1 don't support burst 16
-                 * fall through
-                 */
+                /* OMAP1 don't support burst 16 */
+                /* fall through */
         default:
                 BUG();
         }
@@ -474,10 +472,8 @@ void omap_set_dma_dest_burst_mode(int lch, enum omap_dma_burst_mode burst_mode)
                         burst = 0x3;
                         break;
                 }
-                /*
-                 * OMAP1 don't support burst 16
-                 * fall through
-                 */
+                /* OMAP1 don't support burst 16 */
+                /* fall through */
         default:
                 printk(KERN_ERR "Invalid DMA burst mode\n");
                 BUG();