commit: 39fe86bc72de6a2976071057107ace490bacb774 Author: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> AuthorDate: Tue Nov 21 09:05:51 2017 +0000 Commit: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> CommitDate: Tue Nov 21 09:05:51 2017 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=39fe86bc
linux kernel 4.9.64 0000_README | 4 + 1063_linux-4.9.64.patch | 2758 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2762 insertions(+) diff --git a/0000_README b/0000_README index 7c70a9e..c8f1c9c 100644 --- a/0000_README +++ b/0000_README @@ -295,6 +295,10 @@ Patch: 1062_linux-4.9.63.patch From: http://www.kernel.org Desc: Linux 4.9.63 +Patch: 1063_linux-4.9.64.patch +From: http://www.kernel.org +Desc: Linux 4.9.64 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1063_linux-4.9.64.patch b/1063_linux-4.9.64.patch new file mode 100644 index 0000000..469d63b --- /dev/null +++ b/1063_linux-4.9.64.patch @@ -0,0 +1,2758 @@ +diff --git a/Documentation/devicetree/bindings/arm/davinci.txt b/Documentation/devicetree/bindings/arm/davinci.txt +index 715622c36260..f0841ce725b5 100644 +--- a/Documentation/devicetree/bindings/arm/davinci.txt ++++ b/Documentation/devicetree/bindings/arm/davinci.txt +@@ -13,10 +13,6 @@ EnBW AM1808 based CMC board + Required root node properties: + - compatible = "enbw,cmc", "ti,da850; + +-LEGO MINDSTORMS EV3 (AM1808 based) +-Required root node properties: +- - compatible = "lego,ev3", "ti,da850"; +- + Generic DaVinci Boards + ---------------------- + +diff --git a/Documentation/devicetree/bindings/vendor-prefixes.txt b/Documentation/devicetree/bindings/vendor-prefixes.txt +index f949a22bcd74..bceffffb7502 100644 +--- a/Documentation/devicetree/bindings/vendor-prefixes.txt ++++ b/Documentation/devicetree/bindings/vendor-prefixes.txt +@@ -154,7 +154,6 @@ kosagi Sutajio Ko-Usagi PTE Ltd. + kyo Kyocera Corporation + lacie LaCie + lantiq Lantiq Semiconductor +-lego LEGO Systems A/S + lenovo Lenovo Group Ltd. + lg LG Corporation + linux Linux-specific binding +diff --git a/Makefile b/Makefile +index 339d4a85ffba..d29cace0da6d 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,6 +1,6 @@ + VERSION = 4 + PATCHLEVEL = 9 +-SUBLEVEL = 63 ++SUBLEVEL = 64 + EXTRAVERSION = + NAME = Roaring Lionus + +diff --git a/arch/arm/boot/dts/am33xx.dtsi b/arch/arm/boot/dts/am33xx.dtsi +index 795c1467fa50..a3277e6436d5 100644 +--- a/arch/arm/boot/dts/am33xx.dtsi ++++ b/arch/arm/boot/dts/am33xx.dtsi +@@ -143,10 +143,11 @@ + }; + + scm_conf: scm_conf@0 { +- compatible = "syscon"; ++ compatible = "syscon", "simple-bus"; + reg = <0x0 0x800>; + #address-cells = <1>; + #size-cells = <1>; ++ ranges = <0 0 0x800>; + + scm_clocks: clocks { + #address-cells = <1>; +diff --git a/arch/arm/boot/dts/dm814x.dtsi b/arch/arm/boot/dts/dm814x.dtsi +index d87efab24fa2..ff57a20af9cd 100644 +--- a/arch/arm/boot/dts/dm814x.dtsi ++++ b/arch/arm/boot/dts/dm814x.dtsi +@@ -252,7 +252,7 @@ + }; + + uart1: uart@20000 { +- compatible = "ti,omap3-uart"; ++ compatible = "ti,am3352-uart", "ti,omap3-uart"; + ti,hwmods = "uart1"; + reg = <0x20000 0x2000>; + clock-frequency = <48000000>; +@@ -262,7 +262,7 @@ + }; + + uart2: uart@22000 { +- compatible = "ti,omap3-uart"; ++ compatible = "ti,am3352-uart", "ti,omap3-uart"; + ti,hwmods = "uart2"; + reg = <0x22000 0x2000>; + clock-frequency = <48000000>; +@@ -272,7 +272,7 @@ + }; + + uart3: uart@24000 { +- compatible = "ti,omap3-uart"; ++ compatible = "ti,am3352-uart", "ti,omap3-uart"; + ti,hwmods = "uart3"; + reg = <0x24000 0x2000>; + clock-frequency = <48000000>; +@@ -332,10 +332,11 @@ + ranges = <0 0x140000 0x20000>; + + scm_conf: scm_conf@0 { +- compatible = "syscon"; ++ compatible = "syscon", "simple-bus"; + reg = <0x0 0x800>; + #address-cells = <1>; + #size-cells = <1>; ++ ranges = <0 0 0x800>; + + scm_clocks: clocks { + #address-cells = <1>; +diff --git a/arch/arm/boot/dts/dm816x.dtsi b/arch/arm/boot/dts/dm816x.dtsi +index cbdfbc4e4a26..62c0a6155360 100644 +--- a/arch/arm/boot/dts/dm816x.dtsi ++++ b/arch/arm/boot/dts/dm816x.dtsi +@@ -371,7 +371,7 @@ + }; + + uart1: uart@48020000 { +- compatible = "ti,omap3-uart"; ++ compatible = "ti,am3352-uart", "ti,omap3-uart"; + ti,hwmods = "uart1"; + reg = <0x48020000 0x2000>; + clock-frequency = <48000000>; +@@ -381,7 +381,7 @@ + }; + + uart2: uart@48022000 { +- compatible = "ti,omap3-uart"; ++ compatible = "ti,am3352-uart", "ti,omap3-uart"; + ti,hwmods = "uart2"; + reg = <0x48022000 0x2000>; + clock-frequency = <48000000>; +@@ -391,7 +391,7 @@ + }; + + uart3: uart@48024000 { +- compatible = "ti,omap3-uart"; ++ compatible = "ti,am3352-uart", "ti,omap3-uart"; + ti,hwmods = "uart3"; + reg = <0x48024000 0x2000>; + clock-frequency = <48000000>; +diff --git a/arch/arm/boot/dts/omap5-uevm.dts b/arch/arm/boot/dts/omap5-uevm.dts +index 53d31a87b44b..f3a3e6be79fe 100644 +--- a/arch/arm/boot/dts/omap5-uevm.dts ++++ b/arch/arm/boot/dts/omap5-uevm.dts +@@ -18,6 +18,10 @@ + reg = <0 0x80000000 0 0x7f000000>; /* 2032 MB */ + }; + ++ aliases { ++ ethernet = ðernet; ++ }; ++ + leds { + compatible = "gpio-leds"; + led1 { +@@ -72,6 +76,23 @@ + >; + }; + ++&usbhsehci { ++ #address-cells = <1>; ++ #size-cells = <0>; ++ ++ hub@2 { ++ compatible = "usb424,3503"; ++ reg = <2>; ++ #address-cells = <1>; ++ #size-cells = <0>; ++ }; ++ ++ ethernet: usbether@3 { ++ compatible = "usb424,9730"; ++ reg = <3>; ++ }; ++}; ++ + &wlcore { + compatible = "ti,wl1837"; + }; +diff --git a/arch/arm/crypto/aesbs-glue.c b/arch/arm/crypto/aesbs-glue.c +index 0511a6cafe24..5d934a0039d7 100644 +--- a/arch/arm/crypto/aesbs-glue.c ++++ b/arch/arm/crypto/aesbs-glue.c +@@ -363,7 +363,7 @@ static struct crypto_alg aesbs_algs[] = { { + }, { + .cra_name = "cbc(aes)", + .cra_driver_name = "cbc-aes-neonbs", +- .cra_priority = 300, ++ .cra_priority = 250, + .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER|CRYPTO_ALG_ASYNC, + .cra_blocksize = AES_BLOCK_SIZE, + .cra_ctxsize = sizeof(struct async_helper_ctx), +@@ -383,7 +383,7 @@ static struct crypto_alg aesbs_algs[] = { { + }, { + .cra_name = "ctr(aes)", + .cra_driver_name = "ctr-aes-neonbs", +- .cra_priority = 300, ++ .cra_priority = 250, + .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER|CRYPTO_ALG_ASYNC, + .cra_blocksize = 1, + .cra_ctxsize = sizeof(struct async_helper_ctx), +@@ -403,7 +403,7 @@ static struct crypto_alg aesbs_algs[] = { { + }, { + .cra_name = "xts(aes)", + .cra_driver_name = "xts-aes-neonbs", +- .cra_priority = 300, ++ .cra_priority = 250, + .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER|CRYPTO_ALG_ASYNC, + .cra_blocksize = AES_BLOCK_SIZE, + .cra_ctxsize = sizeof(struct async_helper_ctx), +diff --git a/arch/arm/mach-omap2/pdata-quirks.c b/arch/arm/mach-omap2/pdata-quirks.c +index 05e20aaf68dd..770216baa737 100644 +--- a/arch/arm/mach-omap2/pdata-quirks.c ++++ b/arch/arm/mach-omap2/pdata-quirks.c +@@ -600,7 +600,6 @@ static void pdata_quirks_check(struct pdata_init *quirks) + if (of_machine_is_compatible(quirks->compatible)) { + if (quirks->fn) + quirks->fn(); +- break; + } + quirks++; + } +diff --git a/arch/arm64/boot/dts/broadcom/ns2.dtsi b/arch/arm64/boot/dts/broadcom/ns2.dtsi +index d95dc408629a..a16b1b3f9fc6 100644 +--- a/arch/arm64/boot/dts/broadcom/ns2.dtsi ++++ b/arch/arm64/boot/dts/broadcom/ns2.dtsi +@@ -30,6 +30,8 @@ + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + ++/memreserve/ 0x81000000 0x00200000; ++ + #include <dt-bindings/interrupt-controller/arm-gic.h> + #include <dt-bindings/clock/bcm-ns2.h> + +diff --git a/arch/mips/include/asm/asm.h b/arch/mips/include/asm/asm.h +index 7c26b28bf252..859cf7048347 100644 +--- a/arch/mips/include/asm/asm.h ++++ b/arch/mips/include/asm/asm.h +@@ -54,7 +54,8 @@ + .align 2; \ + .type symbol, @function; \ + .ent symbol, 0; \ +-symbol: .frame sp, 0, ra ++symbol: .frame sp, 0, ra; \ ++ .insn + + /* + * NESTED - declare nested routine entry point +@@ -63,8 +64,9 @@ symbol: .frame sp, 0, ra + .globl symbol; \ + .align 2; \ + .type symbol, @function; \ +- .ent symbol, 0; \ +-symbol: .frame sp, framesize, rpc ++ .ent symbol, 0; \ ++symbol: .frame sp, framesize, rpc; \ ++ .insn + + /* + * END - mark end of function +@@ -86,7 +88,7 @@ symbol: .frame sp, framesize, rpc + #define FEXPORT(symbol) \ + .globl symbol; \ + .type symbol, @function; \ +-symbol: ++symbol: .insn + + /* + * ABS - export absolute symbol +diff --git a/arch/mips/include/asm/mips-cm.h b/arch/mips/include/asm/mips-cm.h +index b6845db453a3..163317fd3d7e 100644 +--- a/arch/mips/include/asm/mips-cm.h ++++ b/arch/mips/include/asm/mips-cm.h +@@ -187,6 +187,7 @@ BUILD_CM_R_(config, MIPS_CM_GCB_OFS + 0x00) + BUILD_CM_RW(base, MIPS_CM_GCB_OFS + 0x08) + BUILD_CM_RW(access, MIPS_CM_GCB_OFS + 0x20) + BUILD_CM_R_(rev, MIPS_CM_GCB_OFS + 0x30) ++BUILD_CM_RW(err_control, MIPS_CM_GCB_OFS + 0x38) + BUILD_CM_RW(error_mask, MIPS_CM_GCB_OFS + 0x40) + BUILD_CM_RW(error_cause, MIPS_CM_GCB_OFS + 0x48) + BUILD_CM_RW(error_addr, MIPS_CM_GCB_OFS + 0x50) +@@ -266,6 +267,12 @@ BUILD_CM_Cx_R_(tcid_8_priority, 0x80) + #define CM_REV_CM2_5 CM_ENCODE_REV(7, 0) + #define CM_REV_CM3 CM_ENCODE_REV(8, 0) + ++/* GCR_ERR_CONTROL register fields */ ++#define CM_GCR_ERR_CONTROL_L2_ECC_EN_SHF 1 ++#define CM_GCR_ERR_CONTROL_L2_ECC_EN_MSK (_ULCAST_(0x1) << 1) ++#define CM_GCR_ERR_CONTROL_L2_ECC_SUPPORT_SHF 0 ++#define CM_GCR_ERR_CONTROL_L2_ECC_SUPPORT_MSK (_ULCAST_(0x1) << 0) ++ + /* GCR_ERROR_CAUSE register fields */ + #define CM_GCR_ERROR_CAUSE_ERRTYPE_SHF 27 + #define CM_GCR_ERROR_CAUSE_ERRTYPE_MSK (_ULCAST_(0x1f) << 27) +diff --git a/arch/mips/kernel/setup.c b/arch/mips/kernel/setup.c +index f66e5ce505b2..695950361d2a 100644 +--- a/arch/mips/kernel/setup.c ++++ b/arch/mips/kernel/setup.c +@@ -153,6 +153,35 @@ void __init detect_memory_region(phys_addr_t start, phys_addr_t sz_min, phys_add + add_memory_region(start, size, BOOT_MEM_RAM); + } + ++bool __init memory_region_available(phys_addr_t start, phys_addr_t size) ++{ ++ int i; ++ bool in_ram = false, free = true; ++ ++ for (i = 0; i < boot_mem_map.nr_map; i++) { ++ phys_addr_t start_, end_; ++ ++ start_ = boot_mem_map.map[i].addr; ++ end_ = boot_mem_map.map[i].addr + boot_mem_map.map[i].size; ++ ++ switch (boot_mem_map.map[i].type) { ++ case BOOT_MEM_RAM: ++ if (start >= start_ && start + size <= end_) ++ in_ram = true; ++ break; ++ case BOOT_MEM_RESERVED: ++ if ((start >= start_ && start < end_) || ++ (start < start_ && start + size >= start_)) ++ free = false; ++ break; ++ default: ++ continue; ++ } ++ } ++ ++ return in_ram && free; ++} ++ + static void __init print_memory_map(void) + { + int i; +@@ -332,11 +361,19 @@ static void __init bootmem_init(void) + + #else /* !CONFIG_SGI_IP27 */ + ++static unsigned long __init bootmap_bytes(unsigned long pages) ++{ ++ unsigned long bytes = DIV_ROUND_UP(pages, 8); ++ ++ return ALIGN(bytes, sizeof(long)); ++} ++ + static void __init bootmem_init(void) + { + unsigned long reserved_end; + unsigned long mapstart = ~0UL; + unsigned long bootmap_size; ++ bool bootmap_valid = false; + int i; + + /* +@@ -430,11 +467,42 @@ static void __init bootmem_init(void) + #endif + + /* +- * Initialize the boot-time allocator with low memory only. ++ * check that mapstart doesn't overlap with any of ++ * memory regions that have been reserved through eg. DTB + */ +- bootmap_size = init_bootmem_node(NODE_DATA(0), mapstart, +- min_low_pfn, max_low_pfn); ++ bootmap_size = bootmap_bytes(max_low_pfn - min_low_pfn); ++ ++ bootmap_valid = memory_region_available(PFN_PHYS(mapstart), ++ bootmap_size); ++ for (i = 0; i < boot_mem_map.nr_map && !bootmap_valid; i++) { ++ unsigned long mapstart_addr; ++ ++ switch (boot_mem_map.map[i].type) { ++ case BOOT_MEM_RESERVED: ++ mapstart_addr = PFN_ALIGN(boot_mem_map.map[i].addr + ++ boot_mem_map.map[i].size); ++ if (PHYS_PFN(mapstart_addr) < mapstart) ++ break; ++ ++ bootmap_valid = memory_region_available(mapstart_addr, ++ bootmap_size); ++ if (bootmap_valid) ++ mapstart = PHYS_PFN(mapstart_addr); ++ break; ++ default: ++ break; ++ } ++ } + ++ if (!bootmap_valid) ++ panic("No memory area to place a bootmap bitmap"); ++ ++ /* ++ * Initialize the boot-time allocator with low memory only. ++ */ ++ if (bootmap_size != init_bootmem_node(NODE_DATA(0), mapstart, ++ min_low_pfn, max_low_pfn)) ++ panic("Unexpected memory size required for bootmap"); + + for (i = 0; i < boot_mem_map.nr_map; i++) { + unsigned long start, end; +@@ -483,6 +551,10 @@ static void __init bootmem_init(void) + continue; + default: + /* Not usable memory */ ++ if (start > min_low_pfn && end < max_low_pfn) ++ reserve_bootmem(boot_mem_map.map[i].addr, ++ boot_mem_map.map[i].size, ++ BOOTMEM_DEFAULT); + continue; + } + +diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c +index b0b29cb6f3d8..bb1d9ff1be5c 100644 +--- a/arch/mips/kernel/traps.c ++++ b/arch/mips/kernel/traps.c +@@ -51,6 +51,7 @@ + #include <asm/idle.h> + #include <asm/mips-cm.h> + #include <asm/mips-r2-to-r6-emul.h> ++#include <asm/mips-cm.h> + #include <asm/mipsregs.h> + #include <asm/mipsmtregs.h> + #include <asm/module.h> +@@ -1646,6 +1647,65 @@ __setup("nol2par", nol2parity); + */ + static inline void parity_protection_init(void) + { ++#define ERRCTL_PE 0x80000000 ++#define ERRCTL_L2P 0x00800000 ++ ++ if (mips_cm_revision() >= CM_REV_CM3) { ++ ulong gcr_ectl, cp0_ectl; ++ ++ /* ++ * With CM3 systems we need to ensure that the L1 & L2 ++ * parity enables are set to the same value, since this ++ * is presumed by the hardware engineers. ++ * ++ * If the user disabled either of L1 or L2 ECC checking, ++ * disable both. ++ */ ++ l1parity &= l2parity; ++ l2parity &= l1parity; ++ ++ /* Probe L1 ECC support */ ++ cp0_ectl = read_c0_ecc(); ++ write_c0_ecc(cp0_ectl | ERRCTL_PE); ++ back_to_back_c0_hazard(); ++ cp0_ectl = read_c0_ecc(); ++ ++ /* Probe L2 ECC support */ ++ gcr_ectl = read_gcr_err_control(); ++ ++ if (!(gcr_ectl & CM_GCR_ERR_CONTROL_L2_ECC_SUPPORT_MSK) || ++ !(cp0_ectl & ERRCTL_PE)) { ++ /* ++ * One of L1 or L2 ECC checking isn't supported, ++ * so we cannot enable either. ++ */ ++ l1parity = l2parity = 0; ++ } ++ ++ /* Configure L1 ECC checking */ ++ if (l1parity) ++ cp0_ectl |= ERRCTL_PE; ++ else ++ cp0_ectl &= ~ERRCTL_PE; ++ write_c0_ecc(cp0_ectl); ++ back_to_back_c0_hazard(); ++ WARN_ON(!!(read_c0_ecc() & ERRCTL_PE) != l1parity); ++ ++ /* Configure L2 ECC checking */ ++ if (l2parity) ++ gcr_ectl |= CM_GCR_ERR_CONTROL_L2_ECC_EN_MSK; ++ else ++ gcr_ectl &= ~CM_GCR_ERR_CONTROL_L2_ECC_EN_MSK; ++ write_gcr_err_control(gcr_ectl); ++ gcr_ectl = read_gcr_err_control(); ++ gcr_ectl &= CM_GCR_ERR_CONTROL_L2_ECC_EN_MSK; ++ WARN_ON(!!gcr_ectl != l2parity); ++ ++ pr_info("Cache parity protection %sabled\n", ++ l1parity ? "en" : "dis"); ++ return; ++ } ++ + switch (current_cpu_type()) { + case CPU_24K: + case CPU_34K: +@@ -1656,11 +1716,8 @@ static inline void parity_protection_init(void) + case CPU_PROAPTIV: + case CPU_P5600: + case CPU_QEMU_GENERIC: +- case CPU_I6400: + case CPU_P6600: + { +-#define ERRCTL_PE 0x80000000 +-#define ERRCTL_L2P 0x00800000 + unsigned long errctl; + unsigned int l1parity_present, l2parity_present; + +diff --git a/arch/mips/netlogic/common/irq.c b/arch/mips/netlogic/common/irq.c +index 3660dc67d544..f4961bc9a61d 100644 +--- a/arch/mips/netlogic/common/irq.c ++++ b/arch/mips/netlogic/common/irq.c +@@ -275,7 +275,7 @@ asmlinkage void plat_irq_dispatch(void) + do_IRQ(nlm_irq_to_xirq(node, i)); + } + +-#ifdef CONFIG_OF ++#ifdef CONFIG_CPU_XLP + static const struct irq_domain_ops xlp_pic_irq_domain_ops = { + .xlate = irq_domain_xlate_onetwocell, + }; +@@ -348,7 +348,7 @@ void __init arch_init_irq(void) + #if defined(CONFIG_CPU_XLR) + nlm_setup_fmn_irq(); + #endif +-#if defined(CONFIG_OF) ++#ifdef CONFIG_CPU_XLP + of_irq_init(xlp_pic_irq_ids); + #endif + } +diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c +index e2ead34da465..c6583efdbdaf 100644 +--- a/arch/x86/kernel/apic/apic.c ++++ b/arch/x86/kernel/apic/apic.c +@@ -1863,14 +1863,14 @@ static void __smp_spurious_interrupt(u8 vector) + "should never happen.\n", vector, smp_processor_id()); + } + +-__visible void smp_spurious_interrupt(struct pt_regs *regs) ++__visible void __irq_entry smp_spurious_interrupt(struct pt_regs *regs) + { + entering_irq(); + __smp_spurious_interrupt(~regs->orig_ax); + exiting_irq(); + } + +-__visible void smp_trace_spurious_interrupt(struct pt_regs *regs) ++__visible void __irq_entry smp_trace_spurious_interrupt(struct pt_regs *regs) + { + u8 vector = ~regs->orig_ax; + +@@ -1921,14 +1921,14 @@ static void __smp_error_interrupt(struct pt_regs *regs) + + } + +-__visible void smp_error_interrupt(struct pt_regs *regs) ++__visible void __irq_entry smp_error_interrupt(struct pt_regs *regs) + { + entering_irq(); + __smp_error_interrupt(regs); + exiting_irq(); + } + +-__visible void smp_trace_error_interrupt(struct pt_regs *regs) ++__visible void __irq_entry smp_trace_error_interrupt(struct pt_regs *regs) + { + entering_irq(); + trace_error_apic_entry(ERROR_APIC_VECTOR); +diff --git a/arch/x86/kernel/apic/vector.c b/arch/x86/kernel/apic/vector.c +index 5d30c5e42bb1..f3557a1eb562 100644 +--- a/arch/x86/kernel/apic/vector.c ++++ b/arch/x86/kernel/apic/vector.c +@@ -559,7 +559,7 @@ void send_cleanup_vector(struct irq_cfg *cfg) + __send_cleanup_vector(data); + } + +-asmlinkage __visible void smp_irq_move_cleanup_interrupt(void) ++asmlinkage __visible void __irq_entry smp_irq_move_cleanup_interrupt(void) + { + unsigned vector, me; + +diff --git a/arch/x86/kernel/cpu/mcheck/mce-severity.c b/arch/x86/kernel/cpu/mcheck/mce-severity.c +index 631356c8cca4..f46071cb2c90 100644 +--- a/arch/x86/kernel/cpu/mcheck/mce-severity.c ++++ b/arch/x86/kernel/cpu/mcheck/mce-severity.c +@@ -245,6 +245,9 @@ static int mce_severity_amd(struct mce *m, int tolerant, char **msg, bool is_exc + + if (m->status & MCI_STATUS_UC) { + ++ if (ctx == IN_KERNEL) ++ return MCE_PANIC_SEVERITY; ++ + /* + * On older systems where overflow_recov flag is not present, we + * should simply panic if an error overflow occurs. If +@@ -255,10 +258,6 @@ static int mce_severity_amd(struct mce *m, int tolerant, char **msg, bool is_exc + if (mce_flags.smca) + return mce_severity_amd_smca(m, ctx); + +- /* software can try to contain */ +- if (!(m->mcgstatus & MCG_STATUS_RIPV) && (ctx == IN_KERNEL)) +- return MCE_PANIC_SEVERITY; +- + /* kill current process */ + return MCE_AR_SEVERITY; + } else { +diff --git a/arch/x86/kernel/cpu/mcheck/mce_amd.c b/arch/x86/kernel/cpu/mcheck/mce_amd.c +index a5b47c1361a0..39526e1e3132 100644 +--- a/arch/x86/kernel/cpu/mcheck/mce_amd.c ++++ b/arch/x86/kernel/cpu/mcheck/mce_amd.c +@@ -593,14 +593,14 @@ static inline void __smp_deferred_error_interrupt(void) + deferred_error_int_vector(); + } + +-asmlinkage __visible void smp_deferred_error_interrupt(void) ++asmlinkage __visible void __irq_entry smp_deferred_error_interrupt(void) + { + entering_irq(); + __smp_deferred_error_interrupt(); + exiting_ack_irq(); + } + +-asmlinkage __visible void smp_trace_deferred_error_interrupt(void) ++asmlinkage __visible void __irq_entry smp_trace_deferred_error_interrupt(void) + { + entering_irq(); + trace_deferred_error_apic_entry(DEFERRED_ERROR_VECTOR); +diff --git a/arch/x86/kernel/cpu/mcheck/therm_throt.c b/arch/x86/kernel/cpu/mcheck/therm_throt.c +index 6b9dc4d18ccc..c460c91d0c8f 100644 +--- a/arch/x86/kernel/cpu/mcheck/therm_throt.c ++++ b/arch/x86/kernel/cpu/mcheck/therm_throt.c +@@ -431,14 +431,16 @@ static inline void __smp_thermal_interrupt(void) + smp_thermal_vector(); + } + +-asmlinkage __visible void smp_thermal_interrupt(struct pt_regs *regs) ++asmlinkage __visible void __irq_entry ++smp_thermal_interrupt(struct pt_regs *regs) + { + entering_irq(); + __smp_thermal_interrupt(); + exiting_ack_irq(); + } + +-asmlinkage __visible void smp_trace_thermal_interrupt(struct pt_regs *regs) ++asmlinkage __visible void __irq_entry ++smp_trace_thermal_interrupt(struct pt_regs *regs) + { + entering_irq(); + trace_thermal_apic_entry(THERMAL_APIC_VECTOR); +diff --git a/arch/x86/kernel/cpu/mcheck/threshold.c b/arch/x86/kernel/cpu/mcheck/threshold.c +index fcf9ae9384f4..976042371b4b 100644 +--- a/arch/x86/kernel/cpu/mcheck/threshold.c ++++ b/arch/x86/kernel/cpu/mcheck/threshold.c +@@ -24,14 +24,14 @@ static inline void __smp_threshold_interrupt(void) + mce_threshold_vector(); + } + +-asmlinkage __visible void smp_threshold_interrupt(void) ++asmlinkage __visible void __irq_entry smp_threshold_interrupt(void) + { + entering_irq(); + __smp_threshold_interrupt(); + exiting_ack_irq(); + } + +-asmlinkage __visible void smp_trace_threshold_interrupt(void) ++asmlinkage __visible void __irq_entry smp_trace_threshold_interrupt(void) + { + entering_irq(); + trace_threshold_apic_entry(THRESHOLD_APIC_VECTOR); +diff --git a/arch/x86/kernel/irq.c b/arch/x86/kernel/irq.c +index 9f669fdd2010..8a7ad9fb22c1 100644 +--- a/arch/x86/kernel/irq.c ++++ b/arch/x86/kernel/irq.c +@@ -265,7 +265,7 @@ void __smp_x86_platform_ipi(void) + x86_platform_ipi_callback(); + } + +-__visible void smp_x86_platform_ipi(struct pt_regs *regs) ++__visible void __irq_entry smp_x86_platform_ipi(struct pt_regs *regs) + { + struct pt_regs *old_regs = set_irq_regs(regs); + +@@ -316,7 +316,7 @@ __visible void smp_kvm_posted_intr_wakeup_ipi(struct pt_regs *regs) + } + #endif + +-__visible void smp_trace_x86_platform_ipi(struct pt_regs *regs) ++__visible void __irq_entry smp_trace_x86_platform_ipi(struct pt_regs *regs) + { + struct pt_regs *old_regs = set_irq_regs(regs); + +diff --git a/arch/x86/kernel/irq_work.c b/arch/x86/kernel/irq_work.c +index 3512ba607361..275487872be2 100644 +--- a/arch/x86/kernel/irq_work.c ++++ b/arch/x86/kernel/irq_work.c +@@ -9,6 +9,7 @@ + #include <linux/hardirq.h> + #include <asm/apic.h> + #include <asm/trace/irq_vectors.h> ++#include <linux/interrupt.h> + + static inline void __smp_irq_work_interrupt(void) + { +@@ -16,14 +17,14 @@ static inline void __smp_irq_work_interrupt(void) + irq_work_run(); + } + +-__visible void smp_irq_work_interrupt(struct pt_regs *regs) ++__visible void __irq_entry smp_irq_work_interrupt(struct pt_regs *regs) + { + ipi_entering_ack_irq(); + __smp_irq_work_interrupt(); + exiting_irq(); + } + +-__visible void smp_trace_irq_work_interrupt(struct pt_regs *regs) ++__visible void __irq_entry smp_trace_irq_work_interrupt(struct pt_regs *regs) + { + ipi_entering_ack_irq(); + trace_irq_work_entry(IRQ_WORK_VECTOR); +diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c +index c00cb64bc0a1..ca699677e288 100644 +--- a/arch/x86/kernel/smp.c ++++ b/arch/x86/kernel/smp.c +@@ -259,7 +259,7 @@ static inline void __smp_reschedule_interrupt(void) + scheduler_ipi(); + } + +-__visible void smp_reschedule_interrupt(struct pt_regs *regs) ++__visible void __irq_entry smp_reschedule_interrupt(struct pt_regs *regs) + { + irq_enter(); + ack_APIC_irq(); +@@ -270,7 +270,7 @@ __visible void smp_reschedule_interrupt(struct pt_regs *regs) + */ + } + +-__visible void smp_trace_reschedule_interrupt(struct pt_regs *regs) ++__visible void __irq_entry smp_trace_reschedule_interrupt(struct pt_regs *regs) + { + /* + * Need to call irq_enter() before calling the trace point. +@@ -294,14 +294,15 @@ static inline void __smp_call_function_interrupt(void) + inc_irq_stat(irq_call_count); + } + +-__visible void smp_call_function_interrupt(struct pt_regs *regs) ++__visible void __irq_entry smp_call_function_interrupt(struct pt_regs *regs) + { + ipi_entering_ack_irq(); + __smp_call_function_interrupt(); + exiting_irq(); + } + +-__visible void smp_trace_call_function_interrupt(struct pt_regs *regs) ++__visible void __irq_entry ++smp_trace_call_function_interrupt(struct pt_regs *regs) + { + ipi_entering_ack_irq(); + trace_call_function_entry(CALL_FUNCTION_VECTOR); +@@ -316,14 +317,16 @@ static inline void __smp_call_function_single_interrupt(void) + inc_irq_stat(irq_call_count); + } + +-__visible void smp_call_function_single_interrupt(struct pt_regs *regs) ++__visible void __irq_entry ++smp_call_function_single_interrupt(struct pt_regs *regs) + { + ipi_entering_ack_irq(); + __smp_call_function_single_interrupt(); + exiting_irq(); + } + +-__visible void smp_trace_call_function_single_interrupt(struct pt_regs *regs) ++__visible void __irq_entry ++smp_trace_call_function_single_interrupt(struct pt_regs *regs) + { + ipi_entering_ack_irq(); + trace_call_function_single_entry(CALL_FUNCTION_SINGLE_VECTOR); +diff --git a/crypto/Kconfig b/crypto/Kconfig +index fa98ad7edb60..84d71482bf08 100644 +--- a/crypto/Kconfig ++++ b/crypto/Kconfig +@@ -360,7 +360,6 @@ config CRYPTO_XTS + select CRYPTO_BLKCIPHER + select CRYPTO_MANAGER + select CRYPTO_GF128MUL +- select CRYPTO_ECB + help + XTS: IEEE1619/D16 narrow block cipher use with aes-xts-plain, + key size 256, 384 or 512 bits. This implementation currently +diff --git a/crypto/dh_helper.c b/crypto/dh_helper.c +index 02db76b20d00..14539904416e 100644 +--- a/crypto/dh_helper.c ++++ b/crypto/dh_helper.c +@@ -83,6 +83,14 @@ int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params) + if (secret.len != crypto_dh_key_len(params)) + return -EINVAL; + ++ /* ++ * Don't permit the buffer for 'key' or 'g' to be larger than 'p', since ++ * some drivers assume otherwise. ++ */ ++ if (params->key_size > params->p_size || ++ params->g_size > params->p_size) ++ return -EINVAL; ++ + /* Don't allocate memory. Set pointers to data within + * the given buffer + */ +@@ -90,6 +98,14 @@ int crypto_dh_decode_key(const char *buf, unsigned int len, struct dh *params) + params->p = (void *)(ptr + params->key_size); + params->g = (void *)(ptr + params->key_size + params->p_size); + ++ /* ++ * Don't permit 'p' to be 0. It's not a prime number, and it's subject ++ * to corner cases such as 'mod 0' being undefined or ++ * crypto_kpp_maxsize() returning 0. ++ */ ++ if (memchr_inv(params->p, 0, params->p_size) == NULL) ++ return -EINVAL; ++ + return 0; + } + EXPORT_SYMBOL_GPL(crypto_dh_decode_key); +diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig +index 2c8be74f401d..5d16fc4fa46c 100644 +--- a/drivers/ata/Kconfig ++++ b/drivers/ata/Kconfig +@@ -289,6 +289,7 @@ config SATA_SX4 + + config ATA_BMDMA + bool "ATA BMDMA support" ++ depends on HAS_DMA + default y + help + This option adds support for SFF ATA controllers with BMDMA +@@ -344,6 +345,7 @@ config SATA_DWC_VDEBUG + + config SATA_HIGHBANK + tristate "Calxeda Highbank SATA support" ++ depends on HAS_DMA + depends on ARCH_HIGHBANK || COMPILE_TEST + help + This option enables support for the Calxeda Highbank SoC's +@@ -353,6 +355,7 @@ config SATA_HIGHBANK + + config SATA_MV + tristate "Marvell SATA support" ++ depends on HAS_DMA + depends on PCI || ARCH_DOVE || ARCH_MV78XX0 || \ + ARCH_MVEBU || ARCH_ORION5X || COMPILE_TEST + select GENERIC_PHY +diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c +index 74e677ac8e37..693028659ccc 100644 +--- a/drivers/bluetooth/btusb.c ++++ b/drivers/bluetooth/btusb.c +@@ -2925,6 +2925,12 @@ static int btusb_probe(struct usb_interface *intf, + if (id->driver_info & BTUSB_QCA_ROME) { + data->setup_on_usb = btusb_setup_qca; + hdev->set_bdaddr = btusb_set_bdaddr_ath3012; ++ ++ /* QCA Rome devices lose their updated firmware over suspend, ++ * but the USB hub doesn't notice any status change. ++ * Explicitly request a device reset on resume. ++ */ ++ set_bit(BTUSB_RESET_RESUME, &data->flags); + } + + #ifdef CONFIG_BT_HCIBTUSB_RTL +diff --git a/drivers/extcon/extcon-palmas.c b/drivers/extcon/extcon-palmas.c +index 634ba70782de..a128fd2eb187 100644 +--- a/drivers/extcon/extcon-palmas.c ++++ b/drivers/extcon/extcon-palmas.c +@@ -190,6 +190,11 @@ static int palmas_usb_probe(struct platform_device *pdev) + struct palmas_usb *palmas_usb; + int status; + ++ if (!palmas) { ++ dev_err(&pdev->dev, "failed to get valid parent\n"); ++ return -EINVAL; ++ } ++ + palmas_usb = devm_kzalloc(&pdev->dev, sizeof(*palmas_usb), GFP_KERNEL); + if (!palmas_usb) + return -ENOMEM; +diff --git a/drivers/extcon/extcon.c b/drivers/extcon/extcon.c +index 7c1e3a7b14e0..d0e367959c91 100644 +--- a/drivers/extcon/extcon.c ++++ b/drivers/extcon/extcon.c +@@ -906,35 +906,16 @@ int extcon_register_notifier(struct extcon_dev *edev, unsigned int id, + unsigned long flags; + int ret, idx = -EINVAL; + +- if (!nb) ++ if (!edev || !nb) + return -EINVAL; + +- if (edev) { +- idx = find_cable_index_by_id(edev, id); +- if (idx < 0) +- return idx; +- +- spin_lock_irqsave(&edev->lock, flags); +- ret = raw_notifier_chain_register(&edev->nh[idx], nb); +- spin_unlock_irqrestore(&edev->lock, flags); +- } else { +- struct extcon_dev *extd; +- +- mutex_lock(&extcon_dev_list_lock); +- list_for_each_entry(extd, &extcon_dev_list, entry) { +- idx = find_cable_index_by_id(extd, id); +- if (idx >= 0) +- break; +- } +- mutex_unlock(&extcon_dev_list_lock); ++ idx = find_cable_index_by_id(edev, id); ++ if (idx < 0) ++ return idx; + +- if (idx >= 0) { +- edev = extd; +- return extcon_register_notifier(extd, id, nb); +- } else { +- ret = -ENODEV; +- } +- } ++ spin_lock_irqsave(&edev->lock, flags); ++ ret = raw_notifier_chain_register(&edev->nh[idx], nb); ++ spin_unlock_irqrestore(&edev->lock, flags); + + return ret; + } +diff --git a/drivers/gpu/drm/mgag200/mgag200_main.c b/drivers/gpu/drm/mgag200/mgag200_main.c +index e79cbc25ae3c..fb03e3057485 100644 +--- a/drivers/gpu/drm/mgag200/mgag200_main.c ++++ b/drivers/gpu/drm/mgag200/mgag200_main.c +@@ -145,6 +145,8 @@ static int mga_vram_init(struct mga_device *mdev) + } + + mem = pci_iomap(mdev->dev->pdev, 0, 0); ++ if (!mem) ++ return -ENOMEM; + + mdev->mc.vram_size = mga_probe_vram(mdev, mem); + +diff --git a/drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c b/drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c +index 3557a4c7dd7b..270a62348a6e 100644 +--- a/drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c ++++ b/drivers/gpu/drm/omapdrm/displays/panel-sony-acx565akm.c +@@ -912,6 +912,7 @@ static struct spi_driver acx565akm_driver = { + + module_spi_driver(acx565akm_driver); + ++MODULE_ALIAS("spi:sony,acx565akm"); + MODULE_AUTHOR("Nokia Corporation"); + MODULE_DESCRIPTION("acx565akm LCD Driver"); + MODULE_LICENSE("GPL"); +diff --git a/drivers/gpu/drm/sti/sti_vtg.c b/drivers/gpu/drm/sti/sti_vtg.c +index a8882bdd0f8b..c3d9c8ae14af 100644 +--- a/drivers/gpu/drm/sti/sti_vtg.c ++++ b/drivers/gpu/drm/sti/sti_vtg.c +@@ -429,6 +429,10 @@ static int vtg_probe(struct platform_device *pdev) + return -ENOMEM; + } + vtg->regs = devm_ioremap_nocache(dev, res->start, resource_size(res)); ++ if (!vtg->regs) { ++ DRM_ERROR("failed to remap I/O memory\n"); ++ return -ENOMEM; ++ } + + np = of_parse_phandle(pdev->dev.of_node, "st,slave", 0); + if (np) { +diff --git a/drivers/media/rc/imon.c b/drivers/media/rc/imon.c +index 2d4b83635018..f072bf28fccd 100644 +--- a/drivers/media/rc/imon.c ++++ b/drivers/media/rc/imon.c +@@ -2412,6 +2412,11 @@ static int imon_probe(struct usb_interface *interface, + mutex_lock(&driver_lock); + + first_if = usb_ifnum_to_if(usbdev, 0); ++ if (!first_if) { ++ ret = -ENODEV; ++ goto fail; ++ } ++ + first_if_ctx = usb_get_intfdata(first_if); + + if (ifnum == 0) { +diff --git a/drivers/media/usb/dvb-usb/dib0700_devices.c b/drivers/media/usb/dvb-usb/dib0700_devices.c +index ef1b8ee75c57..caa55402052e 100644 +--- a/drivers/media/usb/dvb-usb/dib0700_devices.c ++++ b/drivers/media/usb/dvb-usb/dib0700_devices.c +@@ -292,7 +292,7 @@ static int stk7700P2_frontend_attach(struct dvb_usb_adapter *adap) + stk7700d_dib7000p_mt2266_config) + != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + } +@@ -326,7 +326,7 @@ static int stk7700d_frontend_attach(struct dvb_usb_adapter *adap) + stk7700d_dib7000p_mt2266_config) + != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + } +@@ -479,7 +479,7 @@ static int stk7700ph_frontend_attach(struct dvb_usb_adapter *adap) + &stk7700ph_dib7700_xc3028_config) != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", + __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + +@@ -1011,7 +1011,7 @@ static int stk7070p_frontend_attach(struct dvb_usb_adapter *adap) + &dib7070p_dib7000p_config) != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", + __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + +@@ -1069,7 +1069,7 @@ static int stk7770p_frontend_attach(struct dvb_usb_adapter *adap) + &dib7770p_dib7000p_config) != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", + __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + +@@ -3056,7 +3056,7 @@ static int nim7090_frontend_attach(struct dvb_usb_adapter *adap) + + if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x10, &nim7090_dib7000p_config) != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, &nim7090_dib7000p_config); +@@ -3109,7 +3109,7 @@ static int tfe7090pvr_frontend0_attach(struct dvb_usb_adapter *adap) + /* initialize IC 0 */ + if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 0x20, &tfe7090pvr_dib7000p_config[0]) != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + +@@ -3139,7 +3139,7 @@ static int tfe7090pvr_frontend1_attach(struct dvb_usb_adapter *adap) + i2c = state->dib7000p_ops.get_i2c_master(adap->dev->adapter[0].fe_adap[0].fe, DIBX000_I2C_INTERFACE_GPIO_6_7, 1); + if (state->dib7000p_ops.i2c_enumeration(i2c, 1, 0x10, &tfe7090pvr_dib7000p_config[1]) != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + +@@ -3214,7 +3214,7 @@ static int tfe7790p_frontend_attach(struct dvb_usb_adapter *adap) + 1, 0x10, &tfe7790p_dib7000p_config) != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", + __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, +@@ -3309,7 +3309,7 @@ static int stk7070pd_frontend_attach0(struct dvb_usb_adapter *adap) + stk7070pd_dib7000p_config) != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", + __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + +@@ -3384,7 +3384,7 @@ static int novatd_frontend_attach(struct dvb_usb_adapter *adap) + stk7070pd_dib7000p_config) != 0) { + err("%s: state->dib7000p_ops.i2c_enumeration failed. Cannot continue\n", + __func__); +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + } +@@ -3620,7 +3620,7 @@ static int pctv340e_frontend_attach(struct dvb_usb_adapter *adap) + + if (state->dib7000p_ops.dib7000pc_detection(&adap->dev->i2c_adap) == 0) { + /* Demodulator not found for some reason? */ +- dvb_detach(&state->dib7000p_ops); ++ dvb_detach(state->dib7000p_ops.set_wbd_ref); + return -ENODEV; + } + +diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_mbx.c b/drivers/net/ethernet/intel/fm10k/fm10k_mbx.c +index c9dfa6564fcf..334088a101c3 100644 +--- a/drivers/net/ethernet/intel/fm10k/fm10k_mbx.c ++++ b/drivers/net/ethernet/intel/fm10k/fm10k_mbx.c +@@ -2011,9 +2011,10 @@ static void fm10k_sm_mbx_create_reply(struct fm10k_hw *hw, + * function can also be used to respond to an error as the connection + * resetting would also be a means of dealing with errors. + **/ +-static void fm10k_sm_mbx_process_reset(struct fm10k_hw *hw, +- struct fm10k_mbx_info *mbx) ++static s32 fm10k_sm_mbx_process_reset(struct fm10k_hw *hw, ++ struct fm10k_mbx_info *mbx) + { ++ s32 err = 0; + const enum fm10k_mbx_state state = mbx->state; + + switch (state) { +@@ -2026,6 +2027,7 @@ static void fm10k_sm_mbx_process_reset(struct fm10k_hw *hw, + case FM10K_STATE_OPEN: + /* flush any incomplete work */ + fm10k_sm_mbx_connect_reset(mbx); ++ err = FM10K_ERR_RESET_REQUESTED; + break; + case FM10K_STATE_CONNECT: + /* Update remote value to match local value */ +@@ -2035,6 +2037,8 @@ static void fm10k_sm_mbx_process_reset(struct fm10k_hw *hw, + } + + fm10k_sm_mbx_create_reply(hw, mbx, mbx->tail); ++ ++ return err; + } + + /** +@@ -2115,7 +2119,7 @@ static s32 fm10k_sm_mbx_process(struct fm10k_hw *hw, + + switch (FM10K_MSG_HDR_FIELD_GET(mbx->mbx_hdr, SM_VER)) { + case 0: +- fm10k_sm_mbx_process_reset(hw, mbx); ++ err = fm10k_sm_mbx_process_reset(hw, mbx); + break; + case FM10K_SM_MBX_VERSION: + err = fm10k_sm_mbx_process_version_1(hw, mbx); +diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_pci.c b/drivers/net/ethernet/intel/fm10k/fm10k_pci.c +index b1a2f8437d59..e372a5823480 100644 +--- a/drivers/net/ethernet/intel/fm10k/fm10k_pci.c ++++ b/drivers/net/ethernet/intel/fm10k/fm10k_pci.c +@@ -1144,6 +1144,7 @@ static irqreturn_t fm10k_msix_mbx_pf(int __always_unused irq, void *data) + struct fm10k_hw *hw = &interface->hw; + struct fm10k_mbx_info *mbx = &hw->mbx; + u32 eicr; ++ s32 err = 0; + + /* unmask any set bits related to this interrupt */ + eicr = fm10k_read_reg(hw, FM10K_EICR); +@@ -1159,12 +1160,15 @@ static irqreturn_t fm10k_msix_mbx_pf(int __always_unused irq, void *data) + + /* service mailboxes */ + if (fm10k_mbx_trylock(interface)) { +- mbx->ops.process(hw, mbx); ++ err = mbx->ops.process(hw, mbx); + /* handle VFLRE events */ + fm10k_iov_event(interface); + fm10k_mbx_unlock(interface); + } + ++ if (err == FM10K_ERR_RESET_REQUESTED) ++ interface->flags |= FM10K_FLAG_RESET_REQUESTED; ++ + /* if switch toggled state we should reset GLORTs */ + if (eicr & FM10K_EICR_SWITCHNOTREADY) { + /* force link down for at least 4 seconds */ +diff --git a/drivers/net/ethernet/intel/igb/e1000_82575.c b/drivers/net/ethernet/intel/igb/e1000_82575.c +index 1264a3616acf..4a50870e0fa7 100644 +--- a/drivers/net/ethernet/intel/igb/e1000_82575.c ++++ b/drivers/net/ethernet/intel/igb/e1000_82575.c +@@ -245,6 +245,17 @@ static s32 igb_init_phy_params_82575(struct e1000_hw *hw) + hw->bus.func = (rd32(E1000_STATUS) & E1000_STATUS_FUNC_MASK) >> + E1000_STATUS_FUNC_SHIFT; + ++ /* Make sure the PHY is in a good state. Several people have reported ++ * firmware leaving the PHY's page select register set to something ++ * other than the default of zero, which causes the PHY ID read to ++ * access something other than the intended register. ++ */ ++ ret_val = hw->phy.ops.reset(hw); ++ if (ret_val) { ++ hw_dbg("Error resetting the PHY.\n"); ++ goto out; ++ } ++ + /* Set phy->phy_addr and phy->id. */ + igb_write_phy_reg_82580(hw, I347AT4_PAGE_SELECT, 0); + ret_val = igb_get_phy_id_82575(hw); +diff --git a/drivers/net/ethernet/intel/igb/e1000_i210.c b/drivers/net/ethernet/intel/igb/e1000_i210.c +index 8aa798737d4d..07d48f2e3369 100644 +--- a/drivers/net/ethernet/intel/igb/e1000_i210.c ++++ b/drivers/net/ethernet/intel/igb/e1000_i210.c +@@ -699,9 +699,9 @@ static s32 igb_update_flash_i210(struct e1000_hw *hw) + + ret_val = igb_pool_flash_update_done_i210(hw); + if (ret_val) +- hw_dbg("Flash update complete\n"); +- else + hw_dbg("Flash update time out\n"); ++ else ++ hw_dbg("Flash update complete\n"); + + out: + return ret_val; +diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c +index 6a62447fe377..c6c2562d9df3 100644 +--- a/drivers/net/ethernet/intel/igb/igb_main.c ++++ b/drivers/net/ethernet/intel/igb/igb_main.c +@@ -3271,7 +3271,9 @@ static int __igb_close(struct net_device *netdev, bool suspending) + + int igb_close(struct net_device *netdev) + { +- return __igb_close(netdev, false); ++ if (netif_device_present(netdev)) ++ return __igb_close(netdev, false); ++ return 0; + } + + /** +@@ -7548,6 +7550,7 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, + int retval = 0; + #endif + ++ rtnl_lock(); + netif_device_detach(netdev); + + if (netif_running(netdev)) +@@ -7556,6 +7559,7 @@ static int __igb_shutdown(struct pci_dev *pdev, bool *enable_wake, + igb_ptp_suspend(adapter); + + igb_clear_interrupt_scheme(adapter); ++ rtnl_unlock(); + + #ifdef CONFIG_PM + retval = pci_save_state(pdev); +@@ -7674,16 +7678,15 @@ static int igb_resume(struct device *dev) + + wr32(E1000_WUS, ~0); + +- if (netdev->flags & IFF_UP) { +- rtnl_lock(); ++ rtnl_lock(); ++ if (!err && netif_running(netdev)) + err = __igb_open(netdev, true); +- rtnl_unlock(); +- if (err) +- return err; +- } + +- netif_device_attach(netdev); +- return 0; ++ if (!err) ++ netif_device_attach(netdev); ++ rtnl_unlock(); ++ ++ return err; + } + + static int igb_runtime_idle(struct device *dev) +diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c +index f49f80380aa5..a137e060c185 100644 +--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c ++++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c +@@ -199,7 +199,7 @@ static int ixgbe_get_settings(struct net_device *netdev, + if (supported_link & IXGBE_LINK_SPEED_100_FULL) + ecmd->supported |= ixgbe_isbackplane(hw->phy.media_type) ? + SUPPORTED_1000baseKX_Full : +- SUPPORTED_1000baseT_Full; ++ SUPPORTED_100baseT_Full; + + /* default advertised speed if phy.autoneg_advertised isn't set */ + ecmd->advertising = ecmd->supported; +diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c +index 15ab337fd7ad..10d29678d65e 100644 +--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c ++++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c +@@ -308,6 +308,7 @@ static void ixgbe_cache_ring_register(struct ixgbe_adapter *adapter) + ixgbe_cache_ring_rss(adapter); + } + ++#define IXGBE_RSS_64Q_MASK 0x3F + #define IXGBE_RSS_16Q_MASK 0xF + #define IXGBE_RSS_8Q_MASK 0x7 + #define IXGBE_RSS_4Q_MASK 0x3 +@@ -604,6 +605,7 @@ static bool ixgbe_set_sriov_queues(struct ixgbe_adapter *adapter) + **/ + static bool ixgbe_set_rss_queues(struct ixgbe_adapter *adapter) + { ++ struct ixgbe_hw *hw = &adapter->hw; + struct ixgbe_ring_feature *f; + u16 rss_i; + +@@ -612,7 +614,11 @@ static bool ixgbe_set_rss_queues(struct ixgbe_adapter *adapter) + rss_i = f->limit; + + f->indices = rss_i; +- f->mask = IXGBE_RSS_16Q_MASK; ++ ++ if (hw->mac.type < ixgbe_mac_X550) ++ f->mask = IXGBE_RSS_16Q_MASK; ++ else ++ f->mask = IXGBE_RSS_64Q_MASK; + + /* disable ATR by default, it will be configured below */ + adapter->flags &= ~IXGBE_FLAG_FDIR_HASH_CAPABLE; +diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +index fee1f2918ead..334eb96ecda3 100644 +--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c ++++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c +@@ -6194,7 +6194,8 @@ int ixgbe_close(struct net_device *netdev) + + ixgbe_ptp_stop(adapter); + +- ixgbe_close_suspend(adapter); ++ if (netif_device_present(netdev)) ++ ixgbe_close_suspend(adapter); + + ixgbe_fdir_filter_exit(adapter); + +@@ -6239,14 +6240,12 @@ static int ixgbe_resume(struct pci_dev *pdev) + if (!err && netif_running(netdev)) + err = ixgbe_open(netdev); + +- rtnl_unlock(); +- +- if (err) +- return err; + +- netif_device_attach(netdev); ++ if (!err) ++ netif_device_attach(netdev); ++ rtnl_unlock(); + +- return 0; ++ return err; + } + #endif /* CONFIG_PM */ + +@@ -6261,14 +6260,14 @@ static int __ixgbe_shutdown(struct pci_dev *pdev, bool *enable_wake) + int retval = 0; + #endif + ++ rtnl_lock(); + netif_device_detach(netdev); + +- rtnl_lock(); + if (netif_running(netdev)) + ixgbe_close_suspend(adapter); +- rtnl_unlock(); + + ixgbe_clear_interrupt_scheme(adapter); ++ rtnl_unlock(); + + #ifdef CONFIG_PM + retval = pci_save_state(pdev); +@@ -10027,7 +10026,7 @@ static pci_ers_result_t ixgbe_io_error_detected(struct pci_dev *pdev, + } + + if (netif_running(netdev)) +- ixgbe_down(adapter); ++ ixgbe_close_suspend(adapter); + + if (!test_and_set_bit(__IXGBE_DISABLED, &adapter->state)) + pci_disable_device(pdev); +@@ -10097,10 +10096,12 @@ static void ixgbe_io_resume(struct pci_dev *pdev) + } + + #endif ++ rtnl_lock(); + if (netif_running(netdev)) +- ixgbe_up(adapter); ++ ixgbe_open(netdev); + + netif_device_attach(netdev); ++ rtnl_unlock(); + } + + static const struct pci_error_handlers ixgbe_err_handler = { +diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.c +index 021ab9b89c71..b17464e843de 100644 +--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.c ++++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_phy.c +@@ -113,7 +113,7 @@ static s32 ixgbe_read_i2c_combined_generic_int(struct ixgbe_hw *hw, u8 addr, + u16 reg, u16 *val, bool lock) + { + u32 swfw_mask = hw->phy.phy_semaphore_mask; +- int max_retry = 10; ++ int max_retry = 3; + int retry = 0; + u8 csum_byte; + u8 high_bits; +@@ -1764,6 +1764,8 @@ static s32 ixgbe_read_i2c_byte_generic_int(struct ixgbe_hw *hw, u8 byte_offset, + u32 swfw_mask = hw->phy.phy_semaphore_mask; + bool nack = true; + ++ if (hw->mac.type >= ixgbe_mac_X550) ++ max_retry = 3; + if (ixgbe_is_sfp_probe(hw, byte_offset, dev_addr)) + max_retry = IXGBE_SFP_DETECT_RETRIES; + +diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c +index 7e6b9267ca9d..60f0bf779073 100644 +--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c ++++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c +@@ -1932,8 +1932,6 @@ static s32 ixgbe_setup_kr_speed_x550em(struct ixgbe_hw *hw, + return status; + + reg_val |= IXGBE_KRM_LINK_CTRL_1_TETH_AN_ENABLE; +- reg_val &= ~(IXGBE_KRM_LINK_CTRL_1_TETH_AN_FEC_REQ | +- IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_FEC); + reg_val &= ~(IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_KR | + IXGBE_KRM_LINK_CTRL_1_TETH_AN_CAP_KX); + +@@ -1995,12 +1993,11 @@ static s32 ixgbe_setup_kx4_x550em(struct ixgbe_hw *hw) + /** + * ixgbe_setup_kr_x550em - Configure the KR PHY + * @hw: pointer to hardware structure +- * +- * Configures the integrated KR PHY for X550EM_x. + **/ + static s32 ixgbe_setup_kr_x550em(struct ixgbe_hw *hw) + { +- if (hw->mac.type != ixgbe_mac_X550EM_x) ++ /* leave link alone for 2.5G */ ++ if (hw->phy.autoneg_advertised & IXGBE_LINK_SPEED_2_5GB_FULL) + return 0; + + return ixgbe_setup_kr_speed_x550em(hw, hw->phy.autoneg_advertised); +diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c +index fc844a1f6c3f..f507d821aba8 100644 +--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c ++++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c +@@ -147,7 +147,6 @@ static struct ieee80211_rate __wl_rates[] = { + .band = NL80211_BAND_2GHZ, \ + .center_freq = (_freq), \ + .hw_value = (_channel), \ +- .flags = IEEE80211_CHAN_DISABLED, \ + .max_antenna_gain = 0, \ + .max_power = 30, \ + } +@@ -156,7 +155,6 @@ static struct ieee80211_rate __wl_rates[] = { + .band = NL80211_BAND_5GHZ, \ + .center_freq = 5000 + (5 * (_channel)), \ + .hw_value = (_channel), \ +- .flags = IEEE80211_CHAN_DISABLED, \ + .max_antenna_gain = 0, \ + .max_power = 30, \ + } +diff --git a/drivers/power/supply/axp288_fuel_gauge.c b/drivers/power/supply/axp288_fuel_gauge.c +index f62f9dfea984..089056cb8e73 100644 +--- a/drivers/power/supply/axp288_fuel_gauge.c ++++ b/drivers/power/supply/axp288_fuel_gauge.c +@@ -29,6 +29,7 @@ + #include <linux/iio/consumer.h> + #include <linux/debugfs.h> + #include <linux/seq_file.h> ++#include <asm/unaligned.h> + + #define CHRG_STAT_BAT_SAFE_MODE (1 << 3) + #define CHRG_STAT_BAT_VALID (1 << 4) +@@ -73,17 +74,15 @@ + #define FG_CNTL_CC_EN (1 << 6) + #define FG_CNTL_GAUGE_EN (1 << 7) + ++#define FG_15BIT_WORD_VALID (1 << 15) ++#define FG_15BIT_VAL_MASK 0x7fff ++ + #define FG_REP_CAP_VALID (1 << 7) + #define FG_REP_CAP_VAL_MASK 0x7F + + #define FG_DES_CAP1_VALID (1 << 7) +-#define FG_DES_CAP1_VAL_MASK 0x7F +-#define FG_DES_CAP0_VAL_MASK 0xFF + #define FG_DES_CAP_RES_LSB 1456 /* 1.456mAhr */ + +-#define FG_CC_MTR1_VALID (1 << 7) +-#define FG_CC_MTR1_VAL_MASK 0x7F +-#define FG_CC_MTR0_VAL_MASK 0xFF + #define FG_DES_CC_RES_LSB 1456 /* 1.456mAhr */ + + #define FG_OCV_CAP_VALID (1 << 7) +@@ -189,6 +188,44 @@ static int fuel_gauge_reg_writeb(struct axp288_fg_info *info, int reg, u8 val) + return ret; + } + ++static int fuel_gauge_read_15bit_word(struct axp288_fg_info *info, int reg) ++{ ++ unsigned char buf[2]; ++ int ret; ++ ++ ret = regmap_bulk_read(info->regmap, reg, buf, 2); ++ if (ret < 0) { ++ dev_err(&info->pdev->dev, "Error reading reg 0x%02x err: %d\n", ++ reg, ret); ++ return ret; ++ } ++ ++ ret = get_unaligned_be16(buf); ++ if (!(ret & FG_15BIT_WORD_VALID)) { ++ dev_err(&info->pdev->dev, "Error reg 0x%02x contents not valid\n", ++ reg); ++ return -ENXIO; ++ } ++ ++ return ret & FG_15BIT_VAL_MASK; ++} ++ ++static int fuel_gauge_read_12bit_word(struct axp288_fg_info *info, int reg) ++{ ++ unsigned char buf[2]; ++ int ret; ++ ++ ret = regmap_bulk_read(info->regmap, reg, buf, 2); ++ if (ret < 0) { ++ dev_err(&info->pdev->dev, "Error reading reg 0x%02x err: %d\n", ++ reg, ret); ++ return ret; ++ } ++ ++ /* 12-bit data values have upper 8 bits in buf[0], lower 4 in buf[1] */ ++ return (buf[0] << 4) | ((buf[1] >> 4) & 0x0f); ++} ++ + static int pmic_read_adc_val(const char *name, int *raw_val, + struct axp288_fg_info *info) + { +@@ -249,24 +286,15 @@ static int fuel_gauge_debug_show(struct seq_file *s, void *data) + seq_printf(s, " FG_RDC0[%02x] : %02x\n", + AXP288_FG_RDC0_REG, + fuel_gauge_reg_readb(info, AXP288_FG_RDC0_REG)); +- seq_printf(s, " FG_OCVH[%02x] : %02x\n", ++ seq_printf(s, " FG_OCV[%02x] : %04x\n", + AXP288_FG_OCVH_REG, +- fuel_gauge_reg_readb(info, AXP288_FG_OCVH_REG)); +- seq_printf(s, " FG_OCVL[%02x] : %02x\n", +- AXP288_FG_OCVL_REG, +- fuel_gauge_reg_readb(info, AXP288_FG_OCVL_REG)); +- seq_printf(s, "FG_DES_CAP1[%02x] : %02x\n", ++ fuel_gauge_read_12bit_word(info, AXP288_FG_OCVH_REG)); ++ seq_printf(s, " FG_DES_CAP[%02x] : %04x\n", + AXP288_FG_DES_CAP1_REG, +- fuel_gauge_reg_readb(info, AXP288_FG_DES_CAP1_REG)); +- seq_printf(s, "FG_DES_CAP0[%02x] : %02x\n", +- AXP288_FG_DES_CAP0_REG, +- fuel_gauge_reg_readb(info, AXP288_FG_DES_CAP0_REG)); +- seq_printf(s, " FG_CC_MTR1[%02x] : %02x\n", ++ fuel_gauge_read_15bit_word(info, AXP288_FG_DES_CAP1_REG)); ++ seq_printf(s, " FG_CC_MTR[%02x] : %04x\n", + AXP288_FG_CC_MTR1_REG, +- fuel_gauge_reg_readb(info, AXP288_FG_CC_MTR1_REG)); +- seq_printf(s, " FG_CC_MTR0[%02x] : %02x\n", +- AXP288_FG_CC_MTR0_REG, +- fuel_gauge_reg_readb(info, AXP288_FG_CC_MTR0_REG)); ++ fuel_gauge_read_15bit_word(info, AXP288_FG_CC_MTR1_REG)); + seq_printf(s, " FG_OCV_CAP[%02x] : %02x\n", + AXP288_FG_OCV_CAP_REG, + fuel_gauge_reg_readb(info, AXP288_FG_OCV_CAP_REG)); +@@ -517,21 +545,12 @@ static int fuel_gauge_get_btemp(struct axp288_fg_info *info, int *btemp) + + static int fuel_gauge_get_vocv(struct axp288_fg_info *info, int *vocv) + { +- int ret, value; +- +- /* 12-bit data value, upper 8 in OCVH, lower 4 in OCVL */ +- ret = fuel_gauge_reg_readb(info, AXP288_FG_OCVH_REG); +- if (ret < 0) +- goto vocv_read_fail; +- value = ret << 4; ++ int ret; + +- ret = fuel_gauge_reg_readb(info, AXP288_FG_OCVL_REG); +- if (ret < 0) +- goto vocv_read_fail; +- value |= (ret & 0xf); ++ ret = fuel_gauge_read_12bit_word(info, AXP288_FG_OCVH_REG); ++ if (ret >= 0) ++ *vocv = VOLTAGE_FROM_ADC(ret); + +- *vocv = VOLTAGE_FROM_ADC(value); +-vocv_read_fail: + return ret; + } + +@@ -663,28 +682,18 @@ static int fuel_gauge_get_property(struct power_supply *ps, + val->intval = POWER_SUPPLY_TECHNOLOGY_LION; + break; + case POWER_SUPPLY_PROP_CHARGE_NOW: +- ret = fuel_gauge_reg_readb(info, AXP288_FG_CC_MTR1_REG); ++ ret = fuel_gauge_read_15bit_word(info, AXP288_FG_CC_MTR1_REG); + if (ret < 0) + goto fuel_gauge_read_err; + +- value = (ret & FG_CC_MTR1_VAL_MASK) << 8; +- ret = fuel_gauge_reg_readb(info, AXP288_FG_CC_MTR0_REG); +- if (ret < 0) +- goto fuel_gauge_read_err; +- value |= (ret & FG_CC_MTR0_VAL_MASK); +- val->intval = value * FG_DES_CAP_RES_LSB; ++ val->intval = ret * FG_DES_CAP_RES_LSB; + break; + case POWER_SUPPLY_PROP_CHARGE_FULL: +- ret = fuel_gauge_reg_readb(info, AXP288_FG_DES_CAP1_REG); ++ ret = fuel_gauge_read_15bit_word(info, AXP288_FG_DES_CAP1_REG); + if (ret < 0) + goto fuel_gauge_read_err; + +- value = (ret & FG_DES_CAP1_VAL_MASK) << 8; +- ret = fuel_gauge_reg_readb(info, AXP288_FG_DES_CAP0_REG); +- if (ret < 0) +- goto fuel_gauge_read_err; +- value |= (ret & FG_DES_CAP0_VAL_MASK); +- val->intval = value * FG_DES_CAP_RES_LSB; ++ val->intval = ret * FG_DES_CAP_RES_LSB; + break; + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + val->intval = PROP_CURR(info->pdata->design_cap); +diff --git a/drivers/rtc/rtc-rx8010.c b/drivers/rtc/rtc-rx8010.c +index 7163b91bb773..d08da371912c 100644 +--- a/drivers/rtc/rtc-rx8010.c ++++ b/drivers/rtc/rtc-rx8010.c +@@ -63,7 +63,6 @@ struct rx8010_data { + struct i2c_client *client; + struct rtc_device *rtc; + u8 ctrlreg; +- spinlock_t flags_lock; + }; + + static irqreturn_t rx8010_irq_1_handler(int irq, void *dev_id) +@@ -72,12 +71,12 @@ static irqreturn_t rx8010_irq_1_handler(int irq, void *dev_id) + struct rx8010_data *rx8010 = i2c_get_clientdata(client); + int flagreg; + +- spin_lock(&rx8010->flags_lock); ++ mutex_lock(&rx8010->rtc->ops_lock); + + flagreg = i2c_smbus_read_byte_data(client, RX8010_FLAG); + + if (flagreg <= 0) { +- spin_unlock(&rx8010->flags_lock); ++ mutex_unlock(&rx8010->rtc->ops_lock); + return IRQ_NONE; + } + +@@ -101,7 +100,7 @@ static irqreturn_t rx8010_irq_1_handler(int irq, void *dev_id) + + i2c_smbus_write_byte_data(client, RX8010_FLAG, flagreg); + +- spin_unlock(&rx8010->flags_lock); ++ mutex_unlock(&rx8010->rtc->ops_lock); + return IRQ_HANDLED; + } + +@@ -143,7 +142,6 @@ static int rx8010_set_time(struct device *dev, struct rtc_time *dt) + u8 date[7]; + int ctrl, flagreg; + int ret; +- unsigned long irqflags; + + if ((dt->tm_year < 100) || (dt->tm_year > 199)) + return -EINVAL; +@@ -181,11 +179,8 @@ static int rx8010_set_time(struct device *dev, struct rtc_time *dt) + if (ret < 0) + return ret; + +- spin_lock_irqsave(&rx8010->flags_lock, irqflags); +- + flagreg = i2c_smbus_read_byte_data(rx8010->client, RX8010_FLAG); + if (flagreg < 0) { +- spin_unlock_irqrestore(&rx8010->flags_lock, irqflags); + return flagreg; + } + +@@ -193,8 +188,6 @@ static int rx8010_set_time(struct device *dev, struct rtc_time *dt) + ret = i2c_smbus_write_byte_data(rx8010->client, RX8010_FLAG, + flagreg & ~RX8010_FLAG_VLF); + +- spin_unlock_irqrestore(&rx8010->flags_lock, irqflags); +- + return 0; + } + +@@ -288,12 +281,9 @@ static int rx8010_set_alarm(struct device *dev, struct rtc_wkalrm *t) + u8 alarmvals[3]; + int extreg, flagreg; + int err; +- unsigned long irqflags; + +- spin_lock_irqsave(&rx8010->flags_lock, irqflags); + flagreg = i2c_smbus_read_byte_data(client, RX8010_FLAG); + if (flagreg < 0) { +- spin_unlock_irqrestore(&rx8010->flags_lock, irqflags); + return flagreg; + } + +@@ -302,14 +292,12 @@ static int rx8010_set_alarm(struct device *dev, struct rtc_wkalrm *t) + err = i2c_smbus_write_byte_data(rx8010->client, RX8010_CTRL, + rx8010->ctrlreg); + if (err < 0) { +- spin_unlock_irqrestore(&rx8010->flags_lock, irqflags); + return err; + } + } + + flagreg &= ~RX8010_FLAG_AF; + err = i2c_smbus_write_byte_data(rx8010->client, RX8010_FLAG, flagreg); +- spin_unlock_irqrestore(&rx8010->flags_lock, irqflags); + if (err < 0) + return err; + +@@ -404,7 +392,6 @@ static int rx8010_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) + struct rx8010_data *rx8010 = dev_get_drvdata(dev); + int ret, tmp; + int flagreg; +- unsigned long irqflags; + + switch (cmd) { + case RTC_VL_READ: +@@ -419,16 +406,13 @@ static int rx8010_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) + return 0; + + case RTC_VL_CLR: +- spin_lock_irqsave(&rx8010->flags_lock, irqflags); + flagreg = i2c_smbus_read_byte_data(rx8010->client, RX8010_FLAG); + if (flagreg < 0) { +- spin_unlock_irqrestore(&rx8010->flags_lock, irqflags); + return flagreg; + } + + flagreg &= ~RX8010_FLAG_VLF; + ret = i2c_smbus_write_byte_data(client, RX8010_FLAG, flagreg); +- spin_unlock_irqrestore(&rx8010->flags_lock, irqflags); + if (ret < 0) + return ret; + +@@ -466,8 +450,6 @@ static int rx8010_probe(struct i2c_client *client, + rx8010->client = client; + i2c_set_clientdata(client, rx8010); + +- spin_lock_init(&rx8010->flags_lock); +- + err = rx8010_init_client(client); + if (err) + return err; +diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c +index f1019908800e..453299095847 100644 +--- a/drivers/scsi/lpfc/lpfc_attr.c ++++ b/drivers/scsi/lpfc/lpfc_attr.c +@@ -5130,6 +5130,19 @@ lpfc_free_sysfs_attr(struct lpfc_vport *vport) + * Dynamic FC Host Attributes Support + */ + ++/** ++ * lpfc_get_host_symbolic_name - Copy symbolic name into the scsi host ++ * @shost: kernel scsi host pointer. ++ **/ ++static void ++lpfc_get_host_symbolic_name(struct Scsi_Host *shost) ++{ ++ struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata; ++ ++ lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost), ++ sizeof fc_host_symbolic_name(shost)); ++} ++ + /** + * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id + * @shost: kernel scsi host pointer. +@@ -5667,6 +5680,8 @@ struct fc_function_template lpfc_transport_functions = { + .show_host_supported_fc4s = 1, + .show_host_supported_speeds = 1, + .show_host_maxframe_size = 1, ++ ++ .get_host_symbolic_name = lpfc_get_host_symbolic_name, + .show_host_symbolic_name = 1, + + /* dynamic attributes the driver supports */ +@@ -5734,6 +5749,8 @@ struct fc_function_template lpfc_vport_transport_functions = { + .show_host_supported_fc4s = 1, + .show_host_supported_speeds = 1, + .show_host_maxframe_size = 1, ++ ++ .get_host_symbolic_name = lpfc_get_host_symbolic_name, + .show_host_symbolic_name = 1, + + /* dynamic attributes the driver supports */ +diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c +index 7b696d108112..4df3cdcf88ce 100644 +--- a/drivers/scsi/lpfc/lpfc_els.c ++++ b/drivers/scsi/lpfc/lpfc_els.c +@@ -1999,6 +1999,9 @@ lpfc_issue_els_plogi(struct lpfc_vport *vport, uint32_t did, uint8_t retry) + if (sp->cmn.fcphHigh < FC_PH3) + sp->cmn.fcphHigh = FC_PH3; + ++ sp->cmn.valid_vendor_ver_level = 0; ++ memset(sp->vendorVersion, 0, sizeof(sp->vendorVersion)); ++ + lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD, + "Issue PLOGI: did:x%x", + did, 0, 0); +@@ -3990,6 +3993,9 @@ lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag, + } else { + memcpy(pcmd, &vport->fc_sparam, + sizeof(struct serv_parm)); ++ ++ sp->cmn.valid_vendor_ver_level = 0; ++ memset(sp->vendorVersion, 0, sizeof(sp->vendorVersion)); + } + + lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_RSP, +diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h +index 822654322e67..3b970d370600 100644 +--- a/drivers/scsi/lpfc/lpfc_hw.h ++++ b/drivers/scsi/lpfc/lpfc_hw.h +@@ -360,6 +360,12 @@ struct csp { + * Word 1 Bit 30 in PLOGI request is random offset + */ + #define virtual_fabric_support randomOffset /* Word 1, bit 30 */ ++/* ++ * Word 1 Bit 29 in common service parameter is overloaded. ++ * Word 1 Bit 29 in FLOGI response is multiple NPort assignment ++ * Word 1 Bit 29 in FLOGI/PLOGI request is Valid Vendor Version Level ++ */ ++#define valid_vendor_ver_level response_multiple_NPort /* Word 1, bit 29 */ + #ifdef __BIG_ENDIAN_BITFIELD + uint16_t request_multiple_Nport:1; /* FC Word 1, bit 31 */ + uint16_t randomOffset:1; /* FC Word 1, bit 30 */ +diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c +index 2d4f4b58dcfa..8f1df76a77b6 100644 +--- a/drivers/scsi/lpfc/lpfc_sli.c ++++ b/drivers/scsi/lpfc/lpfc_sli.c +@@ -119,6 +119,8 @@ lpfc_sli4_wq_put(struct lpfc_queue *q, union lpfc_wqe *wqe) + if (q->phba->sli3_options & LPFC_SLI4_PHWQ_ENABLED) + bf_set(wqe_wqid, &wqe->generic.wqe_com, q->queue_id); + lpfc_sli_pcimem_bcopy(wqe, temp_wqe, q->entry_size); ++ /* ensure WQE bcopy flushed before doorbell write */ ++ wmb(); + + /* Update the host index before invoking device */ + host_index = q->host_index; +@@ -10004,6 +10006,7 @@ lpfc_sli_abort_iotag_issue(struct lpfc_hba *phba, struct lpfc_sli_ring *pring, + iabt->ulpCommand = CMD_CLOSE_XRI_CN; + + abtsiocbp->iocb_cmpl = lpfc_sli_abort_els_cmpl; ++ abtsiocbp->vport = vport; + + lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI, + "0339 Abort xri x%x, original iotag x%x, " +diff --git a/drivers/scsi/lpfc/lpfc_vport.c b/drivers/scsi/lpfc/lpfc_vport.c +index c27f4b724547..e18bbc66e83b 100644 +--- a/drivers/scsi/lpfc/lpfc_vport.c ++++ b/drivers/scsi/lpfc/lpfc_vport.c +@@ -537,6 +537,12 @@ enable_vport(struct fc_vport *fc_vport) + + spin_lock_irq(shost->host_lock); + vport->load_flag |= FC_LOADING; ++ if (vport->fc_flag & FC_VPORT_NEEDS_INIT_VPI) { ++ spin_unlock_irq(shost->host_lock); ++ lpfc_issue_init_vpi(vport); ++ goto out; ++ } ++ + vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI; + spin_unlock_irq(shost->host_lock); + +@@ -557,6 +563,8 @@ enable_vport(struct fc_vport *fc_vport) + } else { + lpfc_vport_set_state(vport, FC_VPORT_FAILED); + } ++ ++out: + lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, + "1827 Vport Enabled.\n"); + return VPORT_OK; +diff --git a/drivers/scsi/ufs/ufs-qcom.c b/drivers/scsi/ufs/ufs-qcom.c +index 462bf42dd19c..51d559214db6 100644 +--- a/drivers/scsi/ufs/ufs-qcom.c ++++ b/drivers/scsi/ufs/ufs-qcom.c +@@ -1689,6 +1689,7 @@ static const struct of_device_id ufs_qcom_of_match[] = { + { .compatible = "qcom,ufshc"}, + {}, + }; ++MODULE_DEVICE_TABLE(of, ufs_qcom_of_match); + + static const struct dev_pm_ops ufs_qcom_pm_ops = { + .suspend = ufshcd_pltfrm_suspend, +diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c +index edb06e466224..530034bc2d13 100644 +--- a/drivers/scsi/ufs/ufshcd.c ++++ b/drivers/scsi/ufs/ufshcd.c +@@ -3781,18 +3781,25 @@ static int ufshcd_disable_auto_bkops(struct ufs_hba *hba) + } + + /** +- * ufshcd_force_reset_auto_bkops - force enable of auto bkops ++ * ufshcd_force_reset_auto_bkops - force reset auto bkops state + * @hba: per adapter instance + * + * After a device reset the device may toggle the BKOPS_EN flag + * to default value. The s/w tracking variables should be updated +- * as well. Do this by forcing enable of auto bkops. ++ * as well. This function would change the auto-bkops state based on ++ * UFSHCD_CAP_KEEP_AUTO_BKOPS_ENABLED_EXCEPT_SUSPEND. + */ +-static void ufshcd_force_reset_auto_bkops(struct ufs_hba *hba) ++static void ufshcd_force_reset_auto_bkops(struct ufs_hba *hba) + { +- hba->auto_bkops_enabled = false; +- hba->ee_ctrl_mask |= MASK_EE_URGENT_BKOPS; +- ufshcd_enable_auto_bkops(hba); ++ if (ufshcd_keep_autobkops_enabled_except_suspend(hba)) { ++ hba->auto_bkops_enabled = false; ++ hba->ee_ctrl_mask |= MASK_EE_URGENT_BKOPS; ++ ufshcd_enable_auto_bkops(hba); ++ } else { ++ hba->auto_bkops_enabled = true; ++ hba->ee_ctrl_mask &= ~MASK_EE_URGENT_BKOPS; ++ ufshcd_disable_auto_bkops(hba); ++ } + } + + static inline int ufshcd_get_bkops_status(struct ufs_hba *hba, u32 *status) +@@ -6138,11 +6145,15 @@ static int ufshcd_resume(struct ufs_hba *hba, enum ufs_pm_op pm_op) + goto set_old_link_state; + } + +- /* +- * If BKOPs operations are urgently needed at this moment then +- * keep auto-bkops enabled or else disable it. +- */ +- ufshcd_urgent_bkops(hba); ++ if (ufshcd_keep_autobkops_enabled_except_suspend(hba)) ++ ufshcd_enable_auto_bkops(hba); ++ else ++ /* ++ * If BKOPs operations are urgently needed at this moment then ++ * keep auto-bkops enabled or else disable it. ++ */ ++ ufshcd_urgent_bkops(hba); ++ + hba->clk_gating.is_suspended = false; + + if (ufshcd_is_clkscaling_enabled(hba)) +diff --git a/drivers/scsi/ufs/ufshcd.h b/drivers/scsi/ufs/ufshcd.h +index 04509827fe64..f2170d5058a8 100644 +--- a/drivers/scsi/ufs/ufshcd.h ++++ b/drivers/scsi/ufs/ufshcd.h +@@ -548,6 +548,14 @@ struct ufs_hba { + * CAUTION: Enabling this might reduce overall UFS throughput. + */ + #define UFSHCD_CAP_INTR_AGGR (1 << 4) ++ /* ++ * This capability allows the device auto-bkops to be always enabled ++ * except during suspend (both runtime and suspend). ++ * Enabling this capability means that device will always be allowed ++ * to do background operation when it's active but it might degrade ++ * the performance of ongoing read/write operations. ++ */ ++#define UFSHCD_CAP_KEEP_AUTO_BKOPS_ENABLED_EXCEPT_SUSPEND (1 << 5) + + struct devfreq *devfreq; + struct ufs_clk_scaling clk_scaling; +@@ -645,6 +653,11 @@ static inline void *ufshcd_get_variant(struct ufs_hba *hba) + BUG_ON(!hba); + return hba->priv; + } ++static inline bool ufshcd_keep_autobkops_enabled_except_suspend( ++ struct ufs_hba *hba) ++{ ++ return hba->caps & UFSHCD_CAP_KEEP_AUTO_BKOPS_ENABLED_EXCEPT_SUSPEND; ++} + + extern int ufshcd_runtime_suspend(struct ufs_hba *hba); + extern int ufshcd_runtime_resume(struct ufs_hba *hba); +diff --git a/drivers/staging/greybus/connection.c b/drivers/staging/greybus/connection.c +index 557075147f2d..1bf0ee403106 100644 +--- a/drivers/staging/greybus/connection.c ++++ b/drivers/staging/greybus/connection.c +@@ -357,6 +357,9 @@ static int gb_connection_hd_cport_quiesce(struct gb_connection *connection) + size_t peer_space; + int ret; + ++ if (!hd->driver->cport_quiesce) ++ return 0; ++ + peer_space = sizeof(struct gb_operation_msg_hdr) + + sizeof(struct gb_cport_shutdown_request); + +@@ -380,6 +383,9 @@ static int gb_connection_hd_cport_clear(struct gb_connection *connection) + struct gb_host_device *hd = connection->hd; + int ret; + ++ if (!hd->driver->cport_clear) ++ return 0; ++ + ret = hd->driver->cport_clear(hd, connection->hd_cport_id); + if (ret) { + dev_err(&hd->dev, "%s: failed to clear host cport: %d\n", +diff --git a/drivers/staging/greybus/spilib.c b/drivers/staging/greybus/spilib.c +index e97b19148497..1e7321a1404c 100644 +--- a/drivers/staging/greybus/spilib.c ++++ b/drivers/staging/greybus/spilib.c +@@ -544,11 +544,14 @@ int gb_spilib_master_init(struct gb_connection *connection, struct device *dev, + + return 0; + +-exit_spi_unregister: +- spi_unregister_master(master); + exit_spi_put: + spi_master_put(master); + ++ return ret; ++ ++exit_spi_unregister: ++ spi_unregister_master(master); ++ + return ret; + } + EXPORT_SYMBOL_GPL(gb_spilib_master_init); +@@ -558,7 +561,6 @@ void gb_spilib_master_exit(struct gb_connection *connection) + struct spi_master *master = gb_connection_get_data(connection); + + spi_unregister_master(master); +- spi_master_put(master); + } + EXPORT_SYMBOL_GPL(gb_spilib_master_exit); + +diff --git a/drivers/staging/rtl8188eu/include/rtw_debug.h b/drivers/staging/rtl8188eu/include/rtw_debug.h +index 95590a1a7b1b..9cc4b8c7c166 100644 +--- a/drivers/staging/rtl8188eu/include/rtw_debug.h ++++ b/drivers/staging/rtl8188eu/include/rtw_debug.h +@@ -70,7 +70,7 @@ extern u32 GlobalDebugLevel; + #define DBG_88E_LEVEL(_level, fmt, arg...) \ + do { \ + if (_level <= GlobalDebugLevel) \ +- pr_info(DRIVER_PREFIX"ERROR " fmt, ##arg); \ ++ pr_info(DRIVER_PREFIX fmt, ##arg); \ + } while (0) + + #define DBG_88E(...) \ +diff --git a/drivers/staging/rtl8712/rtl871x_ioctl_linux.c b/drivers/staging/rtl8712/rtl871x_ioctl_linux.c +index 475e7904fe45..2d26f9a30fcf 100644 +--- a/drivers/staging/rtl8712/rtl871x_ioctl_linux.c ++++ b/drivers/staging/rtl8712/rtl871x_ioctl_linux.c +@@ -199,7 +199,7 @@ static noinline_for_stack char *translate_scan(struct _adapter *padapter, + iwe.cmd = SIOCGIWMODE; + memcpy((u8 *)&cap, r8712_get_capability_from_ie(pnetwork->network.IEs), + 2); +- cap = le16_to_cpu(cap); ++ le16_to_cpus(&cap); + if (cap & (WLAN_CAPABILITY_IBSS | WLAN_CAPABILITY_BSS)) { + if (cap & WLAN_CAPABILITY_BSS) + iwe.u.mode = (u32)IW_MODE_MASTER; +diff --git a/drivers/staging/wilc1000/linux_wlan.c b/drivers/staging/wilc1000/linux_wlan.c +index defffa75ae1c..07d6e4824a9d 100644 +--- a/drivers/staging/wilc1000/linux_wlan.c ++++ b/drivers/staging/wilc1000/linux_wlan.c +@@ -1001,7 +1001,7 @@ int wilc_mac_xmit(struct sk_buff *skb, struct net_device *ndev) + tx_data->skb = skb; + + eth_h = (struct ethhdr *)(skb->data); +- if (eth_h->h_proto == 0x8e88) ++ if (eth_h->h_proto == cpu_to_be16(0x8e88)) + netdev_dbg(ndev, "EAPOL transmitted\n"); + + ih = (struct iphdr *)(skb->data + sizeof(struct ethhdr)); +diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c +index c8075eb3db26..fa619354c5c5 100644 +--- a/drivers/usb/core/devio.c ++++ b/drivers/usb/core/devio.c +@@ -1838,6 +1838,18 @@ static int proc_unlinkurb(struct usb_dev_state *ps, void __user *arg) + return 0; + } + ++static void compute_isochronous_actual_length(struct urb *urb) ++{ ++ unsigned int i; ++ ++ if (urb->number_of_packets > 0) { ++ urb->actual_length = 0; ++ for (i = 0; i < urb->number_of_packets; i++) ++ urb->actual_length += ++ urb->iso_frame_desc[i].actual_length; ++ } ++} ++ + static int processcompl(struct async *as, void __user * __user *arg) + { + struct urb *urb = as->urb; +@@ -1845,6 +1857,7 @@ static int processcompl(struct async *as, void __user * __user *arg) + void __user *addr = as->userurb; + unsigned int i; + ++ compute_isochronous_actual_length(urb); + if (as->userbuffer && urb->actual_length) { + if (copy_urb_data_to_user(as->userbuffer, urb)) + goto err_out; +@@ -2019,6 +2032,7 @@ static int processcompl_compat(struct async *as, void __user * __user *arg) + void __user *addr = as->userurb; + unsigned int i; + ++ compute_isochronous_actual_length(urb); + if (as->userbuffer && urb->actual_length) { + if (copy_urb_data_to_user(as->userbuffer, urb)) + return -EFAULT; +diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c +index a6aaf2f193a4..37c418e581fb 100644 +--- a/drivers/usb/core/quirks.c ++++ b/drivers/usb/core/quirks.c +@@ -221,6 +221,9 @@ static const struct usb_device_id usb_quirk_list[] = { + /* Corsair Strafe RGB */ + { USB_DEVICE(0x1b1c, 0x1b20), .driver_info = USB_QUIRK_DELAY_INIT }, + ++ /* Corsair K70 LUX */ ++ { USB_DEVICE(0x1b1c, 0x1b36), .driver_info = USB_QUIRK_DELAY_INIT }, ++ + /* MIDI keyboard WORLDE MINI */ + { USB_DEVICE(0x1c75, 0x0204), .driver_info = + USB_QUIRK_CONFIG_INTF_STRINGS }, +diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c +index f9c99803a43d..273320fa30ae 100644 +--- a/drivers/usb/gadget/function/f_fs.c ++++ b/drivers/usb/gadget/function/f_fs.c +@@ -3698,6 +3698,7 @@ static void ffs_closed(struct ffs_data *ffs) + goto done; + + ffs_obj->desc_ready = false; ++ ffs_obj->ffs_data = NULL; + + if (test_and_clear_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags) && + ffs_obj->ffs_closed_callback) +diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c +index b2f2e87aed94..91e7e3a166a5 100644 +--- a/drivers/usb/serial/garmin_gps.c ++++ b/drivers/usb/serial/garmin_gps.c +@@ -138,6 +138,7 @@ struct garmin_data { + __u8 privpkt[4*6]; + spinlock_t lock; + struct list_head pktlist; ++ struct usb_anchor write_urbs; + }; + + +@@ -905,13 +906,19 @@ static int garmin_init_session(struct usb_serial_port *port) + sizeof(GARMIN_START_SESSION_REQ), 0); + + if (status < 0) +- break; ++ goto err_kill_urbs; + } + + if (status > 0) + status = 0; + } + ++ return status; ++ ++err_kill_urbs: ++ usb_kill_anchored_urbs(&garmin_data_p->write_urbs); ++ usb_kill_urb(port->interrupt_in_urb); ++ + return status; + } + +@@ -930,7 +937,6 @@ static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port) + spin_unlock_irqrestore(&garmin_data_p->lock, flags); + + /* shutdown any bulk reads that might be going on */ +- usb_kill_urb(port->write_urb); + usb_kill_urb(port->read_urb); + + if (garmin_data_p->state == STATE_RESET) +@@ -953,7 +959,7 @@ static void garmin_close(struct usb_serial_port *port) + + /* shutdown our urbs */ + usb_kill_urb(port->read_urb); +- usb_kill_urb(port->write_urb); ++ usb_kill_anchored_urbs(&garmin_data_p->write_urbs); + + /* keep reset state so we know that we must start a new session */ + if (garmin_data_p->state != STATE_RESET) +@@ -1037,12 +1043,14 @@ static int garmin_write_bulk(struct usb_serial_port *port, + } + + /* send it down the pipe */ ++ usb_anchor_urb(urb, &garmin_data_p->write_urbs); + status = usb_submit_urb(urb, GFP_ATOMIC); + if (status) { + dev_err(&port->dev, + "%s - usb_submit_urb(write bulk) failed with status = %d\n", + __func__, status); + count = status; ++ usb_unanchor_urb(urb); + kfree(buffer); + } + +@@ -1401,9 +1409,16 @@ static int garmin_port_probe(struct usb_serial_port *port) + garmin_data_p->state = 0; + garmin_data_p->flags = 0; + garmin_data_p->count = 0; ++ init_usb_anchor(&garmin_data_p->write_urbs); + usb_set_serial_port_data(port, garmin_data_p); + + status = garmin_init_session(port); ++ if (status) ++ goto err_free; ++ ++ return 0; ++err_free: ++ kfree(garmin_data_p); + + return status; + } +@@ -1413,6 +1428,7 @@ static int garmin_port_remove(struct usb_serial_port *port) + { + struct garmin_data *garmin_data_p = usb_get_serial_port_data(port); + ++ usb_kill_anchored_urbs(&garmin_data_p->write_urbs); + usb_kill_urb(port->interrupt_in_urb); + del_timer_sync(&garmin_data_p->timer); + kfree(garmin_data_p); +diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c +index e1c1e329c877..4516291df1b8 100644 +--- a/drivers/usb/serial/qcserial.c ++++ b/drivers/usb/serial/qcserial.c +@@ -148,6 +148,7 @@ static const struct usb_device_id id_table[] = { + {DEVICE_SWI(0x1199, 0x68a2)}, /* Sierra Wireless MC7710 */ + {DEVICE_SWI(0x1199, 0x68c0)}, /* Sierra Wireless MC7304/MC7354 */ + {DEVICE_SWI(0x1199, 0x901c)}, /* Sierra Wireless EM7700 */ ++ {DEVICE_SWI(0x1199, 0x901e)}, /* Sierra Wireless EM7355 QDL */ + {DEVICE_SWI(0x1199, 0x901f)}, /* Sierra Wireless EM7355 */ + {DEVICE_SWI(0x1199, 0x9040)}, /* Sierra Wireless Modem */ + {DEVICE_SWI(0x1199, 0x9041)}, /* Sierra Wireless MC7305/MC7355 */ +diff --git a/drivers/video/backlight/adp5520_bl.c b/drivers/video/backlight/adp5520_bl.c +index dd88ba1d71ce..35373e2065b2 100644 +--- a/drivers/video/backlight/adp5520_bl.c ++++ b/drivers/video/backlight/adp5520_bl.c +@@ -332,10 +332,18 @@ static int adp5520_bl_probe(struct platform_device *pdev) + } + + platform_set_drvdata(pdev, bl); +- ret |= adp5520_bl_setup(bl); ++ ret = adp5520_bl_setup(bl); ++ if (ret) { ++ dev_err(&pdev->dev, "failed to setup\n"); ++ if (data->pdata->en_ambl_sens) ++ sysfs_remove_group(&bl->dev.kobj, ++ &adp5520_bl_attr_group); ++ return ret; ++ } ++ + backlight_update_status(bl); + +- return ret; ++ return 0; + } + + static int adp5520_bl_remove(struct platform_device *pdev) +diff --git a/drivers/video/backlight/lcd.c b/drivers/video/backlight/lcd.c +index 7de847df224f..4b40c6a4d441 100644 +--- a/drivers/video/backlight/lcd.c ++++ b/drivers/video/backlight/lcd.c +@@ -226,6 +226,8 @@ struct lcd_device *lcd_device_register(const char *name, struct device *parent, + dev_set_name(&new_ld->dev, "%s", name); + dev_set_drvdata(&new_ld->dev, devdata); + ++ new_ld->ops = ops; ++ + rc = device_register(&new_ld->dev); + if (rc) { + put_device(&new_ld->dev); +@@ -238,8 +240,6 @@ struct lcd_device *lcd_device_register(const char *name, struct device *parent, + return ERR_PTR(rc); + } + +- new_ld->ops = ops; +- + return new_ld; + } + EXPORT_SYMBOL(lcd_device_register); +diff --git a/include/dt-bindings/pinctrl/omap.h b/include/dt-bindings/pinctrl/omap.h +index effadd05695b..fbd6f7202476 100644 +--- a/include/dt-bindings/pinctrl/omap.h ++++ b/include/dt-bindings/pinctrl/omap.h +@@ -45,8 +45,8 @@ + #define PIN_OFF_NONE 0 + #define PIN_OFF_OUTPUT_HIGH (OFF_EN | OFFOUT_EN | OFFOUT_VAL) + #define PIN_OFF_OUTPUT_LOW (OFF_EN | OFFOUT_EN) +-#define PIN_OFF_INPUT_PULLUP (OFF_EN | OFF_PULL_EN | OFF_PULL_UP) +-#define PIN_OFF_INPUT_PULLDOWN (OFF_EN | OFF_PULL_EN) ++#define PIN_OFF_INPUT_PULLUP (OFF_EN | OFFOUT_EN | OFF_PULL_EN | OFF_PULL_UP) ++#define PIN_OFF_INPUT_PULLDOWN (OFF_EN | OFFOUT_EN | OFF_PULL_EN) + #define PIN_OFF_WAKEUPENABLE WAKEUP_EN + + /* +diff --git a/include/uapi/linux/rds.h b/include/uapi/linux/rds.h +index 7af20a136429..804c9b2bfce3 100644 +--- a/include/uapi/linux/rds.h ++++ b/include/uapi/linux/rds.h +@@ -104,8 +104,8 @@ + #define RDS_INFO_LAST 10010 + + struct rds_info_counter { +- uint8_t name[32]; +- uint64_t value; ++ __u8 name[32]; ++ __u64 value; + } __attribute__((packed)); + + #define RDS_INFO_CONNECTION_FLAG_SENDING 0x01 +@@ -115,35 +115,35 @@ struct rds_info_counter { + #define TRANSNAMSIZ 16 + + struct rds_info_connection { +- uint64_t next_tx_seq; +- uint64_t next_rx_seq; ++ __u64 next_tx_seq; ++ __u64 next_rx_seq; + __be32 laddr; + __be32 faddr; +- uint8_t transport[TRANSNAMSIZ]; /* null term ascii */ +- uint8_t flags; ++ __u8 transport[TRANSNAMSIZ]; /* null term ascii */ ++ __u8 flags; + } __attribute__((packed)); + + #define RDS_INFO_MESSAGE_FLAG_ACK 0x01 + #define RDS_INFO_MESSAGE_FLAG_FAST_ACK 0x02 + + struct rds_info_message { +- uint64_t seq; +- uint32_t len; ++ __u64 seq; ++ __u32 len; + __be32 laddr; + __be32 faddr; + __be16 lport; + __be16 fport; +- uint8_t flags; ++ __u8 flags; + } __attribute__((packed)); + + struct rds_info_socket { +- uint32_t sndbuf; ++ __u32 sndbuf; + __be32 bound_addr; + __be32 connected_addr; + __be16 bound_port; + __be16 connected_port; +- uint32_t rcvbuf; +- uint64_t inum; ++ __u32 rcvbuf; ++ __u64 inum; + } __attribute__((packed)); + + struct rds_info_tcp_socket { +@@ -151,25 +151,25 @@ struct rds_info_tcp_socket { + __be16 local_port; + __be32 peer_addr; + __be16 peer_port; +- uint64_t hdr_rem; +- uint64_t data_rem; +- uint32_t last_sent_nxt; +- uint32_t last_expected_una; +- uint32_t last_seen_una; ++ __u64 hdr_rem; ++ __u64 data_rem; ++ __u32 last_sent_nxt; ++ __u32 last_expected_una; ++ __u32 last_seen_una; + } __attribute__((packed)); + + #define RDS_IB_GID_LEN 16 + struct rds_info_rdma_connection { + __be32 src_addr; + __be32 dst_addr; +- uint8_t src_gid[RDS_IB_GID_LEN]; +- uint8_t dst_gid[RDS_IB_GID_LEN]; ++ __u8 src_gid[RDS_IB_GID_LEN]; ++ __u8 dst_gid[RDS_IB_GID_LEN]; + +- uint32_t max_send_wr; +- uint32_t max_recv_wr; +- uint32_t max_send_sge; +- uint32_t rdma_mr_max; +- uint32_t rdma_mr_size; ++ __u32 max_send_wr; ++ __u32 max_recv_wr; ++ __u32 max_send_sge; ++ __u32 rdma_mr_max; ++ __u32 rdma_mr_size; + }; + + /* +@@ -210,70 +210,70 @@ struct rds_info_rdma_connection { + * (so that the application does not have to worry about + * alignment). + */ +-typedef uint64_t rds_rdma_cookie_t; ++typedef __u64 rds_rdma_cookie_t; + + struct rds_iovec { +- uint64_t addr; +- uint64_t bytes; ++ __u64 addr; ++ __u64 bytes; + }; + + struct rds_get_mr_args { + struct rds_iovec vec; +- uint64_t cookie_addr; +- uint64_t flags; ++ __u64 cookie_addr; ++ __u64 flags; + }; + + struct rds_get_mr_for_dest_args { + struct __kernel_sockaddr_storage dest_addr; + struct rds_iovec vec; +- uint64_t cookie_addr; +- uint64_t flags; ++ __u64 cookie_addr; ++ __u64 flags; + }; + + struct rds_free_mr_args { + rds_rdma_cookie_t cookie; +- uint64_t flags; ++ __u64 flags; + }; + + struct rds_rdma_args { + rds_rdma_cookie_t cookie; + struct rds_iovec remote_vec; +- uint64_t local_vec_addr; +- uint64_t nr_local; +- uint64_t flags; +- uint64_t user_token; ++ __u64 local_vec_addr; ++ __u64 nr_local; ++ __u64 flags; ++ __u64 user_token; + }; + + struct rds_atomic_args { + rds_rdma_cookie_t cookie; +- uint64_t local_addr; +- uint64_t remote_addr; ++ __u64 local_addr; ++ __u64 remote_addr; + union { + struct { +- uint64_t compare; +- uint64_t swap; ++ __u64 compare; ++ __u64 swap; + } cswp; + struct { +- uint64_t add; ++ __u64 add; + } fadd; + struct { +- uint64_t compare; +- uint64_t swap; +- uint64_t compare_mask; +- uint64_t swap_mask; ++ __u64 compare; ++ __u64 swap; ++ __u64 compare_mask; ++ __u64 swap_mask; + } m_cswp; + struct { +- uint64_t add; +- uint64_t nocarry_mask; ++ __u64 add; ++ __u64 nocarry_mask; + } m_fadd; + }; +- uint64_t flags; +- uint64_t user_token; ++ __u64 flags; ++ __u64 user_token; + }; + + struct rds_rdma_notify { +- uint64_t user_token; +- int32_t status; ++ __u64 user_token; ++ __s32 status; + }; + + #define RDS_RDMA_SUCCESS 0 +diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c +index 6b3d27e50317..dd33c785ce16 100644 +--- a/net/ipv4/tcp.c ++++ b/net/ipv4/tcp.c +@@ -431,7 +431,7 @@ EXPORT_SYMBOL(tcp_init_sock); + + static void tcp_tx_timestamp(struct sock *sk, u16 tsflags, struct sk_buff *skb) + { +- if (tsflags) { ++ if (tsflags && skb) { + struct skb_shared_info *shinfo = skb_shinfo(skb); + struct tcp_skb_cb *tcb = TCP_SKB_CB(skb); + +@@ -966,10 +966,8 @@ static ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, + copied += copy; + offset += copy; + size -= copy; +- if (!size) { +- tcp_tx_timestamp(sk, sk->sk_tsflags, skb); ++ if (!size) + goto out; +- } + + if (skb->len < size_goal || (flags & MSG_OOB)) + continue; +@@ -995,8 +993,11 @@ static ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset, + } + + out: +- if (copied && !(flags & MSG_SENDPAGE_NOTLAST)) +- tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); ++ if (copied) { ++ tcp_tx_timestamp(sk, sk->sk_tsflags, tcp_write_queue_tail(sk)); ++ if (!(flags & MSG_SENDPAGE_NOTLAST)) ++ tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); ++ } + return copied; + + do_error: +@@ -1289,7 +1290,6 @@ int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size) + + copied += copy; + if (!msg_data_left(msg)) { +- tcp_tx_timestamp(sk, sockc.tsflags, skb); + if (unlikely(flags & MSG_EOR)) + TCP_SKB_CB(skb)->eor = 1; + goto out; +@@ -1320,8 +1320,10 @@ int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size) + } + + out: +- if (copied) ++ if (copied) { ++ tcp_tx_timestamp(sk, sockc.tsflags, tcp_write_queue_tail(sk)); + tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); ++ } + out_nopush: + release_sock(sk); + return copied + copied_syn; +diff --git a/sound/drivers/vx/vx_pcm.c b/sound/drivers/vx/vx_pcm.c +index 11467272089e..ea7b377f0378 100644 +--- a/sound/drivers/vx/vx_pcm.c ++++ b/sound/drivers/vx/vx_pcm.c +@@ -1015,7 +1015,7 @@ static void vx_pcm_capture_update(struct vx_core *chip, struct snd_pcm_substream + int size, space, count; + struct snd_pcm_runtime *runtime = subs->runtime; + +- if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE)) ++ if (!pipe->running || (chip->chip_status & VX_STAT_IS_STALE)) + return; + + size = runtime->buffer_size - snd_pcm_capture_avail(runtime); +@@ -1048,8 +1048,10 @@ static void vx_pcm_capture_update(struct vx_core *chip, struct snd_pcm_substream + /* ok, let's accelerate! */ + int align = pipe->align * 3; + space = (count / align) * align; +- vx_pseudo_dma_read(chip, runtime, pipe, space); +- count -= space; ++ if (space > 0) { ++ vx_pseudo_dma_read(chip, runtime, pipe, space); ++ count -= space; ++ } + } + /* read the rest of bytes */ + while (count > 0) { +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index fe1d06d50392..80c40a1b8b65 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -338,6 +338,7 @@ static void alc_fill_eapd_coef(struct hda_codec *codec) + case 0x10ec0288: + case 0x10ec0295: + case 0x10ec0298: ++ case 0x10ec0299: + alc_update_coef_idx(codec, 0x10, 1<<9, 0); + break; + case 0x10ec0285: +@@ -914,6 +915,7 @@ static struct alc_codec_rename_pci_table rename_pci_tbl[] = { + { 0x10ec0256, 0x1028, 0, "ALC3246" }, + { 0x10ec0225, 0x1028, 0, "ALC3253" }, + { 0x10ec0295, 0x1028, 0, "ALC3254" }, ++ { 0x10ec0299, 0x1028, 0, "ALC3271" }, + { 0x10ec0670, 0x1025, 0, "ALC669X" }, + { 0x10ec0676, 0x1025, 0, "ALC679X" }, + { 0x10ec0282, 0x1043, 0, "ALC3229" }, +@@ -3721,6 +3723,7 @@ static void alc_headset_mode_unplugged(struct hda_codec *codec) + break; + case 0x10ec0225: + case 0x10ec0295: ++ case 0x10ec0299: + alc_process_coef_fw(codec, coef0225); + break; + case 0x10ec0867: +@@ -3829,6 +3832,7 @@ static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin, + break; + case 0x10ec0225: + case 0x10ec0295: ++ case 0x10ec0299: + alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10); + snd_hda_set_pin_ctl_cache(codec, hp_pin, 0); + alc_process_coef_fw(codec, coef0225); +@@ -3887,6 +3891,7 @@ static void alc_headset_mode_default(struct hda_codec *codec) + switch (codec->core.vendor_id) { + case 0x10ec0225: + case 0x10ec0295: ++ case 0x10ec0299: + alc_process_coef_fw(codec, coef0225); + break; + case 0x10ec0236: +@@ -4004,6 +4009,7 @@ static void alc_headset_mode_ctia(struct hda_codec *codec) + break; + case 0x10ec0225: + case 0x10ec0295: ++ case 0x10ec0299: + alc_process_coef_fw(codec, coef0225); + break; + case 0x10ec0867: +@@ -4098,6 +4104,7 @@ static void alc_headset_mode_omtp(struct hda_codec *codec) + break; + case 0x10ec0225: + case 0x10ec0295: ++ case 0x10ec0299: + alc_process_coef_fw(codec, coef0225); + break; + } +@@ -4183,6 +4190,7 @@ static void alc_determine_headset_type(struct hda_codec *codec) + break; + case 0x10ec0225: + case 0x10ec0295: ++ case 0x10ec0299: + alc_process_coef_fw(codec, coef0225); + msleep(800); + val = alc_read_coef_idx(codec, 0x46); +@@ -6251,6 +6259,7 @@ static int patch_alc269(struct hda_codec *codec) + break; + case 0x10ec0225: + case 0x10ec0295: ++ case 0x10ec0299: + spec->codec_variant = ALC269_TYPE_ALC225; + break; + case 0x10ec0234: +@@ -7249,6 +7258,7 @@ static const struct hda_device_id snd_hda_id_realtek[] = { + HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269), + HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269), + HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269), ++ HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269), + HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861), + HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd), + HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861), +diff --git a/sound/pci/vx222/vx222_ops.c b/sound/pci/vx222/vx222_ops.c +index af83b3b38052..8e457ea27f89 100644 +--- a/sound/pci/vx222/vx222_ops.c ++++ b/sound/pci/vx222/vx222_ops.c +@@ -269,12 +269,12 @@ static void vx2_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, + + /* Transfer using pseudo-dma. + */ +- if (offset + count > pipe->buffer_bytes) { ++ if (offset + count >= pipe->buffer_bytes) { + int length = pipe->buffer_bytes - offset; + count -= length; + length >>= 2; /* in 32bit words */ + /* Transfer using pseudo-dma. */ +- while (length-- > 0) { ++ for (; length > 0; length--) { + outl(cpu_to_le32(*addr), port); + addr++; + } +@@ -284,7 +284,7 @@ static void vx2_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, + pipe->hw_ptr += count; + count >>= 2; /* in 32bit words */ + /* Transfer using pseudo-dma. */ +- while (count-- > 0) { ++ for (; count > 0; count--) { + outl(cpu_to_le32(*addr), port); + addr++; + } +@@ -307,12 +307,12 @@ static void vx2_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, + vx2_setup_pseudo_dma(chip, 0); + /* Transfer using pseudo-dma. + */ +- if (offset + count > pipe->buffer_bytes) { ++ if (offset + count >= pipe->buffer_bytes) { + int length = pipe->buffer_bytes - offset; + count -= length; + length >>= 2; /* in 32bit words */ + /* Transfer using pseudo-dma. */ +- while (length-- > 0) ++ for (; length > 0; length--) + *addr++ = le32_to_cpu(inl(port)); + addr = (u32 *)runtime->dma_area; + pipe->hw_ptr = 0; +@@ -320,7 +320,7 @@ static void vx2_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, + pipe->hw_ptr += count; + count >>= 2; /* in 32bit words */ + /* Transfer using pseudo-dma. */ +- while (count-- > 0) ++ for (; count > 0; count--) + *addr++ = le32_to_cpu(inl(port)); + + vx2_release_pseudo_dma(chip); +diff --git a/sound/pcmcia/vx/vxp_ops.c b/sound/pcmcia/vx/vxp_ops.c +index 281972913c32..56aa1ba73ccc 100644 +--- a/sound/pcmcia/vx/vxp_ops.c ++++ b/sound/pcmcia/vx/vxp_ops.c +@@ -369,12 +369,12 @@ static void vxp_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, + unsigned short *addr = (unsigned short *)(runtime->dma_area + offset); + + vx_setup_pseudo_dma(chip, 1); +- if (offset + count > pipe->buffer_bytes) { ++ if (offset + count >= pipe->buffer_bytes) { + int length = pipe->buffer_bytes - offset; + count -= length; + length >>= 1; /* in 16bit words */ + /* Transfer using pseudo-dma. */ +- while (length-- > 0) { ++ for (; length > 0; length--) { + outw(cpu_to_le16(*addr), port); + addr++; + } +@@ -384,7 +384,7 @@ static void vxp_dma_write(struct vx_core *chip, struct snd_pcm_runtime *runtime, + pipe->hw_ptr += count; + count >>= 1; /* in 16bit words */ + /* Transfer using pseudo-dma. */ +- while (count-- > 0) { ++ for (; count > 0; count--) { + outw(cpu_to_le16(*addr), port); + addr++; + } +@@ -411,12 +411,12 @@ static void vxp_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, + if (snd_BUG_ON(count % 2)) + return; + vx_setup_pseudo_dma(chip, 0); +- if (offset + count > pipe->buffer_bytes) { ++ if (offset + count >= pipe->buffer_bytes) { + int length = pipe->buffer_bytes - offset; + count -= length; + length >>= 1; /* in 16bit words */ + /* Transfer using pseudo-dma. */ +- while (length-- > 0) ++ for (; length > 0; length--) + *addr++ = le16_to_cpu(inw(port)); + addr = (unsigned short *)runtime->dma_area; + pipe->hw_ptr = 0; +@@ -424,7 +424,7 @@ static void vxp_dma_read(struct vx_core *chip, struct snd_pcm_runtime *runtime, + pipe->hw_ptr += count; + count >>= 1; /* in 16bit words */ + /* Transfer using pseudo-dma. */ +- while (count-- > 1) ++ for (; count > 1; count--) + *addr++ = le16_to_cpu(inw(port)); + /* Disable DMA */ + pchip->regDIALOG &= ~VXP_DLG_DMAREAD_SEL_MASK;
