Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-alx/patches-4.9/0264-4.9.165-all-fixes.patch

    Contents of /trunk/kernel-alx/patches-4.9/0264-4.9.165-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3341 - (show annotations) (download)
    Tue Jun 18 09:41:55 2019 UTC (4 years, 10 months ago) by niro
    File size: 127195 byte(s) 
    -linux-4.9.165
    1 diff --git a/Makefile b/Makefile
    2 index e1bcc76388dc..9b61da532c42 100644
    3 --- a/Makefile
    4 +++ b/Makefile
    5 @@ -1,6 +1,6 @@
    6 VERSION = 4
    7 PATCHLEVEL = 9
    8 -SUBLEVEL = 164
    9 +SUBLEVEL = 165
    10 EXTRAVERSION =
    11 NAME = Roaring Lionus
    12
    13 diff --git a/arch/arc/include/asm/uaccess.h b/arch/arc/include/asm/uaccess.h
    14 index 0684fd2f42e8..f82393f89215 100644
    15 --- a/arch/arc/include/asm/uaccess.h
    16 +++ b/arch/arc/include/asm/uaccess.h
    17 @@ -209,7 +209,7 @@ __arc_copy_from_user(void *to, const void __user *from, unsigned long n)
    18 */
    19 "=&r" (tmp), "+r" (to), "+r" (from)
    20 :
    21 - : "lp_count", "lp_start", "lp_end", "memory");
    22 + : "lp_count", "memory");
    23
    24 return n;
    25 }
    26 @@ -438,7 +438,7 @@ __arc_copy_to_user(void __user *to, const void *from, unsigned long n)
    27 */
    28 "=&r" (tmp), "+r" (to), "+r" (from)
    29 :
    30 - : "lp_count", "lp_start", "lp_end", "memory");
    31 + : "lp_count", "memory");
    32
    33 return n;
    34 }
    35 @@ -658,7 +658,7 @@ static inline unsigned long __arc_clear_user(void __user *to, unsigned long n)
    36 " .previous \n"
    37 : "+r"(d_char), "+r"(res)
    38 : "i"(0)
    39 - : "lp_count", "lp_start", "lp_end", "memory");
    40 + : "lp_count", "memory");
    41
    42 return res;
    43 }
    44 @@ -691,7 +691,7 @@ __arc_strncpy_from_user(char *dst, const char __user *src, long count)
    45 " .previous \n"
    46 : "+r"(res), "+r"(dst), "+r"(src), "=r"(val)
    47 : "g"(-EFAULT), "r"(count)
    48 - : "lp_count", "lp_start", "lp_end", "memory");
    49 + : "lp_count", "memory");
    50
    51 return res;
    52 }
    53 diff --git a/arch/arc/lib/memcpy-archs.S b/arch/arc/lib/memcpy-archs.S
    54 index d61044dd8b58..ea14b0bf3116 100644
    55 --- a/arch/arc/lib/memcpy-archs.S
    56 +++ b/arch/arc/lib/memcpy-archs.S
    57 @@ -25,15 +25,11 @@
    58 #endif
    59
    60 #ifdef CONFIG_ARC_HAS_LL64
    61 -# define PREFETCH_READ(RX) prefetch [RX, 56]
    62 -# define PREFETCH_WRITE(RX) prefetchw [RX, 64]
    63 # define LOADX(DST,RX) ldd.ab DST, [RX, 8]
    64 # define STOREX(SRC,RX) std.ab SRC, [RX, 8]
    65 # define ZOLSHFT 5
    66 # define ZOLAND 0x1F
    67 #else
    68 -# define PREFETCH_READ(RX) prefetch [RX, 28]
    69 -# define PREFETCH_WRITE(RX) prefetchw [RX, 32]
    70 # define LOADX(DST,RX) ld.ab DST, [RX, 4]
    71 # define STOREX(SRC,RX) st.ab SRC, [RX, 4]
    72 # define ZOLSHFT 4
    73 @@ -41,8 +37,6 @@
    74 #endif
    75
    76 ENTRY_CFI(memcpy)
    77 - prefetch [r1] ; Prefetch the read location
    78 - prefetchw [r0] ; Prefetch the write location
    79 mov.f 0, r2
    80 ;;; if size is zero
    81 jz.d [blink]
    82 @@ -72,8 +66,6 @@ ENTRY_CFI(memcpy)
    83 lpnz @.Lcopy32_64bytes
    84 ;; LOOP START
    85 LOADX (r6, r1)
    86 - PREFETCH_READ (r1)
    87 - PREFETCH_WRITE (r3)
    88 LOADX (r8, r1)
    89 LOADX (r10, r1)
    90 LOADX (r4, r1)
    91 @@ -117,9 +109,7 @@ ENTRY_CFI(memcpy)
    92 lpnz @.Lcopy8bytes_1
    93 ;; LOOP START
    94 ld.ab r6, [r1, 4]
    95 - prefetch [r1, 28] ;Prefetch the next read location
    96 ld.ab r8, [r1,4]
    97 - prefetchw [r3, 32] ;Prefetch the next write location
    98
    99 SHIFT_1 (r7, r6, 24)
    100 or r7, r7, r5
    101 @@ -162,9 +152,7 @@ ENTRY_CFI(memcpy)
    102 lpnz @.Lcopy8bytes_2
    103 ;; LOOP START
    104 ld.ab r6, [r1, 4]
    105 - prefetch [r1, 28] ;Prefetch the next read location
    106 ld.ab r8, [r1,4]
    107 - prefetchw [r3, 32] ;Prefetch the next write location
    108
    109 SHIFT_1 (r7, r6, 16)
    110 or r7, r7, r5
    111 @@ -204,9 +192,7 @@ ENTRY_CFI(memcpy)
    112 lpnz @.Lcopy8bytes_3
    113 ;; LOOP START
    114 ld.ab r6, [r1, 4]
    115 - prefetch [r1, 28] ;Prefetch the next read location
    116 ld.ab r8, [r1,4]
    117 - prefetchw [r3, 32] ;Prefetch the next write location
    118
    119 SHIFT_1 (r7, r6, 8)
    120 or r7, r7, r5
    121 diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
    122 index b5d529fdffab..74a70f91b01a 100644
    123 --- a/arch/arm/Kconfig
    124 +++ b/arch/arm/Kconfig
    125 @@ -1457,6 +1457,7 @@ config NR_CPUS
    126 config HOTPLUG_CPU
    127 bool "Support for hot-pluggable CPUs"
    128 depends on SMP
    129 + select GENERIC_IRQ_MIGRATION
    130 help
    131 Say Y here to experiment with turning CPUs off and on. CPUs
    132 can be controlled through /sys/devices/system/cpu.
    133 diff --git a/arch/arm/include/asm/irq.h b/arch/arm/include/asm/irq.h
    134 index e53638c8ed8a..61e1d089ce1a 100644
    135 --- a/arch/arm/include/asm/irq.h
    136 +++ b/arch/arm/include/asm/irq.h
    137 @@ -24,7 +24,6 @@
    138 #ifndef __ASSEMBLY__
    139 struct irqaction;
    140 struct pt_regs;
    141 -extern void migrate_irqs(void);
    142
    143 extern void asm_do_IRQ(unsigned int, struct pt_regs *);
    144 void handle_IRQ(unsigned int, struct pt_regs *);
    145 diff --git a/arch/arm/kernel/irq.c b/arch/arm/kernel/irq.c
    146 index ece04a457486..5b07c7a31c31 100644
    147 --- a/arch/arm/kernel/irq.c
    148 +++ b/arch/arm/kernel/irq.c
    149 @@ -31,7 +31,6 @@
    150 #include <linux/smp.h>
    151 #include <linux/init.h>
    152 #include <linux/seq_file.h>
    153 -#include <linux/ratelimit.h>
    154 #include <linux/errno.h>
    155 #include <linux/list.h>
    156 #include <linux/kallsyms.h>
    157 @@ -119,64 +118,3 @@ int __init arch_probe_nr_irqs(void)
    158 return nr_irqs;
    159 }
    160 #endif
    161 -
    162 -#ifdef CONFIG_HOTPLUG_CPU
    163 -static bool migrate_one_irq(struct irq_desc *desc)
    164 -{
    165 - struct irq_data *d = irq_desc_get_irq_data(desc);
    166 - const struct cpumask *affinity = irq_data_get_affinity_mask(d);
    167 - struct irq_chip *c;
    168 - bool ret = false;
    169 -
    170 - /*
    171 - * If this is a per-CPU interrupt, or the affinity does not
    172 - * include this CPU, then we have nothing to do.
    173 - */
    174 - if (irqd_is_per_cpu(d) || !cpumask_test_cpu(smp_processor_id(), affinity))
    175 - return false;
    176 -
    177 - if (cpumask_any_and(affinity, cpu_online_mask) >= nr_cpu_ids) {
    178 - affinity = cpu_online_mask;
    179 - ret = true;
    180 - }
    181 -
    182 - c = irq_data_get_irq_chip(d);
    183 - if (!c->irq_set_affinity)
    184 - pr_debug("IRQ%u: unable to set affinity\n", d->irq);
    185 - else if (c->irq_set_affinity(d, affinity, false) == IRQ_SET_MASK_OK && ret)
    186 - cpumask_copy(irq_data_get_affinity_mask(d), affinity);
    187 -
    188 - return ret;
    189 -}
    190 -
    191 -/*
    192 - * The current CPU has been marked offline. Migrate IRQs off this CPU.
    193 - * If the affinity settings do not allow other CPUs, force them onto any
    194 - * available CPU.
    195 - *
    196 - * Note: we must iterate over all IRQs, whether they have an attached
    197 - * action structure or not, as we need to get chained interrupts too.
    198 - */
    199 -void migrate_irqs(void)
    200 -{
    201 - unsigned int i;
    202 - struct irq_desc *desc;
    203 - unsigned long flags;
    204 -
    205 - local_irq_save(flags);
    206 -
    207 - for_each_irq_desc(i, desc) {
    208 - bool affinity_broken;
    209 -
    210 - raw_spin_lock(&desc->lock);
    211 - affinity_broken = migrate_one_irq(desc);
    212 - raw_spin_unlock(&desc->lock);
    213 -
    214 - if (affinity_broken)
    215 - pr_warn_ratelimited("IRQ%u no longer affine to CPU%u\n",
    216 - i, smp_processor_id());
    217 - }
    218 -
    219 - local_irq_restore(flags);
    220 -}
    221 -#endif /* CONFIG_HOTPLUG_CPU */
    222 diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c
    223 index 8faf869e9fb2..bc83ec7ed53f 100644
    224 --- a/arch/arm/kernel/smp.c
    225 +++ b/arch/arm/kernel/smp.c
    226 @@ -253,7 +253,7 @@ int __cpu_disable(void)
    227 /*
    228 * OK - migrate IRQs away from this CPU
    229 */
    230 - migrate_irqs();
    231 + irq_migrate_all_off_this_cpu();
    232
    233 /*
    234 * Flush user cache and TLB mappings, and then remove this CPU
    235 diff --git a/arch/arm/mach-omap2/display.c b/arch/arm/mach-omap2/display.c
    236 index 70b3eaf085e4..5ca7e29ad851 100644
    237 --- a/arch/arm/mach-omap2/display.c
    238 +++ b/arch/arm/mach-omap2/display.c
    239 @@ -115,6 +115,7 @@ static int omap4_dsi_mux_pads(int dsi_id, unsigned lanes)
    240 u32 enable_mask, enable_shift;
    241 u32 pipd_mask, pipd_shift;
    242 u32 reg;
    243 + int ret;
    244
    245 if (dsi_id == 0) {
    246 enable_mask = OMAP4_DSI1_LANEENABLE_MASK;
    247 @@ -130,7 +131,11 @@ static int omap4_dsi_mux_pads(int dsi_id, unsigned lanes)
    248 return -ENODEV;
    249 }
    250
    251 - regmap_read(omap4_dsi_mux_syscon, OMAP4_DSIPHY_SYSCON_OFFSET, &reg);
    252 + ret = regmap_read(omap4_dsi_mux_syscon,
    253 + OMAP4_DSIPHY_SYSCON_OFFSET,
    254 + &reg);
    255 + if (ret)
    256 + return ret;
    257
    258 reg &= ~enable_mask;
    259 reg &= ~pipd_mask;
    260 diff --git a/arch/arm/mach-s3c24xx/mach-osiris-dvs.c b/arch/arm/mach-s3c24xx/mach-osiris-dvs.c
    261 index 262ab0744748..f4fdfca9439b 100644
    262 --- a/arch/arm/mach-s3c24xx/mach-osiris-dvs.c
    263 +++ b/arch/arm/mach-s3c24xx/mach-osiris-dvs.c
    264 @@ -70,16 +70,16 @@ static int osiris_dvs_notify(struct notifier_block *nb,
    265
    266 switch (val) {
    267 case CPUFREQ_PRECHANGE:
    268 - if (old_dvs & !new_dvs ||
    269 - cur_dvs & !new_dvs) {
    270 + if ((old_dvs && !new_dvs) ||
    271 + (cur_dvs && !new_dvs)) {
    272 pr_debug("%s: exiting dvs\n", __func__);
    273 cur_dvs = false;
    274 gpio_set_value(OSIRIS_GPIO_DVS, 1);
    275 }
    276 break;
    277 case CPUFREQ_POSTCHANGE:
    278 - if (!old_dvs & new_dvs ||
    279 - !cur_dvs & new_dvs) {
    280 + if ((!old_dvs && new_dvs) ||
    281 + (!cur_dvs && new_dvs)) {
    282 pr_debug("entering dvs\n");
    283 cur_dvs = true;
    284 gpio_set_value(OSIRIS_GPIO_DVS, 0);
    285 diff --git a/arch/arm64/crypto/aes-ce-ccm-core.S b/arch/arm64/crypto/aes-ce-ccm-core.S
    286 index 3363560c79b7..7bc459d9235c 100644
    287 --- a/arch/arm64/crypto/aes-ce-ccm-core.S
    288 +++ b/arch/arm64/crypto/aes-ce-ccm-core.S
    289 @@ -74,12 +74,13 @@ ENTRY(ce_aes_ccm_auth_data)
    290 beq 10f
    291 ext v0.16b, v0.16b, v0.16b, #1 /* rotate out the mac bytes */
    292 b 7b
    293 -8: mov w7, w8
    294 +8: cbz w8, 91f
    295 + mov w7, w8
    296 add w8, w8, #16
    297 9: ext v1.16b, v1.16b, v1.16b, #1
    298 adds w7, w7, #1
    299 bne 9b
    300 - eor v0.16b, v0.16b, v1.16b
    301 +91: eor v0.16b, v0.16b, v1.16b
    302 st1 {v0.16b}, [x0]
    303 10: str w8, [x3]
    304 ret
    305 diff --git a/arch/arm64/kernel/head.S b/arch/arm64/kernel/head.S
    306 index 3289d1458791..db6ff1944c41 100644
    307 --- a/arch/arm64/kernel/head.S
    308 +++ b/arch/arm64/kernel/head.S
    309 @@ -534,8 +534,7 @@ set_hcr:
    310 /* GICv3 system register access */
    311 mrs x0, id_aa64pfr0_el1
    312 ubfx x0, x0, #24, #4
    313 - cmp x0, #1
    314 - b.ne 3f
    315 + cbz x0, 3f
    316
    317 mrs_s x0, ICC_SRE_EL2
    318 orr x0, x0, #ICC_SRE_EL2_SRE // Set ICC_SRE_EL2.SRE==1
    319 diff --git a/arch/m68k/Makefile b/arch/m68k/Makefile
    320 index f0dd9fc84002..a229d28e14cc 100644
    321 --- a/arch/m68k/Makefile
    322 +++ b/arch/m68k/Makefile
    323 @@ -58,7 +58,10 @@ cpuflags-$(CONFIG_M5206e) := $(call cc-option,-mcpu=5206e,-m5200)
    324 cpuflags-$(CONFIG_M5206) := $(call cc-option,-mcpu=5206,-m5200)
    325
    326 KBUILD_AFLAGS += $(cpuflags-y)
    327 -KBUILD_CFLAGS += $(cpuflags-y) -pipe
    328 +KBUILD_CFLAGS += $(cpuflags-y)
    329 +
    330 +KBUILD_CFLAGS += -pipe -ffreestanding
    331 +
    332 ifdef CONFIG_MMU
    333 # without -fno-strength-reduce the 53c7xx.c driver fails ;-(
    334 KBUILD_CFLAGS += -fno-strength-reduce -ffixed-a2
    335 diff --git a/arch/powerpc/kernel/entry_32.S b/arch/powerpc/kernel/entry_32.S
    336 index 3841d749a430..370645687cc7 100644
    337 --- a/arch/powerpc/kernel/entry_32.S
    338 +++ b/arch/powerpc/kernel/entry_32.S
    339 @@ -698,6 +698,9 @@ fast_exception_return:
    340 mtcr r10
    341 lwz r10,_LINK(r11)
    342 mtlr r10
    343 + /* Clear the exception_marker on the stack to avoid confusing stacktrace */
    344 + li r10, 0
    345 + stw r10, 8(r11)
    346 REST_GPR(10, r11)
    347 mtspr SPRN_SRR1,r9
    348 mtspr SPRN_SRR0,r12
    349 @@ -932,6 +935,9 @@ END_FTR_SECTION_IFSET(CPU_FTR_NEED_PAIRED_STWCX)
    350 mtcrf 0xFF,r10
    351 mtlr r11
    352
    353 + /* Clear the exception_marker on the stack to avoid confusing stacktrace */
    354 + li r10, 0
    355 + stw r10, 8(r1)
    356 /*
    357 * Once we put values in SRR0 and SRR1, we are in a state
    358 * where exceptions are not recoverable, since taking an
    359 @@ -969,6 +975,9 @@ exc_exit_restart_end:
    360 mtlr r11
    361 lwz r10,_CCR(r1)
    362 mtcrf 0xff,r10
    363 + /* Clear the exception_marker on the stack to avoid confusing stacktrace */
    364 + li r10, 0
    365 + stw r10, 8(r1)
    366 REST_2GPRS(9, r1)
    367 .globl exc_exit_restart
    368 exc_exit_restart:
    369 diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
    370 index 1c141d50fbc6..609f0e87ced7 100644
    371 --- a/arch/powerpc/kernel/process.c
    372 +++ b/arch/powerpc/kernel/process.c
    373 @@ -153,7 +153,7 @@ void __giveup_fpu(struct task_struct *tsk)
    374
    375 save_fpu(tsk);
    376 msr = tsk->thread.regs->msr;
    377 - msr &= ~MSR_FP;
    378 + msr &= ~(MSR_FP|MSR_FE0|MSR_FE1);
    379 #ifdef CONFIG_VSX
    380 if (cpu_has_feature(CPU_FTR_VSX))
    381 msr &= ~MSR_VSX;
    382 diff --git a/arch/powerpc/kernel/ptrace.c b/arch/powerpc/kernel/ptrace.c
    383 index adfa63e7df8c..4f2829634d79 100644
    384 --- a/arch/powerpc/kernel/ptrace.c
    385 +++ b/arch/powerpc/kernel/ptrace.c
    386 @@ -547,6 +547,7 @@ static int vr_get(struct task_struct *target, const struct user_regset *regset,
    387 /*
    388 * Copy out only the low-order word of vrsave.
    389 */
    390 + int start, end;
    391 union {
    392 elf_vrreg_t reg;
    393 u32 word;
    394 @@ -555,8 +556,10 @@ static int vr_get(struct task_struct *target, const struct user_regset *regset,
    395
    396 vrsave.word = target->thread.vrsave;
    397
    398 + start = 33 * sizeof(vector128);
    399 + end = start + sizeof(vrsave);
    400 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &vrsave,
    401 - 33 * sizeof(vector128), -1);
    402 + start, end);
    403 }
    404
    405 return ret;
    406 @@ -594,6 +597,7 @@ static int vr_set(struct task_struct *target, const struct user_regset *regset,
    407 /*
    408 * We use only the first word of vrsave.
    409 */
    410 + int start, end;
    411 union {
    412 elf_vrreg_t reg;
    413 u32 word;
    414 @@ -602,8 +606,10 @@ static int vr_set(struct task_struct *target, const struct user_regset *regset,
    415
    416 vrsave.word = target->thread.vrsave;
    417
    418 + start = 33 * sizeof(vector128);
    419 + end = start + sizeof(vrsave);
    420 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &vrsave,
    421 - 33 * sizeof(vector128), -1);
    422 + start, end);
    423 if (!ret)
    424 target->thread.vrsave = vrsave.word;
    425 }
    426 diff --git a/arch/powerpc/platforms/83xx/suspend-asm.S b/arch/powerpc/platforms/83xx/suspend-asm.S
    427 index 3d1ecd211776..8137f77abad5 100644
    428 --- a/arch/powerpc/platforms/83xx/suspend-asm.S
    429 +++ b/arch/powerpc/platforms/83xx/suspend-asm.S
    430 @@ -26,13 +26,13 @@
    431 #define SS_MSR 0x74
    432 #define SS_SDR1 0x78
    433 #define SS_LR 0x7c
    434 -#define SS_SPRG 0x80 /* 4 SPRGs */
    435 -#define SS_DBAT 0x90 /* 8 DBATs */
    436 -#define SS_IBAT 0xd0 /* 8 IBATs */
    437 -#define SS_TB 0x110
    438 -#define SS_CR 0x118
    439 -#define SS_GPREG 0x11c /* r12-r31 */
    440 -#define STATE_SAVE_SIZE 0x16c
    441 +#define SS_SPRG 0x80 /* 8 SPRGs */
    442 +#define SS_DBAT 0xa0 /* 8 DBATs */
    443 +#define SS_IBAT 0xe0 /* 8 IBATs */
    444 +#define SS_TB 0x120
    445 +#define SS_CR 0x128
    446 +#define SS_GPREG 0x12c /* r12-r31 */
    447 +#define STATE_SAVE_SIZE 0x17c
    448
    449 .section .data
    450 .align 5
    451 @@ -103,6 +103,16 @@ _GLOBAL(mpc83xx_enter_deep_sleep)
    452 stw r7, SS_SPRG+12(r3)
    453 stw r8, SS_SDR1(r3)
    454
    455 + mfspr r4, SPRN_SPRG4
    456 + mfspr r5, SPRN_SPRG5
    457 + mfspr r6, SPRN_SPRG6
    458 + mfspr r7, SPRN_SPRG7
    459 +
    460 + stw r4, SS_SPRG+16(r3)
    461 + stw r5, SS_SPRG+20(r3)
    462 + stw r6, SS_SPRG+24(r3)
    463 + stw r7, SS_SPRG+28(r3)
    464 +
    465 mfspr r4, SPRN_DBAT0U
    466 mfspr r5, SPRN_DBAT0L
    467 mfspr r6, SPRN_DBAT1U
    468 @@ -493,6 +503,16 @@ mpc83xx_deep_resume:
    469 mtspr SPRN_IBAT7U, r6
    470 mtspr SPRN_IBAT7L, r7
    471
    472 + lwz r4, SS_SPRG+16(r3)
    473 + lwz r5, SS_SPRG+20(r3)
    474 + lwz r6, SS_SPRG+24(r3)
    475 + lwz r7, SS_SPRG+28(r3)
    476 +
    477 + mtspr SPRN_SPRG4, r4
    478 + mtspr SPRN_SPRG5, r5
    479 + mtspr SPRN_SPRG6, r6
    480 + mtspr SPRN_SPRG7, r7
    481 +
    482 lwz r4, SS_SPRG+0(r3)
    483 lwz r5, SS_SPRG+4(r3)
    484 lwz r6, SS_SPRG+8(r3)
    485 diff --git a/arch/powerpc/platforms/embedded6xx/wii.c b/arch/powerpc/platforms/embedded6xx/wii.c
    486 index 3fd683e40bc9..2914529c0695 100644
    487 --- a/arch/powerpc/platforms/embedded6xx/wii.c
    488 +++ b/arch/powerpc/platforms/embedded6xx/wii.c
    489 @@ -104,6 +104,10 @@ unsigned long __init wii_mmu_mapin_mem2(unsigned long top)
    490 /* MEM2 64MB@0x10000000 */
    491 delta = wii_hole_start + wii_hole_size;
    492 size = top - delta;
    493 +
    494 + if (__map_without_bats)
    495 + return delta;
    496 +
    497 for (bl = 128<<10; bl < max_size; bl <<= 1) {
    498 if (bl * 2 > size)
    499 break;
    500 diff --git a/arch/powerpc/platforms/powernv/opal-msglog.c b/arch/powerpc/platforms/powernv/opal-msglog.c
    501 index 39d6ff9e5630..d10bad14097b 100644
    502 --- a/arch/powerpc/platforms/powernv/opal-msglog.c
    503 +++ b/arch/powerpc/platforms/powernv/opal-msglog.c
    504 @@ -98,7 +98,7 @@ static ssize_t opal_msglog_read(struct file *file, struct kobject *kobj,
    505 }
    506
    507 static struct bin_attribute opal_msglog_attr = {
    508 - .attr = {.name = "msglog", .mode = 0444},
    509 + .attr = {.name = "msglog", .mode = 0400},
    510 .read = opal_msglog_read
    511 };
    512
    513 diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
    514 index 1870fa7387b7..a34fb7284024 100644
    515 --- a/arch/x86/kvm/vmx.c
    516 +++ b/arch/x86/kvm/vmx.c
    517 @@ -5965,6 +5965,7 @@ static int handle_external_interrupt(struct kvm_vcpu *vcpu)
    518 static int handle_triple_fault(struct kvm_vcpu *vcpu)
    519 {
    520 vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;
    521 + vcpu->mmio_needed = 0;
    522 return 0;
    523 }
    524
    525 @@ -7046,6 +7047,10 @@ static int get_vmx_mem_address(struct kvm_vcpu *vcpu,
    526 /* Addr = segment_base + offset */
    527 /* offset = base + [index * scale] + displacement */
    528 off = exit_qualification; /* holds the displacement */
    529 + if (addr_size == 1)
    530 + off = (gva_t)sign_extend64(off, 31);
    531 + else if (addr_size == 0)
    532 + off = (gva_t)sign_extend64(off, 15);
    533 if (base_is_valid)
    534 off += kvm_register_read(vcpu, base_reg);
    535 if (index_is_valid)
    536 @@ -7088,10 +7093,16 @@ static int get_vmx_mem_address(struct kvm_vcpu *vcpu,
    537 /* Protected mode: #GP(0)/#SS(0) if the segment is unusable.
    538 */
    539 exn = (s.unusable != 0);
    540 - /* Protected mode: #GP(0)/#SS(0) if the memory
    541 - * operand is outside the segment limit.
    542 +
    543 + /*
    544 + * Protected mode: #GP(0)/#SS(0) if the memory operand is
    545 + * outside the segment limit. All CPUs that support VMX ignore
    546 + * limit checks for flat segments, i.e. segments with base==0,
    547 + * limit==0xffffffff and of type expand-up data or code.
    548 */
    549 - exn = exn || (off + sizeof(u64) > s.limit);
    550 + if (!(s.base == 0 && s.limit == 0xffffffff &&
    551 + ((s.type & 8) || !(s.type & 4))))
    552 + exn = exn || (off + sizeof(u64) > s.limit);
    553 }
    554 if (exn) {
    555 kvm_queue_exception_e(vcpu,
    556 diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
    557 index 5a35fee46620..a29df9ccbfde 100644
    558 --- a/arch/x86/kvm/x86.c
    559 +++ b/arch/x86/kvm/x86.c
    560 @@ -6769,6 +6769,7 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
    561 }
    562 if (kvm_check_request(KVM_REQ_TRIPLE_FAULT, vcpu)) {
    563 vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;
    564 + vcpu->mmio_needed = 0;
    565 r = 0;
    566 goto out;
    567 }
    568 diff --git a/crypto/ahash.c b/crypto/ahash.c
    569 index 90d73a22f129..9a4e87755a0b 100644
    570 --- a/crypto/ahash.c
    571 +++ b/crypto/ahash.c
    572 @@ -85,17 +85,17 @@ static int hash_walk_new_entry(struct crypto_hash_walk *walk)
    573 int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)
    574 {
    575 unsigned int alignmask = walk->alignmask;
    576 - unsigned int nbytes = walk->entrylen;
    577
    578 walk->data -= walk->offset;
    579
    580 - if (nbytes && walk->offset & alignmask && !err) {
    581 - walk->offset = ALIGN(walk->offset, alignmask + 1);
    582 - nbytes = min(nbytes,
    583 - ((unsigned int)(PAGE_SIZE)) - walk->offset);
    584 - walk->entrylen -= nbytes;
    585 + if (walk->entrylen && (walk->offset & alignmask) && !err) {
    586 + unsigned int nbytes;
    587
    588 + walk->offset = ALIGN(walk->offset, alignmask + 1);
    589 + nbytes = min(walk->entrylen,
    590 + (unsigned int)(PAGE_SIZE - walk->offset));
    591 if (nbytes) {
    592 + walk->entrylen -= nbytes;
    593 walk->data += walk->offset;
    594 return nbytes;
    595 }
    596 @@ -115,7 +115,7 @@ int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)
    597 if (err)
    598 return err;
    599
    600 - if (nbytes) {
    601 + if (walk->entrylen) {
    602 walk->offset = 0;
    603 walk->pg++;
    604 return hash_walk_next(walk);
    605 @@ -189,6 +189,21 @@ static int ahash_setkey_unaligned(struct crypto_ahash *tfm, const u8 *key,
    606 return ret;
    607 }
    608
    609 +static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key,
    610 + unsigned int keylen)
    611 +{
    612 + return -ENOSYS;
    613 +}
    614 +
    615 +static void ahash_set_needkey(struct crypto_ahash *tfm)
    616 +{
    617 + const struct hash_alg_common *alg = crypto_hash_alg_common(tfm);
    618 +
    619 + if (tfm->setkey != ahash_nosetkey &&
    620 + !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
    621 + crypto_ahash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
    622 +}
    623 +
    624 int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
    625 unsigned int keylen)
    626 {
    627 @@ -200,20 +215,16 @@ int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
    628 else
    629 err = tfm->setkey(tfm, key, keylen);
    630
    631 - if (err)
    632 + if (unlikely(err)) {
    633 + ahash_set_needkey(tfm);
    634 return err;
    635 + }
    636
    637 crypto_ahash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
    638 return 0;
    639 }
    640 EXPORT_SYMBOL_GPL(crypto_ahash_setkey);
    641
    642 -static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key,
    643 - unsigned int keylen)
    644 -{
    645 - return -ENOSYS;
    646 -}
    647 -
    648 static inline unsigned int ahash_align_buffer_size(unsigned len,
    649 unsigned long mask)
    650 {
    651 @@ -482,8 +493,7 @@ static int crypto_ahash_init_tfm(struct crypto_tfm *tfm)
    652
    653 if (alg->setkey) {
    654 hash->setkey = alg->setkey;
    655 - if (!(alg->halg.base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
    656 - crypto_ahash_set_flags(hash, CRYPTO_TFM_NEED_KEY);
    657 + ahash_set_needkey(hash);
    658 }
    659 if (alg->export)
    660 hash->export = alg->export;
    661 diff --git a/crypto/pcbc.c b/crypto/pcbc.c
    662 index f654965f0933..de81f716cf26 100644
    663 --- a/crypto/pcbc.c
    664 +++ b/crypto/pcbc.c
    665 @@ -52,7 +52,7 @@ static int crypto_pcbc_encrypt_segment(struct blkcipher_desc *desc,
    666 unsigned int nbytes = walk->nbytes;
    667 u8 *src = walk->src.virt.addr;
    668 u8 *dst = walk->dst.virt.addr;
    669 - u8 *iv = walk->iv;
    670 + u8 * const iv = walk->iv;
    671
    672 do {
    673 crypto_xor(iv, src, bsize);
    674 @@ -76,7 +76,7 @@ static int crypto_pcbc_encrypt_inplace(struct blkcipher_desc *desc,
    675 int bsize = crypto_cipher_blocksize(tfm);
    676 unsigned int nbytes = walk->nbytes;
    677 u8 *src = walk->src.virt.addr;
    678 - u8 *iv = walk->iv;
    679 + u8 * const iv = walk->iv;
    680 u8 tmpbuf[bsize];
    681
    682 do {
    683 @@ -89,8 +89,6 @@ static int crypto_pcbc_encrypt_inplace(struct blkcipher_desc *desc,
    684 src += bsize;
    685 } while ((nbytes -= bsize) >= bsize);
    686
    687 - memcpy(walk->iv, iv, bsize);
    688 -
    689 return nbytes;
    690 }
    691
    692 @@ -130,7 +128,7 @@ static int crypto_pcbc_decrypt_segment(struct blkcipher_desc *desc,
    693 unsigned int nbytes = walk->nbytes;
    694 u8 *src = walk->src.virt.addr;
    695 u8 *dst = walk->dst.virt.addr;
    696 - u8 *iv = walk->iv;
    697 + u8 * const iv = walk->iv;
    698
    699 do {
    700 fn(crypto_cipher_tfm(tfm), dst, src);
    701 @@ -142,8 +140,6 @@ static int crypto_pcbc_decrypt_segment(struct blkcipher_desc *desc,
    702 dst += bsize;
    703 } while ((nbytes -= bsize) >= bsize);
    704
    705 - memcpy(walk->iv, iv, bsize);
    706 -
    707 return nbytes;
    708 }
    709
    710 @@ -156,7 +152,7 @@ static int crypto_pcbc_decrypt_inplace(struct blkcipher_desc *desc,
    711 int bsize = crypto_cipher_blocksize(tfm);
    712 unsigned int nbytes = walk->nbytes;
    713 u8 *src = walk->src.virt.addr;
    714 - u8 *iv = walk->iv;
    715 + u8 * const iv = walk->iv;
    716 u8 tmpbuf[bsize];
    717
    718 do {
    719 @@ -169,8 +165,6 @@ static int crypto_pcbc_decrypt_inplace(struct blkcipher_desc *desc,
    720 src += bsize;
    721 } while ((nbytes -= bsize) >= bsize);
    722
    723 - memcpy(walk->iv, iv, bsize);
    724 -
    725 return nbytes;
    726 }
    727
    728 diff --git a/crypto/shash.c b/crypto/shash.c
    729 index 4f047c7eeca7..a1c7609578ea 100644
    730 --- a/crypto/shash.c
    731 +++ b/crypto/shash.c
    732 @@ -52,6 +52,13 @@ static int shash_setkey_unaligned(struct crypto_shash *tfm, const u8 *key,
    733 return err;
    734 }
    735
    736 +static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
    737 +{
    738 + if (crypto_shash_alg_has_setkey(alg) &&
    739 + !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
    740 + crypto_shash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
    741 +}
    742 +
    743 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
    744 unsigned int keylen)
    745 {
    746 @@ -64,8 +71,10 @@ int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
    747 else
    748 err = shash->setkey(tfm, key, keylen);
    749
    750 - if (err)
    751 + if (unlikely(err)) {
    752 + shash_set_needkey(tfm, shash);
    753 return err;
    754 + }
    755
    756 crypto_shash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
    757 return 0;
    758 @@ -367,7 +376,8 @@ int crypto_init_shash_ops_async(struct crypto_tfm *tfm)
    759 crt->final = shash_async_final;
    760 crt->finup = shash_async_finup;
    761 crt->digest = shash_async_digest;
    762 - crt->setkey = shash_async_setkey;
    763 + if (crypto_shash_alg_has_setkey(alg))
    764 + crt->setkey = shash_async_setkey;
    765
    766 crypto_ahash_set_flags(crt, crypto_shash_get_flags(shash) &
    767 CRYPTO_TFM_NEED_KEY);
    768 @@ -389,9 +399,7 @@ static int crypto_shash_init_tfm(struct crypto_tfm *tfm)
    769
    770 hash->descsize = alg->descsize;
    771
    772 - if (crypto_shash_alg_has_setkey(alg) &&
    773 - !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
    774 - crypto_shash_set_flags(hash, CRYPTO_TFM_NEED_KEY);
    775 + shash_set_needkey(hash, alg);
    776
    777 return 0;
    778 }
    779 diff --git a/drivers/acpi/device_sysfs.c b/drivers/acpi/device_sysfs.c
    780 index 201c7ceb7052..98b513d049f6 100644
    781 --- a/drivers/acpi/device_sysfs.c
    782 +++ b/drivers/acpi/device_sysfs.c
    783 @@ -202,11 +202,15 @@ static int create_of_modalias(struct acpi_device *acpi_dev, char *modalias,
    784 {
    785 struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
    786 const union acpi_object *of_compatible, *obj;
    787 + acpi_status status;
    788 int len, count;
    789 int i, nval;
    790 char *c;
    791
    792 - acpi_get_name(acpi_dev->handle, ACPI_SINGLE_NAME, &buf);
    793 + status = acpi_get_name(acpi_dev->handle, ACPI_SINGLE_NAME, &buf);
    794 + if (ACPI_FAILURE(status))
    795 + return -ENODEV;
    796 +
    797 /* DT strings are all in lower case */
    798 for (c = buf.pointer; *c != '\0'; c++)
    799 *c = tolower(*c);
    800 diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c
    801 index 06cf7427d0c4..31a07609f7a2 100644
    802 --- a/drivers/acpi/nfit/core.c
    803 +++ b/drivers/acpi/nfit/core.c
    804 @@ -307,6 +307,13 @@ int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm,
    805 return -EINVAL;
    806 }
    807
    808 + if (out_obj->type != ACPI_TYPE_BUFFER) {
    809 + dev_dbg(dev, "%s unexpected output object type cmd: %s type: %d\n",
    810 + dimm_name, cmd_name, out_obj->type);
    811 + rc = -EINVAL;
    812 + goto out;
    813 + }
    814 +
    815 if (call_pkg) {
    816 call_pkg->nd_fw_size = out_obj->buffer.length;
    817 memcpy(call_pkg->nd_payload + call_pkg->nd_size_in,
    818 @@ -325,13 +332,6 @@ int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm,
    819 return 0;
    820 }
    821
    822 - if (out_obj->package.type != ACPI_TYPE_BUFFER) {
    823 - dev_dbg(dev, "%s:%s unexpected output object type cmd: %s type: %d\n",
    824 - __func__, dimm_name, cmd_name, out_obj->type);
    825 - rc = -EINVAL;
    826 - goto out;
    827 - }
    828 -
    829 if (IS_ENABLED(CONFIG_ACPI_NFIT_DEBUG)) {
    830 dev_dbg(dev, "%s:%s cmd: %s output length: %d\n", __func__,
    831 dimm_name, cmd_name, out_obj->buffer.length);
    832 diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
    833 index f98121f11f7c..9f51a167bf4e 100644
    834 --- a/drivers/base/power/wakeup.c
    835 +++ b/drivers/base/power/wakeup.c
    836 @@ -113,7 +113,6 @@ void wakeup_source_drop(struct wakeup_source *ws)
    837 if (!ws)
    838 return;
    839
    840 - del_timer_sync(&ws->timer);
    841 __pm_relax(ws);
    842 }
    843 EXPORT_SYMBOL_GPL(wakeup_source_drop);
    844 @@ -201,6 +200,13 @@ void wakeup_source_remove(struct wakeup_source *ws)
    845 list_del_rcu(&ws->entry);
    846 spin_unlock_irqrestore(&events_lock, flags);
    847 synchronize_srcu(&wakeup_srcu);
    848 +
    849 + del_timer_sync(&ws->timer);
    850 + /*
    851 + * Clear timer.function to make wakeup_source_not_registered() treat
    852 + * this wakeup source as not registered.
    853 + */
    854 + ws->timer.function = NULL;
    855 }
    856 EXPORT_SYMBOL_GPL(wakeup_source_remove);
    857
    858 diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
    859 index 326b9ba4518e..6914c6e1e1a8 100644
    860 --- a/drivers/block/floppy.c
    861 +++ b/drivers/block/floppy.c
    862 @@ -3752,7 +3752,7 @@ static unsigned int floppy_check_events(struct gendisk *disk,
    863
    864 if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
    865 if (lock_fdc(drive))
    866 - return -EINTR;
    867 + return 0;
    868 poll_drive(false, 0);
    869 process_fd_request();
    870 }
    871 diff --git a/drivers/clk/clk-twl6040.c b/drivers/clk/clk-twl6040.c
    872 index 7b222a5db931..82d615fe2947 100644
    873 --- a/drivers/clk/clk-twl6040.c
    874 +++ b/drivers/clk/clk-twl6040.c
    875 @@ -41,6 +41,43 @@ static int twl6040_pdmclk_is_prepared(struct clk_hw *hw)
    876 return pdmclk->enabled;
    877 }
    878
    879 +static int twl6040_pdmclk_reset_one_clock(struct twl6040_pdmclk *pdmclk,
    880 + unsigned int reg)
    881 +{
    882 + const u8 reset_mask = TWL6040_HPLLRST; /* Same for HPPLL and LPPLL */
    883 + int ret;
    884 +
    885 + ret = twl6040_set_bits(pdmclk->twl6040, reg, reset_mask);
    886 + if (ret < 0)
    887 + return ret;
    888 +
    889 + ret = twl6040_clear_bits(pdmclk->twl6040, reg, reset_mask);
    890 + if (ret < 0)
    891 + return ret;
    892 +
    893 + return 0;
    894 +}
    895 +
    896 +/*
    897 + * TWL6040A2 Phoenix Audio IC erratum #6: "PDM Clock Generation Issue At
    898 + * Cold Temperature". This affects cold boot and deeper idle states it
    899 + * seems. The workaround consists of resetting HPPLL and LPPLL.
    900 + */
    901 +static int twl6040_pdmclk_quirk_reset_clocks(struct twl6040_pdmclk *pdmclk)
    902 +{
    903 + int ret;
    904 +
    905 + ret = twl6040_pdmclk_reset_one_clock(pdmclk, TWL6040_REG_HPPLLCTL);
    906 + if (ret)
    907 + return ret;
    908 +
    909 + ret = twl6040_pdmclk_reset_one_clock(pdmclk, TWL6040_REG_LPPLLCTL);
    910 + if (ret)
    911 + return ret;
    912 +
    913 + return 0;
    914 +}
    915 +
    916 static int twl6040_pdmclk_prepare(struct clk_hw *hw)
    917 {
    918 struct twl6040_pdmclk *pdmclk = container_of(hw, struct twl6040_pdmclk,
    919 @@ -48,8 +85,20 @@ static int twl6040_pdmclk_prepare(struct clk_hw *hw)
    920 int ret;
    921
    922 ret = twl6040_power(pdmclk->twl6040, 1);
    923 - if (!ret)
    924 - pdmclk->enabled = 1;
    925 + if (ret)
    926 + return ret;
    927 +
    928 + ret = twl6040_pdmclk_quirk_reset_clocks(pdmclk);
    929 + if (ret)
    930 + goto out_err;
    931 +
    932 + pdmclk->enabled = 1;
    933 +
    934 + return 0;
    935 +
    936 +out_err:
    937 + dev_err(pdmclk->dev, "%s: error %i\n", __func__, ret);
    938 + twl6040_power(pdmclk->twl6040, 0);
    939
    940 return ret;
    941 }
    942 diff --git a/drivers/clk/ingenic/cgu.c b/drivers/clk/ingenic/cgu.c
    943 index e8248f9185f7..4dec9e9ccffe 100644
    944 --- a/drivers/clk/ingenic/cgu.c
    945 +++ b/drivers/clk/ingenic/cgu.c
    946 @@ -364,16 +364,16 @@ ingenic_clk_round_rate(struct clk_hw *hw, unsigned long req_rate,
    947 struct ingenic_clk *ingenic_clk = to_ingenic_clk(hw);
    948 struct ingenic_cgu *cgu = ingenic_clk->cgu;
    949 const struct ingenic_cgu_clk_info *clk_info;
    950 - long rate = *parent_rate;
    951 + unsigned int div = 1;
    952
    953 clk_info = &cgu->clock_info[ingenic_clk->idx];
    954
    955 if (clk_info->type & CGU_CLK_DIV)
    956 - rate /= ingenic_clk_calc_div(clk_info, *parent_rate, req_rate);
    957 + div = ingenic_clk_calc_div(clk_info, *parent_rate, req_rate);
    958 else if (clk_info->type & CGU_CLK_FIXDIV)
    959 - rate /= clk_info->fixdiv.div;
    960 + div = clk_info->fixdiv.div;
    961
    962 - return rate;
    963 + return DIV_ROUND_UP(*parent_rate, div);
    964 }
    965
    966 static int
    967 @@ -393,7 +393,7 @@ ingenic_clk_set_rate(struct clk_hw *hw, unsigned long req_rate,
    968
    969 if (clk_info->type & CGU_CLK_DIV) {
    970 div = ingenic_clk_calc_div(clk_info, parent_rate, req_rate);
    971 - rate = parent_rate / div;
    972 + rate = DIV_ROUND_UP(parent_rate, div);
    973
    974 if (rate != req_rate)
    975 return -EINVAL;
    976 diff --git a/drivers/clk/ingenic/cgu.h b/drivers/clk/ingenic/cgu.h
    977 index 09700b2c555d..a22f654b2900 100644
    978 --- a/drivers/clk/ingenic/cgu.h
    979 +++ b/drivers/clk/ingenic/cgu.h
    980 @@ -78,7 +78,7 @@ struct ingenic_cgu_mux_info {
    981 * @reg: offset of the divider control register within the CGU
    982 * @shift: number of bits to left shift the divide value by (ie. the index of
    983 * the lowest bit of the divide value within its control register)
    984 - * @div: number of bits to divide the divider value by (i.e. if the
    985 + * @div: number to divide the divider value by (i.e. if the
    986 * effective divider value is the value written to the register
    987 * multiplied by some constant)
    988 * @bits: the size of the divide value in bits
    989 diff --git a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
    990 index 6ea5401e6881..7f1281298651 100644
    991 --- a/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
    992 +++ b/drivers/clk/sunxi-ng/ccu-sun6i-a31.c
    993 @@ -252,9 +252,9 @@ static SUNXI_CCU_GATE(ahb1_mmc1_clk, "ahb1-mmc1", "ahb1",
    994 static SUNXI_CCU_GATE(ahb1_mmc2_clk, "ahb1-mmc2", "ahb1",
    995 0x060, BIT(10), 0);
    996 static SUNXI_CCU_GATE(ahb1_mmc3_clk, "ahb1-mmc3", "ahb1",
    997 - 0x060, BIT(12), 0);
    998 + 0x060, BIT(11), 0);
    999 static SUNXI_CCU_GATE(ahb1_nand1_clk, "ahb1-nand1", "ahb1",
    1000 - 0x060, BIT(13), 0);
    1001 + 0x060, BIT(12), 0);
    1002 static SUNXI_CCU_GATE(ahb1_nand0_clk, "ahb1-nand0", "ahb1",
    1003 0x060, BIT(13), 0);
    1004 static SUNXI_CCU_GATE(ahb1_sdram_clk, "ahb1-sdram", "ahb1",
    1005 diff --git a/drivers/clocksource/exynos_mct.c b/drivers/clocksource/exynos_mct.c
    1006 index 7f6fed9f0703..fb0cf8b74516 100644
    1007 --- a/drivers/clocksource/exynos_mct.c
    1008 +++ b/drivers/clocksource/exynos_mct.c
    1009 @@ -388,6 +388,13 @@ static void exynos4_mct_tick_start(unsigned long cycles,
    1010 exynos4_mct_write(tmp, mevt->base + MCT_L_TCON_OFFSET);
    1011 }
    1012
    1013 +static void exynos4_mct_tick_clear(struct mct_clock_event_device *mevt)
    1014 +{
    1015 + /* Clear the MCT tick interrupt */
    1016 + if (readl_relaxed(reg_base + mevt->base + MCT_L_INT_CSTAT_OFFSET) & 1)
    1017 + exynos4_mct_write(0x1, mevt->base + MCT_L_INT_CSTAT_OFFSET);
    1018 +}
    1019 +
    1020 static int exynos4_tick_set_next_event(unsigned long cycles,
    1021 struct clock_event_device *evt)
    1022 {
    1023 @@ -404,6 +411,7 @@ static int set_state_shutdown(struct clock_event_device *evt)
    1024
    1025 mevt = container_of(evt, struct mct_clock_event_device, evt);
    1026 exynos4_mct_tick_stop(mevt);
    1027 + exynos4_mct_tick_clear(mevt);
    1028 return 0;
    1029 }
    1030
    1031 @@ -420,8 +428,11 @@ static int set_state_periodic(struct clock_event_device *evt)
    1032 return 0;
    1033 }
    1034
    1035 -static void exynos4_mct_tick_clear(struct mct_clock_event_device *mevt)
    1036 +static irqreturn_t exynos4_mct_tick_isr(int irq, void *dev_id)
    1037 {
    1038 + struct mct_clock_event_device *mevt = dev_id;
    1039 + struct clock_event_device *evt = &mevt->evt;
    1040 +
    1041 /*
    1042 * This is for supporting oneshot mode.
    1043 * Mct would generate interrupt periodically
    1044 @@ -430,16 +441,6 @@ static void exynos4_mct_tick_clear(struct mct_clock_event_device *mevt)
    1045 if (!clockevent_state_periodic(&mevt->evt))
    1046 exynos4_mct_tick_stop(mevt);
    1047
    1048 - /* Clear the MCT tick interrupt */
    1049 - if (readl_relaxed(reg_base + mevt->base + MCT_L_INT_CSTAT_OFFSET) & 1)
    1050 - exynos4_mct_write(0x1, mevt->base + MCT_L_INT_CSTAT_OFFSET);
    1051 -}
    1052 -
    1053 -static irqreturn_t exynos4_mct_tick_isr(int irq, void *dev_id)
    1054 -{
    1055 - struct mct_clock_event_device *mevt = dev_id;
    1056 - struct clock_event_device *evt = &mevt->evt;
    1057 -
    1058 exynos4_mct_tick_clear(mevt);
    1059
    1060 evt->event_handler(evt);
    1061 diff --git a/drivers/cpufreq/pxa2xx-cpufreq.c b/drivers/cpufreq/pxa2xx-cpufreq.c
    1062 index ce345bf34d5d..a24e9f037865 100644
    1063 --- a/drivers/cpufreq/pxa2xx-cpufreq.c
    1064 +++ b/drivers/cpufreq/pxa2xx-cpufreq.c
    1065 @@ -192,7 +192,7 @@ static int pxa_cpufreq_change_voltage(const struct pxa_freqs *pxa_freq)
    1066 return ret;
    1067 }
    1068
    1069 -static void __init pxa_cpufreq_init_voltages(void)
    1070 +static void pxa_cpufreq_init_voltages(void)
    1071 {
    1072 vcc_core = regulator_get(NULL, "vcc_core");
    1073 if (IS_ERR(vcc_core)) {
    1074 @@ -208,7 +208,7 @@ static int pxa_cpufreq_change_voltage(const struct pxa_freqs *pxa_freq)
    1075 return 0;
    1076 }
    1077
    1078 -static void __init pxa_cpufreq_init_voltages(void) { }
    1079 +static void pxa_cpufreq_init_voltages(void) { }
    1080 #endif
    1081
    1082 static void find_freq_tables(struct cpufreq_frequency_table **freq_table,
    1083 diff --git a/drivers/cpufreq/tegra124-cpufreq.c b/drivers/cpufreq/tegra124-cpufreq.c
    1084 index 43530254201a..4bb154f6c54c 100644
    1085 --- a/drivers/cpufreq/tegra124-cpufreq.c
    1086 +++ b/drivers/cpufreq/tegra124-cpufreq.c
    1087 @@ -134,6 +134,8 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
    1088
    1089 platform_set_drvdata(pdev, priv);
    1090
    1091 + of_node_put(np);
    1092 +
    1093 return 0;
    1094
    1095 out_switch_to_pllx:
    1096 diff --git a/drivers/crypto/caam/caamalg.c b/drivers/crypto/caam/caamalg.c
    1097 index 0d743c634f25..88caca3370f2 100644
    1098 --- a/drivers/crypto/caam/caamalg.c
    1099 +++ b/drivers/crypto/caam/caamalg.c
    1100 @@ -2131,6 +2131,7 @@ static void init_aead_job(struct aead_request *req,
    1101 if (unlikely(req->src != req->dst)) {
    1102 if (!edesc->dst_nents) {
    1103 dst_dma = sg_dma_address(req->dst);
    1104 + out_options = 0;
    1105 } else {
    1106 dst_dma = edesc->sec4_sg_dma +
    1107 sec4_sg_index *
    1108 diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
    1109 index 6509031098d5..26c4befcd234 100644
    1110 --- a/drivers/gpu/drm/i915/i915_gem.c
    1111 +++ b/drivers/gpu/drm/i915/i915_gem.c
    1112 @@ -1600,7 +1600,8 @@ __vma_matches(struct vm_area_struct *vma, struct file *filp,
    1113 if (vma->vm_file != filp)
    1114 return false;
    1115
    1116 - return vma->vm_start == addr && (vma->vm_end - vma->vm_start) == size;
    1117 + return vma->vm_start == addr &&
    1118 + (vma->vm_end - vma->vm_start) == PAGE_ALIGN(size);
    1119 }
    1120
    1121 /**
    1122 diff --git a/drivers/gpu/drm/radeon/evergreen_cs.c b/drivers/gpu/drm/radeon/evergreen_cs.c
    1123 index d960d3915408..f09388e00523 100644
    1124 --- a/drivers/gpu/drm/radeon/evergreen_cs.c
    1125 +++ b/drivers/gpu/drm/radeon/evergreen_cs.c
    1126 @@ -1299,6 +1299,7 @@ static int evergreen_cs_handle_reg(struct radeon_cs_parser *p, u32 reg, u32 idx)
    1127 return -EINVAL;
    1128 }
    1129 ib[idx] += (u32)((reloc->gpu_offset >> 8) & 0xffffffff);
    1130 + break;
    1131 case CB_TARGET_MASK:
    1132 track->cb_target_mask = radeon_get_ib_value(p, idx);
    1133 track->cb_dirty = true;
    1134 diff --git a/drivers/gpu/ipu-v3/ipu-common.c b/drivers/gpu/ipu-v3/ipu-common.c
    1135 index 99c813a4ec1f..57d22bc963b5 100644
    1136 --- a/drivers/gpu/ipu-v3/ipu-common.c
    1137 +++ b/drivers/gpu/ipu-v3/ipu-common.c
    1138 @@ -884,8 +884,8 @@ static struct ipu_devtype ipu_type_imx51 = {
    1139 .cpmem_ofs = 0x1f000000,
    1140 .srm_ofs = 0x1f040000,
    1141 .tpm_ofs = 0x1f060000,
    1142 - .csi0_ofs = 0x1f030000,
    1143 - .csi1_ofs = 0x1f038000,
    1144 + .csi0_ofs = 0x1e030000,
    1145 + .csi1_ofs = 0x1e038000,
    1146 .ic_ofs = 0x1e020000,
    1147 .disp0_ofs = 0x1e040000,
    1148 .disp1_ofs = 0x1e048000,
    1149 @@ -900,8 +900,8 @@ static struct ipu_devtype ipu_type_imx53 = {
    1150 .cpmem_ofs = 0x07000000,
    1151 .srm_ofs = 0x07040000,
    1152 .tpm_ofs = 0x07060000,
    1153 - .csi0_ofs = 0x07030000,
    1154 - .csi1_ofs = 0x07038000,
    1155 + .csi0_ofs = 0x06030000,
    1156 + .csi1_ofs = 0x06038000,
    1157 .ic_ofs = 0x06020000,
    1158 .disp0_ofs = 0x06040000,
    1159 .disp1_ofs = 0x06048000,
    1160 diff --git a/drivers/hwtracing/intel_th/gth.c b/drivers/hwtracing/intel_th/gth.c
    1161 index 33e09369a491..b0502e2782c1 100644
    1162 --- a/drivers/hwtracing/intel_th/gth.c
    1163 +++ b/drivers/hwtracing/intel_th/gth.c
    1164 @@ -599,11 +599,15 @@ static void intel_th_gth_unassign(struct intel_th_device *thdev,
    1165 {
    1166 struct gth_device *gth = dev_get_drvdata(&thdev->dev);
    1167 int port = othdev->output.port;
    1168 + int master;
    1169
    1170 spin_lock(&gth->gth_lock);
    1171 othdev->output.port = -1;
    1172 othdev->output.active = false;
    1173 gth->output[port].output = NULL;
    1174 + for (master = 0; master < TH_CONFIGURABLE_MASTERS; master++)
    1175 + if (gth->master[master] == port)
    1176 + gth->master[master] = -1;
    1177 spin_unlock(&gth->gth_lock);
    1178 }
    1179
    1180 diff --git a/drivers/hwtracing/stm/core.c b/drivers/hwtracing/stm/core.c
    1181 index c38645106783..3c45c1c15f7e 100644
    1182 --- a/drivers/hwtracing/stm/core.c
    1183 +++ b/drivers/hwtracing/stm/core.c
    1184 @@ -252,6 +252,9 @@ static int find_free_channels(unsigned long *bitmap, unsigned int start,
    1185 ;
    1186 if (i == width)
    1187 return pos;
    1188 +
    1189 + /* step over [pos..pos+i) to continue search */
    1190 + pos += i;
    1191 }
    1192
    1193 return -1;
    1194 @@ -558,7 +561,7 @@ static int stm_char_policy_set_ioctl(struct stm_file *stmf, void __user *arg)
    1195 {
    1196 struct stm_device *stm = stmf->stm;
    1197 struct stp_policy_id *id;
    1198 - int ret = -EINVAL;
    1199 + int ret = -EINVAL, wlimit = 1;
    1200 u32 size;
    1201
    1202 if (stmf->output.nr_chans)
    1203 @@ -586,8 +589,10 @@ static int stm_char_policy_set_ioctl(struct stm_file *stmf, void __user *arg)
    1204 if (id->__reserved_0 || id->__reserved_1)
    1205 goto err_free;
    1206
    1207 - if (id->width < 1 ||
    1208 - id->width > PAGE_SIZE / stm->data->sw_mmiosz)
    1209 + if (stm->data->sw_mmiosz)
    1210 + wlimit = PAGE_SIZE / stm->data->sw_mmiosz;
    1211 +
    1212 + if (id->width < 1 || id->width > wlimit)
    1213 goto err_free;
    1214
    1215 ret = stm_file_assign(stmf, id->id, id->width);
    1216 diff --git a/drivers/i2c/busses/i2c-cadence.c b/drivers/i2c/busses/i2c-cadence.c
    1217 index 45d6771fac8c..59c08d5b75d6 100644
    1218 --- a/drivers/i2c/busses/i2c-cadence.c
    1219 +++ b/drivers/i2c/busses/i2c-cadence.c
    1220 @@ -382,8 +382,10 @@ static void cdns_i2c_mrecv(struct cdns_i2c *id)
    1221 * Check for the message size against FIFO depth and set the
    1222 * 'hold bus' bit if it is greater than FIFO depth.
    1223 */
    1224 - if (id->recv_count > CDNS_I2C_FIFO_DEPTH)
    1225 + if ((id->recv_count > CDNS_I2C_FIFO_DEPTH) || id->bus_hold_flag)
    1226 ctrl_reg |= CDNS_I2C_CR_HOLD;
    1227 + else
    1228 + ctrl_reg = ctrl_reg & ~CDNS_I2C_CR_HOLD;
    1229
    1230 cdns_i2c_writereg(ctrl_reg, CDNS_I2C_CR_OFFSET);
    1231
    1232 @@ -440,8 +442,11 @@ static void cdns_i2c_msend(struct cdns_i2c *id)
    1233 * Check for the message size against FIFO depth and set the
    1234 * 'hold bus' bit if it is greater than FIFO depth.
    1235 */
    1236 - if (id->send_count > CDNS_I2C_FIFO_DEPTH)
    1237 + if ((id->send_count > CDNS_I2C_FIFO_DEPTH) || id->bus_hold_flag)
    1238 ctrl_reg |= CDNS_I2C_CR_HOLD;
    1239 + else
    1240 + ctrl_reg = ctrl_reg & ~CDNS_I2C_CR_HOLD;
    1241 +
    1242 cdns_i2c_writereg(ctrl_reg, CDNS_I2C_CR_OFFSET);
    1243
    1244 /* Clear the interrupts in interrupt status register. */
    1245 diff --git a/drivers/i2c/busses/i2c-tegra.c b/drivers/i2c/busses/i2c-tegra.c
    1246 index 586e557e113a..36100f453f31 100644
    1247 --- a/drivers/i2c/busses/i2c-tegra.c
    1248 +++ b/drivers/i2c/busses/i2c-tegra.c
    1249 @@ -794,7 +794,7 @@ static const struct i2c_algorithm tegra_i2c_algo = {
    1250 /* payload size is only 12 bit */
    1251 static struct i2c_adapter_quirks tegra_i2c_quirks = {
    1252 .max_read_len = 4096,
    1253 - .max_write_len = 4096,
    1254 + .max_write_len = 4096 - 12,
    1255 };
    1256
    1257 static const struct tegra_i2c_hw_feature tegra20_i2c_hw = {
    1258 diff --git a/drivers/iio/adc/exynos_adc.c b/drivers/iio/adc/exynos_adc.c
    1259 index c15756d7bf7f..eb8b735ca12b 100644
    1260 --- a/drivers/iio/adc/exynos_adc.c
    1261 +++ b/drivers/iio/adc/exynos_adc.c
    1262 @@ -916,7 +916,7 @@ static int exynos_adc_remove(struct platform_device *pdev)
    1263 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
    1264 struct exynos_adc *info = iio_priv(indio_dev);
    1265
    1266 - if (IS_REACHABLE(CONFIG_INPUT)) {
    1267 + if (IS_REACHABLE(CONFIG_INPUT) && info->input) {
    1268 free_irq(info->tsirq, info);
    1269 input_unregister_device(info->input);
    1270 }
    1271 diff --git a/drivers/input/keyboard/cap11xx.c b/drivers/input/keyboard/cap11xx.c
    1272 index 4401be225d64..3c53aa5d5c0c 100644
    1273 --- a/drivers/input/keyboard/cap11xx.c
    1274 +++ b/drivers/input/keyboard/cap11xx.c
    1275 @@ -75,9 +75,7 @@
    1276 struct cap11xx_led {
    1277 struct cap11xx_priv *priv;
    1278 struct led_classdev cdev;
    1279 - struct work_struct work;
    1280 u32 reg;
    1281 - enum led_brightness new_brightness;
    1282 };
    1283 #endif
    1284
    1285 @@ -233,30 +231,21 @@ static void cap11xx_input_close(struct input_dev *idev)
    1286 }
    1287
    1288 #ifdef CONFIG_LEDS_CLASS
    1289 -static void cap11xx_led_work(struct work_struct *work)
    1290 +static int cap11xx_led_set(struct led_classdev *cdev,
    1291 + enum led_brightness value)
    1292 {
    1293 - struct cap11xx_led *led = container_of(work, struct cap11xx_led, work);
    1294 + struct cap11xx_led *led = container_of(cdev, struct cap11xx_led, cdev);
    1295 struct cap11xx_priv *priv = led->priv;
    1296 - int value = led->new_brightness;
    1297
    1298 /*
    1299 - * All LEDs share the same duty cycle as this is a HW limitation.
    1300 - * Brightness levels per LED are either 0 (OFF) and 1 (ON).
    1301 + * All LEDs share the same duty cycle as this is a HW
    1302 + * limitation. Brightness levels per LED are either
    1303 + * 0 (OFF) and 1 (ON).
    1304 */
    1305 - regmap_update_bits(priv->regmap, CAP11XX_REG_LED_OUTPUT_CONTROL,
    1306 - BIT(led->reg), value ? BIT(led->reg) : 0);
    1307 -}
    1308 -
    1309 -static void cap11xx_led_set(struct led_classdev *cdev,
    1310 - enum led_brightness value)
    1311 -{
    1312 - struct cap11xx_led *led = container_of(cdev, struct cap11xx_led, cdev);
    1313 -
    1314 - if (led->new_brightness == value)
    1315 - return;
    1316 -
    1317 - led->new_brightness = value;
    1318 - schedule_work(&led->work);
    1319 + return regmap_update_bits(priv->regmap,
    1320 + CAP11XX_REG_LED_OUTPUT_CONTROL,
    1321 + BIT(led->reg),
    1322 + value ? BIT(led->reg) : 0);
    1323 }
    1324
    1325 static int cap11xx_init_leds(struct device *dev,
    1326 @@ -299,7 +288,7 @@ static int cap11xx_init_leds(struct device *dev,
    1327 led->cdev.default_trigger =
    1328 of_get_property(child, "linux,default-trigger", NULL);
    1329 led->cdev.flags = 0;
    1330 - led->cdev.brightness_set = cap11xx_led_set;
    1331 + led->cdev.brightness_set_blocking = cap11xx_led_set;
    1332 led->cdev.max_brightness = 1;
    1333 led->cdev.brightness = LED_OFF;
    1334
    1335 @@ -312,8 +301,6 @@ static int cap11xx_init_leds(struct device *dev,
    1336 led->reg = reg;
    1337 led->priv = priv;
    1338
    1339 - INIT_WORK(&led->work, cap11xx_led_work);
    1340 -
    1341 error = devm_led_classdev_register(dev, &led->cdev);
    1342 if (error) {
    1343 of_node_put(child);
    1344 diff --git a/drivers/input/keyboard/matrix_keypad.c b/drivers/input/keyboard/matrix_keypad.c
    1345 index c64d87442a62..2e12e31f45c5 100644
    1346 --- a/drivers/input/keyboard/matrix_keypad.c
    1347 +++ b/drivers/input/keyboard/matrix_keypad.c
    1348 @@ -220,7 +220,7 @@ static void matrix_keypad_stop(struct input_dev *dev)
    1349 keypad->stopped = true;
    1350 spin_unlock_irq(&keypad->lock);
    1351
    1352 - flush_work(&keypad->work.work);
    1353 + flush_delayed_work(&keypad->work);
    1354 /*
    1355 * matrix_keypad_scan() will leave IRQs enabled;
    1356 * we should disable them now.
    1357 diff --git a/drivers/input/keyboard/st-keyscan.c b/drivers/input/keyboard/st-keyscan.c
    1358 index de7be4f03d91..ebf9f643d910 100644
    1359 --- a/drivers/input/keyboard/st-keyscan.c
    1360 +++ b/drivers/input/keyboard/st-keyscan.c
    1361 @@ -153,6 +153,8 @@ static int keyscan_probe(struct platform_device *pdev)
    1362
    1363 input_dev->id.bustype = BUS_HOST;
    1364
    1365 + keypad_data->input_dev = input_dev;
    1366 +
    1367 error = keypad_matrix_key_parse_dt(keypad_data);
    1368 if (error)
    1369 return error;
    1370 @@ -168,8 +170,6 @@ static int keyscan_probe(struct platform_device *pdev)
    1371
    1372 input_set_drvdata(input_dev, keypad_data);
    1373
    1374 - keypad_data->input_dev = input_dev;
    1375 -
    1376 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    1377 keypad_data->base = devm_ioremap_resource(&pdev->dev, res);
    1378 if (IS_ERR(keypad_data->base))
    1379 diff --git a/drivers/md/bcache/writeback.h b/drivers/md/bcache/writeback.h
    1380 index cdf8d253209e..6fb6dd600970 100644
    1381 --- a/drivers/md/bcache/writeback.h
    1382 +++ b/drivers/md/bcache/writeback.h
    1383 @@ -68,6 +68,9 @@ static inline bool should_writeback(struct cached_dev *dc, struct bio *bio,
    1384 in_use > CUTOFF_WRITEBACK_SYNC)
    1385 return false;
    1386
    1387 + if (bio_op(bio) == REQ_OP_DISCARD)
    1388 + return false;
    1389 +
    1390 if (dc->partial_stripes_expensive &&
    1391 bcache_dev_stripe_dirty(dc, bio->bi_iter.bi_sector,
    1392 bio_sectors(bio)))
    1393 diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
    1394 index 67414616eb35..717787d09e0f 100644
    1395 --- a/drivers/md/raid10.c
    1396 +++ b/drivers/md/raid10.c
    1397 @@ -3798,6 +3798,8 @@ static int raid10_run(struct mddev *mddev)
    1398 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
    1399 mddev->sync_thread = md_register_thread(md_do_sync, mddev,
    1400 "reshape");
    1401 + if (!mddev->sync_thread)
    1402 + goto out_free_conf;
    1403 }
    1404
    1405 return 0;
    1406 diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
    1407 index 4afc419da60f..9ec74dfe94f4 100644
    1408 --- a/drivers/md/raid5.c
    1409 +++ b/drivers/md/raid5.c
    1410 @@ -6977,6 +6977,8 @@ static int raid5_run(struct mddev *mddev)
    1411 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
    1412 mddev->sync_thread = md_register_thread(md_do_sync, mddev,
    1413 "reshape");
    1414 + if (!mddev->sync_thread)
    1415 + goto abort;
    1416 }
    1417
    1418 /* Ok, everything is just fine now */
    1419 diff --git a/drivers/media/usb/uvc/uvc_video.c b/drivers/media/usb/uvc/uvc_video.c
    1420 index 48503f30b3a2..dcca723f7155 100644
    1421 --- a/drivers/media/usb/uvc/uvc_video.c
    1422 +++ b/drivers/media/usb/uvc/uvc_video.c
    1423 @@ -638,6 +638,14 @@ void uvc_video_clock_update(struct uvc_streaming *stream,
    1424 if (!uvc_hw_timestamps_param)
    1425 return;
    1426
    1427 + /*
    1428 + * We will get called from __vb2_queue_cancel() if there are buffers
    1429 + * done but not dequeued by the user, but the sample array has already
    1430 + * been released at that time. Just bail out in that case.
    1431 + */
    1432 + if (!clock->samples)
    1433 + return;
    1434 +
    1435 spin_lock_irqsave(&clock->lock, flags);
    1436
    1437 if (clock->count < clock->size)
    1438 diff --git a/drivers/media/v4l2-core/videobuf2-v4l2.c b/drivers/media/v4l2-core/videobuf2-v4l2.c
    1439 index 52ef8833f6b6..7e45da4d52e1 100644
    1440 --- a/drivers/media/v4l2-core/videobuf2-v4l2.c
    1441 +++ b/drivers/media/v4l2-core/videobuf2-v4l2.c
    1442 @@ -146,7 +146,6 @@ static void vb2_warn_zero_bytesused(struct vb2_buffer *vb)
    1443 return;
    1444
    1445 check_once = true;
    1446 - WARN_ON(1);
    1447
    1448 pr_warn("use of bytesused == 0 is deprecated and will be removed in the future,\n");
    1449 if (vb->vb2_queue->allow_zero_bytesused)
    1450 diff --git a/drivers/net/ethernet/atheros/atlx/atl2.c b/drivers/net/ethernet/atheros/atlx/atl2.c
    1451 index 2ff465848b65..097a0bf592ab 100644
    1452 --- a/drivers/net/ethernet/atheros/atlx/atl2.c
    1453 +++ b/drivers/net/ethernet/atheros/atlx/atl2.c
    1454 @@ -1338,13 +1338,11 @@ static int atl2_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
    1455 {
    1456 struct net_device *netdev;
    1457 struct atl2_adapter *adapter;
    1458 - static int cards_found;
    1459 + static int cards_found = 0;
    1460 unsigned long mmio_start;
    1461 int mmio_len;
    1462 int err;
    1463
    1464 - cards_found = 0;
    1465 -
    1466 err = pci_enable_device(pdev);
    1467 if (err)
    1468 return err;
    1469 diff --git a/drivers/net/ethernet/broadcom/bcmsysport.c b/drivers/net/ethernet/broadcom/bcmsysport.c
    1470 index 53a506b0d790..95874c10c23b 100644
    1471 --- a/drivers/net/ethernet/broadcom/bcmsysport.c
    1472 +++ b/drivers/net/ethernet/broadcom/bcmsysport.c
    1473 @@ -104,6 +104,10 @@ static int bcm_sysport_set_rx_csum(struct net_device *dev,
    1474
    1475 priv->rx_chk_en = !!(wanted & NETIF_F_RXCSUM);
    1476 reg = rxchk_readl(priv, RXCHK_CONTROL);
    1477 + /* Clear L2 header checks, which would prevent BPDUs
    1478 + * from being received.
    1479 + */
    1480 + reg &= ~RXCHK_L2_HDR_DIS;
    1481 if (priv->rx_chk_en)
    1482 reg |= RXCHK_EN;
    1483 else
    1484 diff --git a/drivers/net/ethernet/cavium/thunder/nic_main.c b/drivers/net/ethernet/cavium/thunder/nic_main.c
    1485 index da142f6bd0c3..18ddd243dfa1 100644
    1486 --- a/drivers/net/ethernet/cavium/thunder/nic_main.c
    1487 +++ b/drivers/net/ethernet/cavium/thunder/nic_main.c
    1488 @@ -999,7 +999,7 @@ static void nic_handle_mbx_intr(struct nicpf *nic, int vf)
    1489 case NIC_MBOX_MSG_CFG_DONE:
    1490 /* Last message of VF config msg sequence */
    1491 nic_enable_vf(nic, vf, true);
    1492 - goto unlock;
    1493 + break;
    1494 case NIC_MBOX_MSG_SHUTDOWN:
    1495 /* First msg in VF teardown sequence */
    1496 if (vf >= nic->num_vf_en)
    1497 diff --git a/drivers/net/ethernet/cavium/thunder/nicvf_main.c b/drivers/net/ethernet/cavium/thunder/nicvf_main.c
    1498 index c75d4ea9342b..71f228cece03 100644
    1499 --- a/drivers/net/ethernet/cavium/thunder/nicvf_main.c
    1500 +++ b/drivers/net/ethernet/cavium/thunder/nicvf_main.c
    1501 @@ -162,6 +162,17 @@ static int nicvf_check_pf_ready(struct nicvf *nic)
    1502 return 1;
    1503 }
    1504
    1505 +static void nicvf_send_cfg_done(struct nicvf *nic)
    1506 +{
    1507 + union nic_mbx mbx = {};
    1508 +
    1509 + mbx.msg.msg = NIC_MBOX_MSG_CFG_DONE;
    1510 + if (nicvf_send_msg_to_pf(nic, &mbx)) {
    1511 + netdev_err(nic->netdev,
    1512 + "PF didn't respond to CFG DONE msg\n");
    1513 + }
    1514 +}
    1515 +
    1516 static void nicvf_read_bgx_stats(struct nicvf *nic, struct bgx_stats_msg *bgx)
    1517 {
    1518 if (bgx->rx)
    1519 @@ -1178,7 +1189,6 @@ int nicvf_open(struct net_device *netdev)
    1520 struct nicvf *nic = netdev_priv(netdev);
    1521 struct queue_set *qs = nic->qs;
    1522 struct nicvf_cq_poll *cq_poll = NULL;
    1523 - union nic_mbx mbx = {};
    1524
    1525 netif_carrier_off(netdev);
    1526
    1527 @@ -1267,8 +1277,7 @@ int nicvf_open(struct net_device *netdev)
    1528 nicvf_enable_intr(nic, NICVF_INTR_RBDR, qidx);
    1529
    1530 /* Send VF config done msg to PF */
    1531 - mbx.msg.msg = NIC_MBOX_MSG_CFG_DONE;
    1532 - nicvf_write_to_mbx(nic, &mbx);
    1533 + nicvf_send_cfg_done(nic);
    1534
    1535 return 0;
    1536 cleanup:
    1537 diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
    1538 index 5bb019d49409..551b2a9ebf0f 100644
    1539 --- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
    1540 +++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
    1541 @@ -2820,6 +2820,7 @@ int hns_dsaf_roce_reset(struct fwnode_handle *dsaf_fwnode, bool dereset)
    1542 dsaf_dev = dev_get_drvdata(&pdev->dev);
    1543 if (!dsaf_dev) {
    1544 dev_err(&pdev->dev, "dsaf_dev is NULL\n");
    1545 + put_device(&pdev->dev);
    1546 return -ENODEV;
    1547 }
    1548
    1549 @@ -2827,6 +2828,7 @@ int hns_dsaf_roce_reset(struct fwnode_handle *dsaf_fwnode, bool dereset)
    1550 if (AE_IS_VER1(dsaf_dev->dsaf_ver)) {
    1551 dev_err(dsaf_dev->dev, "%s v1 chip doesn't support RoCE!\n",
    1552 dsaf_dev->ae_dev.name);
    1553 + put_device(&pdev->dev);
    1554 return -ENODEV;
    1555 }
    1556
    1557 diff --git a/drivers/net/ethernet/marvell/mv643xx_eth.c b/drivers/net/ethernet/marvell/mv643xx_eth.c
    1558 index 5b12022adf1f..526d07e02bbc 100644
    1559 --- a/drivers/net/ethernet/marvell/mv643xx_eth.c
    1560 +++ b/drivers/net/ethernet/marvell/mv643xx_eth.c
    1561 @@ -2886,7 +2886,7 @@ static int mv643xx_eth_shared_probe(struct platform_device *pdev)
    1562
    1563 ret = mv643xx_eth_shared_of_probe(pdev);
    1564 if (ret)
    1565 - return ret;
    1566 + goto err_put_clk;
    1567 pd = dev_get_platdata(&pdev->dev);
    1568
    1569 msp->tx_csum_limit = (pd != NULL && pd->tx_csum_limit) ?
    1570 @@ -2894,6 +2894,11 @@ static int mv643xx_eth_shared_probe(struct platform_device *pdev)
    1571 infer_hw_params(msp);
    1572
    1573 return 0;
    1574 +
    1575 +err_put_clk:
    1576 + if (!IS_ERR(msp->clk))
    1577 + clk_disable_unprepare(msp->clk);
    1578 + return ret;
    1579 }
    1580
    1581 static int mv643xx_eth_shared_remove(struct platform_device *pdev)
    1582 diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
    1583 index c92ffdf91065..d98b874a7238 100644
    1584 --- a/drivers/net/ethernet/marvell/mvneta.c
    1585 +++ b/drivers/net/ethernet/marvell/mvneta.c
    1586 @@ -2050,7 +2050,7 @@ err_drop_frame:
    1587 if (unlikely(!skb))
    1588 goto err_drop_frame_ret_pool;
    1589
    1590 - dma_sync_single_range_for_cpu(dev->dev.parent,
    1591 + dma_sync_single_range_for_cpu(&pp->bm_priv->pdev->dev,
    1592 rx_desc->buf_phys_addr,
    1593 MVNETA_MH_SIZE + NET_SKB_PAD,
    1594 rx_bytes,
    1595 diff --git a/drivers/net/ethernet/netronome/nfp/nfp_bpf_jit.c b/drivers/net/ethernet/netronome/nfp/nfp_bpf_jit.c
    1596 index f8df5300f49c..73087770d72f 100644
    1597 --- a/drivers/net/ethernet/netronome/nfp/nfp_bpf_jit.c
    1598 +++ b/drivers/net/ethernet/netronome/nfp/nfp_bpf_jit.c
    1599 @@ -756,15 +756,10 @@ wrp_alu64_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
    1600
    1601 static int
    1602 wrp_alu32_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
    1603 - enum alu_op alu_op, bool skip)
    1604 + enum alu_op alu_op)
    1605 {
    1606 const struct bpf_insn *insn = &meta->insn;
    1607
    1608 - if (skip) {
    1609 - meta->skip = true;
    1610 - return 0;
    1611 - }
    1612 -
    1613 wrp_alu_imm(nfp_prog, insn->dst_reg * 2, alu_op, insn->imm);
    1614 wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2 + 1), 0);
    1615
    1616 @@ -1017,7 +1012,7 @@ static int xor_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1617
    1618 static int xor_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1619 {
    1620 - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_XOR, !~meta->insn.imm);
    1621 + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_XOR);
    1622 }
    1623
    1624 static int and_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1625 @@ -1027,7 +1022,7 @@ static int and_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1626
    1627 static int and_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1628 {
    1629 - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_AND, !~meta->insn.imm);
    1630 + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_AND);
    1631 }
    1632
    1633 static int or_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1634 @@ -1037,7 +1032,7 @@ static int or_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1635
    1636 static int or_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1637 {
    1638 - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_OR, !meta->insn.imm);
    1639 + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_OR);
    1640 }
    1641
    1642 static int add_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1643 @@ -1047,7 +1042,7 @@ static int add_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1644
    1645 static int add_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1646 {
    1647 - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_ADD, !meta->insn.imm);
    1648 + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_ADD);
    1649 }
    1650
    1651 static int sub_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1652 @@ -1057,7 +1052,7 @@ static int sub_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1653
    1654 static int sub_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1655 {
    1656 - return wrp_alu32_imm(nfp_prog, meta, ALU_OP_SUB, !meta->insn.imm);
    1657 + return wrp_alu32_imm(nfp_prog, meta, ALU_OP_SUB);
    1658 }
    1659
    1660 static int shl_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
    1661 diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
    1662 index 134eb184fa22..16e5c8cd104d 100644
    1663 --- a/drivers/net/usb/qmi_wwan.c
    1664 +++ b/drivers/net/usb/qmi_wwan.c
    1665 @@ -895,8 +895,8 @@ static const struct usb_device_id products[] = {
    1666 {QMI_FIXED_INTF(0x114f, 0x68a2, 8)}, /* Sierra Wireless MC7750 */
    1667 {QMI_FIXED_INTF(0x1199, 0x68a2, 8)}, /* Sierra Wireless MC7710 in QMI mode */
    1668 {QMI_FIXED_INTF(0x1199, 0x68a2, 19)}, /* Sierra Wireless MC7710 in QMI mode */
    1669 - {QMI_FIXED_INTF(0x1199, 0x68c0, 8)}, /* Sierra Wireless MC7304/MC7354 */
    1670 - {QMI_FIXED_INTF(0x1199, 0x68c0, 10)}, /* Sierra Wireless MC7304/MC7354 */
    1671 + {QMI_QUIRK_SET_DTR(0x1199, 0x68c0, 8)}, /* Sierra Wireless MC7304/MC7354, WP76xx */
    1672 + {QMI_QUIRK_SET_DTR(0x1199, 0x68c0, 10)},/* Sierra Wireless MC7304/MC7354 */
    1673 {QMI_FIXED_INTF(0x1199, 0x901c, 8)}, /* Sierra Wireless EM7700 */
    1674 {QMI_FIXED_INTF(0x1199, 0x901f, 8)}, /* Sierra Wireless EM7355 */
    1675 {QMI_FIXED_INTF(0x1199, 0x9041, 8)}, /* Sierra Wireless MC7305/MC7355 */
    1676 diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c
    1677 index 780acf23fd19..e9ec1da9935d 100644
    1678 --- a/drivers/net/wireless/mac80211_hwsim.c
    1679 +++ b/drivers/net/wireless/mac80211_hwsim.c
    1680 @@ -3167,7 +3167,7 @@ static int hwsim_get_radio_nl(struct sk_buff *msg, struct genl_info *info)
    1681 goto out_err;
    1682 }
    1683
    1684 - genlmsg_reply(skb, info);
    1685 + res = genlmsg_reply(skb, info);
    1686 break;
    1687 }
    1688
    1689 diff --git a/drivers/net/wireless/marvell/libertas_tf/if_usb.c b/drivers/net/wireless/marvell/libertas_tf/if_usb.c
    1690 index e0ade40d9497..4b539209999b 100644
    1691 --- a/drivers/net/wireless/marvell/libertas_tf/if_usb.c
    1692 +++ b/drivers/net/wireless/marvell/libertas_tf/if_usb.c
    1693 @@ -433,8 +433,6 @@ static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
    1694 skb_tail_pointer(skb),
    1695 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn, cardp);
    1696
    1697 - cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET;
    1698 -
    1699 lbtf_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n",
    1700 cardp->rx_urb);
    1701 ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC);
    1702 diff --git a/drivers/nvdimm/label.c b/drivers/nvdimm/label.c
    1703 index d8d189d14834..66a089d561cf 100644
    1704 --- a/drivers/nvdimm/label.c
    1705 +++ b/drivers/nvdimm/label.c
    1706 @@ -492,7 +492,7 @@ static unsigned long nd_label_offset(struct nvdimm_drvdata *ndd,
    1707
    1708 static int __pmem_label_update(struct nd_region *nd_region,
    1709 struct nd_mapping *nd_mapping, struct nd_namespace_pmem *nspm,
    1710 - int pos)
    1711 + int pos, unsigned long flags)
    1712 {
    1713 u64 cookie = nd_region_interleave_set_cookie(nd_region);
    1714 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
    1715 @@ -530,7 +530,7 @@ static int __pmem_label_update(struct nd_region *nd_region,
    1716 memcpy(nd_label->uuid, nspm->uuid, NSLABEL_UUID_LEN);
    1717 if (nspm->alt_name)
    1718 memcpy(nd_label->name, nspm->alt_name, NSLABEL_NAME_LEN);
    1719 - nd_label->flags = __cpu_to_le32(NSLABEL_FLAG_UPDATING);
    1720 + nd_label->flags = __cpu_to_le32(flags);
    1721 nd_label->nlabel = __cpu_to_le16(nd_region->ndr_mappings);
    1722 nd_label->position = __cpu_to_le16(pos);
    1723 nd_label->isetcookie = __cpu_to_le64(cookie);
    1724 @@ -922,13 +922,13 @@ static int del_labels(struct nd_mapping *nd_mapping, u8 *uuid)
    1725 int nd_pmem_namespace_label_update(struct nd_region *nd_region,
    1726 struct nd_namespace_pmem *nspm, resource_size_t size)
    1727 {
    1728 - int i;
    1729 + int i, rc;
    1730
    1731 for (i = 0; i < nd_region->ndr_mappings; i++) {
    1732 struct nd_mapping *nd_mapping = &nd_region->mapping[i];
    1733 struct nvdimm_drvdata *ndd = to_ndd(nd_mapping);
    1734 struct resource *res;
    1735 - int rc, count = 0;
    1736 + int count = 0;
    1737
    1738 if (size == 0) {
    1739 rc = del_labels(nd_mapping, nspm->uuid);
    1740 @@ -946,7 +946,20 @@ int nd_pmem_namespace_label_update(struct nd_region *nd_region,
    1741 if (rc < 0)
    1742 return rc;
    1743
    1744 - rc = __pmem_label_update(nd_region, nd_mapping, nspm, i);
    1745 + rc = __pmem_label_update(nd_region, nd_mapping, nspm, i,
    1746 + NSLABEL_FLAG_UPDATING);
    1747 + if (rc)
    1748 + return rc;
    1749 + }
    1750 +
    1751 + if (size == 0)
    1752 + return 0;
    1753 +
    1754 + /* Clear the UPDATING flag per UEFI 2.7 expectations */
    1755 + for (i = 0; i < nd_region->ndr_mappings; i++) {
    1756 + struct nd_mapping *nd_mapping = &nd_region->mapping[i];
    1757 +
    1758 + rc = __pmem_label_update(nd_region, nd_mapping, nspm, i, 0);
    1759 if (rc)
    1760 return rc;
    1761 }
    1762 diff --git a/drivers/nvdimm/namespace_devs.c b/drivers/nvdimm/namespace_devs.c
    1763 index 74257ac92490..9bc5f555ee68 100644
    1764 --- a/drivers/nvdimm/namespace_devs.c
    1765 +++ b/drivers/nvdimm/namespace_devs.c
    1766 @@ -138,6 +138,7 @@ bool nd_is_uuid_unique(struct device *dev, u8 *uuid)
    1767 bool pmem_should_map_pages(struct device *dev)
    1768 {
    1769 struct nd_region *nd_region = to_nd_region(dev->parent);
    1770 + struct nd_namespace_common *ndns = to_ndns(dev);
    1771 struct nd_namespace_io *nsio;
    1772
    1773 if (!IS_ENABLED(CONFIG_ZONE_DEVICE))
    1774 @@ -149,6 +150,9 @@ bool pmem_should_map_pages(struct device *dev)
    1775 if (is_nd_pfn(dev) || is_nd_btt(dev))
    1776 return false;
    1777
    1778 + if (ndns->force_raw)
    1779 + return false;
    1780 +
    1781 nsio = to_nd_namespace_io(dev);
    1782 if (region_intersects(nsio->res.start, resource_size(&nsio->res),
    1783 IORESOURCE_SYSTEM_RAM,
    1784 diff --git a/drivers/nvdimm/pfn_devs.c b/drivers/nvdimm/pfn_devs.c
    1785 index d6aa59ca68b9..ba9aa8475e6d 100644
    1786 --- a/drivers/nvdimm/pfn_devs.c
    1787 +++ b/drivers/nvdimm/pfn_devs.c
    1788 @@ -515,7 +515,7 @@ static unsigned long init_altmap_base(resource_size_t base)
    1789
    1790 static unsigned long init_altmap_reserve(resource_size_t base)
    1791 {
    1792 - unsigned long reserve = PHYS_PFN(SZ_8K);
    1793 + unsigned long reserve = PFN_UP(SZ_8K);
    1794 unsigned long base_pfn = PHYS_PFN(base);
    1795
    1796 reserve += base_pfn - PFN_SECTION_ALIGN_DOWN(base_pfn);
    1797 diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
    1798 index bdce0679674c..02e6485c1ed5 100644
    1799 --- a/drivers/parport/parport_pc.c
    1800 +++ b/drivers/parport/parport_pc.c
    1801 @@ -1377,7 +1377,7 @@ static struct superio_struct *find_superio(struct parport *p)
    1802 {
    1803 int i;
    1804 for (i = 0; i < NR_SUPERIOS; i++)
    1805 - if (superios[i].io != p->base)
    1806 + if (superios[i].io == p->base)
    1807 return &superios[i];
    1808 return NULL;
    1809 }
    1810 diff --git a/drivers/pinctrl/meson/pinctrl-meson8b.c b/drivers/pinctrl/meson/pinctrl-meson8b.c
    1811 index cbe5f5cbddb8..e1b689f840ab 100644
    1812 --- a/drivers/pinctrl/meson/pinctrl-meson8b.c
    1813 +++ b/drivers/pinctrl/meson/pinctrl-meson8b.c
    1814 @@ -662,7 +662,7 @@ static const char * const sd_a_groups[] = {
    1815
    1816 static const char * const sdxc_a_groups[] = {
    1817 "sdxc_d0_0_a", "sdxc_d13_0_a", "sdxc_d47_a", "sdxc_clk_a",
    1818 - "sdxc_cmd_a", "sdxc_d0_1_a", "sdxc_d0_13_1_a"
    1819 + "sdxc_cmd_a", "sdxc_d0_1_a", "sdxc_d13_1_a"
    1820 };
    1821
    1822 static const char * const pcm_a_groups[] = {
    1823 diff --git a/drivers/regulator/s2mpa01.c b/drivers/regulator/s2mpa01.c
    1824 index 92f88753bfed..2daf751c26c7 100644
    1825 --- a/drivers/regulator/s2mpa01.c
    1826 +++ b/drivers/regulator/s2mpa01.c
    1827 @@ -303,13 +303,13 @@ static const struct regulator_desc regulators[] = {
    1828 regulator_desc_ldo(2, STEP_50_MV),
    1829 regulator_desc_ldo(3, STEP_50_MV),
    1830 regulator_desc_ldo(4, STEP_50_MV),
    1831 - regulator_desc_ldo(5, STEP_50_MV),
    1832 + regulator_desc_ldo(5, STEP_25_MV),
    1833 regulator_desc_ldo(6, STEP_25_MV),
    1834 regulator_desc_ldo(7, STEP_50_MV),
    1835 regulator_desc_ldo(8, STEP_50_MV),
    1836 regulator_desc_ldo(9, STEP_50_MV),
    1837 regulator_desc_ldo(10, STEP_50_MV),
    1838 - regulator_desc_ldo(11, STEP_25_MV),
    1839 + regulator_desc_ldo(11, STEP_50_MV),
    1840 regulator_desc_ldo(12, STEP_50_MV),
    1841 regulator_desc_ldo(13, STEP_50_MV),
    1842 regulator_desc_ldo(14, STEP_50_MV),
    1843 @@ -320,11 +320,11 @@ static const struct regulator_desc regulators[] = {
    1844 regulator_desc_ldo(19, STEP_50_MV),
    1845 regulator_desc_ldo(20, STEP_50_MV),
    1846 regulator_desc_ldo(21, STEP_50_MV),
    1847 - regulator_desc_ldo(22, STEP_25_MV),
    1848 - regulator_desc_ldo(23, STEP_25_MV),
    1849 + regulator_desc_ldo(22, STEP_50_MV),
    1850 + regulator_desc_ldo(23, STEP_50_MV),
    1851 regulator_desc_ldo(24, STEP_50_MV),
    1852 regulator_desc_ldo(25, STEP_50_MV),
    1853 - regulator_desc_ldo(26, STEP_50_MV),
    1854 + regulator_desc_ldo(26, STEP_25_MV),
    1855 regulator_desc_buck1_4(1),
    1856 regulator_desc_buck1_4(2),
    1857 regulator_desc_buck1_4(3),
    1858 diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
    1859 index d838e77dd947..1fe1c18cc27b 100644
    1860 --- a/drivers/regulator/s2mps11.c
    1861 +++ b/drivers/regulator/s2mps11.c
    1862 @@ -376,7 +376,7 @@ static const struct regulator_desc s2mps11_regulators[] = {
    1863 regulator_desc_s2mps11_ldo(32, STEP_50_MV),
    1864 regulator_desc_s2mps11_ldo(33, STEP_50_MV),
    1865 regulator_desc_s2mps11_ldo(34, STEP_50_MV),
    1866 - regulator_desc_s2mps11_ldo(35, STEP_50_MV),
    1867 + regulator_desc_s2mps11_ldo(35, STEP_25_MV),
    1868 regulator_desc_s2mps11_ldo(36, STEP_50_MV),
    1869 regulator_desc_s2mps11_ldo(37, STEP_50_MV),
    1870 regulator_desc_s2mps11_ldo(38, STEP_50_MV),
    1871 @@ -386,8 +386,8 @@ static const struct regulator_desc s2mps11_regulators[] = {
    1872 regulator_desc_s2mps11_buck1_4(4),
    1873 regulator_desc_s2mps11_buck5,
    1874 regulator_desc_s2mps11_buck67810(6, MIN_600_MV, STEP_6_25_MV),
    1875 - regulator_desc_s2mps11_buck67810(7, MIN_600_MV, STEP_6_25_MV),
    1876 - regulator_desc_s2mps11_buck67810(8, MIN_600_MV, STEP_6_25_MV),
    1877 + regulator_desc_s2mps11_buck67810(7, MIN_600_MV, STEP_12_5_MV),
    1878 + regulator_desc_s2mps11_buck67810(8, MIN_600_MV, STEP_12_5_MV),
    1879 regulator_desc_s2mps11_buck9,
    1880 regulator_desc_s2mps11_buck67810(10, MIN_750_MV, STEP_12_5_MV),
    1881 };
    1882 diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
    1883 index be17de9807b6..11c6335b1951 100644
    1884 --- a/drivers/s390/block/dasd_eckd.c
    1885 +++ b/drivers/s390/block/dasd_eckd.c
    1886 @@ -4508,6 +4508,14 @@ static int dasd_symm_io(struct dasd_device *device, void __user *argp)
    1887 usrparm.psf_data &= 0x7fffffffULL;
    1888 usrparm.rssd_result &= 0x7fffffffULL;
    1889 }
    1890 + /* at least 2 bytes are accessed and should be allocated */
    1891 + if (usrparm.psf_data_len < 2) {
    1892 + DBF_DEV_EVENT(DBF_WARNING, device,
    1893 + "Symmetrix ioctl invalid data length %d",
    1894 + usrparm.psf_data_len);
    1895 + rc = -EINVAL;
    1896 + goto out;
    1897 + }
    1898 /* alloc I/O data area */
    1899 psf_data = kzalloc(usrparm.psf_data_len, GFP_KERNEL | GFP_DMA);
    1900 rssd_result = kzalloc(usrparm.rssd_result_len, GFP_KERNEL | GFP_DMA);
    1901 diff --git a/drivers/s390/virtio/virtio_ccw.c b/drivers/s390/virtio/virtio_ccw.c
    1902 index 3493d449911c..d5e510ff5437 100644
    1903 --- a/drivers/s390/virtio/virtio_ccw.c
    1904 +++ b/drivers/s390/virtio/virtio_ccw.c
    1905 @@ -283,6 +283,8 @@ static void virtio_ccw_drop_indicators(struct virtio_ccw_device *vcdev)
    1906 {
    1907 struct virtio_ccw_vq_info *info;
    1908
    1909 + if (!vcdev->airq_info)
    1910 + return;
    1911 list_for_each_entry(info, &vcdev->virtqueues, node)
    1912 drop_airq_indicator(info->vq, vcdev->airq_info);
    1913 }
    1914 @@ -424,7 +426,7 @@ static int virtio_ccw_read_vq_conf(struct virtio_ccw_device *vcdev,
    1915 ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_VQ_CONF);
    1916 if (ret)
    1917 return ret;
    1918 - return vcdev->config_block->num;
    1919 + return vcdev->config_block->num ?: -ENOENT;
    1920 }
    1921
    1922 static void virtio_ccw_del_vq(struct virtqueue *vq, struct ccw1 *ccw)
    1923 diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
    1924 index c79743de48f9..2ffe10453e30 100644
    1925 --- a/drivers/scsi/libiscsi.c
    1926 +++ b/drivers/scsi/libiscsi.c
    1927 @@ -1448,7 +1448,13 @@ static int iscsi_xmit_task(struct iscsi_conn *conn)
    1928 if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx))
    1929 return -ENODATA;
    1930
    1931 + spin_lock_bh(&conn->session->back_lock);
    1932 + if (conn->task == NULL) {
    1933 + spin_unlock_bh(&conn->session->back_lock);
    1934 + return -ENODATA;
    1935 + }
    1936 __iscsi_get_task(task);
    1937 + spin_unlock_bh(&conn->session->back_lock);
    1938 spin_unlock_bh(&conn->session->frwd_lock);
    1939 rc = conn->session->tt->xmit_task(task);
    1940 spin_lock_bh(&conn->session->frwd_lock);
    1941 diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
    1942 index 867ae76f93f2..3e9cbba41464 100644
    1943 --- a/drivers/scsi/sd.c
    1944 +++ b/drivers/scsi/sd.c
    1945 @@ -2834,6 +2834,55 @@ static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
    1946 sdkp->ws10 = 1;
    1947 }
    1948
    1949 +/*
    1950 + * Determine the device's preferred I/O size for reads and writes
    1951 + * unless the reported value is unreasonably small, large, not a
    1952 + * multiple of the physical block size, or simply garbage.
    1953 + */
    1954 +static bool sd_validate_opt_xfer_size(struct scsi_disk *sdkp,
    1955 + unsigned int dev_max)
    1956 +{
    1957 + struct scsi_device *sdp = sdkp->device;
    1958 + unsigned int opt_xfer_bytes =
    1959 + logical_to_bytes(sdp, sdkp->opt_xfer_blocks);
    1960 +
    1961 + if (sdkp->opt_xfer_blocks > dev_max) {
    1962 + sd_first_printk(KERN_WARNING, sdkp,
    1963 + "Optimal transfer size %u logical blocks " \
    1964 + "> dev_max (%u logical blocks)\n",
    1965 + sdkp->opt_xfer_blocks, dev_max);
    1966 + return false;
    1967 + }
    1968 +
    1969 + if (sdkp->opt_xfer_blocks > SD_DEF_XFER_BLOCKS) {
    1970 + sd_first_printk(KERN_WARNING, sdkp,
    1971 + "Optimal transfer size %u logical blocks " \
    1972 + "> sd driver limit (%u logical blocks)\n",
    1973 + sdkp->opt_xfer_blocks, SD_DEF_XFER_BLOCKS);
    1974 + return false;
    1975 + }
    1976 +
    1977 + if (opt_xfer_bytes < PAGE_SIZE) {
    1978 + sd_first_printk(KERN_WARNING, sdkp,
    1979 + "Optimal transfer size %u bytes < " \
    1980 + "PAGE_SIZE (%u bytes)\n",
    1981 + opt_xfer_bytes, (unsigned int)PAGE_SIZE);
    1982 + return false;
    1983 + }
    1984 +
    1985 + if (opt_xfer_bytes & (sdkp->physical_block_size - 1)) {
    1986 + sd_first_printk(KERN_WARNING, sdkp,
    1987 + "Optimal transfer size %u bytes not a " \
    1988 + "multiple of physical block size (%u bytes)\n",
    1989 + opt_xfer_bytes, sdkp->physical_block_size);
    1990 + return false;
    1991 + }
    1992 +
    1993 + sd_first_printk(KERN_INFO, sdkp, "Optimal transfer size %u bytes\n",
    1994 + opt_xfer_bytes);
    1995 + return true;
    1996 +}
    1997 +
    1998 /**
    1999 * sd_revalidate_disk - called the first time a new disk is seen,
    2000 * performs disk spin up, read_capacity, etc.
    2001 @@ -2898,15 +2947,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
    2002 dev_max = min_not_zero(dev_max, sdkp->max_xfer_blocks);
    2003 q->limits.max_dev_sectors = logical_to_sectors(sdp, dev_max);
    2004
    2005 - /*
    2006 - * Determine the device's preferred I/O size for reads and writes
    2007 - * unless the reported value is unreasonably small, large, or
    2008 - * garbage.
    2009 - */
    2010 - if (sdkp->opt_xfer_blocks &&
    2011 - sdkp->opt_xfer_blocks <= dev_max &&
    2012 - sdkp->opt_xfer_blocks <= SD_DEF_XFER_BLOCKS &&
    2013 - logical_to_bytes(sdp, sdkp->opt_xfer_blocks) >= PAGE_SIZE) {
    2014 + if (sd_validate_opt_xfer_size(sdkp, dev_max)) {
    2015 q->limits.io_opt = logical_to_bytes(sdp, sdkp->opt_xfer_blocks);
    2016 rw_max = logical_to_sectors(sdp, sdkp->opt_xfer_blocks);
    2017 } else
    2018 diff --git a/drivers/scsi/virtio_scsi.c b/drivers/scsi/virtio_scsi.c
    2019 index cbc8e9388268..7ba0031d3a73 100644
    2020 --- a/drivers/scsi/virtio_scsi.c
    2021 +++ b/drivers/scsi/virtio_scsi.c
    2022 @@ -693,7 +693,6 @@ static int virtscsi_device_reset(struct scsi_cmnd *sc)
    2023 return FAILED;
    2024
    2025 memset(cmd, 0, sizeof(*cmd));
    2026 - cmd->sc = sc;
    2027 cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
    2028 .type = VIRTIO_SCSI_T_TMF,
    2029 .subtype = cpu_to_virtio32(vscsi->vdev,
    2030 @@ -752,7 +751,6 @@ static int virtscsi_abort(struct scsi_cmnd *sc)
    2031 return FAILED;
    2032
    2033 memset(cmd, 0, sizeof(*cmd));
    2034 - cmd->sc = sc;
    2035 cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
    2036 .type = VIRTIO_SCSI_T_TMF,
    2037 .subtype = VIRTIO_SCSI_T_TMF_ABORT_TASK,
    2038 diff --git a/drivers/spi/spi-pxa2xx.c b/drivers/spi/spi-pxa2xx.c
    2039 index 3f3751e2b521..f2209ec4cb68 100644
    2040 --- a/drivers/spi/spi-pxa2xx.c
    2041 +++ b/drivers/spi/spi-pxa2xx.c
    2042 @@ -1668,6 +1668,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
    2043 platform_info->enable_dma = false;
    2044 } else {
    2045 master->can_dma = pxa2xx_spi_can_dma;
    2046 + master->max_dma_len = MAX_DMA_LEN;
    2047 }
    2048 }
    2049
    2050 diff --git a/drivers/spi/spi-ti-qspi.c b/drivers/spi/spi-ti-qspi.c
    2051 index caeac66a3977..4cb72a8e4646 100644
    2052 --- a/drivers/spi/spi-ti-qspi.c
    2053 +++ b/drivers/spi/spi-ti-qspi.c
    2054 @@ -457,8 +457,8 @@ static void ti_qspi_enable_memory_map(struct spi_device *spi)
    2055 ti_qspi_write(qspi, MM_SWITCH, QSPI_SPI_SWITCH_REG);
    2056 if (qspi->ctrl_base) {
    2057 regmap_update_bits(qspi->ctrl_base, qspi->ctrl_reg,
    2058 - MEM_CS_EN(spi->chip_select),
    2059 - MEM_CS_MASK);
    2060 + MEM_CS_MASK,
    2061 + MEM_CS_EN(spi->chip_select));
    2062 }
    2063 qspi->mmap_enabled = true;
    2064 }
    2065 @@ -470,7 +470,7 @@ static void ti_qspi_disable_memory_map(struct spi_device *spi)
    2066 ti_qspi_write(qspi, 0, QSPI_SPI_SWITCH_REG);
    2067 if (qspi->ctrl_base)
    2068 regmap_update_bits(qspi->ctrl_base, qspi->ctrl_reg,
    2069 - 0, MEM_CS_MASK);
    2070 + MEM_CS_MASK, 0);
    2071 qspi->mmap_enabled = false;
    2072 }
    2073
    2074 diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
    2075 index 80205f3362d4..b6c4f55f79e7 100644
    2076 --- a/drivers/target/iscsi/iscsi_target.c
    2077 +++ b/drivers/target/iscsi/iscsi_target.c
    2078 @@ -4084,9 +4084,9 @@ static void iscsit_release_commands_from_conn(struct iscsi_conn *conn)
    2079 struct se_cmd *se_cmd = &cmd->se_cmd;
    2080
    2081 if (se_cmd->se_tfo != NULL) {
    2082 - spin_lock(&se_cmd->t_state_lock);
    2083 + spin_lock_irq(&se_cmd->t_state_lock);
    2084 se_cmd->transport_state |= CMD_T_FABRIC_STOP;
    2085 - spin_unlock(&se_cmd->t_state_lock);
    2086 + spin_unlock_irq(&se_cmd->t_state_lock);
    2087 }
    2088 }
    2089 spin_unlock_bh(&conn->cmd_lock);
    2090 diff --git a/drivers/tty/serial/8250/8250_of.c b/drivers/tty/serial/8250/8250_of.c
    2091 index 7a8b5fc81a19..f89dfde934a3 100644
    2092 --- a/drivers/tty/serial/8250/8250_of.c
    2093 +++ b/drivers/tty/serial/8250/8250_of.c
    2094 @@ -97,6 +97,10 @@ static int of_platform_serial_setup(struct platform_device *ofdev,
    2095 if (of_property_read_u32(np, "reg-offset", &prop) == 0)
    2096 port->mapbase += prop;
    2097
    2098 + /* Compatibility with the deprecated pxa driver and 8250_pxa drivers. */
    2099 + if (of_device_is_compatible(np, "mrvl,mmp-uart"))
    2100 + port->regshift = 2;
    2101 +
    2102 /* Check for registers offset within the devices address range */
    2103 if (of_property_read_u32(np, "reg-shift", &prop) == 0)
    2104 port->regshift = prop;
    2105 diff --git a/drivers/tty/serial/8250/8250_pci.c b/drivers/tty/serial/8250/8250_pci.c
    2106 index e82b3473b6b8..2c38b3a1d518 100644
    2107 --- a/drivers/tty/serial/8250/8250_pci.c
    2108 +++ b/drivers/tty/serial/8250/8250_pci.c
    2109 @@ -1330,6 +1330,30 @@ static int pci_default_setup(struct serial_private *priv,
    2110 return setup_port(priv, port, bar, offset, board->reg_shift);
    2111 }
    2112
    2113 +static int pci_pericom_setup(struct serial_private *priv,
    2114 + const struct pciserial_board *board,
    2115 + struct uart_8250_port *port, int idx)
    2116 +{
    2117 + unsigned int bar, offset = board->first_offset, maxnr;
    2118 +
    2119 + bar = FL_GET_BASE(board->flags);
    2120 + if (board->flags & FL_BASE_BARS)
    2121 + bar += idx;
    2122 + else
    2123 + offset += idx * board->uart_offset;
    2124 +
    2125 + if (idx==3)
    2126 + offset = 0x38;
    2127 +
    2128 + maxnr = (pci_resource_len(priv->dev, bar) - board->first_offset) >>
    2129 + (board->reg_shift + 3);
    2130 +
    2131 + if (board->flags & FL_REGION_SZ_CAP && idx >= maxnr)
    2132 + return 1;
    2133 +
    2134 + return setup_port(priv, port, bar, offset, board->reg_shift);
    2135 +}
    2136 +
    2137 static int
    2138 ce4100_serial_setup(struct serial_private *priv,
    2139 const struct pciserial_board *board,
    2140 @@ -2096,6 +2120,16 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
    2141 .setup = pci_default_setup,
    2142 .exit = pci_plx9050_exit,
    2143 },
    2144 + /*
    2145 + * Pericom (Only 7954 - It have a offset jump for port 4)
    2146 + */
    2147 + {
    2148 + .vendor = PCI_VENDOR_ID_PERICOM,
    2149 + .device = PCI_DEVICE_ID_PERICOM_PI7C9X7954,
    2150 + .subvendor = PCI_ANY_ID,
    2151 + .subdevice = PCI_ANY_ID,
    2152 + .setup = pci_pericom_setup,
    2153 + },
    2154 /*
    2155 * PLX
    2156 */
    2157 @@ -2126,6 +2160,111 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
    2158 .setup = pci_default_setup,
    2159 .exit = pci_plx9050_exit,
    2160 },
    2161 + {
    2162 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2163 + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SDB,
    2164 + .subvendor = PCI_ANY_ID,
    2165 + .subdevice = PCI_ANY_ID,
    2166 + .setup = pci_pericom_setup,
    2167 + },
    2168 + {
    2169 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2170 + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_COM_4S,
    2171 + .subvendor = PCI_ANY_ID,
    2172 + .subdevice = PCI_ANY_ID,
    2173 + .setup = pci_pericom_setup,
    2174 + },
    2175 + {
    2176 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2177 + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM232_4DB,
    2178 + .subvendor = PCI_ANY_ID,
    2179 + .subdevice = PCI_ANY_ID,
    2180 + .setup = pci_pericom_setup,
    2181 + },
    2182 + {
    2183 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2184 + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_COM232_4,
    2185 + .subvendor = PCI_ANY_ID,
    2186 + .subdevice = PCI_ANY_ID,
    2187 + .setup = pci_pericom_setup,
    2188 + },
    2189 + {
    2190 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2191 + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SMDB,
    2192 + .subvendor = PCI_ANY_ID,
    2193 + .subdevice = PCI_ANY_ID,
    2194 + .setup = pci_pericom_setup,
    2195 + },
    2196 + {
    2197 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2198 + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_COM_4SM,
    2199 + .subvendor = PCI_ANY_ID,
    2200 + .subdevice = PCI_ANY_ID,
    2201 + .setup = pci_pericom_setup,
    2202 + },
    2203 + {
    2204 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2205 + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_ICM422_4,
    2206 + .subvendor = PCI_ANY_ID,
    2207 + .subdevice = PCI_ANY_ID,
    2208 + .setup = pci_pericom_setup,
    2209 + },
    2210 + {
    2211 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2212 + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_ICM485_4,
    2213 + .subvendor = PCI_ANY_ID,
    2214 + .subdevice = PCI_ANY_ID,
    2215 + .setup = pci_pericom_setup,
    2216 + },
    2217 + {
    2218 + .vendor = PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4S,
    2219 + .device = PCI_DEVICE_ID_ACCESIO_PCIE_ICM232_4,
    2220 + .subvendor = PCI_ANY_ID,
    2221 + .subdevice = PCI_ANY_ID,
    2222 + .setup = pci_pericom_setup,
    2223 + },
    2224 + {
    2225 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2226 + .device = PCI_DEVICE_ID_ACCESIO_MPCIE_ICM232_4,
    2227 + .subvendor = PCI_ANY_ID,
    2228 + .subdevice = PCI_ANY_ID,
    2229 + .setup = pci_pericom_setup,
    2230 + },
    2231 + {
    2232 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2233 + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM422_4,
    2234 + .subvendor = PCI_ANY_ID,
    2235 + .subdevice = PCI_ANY_ID,
    2236 + .setup = pci_pericom_setup,
    2237 + },
    2238 + {
    2239 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2240 + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM485_4,
    2241 + .subvendor = PCI_ANY_ID,
    2242 + .subdevice = PCI_ANY_ID,
    2243 + .setup = pci_pericom_setup,
    2244 + },
    2245 + {
    2246 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2247 + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM232_4,
    2248 + .subvendor = PCI_ANY_ID,
    2249 + .subdevice = PCI_ANY_ID,
    2250 + .setup = pci_pericom_setup,
    2251 + },
    2252 + {
    2253 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2254 + .device = PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SM,
    2255 + .subvendor = PCI_ANY_ID,
    2256 + .subdevice = PCI_ANY_ID,
    2257 + .setup = pci_pericom_setup,
    2258 + },
    2259 + {
    2260 + .vendor = PCI_VENDOR_ID_ACCESIO,
    2261 + .device = PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4SM,
    2262 + .subvendor = PCI_ANY_ID,
    2263 + .subdevice = PCI_ANY_ID,
    2264 + .setup = pci_pericom_setup,
    2265 + },
    2266 /*
    2267 * SBS Technologies, Inc., PMC-OCTALPRO 232
    2268 */
    2269 @@ -4976,10 +5115,10 @@ static struct pci_device_id serial_pci_tbl[] = {
    2270 */
    2271 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_2SDB,
    2272 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2273 - pbn_pericom_PI7C9X7954 },
    2274 + pbn_pericom_PI7C9X7952 },
    2275 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_COM_2S,
    2276 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2277 - pbn_pericom_PI7C9X7954 },
    2278 + pbn_pericom_PI7C9X7952 },
    2279 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SDB,
    2280 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2281 pbn_pericom_PI7C9X7954 },
    2282 @@ -4988,10 +5127,10 @@ static struct pci_device_id serial_pci_tbl[] = {
    2283 pbn_pericom_PI7C9X7954 },
    2284 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM232_2DB,
    2285 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2286 - pbn_pericom_PI7C9X7954 },
    2287 + pbn_pericom_PI7C9X7952 },
    2288 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_COM232_2,
    2289 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2290 - pbn_pericom_PI7C9X7954 },
    2291 + pbn_pericom_PI7C9X7952 },
    2292 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM232_4DB,
    2293 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2294 pbn_pericom_PI7C9X7954 },
    2295 @@ -5000,10 +5139,10 @@ static struct pci_device_id serial_pci_tbl[] = {
    2296 pbn_pericom_PI7C9X7954 },
    2297 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_2SMDB,
    2298 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2299 - pbn_pericom_PI7C9X7954 },
    2300 + pbn_pericom_PI7C9X7952 },
    2301 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_COM_2SM,
    2302 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2303 - pbn_pericom_PI7C9X7954 },
    2304 + pbn_pericom_PI7C9X7952 },
    2305 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SMDB,
    2306 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2307 pbn_pericom_PI7C9X7954 },
    2308 @@ -5012,13 +5151,13 @@ static struct pci_device_id serial_pci_tbl[] = {
    2309 pbn_pericom_PI7C9X7954 },
    2310 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM485_1,
    2311 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2312 - pbn_pericom_PI7C9X7954 },
    2313 + pbn_pericom_PI7C9X7951 },
    2314 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM422_2,
    2315 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2316 - pbn_pericom_PI7C9X7954 },
    2317 + pbn_pericom_PI7C9X7952 },
    2318 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM485_2,
    2319 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2320 - pbn_pericom_PI7C9X7954 },
    2321 + pbn_pericom_PI7C9X7952 },
    2322 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM422_4,
    2323 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2324 pbn_pericom_PI7C9X7954 },
    2325 @@ -5027,16 +5166,16 @@ static struct pci_device_id serial_pci_tbl[] = {
    2326 pbn_pericom_PI7C9X7954 },
    2327 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM_2S,
    2328 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2329 - pbn_pericom_PI7C9X7954 },
    2330 + pbn_pericom_PI7C9X7952 },
    2331 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4S,
    2332 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2333 pbn_pericom_PI7C9X7954 },
    2334 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM232_2,
    2335 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2336 - pbn_pericom_PI7C9X7954 },
    2337 + pbn_pericom_PI7C9X7952 },
    2338 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_MPCIE_ICM232_2,
    2339 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2340 - pbn_pericom_PI7C9X7954 },
    2341 + pbn_pericom_PI7C9X7952 },
    2342 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM232_4,
    2343 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2344 pbn_pericom_PI7C9X7954 },
    2345 @@ -5045,13 +5184,13 @@ static struct pci_device_id serial_pci_tbl[] = {
    2346 pbn_pericom_PI7C9X7954 },
    2347 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM_2SM,
    2348 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2349 - pbn_pericom_PI7C9X7954 },
    2350 + pbn_pericom_PI7C9X7952 },
    2351 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM422_4,
    2352 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2353 - pbn_pericom_PI7C9X7958 },
    2354 + pbn_pericom_PI7C9X7954 },
    2355 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM485_4,
    2356 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2357 - pbn_pericom_PI7C9X7958 },
    2358 + pbn_pericom_PI7C9X7954 },
    2359 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM422_8,
    2360 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2361 pbn_pericom_PI7C9X7958 },
    2362 @@ -5060,19 +5199,19 @@ static struct pci_device_id serial_pci_tbl[] = {
    2363 pbn_pericom_PI7C9X7958 },
    2364 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM232_4,
    2365 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2366 - pbn_pericom_PI7C9X7958 },
    2367 + pbn_pericom_PI7C9X7954 },
    2368 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM232_8,
    2369 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2370 pbn_pericom_PI7C9X7958 },
    2371 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_4SM,
    2372 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2373 - pbn_pericom_PI7C9X7958 },
    2374 + pbn_pericom_PI7C9X7954 },
    2375 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_COM_8SM,
    2376 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2377 pbn_pericom_PI7C9X7958 },
    2378 { PCI_VENDOR_ID_ACCESIO, PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4SM,
    2379 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
    2380 - pbn_pericom_PI7C9X7958 },
    2381 + pbn_pericom_PI7C9X7954 },
    2382 /*
    2383 * Topic TP560 Data/Fax/Voice 56k modem (reported by Evan Clarke)
    2384 */
    2385 diff --git a/drivers/tty/serial/xilinx_uartps.c b/drivers/tty/serial/xilinx_uartps.c
    2386 index 7333d64f68f2..ffb474c49f0f 100644
    2387 --- a/drivers/tty/serial/xilinx_uartps.c
    2388 +++ b/drivers/tty/serial/xilinx_uartps.c
    2389 @@ -362,7 +362,13 @@ static irqreturn_t cdns_uart_isr(int irq, void *dev_id)
    2390 cdns_uart_handle_tx(dev_id);
    2391 isrstatus &= ~CDNS_UART_IXR_TXEMPTY;
    2392 }
    2393 - if (isrstatus & CDNS_UART_IXR_RXMASK)
    2394 +
    2395 + /*
    2396 + * Skip RX processing if RX is disabled as RXEMPTY will never be set
    2397 + * as read bytes will not be removed from the FIFO.
    2398 + */
    2399 + if (isrstatus & CDNS_UART_IXR_RXMASK &&
    2400 + !(readl(port->membase + CDNS_UART_CR) & CDNS_UART_CR_RX_DIS))
    2401 cdns_uart_handle_rx(dev_id, isrstatus);
    2402
    2403 spin_unlock(&port->lock);
    2404 diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
    2405 index 5a0db6dec8d1..aaee1e6584e6 100644
    2406 --- a/fs/9p/v9fs_vfs.h
    2407 +++ b/fs/9p/v9fs_vfs.h
    2408 @@ -40,6 +40,9 @@
    2409 */
    2410 #define P9_LOCK_TIMEOUT (30*HZ)
    2411
    2412 +/* flags for v9fs_stat2inode() & v9fs_stat2inode_dotl() */
    2413 +#define V9FS_STAT2INODE_KEEP_ISIZE 1
    2414 +
    2415 extern struct file_system_type v9fs_fs_type;
    2416 extern const struct address_space_operations v9fs_addr_operations;
    2417 extern const struct file_operations v9fs_file_operations;
    2418 @@ -61,8 +64,10 @@ int v9fs_init_inode(struct v9fs_session_info *v9ses,
    2419 struct inode *inode, umode_t mode, dev_t);
    2420 void v9fs_evict_inode(struct inode *inode);
    2421 ino_t v9fs_qid2ino(struct p9_qid *qid);
    2422 -void v9fs_stat2inode(struct p9_wstat *, struct inode *, struct super_block *);
    2423 -void v9fs_stat2inode_dotl(struct p9_stat_dotl *, struct inode *);
    2424 +void v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
    2425 + struct super_block *sb, unsigned int flags);
    2426 +void v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode,
    2427 + unsigned int flags);
    2428 int v9fs_dir_release(struct inode *inode, struct file *filp);
    2429 int v9fs_file_open(struct inode *inode, struct file *file);
    2430 void v9fs_inode2stat(struct inode *inode, struct p9_wstat *stat);
    2431 @@ -83,4 +88,18 @@ static inline void v9fs_invalidate_inode_attr(struct inode *inode)
    2432 }
    2433
    2434 int v9fs_open_to_dotl_flags(int flags);
    2435 +
    2436 +static inline void v9fs_i_size_write(struct inode *inode, loff_t i_size)
    2437 +{
    2438 + /*
    2439 + * 32-bit need the lock, concurrent updates could break the
    2440 + * sequences and make i_size_read() loop forever.
    2441 + * 64-bit updates are atomic and can skip the locking.
    2442 + */
    2443 + if (sizeof(i_size) > sizeof(long))
    2444 + spin_lock(&inode->i_lock);
    2445 + i_size_write(inode, i_size);
    2446 + if (sizeof(i_size) > sizeof(long))
    2447 + spin_unlock(&inode->i_lock);
    2448 +}
    2449 #endif
    2450 diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
    2451 index 398a3eddb2df..2f035b15180e 100644
    2452 --- a/fs/9p/vfs_file.c
    2453 +++ b/fs/9p/vfs_file.c
    2454 @@ -442,7 +442,11 @@ v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
    2455 i_size = i_size_read(inode);
    2456 if (iocb->ki_pos > i_size) {
    2457 inode_add_bytes(inode, iocb->ki_pos - i_size);
    2458 - i_size_write(inode, iocb->ki_pos);
    2459 + /*
    2460 + * Need to serialize against i_size_write() in
    2461 + * v9fs_stat2inode()
    2462 + */
    2463 + v9fs_i_size_write(inode, iocb->ki_pos);
    2464 }
    2465 return retval;
    2466 }
    2467 diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
    2468 index f8ab4a66acaf..ddd1eb6aedee 100644
    2469 --- a/fs/9p/vfs_inode.c
    2470 +++ b/fs/9p/vfs_inode.c
    2471 @@ -538,7 +538,7 @@ static struct inode *v9fs_qid_iget(struct super_block *sb,
    2472 if (retval)
    2473 goto error;
    2474
    2475 - v9fs_stat2inode(st, inode, sb);
    2476 + v9fs_stat2inode(st, inode, sb, 0);
    2477 v9fs_cache_inode_get_cookie(inode);
    2478 unlock_new_inode(inode);
    2479 return inode;
    2480 @@ -1078,7 +1078,7 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
    2481 if (IS_ERR(st))
    2482 return PTR_ERR(st);
    2483
    2484 - v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb);
    2485 + v9fs_stat2inode(st, d_inode(dentry), dentry->d_sb, 0);
    2486 generic_fillattr(d_inode(dentry), stat);
    2487
    2488 p9stat_free(st);
    2489 @@ -1156,12 +1156,13 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
    2490 * @stat: Plan 9 metadata (mistat) structure
    2491 * @inode: inode to populate
    2492 * @sb: superblock of filesystem
    2493 + * @flags: control flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE)
    2494 *
    2495 */
    2496
    2497 void
    2498 v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
    2499 - struct super_block *sb)
    2500 + struct super_block *sb, unsigned int flags)
    2501 {
    2502 umode_t mode;
    2503 char ext[32];
    2504 @@ -1202,10 +1203,11 @@ v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
    2505 mode = p9mode2perm(v9ses, stat);
    2506 mode |= inode->i_mode & ~S_IALLUGO;
    2507 inode->i_mode = mode;
    2508 - i_size_write(inode, stat->length);
    2509
    2510 + if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE))
    2511 + v9fs_i_size_write(inode, stat->length);
    2512 /* not real number of blocks, but 512 byte ones ... */
    2513 - inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
    2514 + inode->i_blocks = (stat->length + 512 - 1) >> 9;
    2515 v9inode->cache_validity &= ~V9FS_INO_INVALID_ATTR;
    2516 }
    2517
    2518 @@ -1402,9 +1404,9 @@ int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
    2519 {
    2520 int umode;
    2521 dev_t rdev;
    2522 - loff_t i_size;
    2523 struct p9_wstat *st;
    2524 struct v9fs_session_info *v9ses;
    2525 + unsigned int flags;
    2526
    2527 v9ses = v9fs_inode2v9ses(inode);
    2528 st = p9_client_stat(fid);
    2529 @@ -1417,16 +1419,13 @@ int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode)
    2530 if ((inode->i_mode & S_IFMT) != (umode & S_IFMT))
    2531 goto out;
    2532
    2533 - spin_lock(&inode->i_lock);
    2534 /*
    2535 * We don't want to refresh inode->i_size,
    2536 * because we may have cached data
    2537 */
    2538 - i_size = inode->i_size;
    2539 - v9fs_stat2inode(st, inode, inode->i_sb);
    2540 - if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
    2541 - inode->i_size = i_size;
    2542 - spin_unlock(&inode->i_lock);
    2543 + flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ?
    2544 + V9FS_STAT2INODE_KEEP_ISIZE : 0;
    2545 + v9fs_stat2inode(st, inode, inode->i_sb, flags);
    2546 out:
    2547 p9stat_free(st);
    2548 kfree(st);
    2549 diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
    2550 index c3dd0d42bb3a..425bc1a2b8c1 100644
    2551 --- a/fs/9p/vfs_inode_dotl.c
    2552 +++ b/fs/9p/vfs_inode_dotl.c
    2553 @@ -143,7 +143,7 @@ static struct inode *v9fs_qid_iget_dotl(struct super_block *sb,
    2554 if (retval)
    2555 goto error;
    2556
    2557 - v9fs_stat2inode_dotl(st, inode);
    2558 + v9fs_stat2inode_dotl(st, inode, 0);
    2559 v9fs_cache_inode_get_cookie(inode);
    2560 retval = v9fs_get_acl(inode, fid);
    2561 if (retval)
    2562 @@ -496,7 +496,7 @@ v9fs_vfs_getattr_dotl(struct vfsmount *mnt, struct dentry *dentry,
    2563 if (IS_ERR(st))
    2564 return PTR_ERR(st);
    2565
    2566 - v9fs_stat2inode_dotl(st, d_inode(dentry));
    2567 + v9fs_stat2inode_dotl(st, d_inode(dentry), 0);
    2568 generic_fillattr(d_inode(dentry), stat);
    2569 /* Change block size to what the server returned */
    2570 stat->blksize = st->st_blksize;
    2571 @@ -607,11 +607,13 @@ int v9fs_vfs_setattr_dotl(struct dentry *dentry, struct iattr *iattr)
    2572 * v9fs_stat2inode_dotl - populate an inode structure with stat info
    2573 * @stat: stat structure
    2574 * @inode: inode to populate
    2575 + * @flags: ctrl flags (e.g. V9FS_STAT2INODE_KEEP_ISIZE)
    2576 *
    2577 */
    2578
    2579 void
    2580 -v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
    2581 +v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode,
    2582 + unsigned int flags)
    2583 {
    2584 umode_t mode;
    2585 struct v9fs_inode *v9inode = V9FS_I(inode);
    2586 @@ -631,7 +633,8 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
    2587 mode |= inode->i_mode & ~S_IALLUGO;
    2588 inode->i_mode = mode;
    2589
    2590 - i_size_write(inode, stat->st_size);
    2591 + if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE))
    2592 + v9fs_i_size_write(inode, stat->st_size);
    2593 inode->i_blocks = stat->st_blocks;
    2594 } else {
    2595 if (stat->st_result_mask & P9_STATS_ATIME) {
    2596 @@ -661,8 +664,9 @@ v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode)
    2597 }
    2598 if (stat->st_result_mask & P9_STATS_RDEV)
    2599 inode->i_rdev = new_decode_dev(stat->st_rdev);
    2600 - if (stat->st_result_mask & P9_STATS_SIZE)
    2601 - i_size_write(inode, stat->st_size);
    2602 + if (!(flags & V9FS_STAT2INODE_KEEP_ISIZE) &&
    2603 + stat->st_result_mask & P9_STATS_SIZE)
    2604 + v9fs_i_size_write(inode, stat->st_size);
    2605 if (stat->st_result_mask & P9_STATS_BLOCKS)
    2606 inode->i_blocks = stat->st_blocks;
    2607 }
    2608 @@ -928,9 +932,9 @@ v9fs_vfs_get_link_dotl(struct dentry *dentry,
    2609
    2610 int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode)
    2611 {
    2612 - loff_t i_size;
    2613 struct p9_stat_dotl *st;
    2614 struct v9fs_session_info *v9ses;
    2615 + unsigned int flags;
    2616
    2617 v9ses = v9fs_inode2v9ses(inode);
    2618 st = p9_client_getattr_dotl(fid, P9_STATS_ALL);
    2619 @@ -942,16 +946,13 @@ int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode)
    2620 if ((inode->i_mode & S_IFMT) != (st->st_mode & S_IFMT))
    2621 goto out;
    2622
    2623 - spin_lock(&inode->i_lock);
    2624 /*
    2625 * We don't want to refresh inode->i_size,
    2626 * because we may have cached data
    2627 */
    2628 - i_size = inode->i_size;
    2629 - v9fs_stat2inode_dotl(st, inode);
    2630 - if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE)
    2631 - inode->i_size = i_size;
    2632 - spin_unlock(&inode->i_lock);
    2633 + flags = (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) ?
    2634 + V9FS_STAT2INODE_KEEP_ISIZE : 0;
    2635 + v9fs_stat2inode_dotl(st, inode, flags);
    2636 out:
    2637 kfree(st);
    2638 return 0;
    2639 diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
    2640 index de3ed8629196..06ff1a9089e8 100644
    2641 --- a/fs/9p/vfs_super.c
    2642 +++ b/fs/9p/vfs_super.c
    2643 @@ -165,7 +165,7 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
    2644 goto release_sb;
    2645 }
    2646 d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
    2647 - v9fs_stat2inode_dotl(st, d_inode(root));
    2648 + v9fs_stat2inode_dotl(st, d_inode(root), 0);
    2649 kfree(st);
    2650 } else {
    2651 struct p9_wstat *st = NULL;
    2652 @@ -176,7 +176,7 @@ static struct dentry *v9fs_mount(struct file_system_type *fs_type, int flags,
    2653 }
    2654
    2655 d_inode(root)->i_ino = v9fs_qid2ino(&st->qid);
    2656 - v9fs_stat2inode(st, d_inode(root), sb);
    2657 + v9fs_stat2inode(st, d_inode(root), sb, 0);
    2658
    2659 p9stat_free(st);
    2660 kfree(st);
    2661 diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
    2662 index 5c5c389d8fed..4d901200be13 100644
    2663 --- a/fs/btrfs/extent_io.c
    2664 +++ b/fs/btrfs/extent_io.c
    2665 @@ -3018,11 +3018,11 @@ static int __do_readpage(struct extent_io_tree *tree,
    2666 */
    2667 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags) &&
    2668 prev_em_start && *prev_em_start != (u64)-1 &&
    2669 - *prev_em_start != em->orig_start)
    2670 + *prev_em_start != em->start)
    2671 force_bio_submit = true;
    2672
    2673 if (prev_em_start)
    2674 - *prev_em_start = em->orig_start;
    2675 + *prev_em_start = em->start;
    2676
    2677 free_extent_map(em);
    2678 em = NULL;
    2679 diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
    2680 index 5aa2749eaf42..c063ac57c30e 100644
    2681 --- a/fs/btrfs/volumes.c
    2682 +++ b/fs/btrfs/volumes.c
    2683 @@ -6439,10 +6439,10 @@ static int btrfs_check_chunk_valid(struct btrfs_root *root,
    2684 }
    2685
    2686 if ((type & BTRFS_BLOCK_GROUP_RAID10 && sub_stripes != 2) ||
    2687 - (type & BTRFS_BLOCK_GROUP_RAID1 && num_stripes < 1) ||
    2688 + (type & BTRFS_BLOCK_GROUP_RAID1 && num_stripes != 2) ||
    2689 (type & BTRFS_BLOCK_GROUP_RAID5 && num_stripes < 2) ||
    2690 (type & BTRFS_BLOCK_GROUP_RAID6 && num_stripes < 3) ||
    2691 - (type & BTRFS_BLOCK_GROUP_DUP && num_stripes > 2) ||
    2692 + (type & BTRFS_BLOCK_GROUP_DUP && num_stripes != 2) ||
    2693 ((type & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 &&
    2694 num_stripes != 1)) {
    2695 btrfs_err(root->fs_info,
    2696 diff --git a/fs/cifs/file.c b/fs/cifs/file.c
    2697 index 8ec296308729..1c5099fffaec 100644
    2698 --- a/fs/cifs/file.c
    2699 +++ b/fs/cifs/file.c
    2700 @@ -2797,14 +2797,16 @@ cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
    2701 * these pages but not on the region from pos to ppos+len-1.
    2702 */
    2703 written = cifs_user_writev(iocb, from);
    2704 - if (written > 0 && CIFS_CACHE_READ(cinode)) {
    2705 + if (CIFS_CACHE_READ(cinode)) {
    2706 /*
    2707 - * Windows 7 server can delay breaking level2 oplock if a write
    2708 - * request comes - break it on the client to prevent reading
    2709 - * an old data.
    2710 + * We have read level caching and we have just sent a write
    2711 + * request to the server thus making data in the cache stale.
    2712 + * Zap the cache and set oplock/lease level to NONE to avoid
    2713 + * reading stale data from the cache. All subsequent read
    2714 + * operations will read new data from the server.
    2715 */
    2716 cifs_zap_mapping(inode);
    2717 - cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
    2718 + cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
    2719 inode);
    2720 cinode->oplock = 0;
    2721 }
    2722 diff --git a/fs/cifs/smb2misc.c b/fs/cifs/smb2misc.c
    2723 index e96a74da756f..244d27bb8fba 100644
    2724 --- a/fs/cifs/smb2misc.c
    2725 +++ b/fs/cifs/smb2misc.c
    2726 @@ -474,7 +474,6 @@ smb2_tcon_has_lease(struct cifs_tcon *tcon, struct smb2_lease_break *rsp,
    2727 __u8 lease_state;
    2728 struct list_head *tmp;
    2729 struct cifsFileInfo *cfile;
    2730 - struct TCP_Server_Info *server = tcon->ses->server;
    2731 struct cifs_pending_open *open;
    2732 struct cifsInodeInfo *cinode;
    2733 int ack_req = le32_to_cpu(rsp->Flags &
    2734 @@ -494,13 +493,25 @@ smb2_tcon_has_lease(struct cifs_tcon *tcon, struct smb2_lease_break *rsp,
    2735 cifs_dbg(FYI, "lease key match, lease break 0x%x\n",
    2736 le32_to_cpu(rsp->NewLeaseState));
    2737
    2738 - server->ops->set_oplock_level(cinode, lease_state, 0, NULL);
    2739 -
    2740 if (ack_req)
    2741 cfile->oplock_break_cancelled = false;
    2742 else
    2743 cfile->oplock_break_cancelled = true;
    2744
    2745 + set_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, &cinode->flags);
    2746 +
    2747 + /*
    2748 + * Set or clear flags depending on the lease state being READ.
    2749 + * HANDLE caching flag should be added when the client starts
    2750 + * to defer closing remote file handles with HANDLE leases.
    2751 + */
    2752 + if (lease_state & SMB2_LEASE_READ_CACHING_HE)
    2753 + set_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
    2754 + &cinode->flags);
    2755 + else
    2756 + clear_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2,
    2757 + &cinode->flags);
    2758 +
    2759 queue_work(cifsoplockd_wq, &cfile->oplock_break);
    2760 kfree(lw);
    2761 return true;
    2762 diff --git a/fs/cifs/smb2ops.c b/fs/cifs/smb2ops.c
    2763 index 2db7968febfe..97d8e2a3df9b 100644
    2764 --- a/fs/cifs/smb2ops.c
    2765 +++ b/fs/cifs/smb2ops.c
    2766 @@ -1376,6 +1376,15 @@ smb2_downgrade_oplock(struct TCP_Server_Info *server,
    2767 server->ops->set_oplock_level(cinode, 0, 0, NULL);
    2768 }
    2769
    2770 +static void
    2771 +smb21_downgrade_oplock(struct TCP_Server_Info *server,
    2772 + struct cifsInodeInfo *cinode, bool set_level2)
    2773 +{
    2774 + server->ops->set_oplock_level(cinode,
    2775 + set_level2 ? SMB2_LEASE_READ_CACHING_HE :
    2776 + 0, 0, NULL);
    2777 +}
    2778 +
    2779 static void
    2780 smb2_set_oplock_level(struct cifsInodeInfo *cinode, __u32 oplock,
    2781 unsigned int epoch, bool *purge_cache)
    2782 @@ -1681,7 +1690,7 @@ struct smb_version_operations smb21_operations = {
    2783 .print_stats = smb2_print_stats,
    2784 .is_oplock_break = smb2_is_valid_oplock_break,
    2785 .handle_cancelled_mid = smb2_handle_cancelled_mid,
    2786 - .downgrade_oplock = smb2_downgrade_oplock,
    2787 + .downgrade_oplock = smb21_downgrade_oplock,
    2788 .need_neg = smb2_need_neg,
    2789 .negotiate = smb2_negotiate,
    2790 .negotiate_wsize = smb2_negotiate_wsize,
    2791 @@ -1765,7 +1774,7 @@ struct smb_version_operations smb30_operations = {
    2792 .dump_share_caps = smb2_dump_share_caps,
    2793 .is_oplock_break = smb2_is_valid_oplock_break,
    2794 .handle_cancelled_mid = smb2_handle_cancelled_mid,
    2795 - .downgrade_oplock = smb2_downgrade_oplock,
    2796 + .downgrade_oplock = smb21_downgrade_oplock,
    2797 .need_neg = smb2_need_neg,
    2798 .negotiate = smb2_negotiate,
    2799 .negotiate_wsize = smb2_negotiate_wsize,
    2800 @@ -1855,7 +1864,7 @@ struct smb_version_operations smb311_operations = {
    2801 .dump_share_caps = smb2_dump_share_caps,
    2802 .is_oplock_break = smb2_is_valid_oplock_break,
    2803 .handle_cancelled_mid = smb2_handle_cancelled_mid,
    2804 - .downgrade_oplock = smb2_downgrade_oplock,
    2805 + .downgrade_oplock = smb21_downgrade_oplock,
    2806 .need_neg = smb2_need_neg,
    2807 .negotiate = smb2_negotiate,
    2808 .negotiate_wsize = smb2_negotiate_wsize,
    2809 diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
    2810 index 108df2e3602c..81be3ba17cbf 100644
    2811 --- a/fs/devpts/inode.c
    2812 +++ b/fs/devpts/inode.c
    2813 @@ -396,6 +396,7 @@ devpts_fill_super(struct super_block *s, void *data, int silent)
    2814 s->s_blocksize_bits = 10;
    2815 s->s_magic = DEVPTS_SUPER_MAGIC;
    2816 s->s_op = &devpts_sops;
    2817 + s->s_d_op = &simple_dentry_operations;
    2818 s->s_time_gran = 1;
    2819
    2820 error = -ENOMEM;
    2821 diff --git a/fs/ext2/super.c b/fs/ext2/super.c
    2822 index 6cb042b53b5b..6fcb29b393d3 100644
    2823 --- a/fs/ext2/super.c
    2824 +++ b/fs/ext2/super.c
    2825 @@ -724,7 +724,8 @@ static loff_t ext2_max_size(int bits)
    2826 {
    2827 loff_t res = EXT2_NDIR_BLOCKS;
    2828 int meta_blocks;
    2829 - loff_t upper_limit;
    2830 + unsigned int upper_limit;
    2831 + unsigned int ppb = 1 << (bits-2);
    2832
    2833 /* This is calculated to be the largest file size for a
    2834 * dense, file such that the total number of
    2835 @@ -738,24 +739,34 @@ static loff_t ext2_max_size(int bits)
    2836 /* total blocks in file system block size */
    2837 upper_limit >>= (bits - 9);
    2838
    2839 + /* Compute how many blocks we can address by block tree */
    2840 + res += 1LL << (bits-2);
    2841 + res += 1LL << (2*(bits-2));
    2842 + res += 1LL << (3*(bits-2));
    2843 + /* Does block tree limit file size? */
    2844 + if (res < upper_limit)
    2845 + goto check_lfs;
    2846
    2847 + res = upper_limit;
    2848 + /* How many metadata blocks are needed for addressing upper_limit? */
    2849 + upper_limit -= EXT2_NDIR_BLOCKS;
    2850 /* indirect blocks */
    2851 meta_blocks = 1;
    2852 + upper_limit -= ppb;
    2853 /* double indirect blocks */
    2854 - meta_blocks += 1 + (1LL << (bits-2));
    2855 - /* tripple indirect blocks */
    2856 - meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
    2857 -
    2858 - upper_limit -= meta_blocks;
    2859 - upper_limit <<= bits;
    2860 -
    2861 - res += 1LL << (bits-2);
    2862 - res += 1LL << (2*(bits-2));
    2863 - res += 1LL << (3*(bits-2));
    2864 + if (upper_limit < ppb * ppb) {
    2865 + meta_blocks += 1 + DIV_ROUND_UP(upper_limit, ppb);
    2866 + res -= meta_blocks;
    2867 + goto check_lfs;
    2868 + }
    2869 + meta_blocks += 1 + ppb;
    2870 + upper_limit -= ppb * ppb;
    2871 + /* tripple indirect blocks for the rest */
    2872 + meta_blocks += 1 + DIV_ROUND_UP(upper_limit, ppb) +
    2873 + DIV_ROUND_UP(upper_limit, ppb*ppb);
    2874 + res -= meta_blocks;
    2875 +check_lfs:
    2876 res <<= bits;
    2877 - if (res > upper_limit)
    2878 - res = upper_limit;
    2879 -
    2880 if (res > MAX_LFS_FILESIZE)
    2881 res = MAX_LFS_FILESIZE;
    2882
    2883 diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
    2884 index 58e6b8a03e90..67b359629a66 100644
    2885 --- a/fs/ext4/resize.c
    2886 +++ b/fs/ext4/resize.c
    2887 @@ -1928,7 +1928,8 @@ retry:
    2888 le16_to_cpu(es->s_reserved_gdt_blocks);
    2889 n_group = n_desc_blocks * EXT4_DESC_PER_BLOCK(sb);
    2890 n_blocks_count = (ext4_fsblk_t)n_group *
    2891 - EXT4_BLOCKS_PER_GROUP(sb);
    2892 + EXT4_BLOCKS_PER_GROUP(sb) +
    2893 + le32_to_cpu(es->s_first_data_block);
    2894 n_group--; /* set to last group number */
    2895 }
    2896
    2897 diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
    2898 index b320c1ba7fdc..799f96c67211 100644
    2899 --- a/fs/jbd2/transaction.c
    2900 +++ b/fs/jbd2/transaction.c
    2901 @@ -1211,11 +1211,12 @@ int jbd2_journal_get_undo_access(handle_t *handle, struct buffer_head *bh)
    2902 struct journal_head *jh;
    2903 char *committed_data = NULL;
    2904
    2905 - JBUFFER_TRACE(jh, "entry");
    2906 if (jbd2_write_access_granted(handle, bh, true))
    2907 return 0;
    2908
    2909 jh = jbd2_journal_add_journal_head(bh);
    2910 + JBUFFER_TRACE(jh, "entry");
    2911 +
    2912 /*
    2913 * Do this first --- it can drop the journal lock, so we want to
    2914 * make sure that obtaining the committed_data is done
    2915 @@ -1326,15 +1327,17 @@ int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
    2916
    2917 if (is_handle_aborted(handle))
    2918 return -EROFS;
    2919 - if (!buffer_jbd(bh)) {
    2920 - ret = -EUCLEAN;
    2921 - goto out;
    2922 - }
    2923 + if (!buffer_jbd(bh))
    2924 + return -EUCLEAN;
    2925 +
    2926 /*
    2927 * We don't grab jh reference here since the buffer must be part
    2928 * of the running transaction.
    2929 */
    2930 jh = bh2jh(bh);
    2931 + jbd_debug(5, "journal_head %p\n", jh);
    2932 + JBUFFER_TRACE(jh, "entry");
    2933 +
    2934 /*
    2935 * This and the following assertions are unreliable since we may see jh
    2936 * in inconsistent state unless we grab bh_state lock. But this is
    2937 @@ -1368,9 +1371,6 @@ int jbd2_journal_dirty_metadata(handle_t *handle, struct buffer_head *bh)
    2938 }
    2939
    2940 journal = transaction->t_journal;
    2941 - jbd_debug(5, "journal_head %p\n", jh);
    2942 - JBUFFER_TRACE(jh, "entry");
    2943 -
    2944 jbd_lock_bh_state(bh);
    2945
    2946 if (jh->b_modified == 0) {
    2947 @@ -1568,14 +1568,21 @@ int jbd2_journal_forget (handle_t *handle, struct buffer_head *bh)
    2948 /* However, if the buffer is still owned by a prior
    2949 * (committing) transaction, we can't drop it yet... */
    2950 JBUFFER_TRACE(jh, "belongs to older transaction");
    2951 - /* ... but we CAN drop it from the new transaction if we
    2952 - * have also modified it since the original commit. */
    2953 + /* ... but we CAN drop it from the new transaction through
    2954 + * marking the buffer as freed and set j_next_transaction to
    2955 + * the new transaction, so that not only the commit code
    2956 + * knows it should clear dirty bits when it is done with the
    2957 + * buffer, but also the buffer can be checkpointed only
    2958 + * after the new transaction commits. */
    2959
    2960 - if (jh->b_next_transaction) {
    2961 - J_ASSERT(jh->b_next_transaction == transaction);
    2962 + set_buffer_freed(bh);
    2963 +
    2964 + if (!jh->b_next_transaction) {
    2965 spin_lock(&journal->j_list_lock);
    2966 - jh->b_next_transaction = NULL;
    2967 + jh->b_next_transaction = transaction;
    2968 spin_unlock(&journal->j_list_lock);
    2969 + } else {
    2970 + J_ASSERT(jh->b_next_transaction == transaction);
    2971
    2972 /*
    2973 * only drop a reference if this transaction modified
    2974 diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
    2975 index 892c88542ebd..fad4d5188aaf 100644
    2976 --- a/fs/nfs/pagelist.c
    2977 +++ b/fs/nfs/pagelist.c
    2978 @@ -975,6 +975,17 @@ static void nfs_pageio_doio(struct nfs_pageio_descriptor *desc)
    2979 }
    2980 }
    2981
    2982 +static void
    2983 +nfs_pageio_cleanup_request(struct nfs_pageio_descriptor *desc,
    2984 + struct nfs_page *req)
    2985 +{
    2986 + LIST_HEAD(head);
    2987 +
    2988 + nfs_list_remove_request(req);
    2989 + nfs_list_add_request(req, &head);
    2990 + desc->pg_completion_ops->error_cleanup(&head);
    2991 +}
    2992 +
    2993 /**
    2994 * nfs_pageio_add_request - Attempt to coalesce a request into a page list.
    2995 * @desc: destination io descriptor
    2996 @@ -1012,10 +1023,8 @@ static int __nfs_pageio_add_request(struct nfs_pageio_descriptor *desc,
    2997 nfs_page_group_unlock(req);
    2998 desc->pg_moreio = 1;
    2999 nfs_pageio_doio(desc);
    3000 - if (desc->pg_error < 0)
    3001 - return 0;
    3002 - if (mirror->pg_recoalesce)
    3003 - return 0;
    3004 + if (desc->pg_error < 0 || mirror->pg_recoalesce)
    3005 + goto out_cleanup_subreq;
    3006 /* retry add_request for this subreq */
    3007 nfs_page_group_lock(req, false);
    3008 continue;
    3009 @@ -1048,6 +1057,10 @@ err_ptr:
    3010 desc->pg_error = PTR_ERR(subreq);
    3011 nfs_page_group_unlock(req);
    3012 return 0;
    3013 +out_cleanup_subreq:
    3014 + if (req != subreq)
    3015 + nfs_pageio_cleanup_request(desc, subreq);
    3016 + return 0;
    3017 }
    3018
    3019 static int nfs_do_recoalesce(struct nfs_pageio_descriptor *desc)
    3020 @@ -1066,7 +1079,6 @@ static int nfs_do_recoalesce(struct nfs_pageio_descriptor *desc)
    3021 struct nfs_page *req;
    3022
    3023 req = list_first_entry(&head, struct nfs_page, wb_list);
    3024 - nfs_list_remove_request(req);
    3025 if (__nfs_pageio_add_request(desc, req))
    3026 continue;
    3027 if (desc->pg_error < 0) {
    3028 @@ -1141,11 +1153,14 @@ int nfs_pageio_add_request(struct nfs_pageio_descriptor *desc,
    3029 if (nfs_pgio_has_mirroring(desc))
    3030 desc->pg_mirror_idx = midx;
    3031 if (!nfs_pageio_add_request_mirror(desc, dupreq))
    3032 - goto out_failed;
    3033 + goto out_cleanup_subreq;
    3034 }
    3035
    3036 return 1;
    3037
    3038 +out_cleanup_subreq:
    3039 + if (req != dupreq)
    3040 + nfs_pageio_cleanup_request(desc, dupreq);
    3041 out_failed:
    3042 /*
    3043 * We might have failed before sending any reqs over wire.
    3044 @@ -1185,7 +1200,7 @@ static void nfs_pageio_complete_mirror(struct nfs_pageio_descriptor *desc,
    3045 desc->pg_mirror_idx = mirror_idx;
    3046 for (;;) {
    3047 nfs_pageio_doio(desc);
    3048 - if (!mirror->pg_recoalesce)
    3049 + if (desc->pg_error < 0 || !mirror->pg_recoalesce)
    3050 break;
    3051 if (!nfs_do_recoalesce(desc))
    3052 break;
    3053 diff --git a/fs/nfsd/nfs3proc.c b/fs/nfsd/nfs3proc.c
    3054 index d818e4ffd79f..00b472fe77c1 100644
    3055 --- a/fs/nfsd/nfs3proc.c
    3056 +++ b/fs/nfsd/nfs3proc.c
    3057 @@ -431,8 +431,19 @@ nfsd3_proc_readdir(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
    3058 &resp->common, nfs3svc_encode_entry);
    3059 memcpy(resp->verf, argp->verf, 8);
    3060 resp->count = resp->buffer - argp->buffer;
    3061 - if (resp->offset)
    3062 - xdr_encode_hyper(resp->offset, argp->cookie);
    3063 + if (resp->offset) {
    3064 + loff_t offset = argp->cookie;
    3065 +
    3066 + if (unlikely(resp->offset1)) {
    3067 + /* we ended up with offset on a page boundary */
    3068 + *resp->offset = htonl(offset >> 32);
    3069 + *resp->offset1 = htonl(offset & 0xffffffff);
    3070 + resp->offset1 = NULL;
    3071 + } else {
    3072 + xdr_encode_hyper(resp->offset, offset);
    3073 + }
    3074 + resp->offset = NULL;
    3075 + }
    3076
    3077 RETURN_STATUS(nfserr);
    3078 }
    3079 @@ -500,6 +511,7 @@ nfsd3_proc_readdirplus(struct svc_rqst *rqstp, struct nfsd3_readdirargs *argp,
    3080 } else {
    3081 xdr_encode_hyper(resp->offset, offset);
    3082 }
    3083 + resp->offset = NULL;
    3084 }
    3085
    3086 RETURN_STATUS(nfserr);
    3087 diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
    3088 index 452334694a5d..7e50248ca432 100644
    3089 --- a/fs/nfsd/nfs3xdr.c
    3090 +++ b/fs/nfsd/nfs3xdr.c
    3091 @@ -899,6 +899,7 @@ encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
    3092 } else {
    3093 xdr_encode_hyper(cd->offset, offset64);
    3094 }
    3095 + cd->offset = NULL;
    3096 }
    3097
    3098 /*
    3099 diff --git a/fs/nfsd/nfsctl.c b/fs/nfsd/nfsctl.c
    3100 index 797a155c9a67..f704f90db36c 100644
    3101 --- a/fs/nfsd/nfsctl.c
    3102 +++ b/fs/nfsd/nfsctl.c
    3103 @@ -1103,7 +1103,7 @@ static ssize_t write_v4_end_grace(struct file *file, char *buf, size_t size)
    3104 case 'Y':
    3105 case 'y':
    3106 case '1':
    3107 - if (nn->nfsd_serv)
    3108 + if (!nn->nfsd_serv)
    3109 return -EBUSY;
    3110 nfsd4_end_grace(nn);
    3111 break;
    3112 diff --git a/fs/pipe.c b/fs/pipe.c
    3113 index 34345535f63d..388e09a689de 100644
    3114 --- a/fs/pipe.c
    3115 +++ b/fs/pipe.c
    3116 @@ -238,6 +238,14 @@ static const struct pipe_buf_operations anon_pipe_buf_ops = {
    3117 .get = generic_pipe_buf_get,
    3118 };
    3119
    3120 +static const struct pipe_buf_operations anon_pipe_buf_nomerge_ops = {
    3121 + .can_merge = 0,
    3122 + .confirm = generic_pipe_buf_confirm,
    3123 + .release = anon_pipe_buf_release,
    3124 + .steal = anon_pipe_buf_steal,
    3125 + .get = generic_pipe_buf_get,
    3126 +};
    3127 +
    3128 static const struct pipe_buf_operations packet_pipe_buf_ops = {
    3129 .can_merge = 0,
    3130 .confirm = generic_pipe_buf_confirm,
    3131 @@ -246,6 +254,12 @@ static const struct pipe_buf_operations packet_pipe_buf_ops = {
    3132 .get = generic_pipe_buf_get,
    3133 };
    3134
    3135 +void pipe_buf_mark_unmergeable(struct pipe_buffer *buf)
    3136 +{
    3137 + if (buf->ops == &anon_pipe_buf_ops)
    3138 + buf->ops = &anon_pipe_buf_nomerge_ops;
    3139 +}
    3140 +
    3141 static ssize_t
    3142 pipe_read(struct kiocb *iocb, struct iov_iter *to)
    3143 {
    3144 diff --git a/fs/splice.c b/fs/splice.c
    3145 index 8dd79ecfd383..01983bea760c 100644
    3146 --- a/fs/splice.c
    3147 +++ b/fs/splice.c
    3148 @@ -1594,6 +1594,8 @@ retry:
    3149 */
    3150 obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
    3151
    3152 + pipe_buf_mark_unmergeable(obuf);
    3153 +
    3154 obuf->len = len;
    3155 opipe->nrbufs++;
    3156 ibuf->offset += obuf->len;
    3157 @@ -1668,6 +1670,8 @@ static int link_pipe(struct pipe_inode_info *ipipe,
    3158 */
    3159 obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
    3160
    3161 + pipe_buf_mark_unmergeable(obuf);
    3162 +
    3163 if (obuf->len > len)
    3164 obuf->len = len;
    3165
    3166 diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
    3167 index ef7962e84444..9661bb2fbe22 100644
    3168 --- a/include/linux/device-mapper.h
    3169 +++ b/include/linux/device-mapper.h
    3170 @@ -627,7 +627,7 @@ extern struct ratelimit_state dm_ratelimit_state;
    3171 */
    3172 #define dm_target_offset(ti, sector) ((sector) - (ti)->begin)
    3173
    3174 -static inline sector_t to_sector(unsigned long n)
    3175 +static inline sector_t to_sector(unsigned long long n)
    3176 {
    3177 return (n >> SECTOR_SHIFT);
    3178 }
    3179 diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
    3180 index e7497c9dde7f..4f7129389855 100644
    3181 --- a/include/linux/pipe_fs_i.h
    3182 +++ b/include/linux/pipe_fs_i.h
    3183 @@ -182,6 +182,7 @@ void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
    3184 int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
    3185 int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
    3186 void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
    3187 +void pipe_buf_mark_unmergeable(struct pipe_buffer *buf);
    3188
    3189 extern const struct pipe_buf_operations nosteal_pipe_buf_ops;
    3190
    3191 diff --git a/include/linux/property.h b/include/linux/property.h
    3192 index 459337fb44d0..d5c7ebda4113 100644
    3193 --- a/include/linux/property.h
    3194 +++ b/include/linux/property.h
    3195 @@ -233,7 +233,7 @@ struct property_entry {
    3196 #define PROPERTY_ENTRY_STRING(_name_, _val_) \
    3197 (struct property_entry) { \
    3198 .name = _name_, \
    3199 - .length = sizeof(_val_), \
    3200 + .length = sizeof(const char *), \
    3201 .is_string = true, \
    3202 { .value = { .str = _val_ } }, \
    3203 }
    3204 diff --git a/include/net/phonet/pep.h b/include/net/phonet/pep.h
    3205 index b669fe6dbc3b..98f31c7ea23d 100644
    3206 --- a/include/net/phonet/pep.h
    3207 +++ b/include/net/phonet/pep.h
    3208 @@ -63,10 +63,11 @@ struct pnpipehdr {
    3209 u8 state_after_reset; /* reset request */
    3210 u8 error_code; /* any response */
    3211 u8 pep_type; /* status indication */
    3212 - u8 data[1];
    3213 + u8 data0; /* anything else */
    3214 };
    3215 + u8 data[];
    3216 };
    3217 -#define other_pep_type data[1]
    3218 +#define other_pep_type data[0]
    3219
    3220 static inline struct pnpipehdr *pnp_hdr(struct sk_buff *skb)
    3221 {
    3222 diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
    3223 index d1a02877a42c..d0b113de3316 100644
    3224 --- a/kernel/rcu/tree.c
    3225 +++ b/kernel/rcu/tree.c
    3226 @@ -1718,15 +1718,23 @@ static int rcu_future_gp_cleanup(struct rcu_state *rsp, struct rcu_node *rnp)
    3227 }
    3228
    3229 /*
    3230 - * Awaken the grace-period kthread for the specified flavor of RCU.
    3231 - * Don't do a self-awaken, and don't bother awakening when there is
    3232 - * nothing for the grace-period kthread to do (as in several CPUs
    3233 - * raced to awaken, and we lost), and finally don't try to awaken
    3234 - * a kthread that has not yet been created.
    3235 + * Awaken the grace-period kthread. Don't do a self-awaken (unless in
    3236 + * an interrupt or softirq handler), and don't bother awakening when there
    3237 + * is nothing for the grace-period kthread to do (as in several CPUs raced
    3238 + * to awaken, and we lost), and finally don't try to awaken a kthread that
    3239 + * has not yet been created. If all those checks are passed, track some
    3240 + * debug information and awaken.
    3241 + *
    3242 + * So why do the self-wakeup when in an interrupt or softirq handler
    3243 + * in the grace-period kthread's context? Because the kthread might have
    3244 + * been interrupted just as it was going to sleep, and just after the final
    3245 + * pre-sleep check of the awaken condition. In this case, a wakeup really
    3246 + * is required, and is therefore supplied.
    3247 */
    3248 static void rcu_gp_kthread_wake(struct rcu_state *rsp)
    3249 {
    3250 - if (current == rsp->gp_kthread ||
    3251 + if ((current == rsp->gp_kthread &&
    3252 + !in_interrupt() && !in_serving_softirq()) ||
    3253 !READ_ONCE(rsp->gp_flags) ||
    3254 !rsp->gp_kthread)
    3255 return;
    3256 diff --git a/kernel/sysctl.c b/kernel/sysctl.c
    3257 index 93c7b02279b9..efd340a510a9 100644
    3258 --- a/kernel/sysctl.c
    3259 +++ b/kernel/sysctl.c
    3260 @@ -2377,7 +2377,16 @@ static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
    3261 {
    3262 struct do_proc_dointvec_minmax_conv_param *param = data;
    3263 if (write) {
    3264 - int val = *negp ? -*lvalp : *lvalp;
    3265 + int val;
    3266 + if (*negp) {
    3267 + if (*lvalp > (unsigned long) INT_MAX + 1)
    3268 + return -EINVAL;
    3269 + val = -*lvalp;
    3270 + } else {
    3271 + if (*lvalp > (unsigned long) INT_MAX)
    3272 + return -EINVAL;
    3273 + val = *lvalp;
    3274 + }
    3275 if ((param->min && *param->min > val) ||
    3276 (param->max && *param->max < val))
    3277 return -EINVAL;
    3278 diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
    3279 index 6786c507f1f9..f18dedf9195e 100644
    3280 --- a/kernel/trace/trace.c
    3281 +++ b/kernel/trace/trace.c
    3282 @@ -5057,7 +5057,6 @@ out:
    3283 return ret;
    3284
    3285 fail:
    3286 - kfree(iter->trace);
    3287 kfree(iter);
    3288 __trace_array_put(tr);
    3289 mutex_unlock(&trace_types_lock);
    3290 diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_hist.c
    3291 index 0664044ade06..766e5ccad60a 100644
    3292 --- a/kernel/trace/trace_events_hist.c
    3293 +++ b/kernel/trace/trace_events_hist.c
    3294 @@ -871,9 +871,10 @@ static inline void add_to_key(char *compound_key, void *key,
    3295 /* ensure NULL-termination */
    3296 if (size > key_field->size - 1)
    3297 size = key_field->size - 1;
    3298 - }
    3299
    3300 - memcpy(compound_key + key_field->offset, key, size);
    3301 + strncpy(compound_key + key_field->offset, (char *)key, size);
    3302 + } else
    3303 + memcpy(compound_key + key_field->offset, key, size);
    3304 }
    3305
    3306 static void event_hist_trigger(struct event_trigger_data *data, void *rec)
    3307 diff --git a/lib/assoc_array.c b/lib/assoc_array.c
    3308 index 5cd093589c5a..3b46c5433b7a 100644
    3309 --- a/lib/assoc_array.c
    3310 +++ b/lib/assoc_array.c
    3311 @@ -781,9 +781,11 @@ all_leaves_cluster_together:
    3312 new_s0->index_key[i] =
    3313 ops->get_key_chunk(index_key, i * ASSOC_ARRAY_KEY_CHUNK_SIZE);
    3314
    3315 - blank = ULONG_MAX << (level & ASSOC_ARRAY_KEY_CHUNK_MASK);
    3316 - pr_devel("blank off [%zu] %d: %lx\n", keylen - 1, level, blank);
    3317 - new_s0->index_key[keylen - 1] &= ~blank;
    3318 + if (level & ASSOC_ARRAY_KEY_CHUNK_MASK) {
    3319 + blank = ULONG_MAX << (level & ASSOC_ARRAY_KEY_CHUNK_MASK);
    3320 + pr_devel("blank off [%zu] %d: %lx\n", keylen - 1, level, blank);
    3321 + new_s0->index_key[keylen - 1] &= ~blank;
    3322 + }
    3323
    3324 /* This now reduces to a node splitting exercise for which we'll need
    3325 * to regenerate the disparity table.
    3326 diff --git a/mm/gup.c b/mm/gup.c
    3327 index d71da7216c6e..99c2f10188c0 100644
    3328 --- a/mm/gup.c
    3329 +++ b/mm/gup.c
    3330 @@ -1423,7 +1423,8 @@ static int gup_pmd_range(pud_t pud, unsigned long addr, unsigned long end,
    3331 if (pmd_none(pmd))
    3332 return 0;
    3333
    3334 - if (unlikely(pmd_trans_huge(pmd) || pmd_huge(pmd))) {
    3335 + if (unlikely(pmd_trans_huge(pmd) || pmd_huge(pmd) ||
    3336 + pmd_devmap(pmd))) {
    3337 /*
    3338 * NUMA hinting faults need to be handled in the GUP
    3339 * slowpath for accounting purposes and so that they
    3340 diff --git a/mm/memory-failure.c b/mm/memory-failure.c
    3341 index 4f1f5fd12042..d6524dce43b2 100644
    3342 --- a/mm/memory-failure.c
    3343 +++ b/mm/memory-failure.c
    3344 @@ -1705,19 +1705,17 @@ static int soft_offline_in_use_page(struct page *page, int flags)
    3345 struct page *hpage = compound_head(page);
    3346
    3347 if (!PageHuge(page) && PageTransHuge(hpage)) {
    3348 - lock_page(hpage);
    3349 - if (!PageAnon(hpage) || unlikely(split_huge_page(hpage))) {
    3350 - unlock_page(hpage);
    3351 - if (!PageAnon(hpage))
    3352 + lock_page(page);
    3353 + if (!PageAnon(page) || unlikely(split_huge_page(page))) {
    3354 + unlock_page(page);
    3355 + if (!PageAnon(page))
    3356 pr_info("soft offline: %#lx: non anonymous thp\n", page_to_pfn(page));
    3357 else
    3358 pr_info("soft offline: %#lx: thp split failed\n", page_to_pfn(page));
    3359 - put_hwpoison_page(hpage);
    3360 + put_hwpoison_page(page);
    3361 return -EBUSY;
    3362 }
    3363 - unlock_page(hpage);
    3364 - get_hwpoison_page(page);
    3365 - put_hwpoison_page(hpage);
    3366 + unlock_page(page);
    3367 }
    3368
    3369 if (PageHuge(page))
    3370 diff --git a/mm/page_alloc.c b/mm/page_alloc.c
    3371 index 3af727d95c17..05f141e39ac1 100644
    3372 --- a/mm/page_alloc.c
    3373 +++ b/mm/page_alloc.c
    3374 @@ -3955,11 +3955,11 @@ refill:
    3375 /* Even if we own the page, we do not use atomic_set().
    3376 * This would break get_page_unless_zero() users.
    3377 */
    3378 - page_ref_add(page, size - 1);
    3379 + page_ref_add(page, size);
    3380
    3381 /* reset page count bias and offset to start of new frag */
    3382 nc->pfmemalloc = page_is_pfmemalloc(page);
    3383 - nc->pagecnt_bias = size;
    3384 + nc->pagecnt_bias = size + 1;
    3385 nc->offset = size;
    3386 }
    3387
    3388 @@ -3975,10 +3975,10 @@ refill:
    3389 size = nc->size;
    3390 #endif
    3391 /* OK, page count is 0, we can safely set it */
    3392 - set_page_count(page, size);
    3393 + set_page_count(page, size + 1);
    3394
    3395 /* reset page count bias and offset to start of new frag */
    3396 - nc->pagecnt_bias = size;
    3397 + nc->pagecnt_bias = size + 1;
    3398 offset = size - fragsz;
    3399 }
    3400
    3401 diff --git a/mm/shmem.c b/mm/shmem.c
    3402 index 9b17bd4cbc5e..944242491059 100644
    3403 --- a/mm/shmem.c
    3404 +++ b/mm/shmem.c
    3405 @@ -2896,16 +2896,20 @@ static int shmem_create(struct inode *dir, struct dentry *dentry, umode_t mode,
    3406 static int shmem_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
    3407 {
    3408 struct inode *inode = d_inode(old_dentry);
    3409 - int ret;
    3410 + int ret = 0;
    3411
    3412 /*
    3413 * No ordinary (disk based) filesystem counts links as inodes;
    3414 * but each new link needs a new dentry, pinning lowmem, and
    3415 * tmpfs dentries cannot be pruned until they are unlinked.
    3416 + * But if an O_TMPFILE file is linked into the tmpfs, the
    3417 + * first link must skip that, to get the accounting right.
    3418 */
    3419 - ret = shmem_reserve_inode(inode->i_sb);
    3420 - if (ret)
    3421 - goto out;
    3422 + if (inode->i_nlink) {
    3423 + ret = shmem_reserve_inode(inode->i_sb);
    3424 + if (ret)
    3425 + goto out;
    3426 + }
    3427
    3428 dir->i_size += BOGO_DIRENT_SIZE;
    3429 inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
    3430 diff --git a/mm/vmalloc.c b/mm/vmalloc.c
    3431 index fa598162dbf0..e6aa073f01df 100644
    3432 --- a/mm/vmalloc.c
    3433 +++ b/mm/vmalloc.c
    3434 @@ -2191,7 +2191,7 @@ int remap_vmalloc_range_partial(struct vm_area_struct *vma, unsigned long uaddr,
    3435 if (!(area->flags & VM_USERMAP))
    3436 return -EINVAL;
    3437
    3438 - if (kaddr + size > area->addr + area->size)
    3439 + if (kaddr + size > area->addr + get_vm_area_size(area))
    3440 return -EINVAL;
    3441
    3442 do {
    3443 diff --git a/net/9p/client.c b/net/9p/client.c
    3444 index 142afe70edb9..f1517ca8aba3 100644
    3445 --- a/net/9p/client.c
    3446 +++ b/net/9p/client.c
    3447 @@ -1058,7 +1058,7 @@ struct p9_client *p9_client_create(const char *dev_name, char *options)
    3448 p9_debug(P9_DEBUG_ERROR,
    3449 "Please specify a msize of at least 4k\n");
    3450 err = -EINVAL;
    3451 - goto free_client;
    3452 + goto close_trans;
    3453 }
    3454
    3455 err = p9_client_version(clnt);
    3456 diff --git a/net/phonet/pep.c b/net/phonet/pep.c
    3457 index 850a86cde0b3..f6aa532bcbf6 100644
    3458 --- a/net/phonet/pep.c
    3459 +++ b/net/phonet/pep.c
    3460 @@ -131,7 +131,7 @@ static int pep_indicate(struct sock *sk, u8 id, u8 code,
    3461 ph->utid = 0;
    3462 ph->message_id = id;
    3463 ph->pipe_handle = pn->pipe_handle;
    3464 - ph->data[0] = code;
    3465 + ph->error_code = code;
    3466 return pn_skb_send(sk, skb, NULL);
    3467 }
    3468
    3469 @@ -152,7 +152,7 @@ static int pipe_handler_request(struct sock *sk, u8 id, u8 code,
    3470 ph->utid = id; /* whatever */
    3471 ph->message_id = id;
    3472 ph->pipe_handle = pn->pipe_handle;
    3473 - ph->data[0] = code;
    3474 + ph->error_code = code;
    3475 return pn_skb_send(sk, skb, NULL);
    3476 }
    3477
    3478 @@ -207,7 +207,7 @@ static int pep_ctrlreq_error(struct sock *sk, struct sk_buff *oskb, u8 code,
    3479 struct pnpipehdr *ph;
    3480 struct sockaddr_pn dst;
    3481 u8 data[4] = {
    3482 - oph->data[0], /* PEP type */
    3483 + oph->pep_type, /* PEP type */
    3484 code, /* error code, at an unusual offset */
    3485 PAD, PAD,
    3486 };
    3487 @@ -220,7 +220,7 @@ static int pep_ctrlreq_error(struct sock *sk, struct sk_buff *oskb, u8 code,
    3488 ph->utid = oph->utid;
    3489 ph->message_id = PNS_PEP_CTRL_RESP;
    3490 ph->pipe_handle = oph->pipe_handle;
    3491 - ph->data[0] = oph->data[1]; /* CTRL id */
    3492 + ph->data0 = oph->data[0]; /* CTRL id */
    3493
    3494 pn_skb_get_src_sockaddr(oskb, &dst);
    3495 return pn_skb_send(sk, skb, &dst);
    3496 @@ -271,17 +271,17 @@ static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb)
    3497 return -EINVAL;
    3498
    3499 hdr = pnp_hdr(skb);
    3500 - if (hdr->data[0] != PN_PEP_TYPE_COMMON) {
    3501 + if (hdr->pep_type != PN_PEP_TYPE_COMMON) {
    3502 net_dbg_ratelimited("Phonet unknown PEP type: %u\n",
    3503 - (unsigned int)hdr->data[0]);
    3504 + (unsigned int)hdr->pep_type);
    3505 return -EOPNOTSUPP;
    3506 }
    3507
    3508 - switch (hdr->data[1]) {
    3509 + switch (hdr->data[0]) {
    3510 case PN_PEP_IND_FLOW_CONTROL:
    3511 switch (pn->tx_fc) {
    3512 case PN_LEGACY_FLOW_CONTROL:
    3513 - switch (hdr->data[4]) {
    3514 + switch (hdr->data[3]) {
    3515 case PEP_IND_BUSY:
    3516 atomic_set(&pn->tx_credits, 0);
    3517 break;
    3518 @@ -291,7 +291,7 @@ static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb)
    3519 }
    3520 break;
    3521 case PN_ONE_CREDIT_FLOW_CONTROL:
    3522 - if (hdr->data[4] == PEP_IND_READY)
    3523 + if (hdr->data[3] == PEP_IND_READY)
    3524 atomic_set(&pn->tx_credits, wake = 1);
    3525 break;
    3526 }
    3527 @@ -300,12 +300,12 @@ static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb)
    3528 case PN_PEP_IND_ID_MCFC_GRANT_CREDITS:
    3529 if (pn->tx_fc != PN_MULTI_CREDIT_FLOW_CONTROL)
    3530 break;
    3531 - atomic_add(wake = hdr->data[4], &pn->tx_credits);
    3532 + atomic_add(wake = hdr->data[3], &pn->tx_credits);
    3533 break;
    3534
    3535 default:
    3536 net_dbg_ratelimited("Phonet unknown PEP indication: %u\n",
    3537 - (unsigned int)hdr->data[1]);
    3538 + (unsigned int)hdr->data[0]);
    3539 return -EOPNOTSUPP;
    3540 }
    3541 if (wake)
    3542 @@ -317,7 +317,7 @@ static int pipe_rcv_created(struct sock *sk, struct sk_buff *skb)
    3543 {
    3544 struct pep_sock *pn = pep_sk(sk);
    3545 struct pnpipehdr *hdr = pnp_hdr(skb);
    3546 - u8 n_sb = hdr->data[0];
    3547 + u8 n_sb = hdr->data0;
    3548
    3549 pn->rx_fc = pn->tx_fc = PN_LEGACY_FLOW_CONTROL;
    3550 __skb_pull(skb, sizeof(*hdr));
    3551 @@ -505,7 +505,7 @@ static int pep_connresp_rcv(struct sock *sk, struct sk_buff *skb)
    3552 return -ECONNREFUSED;
    3553
    3554 /* Parse sub-blocks */
    3555 - n_sb = hdr->data[4];
    3556 + n_sb = hdr->data[3];
    3557 while (n_sb > 0) {
    3558 u8 type, buf[6], len = sizeof(buf);
    3559 const u8 *data = pep_get_sb(skb, &type, &len, buf);
    3560 @@ -738,7 +738,7 @@ static int pipe_do_remove(struct sock *sk)
    3561 ph->utid = 0;
    3562 ph->message_id = PNS_PIPE_REMOVE_REQ;
    3563 ph->pipe_handle = pn->pipe_handle;
    3564 - ph->data[0] = PAD;
    3565 + ph->data0 = PAD;
    3566 return pn_skb_send(sk, skb, NULL);
    3567 }
    3568
    3569 @@ -815,7 +815,7 @@ static struct sock *pep_sock_accept(struct sock *sk, int flags, int *errp)
    3570 peer_type = hdr->other_pep_type << 8;
    3571
    3572 /* Parse sub-blocks (options) */
    3573 - n_sb = hdr->data[4];
    3574 + n_sb = hdr->data[3];
    3575 while (n_sb > 0) {
    3576 u8 type, buf[1], len = sizeof(buf);
    3577 const u8 *data = pep_get_sb(skb, &type, &len, buf);
    3578 @@ -1106,7 +1106,7 @@ static int pipe_skb_send(struct sock *sk, struct sk_buff *skb)
    3579 ph->utid = 0;
    3580 if (pn->aligned) {
    3581 ph->message_id = PNS_PIPE_ALIGNED_DATA;
    3582 - ph->data[0] = 0; /* padding */
    3583 + ph->data0 = 0; /* padding */
    3584 } else
    3585 ph->message_id = PNS_PIPE_DATA;
    3586 ph->pipe_handle = pn->pipe_handle;
    3587 diff --git a/sound/soc/fsl/fsl_esai.c b/sound/soc/fsl/fsl_esai.c
    3588 index 3ef174531344..23ab0d169c11 100644
    3589 --- a/sound/soc/fsl/fsl_esai.c
    3590 +++ b/sound/soc/fsl/fsl_esai.c
    3591 @@ -396,7 +396,8 @@ static int fsl_esai_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
    3592 break;
    3593 case SND_SOC_DAIFMT_RIGHT_J:
    3594 /* Data on rising edge of bclk, frame high, right aligned */
    3595 - xccr |= ESAI_xCCR_xCKP | ESAI_xCCR_xHCKP | ESAI_xCR_xWA;
    3596 + xccr |= ESAI_xCCR_xCKP | ESAI_xCCR_xHCKP;
    3597 + xcr |= ESAI_xCR_xWA;
    3598 break;
    3599 case SND_SOC_DAIFMT_DSP_A:
    3600 /* Data on rising edge of bclk, frame high, 1clk before data */
    3601 @@ -453,12 +454,12 @@ static int fsl_esai_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
    3602 return -EINVAL;
    3603 }
    3604
    3605 - mask = ESAI_xCR_xFSL | ESAI_xCR_xFSR;
    3606 + mask = ESAI_xCR_xFSL | ESAI_xCR_xFSR | ESAI_xCR_xWA;
    3607 regmap_update_bits(esai_priv->regmap, REG_ESAI_TCR, mask, xcr);
    3608 regmap_update_bits(esai_priv->regmap, REG_ESAI_RCR, mask, xcr);
    3609
    3610 mask = ESAI_xCCR_xCKP | ESAI_xCCR_xHCKP | ESAI_xCCR_xFSP |
    3611 - ESAI_xCCR_xFSD | ESAI_xCCR_xCKD | ESAI_xCR_xWA;
    3612 + ESAI_xCCR_xFSD | ESAI_xCCR_xCKD;
    3613 regmap_update_bits(esai_priv->regmap, REG_ESAI_TCCR, mask, xccr);
    3614 regmap_update_bits(esai_priv->regmap, REG_ESAI_RCCR, mask, xccr);
    3615
    3616 diff --git a/sound/soc/soc-topology.c b/sound/soc/soc-topology.c
    3617 index d6b48c796bfc..086fe4d27f60 100644
    3618 --- a/sound/soc/soc-topology.c
    3619 +++ b/sound/soc/soc-topology.c
    3620 @@ -1989,6 +1989,7 @@ int snd_soc_tplg_component_load(struct snd_soc_component *comp,
    3621 struct snd_soc_tplg_ops *ops, const struct firmware *fw, u32 id)
    3622 {
    3623 struct soc_tplg tplg;
    3624 + int ret;
    3625
    3626 /* setup parsing context */
    3627 memset(&tplg, 0, sizeof(tplg));
    3628 @@ -2002,7 +2003,12 @@ int snd_soc_tplg_component_load(struct snd_soc_component *comp,
    3629 tplg.bytes_ext_ops = ops->bytes_ext_ops;
    3630 tplg.bytes_ext_ops_count = ops->bytes_ext_ops_count;
    3631
    3632 - return soc_tplg_load(&tplg);
    3633 + ret = soc_tplg_load(&tplg);
    3634 + /* free the created components if fail to load topology */
    3635 + if (ret)
    3636 + snd_soc_tplg_component_remove(comp, SND_SOC_TPLG_INDEX_ALL);
    3637 +
    3638 + return ret;
    3639 }
    3640 EXPORT_SYMBOL_GPL(snd_soc_tplg_component_load);
    3641
    3642 diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c
    3643 index 29d015e2d900..b87221efdf7e 100644
    3644 --- a/tools/perf/util/auxtrace.c
    3645 +++ b/tools/perf/util/auxtrace.c
    3646 @@ -1244,9 +1244,9 @@ static int __auxtrace_mmap__read(struct auxtrace_mmap *mm,
    3647 }
    3648
    3649 /* padding must be written by fn() e.g. record__process_auxtrace() */
    3650 - padding = size & 7;
    3651 + padding = size & (PERF_AUXTRACE_RECORD_ALIGNMENT - 1);
    3652 if (padding)
    3653 - padding = 8 - padding;
    3654 + padding = PERF_AUXTRACE_RECORD_ALIGNMENT - padding;
    3655
    3656 memset(&ev, 0, sizeof(ev));
    3657 ev.auxtrace.header.type = PERF_RECORD_AUXTRACE;
    3658 diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h
    3659 index 26fb1ee5746a..1b6963e09934 100644
    3660 --- a/tools/perf/util/auxtrace.h
    3661 +++ b/tools/perf/util/auxtrace.h
    3662 @@ -37,6 +37,9 @@ struct record_opts;
    3663 struct auxtrace_info_event;
    3664 struct events_stats;
    3665
    3666 +/* Auxtrace records must have the same alignment as perf event records */
    3667 +#define PERF_AUXTRACE_RECORD_ALIGNMENT 8
    3668 +
    3669 enum auxtrace_type {
    3670 PERF_AUXTRACE_UNKNOWN,
    3671 PERF_AUXTRACE_INTEL_PT,
    3672 diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
    3673 index d27715ff9a5f..94764efb0a6a 100644
    3674 --- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
    3675 +++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
    3676 @@ -26,6 +26,7 @@
    3677
    3678 #include "../cache.h"
    3679 #include "../util.h"
    3680 +#include "../auxtrace.h"
    3681
    3682 #include "intel-pt-insn-decoder.h"
    3683 #include "intel-pt-pkt-decoder.h"
    3684 @@ -1311,7 +1312,6 @@ static int intel_pt_overflow(struct intel_pt_decoder *decoder)
    3685 {
    3686 intel_pt_log("ERROR: Buffer overflow\n");
    3687 intel_pt_clear_tx_flags(decoder);
    3688 - decoder->cbr = 0;
    3689 decoder->timestamp_insn_cnt = 0;
    3690 decoder->pkt_state = INTEL_PT_STATE_ERR_RESYNC;
    3691 decoder->overflow = true;
    3692 @@ -2351,6 +2351,34 @@ static int intel_pt_tsc_cmp(uint64_t tsc1, uint64_t tsc2)
    3693 }
    3694 }
    3695
    3696 +#define MAX_PADDING (PERF_AUXTRACE_RECORD_ALIGNMENT - 1)
    3697 +
    3698 +/**
    3699 + * adj_for_padding - adjust overlap to account for padding.
    3700 + * @buf_b: second buffer
    3701 + * @buf_a: first buffer
    3702 + * @len_a: size of first buffer
    3703 + *
    3704 + * @buf_a might have up to 7 bytes of padding appended. Adjust the overlap
    3705 + * accordingly.
    3706 + *
    3707 + * Return: A pointer into @buf_b from where non-overlapped data starts
    3708 + */
    3709 +static unsigned char *adj_for_padding(unsigned char *buf_b,
    3710 + unsigned char *buf_a, size_t len_a)
    3711 +{
    3712 + unsigned char *p = buf_b - MAX_PADDING;
    3713 + unsigned char *q = buf_a + len_a - MAX_PADDING;
    3714 + int i;
    3715 +
    3716 + for (i = MAX_PADDING; i; i--, p++, q++) {
    3717 + if (*p != *q)
    3718 + break;
    3719 + }
    3720 +
    3721 + return p;
    3722 +}
    3723 +
    3724 /**
    3725 * intel_pt_find_overlap_tsc - determine start of non-overlapped trace data
    3726 * using TSC.
    3727 @@ -2401,8 +2429,11 @@ static unsigned char *intel_pt_find_overlap_tsc(unsigned char *buf_a,
    3728
    3729 /* Same TSC, so buffers are consecutive */
    3730 if (!cmp && rem_b >= rem_a) {
    3731 + unsigned char *start;
    3732 +
    3733 *consecutive = true;
    3734 - return buf_b + len_b - (rem_b - rem_a);
    3735 + start = buf_b + len_b - (rem_b - rem_a);
    3736 + return adj_for_padding(start, buf_a, len_a);
    3737 }
    3738 if (cmp < 0)
    3739 return buf_b; /* tsc_a < tsc_b => no overlap */
    3740 @@ -2465,7 +2496,7 @@ unsigned char *intel_pt_find_overlap(unsigned char *buf_a, size_t len_a,
    3741 found = memmem(buf_a, len_a, buf_b, len_a);
    3742 if (found) {
    3743 *consecutive = true;
    3744 - return buf_b + len_a;
    3745 + return adj_for_padding(buf_b + len_a, buf_a, len_a);
    3746 }
    3747
    3748 /* Try again at next PSB in buffer 'a' */
    3749 diff --git a/tools/perf/util/intel-pt.c b/tools/perf/util/intel-pt.c
    3750 index d40ab4cf8932..24c6621e2d95 100644
    3751 --- a/tools/perf/util/intel-pt.c
    3752 +++ b/tools/perf/util/intel-pt.c
    3753 @@ -2259,6 +2259,8 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
    3754 }
    3755
    3756 pt->timeless_decoding = intel_pt_timeless_decoding(pt);
    3757 + if (pt->timeless_decoding && !pt->tc.time_mult)
    3758 + pt->tc.time_mult = 1;
    3759 pt->have_tsc = intel_pt_have_tsc(pt);
    3760 pt->sampling_mode = false;
    3761 pt->est_tsc = !pt->timeless_decoding;