diff --git a/5.12.17-19.diff b/5.12.17-19.diff new file mode 100644 index 0000000..fe30d40 --- /dev/null +++ b/5.12.17-19.diff @@ -0,0 +1,26190 @@ +diff --git a/Documentation/Makefile b/Documentation/Makefile +index 9c42dde97671f..c3feb657b6548 100644 +--- a/Documentation/Makefile ++++ b/Documentation/Makefile +@@ -76,7 +76,7 @@ quiet_cmd_sphinx = SPHINX $@ --> file://$(abspath $(BUILDDIR)/$3/$4) + PYTHONDONTWRITEBYTECODE=1 \ + BUILDDIR=$(abspath $(BUILDDIR)) SPHINX_CONF=$(abspath $(srctree)/$(src)/$5/$(SPHINX_CONF)) \ + $(PYTHON3) $(srctree)/scripts/jobserver-exec \ +- $(SHELL) $(srctree)/Documentation/sphinx/parallel-wrapper.sh \ ++ $(CONFIG_SHELL) $(srctree)/Documentation/sphinx/parallel-wrapper.sh \ + $(SPHINXBUILD) \ + -b $2 \ + -c $(abspath $(srctree)/$(src)) \ +diff --git a/Makefile b/Makefile +index f1d0775925cc6..b708d7c665e12 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 12 +-SUBLEVEL = 17 ++SUBLEVEL = 18 + EXTRAVERSION = + NAME = Frozen Wasteland + +diff --git a/arch/alpha/include/uapi/asm/socket.h b/arch/alpha/include/uapi/asm/socket.h +index 57420356ce4c1..6b3daba60987e 100644 +--- a/arch/alpha/include/uapi/asm/socket.h ++++ b/arch/alpha/include/uapi/asm/socket.h +@@ -127,6 +127,8 @@ + #define SO_PREFER_BUSY_POLL 69 + #define SO_BUSY_POLL_BUDGET 70 + ++#define SO_NETNS_COOKIE 71 ++ + #if !defined(__KERNEL__) + + #if __BITS_PER_LONG == 64 +diff --git a/arch/arm64/include/asm/tlb.h b/arch/arm64/include/asm/tlb.h +index 61c97d3b58c70..c995d1f4594f6 100644 +--- a/arch/arm64/include/asm/tlb.h ++++ b/arch/arm64/include/asm/tlb.h +@@ -28,6 +28,10 @@ static void tlb_flush(struct mmu_gather *tlb); + */ + static inline int tlb_get_level(struct mmu_gather *tlb) + { ++ /* The TTL field is only valid for the leaf entry. */ ++ if (tlb->freed_tables) ++ return 0; ++ + if (tlb->cleared_ptes && !(tlb->cleared_pmds || + tlb->cleared_puds || + tlb->cleared_p4ds)) +diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig +index e89d63cd92d10..ab73622b14dd6 100644 +--- a/arch/mips/Kconfig ++++ b/arch/mips/Kconfig +@@ -425,6 +425,8 @@ config MACH_INGENIC_SOC + select MIPS_GENERIC + select MACH_INGENIC + select SYS_SUPPORTS_ZBOOT_UART16550 ++ select CPU_SUPPORTS_CPUFREQ ++ select MIPS_EXTERNAL_TIMER + + config LANTIQ + bool "Lantiq based platforms" +diff --git a/arch/mips/boot/dts/ingenic/ci20.dts b/arch/mips/boot/dts/ingenic/ci20.dts +index 8877c62609de5..3a4eaf1f3f487 100644 +--- a/arch/mips/boot/dts/ingenic/ci20.dts ++++ b/arch/mips/boot/dts/ingenic/ci20.dts +@@ -525,10 +525,10 @@ + + &tcu { + /* +- * 750 kHz for the system timer and 3 MHz for the clocksource, ++ * 750 kHz for the system timer and clocksource, + * use channel #0 for the system timer, #1 for the clocksource. + */ + assigned-clocks = <&tcu TCU_CLK_TIMER0>, <&tcu TCU_CLK_TIMER1>, + <&tcu TCU_CLK_OST>; +- assigned-clock-rates = <750000>, <3000000>, <3000000>; ++ assigned-clock-rates = <750000>, <750000>, <3000000>; + }; +diff --git a/arch/mips/include/asm/cpu-features.h b/arch/mips/include/asm/cpu-features.h +index 336e02b3b3cea..3d71081afc55f 100644 +--- a/arch/mips/include/asm/cpu-features.h ++++ b/arch/mips/include/asm/cpu-features.h +@@ -64,6 +64,8 @@ + ((MIPS_ISA_REV >= (ge)) && (MIPS_ISA_REV < (lt))) + #define __isa_range_or_flag(ge, lt, flag) \ + (__isa_range(ge, lt) || ((MIPS_ISA_REV < (lt)) && __isa(flag))) ++#define __isa_range_and_ase(ge, lt, ase) \ ++ (__isa_range(ge, lt) && __ase(ase)) + + /* + * SMP assumption: Options of CPU 0 are a superset of all processors. +@@ -421,7 +423,7 @@ + #endif + + #ifndef cpu_has_mipsmt +-#define cpu_has_mipsmt __isa_lt_and_ase(6, MIPS_ASE_MIPSMT) ++#define cpu_has_mipsmt __isa_range_and_ase(2, 6, MIPS_ASE_MIPSMT) + #endif + + #ifndef cpu_has_vp +diff --git a/arch/mips/include/asm/hugetlb.h b/arch/mips/include/asm/hugetlb.h +index 10e3be870df78..c2144409c0c40 100644 +--- a/arch/mips/include/asm/hugetlb.h ++++ b/arch/mips/include/asm/hugetlb.h +@@ -46,7 +46,13 @@ static inline pte_t huge_ptep_get_and_clear(struct mm_struct *mm, + static inline void huge_ptep_clear_flush(struct vm_area_struct *vma, + unsigned long addr, pte_t *ptep) + { +- flush_tlb_page(vma, addr & huge_page_mask(hstate_vma(vma))); ++ /* ++ * clear the huge pte entry firstly, so that the other smp threads will ++ * not get old pte entry after finishing flush_tlb_page and before ++ * setting new huge pte entry ++ */ ++ huge_ptep_get_and_clear(vma->vm_mm, addr, ptep); ++ flush_tlb_page(vma, addr); + } + + #define __HAVE_ARCH_HUGE_PTE_NONE +diff --git a/arch/mips/include/asm/mipsregs.h b/arch/mips/include/asm/mipsregs.h +index 9c8099a6ffed1..acdf8c69220b0 100644 +--- a/arch/mips/include/asm/mipsregs.h ++++ b/arch/mips/include/asm/mipsregs.h +@@ -2077,7 +2077,7 @@ _ASM_MACRO_0(tlbginvf, _ASM_INSN_IF_MIPS(0x4200000c) + ({ int __res; \ + __asm__ __volatile__( \ + ".set\tpush\n\t" \ +- ".set\tmips32r2\n\t" \ ++ ".set\tmips32r5\n\t" \ + _ASM_SET_VIRT \ + "mfgc0\t%0, " #source ", %1\n\t" \ + ".set\tpop" \ +@@ -2090,7 +2090,7 @@ _ASM_MACRO_0(tlbginvf, _ASM_INSN_IF_MIPS(0x4200000c) + ({ unsigned long long __res; \ + __asm__ __volatile__( \ + ".set\tpush\n\t" \ +- ".set\tmips64r2\n\t" \ ++ ".set\tmips64r5\n\t" \ + _ASM_SET_VIRT \ + "dmfgc0\t%0, " #source ", %1\n\t" \ + ".set\tpop" \ +@@ -2103,7 +2103,7 @@ _ASM_MACRO_0(tlbginvf, _ASM_INSN_IF_MIPS(0x4200000c) + do { \ + __asm__ __volatile__( \ + ".set\tpush\n\t" \ +- ".set\tmips32r2\n\t" \ ++ ".set\tmips32r5\n\t" \ + _ASM_SET_VIRT \ + "mtgc0\t%z0, " #register ", %1\n\t" \ + ".set\tpop" \ +@@ -2115,7 +2115,7 @@ do { \ + do { \ + __asm__ __volatile__( \ + ".set\tpush\n\t" \ +- ".set\tmips64r2\n\t" \ ++ ".set\tmips64r5\n\t" \ + _ASM_SET_VIRT \ + "dmtgc0\t%z0, " #register ", %1\n\t" \ + ".set\tpop" \ +diff --git a/arch/mips/include/asm/pgalloc.h b/arch/mips/include/asm/pgalloc.h +index 8b18424b31208..d0cf997b4ba84 100644 +--- a/arch/mips/include/asm/pgalloc.h ++++ b/arch/mips/include/asm/pgalloc.h +@@ -59,11 +59,15 @@ do { \ + + static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address) + { +- pmd_t *pmd; ++ pmd_t *pmd = NULL; ++ struct page *pg; + +- pmd = (pmd_t *) __get_free_pages(GFP_KERNEL, PMD_ORDER); +- if (pmd) ++ pg = alloc_pages(GFP_KERNEL | __GFP_ACCOUNT, PMD_ORDER); ++ if (pg) { ++ pgtable_pmd_page_ctor(pg); ++ pmd = (pmd_t *)page_address(pg); + pmd_init((unsigned long)pmd, (unsigned long)invalid_pte_table); ++ } + return pmd; + } + +diff --git a/arch/mips/include/uapi/asm/socket.h b/arch/mips/include/uapi/asm/socket.h +index 2d949969313b6..cdf404a831b25 100644 +--- a/arch/mips/include/uapi/asm/socket.h ++++ b/arch/mips/include/uapi/asm/socket.h +@@ -138,6 +138,8 @@ + #define SO_PREFER_BUSY_POLL 69 + #define SO_BUSY_POLL_BUDGET 70 + ++#define SO_NETNS_COOKIE 71 ++ + #if !defined(__KERNEL__) + + #if __BITS_PER_LONG == 64 +diff --git a/arch/mips/kernel/cpu-probe.c b/arch/mips/kernel/cpu-probe.c +index 0ef240adefb59..630fcb4cb30e7 100644 +--- a/arch/mips/kernel/cpu-probe.c ++++ b/arch/mips/kernel/cpu-probe.c +@@ -1840,6 +1840,11 @@ static inline void cpu_probe_ingenic(struct cpuinfo_mips *c, unsigned int cpu) + */ + case PRID_COMP_INGENIC_D0: + c->isa_level &= ~MIPS_CPU_ISA_M32R2; ++ ++ /* FPU is not properly detected on JZ4760(B). */ ++ if (c->processor_id == 0x2ed0024f) ++ c->options |= MIPS_CPU_FPU; ++ + fallthrough; + + /* +diff --git a/arch/mips/loongson64/numa.c b/arch/mips/loongson64/numa.c +index a8f57bf012854..a791863ed352f 100644 +--- a/arch/mips/loongson64/numa.c ++++ b/arch/mips/loongson64/numa.c +@@ -118,6 +118,9 @@ static void __init node_mem_init(unsigned int node) + if (node_end_pfn(0) >= (0xffffffff >> PAGE_SHIFT)) + memblock_reserve((node_addrspace_offset | 0xfe000000), + 32 << 20); ++ ++ /* Reserve pfn range 0~node[0]->node_start_pfn */ ++ memblock_reserve(0, PAGE_SIZE * start_pfn); + } + } + +diff --git a/arch/parisc/include/uapi/asm/socket.h b/arch/parisc/include/uapi/asm/socket.h +index f60904329bbcc..5b5351cdcb338 100644 +--- a/arch/parisc/include/uapi/asm/socket.h ++++ b/arch/parisc/include/uapi/asm/socket.h +@@ -119,6 +119,8 @@ + #define SO_PREFER_BUSY_POLL 0x4043 + #define SO_BUSY_POLL_BUDGET 0x4044 + ++#define SO_NETNS_COOKIE 0x4045 ++ + #if !defined(__KERNEL__) + + #if __BITS_PER_LONG == 64 +diff --git a/arch/powerpc/include/asm/barrier.h b/arch/powerpc/include/asm/barrier.h +index aecfde829d5da..6274b864f363d 100644 +--- a/arch/powerpc/include/asm/barrier.h ++++ b/arch/powerpc/include/asm/barrier.h +@@ -46,6 +46,8 @@ + # define SMPWMB eieio + #endif + ++/* clang defines this macro for a builtin, which will not work with runtime patching */ ++#undef __lwsync + #define __lwsync() __asm__ __volatile__ (stringify_in_c(LWSYNC) : : :"memory") + #define dma_rmb() __lwsync() + #define dma_wmb() __asm__ __volatile__ (stringify_in_c(SMPWMB) : : :"memory") +diff --git a/arch/powerpc/mm/fault.c b/arch/powerpc/mm/fault.c +index bb368257b55cb..178525cf686a5 100644 +--- a/arch/powerpc/mm/fault.c ++++ b/arch/powerpc/mm/fault.c +@@ -199,9 +199,7 @@ static bool bad_kernel_fault(struct pt_regs *regs, unsigned long error_code, + { + int is_exec = TRAP(regs) == 0x400; + +- /* NX faults set DSISR_PROTFAULT on the 8xx, DSISR_NOEXEC_OR_G on others */ +- if (is_exec && (error_code & (DSISR_NOEXEC_OR_G | DSISR_KEYFAULT | +- DSISR_PROTFAULT))) { ++ if (is_exec) { + pr_crit_ratelimited("kernel tried to execute %s page (%lx) - exploit attempt? (uid: %d)\n", + address >= TASK_SIZE ? "exec-protected" : "user", + address, +diff --git a/arch/powerpc/platforms/powernv/vas-window.c b/arch/powerpc/platforms/powernv/vas-window.c +index 5f5fe63a3d1ce..7ba0840fc3b55 100644 +--- a/arch/powerpc/platforms/powernv/vas-window.c ++++ b/arch/powerpc/platforms/powernv/vas-window.c +@@ -1093,9 +1093,9 @@ struct vas_window *vas_tx_win_open(int vasid, enum vas_cop_type cop, + /* + * Process closes window during exit. In the case of + * multithread application, the child thread can open +- * window and can exit without closing it. Expects parent +- * thread to use and close the window. So do not need +- * to take pid reference for parent thread. ++ * window and can exit without closing it. so takes tgid ++ * reference until window closed to make sure tgid is not ++ * reused. + */ + txwin->tgid = find_get_pid(task_tgid_vnr(current)); + /* +@@ -1339,8 +1339,9 @@ int vas_win_close(struct vas_window *window) + /* if send window, drop reference to matching receive window */ + if (window->tx_win) { + if (window->user_win) { +- /* Drop references to pid and mm */ ++ /* Drop references to pid. tgid and mm */ + put_pid(window->pid); ++ put_pid(window->tgid); + if (window->mm) { + mm_context_remove_vas_window(window->mm); + mmdrop(window->mm); +diff --git a/arch/sparc/include/uapi/asm/socket.h b/arch/sparc/include/uapi/asm/socket.h +index 848a22fbac20e..92675dc380fa2 100644 +--- a/arch/sparc/include/uapi/asm/socket.h ++++ b/arch/sparc/include/uapi/asm/socket.h +@@ -120,6 +120,8 @@ + #define SO_PREFER_BUSY_POLL 0x0048 + #define SO_BUSY_POLL_BUDGET 0x0049 + ++#define SO_NETNS_COOKIE 0x0050 ++ + #if !defined(__KERNEL__) + + +diff --git a/block/blk-rq-qos.c b/block/blk-rq-qos.c +index 656460636ad34..e83af7bc75919 100644 +--- a/block/blk-rq-qos.c ++++ b/block/blk-rq-qos.c +@@ -266,8 +266,8 @@ void rq_qos_wait(struct rq_wait *rqw, void *private_data, + if (!has_sleeper && acquire_inflight_cb(rqw, private_data)) + return; + +- prepare_to_wait_exclusive(&rqw->wait, &data.wq, TASK_UNINTERRUPTIBLE); +- has_sleeper = !wq_has_single_sleeper(&rqw->wait); ++ has_sleeper = !prepare_to_wait_exclusive(&rqw->wait, &data.wq, ++ TASK_UNINTERRUPTIBLE); + do { + /* The memory barrier in set_task_state saves us here. */ + if (data.got_token) +diff --git a/drivers/ata/ahci_sunxi.c b/drivers/ata/ahci_sunxi.c +index cb69b737cb499..56b695136977a 100644 +--- a/drivers/ata/ahci_sunxi.c ++++ b/drivers/ata/ahci_sunxi.c +@@ -200,7 +200,7 @@ static void ahci_sunxi_start_engine(struct ata_port *ap) + } + + static const struct ata_port_info ahci_sunxi_port_info = { +- .flags = AHCI_FLAG_COMMON | ATA_FLAG_NCQ, ++ .flags = AHCI_FLAG_COMMON | ATA_FLAG_NCQ | ATA_FLAG_NO_DIPM, + .pio_mask = ATA_PIO4, + .udma_mask = ATA_UDMA6, + .port_ops = &ahci_platform_ops, +diff --git a/drivers/atm/iphase.c b/drivers/atm/iphase.c +index eef637fd90b32..a59554e5b8b0f 100644 +--- a/drivers/atm/iphase.c ++++ b/drivers/atm/iphase.c +@@ -3279,7 +3279,7 @@ static void __exit ia_module_exit(void) + { + pci_unregister_driver(&ia_driver); + +- del_timer(&ia_timer); ++ del_timer_sync(&ia_timer); + } + + module_init(ia_module_init); +diff --git a/drivers/atm/nicstar.c b/drivers/atm/nicstar.c +index 5c7e4df159b91..bc5a6ab6fa4b4 100644 +--- a/drivers/atm/nicstar.c ++++ b/drivers/atm/nicstar.c +@@ -299,7 +299,7 @@ static void __exit nicstar_cleanup(void) + { + XPRINTK("nicstar: nicstar_cleanup() called.\n"); + +- del_timer(&ns_timer); ++ del_timer_sync(&ns_timer); + + pci_unregister_driver(&nicstar_driver); + +@@ -527,6 +527,15 @@ static int ns_init_card(int i, struct pci_dev *pcidev) + /* Set the VPI/VCI MSb mask to zero so we can receive OAM cells */ + writel(0x00000000, card->membase + VPM); + ++ card->intcnt = 0; ++ if (request_irq ++ (pcidev->irq, &ns_irq_handler, IRQF_SHARED, "nicstar", card) != 0) { ++ pr_err("nicstar%d: can't allocate IRQ %d.\n", i, pcidev->irq); ++ error = 9; ++ ns_init_card_error(card, error); ++ return error; ++ } ++ + /* Initialize TSQ */ + card->tsq.org = dma_alloc_coherent(&card->pcidev->dev, + NS_TSQSIZE + NS_TSQ_ALIGNMENT, +@@ -753,15 +762,6 @@ static int ns_init_card(int i, struct pci_dev *pcidev) + + card->efbie = 1; + +- card->intcnt = 0; +- if (request_irq +- (pcidev->irq, &ns_irq_handler, IRQF_SHARED, "nicstar", card) != 0) { +- printk("nicstar%d: can't allocate IRQ %d.\n", i, pcidev->irq); +- error = 9; +- ns_init_card_error(card, error); +- return error; +- } +- + /* Register device */ + card->atmdev = atm_dev_register("nicstar", &card->pcidev->dev, &atm_ops, + -1, NULL); +@@ -839,10 +839,12 @@ static void ns_init_card_error(ns_dev *card, int error) + dev_kfree_skb_any(hb); + } + if (error >= 12) { +- kfree(card->rsq.org); ++ dma_free_coherent(&card->pcidev->dev, NS_RSQSIZE + NS_RSQ_ALIGNMENT, ++ card->rsq.org, card->rsq.dma); + } + if (error >= 11) { +- kfree(card->tsq.org); ++ dma_free_coherent(&card->pcidev->dev, NS_TSQSIZE + NS_TSQ_ALIGNMENT, ++ card->tsq.org, card->tsq.dma); + } + if (error >= 10) { + free_irq(card->pcidev->irq, card); +diff --git a/drivers/bluetooth/btusb.c b/drivers/bluetooth/btusb.c +index ddc7b86725cd7..a97e5c476adf1 100644 +--- a/drivers/bluetooth/btusb.c ++++ b/drivers/bluetooth/btusb.c +@@ -270,6 +270,8 @@ static const struct usb_device_id blacklist_table[] = { + BTUSB_WIDEBAND_SPEECH }, + { USB_DEVICE(0x0cf3, 0xe360), .driver_info = BTUSB_QCA_ROME | + BTUSB_WIDEBAND_SPEECH }, ++ { USB_DEVICE(0x0cf3, 0xe500), .driver_info = BTUSB_QCA_ROME | ++ BTUSB_WIDEBAND_SPEECH }, + { USB_DEVICE(0x0489, 0xe092), .driver_info = BTUSB_QCA_ROME | + BTUSB_WIDEBAND_SPEECH }, + { USB_DEVICE(0x0489, 0xe09f), .driver_info = BTUSB_QCA_ROME | +@@ -1747,6 +1749,13 @@ static void btusb_work(struct work_struct *work) + * which work with WBS at all. + */ + new_alts = btusb_find_altsetting(data, 6) ? 6 : 1; ++ /* Because mSBC frames do not need to be aligned to the ++ * SCO packet boundary. If support the Alt 3, use the ++ * Alt 3 for HCI payload >= 60 Bytes let air packet ++ * data satisfy 60 bytes. ++ */ ++ if (new_alts == 1 && btusb_find_altsetting(data, 3)) ++ new_alts = 3; + } + + if (btusb_switch_alt_setting(hdev, new_alts) < 0) +@@ -3377,11 +3386,6 @@ static int btusb_mtk_hci_wmt_sync(struct hci_dev *hdev, + struct btmtk_wmt_hdr *hdr; + int err; + +- /* Submit control IN URB on demand to process the WMT event */ +- err = btusb_mtk_submit_wmt_recv_urb(hdev); +- if (err < 0) +- return err; +- + /* Send the WMT command and wait until the WMT event returns */ + hlen = sizeof(*hdr) + wmt_params->dlen; + if (hlen > 255) +@@ -3407,6 +3411,11 @@ static int btusb_mtk_hci_wmt_sync(struct hci_dev *hdev, + goto err_free_wc; + } + ++ /* Submit control IN URB on demand to process the WMT event */ ++ err = btusb_mtk_submit_wmt_recv_urb(hdev); ++ if (err < 0) ++ return err; ++ + /* The vendor specific WMT commands are all answered by a vendor + * specific event and will have the Command Status or Command + * Complete as with usual HCI command flow control. +@@ -4127,6 +4136,11 @@ static int btusb_setup_qca_download_fw(struct hci_dev *hdev, + sent += size; + count -= size; + ++ /* ep2 need time to switch from function acl to function dfu, ++ * so we add 20ms delay here. ++ */ ++ msleep(20); ++ + while (count) { + size = min_t(size_t, count, QCA_DFU_PACKET_LEN); + +@@ -4219,9 +4233,15 @@ static int btusb_setup_qca_load_nvm(struct hci_dev *hdev, + int err; + + if (((ver->flag >> 8) & 0xff) == QCA_FLAG_MULTI_NVM) { +- snprintf(fwname, sizeof(fwname), "qca/nvm_usb_%08x_%04x.bin", +- le32_to_cpu(ver->rom_version), +- le16_to_cpu(ver->board_id)); ++ /* if boardid equal 0, use default nvm without surfix */ ++ if (le16_to_cpu(ver->board_id) == 0x0) { ++ snprintf(fwname, sizeof(fwname), "qca/nvm_usb_%08x.bin", ++ le32_to_cpu(ver->rom_version)); ++ } else { ++ snprintf(fwname, sizeof(fwname), "qca/nvm_usb_%08x_%04x.bin", ++ le32_to_cpu(ver->rom_version), ++ le16_to_cpu(ver->board_id)); ++ } + } else { + snprintf(fwname, sizeof(fwname), "qca/nvm_usb_%08x.bin", + le32_to_cpu(ver->rom_version)); +diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c +index 32c334e34d553..e4ff3b50de7f3 100644 +--- a/drivers/char/ipmi/ipmi_watchdog.c ++++ b/drivers/char/ipmi/ipmi_watchdog.c +@@ -371,16 +371,18 @@ static int __ipmi_set_timeout(struct ipmi_smi_msg *smi_msg, + data[0] = 0; + WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS); + +- if ((ipmi_version_major > 1) +- || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5))) { +- /* This is an IPMI 1.5-only feature. */ +- data[0] |= WDOG_DONT_STOP_ON_SET; +- } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) { +- /* +- * In ipmi 1.0, setting the timer stops the watchdog, we +- * need to start it back up again. +- */ +- hbnow = 1; ++ if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) { ++ if ((ipmi_version_major > 1) || ++ ((ipmi_version_major == 1) && (ipmi_version_minor >= 5))) { ++ /* This is an IPMI 1.5-only feature. */ ++ data[0] |= WDOG_DONT_STOP_ON_SET; ++ } else { ++ /* ++ * In ipmi 1.0, setting the timer stops the watchdog, we ++ * need to start it back up again. ++ */ ++ hbnow = 1; ++ } + } + + data[1] = 0; +diff --git a/drivers/clk/renesas/r8a77995-cpg-mssr.c b/drivers/clk/renesas/r8a77995-cpg-mssr.c +index 9cfd00cf4e69a..81c0bc1e78af8 100644 +--- a/drivers/clk/renesas/r8a77995-cpg-mssr.c ++++ b/drivers/clk/renesas/r8a77995-cpg-mssr.c +@@ -75,6 +75,7 @@ static const struct cpg_core_clk r8a77995_core_clks[] __initconst = { + DEF_RATE(".oco", CLK_OCO, 8 * 1000 * 1000), + + /* Core Clock Outputs */ ++ DEF_FIXED("za2", R8A77995_CLK_ZA2, CLK_PLL0D3, 2, 1), + DEF_FIXED("z2", R8A77995_CLK_Z2, CLK_PLL0D3, 1, 1), + DEF_FIXED("ztr", R8A77995_CLK_ZTR, CLK_PLL1, 6, 1), + DEF_FIXED("zt", R8A77995_CLK_ZT, CLK_PLL1, 4, 1), +diff --git a/drivers/clk/renesas/rcar-usb2-clock-sel.c b/drivers/clk/renesas/rcar-usb2-clock-sel.c +index 3abafd78f7c8a..8b4e43659023a 100644 +--- a/drivers/clk/renesas/rcar-usb2-clock-sel.c ++++ b/drivers/clk/renesas/rcar-usb2-clock-sel.c +@@ -128,10 +128,8 @@ static int rcar_usb2_clock_sel_resume(struct device *dev) + static int rcar_usb2_clock_sel_remove(struct platform_device *pdev) + { + struct device *dev = &pdev->dev; +- struct usb2_clock_sel_priv *priv = platform_get_drvdata(pdev); + + of_clk_del_provider(dev->of_node); +- clk_hw_unregister(&priv->hw); + pm_runtime_put(dev); + pm_runtime_disable(dev); + +@@ -164,9 +162,6 @@ static int rcar_usb2_clock_sel_probe(struct platform_device *pdev) + if (IS_ERR(priv->rsts)) + return PTR_ERR(priv->rsts); + +- pm_runtime_enable(dev); +- pm_runtime_get_sync(dev); +- + clk = devm_clk_get(dev, "usb_extal"); + if (!IS_ERR(clk) && !clk_prepare_enable(clk)) { + priv->extal = !!clk_get_rate(clk); +@@ -183,6 +178,8 @@ static int rcar_usb2_clock_sel_probe(struct platform_device *pdev) + return -ENOENT; + } + ++ pm_runtime_enable(dev); ++ pm_runtime_get_sync(dev); + platform_set_drvdata(pdev, priv); + dev_set_drvdata(dev, priv); + +@@ -193,11 +190,20 @@ static int rcar_usb2_clock_sel_probe(struct platform_device *pdev) + init.num_parents = 0; + priv->hw.init = &init; + +- clk = clk_register(NULL, &priv->hw); +- if (IS_ERR(clk)) +- return PTR_ERR(clk); ++ ret = devm_clk_hw_register(NULL, &priv->hw); ++ if (ret) ++ goto pm_put; ++ ++ ret = of_clk_add_hw_provider(np, of_clk_hw_simple_get, &priv->hw); ++ if (ret) ++ goto pm_put; ++ ++ return 0; + +- return of_clk_add_hw_provider(np, of_clk_hw_simple_get, &priv->hw); ++pm_put: ++ pm_runtime_put(dev); ++ pm_runtime_disable(dev); ++ return ret; + } + + static const struct dev_pm_ops rcar_usb2_clock_sel_pm_ops = { +diff --git a/drivers/clk/tegra/clk-periph-gate.c b/drivers/clk/tegra/clk-periph-gate.c +index 4b31beefc9fc2..dc3f92678407b 100644 +--- a/drivers/clk/tegra/clk-periph-gate.c ++++ b/drivers/clk/tegra/clk-periph-gate.c +@@ -48,18 +48,9 @@ static int clk_periph_is_enabled(struct clk_hw *hw) + return state; + } + +-static int clk_periph_enable(struct clk_hw *hw) ++static void clk_periph_enable_locked(struct clk_hw *hw) + { + struct tegra_clk_periph_gate *gate = to_clk_periph_gate(hw); +- unsigned long flags = 0; +- +- spin_lock_irqsave(&periph_ref_lock, flags); +- +- gate->enable_refcnt[gate->clk_num]++; +- if (gate->enable_refcnt[gate->clk_num] > 1) { +- spin_unlock_irqrestore(&periph_ref_lock, flags); +- return 0; +- } + + write_enb_set(periph_clk_to_bit(gate), gate); + udelay(2); +@@ -78,6 +69,32 @@ static int clk_periph_enable(struct clk_hw *hw) + udelay(1); + writel_relaxed(0, gate->clk_base + LVL2_CLK_GATE_OVRE); + } ++} ++ ++static void clk_periph_disable_locked(struct clk_hw *hw) ++{ ++ struct tegra_clk_periph_gate *gate = to_clk_periph_gate(hw); ++ ++ /* ++ * If peripheral is in the APB bus then read the APB bus to ++ * flush the write operation in apb bus. This will avoid the ++ * peripheral access after disabling clock ++ */ ++ if (gate->flags & TEGRA_PERIPH_ON_APB) ++ tegra_read_chipid(); ++ ++ write_enb_clr(periph_clk_to_bit(gate), gate); ++} ++ ++static int clk_periph_enable(struct clk_hw *hw) ++{ ++ struct tegra_clk_periph_gate *gate = to_clk_periph_gate(hw); ++ unsigned long flags = 0; ++ ++ spin_lock_irqsave(&periph_ref_lock, flags); ++ ++ if (!gate->enable_refcnt[gate->clk_num]++) ++ clk_periph_enable_locked(hw); + + spin_unlock_irqrestore(&periph_ref_lock, flags); + +@@ -91,21 +108,28 @@ static void clk_periph_disable(struct clk_hw *hw) + + spin_lock_irqsave(&periph_ref_lock, flags); + +- gate->enable_refcnt[gate->clk_num]--; +- if (gate->enable_refcnt[gate->clk_num] > 0) { +- spin_unlock_irqrestore(&periph_ref_lock, flags); +- return; +- } ++ WARN_ON(!gate->enable_refcnt[gate->clk_num]); ++ ++ if (--gate->enable_refcnt[gate->clk_num] == 0) ++ clk_periph_disable_locked(hw); ++ ++ spin_unlock_irqrestore(&periph_ref_lock, flags); ++} ++ ++static void clk_periph_disable_unused(struct clk_hw *hw) ++{ ++ struct tegra_clk_periph_gate *gate = to_clk_periph_gate(hw); ++ unsigned long flags = 0; ++ ++ spin_lock_irqsave(&periph_ref_lock, flags); + + /* +- * If peripheral is in the APB bus then read the APB bus to +- * flush the write operation in apb bus. This will avoid the +- * peripheral access after disabling clock ++ * Some clocks are duplicated and some of them are marked as critical, ++ * like fuse and fuse_burn for example, thus the enable_refcnt will ++ * be non-zero here if the "unused" duplicate is disabled by CCF. + */ +- if (gate->flags & TEGRA_PERIPH_ON_APB) +- tegra_read_chipid(); +- +- write_enb_clr(periph_clk_to_bit(gate), gate); ++ if (!gate->enable_refcnt[gate->clk_num]) ++ clk_periph_disable_locked(hw); + + spin_unlock_irqrestore(&periph_ref_lock, flags); + } +@@ -114,6 +138,7 @@ const struct clk_ops tegra_clk_periph_gate_ops = { + .is_enabled = clk_periph_is_enabled, + .enable = clk_periph_enable, + .disable = clk_periph_disable, ++ .disable_unused = clk_periph_disable_unused, + }; + + struct clk *tegra_clk_register_periph_gate(const char *name, +@@ -148,9 +173,6 @@ struct clk *tegra_clk_register_periph_gate(const char *name, + gate->enable_refcnt = enable_refcnt; + gate->regs = pregs; + +- if (read_enb(gate) & periph_clk_to_bit(gate)) +- enable_refcnt[clk_num]++; +- + /* Data in .init is copied by clk_register(), so stack variable OK */ + gate->hw.init = &init; + +diff --git a/drivers/clk/tegra/clk-periph.c b/drivers/clk/tegra/clk-periph.c +index 67620c7ecd9ee..79ca3aa072b70 100644 +--- a/drivers/clk/tegra/clk-periph.c ++++ b/drivers/clk/tegra/clk-periph.c +@@ -100,6 +100,15 @@ static void clk_periph_disable(struct clk_hw *hw) + gate_ops->disable(gate_hw); + } + ++static void clk_periph_disable_unused(struct clk_hw *hw) ++{ ++ struct tegra_clk_periph *periph = to_clk_periph(hw); ++ const struct clk_ops *gate_ops = periph->gate_ops; ++ struct clk_hw *gate_hw = &periph->gate.hw; ++ ++ gate_ops->disable_unused(gate_hw); ++} ++ + static void clk_periph_restore_context(struct clk_hw *hw) + { + struct tegra_clk_periph *periph = to_clk_periph(hw); +@@ -126,6 +135,7 @@ const struct clk_ops tegra_clk_periph_ops = { + .is_enabled = clk_periph_is_enabled, + .enable = clk_periph_enable, + .disable = clk_periph_disable, ++ .disable_unused = clk_periph_disable_unused, + .restore_context = clk_periph_restore_context, + }; + +@@ -135,6 +145,7 @@ static const struct clk_ops tegra_clk_periph_nodiv_ops = { + .is_enabled = clk_periph_is_enabled, + .enable = clk_periph_enable, + .disable = clk_periph_disable, ++ .disable_unused = clk_periph_disable_unused, + .restore_context = clk_periph_restore_context, + }; + +diff --git a/drivers/clk/tegra/clk-pll.c b/drivers/clk/tegra/clk-pll.c +index c5cc0a2dac6ff..d709ecb7d8d7e 100644 +--- a/drivers/clk/tegra/clk-pll.c ++++ b/drivers/clk/tegra/clk-pll.c +@@ -1131,7 +1131,8 @@ static int clk_pllu_enable(struct clk_hw *hw) + if (pll->lock) + spin_lock_irqsave(pll->lock, flags); + +- _clk_pll_enable(hw); ++ if (!clk_pll_is_enabled(hw)) ++ _clk_pll_enable(hw); + + ret = clk_pll_wait_for_lock(pll); + if (ret < 0) +@@ -1748,15 +1749,13 @@ static int clk_pllu_tegra114_enable(struct clk_hw *hw) + return -EINVAL; + } + +- if (clk_pll_is_enabled(hw)) +- return 0; +- + input_rate = clk_hw_get_rate(__clk_get_hw(osc)); + + if (pll->lock) + spin_lock_irqsave(pll->lock, flags); + +- _clk_pll_enable(hw); ++ if (!clk_pll_is_enabled(hw)) ++ _clk_pll_enable(hw); + + ret = clk_pll_wait_for_lock(pll); + if (ret < 0) +diff --git a/drivers/clk/tegra/clk-tegra124-emc.c b/drivers/clk/tegra/clk-tegra124-emc.c +index bdf6f4a516176..74c1d894cca86 100644 +--- a/drivers/clk/tegra/clk-tegra124-emc.c ++++ b/drivers/clk/tegra/clk-tegra124-emc.c +@@ -249,8 +249,10 @@ static int emc_set_timing(struct tegra_clk_emc *tegra, + div = timing->parent_rate / (timing->rate / 2) - 2; + + err = tegra->prepare_timing_change(emc, timing->rate); +- if (err) ++ if (err) { ++ clk_disable_unprepare(timing->parent); + return err; ++ } + + spin_lock_irqsave(tegra->lock, flags); + +diff --git a/drivers/clocksource/arm_arch_timer.c b/drivers/clocksource/arm_arch_timer.c +index d0177824c518b..f4881764bf8f4 100644 +--- a/drivers/clocksource/arm_arch_timer.c ++++ b/drivers/clocksource/arm_arch_timer.c +@@ -352,7 +352,7 @@ static u64 notrace arm64_858921_read_cntvct_el0(void) + do { \ + _val = read_sysreg(reg); \ + _retries--; \ +- } while (((_val + 1) & GENMASK(9, 0)) <= 1 && _retries); \ ++ } while (((_val + 1) & GENMASK(8, 0)) <= 1 && _retries); \ + \ + WARN_ON_ONCE(!_retries); \ + _val; \ +diff --git a/drivers/extcon/extcon-intel-mrfld.c b/drivers/extcon/extcon-intel-mrfld.c +index f47016fb28a84..cd1a5f230077c 100644 +--- a/drivers/extcon/extcon-intel-mrfld.c ++++ b/drivers/extcon/extcon-intel-mrfld.c +@@ -197,6 +197,7 @@ static int mrfld_extcon_probe(struct platform_device *pdev) + struct intel_soc_pmic *pmic = dev_get_drvdata(dev->parent); + struct regmap *regmap = pmic->regmap; + struct mrfld_extcon_data *data; ++ unsigned int status; + unsigned int id; + int irq, ret; + +@@ -244,6 +245,14 @@ static int mrfld_extcon_probe(struct platform_device *pdev) + /* Get initial state */ + mrfld_extcon_role_detect(data); + ++ /* ++ * Cached status value is used for cable detection, see comments ++ * in mrfld_extcon_cable_detect(), we need to sync cached value ++ * with a real state of the hardware. ++ */ ++ regmap_read(regmap, BCOVE_SCHGRIRQ1, &status); ++ data->status = status; ++ + mrfld_extcon_clear(data, BCOVE_MIRQLVL1, BCOVE_LVL1_CHGR); + mrfld_extcon_clear(data, BCOVE_MCHGRIRQ1, BCOVE_CHGRIRQ_ALL); + +diff --git a/drivers/firmware/qemu_fw_cfg.c b/drivers/firmware/qemu_fw_cfg.c +index 0078260fbabea..172c751a4f6c2 100644 +--- a/drivers/firmware/qemu_fw_cfg.c ++++ b/drivers/firmware/qemu_fw_cfg.c +@@ -299,15 +299,13 @@ static int fw_cfg_do_platform_probe(struct platform_device *pdev) + return 0; + } + +-static ssize_t fw_cfg_showrev(struct kobject *k, struct attribute *a, char *buf) ++static ssize_t fw_cfg_showrev(struct kobject *k, struct kobj_attribute *a, ++ char *buf) + { + return sprintf(buf, "%u\n", fw_cfg_rev); + } + +-static const struct { +- struct attribute attr; +- ssize_t (*show)(struct kobject *k, struct attribute *a, char *buf); +-} fw_cfg_rev_attr = { ++static const struct kobj_attribute fw_cfg_rev_attr = { + .attr = { .name = "rev", .mode = S_IRUSR }, + .show = fw_cfg_showrev, + }; +diff --git a/drivers/fpga/stratix10-soc.c b/drivers/fpga/stratix10-soc.c +index 657a70c5fc996..9e34bbbce26e2 100644 +--- a/drivers/fpga/stratix10-soc.c ++++ b/drivers/fpga/stratix10-soc.c +@@ -454,6 +454,7 @@ static int s10_remove(struct platform_device *pdev) + struct s10_priv *priv = mgr->priv; + + fpga_mgr_unregister(mgr); ++ fpga_mgr_free(mgr); + stratix10_svc_free_channel(priv->chan); + + return 0; +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +index ac0a432a9bf79..3c3f05d1f4daf 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +@@ -49,12 +49,6 @@ static struct { + spinlock_t mem_limit_lock; + } kfd_mem_limit; + +-/* Struct used for amdgpu_amdkfd_bo_validate */ +-struct amdgpu_vm_parser { +- uint32_t domain; +- bool wait; +-}; +- + static const char * const domain_bit_to_string[] = { + "CPU", + "GTT", +@@ -337,11 +331,9 @@ validate_fail: + return ret; + } + +-static int amdgpu_amdkfd_validate(void *param, struct amdgpu_bo *bo) ++static int amdgpu_amdkfd_validate_vm_bo(void *_unused, struct amdgpu_bo *bo) + { +- struct amdgpu_vm_parser *p = param; +- +- return amdgpu_amdkfd_bo_validate(bo, p->domain, p->wait); ++ return amdgpu_amdkfd_bo_validate(bo, bo->allowed_domains, false); + } + + /* vm_validate_pt_pd_bos - Validate page table and directory BOs +@@ -355,20 +347,15 @@ static int vm_validate_pt_pd_bos(struct amdgpu_vm *vm) + { + struct amdgpu_bo *pd = vm->root.base.bo; + struct amdgpu_device *adev = amdgpu_ttm_adev(pd->tbo.bdev); +- struct amdgpu_vm_parser param; + int ret; + +- param.domain = AMDGPU_GEM_DOMAIN_VRAM; +- param.wait = false; +- +- ret = amdgpu_vm_validate_pt_bos(adev, vm, amdgpu_amdkfd_validate, +- ¶m); ++ ret = amdgpu_vm_validate_pt_bos(adev, vm, amdgpu_amdkfd_validate_vm_bo, NULL); + if (ret) { + pr_err("failed to validate PT BOs\n"); + return ret; + } + +- ret = amdgpu_amdkfd_validate(¶m, pd); ++ ret = amdgpu_amdkfd_validate_vm_bo(NULL, pd); + if (ret) { + pr_err("failed to validate PD\n"); + return ret; +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +index 85d90e857693a..1b69aa74056db 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +@@ -2818,7 +2818,7 @@ static int amdgpu_device_ip_reinit_early_sriov(struct amdgpu_device *adev) + AMD_IP_BLOCK_TYPE_IH, + }; + +- for (i = 0; i < ARRAY_SIZE(ip_order); i++) { ++ for (i = 0; i < adev->num_ip_blocks; i++) { + int j; + struct amdgpu_ip_block *block; + +@@ -3141,8 +3141,8 @@ static int amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev) + int ret = 0; + + /* +- * By default timeout for non compute jobs is 10000. +- * And there is no timeout enforced on compute jobs. ++ * By default timeout for non compute jobs is 10000 ++ * and 60000 for compute jobs. + * In SR-IOV or passthrough mode, timeout for compute + * jobs are 60000 by default. + */ +@@ -3151,10 +3151,8 @@ static int amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev) + if (amdgpu_sriov_vf(adev)) + adev->compute_timeout = amdgpu_sriov_is_pp_one_vf(adev) ? + msecs_to_jiffies(60000) : msecs_to_jiffies(10000); +- else if (amdgpu_passthrough(adev)) +- adev->compute_timeout = msecs_to_jiffies(60000); + else +- adev->compute_timeout = MAX_SCHEDULE_TIMEOUT; ++ adev->compute_timeout = msecs_to_jiffies(60000); + + if (strnlen(input, AMDGPU_MAX_TIMEOUT_PARAM_LENGTH)) { + while ((timeout_setting = strsep(&input, ",")) && +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +index e92e7dea71da1..41ebc9d21e5c6 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +@@ -272,9 +272,9 @@ module_param_named(msi, amdgpu_msi, int, 0444); + * for SDMA and Video. + * + * By default(with no lockup_timeout settings), the timeout for all non-compute(GFX, SDMA and Video) +- * jobs is 10000. And there is no timeout enforced on compute jobs. ++ * jobs is 10000. The timeout for compute is 60000. + */ +-MODULE_PARM_DESC(lockup_timeout, "GPU lockup timeout in ms (default: for bare metal 10000 for non-compute jobs and infinity timeout for compute jobs; " ++MODULE_PARM_DESC(lockup_timeout, "GPU lockup timeout in ms (default: for bare metal 10000 for non-compute jobs and 60000 for compute jobs; " + "for passthrough or sriov, 10000 for all jobs." + " 0: keep default value. negative: infinity timeout), " + "format: for bare metal [Non-Compute] or [GFX,Compute,SDMA,Video]; " +@@ -1123,6 +1123,7 @@ static const struct pci_device_id pciidlist[] = { + {0x1002, 0x73E0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_DIMGREY_CAVEFISH}, + {0x1002, 0x73E1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_DIMGREY_CAVEFISH}, + {0x1002, 0x73E2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_DIMGREY_CAVEFISH}, ++ {0x1002, 0x73E3, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_DIMGREY_CAVEFISH}, + {0x1002, 0x73FF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_DIMGREY_CAVEFISH}, + + {0, 0, 0} +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ib.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ib.c +index 97c11aa47ad0b..7892958d5f599 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ib.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ib.c +@@ -131,7 +131,7 @@ int amdgpu_ib_schedule(struct amdgpu_ring *ring, unsigned num_ibs, + struct amdgpu_device *adev = ring->adev; + struct amdgpu_ib *ib = &ibs[0]; + struct dma_fence *tmp = NULL; +- bool skip_preamble, need_ctx_switch; ++ bool need_ctx_switch; + unsigned patch_offset = ~0; + struct amdgpu_vm *vm; + uint64_t fence_ctx; +@@ -228,7 +228,6 @@ int amdgpu_ib_schedule(struct amdgpu_ring *ring, unsigned num_ibs, + if (need_ctx_switch) + status |= AMDGPU_HAVE_CTX_SWITCH; + +- skip_preamble = ring->current_ctx == fence_ctx; + if (job && ring->funcs->emit_cntxcntl) { + status |= job->preamble_status; + status |= job->preemption_status; +@@ -246,14 +245,6 @@ int amdgpu_ib_schedule(struct amdgpu_ring *ring, unsigned num_ibs, + for (i = 0; i < num_ibs; ++i) { + ib = &ibs[i]; + +- /* drop preamble IBs if we don't have a context switch */ +- if ((ib->flags & AMDGPU_IB_FLAG_PREAMBLE) && +- skip_preamble && +- !(status & AMDGPU_PREAMBLE_IB_PRESENT_FIRST) && +- !amdgpu_mcbp && +- !amdgpu_sriov_vf(adev)) /* for SRIOV preemption, Preamble CE ib must be inserted anyway */ +- continue; +- + if (job && ring->funcs->emit_frame_cntl) { + if (secure != !!(ib->flags & AMDGPU_IB_FLAGS_SECURE)) { + amdgpu_ring_emit_frame_cntl(ring, false, secure); +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_nbio.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_nbio.h +index 7c11bce4514bd..1ad7191994ac5 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_nbio.h ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_nbio.h +@@ -89,6 +89,8 @@ struct amdgpu_nbio_funcs { + void (*enable_aspm)(struct amdgpu_device *adev, + bool enable); + void (*program_aspm)(struct amdgpu_device *adev); ++ void (*apply_lc_spc_mode_wa)(struct amdgpu_device *adev); ++ void (*apply_l1_link_width_reconfig_wa)(struct amdgpu_device *adev); + }; + + struct amdgpu_nbio { +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_umc.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_umc.h +index 1838144936580..bda4438c39256 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_umc.h ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_umc.h +@@ -21,6 +21,11 @@ + #ifndef __AMDGPU_UMC_H__ + #define __AMDGPU_UMC_H__ + ++/* ++ * (addr / 256) * 4096, the higher 26 bits in ErrorAddr ++ * is the index of 4KB block ++ */ ++#define ADDR_OF_4KB_BLOCK(addr) (((addr) & ~0xffULL) << 4) + /* + * (addr / 256) * 8192, the higher 26 bits in ErrorAddr + * is the index of 8KB block +diff --git a/drivers/gpu/drm/amd/amdgpu/nbio_v2_3.c b/drivers/gpu/drm/amd/amdgpu/nbio_v2_3.c +index 05ddec7ba7e2e..754b11dea6f04 100644 +--- a/drivers/gpu/drm/amd/amdgpu/nbio_v2_3.c ++++ b/drivers/gpu/drm/amd/amdgpu/nbio_v2_3.c +@@ -51,6 +51,8 @@ + #define mmBIF_MMSCH1_DOORBELL_RANGE 0x01d8 + #define mmBIF_MMSCH1_DOORBELL_RANGE_BASE_IDX 2 + ++#define smnPCIE_LC_LINK_WIDTH_CNTL 0x11140288 ++ + static void nbio_v2_3_remap_hdp_registers(struct amdgpu_device *adev) + { + WREG32_SOC15(NBIO, 0, mmREMAP_HDP_MEM_FLUSH_CNTL, +@@ -463,6 +465,43 @@ static void nbio_v2_3_program_aspm(struct amdgpu_device *adev) + WREG32_PCIE(smnPCIE_LC_CNTL3, data); + } + ++static void nbio_v2_3_apply_lc_spc_mode_wa(struct amdgpu_device *adev) ++{ ++ uint32_t reg_data = 0; ++ uint32_t link_width = 0; ++ ++ if (!((adev->asic_type >= CHIP_NAVI10) && ++ (adev->asic_type <= CHIP_NAVI12))) ++ return; ++ ++ reg_data = RREG32_PCIE(smnPCIE_LC_LINK_WIDTH_CNTL); ++ link_width = (reg_data & PCIE_LC_LINK_WIDTH_CNTL__LC_LINK_WIDTH_RD_MASK) ++ >> PCIE_LC_LINK_WIDTH_CNTL__LC_LINK_WIDTH_RD__SHIFT; ++ ++ /* ++ * Program PCIE_LC_CNTL6.LC_SPC_MODE_8GT to 0x2 (4 symbols per clock data) ++ * if link_width is 0x3 (x4) ++ */ ++ if (0x3 == link_width) { ++ reg_data = RREG32_PCIE(smnPCIE_LC_CNTL6); ++ reg_data &= ~PCIE_LC_CNTL6__LC_SPC_MODE_8GT_MASK; ++ reg_data |= (0x2 << PCIE_LC_CNTL6__LC_SPC_MODE_8GT__SHIFT); ++ WREG32_PCIE(smnPCIE_LC_CNTL6, reg_data); ++ } ++} ++ ++static void nbio_v2_3_apply_l1_link_width_reconfig_wa(struct amdgpu_device *adev) ++{ ++ uint32_t reg_data = 0; ++ ++ if (adev->asic_type != CHIP_NAVI10) ++ return; ++ ++ reg_data = RREG32_PCIE(smnPCIE_LC_LINK_WIDTH_CNTL); ++ reg_data |= PCIE_LC_LINK_WIDTH_CNTL__LC_L1_RECONFIG_EN_MASK; ++ WREG32_PCIE(smnPCIE_LC_LINK_WIDTH_CNTL, reg_data); ++} ++ + const struct amdgpu_nbio_funcs nbio_v2_3_funcs = { + .get_hdp_flush_req_offset = nbio_v2_3_get_hdp_flush_req_offset, + .get_hdp_flush_done_offset = nbio_v2_3_get_hdp_flush_done_offset, +@@ -484,4 +523,6 @@ const struct amdgpu_nbio_funcs nbio_v2_3_funcs = { + .remap_hdp_registers = nbio_v2_3_remap_hdp_registers, + .enable_aspm = nbio_v2_3_enable_aspm, + .program_aspm = nbio_v2_3_program_aspm, ++ .apply_lc_spc_mode_wa = nbio_v2_3_apply_lc_spc_mode_wa, ++ .apply_l1_link_width_reconfig_wa = nbio_v2_3_apply_l1_link_width_reconfig_wa, + }; +diff --git a/drivers/gpu/drm/amd/amdgpu/nv.c b/drivers/gpu/drm/amd/amdgpu/nv.c +index c625c5d8ed890..3677788d47711 100644 +--- a/drivers/gpu/drm/amd/amdgpu/nv.c ++++ b/drivers/gpu/drm/amd/amdgpu/nv.c +@@ -1073,6 +1073,12 @@ static int nv_common_hw_init(void *handle) + { + struct amdgpu_device *adev = (struct amdgpu_device *)handle; + ++ if (adev->nbio.funcs->apply_lc_spc_mode_wa) ++ adev->nbio.funcs->apply_lc_spc_mode_wa(adev); ++ ++ if (adev->nbio.funcs->apply_l1_link_width_reconfig_wa) ++ adev->nbio.funcs->apply_l1_link_width_reconfig_wa(adev); ++ + /* enable pcie gen2/3 link */ + nv_pcie_gen3_enable(adev); + /* enable aspm */ +diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v4_0.c b/drivers/gpu/drm/amd/amdgpu/sdma_v4_0.c +index c8c22c1d1e655..03a6f57c425ab 100644 +--- a/drivers/gpu/drm/amd/amdgpu/sdma_v4_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/sdma_v4_0.c +@@ -142,7 +142,7 @@ static const struct soc15_reg_golden golden_settings_sdma_4_1[] = { + SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC0_RB_WPTR_POLL_CNTL, 0xfffffff7, 0x00403000), + SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC1_IB_CNTL, 0x800f0111, 0x00000100), + SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC1_RB_WPTR_POLL_CNTL, 0xfffffff7, 0x00403000), +- SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_PAGE, 0x000003ff, 0x000003c0), ++ SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_PAGE, 0x000003ff, 0x000003e0), + SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_WATERMK, 0xfc000000, 0x00000000) + }; + +@@ -268,7 +268,7 @@ static const struct soc15_reg_golden golden_settings_sdma_4_3[] = { + SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_POWER_CNTL, 0x003fff07, 0x40000051), + SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC0_RB_WPTR_POLL_CNTL, 0xfffffff7, 0x00403000), + SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC1_RB_WPTR_POLL_CNTL, 0xfffffff7, 0x00403000), +- SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_PAGE, 0x000003ff, 0x000003c0), ++ SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_PAGE, 0x000003ff, 0x000003e0), + SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_WATERMK, 0xfc000000, 0x03fbe1fe) + }; + +diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v5_2.c b/drivers/gpu/drm/amd/amdgpu/sdma_v5_2.c +index 32c6aa03d2673..f884d43d4ff00 100644 +--- a/drivers/gpu/drm/amd/amdgpu/sdma_v5_2.c ++++ b/drivers/gpu/drm/amd/amdgpu/sdma_v5_2.c +@@ -145,9 +145,6 @@ static int sdma_v5_2_init_microcode(struct amdgpu_device *adev) + struct amdgpu_firmware_info *info = NULL; + const struct common_firmware_header *header = NULL; + +- if (amdgpu_sriov_vf(adev) && (adev->asic_type == CHIP_SIENNA_CICHLID)) +- return 0; +- + DRM_DEBUG("\n"); + + switch (adev->asic_type) { +@@ -182,6 +179,9 @@ static int sdma_v5_2_init_microcode(struct amdgpu_device *adev) + (void *)&adev->sdma.instance[0], + sizeof(struct amdgpu_sdma_instance)); + ++ if (amdgpu_sriov_vf(adev) && (adev->asic_type == CHIP_SIENNA_CICHLID)) ++ return 0; ++ + DRM_DEBUG("psp_load == '%s'\n", + adev->firmware.load_type == AMDGPU_FW_LOAD_PSP ? "true" : "false"); + +diff --git a/drivers/gpu/drm/amd/amdgpu/umc_v8_7.c b/drivers/gpu/drm/amd/amdgpu/umc_v8_7.c +index a064c097690c7..66fd797a6f0ec 100644 +--- a/drivers/gpu/drm/amd/amdgpu/umc_v8_7.c ++++ b/drivers/gpu/drm/amd/amdgpu/umc_v8_7.c +@@ -233,7 +233,7 @@ static void umc_v8_7_query_error_address(struct amdgpu_device *adev, + err_addr &= ~((0x1ULL << lsb) - 1); + + /* translate umc channel address to soc pa, 3 parts are included */ +- retired_page = ADDR_OF_8KB_BLOCK(err_addr) | ++ retired_page = ADDR_OF_4KB_BLOCK(err_addr) | + ADDR_OF_256B_BLOCK(channel_index) | + OFFSET_IN_256B_BLOCK(err_addr); + +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +index a4266c4bca135..b2e55917c308e 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +@@ -486,9 +486,6 @@ static int destroy_queue_nocpsch_locked(struct device_queue_manager *dqm, + if (retval == -ETIME) + qpd->reset_wavefronts = true; + +- +- mqd_mgr->free_mqd(mqd_mgr, q->mqd, q->mqd_mem_obj); +- + list_del(&q->list); + if (list_empty(&qpd->queues_list)) { + if (qpd->reset_wavefronts) { +@@ -523,6 +520,8 @@ static int destroy_queue_nocpsch(struct device_queue_manager *dqm, + int retval; + uint64_t sdma_val = 0; + struct kfd_process_device *pdd = qpd_to_pdd(qpd); ++ struct mqd_manager *mqd_mgr = ++ dqm->mqd_mgrs[get_mqd_type_from_queue_type(q->properties.type)]; + + /* Get the SDMA queue stats */ + if ((q->properties.type == KFD_QUEUE_TYPE_SDMA) || +@@ -540,6 +539,8 @@ static int destroy_queue_nocpsch(struct device_queue_manager *dqm, + pdd->sdma_past_activity_counter += sdma_val; + dqm_unlock(dqm); + ++ mqd_mgr->free_mqd(mqd_mgr, q->mqd, q->mqd_mem_obj); ++ + return retval; + } + +@@ -1632,7 +1633,7 @@ static int set_trap_handler(struct device_queue_manager *dqm, + static int process_termination_nocpsch(struct device_queue_manager *dqm, + struct qcm_process_device *qpd) + { +- struct queue *q, *next; ++ struct queue *q; + struct device_process_node *cur, *next_dpn; + int retval = 0; + bool found = false; +@@ -1640,12 +1641,19 @@ static int process_termination_nocpsch(struct device_queue_manager *dqm, + dqm_lock(dqm); + + /* Clear all user mode queues */ +- list_for_each_entry_safe(q, next, &qpd->queues_list, list) { ++ while (!list_empty(&qpd->queues_list)) { ++ struct mqd_manager *mqd_mgr; + int ret; + ++ q = list_first_entry(&qpd->queues_list, struct queue, list); ++ mqd_mgr = dqm->mqd_mgrs[get_mqd_type_from_queue_type( ++ q->properties.type)]; + ret = destroy_queue_nocpsch_locked(dqm, qpd, q); + if (ret) + retval = ret; ++ dqm_unlock(dqm); ++ mqd_mgr->free_mqd(mqd_mgr, q->mqd, q->mqd_mem_obj); ++ dqm_lock(dqm); + } + + /* Unregister process */ +@@ -1677,36 +1685,34 @@ static int get_wave_state(struct device_queue_manager *dqm, + u32 *save_area_used_size) + { + struct mqd_manager *mqd_mgr; +- int r; + + dqm_lock(dqm); + +- if (q->properties.type != KFD_QUEUE_TYPE_COMPUTE || +- q->properties.is_active || !q->device->cwsr_enabled) { +- r = -EINVAL; +- goto dqm_unlock; +- } +- + mqd_mgr = dqm->mqd_mgrs[KFD_MQD_TYPE_CP]; + +- if (!mqd_mgr->get_wave_state) { +- r = -EINVAL; +- goto dqm_unlock; ++ if (q->properties.type != KFD_QUEUE_TYPE_COMPUTE || ++ q->properties.is_active || !q->device->cwsr_enabled || ++ !mqd_mgr->get_wave_state) { ++ dqm_unlock(dqm); ++ return -EINVAL; + } + +- r = mqd_mgr->get_wave_state(mqd_mgr, q->mqd, ctl_stack, +- ctl_stack_used_size, save_area_used_size); +- +-dqm_unlock: + dqm_unlock(dqm); +- return r; ++ ++ /* ++ * get_wave_state is outside the dqm lock to prevent circular locking ++ * and the queue should be protected against destruction by the process ++ * lock. ++ */ ++ return mqd_mgr->get_wave_state(mqd_mgr, q->mqd, ctl_stack, ++ ctl_stack_used_size, save_area_used_size); + } + + static int process_termination_cpsch(struct device_queue_manager *dqm, + struct qcm_process_device *qpd) + { + int retval; +- struct queue *q, *next; ++ struct queue *q; + struct kernel_queue *kq, *kq_next; + struct mqd_manager *mqd_mgr; + struct device_process_node *cur, *next_dpn; +@@ -1763,24 +1769,26 @@ static int process_termination_cpsch(struct device_queue_manager *dqm, + qpd->reset_wavefronts = false; + } + +- dqm_unlock(dqm); +- +- /* Outside the DQM lock because under the DQM lock we can't do +- * reclaim or take other locks that others hold while reclaiming. +- */ +- if (found) +- kfd_dec_compute_active(dqm->dev); +- + /* Lastly, free mqd resources. + * Do free_mqd() after dqm_unlock to avoid circular locking. + */ +- list_for_each_entry_safe(q, next, &qpd->queues_list, list) { ++ while (!list_empty(&qpd->queues_list)) { ++ q = list_first_entry(&qpd->queues_list, struct queue, list); + mqd_mgr = dqm->mqd_mgrs[get_mqd_type_from_queue_type( + q->properties.type)]; + list_del(&q->list); + qpd->queue_count--; ++ dqm_unlock(dqm); + mqd_mgr->free_mqd(mqd_mgr, q->mqd, q->mqd_mem_obj); ++ dqm_lock(dqm); + } ++ dqm_unlock(dqm); ++ ++ /* Outside the DQM lock because under the DQM lock we can't do ++ * reclaim or take other locks that others hold while reclaiming. ++ */ ++ if (found) ++ kfd_dec_compute_active(dqm->dev); + + return retval; + } +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +index 0858e0c7b7a1d..9cac833bc9d6a 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -3867,6 +3867,23 @@ static int fill_dc_scaling_info(const struct drm_plane_state *state, + scaling_info->src_rect.x = state->src_x >> 16; + scaling_info->src_rect.y = state->src_y >> 16; + ++ /* ++ * For reasons we don't (yet) fully understand a non-zero ++ * src_y coordinate into an NV12 buffer can cause a ++ * system hang. To avoid hangs (and maybe be overly cautious) ++ * let's reject both non-zero src_x and src_y. ++ * ++ * We currently know of only one use-case to reproduce a ++ * scenario with non-zero src_x and src_y for NV12, which ++ * is to gesture the YouTube Android app into full screen ++ * on ChromeOS. ++ */ ++ if (state->fb && ++ state->fb->format->format == DRM_FORMAT_NV12 && ++ (scaling_info->src_rect.x != 0 || ++ scaling_info->src_rect.y != 0)) ++ return -EINVAL; ++ + /* + * For reasons we don't (yet) fully understand a non-zero + * src_y coordinate into an NV12 buffer can cause a +@@ -8939,7 +8956,8 @@ skip_modeset: + BUG_ON(dm_new_crtc_state->stream == NULL); + + /* Scaling or underscan settings */ +- if (is_scaling_state_different(dm_old_conn_state, dm_new_conn_state)) ++ if (is_scaling_state_different(dm_old_conn_state, dm_new_conn_state) || ++ drm_atomic_crtc_needs_modeset(new_crtc_state)) + update_stream_scaling_settings( + &new_crtc_state->mode, dm_new_conn_state, dm_new_crtc_state->stream); + +@@ -9498,6 +9516,10 @@ static int amdgpu_dm_atomic_check(struct drm_device *dev, + dm_old_crtc_state->dsc_force_changed == false) + continue; + ++ ret = amdgpu_dm_verify_lut_sizes(new_crtc_state); ++ if (ret) ++ goto fail; ++ + if (!new_crtc_state->enable) + continue; + +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.h b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.h +index 52cc817052802..250adc92dfd0f 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.h ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.h +@@ -529,6 +529,7 @@ void amdgpu_dm_trigger_timing_sync(struct drm_device *dev); + #define MAX_COLOR_LEGACY_LUT_ENTRIES 256 + + void amdgpu_dm_init_color_mod(void); ++int amdgpu_dm_verify_lut_sizes(const struct drm_crtc_state *crtc_state); + int amdgpu_dm_update_crtc_color_mgmt(struct dm_crtc_state *crtc); + int amdgpu_dm_update_plane_color_mgmt(struct dm_crtc_state *crtc, + struct dc_plane_state *dc_plane_state); +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c +index 157fe4efbb599..a022e5bb30a5c 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c +@@ -284,6 +284,37 @@ static int __set_input_tf(struct dc_transfer_func *func, + return res ? 0 : -ENOMEM; + } + ++/** ++ * Verifies that the Degamma and Gamma LUTs attached to the |crtc_state| are of ++ * the expected size. ++ * Returns 0 on success. ++ */ ++int amdgpu_dm_verify_lut_sizes(const struct drm_crtc_state *crtc_state) ++{ ++ const struct drm_color_lut *lut = NULL; ++ uint32_t size = 0; ++ ++ lut = __extract_blob_lut(crtc_state->degamma_lut, &size); ++ if (lut && size != MAX_COLOR_LUT_ENTRIES) { ++ DRM_DEBUG_DRIVER( ++ "Invalid Degamma LUT size. Should be %u but got %u.\n", ++ MAX_COLOR_LUT_ENTRIES, size); ++ return -EINVAL; ++ } ++ ++ lut = __extract_blob_lut(crtc_state->gamma_lut, &size); ++ if (lut && size != MAX_COLOR_LUT_ENTRIES && ++ size != MAX_COLOR_LEGACY_LUT_ENTRIES) { ++ DRM_DEBUG_DRIVER( ++ "Invalid Gamma LUT size. Should be %u (or %u for legacy) but got %u.\n", ++ MAX_COLOR_LUT_ENTRIES, MAX_COLOR_LEGACY_LUT_ENTRIES, ++ size); ++ return -EINVAL; ++ } ++ ++ return 0; ++} ++ + /** + * amdgpu_dm_update_crtc_color_mgmt: Maps DRM color management to DC stream. + * @crtc: amdgpu_dm crtc state +@@ -317,14 +348,12 @@ int amdgpu_dm_update_crtc_color_mgmt(struct dm_crtc_state *crtc) + bool is_legacy; + int r; + +- degamma_lut = __extract_blob_lut(crtc->base.degamma_lut, °amma_size); +- if (degamma_lut && degamma_size != MAX_COLOR_LUT_ENTRIES) +- return -EINVAL; ++ r = amdgpu_dm_verify_lut_sizes(&crtc->base); ++ if (r) ++ return r; + ++ degamma_lut = __extract_blob_lut(crtc->base.degamma_lut, °amma_size); + regamma_lut = __extract_blob_lut(crtc->base.gamma_lut, ®amma_size); +- if (regamma_lut && regamma_size != MAX_COLOR_LUT_ENTRIES && +- regamma_size != MAX_COLOR_LEGACY_LUT_ENTRIES) +- return -EINVAL; + + has_degamma = + degamma_lut && !__is_lut_linear(degamma_lut, degamma_size); +diff --git a/drivers/gpu/drm/amd/display/dc/bios/bios_parser2.c b/drivers/gpu/drm/amd/display/dc/bios/bios_parser2.c +index 9f9fda3118d1f..500bcd0ecf4d2 100644 +--- a/drivers/gpu/drm/amd/display/dc/bios/bios_parser2.c ++++ b/drivers/gpu/drm/amd/display/dc/bios/bios_parser2.c +@@ -1944,7 +1944,7 @@ static enum bp_result get_integrated_info_v2_1( + info_v2_1->edp1_info.edp_pwr_down_bloff_to_vary_bloff; + info->edp1_info.edp_panel_bpc = + info_v2_1->edp1_info.edp_panel_bpc; +- info->edp1_info.edp_bootup_bl_level = ++ info->edp1_info.edp_bootup_bl_level = info_v2_1->edp1_info.edp_bootup_bl_level; + + info->edp2_info.edp_backlight_pwm_hz = + le16_to_cpu(info_v2_1->edp2_info.edp_backlight_pwm_hz); +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_link_dp.c b/drivers/gpu/drm/amd/display/dc/core/dc_link_dp.c +index b85f67341a9a0..c957d7d055ba3 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc_link_dp.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc_link_dp.c +@@ -1726,6 +1726,8 @@ static void set_dp_mst_mode(struct dc_link *link, bool mst_enable) + link->type = dc_connection_single; + link->local_sink = link->remote_sinks[0]; + link->local_sink->sink_signal = SIGNAL_TYPE_DISPLAY_PORT; ++ dc_sink_retain(link->local_sink); ++ dm_helpers_dp_mst_stop_top_mgr(link->ctx, link); + } else if (mst_enable == true && + link->type == dc_connection_single && + link->remote_sinks[0] != NULL) { +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_resource.c b/drivers/gpu/drm/amd/display/dc/core/dc_resource.c +index 0c26c2ade782c..749189eb20bab 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc_resource.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc_resource.c +@@ -652,124 +652,23 @@ static void calculate_split_count_and_index(struct pipe_ctx *pipe_ctx, int *spli + } + } + +-static void calculate_viewport(struct pipe_ctx *pipe_ctx) ++/* ++ * This is a preliminary vp size calculation to allow us to check taps support. ++ * The result is completely overridden afterwards. ++ */ ++static void calculate_viewport_size(struct pipe_ctx *pipe_ctx) + { +- const struct dc_plane_state *plane_state = pipe_ctx->plane_state; +- const struct dc_stream_state *stream = pipe_ctx->stream; + struct scaler_data *data = &pipe_ctx->plane_res.scl_data; +- struct rect surf_src = plane_state->src_rect; +- struct rect clip, dest; +- int vpc_div = (data->format == PIXEL_FORMAT_420BPP8 +- || data->format == PIXEL_FORMAT_420BPP10) ? 2 : 1; +- int split_count = 0; +- int split_idx = 0; +- bool orthogonal_rotation, flip_y_start, flip_x_start; +- +- calculate_split_count_and_index(pipe_ctx, &split_count, &split_idx); + +- if (stream->view_format == VIEW_3D_FORMAT_SIDE_BY_SIDE || +- stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM) { +- split_count = 0; +- split_idx = 0; +- } +- +- /* The actual clip is an intersection between stream +- * source and surface clip +- */ +- dest = plane_state->dst_rect; +- clip.x = stream->src.x > plane_state->clip_rect.x ? +- stream->src.x : plane_state->clip_rect.x; +- +- clip.width = stream->src.x + stream->src.width < +- plane_state->clip_rect.x + plane_state->clip_rect.width ? +- stream->src.x + stream->src.width - clip.x : +- plane_state->clip_rect.x + plane_state->clip_rect.width - clip.x ; +- +- clip.y = stream->src.y > plane_state->clip_rect.y ? +- stream->src.y : plane_state->clip_rect.y; +- +- clip.height = stream->src.y + stream->src.height < +- plane_state->clip_rect.y + plane_state->clip_rect.height ? +- stream->src.y + stream->src.height - clip.y : +- plane_state->clip_rect.y + plane_state->clip_rect.height - clip.y ; +- +- /* +- * Need to calculate how scan origin is shifted in vp space +- * to correctly rotate clip and dst +- */ +- get_vp_scan_direction( +- plane_state->rotation, +- plane_state->horizontal_mirror, +- &orthogonal_rotation, +- &flip_y_start, +- &flip_x_start); +- +- if (orthogonal_rotation) { +- swap(clip.x, clip.y); +- swap(clip.width, clip.height); +- swap(dest.x, dest.y); +- swap(dest.width, dest.height); +- } +- if (flip_x_start) { +- clip.x = dest.x + dest.width - clip.x - clip.width; +- dest.x = 0; +- } +- if (flip_y_start) { +- clip.y = dest.y + dest.height - clip.y - clip.height; +- dest.y = 0; +- } +- +- /* offset = surf_src.ofs + (clip.ofs - surface->dst_rect.ofs) * scl_ratio +- * num_pixels = clip.num_pix * scl_ratio +- */ +- data->viewport.x = surf_src.x + (clip.x - dest.x) * surf_src.width / dest.width; +- data->viewport.width = clip.width * surf_src.width / dest.width; +- +- data->viewport.y = surf_src.y + (clip.y - dest.y) * surf_src.height / dest.height; +- data->viewport.height = clip.height * surf_src.height / dest.height; +- +- /* Handle split */ +- if (split_count) { +- /* extra pixels in the division remainder need to go to pipes after +- * the extra pixel index minus one(epimo) defined here as: +- */ +- int epimo = 0; +- +- if (orthogonal_rotation) { +- if (flip_y_start) +- split_idx = split_count - split_idx; +- +- epimo = split_count - data->viewport.height % (split_count + 1); +- +- data->viewport.y += (data->viewport.height / (split_count + 1)) * split_idx; +- if (split_idx > epimo) +- data->viewport.y += split_idx - epimo - 1; +- data->viewport.height = data->viewport.height / (split_count + 1) + (split_idx > epimo ? 1 : 0); +- } else { +- if (flip_x_start) +- split_idx = split_count - split_idx; +- +- epimo = split_count - data->viewport.width % (split_count + 1); +- +- data->viewport.x += (data->viewport.width / (split_count + 1)) * split_idx; +- if (split_idx > epimo) +- data->viewport.x += split_idx - epimo - 1; +- data->viewport.width = data->viewport.width / (split_count + 1) + (split_idx > epimo ? 1 : 0); +- } ++ data->viewport.width = dc_fixpt_ceil(dc_fixpt_mul_int(data->ratios.horz, data->recout.width)); ++ data->viewport.height = dc_fixpt_ceil(dc_fixpt_mul_int(data->ratios.vert, data->recout.height)); ++ data->viewport_c.width = dc_fixpt_ceil(dc_fixpt_mul_int(data->ratios.horz_c, data->recout.width)); ++ data->viewport_c.height = dc_fixpt_ceil(dc_fixpt_mul_int(data->ratios.vert_c, data->recout.height)); ++ if (pipe_ctx->plane_state->rotation == ROTATION_ANGLE_90 || ++ pipe_ctx->plane_state->rotation == ROTATION_ANGLE_270) { ++ swap(data->viewport.width, data->viewport.height); ++ swap(data->viewport_c.width, data->viewport_c.height); + } +- +- /* Round down, compensate in init */ +- data->viewport_c.x = data->viewport.x / vpc_div; +- data->viewport_c.y = data->viewport.y / vpc_div; +- data->inits.h_c = (data->viewport.x % vpc_div) != 0 ? dc_fixpt_half : dc_fixpt_zero; +- data->inits.v_c = (data->viewport.y % vpc_div) != 0 ? dc_fixpt_half : dc_fixpt_zero; +- +- /* Round up, assume original video size always even dimensions */ +- data->viewport_c.width = (data->viewport.width + vpc_div - 1) / vpc_div; +- data->viewport_c.height = (data->viewport.height + vpc_div - 1) / vpc_div; +- +- data->viewport_unadjusted = data->viewport; +- data->viewport_c_unadjusted = data->viewport_c; + } + + static void calculate_recout(struct pipe_ctx *pipe_ctx) +@@ -778,26 +677,21 @@ static void calculate_recout(struct pipe_ctx *pipe_ctx) + const struct dc_stream_state *stream = pipe_ctx->stream; + struct scaler_data *data = &pipe_ctx->plane_res.scl_data; + struct rect surf_clip = plane_state->clip_rect; +- bool pri_split_tb = pipe_ctx->bottom_pipe && +- pipe_ctx->bottom_pipe->plane_state == pipe_ctx->plane_state && +- stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM; +- bool sec_split_tb = pipe_ctx->top_pipe && +- pipe_ctx->top_pipe->plane_state == pipe_ctx->plane_state && +- stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM; +- int split_count = 0; +- int split_idx = 0; ++ bool split_tb = stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM; ++ int split_count, split_idx; + + calculate_split_count_and_index(pipe_ctx, &split_count, &split_idx); ++ if (stream->view_format == VIEW_3D_FORMAT_SIDE_BY_SIDE) ++ split_idx = 0; + + /* + * Only the leftmost ODM pipe should be offset by a nonzero distance + */ +- if (!pipe_ctx->prev_odm_pipe) { ++ if (!pipe_ctx->prev_odm_pipe || split_idx == split_count) { + data->recout.x = stream->dst.x; + if (stream->src.x < surf_clip.x) + data->recout.x += (surf_clip.x - stream->src.x) * stream->dst.width + / stream->src.width; +- + } else + data->recout.x = 0; + +@@ -818,26 +712,36 @@ static void calculate_recout(struct pipe_ctx *pipe_ctx) + if (data->recout.height + data->recout.y > stream->dst.y + stream->dst.height) + data->recout.height = stream->dst.y + stream->dst.height - data->recout.y; + +- /* Handle h & v split, handle rotation using viewport */ +- if (sec_split_tb) { +- data->recout.y += data->recout.height / 2; +- /* Floor primary pipe, ceil 2ndary pipe */ +- data->recout.height = (data->recout.height + 1) / 2; +- } else if (pri_split_tb) ++ /* Handle h & v split */ ++ if (split_tb) { ++ ASSERT(data->recout.height % 2 == 0); + data->recout.height /= 2; +- else if (split_count) { +- /* extra pixels in the division remainder need to go to pipes after +- * the extra pixel index minus one(epimo) defined here as: +- */ +- int epimo = split_count - data->recout.width % (split_count + 1); +- +- /*no recout offset due to odm */ ++ } else if (split_count) { + if (!pipe_ctx->next_odm_pipe && !pipe_ctx->prev_odm_pipe) { ++ /* extra pixels in the division remainder need to go to pipes after ++ * the extra pixel index minus one(epimo) defined here as: ++ */ ++ int epimo = split_count - data->recout.width % (split_count + 1); ++ + data->recout.x += (data->recout.width / (split_count + 1)) * split_idx; + if (split_idx > epimo) + data->recout.x += split_idx - epimo - 1; ++ ASSERT(stream->view_format != VIEW_3D_FORMAT_SIDE_BY_SIDE || data->recout.width % 2 == 0); ++ data->recout.width = data->recout.width / (split_count + 1) + (split_idx > epimo ? 1 : 0); ++ } else { ++ /* odm */ ++ if (split_idx == split_count) { ++ /* rightmost pipe is the remainder recout */ ++ data->recout.width -= data->h_active * split_count - data->recout.x; ++ ++ /* ODM combine cases with MPO we can get negative widths */ ++ if (data->recout.width < 0) ++ data->recout.width = 0; ++ ++ data->recout.x = 0; ++ } else ++ data->recout.width = data->h_active - data->recout.x; + } +- data->recout.width = data->recout.width / (split_count + 1) + (split_idx > epimo ? 1 : 0); + } + } + +@@ -891,9 +795,15 @@ static void calculate_scaling_ratios(struct pipe_ctx *pipe_ctx) + pipe_ctx->plane_res.scl_data.ratios.vert_c, 19); + } + +-static inline void adjust_vp_and_init_for_seamless_clip( ++ ++/* ++ * We completely calculate vp offset, size and inits here based entirely on scaling ++ * ratios and recout for pixel perfect pipe combine. ++ */ ++static void calculate_init_and_vp( + bool flip_scan_dir, +- int recout_skip, ++ int recout_offset_within_recout_full, ++ int recout_size, + int src_size, + int taps, + struct fixed31_32 ratio, +@@ -901,91 +811,87 @@ static inline void adjust_vp_and_init_for_seamless_clip( + int *vp_offset, + int *vp_size) + { +- if (!flip_scan_dir) { +- /* Adjust for viewport end clip-off */ +- if ((*vp_offset + *vp_size) < src_size) { +- int vp_clip = src_size - *vp_size - *vp_offset; +- int int_part = dc_fixpt_floor(dc_fixpt_sub(*init, ratio)); +- +- int_part = int_part > 0 ? int_part : 0; +- *vp_size += int_part < vp_clip ? int_part : vp_clip; +- } +- +- /* Adjust for non-0 viewport offset */ +- if (*vp_offset) { +- int int_part; +- +- *init = dc_fixpt_add(*init, dc_fixpt_mul_int(ratio, recout_skip)); +- int_part = dc_fixpt_floor(*init) - *vp_offset; +- if (int_part < taps) { +- int int_adj = *vp_offset >= (taps - int_part) ? +- (taps - int_part) : *vp_offset; +- *vp_offset -= int_adj; +- *vp_size += int_adj; +- int_part += int_adj; +- } else if (int_part > taps) { +- *vp_offset += int_part - taps; +- *vp_size -= int_part - taps; +- int_part = taps; +- } +- init->value &= 0xffffffff; +- *init = dc_fixpt_add_int(*init, int_part); +- } +- } else { +- /* Adjust for non-0 viewport offset */ +- if (*vp_offset) { +- int int_part = dc_fixpt_floor(dc_fixpt_sub(*init, ratio)); +- +- int_part = int_part > 0 ? int_part : 0; +- *vp_size += int_part < *vp_offset ? int_part : *vp_offset; +- *vp_offset -= int_part < *vp_offset ? int_part : *vp_offset; +- } ++ struct fixed31_32 temp; ++ int int_part; + +- /* Adjust for viewport end clip-off */ +- if ((*vp_offset + *vp_size) < src_size) { +- int int_part; +- int end_offset = src_size - *vp_offset - *vp_size; +- +- /* +- * this is init if vp had no offset, keep in mind this is from the +- * right side of vp due to scan direction +- */ +- *init = dc_fixpt_add(*init, dc_fixpt_mul_int(ratio, recout_skip)); +- /* +- * this is the difference between first pixel of viewport available to read +- * and init position, takning into account scan direction +- */ +- int_part = dc_fixpt_floor(*init) - end_offset; +- if (int_part < taps) { +- int int_adj = end_offset >= (taps - int_part) ? +- (taps - int_part) : end_offset; +- *vp_size += int_adj; +- int_part += int_adj; +- } else if (int_part > taps) { +- *vp_size += int_part - taps; +- int_part = taps; +- } +- init->value &= 0xffffffff; +- *init = dc_fixpt_add_int(*init, int_part); +- } ++ /* ++ * First of the taps starts sampling pixel number corresponding to recout ++ * pixel 1. Next recout pixel samples int part of and so on. ++ * All following calculations are based on this logic. ++ * ++ * Init calculated according to formula: ++ * init = (scaling_ratio + number_of_taps + 1) / 2 ++ * init_bot = init + scaling_ratio ++ * to get pixel perfect combine add the fraction from calculating vp offset ++ */ ++ temp = dc_fixpt_mul_int(ratio, recout_offset_within_recout_full); ++ *vp_offset = dc_fixpt_floor(temp); ++ temp.value &= 0xffffffff; ++ *init = dc_fixpt_truncate(dc_fixpt_add(dc_fixpt_div_int( ++ dc_fixpt_add_int(ratio, taps + 1), 2), temp), 19); ++ /* ++ * If viewport has non 0 offset and there are more taps than covered by init then ++ * we should decrease the offset and increase init so we are never sampling ++ * outside of viewport. ++ */ ++ int_part = dc_fixpt_floor(*init); ++ if (int_part < taps) { ++ int_part = taps - int_part; ++ if (int_part > *vp_offset) ++ int_part = *vp_offset; ++ *vp_offset -= int_part; ++ *init = dc_fixpt_add_int(*init, int_part); + } ++ /* ++ * If taps are sampling outside of viewport at end of recout and there are more pixels ++ * available in the surface we should increase the viewport size, regardless set vp to ++ * only what is used. ++ */ ++ temp = dc_fixpt_add(*init, dc_fixpt_mul_int(ratio, recout_size - 1)); ++ *vp_size = dc_fixpt_floor(temp); ++ if (*vp_size + *vp_offset > src_size) ++ *vp_size = src_size - *vp_offset; ++ ++ /* We did all the math assuming we are scanning same direction as display does, ++ * however mirror/rotation changes how vp scans vs how it is offset. If scan direction ++ * is flipped we simply need to calculate offset from the other side of plane. ++ * Note that outside of viewport all scaling hardware works in recout space. ++ */ ++ if (flip_scan_dir) ++ *vp_offset = src_size - *vp_offset - *vp_size; + } + +-static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx) ++static void calculate_inits_and_viewports(struct pipe_ctx *pipe_ctx) + { + const struct dc_plane_state *plane_state = pipe_ctx->plane_state; + const struct dc_stream_state *stream = pipe_ctx->stream; +- struct pipe_ctx *odm_pipe = pipe_ctx; + struct scaler_data *data = &pipe_ctx->plane_res.scl_data; +- struct rect src = pipe_ctx->plane_state->src_rect; +- int recout_skip_h, recout_skip_v, surf_size_h, surf_size_v; ++ struct rect src = plane_state->src_rect; + int vpc_div = (data->format == PIXEL_FORMAT_420BPP8 +- || data->format == PIXEL_FORMAT_420BPP10) ? 2 : 1; ++ || data->format == PIXEL_FORMAT_420BPP10) ? 2 : 1; ++ int split_count, split_idx, ro_lb, ro_tb, recout_full_x, recout_full_y; + bool orthogonal_rotation, flip_vert_scan_dir, flip_horz_scan_dir; +- int odm_idx = 0; + ++ calculate_split_count_and_index(pipe_ctx, &split_count, &split_idx); + /* +- * Need to calculate the scan direction for viewport to make adjustments ++ * recout full is what the recout would have been if we didnt clip ++ * the source plane at all. We only care about left(ro_lb) and top(ro_tb) ++ * offsets of recout within recout full because those are the directions ++ * we scan from and therefore the only ones that affect inits. ++ */ ++ recout_full_x = stream->dst.x + (plane_state->dst_rect.x - stream->src.x) ++ * stream->dst.width / stream->src.width; ++ recout_full_y = stream->dst.y + (plane_state->dst_rect.y - stream->src.y) ++ * stream->dst.height / stream->src.height; ++ if (pipe_ctx->prev_odm_pipe && split_idx) ++ ro_lb = data->h_active * split_idx - recout_full_x; ++ else ++ ro_lb = data->recout.x - recout_full_x; ++ ro_tb = data->recout.y - recout_full_y; ++ ASSERT(ro_lb >= 0 && ro_tb >= 0); ++ ++ /* ++ * Work in recout rotation since that requires less transformations + */ + get_vp_scan_direction( + plane_state->rotation, +@@ -994,145 +900,62 @@ static void calculate_inits_and_adj_vp(struct pipe_ctx *pipe_ctx) + &flip_vert_scan_dir, + &flip_horz_scan_dir); + +- /* Calculate src rect rotation adjusted to recout space */ +- surf_size_h = src.x + src.width; +- surf_size_v = src.y + src.height; +- if (flip_horz_scan_dir) +- src.x = 0; +- if (flip_vert_scan_dir) +- src.y = 0; + if (orthogonal_rotation) { +- swap(src.x, src.y); + swap(src.width, src.height); ++ swap(flip_vert_scan_dir, flip_horz_scan_dir); + } + +- /*modified recout_skip_h calculation due to odm having no recout offset*/ +- while (odm_pipe->prev_odm_pipe) { +- odm_idx++; +- odm_pipe = odm_pipe->prev_odm_pipe; +- } +- /*odm_pipe is the leftmost pipe in the ODM group*/ +- recout_skip_h = odm_idx * data->recout.width; +- +- /* Recout matching initial vp offset = recout_offset - (stream dst offset + +- * ((surf dst offset - stream src offset) * 1/ stream scaling ratio) +- * - (surf surf_src offset * 1/ full scl ratio)) +- */ +- recout_skip_h += odm_pipe->plane_res.scl_data.recout.x +- - (stream->dst.x + (plane_state->dst_rect.x - stream->src.x) +- * stream->dst.width / stream->src.width - +- src.x * plane_state->dst_rect.width / src.width +- * stream->dst.width / stream->src.width); +- +- +- recout_skip_v = data->recout.y - (stream->dst.y + (plane_state->dst_rect.y - stream->src.y) +- * stream->dst.height / stream->src.height - +- src.y * plane_state->dst_rect.height / src.height +- * stream->dst.height / stream->src.height); +- if (orthogonal_rotation) +- swap(recout_skip_h, recout_skip_v); +- /* +- * Init calculated according to formula: +- * init = (scaling_ratio + number_of_taps + 1) / 2 +- * init_bot = init + scaling_ratio +- * init_c = init + truncated_vp_c_offset(from calculate viewport) +- */ +- data->inits.h = dc_fixpt_truncate(dc_fixpt_div_int( +- dc_fixpt_add_int(data->ratios.horz, data->taps.h_taps + 1), 2), 19); +- +- data->inits.h_c = dc_fixpt_truncate(dc_fixpt_add(data->inits.h_c, dc_fixpt_div_int( +- dc_fixpt_add_int(data->ratios.horz_c, data->taps.h_taps_c + 1), 2)), 19); +- +- data->inits.v = dc_fixpt_truncate(dc_fixpt_div_int( +- dc_fixpt_add_int(data->ratios.vert, data->taps.v_taps + 1), 2), 19); +- +- data->inits.v_c = dc_fixpt_truncate(dc_fixpt_add(data->inits.v_c, dc_fixpt_div_int( +- dc_fixpt_add_int(data->ratios.vert_c, data->taps.v_taps_c + 1), 2)), 19); +- +- /* +- * Taps, inits and scaling ratios are in recout space need to rotate +- * to viewport rotation before adjustment +- */ +- adjust_vp_and_init_for_seamless_clip( ++ calculate_init_and_vp( + flip_horz_scan_dir, +- recout_skip_h, +- surf_size_h, +- orthogonal_rotation ? data->taps.v_taps : data->taps.h_taps, +- orthogonal_rotation ? data->ratios.vert : data->ratios.horz, +- orthogonal_rotation ? &data->inits.v : &data->inits.h, ++ ro_lb, ++ data->recout.width, ++ src.width, ++ data->taps.h_taps, ++ data->ratios.horz, ++ &data->inits.h, + &data->viewport.x, + &data->viewport.width); +- adjust_vp_and_init_for_seamless_clip( ++ calculate_init_and_vp( + flip_horz_scan_dir, +- recout_skip_h, +- surf_size_h / vpc_div, +- orthogonal_rotation ? data->taps.v_taps_c : data->taps.h_taps_c, +- orthogonal_rotation ? data->ratios.vert_c : data->ratios.horz_c, +- orthogonal_rotation ? &data->inits.v_c : &data->inits.h_c, ++ ro_lb, ++ data->recout.width, ++ src.width / vpc_div, ++ data->taps.h_taps_c, ++ data->ratios.horz_c, ++ &data->inits.h_c, + &data->viewport_c.x, + &data->viewport_c.width); +- adjust_vp_and_init_for_seamless_clip( ++ calculate_init_and_vp( + flip_vert_scan_dir, +- recout_skip_v, +- surf_size_v, +- orthogonal_rotation ? data->taps.h_taps : data->taps.v_taps, +- orthogonal_rotation ? data->ratios.horz : data->ratios.vert, +- orthogonal_rotation ? &data->inits.h : &data->inits.v, ++ ro_tb, ++ data->recout.height, ++ src.height, ++ data->taps.v_taps, ++ data->ratios.vert, ++ &data->inits.v, + &data->viewport.y, + &data->viewport.height); +- adjust_vp_and_init_for_seamless_clip( ++ calculate_init_and_vp( + flip_vert_scan_dir, +- recout_skip_v, +- surf_size_v / vpc_div, +- orthogonal_rotation ? data->taps.h_taps_c : data->taps.v_taps_c, +- orthogonal_rotation ? data->ratios.horz_c : data->ratios.vert_c, +- orthogonal_rotation ? &data->inits.h_c : &data->inits.v_c, ++ ro_tb, ++ data->recout.height, ++ src.height / vpc_div, ++ data->taps.v_taps_c, ++ data->ratios.vert_c, ++ &data->inits.v_c, + &data->viewport_c.y, + &data->viewport_c.height); +- +- /* Interlaced inits based on final vert inits */ +- data->inits.v_bot = dc_fixpt_add(data->inits.v, data->ratios.vert); +- data->inits.v_c_bot = dc_fixpt_add(data->inits.v_c, data->ratios.vert_c); +- +-} +- +-/* +- * When handling 270 rotation in mixed SLS mode, we have +- * stream->timing.h_border_left that is non zero. If we are doing +- * pipe-splitting, this h_border_left value gets added to recout.x and when it +- * calls calculate_inits_and_adj_vp() and +- * adjust_vp_and_init_for_seamless_clip(), it can cause viewport.height for a +- * pipe to be incorrect. +- * +- * To fix this, instead of using stream->timing.h_border_left, we can use +- * stream->dst.x to represent the border instead. So we will set h_border_left +- * to 0 and shift the appropriate amount in stream->dst.x. We will then +- * perform all calculations in resource_build_scaling_params() based on this +- * and then restore the h_border_left and stream->dst.x to their original +- * values. +- * +- * shift_border_left_to_dst() will shift the amount of h_border_left to +- * stream->dst.x and set h_border_left to 0. restore_border_left_from_dst() +- * will restore h_border_left and stream->dst.x back to their original values +- * We also need to make sure pipe_ctx->plane_res.scl_data.h_active uses the +- * original h_border_left value in its calculation. +- */ +-static int shift_border_left_to_dst(struct pipe_ctx *pipe_ctx) +-{ +- int store_h_border_left = pipe_ctx->stream->timing.h_border_left; +- +- if (store_h_border_left) { +- pipe_ctx->stream->timing.h_border_left = 0; +- pipe_ctx->stream->dst.x += store_h_border_left; ++ if (orthogonal_rotation) { ++ swap(data->viewport.x, data->viewport.y); ++ swap(data->viewport.width, data->viewport.height); ++ swap(data->viewport_c.x, data->viewport_c.y); ++ swap(data->viewport_c.width, data->viewport_c.height); + } +- return store_h_border_left; +-} +- +-static void restore_border_left_from_dst(struct pipe_ctx *pipe_ctx, +- int store_h_border_left) +-{ +- pipe_ctx->stream->dst.x -= store_h_border_left; +- pipe_ctx->stream->timing.h_border_left = store_h_border_left; ++ data->viewport.x += src.x; ++ data->viewport.y += src.y; ++ ASSERT(src.x % vpc_div == 0 && src.y % vpc_div == 0); ++ data->viewport_c.x += src.x / vpc_div; ++ data->viewport_c.y += src.y / vpc_div; + } + + bool resource_build_scaling_params(struct pipe_ctx *pipe_ctx) +@@ -1140,48 +963,42 @@ bool resource_build_scaling_params(struct pipe_ctx *pipe_ctx) + const struct dc_plane_state *plane_state = pipe_ctx->plane_state; + struct dc_crtc_timing *timing = &pipe_ctx->stream->timing; + bool res = false; +- int store_h_border_left = shift_border_left_to_dst(pipe_ctx); + DC_LOGGER_INIT(pipe_ctx->stream->ctx->logger); +- /* Important: scaling ratio calculation requires pixel format, +- * lb depth calculation requires recout and taps require scaling ratios. +- * Inits require viewport, taps, ratios and recout of split pipe +- */ ++ + pipe_ctx->plane_res.scl_data.format = convert_pixel_format_to_dalsurface( + pipe_ctx->plane_state->format); + +- calculate_scaling_ratios(pipe_ctx); +- +- calculate_viewport(pipe_ctx); ++ /* Timing borders are part of vactive that we are also supposed to skip in addition ++ * to any stream dst offset. Since dm logic assumes dst is in addressable ++ * space we need to add the the left and top borders to dst offsets temporarily. ++ * TODO: fix in DM, stream dst is supposed to be in vactive ++ */ ++ pipe_ctx->stream->dst.x += timing->h_border_left; ++ pipe_ctx->stream->dst.y += timing->v_border_top; + +- if (pipe_ctx->plane_res.scl_data.viewport.height < MIN_VIEWPORT_SIZE || +- pipe_ctx->plane_res.scl_data.viewport.width < MIN_VIEWPORT_SIZE) { +- if (store_h_border_left) { +- restore_border_left_from_dst(pipe_ctx, +- store_h_border_left); +- } +- return false; +- } ++ /* Calculate H and V active size */ ++ pipe_ctx->plane_res.scl_data.h_active = timing->h_addressable + ++ timing->h_border_left + timing->h_border_right; ++ pipe_ctx->plane_res.scl_data.v_active = timing->v_addressable + ++ timing->v_border_top + timing->v_border_bottom; ++ if (pipe_ctx->next_odm_pipe || pipe_ctx->prev_odm_pipe) ++ pipe_ctx->plane_res.scl_data.h_active /= get_num_odm_splits(pipe_ctx) + 1; + ++ /* depends on h_active */ + calculate_recout(pipe_ctx); ++ /* depends on pixel format */ ++ calculate_scaling_ratios(pipe_ctx); ++ /* depends on scaling ratios and recout, does not calculate offset yet */ ++ calculate_viewport_size(pipe_ctx); + +- /** ++ /* ++ * LB calculations depend on vp size, h/v_active and scaling ratios + * Setting line buffer pixel depth to 24bpp yields banding + * on certain displays, such as the Sharp 4k + */ + pipe_ctx->plane_res.scl_data.lb_params.depth = LB_PIXEL_DEPTH_30BPP; + pipe_ctx->plane_res.scl_data.lb_params.alpha_en = plane_state->per_pixel_alpha; + +- pipe_ctx->plane_res.scl_data.recout.x += timing->h_border_left; +- pipe_ctx->plane_res.scl_data.recout.y += timing->v_border_top; +- +- pipe_ctx->plane_res.scl_data.h_active = timing->h_addressable + +- store_h_border_left + timing->h_border_right; +- pipe_ctx->plane_res.scl_data.v_active = timing->v_addressable + +- timing->v_border_top + timing->v_border_bottom; +- if (pipe_ctx->next_odm_pipe || pipe_ctx->prev_odm_pipe) +- pipe_ctx->plane_res.scl_data.h_active /= get_num_odm_splits(pipe_ctx) + 1; +- +- /* Taps calculations */ + if (pipe_ctx->plane_res.xfm != NULL) + res = pipe_ctx->plane_res.xfm->funcs->transform_get_optimal_number_of_taps( + pipe_ctx->plane_res.xfm, &pipe_ctx->plane_res.scl_data, &plane_state->scaling_quality); +@@ -1208,9 +1025,31 @@ bool resource_build_scaling_params(struct pipe_ctx *pipe_ctx) + &plane_state->scaling_quality); + } + ++ /* ++ * Depends on recout, scaling ratios, h_active and taps ++ * May need to re-check lb size after this in some obscure scenario ++ */ + if (res) +- /* May need to re-check lb size after this in some obscure scenario */ +- calculate_inits_and_adj_vp(pipe_ctx); ++ calculate_inits_and_viewports(pipe_ctx); ++ ++ /* ++ * Handle side by side and top bottom 3d recout offsets after vp calculation ++ * since 3d is special and needs to calculate vp as if there is no recout offset ++ * This may break with rotation, good thing we aren't mixing hw rotation and 3d ++ */ ++ if (pipe_ctx->top_pipe && pipe_ctx->top_pipe->plane_state == plane_state) { ++ ASSERT(plane_state->rotation == ROTATION_ANGLE_0 || ++ (pipe_ctx->stream->view_format != VIEW_3D_FORMAT_TOP_AND_BOTTOM && ++ pipe_ctx->stream->view_format != VIEW_3D_FORMAT_SIDE_BY_SIDE)); ++ if (pipe_ctx->stream->view_format == VIEW_3D_FORMAT_TOP_AND_BOTTOM) ++ pipe_ctx->plane_res.scl_data.recout.y += pipe_ctx->plane_res.scl_data.recout.height; ++ else if (pipe_ctx->stream->view_format == VIEW_3D_FORMAT_SIDE_BY_SIDE) ++ pipe_ctx->plane_res.scl_data.recout.x += pipe_ctx->plane_res.scl_data.recout.width; ++ } ++ ++ if (pipe_ctx->plane_res.scl_data.viewport.height < MIN_VIEWPORT_SIZE || ++ pipe_ctx->plane_res.scl_data.viewport.width < MIN_VIEWPORT_SIZE) ++ res = false; + + DC_LOG_SCALER("%s pipe %d:\nViewport: height:%d width:%d x:%d y:%d Recout: height:%d width:%d x:%d y:%d HACTIVE:%d VACTIVE:%d\n" + "src_rect: height:%d width:%d x:%d y:%d dst_rect: height:%d width:%d x:%d y:%d clip_rect: height:%d width:%d x:%d y:%d\n", +@@ -1239,8 +1078,8 @@ bool resource_build_scaling_params(struct pipe_ctx *pipe_ctx) + plane_state->clip_rect.x, + plane_state->clip_rect.y); + +- if (store_h_border_left) +- restore_border_left_from_dst(pipe_ctx, store_h_border_left); ++ pipe_ctx->stream->dst.x -= timing->h_border_left; ++ pipe_ctx->stream->dst.y -= timing->v_border_top; + + return res; + } +diff --git a/drivers/gpu/drm/amd/display/dc/dc_types.h b/drivers/gpu/drm/amd/display/dc/dc_types.h +index 80757a0ea7c65..2c3ce5d657180 100644 +--- a/drivers/gpu/drm/amd/display/dc/dc_types.h ++++ b/drivers/gpu/drm/amd/display/dc/dc_types.h +@@ -270,11 +270,6 @@ struct dc_edid_caps { + struct dc_panel_patch panel_patch; + }; + +-struct view { +- uint32_t width; +- uint32_t height; +-}; +- + struct dc_mode_flags { + /* note: part of refresh rate flag*/ + uint32_t INTERLACE :1; +diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c +index efa86d5c68470..a33f522a2648a 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp_dscl.c +@@ -496,10 +496,13 @@ static enum lb_memory_config dpp1_dscl_find_lb_memory_config(struct dcn10_dpp *d + int vtaps_c = scl_data->taps.v_taps_c; + int ceil_vratio = dc_fixpt_ceil(scl_data->ratios.vert); + int ceil_vratio_c = dc_fixpt_ceil(scl_data->ratios.vert_c); +- enum lb_memory_config mem_cfg = LB_MEMORY_CONFIG_0; + +- if (dpp->base.ctx->dc->debug.use_max_lb) +- return mem_cfg; ++ if (dpp->base.ctx->dc->debug.use_max_lb) { ++ if (scl_data->format == PIXEL_FORMAT_420BPP8 ++ || scl_data->format == PIXEL_FORMAT_420BPP10) ++ return LB_MEMORY_CONFIG_3; ++ return LB_MEMORY_CONFIG_0; ++ } + + dpp->base.caps->dscl_calc_lb_num_partitions( + scl_data, LB_MEMORY_CONFIG_1, &num_part_y, &num_part_c); +@@ -628,8 +631,10 @@ static void dpp1_dscl_set_manual_ratio_init( + SCL_V_INIT_INT, init_int); + + if (REG(SCL_VERT_FILTER_INIT_BOT)) { +- init_frac = dc_fixpt_u0d19(data->inits.v_bot) << 5; +- init_int = dc_fixpt_floor(data->inits.v_bot); ++ struct fixed31_32 bot = dc_fixpt_add(data->inits.v, data->ratios.vert); ++ ++ init_frac = dc_fixpt_u0d19(bot) << 5; ++ init_int = dc_fixpt_floor(bot); + REG_SET_2(SCL_VERT_FILTER_INIT_BOT, 0, + SCL_V_INIT_FRAC_BOT, init_frac, + SCL_V_INIT_INT_BOT, init_int); +@@ -642,8 +647,10 @@ static void dpp1_dscl_set_manual_ratio_init( + SCL_V_INIT_INT_C, init_int); + + if (REG(SCL_VERT_FILTER_INIT_BOT_C)) { +- init_frac = dc_fixpt_u0d19(data->inits.v_c_bot) << 5; +- init_int = dc_fixpt_floor(data->inits.v_c_bot); ++ struct fixed31_32 bot = dc_fixpt_add(data->inits.v_c, data->ratios.vert_c); ++ ++ init_frac = dc_fixpt_u0d19(bot) << 5; ++ init_int = dc_fixpt_floor(bot); + REG_SET_2(SCL_VERT_FILTER_INIT_BOT_C, 0, + SCL_V_INIT_FRAC_BOT_C, init_frac, + SCL_V_INIT_INT_BOT_C, init_int); +diff --git a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hwseq.c b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hwseq.c +index aece1103331dd..d8a03d8256235 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hwseq.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_hwseq.c +@@ -243,7 +243,7 @@ void dcn20_dccg_init(struct dce_hwseq *hws) + REG_WRITE(MILLISECOND_TIME_BASE_DIV, 0x1186a0); + + /* This value is dependent on the hardware pipeline delay so set once per SOC */ +- REG_WRITE(DISPCLK_FREQ_CHANGE_CNTL, 0x801003c); ++ REG_WRITE(DISPCLK_FREQ_CHANGE_CNTL, 0xe01003c); + } + + void dcn20_disable_vga( +diff --git a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c +index 3e3c898848bd8..2b6eb8c5614b8 100644 +--- a/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c ++++ b/drivers/gpu/drm/amd/display/dc/dcn20/dcn20_resource.c +@@ -2284,12 +2284,14 @@ int dcn20_populate_dml_pipes_from_context( + + pipes[pipe_cnt].pipe.src.source_scan = pln->rotation == ROTATION_ANGLE_90 + || pln->rotation == ROTATION_ANGLE_270 ? dm_vert : dm_horz; +- pipes[pipe_cnt].pipe.src.viewport_y_y = scl->viewport_unadjusted.y; +- pipes[pipe_cnt].pipe.src.viewport_y_c = scl->viewport_c_unadjusted.y; +- pipes[pipe_cnt].pipe.src.viewport_width = scl->viewport_unadjusted.width; +- pipes[pipe_cnt].pipe.src.viewport_width_c = scl->viewport_c_unadjusted.width; +- pipes[pipe_cnt].pipe.src.viewport_height = scl->viewport_unadjusted.height; +- pipes[pipe_cnt].pipe.src.viewport_height_c = scl->viewport_c_unadjusted.height; ++ pipes[pipe_cnt].pipe.src.viewport_y_y = scl->viewport.y; ++ pipes[pipe_cnt].pipe.src.viewport_y_c = scl->viewport_c.y; ++ pipes[pipe_cnt].pipe.src.viewport_width = scl->viewport.width; ++ pipes[pipe_cnt].pipe.src.viewport_width_c = scl->viewport_c.width; ++ pipes[pipe_cnt].pipe.src.viewport_height = scl->viewport.height; ++ pipes[pipe_cnt].pipe.src.viewport_height_c = scl->viewport_c.height; ++ pipes[pipe_cnt].pipe.src.viewport_width_max = pln->src_rect.width; ++ pipes[pipe_cnt].pipe.src.viewport_height_max = pln->src_rect.height; + pipes[pipe_cnt].pipe.src.surface_width_y = pln->plane_size.surface_size.width; + pipes[pipe_cnt].pipe.src.surface_height_y = pln->plane_size.surface_size.height; + pipes[pipe_cnt].pipe.src.surface_width_c = pln->plane_size.chroma_size.width; +diff --git a/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_mode_vba_30.c b/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_mode_vba_30.c +index bc07082c13575..6e326290f2147 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_mode_vba_30.c ++++ b/drivers/gpu/drm/amd/display/dc/dml/dcn30/display_mode_vba_30.c +@@ -64,6 +64,7 @@ typedef struct { + #define BPP_INVALID 0 + #define BPP_BLENDED_PIPE 0xffffffff + #define DCN30_MAX_DSC_IMAGE_WIDTH 5184 ++#define DCN30_MAX_FMT_420_BUFFER_WIDTH 4096 + + static void DisplayPipeConfiguration(struct display_mode_lib *mode_lib); + static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerformanceCalculation( +@@ -2052,7 +2053,7 @@ static void DISPCLKDPPCLKDCFCLKDeepSleepPrefetchParametersWatermarksAndPerforman + v->DISPCLKWithoutRamping, + v->DISPCLKDPPCLKVCOSpeed); + v->MaxDispclkRoundedToDFSGranularity = RoundToDFSGranularityDown( +- v->soc.clock_limits[mode_lib->soc.num_states].dispclk_mhz, ++ v->soc.clock_limits[mode_lib->soc.num_states - 1].dispclk_mhz, + v->DISPCLKDPPCLKVCOSpeed); + if (v->DISPCLKWithoutRampingRoundedToDFSGranularity + > v->MaxDispclkRoundedToDFSGranularity) { +@@ -3957,20 +3958,20 @@ void dml30_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_l + for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) { + v->PlaneRequiredDISPCLKWithoutODMCombine = v->PixelClock[k] * (1.0 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) + * (1.0 + v->DISPCLKRampingMargin / 100.0); +- if ((v->PlaneRequiredDISPCLKWithoutODMCombine >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states] +- && v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states])) { ++ if ((v->PlaneRequiredDISPCLKWithoutODMCombine >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states - 1] ++ && v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states - 1])) { + v->PlaneRequiredDISPCLKWithoutODMCombine = v->PixelClock[k] * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0); + } + v->PlaneRequiredDISPCLKWithODMCombine2To1 = v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) + * (1 + v->DISPCLKRampingMargin / 100.0); +- if ((v->PlaneRequiredDISPCLKWithODMCombine2To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states] +- && v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states])) { ++ if ((v->PlaneRequiredDISPCLKWithODMCombine2To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states - 1] ++ && v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states - 1])) { + v->PlaneRequiredDISPCLKWithODMCombine2To1 = v->PixelClock[k] / 2 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0); + } + v->PlaneRequiredDISPCLKWithODMCombine4To1 = v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) + * (1 + v->DISPCLKRampingMargin / 100.0); +- if ((v->PlaneRequiredDISPCLKWithODMCombine4To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states] +- && v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states])) { ++ if ((v->PlaneRequiredDISPCLKWithODMCombine4To1 >= v->MaxDispclk[i] && v->MaxDispclk[i] == v->MaxDispclk[mode_lib->soc.num_states - 1] ++ && v->MaxDppclk[i] == v->MaxDppclk[mode_lib->soc.num_states - 1])) { + v->PlaneRequiredDISPCLKWithODMCombine4To1 = v->PixelClock[k] / 4 * (1 + v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0); + } + +@@ -3987,19 +3988,30 @@ void dml30_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_l + } else if (v->PlaneRequiredDISPCLKWithoutODMCombine > v->MaxDispclkRoundedDownToDFSGranularity) { + v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1; + v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1; +- } else if (v->DSCEnabled[k] && (v->HActive[k] > DCN30_MAX_DSC_IMAGE_WIDTH)) { +- v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1; +- v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1; + } else { + v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_disabled; + v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithoutODMCombine; +- /*420 format workaround*/ +- if (v->HActive[k] > 4096 && v->OutputFormat[k] == dm_420) { ++ } ++ if (v->DSCEnabled[k] && v->HActive[k] > DCN30_MAX_DSC_IMAGE_WIDTH ++ && v->ODMCombineEnablePerState[i][k] != dm_odm_combine_mode_4to1) { ++ if (v->HActive[k] / 2 > DCN30_MAX_DSC_IMAGE_WIDTH) { ++ v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_4to1; ++ v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine4To1; ++ } else { ++ v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1; ++ v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1; ++ } ++ } ++ if (v->OutputFormat[k] == dm_420 && v->HActive[k] > DCN30_MAX_FMT_420_BUFFER_WIDTH ++ && v->ODMCombineEnablePerState[i][k] != dm_odm_combine_mode_4to1) { ++ if (v->HActive[k] / 2 > DCN30_MAX_FMT_420_BUFFER_WIDTH) { ++ v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_4to1; ++ v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine4To1; ++ } else { + v->ODMCombineEnablePerState[i][k] = dm_odm_combine_mode_2to1; + v->PlaneRequiredDISPCLK = v->PlaneRequiredDISPCLKWithODMCombine2To1; + } + } +- + if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) { + v->MPCCombine[i][j][k] = false; + v->NoOfDPP[i][j][k] = 4; +@@ -4281,42 +4293,8 @@ void dml30_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_l + } + } + +- for (i = 0; i < v->soc.num_states; i++) { +- v->DSCCLKRequiredMoreThanSupported[i] = false; +- for (k = 0; k <= v->NumberOfActivePlanes - 1; k++) { +- if (v->BlendingAndTiming[k] == k) { +- if (v->Output[k] == dm_dp || v->Output[k] == dm_edp) { +- if (v->OutputFormat[k] == dm_420) { +- v->DSCFormatFactor = 2; +- } else if (v->OutputFormat[k] == dm_444) { +- v->DSCFormatFactor = 1; +- } else if (v->OutputFormat[k] == dm_n422) { +- v->DSCFormatFactor = 2; +- } else { +- v->DSCFormatFactor = 1; +- } +- if (v->RequiresDSC[i][k] == true) { +- if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_4to1) { +- if (v->PixelClockBackEnd[k] / 12.0 / v->DSCFormatFactor +- > (1.0 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * v->MaxDSCCLK[i]) { +- v->DSCCLKRequiredMoreThanSupported[i] = true; +- } +- } else if (v->ODMCombineEnablePerState[i][k] == dm_odm_combine_mode_2to1) { +- if (v->PixelClockBackEnd[k] / 6.0 / v->DSCFormatFactor +- > (1.0 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * v->MaxDSCCLK[i]) { +- v->DSCCLKRequiredMoreThanSupported[i] = true; +- } +- } else { +- if (v->PixelClockBackEnd[k] / 3.0 / v->DSCFormatFactor +- > (1.0 - v->DISPCLKDPPCLKDSCCLKDownSpreading / 100.0) * v->MaxDSCCLK[i]) { +- v->DSCCLKRequiredMoreThanSupported[i] = true; +- } +- } +- } +- } +- } +- } +- } ++ /* Skip dscclk validation: as long as dispclk is supported, dscclk is also implicitly supported */ ++ + for (i = 0; i < v->soc.num_states; i++) { + v->NotEnoughDSCUnits[i] = false; + v->TotalDSCUnitsRequired = 0.0; +@@ -5319,7 +5297,7 @@ void dml30_ModeSupportAndSystemConfigurationFull(struct display_mode_lib *mode_l + for (j = 0; j < 2; j++) { + if (v->ScaleRatioAndTapsSupport == 1 && v->SourceFormatPixelAndScanSupport == 1 && v->ViewportSizeSupport[i][j] == 1 + && v->DIOSupport[i] == 1 && v->ODMCombine4To1SupportCheckOK[i] == 1 +- && v->NotEnoughDSCUnits[i] == 0 && v->DSCCLKRequiredMoreThanSupported[i] == 0 ++ && v->NotEnoughDSCUnits[i] == 0 + && v->DTBCLKRequiredMoreThanSupported[i] == 0 + && v->ROBSupport[i][j] == 1 && v->DISPCLK_DPPCLK_Support[i][j] == 1 && v->TotalAvailablePipesSupport[i][j] == 1 + && EnoughWritebackUnits == 1 && WritebackModeSupport == 1 +diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_structs.h b/drivers/gpu/drm/amd/display/dc/dml/display_mode_structs.h +index 0c5128187e089..ea01994a61338 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_structs.h ++++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_structs.h +@@ -253,6 +253,8 @@ struct _vcs_dpi_display_pipe_source_params_st { + unsigned int viewport_y_c; + unsigned int viewport_width_c; + unsigned int viewport_height_c; ++ unsigned int viewport_width_max; ++ unsigned int viewport_height_max; + unsigned int data_pitch; + unsigned int data_pitch_c; + unsigned int meta_pitch; +diff --git a/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c b/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c +index bc0485a59018a..c1bf3cab2f156 100644 +--- a/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c ++++ b/drivers/gpu/drm/amd/display/dc/dml/display_mode_vba.c +@@ -627,6 +627,19 @@ static void fetch_pipe_params(struct display_mode_lib *mode_lib) + } + } + } ++ if (src->viewport_width_max) { ++ int hdiv_c = src->source_format >= dm_420_8 && src->source_format <= dm_422_10 ? 2 : 1; ++ int vdiv_c = src->source_format >= dm_420_8 && src->source_format <= dm_420_12 ? 2 : 1; ++ ++ if (mode_lib->vba.ViewportWidth[mode_lib->vba.NumberOfActivePlanes] > src->viewport_width_max) ++ mode_lib->vba.ViewportWidth[mode_lib->vba.NumberOfActivePlanes] = src->viewport_width_max; ++ if (mode_lib->vba.ViewportHeight[mode_lib->vba.NumberOfActivePlanes] > src->viewport_height_max) ++ mode_lib->vba.ViewportHeight[mode_lib->vba.NumberOfActivePlanes] = src->viewport_height_max; ++ if (mode_lib->vba.ViewportWidthChroma[mode_lib->vba.NumberOfActivePlanes] > src->viewport_width_max / hdiv_c) ++ mode_lib->vba.ViewportWidthChroma[mode_lib->vba.NumberOfActivePlanes] = src->viewport_width_max / hdiv_c; ++ if (mode_lib->vba.ViewportHeightChroma[mode_lib->vba.NumberOfActivePlanes] > src->viewport_height_max / vdiv_c) ++ mode_lib->vba.ViewportHeightChroma[mode_lib->vba.NumberOfActivePlanes] = src->viewport_height_max / vdiv_c; ++ } + + if (pipes[k].pipe.src.immediate_flip) { + mode_lib->vba.ImmediateFlipSupport = true; +diff --git a/drivers/gpu/drm/amd/display/dc/inc/hw/transform.h b/drivers/gpu/drm/amd/display/dc/inc/hw/transform.h +index 2947d1b155129..2a0db2b03047e 100644 +--- a/drivers/gpu/drm/amd/display/dc/inc/hw/transform.h ++++ b/drivers/gpu/drm/amd/display/dc/inc/hw/transform.h +@@ -162,9 +162,7 @@ struct scl_inits { + struct fixed31_32 h; + struct fixed31_32 h_c; + struct fixed31_32 v; +- struct fixed31_32 v_bot; + struct fixed31_32 v_c; +- struct fixed31_32 v_c_bot; + }; + + struct scaler_data { +@@ -173,8 +171,6 @@ struct scaler_data { + struct scaling_taps taps; + struct rect viewport; + struct rect viewport_c; +- struct rect viewport_unadjusted; +- struct rect viewport_c_unadjusted; + struct rect recout; + struct scaling_ratios ratios; + struct scl_inits inits; +diff --git a/drivers/gpu/drm/amd/display/dc/irq_types.h b/drivers/gpu/drm/amd/display/dc/irq_types.h +index 87812d81fed3c..52fbf575e0004 100644 +--- a/drivers/gpu/drm/amd/display/dc/irq_types.h ++++ b/drivers/gpu/drm/amd/display/dc/irq_types.h +@@ -164,7 +164,7 @@ enum irq_type + }; + + #define DAL_VALID_IRQ_SRC_NUM(src) \ +- ((src) <= DAL_IRQ_SOURCES_NUMBER && (src) > DC_IRQ_SOURCE_INVALID) ++ ((src) < DAL_IRQ_SOURCES_NUMBER && (src) > DC_IRQ_SOURCE_INVALID) + + /* Number of Page Flip IRQ Sources. */ + #define DAL_PFLIP_IRQ_SRC_NUM \ +diff --git a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp.c b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp.c +index 20e554e771d16..fa8aeec304ef4 100644 +--- a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp.c ++++ b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp.c +@@ -260,7 +260,6 @@ enum mod_hdcp_status mod_hdcp_setup(struct mod_hdcp *hdcp, + struct mod_hdcp_output output; + enum mod_hdcp_status status = MOD_HDCP_STATUS_SUCCESS; + +- memset(hdcp, 0, sizeof(struct mod_hdcp)); + memset(&output, 0, sizeof(output)); + hdcp->config = *config; + HDCP_TOP_INTERFACE_TRACE(hdcp); +diff --git a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp1_execution.c b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp1_execution.c +index 73ca49f05bd32..eb56526ec32c6 100644 +--- a/drivers/gpu/drm/amd/display/modules/hdcp/hdcp1_execution.c ++++ b/drivers/gpu/drm/amd/display/modules/hdcp/hdcp1_execution.c +@@ -29,8 +29,10 @@ static inline enum mod_hdcp_status validate_bksv(struct mod_hdcp *hdcp) + { + uint64_t n = 0; + uint8_t count = 0; ++ u8 bksv[sizeof(n)] = { }; + +- memcpy(&n, hdcp->auth.msg.hdcp1.bksv, sizeof(uint64_t)); ++ memcpy(bksv, hdcp->auth.msg.hdcp1.bksv, sizeof(hdcp->auth.msg.hdcp1.bksv)); ++ n = *(uint64_t *)bksv; + + while (n) { + count++; +diff --git a/drivers/gpu/drm/amd/include/navi10_enum.h b/drivers/gpu/drm/amd/include/navi10_enum.h +index d5ead9680c6ed..84bcb96f76ea4 100644 +--- a/drivers/gpu/drm/amd/include/navi10_enum.h ++++ b/drivers/gpu/drm/amd/include/navi10_enum.h +@@ -430,7 +430,7 @@ ARRAY_2D_DEPTH = 0x00000001, + */ + + typedef enum ENUM_NUM_SIMD_PER_CU { +-NUM_SIMD_PER_CU = 0x00000004, ++NUM_SIMD_PER_CU = 0x00000002, + } ENUM_NUM_SIMD_PER_CU; + + /* +diff --git a/drivers/gpu/drm/arm/malidp_planes.c b/drivers/gpu/drm/arm/malidp_planes.c +index 351a85088d0ec..f1e8bc39b16d3 100644 +--- a/drivers/gpu/drm/arm/malidp_planes.c ++++ b/drivers/gpu/drm/arm/malidp_planes.c +@@ -922,6 +922,11 @@ static const struct drm_plane_helper_funcs malidp_de_plane_helper_funcs = { + .atomic_disable = malidp_de_plane_disable, + }; + ++static const uint64_t linear_only_modifiers[] = { ++ DRM_FORMAT_MOD_LINEAR, ++ DRM_FORMAT_MOD_INVALID ++}; ++ + int malidp_de_planes_init(struct drm_device *drm) + { + struct malidp_drm *malidp = drm->dev_private; +@@ -985,8 +990,8 @@ int malidp_de_planes_init(struct drm_device *drm) + */ + ret = drm_universal_plane_init(drm, &plane->base, crtcs, + &malidp_de_plane_funcs, formats, n, +- (id == DE_SMART) ? NULL : modifiers, plane_type, +- NULL); ++ (id == DE_SMART) ? linear_only_modifiers : modifiers, ++ plane_type, NULL); + + if (ret < 0) + goto cleanup; +diff --git a/drivers/gpu/drm/ast/ast_dp501.c b/drivers/gpu/drm/ast/ast_dp501.c +index 88121c0e0d05c..cd93c44f26627 100644 +--- a/drivers/gpu/drm/ast/ast_dp501.c ++++ b/drivers/gpu/drm/ast/ast_dp501.c +@@ -189,6 +189,9 @@ bool ast_backup_fw(struct drm_device *dev, u8 *addr, u32 size) + u32 i, data; + u32 boot_address; + ++ if (ast->config_mode != ast_use_p2a) ++ return false; ++ + data = ast_mindwm(ast, 0x1e6e2100) & 0x01; + if (data) { + boot_address = get_fw_base(ast); +@@ -207,6 +210,9 @@ static bool ast_launch_m68k(struct drm_device *dev) + u8 *fw_addr = NULL; + u8 jreg; + ++ if (ast->config_mode != ast_use_p2a) ++ return false; ++ + data = ast_mindwm(ast, 0x1e6e2100) & 0x01; + if (!data) { + +@@ -271,25 +277,55 @@ u8 ast_get_dp501_max_clk(struct drm_device *dev) + struct ast_private *ast = to_ast_private(dev); + u32 boot_address, offset, data; + u8 linkcap[4], linkrate, linklanes, maxclk = 0xff; ++ u32 *plinkcap; + +- boot_address = get_fw_base(ast); +- +- /* validate FW version */ +- offset = 0xf000; +- data = ast_mindwm(ast, boot_address + offset); +- if ((data & 0xf0) != 0x10) /* version: 1x */ +- return maxclk; +- +- /* Read Link Capability */ +- offset = 0xf014; +- *(u32 *)linkcap = ast_mindwm(ast, boot_address + offset); +- if (linkcap[2] == 0) { +- linkrate = linkcap[0]; +- linklanes = linkcap[1]; +- data = (linkrate == 0x0a) ? (90 * linklanes) : (54 * linklanes); +- if (data > 0xff) +- data = 0xff; +- maxclk = (u8)data; ++ if (ast->config_mode == ast_use_p2a) { ++ boot_address = get_fw_base(ast); ++ ++ /* validate FW version */ ++ offset = AST_DP501_GBL_VERSION; ++ data = ast_mindwm(ast, boot_address + offset); ++ if ((data & AST_DP501_FW_VERSION_MASK) != AST_DP501_FW_VERSION_1) /* version: 1x */ ++ return maxclk; ++ ++ /* Read Link Capability */ ++ offset = AST_DP501_LINKRATE; ++ plinkcap = (u32 *)linkcap; ++ *plinkcap = ast_mindwm(ast, boot_address + offset); ++ if (linkcap[2] == 0) { ++ linkrate = linkcap[0]; ++ linklanes = linkcap[1]; ++ data = (linkrate == 0x0a) ? (90 * linklanes) : (54 * linklanes); ++ if (data > 0xff) ++ data = 0xff; ++ maxclk = (u8)data; ++ } ++ } else { ++ if (!ast->dp501_fw_buf) ++ return AST_DP501_DEFAULT_DCLK; /* 1024x768 as default */ ++ ++ /* dummy read */ ++ offset = 0x0000; ++ data = readl(ast->dp501_fw_buf + offset); ++ ++ /* validate FW version */ ++ offset = AST_DP501_GBL_VERSION; ++ data = readl(ast->dp501_fw_buf + offset); ++ if ((data & AST_DP501_FW_VERSION_MASK) != AST_DP501_FW_VERSION_1) /* version: 1x */ ++ return maxclk; ++ ++ /* Read Link Capability */ ++ offset = AST_DP501_LINKRATE; ++ plinkcap = (u32 *)linkcap; ++ *plinkcap = readl(ast->dp501_fw_buf + offset); ++ if (linkcap[2] == 0) { ++ linkrate = linkcap[0]; ++ linklanes = linkcap[1]; ++ data = (linkrate == 0x0a) ? (90 * linklanes) : (54 * linklanes); ++ if (data > 0xff) ++ data = 0xff; ++ maxclk = (u8)data; ++ } + } + return maxclk; + } +@@ -298,26 +334,57 @@ bool ast_dp501_read_edid(struct drm_device *dev, u8 *ediddata) + { + struct ast_private *ast = to_ast_private(dev); + u32 i, boot_address, offset, data; ++ u32 *pEDIDidx; + +- boot_address = get_fw_base(ast); +- +- /* validate FW version */ +- offset = 0xf000; +- data = ast_mindwm(ast, boot_address + offset); +- if ((data & 0xf0) != 0x10) +- return false; +- +- /* validate PnP Monitor */ +- offset = 0xf010; +- data = ast_mindwm(ast, boot_address + offset); +- if (!(data & 0x01)) +- return false; ++ if (ast->config_mode == ast_use_p2a) { ++ boot_address = get_fw_base(ast); + +- /* Read EDID */ +- offset = 0xf020; +- for (i = 0; i < 128; i += 4) { +- data = ast_mindwm(ast, boot_address + offset + i); +- *(u32 *)(ediddata + i) = data; ++ /* validate FW version */ ++ offset = AST_DP501_GBL_VERSION; ++ data = ast_mindwm(ast, boot_address + offset); ++ if ((data & AST_DP501_FW_VERSION_MASK) != AST_DP501_FW_VERSION_1) ++ return false; ++ ++ /* validate PnP Monitor */ ++ offset = AST_DP501_PNPMONITOR; ++ data = ast_mindwm(ast, boot_address + offset); ++ if (!(data & AST_DP501_PNP_CONNECTED)) ++ return false; ++ ++ /* Read EDID */ ++ offset = AST_DP501_EDID_DATA; ++ for (i = 0; i < 128; i += 4) { ++ data = ast_mindwm(ast, boot_address + offset + i); ++ pEDIDidx = (u32 *)(ediddata + i); ++ *pEDIDidx = data; ++ } ++ } else { ++ if (!ast->dp501_fw_buf) ++ return false; ++ ++ /* dummy read */ ++ offset = 0x0000; ++ data = readl(ast->dp501_fw_buf + offset); ++ ++ /* validate FW version */ ++ offset = AST_DP501_GBL_VERSION; ++ data = readl(ast->dp501_fw_buf + offset); ++ if ((data & AST_DP501_FW_VERSION_MASK) != AST_DP501_FW_VERSION_1) ++ return false; ++ ++ /* validate PnP Monitor */ ++ offset = AST_DP501_PNPMONITOR; ++ data = readl(ast->dp501_fw_buf + offset); ++ if (!(data & AST_DP501_PNP_CONNECTED)) ++ return false; ++ ++ /* Read EDID */ ++ offset = AST_DP501_EDID_DATA; ++ for (i = 0; i < 128; i += 4) { ++ data = readl(ast->dp501_fw_buf + offset + i); ++ pEDIDidx = (u32 *)(ediddata + i); ++ *pEDIDidx = data; ++ } + } + + return true; +diff --git a/drivers/gpu/drm/ast/ast_drv.h b/drivers/gpu/drm/ast/ast_drv.h +index f871fc36c2f7a..a3f67a34f6168 100644 +--- a/drivers/gpu/drm/ast/ast_drv.h ++++ b/drivers/gpu/drm/ast/ast_drv.h +@@ -121,6 +121,7 @@ struct ast_private { + + void __iomem *regs; + void __iomem *ioregs; ++ void __iomem *dp501_fw_buf; + + enum ast_chip chip; + bool vga2_clone; +@@ -298,6 +299,17 @@ int ast_mode_config_init(struct ast_private *ast); + #define AST_MM_ALIGN_SHIFT 4 + #define AST_MM_ALIGN_MASK ((1 << AST_MM_ALIGN_SHIFT) - 1) + ++#define AST_DP501_FW_VERSION_MASK GENMASK(7, 4) ++#define AST_DP501_FW_VERSION_1 BIT(4) ++#define AST_DP501_PNP_CONNECTED BIT(1) ++ ++#define AST_DP501_DEFAULT_DCLK 65 ++ ++#define AST_DP501_GBL_VERSION 0xf000 ++#define AST_DP501_PNPMONITOR 0xf010 ++#define AST_DP501_LINKRATE 0xf014 ++#define AST_DP501_EDID_DATA 0xf020 ++ + int ast_mm_init(struct ast_private *ast); + + /* ast post */ +diff --git a/drivers/gpu/drm/ast/ast_main.c b/drivers/gpu/drm/ast/ast_main.c +index c29cc7f19863a..2aff2e6cf450c 100644 +--- a/drivers/gpu/drm/ast/ast_main.c ++++ b/drivers/gpu/drm/ast/ast_main.c +@@ -99,7 +99,7 @@ static void ast_detect_config_mode(struct drm_device *dev, u32 *scu_rev) + if (!(jregd0 & 0x80) || !(jregd1 & 0x10)) { + /* Double check it's actually working */ + data = ast_read32(ast, 0xf004); +- if (data != 0xFFFFFFFF) { ++ if ((data != 0xFFFFFFFF) && (data != 0x00)) { + /* P2A works, grab silicon revision */ + ast->config_mode = ast_use_p2a; + +@@ -450,6 +450,14 @@ struct ast_private *ast_device_create(const struct drm_driver *drv, + if (ret) + return ERR_PTR(ret); + ++ /* map reserved buffer */ ++ ast->dp501_fw_buf = NULL; ++ if (dev->vram_mm->vram_size < pci_resource_len(pdev, 0)) { ++ ast->dp501_fw_buf = pci_iomap_range(pdev, 0, dev->vram_mm->vram_size, 0); ++ if (!ast->dp501_fw_buf) ++ drm_info(dev, "failed to map reserved buffer!\n"); ++ } ++ + ret = ast_mode_config_init(ast); + if (ret) + return ERR_PTR(ret); +diff --git a/drivers/gpu/drm/bridge/cadence/cdns-mhdp8546-core.c b/drivers/gpu/drm/bridge/cadence/cdns-mhdp8546-core.c +index d0c65610ebb5c..f56ff97c98990 100644 +--- a/drivers/gpu/drm/bridge/cadence/cdns-mhdp8546-core.c ++++ b/drivers/gpu/drm/bridge/cadence/cdns-mhdp8546-core.c +@@ -2369,9 +2369,9 @@ static int cdns_mhdp_probe(struct platform_device *pdev) + clk_prepare_enable(clk); + + pm_runtime_enable(dev); +- ret = pm_runtime_get_sync(dev); ++ ret = pm_runtime_resume_and_get(dev); + if (ret < 0) { +- dev_err(dev, "pm_runtime_get_sync failed\n"); ++ dev_err(dev, "pm_runtime_resume_and_get failed\n"); + pm_runtime_disable(dev); + goto clk_disable; + } +diff --git a/drivers/gpu/drm/bridge/cdns-dsi.c b/drivers/gpu/drm/bridge/cdns-dsi.c +index 76373e31df92d..b31281f76117c 100644 +--- a/drivers/gpu/drm/bridge/cdns-dsi.c ++++ b/drivers/gpu/drm/bridge/cdns-dsi.c +@@ -1028,7 +1028,7 @@ static ssize_t cdns_dsi_transfer(struct mipi_dsi_host *host, + struct mipi_dsi_packet packet; + int ret, i, tx_len, rx_len; + +- ret = pm_runtime_get_sync(host->dev); ++ ret = pm_runtime_resume_and_get(host->dev); + if (ret < 0) + return ret; + +diff --git a/drivers/gpu/drm/bridge/lontium-lt9611.c b/drivers/gpu/drm/bridge/lontium-lt9611.c +index d734d9402c350..c1926154eda84 100644 +--- a/drivers/gpu/drm/bridge/lontium-lt9611.c ++++ b/drivers/gpu/drm/bridge/lontium-lt9611.c +@@ -1209,6 +1209,7 @@ static struct i2c_device_id lt9611_id[] = { + { "lontium,lt9611", 0 }, + {} + }; ++MODULE_DEVICE_TABLE(i2c, lt9611_id); + + static const struct of_device_id lt9611_match_table[] = { + { .compatible = "lontium,lt9611" }, +diff --git a/drivers/gpu/drm/bridge/nwl-dsi.c b/drivers/gpu/drm/bridge/nwl-dsi.c +index 66b67402f1acd..c65ca860712d2 100644 +--- a/drivers/gpu/drm/bridge/nwl-dsi.c ++++ b/drivers/gpu/drm/bridge/nwl-dsi.c +@@ -21,6 +21,7 @@ + #include + #include + ++#include + #include + #include + #include +@@ -742,7 +743,9 @@ static int nwl_dsi_disable(struct nwl_dsi *dsi) + return 0; + } + +-static void nwl_dsi_bridge_disable(struct drm_bridge *bridge) ++static void ++nwl_dsi_bridge_atomic_disable(struct drm_bridge *bridge, ++ struct drm_bridge_state *old_bridge_state) + { + struct nwl_dsi *dsi = bridge_to_dsi(bridge); + int ret; +@@ -803,17 +806,6 @@ static int nwl_dsi_get_dphy_params(struct nwl_dsi *dsi, + return 0; + } + +-static bool nwl_dsi_bridge_mode_fixup(struct drm_bridge *bridge, +- const struct drm_display_mode *mode, +- struct drm_display_mode *adjusted_mode) +-{ +- /* At least LCDIF + NWL needs active high sync */ +- adjusted_mode->flags |= (DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC); +- adjusted_mode->flags &= ~(DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC); +- +- return true; +-} +- + static enum drm_mode_status + nwl_dsi_bridge_mode_valid(struct drm_bridge *bridge, + const struct drm_display_info *info, +@@ -831,6 +823,24 @@ nwl_dsi_bridge_mode_valid(struct drm_bridge *bridge, + return MODE_OK; + } + ++static int nwl_dsi_bridge_atomic_check(struct drm_bridge *bridge, ++ struct drm_bridge_state *bridge_state, ++ struct drm_crtc_state *crtc_state, ++ struct drm_connector_state *conn_state) ++{ ++ struct drm_display_mode *adjusted_mode = &crtc_state->adjusted_mode; ++ ++ /* At least LCDIF + NWL needs active high sync */ ++ adjusted_mode->flags |= (DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC); ++ adjusted_mode->flags &= ~(DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC); ++ ++ /* Do a full modeset if crtc_state->active is changed to be true. */ ++ if (crtc_state->active_changed && crtc_state->active) ++ crtc_state->mode_changed = true; ++ ++ return 0; ++} ++ + static void + nwl_dsi_bridge_mode_set(struct drm_bridge *bridge, + const struct drm_display_mode *mode, +@@ -862,7 +872,9 @@ nwl_dsi_bridge_mode_set(struct drm_bridge *bridge, + drm_mode_debug_printmodeline(adjusted_mode); + } + +-static void nwl_dsi_bridge_pre_enable(struct drm_bridge *bridge) ++static void ++nwl_dsi_bridge_atomic_pre_enable(struct drm_bridge *bridge, ++ struct drm_bridge_state *old_bridge_state) + { + struct nwl_dsi *dsi = bridge_to_dsi(bridge); + int ret; +@@ -897,7 +909,9 @@ static void nwl_dsi_bridge_pre_enable(struct drm_bridge *bridge) + } + } + +-static void nwl_dsi_bridge_enable(struct drm_bridge *bridge) ++static void ++nwl_dsi_bridge_atomic_enable(struct drm_bridge *bridge, ++ struct drm_bridge_state *old_bridge_state) + { + struct nwl_dsi *dsi = bridge_to_dsi(bridge); + int ret; +@@ -942,14 +956,17 @@ static void nwl_dsi_bridge_detach(struct drm_bridge *bridge) + } + + static const struct drm_bridge_funcs nwl_dsi_bridge_funcs = { +- .pre_enable = nwl_dsi_bridge_pre_enable, +- .enable = nwl_dsi_bridge_enable, +- .disable = nwl_dsi_bridge_disable, +- .mode_fixup = nwl_dsi_bridge_mode_fixup, +- .mode_set = nwl_dsi_bridge_mode_set, +- .mode_valid = nwl_dsi_bridge_mode_valid, +- .attach = nwl_dsi_bridge_attach, +- .detach = nwl_dsi_bridge_detach, ++ .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, ++ .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, ++ .atomic_reset = drm_atomic_helper_bridge_reset, ++ .atomic_check = nwl_dsi_bridge_atomic_check, ++ .atomic_pre_enable = nwl_dsi_bridge_atomic_pre_enable, ++ .atomic_enable = nwl_dsi_bridge_atomic_enable, ++ .atomic_disable = nwl_dsi_bridge_atomic_disable, ++ .mode_set = nwl_dsi_bridge_mode_set, ++ .mode_valid = nwl_dsi_bridge_mode_valid, ++ .attach = nwl_dsi_bridge_attach, ++ .detach = nwl_dsi_bridge_detach, + }; + + static int nwl_dsi_parse_dt(struct nwl_dsi *dsi) +diff --git a/drivers/gpu/drm/drm_dp_helper.c b/drivers/gpu/drm/drm_dp_helper.c +index eedbb48815b7b..c7d4d43cdee07 100644 +--- a/drivers/gpu/drm/drm_dp_helper.c ++++ b/drivers/gpu/drm/drm_dp_helper.c +@@ -679,7 +679,14 @@ int drm_dp_read_downstream_info(struct drm_dp_aux *aux, + !(dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT)) + return 0; + ++ /* Some branches advertise having 0 downstream ports, despite also advertising they have a ++ * downstream port present. The DP spec isn't clear on if this is allowed or not, but since ++ * some branches do it we need to handle it regardless. ++ */ + len = drm_dp_downstream_port_count(dpcd); ++ if (!len) ++ return 0; ++ + if (dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DETAILED_CAP_INFO_AVAILABLE) + len *= 4; + +diff --git a/drivers/gpu/drm/i915/display/intel_dp.c b/drivers/gpu/drm/i915/display/intel_dp.c +index 97a785aa8839b..9ebc558fd5163 100644 +--- a/drivers/gpu/drm/i915/display/intel_dp.c ++++ b/drivers/gpu/drm/i915/display/intel_dp.c +@@ -3913,7 +3913,7 @@ static int intel_dp_vsc_sdp_unpack(struct drm_dp_vsc_sdp *vsc, + if (size < sizeof(struct dp_sdp)) + return -EINVAL; + +- memset(vsc, 0, size); ++ memset(vsc, 0, sizeof(*vsc)); + + if (sdp->sdp_header.HB0 != 0) + return -EINVAL; +diff --git a/drivers/gpu/drm/ingenic/ingenic-drm-drv.c b/drivers/gpu/drm/ingenic/ingenic-drm-drv.c +index fd8870edde0ed..63f38be391b6f 100644 +--- a/drivers/gpu/drm/ingenic/ingenic-drm-drv.c ++++ b/drivers/gpu/drm/ingenic/ingenic-drm-drv.c +@@ -341,7 +341,7 @@ static void ingenic_drm_crtc_atomic_flush(struct drm_crtc *crtc, + if (priv->update_clk_rate) { + mutex_lock(&priv->clk_mutex); + clk_set_rate(priv->pix_clk, +- crtc_state->adjusted_mode.clock * 1000); ++ crtc_state->adjusted_mode.crtc_clock * 1000); + priv->update_clk_rate = false; + mutex_unlock(&priv->clk_mutex); + } +@@ -413,7 +413,7 @@ static void ingenic_drm_plane_enable(struct ingenic_drm *priv, + unsigned int en_bit; + + if (priv->soc_info->has_osd) { +- if (plane->type == DRM_PLANE_TYPE_PRIMARY) ++ if (plane != &priv->f0) + en_bit = JZ_LCD_OSDC_F1EN; + else + en_bit = JZ_LCD_OSDC_F0EN; +@@ -428,7 +428,7 @@ void ingenic_drm_plane_disable(struct device *dev, struct drm_plane *plane) + unsigned int en_bit; + + if (priv->soc_info->has_osd) { +- if (plane->type == DRM_PLANE_TYPE_PRIMARY) ++ if (plane != &priv->f0) + en_bit = JZ_LCD_OSDC_F1EN; + else + en_bit = JZ_LCD_OSDC_F0EN; +@@ -455,8 +455,7 @@ void ingenic_drm_plane_config(struct device *dev, + + ingenic_drm_plane_enable(priv, plane); + +- if (priv->soc_info->has_osd && +- plane->type == DRM_PLANE_TYPE_PRIMARY) { ++ if (priv->soc_info->has_osd && plane != &priv->f0) { + switch (fourcc) { + case DRM_FORMAT_XRGB1555: + ctrl |= JZ_LCD_OSDCTRL_RGB555; +@@ -504,7 +503,7 @@ void ingenic_drm_plane_config(struct device *dev, + } + + if (priv->soc_info->has_osd) { +- if (plane->type == DRM_PLANE_TYPE_PRIMARY) { ++ if (plane != &priv->f0) { + xy_reg = JZ_REG_LCD_XYP1; + size_reg = JZ_REG_LCD_SIZE1; + } else { +@@ -554,7 +553,7 @@ static void ingenic_drm_plane_atomic_update(struct drm_plane *plane, + height = state->src_h >> 16; + cpp = state->fb->format->cpp[0]; + +- if (!priv->soc_info->has_osd || plane->type == DRM_PLANE_TYPE_OVERLAY) ++ if (!priv->soc_info->has_osd || plane == &priv->f0) + hwdesc = &priv->dma_hwdescs->hwdesc_f0; + else + hwdesc = &priv->dma_hwdescs->hwdesc_f1; +diff --git a/drivers/gpu/drm/ingenic/ingenic-ipu.c b/drivers/gpu/drm/ingenic/ingenic-ipu.c +index e52777ef85fd7..1cab0a743e987 100644 +--- a/drivers/gpu/drm/ingenic/ingenic-ipu.c ++++ b/drivers/gpu/drm/ingenic/ingenic-ipu.c +@@ -760,7 +760,7 @@ static int ingenic_ipu_bind(struct device *dev, struct device *master, void *d) + + err = drm_universal_plane_init(drm, plane, 1, &ingenic_ipu_plane_funcs, + soc_info->formats, soc_info->num_formats, +- NULL, DRM_PLANE_TYPE_PRIMARY, NULL); ++ NULL, DRM_PLANE_TYPE_OVERLAY, NULL); + if (err) { + dev_err(dev, "Failed to init plane: %i\n", err); + return err; +diff --git a/drivers/gpu/drm/mediatek/mtk_drm_crtc.c b/drivers/gpu/drm/mediatek/mtk_drm_crtc.c +index 8b0de90156c6c..69d23ce56d2c6 100644 +--- a/drivers/gpu/drm/mediatek/mtk_drm_crtc.c ++++ b/drivers/gpu/drm/mediatek/mtk_drm_crtc.c +@@ -259,7 +259,7 @@ static int mtk_crtc_ddp_hw_init(struct mtk_drm_crtc *mtk_crtc) + drm_connector_list_iter_end(&conn_iter); + } + +- ret = pm_runtime_get_sync(crtc->dev->dev); ++ ret = pm_runtime_resume_and_get(crtc->dev->dev); + if (ret < 0) { + DRM_ERROR("Failed to enable power domain: %d\n", ret); + return ret; +diff --git a/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c b/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c +index 3d729270bde15..4a5b518288b06 100644 +--- a/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c ++++ b/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c +@@ -88,8 +88,6 @@ static int mdp4_hw_init(struct msm_kms *kms) + if (mdp4_kms->rev > 1) + mdp4_write(mdp4_kms, REG_MDP4_RESET_STATUS, 1); + +- dev->mode_config.allow_fb_modifiers = true; +- + out: + pm_runtime_put_sync(dev->dev); + +diff --git a/drivers/gpu/drm/msm/disp/mdp4/mdp4_plane.c b/drivers/gpu/drm/msm/disp/mdp4/mdp4_plane.c +index da3cc1d8c3312..ee1dbb2b84af4 100644 +--- a/drivers/gpu/drm/msm/disp/mdp4/mdp4_plane.c ++++ b/drivers/gpu/drm/msm/disp/mdp4/mdp4_plane.c +@@ -347,6 +347,12 @@ enum mdp4_pipe mdp4_plane_pipe(struct drm_plane *plane) + return mdp4_plane->pipe; + } + ++static const uint64_t supported_format_modifiers[] = { ++ DRM_FORMAT_MOD_SAMSUNG_64_32_TILE, ++ DRM_FORMAT_MOD_LINEAR, ++ DRM_FORMAT_MOD_INVALID ++}; ++ + /* initialize plane */ + struct drm_plane *mdp4_plane_init(struct drm_device *dev, + enum mdp4_pipe pipe_id, bool private_plane) +@@ -375,7 +381,7 @@ struct drm_plane *mdp4_plane_init(struct drm_device *dev, + type = private_plane ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY; + ret = drm_universal_plane_init(dev, plane, 0xff, &mdp4_plane_funcs, + mdp4_plane->formats, mdp4_plane->nformats, +- NULL, type, NULL); ++ supported_format_modifiers, type, NULL); + if (ret) + goto fail; + +diff --git a/drivers/gpu/drm/mxsfb/Kconfig b/drivers/gpu/drm/mxsfb/Kconfig +index 0143d539f8f82..ee22cd25d3e3d 100644 +--- a/drivers/gpu/drm/mxsfb/Kconfig ++++ b/drivers/gpu/drm/mxsfb/Kconfig +@@ -10,7 +10,6 @@ config DRM_MXSFB + depends on COMMON_CLK + select DRM_MXS + select DRM_KMS_HELPER +- select DRM_KMS_FB_HELPER + select DRM_KMS_CMA_HELPER + select DRM_PANEL + select DRM_PANEL_BRIDGE +diff --git a/drivers/gpu/drm/nouveau/nouveau_display.c b/drivers/gpu/drm/nouveau/nouveau_display.c +index 17831ee897ea4..1376992482b55 100644 +--- a/drivers/gpu/drm/nouveau/nouveau_display.c ++++ b/drivers/gpu/drm/nouveau/nouveau_display.c +@@ -700,7 +700,6 @@ nouveau_display_create(struct drm_device *dev) + + dev->mode_config.preferred_depth = 24; + dev->mode_config.prefer_shadow = 1; +- dev->mode_config.allow_fb_modifiers = true; + + if (drm->client.device.info.chipset < 0x11) + dev->mode_config.async_page_flip = false; +diff --git a/drivers/gpu/drm/radeon/radeon_display.c b/drivers/gpu/drm/radeon/radeon_display.c +index 652af7a134bd0..1d03ec7636047 100644 +--- a/drivers/gpu/drm/radeon/radeon_display.c ++++ b/drivers/gpu/drm/radeon/radeon_display.c +@@ -1325,6 +1325,7 @@ radeon_user_framebuffer_create(struct drm_device *dev, + /* Handle is imported dma-buf, so cannot be migrated to VRAM for scanout */ + if (obj->import_attach) { + DRM_DEBUG_KMS("Cannot create framebuffer from imported dma_buf\n"); ++ drm_gem_object_put(obj); + return ERR_PTR(-EINVAL); + } + +diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c +index efeb115ae70ec..40aece37e0b4e 100644 +--- a/drivers/gpu/drm/radeon/radeon_drv.c ++++ b/drivers/gpu/drm/radeon/radeon_drv.c +@@ -386,13 +386,13 @@ radeon_pci_shutdown(struct pci_dev *pdev) + if (radeon_device_is_virtual()) + radeon_pci_remove(pdev); + +-#ifdef CONFIG_PPC64 ++#if defined(CONFIG_PPC64) || defined(CONFIG_MACH_LOONGSON64) + /* + * Some adapters need to be suspended before a + * shutdown occurs in order to prevent an error +- * during kexec. +- * Make this power specific becauase it breaks +- * some non-power boards. ++ * during kexec, shutdown or reboot. ++ * Make this power and Loongson specific because ++ * it breaks some other boards. + */ + radeon_suspend_kms(pci_get_drvdata(pdev), true, true, false); + #endif +diff --git a/drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c b/drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c +index d8c47ee3cad37..520a0a0cd2b56 100644 +--- a/drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c ++++ b/drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c +@@ -243,7 +243,6 @@ struct dw_mipi_dsi_rockchip { + struct dw_mipi_dsi *dmd; + const struct rockchip_dw_dsi_chip_data *cdata; + struct dw_mipi_dsi_plat_data pdata; +- int devcnt; + }; + + struct dphy_pll_parameter_map { +@@ -1141,9 +1140,6 @@ static int dw_mipi_dsi_rockchip_remove(struct platform_device *pdev) + { + struct dw_mipi_dsi_rockchip *dsi = platform_get_drvdata(pdev); + +- if (dsi->devcnt == 0) +- component_del(dsi->dev, &dw_mipi_dsi_rockchip_ops); +- + dw_mipi_dsi_remove(dsi->dmd); + + return 0; +diff --git a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c +index 80053d91a301f..a6fe03c3748aa 100644 +--- a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c ++++ b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c +@@ -349,8 +349,8 @@ static const struct vop_win_phy rk3066_win0_data = { + .nformats = ARRAY_SIZE(formats_win_full), + .format_modifiers = format_modifiers_win_full, + .enable = VOP_REG(RK3066_SYS_CTRL1, 0x1, 0), +- .format = VOP_REG(RK3066_SYS_CTRL0, 0x7, 4), +- .rb_swap = VOP_REG(RK3066_SYS_CTRL0, 0x1, 19), ++ .format = VOP_REG(RK3066_SYS_CTRL1, 0x7, 4), ++ .rb_swap = VOP_REG(RK3066_SYS_CTRL1, 0x1, 19), + .act_info = VOP_REG(RK3066_WIN0_ACT_INFO, 0x1fff1fff, 0), + .dsp_info = VOP_REG(RK3066_WIN0_DSP_INFO, 0x0fff0fff, 0), + .dsp_st = VOP_REG(RK3066_WIN0_DSP_ST, 0x1fff1fff, 0), +@@ -361,13 +361,12 @@ static const struct vop_win_phy rk3066_win0_data = { + }; + + static const struct vop_win_phy rk3066_win1_data = { +- .scl = &rk3066_win_scl, + .data_formats = formats_win_full, + .nformats = ARRAY_SIZE(formats_win_full), + .format_modifiers = format_modifiers_win_full, + .enable = VOP_REG(RK3066_SYS_CTRL1, 0x1, 1), +- .format = VOP_REG(RK3066_SYS_CTRL0, 0x7, 7), +- .rb_swap = VOP_REG(RK3066_SYS_CTRL0, 0x1, 23), ++ .format = VOP_REG(RK3066_SYS_CTRL1, 0x7, 7), ++ .rb_swap = VOP_REG(RK3066_SYS_CTRL1, 0x1, 23), + .act_info = VOP_REG(RK3066_WIN1_ACT_INFO, 0x1fff1fff, 0), + .dsp_info = VOP_REG(RK3066_WIN1_DSP_INFO, 0x0fff0fff, 0), + .dsp_st = VOP_REG(RK3066_WIN1_DSP_ST, 0x1fff1fff, 0), +@@ -382,8 +381,8 @@ static const struct vop_win_phy rk3066_win2_data = { + .nformats = ARRAY_SIZE(formats_win_lite), + .format_modifiers = format_modifiers_win_lite, + .enable = VOP_REG(RK3066_SYS_CTRL1, 0x1, 2), +- .format = VOP_REG(RK3066_SYS_CTRL0, 0x7, 10), +- .rb_swap = VOP_REG(RK3066_SYS_CTRL0, 0x1, 27), ++ .format = VOP_REG(RK3066_SYS_CTRL1, 0x7, 10), ++ .rb_swap = VOP_REG(RK3066_SYS_CTRL1, 0x1, 27), + .dsp_info = VOP_REG(RK3066_WIN2_DSP_INFO, 0x0fff0fff, 0), + .dsp_st = VOP_REG(RK3066_WIN2_DSP_ST, 0x1fff1fff, 0), + .yrgb_mst = VOP_REG(RK3066_WIN2_MST, 0xffffffff, 0), +@@ -408,6 +407,9 @@ static const struct vop_common rk3066_common = { + .dither_down_en = VOP_REG(RK3066_DSP_CTRL0, 0x1, 11), + .dither_down_mode = VOP_REG(RK3066_DSP_CTRL0, 0x1, 10), + .dsp_blank = VOP_REG(RK3066_DSP_CTRL1, 0x1, 24), ++ .dither_up = VOP_REG(RK3066_DSP_CTRL0, 0x1, 9), ++ .dsp_lut_en = VOP_REG(RK3066_SYS_CTRL1, 0x1, 31), ++ .data_blank = VOP_REG(RK3066_DSP_CTRL1, 0x1, 25), + }; + + static const struct vop_win_data rk3066_vop_win_data[] = { +@@ -505,7 +507,10 @@ static const struct vop_common rk3188_common = { + .dither_down_sel = VOP_REG(RK3188_DSP_CTRL0, 0x1, 27), + .dither_down_en = VOP_REG(RK3188_DSP_CTRL0, 0x1, 11), + .dither_down_mode = VOP_REG(RK3188_DSP_CTRL0, 0x1, 10), +- .dsp_blank = VOP_REG(RK3188_DSP_CTRL1, 0x3, 24), ++ .dsp_blank = VOP_REG(RK3188_DSP_CTRL1, 0x1, 24), ++ .dither_up = VOP_REG(RK3188_DSP_CTRL0, 0x1, 9), ++ .dsp_lut_en = VOP_REG(RK3188_SYS_CTRL, 0x1, 28), ++ .data_blank = VOP_REG(RK3188_DSP_CTRL1, 0x1, 25), + }; + + static const struct vop_win_data rk3188_vop_win_data[] = { +diff --git a/drivers/gpu/drm/scheduler/sched_entity.c b/drivers/gpu/drm/scheduler/sched_entity.c +index c1ac3e4003c6f..1b2fdf7f3ccd8 100644 +--- a/drivers/gpu/drm/scheduler/sched_entity.c ++++ b/drivers/gpu/drm/scheduler/sched_entity.c +@@ -116,7 +116,8 @@ static bool drm_sched_entity_is_idle(struct drm_sched_entity *entity) + rmb(); /* for list_empty to work without lock */ + + if (list_empty(&entity->list) || +- spsc_queue_count(&entity->job_queue) == 0) ++ spsc_queue_count(&entity->job_queue) == 0 || ++ entity->stopped) + return true; + + return false; +@@ -221,11 +222,16 @@ static void drm_sched_entity_kill_jobs_cb(struct dma_fence *f, + static void drm_sched_entity_kill_jobs(struct drm_sched_entity *entity) + { + struct drm_sched_job *job; ++ struct dma_fence *f; + int r; + + while ((job = to_drm_sched_job(spsc_queue_pop(&entity->job_queue)))) { + struct drm_sched_fence *s_fence = job->s_fence; + ++ /* Wait for all dependencies to avoid data corruptions */ ++ while ((f = job->sched->ops->dependency(job, entity))) ++ dma_fence_wait(f, false); ++ + drm_sched_fence_scheduled(s_fence); + dma_fence_set_error(&s_fence->finished, -ESRCH); + +diff --git a/drivers/gpu/drm/scheduler/sched_main.c b/drivers/gpu/drm/scheduler/sched_main.c +index 92637b70c9bf6..16244e9669b90 100644 +--- a/drivers/gpu/drm/scheduler/sched_main.c ++++ b/drivers/gpu/drm/scheduler/sched_main.c +@@ -896,9 +896,33 @@ EXPORT_SYMBOL(drm_sched_init); + */ + void drm_sched_fini(struct drm_gpu_scheduler *sched) + { ++ struct drm_sched_entity *s_entity; ++ int i; ++ + if (sched->thread) + kthread_stop(sched->thread); + ++ for (i = DRM_SCHED_PRIORITY_COUNT - 1; i >= DRM_SCHED_PRIORITY_MIN; i--) { ++ struct drm_sched_rq *rq = &sched->sched_rq[i]; ++ ++ if (!rq) ++ continue; ++ ++ spin_lock(&rq->lock); ++ list_for_each_entry(s_entity, &rq->entities, list) ++ /* ++ * Prevents reinsertion and marks job_queue as idle, ++ * it will removed from rq in drm_sched_entity_fini ++ * eventually ++ */ ++ s_entity->stopped = true; ++ spin_unlock(&rq->lock); ++ ++ } ++ ++ /* Wakeup everyone stuck in drm_sched_entity_flush for this scheduler */ ++ wake_up_all(&sched->job_scheduled); ++ + /* Confirm no work left behind accessing device structures */ + cancel_delayed_work_sync(&sched->work_tdr); + +diff --git a/drivers/gpu/drm/tegra/dc.c b/drivers/gpu/drm/tegra/dc.c +index 134986dc2783f..2c0510bbd0fbd 100644 +--- a/drivers/gpu/drm/tegra/dc.c ++++ b/drivers/gpu/drm/tegra/dc.c +@@ -947,6 +947,11 @@ static const struct drm_plane_helper_funcs tegra_cursor_plane_helper_funcs = { + .atomic_disable = tegra_cursor_atomic_disable, + }; + ++static const uint64_t linear_modifiers[] = { ++ DRM_FORMAT_MOD_LINEAR, ++ DRM_FORMAT_MOD_INVALID ++}; ++ + static struct drm_plane *tegra_dc_cursor_plane_create(struct drm_device *drm, + struct tegra_dc *dc) + { +@@ -975,7 +980,7 @@ static struct drm_plane *tegra_dc_cursor_plane_create(struct drm_device *drm, + + err = drm_universal_plane_init(drm, &plane->base, possible_crtcs, + &tegra_plane_funcs, formats, +- num_formats, NULL, ++ num_formats, linear_modifiers, + DRM_PLANE_TYPE_CURSOR, NULL); + if (err < 0) { + kfree(plane); +@@ -1094,7 +1099,8 @@ static struct drm_plane *tegra_dc_overlay_plane_create(struct drm_device *drm, + + err = drm_universal_plane_init(drm, &plane->base, possible_crtcs, + &tegra_plane_funcs, formats, +- num_formats, NULL, type, NULL); ++ num_formats, linear_modifiers, ++ type, NULL); + if (err < 0) { + kfree(plane); + return ERR_PTR(err); +diff --git a/drivers/gpu/drm/tegra/drm.c b/drivers/gpu/drm/tegra/drm.c +index e9ce7d6992d21..e3d4fd76b6a0b 100644 +--- a/drivers/gpu/drm/tegra/drm.c ++++ b/drivers/gpu/drm/tegra/drm.c +@@ -1122,8 +1122,6 @@ static int host1x_drm_probe(struct host1x_device *dev) + drm->mode_config.max_width = 4096; + drm->mode_config.max_height = 4096; + +- drm->mode_config.allow_fb_modifiers = true; +- + drm->mode_config.normalize_zpos = true; + + drm->mode_config.funcs = &tegra_drm_mode_config_funcs; +diff --git a/drivers/gpu/drm/vc4/vc4_crtc.c b/drivers/gpu/drm/vc4/vc4_crtc.c +index 1f36b67cd6ce9..18f5009ce90e3 100644 +--- a/drivers/gpu/drm/vc4/vc4_crtc.c ++++ b/drivers/gpu/drm/vc4/vc4_crtc.c +@@ -1035,7 +1035,7 @@ static const struct vc4_pv_data bcm2711_pv3_data = { + .fifo_depth = 64, + .pixels_per_clock = 1, + .encoder_types = { +- [0] = VC4_ENCODER_TYPE_VEC, ++ [PV_CONTROL_CLK_SELECT_VEC] = VC4_ENCODER_TYPE_VEC, + }, + }; + +@@ -1076,6 +1076,9 @@ static void vc4_set_crtc_possible_masks(struct drm_device *drm, + struct vc4_encoder *vc4_encoder; + int i; + ++ if (encoder->encoder_type == DRM_MODE_ENCODER_VIRTUAL) ++ continue; ++ + vc4_encoder = to_vc4_encoder(encoder); + for (i = 0; i < ARRAY_SIZE(pv_data->encoder_types); i++) { + if (vc4_encoder->type == encoder_types[i]) { +diff --git a/drivers/gpu/drm/vc4/vc4_drv.h b/drivers/gpu/drm/vc4/vc4_drv.h +index a7500716cf3f1..5dceadc61600e 100644 +--- a/drivers/gpu/drm/vc4/vc4_drv.h ++++ b/drivers/gpu/drm/vc4/vc4_drv.h +@@ -825,7 +825,7 @@ void vc4_crtc_destroy_state(struct drm_crtc *crtc, + void vc4_crtc_reset(struct drm_crtc *crtc); + void vc4_crtc_handle_vblank(struct vc4_crtc *crtc); + void vc4_crtc_get_margins(struct drm_crtc_state *state, +- unsigned int *right, unsigned int *left, ++ unsigned int *left, unsigned int *right, + unsigned int *top, unsigned int *bottom); + + /* vc4_debugfs.c */ +diff --git a/drivers/gpu/drm/vc4/vc4_hdmi.c b/drivers/gpu/drm/vc4/vc4_hdmi.c +index e94730beb15b7..188b74c9e9fff 100644 +--- a/drivers/gpu/drm/vc4/vc4_hdmi.c ++++ b/drivers/gpu/drm/vc4/vc4_hdmi.c +@@ -745,7 +745,7 @@ static void vc4_hdmi_encoder_pre_crtc_configure(struct drm_encoder *encoder, + unsigned long pixel_rate, hsm_rate; + int ret; + +- ret = pm_runtime_get_sync(&vc4_hdmi->pdev->dev); ++ ret = pm_runtime_resume_and_get(&vc4_hdmi->pdev->dev); + if (ret < 0) { + DRM_ERROR("Failed to retain power domain: %d\n", ret); + return; +@@ -2012,6 +2012,14 @@ static int vc4_hdmi_bind(struct device *dev, struct device *master, void *data) + if (vc4_hdmi->variant->reset) + vc4_hdmi->variant->reset(vc4_hdmi); + ++ if ((of_device_is_compatible(dev->of_node, "brcm,bcm2711-hdmi0") || ++ of_device_is_compatible(dev->of_node, "brcm,bcm2711-hdmi1")) && ++ HDMI_READ(HDMI_VID_CTL) & VC4_HD_VID_CTL_ENABLE) { ++ clk_prepare_enable(vc4_hdmi->pixel_clock); ++ clk_prepare_enable(vc4_hdmi->hsm_clock); ++ clk_prepare_enable(vc4_hdmi->pixel_bvb_clock); ++ } ++ + pm_runtime_enable(dev); + + drm_simple_encoder_init(drm, encoder, DRM_MODE_ENCODER_TMDS); +diff --git a/drivers/gpu/drm/vc4/vc4_txp.c b/drivers/gpu/drm/vc4/vc4_txp.c +index c0122d83b6511..2fc7f4b5fa098 100644 +--- a/drivers/gpu/drm/vc4/vc4_txp.c ++++ b/drivers/gpu/drm/vc4/vc4_txp.c +@@ -507,7 +507,7 @@ static int vc4_txp_bind(struct device *dev, struct device *master, void *data) + return ret; + + encoder = &txp->connector.encoder; +- encoder->possible_crtcs |= drm_crtc_mask(crtc); ++ encoder->possible_crtcs = drm_crtc_mask(crtc); + + ret = devm_request_irq(dev, irq, vc4_txp_interrupt, 0, + dev_name(dev), txp); +diff --git a/drivers/gpu/drm/virtio/virtgpu_kms.c b/drivers/gpu/drm/virtio/virtgpu_kms.c +index b375394193be8..37a21a88d674c 100644 +--- a/drivers/gpu/drm/virtio/virtgpu_kms.c ++++ b/drivers/gpu/drm/virtio/virtgpu_kms.c +@@ -234,6 +234,7 @@ err_scanouts: + err_vbufs: + vgdev->vdev->config->del_vqs(vgdev->vdev); + err_vqs: ++ dev->dev_private = NULL; + kfree(vgdev); + return ret; + } +diff --git a/drivers/gpu/drm/zte/Kconfig b/drivers/gpu/drm/zte/Kconfig +index 90ebaedc11fdf..aa8594190b509 100644 +--- a/drivers/gpu/drm/zte/Kconfig ++++ b/drivers/gpu/drm/zte/Kconfig +@@ -3,7 +3,6 @@ config DRM_ZTE + tristate "DRM Support for ZTE SoCs" + depends on DRM && ARCH_ZX + select DRM_KMS_CMA_HELPER +- select DRM_KMS_FB_HELPER + select DRM_KMS_HELPER + select SND_SOC_HDMI_CODEC if SND_SOC + select VIDEOMODE_HELPERS +diff --git a/drivers/hwtracing/coresight/coresight-core.c b/drivers/hwtracing/coresight/coresight-core.c +index 237a8c0d6c244..30271d9e470de 100644 +--- a/drivers/hwtracing/coresight/coresight-core.c ++++ b/drivers/hwtracing/coresight/coresight-core.c +@@ -1367,7 +1367,7 @@ static int coresight_fixup_device_conns(struct coresight_device *csdev) + } + } + +- return 0; ++ return ret; + } + + static int coresight_remove_match(struct device *dev, void *data) +diff --git a/drivers/hwtracing/coresight/coresight-tmc-etf.c b/drivers/hwtracing/coresight/coresight-tmc-etf.c +index 45b85edfc6900..cd0fb7bfba684 100644 +--- a/drivers/hwtracing/coresight/coresight-tmc-etf.c ++++ b/drivers/hwtracing/coresight/coresight-tmc-etf.c +@@ -530,7 +530,7 @@ static unsigned long tmc_update_etf_buffer(struct coresight_device *csdev, + buf_ptr = buf->data_pages[cur] + offset; + *buf_ptr = readl_relaxed(drvdata->base + TMC_RRD); + +- if (lost && *barrier) { ++ if (lost && i < CORESIGHT_BARRIER_PKT_SIZE) { + *buf_ptr = *barrier; + barrier++; + } +diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c +index bb46f794f3240..8d94a6bfcac12 100644 +--- a/drivers/infiniband/core/cma.c ++++ b/drivers/infiniband/core/cma.c +@@ -2793,7 +2793,8 @@ static int cma_resolve_ib_route(struct rdma_id_private *id_priv, + + cma_init_resolve_route_work(work, id_priv); + +- route->path_rec = kmalloc(sizeof *route->path_rec, GFP_KERNEL); ++ if (!route->path_rec) ++ route->path_rec = kmalloc(sizeof *route->path_rec, GFP_KERNEL); + if (!route->path_rec) { + ret = -ENOMEM; + goto err1; +diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c +index d109bb3822a5f..c9403743346e1 100644 +--- a/drivers/infiniband/hw/cxgb4/qp.c ++++ b/drivers/infiniband/hw/cxgb4/qp.c +@@ -295,6 +295,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq, + if (user && (!wq->sq.bar2_pa || (need_rq && !wq->rq.bar2_pa))) { + pr_warn("%s: sqid %u or rqid %u not in BAR2 range\n", + pci_name(rdev->lldi.pdev), wq->sq.qid, wq->rq.qid); ++ ret = -EINVAL; + goto free_dma; + } + +diff --git a/drivers/infiniband/sw/rxe/rxe_mr.c b/drivers/infiniband/sw/rxe/rxe_mr.c +index 9f63947bab123..fe2b7d223183f 100644 +--- a/drivers/infiniband/sw/rxe/rxe_mr.c ++++ b/drivers/infiniband/sw/rxe/rxe_mr.c +@@ -135,7 +135,7 @@ int rxe_mr_init_user(struct rxe_pd *pd, u64 start, u64 length, u64 iova, + if (IS_ERR(umem)) { + pr_warn("err %d from rxe_umem_get\n", + (int)PTR_ERR(umem)); +- err = -EINVAL; ++ err = PTR_ERR(umem); + goto err1; + } + +diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c +index 18266f07c58d9..de3fc05fd2e8a 100644 +--- a/drivers/infiniband/ulp/isert/ib_isert.c ++++ b/drivers/infiniband/ulp/isert/ib_isert.c +@@ -35,10 +35,10 @@ static const struct kernel_param_ops sg_tablesize_ops = { + .get = param_get_int, + }; + +-static int isert_sg_tablesize = ISCSI_ISER_DEF_SG_TABLESIZE; ++static int isert_sg_tablesize = ISCSI_ISER_MIN_SG_TABLESIZE; + module_param_cb(sg_tablesize, &sg_tablesize_ops, &isert_sg_tablesize, 0644); + MODULE_PARM_DESC(sg_tablesize, +- "Number of gather/scatter entries in a single scsi command, should >= 128 (default: 256, max: 4096)"); ++ "Number of gather/scatter entries in a single scsi command, should >= 128 (default: 128, max: 4096)"); + + static DEFINE_MUTEX(device_list_mutex); + static LIST_HEAD(device_list); +diff --git a/drivers/infiniband/ulp/isert/ib_isert.h b/drivers/infiniband/ulp/isert/ib_isert.h +index 6c5af13db4e0d..ca8cfebe26ca7 100644 +--- a/drivers/infiniband/ulp/isert/ib_isert.h ++++ b/drivers/infiniband/ulp/isert/ib_isert.h +@@ -65,9 +65,6 @@ + */ + #define ISER_RX_SIZE (ISCSI_DEF_MAX_RECV_SEG_LEN + 1024) + +-/* Default I/O size is 1MB */ +-#define ISCSI_ISER_DEF_SG_TABLESIZE 256 +- + /* Minimum I/O size is 512KB */ + #define ISCSI_ISER_MIN_SG_TABLESIZE 128 + +diff --git a/drivers/infiniband/ulp/rtrs/rtrs-pri.h b/drivers/infiniband/ulp/rtrs/rtrs-pri.h +index 8caad0a2322bf..51c60f5428761 100644 +--- a/drivers/infiniband/ulp/rtrs/rtrs-pri.h ++++ b/drivers/infiniband/ulp/rtrs/rtrs-pri.h +@@ -47,12 +47,15 @@ enum { + MAX_PATHS_NUM = 128, + + /* +- * With the size of struct rtrs_permit allocated on the client, 4K +- * is the maximum number of rtrs_permits we can allocate. This number is +- * also used on the client to allocate the IU for the user connection +- * to receive the RDMA addresses from the server. ++ * Max IB immediate data size is 2^28 (MAX_IMM_PAYL_BITS) ++ * and the minimum chunk size is 4096 (2^12). ++ * So the maximum sess_queue_depth is 65536 (2^16) in theory. ++ * But mempool_create, create_qp and ib_post_send fail with ++ * "cannot allocate memory" error if sess_queue_depth is too big. ++ * Therefore the pratical max value of sess_queue_depth is ++ * somewhere between 1 and 65536 and it depends on the system. + */ +- MAX_SESS_QUEUE_DEPTH = 4096, ++ MAX_SESS_QUEUE_DEPTH = 65536, + + RTRS_HB_INTERVAL_MS = 5000, + RTRS_HB_MISSED_MAX = 5, +diff --git a/drivers/ipack/carriers/tpci200.c b/drivers/ipack/carriers/tpci200.c +index ec71063fff76a..e1822e87ec3d2 100644 +--- a/drivers/ipack/carriers/tpci200.c ++++ b/drivers/ipack/carriers/tpci200.c +@@ -596,8 +596,11 @@ static int tpci200_pci_probe(struct pci_dev *pdev, + + out_err_bus_register: + tpci200_uninstall(tpci200); ++ /* tpci200->info->cfg_regs is unmapped in tpci200_uninstall */ ++ tpci200->info->cfg_regs = NULL; + out_err_install: +- iounmap(tpci200->info->cfg_regs); ++ if (tpci200->info->cfg_regs) ++ iounmap(tpci200->info->cfg_regs); + out_err_ioremap: + pci_release_region(pdev, TPCI200_CFG_MEM_BAR); + out_err_pci_request: +diff --git a/drivers/isdn/hardware/mISDN/hfcpci.c b/drivers/isdn/hardware/mISDN/hfcpci.c +index 56bd2e9db6ed6..e501cb03f211d 100644 +--- a/drivers/isdn/hardware/mISDN/hfcpci.c ++++ b/drivers/isdn/hardware/mISDN/hfcpci.c +@@ -2342,7 +2342,7 @@ static void __exit + HFC_cleanup(void) + { + if (timer_pending(&hfc_tl)) +- del_timer(&hfc_tl); ++ del_timer_sync(&hfc_tl); + + pci_unregister_driver(&hfc_driver); + } +diff --git a/drivers/md/dm-writecache.c b/drivers/md/dm-writecache.c +index 4f72b6f66c3ae..9e9f1ee141652 100644 +--- a/drivers/md/dm-writecache.c ++++ b/drivers/md/dm-writecache.c +@@ -532,7 +532,7 @@ static void ssd_commit_superblock(struct dm_writecache *wc) + + region.bdev = wc->ssd_dev->bdev; + region.sector = 0; +- region.count = PAGE_SIZE >> SECTOR_SHIFT; ++ region.count = max(4096U, wc->block_size) >> SECTOR_SHIFT; + + if (unlikely(region.sector + region.count > wc->metadata_sectors)) + region.count = wc->metadata_sectors - region.sector; +@@ -1301,8 +1301,12 @@ static int writecache_map(struct dm_target *ti, struct bio *bio) + writecache_flush(wc); + if (writecache_has_error(wc)) + goto unlock_error; ++ if (unlikely(wc->cleaner)) ++ goto unlock_remap_origin; + goto unlock_submit; + } else { ++ if (dm_bio_get_target_bio_nr(bio)) ++ goto unlock_remap_origin; + writecache_offload_bio(wc, bio); + goto unlock_return; + } +@@ -1360,14 +1364,18 @@ read_next_block: + } else { + do { + bool found_entry = false; ++ bool search_used = false; + if (writecache_has_error(wc)) + goto unlock_error; + e = writecache_find_entry(wc, bio->bi_iter.bi_sector, 0); + if (e) { +- if (!writecache_entry_is_committed(wc, e)) ++ if (!writecache_entry_is_committed(wc, e)) { ++ search_used = true; + goto bio_copy; ++ } + if (!WC_MODE_PMEM(wc) && !e->write_in_progress) { + wc->overwrote_committed = true; ++ search_used = true; + goto bio_copy; + } + found_entry = true; +@@ -1377,7 +1385,7 @@ read_next_block: + } + e = writecache_pop_from_freelist(wc, (sector_t)-1); + if (unlikely(!e)) { +- if (!found_entry) { ++ if (!WC_MODE_PMEM(wc) && !found_entry) { + direct_write: + e = writecache_find_entry(wc, bio->bi_iter.bi_sector, WFE_RETURN_FOLLOWING); + if (e) { +@@ -1404,13 +1412,31 @@ bio_copy: + sector_t current_cache_sec = start_cache_sec + (bio_size >> SECTOR_SHIFT); + + while (bio_size < bio->bi_iter.bi_size) { +- struct wc_entry *f = writecache_pop_from_freelist(wc, current_cache_sec); +- if (!f) +- break; +- write_original_sector_seq_count(wc, f, bio->bi_iter.bi_sector + +- (bio_size >> SECTOR_SHIFT), wc->seq_count); +- writecache_insert_entry(wc, f); +- wc->uncommitted_blocks++; ++ if (!search_used) { ++ struct wc_entry *f = writecache_pop_from_freelist(wc, current_cache_sec); ++ if (!f) ++ break; ++ write_original_sector_seq_count(wc, f, bio->bi_iter.bi_sector + ++ (bio_size >> SECTOR_SHIFT), wc->seq_count); ++ writecache_insert_entry(wc, f); ++ wc->uncommitted_blocks++; ++ } else { ++ struct wc_entry *f; ++ struct rb_node *next = rb_next(&e->rb_node); ++ if (!next) ++ break; ++ f = container_of(next, struct wc_entry, rb_node); ++ if (f != e + 1) ++ break; ++ if (read_original_sector(wc, f) != ++ read_original_sector(wc, e) + (wc->block_size >> SECTOR_SHIFT)) ++ break; ++ if (unlikely(f->write_in_progress)) ++ break; ++ if (writecache_entry_is_committed(wc, f)) ++ wc->overwrote_committed = true; ++ e = f; ++ } + bio_size += wc->block_size; + current_cache_sec += wc->block_size >> SECTOR_SHIFT; + } +@@ -2463,7 +2489,7 @@ overflow: + goto bad; + } + +- ti->num_flush_bios = 1; ++ ti->num_flush_bios = WC_MODE_PMEM(wc) ? 1 : 2; + ti->flush_supported = true; + ti->num_discard_bios = 1; + +diff --git a/drivers/md/dm-zoned-metadata.c b/drivers/md/dm-zoned-metadata.c +index 039d17b289384..ee4626d085574 100644 +--- a/drivers/md/dm-zoned-metadata.c ++++ b/drivers/md/dm-zoned-metadata.c +@@ -1390,6 +1390,13 @@ static int dmz_init_zone(struct blk_zone *blkz, unsigned int num, void *data) + return -ENXIO; + } + ++ /* ++ * Devices that have zones with a capacity smaller than the zone size ++ * (e.g. NVMe zoned namespaces) are not supported. ++ */ ++ if (blkz->capacity != blkz->len) ++ return -ENXIO; ++ + switch (blkz->type) { + case BLK_ZONE_TYPE_CONVENTIONAL: + set_bit(DMZ_RND, &zone->flags); +diff --git a/drivers/md/dm.c b/drivers/md/dm.c +index 3f3be9408afa7..05747d2736a77 100644 +--- a/drivers/md/dm.c ++++ b/drivers/md/dm.c +@@ -1239,8 +1239,8 @@ static int dm_dax_zero_page_range(struct dax_device *dax_dev, pgoff_t pgoff, + + /* + * A target may call dm_accept_partial_bio only from the map routine. It is +- * allowed for all bio types except REQ_PREFLUSH, REQ_OP_ZONE_RESET, +- * REQ_OP_ZONE_OPEN, REQ_OP_ZONE_CLOSE and REQ_OP_ZONE_FINISH. ++ * allowed for all bio types except REQ_PREFLUSH, REQ_OP_ZONE_* zone management ++ * operations and REQ_OP_ZONE_APPEND (zone append writes). + * + * dm_accept_partial_bio informs the dm that the target only wants to process + * additional n_sectors sectors of the bio and the rest of the data should be +@@ -1270,9 +1270,13 @@ void dm_accept_partial_bio(struct bio *bio, unsigned n_sectors) + { + struct dm_target_io *tio = container_of(bio, struct dm_target_io, clone); + unsigned bi_size = bio->bi_iter.bi_size >> SECTOR_SHIFT; ++ + BUG_ON(bio->bi_opf & REQ_PREFLUSH); ++ BUG_ON(op_is_zone_mgmt(bio_op(bio))); ++ BUG_ON(bio_op(bio) == REQ_OP_ZONE_APPEND); + BUG_ON(bi_size > *tio->len_ptr); + BUG_ON(n_sectors > bi_size); ++ + *tio->len_ptr -= bi_size - n_sectors; + bio->bi_iter.bi_size = n_sectors << SECTOR_SHIFT; + } +diff --git a/drivers/md/persistent-data/dm-btree-remove.c b/drivers/md/persistent-data/dm-btree-remove.c +index eff04fa23dfad..9e4d1212f4c16 100644 +--- a/drivers/md/persistent-data/dm-btree-remove.c ++++ b/drivers/md/persistent-data/dm-btree-remove.c +@@ -549,7 +549,8 @@ int dm_btree_remove(struct dm_btree_info *info, dm_block_t root, + delete_at(n, index); + } + +- *new_root = shadow_root(&spine); ++ if (!r) ++ *new_root = shadow_root(&spine); + exit_shadow_spine(&spine); + + return r; +diff --git a/drivers/md/persistent-data/dm-space-map-disk.c b/drivers/md/persistent-data/dm-space-map-disk.c +index bf4c5e2ccb6ff..e0acae7a3815d 100644 +--- a/drivers/md/persistent-data/dm-space-map-disk.c ++++ b/drivers/md/persistent-data/dm-space-map-disk.c +@@ -171,6 +171,14 @@ static int sm_disk_new_block(struct dm_space_map *sm, dm_block_t *b) + * Any block we allocate has to be free in both the old and current ll. + */ + r = sm_ll_find_common_free_block(&smd->old_ll, &smd->ll, smd->begin, smd->ll.nr_blocks, b); ++ if (r == -ENOSPC) { ++ /* ++ * There's no free block between smd->begin and the end of the metadata device. ++ * We search before smd->begin in case something has been freed. ++ */ ++ r = sm_ll_find_common_free_block(&smd->old_ll, &smd->ll, 0, smd->begin, b); ++ } ++ + if (r) + return r; + +@@ -199,7 +207,6 @@ static int sm_disk_commit(struct dm_space_map *sm) + return r; + + memcpy(&smd->old_ll, &smd->ll, sizeof(smd->old_ll)); +- smd->begin = 0; + smd->nr_allocated_this_transaction = 0; + + r = sm_disk_get_nr_free(sm, &nr_free); +diff --git a/drivers/md/persistent-data/dm-space-map-metadata.c b/drivers/md/persistent-data/dm-space-map-metadata.c +index 9e3c64ec2026f..da439ac857963 100644 +--- a/drivers/md/persistent-data/dm-space-map-metadata.c ++++ b/drivers/md/persistent-data/dm-space-map-metadata.c +@@ -452,6 +452,14 @@ static int sm_metadata_new_block_(struct dm_space_map *sm, dm_block_t *b) + * Any block we allocate has to be free in both the old and current ll. + */ + r = sm_ll_find_common_free_block(&smm->old_ll, &smm->ll, smm->begin, smm->ll.nr_blocks, b); ++ if (r == -ENOSPC) { ++ /* ++ * There's no free block between smm->begin and the end of the metadata device. ++ * We search before smm->begin in case something has been freed. ++ */ ++ r = sm_ll_find_common_free_block(&smm->old_ll, &smm->ll, 0, smm->begin, b); ++ } ++ + if (r) + return r; + +@@ -503,7 +511,6 @@ static int sm_metadata_commit(struct dm_space_map *sm) + return r; + + memcpy(&smm->old_ll, &smm->ll, sizeof(smm->old_ll)); +- smm->begin = 0; + smm->allocated_this_transaction = 0; + + return 0; +diff --git a/drivers/media/i2c/ccs/ccs-core.c b/drivers/media/i2c/ccs/ccs-core.c +index fde0c51f04069..220240f62a666 100644 +--- a/drivers/media/i2c/ccs/ccs-core.c ++++ b/drivers/media/i2c/ccs/ccs-core.c +@@ -1880,21 +1880,33 @@ static int ccs_pm_get_init(struct ccs_sensor *sensor) + struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); + int rval; + ++ /* ++ * It can't use pm_runtime_resume_and_get() here, as the driver ++ * relies at the returned value to detect if the device was already ++ * active or not. ++ */ + rval = pm_runtime_get_sync(&client->dev); +- if (rval < 0) { +- pm_runtime_put_noidle(&client->dev); ++ if (rval < 0) ++ goto error; + +- return rval; +- } else if (!rval) { +- rval = v4l2_ctrl_handler_setup(&sensor->pixel_array-> +- ctrl_handler); +- if (rval) +- return rval; ++ /* Device was already active, so don't set controls */ ++ if (rval == 1) ++ return 0; + +- return v4l2_ctrl_handler_setup(&sensor->src->ctrl_handler); +- } ++ /* Restore V4L2 controls to the previously suspended device */ ++ rval = v4l2_ctrl_handler_setup(&sensor->pixel_array->ctrl_handler); ++ if (rval) ++ goto error; + ++ rval = v4l2_ctrl_handler_setup(&sensor->src->ctrl_handler); ++ if (rval) ++ goto error; ++ ++ /* Keep PM runtime usage_count incremented on success */ + return 0; ++error: ++ pm_runtime_put(&client->dev); ++ return rval; + } + + static int ccs_set_stream(struct v4l2_subdev *subdev, int enable) +diff --git a/drivers/media/i2c/ccs/ccs-limits.c b/drivers/media/i2c/ccs/ccs-limits.c +index f5511789ac837..4969fa425317d 100644 +--- a/drivers/media/i2c/ccs/ccs-limits.c ++++ b/drivers/media/i2c/ccs/ccs-limits.c +@@ -1,5 +1,9 @@ + // SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause + /* Copyright (C) 2019--2020 Intel Corporation */ ++/* ++ * Generated by Documentation/driver-api/media/drivers/ccs/mk-ccs-regs; ++ * do not modify. ++ */ + + #include "ccs-limits.h" + #include "ccs-regs.h" +diff --git a/drivers/media/i2c/ccs/ccs-limits.h b/drivers/media/i2c/ccs/ccs-limits.h +index 1efa43c23a2eb..551d3ee9d04e1 100644 +--- a/drivers/media/i2c/ccs/ccs-limits.h ++++ b/drivers/media/i2c/ccs/ccs-limits.h +@@ -1,5 +1,9 @@ + /* SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause */ + /* Copyright (C) 2019--2020 Intel Corporation */ ++/* ++ * Generated by Documentation/driver-api/media/drivers/ccs/mk-ccs-regs; ++ * do not modify. ++ */ + + #ifndef __CCS_LIMITS_H__ + #define __CCS_LIMITS_H__ +diff --git a/drivers/media/i2c/ccs/ccs-regs.h b/drivers/media/i2c/ccs/ccs-regs.h +index 4b3e5df2121f8..6ce84c5ecf207 100644 +--- a/drivers/media/i2c/ccs/ccs-regs.h ++++ b/drivers/media/i2c/ccs/ccs-regs.h +@@ -1,5 +1,9 @@ + /* SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause */ + /* Copyright (C) 2019--2020 Intel Corporation */ ++/* ++ * Generated by Documentation/driver-api/media/drivers/ccs/mk-ccs-regs; ++ * do not modify. ++ */ + + #ifndef __CCS_REGS_H__ + #define __CCS_REGS_H__ +@@ -202,7 +206,7 @@ + #define CCS_R_OP_PIX_CLK_DIV (0x0308 | CCS_FL_16BIT) + #define CCS_R_OP_SYS_CLK_DIV (0x030a | CCS_FL_16BIT) + #define CCS_R_OP_PRE_PLL_CLK_DIV (0x030c | CCS_FL_16BIT) +-#define CCS_R_OP_PLL_MULTIPLIER (0x031e | CCS_FL_16BIT) ++#define CCS_R_OP_PLL_MULTIPLIER (0x030e | CCS_FL_16BIT) + #define CCS_R_PLL_MODE 0x0310 + #define CCS_PLL_MODE_SHIFT 0U + #define CCS_PLL_MODE_MASK 0x1 +diff --git a/drivers/media/i2c/saa6588.c b/drivers/media/i2c/saa6588.c +index ecb491d5f2ab8..d1e0716bdfffd 100644 +--- a/drivers/media/i2c/saa6588.c ++++ b/drivers/media/i2c/saa6588.c +@@ -380,7 +380,7 @@ static void saa6588_configure(struct saa6588 *s) + + /* ---------------------------------------------------------------------- */ + +-static long saa6588_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg) ++static long saa6588_command(struct v4l2_subdev *sd, unsigned int cmd, void *arg) + { + struct saa6588 *s = to_saa6588(sd); + struct saa6588_command *a = arg; +@@ -433,7 +433,7 @@ static int saa6588_s_tuner(struct v4l2_subdev *sd, const struct v4l2_tuner *vt) + /* ----------------------------------------------------------------------- */ + + static const struct v4l2_subdev_core_ops saa6588_core_ops = { +- .ioctl = saa6588_ioctl, ++ .command = saa6588_command, + }; + + static const struct v4l2_subdev_tuner_ops saa6588_tuner_ops = { +diff --git a/drivers/media/pci/bt8xx/bttv-driver.c b/drivers/media/pci/bt8xx/bttv-driver.c +index 1f62a9d8ea1d3..0e9df8b35ac66 100644 +--- a/drivers/media/pci/bt8xx/bttv-driver.c ++++ b/drivers/media/pci/bt8xx/bttv-driver.c +@@ -3179,7 +3179,7 @@ static int radio_release(struct file *file) + + btv->radio_user--; + +- bttv_call_all(btv, core, ioctl, SAA6588_CMD_CLOSE, &cmd); ++ bttv_call_all(btv, core, command, SAA6588_CMD_CLOSE, &cmd); + + if (btv->radio_user == 0) + btv->has_radio_tuner = 0; +@@ -3260,7 +3260,7 @@ static ssize_t radio_read(struct file *file, char __user *data, + cmd.result = -ENODEV; + radio_enable(btv); + +- bttv_call_all(btv, core, ioctl, SAA6588_CMD_READ, &cmd); ++ bttv_call_all(btv, core, command, SAA6588_CMD_READ, &cmd); + + return cmd.result; + } +@@ -3281,7 +3281,7 @@ static __poll_t radio_poll(struct file *file, poll_table *wait) + cmd.instance = file; + cmd.event_list = wait; + cmd.poll_mask = res; +- bttv_call_all(btv, core, ioctl, SAA6588_CMD_POLL, &cmd); ++ bttv_call_all(btv, core, command, SAA6588_CMD_POLL, &cmd); + + return cmd.poll_mask; + } +diff --git a/drivers/media/pci/saa7134/saa7134-video.c b/drivers/media/pci/saa7134/saa7134-video.c +index 0f9d6b9edb90a..374c8e1087de1 100644 +--- a/drivers/media/pci/saa7134/saa7134-video.c ++++ b/drivers/media/pci/saa7134/saa7134-video.c +@@ -1181,7 +1181,7 @@ static int video_release(struct file *file) + + saa_call_all(dev, tuner, standby); + if (vdev->vfl_type == VFL_TYPE_RADIO) +- saa_call_all(dev, core, ioctl, SAA6588_CMD_CLOSE, &cmd); ++ saa_call_all(dev, core, command, SAA6588_CMD_CLOSE, &cmd); + mutex_unlock(&dev->lock); + + return 0; +@@ -1200,7 +1200,7 @@ static ssize_t radio_read(struct file *file, char __user *data, + cmd.result = -ENODEV; + + mutex_lock(&dev->lock); +- saa_call_all(dev, core, ioctl, SAA6588_CMD_READ, &cmd); ++ saa_call_all(dev, core, command, SAA6588_CMD_READ, &cmd); + mutex_unlock(&dev->lock); + + return cmd.result; +@@ -1216,7 +1216,7 @@ static __poll_t radio_poll(struct file *file, poll_table *wait) + cmd.event_list = wait; + cmd.poll_mask = 0; + mutex_lock(&dev->lock); +- saa_call_all(dev, core, ioctl, SAA6588_CMD_POLL, &cmd); ++ saa_call_all(dev, core, command, SAA6588_CMD_POLL, &cmd); + mutex_unlock(&dev->lock); + + return rc | cmd.poll_mask; +diff --git a/drivers/media/platform/davinci/vpbe_display.c b/drivers/media/platform/davinci/vpbe_display.c +index d19bad997f30c..bf3c3e76b9213 100644 +--- a/drivers/media/platform/davinci/vpbe_display.c ++++ b/drivers/media/platform/davinci/vpbe_display.c +@@ -47,7 +47,7 @@ static int venc_is_second_field(struct vpbe_display *disp_dev) + + ret = v4l2_subdev_call(vpbe_dev->venc, + core, +- ioctl, ++ command, + VENC_GET_FLD, + &val); + if (ret < 0) { +diff --git a/drivers/media/platform/davinci/vpbe_venc.c b/drivers/media/platform/davinci/vpbe_venc.c +index 8caa084e57046..bde241c26d795 100644 +--- a/drivers/media/platform/davinci/vpbe_venc.c ++++ b/drivers/media/platform/davinci/vpbe_venc.c +@@ -521,9 +521,7 @@ static int venc_s_routing(struct v4l2_subdev *sd, u32 input, u32 output, + return ret; + } + +-static long venc_ioctl(struct v4l2_subdev *sd, +- unsigned int cmd, +- void *arg) ++static long venc_command(struct v4l2_subdev *sd, unsigned int cmd, void *arg) + { + u32 val; + +@@ -542,7 +540,7 @@ static long venc_ioctl(struct v4l2_subdev *sd, + } + + static const struct v4l2_subdev_core_ops venc_core_ops = { +- .ioctl = venc_ioctl, ++ .command = venc_command, + }; + + static const struct v4l2_subdev_video_ops venc_video_ops = { +diff --git a/drivers/media/rc/bpf-lirc.c b/drivers/media/rc/bpf-lirc.c +index 3fe3edd808765..afae0afe3f810 100644 +--- a/drivers/media/rc/bpf-lirc.c ++++ b/drivers/media/rc/bpf-lirc.c +@@ -326,7 +326,8 @@ int lirc_prog_query(const union bpf_attr *attr, union bpf_attr __user *uattr) + } + + if (attr->query.prog_cnt != 0 && prog_ids && cnt) +- ret = bpf_prog_array_copy_to_user(progs, prog_ids, cnt); ++ ret = bpf_prog_array_copy_to_user(progs, prog_ids, ++ attr->query.prog_cnt); + + unlock: + mutex_unlock(&ir_raw_handler_lock); +diff --git a/drivers/media/usb/dvb-usb/dtv5100.c b/drivers/media/usb/dvb-usb/dtv5100.c +index fba06932a9e0e..1c13e493322cc 100644 +--- a/drivers/media/usb/dvb-usb/dtv5100.c ++++ b/drivers/media/usb/dvb-usb/dtv5100.c +@@ -26,6 +26,7 @@ static int dtv5100_i2c_msg(struct dvb_usb_device *d, u8 addr, + u8 *wbuf, u16 wlen, u8 *rbuf, u16 rlen) + { + struct dtv5100_state *st = d->priv; ++ unsigned int pipe; + u8 request; + u8 type; + u16 value; +@@ -34,6 +35,7 @@ static int dtv5100_i2c_msg(struct dvb_usb_device *d, u8 addr, + switch (wlen) { + case 1: + /* write { reg }, read { value } */ ++ pipe = usb_rcvctrlpipe(d->udev, 0); + request = (addr == DTV5100_DEMOD_ADDR ? DTV5100_DEMOD_READ : + DTV5100_TUNER_READ); + type = USB_TYPE_VENDOR | USB_DIR_IN; +@@ -41,6 +43,7 @@ static int dtv5100_i2c_msg(struct dvb_usb_device *d, u8 addr, + break; + case 2: + /* write { reg, value } */ ++ pipe = usb_sndctrlpipe(d->udev, 0); + request = (addr == DTV5100_DEMOD_ADDR ? DTV5100_DEMOD_WRITE : + DTV5100_TUNER_WRITE); + type = USB_TYPE_VENDOR | USB_DIR_OUT; +@@ -54,7 +57,7 @@ static int dtv5100_i2c_msg(struct dvb_usb_device *d, u8 addr, + + memcpy(st->data, rbuf, rlen); + msleep(1); /* avoid I2C errors */ +- return usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0), request, ++ return usb_control_msg(d->udev, pipe, request, + type, value, index, st->data, rlen, + DTV5100_USB_TIMEOUT); + } +@@ -141,7 +144,7 @@ static int dtv5100_probe(struct usb_interface *intf, + + /* initialize non qt1010/zl10353 part? */ + for (i = 0; dtv5100_init[i].request; i++) { +- ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), ++ ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), + dtv5100_init[i].request, + USB_TYPE_VENDOR | USB_DIR_OUT, + dtv5100_init[i].value, +diff --git a/drivers/media/usb/gspca/sq905.c b/drivers/media/usb/gspca/sq905.c +index 9491110709718..32504ebcfd4de 100644 +--- a/drivers/media/usb/gspca/sq905.c ++++ b/drivers/media/usb/gspca/sq905.c +@@ -116,7 +116,7 @@ static int sq905_command(struct gspca_dev *gspca_dev, u16 index) + } + + ret = usb_control_msg(gspca_dev->dev, +- usb_sndctrlpipe(gspca_dev->dev, 0), ++ usb_rcvctrlpipe(gspca_dev->dev, 0), + USB_REQ_SYNCH_FRAME, /* request */ + USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, + SQ905_PING, 0, gspca_dev->usb_buf, 1, +diff --git a/drivers/media/usb/gspca/sunplus.c b/drivers/media/usb/gspca/sunplus.c +index ace3da40006e7..971dee0a56dae 100644 +--- a/drivers/media/usb/gspca/sunplus.c ++++ b/drivers/media/usb/gspca/sunplus.c +@@ -242,6 +242,10 @@ static void reg_r(struct gspca_dev *gspca_dev, + gspca_err(gspca_dev, "reg_r: buffer overflow\n"); + return; + } ++ if (len == 0) { ++ gspca_err(gspca_dev, "reg_r: zero-length read\n"); ++ return; ++ } + if (gspca_dev->usb_err < 0) + return; + ret = usb_control_msg(gspca_dev->dev, +@@ -250,7 +254,7 @@ static void reg_r(struct gspca_dev *gspca_dev, + USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, + 0, /* value */ + index, +- len ? gspca_dev->usb_buf : NULL, len, ++ gspca_dev->usb_buf, len, + 500); + if (ret < 0) { + pr_err("reg_r err %d\n", ret); +@@ -727,7 +731,7 @@ static int sd_start(struct gspca_dev *gspca_dev) + case MegaImageVI: + reg_w_riv(gspca_dev, 0xf0, 0, 0); + spca504B_WaitCmdStatus(gspca_dev); +- reg_r(gspca_dev, 0xf0, 4, 0); ++ reg_w_riv(gspca_dev, 0xf0, 4, 0); + spca504B_WaitCmdStatus(gspca_dev); + break; + default: +diff --git a/drivers/media/usb/uvc/uvc_video.c b/drivers/media/usb/uvc/uvc_video.c +index f2f565281e63f..9046d8ba7c634 100644 +--- a/drivers/media/usb/uvc/uvc_video.c ++++ b/drivers/media/usb/uvc/uvc_video.c +@@ -124,10 +124,37 @@ int uvc_query_ctrl(struct uvc_device *dev, u8 query, u8 unit, + static void uvc_fixup_video_ctrl(struct uvc_streaming *stream, + struct uvc_streaming_control *ctrl) + { ++ static const struct usb_device_id elgato_cam_link_4k = { ++ USB_DEVICE(0x0fd9, 0x0066) ++ }; + struct uvc_format *format = NULL; + struct uvc_frame *frame = NULL; + unsigned int i; + ++ /* ++ * The response of the Elgato Cam Link 4K is incorrect: The second byte ++ * contains bFormatIndex (instead of being the second byte of bmHint). ++ * The first byte is always zero. The third byte is always 1. ++ * ++ * The UVC 1.5 class specification defines the first five bits in the ++ * bmHint bitfield. The remaining bits are reserved and should be zero. ++ * Therefore a valid bmHint will be less than 32. ++ * ++ * Latest Elgato Cam Link 4K firmware as of 2021-03-23 needs this fix. ++ * MCU: 20.02.19, FPGA: 67 ++ */ ++ if (usb_match_one_id(stream->dev->intf, &elgato_cam_link_4k) && ++ ctrl->bmHint > 255) { ++ u8 corrected_format_index = ctrl->bmHint >> 8; ++ ++ uvc_dbg(stream->dev, VIDEO, ++ "Correct USB video probe response from {bmHint: 0x%04x, bFormatIndex: %u} to {bmHint: 0x%04x, bFormatIndex: %u}\n", ++ ctrl->bmHint, ctrl->bFormatIndex, ++ 1, corrected_format_index); ++ ctrl->bmHint = 1; ++ ctrl->bFormatIndex = corrected_format_index; ++ } ++ + for (i = 0; i < stream->nformats; ++i) { + if (stream->format[i].index == ctrl->bFormatIndex) { + format = &stream->format[i]; +diff --git a/drivers/media/usb/zr364xx/zr364xx.c b/drivers/media/usb/zr364xx/zr364xx.c +index 1ef611e083237..538a330046ec9 100644 +--- a/drivers/media/usb/zr364xx/zr364xx.c ++++ b/drivers/media/usb/zr364xx/zr364xx.c +@@ -1032,6 +1032,7 @@ static int zr364xx_start_readpipe(struct zr364xx_camera *cam) + DBG("submitting URB %p\n", pipe_info->stream_urb); + retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL); + if (retval) { ++ usb_free_urb(pipe_info->stream_urb); + printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n"); + return retval; + } +diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c +index 7e8bf4b1ab2e5..efdf6a5475cb3 100644 +--- a/drivers/media/v4l2-core/v4l2-ioctl.c ++++ b/drivers/media/v4l2-core/v4l2-ioctl.c +@@ -3166,8 +3166,10 @@ static int video_get_user(void __user *arg, void *parg, + if (copy_from_user(parg, (void __user *)arg, n)) + err = -EFAULT; + } else if (in_compat_syscall()) { ++ memset(parg, 0, n); + err = v4l2_compat_get_user(arg, parg, cmd); + } else { ++ memset(parg, 0, n); + #if !defined(CONFIG_64BIT) && defined(CONFIG_COMPAT_32BIT_TIME) + switch (cmd) { + case VIDIOC_QUERYBUF_TIME32: +diff --git a/drivers/mfd/syscon.c b/drivers/mfd/syscon.c +index c6f139b2e0c09..765c0210cb528 100644 +--- a/drivers/mfd/syscon.c ++++ b/drivers/mfd/syscon.c +@@ -108,6 +108,7 @@ static struct syscon *of_syscon_register(struct device_node *np, bool check_clk) + syscon_config.max_register = resource_size(&res) - reg_io_width; + + regmap = regmap_init_mmio(NULL, base, &syscon_config); ++ kfree(syscon_config.name); + if (IS_ERR(regmap)) { + pr_err("regmap init failed\n"); + ret = PTR_ERR(regmap); +@@ -144,7 +145,6 @@ err_clk: + regmap_exit(regmap); + err_regmap: + iounmap(base); +- kfree(syscon_config.name); + err_map: + kfree(syscon); + return ERR_PTR(ret); +diff --git a/drivers/misc/lkdtm/bugs.c b/drivers/misc/lkdtm/bugs.c +index 110f5a8538e96..8787d1d6774b1 100644 +--- a/drivers/misc/lkdtm/bugs.c ++++ b/drivers/misc/lkdtm/bugs.c +@@ -144,6 +144,9 @@ void lkdtm_UNALIGNED_LOAD_STORE_WRITE(void) + if (*p == 0) + val = 0x87654321; + *p = val; ++ ++ if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)) ++ pr_err("XFAIL: arch has CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS\n"); + } + + void lkdtm_SOFTLOCKUP(void) +diff --git a/drivers/misc/lkdtm/core.c b/drivers/misc/lkdtm/core.c +index b2aff4d87c014..94ed7860cfee3 100644 +--- a/drivers/misc/lkdtm/core.c ++++ b/drivers/misc/lkdtm/core.c +@@ -176,9 +176,7 @@ static const struct crashtype crashtypes[] = { + CRASHTYPE(STACKLEAK_ERASING), + CRASHTYPE(CFI_FORWARD_PROTO), + CRASHTYPE(FORTIFIED_STRSCPY), +-#ifdef CONFIG_X86_32 + CRASHTYPE(DOUBLE_FAULT), +-#endif + #ifdef CONFIG_PPC_BOOK3S_64 + CRASHTYPE(PPC_SLB_MULTIHIT), + #endif +diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c +index e30c4e88e4043..f988bc91e65f3 100644 +--- a/drivers/mmc/core/core.c ++++ b/drivers/mmc/core/core.c +@@ -937,11 +937,14 @@ int mmc_execute_tuning(struct mmc_card *card) + + err = host->ops->execute_tuning(host, opcode); + +- if (err) ++ if (err) { + pr_err("%s: tuning execution failed: %d\n", + mmc_hostname(host), err); +- else ++ } else { ++ host->retune_now = 0; ++ host->need_retune = 0; + mmc_retune_enable(host); ++ } + + return err; + } +diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c +index 2c48d65041013..e277ef4fa0995 100644 +--- a/drivers/mmc/core/sd.c ++++ b/drivers/mmc/core/sd.c +@@ -847,11 +847,13 @@ try_again: + return err; + + /* +- * In case CCS and S18A in the response is set, start Signal Voltage +- * Switch procedure. SPI mode doesn't support CMD11. ++ * In case the S18A bit is set in the response, let's start the signal ++ * voltage switch procedure. SPI mode doesn't support CMD11. ++ * Note that, according to the spec, the S18A bit is not valid unless ++ * the CCS bit is set as well. We deliberately deviate from the spec in ++ * regards to this, which allows UHS-I to be supported for SDSC cards. + */ +- if (!mmc_host_is_spi(host) && rocr && +- ((*rocr & 0x41000000) == 0x41000000)) { ++ if (!mmc_host_is_spi(host) && rocr && (*rocr & 0x01000000)) { + err = mmc_set_uhs_voltage(host, pocr); + if (err == -EAGAIN) { + retries--; +diff --git a/drivers/mmc/host/sdhci-acpi.c b/drivers/mmc/host/sdhci-acpi.c +index b6574e7fd26bf..9e4358d7a0a66 100644 +--- a/drivers/mmc/host/sdhci-acpi.c ++++ b/drivers/mmc/host/sdhci-acpi.c +@@ -820,6 +820,17 @@ static const struct dmi_system_id sdhci_acpi_quirks[] = { + }, + .driver_data = (void *)DMI_QUIRK_SD_NO_WRITE_PROTECT, + }, ++ { ++ /* ++ * The Toshiba WT8-B's microSD slot always reports the card being ++ * write-protected. ++ */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "TOSHIBA ENCORE 2 WT8-B"), ++ }, ++ .driver_data = (void *)DMI_QUIRK_SD_NO_WRITE_PROTECT, ++ }, + {} /* Terminating entry */ + }; + +diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c +index a9e20818ff3a3..76ef837430caa 100644 +--- a/drivers/mmc/host/sdhci.c ++++ b/drivers/mmc/host/sdhci.c +@@ -1812,6 +1812,10 @@ static u16 sdhci_get_preset_value(struct sdhci_host *host) + u16 preset = 0; + + switch (host->timing) { ++ case MMC_TIMING_MMC_HS: ++ case MMC_TIMING_SD_HS: ++ preset = sdhci_readw(host, SDHCI_PRESET_FOR_HIGH_SPEED); ++ break; + case MMC_TIMING_UHS_SDR12: + preset = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12); + break; +diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h +index 0770c036e2ff5..960fed78529e1 100644 +--- a/drivers/mmc/host/sdhci.h ++++ b/drivers/mmc/host/sdhci.h +@@ -253,6 +253,7 @@ + + /* 60-FB reserved */ + ++#define SDHCI_PRESET_FOR_HIGH_SPEED 0x64 + #define SDHCI_PRESET_FOR_SDR12 0x66 + #define SDHCI_PRESET_FOR_SDR25 0x68 + #define SDHCI_PRESET_FOR_SDR50 0x6A +diff --git a/drivers/net/dsa/ocelot/seville_vsc9953.c b/drivers/net/dsa/ocelot/seville_vsc9953.c +index 84f93a874d502..deae923c8b7a8 100644 +--- a/drivers/net/dsa/ocelot/seville_vsc9953.c ++++ b/drivers/net/dsa/ocelot/seville_vsc9953.c +@@ -1206,6 +1206,11 @@ static int seville_probe(struct platform_device *pdev) + felix->info = &seville_info_vsc9953; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); ++ if (!res) { ++ err = -EINVAL; ++ dev_err(&pdev->dev, "Invalid resource\n"); ++ goto err_alloc_felix; ++ } + felix->switch_base = res->start; + + ds = kzalloc(sizeof(struct dsa_switch), GFP_KERNEL); +diff --git a/drivers/net/ethernet/broadcom/genet/bcmmii.c b/drivers/net/ethernet/broadcom/genet/bcmmii.c +index 5335244e4577a..89d16c587bb7d 100644 +--- a/drivers/net/ethernet/broadcom/genet/bcmmii.c ++++ b/drivers/net/ethernet/broadcom/genet/bcmmii.c +@@ -423,6 +423,10 @@ static int bcmgenet_mii_register(struct bcmgenet_priv *priv) + int id, ret; + + pres = platform_get_resource(pdev, IORESOURCE_MEM, 0); ++ if (!pres) { ++ dev_err(&pdev->dev, "Invalid resource\n"); ++ return -EINVAL; ++ } + memset(&res, 0, sizeof(res)); + memset(&ppd, 0, sizeof(ppd)); + +diff --git a/drivers/net/ethernet/freescale/fec.h b/drivers/net/ethernet/freescale/fec.h +index 0602d5d5d2eee..2e002e4b4b4aa 100644 +--- a/drivers/net/ethernet/freescale/fec.h ++++ b/drivers/net/ethernet/freescale/fec.h +@@ -467,6 +467,11 @@ struct bufdesc_ex { + */ + #define FEC_QUIRK_NO_HARD_RESET (1 << 18) + ++/* i.MX6SX ENET IP supports multiple queues (3 queues), use this quirk to ++ * represents this ENET IP. ++ */ ++#define FEC_QUIRK_HAS_MULTI_QUEUES (1 << 19) ++ + struct bufdesc_prop { + int qid; + /* Address of Rx and Tx buffers */ +diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c +index 89393fbc726f6..6c097ae3bac58 100644 +--- a/drivers/net/ethernet/freescale/fec_main.c ++++ b/drivers/net/ethernet/freescale/fec_main.c +@@ -75,6 +75,8 @@ static void fec_enet_itr_coal_init(struct net_device *ndev); + + #define DRIVER_NAME "fec" + ++static const u16 fec_enet_vlan_pri_to_queue[8] = {0, 0, 1, 1, 1, 2, 2, 2}; ++ + /* Pause frame feild and FIFO threshold */ + #define FEC_ENET_FCE (1 << 5) + #define FEC_ENET_RSEM_V 0x84 +@@ -121,7 +123,7 @@ static const struct fec_devinfo fec_imx6x_info = { + FEC_QUIRK_HAS_VLAN | FEC_QUIRK_HAS_AVB | + FEC_QUIRK_ERR007885 | FEC_QUIRK_BUG_CAPTURE | + FEC_QUIRK_HAS_RACC | FEC_QUIRK_HAS_COALESCE | +- FEC_QUIRK_CLEAR_SETUP_MII, ++ FEC_QUIRK_CLEAR_SETUP_MII | FEC_QUIRK_HAS_MULTI_QUEUES, + }; + + static const struct fec_devinfo fec_imx6ul_info = { +@@ -420,6 +422,7 @@ fec_enet_txq_submit_frag_skb(struct fec_enet_priv_tx_q *txq, + estatus |= FEC_TX_BD_FTYPE(txq->bd.qid); + if (skb->ip_summed == CHECKSUM_PARTIAL) + estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS; ++ + ebdp->cbd_bdu = 0; + ebdp->cbd_esc = cpu_to_fec32(estatus); + } +@@ -953,7 +956,7 @@ fec_restart(struct net_device *ndev) + * For i.MX6SX SOC, enet use AXI bus, we use disable MAC + * instead of reset MAC itself. + */ +- if (fep->quirks & FEC_QUIRK_HAS_AVB || ++ if (fep->quirks & FEC_QUIRK_HAS_MULTI_QUEUES || + ((fep->quirks & FEC_QUIRK_NO_HARD_RESET) && fep->link)) { + writel(0, fep->hwp + FEC_ECNTRL); + } else { +@@ -1164,7 +1167,7 @@ fec_stop(struct net_device *ndev) + * instead of reset MAC itself. + */ + if (!(fep->wol_flag & FEC_WOL_FLAG_SLEEP_ON)) { +- if (fep->quirks & FEC_QUIRK_HAS_AVB) { ++ if (fep->quirks & FEC_QUIRK_HAS_MULTI_QUEUES) { + writel(0, fep->hwp + FEC_ECNTRL); + } else { + writel(1, fep->hwp + FEC_ECNTRL); +@@ -2559,7 +2562,7 @@ static void fec_enet_itr_coal_set(struct net_device *ndev) + + writel(tx_itr, fep->hwp + FEC_TXIC0); + writel(rx_itr, fep->hwp + FEC_RXIC0); +- if (fep->quirks & FEC_QUIRK_HAS_AVB) { ++ if (fep->quirks & FEC_QUIRK_HAS_MULTI_QUEUES) { + writel(tx_itr, fep->hwp + FEC_TXIC1); + writel(rx_itr, fep->hwp + FEC_RXIC1); + writel(tx_itr, fep->hwp + FEC_TXIC2); +@@ -3227,10 +3230,40 @@ static int fec_set_features(struct net_device *netdev, + return 0; + } + ++static u16 fec_enet_get_raw_vlan_tci(struct sk_buff *skb) ++{ ++ struct vlan_ethhdr *vhdr; ++ unsigned short vlan_TCI = 0; ++ ++ if (skb->protocol == htons(ETH_P_ALL)) { ++ vhdr = (struct vlan_ethhdr *)(skb->data); ++ vlan_TCI = ntohs(vhdr->h_vlan_TCI); ++ } ++ ++ return vlan_TCI; ++} ++ ++static u16 fec_enet_select_queue(struct net_device *ndev, struct sk_buff *skb, ++ struct net_device *sb_dev) ++{ ++ struct fec_enet_private *fep = netdev_priv(ndev); ++ u16 vlan_tag; ++ ++ if (!(fep->quirks & FEC_QUIRK_HAS_AVB)) ++ return netdev_pick_tx(ndev, skb, NULL); ++ ++ vlan_tag = fec_enet_get_raw_vlan_tci(skb); ++ if (!vlan_tag) ++ return vlan_tag; ++ ++ return fec_enet_vlan_pri_to_queue[vlan_tag >> 13]; ++} ++ + static const struct net_device_ops fec_netdev_ops = { + .ndo_open = fec_enet_open, + .ndo_stop = fec_enet_close, + .ndo_start_xmit = fec_enet_start_xmit, ++ .ndo_select_queue = fec_enet_select_queue, + .ndo_set_rx_mode = set_multicast_list, + .ndo_validate_addr = eth_validate_addr, + .ndo_tx_timeout = fec_timeout, +@@ -3356,7 +3389,7 @@ static int fec_enet_init(struct net_device *ndev) + fep->csum_flags |= FLAG_RX_CSUM_ENABLED; + } + +- if (fep->quirks & FEC_QUIRK_HAS_AVB) { ++ if (fep->quirks & FEC_QUIRK_HAS_MULTI_QUEUES) { + fep->tx_align = 0; + fep->rx_align = 0x3f; + } +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index 3c77897b3f31f..df10b87ca0f80 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -1528,7 +1528,8 @@ static int create_hdr_descs(u8 hdr_field, u8 *hdr_data, int len, int *hdr_len, + + /** + * build_hdr_descs_arr - build a header descriptor array +- * @txbuff: tx buffer ++ * @skb: tx socket buffer ++ * @indir_arr: indirect array + * @num_entries: number of descriptors to be sent + * @hdr_field: bit field determining which headers will be sent + * +diff --git a/drivers/net/ethernet/intel/e100.c b/drivers/net/ethernet/intel/e100.c +index f8d78af76d7de..1b0958bd24f6c 100644 +--- a/drivers/net/ethernet/intel/e100.c ++++ b/drivers/net/ethernet/intel/e100.c +@@ -1395,7 +1395,7 @@ static int e100_phy_check_without_mii(struct nic *nic) + u8 phy_type; + int without_mii; + +- phy_type = (nic->eeprom[eeprom_phy_iface] >> 8) & 0x0f; ++ phy_type = (le16_to_cpu(nic->eeprom[eeprom_phy_iface]) >> 8) & 0x0f; + + switch (phy_type) { + case NoSuchPhy: /* Non-MII PHY; UNTESTED! */ +@@ -1515,7 +1515,7 @@ static int e100_phy_init(struct nic *nic) + mdio_write(netdev, nic->mii.phy_id, MII_BMCR, bmcr); + } else if ((nic->mac >= mac_82550_D102) || ((nic->flags & ich) && + (mdio_read(netdev, nic->mii.phy_id, MII_TPISTATUS) & 0x8000) && +- (nic->eeprom[eeprom_cnfg_mdix] & eeprom_mdix_enabled))) { ++ (le16_to_cpu(nic->eeprom[eeprom_cnfg_mdix]) & eeprom_mdix_enabled))) { + /* enable/disable MDI/MDI-X auto-switching. */ + mdio_write(netdev, nic->mii.phy_id, MII_NCONFIG, + nic->mii.force_media ? 0 : NCONFIG_AUTO_SWITCH); +@@ -2269,9 +2269,9 @@ static int e100_asf(struct nic *nic) + { + /* ASF can be enabled from eeprom */ + return (nic->pdev->device >= 0x1050) && (nic->pdev->device <= 0x1057) && +- (nic->eeprom[eeprom_config_asf] & eeprom_asf) && +- !(nic->eeprom[eeprom_config_asf] & eeprom_gcl) && +- ((nic->eeprom[eeprom_smbus_addr] & 0xFF) != 0xFE); ++ (le16_to_cpu(nic->eeprom[eeprom_config_asf]) & eeprom_asf) && ++ !(le16_to_cpu(nic->eeprom[eeprom_config_asf]) & eeprom_gcl) && ++ ((le16_to_cpu(nic->eeprom[eeprom_smbus_addr]) & 0xFF) != 0xFE); + } + + static int e100_up(struct nic *nic) +@@ -2926,7 +2926,7 @@ static int e100_probe(struct pci_dev *pdev, const struct pci_device_id *ent) + + /* Wol magic packet can be enabled from eeprom */ + if ((nic->mac >= mac_82558_D101_A4) && +- (nic->eeprom[eeprom_id] & eeprom_id_wol)) { ++ (le16_to_cpu(nic->eeprom[eeprom_id]) & eeprom_id_wol)) { + nic->flags |= wol_magic; + device_set_wakeup_enable(&pdev->dev, true); + } +diff --git a/drivers/net/ethernet/intel/i40e/i40e_ptp.c b/drivers/net/ethernet/intel/i40e/i40e_ptp.c +index 7a879614ca55e..1dad6c93ac9c8 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_ptp.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_ptp.c +@@ -11,13 +11,14 @@ + * operate with the nanosecond field directly without fear of overflow. + * + * Much like the 82599, the update period is dependent upon the link speed: +- * At 40Gb link or no link, the period is 1.6ns. +- * At 10Gb link, the period is multiplied by 2. (3.2ns) ++ * At 40Gb, 25Gb, or no link, the period is 1.6ns. ++ * At 10Gb or 5Gb link, the period is multiplied by 2. (3.2ns) + * At 1Gb link, the period is multiplied by 20. (32ns) + * 1588 functionality is not supported at 100Mbps. + */ + #define I40E_PTP_40GB_INCVAL 0x0199999999ULL + #define I40E_PTP_10GB_INCVAL_MULT 2 ++#define I40E_PTP_5GB_INCVAL_MULT 2 + #define I40E_PTP_1GB_INCVAL_MULT 20 + + #define I40E_PRTTSYN_CTL1_TSYNTYPE_V1 BIT(I40E_PRTTSYN_CTL1_TSYNTYPE_SHIFT) +@@ -465,6 +466,9 @@ void i40e_ptp_set_increment(struct i40e_pf *pf) + case I40E_LINK_SPEED_10GB: + mult = I40E_PTP_10GB_INCVAL_MULT; + break; ++ case I40E_LINK_SPEED_5GB: ++ mult = I40E_PTP_5GB_INCVAL_MULT; ++ break; + case I40E_LINK_SPEED_1GB: + mult = I40E_PTP_1GB_INCVAL_MULT; + break; +diff --git a/drivers/net/ethernet/intel/ice/ice_ethtool.c b/drivers/net/ethernet/intel/ice/ice_ethtool.c +index f80fff97d8dce..0d136708f9607 100644 +--- a/drivers/net/ethernet/intel/ice/ice_ethtool.c ++++ b/drivers/net/ethernet/intel/ice/ice_ethtool.c +@@ -3492,13 +3492,9 @@ static int + ice_get_rc_coalesce(struct ethtool_coalesce *ec, enum ice_container_type c_type, + struct ice_ring_container *rc) + { +- struct ice_pf *pf; +- + if (!rc->ring) + return -EINVAL; + +- pf = rc->ring->vsi->back; +- + switch (c_type) { + case ICE_RX_CONTAINER: + ec->use_adaptive_rx_coalesce = ITR_IS_DYNAMIC(rc->itr_setting); +@@ -3510,7 +3506,7 @@ ice_get_rc_coalesce(struct ethtool_coalesce *ec, enum ice_container_type c_type, + ec->tx_coalesce_usecs = rc->itr_setting & ~ICE_ITR_DYNAMIC; + break; + default: +- dev_dbg(ice_pf_to_dev(pf), "Invalid c_type %d\n", c_type); ++ dev_dbg(ice_pf_to_dev(rc->ring->vsi->back), "Invalid c_type %d\n", c_type); + return -EINVAL; + } + +diff --git a/drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h b/drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h +index 4ec24c3e813fe..c0ee0541e53fc 100644 +--- a/drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h ++++ b/drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h +@@ -608,7 +608,7 @@ static const struct ice_rx_ptype_decoded ice_ptype_lkup[] = { + /* L2 Packet types */ + ICE_PTT_UNUSED_ENTRY(0), + ICE_PTT(1, L2, NONE, NOF, NONE, NONE, NOF, NONE, PAY2), +- ICE_PTT(2, L2, NONE, NOF, NONE, NONE, NOF, NONE, NONE), ++ ICE_PTT_UNUSED_ENTRY(2), + ICE_PTT_UNUSED_ENTRY(3), + ICE_PTT_UNUSED_ENTRY(4), + ICE_PTT_UNUSED_ENTRY(5), +@@ -722,7 +722,7 @@ static const struct ice_rx_ptype_decoded ice_ptype_lkup[] = { + /* Non Tunneled IPv6 */ + ICE_PTT(88, IP, IPV6, FRG, NONE, NONE, NOF, NONE, PAY3), + ICE_PTT(89, IP, IPV6, NOF, NONE, NONE, NOF, NONE, PAY3), +- ICE_PTT(90, IP, IPV6, NOF, NONE, NONE, NOF, UDP, PAY3), ++ ICE_PTT(90, IP, IPV6, NOF, NONE, NONE, NOF, UDP, PAY4), + ICE_PTT_UNUSED_ENTRY(91), + ICE_PTT(92, IP, IPV6, NOF, NONE, NONE, NOF, TCP, PAY4), + ICE_PTT(93, IP, IPV6, NOF, NONE, NONE, NOF, SCTP, PAY4), +diff --git a/drivers/net/ethernet/intel/ice/ice_type.h b/drivers/net/ethernet/intel/ice/ice_type.h +index 266036b7a49ab..8a90c47e337df 100644 +--- a/drivers/net/ethernet/intel/ice/ice_type.h ++++ b/drivers/net/ethernet/intel/ice/ice_type.h +@@ -63,7 +63,7 @@ enum ice_aq_res_ids { + /* FW update timeout definitions are in milliseconds */ + #define ICE_NVM_TIMEOUT 180000 + #define ICE_CHANGE_LOCK_TIMEOUT 1000 +-#define ICE_GLOBAL_CFG_LOCK_TIMEOUT 3000 ++#define ICE_GLOBAL_CFG_LOCK_TIMEOUT 5000 + + enum ice_aq_res_access_type { + ICE_RES_READ = 1, +diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c +index caa8929289ae7..434220a342dfb 100644 +--- a/drivers/net/ethernet/intel/igb/igb_main.c ++++ b/drivers/net/ethernet/intel/igb/igb_main.c +@@ -2643,7 +2643,8 @@ static int igb_parse_cls_flower(struct igb_adapter *adapter, + } + + input->filter.match_flags |= IGB_FILTER_FLAG_VLAN_TCI; +- input->filter.vlan_tci = match.key->vlan_priority; ++ input->filter.vlan_tci = ++ (__force __be16)match.key->vlan_priority; + } + } + +@@ -6276,12 +6277,12 @@ int igb_xmit_xdp_ring(struct igb_adapter *adapter, + cmd_type |= len | IGB_TXD_DCMD; + tx_desc->read.cmd_type_len = cpu_to_le32(cmd_type); + +- olinfo_status = cpu_to_le32(len << E1000_ADVTXD_PAYLEN_SHIFT); ++ olinfo_status = len << E1000_ADVTXD_PAYLEN_SHIFT; + /* 82575 requires a unique index per ring */ + if (test_bit(IGB_RING_FLAG_TX_CTX_IDX, &tx_ring->flags)) + olinfo_status |= tx_ring->reg_idx << 4; + +- tx_desc->read.olinfo_status = olinfo_status; ++ tx_desc->read.olinfo_status = cpu_to_le32(olinfo_status); + + netdev_tx_sent_queue(txring_txq(tx_ring), tx_buffer->bytecount); + +@@ -8593,7 +8594,7 @@ static void igb_process_skb_fields(struct igb_ring *rx_ring, + + if (igb_test_staterr(rx_desc, E1000_RXDEXT_STATERR_LB) && + test_bit(IGB_RING_FLAG_RX_LB_VLAN_BSWAP, &rx_ring->flags)) +- vid = be16_to_cpu(rx_desc->wb.upper.vlan); ++ vid = be16_to_cpu((__force __be16)rx_desc->wb.upper.vlan); + else + vid = le16_to_cpu(rx_desc->wb.upper.vlan); + +diff --git a/drivers/net/ethernet/intel/igbvf/netdev.c b/drivers/net/ethernet/intel/igbvf/netdev.c +index fb3fbcb133310..630c1155f1965 100644 +--- a/drivers/net/ethernet/intel/igbvf/netdev.c ++++ b/drivers/net/ethernet/intel/igbvf/netdev.c +@@ -83,14 +83,14 @@ static int igbvf_desc_unused(struct igbvf_ring *ring) + static void igbvf_receive_skb(struct igbvf_adapter *adapter, + struct net_device *netdev, + struct sk_buff *skb, +- u32 status, u16 vlan) ++ u32 status, __le16 vlan) + { + u16 vid; + + if (status & E1000_RXD_STAT_VP) { + if ((adapter->flags & IGBVF_FLAG_RX_LB_VLAN_BSWAP) && + (status & E1000_RXDEXT_STATERR_LB)) +- vid = be16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK; ++ vid = be16_to_cpu((__force __be16)vlan) & E1000_RXD_SPC_VLAN_MASK; + else + vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK; + if (test_bit(vid, adapter->active_vlans)) +diff --git a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c +index bf06f2d785db6..fbee581d02b4b 100644 +--- a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c ++++ b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c +@@ -7388,6 +7388,10 @@ static int mvpp2_probe(struct platform_device *pdev) + return PTR_ERR(priv->lms_base); + } else { + res = platform_get_resource(pdev, IORESOURCE_MEM, 1); ++ if (!res) { ++ dev_err(&pdev->dev, "Invalid resource\n"); ++ return -EINVAL; ++ } + if (has_acpi_companion(&pdev->dev)) { + /* In case the MDIO memory region is declared in + * the ACPI, it can already appear as 'in-use' +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c +index 249d8905e644a..e7528fa7e1876 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c +@@ -1308,7 +1308,8 @@ static void mlx5e_handle_rx_cqe_rep(struct mlx5e_rq *rq, struct mlx5_cqe64 *cqe) + if (rep->vlan && skb_vlan_tag_present(skb)) + skb_vlan_pop(skb); + +- if (!mlx5e_rep_tc_update_skb(cqe, skb, &tc_priv)) { ++ if (unlikely(!mlx5_ipsec_is_rx_flow(cqe) && ++ !mlx5e_rep_tc_update_skb(cqe, skb, &tc_priv))) { + dev_kfree_skb_any(skb); + goto free_wqe; + } +@@ -1365,7 +1366,8 @@ static void mlx5e_handle_rx_cqe_mpwrq_rep(struct mlx5e_rq *rq, struct mlx5_cqe64 + + mlx5e_complete_rx_cqe(rq, cqe, cqe_bcnt, skb); + +- if (!mlx5e_rep_tc_update_skb(cqe, skb, &tc_priv)) { ++ if (unlikely(!mlx5_ipsec_is_rx_flow(cqe) && ++ !mlx5e_rep_tc_update_skb(cqe, skb, &tc_priv))) { + dev_kfree_skb_any(skb); + goto mpwrq_cqe_out; + } +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/lag.c b/drivers/net/ethernet/mellanox/mlx5/core/lag.c +index 83a05371e2aa1..8d029401ca6cc 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/lag.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/lag.c +@@ -118,17 +118,24 @@ static bool __mlx5_lag_is_sriov(struct mlx5_lag *ldev) + static void mlx5_infer_tx_affinity_mapping(struct lag_tracker *tracker, + u8 *port1, u8 *port2) + { ++ bool p1en; ++ bool p2en; ++ ++ p1en = tracker->netdev_state[MLX5_LAG_P1].tx_enabled && ++ tracker->netdev_state[MLX5_LAG_P1].link_up; ++ ++ p2en = tracker->netdev_state[MLX5_LAG_P2].tx_enabled && ++ tracker->netdev_state[MLX5_LAG_P2].link_up; ++ + *port1 = 1; + *port2 = 2; +- if (!tracker->netdev_state[MLX5_LAG_P1].tx_enabled || +- !tracker->netdev_state[MLX5_LAG_P1].link_up) { +- *port1 = 2; ++ if ((!p1en && !p2en) || (p1en && p2en)) + return; +- } + +- if (!tracker->netdev_state[MLX5_LAG_P2].tx_enabled || +- !tracker->netdev_state[MLX5_LAG_P2].link_up) ++ if (p1en) + *port2 = 1; ++ else ++ *port1 = 2; + } + + void mlx5_modify_lag(struct mlx5_lag *ldev, +diff --git a/drivers/net/ethernet/micrel/ks8842.c b/drivers/net/ethernet/micrel/ks8842.c +index caa251d0e3815..b27713906d3a6 100644 +--- a/drivers/net/ethernet/micrel/ks8842.c ++++ b/drivers/net/ethernet/micrel/ks8842.c +@@ -1135,6 +1135,10 @@ static int ks8842_probe(struct platform_device *pdev) + unsigned i; + + iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0); ++ if (!iomem) { ++ dev_err(&pdev->dev, "Invalid resource\n"); ++ return -EINVAL; ++ } + if (!request_mem_region(iomem->start, resource_size(iomem), DRV_NAME)) + goto err_mem_region; + +diff --git a/drivers/net/ethernet/moxa/moxart_ether.c b/drivers/net/ethernet/moxa/moxart_ether.c +index 49fd843c4c8a0..a4380c45f6689 100644 +--- a/drivers/net/ethernet/moxa/moxart_ether.c ++++ b/drivers/net/ethernet/moxa/moxart_ether.c +@@ -481,14 +481,13 @@ static int moxart_mac_probe(struct platform_device *pdev) + priv->ndev = ndev; + priv->pdev = pdev; + +- res = platform_get_resource(pdev, IORESOURCE_MEM, 0); +- ndev->base_addr = res->start; +- priv->base = devm_ioremap_resource(p_dev, res); ++ priv->base = devm_platform_get_and_ioremap_resource(pdev, 0, &res); + if (IS_ERR(priv->base)) { + dev_err(p_dev, "devm_ioremap_resource failed\n"); + ret = PTR_ERR(priv->base); + goto init_fail; + } ++ ndev->base_addr = res->start; + + spin_lock_init(&priv->txlock); + +diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c +index 1b32a43f70242..df0501b5fe830 100644 +--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c ++++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c +@@ -107,7 +107,7 @@ static int pch_ptp_match(struct sk_buff *skb, u16 uid_hi, u32 uid_lo, u16 seqid) + { + u8 *data = skb->data; + unsigned int offset; +- u16 *hi, *id; ++ u16 hi, id; + u32 lo; + + if (ptp_classify_raw(skb) == PTP_CLASS_NONE) +@@ -118,14 +118,11 @@ static int pch_ptp_match(struct sk_buff *skb, u16 uid_hi, u32 uid_lo, u16 seqid) + if (skb->len < offset + OFF_PTP_SEQUENCE_ID + sizeof(seqid)) + return 0; + +- hi = (u16 *)(data + offset + OFF_PTP_SOURCE_UUID); +- id = (u16 *)(data + offset + OFF_PTP_SEQUENCE_ID); ++ hi = get_unaligned_be16(data + offset + OFF_PTP_SOURCE_UUID + 0); ++ lo = get_unaligned_be32(data + offset + OFF_PTP_SOURCE_UUID + 2); ++ id = get_unaligned_be16(data + offset + OFF_PTP_SEQUENCE_ID); + +- memcpy(&lo, &hi[1], sizeof(lo)); +- +- return (uid_hi == *hi && +- uid_lo == lo && +- seqid == *id); ++ return (uid_hi == hi && uid_lo == lo && seqid == id); + } + + static void +@@ -135,7 +132,6 @@ pch_rx_timestamp(struct pch_gbe_adapter *adapter, struct sk_buff *skb) + struct pci_dev *pdev; + u64 ns; + u32 hi, lo, val; +- u16 uid, seq; + + if (!adapter->hwts_rx_en) + return; +@@ -151,10 +147,7 @@ pch_rx_timestamp(struct pch_gbe_adapter *adapter, struct sk_buff *skb) + lo = pch_src_uuid_lo_read(pdev); + hi = pch_src_uuid_hi_read(pdev); + +- uid = hi & 0xffff; +- seq = (hi >> 16) & 0xffff; +- +- if (!pch_ptp_match(skb, htons(uid), htonl(lo), htons(seq))) ++ if (!pch_ptp_match(skb, hi, lo, hi >> 16)) + goto out; + + ns = pch_rx_snap_read(pdev); +diff --git a/drivers/net/ethernet/realtek/r8169_main.c b/drivers/net/ethernet/realtek/r8169_main.c +index f7a56e05ec8a4..552164af2dd4b 100644 +--- a/drivers/net/ethernet/realtek/r8169_main.c ++++ b/drivers/net/ethernet/realtek/r8169_main.c +@@ -3477,7 +3477,6 @@ static void rtl_hw_start_8106(struct rtl8169_private *tp) + rtl_eri_write(tp, 0x1b0, ERIAR_MASK_0011, 0x0000); + + rtl_pcie_state_l2l3_disable(tp); +- rtl_hw_aspm_clkreq_enable(tp, true); + } + + DECLARE_RTL_COND(rtl_mac_ocp_e00e_cond) +diff --git a/drivers/net/ethernet/sfc/ef10_sriov.c b/drivers/net/ethernet/sfc/ef10_sriov.c +index 21fa6c0e88734..84041cd587d78 100644 +--- a/drivers/net/ethernet/sfc/ef10_sriov.c ++++ b/drivers/net/ethernet/sfc/ef10_sriov.c +@@ -402,12 +402,17 @@ fail1: + return rc; + } + ++/* Disable SRIOV and remove VFs ++ * If some VFs are attached to a guest (using Xen, only) nothing is ++ * done if force=false, and vports are freed if force=true (for the non ++ * attachedc ones, only) but SRIOV is not disabled and VFs are not ++ * removed in either case. ++ */ + static int efx_ef10_pci_sriov_disable(struct efx_nic *efx, bool force) + { + struct pci_dev *dev = efx->pci_dev; +- unsigned int vfs_assigned = 0; +- +- vfs_assigned = pci_vfs_assigned(dev); ++ unsigned int vfs_assigned = pci_vfs_assigned(dev); ++ int rc = 0; + + if (vfs_assigned && !force) { + netif_info(efx, drv, efx->net_dev, "VFs are assigned to guests; " +@@ -417,10 +422,12 @@ static int efx_ef10_pci_sriov_disable(struct efx_nic *efx, bool force) + + if (!vfs_assigned) + pci_disable_sriov(dev); ++ else ++ rc = -EBUSY; + + efx_ef10_sriov_free_vf_vswitching(efx); + efx->vf_count = 0; +- return 0; ++ return rc; + } + + int efx_ef10_sriov_configure(struct efx_nic *efx, int num_vfs) +@@ -439,7 +446,6 @@ int efx_ef10_sriov_init(struct efx_nic *efx) + void efx_ef10_sriov_fini(struct efx_nic *efx) + { + struct efx_ef10_nic_data *nic_data = efx->nic_data; +- unsigned int i; + int rc; + + if (!nic_data->vf) { +@@ -449,14 +455,7 @@ void efx_ef10_sriov_fini(struct efx_nic *efx) + return; + } + +- /* Remove any VFs in the host */ +- for (i = 0; i < efx->vf_count; ++i) { +- struct efx_nic *vf_efx = nic_data->vf[i].efx; +- +- if (vf_efx) +- vf_efx->pci_dev->driver->remove(vf_efx->pci_dev); +- } +- ++ /* Disable SRIOV and remove any VFs in the host */ + rc = efx_ef10_pci_sriov_disable(efx, true); + if (rc) + netif_dbg(efx, drv, efx->net_dev, +diff --git a/drivers/net/ethernet/sgi/ioc3-eth.c b/drivers/net/ethernet/sgi/ioc3-eth.c +index 6eef0f45b133b..2b29fd4cbdf44 100644 +--- a/drivers/net/ethernet/sgi/ioc3-eth.c ++++ b/drivers/net/ethernet/sgi/ioc3-eth.c +@@ -835,6 +835,10 @@ static int ioc3eth_probe(struct platform_device *pdev) + int err; + + regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); ++ if (!regs) { ++ dev_err(&pdev->dev, "Invalid resource\n"); ++ return -EINVAL; ++ } + /* get mac addr from one wire prom */ + if (ioc3eth_get_mac_addr(regs, mac_addr)) + return -EPROBE_DEFER; /* not available yet */ +diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c +index d64116e0543ed..a4ba27bf3131e 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c ++++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c +@@ -444,6 +444,12 @@ int stmmac_mdio_register(struct net_device *ndev) + found = 1; + } + ++ if (!found && !mdio_node) { ++ dev_warn(dev, "No PHY found\n"); ++ err = -ENODEV; ++ goto no_phy_found; ++ } ++ + /* Try to probe the XPCS by scanning all addresses. */ + if (priv->hw->xpcs) { + struct mdio_xpcs_args *xpcs = &priv->hw->xpcs_args; +@@ -452,6 +458,7 @@ int stmmac_mdio_register(struct net_device *ndev) + + xpcs->bus = new_bus; + ++ found = 0; + for (addr = 0; addr < max_addr; addr++) { + xpcs->addr = addr; + +@@ -461,13 +468,12 @@ int stmmac_mdio_register(struct net_device *ndev) + break; + } + } +- } + +- if (!found && !mdio_node) { +- dev_warn(dev, "No PHY found\n"); +- mdiobus_unregister(new_bus); +- mdiobus_free(new_bus); +- return -ENODEV; ++ if (!found && !mdio_node) { ++ dev_warn(dev, "No XPCS found\n"); ++ err = -ENODEV; ++ goto no_xpcs_found; ++ } + } + + bus_register_done: +@@ -475,6 +481,9 @@ bus_register_done: + + return 0; + ++no_xpcs_found: ++no_phy_found: ++ mdiobus_unregister(new_bus); + bus_register_fail: + mdiobus_free(new_bus); + return err; +diff --git a/drivers/net/ethernet/xilinx/xilinx_emaclite.c b/drivers/net/ethernet/xilinx/xilinx_emaclite.c +index 007840d4a8073..3ffe8d2a1f14b 100644 +--- a/drivers/net/ethernet/xilinx/xilinx_emaclite.c ++++ b/drivers/net/ethernet/xilinx/xilinx_emaclite.c +@@ -1193,9 +1193,8 @@ static int xemaclite_of_probe(struct platform_device *ofdev) + } + + dev_info(dev, +- "Xilinx EmacLite at 0x%08lX mapped to 0x%08lX, irq=%d\n", +- (unsigned long __force)ndev->mem_start, +- (unsigned long __force)lp->base_addr, ndev->irq); ++ "Xilinx EmacLite at 0x%08lX mapped to 0x%p, irq=%d\n", ++ (unsigned long __force)ndev->mem_start, lp->base_addr, ndev->irq); + return 0; + + error: +diff --git a/drivers/net/fjes/fjes_main.c b/drivers/net/fjes/fjes_main.c +index 466622664424d..e449d94661225 100644 +--- a/drivers/net/fjes/fjes_main.c ++++ b/drivers/net/fjes/fjes_main.c +@@ -1262,6 +1262,10 @@ static int fjes_probe(struct platform_device *plat_dev) + adapter->interrupt_watch_enable = false; + + res = platform_get_resource(plat_dev, IORESOURCE_MEM, 0); ++ if (!res) { ++ err = -EINVAL; ++ goto err_free_control_wq; ++ } + hw->hw_res.start = res->start; + hw->hw_res.size = resource_size(res); + hw->hw_res.irq = platform_get_irq(plat_dev, 0); +diff --git a/drivers/net/ipa/ipa_main.c b/drivers/net/ipa/ipa_main.c +index 97c1b55405cbf..ba27bcde901e3 100644 +--- a/drivers/net/ipa/ipa_main.c ++++ b/drivers/net/ipa/ipa_main.c +@@ -679,6 +679,7 @@ static int ipa_firmware_load(struct device *dev) + } + + ret = of_address_to_resource(node, 0, &res); ++ of_node_put(node); + if (ret) { + dev_err(dev, "error %d getting \"memory-region\" resource\n", + ret); +diff --git a/drivers/net/mdio/mdio-ipq8064.c b/drivers/net/mdio/mdio-ipq8064.c +index 1bd18857e1c5e..f0a6bfa61645e 100644 +--- a/drivers/net/mdio/mdio-ipq8064.c ++++ b/drivers/net/mdio/mdio-ipq8064.c +@@ -10,7 +10,7 @@ + #include + #include + #include +-#include ++#include + #include + #include + +@@ -96,14 +96,34 @@ ipq8064_mdio_write(struct mii_bus *bus, int phy_addr, int reg_offset, u16 data) + return ipq8064_mdio_wait_busy(priv); + } + ++static const struct regmap_config ipq8064_mdio_regmap_config = { ++ .reg_bits = 32, ++ .reg_stride = 4, ++ .val_bits = 32, ++ .can_multi_write = false, ++ /* the mdio lock is used by any user of this mdio driver */ ++ .disable_locking = true, ++ ++ .cache_type = REGCACHE_NONE, ++}; ++ + static int + ipq8064_mdio_probe(struct platform_device *pdev) + { + struct device_node *np = pdev->dev.of_node; + struct ipq8064_mdio *priv; ++ struct resource res; + struct mii_bus *bus; ++ void __iomem *base; + int ret; + ++ if (of_address_to_resource(np, 0, &res)) ++ return -ENOMEM; ++ ++ base = ioremap(res.start, resource_size(&res)); ++ if (!base) ++ return -ENOMEM; ++ + bus = devm_mdiobus_alloc_size(&pdev->dev, sizeof(*priv)); + if (!bus) + return -ENOMEM; +@@ -115,15 +135,10 @@ ipq8064_mdio_probe(struct platform_device *pdev) + bus->parent = &pdev->dev; + + priv = bus->priv; +- priv->base = device_node_to_regmap(np); +- if (IS_ERR(priv->base)) { +- if (priv->base == ERR_PTR(-EPROBE_DEFER)) +- return -EPROBE_DEFER; +- +- dev_err(&pdev->dev, "error getting device regmap, error=%pe\n", +- priv->base); ++ priv->base = devm_regmap_init_mmio(&pdev->dev, base, ++ &ipq8064_mdio_regmap_config); ++ if (IS_ERR(priv->base)) + return PTR_ERR(priv->base); +- } + + ret = of_mdiobus_register(bus, np); + if (ret) +diff --git a/drivers/net/phy/realtek.c b/drivers/net/phy/realtek.c +index 821e85a973679..7b99a3234c652 100644 +--- a/drivers/net/phy/realtek.c ++++ b/drivers/net/phy/realtek.c +@@ -357,6 +357,19 @@ static int rtl8211f_config_init(struct phy_device *phydev) + return 0; + } + ++static int rtl821x_resume(struct phy_device *phydev) ++{ ++ int ret; ++ ++ ret = genphy_resume(phydev); ++ if (ret < 0) ++ return ret; ++ ++ msleep(20); ++ ++ return 0; ++} ++ + static int rtl8211e_config_init(struct phy_device *phydev) + { + int ret = 0, oldpage; +@@ -852,7 +865,7 @@ static struct phy_driver realtek_drvs[] = { + .config_intr = &rtl8211f_config_intr, + .handle_interrupt = rtl8211f_handle_interrupt, + .suspend = genphy_suspend, +- .resume = genphy_resume, ++ .resume = rtl821x_resume, + .read_page = rtl821x_read_page, + .write_page = rtl821x_write_page, + }, { +diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c +index 0824e6999e499..f7ce341bb328f 100644 +--- a/drivers/net/virtio_net.c ++++ b/drivers/net/virtio_net.c +@@ -660,6 +660,12 @@ static struct sk_buff *receive_small(struct net_device *dev, + len -= vi->hdr_len; + stats->bytes += len; + ++ if (unlikely(len > GOOD_PACKET_LEN)) { ++ pr_debug("%s: rx error: len %u exceeds max size %d\n", ++ dev->name, len, GOOD_PACKET_LEN); ++ dev->stats.rx_length_errors++; ++ goto err_len; ++ } + rcu_read_lock(); + xdp_prog = rcu_dereference(rq->xdp_prog); + if (xdp_prog) { +@@ -761,6 +767,7 @@ err: + err_xdp: + rcu_read_unlock(); + stats->xdp_drops++; ++err_len: + stats->drops++; + put_page(page); + xdp_xmit: +@@ -814,6 +821,12 @@ static struct sk_buff *receive_mergeable(struct net_device *dev, + head_skb = NULL; + stats->bytes += len - vi->hdr_len; + ++ if (unlikely(len > truesize)) { ++ pr_debug("%s: rx error: len %u exceeds truesize %lu\n", ++ dev->name, len, (unsigned long)ctx); ++ dev->stats.rx_length_errors++; ++ goto err_skb; ++ } + rcu_read_lock(); + xdp_prog = rcu_dereference(rq->xdp_prog); + if (xdp_prog) { +@@ -938,13 +951,6 @@ static struct sk_buff *receive_mergeable(struct net_device *dev, + } + rcu_read_unlock(); + +- if (unlikely(len > truesize)) { +- pr_debug("%s: rx error: len %u exceeds truesize %lu\n", +- dev->name, len, (unsigned long)ctx); +- dev->stats.rx_length_errors++; +- goto err_skb; +- } +- + head_skb = page_to_skb(vi, rq, page, offset, len, truesize, !xdp_prog, + metasize); + curr_skb = head_skb; +@@ -1552,7 +1558,7 @@ static int xmit_skb(struct send_queue *sq, struct sk_buff *skb) + if (virtio_net_hdr_from_skb(skb, &hdr->hdr, + virtio_is_little_endian(vi->vdev), false, + 0)) +- BUG(); ++ return -EPROTO; + + if (vi->mergeable_rx_bufs) + hdr->num_buffers = 0; +diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c +index baf7404c137db..873d41c21a779 100644 +--- a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c ++++ b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c +@@ -3798,6 +3798,7 @@ static int iwl_mvm_roc(struct ieee80211_hw *hw, + struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); + struct cfg80211_chan_def chandef; + struct iwl_mvm_phy_ctxt *phy_ctxt; ++ bool band_change_removal; + int ret, i; + + IWL_DEBUG_MAC80211(mvm, "enter (%d, %d, %d)\n", channel->hw_value, +@@ -3878,19 +3879,30 @@ static int iwl_mvm_roc(struct ieee80211_hw *hw, + cfg80211_chandef_create(&chandef, channel, NL80211_CHAN_NO_HT); + + /* +- * Change the PHY context configuration as it is currently referenced +- * only by the P2P Device MAC ++ * Check if the remain-on-channel is on a different band and that ++ * requires context removal, see iwl_mvm_phy_ctxt_changed(). If ++ * so, we'll need to release and then re-configure here, since we ++ * must not remove a PHY context that's part of a binding. + */ +- if (mvmvif->phy_ctxt->ref == 1) { ++ band_change_removal = ++ fw_has_capa(&mvm->fw->ucode_capa, ++ IWL_UCODE_TLV_CAPA_BINDING_CDB_SUPPORT) && ++ mvmvif->phy_ctxt->channel->band != chandef.chan->band; ++ ++ if (mvmvif->phy_ctxt->ref == 1 && !band_change_removal) { ++ /* ++ * Change the PHY context configuration as it is currently ++ * referenced only by the P2P Device MAC (and we can modify it) ++ */ + ret = iwl_mvm_phy_ctxt_changed(mvm, mvmvif->phy_ctxt, + &chandef, 1, 1); + if (ret) + goto out_unlock; + } else { + /* +- * The PHY context is shared with other MACs. Need to remove the +- * P2P Device from the binding, allocate an new PHY context and +- * create a new binding ++ * The PHY context is shared with other MACs (or we're trying to ++ * switch bands), so remove the P2P Device from the binding, ++ * allocate an new PHY context and create a new binding. + */ + phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm); + if (!phy_ctxt) { +diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h +index 0a963d01b8250..f17dfdf2bfaf4 100644 +--- a/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h ++++ b/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h +@@ -1828,7 +1828,8 @@ int iwl_mvm_disable_beacon_filter(struct iwl_mvm *mvm, + void iwl_mvm_update_smps(struct iwl_mvm *mvm, struct ieee80211_vif *vif, + enum iwl_mvm_smps_type_request req_type, + enum ieee80211_smps_mode smps_request); +-bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm); ++bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm, ++ struct iwl_mvm_phy_ctxt *ctxt); + + /* Low latency */ + int iwl_mvm_update_low_latency(struct iwl_mvm *mvm, struct ieee80211_vif *vif, +diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/phy-ctxt.c b/drivers/net/wireless/intel/iwlwifi/mvm/phy-ctxt.c +index 0fd51f6aa2061..4ed2338027d13 100644 +--- a/drivers/net/wireless/intel/iwlwifi/mvm/phy-ctxt.c ++++ b/drivers/net/wireless/intel/iwlwifi/mvm/phy-ctxt.c +@@ -1,6 +1,6 @@ + // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause + /* +- * Copyright (C) 2012-2014, 2018-2020 Intel Corporation ++ * Copyright (C) 2012-2014, 2018-2021 Intel Corporation + * Copyright (C) 2013-2014 Intel Mobile Communications GmbH + * Copyright (C) 2017 Intel Deutschland GmbH + */ +@@ -76,6 +76,7 @@ static void iwl_mvm_phy_ctxt_cmd_hdr(struct iwl_mvm_phy_ctxt *ctxt, + } + + static void iwl_mvm_phy_ctxt_set_rxchain(struct iwl_mvm *mvm, ++ struct iwl_mvm_phy_ctxt *ctxt, + __le32 *rxchain_info, + u8 chains_static, + u8 chains_dynamic) +@@ -93,7 +94,7 @@ static void iwl_mvm_phy_ctxt_set_rxchain(struct iwl_mvm *mvm, + * between the two antennas is sufficiently different to impact + * performance. + */ +- if (active_cnt == 1 && iwl_mvm_rx_diversity_allowed(mvm)) { ++ if (active_cnt == 1 && iwl_mvm_rx_diversity_allowed(mvm, ctxt)) { + idle_cnt = 2; + active_cnt = 2; + } +@@ -113,6 +114,7 @@ static void iwl_mvm_phy_ctxt_set_rxchain(struct iwl_mvm *mvm, + * Add the phy configuration to the PHY context command + */ + static void iwl_mvm_phy_ctxt_cmd_data_v1(struct iwl_mvm *mvm, ++ struct iwl_mvm_phy_ctxt *ctxt, + struct iwl_phy_context_cmd_v1 *cmd, + struct cfg80211_chan_def *chandef, + u8 chains_static, u8 chains_dynamic) +@@ -123,7 +125,7 @@ static void iwl_mvm_phy_ctxt_cmd_data_v1(struct iwl_mvm *mvm, + /* Set the channel info data */ + iwl_mvm_set_chan_info_chandef(mvm, &cmd->ci, chandef); + +- iwl_mvm_phy_ctxt_set_rxchain(mvm, &tail->rxchain_info, ++ iwl_mvm_phy_ctxt_set_rxchain(mvm, ctxt, &tail->rxchain_info, + chains_static, chains_dynamic); + + tail->txchain_info = cpu_to_le32(iwl_mvm_get_valid_tx_ant(mvm)); +@@ -133,6 +135,7 @@ static void iwl_mvm_phy_ctxt_cmd_data_v1(struct iwl_mvm *mvm, + * Add the phy configuration to the PHY context command + */ + static void iwl_mvm_phy_ctxt_cmd_data(struct iwl_mvm *mvm, ++ struct iwl_mvm_phy_ctxt *ctxt, + struct iwl_phy_context_cmd *cmd, + struct cfg80211_chan_def *chandef, + u8 chains_static, u8 chains_dynamic) +@@ -143,7 +146,7 @@ static void iwl_mvm_phy_ctxt_cmd_data(struct iwl_mvm *mvm, + /* Set the channel info data */ + iwl_mvm_set_chan_info_chandef(mvm, &cmd->ci, chandef); + +- iwl_mvm_phy_ctxt_set_rxchain(mvm, &cmd->rxchain_info, ++ iwl_mvm_phy_ctxt_set_rxchain(mvm, ctxt, &cmd->rxchain_info, + chains_static, chains_dynamic); + } + +@@ -170,7 +173,7 @@ static int iwl_mvm_phy_ctxt_apply(struct iwl_mvm *mvm, + iwl_mvm_phy_ctxt_cmd_hdr(ctxt, &cmd, action); + + /* Set the command data */ +- iwl_mvm_phy_ctxt_cmd_data(mvm, &cmd, chandef, ++ iwl_mvm_phy_ctxt_cmd_data(mvm, ctxt, &cmd, chandef, + chains_static, + chains_dynamic); + +@@ -186,7 +189,7 @@ static int iwl_mvm_phy_ctxt_apply(struct iwl_mvm *mvm, + action); + + /* Set the command data */ +- iwl_mvm_phy_ctxt_cmd_data_v1(mvm, &cmd, chandef, ++ iwl_mvm_phy_ctxt_cmd_data_v1(mvm, ctxt, &cmd, chandef, + chains_static, + chains_dynamic); + ret = iwl_mvm_send_cmd_pdu(mvm, PHY_CONTEXT_CMD, +diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/time-event.c b/drivers/net/wireless/intel/iwlwifi/mvm/time-event.c +index 0b012f8c9eb22..9a4a1b363254f 100644 +--- a/drivers/net/wireless/intel/iwlwifi/mvm/time-event.c ++++ b/drivers/net/wireless/intel/iwlwifi/mvm/time-event.c +@@ -289,6 +289,8 @@ static void iwl_mvm_te_handle_notif(struct iwl_mvm *mvm, + * and know the dtim period. + */ + iwl_mvm_te_check_disconnect(mvm, te_data->vif, ++ !te_data->vif->bss_conf.assoc ? ++ "Not associated and the time event is over already..." : + "No beacon heard and the time event is over already..."); + break; + default: +@@ -787,6 +789,8 @@ void iwl_mvm_rx_session_protect_notif(struct iwl_mvm *mvm, + * and know the dtim period. + */ + iwl_mvm_te_check_disconnect(mvm, vif, ++ !vif->bss_conf.assoc ? ++ "Not associated and the session protection is over already..." : + "No beacon heard and the session protection is over already..."); + spin_lock_bh(&mvm->time_event_lock); + iwl_mvm_te_clear_data(mvm, te_data); +diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/utils.c b/drivers/net/wireless/intel/iwlwifi/mvm/utils.c +index b6b481ff15185..fc4d8840eca44 100644 +--- a/drivers/net/wireless/intel/iwlwifi/mvm/utils.c ++++ b/drivers/net/wireless/intel/iwlwifi/mvm/utils.c +@@ -683,23 +683,37 @@ void iwl_mvm_accu_radio_stats(struct iwl_mvm *mvm) + mvm->accu_radio_stats.on_time_scan += mvm->radio_stats.on_time_scan; + } + ++struct iwl_mvm_diversity_iter_data { ++ struct iwl_mvm_phy_ctxt *ctxt; ++ bool result; ++}; ++ + static void iwl_mvm_diversity_iter(void *_data, u8 *mac, + struct ieee80211_vif *vif) + { + struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); +- bool *result = _data; ++ struct iwl_mvm_diversity_iter_data *data = _data; + int i; + ++ if (mvmvif->phy_ctxt != data->ctxt) ++ return; ++ + for (i = 0; i < NUM_IWL_MVM_SMPS_REQ; i++) { + if (mvmvif->smps_requests[i] == IEEE80211_SMPS_STATIC || +- mvmvif->smps_requests[i] == IEEE80211_SMPS_DYNAMIC) +- *result = false; ++ mvmvif->smps_requests[i] == IEEE80211_SMPS_DYNAMIC) { ++ data->result = false; ++ break; ++ } + } + } + +-bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm) ++bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm, ++ struct iwl_mvm_phy_ctxt *ctxt) + { +- bool result = true; ++ struct iwl_mvm_diversity_iter_data data = { ++ .ctxt = ctxt, ++ .result = true, ++ }; + + lockdep_assert_held(&mvm->mutex); + +@@ -711,9 +725,9 @@ bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm) + + ieee80211_iterate_active_interfaces_atomic( + mvm->hw, IEEE80211_IFACE_ITER_NORMAL, +- iwl_mvm_diversity_iter, &result); ++ iwl_mvm_diversity_iter, &data); + +- return result; ++ return data.result; + } + + void iwl_mvm_send_low_latency_cmd(struct iwl_mvm *mvm, +diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/ctxt-info-gen3.c b/drivers/net/wireless/intel/iwlwifi/pcie/ctxt-info-gen3.c +index cecc32e7dbe8a..2dbc51daa2f8a 100644 +--- a/drivers/net/wireless/intel/iwlwifi/pcie/ctxt-info-gen3.c ++++ b/drivers/net/wireless/intel/iwlwifi/pcie/ctxt-info-gen3.c +@@ -79,7 +79,6 @@ int iwl_pcie_ctxt_info_gen3_init(struct iwl_trans *trans, + struct iwl_prph_scratch *prph_scratch; + struct iwl_prph_scratch_ctrl_cfg *prph_sc_ctrl; + struct iwl_prph_info *prph_info; +- void *iml_img; + u32 control_flags = 0; + int ret; + int cmdq_size = max_t(u32, IWL_CMD_QUEUE_SIZE, +@@ -187,14 +186,15 @@ int iwl_pcie_ctxt_info_gen3_init(struct iwl_trans *trans, + trans_pcie->prph_scratch = prph_scratch; + + /* Allocate IML */ +- iml_img = dma_alloc_coherent(trans->dev, trans->iml_len, +- &trans_pcie->iml_dma_addr, GFP_KERNEL); +- if (!iml_img) { ++ trans_pcie->iml = dma_alloc_coherent(trans->dev, trans->iml_len, ++ &trans_pcie->iml_dma_addr, ++ GFP_KERNEL); ++ if (!trans_pcie->iml) { + ret = -ENOMEM; + goto err_free_ctxt_info; + } + +- memcpy(iml_img, trans->iml, trans->iml_len); ++ memcpy(trans_pcie->iml, trans->iml, trans->iml_len); + + iwl_enable_fw_load_int_ctx_info(trans); + +@@ -243,6 +243,11 @@ void iwl_pcie_ctxt_info_gen3_free(struct iwl_trans *trans) + trans_pcie->ctxt_info_dma_addr = 0; + trans_pcie->ctxt_info_gen3 = NULL; + ++ dma_free_coherent(trans->dev, trans->iml_len, trans_pcie->iml, ++ trans_pcie->iml_dma_addr); ++ trans_pcie->iml_dma_addr = 0; ++ trans_pcie->iml = NULL; ++ + iwl_pcie_ctxt_info_free_fw_img(trans); + + dma_free_coherent(trans->dev, sizeof(*trans_pcie->prph_scratch), +diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/internal.h b/drivers/net/wireless/intel/iwlwifi/pcie/internal.h +index d9688c7bed07c..53af3f29eab8e 100644 +--- a/drivers/net/wireless/intel/iwlwifi/pcie/internal.h ++++ b/drivers/net/wireless/intel/iwlwifi/pcie/internal.h +@@ -279,6 +279,8 @@ struct cont_rec { + * Context information addresses will be taken from here. + * This is driver's local copy for keeping track of size and + * count for allocating and freeing the memory. ++ * @iml: image loader image virtual address ++ * @iml_dma_addr: image loader image DMA address + * @trans: pointer to the generic transport area + * @scd_base_addr: scheduler sram base address in SRAM + * @kw: keep warm address +@@ -329,6 +331,7 @@ struct iwl_trans_pcie { + }; + struct iwl_prph_info *prph_info; + struct iwl_prph_scratch *prph_scratch; ++ void *iml; + dma_addr_t ctxt_info_dma_addr; + dma_addr_t prph_info_dma_addr; + dma_addr_t prph_scratch_dma_addr; +diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/trans-gen2.c b/drivers/net/wireless/intel/iwlwifi/pcie/trans-gen2.c +index af9412bd697ee..7996b05a51c2c 100644 +--- a/drivers/net/wireless/intel/iwlwifi/pcie/trans-gen2.c ++++ b/drivers/net/wireless/intel/iwlwifi/pcie/trans-gen2.c +@@ -254,7 +254,8 @@ void iwl_trans_pcie_gen2_fw_alive(struct iwl_trans *trans, u32 scd_addr) + /* now that we got alive we can free the fw image & the context info. + * paging memory cannot be freed included since FW will still use it + */ +- iwl_pcie_ctxt_info_free(trans); ++ if (trans->trans_cfg->device_family < IWL_DEVICE_FAMILY_AX210) ++ iwl_pcie_ctxt_info_free(trans); + + /* + * Re-enable all the interrupts, including the RF-Kill one, now that +diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c +index 30b39cb4056a3..1005bef16b61a 100644 +--- a/drivers/net/wireless/mac80211_hwsim.c ++++ b/drivers/net/wireless/mac80211_hwsim.c +@@ -626,6 +626,7 @@ struct mac80211_hwsim_data { + u32 ciphers[ARRAY_SIZE(hwsim_ciphers)]; + + struct mac_address addresses[2]; ++ struct ieee80211_chanctx_conf *chanctx; + int channels, idx; + bool use_chanctx; + bool destroy_on_close; +@@ -1257,7 +1258,8 @@ static inline u16 trans_tx_rate_flags_ieee2hwsim(struct ieee80211_tx_rate *rate) + + static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw, + struct sk_buff *my_skb, +- int dst_portid) ++ int dst_portid, ++ struct ieee80211_channel *channel) + { + struct sk_buff *skb; + struct mac80211_hwsim_data *data = hw->priv; +@@ -1312,7 +1314,7 @@ static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw, + if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags)) + goto nla_put_failure; + +- if (nla_put_u32(skb, HWSIM_ATTR_FREQ, data->channel->center_freq)) ++ if (nla_put_u32(skb, HWSIM_ATTR_FREQ, channel->center_freq)) + goto nla_put_failure; + + /* We get the tx control (rate and retries) info*/ +@@ -1659,7 +1661,7 @@ static void mac80211_hwsim_tx(struct ieee80211_hw *hw, + _portid = READ_ONCE(data->wmediumd); + + if (_portid || hwsim_virtio_enabled) +- return mac80211_hwsim_tx_frame_nl(hw, skb, _portid); ++ return mac80211_hwsim_tx_frame_nl(hw, skb, _portid, channel); + + /* NO wmediumd detected, perfect medium simulation */ + data->tx_pkts++; +@@ -1775,7 +1777,7 @@ static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw, + mac80211_hwsim_monitor_rx(hw, skb, chan); + + if (_pid || hwsim_virtio_enabled) +- return mac80211_hwsim_tx_frame_nl(hw, skb, _pid); ++ return mac80211_hwsim_tx_frame_nl(hw, skb, _pid, chan); + + mac80211_hwsim_tx_frame_no_nl(hw, skb, chan); + dev_kfree_skb(skb); +@@ -2514,6 +2516,11 @@ static int mac80211_hwsim_croc(struct ieee80211_hw *hw, + static int mac80211_hwsim_add_chanctx(struct ieee80211_hw *hw, + struct ieee80211_chanctx_conf *ctx) + { ++ struct mac80211_hwsim_data *hwsim = hw->priv; ++ ++ mutex_lock(&hwsim->mutex); ++ hwsim->chanctx = ctx; ++ mutex_unlock(&hwsim->mutex); + hwsim_set_chanctx_magic(ctx); + wiphy_dbg(hw->wiphy, + "add channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n", +@@ -2525,6 +2532,11 @@ static int mac80211_hwsim_add_chanctx(struct ieee80211_hw *hw, + static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw, + struct ieee80211_chanctx_conf *ctx) + { ++ struct mac80211_hwsim_data *hwsim = hw->priv; ++ ++ mutex_lock(&hwsim->mutex); ++ hwsim->chanctx = NULL; ++ mutex_unlock(&hwsim->mutex); + wiphy_dbg(hw->wiphy, + "remove channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n", + ctx->def.chan->center_freq, ctx->def.width, +@@ -2537,6 +2549,11 @@ static void mac80211_hwsim_change_chanctx(struct ieee80211_hw *hw, + struct ieee80211_chanctx_conf *ctx, + u32 changed) + { ++ struct mac80211_hwsim_data *hwsim = hw->priv; ++ ++ mutex_lock(&hwsim->mutex); ++ hwsim->chanctx = ctx; ++ mutex_unlock(&hwsim->mutex); + hwsim_check_chanctx_magic(ctx); + wiphy_dbg(hw->wiphy, + "change channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n", +@@ -3129,6 +3146,7 @@ static int mac80211_hwsim_new_radio(struct genl_info *info, + hw->wiphy->max_remain_on_channel_duration = 1000; + data->if_combination.radar_detect_widths = 0; + data->if_combination.num_different_channels = data->channels; ++ data->chanctx = NULL; + } else { + data->if_combination.num_different_channels = 1; + data->if_combination.radar_detect_widths = +@@ -3638,6 +3656,7 @@ static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2, + int frame_data_len; + void *frame_data; + struct sk_buff *skb = NULL; ++ struct ieee80211_channel *channel = NULL; + + if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] || + !info->attrs[HWSIM_ATTR_FRAME] || +@@ -3664,6 +3683,17 @@ static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2, + if (!data2) + goto out; + ++ if (data2->use_chanctx) { ++ if (data2->tmp_chan) ++ channel = data2->tmp_chan; ++ else if (data2->chanctx) ++ channel = data2->chanctx->def.chan; ++ } else { ++ channel = data2->channel; ++ } ++ if (!channel) ++ goto out; ++ + if (!hwsim_virtio_enabled) { + if (hwsim_net_get_netgroup(genl_info_net(info)) != + data2->netgroup) +@@ -3675,7 +3705,7 @@ static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2, + + /* check if radio is configured properly */ + +- if (data2->idle || !data2->started) ++ if ((data2->idle && !data2->tmp_chan) || !data2->started) + goto out; + + /* A frame is received from user space */ +@@ -3688,18 +3718,16 @@ static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2, + mutex_lock(&data2->mutex); + rx_status.freq = nla_get_u32(info->attrs[HWSIM_ATTR_FREQ]); + +- if (rx_status.freq != data2->channel->center_freq && +- (!data2->tmp_chan || +- rx_status.freq != data2->tmp_chan->center_freq)) { ++ if (rx_status.freq != channel->center_freq) { + mutex_unlock(&data2->mutex); + goto out; + } + mutex_unlock(&data2->mutex); + } else { +- rx_status.freq = data2->channel->center_freq; ++ rx_status.freq = channel->center_freq; + } + +- rx_status.band = data2->channel->band; ++ rx_status.band = channel->band; + rx_status.rate_idx = nla_get_u32(info->attrs[HWSIM_ATTR_RX_RATE]); + rx_status.signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]); + +diff --git a/drivers/net/wireless/marvell/mwifiex/main.c b/drivers/net/wireless/marvell/mwifiex/main.c +index 529dfd8b7ae85..17399d4aa1290 100644 +--- a/drivers/net/wireless/marvell/mwifiex/main.c ++++ b/drivers/net/wireless/marvell/mwifiex/main.c +@@ -1445,11 +1445,18 @@ static void mwifiex_uninit_sw(struct mwifiex_adapter *adapter) + if (!priv) + continue; + rtnl_lock(); +- wiphy_lock(adapter->wiphy); + if (priv->netdev && +- priv->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) ++ priv->wdev.iftype != NL80211_IFTYPE_UNSPECIFIED) { ++ /* ++ * Close the netdev now, because if we do it later, the ++ * netdev notifiers will need to acquire the wiphy lock ++ * again --> deadlock. ++ */ ++ dev_close(priv->wdev.netdev); ++ wiphy_lock(adapter->wiphy); + mwifiex_del_virtual_intf(adapter->wiphy, &priv->wdev); +- wiphy_unlock(adapter->wiphy); ++ wiphy_unlock(adapter->wiphy); ++ } + rtnl_unlock(); + } + +diff --git a/drivers/net/wireless/mediatek/mt76/dma.c b/drivers/net/wireless/mediatek/mt76/dma.c +index 426787f4b2ae4..ee0acde53a609 100644 +--- a/drivers/net/wireless/mediatek/mt76/dma.c ++++ b/drivers/net/wireless/mediatek/mt76/dma.c +@@ -349,6 +349,9 @@ mt76_dma_tx_queue_skb(struct mt76_dev *dev, struct mt76_queue *q, + struct sk_buff *skb, struct mt76_wcid *wcid, + struct ieee80211_sta *sta) + { ++ struct ieee80211_tx_status status = { ++ .sta = sta, ++ }; + struct mt76_tx_info tx_info = { + .skb = skb, + }; +@@ -360,11 +363,9 @@ mt76_dma_tx_queue_skb(struct mt76_dev *dev, struct mt76_queue *q, + u8 *txwi; + + t = mt76_get_txwi(dev); +- if (!t) { +- hw = mt76_tx_status_get_hw(dev, skb); +- ieee80211_free_txskb(hw, skb); +- return -ENOMEM; +- } ++ if (!t) ++ goto free_skb; ++ + txwi = mt76_get_txwi_ptr(dev, t); + + skb->prev = skb->next = NULL; +@@ -427,8 +428,13 @@ free: + } + #endif + +- dev_kfree_skb(tx_info.skb); + mt76_put_txwi(dev, t); ++ ++free_skb: ++ status.skb = tx_info.skb; ++ hw = mt76_tx_status_get_hw(dev, tx_info.skb); ++ ieee80211_tx_status_ext(hw, &status); ++ + return ret; + } + +diff --git a/drivers/net/wireless/mediatek/mt76/mt76.h b/drivers/net/wireless/mediatek/mt76/mt76.h +index 967fe3e11d94e..1ed63eddfcf2b 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76.h ++++ b/drivers/net/wireless/mediatek/mt76/mt76.h +@@ -85,6 +85,22 @@ enum mt76_rxq_id { + __MT_RXQ_MAX + }; + ++enum mt76_cipher_type { ++ MT_CIPHER_NONE, ++ MT_CIPHER_WEP40, ++ MT_CIPHER_TKIP, ++ MT_CIPHER_TKIP_NO_MIC, ++ MT_CIPHER_AES_CCMP, ++ MT_CIPHER_WEP104, ++ MT_CIPHER_BIP_CMAC_128, ++ MT_CIPHER_WEP128, ++ MT_CIPHER_WAPI, ++ MT_CIPHER_CCMP_CCX, ++ MT_CIPHER_CCMP_256, ++ MT_CIPHER_GCMP, ++ MT_CIPHER_GCMP_256, ++}; ++ + struct mt76_queue_buf { + dma_addr_t addr; + u16 len; +diff --git a/drivers/net/wireless/mediatek/mt76/mt7603/mac.c b/drivers/net/wireless/mediatek/mt76/mt7603/mac.c +index cc4e7bc482940..92a7b45fbc157 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7603/mac.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7603/mac.c +@@ -564,14 +564,27 @@ mt7603_mac_fill_rx(struct mt7603_dev *dev, struct sk_buff *skb) + u8 *data = (u8 *)rxd; + + if (status->flag & RX_FLAG_DECRYPTED) { +- status->iv[0] = data[5]; +- status->iv[1] = data[4]; +- status->iv[2] = data[3]; +- status->iv[3] = data[2]; +- status->iv[4] = data[1]; +- status->iv[5] = data[0]; +- +- insert_ccmp_hdr = FIELD_GET(MT_RXD2_NORMAL_FRAG, rxd2); ++ switch (FIELD_GET(MT_RXD2_NORMAL_SEC_MODE, rxd2)) { ++ case MT_CIPHER_AES_CCMP: ++ case MT_CIPHER_CCMP_CCX: ++ case MT_CIPHER_CCMP_256: ++ insert_ccmp_hdr = ++ FIELD_GET(MT_RXD2_NORMAL_FRAG, rxd2); ++ fallthrough; ++ case MT_CIPHER_TKIP: ++ case MT_CIPHER_TKIP_NO_MIC: ++ case MT_CIPHER_GCMP: ++ case MT_CIPHER_GCMP_256: ++ status->iv[0] = data[5]; ++ status->iv[1] = data[4]; ++ status->iv[2] = data[3]; ++ status->iv[3] = data[2]; ++ status->iv[4] = data[1]; ++ status->iv[5] = data[0]; ++ break; ++ default: ++ break; ++ } + } + + rxd += 4; +@@ -828,7 +841,7 @@ void mt7603_wtbl_set_rates(struct mt7603_dev *dev, struct mt7603_sta *sta, + sta->wcid.tx_info |= MT_WCID_TX_INFO_SET; + } + +-static enum mt7603_cipher_type ++static enum mt76_cipher_type + mt7603_mac_get_key_info(struct ieee80211_key_conf *key, u8 *key_data) + { + memset(key_data, 0, 32); +@@ -860,7 +873,7 @@ mt7603_mac_get_key_info(struct ieee80211_key_conf *key, u8 *key_data) + int mt7603_wtbl_set_key(struct mt7603_dev *dev, int wcid, + struct ieee80211_key_conf *key) + { +- enum mt7603_cipher_type cipher; ++ enum mt76_cipher_type cipher; + u32 addr = mt7603_wtbl3_addr(wcid); + u8 key_data[32]; + int key_len = sizeof(key_data); +diff --git a/drivers/net/wireless/mediatek/mt76/mt7603/regs.h b/drivers/net/wireless/mediatek/mt76/mt7603/regs.h +index 6741e69071940..3b901090b29c6 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7603/regs.h ++++ b/drivers/net/wireless/mediatek/mt76/mt7603/regs.h +@@ -765,16 +765,4 @@ enum { + #define MT_WTBL1_OR (MT_WTBL1_BASE + 0x2300) + #define MT_WTBL1_OR_PSM_WRITE BIT(31) + +-enum mt7603_cipher_type { +- MT_CIPHER_NONE, +- MT_CIPHER_WEP40, +- MT_CIPHER_TKIP, +- MT_CIPHER_TKIP_NO_MIC, +- MT_CIPHER_AES_CCMP, +- MT_CIPHER_WEP104, +- MT_CIPHER_BIP_CMAC_128, +- MT_CIPHER_WEP128, +- MT_CIPHER_WAPI, +-}; +- + #endif +diff --git a/drivers/net/wireless/mediatek/mt76/mt7615/mac.c b/drivers/net/wireless/mediatek/mt76/mt7615/mac.c +index d06e61cadc411..1da59c16e8200 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7615/mac.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7615/mac.c +@@ -57,6 +57,33 @@ static const struct mt7615_dfs_radar_spec jp_radar_specs = { + }, + }; + ++static enum mt76_cipher_type ++mt7615_mac_get_cipher(int cipher) ++{ ++ switch (cipher) { ++ case WLAN_CIPHER_SUITE_WEP40: ++ return MT_CIPHER_WEP40; ++ case WLAN_CIPHER_SUITE_WEP104: ++ return MT_CIPHER_WEP104; ++ case WLAN_CIPHER_SUITE_TKIP: ++ return MT_CIPHER_TKIP; ++ case WLAN_CIPHER_SUITE_AES_CMAC: ++ return MT_CIPHER_BIP_CMAC_128; ++ case WLAN_CIPHER_SUITE_CCMP: ++ return MT_CIPHER_AES_CCMP; ++ case WLAN_CIPHER_SUITE_CCMP_256: ++ return MT_CIPHER_CCMP_256; ++ case WLAN_CIPHER_SUITE_GCMP: ++ return MT_CIPHER_GCMP; ++ case WLAN_CIPHER_SUITE_GCMP_256: ++ return MT_CIPHER_GCMP_256; ++ case WLAN_CIPHER_SUITE_SMS4: ++ return MT_CIPHER_WAPI; ++ default: ++ return MT_CIPHER_NONE; ++ } ++} ++ + static struct mt76_wcid *mt7615_rx_get_wcid(struct mt7615_dev *dev, + u8 idx, bool unicast) + { +@@ -297,14 +324,27 @@ static int mt7615_mac_fill_rx(struct mt7615_dev *dev, struct sk_buff *skb) + u8 *data = (u8 *)rxd; + + if (status->flag & RX_FLAG_DECRYPTED) { +- status->iv[0] = data[5]; +- status->iv[1] = data[4]; +- status->iv[2] = data[3]; +- status->iv[3] = data[2]; +- status->iv[4] = data[1]; +- status->iv[5] = data[0]; +- +- insert_ccmp_hdr = FIELD_GET(MT_RXD2_NORMAL_FRAG, rxd2); ++ switch (FIELD_GET(MT_RXD2_NORMAL_SEC_MODE, rxd2)) { ++ case MT_CIPHER_AES_CCMP: ++ case MT_CIPHER_CCMP_CCX: ++ case MT_CIPHER_CCMP_256: ++ insert_ccmp_hdr = ++ FIELD_GET(MT_RXD2_NORMAL_FRAG, rxd2); ++ fallthrough; ++ case MT_CIPHER_TKIP: ++ case MT_CIPHER_TKIP_NO_MIC: ++ case MT_CIPHER_GCMP: ++ case MT_CIPHER_GCMP_256: ++ status->iv[0] = data[5]; ++ status->iv[1] = data[4]; ++ status->iv[2] = data[3]; ++ status->iv[3] = data[2]; ++ status->iv[4] = data[1]; ++ status->iv[5] = data[0]; ++ break; ++ default: ++ break; ++ } + } + rxd += 4; + if ((u8 *)rxd - skb->data >= skb->len) +@@ -1037,7 +1077,7 @@ EXPORT_SYMBOL_GPL(mt7615_mac_set_rates); + static int + mt7615_mac_wtbl_update_key(struct mt7615_dev *dev, struct mt76_wcid *wcid, + struct ieee80211_key_conf *key, +- enum mt7615_cipher_type cipher, u16 cipher_mask, ++ enum mt76_cipher_type cipher, u16 cipher_mask, + enum set_key_cmd cmd) + { + u32 addr = mt7615_mac_wtbl_addr(dev, wcid->idx) + 30 * 4; +@@ -1077,7 +1117,7 @@ mt7615_mac_wtbl_update_key(struct mt7615_dev *dev, struct mt76_wcid *wcid, + + static int + mt7615_mac_wtbl_update_pk(struct mt7615_dev *dev, struct mt76_wcid *wcid, +- enum mt7615_cipher_type cipher, u16 cipher_mask, ++ enum mt76_cipher_type cipher, u16 cipher_mask, + int keyidx, enum set_key_cmd cmd) + { + u32 addr = mt7615_mac_wtbl_addr(dev, wcid->idx), w0, w1; +@@ -1116,7 +1156,7 @@ mt7615_mac_wtbl_update_pk(struct mt7615_dev *dev, struct mt76_wcid *wcid, + + static void + mt7615_mac_wtbl_update_cipher(struct mt7615_dev *dev, struct mt76_wcid *wcid, +- enum mt7615_cipher_type cipher, u16 cipher_mask, ++ enum mt76_cipher_type cipher, u16 cipher_mask, + enum set_key_cmd cmd) + { + u32 addr = mt7615_mac_wtbl_addr(dev, wcid->idx); +@@ -1142,7 +1182,7 @@ int __mt7615_mac_wtbl_set_key(struct mt7615_dev *dev, + struct ieee80211_key_conf *key, + enum set_key_cmd cmd) + { +- enum mt7615_cipher_type cipher; ++ enum mt76_cipher_type cipher; + u16 cipher_mask = wcid->cipher; + int err; + +@@ -1194,22 +1234,20 @@ static bool mt7615_fill_txs(struct mt7615_dev *dev, struct mt7615_sta *sta, + int first_idx = 0, last_idx; + int i, idx, count; + bool fixed_rate, ack_timeout; +- bool probe, ampdu, cck = false; ++ bool ampdu, cck = false; + bool rs_idx; + u32 rate_set_tsf; + u32 final_rate, final_rate_flags, final_nss, txs; + +- fixed_rate = info->status.rates[0].count; +- probe = !!(info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE); +- + txs = le32_to_cpu(txs_data[1]); +- ampdu = !fixed_rate && (txs & MT_TXS1_AMPDU); ++ ampdu = txs & MT_TXS1_AMPDU; + + txs = le32_to_cpu(txs_data[3]); + count = FIELD_GET(MT_TXS3_TX_COUNT, txs); + last_idx = FIELD_GET(MT_TXS3_LAST_TX_RATE, txs); + + txs = le32_to_cpu(txs_data[0]); ++ fixed_rate = txs & MT_TXS0_FIXED_RATE; + final_rate = FIELD_GET(MT_TXS0_TX_RATE, txs); + ack_timeout = txs & MT_TXS0_ACK_TIMEOUT; + +@@ -1231,7 +1269,7 @@ static bool mt7615_fill_txs(struct mt7615_dev *dev, struct mt7615_sta *sta, + + first_idx = max_t(int, 0, last_idx - (count - 1) / MT7615_RATE_RETRY); + +- if (fixed_rate && !probe) { ++ if (fixed_rate) { + info->status.rates[0].count = count; + i = 0; + goto out; +diff --git a/drivers/net/wireless/mediatek/mt76/mt7615/mac.h b/drivers/net/wireless/mediatek/mt76/mt7615/mac.h +index 169f4e17b5b42..1fb07799671bb 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7615/mac.h ++++ b/drivers/net/wireless/mediatek/mt76/mt7615/mac.h +@@ -375,48 +375,6 @@ struct mt7615_dfs_radar_spec { + struct mt7615_dfs_pattern radar_pattern[16]; + }; + +-enum mt7615_cipher_type { +- MT_CIPHER_NONE, +- MT_CIPHER_WEP40, +- MT_CIPHER_TKIP, +- MT_CIPHER_TKIP_NO_MIC, +- MT_CIPHER_AES_CCMP, +- MT_CIPHER_WEP104, +- MT_CIPHER_BIP_CMAC_128, +- MT_CIPHER_WEP128, +- MT_CIPHER_WAPI, +- MT_CIPHER_CCMP_256 = 10, +- MT_CIPHER_GCMP, +- MT_CIPHER_GCMP_256, +-}; +- +-static inline enum mt7615_cipher_type +-mt7615_mac_get_cipher(int cipher) +-{ +- switch (cipher) { +- case WLAN_CIPHER_SUITE_WEP40: +- return MT_CIPHER_WEP40; +- case WLAN_CIPHER_SUITE_WEP104: +- return MT_CIPHER_WEP104; +- case WLAN_CIPHER_SUITE_TKIP: +- return MT_CIPHER_TKIP; +- case WLAN_CIPHER_SUITE_AES_CMAC: +- return MT_CIPHER_BIP_CMAC_128; +- case WLAN_CIPHER_SUITE_CCMP: +- return MT_CIPHER_AES_CCMP; +- case WLAN_CIPHER_SUITE_CCMP_256: +- return MT_CIPHER_CCMP_256; +- case WLAN_CIPHER_SUITE_GCMP: +- return MT_CIPHER_GCMP; +- case WLAN_CIPHER_SUITE_GCMP_256: +- return MT_CIPHER_GCMP_256; +- case WLAN_CIPHER_SUITE_SMS4: +- return MT_CIPHER_WAPI; +- default: +- return MT_CIPHER_NONE; +- } +-} +- + static inline struct mt7615_txp_common * + mt7615_txwi_to_txp(struct mt76_dev *dev, struct mt76_txwi_cache *t) + { +diff --git a/drivers/net/wireless/mediatek/mt76/mt76x02_mac.c b/drivers/net/wireless/mediatek/mt76/mt76x02_mac.c +index 771bad60e1bc7..b21edc8e86e11 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76x02_mac.c ++++ b/drivers/net/wireless/mediatek/mt76/mt76x02_mac.c +@@ -34,24 +34,24 @@ mt76x02_mac_get_key_info(struct ieee80211_key_conf *key, u8 *key_data) + { + memset(key_data, 0, 32); + if (!key) +- return MT_CIPHER_NONE; ++ return MT76X02_CIPHER_NONE; + + if (key->keylen > 32) +- return MT_CIPHER_NONE; ++ return MT76X02_CIPHER_NONE; + + memcpy(key_data, key->key, key->keylen); + + switch (key->cipher) { + case WLAN_CIPHER_SUITE_WEP40: +- return MT_CIPHER_WEP40; ++ return MT76X02_CIPHER_WEP40; + case WLAN_CIPHER_SUITE_WEP104: +- return MT_CIPHER_WEP104; ++ return MT76X02_CIPHER_WEP104; + case WLAN_CIPHER_SUITE_TKIP: +- return MT_CIPHER_TKIP; ++ return MT76X02_CIPHER_TKIP; + case WLAN_CIPHER_SUITE_CCMP: +- return MT_CIPHER_AES_CCMP; ++ return MT76X02_CIPHER_AES_CCMP; + default: +- return MT_CIPHER_NONE; ++ return MT76X02_CIPHER_NONE; + } + } + +@@ -63,7 +63,7 @@ int mt76x02_mac_shared_key_setup(struct mt76x02_dev *dev, u8 vif_idx, + u32 val; + + cipher = mt76x02_mac_get_key_info(key, key_data); +- if (cipher == MT_CIPHER_NONE && key) ++ if (cipher == MT76X02_CIPHER_NONE && key) + return -EOPNOTSUPP; + + val = mt76_rr(dev, MT_SKEY_MODE(vif_idx)); +@@ -91,10 +91,10 @@ void mt76x02_mac_wcid_sync_pn(struct mt76x02_dev *dev, u8 idx, + eiv = mt76_rr(dev, MT_WCID_IV(idx) + 4); + + pn = (u64)eiv << 16; +- if (cipher == MT_CIPHER_TKIP) { ++ if (cipher == MT76X02_CIPHER_TKIP) { + pn |= (iv >> 16) & 0xff; + pn |= (iv & 0xff) << 8; +- } else if (cipher >= MT_CIPHER_AES_CCMP) { ++ } else if (cipher >= MT76X02_CIPHER_AES_CCMP) { + pn |= iv & 0xffff; + } else { + return; +@@ -112,7 +112,7 @@ int mt76x02_mac_wcid_set_key(struct mt76x02_dev *dev, u8 idx, + u64 pn; + + cipher = mt76x02_mac_get_key_info(key, key_data); +- if (cipher == MT_CIPHER_NONE && key) ++ if (cipher == MT76X02_CIPHER_NONE && key) + return -EOPNOTSUPP; + + mt76_wr_copy(dev, MT_WCID_KEY(idx), key_data, sizeof(key_data)); +@@ -126,16 +126,16 @@ int mt76x02_mac_wcid_set_key(struct mt76x02_dev *dev, u8 idx, + pn = atomic64_read(&key->tx_pn); + + iv_data[3] = key->keyidx << 6; +- if (cipher >= MT_CIPHER_TKIP) { ++ if (cipher >= MT76X02_CIPHER_TKIP) { + iv_data[3] |= 0x20; + put_unaligned_le32(pn >> 16, &iv_data[4]); + } + +- if (cipher == MT_CIPHER_TKIP) { ++ if (cipher == MT76X02_CIPHER_TKIP) { + iv_data[0] = (pn >> 8) & 0xff; + iv_data[1] = (iv_data[0] | 0x20) & 0x7f; + iv_data[2] = pn & 0xff; +- } else if (cipher >= MT_CIPHER_AES_CCMP) { ++ } else if (cipher >= MT76X02_CIPHER_AES_CCMP) { + put_unaligned_le16((pn & 0xffff), &iv_data[0]); + } + } +diff --git a/drivers/net/wireless/mediatek/mt76/mt76x02_regs.h b/drivers/net/wireless/mediatek/mt76/mt76x02_regs.h +index 3e722276b5c2f..fa7872ac22bf8 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt76x02_regs.h ++++ b/drivers/net/wireless/mediatek/mt76/mt76x02_regs.h +@@ -692,15 +692,15 @@ struct mt76_wcid_key { + } __packed __aligned(4); + + enum mt76x02_cipher_type { +- MT_CIPHER_NONE, +- MT_CIPHER_WEP40, +- MT_CIPHER_WEP104, +- MT_CIPHER_TKIP, +- MT_CIPHER_AES_CCMP, +- MT_CIPHER_CKIP40, +- MT_CIPHER_CKIP104, +- MT_CIPHER_CKIP128, +- MT_CIPHER_WAPI, ++ MT76X02_CIPHER_NONE, ++ MT76X02_CIPHER_WEP40, ++ MT76X02_CIPHER_WEP104, ++ MT76X02_CIPHER_TKIP, ++ MT76X02_CIPHER_AES_CCMP, ++ MT76X02_CIPHER_CKIP40, ++ MT76X02_CIPHER_CKIP104, ++ MT76X02_CIPHER_CKIP128, ++ MT76X02_CIPHER_WAPI, + }; + + #endif +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/eeprom.h b/drivers/net/wireless/mediatek/mt76/mt7915/eeprom.h +index 3ee8c27bb61b7..40a51d99a7814 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/eeprom.h ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/eeprom.h +@@ -116,12 +116,15 @@ static inline bool + mt7915_tssi_enabled(struct mt7915_dev *dev, enum nl80211_band band) + { + u8 *eep = dev->mt76.eeprom.data; ++ u8 val = eep[MT_EE_WIFI_CONF + 7]; + +- /* TODO: DBDC */ +- if (band == NL80211_BAND_5GHZ) +- return eep[MT_EE_WIFI_CONF + 7] & MT_EE_WIFI_CONF7_TSSI0_5G; ++ if (band == NL80211_BAND_2GHZ) ++ return val & MT_EE_WIFI_CONF7_TSSI0_2G; ++ ++ if (dev->dbdc_support) ++ return val & MT_EE_WIFI_CONF7_TSSI1_5G; + else +- return eep[MT_EE_WIFI_CONF + 7] & MT_EE_WIFI_CONF7_TSSI0_2G; ++ return val & MT_EE_WIFI_CONF7_TSSI0_5G; + } + + extern const struct sku_group mt7915_sku_groups[]; +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/init.c b/drivers/net/wireless/mediatek/mt76/mt7915/init.c +index c7d4268d860af..5ab34606c021b 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/init.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/init.c +@@ -452,6 +452,9 @@ mt7915_set_stream_he_txbf_caps(struct ieee80211_sta_he_cap *he_cap, + if (nss < 2) + return; + ++ /* the maximum cap is 4 x 3, (Nr, Nc) = (3, 2) */ ++ elem->phy_cap_info[7] |= min_t(int, nss - 1, 2) << 3; ++ + if (vif != NL80211_IFTYPE_AP) + return; + +@@ -465,9 +468,6 @@ mt7915_set_stream_he_txbf_caps(struct ieee80211_sta_he_cap *he_cap, + c = IEEE80211_HE_PHY_CAP6_TRIG_SU_BEAMFORMER_FB | + IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMER_FB; + elem->phy_cap_info[6] |= c; +- +- /* the maximum cap is 4 x 3, (Nr, Nc) = (3, 2) */ +- elem->phy_cap_info[7] |= min_t(int, nss - 1, 2) << 3; + } + + static void +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/mac.c b/drivers/net/wireless/mediatek/mt76/mt7915/mac.c +index 819670767521f..be40b07775171 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/mac.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/mac.c +@@ -404,14 +404,27 @@ int mt7915_mac_fill_rx(struct mt7915_dev *dev, struct sk_buff *skb) + u8 *data = (u8 *)rxd; + + if (status->flag & RX_FLAG_DECRYPTED) { +- status->iv[0] = data[5]; +- status->iv[1] = data[4]; +- status->iv[2] = data[3]; +- status->iv[3] = data[2]; +- status->iv[4] = data[1]; +- status->iv[5] = data[0]; +- +- insert_ccmp_hdr = FIELD_GET(MT_RXD2_NORMAL_FRAG, rxd2); ++ switch (FIELD_GET(MT_RXD1_NORMAL_SEC_MODE, rxd1)) { ++ case MT_CIPHER_AES_CCMP: ++ case MT_CIPHER_CCMP_CCX: ++ case MT_CIPHER_CCMP_256: ++ insert_ccmp_hdr = ++ FIELD_GET(MT_RXD2_NORMAL_FRAG, rxd2); ++ fallthrough; ++ case MT_CIPHER_TKIP: ++ case MT_CIPHER_TKIP_NO_MIC: ++ case MT_CIPHER_GCMP: ++ case MT_CIPHER_GCMP_256: ++ status->iv[0] = data[5]; ++ status->iv[1] = data[4]; ++ status->iv[2] = data[3]; ++ status->iv[3] = data[2]; ++ status->iv[4] = data[1]; ++ status->iv[5] = data[0]; ++ break; ++ default: ++ break; ++ } + } + rxd += 4; + if ((u8 *)rxd - skb->data >= skb->len) +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/mcu.c b/drivers/net/wireless/mediatek/mt76/mt7915/mcu.c +index f069a5a03e145..22c791b084baf 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/mcu.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/mcu.c +@@ -88,28 +88,28 @@ struct mt7915_fw_region { + #define HE_PHY(p, c) u8_get_bits(c, IEEE80211_HE_PHY_##p) + #define HE_MAC(m, c) u8_get_bits(c, IEEE80211_HE_MAC_##m) + +-static enum mt7915_cipher_type ++static enum mcu_cipher_type + mt7915_mcu_get_cipher(int cipher) + { + switch (cipher) { + case WLAN_CIPHER_SUITE_WEP40: +- return MT_CIPHER_WEP40; ++ return MCU_CIPHER_WEP40; + case WLAN_CIPHER_SUITE_WEP104: +- return MT_CIPHER_WEP104; ++ return MCU_CIPHER_WEP104; + case WLAN_CIPHER_SUITE_TKIP: +- return MT_CIPHER_TKIP; ++ return MCU_CIPHER_TKIP; + case WLAN_CIPHER_SUITE_AES_CMAC: +- return MT_CIPHER_BIP_CMAC_128; ++ return MCU_CIPHER_BIP_CMAC_128; + case WLAN_CIPHER_SUITE_CCMP: +- return MT_CIPHER_AES_CCMP; ++ return MCU_CIPHER_AES_CCMP; + case WLAN_CIPHER_SUITE_CCMP_256: +- return MT_CIPHER_CCMP_256; ++ return MCU_CIPHER_CCMP_256; + case WLAN_CIPHER_SUITE_GCMP: +- return MT_CIPHER_GCMP; ++ return MCU_CIPHER_GCMP; + case WLAN_CIPHER_SUITE_GCMP_256: +- return MT_CIPHER_GCMP_256; ++ return MCU_CIPHER_GCMP_256; + case WLAN_CIPHER_SUITE_SMS4: +- return MT_CIPHER_WAPI; ++ return MCU_CIPHER_WAPI; + default: + return MT_CIPHER_NONE; + } +@@ -1060,14 +1060,14 @@ mt7915_mcu_sta_key_tlv(struct mt7915_sta *msta, struct sk_buff *skb, + sec_key = &sec->key[0]; + sec_key->cipher_len = sizeof(*sec_key); + +- if (cipher == MT_CIPHER_BIP_CMAC_128) { +- sec_key->cipher_id = MT_CIPHER_AES_CCMP; ++ if (cipher == MCU_CIPHER_BIP_CMAC_128) { ++ sec_key->cipher_id = MCU_CIPHER_AES_CCMP; + sec_key->key_id = bip->keyidx; + sec_key->key_len = 16; + memcpy(sec_key->key, bip->key, 16); + + sec_key = &sec->key[1]; +- sec_key->cipher_id = MT_CIPHER_BIP_CMAC_128; ++ sec_key->cipher_id = MCU_CIPHER_BIP_CMAC_128; + sec_key->cipher_len = sizeof(*sec_key); + sec_key->key_len = 16; + memcpy(sec_key->key, key->key, 16); +@@ -1079,14 +1079,14 @@ mt7915_mcu_sta_key_tlv(struct mt7915_sta *msta, struct sk_buff *skb, + sec_key->key_len = key->keylen; + memcpy(sec_key->key, key->key, key->keylen); + +- if (cipher == MT_CIPHER_TKIP) { ++ if (cipher == MCU_CIPHER_TKIP) { + /* Rx/Tx MIC keys are swapped */ + memcpy(sec_key->key + 16, key->key + 24, 8); + memcpy(sec_key->key + 24, key->key + 16, 8); + } + + /* store key_conf for BIP batch update */ +- if (cipher == MT_CIPHER_AES_CCMP) { ++ if (cipher == MCU_CIPHER_AES_CCMP) { + memcpy(bip->key, key->key, key->keylen); + bip->keyidx = key->keyidx; + } +diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/mcu.h b/drivers/net/wireless/mediatek/mt76/mt7915/mcu.h +index 2d584142c27b0..1a865ef81a43a 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7915/mcu.h ++++ b/drivers/net/wireless/mediatek/mt76/mt7915/mcu.h +@@ -1023,18 +1023,17 @@ enum { + STA_REC_MAX_NUM + }; + +-enum mt7915_cipher_type { +- MT_CIPHER_NONE, +- MT_CIPHER_WEP40, +- MT_CIPHER_WEP104, +- MT_CIPHER_WEP128, +- MT_CIPHER_TKIP, +- MT_CIPHER_AES_CCMP, +- MT_CIPHER_CCMP_256, +- MT_CIPHER_GCMP, +- MT_CIPHER_GCMP_256, +- MT_CIPHER_WAPI, +- MT_CIPHER_BIP_CMAC_128, ++enum mcu_cipher_type { ++ MCU_CIPHER_WEP40 = 1, ++ MCU_CIPHER_WEP104, ++ MCU_CIPHER_WEP128, ++ MCU_CIPHER_TKIP, ++ MCU_CIPHER_AES_CCMP, ++ MCU_CIPHER_CCMP_256, ++ MCU_CIPHER_GCMP, ++ MCU_CIPHER_GCMP_256, ++ MCU_CIPHER_WAPI, ++ MCU_CIPHER_BIP_CMAC_128, + }; + + enum { +diff --git a/drivers/net/wireless/mediatek/mt76/mt7921/mac.c b/drivers/net/wireless/mediatek/mt76/mt7921/mac.c +index c4b144391a8e2..b7af252a00914 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7921/mac.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7921/mac.c +@@ -378,14 +378,27 @@ int mt7921_mac_fill_rx(struct mt7921_dev *dev, struct sk_buff *skb) + u8 *data = (u8 *)rxd; + + if (status->flag & RX_FLAG_DECRYPTED) { +- status->iv[0] = data[5]; +- status->iv[1] = data[4]; +- status->iv[2] = data[3]; +- status->iv[3] = data[2]; +- status->iv[4] = data[1]; +- status->iv[5] = data[0]; +- +- insert_ccmp_hdr = FIELD_GET(MT_RXD2_NORMAL_FRAG, rxd2); ++ switch (FIELD_GET(MT_RXD1_NORMAL_SEC_MODE, rxd1)) { ++ case MT_CIPHER_AES_CCMP: ++ case MT_CIPHER_CCMP_CCX: ++ case MT_CIPHER_CCMP_256: ++ insert_ccmp_hdr = ++ FIELD_GET(MT_RXD2_NORMAL_FRAG, rxd2); ++ fallthrough; ++ case MT_CIPHER_TKIP: ++ case MT_CIPHER_TKIP_NO_MIC: ++ case MT_CIPHER_GCMP: ++ case MT_CIPHER_GCMP_256: ++ status->iv[0] = data[5]; ++ status->iv[1] = data[4]; ++ status->iv[2] = data[3]; ++ status->iv[3] = data[2]; ++ status->iv[4] = data[1]; ++ status->iv[5] = data[0]; ++ break; ++ default: ++ break; ++ } + } + rxd += 4; + if ((u8 *)rxd - skb->data >= skb->len) +diff --git a/drivers/net/wireless/mediatek/mt76/mt7921/mcu.c b/drivers/net/wireless/mediatek/mt76/mt7921/mcu.c +index a4f070cd78fda..02da127e91263 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7921/mcu.c ++++ b/drivers/net/wireless/mediatek/mt76/mt7921/mcu.c +@@ -87,28 +87,28 @@ struct mt7921_fw_region { + #define to_wcid_lo(id) FIELD_GET(GENMASK(7, 0), (u16)id) + #define to_wcid_hi(id) FIELD_GET(GENMASK(9, 8), (u16)id) + +-static enum mt7921_cipher_type ++static enum mcu_cipher_type + mt7921_mcu_get_cipher(int cipher) + { + switch (cipher) { + case WLAN_CIPHER_SUITE_WEP40: +- return MT_CIPHER_WEP40; ++ return MCU_CIPHER_WEP40; + case WLAN_CIPHER_SUITE_WEP104: +- return MT_CIPHER_WEP104; ++ return MCU_CIPHER_WEP104; + case WLAN_CIPHER_SUITE_TKIP: +- return MT_CIPHER_TKIP; ++ return MCU_CIPHER_TKIP; + case WLAN_CIPHER_SUITE_AES_CMAC: +- return MT_CIPHER_BIP_CMAC_128; ++ return MCU_CIPHER_BIP_CMAC_128; + case WLAN_CIPHER_SUITE_CCMP: +- return MT_CIPHER_AES_CCMP; ++ return MCU_CIPHER_AES_CCMP; + case WLAN_CIPHER_SUITE_CCMP_256: +- return MT_CIPHER_CCMP_256; ++ return MCU_CIPHER_CCMP_256; + case WLAN_CIPHER_SUITE_GCMP: +- return MT_CIPHER_GCMP; ++ return MCU_CIPHER_GCMP; + case WLAN_CIPHER_SUITE_GCMP_256: +- return MT_CIPHER_GCMP_256; ++ return MCU_CIPHER_GCMP_256; + case WLAN_CIPHER_SUITE_SMS4: +- return MT_CIPHER_WAPI; ++ return MCU_CIPHER_WAPI; + default: + return MT_CIPHER_NONE; + } +@@ -579,14 +579,14 @@ mt7921_mcu_sta_key_tlv(struct mt7921_sta *msta, struct sk_buff *skb, + sec_key = &sec->key[0]; + sec_key->cipher_len = sizeof(*sec_key); + +- if (cipher == MT_CIPHER_BIP_CMAC_128) { +- sec_key->cipher_id = MT_CIPHER_AES_CCMP; ++ if (cipher == MCU_CIPHER_BIP_CMAC_128) { ++ sec_key->cipher_id = MCU_CIPHER_AES_CCMP; + sec_key->key_id = bip->keyidx; + sec_key->key_len = 16; + memcpy(sec_key->key, bip->key, 16); + + sec_key = &sec->key[1]; +- sec_key->cipher_id = MT_CIPHER_BIP_CMAC_128; ++ sec_key->cipher_id = MCU_CIPHER_BIP_CMAC_128; + sec_key->cipher_len = sizeof(*sec_key); + sec_key->key_len = 16; + memcpy(sec_key->key, key->key, 16); +@@ -598,14 +598,14 @@ mt7921_mcu_sta_key_tlv(struct mt7921_sta *msta, struct sk_buff *skb, + sec_key->key_len = key->keylen; + memcpy(sec_key->key, key->key, key->keylen); + +- if (cipher == MT_CIPHER_TKIP) { ++ if (cipher == MCU_CIPHER_TKIP) { + /* Rx/Tx MIC keys are swapped */ + memcpy(sec_key->key + 16, key->key + 24, 8); + memcpy(sec_key->key + 24, key->key + 16, 8); + } + + /* store key_conf for BIP batch update */ +- if (cipher == MT_CIPHER_AES_CCMP) { ++ if (cipher == MCU_CIPHER_AES_CCMP) { + memcpy(bip->key, key->key, key->keylen); + bip->keyidx = key->keyidx; + } +diff --git a/drivers/net/wireless/mediatek/mt76/mt7921/mcu.h b/drivers/net/wireless/mediatek/mt76/mt7921/mcu.h +index 2fdc62367b3fb..4028c667bd688 100644 +--- a/drivers/net/wireless/mediatek/mt76/mt7921/mcu.h ++++ b/drivers/net/wireless/mediatek/mt76/mt7921/mcu.h +@@ -214,18 +214,17 @@ struct sta_rec_sec { + struct sec_key key[2]; + } __packed; + +-enum mt7921_cipher_type { +- MT_CIPHER_NONE, +- MT_CIPHER_WEP40, +- MT_CIPHER_WEP104, +- MT_CIPHER_WEP128, +- MT_CIPHER_TKIP, +- MT_CIPHER_AES_CCMP, +- MT_CIPHER_CCMP_256, +- MT_CIPHER_GCMP, +- MT_CIPHER_GCMP_256, +- MT_CIPHER_WAPI, +- MT_CIPHER_BIP_CMAC_128, ++enum mcu_cipher_type { ++ MCU_CIPHER_WEP40 = 1, ++ MCU_CIPHER_WEP104, ++ MCU_CIPHER_WEP128, ++ MCU_CIPHER_TKIP, ++ MCU_CIPHER_AES_CCMP, ++ MCU_CIPHER_CCMP_256, ++ MCU_CIPHER_GCMP, ++ MCU_CIPHER_GCMP_256, ++ MCU_CIPHER_WAPI, ++ MCU_CIPHER_BIP_CMAC_128, + }; + + enum { +diff --git a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.h b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.h +index d6d1be4169e5f..acb6b0cd36672 100644 +--- a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.h ++++ b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu.h +@@ -853,15 +853,10 @@ struct rtl8192eu_efuse { + u8 usb_optional_function; + u8 res9[2]; + u8 mac_addr[ETH_ALEN]; /* 0xd7 */ +- u8 res10[2]; +- u8 vendor_name[7]; +- u8 res11[2]; +- u8 device_name[0x0b]; /* 0xe8 */ +- u8 res12[2]; +- u8 serial[0x0b]; /* 0xf5 */ +- u8 res13[0x30]; ++ u8 device_info[80]; ++ u8 res11[3]; + u8 unknown[0x0d]; /* 0x130 */ +- u8 res14[0xc3]; ++ u8 res12[0xc3]; + }; + + struct rtl8xxxu_reg8val { +diff --git a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_8192e.c b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_8192e.c +index cfe2dfdae928f..b06508d0cdf8f 100644 +--- a/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_8192e.c ++++ b/drivers/net/wireless/realtek/rtl8xxxu/rtl8xxxu_8192e.c +@@ -554,9 +554,43 @@ rtl8192e_set_tx_power(struct rtl8xxxu_priv *priv, int channel, bool ht40) + } + } + ++static void rtl8192eu_log_next_device_info(struct rtl8xxxu_priv *priv, ++ char *record_name, ++ char *device_info, ++ unsigned int *record_offset) ++{ ++ char *record = device_info + *record_offset; ++ ++ /* A record is [ total length | 0x03 | value ] */ ++ unsigned char l = record[0]; ++ ++ /* ++ * The whole device info section seems to be 80 characters, make sure ++ * we don't read further. ++ */ ++ if (*record_offset + l > 80) { ++ dev_warn(&priv->udev->dev, ++ "invalid record length %d while parsing \"%s\" at offset %u.\n", ++ l, record_name, *record_offset); ++ return; ++ } ++ ++ if (l >= 2) { ++ char value[80]; ++ ++ memcpy(value, &record[2], l - 2); ++ value[l - 2] = '\0'; ++ dev_info(&priv->udev->dev, "%s: %s\n", record_name, value); ++ *record_offset = *record_offset + l; ++ } else { ++ dev_info(&priv->udev->dev, "%s not available.\n", record_name); ++ } ++} ++ + static int rtl8192eu_parse_efuse(struct rtl8xxxu_priv *priv) + { + struct rtl8192eu_efuse *efuse = &priv->efuse_wifi.efuse8192eu; ++ unsigned int record_offset; + int i; + + if (efuse->rtl_id != cpu_to_le16(0x8129)) +@@ -604,12 +638,25 @@ static int rtl8192eu_parse_efuse(struct rtl8xxxu_priv *priv) + priv->has_xtalk = 1; + priv->xtalk = priv->efuse_wifi.efuse8192eu.xtal_k & 0x3f; + +- dev_info(&priv->udev->dev, "Vendor: %.7s\n", efuse->vendor_name); +- dev_info(&priv->udev->dev, "Product: %.11s\n", efuse->device_name); +- if (memchr_inv(efuse->serial, 0xff, 11)) +- dev_info(&priv->udev->dev, "Serial: %.11s\n", efuse->serial); +- else +- dev_info(&priv->udev->dev, "Serial not available.\n"); ++ /* ++ * device_info section seems to be laid out as records ++ * [ total length | 0x03 | value ] so: ++ * - vendor length + 2 ++ * - 0x03 ++ * - vendor string (not null terminated) ++ * - product length + 2 ++ * - 0x03 ++ * - product string (not null terminated) ++ * Then there is one or 2 0x00 on all the 4 devices I own or found ++ * dumped online. ++ * As previous version of the code handled an optional serial ++ * string, I now assume there may be a third record if the ++ * length is not 0. ++ */ ++ record_offset = 0; ++ rtl8192eu_log_next_device_info(priv, "Vendor", efuse->device_info, &record_offset); ++ rtl8192eu_log_next_device_info(priv, "Product", efuse->device_info, &record_offset); ++ rtl8192eu_log_next_device_info(priv, "Serial", efuse->device_info, &record_offset); + + if (rtl8xxxu_debug & RTL8XXXU_DEBUG_EFUSE) { + unsigned char *raw = priv->efuse_wifi.raw; +diff --git a/drivers/net/wireless/realtek/rtw88/pci.c b/drivers/net/wireless/realtek/rtw88/pci.c +index 6b5c885798a4b..e5110d2cbc1d5 100644 +--- a/drivers/net/wireless/realtek/rtw88/pci.c ++++ b/drivers/net/wireless/realtek/rtw88/pci.c +@@ -2,6 +2,7 @@ + /* Copyright(c) 2018-2019 Realtek Corporation + */ + ++#include + #include + #include + #include "main.h" +@@ -1598,6 +1599,36 @@ static void rtw_pci_napi_deinit(struct rtw_dev *rtwdev) + netif_napi_del(&rtwpci->napi); + } + ++enum rtw88_quirk_dis_pci_caps { ++ QUIRK_DIS_PCI_CAP_MSI, ++ QUIRK_DIS_PCI_CAP_ASPM, ++}; ++ ++static int disable_pci_caps(const struct dmi_system_id *dmi) ++{ ++ uintptr_t dis_caps = (uintptr_t)dmi->driver_data; ++ ++ if (dis_caps & BIT(QUIRK_DIS_PCI_CAP_MSI)) ++ rtw_disable_msi = true; ++ if (dis_caps & BIT(QUIRK_DIS_PCI_CAP_ASPM)) ++ rtw_pci_disable_aspm = true; ++ ++ return 1; ++} ++ ++static const struct dmi_system_id rtw88_pci_quirks[] = { ++ { ++ .callback = disable_pci_caps, ++ .ident = "Protempo Ltd L116HTN6SPW", ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Protempo Ltd"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "L116HTN6SPW"), ++ }, ++ .driver_data = (void *)BIT(QUIRK_DIS_PCI_CAP_ASPM), ++ }, ++ {} ++}; ++ + int rtw_pci_probe(struct pci_dev *pdev, + const struct pci_device_id *id) + { +@@ -1648,6 +1679,7 @@ int rtw_pci_probe(struct pci_dev *pdev, + goto err_destroy_pci; + } + ++ dmi_check_system(rtw88_pci_quirks); + rtw_pci_phy_cfg(rtwdev); + + ret = rtw_register_hw(rtwdev, hw); +diff --git a/drivers/net/wireless/realtek/rtw88/rtw8822c_table.c b/drivers/net/wireless/realtek/rtw88/rtw8822c_table.c +index ad5715c65de3e..03f97acbf80f6 100644 +--- a/drivers/net/wireless/realtek/rtw88/rtw8822c_table.c ++++ b/drivers/net/wireless/realtek/rtw88/rtw8822c_table.c +@@ -16812,53 +16812,53 @@ static const u32 rtw8822c_rf_a[] = { + 0x92000002, 0x00000000, 0x40000000, 0x00000000, + 0x03F, 0x00010E46, + 0x93000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x93000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x93000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x93000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x93000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x93000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x93000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x93000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x94000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x94000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x94000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x94000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x94000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x94000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x94000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x94000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x95000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x95000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x95000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x95000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x95000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x95000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x95000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0x95000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00030246, ++ 0x03F, 0x0003D646, + 0xA0000000, 0x00000000, + 0x03F, 0x00002A46, + 0xB0000000, 0x00000000, +@@ -18762,53 +18762,53 @@ static const u32 rtw8822c_rf_a[] = { + 0x92000002, 0x00000000, 0x40000000, 0x00000000, + 0x03F, 0x0000EA46, + 0x93000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0xA0000000, 0x00000000, + 0x03F, 0x00002A46, + 0xB0000000, 0x00000000, +@@ -18957,53 +18957,53 @@ static const u32 rtw8822c_rf_a[] = { + 0x92000002, 0x00000000, 0x40000000, 0x00000000, + 0x03F, 0x0000EA46, + 0x93000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0xA0000000, 0x00000000, + 0x03F, 0x00002A46, + 0xB0000000, 0x00000000, +@@ -19152,53 +19152,53 @@ static const u32 rtw8822c_rf_a[] = { + 0x92000002, 0x00000000, 0x40000000, 0x00000000, + 0x03F, 0x0000EA46, + 0x93000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0xA0000000, 0x00000000, + 0x03F, 0x00002A46, + 0xB0000000, 0x00000000, +@@ -19347,53 +19347,53 @@ static const u32 rtw8822c_rf_a[] = { + 0x92000002, 0x00000000, 0x40000000, 0x00000000, + 0x03F, 0x0000EA46, + 0x93000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x93000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x94000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000001, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000002, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000003, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000004, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000005, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000006, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000015, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0x95000016, 0x00000000, 0x40000000, 0x00000000, +- 0x03F, 0x00031E46, ++ 0x03F, 0x0003D646, + 0xA0000000, 0x00000000, + 0x03F, 0x00002A46, + 0xB0000000, 0x00000000, +@@ -19610,21 +19610,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000002, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19633,21 +19633,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000003, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19656,21 +19656,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000004, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19679,21 +19679,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000005, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19702,21 +19702,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000006, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19725,21 +19725,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000015, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19748,21 +19748,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000016, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19771,21 +19771,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000001, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19794,21 +19794,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000002, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19817,21 +19817,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000003, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19840,21 +19840,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000004, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19863,21 +19863,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000005, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19886,21 +19886,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000006, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19909,21 +19909,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000015, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19932,21 +19932,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000016, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19955,21 +19955,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000001, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -19978,21 +19978,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000002, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -20001,21 +20001,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000003, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -20024,21 +20024,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000004, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -20047,21 +20047,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000005, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -20070,21 +20070,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000006, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -20093,21 +20093,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000015, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -20116,21 +20116,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000016, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -20139,21 +20139,21 @@ static const u32 rtw8822c_rf_a[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x000008C8, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x000008CB, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x000008CE, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x000008D1, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x000008D4, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000DD1, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0xA0000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000487, +@@ -38484,21 +38484,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000002, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38507,21 +38507,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000003, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38530,21 +38530,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000004, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38553,21 +38553,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000005, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38576,21 +38576,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000006, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38599,21 +38599,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000015, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38622,21 +38622,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x93000016, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38645,21 +38645,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000001, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38668,21 +38668,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000002, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38691,21 +38691,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000003, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38714,21 +38714,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000004, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38737,21 +38737,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000005, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38760,21 +38760,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000006, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38783,21 +38783,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000015, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38806,21 +38806,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x94000016, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38829,21 +38829,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000001, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38852,21 +38852,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000002, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38875,21 +38875,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000003, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38898,21 +38898,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000004, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38921,21 +38921,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000005, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38944,21 +38944,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000006, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38967,21 +38967,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000015, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -38990,21 +38990,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0x95000016, 0x00000000, 0x40000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000467, +@@ -39013,21 +39013,21 @@ static const u32 rtw8822c_rf_b[] = { + 0x033, 0x00000062, + 0x03F, 0x00000908, + 0x033, 0x00000063, +- 0x03F, 0x00000D09, ++ 0x03F, 0x00000CC6, + 0x033, 0x00000064, +- 0x03F, 0x00000D49, ++ 0x03F, 0x00000CC9, + 0x033, 0x00000065, +- 0x03F, 0x00000D8A, ++ 0x03F, 0x00000CCC, + 0x033, 0x00000066, +- 0x03F, 0x00000DEB, ++ 0x03F, 0x00000CCF, + 0x033, 0x00000067, +- 0x03F, 0x00000DEE, ++ 0x03F, 0x00000CD2, + 0x033, 0x00000068, +- 0x03F, 0x00000DF1, ++ 0x03F, 0x00000CD5, + 0x033, 0x00000069, +- 0x03F, 0x00000DF4, ++ 0x03F, 0x00000DD4, + 0x033, 0x0000006A, +- 0x03F, 0x00000DF7, ++ 0x03F, 0x00000DD7, + 0xA0000000, 0x00000000, + 0x033, 0x00000060, + 0x03F, 0x00000487, +diff --git a/drivers/net/wireless/st/cw1200/cw1200_sdio.c b/drivers/net/wireless/st/cw1200/cw1200_sdio.c +index b65ec14136c7e..4c30b5772ce0f 100644 +--- a/drivers/net/wireless/st/cw1200/cw1200_sdio.c ++++ b/drivers/net/wireless/st/cw1200/cw1200_sdio.c +@@ -53,6 +53,7 @@ static const struct sdio_device_id cw1200_sdio_ids[] = { + { SDIO_DEVICE(SDIO_VENDOR_ID_STE, SDIO_DEVICE_ID_STE_CW1200) }, + { /* end: all zeroes */ }, + }; ++MODULE_DEVICE_TABLE(sdio, cw1200_sdio_ids); + + /* hwbus_ops implemetation */ + +diff --git a/drivers/net/wireless/ti/wl1251/cmd.c b/drivers/net/wireless/ti/wl1251/cmd.c +index 498c8db2eb48b..d7a869106782f 100644 +--- a/drivers/net/wireless/ti/wl1251/cmd.c ++++ b/drivers/net/wireless/ti/wl1251/cmd.c +@@ -454,9 +454,12 @@ int wl1251_cmd_scan(struct wl1251 *wl, u8 *ssid, size_t ssid_len, + cmd->channels[i].channel = channels[i]->hw_value; + } + +- cmd->params.ssid_len = ssid_len; +- if (ssid) +- memcpy(cmd->params.ssid, ssid, ssid_len); ++ if (ssid) { ++ int len = clamp_val(ssid_len, 0, IEEE80211_MAX_SSID_LEN); ++ ++ cmd->params.ssid_len = len; ++ memcpy(cmd->params.ssid, ssid, len); ++ } + + ret = wl1251_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd)); + if (ret < 0) { +diff --git a/drivers/net/wireless/ti/wl12xx/main.c b/drivers/net/wireless/ti/wl12xx/main.c +index 9d7dbfe7fe0c3..c6da0cfb4afbe 100644 +--- a/drivers/net/wireless/ti/wl12xx/main.c ++++ b/drivers/net/wireless/ti/wl12xx/main.c +@@ -1503,6 +1503,13 @@ static int wl12xx_get_fuse_mac(struct wl1271 *wl) + u32 mac1, mac2; + int ret; + ++ /* Device may be in ELP from the bootloader or kexec */ ++ ret = wlcore_write32(wl, WL12XX_WELP_ARM_COMMAND, WELP_ARM_COMMAND_VAL); ++ if (ret < 0) ++ goto out; ++ ++ usleep_range(500000, 700000); ++ + ret = wlcore_set_partition(wl, &wl->ptable[PART_DRPW]); + if (ret < 0) + goto out; +diff --git a/drivers/nvmem/core.c b/drivers/nvmem/core.c +index a5ab1e0c74cf6..3ffe676ed7f16 100644 +--- a/drivers/nvmem/core.c ++++ b/drivers/nvmem/core.c +@@ -686,15 +686,17 @@ static int nvmem_add_cells_from_of(struct nvmem_device *nvmem) + continue; + if (len < 2 * sizeof(u32)) { + dev_err(dev, "nvmem: invalid reg on %pOF\n", child); ++ of_node_put(child); + return -EINVAL; + } + + cell = kzalloc(sizeof(*cell), GFP_KERNEL); +- if (!cell) ++ if (!cell) { ++ of_node_put(child); + return -ENOMEM; ++ } + + cell->nvmem = nvmem; +- cell->np = of_node_get(child); + cell->offset = be32_to_cpup(addr++); + cell->bytes = be32_to_cpup(addr); + cell->name = kasprintf(GFP_KERNEL, "%pOFn", child); +@@ -715,11 +717,12 @@ static int nvmem_add_cells_from_of(struct nvmem_device *nvmem) + cell->name, nvmem->stride); + /* Cells already added will be freed later. */ + kfree_const(cell->name); +- of_node_put(cell->np); + kfree(cell); ++ of_node_put(child); + return -EINVAL; + } + ++ cell->np = of_node_get(child); + nvmem_cell_add(cell); + } + +diff --git a/drivers/pci/controller/dwc/pcie-tegra194.c b/drivers/pci/controller/dwc/pcie-tegra194.c +index 0e94190ca4e88..8dee6d3f33a70 100644 +--- a/drivers/pci/controller/dwc/pcie-tegra194.c ++++ b/drivers/pci/controller/dwc/pcie-tegra194.c +@@ -2214,6 +2214,8 @@ static int tegra_pcie_dw_resume_noirq(struct device *dev) + goto fail_host_init; + } + ++ dw_pcie_setup_rc(&pcie->pci.pp); ++ + ret = tegra_pcie_dw_start_link(&pcie->pci); + if (ret < 0) + goto fail_host_init; +diff --git a/drivers/pci/controller/pci-aardvark.c b/drivers/pci/controller/pci-aardvark.c +index e3f5e7ab76063..c95ebe808f92b 100644 +--- a/drivers/pci/controller/pci-aardvark.c ++++ b/drivers/pci/controller/pci-aardvark.c +@@ -57,7 +57,7 @@ + #define PIO_COMPLETION_STATUS_UR 1 + #define PIO_COMPLETION_STATUS_CRS 2 + #define PIO_COMPLETION_STATUS_CA 4 +-#define PIO_NON_POSTED_REQ BIT(0) ++#define PIO_NON_POSTED_REQ BIT(10) + #define PIO_ADDR_LS (PIO_BASE_ADDR + 0x8) + #define PIO_ADDR_MS (PIO_BASE_ADDR + 0xc) + #define PIO_WR_DATA (PIO_BASE_ADDR + 0x10) +@@ -125,6 +125,7 @@ + #define LTSSM_MASK 0x3f + #define LTSSM_L0 0x10 + #define RC_BAR_CONFIG 0x300 ++#define VENDOR_ID_REG (LMI_BASE_ADDR + 0x44) + + /* PCIe core controller registers */ + #define CTRL_CORE_BASE_ADDR 0x18000 +@@ -385,6 +386,16 @@ static void advk_pcie_setup_hw(struct advk_pcie *pcie) + reg |= (IS_RC_MSK << IS_RC_SHIFT); + advk_writel(pcie, reg, PCIE_CORE_CTRL0_REG); + ++ /* ++ * Replace incorrect PCI vendor id value 0x1b4b by correct value 0x11ab. ++ * VENDOR_ID_REG contains vendor id in low 16 bits and subsystem vendor ++ * id in high 16 bits. Updating this register changes readback value of ++ * read-only vendor id bits in PCIE_CORE_DEV_ID_REG register. Workaround ++ * for erratum 4.1: "The value of device and vendor ID is incorrect". ++ */ ++ reg = (PCI_VENDOR_ID_MARVELL << 16) | PCI_VENDOR_ID_MARVELL; ++ advk_writel(pcie, reg, VENDOR_ID_REG); ++ + /* Set Advanced Error Capabilities and Control PF0 register */ + reg = PCIE_CORE_ERR_CAPCTL_ECRC_CHK_TX | + PCIE_CORE_ERR_CAPCTL_ECRC_CHK_TX_EN | +diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c +index 7bf76bca888da..909343ee7e0ac 100644 +--- a/drivers/pci/quirks.c ++++ b/drivers/pci/quirks.c +@@ -27,6 +27,7 @@ + #include + #include + #include ++#include + #include + #include /* isa_dma_bridge_buggy */ + #include "pci.h" +@@ -3668,6 +3669,16 @@ static void quirk_apple_poweroff_thunderbolt(struct pci_dev *dev) + return; + if (pci_pcie_type(dev) != PCI_EXP_TYPE_UPSTREAM) + return; ++ ++ /* ++ * SXIO/SXFP/SXLF turns off power to the Thunderbolt controller. ++ * We don't know how to turn it back on again, but firmware does, ++ * so we can only use SXIO/SXFP/SXLF if we're suspending via ++ * firmware. ++ */ ++ if (!pm_suspend_via_firmware()) ++ return; ++ + bridge = ACPI_HANDLE(&dev->dev); + if (!bridge) + return; +diff --git a/drivers/pinctrl/pinctrl-amd.c b/drivers/pinctrl/pinctrl-amd.c +index 2d4acf21117cc..c5950a3b4e4ce 100644 +--- a/drivers/pinctrl/pinctrl-amd.c ++++ b/drivers/pinctrl/pinctrl-amd.c +@@ -991,6 +991,7 @@ static int amd_gpio_remove(struct platform_device *pdev) + static const struct acpi_device_id amd_gpio_acpi_match[] = { + { "AMD0030", 0 }, + { "AMDI0030", 0}, ++ { "AMDI0031", 0}, + { }, + }; + MODULE_DEVICE_TABLE(acpi, amd_gpio_acpi_match); +diff --git a/drivers/pinctrl/pinctrl-equilibrium.c b/drivers/pinctrl/pinctrl-equilibrium.c +index 067271b7d35a3..ac1c47f542c11 100644 +--- a/drivers/pinctrl/pinctrl-equilibrium.c ++++ b/drivers/pinctrl/pinctrl-equilibrium.c +@@ -929,6 +929,7 @@ static const struct of_device_id eqbr_pinctrl_dt_match[] = { + { .compatible = "intel,lgm-io" }, + {} + }; ++MODULE_DEVICE_TABLE(of, eqbr_pinctrl_dt_match); + + static struct platform_driver eqbr_pinctrl_driver = { + .probe = eqbr_pinctrl_probe, +diff --git a/drivers/pinctrl/pinctrl-mcp23s08.c b/drivers/pinctrl/pinctrl-mcp23s08.c +index ce2d8014b7e0b..d0259577934e9 100644 +--- a/drivers/pinctrl/pinctrl-mcp23s08.c ++++ b/drivers/pinctrl/pinctrl-mcp23s08.c +@@ -351,6 +351,11 @@ static irqreturn_t mcp23s08_irq(int irq, void *data) + if (mcp_read(mcp, MCP_INTF, &intf)) + goto unlock; + ++ if (intf == 0) { ++ /* There is no interrupt pending */ ++ goto unlock; ++ } ++ + if (mcp_read(mcp, MCP_INTCAP, &intcap)) + goto unlock; + +@@ -368,11 +373,6 @@ static irqreturn_t mcp23s08_irq(int irq, void *data) + mcp->cached_gpio = gpio; + mutex_unlock(&mcp->lock); + +- if (intf == 0) { +- /* There is no interrupt pending */ +- return IRQ_HANDLED; +- } +- + dev_dbg(mcp->chip.parent, + "intcap 0x%04X intf 0x%04X gpio_orig 0x%04X gpio 0x%04X\n", + intcap, intf, gpio_orig, gpio); +diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c +index 9e6f2a895a234..5b1355fae9b41 100644 +--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c ++++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c +@@ -100,24 +100,27 @@ static ssize_t tcc_offset_degree_celsius_show(struct device *dev, + if (err) + return err; + +- val = (val >> 24) & 0xff; ++ val = (val >> 24) & 0x3f; + return sprintf(buf, "%d\n", (int)val); + } + +-static int tcc_offset_update(int tcc) ++static int tcc_offset_update(unsigned int tcc) + { + u64 val; + int err; + +- if (!tcc) ++ if (tcc > 63) + return -EINVAL; + + err = rdmsrl_safe(MSR_IA32_TEMPERATURE_TARGET, &val); + if (err) + return err; + +- val &= ~GENMASK_ULL(31, 24); +- val |= (tcc & 0xff) << 24; ++ if (val & BIT(31)) ++ return -EPERM; ++ ++ val &= ~GENMASK_ULL(29, 24); ++ val |= (tcc & 0x3f) << 24; + + err = wrmsrl_safe(MSR_IA32_TEMPERATURE_TARGET, val); + if (err) +@@ -126,14 +129,15 @@ static int tcc_offset_update(int tcc) + return 0; + } + +-static int tcc_offset_save; ++static unsigned int tcc_offset_save; + + static ssize_t tcc_offset_degree_celsius_store(struct device *dev, + struct device_attribute *attr, const char *buf, + size_t count) + { ++ unsigned int tcc; + u64 val; +- int tcc, err; ++ int err; + + err = rdmsrl_safe(MSR_PLATFORM_INFO, &val); + if (err) +@@ -142,7 +146,7 @@ static ssize_t tcc_offset_degree_celsius_store(struct device *dev, + if (!(val & BIT(30))) + return -EACCES; + +- if (kstrtoint(buf, 0, &tcc)) ++ if (kstrtouint(buf, 0, &tcc)) + return -EINVAL; + + err = tcc_offset_update(tcc); +diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h +index 826a56e3bbd28..62210cbea84b8 100644 +--- a/fs/ext4/ext4.h ++++ b/fs/ext4/ext4.h +@@ -1490,6 +1490,7 @@ struct ext4_sb_info { + struct kobject s_kobj; + struct completion s_kobj_unregister; + struct super_block *s_sb; ++ struct buffer_head *s_mmp_bh; + + /* Journaling */ + struct journal_s *s_journal; +@@ -3663,6 +3664,9 @@ extern struct ext4_io_end_vec *ext4_last_io_end_vec(ext4_io_end_t *io_end); + /* mmp.c */ + extern int ext4_multi_mount_protect(struct super_block *, ext4_fsblk_t); + ++/* mmp.c */ ++extern void ext4_stop_mmpd(struct ext4_sb_info *sbi); ++ + /* verity.c */ + extern const struct fsverity_operations ext4_verityops; + +diff --git a/fs/ext4/mmp.c b/fs/ext4/mmp.c +index 68fbeedd627bc..6cb598b549ca1 100644 +--- a/fs/ext4/mmp.c ++++ b/fs/ext4/mmp.c +@@ -127,9 +127,9 @@ void __dump_mmp_msg(struct super_block *sb, struct mmp_struct *mmp, + */ + static int kmmpd(void *data) + { +- struct super_block *sb = ((struct mmpd_data *) data)->sb; +- struct buffer_head *bh = ((struct mmpd_data *) data)->bh; ++ struct super_block *sb = (struct super_block *) data; + struct ext4_super_block *es = EXT4_SB(sb)->s_es; ++ struct buffer_head *bh = EXT4_SB(sb)->s_mmp_bh; + struct mmp_struct *mmp; + ext4_fsblk_t mmp_block; + u32 seq = 0; +@@ -245,12 +245,18 @@ static int kmmpd(void *data) + retval = write_mmp_block(sb, bh); + + exit_thread: +- EXT4_SB(sb)->s_mmp_tsk = NULL; +- kfree(data); +- brelse(bh); + return retval; + } + ++void ext4_stop_mmpd(struct ext4_sb_info *sbi) ++{ ++ if (sbi->s_mmp_tsk) { ++ kthread_stop(sbi->s_mmp_tsk); ++ brelse(sbi->s_mmp_bh); ++ sbi->s_mmp_tsk = NULL; ++ } ++} ++ + /* + * Get a random new sequence number but make sure it is not greater than + * EXT4_MMP_SEQ_MAX. +@@ -275,7 +281,6 @@ int ext4_multi_mount_protect(struct super_block *sb, + struct ext4_super_block *es = EXT4_SB(sb)->s_es; + struct buffer_head *bh = NULL; + struct mmp_struct *mmp = NULL; +- struct mmpd_data *mmpd_data; + u32 seq; + unsigned int mmp_check_interval = le16_to_cpu(es->s_mmp_update_interval); + unsigned int wait_time = 0; +@@ -364,24 +369,17 @@ skip: + goto failed; + } + +- mmpd_data = kmalloc(sizeof(*mmpd_data), GFP_KERNEL); +- if (!mmpd_data) { +- ext4_warning(sb, "not enough memory for mmpd_data"); +- goto failed; +- } +- mmpd_data->sb = sb; +- mmpd_data->bh = bh; ++ EXT4_SB(sb)->s_mmp_bh = bh; + + /* + * Start a kernel thread to update the MMP block periodically. + */ +- EXT4_SB(sb)->s_mmp_tsk = kthread_run(kmmpd, mmpd_data, "kmmpd-%.*s", ++ EXT4_SB(sb)->s_mmp_tsk = kthread_run(kmmpd, sb, "kmmpd-%.*s", + (int)sizeof(mmp->mmp_bdevname), + bdevname(bh->b_bdev, + mmp->mmp_bdevname)); + if (IS_ERR(EXT4_SB(sb)->s_mmp_tsk)) { + EXT4_SB(sb)->s_mmp_tsk = NULL; +- kfree(mmpd_data); + ext4_warning(sb, "Unable to create kmmpd thread for %s.", + sb->s_id); + goto failed; +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index 4a869bc5271b9..62dd98189e326 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -1245,8 +1245,8 @@ static void ext4_put_super(struct super_block *sb) + ext4_xattr_destroy_cache(sbi->s_ea_block_cache); + sbi->s_ea_block_cache = NULL; + +- if (sbi->s_mmp_tsk) +- kthread_stop(sbi->s_mmp_tsk); ++ ext4_stop_mmpd(sbi); ++ + brelse(sbi->s_sbh); + sb->s_fs_info = NULL; + /* +@@ -5168,8 +5168,7 @@ failed_mount3a: + failed_mount3: + flush_work(&sbi->s_error_work); + del_timer_sync(&sbi->s_err_report); +- if (sbi->s_mmp_tsk) +- kthread_stop(sbi->s_mmp_tsk); ++ ext4_stop_mmpd(sbi); + failed_mount2: + rcu_read_lock(); + group_desc = rcu_dereference(sbi->s_group_desc); +@@ -5967,8 +5966,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) + */ + ext4_mark_recovery_complete(sb, es); + } +- if (sbi->s_mmp_tsk) +- kthread_stop(sbi->s_mmp_tsk); ++ ext4_stop_mmpd(sbi); + } else { + /* Make sure we can mount this feature set readwrite */ + if (ext4_has_feature_readonly(sb) || +diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h +index f3fabb1edfe97..148fc1ce52d77 100644 +--- a/fs/f2fs/f2fs.h ++++ b/fs/f2fs/f2fs.h +@@ -3560,6 +3560,8 @@ void f2fs_destroy_garbage_collection_cache(void); + */ + int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only); + bool f2fs_space_for_roll_forward(struct f2fs_sb_info *sbi); ++int __init f2fs_create_recovery_cache(void); ++void f2fs_destroy_recovery_cache(void); + + /* + * debug.c +diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c +index da75d5d52f0ac..4ae055f39e211 100644 +--- a/fs/f2fs/recovery.c ++++ b/fs/f2fs/recovery.c +@@ -787,13 +787,6 @@ int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only) + quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY); + #endif + +- fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry", +- sizeof(struct fsync_inode_entry)); +- if (!fsync_entry_slab) { +- err = -ENOMEM; +- goto out; +- } +- + INIT_LIST_HEAD(&inode_list); + INIT_LIST_HEAD(&tmp_inode_list); + INIT_LIST_HEAD(&dir_list); +@@ -866,8 +859,6 @@ skip: + } + } + +- kmem_cache_destroy(fsync_entry_slab); +-out: + #ifdef CONFIG_QUOTA + /* Turn quotas off */ + if (quota_enabled) +@@ -877,3 +868,17 @@ out: + + return ret ? ret: err; + } ++ ++int __init f2fs_create_recovery_cache(void) ++{ ++ fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry", ++ sizeof(struct fsync_inode_entry)); ++ if (!fsync_entry_slab) ++ return -ENOMEM; ++ return 0; ++} ++ ++void f2fs_destroy_recovery_cache(void) ++{ ++ kmem_cache_destroy(fsync_entry_slab); ++} +diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c +index d852d96773a32..1f7bc4b3f6aec 100644 +--- a/fs/f2fs/super.c ++++ b/fs/f2fs/super.c +@@ -4187,9 +4187,12 @@ static int __init init_f2fs_fs(void) + err = f2fs_create_checkpoint_caches(); + if (err) + goto free_segment_manager_caches; +- err = f2fs_create_extent_cache(); ++ err = f2fs_create_recovery_cache(); + if (err) + goto free_checkpoint_caches; ++ err = f2fs_create_extent_cache(); ++ if (err) ++ goto free_recovery_cache; + err = f2fs_create_garbage_collection_cache(); + if (err) + goto free_extent_cache; +@@ -4238,6 +4241,8 @@ free_garbage_collection_cache: + f2fs_destroy_garbage_collection_cache(); + free_extent_cache: + f2fs_destroy_extent_cache(); ++free_recovery_cache: ++ f2fs_destroy_recovery_cache(); + free_checkpoint_caches: + f2fs_destroy_checkpoint_caches(); + free_segment_manager_caches: +@@ -4263,6 +4268,7 @@ static void __exit exit_f2fs_fs(void) + f2fs_exit_sysfs(); + f2fs_destroy_garbage_collection_cache(); + f2fs_destroy_extent_cache(); ++ f2fs_destroy_recovery_cache(); + f2fs_destroy_checkpoint_caches(); + f2fs_destroy_segment_manager_caches(); + f2fs_destroy_node_manager_caches(); +diff --git a/fs/io-wq.c b/fs/io-wq.c +index 4eba531bea5a9..b836737f96f31 100644 +--- a/fs/io-wq.c ++++ b/fs/io-wq.c +@@ -243,7 +243,8 @@ static void io_wqe_wake_worker(struct io_wqe *wqe, struct io_wqe_acct *acct) + * Most likely an attempt to queue unbounded work on an io_wq that + * wasn't setup with any unbounded workers. + */ +- WARN_ON_ONCE(!acct->max_workers); ++ if (unlikely(!acct->max_workers)) ++ pr_warn_once("io-wq is not configured for unbound workers"); + + rcu_read_lock(); + ret = io_wqe_activate_free_worker(wqe); +@@ -991,6 +992,8 @@ struct io_wq *io_wq_create(unsigned bounded, struct io_wq_data *data) + + if (WARN_ON_ONCE(!data->free_work || !data->do_work)) + return ERR_PTR(-EINVAL); ++ if (WARN_ON_ONCE(!bounded)) ++ return ERR_PTR(-EINVAL); + + wq = kzalloc(sizeof(*wq), GFP_KERNEL); + if (!wq) +diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c +index 6f65bfa9f18d5..b0eb9c85eea0c 100644 +--- a/fs/jfs/inode.c ++++ b/fs/jfs/inode.c +@@ -151,7 +151,8 @@ void jfs_evict_inode(struct inode *inode) + if (test_cflag(COMMIT_Freewmap, inode)) + jfs_free_zero_link(inode); + +- diFree(inode); ++ if (JFS_SBI(inode->i_sb)->ipimap) ++ diFree(inode); + + /* + * Free the inode from the quota allocation. +diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c +index e98f99338f8f8..df5fc12a6ceed 100644 +--- a/fs/reiserfs/journal.c ++++ b/fs/reiserfs/journal.c +@@ -2760,6 +2760,20 @@ int journal_init(struct super_block *sb, const char *j_dev_name, + goto free_and_return; + } + ++ /* ++ * Sanity check to see if journal first block is correct. ++ * If journal first block is invalid it can cause ++ * zeroing important superblock members. ++ */ ++ if (!SB_ONDISK_JOURNAL_DEVICE(sb) && ++ SB_ONDISK_JOURNAL_1st_BLOCK(sb) < SB_JOURNAL_1st_RESERVED_BLOCK(sb)) { ++ reiserfs_warning(sb, "journal-1393", ++ "journal 1st super block is invalid: 1st reserved block %d, but actual 1st block is %d", ++ SB_JOURNAL_1st_RESERVED_BLOCK(sb), ++ SB_ONDISK_JOURNAL_1st_BLOCK(sb)); ++ goto free_and_return; ++ } ++ + if (journal_init_dev(sb, journal, j_dev_name) != 0) { + reiserfs_warning(sb, "sh-462", + "unable to initialize journal device"); +diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c +index ddb2ca636c93d..274e635e00c3d 100644 +--- a/fs/ubifs/super.c ++++ b/fs/ubifs/super.c +@@ -275,6 +275,7 @@ static struct inode *ubifs_alloc_inode(struct super_block *sb) + memset((void *)ui + sizeof(struct inode), 0, + sizeof(struct ubifs_inode) - sizeof(struct inode)); + mutex_init(&ui->ui_mutex); ++ init_rwsem(&ui->xattr_sem); + spin_lock_init(&ui->ui_lock); + return &ui->vfs_inode; + }; +diff --git a/fs/ubifs/ubifs.h b/fs/ubifs/ubifs.h +index 7fdfdbda4b8ae..15847c1474ba1 100644 +--- a/fs/ubifs/ubifs.h ++++ b/fs/ubifs/ubifs.h +@@ -356,6 +356,7 @@ struct ubifs_gced_idx_leb { + * @ui_mutex: serializes inode write-back with the rest of VFS operations, + * serializes "clean <-> dirty" state changes, serializes bulk-read, + * protects @dirty, @bulk_read, @ui_size, and @xattr_size ++ * @xattr_sem: serilizes write operations (remove|set|create) on xattr + * @ui_lock: protects @synced_i_size + * @synced_i_size: synchronized size of inode, i.e. the value of inode size + * currently stored on the flash; used only for regular file +@@ -409,6 +410,7 @@ struct ubifs_inode { + unsigned int bulk_read:1; + unsigned int compr_type:2; + struct mutex ui_mutex; ++ struct rw_semaphore xattr_sem; + spinlock_t ui_lock; + loff_t synced_i_size; + loff_t ui_size; +diff --git a/fs/ubifs/xattr.c b/fs/ubifs/xattr.c +index 6b1e9830b2745..1fce27e9b7697 100644 +--- a/fs/ubifs/xattr.c ++++ b/fs/ubifs/xattr.c +@@ -285,6 +285,7 @@ int ubifs_xattr_set(struct inode *host, const char *name, const void *value, + if (!xent) + return -ENOMEM; + ++ down_write(&ubifs_inode(host)->xattr_sem); + /* + * The extended attribute entries are stored in LNC, so multiple + * look-ups do not involve reading the flash. +@@ -319,6 +320,7 @@ int ubifs_xattr_set(struct inode *host, const char *name, const void *value, + iput(inode); + + out_free: ++ up_write(&ubifs_inode(host)->xattr_sem); + kfree(xent); + return err; + } +@@ -341,18 +343,19 @@ ssize_t ubifs_xattr_get(struct inode *host, const char *name, void *buf, + if (!xent) + return -ENOMEM; + ++ down_read(&ubifs_inode(host)->xattr_sem); + xent_key_init(c, &key, host->i_ino, &nm); + err = ubifs_tnc_lookup_nm(c, &key, xent, &nm); + if (err) { + if (err == -ENOENT) + err = -ENODATA; +- goto out_unlock; ++ goto out_cleanup; + } + + inode = iget_xattr(c, le64_to_cpu(xent->inum)); + if (IS_ERR(inode)) { + err = PTR_ERR(inode); +- goto out_unlock; ++ goto out_cleanup; + } + + ui = ubifs_inode(inode); +@@ -374,7 +377,8 @@ ssize_t ubifs_xattr_get(struct inode *host, const char *name, void *buf, + out_iput: + mutex_unlock(&ui->ui_mutex); + iput(inode); +-out_unlock: ++out_cleanup: ++ up_read(&ubifs_inode(host)->xattr_sem); + kfree(xent); + return err; + } +@@ -406,16 +410,21 @@ ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size) + dbg_gen("ino %lu ('%pd'), buffer size %zd", host->i_ino, + dentry, size); + ++ down_read(&host_ui->xattr_sem); + len = host_ui->xattr_names + host_ui->xattr_cnt; +- if (!buffer) ++ if (!buffer) { + /* + * We should return the minimum buffer size which will fit a + * null-terminated list of all the extended attribute names. + */ +- return len; ++ err = len; ++ goto out_err; ++ } + +- if (len > size) +- return -ERANGE; ++ if (len > size) { ++ err = -ERANGE; ++ goto out_err; ++ } + + lowest_xent_key(c, &key, host->i_ino); + while (1) { +@@ -437,8 +446,9 @@ ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size) + pxent = xent; + key_read(c, &xent->key, &key); + } +- + kfree(pxent); ++ up_read(&host_ui->xattr_sem); ++ + if (err != -ENOENT) { + ubifs_err(c, "cannot find next direntry, error %d", err); + return err; +@@ -446,6 +456,10 @@ ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size) + + ubifs_assert(c, written <= size); + return written; ++ ++out_err: ++ up_read(&host_ui->xattr_sem); ++ return err; + } + + static int remove_xattr(struct ubifs_info *c, struct inode *host, +@@ -504,6 +518,7 @@ int ubifs_purge_xattrs(struct inode *host) + ubifs_warn(c, "inode %lu has too many xattrs, doing a non-atomic deletion", + host->i_ino); + ++ down_write(&ubifs_inode(host)->xattr_sem); + lowest_xent_key(c, &key, host->i_ino); + while (1) { + xent = ubifs_tnc_next_ent(c, &key, &nm); +@@ -523,7 +538,7 @@ int ubifs_purge_xattrs(struct inode *host) + ubifs_ro_mode(c, err); + kfree(pxent); + kfree(xent); +- return err; ++ goto out_err; + } + + ubifs_assert(c, ubifs_inode(xino)->xattr); +@@ -535,7 +550,7 @@ int ubifs_purge_xattrs(struct inode *host) + kfree(xent); + iput(xino); + ubifs_err(c, "cannot remove xattr, error %d", err); +- return err; ++ goto out_err; + } + + iput(xino); +@@ -544,14 +559,19 @@ int ubifs_purge_xattrs(struct inode *host) + pxent = xent; + key_read(c, &xent->key, &key); + } +- + kfree(pxent); ++ up_write(&ubifs_inode(host)->xattr_sem); ++ + if (err != -ENOENT) { + ubifs_err(c, "cannot find next direntry, error %d", err); + return err; + } + + return 0; ++ ++out_err: ++ up_write(&ubifs_inode(host)->xattr_sem); ++ return err; + } + + /** +@@ -594,6 +614,7 @@ static int ubifs_xattr_remove(struct inode *host, const char *name) + if (!xent) + return -ENOMEM; + ++ down_write(&ubifs_inode(host)->xattr_sem); + xent_key_init(c, &key, host->i_ino, &nm); + err = ubifs_tnc_lookup_nm(c, &key, xent, &nm); + if (err) { +@@ -618,6 +639,7 @@ static int ubifs_xattr_remove(struct inode *host, const char *name) + iput(inode); + + out_free: ++ up_write(&ubifs_inode(host)->xattr_sem); + kfree(xent); + return err; + } +diff --git a/fs/udf/namei.c b/fs/udf/namei.c +index f146b3089f3da..6c5692ad42b55 100644 +--- a/fs/udf/namei.c ++++ b/fs/udf/namei.c +@@ -934,6 +934,10 @@ static int udf_symlink(struct user_namespace *mnt_userns, struct inode *dir, + iinfo->i_location.partitionReferenceNum, + 0); + epos.bh = udf_tgetblk(sb, block); ++ if (unlikely(!epos.bh)) { ++ err = -ENOMEM; ++ goto out_no_entry; ++ } + lock_buffer(epos.bh); + memset(epos.bh->b_data, 0x00, bsize); + set_buffer_uptodate(epos.bh); +diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h +index db026b6ec15ab..e5cf12f102a21 100644 +--- a/include/linux/blk_types.h ++++ b/include/linux/blk_types.h +@@ -304,6 +304,7 @@ enum { + BIO_CGROUP_ACCT, /* has been accounted to a cgroup */ + BIO_TRACKED, /* set if bio goes through the rq_qos path */ + BIO_REMAPPED, ++ BIO_ZONE_WRITE_LOCKED, /* Owns a zoned device zone write lock */ + BIO_FLAG_LAST + }; + +diff --git a/include/linux/mfd/abx500/ux500_chargalg.h b/include/linux/mfd/abx500/ux500_chargalg.h +index 9b97d284d0ce8..bc3819dc33e12 100644 +--- a/include/linux/mfd/abx500/ux500_chargalg.h ++++ b/include/linux/mfd/abx500/ux500_chargalg.h +@@ -15,7 +15,7 @@ + * - POWER_SUPPLY_TYPE_USB, + * because only them store as drv_data pointer to struct ux500_charger. + */ +-#define psy_to_ux500_charger(x) power_supply_get_drvdata(psy) ++#define psy_to_ux500_charger(x) power_supply_get_drvdata(x) + + /* Forward declaration */ + struct ux500_charger; +diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h +index 3de38d6a0aeac..2c6b9e4162254 100644 +--- a/include/linux/netdev_features.h ++++ b/include/linux/netdev_features.h +@@ -93,7 +93,7 @@ enum { + + /* + * Add your fresh new feature above and remember to update +- * netdev_features_strings[] in net/core/ethtool.c and maybe ++ * netdev_features_strings[] in net/ethtool/common.c and maybe + * some feature mask #defines below. Please also describe it + * in Documentation/networking/netdev-features.rst. + */ +diff --git a/include/linux/of_mdio.h b/include/linux/of_mdio.h +index 2b05e7f7c2385..da633d34ab866 100644 +--- a/include/linux/of_mdio.h ++++ b/include/linux/of_mdio.h +@@ -72,6 +72,13 @@ static inline int of_mdiobus_register(struct mii_bus *mdio, struct device_node * + return mdiobus_register(mdio); + } + ++static inline int devm_of_mdiobus_register(struct device *dev, ++ struct mii_bus *mdio, ++ struct device_node *np) ++{ ++ return devm_mdiobus_register(dev, mdio); ++} ++ + static inline struct mdio_device *of_mdio_find_device(struct device_node *np) + { + return NULL; +diff --git a/include/linux/wait.h b/include/linux/wait.h +index fe10e8570a522..6598ae35e1b5a 100644 +--- a/include/linux/wait.h ++++ b/include/linux/wait.h +@@ -1136,7 +1136,7 @@ do { \ + * Waitqueues which are removed from the waitqueue_head at wakeup time + */ + void prepare_to_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state); +-void prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state); ++bool prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state); + long prepare_to_wait_event(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state); + void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry); + long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout); +diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h +index d0e9a5bdb08bb..6078dd29f3e77 100644 +--- a/include/media/v4l2-subdev.h ++++ b/include/media/v4l2-subdev.h +@@ -162,6 +162,9 @@ struct v4l2_subdev_io_pin_config { + * @s_gpio: set GPIO pins. Very simple right now, might need to be extended with + * a direction argument if needed. + * ++ * @command: called by in-kernel drivers in order to call functions internal ++ * to subdev drivers driver that have a separate callback. ++ * + * @ioctl: called at the end of ioctl() syscall handler at the V4L2 core. + * used to provide support for private ioctls used on the driver. + * +@@ -193,6 +196,7 @@ struct v4l2_subdev_core_ops { + int (*load_fw)(struct v4l2_subdev *sd); + int (*reset)(struct v4l2_subdev *sd, u32 val); + int (*s_gpio)(struct v4l2_subdev *sd, u32 val); ++ long (*command)(struct v4l2_subdev *sd, unsigned int cmd, void *arg); + long (*ioctl)(struct v4l2_subdev *sd, unsigned int cmd, void *arg); + #ifdef CONFIG_COMPAT + long (*compat_ioctl32)(struct v4l2_subdev *sd, unsigned int cmd, +diff --git a/include/net/flow_offload.h b/include/net/flow_offload.h +index e6bd8ebf9ac33..c28ea1f0ec9c0 100644 +--- a/include/net/flow_offload.h ++++ b/include/net/flow_offload.h +@@ -313,12 +313,14 @@ flow_action_mixed_hw_stats_check(const struct flow_action *action, + if (flow_offload_has_one_action(action)) + return true; + +- flow_action_for_each(i, action_entry, action) { +- if (i && action_entry->hw_stats != last_hw_stats) { +- NL_SET_ERR_MSG_MOD(extack, "Mixing HW stats types for actions is not supported"); +- return false; ++ if (action) { ++ flow_action_for_each(i, action_entry, action) { ++ if (i && action_entry->hw_stats != last_hw_stats) { ++ NL_SET_ERR_MSG_MOD(extack, "Mixing HW stats types for actions is not supported"); ++ return false; ++ } ++ last_hw_stats = action_entry->hw_stats; + } +- last_hw_stats = action_entry->hw_stats; + } + return true; + } +diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h +index 1aa585216f34b..d49593c72a555 100644 +--- a/include/net/sctp/structs.h ++++ b/include/net/sctp/structs.h +@@ -461,7 +461,7 @@ struct sctp_af { + int saddr); + void (*from_sk) (union sctp_addr *, + struct sock *sk); +- void (*from_addr_param) (union sctp_addr *, ++ bool (*from_addr_param) (union sctp_addr *, + union sctp_addr_param *, + __be16 port, int iif); + int (*to_addr_param) (const union sctp_addr *, +diff --git a/include/uapi/asm-generic/socket.h b/include/uapi/asm-generic/socket.h +index 4dcd13d097a9e..d588c244ec2fa 100644 +--- a/include/uapi/asm-generic/socket.h ++++ b/include/uapi/asm-generic/socket.h +@@ -122,6 +122,8 @@ + #define SO_PREFER_BUSY_POLL 69 + #define SO_BUSY_POLL_BUDGET 70 + ++#define SO_NETNS_COOKIE 71 ++ + #if !defined(__KERNEL__) + + #if __BITS_PER_LONG == 64 || (defined(__x86_64__) && defined(__ILP32__)) +diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h +index 5afea692a3f7c..e36eee9132ecb 100644 +--- a/include/uapi/linux/ethtool.h ++++ b/include/uapi/linux/ethtool.h +@@ -233,7 +233,7 @@ enum tunable_id { + ETHTOOL_PFC_PREVENTION_TOUT, /* timeout in msecs */ + /* + * Add your fresh new tunable attribute above and remember to update +- * tunable_strings[] in net/core/ethtool.c ++ * tunable_strings[] in net/ethtool/common.c + */ + __ETHTOOL_TUNABLE_COUNT, + }; +@@ -297,7 +297,7 @@ enum phy_tunable_id { + ETHTOOL_PHY_EDPD, + /* + * Add your fresh new phy tunable attribute above and remember to update +- * phy_tunable_strings[] in net/core/ethtool.c ++ * phy_tunable_strings[] in net/ethtool/common.c + */ + __ETHTOOL_PHY_TUNABLE_COUNT, + }; +diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c +index 75244ecb2389f..952d98beda636 100644 +--- a/kernel/bpf/core.c ++++ b/kernel/bpf/core.c +@@ -1399,29 +1399,54 @@ static u64 ___bpf_prog_run(u64 *regs, const struct bpf_insn *insn, u64 *stack) + select_insn: + goto *jumptable[insn->code]; + +- /* ALU */ +-#define ALU(OPCODE, OP) \ +- ALU64_##OPCODE##_X: \ +- DST = DST OP SRC; \ +- CONT; \ +- ALU_##OPCODE##_X: \ +- DST = (u32) DST OP (u32) SRC; \ +- CONT; \ +- ALU64_##OPCODE##_K: \ +- DST = DST OP IMM; \ +- CONT; \ +- ALU_##OPCODE##_K: \ +- DST = (u32) DST OP (u32) IMM; \ ++ /* Explicitly mask the register-based shift amounts with 63 or 31 ++ * to avoid undefined behavior. Normally this won't affect the ++ * generated code, for example, in case of native 64 bit archs such ++ * as x86-64 or arm64, the compiler is optimizing the AND away for ++ * the interpreter. In case of JITs, each of the JIT backends compiles ++ * the BPF shift operations to machine instructions which produce ++ * implementation-defined results in such a case; the resulting ++ * contents of the register may be arbitrary, but program behaviour ++ * as a whole remains defined. In other words, in case of JIT backends, ++ * the AND must /not/ be added to the emitted LSH/RSH/ARSH translation. ++ */ ++ /* ALU (shifts) */ ++#define SHT(OPCODE, OP) \ ++ ALU64_##OPCODE##_X: \ ++ DST = DST OP (SRC & 63); \ ++ CONT; \ ++ ALU_##OPCODE##_X: \ ++ DST = (u32) DST OP ((u32) SRC & 31); \ ++ CONT; \ ++ ALU64_##OPCODE##_K: \ ++ DST = DST OP IMM; \ ++ CONT; \ ++ ALU_##OPCODE##_K: \ ++ DST = (u32) DST OP (u32) IMM; \ ++ CONT; ++ /* ALU (rest) */ ++#define ALU(OPCODE, OP) \ ++ ALU64_##OPCODE##_X: \ ++ DST = DST OP SRC; \ ++ CONT; \ ++ ALU_##OPCODE##_X: \ ++ DST = (u32) DST OP (u32) SRC; \ ++ CONT; \ ++ ALU64_##OPCODE##_K: \ ++ DST = DST OP IMM; \ ++ CONT; \ ++ ALU_##OPCODE##_K: \ ++ DST = (u32) DST OP (u32) IMM; \ + CONT; +- + ALU(ADD, +) + ALU(SUB, -) + ALU(AND, &) + ALU(OR, |) +- ALU(LSH, <<) +- ALU(RSH, >>) + ALU(XOR, ^) + ALU(MUL, *) ++ SHT(LSH, <<) ++ SHT(RSH, >>) ++#undef SHT + #undef ALU + ALU_NEG: + DST = (u32) -DST; +@@ -1446,13 +1471,13 @@ select_insn: + insn++; + CONT; + ALU_ARSH_X: +- DST = (u64) (u32) (((s32) DST) >> SRC); ++ DST = (u64) (u32) (((s32) DST) >> (SRC & 31)); + CONT; + ALU_ARSH_K: + DST = (u64) (u32) (((s32) DST) >> IMM); + CONT; + ALU64_ARSH_X: +- (*(s64 *) &DST) >>= SRC; ++ (*(s64 *) &DST) >>= (SRC & 63); + CONT; + ALU64_ARSH_K: + (*(s64 *) &DST) >>= IMM; +diff --git a/kernel/bpf/ringbuf.c b/kernel/bpf/ringbuf.c +index 84b3b35fc0d05..9e0c10c6892ad 100644 +--- a/kernel/bpf/ringbuf.c ++++ b/kernel/bpf/ringbuf.c +@@ -8,6 +8,7 @@ + #include + #include + #include ++#include + #include + + #define RINGBUF_CREATE_FLAG_MASK (BPF_F_NUMA_NODE) +@@ -105,6 +106,7 @@ static struct bpf_ringbuf *bpf_ringbuf_area_alloc(size_t data_sz, int numa_node) + rb = vmap(pages, nr_meta_pages + 2 * nr_data_pages, + VM_ALLOC | VM_USERMAP, PAGE_KERNEL); + if (rb) { ++ kmemleak_not_leak(pages); + rb->pages = pages; + rb->nr_pages = nr_pages; + return rb; +diff --git a/kernel/cpu.c b/kernel/cpu.c +index 1b6302ecbabe9..83e65219da567 100644 +--- a/kernel/cpu.c ++++ b/kernel/cpu.c +@@ -32,6 +32,7 @@ + #include + #include + #include ++#include + + #include + #define CREATE_TRACE_POINTS +@@ -821,6 +822,52 @@ void __init cpuhp_threads_init(void) + kthread_unpark(this_cpu_read(cpuhp_state.thread)); + } + ++/* ++ * ++ * Serialize hotplug trainwrecks outside of the cpu_hotplug_lock ++ * protected region. ++ * ++ * The operation is still serialized against concurrent CPU hotplug via ++ * cpu_add_remove_lock, i.e. CPU map protection. But it is _not_ ++ * serialized against other hotplug related activity like adding or ++ * removing of state callbacks and state instances, which invoke either the ++ * startup or the teardown callback of the affected state. ++ * ++ * This is required for subsystems which are unfixable vs. CPU hotplug and ++ * evade lock inversion problems by scheduling work which has to be ++ * completed _before_ cpu_up()/_cpu_down() returns. ++ * ++ * Don't even think about adding anything to this for any new code or even ++ * drivers. It's only purpose is to keep existing lock order trainwrecks ++ * working. ++ * ++ * For cpu_down() there might be valid reasons to finish cleanups which are ++ * not required to be done under cpu_hotplug_lock, but that's a different ++ * story and would be not invoked via this. ++ */ ++static void cpu_up_down_serialize_trainwrecks(bool tasks_frozen) ++{ ++ /* ++ * cpusets delegate hotplug operations to a worker to "solve" the ++ * lock order problems. Wait for the worker, but only if tasks are ++ * _not_ frozen (suspend, hibernate) as that would wait forever. ++ * ++ * The wait is required because otherwise the hotplug operation ++ * returns with inconsistent state, which could even be observed in ++ * user space when a new CPU is brought up. The CPU plug uevent ++ * would be delivered and user space reacting on it would fail to ++ * move tasks to the newly plugged CPU up to the point where the ++ * work has finished because up to that point the newly plugged CPU ++ * is not assignable in cpusets/cgroups. On unplug that's not ++ * necessarily a visible issue, but it is still inconsistent state, ++ * which is the real problem which needs to be "fixed". This can't ++ * prevent the transient state between scheduling the work and ++ * returning from waiting for it. ++ */ ++ if (!tasks_frozen) ++ cpuset_wait_for_hotplug(); ++} ++ + #ifdef CONFIG_HOTPLUG_CPU + #ifndef arch_clear_mm_cpumask_cpu + #define arch_clear_mm_cpumask_cpu(cpu, mm) cpumask_clear_cpu(cpu, mm_cpumask(mm)) +@@ -1058,6 +1105,7 @@ out: + */ + lockup_detector_cleanup(); + arch_smt_update(); ++ cpu_up_down_serialize_trainwrecks(tasks_frozen); + return ret; + } + +@@ -1254,6 +1302,7 @@ static int _cpu_up(unsigned int cpu, int tasks_frozen, enum cpuhp_state target) + out: + cpus_write_unlock(); + arch_smt_update(); ++ cpu_up_down_serialize_trainwrecks(tasks_frozen); + return ret; + } + +diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c +index 20ac5dff9a0ce..572f312cc8039 100644 +--- a/kernel/sched/fair.c ++++ b/kernel/sched/fair.c +@@ -3665,15 +3665,15 @@ update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq) + + r = removed_load; + sub_positive(&sa->load_avg, r); +- sub_positive(&sa->load_sum, r * divider); ++ sa->load_sum = sa->load_avg * divider; + + r = removed_util; + sub_positive(&sa->util_avg, r); +- sub_positive(&sa->util_sum, r * divider); ++ sa->util_sum = sa->util_avg * divider; + + r = removed_runnable; + sub_positive(&sa->runnable_avg, r); +- sub_positive(&sa->runnable_sum, r * divider); ++ sa->runnable_sum = sa->runnable_avg * divider; + + /* + * removed_runnable is the unweighted version of removed_load so we +diff --git a/kernel/sched/wait.c b/kernel/sched/wait.c +index 183cc6ae68a68..76577d1642a5d 100644 +--- a/kernel/sched/wait.c ++++ b/kernel/sched/wait.c +@@ -264,17 +264,22 @@ prepare_to_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_ent + } + EXPORT_SYMBOL(prepare_to_wait); + +-void ++/* Returns true if we are the first waiter in the queue, false otherwise. */ ++bool + prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state) + { + unsigned long flags; ++ bool was_empty = false; + + wq_entry->flags |= WQ_FLAG_EXCLUSIVE; + spin_lock_irqsave(&wq_head->lock, flags); +- if (list_empty(&wq_entry->entry)) ++ if (list_empty(&wq_entry->entry)) { ++ was_empty = list_empty(&wq_head->head); + __add_wait_queue_entry_tail(wq_head, wq_entry); ++ } + set_current_state(state); + spin_unlock_irqrestore(&wq_head->lock, flags); ++ return was_empty; + } + EXPORT_SYMBOL(prepare_to_wait_exclusive); + +diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c +index 7c8151d74faf0..534bab352fc94 100644 +--- a/kernel/trace/trace.c ++++ b/kernel/trace/trace.c +@@ -2184,8 +2184,15 @@ void tracing_reset_all_online_cpus(void) + } + } + ++/* ++ * The tgid_map array maps from pid to tgid; i.e. the value stored at index i ++ * is the tgid last observed corresponding to pid=i. ++ */ + static int *tgid_map; + ++/* The maximum valid index into tgid_map. */ ++static size_t tgid_map_max; ++ + #define SAVED_CMDLINES_DEFAULT 128 + #define NO_CMDLINE_MAP UINT_MAX + static arch_spinlock_t trace_cmdline_lock = __ARCH_SPIN_LOCK_UNLOCKED; +@@ -2458,24 +2465,41 @@ void trace_find_cmdline(int pid, char comm[]) + preempt_enable(); + } + ++static int *trace_find_tgid_ptr(int pid) ++{ ++ /* ++ * Pairs with the smp_store_release in set_tracer_flag() to ensure that ++ * if we observe a non-NULL tgid_map then we also observe the correct ++ * tgid_map_max. ++ */ ++ int *map = smp_load_acquire(&tgid_map); ++ ++ if (unlikely(!map || pid > tgid_map_max)) ++ return NULL; ++ ++ return &map[pid]; ++} ++ + int trace_find_tgid(int pid) + { +- if (unlikely(!tgid_map || !pid || pid > PID_MAX_DEFAULT)) +- return 0; ++ int *ptr = trace_find_tgid_ptr(pid); + +- return tgid_map[pid]; ++ return ptr ? *ptr : 0; + } + + static int trace_save_tgid(struct task_struct *tsk) + { ++ int *ptr; ++ + /* treat recording of idle task as a success */ + if (!tsk->pid) + return 1; + +- if (unlikely(!tgid_map || tsk->pid > PID_MAX_DEFAULT)) ++ ptr = trace_find_tgid_ptr(tsk->pid); ++ if (!ptr) + return 0; + +- tgid_map[tsk->pid] = tsk->tgid; ++ *ptr = tsk->tgid; + return 1; + } + +@@ -4915,6 +4939,8 @@ int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set) + + int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled) + { ++ int *map; ++ + if ((mask == TRACE_ITER_RECORD_TGID) || + (mask == TRACE_ITER_RECORD_CMD)) + lockdep_assert_held(&event_mutex); +@@ -4937,10 +4963,19 @@ int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled) + trace_event_enable_cmd_record(enabled); + + if (mask == TRACE_ITER_RECORD_TGID) { +- if (!tgid_map) +- tgid_map = kvcalloc(PID_MAX_DEFAULT + 1, +- sizeof(*tgid_map), +- GFP_KERNEL); ++ if (!tgid_map) { ++ tgid_map_max = pid_max; ++ map = kvcalloc(tgid_map_max + 1, sizeof(*tgid_map), ++ GFP_KERNEL); ++ ++ /* ++ * Pairs with smp_load_acquire() in ++ * trace_find_tgid_ptr() to ensure that if it observes ++ * the tgid_map we just allocated then it also observes ++ * the corresponding tgid_map_max value. ++ */ ++ smp_store_release(&tgid_map, map); ++ } + if (!tgid_map) { + tr->trace_flags &= ~TRACE_ITER_RECORD_TGID; + return -ENOMEM; +@@ -5352,37 +5387,16 @@ static const struct file_operations tracing_readme_fops = { + + static void *saved_tgids_next(struct seq_file *m, void *v, loff_t *pos) + { +- int *ptr = v; ++ int pid = ++(*pos); + +- if (*pos || m->count) +- ptr++; +- +- (*pos)++; +- +- for (; ptr <= &tgid_map[PID_MAX_DEFAULT]; ptr++) { +- if (trace_find_tgid(*ptr)) +- return ptr; +- } +- +- return NULL; ++ return trace_find_tgid_ptr(pid); + } + + static void *saved_tgids_start(struct seq_file *m, loff_t *pos) + { +- void *v; +- loff_t l = 0; ++ int pid = *pos; + +- if (!tgid_map) +- return NULL; +- +- v = &tgid_map[0]; +- while (l <= *pos) { +- v = saved_tgids_next(m, v, &l); +- if (!v) +- return NULL; +- } +- +- return v; ++ return trace_find_tgid_ptr(pid); + } + + static void saved_tgids_stop(struct seq_file *m, void *v) +@@ -5391,9 +5405,14 @@ static void saved_tgids_stop(struct seq_file *m, void *v) + + static int saved_tgids_show(struct seq_file *m, void *v) + { +- int pid = (int *)v - tgid_map; ++ int *entry = (int *)v; ++ int pid = entry - tgid_map; ++ int tgid = *entry; ++ ++ if (tgid == 0) ++ return SEQ_SKIP; + +- seq_printf(m, "%d %d\n", pid, trace_find_tgid(pid)); ++ seq_printf(m, "%d %d\n", pid, tgid); + return 0; + } + +diff --git a/lib/seq_buf.c b/lib/seq_buf.c +index 89c26c393bdba..6dafde8513337 100644 +--- a/lib/seq_buf.c ++++ b/lib/seq_buf.c +@@ -229,8 +229,10 @@ int seq_buf_putmem_hex(struct seq_buf *s, const void *mem, + + WARN_ON(s->size == 0); + ++ BUILD_BUG_ON(MAX_MEMHEX_BYTES * 2 >= HEX_CHARS); ++ + while (len) { +- start_len = min(len, HEX_CHARS - 1); ++ start_len = min(len, MAX_MEMHEX_BYTES); + #ifdef __BIG_ENDIAN + for (i = 0, j = 0; i < start_len; i++) { + #else +diff --git a/mm/mremap.c b/mm/mremap.c +index ec8f840399ed4..7de4a01b0f8d9 100644 +--- a/mm/mremap.c ++++ b/mm/mremap.c +@@ -439,7 +439,7 @@ unsigned long move_page_tables(struct vm_area_struct *vma, + if (!new_pud) + break; + if (move_pgt_entry(NORMAL_PUD, vma, old_addr, new_addr, +- old_pud, new_pud, need_rmap_locks)) ++ old_pud, new_pud, true)) + continue; + } + +@@ -466,7 +466,7 @@ unsigned long move_page_tables(struct vm_area_struct *vma, + * moving at the PMD level if possible. + */ + if (move_pgt_entry(NORMAL_PMD, vma, old_addr, new_addr, +- old_pmd, new_pmd, need_rmap_locks)) ++ old_pmd, new_pmd, true)) + continue; + } + +diff --git a/net/bluetooth/hci_core.c b/net/bluetooth/hci_core.c +index 4fad2ca661ed9..f4e8a4ba663f4 100644 +--- a/net/bluetooth/hci_core.c ++++ b/net/bluetooth/hci_core.c +@@ -1719,14 +1719,6 @@ int hci_dev_do_close(struct hci_dev *hdev) + + BT_DBG("%s %p", hdev->name, hdev); + +- if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && +- !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && +- test_bit(HCI_UP, &hdev->flags)) { +- /* Execute vendor specific shutdown routine */ +- if (hdev->shutdown) +- hdev->shutdown(hdev); +- } +- + cancel_delayed_work(&hdev->power_off); + + hci_request_cancel_all(hdev); +@@ -1802,6 +1794,14 @@ int hci_dev_do_close(struct hci_dev *hdev) + clear_bit(HCI_INIT, &hdev->flags); + } + ++ if (!hci_dev_test_flag(hdev, HCI_UNREGISTER) && ++ !hci_dev_test_flag(hdev, HCI_USER_CHANNEL) && ++ test_bit(HCI_UP, &hdev->flags)) { ++ /* Execute vendor specific shutdown routine */ ++ if (hdev->shutdown) ++ hdev->shutdown(hdev); ++ } ++ + /* flush cmd work */ + flush_work(&hdev->cmd_work); + +diff --git a/net/bluetooth/hci_event.c b/net/bluetooth/hci_event.c +index c6f400b108d94..99c89f02a9747 100644 +--- a/net/bluetooth/hci_event.c ++++ b/net/bluetooth/hci_event.c +@@ -4379,12 +4379,12 @@ static void hci_sync_conn_complete_evt(struct hci_dev *hdev, + + bt_dev_dbg(hdev, "SCO connected with air mode: %02x", ev->air_mode); + +- switch (conn->setting & SCO_AIRMODE_MASK) { +- case SCO_AIRMODE_CVSD: ++ switch (ev->air_mode) { ++ case 0x02: + if (hdev->notify) + hdev->notify(hdev, HCI_NOTIFY_ENABLE_SCO_CVSD); + break; +- case SCO_AIRMODE_TRANSP: ++ case 0x03: + if (hdev->notify) + hdev->notify(hdev, HCI_NOTIFY_ENABLE_SCO_TRANSP); + break; +diff --git a/net/bluetooth/l2cap_core.c b/net/bluetooth/l2cap_core.c +index 53ddbee459b99..b1f4d5505bbac 100644 +--- a/net/bluetooth/l2cap_core.c ++++ b/net/bluetooth/l2cap_core.c +@@ -6062,7 +6062,7 @@ static inline int l2cap_ecred_conn_rsp(struct l2cap_conn *conn, + struct l2cap_ecred_conn_rsp *rsp = (void *) data; + struct hci_conn *hcon = conn->hcon; + u16 mtu, mps, credits, result; +- struct l2cap_chan *chan; ++ struct l2cap_chan *chan, *tmp; + int err = 0, sec_level; + int i = 0; + +@@ -6081,7 +6081,7 @@ static inline int l2cap_ecred_conn_rsp(struct l2cap_conn *conn, + + cmd_len -= sizeof(*rsp); + +- list_for_each_entry(chan, &conn->chan_l, list) { ++ list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { + u16 dcid; + + if (chan->ident != cmd->ident || +@@ -6244,7 +6244,7 @@ static inline int l2cap_ecred_reconf_rsp(struct l2cap_conn *conn, + struct l2cap_cmd_hdr *cmd, u16 cmd_len, + u8 *data) + { +- struct l2cap_chan *chan; ++ struct l2cap_chan *chan, *tmp; + struct l2cap_ecred_conn_rsp *rsp = (void *) data; + u16 result; + +@@ -6258,7 +6258,7 @@ static inline int l2cap_ecred_reconf_rsp(struct l2cap_conn *conn, + if (!result) + return 0; + +- list_for_each_entry(chan, &conn->chan_l, list) { ++ list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) { + if (chan->ident != cmd->ident) + continue; + +diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c +index 71de147f55584..b4f6773b1a5b6 100644 +--- a/net/bluetooth/mgmt.c ++++ b/net/bluetooth/mgmt.c +@@ -250,12 +250,15 @@ static const u8 mgmt_status_table[] = { + MGMT_STATUS_TIMEOUT, /* Instant Passed */ + MGMT_STATUS_NOT_SUPPORTED, /* Pairing Not Supported */ + MGMT_STATUS_FAILED, /* Transaction Collision */ ++ MGMT_STATUS_FAILED, /* Reserved for future use */ + MGMT_STATUS_INVALID_PARAMS, /* Unacceptable Parameter */ + MGMT_STATUS_REJECTED, /* QoS Rejected */ + MGMT_STATUS_NOT_SUPPORTED, /* Classification Not Supported */ + MGMT_STATUS_REJECTED, /* Insufficient Security */ + MGMT_STATUS_INVALID_PARAMS, /* Parameter Out Of Range */ ++ MGMT_STATUS_FAILED, /* Reserved for future use */ + MGMT_STATUS_BUSY, /* Role Switch Pending */ ++ MGMT_STATUS_FAILED, /* Reserved for future use */ + MGMT_STATUS_FAILED, /* Slot Violation */ + MGMT_STATUS_FAILED, /* Role Switch Failed */ + MGMT_STATUS_INVALID_PARAMS, /* EIR Too Large */ +@@ -4053,6 +4056,8 @@ static int get_device_flags(struct sock *sk, struct hci_dev *hdev, void *data, + + hci_dev_lock(hdev); + ++ memset(&rp, 0, sizeof(rp)); ++ + if (cp->addr.type == BDADDR_BREDR) { + br_params = hci_bdaddr_list_lookup_with_flags(&hdev->whitelist, + &cp->addr.bdaddr, +diff --git a/net/bridge/br_mrp.c b/net/bridge/br_mrp.c +index 12487f6fe9b48..58254fbfda858 100644 +--- a/net/bridge/br_mrp.c ++++ b/net/bridge/br_mrp.c +@@ -620,8 +620,7 @@ int br_mrp_set_ring_state(struct net_bridge *br, + if (!mrp) + return -EINVAL; + +- if (mrp->ring_state == BR_MRP_RING_STATE_CLOSED && +- state->ring_state != BR_MRP_RING_STATE_CLOSED) ++ if (mrp->ring_state != state->ring_state) + mrp->ring_transitions++; + + mrp->ring_state = state->ring_state; +@@ -708,8 +707,7 @@ int br_mrp_set_in_state(struct net_bridge *br, struct br_mrp_in_state *state) + if (!mrp) + return -EINVAL; + +- if (mrp->in_state == BR_MRP_IN_STATE_CLOSED && +- state->in_state != BR_MRP_IN_STATE_CLOSED) ++ if (mrp->in_state != state->in_state) + mrp->in_transitions++; + + mrp->in_state = state->in_state; +diff --git a/net/core/dev.c b/net/core/dev.c +index 9631944740586..a8c89cad1ca48 100644 +--- a/net/core/dev.c ++++ b/net/core/dev.c +@@ -6472,11 +6472,18 @@ EXPORT_SYMBOL(napi_schedule_prep); + * __napi_schedule_irqoff - schedule for receive + * @n: entry to schedule + * +- * Variant of __napi_schedule() assuming hard irqs are masked ++ * Variant of __napi_schedule() assuming hard irqs are masked. ++ * ++ * On PREEMPT_RT enabled kernels this maps to __napi_schedule() ++ * because the interrupt disabled assumption might not be true ++ * due to force-threaded interrupts and spinlock substitution. + */ + void __napi_schedule_irqoff(struct napi_struct *n) + { +- ____napi_schedule(this_cpu_ptr(&softnet_data), n); ++ if (!IS_ENABLED(CONFIG_PREEMPT_RT)) ++ ____napi_schedule(this_cpu_ptr(&softnet_data), n); ++ else ++ __napi_schedule(n); + } + EXPORT_SYMBOL(__napi_schedule_irqoff); + +diff --git a/net/core/sock.c b/net/core/sock.c +index a266760cd65ea..60750f9ae32d4 100644 +--- a/net/core/sock.c ++++ b/net/core/sock.c +@@ -1622,6 +1622,13 @@ int sock_getsockopt(struct socket *sock, int level, int optname, + v.val = sk->sk_bound_dev_if; + break; + ++ case SO_NETNS_COOKIE: ++ lv = sizeof(u64); ++ if (len != lv) ++ return -EINVAL; ++ v.val64 = sock_net(sk)->net_cookie; ++ break; ++ + default: + /* We implement the SO_SNDLOWAT etc to not be settable + * (1003.1g 7). +diff --git a/net/hsr/hsr_framereg.c b/net/hsr/hsr_framereg.c +index bb1351c38397f..e31949479305e 100644 +--- a/net/hsr/hsr_framereg.c ++++ b/net/hsr/hsr_framereg.c +@@ -397,7 +397,8 @@ void hsr_register_frame_in(struct hsr_node *node, struct hsr_port *port, + * ensures entries of restarted nodes gets pruned so that they can + * re-register and resume communications. + */ +- if (seq_nr_before(sequence_nr, node->seq_out[port->type])) ++ if (!(port->dev->features & NETIF_F_HW_HSR_TAG_RM) && ++ seq_nr_before(sequence_nr, node->seq_out[port->type])) + return; + + node->time_in[port->type] = jiffies; +diff --git a/net/ipv4/ip_output.c b/net/ipv4/ip_output.c +index 3aab53beb4ea2..3ec3b67c184fb 100644 +--- a/net/ipv4/ip_output.c ++++ b/net/ipv4/ip_output.c +@@ -1054,7 +1054,7 @@ static int __ip_append_data(struct sock *sk, + unsigned int datalen; + unsigned int fraglen; + unsigned int fraggap; +- unsigned int alloclen; ++ unsigned int alloclen, alloc_extra; + unsigned int pagedlen; + struct sk_buff *skb_prev; + alloc_new_skb: +@@ -1074,35 +1074,39 @@ alloc_new_skb: + fraglen = datalen + fragheaderlen; + pagedlen = 0; + ++ alloc_extra = hh_len + 15; ++ alloc_extra += exthdrlen; ++ ++ /* The last fragment gets additional space at tail. ++ * Note, with MSG_MORE we overallocate on fragments, ++ * because we have no idea what fragment will be ++ * the last. ++ */ ++ if (datalen == length + fraggap) ++ alloc_extra += rt->dst.trailer_len; ++ + if ((flags & MSG_MORE) && + !(rt->dst.dev->features&NETIF_F_SG)) + alloclen = mtu; +- else if (!paged) ++ else if (!paged && ++ (fraglen + alloc_extra < SKB_MAX_ALLOC || ++ !(rt->dst.dev->features & NETIF_F_SG))) + alloclen = fraglen; + else { + alloclen = min_t(int, fraglen, MAX_HEADER); + pagedlen = fraglen - alloclen; + } + +- alloclen += exthdrlen; +- +- /* The last fragment gets additional space at tail. +- * Note, with MSG_MORE we overallocate on fragments, +- * because we have no idea what fragment will be +- * the last. +- */ +- if (datalen == length + fraggap) +- alloclen += rt->dst.trailer_len; ++ alloclen += alloc_extra; + + if (transhdrlen) { +- skb = sock_alloc_send_skb(sk, +- alloclen + hh_len + 15, ++ skb = sock_alloc_send_skb(sk, alloclen, + (flags & MSG_DONTWAIT), &err); + } else { + skb = NULL; + if (refcount_read(&sk->sk_wmem_alloc) + wmem_alloc_delta <= + 2 * sk->sk_sndbuf) +- skb = alloc_skb(alloclen + hh_len + 15, ++ skb = alloc_skb(alloclen, + sk->sk_allocation); + if (unlikely(!skb)) + err = -ENOBUFS; +diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c +index 69a545db80d2e..e567fff1d1a66 100644 +--- a/net/ipv4/tcp_input.c ++++ b/net/ipv4/tcp_input.c +@@ -2816,8 +2816,17 @@ static void tcp_process_loss(struct sock *sk, int flag, int num_dupack, + *rexmit = REXMIT_LOST; + } + ++static bool tcp_force_fast_retransmit(struct sock *sk) ++{ ++ struct tcp_sock *tp = tcp_sk(sk); ++ ++ return after(tcp_highest_sack_seq(tp), ++ tp->snd_una + tp->reordering * tp->mss_cache); ++} ++ + /* Undo during fast recovery after partial ACK. */ +-static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una) ++static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una, ++ bool *do_lost) + { + struct tcp_sock *tp = tcp_sk(sk); + +@@ -2842,7 +2851,9 @@ static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una) + tcp_undo_cwnd_reduction(sk, true); + NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO); + tcp_try_keep_open(sk); +- return true; ++ } else { ++ /* Partial ACK arrived. Force fast retransmit. */ ++ *do_lost = tcp_force_fast_retransmit(sk); + } + return false; + } +@@ -2866,14 +2877,6 @@ static void tcp_identify_packet_loss(struct sock *sk, int *ack_flag) + } + } + +-static bool tcp_force_fast_retransmit(struct sock *sk) +-{ +- struct tcp_sock *tp = tcp_sk(sk); +- +- return after(tcp_highest_sack_seq(tp), +- tp->snd_una + tp->reordering * tp->mss_cache); +-} +- + /* Process an event, which can update packets-in-flight not trivially. + * Main goal of this function is to calculate new estimate for left_out, + * taking into account both packets sitting in receiver's buffer and +@@ -2943,17 +2946,21 @@ static void tcp_fastretrans_alert(struct sock *sk, const u32 prior_snd_una, + if (!(flag & FLAG_SND_UNA_ADVANCED)) { + if (tcp_is_reno(tp)) + tcp_add_reno_sack(sk, num_dupack, ece_ack); +- } else { +- if (tcp_try_undo_partial(sk, prior_snd_una)) +- return; +- /* Partial ACK arrived. Force fast retransmit. */ +- do_lost = tcp_force_fast_retransmit(sk); +- } +- if (tcp_try_undo_dsack(sk)) { +- tcp_try_keep_open(sk); ++ } else if (tcp_try_undo_partial(sk, prior_snd_una, &do_lost)) + return; +- } ++ ++ if (tcp_try_undo_dsack(sk)) ++ tcp_try_keep_open(sk); ++ + tcp_identify_packet_loss(sk, ack_flag); ++ if (icsk->icsk_ca_state != TCP_CA_Recovery) { ++ if (!tcp_time_to_recover(sk, flag)) ++ return; ++ /* Undo reverts the recovery state. If loss is evident, ++ * starts a new recovery (e.g. reordering then loss); ++ */ ++ tcp_enter_recovery(sk, ece_ack); ++ } + break; + case TCP_CA_Loss: + tcp_process_loss(sk, flag, num_dupack, rexmit); +diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c +index ff4f9ebcf7f65..497974b4372a7 100644 +--- a/net/ipv6/ip6_output.c ++++ b/net/ipv6/ip6_output.c +@@ -1555,7 +1555,7 @@ emsgsize: + unsigned int datalen; + unsigned int fraglen; + unsigned int fraggap; +- unsigned int alloclen; ++ unsigned int alloclen, alloc_extra; + unsigned int pagedlen; + alloc_new_skb: + /* There's no room in the current skb */ +@@ -1582,17 +1582,28 @@ alloc_new_skb: + fraglen = datalen + fragheaderlen; + pagedlen = 0; + ++ alloc_extra = hh_len; ++ alloc_extra += dst_exthdrlen; ++ alloc_extra += rt->dst.trailer_len; ++ ++ /* We just reserve space for fragment header. ++ * Note: this may be overallocation if the message ++ * (without MSG_MORE) fits into the MTU. ++ */ ++ alloc_extra += sizeof(struct frag_hdr); ++ + if ((flags & MSG_MORE) && + !(rt->dst.dev->features&NETIF_F_SG)) + alloclen = mtu; +- else if (!paged) ++ else if (!paged && ++ (fraglen + alloc_extra < SKB_MAX_ALLOC || ++ !(rt->dst.dev->features & NETIF_F_SG))) + alloclen = fraglen; + else { + alloclen = min_t(int, fraglen, MAX_HEADER); + pagedlen = fraglen - alloclen; + } +- +- alloclen += dst_exthdrlen; ++ alloclen += alloc_extra; + + if (datalen != length + fraggap) { + /* +@@ -1602,30 +1613,21 @@ alloc_new_skb: + datalen += rt->dst.trailer_len; + } + +- alloclen += rt->dst.trailer_len; + fraglen = datalen + fragheaderlen; + +- /* +- * We just reserve space for fragment header. +- * Note: this may be overallocation if the message +- * (without MSG_MORE) fits into the MTU. +- */ +- alloclen += sizeof(struct frag_hdr); +- + copy = datalen - transhdrlen - fraggap - pagedlen; + if (copy < 0) { + err = -EINVAL; + goto error; + } + if (transhdrlen) { +- skb = sock_alloc_send_skb(sk, +- alloclen + hh_len, ++ skb = sock_alloc_send_skb(sk, alloclen, + (flags & MSG_DONTWAIT), &err); + } else { + skb = NULL; + if (refcount_read(&sk->sk_wmem_alloc) + wmem_alloc_delta <= + 2 * sk->sk_sndbuf) +- skb = alloc_skb(alloclen + hh_len, ++ skb = alloc_skb(alloclen, + sk->sk_allocation); + if (unlikely(!skb)) + err = -ENOBUFS; +diff --git a/net/ipv6/output_core.c b/net/ipv6/output_core.c +index af36acc1a6448..2880dc7d9a491 100644 +--- a/net/ipv6/output_core.c ++++ b/net/ipv6/output_core.c +@@ -15,29 +15,11 @@ static u32 __ipv6_select_ident(struct net *net, + const struct in6_addr *dst, + const struct in6_addr *src) + { +- const struct { +- struct in6_addr dst; +- struct in6_addr src; +- } __aligned(SIPHASH_ALIGNMENT) combined = { +- .dst = *dst, +- .src = *src, +- }; +- u32 hash, id; +- +- /* Note the following code is not safe, but this is okay. */ +- if (unlikely(siphash_key_is_zero(&net->ipv4.ip_id_key))) +- get_random_bytes(&net->ipv4.ip_id_key, +- sizeof(net->ipv4.ip_id_key)); +- +- hash = siphash(&combined, sizeof(combined), &net->ipv4.ip_id_key); +- +- /* Treat id of 0 as unset and if we get 0 back from ip_idents_reserve, +- * set the hight order instead thus minimizing possible future +- * collisions. +- */ +- id = ip_idents_reserve(hash, 1); +- if (unlikely(!id)) +- id = 1 << 31; ++ u32 id; ++ ++ do { ++ id = prandom_u32(); ++ } while (!id); + + return id; + } +diff --git a/net/mac80211/main.c b/net/mac80211/main.c +index 9dd741b68f268..937a024a13e2d 100644 +--- a/net/mac80211/main.c ++++ b/net/mac80211/main.c +@@ -257,14 +257,13 @@ static void ieee80211_restart_work(struct work_struct *work) + /* wait for scan work complete */ + flush_workqueue(local->workqueue); + flush_work(&local->sched_scan_stopped_work); ++ flush_work(&local->radar_detected_work); ++ ++ rtnl_lock(); + + WARN(test_bit(SCAN_HW_SCANNING, &local->scanning), + "%s called with hardware scan in progress\n", __func__); + +- flush_work(&local->radar_detected_work); +- /* we might do interface manipulations, so need both */ +- rtnl_lock(); +- wiphy_lock(local->hw.wiphy); + list_for_each_entry(sdata, &local->interfaces, list) { + /* + * XXX: there may be more work for other vif types and even +diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c +index 13250cadb4202..e18c3855f6161 100644 +--- a/net/mac80211/sta_info.c ++++ b/net/mac80211/sta_info.c +@@ -2088,10 +2088,9 @@ static struct ieee80211_sta_rx_stats * + sta_get_last_rx_stats(struct sta_info *sta) + { + struct ieee80211_sta_rx_stats *stats = &sta->rx_stats; +- struct ieee80211_local *local = sta->local; + int cpu; + +- if (!ieee80211_hw_check(&local->hw, USES_RSS)) ++ if (!sta->pcpu_rx_stats) + return stats; + + for_each_possible_cpu(cpu) { +@@ -2191,9 +2190,7 @@ static void sta_set_tidstats(struct sta_info *sta, + int cpu; + + if (!(tidstats->filled & BIT(NL80211_TID_STATS_RX_MSDU))) { +- if (!ieee80211_hw_check(&local->hw, USES_RSS)) +- tidstats->rx_msdu += +- sta_get_tidstats_msdu(&sta->rx_stats, tid); ++ tidstats->rx_msdu += sta_get_tidstats_msdu(&sta->rx_stats, tid); + + if (sta->pcpu_rx_stats) { + for_each_possible_cpu(cpu) { +@@ -2272,7 +2269,6 @@ void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo, + sinfo->rx_beacon = sdata->u.mgd.count_beacon_signal; + + drv_sta_statistics(local, sdata, &sta->sta, sinfo); +- + sinfo->filled |= BIT_ULL(NL80211_STA_INFO_INACTIVE_TIME) | + BIT_ULL(NL80211_STA_INFO_STA_FLAGS) | + BIT_ULL(NL80211_STA_INFO_BSS_PARAM) | +@@ -2307,8 +2303,7 @@ void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo, + + if (!(sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES64) | + BIT_ULL(NL80211_STA_INFO_RX_BYTES)))) { +- if (!ieee80211_hw_check(&local->hw, USES_RSS)) +- sinfo->rx_bytes += sta_get_stats_bytes(&sta->rx_stats); ++ sinfo->rx_bytes += sta_get_stats_bytes(&sta->rx_stats); + + if (sta->pcpu_rx_stats) { + for_each_possible_cpu(cpu) { +diff --git a/net/sched/act_api.c b/net/sched/act_api.c +index f6d5755d669eb..d17a66aab8eea 100644 +--- a/net/sched/act_api.c ++++ b/net/sched/act_api.c +@@ -381,7 +381,8 @@ static int tcf_del_walker(struct tcf_idrinfo *idrinfo, struct sk_buff *skb, + } + mutex_unlock(&idrinfo->lock); + +- if (nla_put_u32(skb, TCA_FCNT, n_i)) ++ ret = nla_put_u32(skb, TCA_FCNT, n_i); ++ if (ret) + goto nla_put_failure; + nla_nest_end(skb, nest); + +diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c +index 94f6942d7ec11..2f82ac7c0f93c 100644 +--- a/net/sched/cls_api.c ++++ b/net/sched/cls_api.c +@@ -1531,7 +1531,7 @@ static inline int __tcf_classify(struct sk_buff *skb, + u32 *last_executed_chain) + { + #ifdef CONFIG_NET_CLS_ACT +- const int max_reclassify_loop = 4; ++ const int max_reclassify_loop = 16; + const struct tcf_proto *first_tp; + int limit = 0; + +diff --git a/net/sctp/bind_addr.c b/net/sctp/bind_addr.c +index 53e5ed79f63f3..59e653b528b1f 100644 +--- a/net/sctp/bind_addr.c ++++ b/net/sctp/bind_addr.c +@@ -270,22 +270,19 @@ int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list, + rawaddr = (union sctp_addr_param *)raw_addr_list; + + af = sctp_get_af_specific(param_type2af(param->type)); +- if (unlikely(!af)) { ++ if (unlikely(!af) || ++ !af->from_addr_param(&addr, rawaddr, htons(port), 0)) { + retval = -EINVAL; +- sctp_bind_addr_clean(bp); +- break; ++ goto out_err; + } + +- af->from_addr_param(&addr, rawaddr, htons(port), 0); + if (sctp_bind_addr_state(bp, &addr) != -1) + goto next; + retval = sctp_add_bind_addr(bp, &addr, sizeof(addr), + SCTP_ADDR_SRC, gfp); +- if (retval) { ++ if (retval) + /* Can't finish building the list, clean up. */ +- sctp_bind_addr_clean(bp); +- break; +- } ++ goto out_err; + + next: + len = ntohs(param->length); +@@ -294,6 +291,12 @@ next: + } + + return retval; ++ ++out_err: ++ if (retval) ++ sctp_bind_addr_clean(bp); ++ ++ return retval; + } + + /******************************************************************** +diff --git a/net/sctp/input.c b/net/sctp/input.c +index d508f6f3dd08a..f72bff93745c4 100644 +--- a/net/sctp/input.c ++++ b/net/sctp/input.c +@@ -1131,7 +1131,8 @@ static struct sctp_association *__sctp_rcv_init_lookup(struct net *net, + if (!af) + continue; + +- af->from_addr_param(paddr, params.addr, sh->source, 0); ++ if (!af->from_addr_param(paddr, params.addr, sh->source, 0)) ++ continue; + + asoc = __sctp_lookup_association(net, laddr, paddr, transportp); + if (asoc) +@@ -1174,7 +1175,8 @@ static struct sctp_association *__sctp_rcv_asconf_lookup( + if (unlikely(!af)) + return NULL; + +- af->from_addr_param(&paddr, param, peer_port, 0); ++ if (af->from_addr_param(&paddr, param, peer_port, 0)) ++ return NULL; + + return __sctp_lookup_association(net, laddr, &paddr, transportp); + } +@@ -1245,7 +1247,7 @@ static struct sctp_association *__sctp_rcv_walk_lookup(struct net *net, + + ch = (struct sctp_chunkhdr *)ch_end; + chunk_num++; +- } while (ch_end < skb_tail_pointer(skb)); ++ } while (ch_end + sizeof(*ch) < skb_tail_pointer(skb)); + + return asoc; + } +diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c +index bd08807c9e447..5c6f5ced9cfa6 100644 +--- a/net/sctp/ipv6.c ++++ b/net/sctp/ipv6.c +@@ -551,15 +551,20 @@ static void sctp_v6_to_sk_daddr(union sctp_addr *addr, struct sock *sk) + } + + /* Initialize a sctp_addr from an address parameter. */ +-static void sctp_v6_from_addr_param(union sctp_addr *addr, ++static bool sctp_v6_from_addr_param(union sctp_addr *addr, + union sctp_addr_param *param, + __be16 port, int iif) + { ++ if (ntohs(param->v6.param_hdr.length) < sizeof(struct sctp_ipv6addr_param)) ++ return false; ++ + addr->v6.sin6_family = AF_INET6; + addr->v6.sin6_port = port; + addr->v6.sin6_flowinfo = 0; /* BUG */ + addr->v6.sin6_addr = param->v6.addr; + addr->v6.sin6_scope_id = iif; ++ ++ return true; + } + + /* Initialize an address parameter from a sctp_addr and return the length +diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c +index 6f2bbfeec3a4c..25192b378e2ec 100644 +--- a/net/sctp/protocol.c ++++ b/net/sctp/protocol.c +@@ -254,14 +254,19 @@ static void sctp_v4_to_sk_daddr(union sctp_addr *addr, struct sock *sk) + } + + /* Initialize a sctp_addr from an address parameter. */ +-static void sctp_v4_from_addr_param(union sctp_addr *addr, ++static bool sctp_v4_from_addr_param(union sctp_addr *addr, + union sctp_addr_param *param, + __be16 port, int iif) + { ++ if (ntohs(param->v4.param_hdr.length) < sizeof(struct sctp_ipv4addr_param)) ++ return false; ++ + addr->v4.sin_family = AF_INET; + addr->v4.sin_port = port; + addr->v4.sin_addr.s_addr = param->v4.addr.s_addr; + memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero)); ++ ++ return true; + } + + /* Initialize an address parameter from a sctp_addr and return the length +diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c +index da4ce0947c3aa..1fdbde6f07b82 100644 +--- a/net/sctp/sm_make_chunk.c ++++ b/net/sctp/sm_make_chunk.c +@@ -2350,11 +2350,13 @@ int sctp_process_init(struct sctp_association *asoc, struct sctp_chunk *chunk, + + /* Process the initialization parameters. */ + sctp_walk_params(param, peer_init, init_hdr.params) { +- if (!src_match && (param.p->type == SCTP_PARAM_IPV4_ADDRESS || +- param.p->type == SCTP_PARAM_IPV6_ADDRESS)) { ++ if (!src_match && ++ (param.p->type == SCTP_PARAM_IPV4_ADDRESS || ++ param.p->type == SCTP_PARAM_IPV6_ADDRESS)) { + af = sctp_get_af_specific(param_type2af(param.p->type)); +- af->from_addr_param(&addr, param.addr, +- chunk->sctp_hdr->source, 0); ++ if (!af->from_addr_param(&addr, param.addr, ++ chunk->sctp_hdr->source, 0)) ++ continue; + if (sctp_cmp_addr_exact(sctp_source(chunk), &addr)) + src_match = 1; + } +@@ -2535,7 +2537,8 @@ static int sctp_process_param(struct sctp_association *asoc, + break; + do_addr_param: + af = sctp_get_af_specific(param_type2af(param.p->type)); +- af->from_addr_param(&addr, param.addr, htons(asoc->peer.port), 0); ++ if (!af->from_addr_param(&addr, param.addr, htons(asoc->peer.port), 0)) ++ break; + scope = sctp_scope(peer_addr); + if (sctp_in_scope(net, &addr, scope)) + if (!sctp_assoc_add_peer(asoc, &addr, gfp, SCTP_UNCONFIRMED)) +@@ -2636,15 +2639,13 @@ do_addr_param: + addr_param = param.v + sizeof(struct sctp_addip_param); + + af = sctp_get_af_specific(param_type2af(addr_param->p.type)); +- if (af == NULL) ++ if (!af) + break; + +- af->from_addr_param(&addr, addr_param, +- htons(asoc->peer.port), 0); ++ if (!af->from_addr_param(&addr, addr_param, ++ htons(asoc->peer.port), 0)) ++ break; + +- /* if the address is invalid, we can't process it. +- * XXX: see spec for what to do. +- */ + if (!af->addr_valid(&addr, NULL, NULL)) + break; + +@@ -3058,7 +3059,8 @@ static __be16 sctp_process_asconf_param(struct sctp_association *asoc, + if (unlikely(!af)) + return SCTP_ERROR_DNS_FAILED; + +- af->from_addr_param(&addr, addr_param, htons(asoc->peer.port), 0); ++ if (!af->from_addr_param(&addr, addr_param, htons(asoc->peer.port), 0)) ++ return SCTP_ERROR_DNS_FAILED; + + /* ADDIP 4.2.1 This parameter MUST NOT contain a broadcast + * or multicast address. +@@ -3335,7 +3337,8 @@ static void sctp_asconf_param_success(struct sctp_association *asoc, + + /* We have checked the packet before, so we do not check again. */ + af = sctp_get_af_specific(param_type2af(addr_param->p.type)); +- af->from_addr_param(&addr, addr_param, htons(bp->port), 0); ++ if (!af->from_addr_param(&addr, addr_param, htons(bp->port), 0)) ++ return; + + switch (asconf_param->param_hdr.type) { + case SCTP_PARAM_ADD_IP: +diff --git a/net/vmw_vsock/af_vsock.c b/net/vmw_vsock/af_vsock.c +index bc7fb9bf3351e..2a82fbf32ccc7 100644 +--- a/net/vmw_vsock/af_vsock.c ++++ b/net/vmw_vsock/af_vsock.c +@@ -1369,7 +1369,7 @@ static int vsock_stream_connect(struct socket *sock, struct sockaddr *addr, + + if (signal_pending(current)) { + err = sock_intr_errno(timeout); +- sk->sk_state = TCP_CLOSE; ++ sk->sk_state = sk->sk_state == TCP_ESTABLISHED ? TCP_CLOSING : TCP_CLOSE; + sock->state = SS_UNCONNECTED; + vsock_transport_cancel_pkt(vsk); + goto out_wait; +diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c +index a5224da638328..be0f616f85d34 100644 +--- a/net/wireless/nl80211.c ++++ b/net/wireless/nl80211.c +@@ -4779,11 +4779,10 @@ static int nl80211_parse_tx_bitrate_mask(struct genl_info *info, + sband->ht_cap.mcs.rx_mask, + sizeof(mask->control[i].ht_mcs)); + +- if (!sband->vht_cap.vht_supported) +- continue; +- +- vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); +- vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs); ++ if (sband->vht_cap.vht_supported) { ++ vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); ++ vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs); ++ } + + he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype); + if (!he_cap) +diff --git a/net/wireless/wext-spy.c b/net/wireless/wext-spy.c +index 33bef22e44e95..b379a03716539 100644 +--- a/net/wireless/wext-spy.c ++++ b/net/wireless/wext-spy.c +@@ -120,8 +120,8 @@ int iw_handler_set_thrspy(struct net_device * dev, + return -EOPNOTSUPP; + + /* Just do it */ +- memcpy(&(spydata->spy_thr_low), &(threshold->low), +- 2 * sizeof(struct iw_quality)); ++ spydata->spy_thr_low = threshold->low; ++ spydata->spy_thr_high = threshold->high; + + /* Clear flag */ + memset(spydata->spy_thr_under, '\0', sizeof(spydata->spy_thr_under)); +@@ -147,8 +147,8 @@ int iw_handler_get_thrspy(struct net_device * dev, + return -EOPNOTSUPP; + + /* Just do it */ +- memcpy(&(threshold->low), &(spydata->spy_thr_low), +- 2 * sizeof(struct iw_quality)); ++ threshold->low = spydata->spy_thr_low; ++ threshold->high = spydata->spy_thr_high; + + return 0; + } +@@ -173,10 +173,10 @@ static void iw_send_thrspy_event(struct net_device * dev, + memcpy(threshold.addr.sa_data, address, ETH_ALEN); + threshold.addr.sa_family = ARPHRD_ETHER; + /* Copy stats */ +- memcpy(&(threshold.qual), wstats, sizeof(struct iw_quality)); ++ threshold.qual = *wstats; + /* Copy also thresholds */ +- memcpy(&(threshold.low), &(spydata->spy_thr_low), +- 2 * sizeof(struct iw_quality)); ++ threshold.low = spydata->spy_thr_low; ++ threshold.high = spydata->spy_thr_high; + + /* Send event to user space */ + wireless_send_event(dev, SIOCGIWTHRSPY, &wrqu, (char *) &threshold); +diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c +index 5a0ef4361e436..817e714dedea0 100644 +--- a/net/xfrm/xfrm_user.c ++++ b/net/xfrm/xfrm_user.c +@@ -580,6 +580,20 @@ static struct xfrm_state *xfrm_state_construct(struct net *net, + + copy_from_user_state(x, p); + ++ if (attrs[XFRMA_ENCAP]) { ++ x->encap = kmemdup(nla_data(attrs[XFRMA_ENCAP]), ++ sizeof(*x->encap), GFP_KERNEL); ++ if (x->encap == NULL) ++ goto error; ++ } ++ ++ if (attrs[XFRMA_COADDR]) { ++ x->coaddr = kmemdup(nla_data(attrs[XFRMA_COADDR]), ++ sizeof(*x->coaddr), GFP_KERNEL); ++ if (x->coaddr == NULL) ++ goto error; ++ } ++ + if (attrs[XFRMA_SA_EXTRA_FLAGS]) + x->props.extra_flags = nla_get_u32(attrs[XFRMA_SA_EXTRA_FLAGS]); + +@@ -600,23 +614,9 @@ static struct xfrm_state *xfrm_state_construct(struct net *net, + attrs[XFRMA_ALG_COMP]))) + goto error; + +- if (attrs[XFRMA_ENCAP]) { +- x->encap = kmemdup(nla_data(attrs[XFRMA_ENCAP]), +- sizeof(*x->encap), GFP_KERNEL); +- if (x->encap == NULL) +- goto error; +- } +- + if (attrs[XFRMA_TFCPAD]) + x->tfcpad = nla_get_u32(attrs[XFRMA_TFCPAD]); + +- if (attrs[XFRMA_COADDR]) { +- x->coaddr = kmemdup(nla_data(attrs[XFRMA_COADDR]), +- sizeof(*x->coaddr), GFP_KERNEL); +- if (x->coaddr == NULL) +- goto error; +- } +- + xfrm_mark_get(attrs, &x->mark); + + xfrm_smark_init(attrs, &x->props.smark); +diff --git a/security/selinux/avc.c b/security/selinux/avc.c +index ad451cf9375e4..a2dc83228daf4 100644 +--- a/security/selinux/avc.c ++++ b/security/selinux/avc.c +@@ -297,26 +297,27 @@ static struct avc_xperms_decision_node + struct avc_xperms_decision_node *xpd_node; + struct extended_perms_decision *xpd; + +- xpd_node = kmem_cache_zalloc(avc_xperms_decision_cachep, GFP_NOWAIT); ++ xpd_node = kmem_cache_zalloc(avc_xperms_decision_cachep, ++ GFP_NOWAIT | __GFP_NOWARN); + if (!xpd_node) + return NULL; + + xpd = &xpd_node->xpd; + if (which & XPERMS_ALLOWED) { + xpd->allowed = kmem_cache_zalloc(avc_xperms_data_cachep, +- GFP_NOWAIT); ++ GFP_NOWAIT | __GFP_NOWARN); + if (!xpd->allowed) + goto error; + } + if (which & XPERMS_AUDITALLOW) { + xpd->auditallow = kmem_cache_zalloc(avc_xperms_data_cachep, +- GFP_NOWAIT); ++ GFP_NOWAIT | __GFP_NOWARN); + if (!xpd->auditallow) + goto error; + } + if (which & XPERMS_DONTAUDIT) { + xpd->dontaudit = kmem_cache_zalloc(avc_xperms_data_cachep, +- GFP_NOWAIT); ++ GFP_NOWAIT | __GFP_NOWARN); + if (!xpd->dontaudit) + goto error; + } +@@ -344,7 +345,7 @@ static struct avc_xperms_node *avc_xperms_alloc(void) + { + struct avc_xperms_node *xp_node; + +- xp_node = kmem_cache_zalloc(avc_xperms_cachep, GFP_NOWAIT); ++ xp_node = kmem_cache_zalloc(avc_xperms_cachep, GFP_NOWAIT | __GFP_NOWARN); + if (!xp_node) + return xp_node; + INIT_LIST_HEAD(&xp_node->xpd_head); +@@ -500,7 +501,7 @@ static struct avc_node *avc_alloc_node(struct selinux_avc *avc) + { + struct avc_node *node; + +- node = kmem_cache_zalloc(avc_node_cachep, GFP_NOWAIT); ++ node = kmem_cache_zalloc(avc_node_cachep, GFP_NOWAIT | __GFP_NOWARN); + if (!node) + goto out; + +diff --git a/security/smack/smackfs.c b/security/smack/smackfs.c +index 22ded2c26089c..1ad7d0d1ea62e 100644 +--- a/security/smack/smackfs.c ++++ b/security/smack/smackfs.c +@@ -855,6 +855,8 @@ static ssize_t smk_set_cipso(struct file *file, const char __user *buf, + if (format == SMK_FIXED24_FMT && + (count < SMK_CIPSOMIN || count > SMK_CIPSOMAX)) + return -EINVAL; ++ if (count > PAGE_SIZE) ++ return -EINVAL; + + data = memdup_user_nul(buf, count); + if (IS_ERR(data)) +diff --git a/sound/soc/tegra/tegra_alc5632.c b/sound/soc/tegra/tegra_alc5632.c +index 0a0efd24e4b0f..81ea6ceba689a 100644 +--- a/sound/soc/tegra/tegra_alc5632.c ++++ b/sound/soc/tegra/tegra_alc5632.c +@@ -139,6 +139,7 @@ static struct snd_soc_dai_link tegra_alc5632_dai = { + + static struct snd_soc_card snd_soc_tegra_alc5632 = { + .name = "tegra-alc5632", ++ .driver_name = "tegra", + .owner = THIS_MODULE, + .dai_link = &tegra_alc5632_dai, + .num_links = 1, +diff --git a/sound/soc/tegra/tegra_max98090.c b/sound/soc/tegra/tegra_max98090.c +index 00c19704057b6..5a649810c0c87 100644 +--- a/sound/soc/tegra/tegra_max98090.c ++++ b/sound/soc/tegra/tegra_max98090.c +@@ -182,6 +182,7 @@ static struct snd_soc_dai_link tegra_max98090_dai = { + + static struct snd_soc_card snd_soc_tegra_max98090 = { + .name = "tegra-max98090", ++ .driver_name = "tegra", + .owner = THIS_MODULE, + .dai_link = &tegra_max98090_dai, + .num_links = 1, +diff --git a/sound/soc/tegra/tegra_rt5640.c b/sound/soc/tegra/tegra_rt5640.c +index 9afba37a3b086..3344f16258bec 100644 +--- a/sound/soc/tegra/tegra_rt5640.c ++++ b/sound/soc/tegra/tegra_rt5640.c +@@ -132,6 +132,7 @@ static struct snd_soc_dai_link tegra_rt5640_dai = { + + static struct snd_soc_card snd_soc_tegra_rt5640 = { + .name = "tegra-rt5640", ++ .driver_name = "tegra", + .owner = THIS_MODULE, + .dai_link = &tegra_rt5640_dai, + .num_links = 1, +diff --git a/sound/soc/tegra/tegra_rt5677.c b/sound/soc/tegra/tegra_rt5677.c +index d30f8b6deda4b..0f03e97d93558 100644 +--- a/sound/soc/tegra/tegra_rt5677.c ++++ b/sound/soc/tegra/tegra_rt5677.c +@@ -175,6 +175,7 @@ static struct snd_soc_dai_link tegra_rt5677_dai = { + + static struct snd_soc_card snd_soc_tegra_rt5677 = { + .name = "tegra-rt5677", ++ .driver_name = "tegra", + .owner = THIS_MODULE, + .dai_link = &tegra_rt5677_dai, + .num_links = 1, +diff --git a/sound/soc/tegra/tegra_sgtl5000.c b/sound/soc/tegra/tegra_sgtl5000.c +index 885332170c77b..ef6a553e0b7da 100644 +--- a/sound/soc/tegra/tegra_sgtl5000.c ++++ b/sound/soc/tegra/tegra_sgtl5000.c +@@ -97,6 +97,7 @@ static struct snd_soc_dai_link tegra_sgtl5000_dai = { + + static struct snd_soc_card snd_soc_tegra_sgtl5000 = { + .name = "tegra-sgtl5000", ++ .driver_name = "tegra", + .owner = THIS_MODULE, + .dai_link = &tegra_sgtl5000_dai, + .num_links = 1, +diff --git a/sound/soc/tegra/tegra_wm8753.c b/sound/soc/tegra/tegra_wm8753.c +index efd7938866895..27089077f2ea4 100644 +--- a/sound/soc/tegra/tegra_wm8753.c ++++ b/sound/soc/tegra/tegra_wm8753.c +@@ -101,6 +101,7 @@ static struct snd_soc_dai_link tegra_wm8753_dai = { + + static struct snd_soc_card snd_soc_tegra_wm8753 = { + .name = "tegra-wm8753", ++ .driver_name = "tegra", + .owner = THIS_MODULE, + .dai_link = &tegra_wm8753_dai, + .num_links = 1, +diff --git a/sound/soc/tegra/tegra_wm8903.c b/sound/soc/tegra/tegra_wm8903.c +index e4863fa37b0c6..f219c26d66a31 100644 +--- a/sound/soc/tegra/tegra_wm8903.c ++++ b/sound/soc/tegra/tegra_wm8903.c +@@ -235,6 +235,7 @@ static struct snd_soc_dai_link tegra_wm8903_dai = { + + static struct snd_soc_card snd_soc_tegra_wm8903 = { + .name = "tegra-wm8903", ++ .driver_name = "tegra", + .owner = THIS_MODULE, + .dai_link = &tegra_wm8903_dai, + .num_links = 1, +diff --git a/sound/soc/tegra/tegra_wm9712.c b/sound/soc/tegra/tegra_wm9712.c +index 4f09a178049d3..c66da161c85aa 100644 +--- a/sound/soc/tegra/tegra_wm9712.c ++++ b/sound/soc/tegra/tegra_wm9712.c +@@ -54,6 +54,7 @@ static struct snd_soc_dai_link tegra_wm9712_dai = { + + static struct snd_soc_card snd_soc_tegra_wm9712 = { + .name = "tegra-wm9712", ++ .driver_name = "tegra", + .owner = THIS_MODULE, + .dai_link = &tegra_wm9712_dai, + .num_links = 1, +diff --git a/sound/soc/tegra/trimslice.c b/sound/soc/tegra/trimslice.c +index 6c1cc3d0ac336..cb4c8f72e4e67 100644 +--- a/sound/soc/tegra/trimslice.c ++++ b/sound/soc/tegra/trimslice.c +@@ -94,6 +94,7 @@ static struct snd_soc_dai_link trimslice_tlv320aic23_dai = { + + static struct snd_soc_card snd_soc_trimslice = { + .name = "tegra-trimslice", ++ .driver_name = "tegra", + .owner = THIS_MODULE, + .dai_link = &trimslice_tlv320aic23_dai, + .num_links = 1, +diff --git a/tools/testing/selftests/drivers/net/mlxsw/devlink_trap_l3_drops.sh b/tools/testing/selftests/drivers/net/mlxsw/devlink_trap_l3_drops.sh +index 4029833f7e271..160891dcb4bcb 100755 +--- a/tools/testing/selftests/drivers/net/mlxsw/devlink_trap_l3_drops.sh ++++ b/tools/testing/selftests/drivers/net/mlxsw/devlink_trap_l3_drops.sh +@@ -109,6 +109,9 @@ router_destroy() + __addr_add_del $rp1 del 192.0.2.2/24 2001:db8:1::2/64 + + tc qdisc del dev $rp2 clsact ++ ++ ip link set dev $rp2 down ++ ip link set dev $rp1 down + } + + setup_prepare() +diff --git a/tools/testing/selftests/drivers/net/mlxsw/devlink_trap_l3_exceptions.sh b/tools/testing/selftests/drivers/net/mlxsw/devlink_trap_l3_exceptions.sh +index 1fedfc9da434f..1d157b1bd838a 100755 +--- a/tools/testing/selftests/drivers/net/mlxsw/devlink_trap_l3_exceptions.sh ++++ b/tools/testing/selftests/drivers/net/mlxsw/devlink_trap_l3_exceptions.sh +@@ -111,6 +111,9 @@ router_destroy() + __addr_add_del $rp1 del 192.0.2.2/24 2001:db8:1::2/64 + + tc qdisc del dev $rp2 clsact ++ ++ ip link set dev $rp2 down ++ ip link set dev $rp1 down + } + + setup_prepare() +diff --git a/tools/testing/selftests/drivers/net/mlxsw/qos_dscp_bridge.sh b/tools/testing/selftests/drivers/net/mlxsw/qos_dscp_bridge.sh +index 5cbff8038f84c..28a570006d4d9 100755 +--- a/tools/testing/selftests/drivers/net/mlxsw/qos_dscp_bridge.sh ++++ b/tools/testing/selftests/drivers/net/mlxsw/qos_dscp_bridge.sh +@@ -93,7 +93,9 @@ switch_destroy() + lldptool -T -i $swp1 -V APP -d $(dscp_map 10) >/dev/null + lldpad_app_wait_del + ++ ip link set dev $swp2 down + ip link set dev $swp2 nomaster ++ ip link set dev $swp1 down + ip link set dev $swp1 nomaster + ip link del dev br1 + } +diff --git a/tools/testing/selftests/lkdtm/tests.txt b/tools/testing/selftests/lkdtm/tests.txt +index 11ef159be0fd4..a5fce7fd4520d 100644 +--- a/tools/testing/selftests/lkdtm/tests.txt ++++ b/tools/testing/selftests/lkdtm/tests.txt +@@ -11,7 +11,7 @@ CORRUPT_LIST_ADD list_add corruption + CORRUPT_LIST_DEL list_del corruption + STACK_GUARD_PAGE_LEADING + STACK_GUARD_PAGE_TRAILING +-UNSET_SMEP CR4 bits went missing ++UNSET_SMEP pinned CR4 bits changed: + DOUBLE_FAULT + CORRUPT_PAC + UNALIGNED_LOAD_STORE_WRITE +diff --git a/tools/testing/selftests/net/forwarding/pedit_dsfield.sh b/tools/testing/selftests/net/forwarding/pedit_dsfield.sh +index 55eeacf592411..64fbd211d907b 100755 +--- a/tools/testing/selftests/net/forwarding/pedit_dsfield.sh ++++ b/tools/testing/selftests/net/forwarding/pedit_dsfield.sh +@@ -75,7 +75,9 @@ switch_destroy() + tc qdisc del dev $swp2 clsact + tc qdisc del dev $swp1 clsact + ++ ip link set dev $swp2 down + ip link set dev $swp2 nomaster ++ ip link set dev $swp1 down + ip link set dev $swp1 nomaster + ip link del dev br1 + } +diff --git a/tools/testing/selftests/net/forwarding/pedit_l4port.sh b/tools/testing/selftests/net/forwarding/pedit_l4port.sh +index 5f20d289ee43c..10e594c551175 100755 +--- a/tools/testing/selftests/net/forwarding/pedit_l4port.sh ++++ b/tools/testing/selftests/net/forwarding/pedit_l4port.sh +@@ -71,7 +71,9 @@ switch_destroy() + tc qdisc del dev $swp2 clsact + tc qdisc del dev $swp1 clsact + ++ ip link set dev $swp2 down + ip link set dev $swp2 nomaster ++ ip link set dev $swp1 down + ip link set dev $swp1 nomaster + ip link del dev br1 + } +diff --git a/tools/testing/selftests/net/forwarding/skbedit_priority.sh b/tools/testing/selftests/net/forwarding/skbedit_priority.sh +index e3bd8a6bb8b40..bde11dc27873c 100755 +--- a/tools/testing/selftests/net/forwarding/skbedit_priority.sh ++++ b/tools/testing/selftests/net/forwarding/skbedit_priority.sh +@@ -72,7 +72,9 @@ switch_destroy() + tc qdisc del dev $swp2 clsact + tc qdisc del dev $swp1 clsact + ++ ip link set dev $swp2 down + ip link set dev $swp2 nomaster ++ ip link set dev $swp1 down + ip link set dev $swp1 nomaster + ip link del dev br1 + } +diff --git a/tools/testing/selftests/resctrl/README b/tools/testing/selftests/resctrl/README +index 6e5a0ffa18e8b..20502cb4791fc 100644 +--- a/tools/testing/selftests/resctrl/README ++++ b/tools/testing/selftests/resctrl/README +@@ -47,7 +47,7 @@ Parameter '-h' shows usage information. + + usage: resctrl_tests [-h] [-b "benchmark_cmd [options]"] [-t test list] [-n no_of_bits] + -b benchmark_cmd [options]: run specified benchmark for MBM, MBA and CQM default benchmark is builtin fill_buf +- -t test list: run tests specified in the test list, e.g. -t mbm, mba, cqm, cat ++ -t test list: run tests specified in the test list, e.g. -t mbm,mba,cqm,cat + -n no_of_bits: run cache tests using specified no of bits in cache bit mask + -p cpu_no: specify CPU number to run the test. 1 is default + -h: help +diff --git a/tools/testing/selftests/resctrl/resctrl_tests.c b/tools/testing/selftests/resctrl/resctrl_tests.c +index ac2269610aa9d..bd98746c6f858 100644 +--- a/tools/testing/selftests/resctrl/resctrl_tests.c ++++ b/tools/testing/selftests/resctrl/resctrl_tests.c +@@ -40,7 +40,7 @@ static void cmd_help(void) + printf("\t-b benchmark_cmd [options]: run specified benchmark for MBM, MBA and CQM"); + printf("\t default benchmark is builtin fill_buf\n"); + printf("\t-t test list: run tests specified in the test list, "); +- printf("e.g. -t mbm, mba, cqm, cat\n"); ++ printf("e.g. -t mbm,mba,cqm,cat\n"); + printf("\t-n no_of_bits: run cache tests using specified no of bits in cache bit mask\n"); + printf("\t-p cpu_no: specify CPU number to run the test. 1 is default\n"); + printf("\t-h: help\n"); +@@ -98,7 +98,7 @@ int main(int argc, char **argv) + + return -1; + } +- token = strtok(NULL, ":\t"); ++ token = strtok(NULL, ","); + } + break; + case 'p': +diff --git a/Documentation/devicetree/bindings/i2c/i2c-at91.txt b/Documentation/devicetree/bindings/i2c/i2c-at91.txt +index 96c914e048f59..2015f50aed0f9 100644 +--- a/Documentation/devicetree/bindings/i2c/i2c-at91.txt ++++ b/Documentation/devicetree/bindings/i2c/i2c-at91.txt +@@ -73,7 +73,7 @@ i2c0: i2c@f8034600 { + pinctrl-0 = <&pinctrl_i2c0>; + pinctrl-1 = <&pinctrl_i2c0_gpio>; + sda-gpios = <&pioA 30 GPIO_ACTIVE_HIGH>; +- scl-gpios = <&pioA 31 GPIO_ACTIVE_HIGH>; ++ scl-gpios = <&pioA 31 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; + + wm8731: wm8731@1a { + compatible = "wm8731"; +diff --git a/Documentation/filesystems/f2fs.rst b/Documentation/filesystems/f2fs.rst +index 35ed01a5fbc9d..bb2261431fbbf 100644 +--- a/Documentation/filesystems/f2fs.rst ++++ b/Documentation/filesystems/f2fs.rst +@@ -711,10 +711,10 @@ users. + ===================== ======================== =================== + User F2FS Block + ===================== ======================== =================== +- META WRITE_LIFE_NOT_SET +- HOT_NODE " +- WARM_NODE " +- COLD_NODE " ++N/A META WRITE_LIFE_NOT_SET ++N/A HOT_NODE " ++N/A WARM_NODE " ++N/A COLD_NODE " + ioctl(COLD) COLD_DATA WRITE_LIFE_EXTREME + extension list " " + +@@ -740,10 +740,10 @@ WRITE_LIFE_LONG " WRITE_LIFE_LONG + ===================== ======================== =================== + User F2FS Block + ===================== ======================== =================== +- META WRITE_LIFE_MEDIUM; +- HOT_NODE WRITE_LIFE_NOT_SET +- WARM_NODE " +- COLD_NODE WRITE_LIFE_NONE ++N/A META WRITE_LIFE_MEDIUM; ++N/A HOT_NODE WRITE_LIFE_NOT_SET ++N/A WARM_NODE " ++N/A COLD_NODE WRITE_LIFE_NONE + ioctl(COLD) COLD_DATA WRITE_LIFE_EXTREME + extension list " " + +diff --git a/Makefile b/Makefile +index b708d7c665e12..9658bc0ba389b 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 12 +-SUBLEVEL = 18 ++SUBLEVEL = 19 + EXTRAVERSION = + NAME = Frozen Wasteland + +diff --git a/arch/arm/boot/dts/am335x-cm-t335.dts b/arch/arm/boot/dts/am335x-cm-t335.dts +index 36d963db40266..ec4730c82d398 100644 +--- a/arch/arm/boot/dts/am335x-cm-t335.dts ++++ b/arch/arm/boot/dts/am335x-cm-t335.dts +@@ -496,7 +496,7 @@ status = "okay"; + status = "okay"; + pinctrl-names = "default"; + pinctrl-0 = <&spi0_pins>; +- ti,pindir-d0-out-d1-in = <1>; ++ ti,pindir-d0-out-d1-in; + /* WLS1271 WiFi */ + wlcore: wlcore@1 { + compatible = "ti,wl1271"; +diff --git a/arch/arm/boot/dts/am43x-epos-evm.dts b/arch/arm/boot/dts/am43x-epos-evm.dts +index f517d1e843cf4..8b696107eef8c 100644 +--- a/arch/arm/boot/dts/am43x-epos-evm.dts ++++ b/arch/arm/boot/dts/am43x-epos-evm.dts +@@ -860,7 +860,7 @@ + pinctrl-names = "default", "sleep"; + pinctrl-0 = <&spi0_pins_default>; + pinctrl-1 = <&spi0_pins_sleep>; +- ti,pindir-d0-out-d1-in = <1>; ++ ti,pindir-d0-out-d1-in; + }; + + &spi1 { +@@ -868,7 +868,7 @@ + pinctrl-names = "default", "sleep"; + pinctrl-0 = <&spi1_pins_default>; + pinctrl-1 = <&spi1_pins_sleep>; +- ti,pindir-d0-out-d1-in = <1>; ++ ti,pindir-d0-out-d1-in; + }; + + &usb2_phy1 { +diff --git a/arch/arm/boot/dts/am5718.dtsi b/arch/arm/boot/dts/am5718.dtsi +index ebf4d3cc1cfbe..6d7530a48c73f 100644 +--- a/arch/arm/boot/dts/am5718.dtsi ++++ b/arch/arm/boot/dts/am5718.dtsi +@@ -17,17 +17,13 @@ + * VCP1, VCP2 + * MLB + * ISS +- * USB3, USB4 ++ * USB3 + */ + + &usb3_tm { + status = "disabled"; + }; + +-&usb4_tm { +- status = "disabled"; +-}; +- + &atl_tm { + status = "disabled"; + }; +diff --git a/arch/arm/boot/dts/bcm283x-rpi-usb-otg.dtsi b/arch/arm/boot/dts/bcm283x-rpi-usb-otg.dtsi +index 20322de2f8bf1..e2fd9610e1252 100644 +--- a/arch/arm/boot/dts/bcm283x-rpi-usb-otg.dtsi ++++ b/arch/arm/boot/dts/bcm283x-rpi-usb-otg.dtsi +@@ -1,7 +1,7 @@ + // SPDX-License-Identifier: GPL-2.0 + &usb { + dr_mode = "otg"; +- g-rx-fifo-size = <558>; ++ g-rx-fifo-size = <256>; + g-np-tx-fifo-size = <32>; + /* + * According to dwc2 the sum of all device EP +diff --git a/arch/arm/boot/dts/bcm283x-rpi-usb-peripheral.dtsi b/arch/arm/boot/dts/bcm283x-rpi-usb-peripheral.dtsi +index 1409d1b559c18..0ff0e9e253272 100644 +--- a/arch/arm/boot/dts/bcm283x-rpi-usb-peripheral.dtsi ++++ b/arch/arm/boot/dts/bcm283x-rpi-usb-peripheral.dtsi +@@ -1,7 +1,7 @@ + // SPDX-License-Identifier: GPL-2.0 + &usb { + dr_mode = "peripheral"; +- g-rx-fifo-size = <558>; ++ g-rx-fifo-size = <256>; + g-np-tx-fifo-size = <32>; + g-tx-fifo-size = <256 256 512 512 512 768 768>; + }; +diff --git a/arch/arm/boot/dts/bcm5301x.dtsi b/arch/arm/boot/dts/bcm5301x.dtsi +index 7db72a2f1020d..86872e12c355e 100644 +--- a/arch/arm/boot/dts/bcm5301x.dtsi ++++ b/arch/arm/boot/dts/bcm5301x.dtsi +@@ -520,27 +520,27 @@ + <0x1811b408 0x004>, + <0x180293a0 0x01c>; + reg-names = "mspi", "bspi", "intr_regs", "intr_status_reg"; +- interrupts = , ++ interrupts = , ++ , ++ , + , + , + , +- , +- , +- ; +- interrupt-names = "spi_lr_fullness_reached", ++ ; ++ interrupt-names = "mspi_done", ++ "mspi_halted", ++ "spi_lr_fullness_reached", + "spi_lr_session_aborted", + "spi_lr_impatient", + "spi_lr_session_done", +- "spi_lr_overhead", +- "mspi_done", +- "mspi_halted"; ++ "spi_lr_overread"; + clocks = <&iprocmed>; + clock-names = "iprocmed"; + num-cs = <2>; + #address-cells = <1>; + #size-cells = <0>; + +- spi_nor: spi-nor@0 { ++ spi_nor: flash@0 { + compatible = "jedec,spi-nor"; + reg = <0>; + spi-max-frequency = <20000000>; +diff --git a/arch/arm/boot/dts/dra7-l4.dtsi b/arch/arm/boot/dts/dra7-l4.dtsi +index a294a02f2d232..1dafce92fc767 100644 +--- a/arch/arm/boot/dts/dra7-l4.dtsi ++++ b/arch/arm/boot/dts/dra7-l4.dtsi +@@ -4095,28 +4095,6 @@ + }; + }; + +- usb4_tm: target-module@140000 { /* 0x48940000, ap 75 3c.0 */ +- compatible = "ti,sysc-omap4", "ti,sysc"; +- reg = <0x140000 0x4>, +- <0x140010 0x4>; +- reg-names = "rev", "sysc"; +- ti,sysc-mask = ; +- ti,sysc-midle = , +- , +- , +- ; +- ti,sysc-sidle = , +- , +- , +- ; +- /* Domains (P, C): l3init_pwrdm, l3init_clkdm */ +- clocks = <&l3init_clkctrl DRA7_L3INIT_USB_OTG_SS4_CLKCTRL 0>; +- clock-names = "fck"; +- #address-cells = <1>; +- #size-cells = <1>; +- ranges = <0x0 0x140000 0x20000>; +- }; +- + target-module@170000 { /* 0x48970000, ap 21 0a.0 */ + compatible = "ti,sysc-omap4", "ti,sysc"; + reg = <0x170010 0x4>; +diff --git a/arch/arm/boot/dts/dra71x.dtsi b/arch/arm/boot/dts/dra71x.dtsi +index cad0e4a2bd8df..9c270d8f75d5b 100644 +--- a/arch/arm/boot/dts/dra71x.dtsi ++++ b/arch/arm/boot/dts/dra71x.dtsi +@@ -11,7 +11,3 @@ + &rtctarget { + status = "disabled"; + }; +- +-&usb4_tm { +- status = "disabled"; +-}; +diff --git a/arch/arm/boot/dts/dra72x.dtsi b/arch/arm/boot/dts/dra72x.dtsi +index d403acc754b68..f3e934ef7d3e2 100644 +--- a/arch/arm/boot/dts/dra72x.dtsi ++++ b/arch/arm/boot/dts/dra72x.dtsi +@@ -108,7 +108,3 @@ + &pcie2_rc { + compatible = "ti,dra726-pcie-rc", "ti,dra7-pcie"; + }; +- +-&usb4_tm { +- status = "disabled"; +-}; +diff --git a/arch/arm/boot/dts/dra74x.dtsi b/arch/arm/boot/dts/dra74x.dtsi +index e1850d6c841a7..b4e07d99ffde1 100644 +--- a/arch/arm/boot/dts/dra74x.dtsi ++++ b/arch/arm/boot/dts/dra74x.dtsi +@@ -49,49 +49,6 @@ + reg = <0x41500000 0x100>; + }; + +- target-module@48940000 { +- compatible = "ti,sysc-omap4", "ti,sysc"; +- reg = <0x48940000 0x4>, +- <0x48940010 0x4>; +- reg-names = "rev", "sysc"; +- ti,sysc-mask = ; +- ti,sysc-midle = , +- , +- , +- ; +- ti,sysc-sidle = , +- , +- , +- ; +- clocks = <&l3init_clkctrl DRA7_L3INIT_USB_OTG_SS4_CLKCTRL 0>; +- clock-names = "fck"; +- #address-cells = <1>; +- #size-cells = <1>; +- ranges = <0x0 0x48940000 0x20000>; +- +- omap_dwc3_4: omap_dwc3_4@0 { +- compatible = "ti,dwc3"; +- reg = <0 0x10000>; +- interrupts = ; +- #address-cells = <1>; +- #size-cells = <1>; +- utmi-mode = <2>; +- ranges; +- status = "disabled"; +- usb4: usb@10000 { +- compatible = "snps,dwc3"; +- reg = <0x10000 0x17000>; +- interrupts = , +- , +- ; +- interrupt-names = "peripheral", +- "host", +- "otg"; +- maximum-speed = "high-speed"; +- dr_mode = "otg"; +- }; +- }; +- }; + + target-module@41501000 { + compatible = "ti,sysc-omap2", "ti,sysc"; +@@ -224,3 +181,52 @@ + &pcie2_rc { + compatible = "ti,dra746-pcie-rc", "ti,dra7-pcie"; + }; ++ ++&l4_per3 { ++ segment@0 { ++ usb4_tm: target-module@140000 { /* 0x48940000, ap 75 3c.0 */ ++ compatible = "ti,sysc-omap4", "ti,sysc"; ++ reg = <0x140000 0x4>, ++ <0x140010 0x4>; ++ reg-names = "rev", "sysc"; ++ ti,sysc-mask = ; ++ ti,sysc-midle = , ++ , ++ , ++ ; ++ ti,sysc-sidle = , ++ , ++ , ++ ; ++ /* Domains (P, C): l3init_pwrdm, l3init_clkdm */ ++ clocks = <&l3init_clkctrl DRA7_L3INIT_USB_OTG_SS4_CLKCTRL 0>; ++ clock-names = "fck"; ++ #address-cells = <1>; ++ #size-cells = <1>; ++ ranges = <0x0 0x140000 0x20000>; ++ ++ omap_dwc3_4: omap_dwc3_4@0 { ++ compatible = "ti,dwc3"; ++ reg = <0 0x10000>; ++ interrupts = ; ++ #address-cells = <1>; ++ #size-cells = <1>; ++ utmi-mode = <2>; ++ ranges; ++ status = "disabled"; ++ usb4: usb@10000 { ++ compatible = "snps,dwc3"; ++ reg = <0x10000 0x17000>; ++ interrupts = , ++ , ++ ; ++ interrupt-names = "peripheral", ++ "host", ++ "otg"; ++ maximum-speed = "high-speed"; ++ dr_mode = "otg"; ++ }; ++ }; ++ }; ++ }; ++}; +diff --git a/arch/arm/boot/dts/exynos5422-odroidhc1.dts b/arch/arm/boot/dts/exynos5422-odroidhc1.dts +index 20c222b33f98e..d91f7fa2cf808 100644 +--- a/arch/arm/boot/dts/exynos5422-odroidhc1.dts ++++ b/arch/arm/boot/dts/exynos5422-odroidhc1.dts +@@ -22,7 +22,7 @@ + label = "blue:heartbeat"; + pwms = <&pwm 2 2000000 0>; + pwm-names = "pwm2"; +- max_brightness = <255>; ++ max-brightness = <255>; + linux,default-trigger = "heartbeat"; + }; + }; +diff --git a/arch/arm/boot/dts/exynos5422-odroidxu4.dts b/arch/arm/boot/dts/exynos5422-odroidxu4.dts +index ede7822576436..1c24f9b35973f 100644 +--- a/arch/arm/boot/dts/exynos5422-odroidxu4.dts ++++ b/arch/arm/boot/dts/exynos5422-odroidxu4.dts +@@ -24,7 +24,7 @@ + label = "blue:heartbeat"; + pwms = <&pwm 2 2000000 0>; + pwm-names = "pwm2"; +- max_brightness = <255>; ++ max-brightness = <255>; + linux,default-trigger = "heartbeat"; + }; + }; +diff --git a/arch/arm/boot/dts/exynos54xx-odroidxu-leds.dtsi b/arch/arm/boot/dts/exynos54xx-odroidxu-leds.dtsi +index 2fc3e86dc5f70..982752e1df24a 100644 +--- a/arch/arm/boot/dts/exynos54xx-odroidxu-leds.dtsi ++++ b/arch/arm/boot/dts/exynos54xx-odroidxu-leds.dtsi +@@ -22,7 +22,7 @@ + * Green LED is much brighter than the others + * so limit its max brightness + */ +- max_brightness = <127>; ++ max-brightness = <127>; + linux,default-trigger = "mmc0"; + }; + +@@ -30,7 +30,7 @@ + label = "blue:heartbeat"; + pwms = <&pwm 2 2000000 0>; + pwm-names = "pwm2"; +- max_brightness = <255>; ++ max-brightness = <255>; + linux,default-trigger = "heartbeat"; + }; + }; +diff --git a/arch/arm/boot/dts/gemini-rut1xx.dts b/arch/arm/boot/dts/gemini-rut1xx.dts +index 9611ddf067927..08091d2a64e15 100644 +--- a/arch/arm/boot/dts/gemini-rut1xx.dts ++++ b/arch/arm/boot/dts/gemini-rut1xx.dts +@@ -125,18 +125,6 @@ + }; + }; + +- ethernet@60000000 { +- status = "okay"; +- +- ethernet-port@0 { +- phy-mode = "rgmii"; +- phy-handle = <&phy0>; +- }; +- ethernet-port@1 { +- /* Not used in this platform */ +- }; +- }; +- + usb@68000000 { + status = "okay"; + }; +diff --git a/arch/arm/boot/dts/imx6q-dhcom-som.dtsi b/arch/arm/boot/dts/imx6q-dhcom-som.dtsi +index d0768ae429faa..e3de2b487cf49 100644 +--- a/arch/arm/boot/dts/imx6q-dhcom-som.dtsi ++++ b/arch/arm/boot/dts/imx6q-dhcom-som.dtsi +@@ -96,30 +96,40 @@ + reg = <0>; + max-speed = <100>; + reset-gpios = <&gpio5 0 GPIO_ACTIVE_LOW>; +- reset-delay-us = <1000>; +- reset-post-delay-us = <1000>; ++ reset-assert-us = <1000>; ++ reset-deassert-us = <1000>; ++ smsc,disable-energy-detect; /* Make plugin detection reliable */ + }; + }; + }; + + &i2c1 { + clock-frequency = <100000>; +- pinctrl-names = "default"; ++ pinctrl-names = "default", "gpio"; + pinctrl-0 = <&pinctrl_i2c1>; ++ pinctrl-1 = <&pinctrl_i2c1_gpio>; ++ scl-gpios = <&gpio3 21 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; ++ sda-gpios = <&gpio3 28 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; + status = "okay"; + }; + + &i2c2 { + clock-frequency = <100000>; +- pinctrl-names = "default"; ++ pinctrl-names = "default", "gpio"; + pinctrl-0 = <&pinctrl_i2c2>; ++ pinctrl-1 = <&pinctrl_i2c2_gpio>; ++ scl-gpios = <&gpio4 12 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; ++ sda-gpios = <&gpio4 13 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; + status = "okay"; + }; + + &i2c3 { + clock-frequency = <100000>; +- pinctrl-names = "default"; ++ pinctrl-names = "default", "gpio"; + pinctrl-0 = <&pinctrl_i2c3>; ++ pinctrl-1 = <&pinctrl_i2c3_gpio>; ++ scl-gpios = <&gpio1 3 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; ++ sda-gpios = <&gpio1 6 (GPIO_ACTIVE_HIGH | GPIO_OPEN_DRAIN)>; + status = "okay"; + + ltc3676: pmic@3c { +@@ -285,6 +295,13 @@ + >; + }; + ++ pinctrl_i2c1_gpio: i2c1-gpio-grp { ++ fsl,pins = < ++ MX6QDL_PAD_EIM_D21__GPIO3_IO21 0x4001b8b1 ++ MX6QDL_PAD_EIM_D28__GPIO3_IO28 0x4001b8b1 ++ >; ++ }; ++ + pinctrl_i2c2: i2c2-grp { + fsl,pins = < + MX6QDL_PAD_KEY_COL3__I2C2_SCL 0x4001b8b1 +@@ -292,6 +309,13 @@ + >; + }; + ++ pinctrl_i2c2_gpio: i2c2-gpio-grp { ++ fsl,pins = < ++ MX6QDL_PAD_KEY_COL3__GPIO4_IO12 0x4001b8b1 ++ MX6QDL_PAD_KEY_ROW3__GPIO4_IO13 0x4001b8b1 ++ >; ++ }; ++ + pinctrl_i2c3: i2c3-grp { + fsl,pins = < + MX6QDL_PAD_GPIO_3__I2C3_SCL 0x4001b8b1 +@@ -299,6 +323,13 @@ + >; + }; + ++ pinctrl_i2c3_gpio: i2c3-gpio-grp { ++ fsl,pins = < ++ MX6QDL_PAD_GPIO_3__GPIO1_IO03 0x4001b8b1 ++ MX6QDL_PAD_GPIO_6__GPIO1_IO06 0x4001b8b1 ++ >; ++ }; ++ + pinctrl_pmic_hw300: pmic-hw300-grp { + fsl,pins = < + MX6QDL_PAD_EIM_A25__GPIO5_IO02 0x1B0B0 +diff --git a/arch/arm/boot/dts/r8a7779-marzen.dts b/arch/arm/boot/dts/r8a7779-marzen.dts +index d2240b89ee529..4658453234959 100644 +--- a/arch/arm/boot/dts/r8a7779-marzen.dts ++++ b/arch/arm/boot/dts/r8a7779-marzen.dts +@@ -145,7 +145,7 @@ + status = "okay"; + + clocks = <&mstp1_clks R8A7779_CLK_DU>, <&x3_clk>; +- clock-names = "du", "dclkin.0"; ++ clock-names = "du.0", "dclkin.0"; + + ports { + port@0 { +diff --git a/arch/arm/boot/dts/r8a7779.dtsi b/arch/arm/boot/dts/r8a7779.dtsi +index 74d7e9084eabe..3c5fcdfe16b87 100644 +--- a/arch/arm/boot/dts/r8a7779.dtsi ++++ b/arch/arm/boot/dts/r8a7779.dtsi +@@ -463,6 +463,7 @@ + reg = <0xfff80000 0x40000>; + interrupts = ; + clocks = <&mstp1_clks R8A7779_CLK_DU>; ++ clock-names = "du.0"; + power-domains = <&sysc R8A7779_PD_ALWAYS_ON>; + status = "disabled"; + +diff --git a/arch/arm/boot/dts/stm32mp15xx-dhcom-som.dtsi b/arch/arm/boot/dts/stm32mp15xx-dhcom-som.dtsi +index 2617815e42a64..30e4d990c5a38 100644 +--- a/arch/arm/boot/dts/stm32mp15xx-dhcom-som.dtsi ++++ b/arch/arm/boot/dts/stm32mp15xx-dhcom-som.dtsi +@@ -119,7 +119,6 @@ + max-speed = <100>; + phy-handle = <&phy0>; + st,eth-ref-clk-sel; +- phy-reset-gpios = <&gpioh 3 GPIO_ACTIVE_LOW>; + + mdio0 { + #address-cells = <1>; +@@ -128,6 +127,13 @@ + + phy0: ethernet-phy@1 { + reg = <1>; ++ /* LAN8710Ai */ ++ compatible = "ethernet-phy-id0007.c0f0", ++ "ethernet-phy-ieee802.3-c22"; ++ clocks = <&rcc ETHCK_K>; ++ reset-gpios = <&gpioh 3 GPIO_ACTIVE_LOW>; ++ reset-assert-us = <500>; ++ reset-deassert-us = <500>; + interrupt-parent = <&gpioi>; + interrupts = <11 IRQ_TYPE_LEVEL_LOW>; + }; +diff --git a/arch/arm/boot/dts/sun8i-h3-orangepi-plus.dts b/arch/arm/boot/dts/sun8i-h3-orangepi-plus.dts +index 97f497854e05d..d05fa679dcd30 100644 +--- a/arch/arm/boot/dts/sun8i-h3-orangepi-plus.dts ++++ b/arch/arm/boot/dts/sun8i-h3-orangepi-plus.dts +@@ -85,7 +85,7 @@ + pinctrl-0 = <&emac_rgmii_pins>; + phy-supply = <®_gmac_3v3>; + phy-handle = <&ext_rgmii_phy>; +- phy-mode = "rgmii"; ++ phy-mode = "rgmii-id"; + + status = "okay"; + }; +diff --git a/arch/arm/mach-exynos/exynos.c b/arch/arm/mach-exynos/exynos.c +index 25b01da4771b3..8b48326be9fd5 100644 +--- a/arch/arm/mach-exynos/exynos.c ++++ b/arch/arm/mach-exynos/exynos.c +@@ -55,6 +55,7 @@ void __init exynos_sysram_init(void) + sysram_base_addr = of_iomap(node, 0); + sysram_base_phys = of_translate_address(node, + of_get_address(node, 0, NULL, NULL)); ++ of_node_put(node); + break; + } + +@@ -62,6 +63,7 @@ void __init exynos_sysram_init(void) + if (!of_device_is_available(node)) + continue; + sysram_ns_base_addr = of_iomap(node, 0); ++ of_node_put(node); + break; + } + } +diff --git a/arch/arm/probes/kprobes/test-thumb.c b/arch/arm/probes/kprobes/test-thumb.c +index 456c181a7bfe8..4e11f0b760f89 100644 +--- a/arch/arm/probes/kprobes/test-thumb.c ++++ b/arch/arm/probes/kprobes/test-thumb.c +@@ -441,21 +441,21 @@ void kprobe_thumb32_test_cases(void) + "3: mvn r0, r0 \n\t" + "2: nop \n\t") + +- TEST_RX("tbh [pc, r",7, (9f-(1f+4))>>1,"]", ++ TEST_RX("tbh [pc, r",7, (9f-(1f+4))>>1,", lsl #1]", + "9: \n\t" + ".short (2f-1b-4)>>1 \n\t" + ".short (3f-1b-4)>>1 \n\t" + "3: mvn r0, r0 \n\t" + "2: nop \n\t") + +- TEST_RX("tbh [pc, r",12, ((9f-(1f+4))>>1)+1,"]", ++ TEST_RX("tbh [pc, r",12, ((9f-(1f+4))>>1)+1,", lsl #1]", + "9: \n\t" + ".short (2f-1b-4)>>1 \n\t" + ".short (3f-1b-4)>>1 \n\t" + "3: mvn r0, r0 \n\t" + "2: nop \n\t") + +- TEST_RRX("tbh [r",1,9f, ", r",14,1,"]", ++ TEST_RRX("tbh [r",1,9f, ", r",14,1,", lsl #1]", + "9: \n\t" + ".short (2f-1b-4)>>1 \n\t" + ".short (3f-1b-4)>>1 \n\t" +@@ -468,10 +468,10 @@ void kprobe_thumb32_test_cases(void) + + TEST_UNSUPPORTED("strexb r0, r1, [r2]") + TEST_UNSUPPORTED("strexh r0, r1, [r2]") +- TEST_UNSUPPORTED("strexd r0, r1, [r2]") ++ TEST_UNSUPPORTED("strexd r0, r1, r2, [r2]") + TEST_UNSUPPORTED("ldrexb r0, [r1]") + TEST_UNSUPPORTED("ldrexh r0, [r1]") +- TEST_UNSUPPORTED("ldrexd r0, [r1]") ++ TEST_UNSUPPORTED("ldrexd r0, r1, [r1]") + + TEST_GROUP("Data-processing (shifted register) and (modified immediate)") + +diff --git a/arch/arm64/boot/dts/allwinner/sun50i-a64-sopine-baseboard.dts b/arch/arm64/boot/dts/allwinner/sun50i-a64-sopine-baseboard.dts +index e22b94c83647f..5e66ce1a334fb 100644 +--- a/arch/arm64/boot/dts/allwinner/sun50i-a64-sopine-baseboard.dts ++++ b/arch/arm64/boot/dts/allwinner/sun50i-a64-sopine-baseboard.dts +@@ -79,7 +79,7 @@ + &emac { + pinctrl-names = "default"; + pinctrl-0 = <&rgmii_pins>; +- phy-mode = "rgmii-id"; ++ phy-mode = "rgmii-txid"; + phy-handle = <&ext_rgmii_phy>; + phy-supply = <®_dc1sw>; + status = "okay"; +diff --git a/arch/arm64/boot/dts/qcom/sc7180-trogdor.dtsi b/arch/arm64/boot/dts/qcom/sc7180-trogdor.dtsi +index b8f7cf5cbdab1..96914a307ba1d 100644 +--- a/arch/arm64/boot/dts/qcom/sc7180-trogdor.dtsi ++++ b/arch/arm64/boot/dts/qcom/sc7180-trogdor.dtsi +@@ -597,6 +597,8 @@ edp_brij_i2c: &i2c2 { + clocks = <&rpmhcc RPMH_LN_BB_CLK3>; + clock-names = "refclk"; + ++ no-hpd; ++ + ports { + #address-cells = <1>; + #size-cells = <0>; +diff --git a/arch/arm64/boot/dts/qcom/sdm845-oneplus-common.dtsi b/arch/arm64/boot/dts/qcom/sdm845-oneplus-common.dtsi +index 8f617f7b6d34e..f712771df0c77 100644 +--- a/arch/arm64/boot/dts/qcom/sdm845-oneplus-common.dtsi ++++ b/arch/arm64/boot/dts/qcom/sdm845-oneplus-common.dtsi +@@ -46,6 +46,14 @@ + }; + + reserved-memory { ++ /* The rmtfs_mem needs to be guarded due to "XPU limitations" ++ * it is otherwise possible for an allocation adjacent to the ++ * rmtfs_mem region to trigger an XPU violation, causing a crash. ++ */ ++ rmtfs_lower_guard: memory@f5b00000 { ++ no-map; ++ reg = <0 0xf5b00000 0 0x1000>; ++ }; + /* + * The rmtfs memory region in downstream is 'dynamically allocated' + * but given the same address every time. Hard code it as this address is +@@ -59,6 +67,10 @@ + qcom,client-id = <1>; + qcom,vmid = <15>; + }; ++ rmtfs_upper_guard: memory@f5d01000 { ++ no-map; ++ reg = <0 0xf5d01000 0 0x2000>; ++ }; + + /* + * It seems like reserving the old rmtfs_mem region is also needed to prevent +diff --git a/arch/arm64/boot/dts/qcom/sdm850-lenovo-yoga-c630.dts b/arch/arm64/boot/dts/qcom/sdm850-lenovo-yoga-c630.dts +index 140db2d5ba317..c2a709a384e9e 100644 +--- a/arch/arm64/boot/dts/qcom/sdm850-lenovo-yoga-c630.dts ++++ b/arch/arm64/boot/dts/qcom/sdm850-lenovo-yoga-c630.dts +@@ -376,6 +376,8 @@ + clocks = <&sn65dsi86_refclk>; + clock-names = "refclk"; + ++ no-hpd; ++ + ports { + #address-cells = <1>; + #size-cells = <0>; +diff --git a/arch/arm64/boot/dts/renesas/r8a774a1.dtsi b/arch/arm64/boot/dts/renesas/r8a774a1.dtsi +index d64fb8b1b86c3..2e427f21130d2 100644 +--- a/arch/arm64/boot/dts/renesas/r8a774a1.dtsi ++++ b/arch/arm64/boot/dts/renesas/r8a774a1.dtsi +@@ -76,6 +76,7 @@ + opp-hz = /bits/ 64 <1500000000>; + opp-microvolt = <820000>; + clock-latency-ns = <300000>; ++ opp-suspend; + }; + }; + +diff --git a/arch/arm64/boot/dts/renesas/r8a77960.dtsi b/arch/arm64/boot/dts/renesas/r8a77960.dtsi +index 25d947a81b294..949a8b7873947 100644 +--- a/arch/arm64/boot/dts/renesas/r8a77960.dtsi ++++ b/arch/arm64/boot/dts/renesas/r8a77960.dtsi +@@ -63,18 +63,19 @@ + + opp-500000000 { + opp-hz = /bits/ 64 <500000000>; +- opp-microvolt = <820000>; ++ opp-microvolt = <830000>; + clock-latency-ns = <300000>; + }; + opp-1000000000 { + opp-hz = /bits/ 64 <1000000000>; +- opp-microvolt = <820000>; ++ opp-microvolt = <830000>; + clock-latency-ns = <300000>; + }; + opp-1500000000 { + opp-hz = /bits/ 64 <1500000000>; +- opp-microvolt = <820000>; ++ opp-microvolt = <830000>; + clock-latency-ns = <300000>; ++ opp-suspend; + }; + opp-1600000000 { + opp-hz = /bits/ 64 <1600000000>; +diff --git a/arch/arm64/boot/dts/renesas/r8a77961.dtsi b/arch/arm64/boot/dts/renesas/r8a77961.dtsi +index e8c31ebec0973..550b10a7e18bb 100644 +--- a/arch/arm64/boot/dts/renesas/r8a77961.dtsi ++++ b/arch/arm64/boot/dts/renesas/r8a77961.dtsi +@@ -52,18 +52,19 @@ + + opp-500000000 { + opp-hz = /bits/ 64 <500000000>; +- opp-microvolt = <820000>; ++ opp-microvolt = <830000>; + clock-latency-ns = <300000>; + }; + opp-1000000000 { + opp-hz = /bits/ 64 <1000000000>; +- opp-microvolt = <820000>; ++ opp-microvolt = <830000>; + clock-latency-ns = <300000>; + }; + opp-1500000000 { + opp-hz = /bits/ 64 <1500000000>; +- opp-microvolt = <820000>; ++ opp-microvolt = <830000>; + clock-latency-ns = <300000>; ++ opp-suspend; + }; + opp-1600000000 { + opp-hz = /bits/ 64 <1600000000>; +diff --git a/arch/arm64/boot/dts/renesas/r8a77970-v3msk.dts b/arch/arm64/boot/dts/renesas/r8a77970-v3msk.dts +index 7417cf5fea0f0..2426e533128ce 100644 +--- a/arch/arm64/boot/dts/renesas/r8a77970-v3msk.dts ++++ b/arch/arm64/boot/dts/renesas/r8a77970-v3msk.dts +@@ -59,7 +59,7 @@ + memory@48000000 { + device_type = "memory"; + /* first 128MB is reserved for secure area. */ +- reg = <0x0 0x48000000 0x0 0x38000000>; ++ reg = <0x0 0x48000000 0x0 0x78000000>; + }; + + osc5_clk: osc5-clock { +diff --git a/arch/arm64/boot/dts/renesas/r8a779a0.dtsi b/arch/arm64/boot/dts/renesas/r8a779a0.dtsi +index 86ac48e2c8491..2e17fc9fd7116 100644 +--- a/arch/arm64/boot/dts/renesas/r8a779a0.dtsi ++++ b/arch/arm64/boot/dts/renesas/r8a779a0.dtsi +@@ -948,7 +948,6 @@ + <0x0 0xf1060000 0 0x110000>; + interrupts = ; +- power-domains = <&sysc R8A779A0_PD_ALWAYS_ON>; + }; + + prr: chipid@fff00044 { +diff --git a/arch/arm64/boot/dts/rockchip/rk3328-rock-pi-e.dts b/arch/arm64/boot/dts/rockchip/rk3328-rock-pi-e.dts +index 2d71ca7e429c1..a53055bb7ca4d 100644 +--- a/arch/arm64/boot/dts/rockchip/rk3328-rock-pi-e.dts ++++ b/arch/arm64/boot/dts/rockchip/rk3328-rock-pi-e.dts +@@ -172,8 +172,6 @@ + }; + + &gmac2phy { +- pinctrl-names = "default"; +- pinctrl-0 = <&fephyled_linkm1>, <&fephyled_rxm1>; + status = "okay"; + }; + +diff --git a/arch/arm64/boot/dts/rockchip/rk3399-roc-pc.dtsi b/arch/arm64/boot/dts/rockchip/rk3399-roc-pc.dtsi +index 20309076dbac0..35b7ab3bf10c6 100644 +--- a/arch/arm64/boot/dts/rockchip/rk3399-roc-pc.dtsi ++++ b/arch/arm64/boot/dts/rockchip/rk3399-roc-pc.dtsi +@@ -384,6 +384,7 @@ + + vcc_sdio: LDO_REG4 { + regulator-name = "vcc_sdio"; ++ regulator-always-on; + regulator-boot-on; + regulator-min-microvolt = <1800000>; + regulator-max-microvolt = <3000000>; +@@ -488,6 +489,8 @@ + regulator-min-microvolt = <712500>; + regulator-max-microvolt = <1500000>; + regulator-ramp-delay = <1000>; ++ regulator-always-on; ++ regulator-boot-on; + vin-supply = <&vcc3v3_sys>; + + regulator-state-mem { +diff --git a/arch/arm64/boot/dts/ti/k3-j7200-main.dtsi b/arch/arm64/boot/dts/ti/k3-j7200-main.dtsi +index 3398f174f09b3..bfdf63d3947f6 100644 +--- a/arch/arm64/boot/dts/ti/k3-j7200-main.dtsi ++++ b/arch/arm64/boot/dts/ti/k3-j7200-main.dtsi +@@ -671,6 +671,7 @@ + "otg"; + maximum-speed = "super-speed"; + dr_mode = "otg"; ++ cdns,phyrst-a-enable; + }; + }; + +diff --git a/arch/arm64/boot/dts/ti/k3-j721e-common-proc-board.dts b/arch/arm64/boot/dts/ti/k3-j721e-common-proc-board.dts +index 60764366e22bd..86f7ab511ee86 100644 +--- a/arch/arm64/boot/dts/ti/k3-j721e-common-proc-board.dts ++++ b/arch/arm64/boot/dts/ti/k3-j721e-common-proc-board.dts +@@ -635,6 +635,10 @@ + status = "disabled"; + }; + ++&cmn_refclk1 { ++ clock-frequency = <100000000>; ++}; ++ + &serdes0 { + serdes0_pcie_link: link@0 { + reg = <0>; +diff --git a/arch/arm64/boot/dts/ti/k3-j721e-main.dtsi b/arch/arm64/boot/dts/ti/k3-j721e-main.dtsi +index f1e7da3dfa276..411d85562d518 100644 +--- a/arch/arm64/boot/dts/ti/k3-j721e-main.dtsi ++++ b/arch/arm64/boot/dts/ti/k3-j721e-main.dtsi +@@ -8,6 +8,20 @@ + #include + #include + ++/ { ++ cmn_refclk: clock-cmnrefclk { ++ #clock-cells = <0>; ++ compatible = "fixed-clock"; ++ clock-frequency = <0>; ++ }; ++ ++ cmn_refclk1: clock-cmnrefclk1 { ++ #clock-cells = <0>; ++ compatible = "fixed-clock"; ++ clock-frequency = <0>; ++ }; ++}; ++ + &cbass_main { + msmc_ram: sram@70000000 { + compatible = "mmio-sram"; +@@ -336,24 +350,12 @@ + pinctrl-single,function-mask = <0xffffffff>; + }; + +- dummy_cmn_refclk: dummy-cmn-refclk { +- #clock-cells = <0>; +- compatible = "fixed-clock"; +- clock-frequency = <100000000>; +- }; +- +- dummy_cmn_refclk1: dummy-cmn-refclk1 { +- #clock-cells = <0>; +- compatible = "fixed-clock"; +- clock-frequency = <100000000>; +- }; +- + serdes_wiz0: wiz@5000000 { + compatible = "ti,j721e-wiz-16g"; + #address-cells = <1>; + #size-cells = <1>; + power-domains = <&k3_pds 292 TI_SCI_PD_EXCLUSIVE>; +- clocks = <&k3_clks 292 5>, <&k3_clks 292 11>, <&dummy_cmn_refclk>; ++ clocks = <&k3_clks 292 5>, <&k3_clks 292 11>, <&cmn_refclk>; + clock-names = "fck", "core_ref_clk", "ext_ref_clk"; + assigned-clocks = <&k3_clks 292 11>, <&k3_clks 292 0>; + assigned-clock-parents = <&k3_clks 292 15>, <&k3_clks 292 4>; +@@ -362,21 +364,21 @@ + ranges = <0x5000000 0x0 0x5000000 0x10000>; + + wiz0_pll0_refclk: pll0-refclk { +- clocks = <&k3_clks 292 11>, <&dummy_cmn_refclk>; ++ clocks = <&k3_clks 292 11>, <&cmn_refclk>; + #clock-cells = <0>; + assigned-clocks = <&wiz0_pll0_refclk>; + assigned-clock-parents = <&k3_clks 292 11>; + }; + + wiz0_pll1_refclk: pll1-refclk { +- clocks = <&k3_clks 292 0>, <&dummy_cmn_refclk1>; ++ clocks = <&k3_clks 292 0>, <&cmn_refclk1>; + #clock-cells = <0>; + assigned-clocks = <&wiz0_pll1_refclk>; + assigned-clock-parents = <&k3_clks 292 0>; + }; + + wiz0_refclk_dig: refclk-dig { +- clocks = <&k3_clks 292 11>, <&k3_clks 292 0>, <&dummy_cmn_refclk>, <&dummy_cmn_refclk1>; ++ clocks = <&k3_clks 292 11>, <&k3_clks 292 0>, <&cmn_refclk>, <&cmn_refclk1>; + #clock-cells = <0>; + assigned-clocks = <&wiz0_refclk_dig>; + assigned-clock-parents = <&k3_clks 292 11>; +@@ -410,7 +412,7 @@ + #address-cells = <1>; + #size-cells = <1>; + power-domains = <&k3_pds 293 TI_SCI_PD_EXCLUSIVE>; +- clocks = <&k3_clks 293 5>, <&k3_clks 293 13>, <&dummy_cmn_refclk>; ++ clocks = <&k3_clks 293 5>, <&k3_clks 293 13>, <&cmn_refclk>; + clock-names = "fck", "core_ref_clk", "ext_ref_clk"; + assigned-clocks = <&k3_clks 293 13>, <&k3_clks 293 0>; + assigned-clock-parents = <&k3_clks 293 17>, <&k3_clks 293 4>; +@@ -419,21 +421,21 @@ + ranges = <0x5010000 0x0 0x5010000 0x10000>; + + wiz1_pll0_refclk: pll0-refclk { +- clocks = <&k3_clks 293 13>, <&dummy_cmn_refclk>; ++ clocks = <&k3_clks 293 13>, <&cmn_refclk>; + #clock-cells = <0>; + assigned-clocks = <&wiz1_pll0_refclk>; + assigned-clock-parents = <&k3_clks 293 13>; + }; + + wiz1_pll1_refclk: pll1-refclk { +- clocks = <&k3_clks 293 0>, <&dummy_cmn_refclk1>; ++ clocks = <&k3_clks 293 0>, <&cmn_refclk1>; + #clock-cells = <0>; + assigned-clocks = <&wiz1_pll1_refclk>; + assigned-clock-parents = <&k3_clks 293 0>; + }; + + wiz1_refclk_dig: refclk-dig { +- clocks = <&k3_clks 293 13>, <&k3_clks 293 0>, <&dummy_cmn_refclk>, <&dummy_cmn_refclk1>; ++ clocks = <&k3_clks 293 13>, <&k3_clks 293 0>, <&cmn_refclk>, <&cmn_refclk1>; + #clock-cells = <0>; + assigned-clocks = <&wiz1_refclk_dig>; + assigned-clock-parents = <&k3_clks 293 13>; +@@ -467,7 +469,7 @@ + #address-cells = <1>; + #size-cells = <1>; + power-domains = <&k3_pds 294 TI_SCI_PD_EXCLUSIVE>; +- clocks = <&k3_clks 294 5>, <&k3_clks 294 11>, <&dummy_cmn_refclk>; ++ clocks = <&k3_clks 294 5>, <&k3_clks 294 11>, <&cmn_refclk>; + clock-names = "fck", "core_ref_clk", "ext_ref_clk"; + assigned-clocks = <&k3_clks 294 11>, <&k3_clks 294 0>; + assigned-clock-parents = <&k3_clks 294 15>, <&k3_clks 294 4>; +@@ -476,21 +478,21 @@ + ranges = <0x5020000 0x0 0x5020000 0x10000>; + + wiz2_pll0_refclk: pll0-refclk { +- clocks = <&k3_clks 294 11>, <&dummy_cmn_refclk>; ++ clocks = <&k3_clks 294 11>, <&cmn_refclk>; + #clock-cells = <0>; + assigned-clocks = <&wiz2_pll0_refclk>; + assigned-clock-parents = <&k3_clks 294 11>; + }; + + wiz2_pll1_refclk: pll1-refclk { +- clocks = <&k3_clks 294 0>, <&dummy_cmn_refclk1>; ++ clocks = <&k3_clks 294 0>, <&cmn_refclk1>; + #clock-cells = <0>; + assigned-clocks = <&wiz2_pll1_refclk>; + assigned-clock-parents = <&k3_clks 294 0>; + }; + + wiz2_refclk_dig: refclk-dig { +- clocks = <&k3_clks 294 11>, <&k3_clks 294 0>, <&dummy_cmn_refclk>, <&dummy_cmn_refclk1>; ++ clocks = <&k3_clks 294 11>, <&k3_clks 294 0>, <&cmn_refclk>, <&cmn_refclk1>; + #clock-cells = <0>; + assigned-clocks = <&wiz2_refclk_dig>; + assigned-clock-parents = <&k3_clks 294 11>; +@@ -524,7 +526,7 @@ + #address-cells = <1>; + #size-cells = <1>; + power-domains = <&k3_pds 295 TI_SCI_PD_EXCLUSIVE>; +- clocks = <&k3_clks 295 5>, <&k3_clks 295 9>, <&dummy_cmn_refclk>; ++ clocks = <&k3_clks 295 5>, <&k3_clks 295 9>, <&cmn_refclk>; + clock-names = "fck", "core_ref_clk", "ext_ref_clk"; + assigned-clocks = <&k3_clks 295 9>, <&k3_clks 295 0>; + assigned-clock-parents = <&k3_clks 295 13>, <&k3_clks 295 4>; +@@ -533,21 +535,21 @@ + ranges = <0x5030000 0x0 0x5030000 0x10000>; + + wiz3_pll0_refclk: pll0-refclk { +- clocks = <&k3_clks 295 9>, <&dummy_cmn_refclk>; ++ clocks = <&k3_clks 295 9>, <&cmn_refclk>; + #clock-cells = <0>; + assigned-clocks = <&wiz3_pll0_refclk>; + assigned-clock-parents = <&k3_clks 295 9>; + }; + + wiz3_pll1_refclk: pll1-refclk { +- clocks = <&k3_clks 295 0>, <&dummy_cmn_refclk1>; ++ clocks = <&k3_clks 295 0>, <&cmn_refclk1>; + #clock-cells = <0>; + assigned-clocks = <&wiz3_pll1_refclk>; + assigned-clock-parents = <&k3_clks 295 0>; + }; + + wiz3_refclk_dig: refclk-dig { +- clocks = <&k3_clks 295 9>, <&k3_clks 295 0>, <&dummy_cmn_refclk>, <&dummy_cmn_refclk1>; ++ clocks = <&k3_clks 295 9>, <&k3_clks 295 0>, <&cmn_refclk>, <&cmn_refclk1>; + #clock-cells = <0>; + assigned-clocks = <&wiz3_refclk_dig>; + assigned-clock-parents = <&k3_clks 295 9>; +diff --git a/arch/arm64/lib/copy_from_user.S b/arch/arm64/lib/copy_from_user.S +index 95cd62d673711..2cf999e41d30e 100644 +--- a/arch/arm64/lib/copy_from_user.S ++++ b/arch/arm64/lib/copy_from_user.S +@@ -29,7 +29,7 @@ + .endm + + .macro ldrh1 reg, ptr, val +- user_ldst 9998f, ldtrh, \reg, \ptr, \val ++ user_ldst 9997f, ldtrh, \reg, \ptr, \val + .endm + + .macro strh1 reg, ptr, val +@@ -37,7 +37,7 @@ + .endm + + .macro ldr1 reg, ptr, val +- user_ldst 9998f, ldtr, \reg, \ptr, \val ++ user_ldst 9997f, ldtr, \reg, \ptr, \val + .endm + + .macro str1 reg, ptr, val +@@ -45,7 +45,7 @@ + .endm + + .macro ldp1 reg1, reg2, ptr, val +- user_ldp 9998f, \reg1, \reg2, \ptr, \val ++ user_ldp 9997f, \reg1, \reg2, \ptr, \val + .endm + + .macro stp1 reg1, reg2, ptr, val +@@ -53,8 +53,10 @@ + .endm + + end .req x5 ++srcin .req x15 + SYM_FUNC_START(__arch_copy_from_user) + add end, x0, x2 ++ mov srcin, x1 + #include "copy_template.S" + mov x0, #0 // Nothing to copy + ret +@@ -63,6 +65,11 @@ EXPORT_SYMBOL(__arch_copy_from_user) + + .section .fixup,"ax" + .align 2 ++9997: cmp dst, dstin ++ b.ne 9998f ++ // Before being absolutely sure we couldn't copy anything, try harder ++USER(9998f, ldtrb tmp1w, [srcin]) ++ strb tmp1w, [dst], #1 + 9998: sub x0, end, dst // bytes not copied + ret + .previous +diff --git a/arch/arm64/lib/copy_in_user.S b/arch/arm64/lib/copy_in_user.S +index 1f61cd0df0627..dbea3799c3efb 100644 +--- a/arch/arm64/lib/copy_in_user.S ++++ b/arch/arm64/lib/copy_in_user.S +@@ -30,33 +30,34 @@ + .endm + + .macro ldrh1 reg, ptr, val +- user_ldst 9998f, ldtrh, \reg, \ptr, \val ++ user_ldst 9997f, ldtrh, \reg, \ptr, \val + .endm + + .macro strh1 reg, ptr, val +- user_ldst 9998f, sttrh, \reg, \ptr, \val ++ user_ldst 9997f, sttrh, \reg, \ptr, \val + .endm + + .macro ldr1 reg, ptr, val +- user_ldst 9998f, ldtr, \reg, \ptr, \val ++ user_ldst 9997f, ldtr, \reg, \ptr, \val + .endm + + .macro str1 reg, ptr, val +- user_ldst 9998f, sttr, \reg, \ptr, \val ++ user_ldst 9997f, sttr, \reg, \ptr, \val + .endm + + .macro ldp1 reg1, reg2, ptr, val +- user_ldp 9998f, \reg1, \reg2, \ptr, \val ++ user_ldp 9997f, \reg1, \reg2, \ptr, \val + .endm + + .macro stp1 reg1, reg2, ptr, val +- user_stp 9998f, \reg1, \reg2, \ptr, \val ++ user_stp 9997f, \reg1, \reg2, \ptr, \val + .endm + + end .req x5 +- ++srcin .req x15 + SYM_FUNC_START(__arch_copy_in_user) + add end, x0, x2 ++ mov srcin, x1 + #include "copy_template.S" + mov x0, #0 + ret +@@ -65,6 +66,12 @@ EXPORT_SYMBOL(__arch_copy_in_user) + + .section .fixup,"ax" + .align 2 ++9997: cmp dst, dstin ++ b.ne 9998f ++ // Before being absolutely sure we couldn't copy anything, try harder ++USER(9998f, ldtrb tmp1w, [srcin]) ++USER(9998f, sttrb tmp1w, [dst]) ++ add dst, dst, #1 + 9998: sub x0, end, dst // bytes not copied + ret + .previous +diff --git a/arch/arm64/lib/copy_to_user.S b/arch/arm64/lib/copy_to_user.S +index 043da90f5dd7d..9f380eecf6531 100644 +--- a/arch/arm64/lib/copy_to_user.S ++++ b/arch/arm64/lib/copy_to_user.S +@@ -32,7 +32,7 @@ + .endm + + .macro strh1 reg, ptr, val +- user_ldst 9998f, sttrh, \reg, \ptr, \val ++ user_ldst 9997f, sttrh, \reg, \ptr, \val + .endm + + .macro ldr1 reg, ptr, val +@@ -40,7 +40,7 @@ + .endm + + .macro str1 reg, ptr, val +- user_ldst 9998f, sttr, \reg, \ptr, \val ++ user_ldst 9997f, sttr, \reg, \ptr, \val + .endm + + .macro ldp1 reg1, reg2, ptr, val +@@ -48,12 +48,14 @@ + .endm + + .macro stp1 reg1, reg2, ptr, val +- user_stp 9998f, \reg1, \reg2, \ptr, \val ++ user_stp 9997f, \reg1, \reg2, \ptr, \val + .endm + + end .req x5 ++srcin .req x15 + SYM_FUNC_START(__arch_copy_to_user) + add end, x0, x2 ++ mov srcin, x1 + #include "copy_template.S" + mov x0, #0 + ret +@@ -62,6 +64,12 @@ EXPORT_SYMBOL(__arch_copy_to_user) + + .section .fixup,"ax" + .align 2 ++9997: cmp dst, dstin ++ b.ne 9998f ++ // Before being absolutely sure we couldn't copy anything, try harder ++ ldrb tmp1w, [srcin] ++USER(9998f, sttrb tmp1w, [dst]) ++ add dst, dst, #1 + 9998: sub x0, end, dst // bytes not copied + ret + .previous +diff --git a/arch/hexagon/kernel/vmlinux.lds.S b/arch/hexagon/kernel/vmlinux.lds.S +index 35b18e55eae80..57465bff1fe49 100644 +--- a/arch/hexagon/kernel/vmlinux.lds.S ++++ b/arch/hexagon/kernel/vmlinux.lds.S +@@ -38,6 +38,8 @@ SECTIONS + .text : AT(ADDR(.text)) { + _text = .; + TEXT_TEXT ++ IRQENTRY_TEXT ++ SOFTIRQENTRY_TEXT + SCHED_TEXT + CPUIDLE_TEXT + LOCK_TEXT +@@ -59,14 +61,9 @@ SECTIONS + + _end = .; + +- /DISCARD/ : { +- EXIT_TEXT +- EXIT_DATA +- EXIT_CALL +- } +- + STABS_DEBUG + DWARF_DEBUG + ELF_DETAILS + ++ DISCARDS + } +diff --git a/arch/m68k/68000/dragen2.c b/arch/m68k/68000/dragen2.c +index 584893c57c373..62f10a9e1ab7f 100644 +--- a/arch/m68k/68000/dragen2.c ++++ b/arch/m68k/68000/dragen2.c +@@ -11,6 +11,7 @@ + #include + #include + #include ++#include "screen.h" + + /***************************************************************************/ + /* Init Drangon Engine hardware */ +diff --git a/arch/m68k/68000/screen.h b/arch/m68k/68000/screen.h +new file mode 100644 +index 0000000000000..2089bdf02688f +--- /dev/null ++++ b/arch/m68k/68000/screen.h +@@ -0,0 +1,804 @@ ++/* Created with The GIMP */ ++#define screen_width 320 ++#define screen_height 240 ++static unsigned char screen_bits[] = { ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x56, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x0d, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x5a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6b, 0x55, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x03, 0x95, 0x6a, 0x00, 0x00, 0x00, 0x03, 0xf8, 0x70, 0xe0, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, ++ 0x01, 0xf8, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x5b, 0x55, 0x00, 0x00, 0x00, 0x0f, ++ 0xfc, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x38, 0x03, 0xfc, 0x00, 0x7f, 0x80, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0xb5, 0x56, ++ 0x00, 0x00, 0x00, 0x1e, 0x0c, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x03, 0x0e, 0x00, 0x61, ++ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0xd7, 0x55, 0x55, 0x00, 0x03, 0x8e, 0x1c, 0x00, 0x70, 0xe1, 0x9e, ++ 0x0e, 0x38, 0xe1, 0x80, 0x70, 0xc0, 0xf0, 0x73, 0x33, 0xc0, 0x78, 0x38, ++ 0x00, 0x0e, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x02, 0xa9, 0xaa, 0xad, 0x00, 0x03, 0x8e, 0x38, ++ 0x00, 0x70, 0xe1, 0xff, 0x0e, 0x38, 0xe3, 0x80, 0x71, 0xc3, 0xf8, 0x77, ++ 0x3f, 0xe1, 0xfc, 0x38, 0x00, 0x0e, 0x00, 0xef, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x2b, 0x55, 0x6a, ++ 0x00, 0x03, 0x8e, 0x38, 0x00, 0x70, 0xe1, 0xe7, 0x0e, 0x38, 0x73, 0x00, ++ 0x73, 0x83, 0x9c, 0x7f, 0x3c, 0xe1, 0xce, 0x38, 0x00, 0x1c, 0x00, 0xff, ++ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x15, 0x56, 0xab, 0x55, 0x00, 0x03, 0x8e, 0x38, 0x00, 0x70, 0xe1, 0xc7, ++ 0x0e, 0x38, 0x76, 0x00, 0x77, 0x07, 0x1c, 0x78, 0x38, 0xe3, 0x8e, 0x38, ++ 0x00, 0x78, 0x00, 0xf3, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x69, 0x55, 0x5a, 0xb7, 0x00, 0x03, 0x8e, 0x38, ++ 0x00, 0x70, 0xe1, 0xc7, 0x0e, 0x38, 0x3c, 0x00, 0x7e, 0x07, 0xfc, 0x70, ++ 0x38, 0xe3, 0xfe, 0x38, 0x00, 0xf0, 0x00, 0xe1, 0xc0, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xa5, 0x9a, 0xab, 0x6d, ++ 0x00, 0x03, 0x8e, 0x3c, 0x00, 0x70, 0xe1, 0xc7, 0x0e, 0x38, 0x3e, 0x00, ++ 0x7f, 0x07, 0xfc, 0x70, 0x38, 0xe3, 0xfe, 0x38, 0x01, 0xc0, 0x00, 0xe1, ++ 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, ++ 0x4d, 0x75, 0xb6, 0xd5, 0x00, 0x03, 0x8e, 0x1c, 0x00, 0x70, 0xe1, 0xc7, ++ 0x0e, 0x38, 0x77, 0x00, 0x77, 0x87, 0x00, 0x70, 0x38, 0xe3, 0x80, 0x38, ++ 0x03, 0x80, 0x00, 0xe1, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x14, 0xaa, 0xca, 0xd5, 0x5b, 0x00, 0x03, 0x9e, 0x1f, ++ 0x0c, 0x70, 0xe1, 0xc7, 0x0e, 0x78, 0x67, 0x00, 0x73, 0xc7, 0x8c, 0x70, ++ 0x38, 0xe3, 0xc6, 0x38, 0x03, 0xfe, 0x38, 0x71, 0xc0, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0xb5, 0xbb, 0x5b, 0x6a, ++ 0x00, 0x03, 0xfe, 0x0f, 0xfc, 0x70, 0xe1, 0xc7, 0x0f, 0xf8, 0xe3, 0x80, ++ 0x71, 0xe3, 0xfc, 0x70, 0x38, 0xe1, 0xfe, 0x38, 0x03, 0xfe, 0x38, 0x7f, ++ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa9, ++ 0x6b, 0x56, 0xd6, 0xad, 0x00, 0x01, 0xe6, 0x03, 0xf0, 0x70, 0xe1, 0xc7, ++ 0x07, 0x98, 0xc3, 0x80, 0x70, 0xe0, 0xf8, 0x70, 0x38, 0xe0, 0x7c, 0x38, ++ 0x03, 0xfe, 0x38, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x03, 0x55, 0x55, 0x6a, 0xba, 0xeb, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x56, 0xd5, 0xd5, 0xd5, 0xac, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x5a, ++ 0xb7, 0x3d, 0x57, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x75, 0x6d, 0xaa, 0xd3, 0xac, 0xaa, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x8b, 0x6a, 0xb6, 0xde, 0x6b, 0xb6, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xba, 0xad, ++ 0xeb, 0x32, 0xda, 0xad, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x1e, 0xaa, 0xb5, 0xad, 0x6e, 0x96, 0xaa, 0x00, 0x00, 0x00, 0x00, ++ 0x01, 0x86, 0x00, 0x00, 0x07, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0xfc, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0xc3, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x6b, 0x6f, 0x5a, 0xb5, 0x75, 0x69, ++ 0x00, 0x00, 0x00, 0x00, 0x01, 0x86, 0x00, 0x00, 0x06, 0x18, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf5, 0xda, 0xd9, ++ 0x53, 0xeb, 0x6b, 0x4b, 0x00, 0x00, 0xf0, 0xde, 0x03, 0xe6, 0xf0, 0x78, ++ 0x06, 0x0c, 0x6c, 0x7c, 0x1f, 0x87, 0x86, 0xf0, 0xc0, 0xde, 0x0f, 0xcc, ++ 0xde, 0x0f, 0x00, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x03, 0xd6, 0xab, 0x57, 0x6e, 0x8a, 0xd6, 0xba, 0x00, 0x01, 0x98, 0xe7, ++ 0x01, 0x87, 0x38, 0xcc, 0x06, 0x0c, 0x6c, 0x06, 0x31, 0x8c, 0xc7, 0x38, ++ 0xc0, 0xe7, 0x18, 0xcc, 0xe7, 0x19, 0x80, 0xc3, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x0e, 0x2d, 0x5e, 0xda, 0x55, 0xbb, 0x59, 0x42, ++ 0x00, 0x03, 0x0c, 0xc3, 0x01, 0x86, 0x19, 0x8c, 0x06, 0x0c, 0x70, 0x06, ++ 0x61, 0x98, 0x66, 0x18, 0xf8, 0xc3, 0x30, 0xcc, 0xc3, 0x31, 0x80, 0xc3, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xf7, 0x6b, 0x6a, ++ 0xab, 0x56, 0xd6, 0xbf, 0x00, 0x03, 0x0c, 0xc3, 0x01, 0x86, 0x19, 0xfc, ++ 0x06, 0x0c, 0x60, 0x7e, 0x61, 0x98, 0x66, 0x18, 0xc0, 0xc3, 0x30, 0xcc, ++ 0xc3, 0x3f, 0x80, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x75, 0x94, 0xdb, 0x75, 0x6e, 0xda, 0xaa, 0xa2, 0x00, 0x03, 0x0c, 0xc3, ++ 0x01, 0x86, 0x19, 0x80, 0x06, 0x0c, 0x60, 0xc6, 0x61, 0x98, 0x66, 0x18, ++ 0xc0, 0xc3, 0x30, 0xcc, 0xc3, 0x30, 0x00, 0xc3, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x01, 0xdb, 0x6b, 0xad, 0x9b, 0x27, 0x55, 0x55, 0x55, ++ 0x00, 0x03, 0x0c, 0xc3, 0x01, 0x86, 0x19, 0x80, 0x06, 0x0c, 0x60, 0xc6, ++ 0x33, 0x98, 0x66, 0x18, 0xc0, 0xc3, 0x19, 0xcc, 0xc3, 0x30, 0x00, 0xc3, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x36, 0xde, 0xb5, 0x65, ++ 0x75, 0x5a, 0xd5, 0x56, 0x00, 0x01, 0x98, 0xc3, 0x01, 0x86, 0x18, 0xc4, ++ 0x06, 0x18, 0x60, 0xce, 0x1d, 0x8c, 0xc6, 0x18, 0xc0, 0xc3, 0x0e, 0xcc, ++ 0xc3, 0x18, 0x80, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, ++ 0xed, 0xb5, 0x6d, 0x56, 0x55, 0x55, 0x55, 0xae, 0x00, 0x00, 0xf0, 0xc3, ++ 0x00, 0xe6, 0x18, 0x78, 0x07, 0xf0, 0x60, 0x77, 0x01, 0x87, 0x86, 0x18, ++ 0xfc, 0xc3, 0x00, 0xcc, 0xc3, 0x0f, 0x00, 0xc3, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x7a, 0xab, 0x6d, 0xda, 0xaa, 0xca, 0xd5, 0x6d, 0x58, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x80, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x56, 0xda, 0xaa, 0xea, 0xae, ++ 0x9b, 0x5a, 0xa9, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xd5, ++ 0xbb, 0xfd, 0xad, 0xad, 0x69, 0xea, 0xcb, 0x55, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x05, 0xaf, 0xb6, 0x8a, 0x6a, 0xb9, 0x5a, 0x2d, 0xba, 0xb6, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x7a, 0x75, 0x6e, 0xcd, 0x52, ++ 0x9b, 0xdb, 0x55, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0xad, ++ 0xaf, 0x95, 0x55, 0xed, 0x55, 0x55, 0x6b, 0x55, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0xea, 0xb5, 0xec, 0xfd, 0x59, 0x5a, 0xb5, 0x56, 0xaa, 0xb6, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xb7, 0x6b, 0x36, 0x4a, 0xeb, 0xab, ++ 0x2d, 0x6a, 0x9b, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xad, 0x6f, ++ 0x6b, 0xeb, 0xdd, 0x7b, 0x6a, 0x55, 0xb5, 0x56, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x17, 0x76, 0xda, 0xd6, 0x5d, 0x62, 0xc6, 0xd5, 0x36, 0xaa, 0xb5, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xdb, 0x56, 0xbc, 0xf2, 0xa5, 0x5d, ++ 0x96, 0xaa, 0xb6, 0xd6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xab, 0xee, 0xfd, ++ 0xd5, 0x2c, 0x6d, 0x9a, 0x75, 0x5b, 0x6a, 0xb5, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x03, 0xee, 0xad, 0x55, 0x15, 0xef, 0x54, 0xf6, 0xc5, 0x6a, 0xa9, 0xa6, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x05, 0x5b, 0xd6, 0xad, 0xbe, 0xb0, 0xa6, 0x35, ++ 0x5b, 0xd5, 0x4a, 0x9b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b, 0xeb, 0x5d, 0xf5, ++ 0xaa, 0xd7, 0xf4, 0x75, 0xba, 0x55, 0xaf, 0x6e, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x37, 0x5e, 0xf7, 0x55, 0x61, 0xbc, 0x08, 0x5b, 0x55, 0x5a, 0xa9, 0xb5, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x01, 0xf6, 0xba, 0xaa, 0xaa, 0x9f, 0x69, 0xec, 0xd5, ++ 0x4b, 0xa9, 0xaa, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x2d, 0xd5, 0xed, 0x5a, ++ 0xf2, 0xd6, 0xae, 0xdb, 0x9e, 0x27, 0x5f, 0xb5, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, ++ 0x6d, 0x5b, 0xaa, 0xda, 0xae, 0x95, 0x58, 0xd5, 0x34, 0x6d, 0x68, 0xad, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x15, 0xdb, 0xd7, 0x56, 0xb5, 0xd5, 0x6d, 0x29, 0x5b, ++ 0x4b, 0xdb, 0x57, 0xb6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0xda, 0xac, 0xd5, 0x4b, ++ 0x57, 0x6a, 0x9b, 0x76, 0x5c, 0x95, 0x54, 0x2a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfa, ++ 0xb7, 0xfb, 0xab, 0xb6, 0xea, 0xad, 0x62, 0x95, 0xa1, 0xf5, 0xa9, 0xad, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x03, 0x57, 0xaf, 0x6b, 0x72, 0x54, 0x99, 0xd5, 0x0e, 0xf3, ++ 0x5f, 0x15, 0x2a, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xea, 0xd4, 0xad, 0x5d, 0x35, ++ 0xb5, 0x34, 0xb2, 0xaa, 0x54, 0xba, 0xad, 0x55, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x5e, ++ 0xaf, 0xed, 0xab, 0xea, 0xb3, 0xaa, 0x6a, 0xad, 0xd5, 0xd5, 0xaa, 0xab, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x2a, 0xb9, 0xf5, 0xbb, 0xb5, 0x55, 0x64, 0x57, 0x55, 0x6b, ++ 0x5d, 0xd0, 0x52, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xab, 0x5b, 0xb6, 0x6d, 0x37, ++ 0x6f, 0xaa, 0x5b, 0xa2, 0xb5, 0x1f, 0xed, 0x73, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x65, 0xaa, ++ 0x6e, 0xfb, 0xd3, 0x5a, 0xd4, 0x54, 0xaa, 0x5e, 0xc3, 0xb5, 0x15, 0x56, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x07, 0xaf, 0x7f, 0xea, 0xb6, 0xaa, 0xd6, 0xad, 0xf1, 0xd2, 0xd5, ++ 0x56, 0x55, 0x6a, 0xd5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xbd, 0xda, 0xaf, 0x75, 0x6f, 0x5a, ++ 0x45, 0x26, 0xb7, 0x5b, 0x20, 0xdd, 0x55, 0x2a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xeb, 0x7f, ++ 0xf5, 0x4d, 0x95, 0x76, 0xd9, 0x56, 0xb5, 0x52, 0x6d, 0x12, 0xad, 0xaa, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x57, 0x3f, 0xa4, 0x8f, 0xb9, 0x6e, 0xa2, 0x6f, 0x1d, 0x6a, 0xef, ++ 0xb5, 0x6d, 0xaa, 0xb5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x03, 0xfd, 0x75, 0x2f, 0x7c, 0x57, 0x88, 0xf6, ++ 0x80, 0xb5, 0x57, 0x5c, 0xd7, 0x55, 0x54, 0xae, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x39, 0xff, 0xf6, ++ 0xab, 0x7a, 0x57, 0x94, 0xef, 0x0d, 0xe4, 0xea, 0xa8, 0xaa, 0xab, 0xff, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x0c, 0xf7, 0xff, 0x6d, 0xb7, 0x4b, 0x39, 0x17, 0x2a, 0xfa, 0xb7, 0x56, ++ 0xb7, 0xaa, 0xed, 0xd9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x18, 0xbe, 0xfd, 0xda, 0x9e, 0xec, 0xe6, 0xd5, ++ 0x52, 0x2a, 0x58, 0xa9, 0x54, 0x5a, 0x97, 0xe7, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0xe9, 0xf6, 0xbe, ++ 0xd4, 0x5b, 0xad, 0x63, 0x61, 0xf7, 0xb7, 0xaf, 0x55, 0x52, 0x9f, 0xee, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, ++ 0xc9, 0xbd, 0xfb, 0x6b, 0xeb, 0xf5, 0x6b, 0x2d, 0x57, 0x52, 0x94, 0xaa, ++ 0xb1, 0xab, 0x4a, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x02, 0xdb, 0xcb, 0xff, 0xf5, 0x3b, 0x55, 0xa0, 0x00, ++ 0x45, 0x6e, 0xb5, 0xb5, 0x65, 0x52, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x2e, 0x7d, 0xdb, 0xa5, ++ 0xca, 0xbe, 0x80, 0x00, 0x0a, 0x54, 0xaa, 0xa5, 0x45, 0x08, 0x09, 0x15, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, ++ 0xd8, 0xd3, 0x1b, 0xae, 0xb7, 0xea, 0x00, 0x00, 0x00, 0x95, 0xaa, 0x56, ++ 0xdc, 0xe1, 0x21, 0x35, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x53, 0x41, 0xff, 0x77, 0xbd, 0xaa, 0x58, 0x00, 0x00, ++ 0x00, 0xdb, 0x75, 0xd4, 0xb2, 0xa4, 0x07, 0xea, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xef, 0x07, 0xbd, 0x65, 0xeb, ++ 0xa2, 0xd0, 0x00, 0x00, 0x00, 0x25, 0x4b, 0x35, 0x56, 0x80, 0x77, 0x6a, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x28, ++ 0x01, 0x28, 0x9a, 0xb6, 0xd7, 0x60, 0x00, 0x00, 0x00, 0x0c, 0xaa, 0xaa, ++ 0xaa, 0x02, 0x07, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x17, 0xe0, 0x17, 0xb1, 0xbf, 0xee, 0xb4, 0xc0, 0x00, 0x00, ++ 0x00, 0x08, 0xaa, 0xad, 0x68, 0x54, 0x04, 0x5a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x74, 0x87, 0x77, 0x72, 0x5a, ++ 0xab, 0x80, 0x00, 0x00, 0x00, 0x02, 0xd4, 0xb5, 0x52, 0x08, 0x5b, 0xd4, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x00, ++ 0x1f, 0xd6, 0xef, 0xda, 0xd5, 0x00, 0x00, 0x00, 0x0c, 0x01, 0x52, 0xd5, ++ 0x40, 0xf1, 0x55, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x9b, 0x00, 0x17, 0x4b, 0x92, 0xb7, 0xaf, 0x00, 0x00, 0x00, ++ 0x0e, 0x01, 0x4e, 0xaa, 0xae, 0x95, 0x55, 0x6d, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xb8, 0x11, 0x2b, 0x13, 0x76, 0xef, ++ 0x54, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x54, 0xaa, 0xaa, 0xb5, 0xad, 0x55, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x40, 0x00, ++ 0x7e, 0x7c, 0x65, 0xf4, 0x78, 0x00, 0x00, 0x00, 0x1f, 0x00, 0xab, 0x56, ++ 0xd5, 0x55, 0x59, 0x5a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x0a, 0x40, 0x42, 0x6d, 0xce, 0xe5, 0xae, 0x54, 0x00, 0x00, 0x00, ++ 0x18, 0x00, 0x6d, 0x75, 0x5d, 0x55, 0x4d, 0x52, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x82, 0x03, 0xdc, 0x54, 0xbf, 0x61, ++ 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0xad, 0xa2, 0xb5, 0x60, 0xad, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x16, ++ 0xd9, 0xb5, 0xa4, 0xc7, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0xea, ++ 0xae, 0xd5, 0x57, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x54, 0x04, 0x0d, 0x76, 0xbb, 0x4b, 0xbc, 0x58, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x36, 0x95, 0xa9, 0x55, 0x54, 0xaa, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x01, 0x50, 0x08, 0x5b, 0xc5, 0x3d, 0x97, 0x0a, ++ 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xb6, 0xab, 0x2b, 0x55, 0xab, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x24, 0x20, 0x3d, ++ 0x59, 0x7b, 0x76, 0x37, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x6d, ++ 0x75, 0xb5, 0x55, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x12, 0xf0, 0x01, 0xff, 0x21, 0xa8, 0xc3, 0x74, 0xa8, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x1b, 0xa9, 0x4b, 0x55, 0x55, 0x2a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x25, 0xc0, 0x41, 0xca, 0x9c, 0x77, 0x58, 0x9d, ++ 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x56, 0xb4, 0xad, 0xb2, 0x55, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4b, 0x80, 0x0f, 0xbe, ++ 0xc0, 0xf6, 0xd5, 0xb3, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x54, ++ 0xa5, 0xaa, 0x55, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x17, 0x04, 0x87, 0xbc, 0x6a, 0x3b, 0xac, 0x9d, 0x58, 0x00, 0x00, 0x03, ++ 0xe0, 0x00, 0x16, 0xab, 0x55, 0x4a, 0xd6, 0xa5, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x01, 0x5c, 0x00, 0x1f, 0x54, 0xc9, 0x2a, 0xb7, 0xa6, ++ 0xd8, 0x0f, 0x00, 0x07, 0xf8, 0x00, 0x15, 0x6a, 0x55, 0x5a, 0xa4, 0xaa, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0x08, 0x74, 0xca, ++ 0x9c, 0x5a, 0xa8, 0xc5, 0x30, 0x1f, 0x80, 0x0f, 0xfc, 0x00, 0x0d, 0x55, ++ 0xaa, 0xa5, 0x55, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, ++ 0xf0, 0x20, 0xea, 0x5a, 0xb0, 0xe7, 0x95, 0x7d, 0x10, 0x3f, 0xc0, 0x1f, ++ 0xfe, 0x00, 0x0a, 0xaa, 0xaa, 0xad, 0x4a, 0x95, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x03, 0xf4, 0x02, 0x7d, 0xb5, 0x8f, 0x9c, 0xaa, 0xe9, ++ 0xa0, 0x3f, 0xc0, 0x1f, 0xfe, 0x00, 0x06, 0xb5, 0x54, 0xa9, 0x2a, 0x54, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x40, 0x47, 0xeb, 0xab, ++ 0x75, 0x51, 0x55, 0x4d, 0xd8, 0x3f, 0xe0, 0x3f, 0x3f, 0x00, 0x0a, 0xaa, ++ 0xa9, 0x4a, 0xaa, 0xad, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, ++ 0xc0, 0x06, 0xff, 0xe5, 0xb6, 0xbb, 0xa9, 0x34, 0x48, 0x30, 0xe0, 0x3c, ++ 0x0f, 0x00, 0x0a, 0xaa, 0x8a, 0xaa, 0xaa, 0xa4, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0xaf, 0x80, 0x9f, 0xa1, 0x8d, 0xb5, 0xd6, 0x93, 0xcd, ++ 0x90, 0x62, 0x60, 0x3c, 0x27, 0x00, 0x06, 0xaa, 0xb5, 0xaa, 0xaa, 0xa9, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9f, 0x92, 0x3f, 0xb5, 0x36, ++ 0x56, 0xb5, 0x9d, 0x55, 0x90, 0x62, 0x60, 0x38, 0x17, 0x80, 0x0d, 0x54, ++ 0xaa, 0x54, 0xaa, 0x9a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x7a, ++ 0x00, 0xba, 0xab, 0x73, 0xe7, 0xa2, 0xb6, 0x55, 0x2c, 0x61, 0x60, 0x38, ++ 0x17, 0x80, 0x09, 0x6b, 0x4a, 0xd5, 0x4a, 0x92, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x0d, 0xfe, 0x03, 0x6d, 0xea, 0x08, 0x51, 0x1d, 0x2b, 0x35, ++ 0x08, 0x61, 0x60, 0x38, 0x07, 0x80, 0x06, 0xda, 0xaa, 0xa9, 0x55, 0x55, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0xf8, 0x4e, 0xfb, 0x89, 0xde, ++ 0x35, 0xea, 0x6b, 0x72, 0x28, 0x60, 0x70, 0x38, 0x07, 0x80, 0x05, 0x52, ++ 0xaa, 0xaa, 0x95, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf8, ++ 0x0d, 0x63, 0xbd, 0xe3, 0x57, 0x55, 0xb6, 0x49, 0xcc, 0x20, 0x7f, 0xf8, ++ 0x07, 0x80, 0x0a, 0xaa, 0xaa, 0xaa, 0xaa, 0xad, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x5d, 0xe1, 0x34, 0xc6, 0xab, 0xa7, 0x91, 0x77, 0x37, 0xcc, ++ 0x48, 0x30, 0x9f, 0x3c, 0x07, 0x80, 0x0a, 0xaa, 0xaa, 0xaa, 0xaa, 0x69, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x3b, 0xc0, 0x34, 0xdb, 0x4e, 0xf9, ++ 0xae, 0xd5, 0x54, 0xe1, 0xb4, 0x19, 0x3f, 0xfe, 0x0f, 0x00, 0x05, 0x55, ++ 0x55, 0x55, 0x52, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x7f, 0x89, ++ 0xf1, 0xf7, 0xe5, 0x57, 0xea, 0x8d, 0x4c, 0xda, 0xac, 0x13, 0xff, 0xff, ++ 0x80, 0x00, 0x0a, 0xd5, 0xaa, 0xa4, 0x95, 0x54, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0xf7, 0x02, 0x53, 0x6c, 0x72, 0x10, 0xa3, 0x6a, 0x74, 0xea, ++ 0x34, 0x07, 0xff, 0xff, 0xe0, 0x00, 0x05, 0x4e, 0x54, 0x95, 0x55, 0x55, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xfc, 0x97, 0xd6, 0x55, 0xb6, 0xab, ++ 0xb7, 0x45, 0x46, 0xad, 0xf4, 0x1f, 0xff, 0xff, 0xfe, 0x00, 0x05, 0x2a, ++ 0xd5, 0x54, 0x95, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xcf, 0x0e, ++ 0xfb, 0x2d, 0x12, 0xd4, 0xb8, 0xb6, 0xeb, 0x6a, 0x10, 0x3f, 0xff, 0xff, ++ 0xff, 0x00, 0x02, 0xda, 0x8a, 0xab, 0x6a, 0xaa, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x57, 0xbc, 0x3a, 0xc6, 0x0d, 0x76, 0xb1, 0x77, 0x15, 0x2a, 0x56, ++ 0x34, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x02, 0xa5, 0x75, 0x2a, 0x52, 0xaa, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x02, 0x0f, 0xfc, 0xdf, 0x75, 0x9d, 0x5a, 0x67, ++ 0x15, 0x59, 0xb3, 0x6c, 0x4c, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x05, 0x55, ++ 0x8a, 0xaa, 0xaa, 0xa4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf9, 0xdb, ++ 0xed, 0x36, 0x5a, 0xeb, 0xad, 0x6b, 0x57, 0x5d, 0xa4, 0x7f, 0xff, 0xff, ++ 0xf3, 0x80, 0x05, 0x54, 0xb2, 0xaa, 0xaa, 0xa9, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x7f, 0xf4, 0x5a, 0xaa, 0xdb, 0x40, 0x20, 0xea, 0xaa, 0xa8, 0x19, ++ 0xe8, 0x1f, 0xff, 0xff, 0xe7, 0x00, 0x02, 0x55, 0x4b, 0xd5, 0x55, 0x4a, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x05, 0xff, 0xf2, 0xb5, 0x7d, 0x56, 0xaa, 0x76, ++ 0xa5, 0xce, 0xb4, 0xd1, 0x2c, 0x0f, 0xff, 0xff, 0x0f, 0x00, 0x02, 0xa5, ++ 0x5a, 0x2a, 0x55, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xc1, 0x31, ++ 0x9a, 0x8d, 0x61, 0x2e, 0xb2, 0xb5, 0x57, 0x59, 0x88, 0x07, 0xff, 0xf8, ++ 0x7e, 0x06, 0x00, 0xaa, 0x65, 0xd2, 0xaa, 0xaa, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x1f, 0x7e, 0x02, 0x55, 0x67, 0xb5, 0x5b, 0x05, 0xfa, 0xab, 0x0a, 0x8d, ++ 0xe4, 0x03, 0xff, 0xc3, 0xfe, 0x07, 0x01, 0xaa, 0xaa, 0x26, 0xaa, 0xa9, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x16, 0x7d, 0x10, 0x57, 0x9d, 0x4a, 0x8a, 0xd7, ++ 0x95, 0x5a, 0xd5, 0x4d, 0x58, 0x00, 0xfc, 0x1f, 0xe6, 0x03, 0xc1, 0x55, ++ 0x52, 0xd5, 0x55, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0xe1, 0x42, 0xa4, ++ 0x7d, 0xd7, 0xba, 0xb0, 0x24, 0xd5, 0x97, 0xc5, 0xd2, 0x00, 0x00, 0x7f, ++ 0x87, 0x03, 0xe0, 0x42, 0xaa, 0x95, 0x55, 0x4b, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x0d, 0x42, 0x17, 0xfb, 0x8c, 0xac, 0x46, 0xae, 0xdd, 0xb3, 0x68, 0x92, ++ 0x6c, 0x03, 0x03, 0xfe, 0x0f, 0x01, 0xe0, 0x5a, 0x55, 0x62, 0xaa, 0x54, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x01, 0x3d, 0x0a, 0x32, 0xd5, 0x7b, 0xc9, 0xde, 0xad, ++ 0x91, 0x4a, 0xaa, 0xc6, 0x68, 0x21, 0xff, 0xf8, 0x7f, 0x00, 0x60, 0x2a, ++ 0xa9, 0x2e, 0xa9, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x64, 0xb3, 0x18, ++ 0x8e, 0xae, 0xb4, 0x46, 0x9a, 0xbb, 0x54, 0xd5, 0xb4, 0x30, 0xff, 0xe0, ++ 0xff, 0x80, 0x00, 0x52, 0xa5, 0x51, 0x55, 0x4a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, ++ 0x82, 0xc1, 0x52, 0xb3, 0xcb, 0xc5, 0xd4, 0xda, 0xd3, 0x4a, 0x68, 0x87, ++ 0x68, 0x30, 0x3f, 0x03, 0xff, 0x80, 0x00, 0x2a, 0xaa, 0x55, 0x45, 0x55, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x01, 0x5b, 0xc6, 0xa9, 0x19, 0x74, 0x3d, 0xa9, 0x92, ++ 0xab, 0x5b, 0x95, 0xb0, 0x28, 0x78, 0x00, 0x07, 0xff, 0xc0, 0x00, 0x15, ++ 0x2a, 0x95, 0x2a, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x10, 0x0f, 0x6b, 0xa2, ++ 0xb7, 0x22, 0x61, 0x2b, 0x52, 0xaa, 0x33, 0x1d, 0xa0, 0x7c, 0x00, 0x0f, ++ 0xff, 0xe0, 0x00, 0x14, 0xa4, 0xaa, 0xa9, 0x52, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, ++ 0x00, 0x23, 0x27, 0x64, 0x8d, 0xfb, 0x64, 0xa7, 0x5a, 0xaa, 0xd3, 0x5a, ++ 0xa0, 0x7c, 0x00, 0x3f, 0xff, 0xe0, 0x00, 0x05, 0x29, 0x52, 0x45, 0x55, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x02, 0x4a, 0x5f, 0x66, 0x6a, 0xab, 0x22, 0xaf, 0xec, ++ 0xa9, 0x55, 0x17, 0x17, 0xa0, 0xfe, 0x00, 0x7f, 0xff, 0xf0, 0x00, 0x02, ++ 0xaa, 0x4a, 0xaa, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x8d, 0x83, 0x49, 0xad, ++ 0x9a, 0x57, 0x50, 0x6b, 0x6b, 0x5a, 0xd1, 0x1a, 0x80, 0xff, 0x00, 0xff, ++ 0xff, 0xf0, 0x00, 0x05, 0x52, 0x95, 0x29, 0x55, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, ++ 0x1b, 0x4b, 0xcb, 0x45, 0x7b, 0x4e, 0x4b, 0x5d, 0x2a, 0xd5, 0x16, 0x29, ++ 0x41, 0xff, 0x87, 0xff, 0xff, 0xf8, 0x00, 0x01, 0x2a, 0xa5, 0x4a, 0x52, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x20, 0x52, 0x98, 0x9d, 0x0e, 0x95, 0x65, 0x38, 0x95, ++ 0x55, 0x6a, 0xab, 0x35, 0x81, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x01, ++ 0xa9, 0x14, 0xa9, 0x4a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x80, 0xe3, 0x2b, 0x74, 0x4d, ++ 0xb5, 0x55, 0xd5, 0x95, 0x69, 0x4a, 0xac, 0x6e, 0x03, 0xff, 0xff, 0xff, ++ 0xff, 0xfc, 0x00, 0x01, 0x25, 0x65, 0x2a, 0x95, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, ++ 0x9a, 0xb7, 0x0b, 0xb0, 0x6f, 0xfc, 0xfd, 0x6a, 0x8b, 0xd5, 0x4e, 0xa8, ++ 0x03, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x01, 0x49, 0x14, 0xa5, 0x6a, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x08, 0x02, 0x94, 0xab, 0x3d, 0xc9, 0x6b, 0xb5, 0x43, 0xee, ++ 0xb6, 0x95, 0x54, 0x9a, 0x07, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, ++ 0xaa, 0x54, 0xaa, 0x4a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x13, 0x9f, 0x68, 0x5b, ++ 0xff, 0xfa, 0xd7, 0xfa, 0xa5, 0x6a, 0xac, 0xd4, 0x07, 0xff, 0xff, 0xff, ++ 0xff, 0xfe, 0x00, 0x00, 0x55, 0x53, 0x2a, 0xaa, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x04, ++ 0x65, 0x3c, 0x8b, 0x93, 0x87, 0x76, 0x75, 0xf5, 0x57, 0x55, 0x5c, 0xa8, ++ 0x0f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x0b, 0x54, 0x95, 0x54, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x2a, 0x7b, 0xfd, 0x75, 0xba, 0xae, 0xfe, 0x44, 0x5a, ++ 0x8a, 0xca, 0x9c, 0xf0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, ++ 0x14, 0x4a, 0xaa, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xd8, 0xa2, 0xbd, 0x59, 0x52, ++ 0x8e, 0xec, 0x48, 0xf1, 0x2d, 0x52, 0x9c, 0xa0, 0x0f, 0xff, 0xff, 0xff, ++ 0xff, 0xfe, 0x02, 0x00, 0x02, 0x95, 0x54, 0x92, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x35, ++ 0x5f, 0xed, 0x6a, 0xf2, 0x95, 0x19, 0x09, 0xaa, 0x6a, 0x5d, 0x48, 0xc0, ++ 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x02, 0xaa, 0x52, 0xaa, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x04, 0x22, 0xa6, 0xc3, 0xdf, 0xd0, 0x66, 0x29, 0xf0, 0x01, 0x6a, ++ 0xca, 0xd5, 0x59, 0x80, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, ++ 0x05, 0x2a, 0xaa, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0xa4, 0x03, 0xf2, 0x61, 0xed, ++ 0x17, 0xe2, 0x02, 0xaa, 0x99, 0x2a, 0x98, 0x80, 0x07, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0x80, 0x40, 0x02, 0x55, 0x55, 0x2a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x09, 0x05, ++ 0x88, 0xa7, 0x47, 0xdc, 0xc0, 0x00, 0x2a, 0x6b, 0x4a, 0x6a, 0xb0, 0x00, ++ 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x20, 0x01, 0x55, 0x55, 0x55, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x80, 0x2e, 0x89, 0x11, 0xfb, 0x87, 0x9c, 0x90, 0x64, 0xaa, 0x9a, ++ 0x4a, 0xa9, 0x1a, 0x00, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x30, ++ 0x00, 0xa8, 0x42, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x2b, 0x16, 0x2b, 0x85, 0x09, 0xf8, ++ 0x83, 0x45, 0x5d, 0xad, 0x95, 0x49, 0x5c, 0x08, 0x1f, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xe0, 0x10, 0x00, 0xae, 0xea, 0x4a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x49, 0x28, ++ 0x3b, 0xf5, 0xbd, 0x30, 0x14, 0x96, 0x95, 0x6a, 0xd2, 0xb5, 0xaa, 0x10, ++ 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x18, 0x00, 0xa9, 0x15, 0x55, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x02, 0x19, 0x26, 0x58, 0x76, 0x4a, 0x1e, 0xe1, 0x7a, 0xba, 0xb1, 0x5b, ++ 0x4a, 0xab, 0x2c, 0x10, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x08, ++ 0x00, 0x2b, 0x6a, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x11, 0x21, 0x4d, 0x78, 0x6d, 0x20, ++ 0x0a, 0x84, 0xda, 0xaf, 0x55, 0x56, 0x52, 0x20, 0x3f, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xf0, 0x0c, 0x00, 0x54, 0xaa, 0xa5, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0xe8, 0x62, ++ 0xcd, 0x49, 0xd8, 0x42, 0xb4, 0xb8, 0x96, 0x3a, 0xa5, 0x54, 0xd4, 0x00, ++ 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x04, 0x00, 0x14, 0xaa, 0x4a, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x05, 0x2d, 0x18, 0x4e, 0x0e, 0x61, 0xb0, 0x0a, 0xab, 0x6b, 0xaa, 0x37, ++ 0x0d, 0x5a, 0xa8, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x06, ++ 0x00, 0x2b, 0x4a, 0xaa, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x10, 0x40, 0xb1, 0xd8, 0x5f, 0xc1, 0x90, 0x55, ++ 0x55, 0x4a, 0x32, 0xed, 0x79, 0x49, 0x50, 0x00, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xf8, 0x06, 0x00, 0x12, 0xaa, 0xa9, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x16, 0x00, 0xd1, ++ 0xac, 0x89, 0x91, 0x4a, 0xaa, 0xaa, 0xa9, 0xb2, 0xc5, 0x65, 0x68, 0x00, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x03, 0x00, 0x15, 0x2a, 0x4a, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, ++ 0x64, 0x54, 0x81, 0xcf, 0x89, 0x00, 0x1f, 0xf2, 0xaa, 0xd5, 0x6b, 0x35, ++ 0x5a, 0xad, 0xa8, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x03, ++ 0x00, 0x05, 0x6a, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x89, 0x23, 0xf6, 0x52, 0x28, 0x19, 0xd5, ++ 0x45, 0x55, 0x49, 0x54, 0xa5, 0x6a, 0xa0, 0x01, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xfc, 0x03, 0x00, 0x15, 0x24, 0xaa, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x09, 0x18, 0x04, 0x6c, ++ 0x64, 0x61, 0x21, 0x95, 0xad, 0x56, 0xaa, 0xd7, 0xab, 0x55, 0x50, 0x03, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x01, 0x80, 0x04, 0xaa, 0x94, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, ++ 0x12, 0x46, 0x20, 0xdc, 0xc4, 0x01, 0x01, 0xaa, 0xaa, 0xa9, 0x5b, 0x49, ++ 0x2a, 0xad, 0xa0, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x01, ++ 0x80, 0x02, 0xa4, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x10, 0x44, 0x08, 0x00, 0xd1, 0x84, 0x20, 0x05, 0xaa, ++ 0xaa, 0x95, 0x66, 0xaa, 0xaa, 0xaa, 0xa0, 0x03, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xfe, 0x01, 0x80, 0x05, 0x55, 0x29, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0c, 0xa8, 0x89, 0x99, ++ 0x00, 0x22, 0x03, 0xd5, 0x4a, 0xaa, 0xa7, 0x4d, 0x5a, 0xd5, 0x40, 0x07, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x01, 0x80, 0x02, 0x49, 0x4a, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, ++ 0x18, 0x02, 0x03, 0x24, 0x10, 0xa8, 0x2f, 0x6a, 0xaa, 0xaa, 0x45, 0x51, ++ 0x4a, 0xb5, 0x40, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, ++ 0x80, 0x04, 0x95, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x02, 0x01, 0x05, 0x48, 0x07, 0xae, 0x83, 0x02, 0x8c, 0x2a, ++ 0x95, 0x52, 0xcd, 0x56, 0xad, 0x56, 0xc0, 0x07, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xfe, 0x00, 0xc0, 0x01, 0x52, 0x52, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x58, 0x98, 0x2f, 0x30, ++ 0x02, 0x82, 0x01, 0x6a, 0xaa, 0xaa, 0x8d, 0x29, 0x35, 0xb5, 0x04, 0x07, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0xc0, 0x02, 0x94, 0x95, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, ++ 0x45, 0x30, 0x1f, 0xa0, 0x25, 0x1d, 0x15, 0x4a, 0xa5, 0x51, 0xad, 0x55, ++ 0x6d, 0x6a, 0x84, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, ++ 0xc0, 0x01, 0x29, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x08, 0xa1, 0x2d, 0x21, 0x7f, 0x40, 0x4d, 0xb0, 0x35, 0x55, ++ 0x15, 0x15, 0x79, 0x25, 0x4a, 0xca, 0x04, 0x0f, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xff, 0x00, 0xc0, 0x02, 0x52, 0x96, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x40, 0x7f, 0x24, ++ 0x8a, 0x58, 0xad, 0x55, 0x55, 0x52, 0x0a, 0x5a, 0xaa, 0xbb, 0x04, 0x0f, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xc0, 0x00, 0xa5, 0x20, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x09, ++ 0x50, 0x42, 0xfd, 0xc0, 0x59, 0x53, 0x53, 0x4c, 0xaa, 0x54, 0x5a, 0xa2, ++ 0xad, 0xaa, 0x04, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, ++ 0xc0, 0x01, 0x4d, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x08, 0x02, 0x15, 0x90, 0x7d, 0x15, 0x76, 0xac, 0xad, 0x52, ++ 0x95, 0x55, 0xaa, 0x4c, 0xa5, 0x54, 0x04, 0x0f, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xff, 0x00, 0xc0, 0x00, 0xa5, 0x12, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0c, 0x83, 0x01, 0xff, 0xf9, ++ 0x15, 0x29, 0x51, 0x55, 0x52, 0x2c, 0xa2, 0x54, 0xab, 0x6c, 0x04, 0x0f, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x80, 0x01, 0x28, 0x54, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x98, ++ 0x06, 0x01, 0xff, 0xe9, 0x55, 0xd5, 0x56, 0xa5, 0x55, 0xaa, 0xad, 0x51, ++ 0x35, 0x54, 0x04, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, ++ 0x80, 0x00, 0x4a, 0xa9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x01, 0x08, 0x31, 0x1c, 0x12, 0xf4, 0xc5, 0x44, 0x5a, 0xaa, 0x49, ++ 0xaa, 0xa9, 0xa8, 0x95, 0x55, 0x50, 0x04, 0x0f, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xff, 0x01, 0x80, 0x01, 0x52, 0x82, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x48, 0x1c, 0x41, 0x3e, 0x2e, ++ 0x8b, 0x54, 0xaa, 0xab, 0x52, 0xa5, 0x45, 0x24, 0x95, 0x50, 0x06, 0x0f, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x01, 0x24, 0x5a, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x00, ++ 0x38, 0x01, 0x1d, 0x64, 0x9a, 0xa9, 0x2a, 0x94, 0xaa, 0xab, 0x55, 0x55, ++ 0xaa, 0xd8, 0x02, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, ++ 0x00, 0x01, 0x4a, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x13, 0xc8, 0x00, 0xb0, 0x02, 0x3e, 0x96, 0x35, 0x6a, 0xaa, 0x55, ++ 0x4a, 0x95, 0x4a, 0x54, 0x55, 0x28, 0x03, 0x0f, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xff, 0x8f, 0xc0, 0x01, 0x29, 0x4a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x83, 0x49, 0x20, 0x8c, 0x78, 0xb5, ++ 0x65, 0x4a, 0xaa, 0xa6, 0xaa, 0xa5, 0x29, 0x45, 0xaa, 0xa8, 0x03, 0x0f, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x70, 0x01, 0x45, 0x28, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x03, 0x20, ++ 0x00, 0x30, 0x75, 0x4c, 0x95, 0x55, 0x54, 0xa9, 0x52, 0x95, 0x52, 0x95, ++ 0x2a, 0xa8, 0x01, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, ++ 0x18, 0x00, 0x94, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x0d, 0x0c, 0x0c, 0x44, 0x18, 0xe5, 0xb9, 0xb5, 0x54, 0x92, 0x96, ++ 0xaa, 0x55, 0x4a, 0x69, 0x55, 0x20, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x29, 0x29, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x01, 0x2e, 0x08, 0x1c, 0x01, 0x7b, 0xdc, 0x96, ++ 0x4a, 0xaa, 0xaa, 0xa9, 0x4a, 0xaa, 0x95, 0x0a, 0x73, 0x50, 0x00, 0xff, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x01, 0x52, 0x52, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x30, ++ 0x44, 0x79, 0x88, 0xd4, 0x95, 0x49, 0x54, 0xab, 0x52, 0x94, 0xa4, 0xaa, ++ 0xc6, 0x51, 0xe0, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, ++ 0x00, 0x00, 0x8a, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x38, 0x2a, 0x21, 0x01, 0xfb, 0xa0, 0x7d, 0x54, 0xb5, 0x55, 0x54, ++ 0x95, 0x55, 0x29, 0x55, 0x29, 0x57, 0xf8, 0x3f, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xfe, 0x00, 0x00, 0x02, 0x50, 0x52, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x02, 0x78, 0x90, 0x00, 0x0d, 0xfb, 0xca, 0xd2, ++ 0xaa, 0x92, 0x49, 0x55, 0x55, 0x2a, 0x4a, 0x4a, 0xd3, 0x57, 0xfc, 0x1f, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x02, 0x95, 0x54, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, 0x20, 0xa4, ++ 0x13, 0xfd, 0xab, 0x2a, 0x52, 0xa5, 0x52, 0x55, 0x52, 0xa9, 0x55, 0x55, ++ 0x2a, 0x57, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x00, ++ 0x00, 0x0d, 0x24, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x08, 0x30, 0xc0, 0x00, 0x77, 0xb5, 0x55, 0x69, 0x4a, 0xaa, 0x96, 0xaa, ++ 0x94, 0xaa, 0x91, 0x45, 0x55, 0x4f, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0xcf, 0x00, 0x00, 0x1e, 0x55, 0x2a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x01, 0x30, 0x81, 0x00, 0x67, 0xb4, 0x74, 0x52, ++ 0x55, 0x55, 0x2a, 0xaa, 0xaa, 0x52, 0x55, 0x35, 0x52, 0xaf, 0xff, 0x81, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x00, 0x00, 0x1e, 0xa0, 0x48, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xe3, 0x00, 0x08, ++ 0x86, 0x4a, 0xd4, 0xd5, 0x54, 0x91, 0x49, 0x55, 0x51, 0x54, 0x95, 0x49, ++ 0x56, 0x4f, 0xff, 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x80, ++ 0x00, 0x3e, 0x0b, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x05, 0xc4, 0x02, 0x00, 0x7f, 0xbd, 0x8a, 0x25, 0x49, 0x55, 0x2a, 0xb5, ++ 0x55, 0x52, 0xa4, 0x96, 0xac, 0x8f, 0xff, 0xe0, 0x7f, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0x9f, 0x80, 0x00, 0x7e, 0x54, 0xa4, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x43, 0x80, 0x20, 0x21, 0x4d, 0x3f, 0x52, 0xb4, ++ 0x55, 0x2a, 0x55, 0x55, 0x4a, 0xa4, 0x95, 0x32, 0xa5, 0x4f, 0xff, 0xe0, ++ 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xc0, 0x00, 0xfe, 0x49, 0x14, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe8, 0x04, 0x08, ++ 0x1a, 0x46, 0xd4, 0x49, 0xaa, 0xa4, 0xaa, 0xaa, 0x54, 0x95, 0x2a, 0xc4, ++ 0x94, 0x8f, 0xff, 0xf0, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xe0, ++ 0x01, 0xfe, 0x92, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x8e, 0x40, 0x80, 0x00, 0x74, 0x44, 0x51, 0x55, 0x64, 0xa9, 0x49, 0x55, ++ 0x49, 0x51, 0x52, 0x5a, 0x2a, 0x1f, 0xff, 0xf8, 0x07, 0xff, 0xff, 0xff, ++ 0xff, 0xff, 0x9f, 0xf0, 0x07, 0xfe, 0x24, 0x52, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x0d, 0x90, 0x00, 0x41, 0xeb, 0x12, 0xab, 0x52, ++ 0xa9, 0x4a, 0xaa, 0xa5, 0x52, 0x95, 0x2a, 0xa2, 0xa8, 0x1f, 0xff, 0xf8, ++ 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xf8, 0x1f, 0xfe, 0x52, 0x8a, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x3b, 0x81, 0x08, 0x05, ++ 0xe3, 0x15, 0xa5, 0x36, 0x95, 0x4a, 0x4a, 0xaa, 0x45, 0x2a, 0xa2, 0xac, ++ 0x00, 0x3f, 0xff, 0xfc, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xff, ++ 0xff, 0xfe, 0x04, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0xb2, 0x00, 0x00, 0x80, 0xe8, 0x52, 0xac, 0xa8, 0xa4, 0x92, 0xa9, 0x4a, ++ 0x95, 0x51, 0x2d, 0x50, 0xe1, 0xff, 0xff, 0xfe, 0x00, 0x7f, 0xff, 0xff, ++ 0xff, 0xff, 0x9f, 0xff, 0xff, 0xfe, 0x29, 0x05, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x04, 0x00, 0x35, 0x10, 0x09, 0xa9, 0x4a, 0xaa, 0xaa, ++ 0xa9, 0x54, 0x95, 0x2a, 0xa4, 0x8a, 0xa9, 0x43, 0xff, 0xff, 0xff, 0xfe, ++ 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xfe, 0x12, 0xa9, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x01, 0x03, ++ 0x34, 0xa5, 0x19, 0x25, 0x55, 0x55, 0x55, 0x55, 0x15, 0x55, 0x45, 0x53, ++ 0xff, 0xff, 0xff, 0xff, 0x00, 0x1f, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xff, ++ 0xff, 0xfe, 0x04, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, ++ 0x49, 0x3c, 0x00, 0x34, 0x75, 0x4a, 0xa2, 0xaa, 0x92, 0x92, 0x92, 0x54, ++ 0x52, 0x54, 0x99, 0x53, 0xff, 0xff, 0xff, 0xff, 0x80, 0x0f, 0xff, 0xff, ++ 0xff, 0xff, 0x9f, 0xff, 0xff, 0xff, 0x14, 0x94, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x02, 0x00, 0x78, 0x12, 0xfc, 0xaa, 0x92, 0x2d, 0x54, ++ 0xa4, 0xa5, 0x2a, 0x92, 0x94, 0x92, 0xa2, 0xa3, 0xff, 0xff, 0xff, 0xff, ++ 0x80, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xff, 0x01, 0x51, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x16, 0xf0, 0x80, 0x71, ++ 0xc5, 0x2a, 0x65, 0x25, 0x55, 0x4a, 0x52, 0xaa, 0x51, 0x52, 0x95, 0x21, ++ 0xff, 0xff, 0xff, 0xff, 0xc0, 0x07, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, ++ 0xff, 0xff, 0x81, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, ++ 0x8e, 0xa0, 0x00, 0xb3, 0x94, 0xa4, 0xa9, 0x55, 0x45, 0x54, 0xa5, 0x25, ++ 0x25, 0x2a, 0x65, 0x41, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x07, 0xff, 0xff, ++ 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0x80, 0x4a, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0xa0, 0x0f, 0x42, 0x13, 0x46, 0x94, 0x94, 0xa5, 0x4a, ++ 0x54, 0x92, 0x88, 0xa8, 0x49, 0x55, 0x4a, 0x51, 0xff, 0xff, 0xff, 0xff, ++ 0xe0, 0x07, 0xff, 0xff, 0xff, 0xff, 0x8f, 0xff, 0xff, 0xff, 0xe0, 0x52, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x2d, 0x00, 0x87, 0x56, ++ 0x4b, 0x2a, 0x99, 0x55, 0x4a, 0xaa, 0x55, 0x4a, 0x92, 0xa2, 0x54, 0xa8, ++ 0xff, 0xff, 0xff, 0xff, 0xf0, 0x07, 0xff, 0xff, 0xff, 0xfd, 0x8f, 0xff, ++ 0xff, 0xff, 0xfe, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x88, ++ 0x18, 0x04, 0x1f, 0x11, 0x51, 0x51, 0x0b, 0x54, 0x94, 0xa5, 0x52, 0x92, ++ 0x55, 0x54, 0x95, 0x20, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x0f, 0xff, 0xff, ++ 0xff, 0xf9, 0x8f, 0xff, 0xff, 0xff, 0xff, 0x89, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x11, 0xe0, 0x38, 0x01, 0x3e, 0x4d, 0x0a, 0x55, 0x5a, 0x55, ++ 0x55, 0x4a, 0x25, 0x24, 0x81, 0x25, 0x29, 0x48, 0xff, 0xff, 0xff, 0xff, ++ 0xf8, 0x1f, 0xff, 0xff, 0xff, 0xf0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xc2, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x80, 0xf0, 0x90, 0x7e, 0xd4, ++ 0x68, 0x92, 0xaa, 0x54, 0x92, 0x92, 0xa9, 0x55, 0x2e, 0xaa, 0xa2, 0x58, ++ 0x7f, 0xff, 0xff, 0xff, 0xfc, 0x3f, 0xff, 0xff, 0xff, 0xe0, 0x8f, 0xff, ++ 0xff, 0xff, 0xff, 0xe4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x04, ++ 0x40, 0x00, 0x49, 0xe2, 0x8a, 0xa9, 0x54, 0x95, 0x2a, 0x54, 0x4a, 0x48, ++ 0x91, 0x51, 0x2a, 0xc8, 0x7f, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, ++ 0xff, 0xc0, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x2e, 0x00, 0x00, 0x03, 0x79, 0x4a, 0xa9, 0x45, 0x49, 0x54, ++ 0xa4, 0x89, 0x49, 0x52, 0x8a, 0x85, 0x4a, 0x98, 0x7f, 0xff, 0xff, 0xff, ++ 0xfe, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x8f, 0xff, 0xff, 0xff, 0xff, 0xc4, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x48, 0x44, 0x91, 0x65, 0x55, ++ 0x4a, 0x54, 0x96, 0x85, 0x55, 0x52, 0xaa, 0x8a, 0x1a, 0xaa, 0x59, 0x30, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xfe, 0x01, 0x0f, 0xff, ++ 0xff, 0xff, 0xff, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00, ++ 0x00, 0x02, 0xc3, 0x50, 0x29, 0x49, 0x2d, 0x35, 0x24, 0x54, 0x89, 0x32, ++ 0x52, 0x91, 0x49, 0x40, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0xff, 0xff, ++ 0xfc, 0x01, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x04, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00, 0x20, 0x08, 0x80, 0x00, 0x87, 0x4b, 0x42, 0x95, 0x2a, 0x4a, ++ 0x4a, 0x89, 0x52, 0x44, 0x45, 0x25, 0x55, 0x10, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0x98, 0x7f, 0xff, 0xf0, 0x01, 0x0f, 0xff, 0xff, 0xff, 0xfc, 0x09, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x40, 0x11, 0x15, 0x6a, 0x92, ++ 0x4d, 0x29, 0x4a, 0xaa, 0xa4, 0xaa, 0x55, 0x54, 0x9a, 0x74, 0x44, 0xb1, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8c, 0x1f, 0xff, 0x00, 0x01, 0x0f, 0xff, ++ 0xff, 0xff, 0xf0, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, ++ 0x80, 0x01, 0x48, 0x54, 0x94, 0xa6, 0xa9, 0x52, 0x45, 0x24, 0x84, 0x92, ++ 0xa4, 0x85, 0x2a, 0x43, 0xff, 0xff, 0xff, 0xff, 0xff, 0x84, 0x00, 0x00, ++ 0x00, 0x01, 0x1f, 0xff, 0xff, 0xff, 0xc0, 0x92, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x11, 0x00, 0x09, 0x02, 0x03, 0x53, 0x15, 0x2a, 0x49, 0x4a, 0xa5, ++ 0x49, 0x29, 0x29, 0x24, 0x2a, 0xd5, 0x54, 0xa3, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xc6, 0x00, 0x00, 0x00, 0x03, 0x1f, 0xff, 0xff, 0xfe, 0x01, 0x24, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x02, 0x20, 0x26, 0xd4, 0xa2, ++ 0x49, 0xb5, 0x15, 0x4a, 0x52, 0xa9, 0x4a, 0x92, 0xa5, 0x12, 0x52, 0xa3, ++ 0xff, 0xff, 0xff, 0xff, 0xff, 0xc6, 0x00, 0x00, 0x00, 0x03, 0x1f, 0xff, ++ 0xff, 0xf0, 0x14, 0x92, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x00, 0x44, ++ 0x00, 0x0c, 0xc4, 0xa4, 0xa8, 0x25, 0x2a, 0xaa, 0x84, 0x45, 0x28, 0xa4, ++ 0xa8, 0xa5, 0x4a, 0x43, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x00, 0x00, ++ 0x00, 0x06, 0x1f, 0xff, 0xff, 0xc0, 0x25, 0x24, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x10, 0x80, 0x12, 0x01, 0x11, 0x12, 0x8a, 0x95, 0x49, 0x55, 0x49, ++ 0x2a, 0xaa, 0x45, 0x0a, 0x4a, 0x94, 0xaa, 0x90, 0xff, 0xff, 0xff, 0xff, ++ 0xff, 0xc2, 0x00, 0x00, 0x00, 0x06, 0x1f, 0xff, 0xff, 0x02, 0x48, 0x92, ++ 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x08, 0x00, 0x22, 0x01, 0x24, 0x95, ++ 0x21, 0x55, 0x55, 0x2a, 0x54, 0x92, 0x94, 0xa8, 0xa9, 0x2a, 0x92, 0xa8, ++ 0x1f, 0xff, 0xff, 0xff, 0xff, 0x82, 0x00, 0x00, 0x00, 0x06, 0x0f, 0xff, ++ 0xfe, 0x02, 0x49, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x01, 0x40, ++ 0x00, 0xc4, 0x89, 0x11, 0x54, 0x95, 0x29, 0x49, 0x49, 0x24, 0x29, 0x12, ++ 0x92, 0xa5, 0x55, 0x28, 0x01, 0xff, 0xff, 0xff, 0xff, 0x82, 0x00, 0x00, ++ 0x00, 0x02, 0x0f, 0xff, 0xfc, 0x14, 0x92, 0x49, 0x00, 0x00, 0x00, 0x00, ++ 0x08, 0x42, 0x06, 0x44, 0x45, 0x08, 0x92, 0x24, 0x95, 0xaa, 0xa5, 0x52, ++ 0x92, 0x55, 0x42, 0x52, 0xaa, 0x4a, 0x49, 0x4a, 0x80, 0x0f, 0xff, 0xff, ++ 0xff, 0x84, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, 0x04, 0x92, 0x49, ++ 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x2a, 0x80, 0x01, 0x95, 0x2a, 0x8a, ++ 0xa0, 0x95, 0x2a, 0x95, 0x54, 0xa4, 0x54, 0x84, 0x44, 0x95, 0x55, 0x29, ++ 0x54, 0x00, 0x7f, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, ++ 0xe0, 0x29, 0x24, 0x92, 0x00, 0x00, 0x00, 0x00, 0x22, 0x04, 0x03, 0x03, ++ 0x42, 0x12, 0x52, 0x2a, 0x15, 0x55, 0x54, 0xa8, 0x92, 0xa9, 0x49, 0x29, ++ 0x54, 0xaa, 0x92, 0x52, 0xa5, 0x40, 0x07, 0xff, 0xff, 0x00, 0x15, 0x50, ++ 0x92, 0x44, 0x07, 0xff, 0xc0, 0x52, 0x54, 0xaa, 0x00, 0x00, 0x00, 0x00, ++ 0x84, 0x02, 0x86, 0x03, 0x08, 0x41, 0x48, 0x94, 0xa5, 0x52, 0xaa, 0x8a, ++ 0x49, 0x52, 0x92, 0x45, 0x49, 0x55, 0x2a, 0xaa, 0x94, 0x96, 0x00, 0x7f, ++ 0xfe, 0x01, 0x55, 0x2b, 0x25, 0x50, 0x03, 0xff, 0x00, 0xa4, 0x91, 0x08, ++ 0x00, 0x00, 0x00, 0x00, 0x88, 0x2c, 0x18, 0x14, 0x0a, 0xaa, 0x92, 0x55, ++ 0x49, 0x55, 0x4a, 0xa9, 0x52, 0x44, 0x92, 0x94, 0x92, 0x92, 0xca, 0x4a, ++ 0x55, 0x27, 0xa0, 0x0f, 0xf8, 0x05, 0x35, 0x49, 0x68, 0x91, 0x00, 0xf8, ++ 0x04, 0x95, 0x25, 0x29, 0x00, 0x00, 0x00, 0x01, 0x08, 0x04, 0x18, 0x00, ++ 0x08, 0x04, 0x49, 0x08, 0x55, 0x4a, 0xa9, 0x12, 0x95, 0x55, 0x49, 0x22, ++ 0x65, 0x2a, 0x5a, 0x92, 0xa9, 0x49, 0x54, 0x00, 0xe0, 0x24, 0xb2, 0x55, ++ 0x15, 0x4c, 0x00, 0x00, 0x02, 0x48, 0x52, 0x52, 0x00, 0x00, 0x00, 0x02, ++ 0x21, 0x09, 0x50, 0x81, 0x51, 0x69, 0x48, 0x52, 0x92, 0x94, 0xaa, 0x54, ++ 0x25, 0x54, 0x92, 0x4a, 0x89, 0x54, 0x82, 0xaa, 0x4a, 0x53, 0x55, 0x00, ++ 0x00, 0x49, 0x65, 0x52, 0x51, 0x12, 0x80, 0x00, 0x14, 0x92, 0x92, 0x42, ++ 0x00, 0x00, 0x00, 0x01, 0x00, 0x20, 0x50, 0x24, 0x2a, 0x95, 0x25, 0x29, ++ 0x4a, 0xb5, 0x48, 0xa5, 0x52, 0x49, 0x24, 0x94, 0xaa, 0xab, 0x15, 0x24, ++ 0x92, 0xa5, 0x54, 0x40, 0x00, 0xaa, 0xb5, 0x25, 0x4a, 0xa4, 0x80, 0x00, ++ 0x21, 0x24, 0xa8, 0x94, 0x00, 0x00, 0x00, 0x0a, 0x44, 0x02, 0xb1, 0x01, ++ 0x24, 0x80, 0x48, 0xa2, 0x55, 0x55, 0x52, 0x8a, 0x94, 0xaa, 0x49, 0x22, ++ 0x8a, 0x49, 0x49, 0x55, 0x4a, 0x51, 0x25, 0x48, 0x02, 0xa8, 0x6a, 0x69, ++ 0x12, 0x29, 0x50, 0x00, 0x55, 0x24, 0x81, 0x24, 0x00, 0x00, 0x00, 0x23, ++ 0x80, 0x90, 0x70, 0x14, 0x82, 0x55, 0x22, 0x8a, 0xa9, 0x14, 0xaa, 0xa9, ++ 0x25, 0x51, 0x2a, 0x55, 0x21, 0x55, 0x55, 0x12, 0x55, 0x32, 0xaa, 0x94, ++ 0xa5, 0x55, 0x5a, 0x92, 0x54, 0xa5, 0x52, 0x24, 0xa2, 0x49, 0x2a, 0x92, ++ 0x00, 0x00, 0x00, 0x0e, 0x08, 0x00, 0xe2, 0xa0, 0x04, 0x54, 0x84, 0x52, ++ 0x4a, 0xa4, 0xaa, 0x2a, 0xa9, 0x25, 0x45, 0x42, 0xae, 0x92, 0x44, 0xa4, ++ 0x91, 0x24, 0xaa, 0xaa, 0xaa, 0x91, 0x55, 0x55, 0x51, 0x55, 0x54, 0xa9, ++ 0x14, 0x92, 0x49, 0x24, 0x00, 0x00, 0x00, 0x24, 0x01, 0x82, 0x70, 0x09, ++ 0x2a, 0x41, 0x2a, 0x89, 0x14, 0x49, 0x29, 0x52, 0x4a, 0xaa, 0x2a, 0x15, ++ 0x12, 0xaa, 0xa9, 0x2a, 0xaa, 0xba, 0xa4, 0x94, 0x95, 0x55, 0x5a, 0x49, ++ 0x25, 0x20, 0x49, 0x22, 0xa5, 0x24, 0x92, 0x92, 0x00, 0x00, 0x01, 0x0c, ++ 0x93, 0x10, 0xe2, 0x11, 0x00, 0x94, 0x22, 0x52, 0x69, 0x53, 0x52, 0x45, ++ 0x49, 0x22, 0xa4, 0x4a, 0x55, 0x29, 0x2a, 0xa4, 0x52, 0x42, 0xaa, 0xa5, ++ 0x52, 0xa8, 0xaa, 0x55, 0x4a, 0xab, 0xa9, 0x4a, 0x54, 0x49, 0x32, 0x24 }; +diff --git a/arch/mips/boot/compressed/Makefile b/arch/mips/boot/compressed/Makefile +index f93f72bcba97e..0db5b2c38893b 100644 +--- a/arch/mips/boot/compressed/Makefile ++++ b/arch/mips/boot/compressed/Makefile +@@ -40,7 +40,7 @@ GCOV_PROFILE := n + UBSAN_SANITIZE := n + + # decompressor objects (linked with vmlinuz) +-vmlinuzobjs-y := $(obj)/head.o $(obj)/decompress.o $(obj)/string.o ++vmlinuzobjs-y := $(obj)/head.o $(obj)/decompress.o $(obj)/string.o $(obj)/bswapsi.o + + ifdef CONFIG_DEBUG_ZBOOT + vmlinuzobjs-$(CONFIG_DEBUG_ZBOOT) += $(obj)/dbg.o +@@ -54,7 +54,7 @@ extra-y += uart-ath79.c + $(obj)/uart-ath79.c: $(srctree)/arch/mips/ath79/early_printk.c + $(call cmd,shipped) + +-vmlinuzobjs-$(CONFIG_KERNEL_XZ) += $(obj)/ashldi3.o $(obj)/bswapsi.o ++vmlinuzobjs-$(CONFIG_KERNEL_XZ) += $(obj)/ashldi3.o + + extra-y += ashldi3.c + $(obj)/ashldi3.c: $(obj)/%.c: $(srctree)/lib/%.c FORCE +diff --git a/arch/mips/boot/compressed/decompress.c b/arch/mips/boot/compressed/decompress.c +index 3d70d15ada286..aae1346a509a9 100644 +--- a/arch/mips/boot/compressed/decompress.c ++++ b/arch/mips/boot/compressed/decompress.c +@@ -7,6 +7,8 @@ + * Author: Wu Zhangjin + */ + ++#define DISABLE_BRANCH_PROFILING ++ + #include + #include + #include +diff --git a/arch/mips/include/asm/vdso/vdso.h b/arch/mips/include/asm/vdso/vdso.h +index 737ddfc3411cb..a327ca21270ec 100644 +--- a/arch/mips/include/asm/vdso/vdso.h ++++ b/arch/mips/include/asm/vdso/vdso.h +@@ -67,7 +67,7 @@ static inline const struct vdso_data *get_vdso_data(void) + + static inline void __iomem *get_gic(const struct vdso_data *data) + { +- return (void __iomem *)data - PAGE_SIZE; ++ return (void __iomem *)((unsigned long)data & PAGE_MASK) - PAGE_SIZE; + } + + #endif /* CONFIG_CLKSRC_MIPS_GIC */ +diff --git a/arch/powerpc/boot/devtree.c b/arch/powerpc/boot/devtree.c +index 5d91036ad626d..58fbcfcc98c9e 100644 +--- a/arch/powerpc/boot/devtree.c ++++ b/arch/powerpc/boot/devtree.c +@@ -13,6 +13,7 @@ + #include "string.h" + #include "stdio.h" + #include "ops.h" ++#include "of.h" + + void dt_fixup_memory(u64 start, u64 size) + { +@@ -23,21 +24,25 @@ void dt_fixup_memory(u64 start, u64 size) + root = finddevice("/"); + if (getprop(root, "#address-cells", &naddr, sizeof(naddr)) < 0) + naddr = 2; ++ else ++ naddr = be32_to_cpu(naddr); + if (naddr < 1 || naddr > 2) + fatal("Can't cope with #address-cells == %d in /\n\r", naddr); + + if (getprop(root, "#size-cells", &nsize, sizeof(nsize)) < 0) + nsize = 1; ++ else ++ nsize = be32_to_cpu(nsize); + if (nsize < 1 || nsize > 2) + fatal("Can't cope with #size-cells == %d in /\n\r", nsize); + + i = 0; + if (naddr == 2) +- memreg[i++] = start >> 32; +- memreg[i++] = start & 0xffffffff; ++ memreg[i++] = cpu_to_be32(start >> 32); ++ memreg[i++] = cpu_to_be32(start & 0xffffffff); + if (nsize == 2) +- memreg[i++] = size >> 32; +- memreg[i++] = size & 0xffffffff; ++ memreg[i++] = cpu_to_be32(size >> 32); ++ memreg[i++] = cpu_to_be32(size & 0xffffffff); + + memory = finddevice("/memory"); + if (! memory) { +@@ -45,9 +50,9 @@ void dt_fixup_memory(u64 start, u64 size) + setprop_str(memory, "device_type", "memory"); + } + +- printf("Memory <- <0x%x", memreg[0]); ++ printf("Memory <- <0x%x", be32_to_cpu(memreg[0])); + for (i = 1; i < (naddr + nsize); i++) +- printf(" 0x%x", memreg[i]); ++ printf(" 0x%x", be32_to_cpu(memreg[i])); + printf("> (%ldMB)\n\r", (unsigned long)(size >> 20)); + + setprop(memory, "reg", memreg, (naddr + nsize)*sizeof(u32)); +@@ -65,10 +70,10 @@ void dt_fixup_cpu_clocks(u32 cpu, u32 tb, u32 bus) + printf("CPU bus-frequency <- 0x%x (%dMHz)\n\r", bus, MHZ(bus)); + + while ((devp = find_node_by_devtype(devp, "cpu"))) { +- setprop_val(devp, "clock-frequency", cpu); +- setprop_val(devp, "timebase-frequency", tb); ++ setprop_val(devp, "clock-frequency", cpu_to_be32(cpu)); ++ setprop_val(devp, "timebase-frequency", cpu_to_be32(tb)); + if (bus > 0) +- setprop_val(devp, "bus-frequency", bus); ++ setprop_val(devp, "bus-frequency", cpu_to_be32(bus)); + } + + timebase_period_ns = 1000000000 / tb; +@@ -80,7 +85,7 @@ void dt_fixup_clock(const char *path, u32 freq) + + if (devp) { + printf("%s: clock-frequency <- %x (%dMHz)\n\r", path, freq, MHZ(freq)); +- setprop_val(devp, "clock-frequency", freq); ++ setprop_val(devp, "clock-frequency", cpu_to_be32(freq)); + } + } + +@@ -133,8 +138,12 @@ void dt_get_reg_format(void *node, u32 *naddr, u32 *nsize) + { + if (getprop(node, "#address-cells", naddr, 4) != 4) + *naddr = 2; ++ else ++ *naddr = be32_to_cpu(*naddr); + if (getprop(node, "#size-cells", nsize, 4) != 4) + *nsize = 1; ++ else ++ *nsize = be32_to_cpu(*nsize); + } + + static void copy_val(u32 *dest, u32 *src, int naddr) +@@ -163,9 +172,9 @@ static int add_reg(u32 *reg, u32 *add, int naddr) + int i, carry = 0; + + for (i = MAX_ADDR_CELLS - 1; i >= MAX_ADDR_CELLS - naddr; i--) { +- u64 tmp = (u64)reg[i] + add[i] + carry; ++ u64 tmp = (u64)be32_to_cpu(reg[i]) + be32_to_cpu(add[i]) + carry; + carry = tmp >> 32; +- reg[i] = (u32)tmp; ++ reg[i] = cpu_to_be32((u32)tmp); + } + + return !carry; +@@ -180,18 +189,18 @@ static int compare_reg(u32 *reg, u32 *range, u32 *rangesize) + u32 end; + + for (i = 0; i < MAX_ADDR_CELLS; i++) { +- if (reg[i] < range[i]) ++ if (be32_to_cpu(reg[i]) < be32_to_cpu(range[i])) + return 0; +- if (reg[i] > range[i]) ++ if (be32_to_cpu(reg[i]) > be32_to_cpu(range[i])) + break; + } + + for (i = 0; i < MAX_ADDR_CELLS; i++) { +- end = range[i] + rangesize[i]; ++ end = be32_to_cpu(range[i]) + be32_to_cpu(rangesize[i]); + +- if (reg[i] < end) ++ if (be32_to_cpu(reg[i]) < end) + break; +- if (reg[i] > end) ++ if (be32_to_cpu(reg[i]) > end) + return 0; + } + +@@ -240,7 +249,6 @@ static int dt_xlate(void *node, int res, int reglen, unsigned long *addr, + return 0; + + dt_get_reg_format(parent, &naddr, &nsize); +- + if (nsize > 2) + return 0; + +@@ -252,10 +260,10 @@ static int dt_xlate(void *node, int res, int reglen, unsigned long *addr, + + copy_val(last_addr, prop_buf + offset, naddr); + +- ret_size = prop_buf[offset + naddr]; ++ ret_size = be32_to_cpu(prop_buf[offset + naddr]); + if (nsize == 2) { + ret_size <<= 32; +- ret_size |= prop_buf[offset + naddr + 1]; ++ ret_size |= be32_to_cpu(prop_buf[offset + naddr + 1]); + } + + for (;;) { +@@ -278,7 +286,6 @@ static int dt_xlate(void *node, int res, int reglen, unsigned long *addr, + + offset = find_range(last_addr, prop_buf, prev_naddr, + naddr, prev_nsize, buflen / 4); +- + if (offset < 0) + return 0; + +@@ -296,8 +303,7 @@ static int dt_xlate(void *node, int res, int reglen, unsigned long *addr, + if (naddr > 2) + return 0; + +- ret_addr = ((u64)last_addr[2] << 32) | last_addr[3]; +- ++ ret_addr = ((u64)be32_to_cpu(last_addr[2]) << 32) | be32_to_cpu(last_addr[3]); + if (sizeof(void *) == 4 && + (ret_addr >= 0x100000000ULL || ret_size > 0x100000000ULL || + ret_addr + ret_size > 0x100000000ULL)) +@@ -350,11 +356,14 @@ int dt_is_compatible(void *node, const char *compat) + int dt_get_virtual_reg(void *node, void **addr, int nres) + { + unsigned long xaddr; +- int n; ++ int n, i; + + n = getprop(node, "virtual-reg", addr, nres * 4); +- if (n > 0) ++ if (n > 0) { ++ for (i = 0; i < n/4; i ++) ++ ((u32 *)addr)[i] = be32_to_cpu(((u32 *)addr)[i]); + return n / 4; ++ } + + for (n = 0; n < nres; n++) { + if (!dt_xlate_reg(node, n, &xaddr, NULL)) +diff --git a/arch/powerpc/boot/ns16550.c b/arch/powerpc/boot/ns16550.c +index b0da4466d4198..f16d2be1d0f31 100644 +--- a/arch/powerpc/boot/ns16550.c ++++ b/arch/powerpc/boot/ns16550.c +@@ -15,6 +15,7 @@ + #include "stdio.h" + #include "io.h" + #include "ops.h" ++#include "of.h" + + #define UART_DLL 0 /* Out: Divisor Latch Low */ + #define UART_DLM 1 /* Out: Divisor Latch High */ +@@ -58,16 +59,20 @@ int ns16550_console_init(void *devp, struct serial_console_data *scdp) + int n; + u32 reg_offset; + +- if (dt_get_virtual_reg(devp, (void **)®_base, 1) < 1) ++ if (dt_get_virtual_reg(devp, (void **)®_base, 1) < 1) { ++ printf("virt reg parse fail...\r\n"); + return -1; ++ } + + n = getprop(devp, "reg-offset", ®_offset, sizeof(reg_offset)); + if (n == sizeof(reg_offset)) +- reg_base += reg_offset; ++ reg_base += be32_to_cpu(reg_offset); + + n = getprop(devp, "reg-shift", ®_shift, sizeof(reg_shift)); + if (n != sizeof(reg_shift)) + reg_shift = 0; ++ else ++ reg_shift = be32_to_cpu(reg_shift); + + scdp->open = ns16550_open; + scdp->putc = ns16550_putc; +diff --git a/arch/powerpc/include/asm/ps3.h b/arch/powerpc/include/asm/ps3.h +index e646c7f218bc8..12b6b76e8d0f7 100644 +--- a/arch/powerpc/include/asm/ps3.h ++++ b/arch/powerpc/include/asm/ps3.h +@@ -71,6 +71,7 @@ struct ps3_dma_region_ops; + * @bus_addr: The 'translated' bus address of the region. + * @len: The length in bytes of the region. + * @offset: The offset from the start of memory of the region. ++ * @dma_mask: Device dma_mask. + * @ioid: The IOID of the device who owns this region + * @chunk_list: Opaque variable used by the ioc page manager. + * @region_ops: struct ps3_dma_region_ops - dma region operations +@@ -85,6 +86,7 @@ struct ps3_dma_region { + enum ps3_dma_region_type region_type; + unsigned long len; + unsigned long offset; ++ u64 dma_mask; + + /* driver variables (set by ps3_dma_region_create) */ + unsigned long bus_addr; +diff --git a/arch/powerpc/mm/book3s64/radix_tlb.c b/arch/powerpc/mm/book3s64/radix_tlb.c +index 409e612107892..817a02ef60320 100644 +--- a/arch/powerpc/mm/book3s64/radix_tlb.c ++++ b/arch/powerpc/mm/book3s64/radix_tlb.c +@@ -291,22 +291,30 @@ static inline void fixup_tlbie_lpid(unsigned long lpid) + /* + * We use 128 set in radix mode and 256 set in hpt mode. + */ +-static __always_inline void _tlbiel_pid(unsigned long pid, unsigned long ric) ++static inline void _tlbiel_pid(unsigned long pid, unsigned long ric) + { + int set; + + asm volatile("ptesync": : :"memory"); + +- /* +- * Flush the first set of the TLB, and if we're doing a RIC_FLUSH_ALL, +- * also flush the entire Page Walk Cache. +- */ +- __tlbiel_pid(pid, 0, ric); ++ switch (ric) { ++ case RIC_FLUSH_PWC: + +- /* For PWC, only one flush is needed */ +- if (ric == RIC_FLUSH_PWC) { ++ /* For PWC, only one flush is needed */ ++ __tlbiel_pid(pid, 0, RIC_FLUSH_PWC); + ppc_after_tlbiel_barrier(); + return; ++ case RIC_FLUSH_TLB: ++ __tlbiel_pid(pid, 0, RIC_FLUSH_TLB); ++ break; ++ case RIC_FLUSH_ALL: ++ default: ++ /* ++ * Flush the first set of the TLB, and if ++ * we're doing a RIC_FLUSH_ALL, also flush ++ * the entire Page Walk Cache. ++ */ ++ __tlbiel_pid(pid, 0, RIC_FLUSH_ALL); + } + + if (!cpu_has_feature(CPU_FTR_ARCH_31)) { +@@ -1176,7 +1184,7 @@ void radix__tlb_flush(struct mmu_gather *tlb) + } + } + +-static __always_inline void __radix__flush_tlb_range_psize(struct mm_struct *mm, ++static void __radix__flush_tlb_range_psize(struct mm_struct *mm, + unsigned long start, unsigned long end, + int psize, bool also_pwc) + { +diff --git a/arch/powerpc/net/bpf_jit_comp64.c b/arch/powerpc/net/bpf_jit_comp64.c +index aaf1a887f653b..2657bf542985a 100644 +--- a/arch/powerpc/net/bpf_jit_comp64.c ++++ b/arch/powerpc/net/bpf_jit_comp64.c +@@ -686,7 +686,7 @@ emit_clear: + * BPF_STX ATOMIC (atomic ops) + */ + case BPF_STX | BPF_ATOMIC | BPF_W: +- if (insn->imm != BPF_ADD) { ++ if (imm != BPF_ADD) { + pr_err_ratelimited( + "eBPF filter atomic op code %02x (@%d) unsupported\n", + code, i); +@@ -708,7 +708,7 @@ emit_clear: + PPC_BCC_SHORT(COND_NE, tmp_idx); + break; + case BPF_STX | BPF_ATOMIC | BPF_DW: +- if (insn->imm != BPF_ADD) { ++ if (imm != BPF_ADD) { + pr_err_ratelimited( + "eBPF filter atomic op code %02x (@%d) unsupported\n", + code, i); +diff --git a/arch/powerpc/platforms/ps3/mm.c b/arch/powerpc/platforms/ps3/mm.c +index d094321964fb0..a81eac35d9009 100644 +--- a/arch/powerpc/platforms/ps3/mm.c ++++ b/arch/powerpc/platforms/ps3/mm.c +@@ -6,6 +6,7 @@ + * Copyright 2006 Sony Corp. + */ + ++#include + #include + #include + #include +@@ -1118,6 +1119,7 @@ int ps3_dma_region_init(struct ps3_system_bus_device *dev, + enum ps3_dma_region_type region_type, void *addr, unsigned long len) + { + unsigned long lpar_addr; ++ int result; + + lpar_addr = addr ? ps3_mm_phys_to_lpar(__pa(addr)) : 0; + +@@ -1129,6 +1131,16 @@ int ps3_dma_region_init(struct ps3_system_bus_device *dev, + r->offset -= map.r1.offset; + r->len = len ? len : ALIGN(map.total, 1 << r->page_size); + ++ dev->core.dma_mask = &r->dma_mask; ++ ++ result = dma_set_mask_and_coherent(&dev->core, DMA_BIT_MASK(32)); ++ ++ if (result < 0) { ++ dev_err(&dev->core, "%s:%d: dma_set_mask_and_coherent failed: %d\n", ++ __func__, __LINE__, result); ++ return result; ++ } ++ + switch (dev->dev_type) { + case PS3_DEVICE_TYPE_SB: + r->region_ops = (USE_DYNAMIC_DMA) +diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig +index 4fcd460f496ec..0cf31cb872e5e 100644 +--- a/arch/s390/Kconfig ++++ b/arch/s390/Kconfig +@@ -161,7 +161,6 @@ config S390 + select HAVE_GCC_PLUGINS + select HAVE_GENERIC_VDSO + select HAVE_IOREMAP_PROT if PCI +- select HAVE_IRQ_EXIT_ON_IRQ_STACK + select HAVE_KERNEL_BZIP2 + select HAVE_KERNEL_GZIP + select HAVE_KERNEL_LZ4 +diff --git a/arch/s390/Makefile b/arch/s390/Makefile +index e443ed9947bd6..098abe3a56f37 100644 +--- a/arch/s390/Makefile ++++ b/arch/s390/Makefile +@@ -28,6 +28,7 @@ KBUILD_CFLAGS_DECOMPRESSOR += -DDISABLE_BRANCH_PROFILING -D__NO_FORTIFY + KBUILD_CFLAGS_DECOMPRESSOR += -fno-delete-null-pointer-checks -msoft-float -mbackchain + KBUILD_CFLAGS_DECOMPRESSOR += -fno-asynchronous-unwind-tables + KBUILD_CFLAGS_DECOMPRESSOR += -ffreestanding ++KBUILD_CFLAGS_DECOMPRESSOR += -fno-stack-protector + KBUILD_CFLAGS_DECOMPRESSOR += $(call cc-disable-warning, address-of-packed-member) + KBUILD_CFLAGS_DECOMPRESSOR += $(if $(CONFIG_DEBUG_INFO),-g) + KBUILD_CFLAGS_DECOMPRESSOR += $(if $(CONFIG_DEBUG_INFO_DWARF4), $(call cc-option, -gdwarf-4,)) +diff --git a/arch/s390/boot/ipl_parm.c b/arch/s390/boot/ipl_parm.c +index d372a45fe10e7..dd92092e3eec3 100644 +--- a/arch/s390/boot/ipl_parm.c ++++ b/arch/s390/boot/ipl_parm.c +@@ -28,22 +28,25 @@ static inline int __diag308(unsigned long subcode, void *addr) + register unsigned long _addr asm("0") = (unsigned long)addr; + register unsigned long _rc asm("1") = 0; + unsigned long reg1, reg2; +- psw_t old = S390_lowcore.program_new_psw; ++ psw_t old; + + asm volatile( ++ " mvc 0(16,%[psw_old]),0(%[psw_pgm])\n" + " epsw %0,%1\n" +- " st %0,%[psw_pgm]\n" +- " st %1,%[psw_pgm]+4\n" ++ " st %0,0(%[psw_pgm])\n" ++ " st %1,4(%[psw_pgm])\n" + " larl %0,1f\n" +- " stg %0,%[psw_pgm]+8\n" ++ " stg %0,8(%[psw_pgm])\n" + " diag %[addr],%[subcode],0x308\n" +- "1: nopr %%r7\n" ++ "1: mvc 0(16,%[psw_pgm]),0(%[psw_old])\n" + : "=&d" (reg1), "=&a" (reg2), +- [psw_pgm] "=Q" (S390_lowcore.program_new_psw), ++ "+Q" (S390_lowcore.program_new_psw), ++ "=Q" (old), + [addr] "+d" (_addr), "+d" (_rc) +- : [subcode] "d" (subcode) ++ : [subcode] "d" (subcode), ++ [psw_old] "a" (&old), ++ [psw_pgm] "a" (&S390_lowcore.program_new_psw) + : "cc", "memory"); +- S390_lowcore.program_new_psw = old; + return _rc; + } + +diff --git a/arch/s390/boot/mem_detect.c b/arch/s390/boot/mem_detect.c +index 40168e59abd38..a0e980f57c02c 100644 +--- a/arch/s390/boot/mem_detect.c ++++ b/arch/s390/boot/mem_detect.c +@@ -69,24 +69,27 @@ static int __diag260(unsigned long rx1, unsigned long rx2) + register unsigned long _ry asm("4") = 0x10; /* storage configuration */ + int rc = -1; /* fail */ + unsigned long reg1, reg2; +- psw_t old = S390_lowcore.program_new_psw; ++ psw_t old; + + asm volatile( ++ " mvc 0(16,%[psw_old]),0(%[psw_pgm])\n" + " epsw %0,%1\n" +- " st %0,%[psw_pgm]\n" +- " st %1,%[psw_pgm]+4\n" ++ " st %0,0(%[psw_pgm])\n" ++ " st %1,4(%[psw_pgm])\n" + " larl %0,1f\n" +- " stg %0,%[psw_pgm]+8\n" ++ " stg %0,8(%[psw_pgm])\n" + " diag %[rx],%[ry],0x260\n" + " ipm %[rc]\n" + " srl %[rc],28\n" +- "1:\n" ++ "1: mvc 0(16,%[psw_pgm]),0(%[psw_old])\n" + : "=&d" (reg1), "=&a" (reg2), +- [psw_pgm] "=Q" (S390_lowcore.program_new_psw), ++ "+Q" (S390_lowcore.program_new_psw), ++ "=Q" (old), + [rc] "+&d" (rc), [ry] "+d" (_ry) +- : [rx] "d" (_rx1), "d" (_rx2) ++ : [rx] "d" (_rx1), "d" (_rx2), ++ [psw_old] "a" (&old), ++ [psw_pgm] "a" (&S390_lowcore.program_new_psw) + : "cc", "memory"); +- S390_lowcore.program_new_psw = old; + return rc == 0 ? _ry : -1; + } + +@@ -111,24 +114,30 @@ static int diag260(void) + + static int tprot(unsigned long addr) + { +- unsigned long pgm_addr; ++ unsigned long reg1, reg2; + int rc = -EFAULT; +- psw_t old = S390_lowcore.program_new_psw; ++ psw_t old; + +- S390_lowcore.program_new_psw.mask = __extract_psw(); + asm volatile( +- " larl %[pgm_addr],1f\n" +- " stg %[pgm_addr],%[psw_pgm_addr]\n" ++ " mvc 0(16,%[psw_old]),0(%[psw_pgm])\n" ++ " epsw %[reg1],%[reg2]\n" ++ " st %[reg1],0(%[psw_pgm])\n" ++ " st %[reg2],4(%[psw_pgm])\n" ++ " larl %[reg1],1f\n" ++ " stg %[reg1],8(%[psw_pgm])\n" + " tprot 0(%[addr]),0\n" + " ipm %[rc]\n" + " srl %[rc],28\n" +- "1:\n" +- : [pgm_addr] "=&d"(pgm_addr), +- [psw_pgm_addr] "=Q"(S390_lowcore.program_new_psw.addr), +- [rc] "+&d"(rc) +- : [addr] "a"(addr) ++ "1: mvc 0(16,%[psw_pgm]),0(%[psw_old])\n" ++ : [reg1] "=&d" (reg1), ++ [reg2] "=&a" (reg2), ++ [rc] "+&d" (rc), ++ "=Q" (S390_lowcore.program_new_psw.addr), ++ "=Q" (old) ++ : [psw_old] "a" (&old), ++ [psw_pgm] "a" (&S390_lowcore.program_new_psw), ++ [addr] "a" (addr) + : "cc", "memory"); +- S390_lowcore.program_new_psw = old; + return rc; + } + +diff --git a/arch/s390/include/asm/processor.h b/arch/s390/include/asm/processor.h +index 023a15dc25a33..dbd380d811335 100644 +--- a/arch/s390/include/asm/processor.h ++++ b/arch/s390/include/asm/processor.h +@@ -207,7 +207,7 @@ static __always_inline unsigned long current_stack_pointer(void) + return sp; + } + +-static __no_kasan_or_inline unsigned short stap(void) ++static __always_inline unsigned short stap(void) + { + unsigned short cpu_address; + +@@ -246,7 +246,7 @@ static inline void __load_psw(psw_t psw) + * Set PSW mask to specified value, while leaving the + * PSW addr pointing to the next instruction. + */ +-static __no_kasan_or_inline void __load_psw_mask(unsigned long mask) ++static __always_inline void __load_psw_mask(unsigned long mask) + { + unsigned long addr; + psw_t psw; +diff --git a/arch/s390/kernel/setup.c b/arch/s390/kernel/setup.c +index 382d73da134cf..93538e63fa03f 100644 +--- a/arch/s390/kernel/setup.c ++++ b/arch/s390/kernel/setup.c +@@ -165,7 +165,7 @@ static void __init set_preferred_console(void) + else if (CONSOLE_IS_3270) + add_preferred_console("tty3270", 0, NULL); + else if (CONSOLE_IS_VT220) +- add_preferred_console("ttyS", 1, NULL); ++ add_preferred_console("ttysclp", 0, NULL); + else if (CONSOLE_IS_HVC) + add_preferred_console("hvc", 0, NULL); + } +diff --git a/arch/s390/purgatory/Makefile b/arch/s390/purgatory/Makefile +index c57f8c40e9926..21c4ebe29b9a2 100644 +--- a/arch/s390/purgatory/Makefile ++++ b/arch/s390/purgatory/Makefile +@@ -24,6 +24,7 @@ KBUILD_CFLAGS := -fno-strict-aliasing -Wall -Wstrict-prototypes + KBUILD_CFLAGS += -Wno-pointer-sign -Wno-sign-compare + KBUILD_CFLAGS += -fno-zero-initialized-in-bss -fno-builtin -ffreestanding + KBUILD_CFLAGS += -c -MD -Os -m64 -msoft-float -fno-common ++KBUILD_CFLAGS += -fno-stack-protector + KBUILD_CFLAGS += $(CLANG_FLAGS) + KBUILD_CFLAGS += $(call cc-option,-fno-PIE) + KBUILD_AFLAGS := $(filter-out -DCC_USING_EXPOLINE,$(KBUILD_AFLAGS)) +diff --git a/arch/um/drivers/chan_user.c b/arch/um/drivers/chan_user.c +index d8845d4aac6a7..6040817c036f3 100644 +--- a/arch/um/drivers/chan_user.c ++++ b/arch/um/drivers/chan_user.c +@@ -256,7 +256,8 @@ static int winch_tramp(int fd, struct tty_port *port, int *fd_out, + goto out_close; + } + +- if (os_set_fd_block(*fd_out, 0)) { ++ err = os_set_fd_block(*fd_out, 0); ++ if (err) { + printk(UM_KERN_ERR "winch_tramp: failed to set thread_fd " + "non-blocking.\n"); + goto out_close; +diff --git a/arch/um/drivers/slip_user.c b/arch/um/drivers/slip_user.c +index 482a19c5105c5..7334019c9e60a 100644 +--- a/arch/um/drivers/slip_user.c ++++ b/arch/um/drivers/slip_user.c +@@ -145,7 +145,8 @@ static int slip_open(void *data) + } + sfd = err; + +- if (set_up_tty(sfd)) ++ err = set_up_tty(sfd); ++ if (err) + goto out_close2; + + pri->slave = sfd; +diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c +index 8e0b43cf089f4..cbd4f00fe77ee 100644 +--- a/arch/um/drivers/ubd_kern.c ++++ b/arch/um/drivers/ubd_kern.c +@@ -1242,8 +1242,7 @@ static int __init ubd_driver_init(void){ + * enough. So use anyway the io thread. */ + } + stack = alloc_stack(0, 0); +- io_pid = start_io_thread(stack + PAGE_SIZE - sizeof(void *), +- &thread_fd); ++ io_pid = start_io_thread(stack + PAGE_SIZE, &thread_fd); + if(io_pid < 0){ + printk(KERN_ERR + "ubd : Failed to start I/O thread (errno = %d) - " +diff --git a/arch/um/kernel/skas/clone.c b/arch/um/kernel/skas/clone.c +index 592cdb1384415..5afac0fef24ea 100644 +--- a/arch/um/kernel/skas/clone.c ++++ b/arch/um/kernel/skas/clone.c +@@ -29,7 +29,7 @@ stub_clone_handler(void) + long err; + + err = stub_syscall2(__NR_clone, CLONE_PARENT | CLONE_FILES | SIGCHLD, +- (unsigned long)data + UM_KERN_PAGE_SIZE / 2 - sizeof(void *)); ++ (unsigned long)data + UM_KERN_PAGE_SIZE / 2); + if (err) { + data->parent_err = err; + goto done; +diff --git a/arch/um/os-Linux/helper.c b/arch/um/os-Linux/helper.c +index 9fa6e4187d4fb..32e88baf18dd4 100644 +--- a/arch/um/os-Linux/helper.c ++++ b/arch/um/os-Linux/helper.c +@@ -64,7 +64,7 @@ int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv) + goto out_close; + } + +- sp = stack + UM_KERN_PAGE_SIZE - sizeof(void *); ++ sp = stack + UM_KERN_PAGE_SIZE; + data.pre_exec = pre_exec; + data.pre_data = pre_data; + data.argv = argv; +@@ -120,7 +120,7 @@ int run_helper_thread(int (*proc)(void *), void *arg, unsigned int flags, + if (stack == 0) + return -ENOMEM; + +- sp = stack + UM_KERN_PAGE_SIZE - sizeof(void *); ++ sp = stack + UM_KERN_PAGE_SIZE; + pid = clone(proc, (void *) sp, flags, arg); + if (pid < 0) { + err = -errno; +diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c +index 96f511d1aabe6..e283f130aadc5 100644 +--- a/arch/um/os-Linux/signal.c ++++ b/arch/um/os-Linux/signal.c +@@ -129,7 +129,7 @@ void set_sigstack(void *sig_stack, int size) + stack_t stack = { + .ss_flags = 0, + .ss_sp = sig_stack, +- .ss_size = size - sizeof(void *) ++ .ss_size = size + }; + + if (sigaltstack(&stack, NULL) != 0) +diff --git a/arch/um/os-Linux/skas/process.c b/arch/um/os-Linux/skas/process.c +index fba674fac8b73..87d3129e7362e 100644 +--- a/arch/um/os-Linux/skas/process.c ++++ b/arch/um/os-Linux/skas/process.c +@@ -327,7 +327,7 @@ int start_userspace(unsigned long stub_stack) + } + + /* set stack pointer to the end of the stack page, so it can grow downwards */ +- sp = (unsigned long) stack + UM_KERN_PAGE_SIZE - sizeof(void *); ++ sp = (unsigned long)stack + UM_KERN_PAGE_SIZE; + + flags = CLONE_FILES | SIGCHLD; + +diff --git a/arch/x86/include/asm/fpu/internal.h b/arch/x86/include/asm/fpu/internal.h +index 16bf4d4a8159e..4e5af2b00d89b 100644 +--- a/arch/x86/include/asm/fpu/internal.h ++++ b/arch/x86/include/asm/fpu/internal.h +@@ -103,6 +103,7 @@ static inline void fpstate_init_fxstate(struct fxregs_state *fx) + } + extern void fpstate_sanitize_xstate(struct fpu *fpu); + ++/* Returns 0 or the negated trap number, which results in -EFAULT for #PF */ + #define user_insn(insn, output, input...) \ + ({ \ + int err; \ +@@ -110,14 +111,14 @@ extern void fpstate_sanitize_xstate(struct fpu *fpu); + might_fault(); \ + \ + asm volatile(ASM_STAC "\n" \ +- "1:" #insn "\n\t" \ ++ "1: " #insn "\n" \ + "2: " ASM_CLAC "\n" \ + ".section .fixup,\"ax\"\n" \ +- "3: movl $-1,%[err]\n" \ ++ "3: negl %%eax\n" \ + " jmp 2b\n" \ + ".previous\n" \ +- _ASM_EXTABLE(1b, 3b) \ +- : [err] "=r" (err), output \ ++ _ASM_EXTABLE_FAULT(1b, 3b) \ ++ : [err] "=a" (err), output \ + : "0"(0), input); \ + err; \ + }) +@@ -219,16 +220,20 @@ static inline void fxsave(struct fxregs_state *fx) + #define XRSTOR ".byte " REX_PREFIX "0x0f,0xae,0x2f" + #define XRSTORS ".byte " REX_PREFIX "0x0f,0xc7,0x1f" + ++/* ++ * After this @err contains 0 on success or the negated trap number when ++ * the operation raises an exception. For faults this results in -EFAULT. ++ */ + #define XSTATE_OP(op, st, lmask, hmask, err) \ + asm volatile("1:" op "\n\t" \ + "xor %[err], %[err]\n" \ + "2:\n\t" \ + ".pushsection .fixup,\"ax\"\n\t" \ +- "3: movl $-2,%[err]\n\t" \ ++ "3: negl %%eax\n\t" \ + "jmp 2b\n\t" \ + ".popsection\n\t" \ +- _ASM_EXTABLE(1b, 3b) \ +- : [err] "=r" (err) \ ++ _ASM_EXTABLE_FAULT(1b, 3b) \ ++ : [err] "=a" (err) \ + : "D" (st), "m" (*st), "a" (lmask), "d" (hmask) \ + : "memory") + +diff --git a/arch/x86/kernel/fpu/regset.c b/arch/x86/kernel/fpu/regset.c +index c413756ba89fa..6bb874441de8b 100644 +--- a/arch/x86/kernel/fpu/regset.c ++++ b/arch/x86/kernel/fpu/regset.c +@@ -117,7 +117,7 @@ int xstateregs_set(struct task_struct *target, const struct user_regset *regset, + /* + * A whole standard-format XSAVE buffer is needed: + */ +- if ((pos != 0) || (count < fpu_user_xstate_size)) ++ if (pos != 0 || count != fpu_user_xstate_size) + return -EFAULT; + + xsave = &fpu->state.xsave; +diff --git a/arch/x86/kernel/fpu/xstate.c b/arch/x86/kernel/fpu/xstate.c +index 451435d7ff413..038a119114c4f 100644 +--- a/arch/x86/kernel/fpu/xstate.c ++++ b/arch/x86/kernel/fpu/xstate.c +@@ -1084,20 +1084,10 @@ static inline bool xfeatures_mxcsr_quirk(u64 xfeatures) + return true; + } + +-static void fill_gap(struct membuf *to, unsigned *last, unsigned offset) ++static void copy_feature(bool from_xstate, struct membuf *to, void *xstate, ++ void *init_xstate, unsigned int size) + { +- if (*last >= offset) +- return; +- membuf_write(to, (void *)&init_fpstate.xsave + *last, offset - *last); +- *last = offset; +-} +- +-static void copy_part(struct membuf *to, unsigned *last, unsigned offset, +- unsigned size, void *from) +-{ +- fill_gap(to, last, offset); +- membuf_write(to, from, size); +- *last = offset + size; ++ membuf_write(to, from_xstate ? xstate : init_xstate, size); + } + + /* +@@ -1109,10 +1099,10 @@ static void copy_part(struct membuf *to, unsigned *last, unsigned offset, + */ + void copy_xstate_to_kernel(struct membuf to, struct xregs_state *xsave) + { ++ const unsigned int off_mxcsr = offsetof(struct fxregs_state, mxcsr); ++ struct xregs_state *xinit = &init_fpstate.xsave; + struct xstate_header header; +- const unsigned off_mxcsr = offsetof(struct fxregs_state, mxcsr); +- unsigned size = to.left; +- unsigned last = 0; ++ unsigned int zerofrom; + int i; + + /* +@@ -1122,41 +1112,68 @@ void copy_xstate_to_kernel(struct membuf to, struct xregs_state *xsave) + header.xfeatures = xsave->header.xfeatures; + header.xfeatures &= xfeatures_mask_user(); + +- if (header.xfeatures & XFEATURE_MASK_FP) +- copy_part(&to, &last, 0, off_mxcsr, &xsave->i387); +- if (header.xfeatures & (XFEATURE_MASK_SSE | XFEATURE_MASK_YMM)) +- copy_part(&to, &last, off_mxcsr, +- MXCSR_AND_FLAGS_SIZE, &xsave->i387.mxcsr); +- if (header.xfeatures & XFEATURE_MASK_FP) +- copy_part(&to, &last, offsetof(struct fxregs_state, st_space), +- 128, &xsave->i387.st_space); +- if (header.xfeatures & XFEATURE_MASK_SSE) +- copy_part(&to, &last, xstate_offsets[XFEATURE_SSE], +- 256, &xsave->i387.xmm_space); +- /* +- * Fill xsave->i387.sw_reserved value for ptrace frame: +- */ +- copy_part(&to, &last, offsetof(struct fxregs_state, sw_reserved), +- 48, xstate_fx_sw_bytes); +- /* +- * Copy xregs_state->header: +- */ +- copy_part(&to, &last, offsetof(struct xregs_state, header), +- sizeof(header), &header); ++ /* Copy FP state up to MXCSR */ ++ copy_feature(header.xfeatures & XFEATURE_MASK_FP, &to, &xsave->i387, ++ &xinit->i387, off_mxcsr); ++ ++ /* Copy MXCSR when SSE or YMM are set in the feature mask */ ++ copy_feature(header.xfeatures & (XFEATURE_MASK_SSE | XFEATURE_MASK_YMM), ++ &to, &xsave->i387.mxcsr, &xinit->i387.mxcsr, ++ MXCSR_AND_FLAGS_SIZE); ++ ++ /* Copy the remaining FP state */ ++ copy_feature(header.xfeatures & XFEATURE_MASK_FP, ++ &to, &xsave->i387.st_space, &xinit->i387.st_space, ++ sizeof(xsave->i387.st_space)); ++ ++ /* Copy the SSE state - shared with YMM, but independently managed */ ++ copy_feature(header.xfeatures & XFEATURE_MASK_SSE, ++ &to, &xsave->i387.xmm_space, &xinit->i387.xmm_space, ++ sizeof(xsave->i387.xmm_space)); ++ ++ /* Zero the padding area */ ++ membuf_zero(&to, sizeof(xsave->i387.padding)); ++ ++ /* Copy xsave->i387.sw_reserved */ ++ membuf_write(&to, xstate_fx_sw_bytes, sizeof(xsave->i387.sw_reserved)); ++ ++ /* Copy the user space relevant state of @xsave->header */ ++ membuf_write(&to, &header, sizeof(header)); ++ ++ zerofrom = offsetof(struct xregs_state, extended_state_area); + + for (i = FIRST_EXTENDED_XFEATURE; i < XFEATURE_MAX; i++) { + /* +- * Copy only in-use xstates: ++ * The ptrace buffer is in non-compacted XSAVE format. ++ * In non-compacted format disabled features still occupy ++ * state space, but there is no state to copy from in the ++ * compacted init_fpstate. The gap tracking will zero this ++ * later. + */ +- if ((header.xfeatures >> i) & 1) { +- void *src = __raw_xsave_addr(xsave, i); ++ if (!(xfeatures_mask_user() & BIT_ULL(i))) ++ continue; + +- copy_part(&to, &last, xstate_offsets[i], +- xstate_sizes[i], src); +- } ++ /* ++ * If there was a feature or alignment gap, zero the space ++ * in the destination buffer. ++ */ ++ if (zerofrom < xstate_offsets[i]) ++ membuf_zero(&to, xstate_offsets[i] - zerofrom); ++ ++ copy_feature(header.xfeatures & BIT_ULL(i), &to, ++ __raw_xsave_addr(xsave, i), ++ __raw_xsave_addr(xinit, i), ++ xstate_sizes[i]); + ++ /* ++ * Keep track of the last copied state in the non-compacted ++ * target buffer for gap zeroing. ++ */ ++ zerofrom = xstate_offsets[i] + xstate_sizes[i]; + } +- fill_gap(&to, &last, size); ++ ++ if (to.left) ++ membuf_zero(&to, to.left); + } + + /* +diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c +index f306e85a08a64..6f4e261071e0d 100644 +--- a/arch/x86/kernel/signal.c ++++ b/arch/x86/kernel/signal.c +@@ -234,10 +234,11 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, + void __user **fpstate) + { + /* Default to using normal stack */ ++ bool nested_altstack = on_sig_stack(regs->sp); ++ bool entering_altstack = false; + unsigned long math_size = 0; + unsigned long sp = regs->sp; + unsigned long buf_fx = 0; +- int onsigstack = on_sig_stack(sp); + int ret; + + /* redzone */ +@@ -246,15 +247,23 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, + + /* This is the X/Open sanctioned signal stack switching. */ + if (ka->sa.sa_flags & SA_ONSTACK) { +- if (sas_ss_flags(sp) == 0) ++ /* ++ * This checks nested_altstack via sas_ss_flags(). Sensible ++ * programs use SS_AUTODISARM, which disables that check, and ++ * programs that don't use SS_AUTODISARM get compatible. ++ */ ++ if (sas_ss_flags(sp) == 0) { + sp = current->sas_ss_sp + current->sas_ss_size; ++ entering_altstack = true; ++ } + } else if (IS_ENABLED(CONFIG_X86_32) && +- !onsigstack && ++ !nested_altstack && + regs->ss != __USER_DS && + !(ka->sa.sa_flags & SA_RESTORER) && + ka->sa.sa_restorer) { + /* This is the legacy signal stack switching. */ + sp = (unsigned long) ka->sa.sa_restorer; ++ entering_altstack = true; + } + + sp = fpu__alloc_mathframe(sp, IS_ENABLED(CONFIG_X86_32), +@@ -267,8 +276,15 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, + * If we are on the alternate signal stack and would overflow it, don't. + * Return an always-bogus address instead so we will die with SIGSEGV. + */ +- if (onsigstack && !likely(on_sig_stack(sp))) ++ if (unlikely((nested_altstack || entering_altstack) && ++ !__on_sig_stack(sp))) { ++ ++ if (show_unhandled_signals && printk_ratelimit()) ++ pr_info("%s[%d] overflowed sigaltstack\n", ++ current->comm, task_pid_nr(current)); ++ + return (void __user *)-1L; ++ } + + /* save i387 and extended state */ + ret = copy_fpstate_to_sigframe(*fpstate, (void __user *)buf_fx, math_size); +diff --git a/arch/x86/kvm/cpuid.c b/arch/x86/kvm/cpuid.c +index 0ed116b8c211d..40d479a59f6c2 100644 +--- a/arch/x86/kvm/cpuid.c ++++ b/arch/x86/kvm/cpuid.c +@@ -844,8 +844,14 @@ static inline int __do_cpuid_func(struct kvm_cpuid_array *array, u32 function) + unsigned virt_as = max((entry->eax >> 8) & 0xff, 48U); + unsigned phys_as = entry->eax & 0xff; + +- if (!g_phys_as) ++ /* ++ * Use bare metal's MAXPHADDR if the CPU doesn't report guest ++ * MAXPHYADDR separately, or if TDP (NPT) is disabled, as the ++ * guest version "applies only to guests using nested paging". ++ */ ++ if (!g_phys_as || !tdp_enabled) + g_phys_as = phys_as; ++ + entry->eax = g_phys_as | (virt_as << 8); + entry->edx = 0; + cpuid_entry_override(entry, CPUID_8000_0008_EBX); +diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c +index 7ffeeb6880d93..cd7c8bae79ed1 100644 +--- a/arch/x86/kvm/mmu/mmu.c ++++ b/arch/x86/kvm/mmu/mmu.c +@@ -52,6 +52,8 @@ + #include + #include "trace.h" + ++#include "paging.h" ++ + extern bool itlb_multihit_kvm_mitigation; + + static int __read_mostly nx_huge_pages = -1; +diff --git a/arch/x86/kvm/mmu/paging.h b/arch/x86/kvm/mmu/paging.h +new file mode 100644 +index 0000000000000..de8ab323bb707 +--- /dev/null ++++ b/arch/x86/kvm/mmu/paging.h +@@ -0,0 +1,14 @@ ++/* SPDX-License-Identifier: GPL-2.0-only */ ++/* Shadow paging constants/helpers that don't need to be #undef'd. */ ++#ifndef __KVM_X86_PAGING_H ++#define __KVM_X86_PAGING_H ++ ++#define GUEST_PT64_BASE_ADDR_MASK (((1ULL << 52) - 1) & ~(u64)(PAGE_SIZE-1)) ++#define PT64_LVL_ADDR_MASK(level) \ ++ (GUEST_PT64_BASE_ADDR_MASK & ~((1ULL << (PAGE_SHIFT + (((level) - 1) \ ++ * PT64_LEVEL_BITS))) - 1)) ++#define PT64_LVL_OFFSET_MASK(level) \ ++ (GUEST_PT64_BASE_ADDR_MASK & ((1ULL << (PAGE_SHIFT + (((level) - 1) \ ++ * PT64_LEVEL_BITS))) - 1)) ++#endif /* __KVM_X86_PAGING_H */ ++ +diff --git a/arch/x86/kvm/mmu/paging_tmpl.h b/arch/x86/kvm/mmu/paging_tmpl.h +index de6407610b19a..db8c3188aae03 100644 +--- a/arch/x86/kvm/mmu/paging_tmpl.h ++++ b/arch/x86/kvm/mmu/paging_tmpl.h +@@ -24,7 +24,7 @@ + #define pt_element_t u64 + #define guest_walker guest_walker64 + #define FNAME(name) paging##64_##name +- #define PT_BASE_ADDR_MASK PT64_BASE_ADDR_MASK ++ #define PT_BASE_ADDR_MASK GUEST_PT64_BASE_ADDR_MASK + #define PT_LVL_ADDR_MASK(lvl) PT64_LVL_ADDR_MASK(lvl) + #define PT_LVL_OFFSET_MASK(lvl) PT64_LVL_OFFSET_MASK(lvl) + #define PT_INDEX(addr, level) PT64_INDEX(addr, level) +@@ -57,7 +57,7 @@ + #define pt_element_t u64 + #define guest_walker guest_walkerEPT + #define FNAME(name) ept_##name +- #define PT_BASE_ADDR_MASK PT64_BASE_ADDR_MASK ++ #define PT_BASE_ADDR_MASK GUEST_PT64_BASE_ADDR_MASK + #define PT_LVL_ADDR_MASK(lvl) PT64_LVL_ADDR_MASK(lvl) + #define PT_LVL_OFFSET_MASK(lvl) PT64_LVL_OFFSET_MASK(lvl) + #define PT_INDEX(addr, level) PT64_INDEX(addr, level) +diff --git a/arch/x86/kvm/mmu/spte.h b/arch/x86/kvm/mmu/spte.h +index 6de3950fd704f..8a8e47bbf8040 100644 +--- a/arch/x86/kvm/mmu/spte.h ++++ b/arch/x86/kvm/mmu/spte.h +@@ -23,12 +23,6 @@ + #else + #define PT64_BASE_ADDR_MASK (((1ULL << 52) - 1) & ~(u64)(PAGE_SIZE-1)) + #endif +-#define PT64_LVL_ADDR_MASK(level) \ +- (PT64_BASE_ADDR_MASK & ~((1ULL << (PAGE_SHIFT + (((level) - 1) \ +- * PT64_LEVEL_BITS))) - 1)) +-#define PT64_LVL_OFFSET_MASK(level) \ +- (PT64_BASE_ADDR_MASK & ((1ULL << (PAGE_SHIFT + (((level) - 1) \ +- * PT64_LEVEL_BITS))) - 1)) + + #define PT64_PERM_MASK (PT_PRESENT_MASK | PT_WRITABLE_MASK | shadow_user_mask \ + | shadow_x_mask | shadow_nx_mask | shadow_me_mask) +diff --git a/arch/x86/kvm/svm/svm.c b/arch/x86/kvm/svm/svm.c +index 30569bbbca9ac..f262edf7551b3 100644 +--- a/arch/x86/kvm/svm/svm.c ++++ b/arch/x86/kvm/svm/svm.c +@@ -2982,7 +2982,16 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr) + svm_disable_lbrv(vcpu); + break; + case MSR_VM_HSAVE_PA: +- svm->nested.hsave_msr = data; ++ /* ++ * Old kernels did not validate the value written to ++ * MSR_VM_HSAVE_PA. Allow KVM_SET_MSR to set an invalid ++ * value to allow live migrating buggy or malicious guests ++ * originating from those kernels. ++ */ ++ if (!msr->host_initiated && !page_address_valid(vcpu, data)) ++ return 1; ++ ++ svm->nested.hsave_msr = data & PAGE_MASK; + break; + case MSR_VM_CR: + return svm_set_vm_cr(vcpu, data); +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index 615dd236e8429..78b3a18d24e07 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -9194,6 +9194,8 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu) + set_debugreg(vcpu->arch.eff_db[3], 3); + set_debugreg(vcpu->arch.dr6, 6); + vcpu->arch.switch_db_regs &= ~KVM_DEBUGREG_RELOAD; ++ } else if (unlikely(hw_breakpoint_active())) { ++ set_debugreg(0, 7); + } + + for (;;) { +diff --git a/block/blk-core.c b/block/blk-core.c +index fc60ff2084973..e34dfa13b7bcd 100644 +--- a/block/blk-core.c ++++ b/block/blk-core.c +@@ -1255,7 +1255,7 @@ static void update_io_ticks(struct block_device *part, unsigned long now, + unsigned long stamp; + again: + stamp = READ_ONCE(part->bd_stamp); +- if (unlikely(stamp != now)) { ++ if (unlikely(time_after(now, stamp))) { + if (likely(cmpxchg(&part->bd_stamp, stamp, now) == stamp)) + __part_stat_add(part, io_ticks, end ? now - stamp : 1); + } +diff --git a/block/partitions/ldm.c b/block/partitions/ldm.c +index d333786b5c7eb..cc86534c80ad9 100644 +--- a/block/partitions/ldm.c ++++ b/block/partitions/ldm.c +@@ -510,7 +510,7 @@ static bool ldm_validate_partition_table(struct parsed_partitions *state) + + p = (struct msdos_partition *)(data + 0x01BE); + for (i = 0; i < 4; i++, p++) +- if (SYS_IND (p) == LDM_PARTITION) { ++ if (p->sys_ind == LDM_PARTITION) { + result = true; + break; + } +diff --git a/block/partitions/ldm.h b/block/partitions/ldm.h +index d8d6beaa72c4d..8693704dcf5e9 100644 +--- a/block/partitions/ldm.h ++++ b/block/partitions/ldm.h +@@ -84,9 +84,6 @@ struct parsed_partitions; + #define TOC_BITMAP1 "config" /* Names of the two defined */ + #define TOC_BITMAP2 "log" /* bitmaps in the TOCBLOCK. */ + +-/* Borrowed from msdos.c */ +-#define SYS_IND(p) (get_unaligned(&(p)->sys_ind)) +- + struct frag { /* VBLK Fragment handling */ + struct list_head list; + u32 group; +diff --git a/block/partitions/msdos.c b/block/partitions/msdos.c +index 8f2fcc0802642..c94de377c5025 100644 +--- a/block/partitions/msdos.c ++++ b/block/partitions/msdos.c +@@ -38,8 +38,6 @@ + */ + #include + +-#define SYS_IND(p) get_unaligned(&p->sys_ind) +- + static inline sector_t nr_sects(struct msdos_partition *p) + { + return (sector_t)get_unaligned_le32(&p->nr_sects); +@@ -52,9 +50,9 @@ static inline sector_t start_sect(struct msdos_partition *p) + + static inline int is_extended_partition(struct msdos_partition *p) + { +- return (SYS_IND(p) == DOS_EXTENDED_PARTITION || +- SYS_IND(p) == WIN98_EXTENDED_PARTITION || +- SYS_IND(p) == LINUX_EXTENDED_PARTITION); ++ return (p->sys_ind == DOS_EXTENDED_PARTITION || ++ p->sys_ind == WIN98_EXTENDED_PARTITION || ++ p->sys_ind == LINUX_EXTENDED_PARTITION); + } + + #define MSDOS_LABEL_MAGIC1 0x55 +@@ -193,7 +191,7 @@ static void parse_extended(struct parsed_partitions *state, + + put_partition(state, state->next, next, size); + set_info(state, state->next, disksig); +- if (SYS_IND(p) == LINUX_RAID_PARTITION) ++ if (p->sys_ind == LINUX_RAID_PARTITION) + state->parts[state->next].flags = ADDPART_FLAG_RAID; + loopct = 0; + if (++state->next == state->limit) +@@ -546,7 +544,7 @@ static void parse_minix(struct parsed_partitions *state, + * a secondary MBR describing its subpartitions, or + * the normal boot sector. */ + if (msdos_magic_present(data + 510) && +- SYS_IND(p) == MINIX_PARTITION) { /* subpartition table present */ ++ p->sys_ind == MINIX_PARTITION) { /* subpartition table present */ + char tmp[1 + BDEVNAME_SIZE + 10 + 9 + 1]; + + snprintf(tmp, sizeof(tmp), " %s%d: name, origin); +@@ -555,7 +553,7 @@ static void parse_minix(struct parsed_partitions *state, + if (state->next == state->limit) + break; + /* add each partition in use */ +- if (SYS_IND(p) == MINIX_PARTITION) ++ if (p->sys_ind == MINIX_PARTITION) + put_partition(state, state->next++, + start_sect(p), nr_sects(p)); + } +@@ -643,7 +641,7 @@ int msdos_partition(struct parsed_partitions *state) + p = (struct msdos_partition *) (data + 0x1be); + for (slot = 1 ; slot <= 4 ; slot++, p++) { + /* If this is an EFI GPT disk, msdos should ignore it. */ +- if (SYS_IND(p) == EFI_PMBR_OSTYPE_EFI_GPT) { ++ if (p->sys_ind == EFI_PMBR_OSTYPE_EFI_GPT) { + put_dev_sector(sect); + return 0; + } +@@ -685,11 +683,11 @@ int msdos_partition(struct parsed_partitions *state) + } + put_partition(state, slot, start, size); + set_info(state, slot, disksig); +- if (SYS_IND(p) == LINUX_RAID_PARTITION) ++ if (p->sys_ind == LINUX_RAID_PARTITION) + state->parts[slot].flags = ADDPART_FLAG_RAID; +- if (SYS_IND(p) == DM6_PARTITION) ++ if (p->sys_ind == DM6_PARTITION) + strlcat(state->pp_buf, "[DM]", PAGE_SIZE); +- if (SYS_IND(p) == EZD_PARTITION) ++ if (p->sys_ind == EZD_PARTITION) + strlcat(state->pp_buf, "[EZD]", PAGE_SIZE); + } + +@@ -698,7 +696,7 @@ int msdos_partition(struct parsed_partitions *state) + /* second pass - output for each on a separate line */ + p = (struct msdos_partition *) (0x1be + data); + for (slot = 1 ; slot <= 4 ; slot++, p++) { +- unsigned char id = SYS_IND(p); ++ unsigned char id = p->sys_ind; + int n; + + if (!nr_sects(p)) +diff --git a/certs/.gitignore b/certs/.gitignore +index 2a24839906863..6cbd1f1a5837b 100644 +--- a/certs/.gitignore ++++ b/certs/.gitignore +@@ -1,2 +1,3 @@ + # SPDX-License-Identifier: GPL-2.0-only + x509_certificate_list ++x509_revocation_list +diff --git a/drivers/acpi/acpi_amba.c b/drivers/acpi/acpi_amba.c +index 49b781a9cd979..ab8a4e0191b19 100644 +--- a/drivers/acpi/acpi_amba.c ++++ b/drivers/acpi/acpi_amba.c +@@ -76,6 +76,7 @@ static int amba_handler_attach(struct acpi_device *adev, + case IORESOURCE_MEM: + if (!address_found) { + dev->res = *rentry->res; ++ dev->res.name = dev_name(&dev->dev); + address_found = true; + } + break; +diff --git a/drivers/acpi/acpi_video.c b/drivers/acpi/acpi_video.c +index 2ea1781290ccf..1b68d116d808c 100644 +--- a/drivers/acpi/acpi_video.c ++++ b/drivers/acpi/acpi_video.c +@@ -540,6 +540,15 @@ static const struct dmi_system_id video_dmi_table[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V131"), + }, + }, ++ { ++ .callback = video_set_report_key_events, ++ .driver_data = (void *)((uintptr_t)REPORT_BRIGHTNESS_KEY_EVENTS), ++ .ident = "Dell Vostro 3350", ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), ++ DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 3350"), ++ }, ++ }, + /* + * Some machines change the brightness themselves when a brightness + * hotkey gets pressed, despite us telling them not to. In this case +diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c +index b9fa3ef5b57c0..425bae6181319 100644 +--- a/drivers/block/virtio_blk.c ++++ b/drivers/block/virtio_blk.c +@@ -948,6 +948,8 @@ static int virtblk_freeze(struct virtio_device *vdev) + blk_mq_quiesce_queue(vblk->disk->queue); + + vdev->config->del_vqs(vdev); ++ kfree(vblk->vqs); ++ + return 0; + } + +diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c +index 1836cc56e357b..673522874cec4 100644 +--- a/drivers/char/virtio_console.c ++++ b/drivers/char/virtio_console.c +@@ -475,7 +475,7 @@ static struct port_buffer *get_inbuf(struct port *port) + + buf = virtqueue_get_buf(port->in_vq, &len); + if (buf) { +- buf->len = len; ++ buf->len = min_t(size_t, len, buf->size); + buf->offset = 0; + port->stats.bytes_received += len; + } +@@ -1712,7 +1712,7 @@ static void control_work_handler(struct work_struct *work) + while ((buf = virtqueue_get_buf(vq, &len))) { + spin_unlock(&portdev->c_ivq_lock); + +- buf->len = len; ++ buf->len = min_t(size_t, len, buf->size); + buf->offset = 0; + + handle_control_message(vq->vdev, portdev, buf); +diff --git a/drivers/cpufreq/cppc_cpufreq.c b/drivers/cpufreq/cppc_cpufreq.c +index 8a482c434ea6a..9ff81e2603127 100644 +--- a/drivers/cpufreq/cppc_cpufreq.c ++++ b/drivers/cpufreq/cppc_cpufreq.c +@@ -182,6 +182,16 @@ static int cppc_verify_policy(struct cpufreq_policy_data *policy) + return 0; + } + ++static void cppc_cpufreq_put_cpu_data(struct cpufreq_policy *policy) ++{ ++ struct cppc_cpudata *cpu_data = policy->driver_data; ++ ++ list_del(&cpu_data->node); ++ free_cpumask_var(cpu_data->shared_cpu_map); ++ kfree(cpu_data); ++ policy->driver_data = NULL; ++} ++ + static void cppc_cpufreq_stop_cpu(struct cpufreq_policy *policy) + { + struct cppc_cpudata *cpu_data = policy->driver_data; +@@ -196,11 +206,7 @@ static void cppc_cpufreq_stop_cpu(struct cpufreq_policy *policy) + pr_debug("Err setting perf value:%d on CPU:%d. ret:%d\n", + caps->lowest_perf, cpu, ret); + +- /* Remove CPU node from list and free driver data for policy */ +- free_cpumask_var(cpu_data->shared_cpu_map); +- list_del(&cpu_data->node); +- kfree(policy->driver_data); +- policy->driver_data = NULL; ++ cppc_cpufreq_put_cpu_data(policy); + } + + /* +@@ -340,7 +346,8 @@ static int cppc_cpufreq_cpu_init(struct cpufreq_policy *policy) + default: + pr_debug("Unsupported CPU co-ord type: %d\n", + policy->shared_type); +- return -EFAULT; ++ ret = -EFAULT; ++ goto out; + } + + /* +@@ -355,10 +362,16 @@ static int cppc_cpufreq_cpu_init(struct cpufreq_policy *policy) + cpu_data->perf_ctrls.desired_perf = caps->highest_perf; + + ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls); +- if (ret) ++ if (ret) { + pr_debug("Err setting perf value:%d on CPU:%d. ret:%d\n", + caps->highest_perf, cpu, ret); ++ goto out; ++ } + ++ return 0; ++ ++out: ++ cppc_cpufreq_put_cpu_data(policy); + return ret; + } + +diff --git a/drivers/dma/fsl-qdma.c b/drivers/dma/fsl-qdma.c +index ed2ab46b15e7f..045ead46ec8fc 100644 +--- a/drivers/dma/fsl-qdma.c ++++ b/drivers/dma/fsl-qdma.c +@@ -1235,7 +1235,11 @@ static int fsl_qdma_probe(struct platform_device *pdev) + fsl_qdma->dma_dev.device_synchronize = fsl_qdma_synchronize; + fsl_qdma->dma_dev.device_terminate_all = fsl_qdma_terminate_all; + +- dma_set_mask(&pdev->dev, DMA_BIT_MASK(40)); ++ ret = dma_set_mask(&pdev->dev, DMA_BIT_MASK(40)); ++ if (ret) { ++ dev_err(&pdev->dev, "dma_set_mask failure.\n"); ++ return ret; ++ } + + platform_set_drvdata(pdev, fsl_qdma); + +diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig +index 9b21e45debc22..8c825242d6572 100644 +--- a/drivers/edac/Kconfig ++++ b/drivers/edac/Kconfig +@@ -271,7 +271,7 @@ config EDAC_PND2 + config EDAC_IGEN6 + tristate "Intel client SoC Integrated MC" + depends on PCI && PCI_MMCONFIG && ARCH_HAVE_NMI_SAFE_CMPXCHG +- depends on X64_64 && X86_MCE_INTEL ++ depends on X86_64 && X86_MCE_INTEL + help + Support for error detection and correction on the Intel + client SoC Integrated Memory Controller using In-Band ECC IP. +diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c +index cacdf1589b101..9485e0f1f05fb 100644 +--- a/drivers/firmware/arm_scmi/driver.c ++++ b/drivers/firmware/arm_scmi/driver.c +@@ -268,6 +268,10 @@ static void scmi_handle_response(struct scmi_chan_info *cinfo, + return; + } + ++ /* rx.len could be shrunk in the sync do_xfer, so reset to maxsz */ ++ if (msg_type == MSG_TYPE_DELAYED_RESP) ++ xfer->rx.len = info->desc->max_msg_size; ++ + scmi_dump_header_dbg(dev, &xfer->hdr); + + info->desc->ops->fetch_response(cinfo, xfer); +diff --git a/drivers/firmware/tegra/bpmp-tegra210.c b/drivers/firmware/tegra/bpmp-tegra210.c +index ae15940a078e3..c32754055c60b 100644 +--- a/drivers/firmware/tegra/bpmp-tegra210.c ++++ b/drivers/firmware/tegra/bpmp-tegra210.c +@@ -210,7 +210,7 @@ static int tegra210_bpmp_init(struct tegra_bpmp *bpmp) + priv->tx_irq_data = irq_get_irq_data(err); + if (!priv->tx_irq_data) { + dev_err(&pdev->dev, "failed to get IRQ data for TX IRQ\n"); +- return err; ++ return -ENOENT; + } + + err = platform_get_irq_byname(pdev, "rx"); +diff --git a/drivers/firmware/turris-mox-rwtm.c b/drivers/firmware/turris-mox-rwtm.c +index 62f0d1a5dd324..1cf4f10874923 100644 +--- a/drivers/firmware/turris-mox-rwtm.c ++++ b/drivers/firmware/turris-mox-rwtm.c +@@ -147,11 +147,14 @@ MOX_ATTR_RO(pubkey, "%s\n", pubkey); + + static int mox_get_status(enum mbox_cmd cmd, u32 retval) + { +- if (MBOX_STS_CMD(retval) != cmd || +- MBOX_STS_ERROR(retval) != MBOX_STS_SUCCESS) ++ if (MBOX_STS_CMD(retval) != cmd) + return -EIO; + else if (MBOX_STS_ERROR(retval) == MBOX_STS_FAIL) + return -(int)MBOX_STS_VALUE(retval); ++ else if (MBOX_STS_ERROR(retval) == MBOX_STS_BADCMD) ++ return -ENOSYS; ++ else if (MBOX_STS_ERROR(retval) != MBOX_STS_SUCCESS) ++ return -EIO; + else + return MBOX_STS_VALUE(retval); + } +@@ -201,11 +204,14 @@ static int mox_get_board_info(struct mox_rwtm *rwtm) + return ret; + + ret = mox_get_status(MBOX_CMD_BOARD_INFO, reply->retval); +- if (ret < 0 && ret != -ENODATA) { +- return ret; +- } else if (ret == -ENODATA) { ++ if (ret == -ENODATA) { + dev_warn(rwtm->dev, + "Board does not have manufacturing information burned!\n"); ++ } else if (ret == -ENOSYS) { ++ dev_notice(rwtm->dev, ++ "Firmware does not support the BOARD_INFO command\n"); ++ } else if (ret < 0) { ++ return ret; + } else { + rwtm->serial_number = reply->status[1]; + rwtm->serial_number <<= 32; +@@ -234,10 +240,13 @@ static int mox_get_board_info(struct mox_rwtm *rwtm) + return ret; + + ret = mox_get_status(MBOX_CMD_ECDSA_PUB_KEY, reply->retval); +- if (ret < 0 && ret != -ENODATA) { +- return ret; +- } else if (ret == -ENODATA) { ++ if (ret == -ENODATA) { + dev_warn(rwtm->dev, "Board has no public key burned!\n"); ++ } else if (ret == -ENOSYS) { ++ dev_notice(rwtm->dev, ++ "Firmware does not support the ECDSA_PUB_KEY command\n"); ++ } else if (ret < 0) { ++ return ret; + } else { + u32 *s = reply->status; + +@@ -251,6 +260,27 @@ static int mox_get_board_info(struct mox_rwtm *rwtm) + return 0; + } + ++static int check_get_random_support(struct mox_rwtm *rwtm) ++{ ++ struct armada_37xx_rwtm_tx_msg msg; ++ int ret; ++ ++ msg.command = MBOX_CMD_GET_RANDOM; ++ msg.args[0] = 1; ++ msg.args[1] = rwtm->buf_phys; ++ msg.args[2] = 4; ++ ++ ret = mbox_send_message(rwtm->mbox, &msg); ++ if (ret < 0) ++ return ret; ++ ++ ret = wait_for_completion_timeout(&rwtm->cmd_done, HZ / 2); ++ if (ret < 0) ++ return ret; ++ ++ return mox_get_status(MBOX_CMD_GET_RANDOM, rwtm->reply.retval); ++} ++ + static int mox_hwrng_read(struct hwrng *rng, void *data, size_t max, bool wait) + { + struct mox_rwtm *rwtm = (struct mox_rwtm *) rng->priv; +@@ -488,6 +518,13 @@ static int turris_mox_rwtm_probe(struct platform_device *pdev) + if (ret < 0) + dev_warn(dev, "Cannot read board information: %i\n", ret); + ++ ret = check_get_random_support(rwtm); ++ if (ret < 0) { ++ dev_notice(dev, ++ "Firmware does not support the GET_RANDOM command\n"); ++ goto free_channel; ++ } ++ + rwtm->hwrng.name = DRIVER_NAME "_hwrng"; + rwtm->hwrng.read = mox_hwrng_read; + rwtm->hwrng.priv = (unsigned long) rwtm; +@@ -505,6 +542,8 @@ static int turris_mox_rwtm_probe(struct platform_device *pdev) + goto free_channel; + } + ++ dev_info(dev, "HWRNG successfully registered\n"); ++ + return 0; + + free_channel: +diff --git a/drivers/fsi/fsi-master-aspeed.c b/drivers/fsi/fsi-master-aspeed.c +index 90dbe58ca1edc..dbad73162c833 100644 +--- a/drivers/fsi/fsi-master-aspeed.c ++++ b/drivers/fsi/fsi-master-aspeed.c +@@ -645,6 +645,7 @@ static const struct of_device_id fsi_master_aspeed_match[] = { + { .compatible = "aspeed,ast2600-fsi-master" }, + { }, + }; ++MODULE_DEVICE_TABLE(of, fsi_master_aspeed_match); + + static struct platform_driver fsi_master_aspeed_driver = { + .driver = { +diff --git a/drivers/fsi/fsi-master-ast-cf.c b/drivers/fsi/fsi-master-ast-cf.c +index 57a779a89b073..70c03e304d6c8 100644 +--- a/drivers/fsi/fsi-master-ast-cf.c ++++ b/drivers/fsi/fsi-master-ast-cf.c +@@ -1427,6 +1427,7 @@ static const struct of_device_id fsi_master_acf_match[] = { + { .compatible = "aspeed,ast2500-cf-fsi-master" }, + { }, + }; ++MODULE_DEVICE_TABLE(of, fsi_master_acf_match); + + static struct platform_driver fsi_master_acf = { + .driver = { +diff --git a/drivers/fsi/fsi-master-gpio.c b/drivers/fsi/fsi-master-gpio.c +index aa97c4a250cb4..7d5f29b4b595d 100644 +--- a/drivers/fsi/fsi-master-gpio.c ++++ b/drivers/fsi/fsi-master-gpio.c +@@ -882,6 +882,7 @@ static const struct of_device_id fsi_master_gpio_match[] = { + { .compatible = "fsi-master-gpio" }, + { }, + }; ++MODULE_DEVICE_TABLE(of, fsi_master_gpio_match); + + static struct platform_driver fsi_master_gpio_driver = { + .driver = { +diff --git a/drivers/fsi/fsi-occ.c b/drivers/fsi/fsi-occ.c +index cb05b6dacc9d5..dc74bffedd727 100644 +--- a/drivers/fsi/fsi-occ.c ++++ b/drivers/fsi/fsi-occ.c +@@ -636,6 +636,7 @@ static const struct of_device_id occ_match[] = { + }, + { }, + }; ++MODULE_DEVICE_TABLE(of, occ_match); + + static struct platform_driver occ_driver = { + .driver = { +diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c +index c91d056515966..f5cfc0698799a 100644 +--- a/drivers/gpio/gpio-pca953x.c ++++ b/drivers/gpio/gpio-pca953x.c +@@ -1241,6 +1241,7 @@ static const struct of_device_id pca953x_dt_ids[] = { + + { .compatible = "onnn,cat9554", .data = OF_953X( 8, PCA_INT), }, + { .compatible = "onnn,pca9654", .data = OF_953X( 8, PCA_INT), }, ++ { .compatible = "onnn,pca9655", .data = OF_953X(16, PCA_INT), }, + + { .compatible = "exar,xra1202", .data = OF_953X( 8, 0), }, + { } +diff --git a/drivers/gpio/gpio-zynq.c b/drivers/gpio/gpio-zynq.c +index 3521c1dc3ac00..c288a7502de25 100644 +--- a/drivers/gpio/gpio-zynq.c ++++ b/drivers/gpio/gpio-zynq.c +@@ -736,6 +736,11 @@ static int __maybe_unused zynq_gpio_suspend(struct device *dev) + struct zynq_gpio *gpio = dev_get_drvdata(dev); + struct irq_data *data = irq_get_irq_data(gpio->irq); + ++ if (!data) { ++ dev_err(dev, "irq_get_irq_data() failed\n"); ++ return -EINVAL; ++ } ++ + if (!device_may_wakeup(dev)) + disable_irq(gpio->irq); + +@@ -753,6 +758,11 @@ static int __maybe_unused zynq_gpio_resume(struct device *dev) + struct irq_data *data = irq_get_irq_data(gpio->irq); + int ret; + ++ if (!data) { ++ dev_err(dev, "irq_get_irq_data() failed\n"); ++ return -EINVAL; ++ } ++ + if (!device_may_wakeup(dev)) + enable_irq(gpio->irq); + +@@ -1001,8 +1011,11 @@ err_pm_dis: + static int zynq_gpio_remove(struct platform_device *pdev) + { + struct zynq_gpio *gpio = platform_get_drvdata(pdev); ++ int ret; + +- pm_runtime_get_sync(&pdev->dev); ++ ret = pm_runtime_get_sync(&pdev->dev); ++ if (ret < 0) ++ dev_warn(&pdev->dev, "pm_runtime_get_sync() Failed\n"); + gpiochip_remove(&gpio->chip); + clk_disable_unprepare(gpio->clk); + device_set_wakeup_capable(&pdev->dev, 0); +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +index 41ebc9d21e5c6..de394de9e6303 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +@@ -1092,6 +1092,7 @@ static const struct pci_device_id pciidlist[] = { + {0x1002, 0x734F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_NAVI14}, + + /* Renoir */ ++ {0x1002, 0x15E7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RENOIR|AMD_IS_APU}, + {0x1002, 0x1636, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RENOIR|AMD_IS_APU}, + {0x1002, 0x1638, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RENOIR|AMD_IS_APU}, + {0x1002, 0x164C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RENOIR|AMD_IS_APU}, +diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c +index 2342c5d216f9b..5c40912b51d1c 100644 +--- a/drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c ++++ b/drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c +@@ -7744,6 +7744,97 @@ static void gfx_v10_0_update_fine_grain_clock_gating(struct amdgpu_device *adev, + } + } + ++static void gfx_v10_0_apply_medium_grain_clock_gating_workaround(struct amdgpu_device *adev) ++{ ++ uint32_t reg_data = 0; ++ uint32_t reg_idx = 0; ++ uint32_t i; ++ ++ const uint32_t tcp_ctrl_regs[] = { ++ mmCGTS_SA0_WGP00_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP00_CU1_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP01_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP01_CU1_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP02_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP02_CU1_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP10_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP10_CU1_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP11_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP11_CU1_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP12_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP12_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP00_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP00_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP01_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP01_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP02_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP02_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP10_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP10_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP11_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP11_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP12_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP12_CU1_TCP_CTRL_REG ++ }; ++ ++ const uint32_t tcp_ctrl_regs_nv12[] = { ++ mmCGTS_SA0_WGP00_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP00_CU1_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP01_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP01_CU1_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP02_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP02_CU1_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP10_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP10_CU1_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP11_CU0_TCP_CTRL_REG, ++ mmCGTS_SA0_WGP11_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP00_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP00_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP01_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP01_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP02_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP02_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP10_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP10_CU1_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP11_CU0_TCP_CTRL_REG, ++ mmCGTS_SA1_WGP11_CU1_TCP_CTRL_REG, ++ }; ++ ++ const uint32_t sm_ctlr_regs[] = { ++ mmCGTS_SA0_QUAD0_SM_CTRL_REG, ++ mmCGTS_SA0_QUAD1_SM_CTRL_REG, ++ mmCGTS_SA1_QUAD0_SM_CTRL_REG, ++ mmCGTS_SA1_QUAD1_SM_CTRL_REG ++ }; ++ ++ if (adev->asic_type == CHIP_NAVI12) { ++ for (i = 0; i < ARRAY_SIZE(tcp_ctrl_regs_nv12); i++) { ++ reg_idx = adev->reg_offset[GC_HWIP][0][mmCGTS_SA0_WGP00_CU0_TCP_CTRL_REG_BASE_IDX] + ++ tcp_ctrl_regs_nv12[i]; ++ reg_data = RREG32(reg_idx); ++ reg_data |= CGTS_SA0_WGP00_CU0_TCP_CTRL_REG__TCPI_LS_OVERRIDE_MASK; ++ WREG32(reg_idx, reg_data); ++ } ++ } else { ++ for (i = 0; i < ARRAY_SIZE(tcp_ctrl_regs); i++) { ++ reg_idx = adev->reg_offset[GC_HWIP][0][mmCGTS_SA0_WGP00_CU0_TCP_CTRL_REG_BASE_IDX] + ++ tcp_ctrl_regs[i]; ++ reg_data = RREG32(reg_idx); ++ reg_data |= CGTS_SA0_WGP00_CU0_TCP_CTRL_REG__TCPI_LS_OVERRIDE_MASK; ++ WREG32(reg_idx, reg_data); ++ } ++ } ++ ++ for (i = 0; i < ARRAY_SIZE(sm_ctlr_regs); i++) { ++ reg_idx = adev->reg_offset[GC_HWIP][0][mmCGTS_SA0_QUAD0_SM_CTRL_REG_BASE_IDX] + ++ sm_ctlr_regs[i]; ++ reg_data = RREG32(reg_idx); ++ reg_data &= ~CGTS_SA0_QUAD0_SM_CTRL_REG__SM_MODE_MASK; ++ reg_data |= 2 << CGTS_SA0_QUAD0_SM_CTRL_REG__SM_MODE__SHIFT; ++ WREG32(reg_idx, reg_data); ++ } ++} ++ + static int gfx_v10_0_update_gfx_clock_gating(struct amdgpu_device *adev, + bool enable) + { +@@ -7760,6 +7851,10 @@ static int gfx_v10_0_update_gfx_clock_gating(struct amdgpu_device *adev, + gfx_v10_0_update_3d_clock_gating(adev, enable); + /* === CGCG + CGLS === */ + gfx_v10_0_update_coarse_grain_clock_gating(adev, enable); ++ ++ if ((adev->asic_type >= CHIP_NAVI10) && ++ (adev->asic_type <= CHIP_NAVI12)) ++ gfx_v10_0_apply_medium_grain_clock_gating_workaround(adev); + } else { + /* CGCG/CGLS should be disabled before MGCG/MGLS + * === CGCG + CGLS === +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_process.c b/drivers/gpu/drm/amd/amdkfd/kfd_process.c +index 65803e153a223..d243e60c6eef7 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_process.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_process.c +@@ -452,13 +452,9 @@ static const struct sysfs_ops procfs_stats_ops = { + .show = kfd_procfs_stats_show, + }; + +-static struct attribute *procfs_stats_attrs[] = { +- NULL +-}; +- + static struct kobj_type procfs_stats_type = { + .sysfs_ops = &procfs_stats_ops, +- .default_attrs = procfs_stats_attrs, ++ .release = kfd_procfs_kobj_release, + }; + + int kfd_procfs_add_queue(struct queue *q) +@@ -973,9 +969,11 @@ static void kfd_process_wq_release(struct work_struct *work) + list_for_each_entry(pdd, &p->per_device_data, per_device_list) { + sysfs_remove_file(p->kobj, &pdd->attr_vram); + sysfs_remove_file(p->kobj, &pdd->attr_sdma); +- sysfs_remove_file(p->kobj, &pdd->attr_evict); +- if (pdd->dev->kfd2kgd->get_cu_occupancy != NULL) +- sysfs_remove_file(p->kobj, &pdd->attr_cu_occupancy); ++ ++ sysfs_remove_file(pdd->kobj_stats, &pdd->attr_evict); ++ if (pdd->dev->kfd2kgd->get_cu_occupancy) ++ sysfs_remove_file(pdd->kobj_stats, ++ &pdd->attr_cu_occupancy); + kobject_del(pdd->kobj_stats); + kobject_put(pdd->kobj_stats); + pdd->kobj_stats = NULL; +diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c b/drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +index eb1635ac89887..43c07ac2c6fce 100644 +--- a/drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c ++++ b/drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +@@ -153,6 +153,7 @@ void pqm_uninit(struct process_queue_manager *pqm) + if (pqn->q && pqn->q->gws) + amdgpu_amdkfd_remove_gws_from_process(pqm->process->kgd_process_info, + pqn->q->gws); ++ kfd_procfs_del_queue(pqn->q); + uninit_queue(pqn->q); + list_del(&pqn->process_queue_list); + kfree(pqn); +diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp_mst_topology.c +index 9c75c88150569..dfbd904310435 100644 +--- a/drivers/gpu/drm/drm_dp_mst_topology.c ++++ b/drivers/gpu/drm/drm_dp_mst_topology.c +@@ -94,6 +94,9 @@ static int drm_dp_mst_register_i2c_bus(struct drm_dp_mst_port *port); + static void drm_dp_mst_unregister_i2c_bus(struct drm_dp_mst_port *port); + static void drm_dp_mst_kick_tx(struct drm_dp_mst_topology_mgr *mgr); + ++static bool drm_dp_mst_port_downstream_of_branch(struct drm_dp_mst_port *port, ++ struct drm_dp_mst_branch *branch); ++ + #define DBG_PREFIX "[dp_mst]" + + #define DP_STR(x) [DP_ ## x] = #x +@@ -2499,7 +2502,7 @@ drm_dp_mst_handle_conn_stat(struct drm_dp_mst_branch *mstb, + { + struct drm_dp_mst_topology_mgr *mgr = mstb->mgr; + struct drm_dp_mst_port *port; +- int old_ddps, old_input, ret, i; ++ int old_ddps, ret; + u8 new_pdt; + bool new_mcs; + bool dowork = false, create_connector = false; +@@ -2531,7 +2534,6 @@ drm_dp_mst_handle_conn_stat(struct drm_dp_mst_branch *mstb, + } + + old_ddps = port->ddps; +- old_input = port->input; + port->input = conn_stat->input_port; + port->ldps = conn_stat->legacy_device_plug_status; + port->ddps = conn_stat->displayport_device_plug_status; +@@ -2554,28 +2556,6 @@ drm_dp_mst_handle_conn_stat(struct drm_dp_mst_branch *mstb, + dowork = false; + } + +- if (!old_input && old_ddps != port->ddps && !port->ddps) { +- for (i = 0; i < mgr->max_payloads; i++) { +- struct drm_dp_vcpi *vcpi = mgr->proposed_vcpis[i]; +- struct drm_dp_mst_port *port_validated; +- +- if (!vcpi) +- continue; +- +- port_validated = +- container_of(vcpi, struct drm_dp_mst_port, vcpi); +- port_validated = +- drm_dp_mst_topology_get_port_validated(mgr, port_validated); +- if (!port_validated) { +- mutex_lock(&mgr->payload_lock); +- vcpi->num_slots = 0; +- mutex_unlock(&mgr->payload_lock); +- } else { +- drm_dp_mst_topology_put_port(port_validated); +- } +- } +- } +- + if (port->connector) + drm_modeset_unlock(&mgr->base.lock); + else if (create_connector) +@@ -3385,6 +3365,7 @@ int drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr *mgr) + struct drm_dp_mst_port *port; + int i, j; + int cur_slots = 1; ++ bool skip; + + mutex_lock(&mgr->payload_lock); + for (i = 0; i < mgr->max_payloads; i++) { +@@ -3399,6 +3380,16 @@ int drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr *mgr) + port = container_of(vcpi, struct drm_dp_mst_port, + vcpi); + ++ mutex_lock(&mgr->lock); ++ skip = !drm_dp_mst_port_downstream_of_branch(port, mgr->mst_primary); ++ mutex_unlock(&mgr->lock); ++ ++ if (skip) { ++ drm_dbg_kms(mgr->dev, ++ "Virtual channel %d is not in current topology\n", ++ i); ++ continue; ++ } + /* Validated ports don't matter if we're releasing + * VCPI + */ +@@ -3406,8 +3397,16 @@ int drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr *mgr) + port = drm_dp_mst_topology_get_port_validated( + mgr, port); + if (!port) { +- mutex_unlock(&mgr->payload_lock); +- return -EINVAL; ++ if (vcpi->num_slots == payload->num_slots) { ++ cur_slots += vcpi->num_slots; ++ payload->start_slot = req_payload.start_slot; ++ continue; ++ } else { ++ drm_dbg_kms(mgr->dev, ++ "Fail:set payload to invalid sink"); ++ mutex_unlock(&mgr->payload_lock); ++ return -EINVAL; ++ } + } + put_port = true; + } +@@ -3491,6 +3490,7 @@ int drm_dp_update_payload_part2(struct drm_dp_mst_topology_mgr *mgr) + struct drm_dp_mst_port *port; + int i; + int ret = 0; ++ bool skip; + + mutex_lock(&mgr->payload_lock); + for (i = 0; i < mgr->max_payloads; i++) { +@@ -3500,6 +3500,13 @@ int drm_dp_update_payload_part2(struct drm_dp_mst_topology_mgr *mgr) + + port = container_of(mgr->proposed_vcpis[i], struct drm_dp_mst_port, vcpi); + ++ mutex_lock(&mgr->lock); ++ skip = !drm_dp_mst_port_downstream_of_branch(port, mgr->mst_primary); ++ mutex_unlock(&mgr->lock); ++ ++ if (skip) ++ continue; ++ + DRM_DEBUG_KMS("payload %d %d\n", i, mgr->payloads[i].payload_state); + if (mgr->payloads[i].payload_state == DP_PAYLOAD_LOCAL) { + ret = drm_dp_create_payload_step2(mgr, port, mgr->proposed_vcpis[i]->vcpi, &mgr->payloads[i]); +@@ -4581,9 +4588,18 @@ EXPORT_SYMBOL(drm_dp_mst_reset_vcpi_slots); + void drm_dp_mst_deallocate_vcpi(struct drm_dp_mst_topology_mgr *mgr, + struct drm_dp_mst_port *port) + { ++ bool skip; ++ + if (!port->vcpi.vcpi) + return; + ++ mutex_lock(&mgr->lock); ++ skip = !drm_dp_mst_port_downstream_of_branch(port, mgr->mst_primary); ++ mutex_unlock(&mgr->lock); ++ ++ if (skip) ++ return; ++ + drm_dp_mst_put_payload_id(mgr, port->vcpi.vcpi); + port->vcpi.num_slots = 0; + port->vcpi.pbn = 0; +diff --git a/drivers/gpu/drm/gma500/framebuffer.c b/drivers/gpu/drm/gma500/framebuffer.c +index ebe9dccf2d830..0b8648396fb24 100644 +--- a/drivers/gpu/drm/gma500/framebuffer.c ++++ b/drivers/gpu/drm/gma500/framebuffer.c +@@ -352,6 +352,7 @@ static struct drm_framebuffer *psb_user_framebuffer_create + const struct drm_mode_fb_cmd2 *cmd) + { + struct drm_gem_object *obj; ++ struct drm_framebuffer *fb; + + /* + * Find the GEM object and thus the gtt range object that is +@@ -362,7 +363,11 @@ static struct drm_framebuffer *psb_user_framebuffer_create + return ERR_PTR(-ENOENT); + + /* Let the core code do all the work */ +- return psb_framebuffer_create(dev, cmd, obj); ++ fb = psb_framebuffer_create(dev, cmd, obj); ++ if (IS_ERR(fb)) ++ drm_gem_object_put(obj); ++ ++ return fb; + } + + static int psbfb_probe(struct drm_fb_helper *fb_helper, +diff --git a/drivers/gpu/drm/i915/gt/gen8_ppgtt.c b/drivers/gpu/drm/i915/gt/gen8_ppgtt.c +index 3ae16945bd436..c11e6b468fc49 100644 +--- a/drivers/gpu/drm/i915/gt/gen8_ppgtt.c ++++ b/drivers/gpu/drm/i915/gt/gen8_ppgtt.c +@@ -298,10 +298,7 @@ static void __gen8_ppgtt_alloc(struct i915_address_space * const vm, + __i915_gem_object_pin_pages(pt->base); + i915_gem_object_make_unshrinkable(pt->base); + +- if (lvl || +- gen8_pt_count(*start, end) < I915_PDES || +- intel_vgpu_active(vm->i915)) +- fill_px(pt, vm->scratch[lvl]->encode); ++ fill_px(pt, vm->scratch[lvl]->encode); + + spin_lock(&pd->lock); + if (likely(!pd->entry[idx])) { +diff --git a/drivers/gpu/drm/i915/gt/intel_ggtt_fencing.c b/drivers/gpu/drm/i915/gt/intel_ggtt_fencing.c +index 4b09490c20c0a..e144aef0fd2fe 100644 +--- a/drivers/gpu/drm/i915/gt/intel_ggtt_fencing.c ++++ b/drivers/gpu/drm/i915/gt/intel_ggtt_fencing.c +@@ -366,7 +366,7 @@ static struct i915_fence_reg *fence_find(struct i915_ggtt *ggtt) + if (intel_has_pending_fb_unpin(ggtt->vm.i915)) + return ERR_PTR(-EAGAIN); + +- return ERR_PTR(-EDEADLK); ++ return ERR_PTR(-ENOBUFS); + } + + int __i915_vma_pin_fence(struct i915_vma *vma) +diff --git a/drivers/hwtracing/intel_th/core.c b/drivers/hwtracing/intel_th/core.c +index c9ac3dc651135..9cb8c7d13d46b 100644 +--- a/drivers/hwtracing/intel_th/core.c ++++ b/drivers/hwtracing/intel_th/core.c +@@ -215,6 +215,22 @@ static ssize_t port_show(struct device *dev, struct device_attribute *attr, + + static DEVICE_ATTR_RO(port); + ++static void intel_th_trace_prepare(struct intel_th_device *thdev) ++{ ++ struct intel_th_device *hub = to_intel_th_hub(thdev); ++ struct intel_th_driver *hubdrv = to_intel_th_driver(hub->dev.driver); ++ ++ if (hub->type != INTEL_TH_SWITCH) ++ return; ++ ++ if (thdev->type != INTEL_TH_OUTPUT) ++ return; ++ ++ pm_runtime_get_sync(&thdev->dev); ++ hubdrv->prepare(hub, &thdev->output); ++ pm_runtime_put(&thdev->dev); ++} ++ + static int intel_th_output_activate(struct intel_th_device *thdev) + { + struct intel_th_driver *thdrv = +@@ -235,6 +251,7 @@ static int intel_th_output_activate(struct intel_th_device *thdev) + if (ret) + goto fail_put; + ++ intel_th_trace_prepare(thdev); + if (thdrv->activate) + ret = thdrv->activate(thdev); + else +diff --git a/drivers/hwtracing/intel_th/gth.c b/drivers/hwtracing/intel_th/gth.c +index 28509b02a0b56..b3308934a687d 100644 +--- a/drivers/hwtracing/intel_th/gth.c ++++ b/drivers/hwtracing/intel_th/gth.c +@@ -564,6 +564,21 @@ static void gth_tscu_resync(struct gth_device *gth) + iowrite32(reg, gth->base + REG_TSCU_TSUCTRL); + } + ++static void intel_th_gth_prepare(struct intel_th_device *thdev, ++ struct intel_th_output *output) ++{ ++ struct gth_device *gth = dev_get_drvdata(&thdev->dev); ++ int count; ++ ++ /* ++ * Wait until the output port is in reset before we start ++ * programming it. ++ */ ++ for (count = GTH_PLE_WAITLOOP_DEPTH; ++ count && !(gth_output_get(gth, output->port) & BIT(5)); count--) ++ cpu_relax(); ++} ++ + /** + * intel_th_gth_enable() - enable tracing to an output device + * @thdev: GTH device +@@ -815,6 +830,7 @@ static struct intel_th_driver intel_th_gth_driver = { + .assign = intel_th_gth_assign, + .unassign = intel_th_gth_unassign, + .set_output = intel_th_gth_set_output, ++ .prepare = intel_th_gth_prepare, + .enable = intel_th_gth_enable, + .trig_switch = intel_th_gth_switch, + .disable = intel_th_gth_disable, +diff --git a/drivers/hwtracing/intel_th/intel_th.h b/drivers/hwtracing/intel_th/intel_th.h +index 5fe694708b7a3..595615b791086 100644 +--- a/drivers/hwtracing/intel_th/intel_th.h ++++ b/drivers/hwtracing/intel_th/intel_th.h +@@ -143,6 +143,7 @@ intel_th_output_assigned(struct intel_th_device *thdev) + * @remove: remove method + * @assign: match a given output type device against available outputs + * @unassign: deassociate an output type device from an output port ++ * @prepare: prepare output port for tracing + * @enable: enable tracing for a given output device + * @disable: disable tracing for a given output device + * @irq: interrupt callback +@@ -164,6 +165,8 @@ struct intel_th_driver { + struct intel_th_device *othdev); + void (*unassign)(struct intel_th_device *thdev, + struct intel_th_device *othdev); ++ void (*prepare)(struct intel_th_device *thdev, ++ struct intel_th_output *output); + void (*enable)(struct intel_th_device *thdev, + struct intel_th_output *output); + void (*trig_switch)(struct intel_th_device *thdev, +diff --git a/drivers/i2c/i2c-core-base.c b/drivers/i2c/i2c-core-base.c +index f21362355973e..8e4be0d4ce34e 100644 +--- a/drivers/i2c/i2c-core-base.c ++++ b/drivers/i2c/i2c-core-base.c +@@ -24,6 +24,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -587,6 +588,8 @@ static void i2c_device_shutdown(struct device *dev) + driver = to_i2c_driver(dev->driver); + if (driver->shutdown) + driver->shutdown(client); ++ else if (client->irq > 0) ++ disable_irq(client->irq); + } + + static void i2c_client_dev_release(struct device *dev) +diff --git a/drivers/iio/gyro/fxas21002c_core.c b/drivers/iio/gyro/fxas21002c_core.c +index b7523357d8eba..ec6bd15bd2d4c 100644 +--- a/drivers/iio/gyro/fxas21002c_core.c ++++ b/drivers/iio/gyro/fxas21002c_core.c +@@ -366,14 +366,7 @@ out_unlock: + + static int fxas21002c_pm_get(struct fxas21002c_data *data) + { +- struct device *dev = regmap_get_device(data->regmap); +- int ret; +- +- ret = pm_runtime_get_sync(dev); +- if (ret < 0) +- pm_runtime_put_noidle(dev); +- +- return ret; ++ return pm_runtime_resume_and_get(regmap_get_device(data->regmap)); + } + + static int fxas21002c_pm_put(struct fxas21002c_data *data) +@@ -1005,7 +998,6 @@ int fxas21002c_core_probe(struct device *dev, struct regmap *regmap, int irq, + pm_disable: + pm_runtime_disable(dev); + pm_runtime_set_suspended(dev); +- pm_runtime_put_noidle(dev); + + return ret; + } +@@ -1019,7 +1011,6 @@ void fxas21002c_core_remove(struct device *dev) + + pm_runtime_disable(dev); + pm_runtime_set_suspended(dev); +- pm_runtime_put_noidle(dev); + } + EXPORT_SYMBOL_GPL(fxas21002c_core_remove); + +diff --git a/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c b/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c +index 7cedaab096a7f..e8d242ee6743b 100644 +--- a/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c ++++ b/drivers/iio/imu/st_lsm6dsx/st_lsm6dsx_core.c +@@ -15,19 +15,19 @@ + * + * Supported sensors: + * - LSM6DS3: +- * - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416 ++ * - Accelerometer/Gyroscope supported ODR [Hz]: 12.5, 26, 52, 104, 208, 416 + * - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16 + * - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000 + * - FIFO size: 8KB + * + * - LSM6DS3H/LSM6DSL/LSM6DSM/ISM330DLC/LSM6DS3TR-C: +- * - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416 ++ * - Accelerometer/Gyroscope supported ODR [Hz]: 12.5, 26, 52, 104, 208, 416 + * - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16 + * - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000 + * - FIFO size: 4KB + * + * - LSM6DSO/LSM6DSOX/ASM330LHH/LSM6DSR/ISM330DHCX/LSM6DST/LSM6DSOP: +- * - Accelerometer/Gyroscope supported ODR [Hz]: 13, 26, 52, 104, 208, 416, ++ * - Accelerometer/Gyroscope supported ODR [Hz]: 12.5, 26, 52, 104, 208, 416, + * 833 + * - Accelerometer supported full-scale [g]: +-2/+-4/+-8/+-16 + * - Gyroscope supported full-scale [dps]: +-125/+-245/+-500/+-1000/+-2000 +diff --git a/drivers/iio/magnetometer/bmc150_magn.c b/drivers/iio/magnetometer/bmc150_magn.c +index 20a0842f0e3a6..26c6400cb08ca 100644 +--- a/drivers/iio/magnetometer/bmc150_magn.c ++++ b/drivers/iio/magnetometer/bmc150_magn.c +@@ -265,7 +265,7 @@ static int bmc150_magn_set_power_state(struct bmc150_magn_data *data, bool on) + int ret; + + if (on) { +- ret = pm_runtime_get_sync(data->dev); ++ ret = pm_runtime_resume_and_get(data->dev); + } else { + pm_runtime_mark_last_busy(data->dev); + ret = pm_runtime_put_autosuspend(data->dev); +@@ -274,9 +274,6 @@ static int bmc150_magn_set_power_state(struct bmc150_magn_data *data, bool on) + if (ret < 0) { + dev_err(data->dev, + "failed to change power state to %d\n", on); +- if (on) +- pm_runtime_put_noidle(data->dev); +- + return ret; + } + #endif +@@ -967,12 +964,14 @@ int bmc150_magn_probe(struct device *dev, struct regmap *regmap, + ret = iio_device_register(indio_dev); + if (ret < 0) { + dev_err(dev, "unable to register iio device\n"); +- goto err_buffer_cleanup; ++ goto err_disable_runtime_pm; + } + + dev_dbg(dev, "Registered device %s\n", name); + return 0; + ++err_disable_runtime_pm: ++ pm_runtime_disable(dev); + err_buffer_cleanup: + iio_triggered_buffer_cleanup(indio_dev); + err_free_irq: +@@ -996,7 +995,6 @@ int bmc150_magn_remove(struct device *dev) + + pm_runtime_disable(dev); + pm_runtime_set_suspended(dev); +- pm_runtime_put_noidle(dev); + + iio_triggered_buffer_cleanup(indio_dev); + +diff --git a/drivers/input/touchscreen/hideep.c b/drivers/input/touchscreen/hideep.c +index ddad4a82a5e55..e9547ee297564 100644 +--- a/drivers/input/touchscreen/hideep.c ++++ b/drivers/input/touchscreen/hideep.c +@@ -361,13 +361,16 @@ static int hideep_enter_pgm(struct hideep_ts *ts) + return -EIO; + } + +-static void hideep_nvm_unlock(struct hideep_ts *ts) ++static int hideep_nvm_unlock(struct hideep_ts *ts) + { + u32 unmask_code; ++ int error; + + hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_SFR_RPAGE); +- hideep_pgm_r_reg(ts, 0x0000000C, &unmask_code); ++ error = hideep_pgm_r_reg(ts, 0x0000000C, &unmask_code); + hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_DEFAULT_PAGE); ++ if (error) ++ return error; + + /* make it unprotected code */ + unmask_code &= ~HIDEEP_PROT_MODE; +@@ -384,6 +387,8 @@ static void hideep_nvm_unlock(struct hideep_ts *ts) + NVM_W_SFR(HIDEEP_NVM_MASK_OFS, ts->nvm_mask); + SET_FLASH_HWCONTROL(); + hideep_pgm_w_reg(ts, HIDEEP_FLASH_CFG, HIDEEP_NVM_DEFAULT_PAGE); ++ ++ return 0; + } + + static int hideep_check_status(struct hideep_ts *ts) +@@ -462,7 +467,9 @@ static int hideep_program_nvm(struct hideep_ts *ts, + u32 addr = 0; + int error; + +- hideep_nvm_unlock(ts); ++ error = hideep_nvm_unlock(ts); ++ if (error) ++ return error; + + while (ucode_len > 0) { + xfer_len = min_t(size_t, ucode_len, HIDEEP_NVM_PAGE_SIZE); +diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c +index 98b3a1c2a1813..44a427833385e 100644 +--- a/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c ++++ b/drivers/iommu/arm/arm-smmu/arm-smmu-qcom.c +@@ -130,6 +130,16 @@ static int qcom_adreno_smmu_alloc_context_bank(struct arm_smmu_domain *smmu_doma + return __arm_smmu_alloc_bitmap(smmu->context_map, start, count); + } + ++static bool qcom_adreno_can_do_ttbr1(struct arm_smmu_device *smmu) ++{ ++ const struct device_node *np = smmu->dev->of_node; ++ ++ if (of_device_is_compatible(np, "qcom,msm8996-smmu-v2")) ++ return false; ++ ++ return true; ++} ++ + static int qcom_adreno_smmu_init_context(struct arm_smmu_domain *smmu_domain, + struct io_pgtable_cfg *pgtbl_cfg, struct device *dev) + { +@@ -144,7 +154,8 @@ static int qcom_adreno_smmu_init_context(struct arm_smmu_domain *smmu_domain, + * be AARCH64 stage 1 but double check because the arm-smmu code assumes + * that is the case when the TTBR1 quirk is enabled + */ +- if ((smmu_domain->stage == ARM_SMMU_DOMAIN_S1) && ++ if (qcom_adreno_can_do_ttbr1(smmu_domain->smmu) && ++ (smmu_domain->stage == ARM_SMMU_DOMAIN_S1) && + (smmu_domain->cfg.fmt == ARM_SMMU_CTX_FMT_AARCH64)) + pgtbl_cfg->quirks |= IO_PGTABLE_QUIRK_ARM_TTBR1; + +diff --git a/drivers/iommu/arm/arm-smmu/arm-smmu.c b/drivers/iommu/arm/arm-smmu/arm-smmu.c +index d8c6bfde6a615..c6ff32797a238 100644 +--- a/drivers/iommu/arm/arm-smmu/arm-smmu.c ++++ b/drivers/iommu/arm/arm-smmu/arm-smmu.c +@@ -74,7 +74,7 @@ static bool using_legacy_binding, using_generic_binding; + static inline int arm_smmu_rpm_get(struct arm_smmu_device *smmu) + { + if (pm_runtime_enabled(smmu->dev)) +- return pm_runtime_get_sync(smmu->dev); ++ return pm_runtime_resume_and_get(smmu->dev); + + return 0; + } +@@ -1268,6 +1268,7 @@ static phys_addr_t arm_smmu_iova_to_phys_hard(struct iommu_domain *domain, + u64 phys; + unsigned long va, flags; + int ret, idx = cfg->cbndx; ++ phys_addr_t addr = 0; + + ret = arm_smmu_rpm_get(smmu); + if (ret < 0) +@@ -1287,6 +1288,7 @@ static phys_addr_t arm_smmu_iova_to_phys_hard(struct iommu_domain *domain, + dev_err(dev, + "iova to phys timed out on %pad. Falling back to software table walk.\n", + &iova); ++ arm_smmu_rpm_put(smmu); + return ops->iova_to_phys(ops, iova); + } + +@@ -1295,12 +1297,14 @@ static phys_addr_t arm_smmu_iova_to_phys_hard(struct iommu_domain *domain, + if (phys & ARM_SMMU_CB_PAR_F) { + dev_err(dev, "translation fault!\n"); + dev_err(dev, "PAR = 0x%llx\n", phys); +- return 0; ++ goto out; + } + ++ addr = (phys & GENMASK_ULL(39, 12)) | (iova & 0xfff); ++out: + arm_smmu_rpm_put(smmu); + +- return (phys & GENMASK_ULL(39, 12)) | (iova & 0xfff); ++ return addr; + } + + static phys_addr_t arm_smmu_iova_to_phys(struct iommu_domain *domain, +diff --git a/drivers/iommu/intel/iommu.c b/drivers/iommu/intel/iommu.c +index 56930e0b8f590..8cdee1a0d25a8 100644 +--- a/drivers/iommu/intel/iommu.c ++++ b/drivers/iommu/intel/iommu.c +@@ -2434,10 +2434,11 @@ __domain_mapping(struct dmar_domain *domain, unsigned long iov_pfn, + return 0; + } + +-static void domain_context_clear_one(struct intel_iommu *iommu, u8 bus, u8 devfn) ++static void domain_context_clear_one(struct device_domain_info *info, u8 bus, u8 devfn) + { +- unsigned long flags; ++ struct intel_iommu *iommu = info->iommu; + struct context_entry *context; ++ unsigned long flags; + u16 did_old; + + if (!iommu) +@@ -2449,7 +2450,16 @@ static void domain_context_clear_one(struct intel_iommu *iommu, u8 bus, u8 devfn + spin_unlock_irqrestore(&iommu->lock, flags); + return; + } +- did_old = context_domain_id(context); ++ ++ if (sm_supported(iommu)) { ++ if (hw_pass_through && domain_type_is_si(info->domain)) ++ did_old = FLPT_DEFAULT_DID; ++ else ++ did_old = info->domain->iommu_did[iommu->seq_id]; ++ } else { ++ did_old = context_domain_id(context); ++ } ++ + context_clear_entry(context); + __iommu_flush_cache(iommu, context, sizeof(*context)); + spin_unlock_irqrestore(&iommu->lock, flags); +@@ -2467,6 +2477,8 @@ static void domain_context_clear_one(struct intel_iommu *iommu, u8 bus, u8 devfn + 0, + 0, + DMA_TLB_DSI_FLUSH); ++ ++ __iommu_flush_dev_iotlb(info, 0, MAX_AGAW_PFN_WIDTH); + } + + static inline void unlink_domain_info(struct device_domain_info *info) +@@ -4456,9 +4468,9 @@ out_free_dmar: + + static int domain_context_clear_one_cb(struct pci_dev *pdev, u16 alias, void *opaque) + { +- struct intel_iommu *iommu = opaque; ++ struct device_domain_info *info = opaque; + +- domain_context_clear_one(iommu, PCI_BUS_NUM(alias), alias & 0xff); ++ domain_context_clear_one(info, PCI_BUS_NUM(alias), alias & 0xff); + return 0; + } + +@@ -4468,12 +4480,13 @@ static int domain_context_clear_one_cb(struct pci_dev *pdev, u16 alias, void *op + * devices, unbinding the driver from any one of them will possibly leave + * the others unable to operate. + */ +-static void domain_context_clear(struct intel_iommu *iommu, struct device *dev) ++static void domain_context_clear(struct device_domain_info *info) + { +- if (!iommu || !dev || !dev_is_pci(dev)) ++ if (!info->iommu || !info->dev || !dev_is_pci(info->dev)) + return; + +- pci_for_each_dma_alias(to_pci_dev(dev), &domain_context_clear_one_cb, iommu); ++ pci_for_each_dma_alias(to_pci_dev(info->dev), ++ &domain_context_clear_one_cb, info); + } + + static void __dmar_remove_one_dev_info(struct device_domain_info *info) +@@ -4490,14 +4503,13 @@ static void __dmar_remove_one_dev_info(struct device_domain_info *info) + iommu = info->iommu; + domain = info->domain; + +- if (info->dev) { ++ if (info->dev && !dev_is_real_dma_subdevice(info->dev)) { + if (dev_is_pci(info->dev) && sm_supported(iommu)) + intel_pasid_tear_down_entry(iommu, info->dev, + PASID_RID2PASID, false); + + iommu_disable_dev_iotlb(info); +- if (!dev_is_real_dma_subdevice(info->dev)) +- domain_context_clear(iommu, info->dev); ++ domain_context_clear(info); + intel_pasid_free_table(info->dev); + } + +diff --git a/drivers/leds/leds-tlc591xx.c b/drivers/leds/leds-tlc591xx.c +index 5b9dfdf743ecd..cb7bd1353f9f0 100644 +--- a/drivers/leds/leds-tlc591xx.c ++++ b/drivers/leds/leds-tlc591xx.c +@@ -148,16 +148,20 @@ static int + tlc591xx_probe(struct i2c_client *client, + const struct i2c_device_id *id) + { +- struct device_node *np = dev_of_node(&client->dev), *child; ++ struct device_node *np, *child; + struct device *dev = &client->dev; + const struct tlc591xx *tlc591xx; + struct tlc591xx_priv *priv; + int err, count, reg; + +- tlc591xx = device_get_match_data(dev); ++ np = dev_of_node(dev); + if (!np) + return -ENODEV; + ++ tlc591xx = device_get_match_data(dev); ++ if (!tlc591xx) ++ return -ENODEV; ++ + count = of_get_available_child_count(np); + if (!count || count > tlc591xx->max_leds) + return -EINVAL; +diff --git a/drivers/leds/leds-turris-omnia.c b/drivers/leds/leds-turris-omnia.c +index 2f9a289ab2456..1adfed1c0619b 100644 +--- a/drivers/leds/leds-turris-omnia.c ++++ b/drivers/leds/leds-turris-omnia.c +@@ -274,6 +274,7 @@ static const struct i2c_device_id omnia_id[] = { + { "omnia", 0 }, + { } + }; ++MODULE_DEVICE_TABLE(i2c, omnia_id); + + static struct i2c_driver omnia_leds_driver = { + .probe = omnia_leds_probe, +diff --git a/drivers/memory/atmel-ebi.c b/drivers/memory/atmel-ebi.c +index 14386d0b5f578..c267283b01fda 100644 +--- a/drivers/memory/atmel-ebi.c ++++ b/drivers/memory/atmel-ebi.c +@@ -600,8 +600,10 @@ static int atmel_ebi_probe(struct platform_device *pdev) + child); + + ret = atmel_ebi_dev_disable(ebi, child); +- if (ret) ++ if (ret) { ++ of_node_put(child); + return ret; ++ } + } + } + +diff --git a/drivers/memory/fsl_ifc.c b/drivers/memory/fsl_ifc.c +index 89f99b5b64504..d062c2f8250f4 100644 +--- a/drivers/memory/fsl_ifc.c ++++ b/drivers/memory/fsl_ifc.c +@@ -97,7 +97,6 @@ static int fsl_ifc_ctrl_remove(struct platform_device *dev) + iounmap(ctrl->gregs); + + dev_set_drvdata(&dev->dev, NULL); +- kfree(ctrl); + + return 0; + } +@@ -209,7 +208,8 @@ static int fsl_ifc_ctrl_probe(struct platform_device *dev) + + dev_info(&dev->dev, "Freescale Integrated Flash Controller\n"); + +- fsl_ifc_ctrl_dev = kzalloc(sizeof(*fsl_ifc_ctrl_dev), GFP_KERNEL); ++ fsl_ifc_ctrl_dev = devm_kzalloc(&dev->dev, sizeof(*fsl_ifc_ctrl_dev), ++ GFP_KERNEL); + if (!fsl_ifc_ctrl_dev) + return -ENOMEM; + +@@ -219,8 +219,7 @@ static int fsl_ifc_ctrl_probe(struct platform_device *dev) + fsl_ifc_ctrl_dev->gregs = of_iomap(dev->dev.of_node, 0); + if (!fsl_ifc_ctrl_dev->gregs) { + dev_err(&dev->dev, "failed to get memory region\n"); +- ret = -ENODEV; +- goto err; ++ return -ENODEV; + } + + if (of_property_read_bool(dev->dev.of_node, "little-endian")) { +@@ -295,6 +294,7 @@ err_irq: + free_irq(fsl_ifc_ctrl_dev->irq, fsl_ifc_ctrl_dev); + irq_dispose_mapping(fsl_ifc_ctrl_dev->irq); + err: ++ iounmap(fsl_ifc_ctrl_dev->gregs); + return ret; + } + +diff --git a/drivers/memory/pl353-smc.c b/drivers/memory/pl353-smc.c +index 9c0a284167773..b0b251bb207f3 100644 +--- a/drivers/memory/pl353-smc.c ++++ b/drivers/memory/pl353-smc.c +@@ -407,6 +407,7 @@ static int pl353_smc_probe(struct amba_device *adev, const struct amba_id *id) + break; + } + if (!match) { ++ err = -ENODEV; + dev_err(&adev->dev, "no matching children\n"); + goto out_clk_disable; + } +diff --git a/drivers/memory/stm32-fmc2-ebi.c b/drivers/memory/stm32-fmc2-ebi.c +index 4d5758c419c55..ffec26a99313b 100644 +--- a/drivers/memory/stm32-fmc2-ebi.c ++++ b/drivers/memory/stm32-fmc2-ebi.c +@@ -1048,16 +1048,19 @@ static int stm32_fmc2_ebi_parse_dt(struct stm32_fmc2_ebi *ebi) + if (ret) { + dev_err(dev, "could not retrieve reg property: %d\n", + ret); ++ of_node_put(child); + return ret; + } + + if (bank >= FMC2_MAX_BANKS) { + dev_err(dev, "invalid reg value: %d\n", bank); ++ of_node_put(child); + return -EINVAL; + } + + if (ebi->bank_assigned & BIT(bank)) { + dev_err(dev, "bank already assigned: %d\n", bank); ++ of_node_put(child); + return -EINVAL; + } + +@@ -1066,6 +1069,7 @@ static int stm32_fmc2_ebi_parse_dt(struct stm32_fmc2_ebi *ebi) + if (ret) { + dev_err(dev, "setup chip select %d failed: %d\n", + bank, ret); ++ of_node_put(child); + return ret; + } + } +diff --git a/drivers/mfd/da9052-i2c.c b/drivers/mfd/da9052-i2c.c +index 47556d2d9abe2..8ebfc7bbe4e01 100644 +--- a/drivers/mfd/da9052-i2c.c ++++ b/drivers/mfd/da9052-i2c.c +@@ -113,6 +113,7 @@ static const struct i2c_device_id da9052_i2c_id[] = { + {"da9053-bc", DA9053_BC}, + {} + }; ++MODULE_DEVICE_TABLE(i2c, da9052_i2c_id); + + #ifdef CONFIG_OF + static const struct of_device_id dialog_dt_ids[] = { +diff --git a/drivers/mfd/motorola-cpcap.c b/drivers/mfd/motorola-cpcap.c +index 30d82bfe5b02f..6fb206da27298 100644 +--- a/drivers/mfd/motorola-cpcap.c ++++ b/drivers/mfd/motorola-cpcap.c +@@ -327,6 +327,10 @@ static int cpcap_probe(struct spi_device *spi) + if (ret) + return ret; + ++ /* Parent SPI controller uses DMA, CPCAP and child devices do not */ ++ spi->dev.coherent_dma_mask = 0; ++ spi->dev.dma_mask = &spi->dev.coherent_dma_mask; ++ + return devm_mfd_add_devices(&spi->dev, 0, cpcap_mfd_devices, + ARRAY_SIZE(cpcap_mfd_devices), NULL, 0, NULL); + } +diff --git a/drivers/mfd/stmpe-i2c.c b/drivers/mfd/stmpe-i2c.c +index 61aa020199f57..cd2f45257dc16 100644 +--- a/drivers/mfd/stmpe-i2c.c ++++ b/drivers/mfd/stmpe-i2c.c +@@ -109,7 +109,7 @@ static const struct i2c_device_id stmpe_i2c_id[] = { + { "stmpe2403", STMPE2403 }, + { } + }; +-MODULE_DEVICE_TABLE(i2c, stmpe_id); ++MODULE_DEVICE_TABLE(i2c, stmpe_i2c_id); + + static struct i2c_driver stmpe_i2c_driver = { + .driver = { +diff --git a/drivers/misc/cardreader/alcor_pci.c b/drivers/misc/cardreader/alcor_pci.c +index cd402c89189ea..de6d44a158bba 100644 +--- a/drivers/misc/cardreader/alcor_pci.c ++++ b/drivers/misc/cardreader/alcor_pci.c +@@ -139,7 +139,13 @@ static void alcor_pci_init_check_aspm(struct alcor_pci_priv *priv) + u32 val32; + + priv->pdev_cap_off = alcor_pci_find_cap_offset(priv, priv->pdev); +- priv->parent_cap_off = alcor_pci_find_cap_offset(priv, ++ /* ++ * A device might be attached to root complex directly and ++ * priv->parent_pdev will be NULL. In this case we don't check its ++ * capability and disable ASPM completely. ++ */ ++ if (priv->parent_pdev) ++ priv->parent_cap_off = alcor_pci_find_cap_offset(priv, + priv->parent_pdev); + + if ((priv->pdev_cap_off == 0) || (priv->parent_cap_off == 0)) { +diff --git a/drivers/misc/habanalabs/common/device.c b/drivers/misc/habanalabs/common/device.c +index 334009e838236..b11e9830422ed 100644 +--- a/drivers/misc/habanalabs/common/device.c ++++ b/drivers/misc/habanalabs/common/device.c +@@ -1370,8 +1370,9 @@ int hl_device_init(struct hl_device *hdev, struct class *hclass) + } + + /* +- * From this point, in case of an error, add char devices and create +- * sysfs nodes as part of the error flow, to allow debugging. ++ * From this point, override rc (=0) in case of an error to allow ++ * debugging (by adding char devices and create sysfs nodes as part of ++ * the error flow). + */ + add_cdev_sysfs_on_err = true; + +diff --git a/drivers/misc/habanalabs/common/firmware_if.c b/drivers/misc/habanalabs/common/firmware_if.c +index 09706c571e950..7a96c9753dbfb 100644 +--- a/drivers/misc/habanalabs/common/firmware_if.c ++++ b/drivers/misc/habanalabs/common/firmware_if.c +@@ -803,11 +803,14 @@ int hl_fw_init_cpu(struct hl_device *hdev, u32 cpu_boot_status_reg, + + if (!(hdev->fw_loading & FW_TYPE_LINUX)) { + dev_info(hdev->dev, "Skip loading Linux F/W\n"); ++ rc = 0; + goto out; + } + +- if (status == CPU_BOOT_STATUS_SRAM_AVAIL) ++ if (status == CPU_BOOT_STATUS_SRAM_AVAIL) { ++ rc = 0; + goto out; ++ } + + dev_info(hdev->dev, + "Loading firmware to device, may take some time...\n"); +diff --git a/drivers/misc/habanalabs/common/mmu/mmu.c b/drivers/misc/habanalabs/common/mmu/mmu.c +index 93c9e5f587e1a..86dfa7c41ee71 100644 +--- a/drivers/misc/habanalabs/common/mmu/mmu.c ++++ b/drivers/misc/habanalabs/common/mmu/mmu.c +@@ -501,12 +501,20 @@ static void hl_mmu_pa_page_with_offset(struct hl_ctx *ctx, u64 virt_addr, + + if ((hops->range_type == HL_VA_RANGE_TYPE_DRAM) && + !is_power_of_2(prop->dram_page_size)) { +- u32 bit; ++ unsigned long dram_page_size = prop->dram_page_size; + u64 page_offset_mask; + u64 phys_addr_mask; ++ u32 bit; + +- bit = __ffs64((u64)prop->dram_page_size); +- page_offset_mask = ((1ull << bit) - 1); ++ /* ++ * find last set bit in page_size to cover all bits of page ++ * offset. note that 1 has to be added to bit index. ++ * note that the internal ulong variable is used to avoid ++ * alignment issue. ++ */ ++ bit = find_last_bit(&dram_page_size, ++ sizeof(dram_page_size) * BITS_PER_BYTE) + 1; ++ page_offset_mask = (BIT_ULL(bit) - 1); + phys_addr_mask = ~page_offset_mask; + *phys_addr = (tmp_phys_addr & phys_addr_mask) | + (virt_addr & page_offset_mask); +diff --git a/drivers/misc/habanalabs/gaudi/gaudi.c b/drivers/misc/habanalabs/gaudi/gaudi.c +index ecdedd87f8ccf..894056da22cfb 100644 +--- a/drivers/misc/habanalabs/gaudi/gaudi.c ++++ b/drivers/misc/habanalabs/gaudi/gaudi.c +@@ -2801,7 +2801,7 @@ static void gaudi_init_mme_qman(struct hl_device *hdev, u32 mme_offset, + + /* Configure RAZWI IRQ */ + mme_id = mme_offset / +- (mmMME1_QM_GLBL_CFG0 - mmMME0_QM_GLBL_CFG0); ++ (mmMME1_QM_GLBL_CFG0 - mmMME0_QM_GLBL_CFG0) / 2; + + mme_qm_err_cfg = MME_QMAN_GLBL_ERR_CFG_MSG_EN_MASK; + if (hdev->stop_on_err) { +@@ -4901,6 +4901,7 @@ already_pinned: + return 0; + + unpin_memory: ++ list_del(&userptr->job_node); + hl_unpin_host_memory(hdev, userptr); + free_userptr: + kfree(userptr); +@@ -8069,8 +8070,10 @@ static int gaudi_internal_cb_pool_init(struct hl_device *hdev, + HL_VA_RANGE_TYPE_HOST, HOST_SPACE_INTERNAL_CB_SZ, + HL_MMU_VA_ALIGNMENT_NOT_NEEDED); + +- if (!hdev->internal_cb_va_base) ++ if (!hdev->internal_cb_va_base) { ++ rc = -ENOMEM; + goto destroy_internal_cb_pool; ++ } + + mutex_lock(&ctx->mmu_lock); + rc = hl_mmu_map_contiguous(ctx, hdev->internal_cb_va_base, +diff --git a/drivers/misc/habanalabs/goya/goya.c b/drivers/misc/habanalabs/goya/goya.c +index ed566c52ccaa0..45c9065c4b922 100644 +--- a/drivers/misc/habanalabs/goya/goya.c ++++ b/drivers/misc/habanalabs/goya/goya.c +@@ -3249,6 +3249,7 @@ already_pinned: + return 0; + + unpin_memory: ++ list_del(&userptr->job_node); + hl_unpin_host_memory(hdev, userptr); + free_userptr: + kfree(userptr); +diff --git a/drivers/misc/ibmasm/module.c b/drivers/misc/ibmasm/module.c +index 4edad6c445d37..dc8a06c06c637 100644 +--- a/drivers/misc/ibmasm/module.c ++++ b/drivers/misc/ibmasm/module.c +@@ -111,7 +111,7 @@ static int ibmasm_init_one(struct pci_dev *pdev, const struct pci_device_id *id) + result = ibmasm_init_remote_input_dev(sp); + if (result) { + dev_err(sp->dev, "Failed to initialize remote queue\n"); +- goto error_send_message; ++ goto error_init_remote; + } + + result = ibmasm_send_driver_vpd(sp); +@@ -131,8 +131,9 @@ static int ibmasm_init_one(struct pci_dev *pdev, const struct pci_device_id *id) + return 0; + + error_send_message: +- disable_sp_interrupts(sp->base_address); + ibmasm_free_remote_input_dev(sp); ++error_init_remote: ++ disable_sp_interrupts(sp->base_address); + free_irq(sp->irq, (void *)sp); + error_request_irq: + iounmap(sp->base_address); +diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c +index f7ce341bb328f..beb0860230932 100644 +--- a/drivers/net/virtio_net.c ++++ b/drivers/net/virtio_net.c +@@ -1514,6 +1514,8 @@ static int virtnet_poll_tx(struct napi_struct *napi, int budget) + struct virtnet_info *vi = sq->vq->vdev->priv; + unsigned int index = vq2txq(sq->vq); + struct netdev_queue *txq; ++ int opaque; ++ bool done; + + if (unlikely(is_xdp_raw_buffer_queue(vi, index))) { + /* We don't need to enable cb for XDP */ +@@ -1523,10 +1525,28 @@ static int virtnet_poll_tx(struct napi_struct *napi, int budget) + + txq = netdev_get_tx_queue(vi->dev, index); + __netif_tx_lock(txq, raw_smp_processor_id()); ++ virtqueue_disable_cb(sq->vq); + free_old_xmit_skbs(sq, true); ++ ++ opaque = virtqueue_enable_cb_prepare(sq->vq); ++ ++ done = napi_complete_done(napi, 0); ++ ++ if (!done) ++ virtqueue_disable_cb(sq->vq); ++ + __netif_tx_unlock(txq); + +- virtqueue_napi_complete(napi, sq->vq, 0); ++ if (done) { ++ if (unlikely(virtqueue_poll(sq->vq, opaque))) { ++ if (napi_schedule_prep(napi)) { ++ __netif_tx_lock(txq, raw_smp_processor_id()); ++ virtqueue_disable_cb(sq->vq); ++ __netif_tx_unlock(txq); ++ __napi_schedule(napi); ++ } ++ } ++ } + + if (sq->vq->num_free >= 2 + MAX_SKB_FRAGS) + netif_tx_wake_queue(txq); +@@ -3229,8 +3249,11 @@ static __maybe_unused int virtnet_restore(struct virtio_device *vdev) + virtnet_set_queues(vi, vi->curr_queue_pairs); + + err = virtnet_cpu_notif_add(vi); +- if (err) ++ if (err) { ++ virtnet_freeze_down(vdev); ++ remove_vq_common(vi); + return err; ++ } + + return 0; + } +diff --git a/drivers/nvme/target/tcp.c b/drivers/nvme/target/tcp.c +index 4df4f37e6b895..dedcb7aaf0d82 100644 +--- a/drivers/nvme/target/tcp.c ++++ b/drivers/nvme/target/tcp.c +@@ -1467,7 +1467,6 @@ static void nvmet_tcp_state_change(struct sock *sk) + case TCP_CLOSE_WAIT: + case TCP_CLOSE: + /* FALLTHRU */ +- sk->sk_user_data = NULL; + nvmet_tcp_schedule_release_queue(queue); + break; + default: +diff --git a/drivers/pci/controller/dwc/pcie-intel-gw.c b/drivers/pci/controller/dwc/pcie-intel-gw.c +index 0cedd1f95f372..ae96bfbb6c832 100644 +--- a/drivers/pci/controller/dwc/pcie-intel-gw.c ++++ b/drivers/pci/controller/dwc/pcie-intel-gw.c +@@ -39,6 +39,10 @@ + #define PCIE_APP_IRN_PM_TO_ACK BIT(9) + #define PCIE_APP_IRN_LINK_AUTO_BW_STAT BIT(11) + #define PCIE_APP_IRN_BW_MGT BIT(12) ++#define PCIE_APP_IRN_INTA BIT(13) ++#define PCIE_APP_IRN_INTB BIT(14) ++#define PCIE_APP_IRN_INTC BIT(15) ++#define PCIE_APP_IRN_INTD BIT(16) + #define PCIE_APP_IRN_MSG_LTR BIT(18) + #define PCIE_APP_IRN_SYS_ERR_RC BIT(29) + #define PCIE_APP_INTX_OFST 12 +@@ -48,10 +52,8 @@ + PCIE_APP_IRN_RX_VDM_MSG | PCIE_APP_IRN_SYS_ERR_RC | \ + PCIE_APP_IRN_PM_TO_ACK | PCIE_APP_IRN_MSG_LTR | \ + PCIE_APP_IRN_BW_MGT | PCIE_APP_IRN_LINK_AUTO_BW_STAT | \ +- (PCIE_APP_INTX_OFST + PCI_INTERRUPT_INTA) | \ +- (PCIE_APP_INTX_OFST + PCI_INTERRUPT_INTB) | \ +- (PCIE_APP_INTX_OFST + PCI_INTERRUPT_INTC) | \ +- (PCIE_APP_INTX_OFST + PCI_INTERRUPT_INTD)) ++ PCIE_APP_IRN_INTA | PCIE_APP_IRN_INTB | \ ++ PCIE_APP_IRN_INTC | PCIE_APP_IRN_INTD) + + #define BUS_IATU_OFFSET SZ_256M + #define RESET_INTERVAL_MS 100 +diff --git a/drivers/pci/controller/dwc/pcie-tegra194.c b/drivers/pci/controller/dwc/pcie-tegra194.c +index 8dee6d3f33a70..fb1df066a2364 100644 +--- a/drivers/pci/controller/dwc/pcie-tegra194.c ++++ b/drivers/pci/controller/dwc/pcie-tegra194.c +@@ -1826,7 +1826,7 @@ static int tegra_pcie_ep_raise_msi_irq(struct tegra_pcie_dw *pcie, u16 irq) + if (unlikely(irq > 31)) + return -EINVAL; + +- appl_writel(pcie, (1 << irq), APPL_MSI_CTRL_1); ++ appl_writel(pcie, BIT(irq), APPL_MSI_CTRL_1); + + return 0; + } +diff --git a/drivers/pci/controller/pci-ftpci100.c b/drivers/pci/controller/pci-ftpci100.c +index da3cd216da007..aefef1986201a 100644 +--- a/drivers/pci/controller/pci-ftpci100.c ++++ b/drivers/pci/controller/pci-ftpci100.c +@@ -34,12 +34,12 @@ + * Special configuration registers directly in the first few words + * in I/O space. + */ +-#define PCI_IOSIZE 0x00 +-#define PCI_PROT 0x04 /* AHB protection */ +-#define PCI_CTRL 0x08 /* PCI control signal */ +-#define PCI_SOFTRST 0x10 /* Soft reset counter and response error enable */ +-#define PCI_CONFIG 0x28 /* PCI configuration command register */ +-#define PCI_DATA 0x2C ++#define FTPCI_IOSIZE 0x00 ++#define FTPCI_PROT 0x04 /* AHB protection */ ++#define FTPCI_CTRL 0x08 /* PCI control signal */ ++#define FTPCI_SOFTRST 0x10 /* Soft reset counter and response error enable */ ++#define FTPCI_CONFIG 0x28 /* PCI configuration command register */ ++#define FTPCI_DATA 0x2C + + #define FARADAY_PCI_STATUS_CMD 0x04 /* Status and command */ + #define FARADAY_PCI_PMC 0x40 /* Power management control */ +@@ -195,9 +195,9 @@ static int faraday_raw_pci_read_config(struct faraday_pci *p, int bus_number, + PCI_CONF_FUNCTION(PCI_FUNC(fn)) | + PCI_CONF_WHERE(config) | + PCI_CONF_ENABLE, +- p->base + PCI_CONFIG); ++ p->base + FTPCI_CONFIG); + +- *value = readl(p->base + PCI_DATA); ++ *value = readl(p->base + FTPCI_DATA); + + if (size == 1) + *value = (*value >> (8 * (config & 3))) & 0xFF; +@@ -230,17 +230,17 @@ static int faraday_raw_pci_write_config(struct faraday_pci *p, int bus_number, + PCI_CONF_FUNCTION(PCI_FUNC(fn)) | + PCI_CONF_WHERE(config) | + PCI_CONF_ENABLE, +- p->base + PCI_CONFIG); ++ p->base + FTPCI_CONFIG); + + switch (size) { + case 4: +- writel(value, p->base + PCI_DATA); ++ writel(value, p->base + FTPCI_DATA); + break; + case 2: +- writew(value, p->base + PCI_DATA + (config & 3)); ++ writew(value, p->base + FTPCI_DATA + (config & 3)); + break; + case 1: +- writeb(value, p->base + PCI_DATA + (config & 3)); ++ writeb(value, p->base + FTPCI_DATA + (config & 3)); + break; + default: + ret = PCIBIOS_BAD_REGISTER_NUMBER; +@@ -469,7 +469,7 @@ static int faraday_pci_probe(struct platform_device *pdev) + if (!faraday_res_to_memcfg(io->start - win->offset, + resource_size(io), &val)) { + /* setup I/O space size */ +- writel(val, p->base + PCI_IOSIZE); ++ writel(val, p->base + FTPCI_IOSIZE); + } else { + dev_err(dev, "illegal IO mem size\n"); + return -EINVAL; +@@ -477,11 +477,11 @@ static int faraday_pci_probe(struct platform_device *pdev) + } + + /* Setup hostbridge */ +- val = readl(p->base + PCI_CTRL); ++ val = readl(p->base + FTPCI_CTRL); + val |= PCI_COMMAND_IO; + val |= PCI_COMMAND_MEMORY; + val |= PCI_COMMAND_MASTER; +- writel(val, p->base + PCI_CTRL); ++ writel(val, p->base + FTPCI_CTRL); + /* Mask and clear all interrupts */ + faraday_raw_pci_write_config(p, 0, 0, FARADAY_PCI_CTRL2 + 2, 2, 0xF000); + if (variant->cascaded_irq) { +diff --git a/drivers/pci/controller/pci-hyperv.c b/drivers/pci/controller/pci-hyperv.c +index 7479edf3676c1..fd30f70c7560e 100644 +--- a/drivers/pci/controller/pci-hyperv.c ++++ b/drivers/pci/controller/pci-hyperv.c +@@ -444,7 +444,6 @@ enum hv_pcibus_state { + hv_pcibus_probed, + hv_pcibus_installed, + hv_pcibus_removing, +- hv_pcibus_removed, + hv_pcibus_maximum + }; + +@@ -3247,8 +3246,9 @@ static int hv_pci_bus_exit(struct hv_device *hdev, bool keep_devs) + struct pci_packet teardown_packet; + u8 buffer[sizeof(struct pci_message)]; + } pkt; +- struct hv_dr_state *dr; + struct hv_pci_compl comp_pkt; ++ struct hv_pci_dev *hpdev, *tmp; ++ unsigned long flags; + int ret; + + /* +@@ -3260,9 +3260,16 @@ static int hv_pci_bus_exit(struct hv_device *hdev, bool keep_devs) + + if (!keep_devs) { + /* Delete any children which might still exist. */ +- dr = kzalloc(sizeof(*dr), GFP_KERNEL); +- if (dr && hv_pci_start_relations_work(hbus, dr)) +- kfree(dr); ++ spin_lock_irqsave(&hbus->device_list_lock, flags); ++ list_for_each_entry_safe(hpdev, tmp, &hbus->children, list_entry) { ++ list_del(&hpdev->list_entry); ++ if (hpdev->pci_slot) ++ pci_destroy_slot(hpdev->pci_slot); ++ /* For the two refs got in new_pcichild_device() */ ++ put_pcichild(hpdev); ++ put_pcichild(hpdev); ++ } ++ spin_unlock_irqrestore(&hbus->device_list_lock, flags); + } + + ret = hv_send_resources_released(hdev); +@@ -3305,13 +3312,23 @@ static int hv_pci_remove(struct hv_device *hdev) + + hbus = hv_get_drvdata(hdev); + if (hbus->state == hv_pcibus_installed) { ++ tasklet_disable(&hdev->channel->callback_event); ++ hbus->state = hv_pcibus_removing; ++ tasklet_enable(&hdev->channel->callback_event); ++ destroy_workqueue(hbus->wq); ++ hbus->wq = NULL; ++ /* ++ * At this point, no work is running or can be scheduled ++ * on hbus-wq. We can't race with hv_pci_devices_present() ++ * or hv_pci_eject_device(), it's safe to proceed. ++ */ ++ + /* Remove the bus from PCI's point of view. */ + pci_lock_rescan_remove(); + pci_stop_root_bus(hbus->pci_bus); + hv_pci_remove_slots(hbus); + pci_remove_root_bus(hbus->pci_bus); + pci_unlock_rescan_remove(); +- hbus->state = hv_pcibus_removed; + } + + ret = hv_pci_bus_exit(hdev, false); +@@ -3326,7 +3343,6 @@ static int hv_pci_remove(struct hv_device *hdev) + irq_domain_free_fwnode(hbus->sysdata.fwnode); + put_hvpcibus(hbus); + wait_for_completion(&hbus->remove_event); +- destroy_workqueue(hbus->wq); + + hv_put_dom_num(hbus->sysdata.domain); + +diff --git a/drivers/pci/controller/pci-tegra.c b/drivers/pci/controller/pci-tegra.c +index 8fcabed7c6a67..1a2af963599ca 100644 +--- a/drivers/pci/controller/pci-tegra.c ++++ b/drivers/pci/controller/pci-tegra.c +@@ -2506,6 +2506,7 @@ static const struct of_device_id tegra_pcie_of_match[] = { + { .compatible = "nvidia,tegra20-pcie", .data = &tegra20_pcie }, + { }, + }; ++MODULE_DEVICE_TABLE(of, tegra_pcie_of_match); + + static void *tegra_pcie_ports_seq_start(struct seq_file *s, loff_t *pos) + { +diff --git a/drivers/pci/controller/pcie-iproc-msi.c b/drivers/pci/controller/pcie-iproc-msi.c +index eede4e8f3f75a..81b4effeb1309 100644 +--- a/drivers/pci/controller/pcie-iproc-msi.c ++++ b/drivers/pci/controller/pcie-iproc-msi.c +@@ -171,7 +171,7 @@ static struct irq_chip iproc_msi_irq_chip = { + + static struct msi_domain_info iproc_msi_domain_info = { + .flags = MSI_FLAG_USE_DEF_DOM_OPS | MSI_FLAG_USE_DEF_CHIP_OPS | +- MSI_FLAG_MULTI_PCI_MSI | MSI_FLAG_PCI_MSIX, ++ MSI_FLAG_PCI_MSIX, + .chip = &iproc_msi_irq_chip, + }; + +@@ -250,20 +250,23 @@ static int iproc_msi_irq_domain_alloc(struct irq_domain *domain, + struct iproc_msi *msi = domain->host_data; + int hwirq, i; + ++ if (msi->nr_cpus > 1 && nr_irqs > 1) ++ return -EINVAL; ++ + mutex_lock(&msi->bitmap_lock); + +- /* Allocate 'nr_cpus' number of MSI vectors each time */ +- hwirq = bitmap_find_next_zero_area(msi->bitmap, msi->nr_msi_vecs, 0, +- msi->nr_cpus, 0); +- if (hwirq < msi->nr_msi_vecs) { +- bitmap_set(msi->bitmap, hwirq, msi->nr_cpus); +- } else { +- mutex_unlock(&msi->bitmap_lock); +- return -ENOSPC; +- } ++ /* ++ * Allocate 'nr_irqs' multiplied by 'nr_cpus' number of MSI vectors ++ * each time ++ */ ++ hwirq = bitmap_find_free_region(msi->bitmap, msi->nr_msi_vecs, ++ order_base_2(msi->nr_cpus * nr_irqs)); + + mutex_unlock(&msi->bitmap_lock); + ++ if (hwirq < 0) ++ return -ENOSPC; ++ + for (i = 0; i < nr_irqs; i++) { + irq_domain_set_info(domain, virq + i, hwirq + i, + &iproc_msi_bottom_irq_chip, +@@ -284,7 +287,8 @@ static void iproc_msi_irq_domain_free(struct irq_domain *domain, + mutex_lock(&msi->bitmap_lock); + + hwirq = hwirq_to_canonical_hwirq(msi, data->hwirq); +- bitmap_clear(msi->bitmap, hwirq, msi->nr_cpus); ++ bitmap_release_region(msi->bitmap, hwirq, ++ order_base_2(msi->nr_cpus * nr_irqs)); + + mutex_unlock(&msi->bitmap_lock); + +@@ -539,6 +543,9 @@ int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node) + mutex_init(&msi->bitmap_lock); + msi->nr_cpus = num_possible_cpus(); + ++ if (msi->nr_cpus == 1) ++ iproc_msi_domain_info.flags |= MSI_FLAG_MULTI_PCI_MSI; ++ + msi->nr_irqs = of_irq_count(node); + if (!msi->nr_irqs) { + dev_err(pcie->dev, "found no MSI GIC interrupt\n"); +diff --git a/drivers/pci/controller/pcie-rockchip-host.c b/drivers/pci/controller/pcie-rockchip-host.c +index f1d08a1b1591f..78d04ac29cd56 100644 +--- a/drivers/pci/controller/pcie-rockchip-host.c ++++ b/drivers/pci/controller/pcie-rockchip-host.c +@@ -592,10 +592,6 @@ static int rockchip_pcie_parse_host_dt(struct rockchip_pcie *rockchip) + if (err) + return err; + +- err = rockchip_pcie_setup_irq(rockchip); +- if (err) +- return err; +- + rockchip->vpcie12v = devm_regulator_get_optional(dev, "vpcie12v"); + if (IS_ERR(rockchip->vpcie12v)) { + if (PTR_ERR(rockchip->vpcie12v) != -ENODEV) +@@ -973,8 +969,6 @@ static int rockchip_pcie_probe(struct platform_device *pdev) + if (err) + goto err_vpcie; + +- rockchip_pcie_enable_interrupts(rockchip); +- + err = rockchip_pcie_init_irq_domain(rockchip); + if (err < 0) + goto err_deinit_port; +@@ -992,6 +986,12 @@ static int rockchip_pcie_probe(struct platform_device *pdev) + bridge->sysdata = rockchip; + bridge->ops = &rockchip_pcie_ops; + ++ err = rockchip_pcie_setup_irq(rockchip); ++ if (err) ++ goto err_remove_irq_domain; ++ ++ rockchip_pcie_enable_interrupts(rockchip); ++ + err = pci_host_probe(bridge); + if (err < 0) + goto err_remove_irq_domain; +diff --git a/drivers/pci/ecam.c b/drivers/pci/ecam.c +index d2a1920bb0557..1c40d2506aef3 100644 +--- a/drivers/pci/ecam.c ++++ b/drivers/pci/ecam.c +@@ -32,7 +32,7 @@ struct pci_config_window *pci_ecam_create(struct device *dev, + struct pci_config_window *cfg; + unsigned int bus_range, bus_range_max, bsz; + struct resource *conflict; +- int i, err; ++ int err; + + if (busr->start > busr->end) + return ERR_PTR(-EINVAL); +@@ -50,6 +50,7 @@ struct pci_config_window *pci_ecam_create(struct device *dev, + cfg->busr.start = busr->start; + cfg->busr.end = busr->end; + cfg->busr.flags = IORESOURCE_BUS; ++ cfg->bus_shift = bus_shift; + bus_range = resource_size(&cfg->busr); + bus_range_max = resource_size(cfgres) >> bus_shift; + if (bus_range > bus_range_max) { +@@ -77,13 +78,6 @@ struct pci_config_window *pci_ecam_create(struct device *dev, + cfg->winp = kcalloc(bus_range, sizeof(*cfg->winp), GFP_KERNEL); + if (!cfg->winp) + goto err_exit_malloc; +- for (i = 0; i < bus_range; i++) { +- cfg->winp[i] = +- pci_remap_cfgspace(cfgres->start + i * bsz, +- bsz); +- if (!cfg->winp[i]) +- goto err_exit_iomap; +- } + } else { + cfg->win = pci_remap_cfgspace(cfgres->start, bus_range * bsz); + if (!cfg->win) +@@ -129,6 +123,44 @@ void pci_ecam_free(struct pci_config_window *cfg) + } + EXPORT_SYMBOL_GPL(pci_ecam_free); + ++static int pci_ecam_add_bus(struct pci_bus *bus) ++{ ++ struct pci_config_window *cfg = bus->sysdata; ++ unsigned int bsz = 1 << cfg->bus_shift; ++ unsigned int busn = bus->number; ++ phys_addr_t start; ++ ++ if (!per_bus_mapping) ++ return 0; ++ ++ if (busn < cfg->busr.start || busn > cfg->busr.end) ++ return -EINVAL; ++ ++ busn -= cfg->busr.start; ++ start = cfg->res.start + busn * bsz; ++ ++ cfg->winp[busn] = pci_remap_cfgspace(start, bsz); ++ if (!cfg->winp[busn]) ++ return -ENOMEM; ++ ++ return 0; ++} ++ ++static void pci_ecam_remove_bus(struct pci_bus *bus) ++{ ++ struct pci_config_window *cfg = bus->sysdata; ++ unsigned int busn = bus->number; ++ ++ if (!per_bus_mapping || busn < cfg->busr.start || busn > cfg->busr.end) ++ return; ++ ++ busn -= cfg->busr.start; ++ if (cfg->winp[busn]) { ++ iounmap(cfg->winp[busn]); ++ cfg->winp[busn] = NULL; ++ } ++} ++ + /* + * Function to implement the pci_ops ->map_bus method + */ +@@ -167,6 +199,8 @@ EXPORT_SYMBOL_GPL(pci_ecam_map_bus); + /* ECAM ops */ + const struct pci_ecam_ops pci_generic_ecam_ops = { + .pci_ops = { ++ .add_bus = pci_ecam_add_bus, ++ .remove_bus = pci_ecam_remove_bus, + .map_bus = pci_ecam_map_bus, + .read = pci_generic_config_read, + .write = pci_generic_config_write, +@@ -178,6 +212,8 @@ EXPORT_SYMBOL_GPL(pci_generic_ecam_ops); + /* ECAM ops for 32-bit access only (non-compliant) */ + const struct pci_ecam_ops pci_32b_ops = { + .pci_ops = { ++ .add_bus = pci_ecam_add_bus, ++ .remove_bus = pci_ecam_remove_bus, + .map_bus = pci_ecam_map_bus, + .read = pci_generic_config_read32, + .write = pci_generic_config_write32, +@@ -187,6 +223,8 @@ const struct pci_ecam_ops pci_32b_ops = { + /* ECAM ops for 32-bit read only (non-compliant) */ + const struct pci_ecam_ops pci_32b_read_ops = { + .pci_ops = { ++ .add_bus = pci_ecam_add_bus, ++ .remove_bus = pci_ecam_remove_bus, + .map_bus = pci_ecam_map_bus, + .read = pci_generic_config_read32, + .write = pci_generic_config_write, +diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c +index fb3840e222add..9d06939736c0f 100644 +--- a/drivers/pci/hotplug/pciehp_hpc.c ++++ b/drivers/pci/hotplug/pciehp_hpc.c +@@ -563,6 +563,32 @@ void pciehp_power_off_slot(struct controller *ctrl) + PCI_EXP_SLTCTL_PWR_OFF); + } + ++static void pciehp_ignore_dpc_link_change(struct controller *ctrl, ++ struct pci_dev *pdev, int irq) ++{ ++ /* ++ * Ignore link changes which occurred while waiting for DPC recovery. ++ * Could be several if DPC triggered multiple times consecutively. ++ */ ++ synchronize_hardirq(irq); ++ atomic_and(~PCI_EXP_SLTSTA_DLLSC, &ctrl->pending_events); ++ if (pciehp_poll_mode) ++ pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, ++ PCI_EXP_SLTSTA_DLLSC); ++ ctrl_info(ctrl, "Slot(%s): Link Down/Up ignored (recovered by DPC)\n", ++ slot_name(ctrl)); ++ ++ /* ++ * If the link is unexpectedly down after successful recovery, ++ * the corresponding link change may have been ignored above. ++ * Synthesize it to ensure that it is acted on. ++ */ ++ down_read(&ctrl->reset_lock); ++ if (!pciehp_check_link_active(ctrl)) ++ pciehp_request(ctrl, PCI_EXP_SLTSTA_DLLSC); ++ up_read(&ctrl->reset_lock); ++} ++ + static irqreturn_t pciehp_isr(int irq, void *dev_id) + { + struct controller *ctrl = (struct controller *)dev_id; +@@ -706,6 +732,16 @@ static irqreturn_t pciehp_ist(int irq, void *dev_id) + PCI_EXP_SLTCTL_ATTN_IND_ON); + } + ++ /* ++ * Ignore Link Down/Up events caused by Downstream Port Containment ++ * if recovery from the error succeeded. ++ */ ++ if ((events & PCI_EXP_SLTSTA_DLLSC) && pci_dpc_recovered(pdev) && ++ ctrl->state == ON_STATE) { ++ events &= ~PCI_EXP_SLTSTA_DLLSC; ++ pciehp_ignore_dpc_link_change(ctrl, pdev, irq); ++ } ++ + /* + * Disable requests have higher priority than Presence Detect Changed + * or Data Link Layer State Changed events. +diff --git a/drivers/pci/p2pdma.c b/drivers/pci/p2pdma.c +index 1963826303631..c49c13a5fedc7 100644 +--- a/drivers/pci/p2pdma.c ++++ b/drivers/pci/p2pdma.c +@@ -308,10 +308,41 @@ static const struct pci_p2pdma_whitelist_entry { + {} + }; + ++/* ++ * This lookup function tries to find the PCI device corresponding to a given ++ * host bridge. ++ * ++ * It assumes the host bridge device is the first PCI device in the ++ * bus->devices list and that the devfn is 00.0. These assumptions should hold ++ * for all the devices in the whitelist above. ++ * ++ * This function is equivalent to pci_get_slot(host->bus, 0), however it does ++ * not take the pci_bus_sem lock seeing __host_bridge_whitelist() must not ++ * sleep. ++ * ++ * For this to be safe, the caller should hold a reference to a device on the ++ * bridge, which should ensure the host_bridge device will not be freed ++ * or removed from the head of the devices list. ++ */ ++static struct pci_dev *pci_host_bridge_dev(struct pci_host_bridge *host) ++{ ++ struct pci_dev *root; ++ ++ root = list_first_entry_or_null(&host->bus->devices, ++ struct pci_dev, bus_list); ++ ++ if (!root) ++ return NULL; ++ if (root->devfn != PCI_DEVFN(0, 0)) ++ return NULL; ++ ++ return root; ++} ++ + static bool __host_bridge_whitelist(struct pci_host_bridge *host, + bool same_host_bridge) + { +- struct pci_dev *root = pci_get_slot(host->bus, PCI_DEVFN(0, 0)); ++ struct pci_dev *root = pci_host_bridge_dev(host); + const struct pci_p2pdma_whitelist_entry *entry; + unsigned short vendor, device; + +@@ -320,7 +351,6 @@ static bool __host_bridge_whitelist(struct pci_host_bridge *host, + + vendor = root->vendor; + device = root->device; +- pci_dev_put(root); + + for (entry = pci_p2pdma_whitelist; entry->vendor; entry++) { + if (vendor != entry->vendor || device != entry->device) +diff --git a/drivers/pci/pci-label.c b/drivers/pci/pci-label.c +index 781e45cf60d1c..cd84cf52a92e1 100644 +--- a/drivers/pci/pci-label.c ++++ b/drivers/pci/pci-label.c +@@ -162,7 +162,7 @@ static void dsm_label_utf16s_to_utf8s(union acpi_object *obj, char *buf) + len = utf16s_to_utf8s((const wchar_t *)obj->buffer.pointer, + obj->buffer.length, + UTF16_LITTLE_ENDIAN, +- buf, PAGE_SIZE); ++ buf, PAGE_SIZE - 1); + buf[len] = '\n'; + } + +diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h +index 9684b468267f2..e5ae5e8604310 100644 +--- a/drivers/pci/pci.h ++++ b/drivers/pci/pci.h +@@ -392,6 +392,8 @@ static inline bool pci_dev_is_disconnected(const struct pci_dev *dev) + + /* pci_dev priv_flags */ + #define PCI_DEV_ADDED 0 ++#define PCI_DPC_RECOVERED 1 ++#define PCI_DPC_RECOVERING 2 + + static inline void pci_dev_assign_added(struct pci_dev *dev, bool added) + { +@@ -446,10 +448,12 @@ void pci_restore_dpc_state(struct pci_dev *dev); + void pci_dpc_init(struct pci_dev *pdev); + void dpc_process_error(struct pci_dev *pdev); + pci_ers_result_t dpc_reset_link(struct pci_dev *pdev); ++bool pci_dpc_recovered(struct pci_dev *pdev); + #else + static inline void pci_save_dpc_state(struct pci_dev *dev) {} + static inline void pci_restore_dpc_state(struct pci_dev *dev) {} + static inline void pci_dpc_init(struct pci_dev *pdev) {} ++static inline bool pci_dpc_recovered(struct pci_dev *pdev) { return false; } + #endif + + #ifdef CONFIG_PCIEPORTBUS +diff --git a/drivers/pci/pcie/dpc.c b/drivers/pci/pcie/dpc.c +index e05aba86a3179..c556e7beafe38 100644 +--- a/drivers/pci/pcie/dpc.c ++++ b/drivers/pci/pcie/dpc.c +@@ -71,6 +71,58 @@ void pci_restore_dpc_state(struct pci_dev *dev) + pci_write_config_word(dev, dev->dpc_cap + PCI_EXP_DPC_CTL, *cap); + } + ++static DECLARE_WAIT_QUEUE_HEAD(dpc_completed_waitqueue); ++ ++#ifdef CONFIG_HOTPLUG_PCI_PCIE ++static bool dpc_completed(struct pci_dev *pdev) ++{ ++ u16 status; ++ ++ pci_read_config_word(pdev, pdev->dpc_cap + PCI_EXP_DPC_STATUS, &status); ++ if ((status != 0xffff) && (status & PCI_EXP_DPC_STATUS_TRIGGER)) ++ return false; ++ ++ if (test_bit(PCI_DPC_RECOVERING, &pdev->priv_flags)) ++ return false; ++ ++ return true; ++} ++ ++/** ++ * pci_dpc_recovered - whether DPC triggered and has recovered successfully ++ * @pdev: PCI device ++ * ++ * Return true if DPC was triggered for @pdev and has recovered successfully. ++ * Wait for recovery if it hasn't completed yet. Called from the PCIe hotplug ++ * driver to recognize and ignore Link Down/Up events caused by DPC. ++ */ ++bool pci_dpc_recovered(struct pci_dev *pdev) ++{ ++ struct pci_host_bridge *host; ++ ++ if (!pdev->dpc_cap) ++ return false; ++ ++ /* ++ * Synchronization between hotplug and DPC is not supported ++ * if DPC is owned by firmware and EDR is not enabled. ++ */ ++ host = pci_find_host_bridge(pdev->bus); ++ if (!host->native_dpc && !IS_ENABLED(CONFIG_PCIE_EDR)) ++ return false; ++ ++ /* ++ * Need a timeout in case DPC never completes due to failure of ++ * dpc_wait_rp_inactive(). The spec doesn't mandate a time limit, ++ * but reports indicate that DPC completes within 4 seconds. ++ */ ++ wait_event_timeout(dpc_completed_waitqueue, dpc_completed(pdev), ++ msecs_to_jiffies(4000)); ++ ++ return test_and_clear_bit(PCI_DPC_RECOVERED, &pdev->priv_flags); ++} ++#endif /* CONFIG_HOTPLUG_PCI_PCIE */ ++ + static int dpc_wait_rp_inactive(struct pci_dev *pdev) + { + unsigned long timeout = jiffies + HZ; +@@ -91,8 +143,11 @@ static int dpc_wait_rp_inactive(struct pci_dev *pdev) + + pci_ers_result_t dpc_reset_link(struct pci_dev *pdev) + { ++ pci_ers_result_t ret; + u16 cap; + ++ set_bit(PCI_DPC_RECOVERING, &pdev->priv_flags); ++ + /* + * DPC disables the Link automatically in hardware, so it has + * already been reset by the time we get here. +@@ -106,18 +161,27 @@ pci_ers_result_t dpc_reset_link(struct pci_dev *pdev) + if (!pcie_wait_for_link(pdev, false)) + pci_info(pdev, "Data Link Layer Link Active not cleared in 1000 msec\n"); + +- if (pdev->dpc_rp_extensions && dpc_wait_rp_inactive(pdev)) +- return PCI_ERS_RESULT_DISCONNECT; ++ if (pdev->dpc_rp_extensions && dpc_wait_rp_inactive(pdev)) { ++ clear_bit(PCI_DPC_RECOVERED, &pdev->priv_flags); ++ ret = PCI_ERS_RESULT_DISCONNECT; ++ goto out; ++ } + + pci_write_config_word(pdev, cap + PCI_EXP_DPC_STATUS, + PCI_EXP_DPC_STATUS_TRIGGER); + + if (!pcie_wait_for_link(pdev, true)) { + pci_info(pdev, "Data Link Layer Link Active not set in 1000 msec\n"); +- return PCI_ERS_RESULT_DISCONNECT; ++ clear_bit(PCI_DPC_RECOVERED, &pdev->priv_flags); ++ ret = PCI_ERS_RESULT_DISCONNECT; ++ } else { ++ set_bit(PCI_DPC_RECOVERED, &pdev->priv_flags); ++ ret = PCI_ERS_RESULT_RECOVERED; + } +- +- return PCI_ERS_RESULT_RECOVERED; ++out: ++ clear_bit(PCI_DPC_RECOVERING, &pdev->priv_flags); ++ wake_up_all(&dpc_completed_waitqueue); ++ return ret; + } + + static void dpc_process_rp_pio_error(struct pci_dev *pdev) +diff --git a/drivers/phy/intel/phy-intel-keembay-emmc.c b/drivers/phy/intel/phy-intel-keembay-emmc.c +index eb7c635ed89ae..0eb11ac7c2e2e 100644 +--- a/drivers/phy/intel/phy-intel-keembay-emmc.c ++++ b/drivers/phy/intel/phy-intel-keembay-emmc.c +@@ -95,7 +95,8 @@ static int keembay_emmc_phy_power(struct phy *phy, bool on_off) + else + freqsel = 0x0; + +- if (mhz < 50 || mhz > 200) ++ /* Check for EMMC clock rate*/ ++ if (mhz > 175) + dev_warn(&phy->dev, "Unsupported rate: %d MHz\n", mhz); + + /* +diff --git a/drivers/power/reset/gpio-poweroff.c b/drivers/power/reset/gpio-poweroff.c +index c5067eb753706..1c5af2fef1423 100644 +--- a/drivers/power/reset/gpio-poweroff.c ++++ b/drivers/power/reset/gpio-poweroff.c +@@ -90,6 +90,7 @@ static const struct of_device_id of_gpio_poweroff_match[] = { + { .compatible = "gpio-poweroff", }, + {}, + }; ++MODULE_DEVICE_TABLE(of, of_gpio_poweroff_match); + + static struct platform_driver gpio_poweroff_driver = { + .probe = gpio_poweroff_probe, +diff --git a/drivers/power/reset/regulator-poweroff.c b/drivers/power/reset/regulator-poweroff.c +index f697088e0ad1a..20701203935f0 100644 +--- a/drivers/power/reset/regulator-poweroff.c ++++ b/drivers/power/reset/regulator-poweroff.c +@@ -64,6 +64,7 @@ static const struct of_device_id of_regulator_poweroff_match[] = { + { .compatible = "regulator-poweroff", }, + {}, + }; ++MODULE_DEVICE_TABLE(of, of_regulator_poweroff_match); + + static struct platform_driver regulator_poweroff_driver = { + .probe = regulator_poweroff_probe, +diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig +index 006b95eca6739..5207beea9d232 100644 +--- a/drivers/power/supply/Kconfig ++++ b/drivers/power/supply/Kconfig +@@ -712,7 +712,8 @@ config BATTERY_GOLDFISH + + config BATTERY_RT5033 + tristate "RT5033 fuel gauge support" +- depends on MFD_RT5033 ++ depends on I2C ++ select REGMAP_I2C + help + This adds support for battery fuel gauge in Richtek RT5033 PMIC. + The fuelgauge calculates and determines the battery state of charge +diff --git a/drivers/power/supply/ab8500_btemp.c b/drivers/power/supply/ab8500_btemp.c +index d20345386b1e6..69f67edf83c55 100644 +--- a/drivers/power/supply/ab8500_btemp.c ++++ b/drivers/power/supply/ab8500_btemp.c +@@ -1135,6 +1135,7 @@ static const struct of_device_id ab8500_btemp_match[] = { + { .compatible = "stericsson,ab8500-btemp", }, + { }, + }; ++MODULE_DEVICE_TABLE(of, ab8500_btemp_match); + + static struct platform_driver ab8500_btemp_driver = { + .probe = ab8500_btemp_probe, +diff --git a/drivers/power/supply/ab8500_charger.c b/drivers/power/supply/ab8500_charger.c +index ac77c8882d17a..163d6098e8e0f 100644 +--- a/drivers/power/supply/ab8500_charger.c ++++ b/drivers/power/supply/ab8500_charger.c +@@ -413,6 +413,14 @@ disable_otp: + static void ab8500_power_supply_changed(struct ab8500_charger *di, + struct power_supply *psy) + { ++ /* ++ * This happens if we get notifications or interrupts and ++ * the platform has been configured not to support one or ++ * other type of charging. ++ */ ++ if (!psy) ++ return; ++ + if (di->autopower_cfg) { + if (!di->usb.charger_connected && + !di->ac.charger_connected && +@@ -439,7 +447,15 @@ static void ab8500_charger_set_usb_connected(struct ab8500_charger *di, + if (!connected) + di->flags.vbus_drop_end = false; + +- sysfs_notify(&di->usb_chg.psy->dev.kobj, NULL, "present"); ++ /* ++ * Sometimes the platform is configured not to support ++ * USB charging and no psy has been created, but we still ++ * will get these notifications. ++ */ ++ if (di->usb_chg.psy) { ++ sysfs_notify(&di->usb_chg.psy->dev.kobj, NULL, ++ "present"); ++ } + + if (connected) { + mutex_lock(&di->charger_attached_mutex); +@@ -3651,6 +3667,7 @@ static const struct of_device_id ab8500_charger_match[] = { + { .compatible = "stericsson,ab8500-charger", }, + { }, + }; ++MODULE_DEVICE_TABLE(of, ab8500_charger_match); + + static struct platform_driver ab8500_charger_driver = { + .probe = ab8500_charger_probe, +diff --git a/drivers/power/supply/ab8500_fg.c b/drivers/power/supply/ab8500_fg.c +index 06ff42c71f241..2fe41091fa03f 100644 +--- a/drivers/power/supply/ab8500_fg.c ++++ b/drivers/power/supply/ab8500_fg.c +@@ -3218,6 +3218,7 @@ static const struct of_device_id ab8500_fg_match[] = { + { .compatible = "stericsson,ab8500-fg", }, + { }, + }; ++MODULE_DEVICE_TABLE(of, ab8500_fg_match); + + static struct platform_driver ab8500_fg_driver = { + .probe = ab8500_fg_probe, +diff --git a/drivers/power/supply/axp288_fuel_gauge.c b/drivers/power/supply/axp288_fuel_gauge.c +index 39e16ecb76386..37af0e216bc3a 100644 +--- a/drivers/power/supply/axp288_fuel_gauge.c ++++ b/drivers/power/supply/axp288_fuel_gauge.c +@@ -723,15 +723,6 @@ static const struct dmi_system_id axp288_fuel_gauge_blacklist[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "MEEGOPAD T02"), + }, + }, +- { +- /* Meegopad T08 */ +- .matches = { +- DMI_MATCH(DMI_SYS_VENDOR, "Default string"), +- DMI_MATCH(DMI_BOARD_VENDOR, "To be filled by OEM."), +- DMI_MATCH(DMI_BOARD_NAME, "T3 MRD"), +- DMI_MATCH(DMI_BOARD_VERSION, "V1.1"), +- }, +- }, + { /* Mele PCG03 Mini PC */ + .matches = { + DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "Mini PC"), +@@ -745,6 +736,15 @@ static const struct dmi_system_id axp288_fuel_gauge_blacklist[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"), + } + }, ++ { ++ /* Various Ace PC/Meegopad/MinisForum/Wintel Mini-PCs/HDMI-sticks */ ++ .matches = { ++ DMI_MATCH(DMI_BOARD_NAME, "T3 MRD"), ++ DMI_MATCH(DMI_CHASSIS_TYPE, "3"), ++ DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."), ++ DMI_MATCH(DMI_BIOS_VERSION, "5.11"), ++ }, ++ }, + {} + }; + +diff --git a/drivers/power/supply/charger-manager.c b/drivers/power/supply/charger-manager.c +index 4dea8ecd70bca..331803c221da8 100644 +--- a/drivers/power/supply/charger-manager.c ++++ b/drivers/power/supply/charger-manager.c +@@ -1279,6 +1279,7 @@ static const struct of_device_id charger_manager_match[] = { + }, + {}, + }; ++MODULE_DEVICE_TABLE(of, charger_manager_match); + + static struct charger_desc *of_cm_parse_desc(struct device *dev) + { +diff --git a/drivers/power/supply/max17042_battery.c b/drivers/power/supply/max17042_battery.c +index 79d4b5988360a..8117ecabe31cb 100644 +--- a/drivers/power/supply/max17042_battery.c ++++ b/drivers/power/supply/max17042_battery.c +@@ -1104,7 +1104,7 @@ static int max17042_probe(struct i2c_client *client, + } + + if (client->irq) { +- unsigned int flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT; ++ unsigned int flags = IRQF_ONESHOT; + + /* + * On ACPI systems the IRQ may be handled by ACPI-event code, +diff --git a/drivers/power/supply/rt5033_battery.c b/drivers/power/supply/rt5033_battery.c +index f330452341f02..9ad0afe83d1b7 100644 +--- a/drivers/power/supply/rt5033_battery.c ++++ b/drivers/power/supply/rt5033_battery.c +@@ -164,9 +164,16 @@ static const struct i2c_device_id rt5033_battery_id[] = { + }; + MODULE_DEVICE_TABLE(i2c, rt5033_battery_id); + ++static const struct of_device_id rt5033_battery_of_match[] = { ++ { .compatible = "richtek,rt5033-battery", }, ++ { } ++}; ++MODULE_DEVICE_TABLE(of, rt5033_battery_of_match); ++ + static struct i2c_driver rt5033_battery_driver = { + .driver = { + .name = "rt5033-battery", ++ .of_match_table = rt5033_battery_of_match, + }, + .probe = rt5033_battery_probe, + .remove = rt5033_battery_remove, +diff --git a/drivers/power/supply/sc2731_charger.c b/drivers/power/supply/sc2731_charger.c +index 335cb857ef307..288b79836c139 100644 +--- a/drivers/power/supply/sc2731_charger.c ++++ b/drivers/power/supply/sc2731_charger.c +@@ -524,6 +524,7 @@ static const struct of_device_id sc2731_charger_of_match[] = { + { .compatible = "sprd,sc2731-charger", }, + { } + }; ++MODULE_DEVICE_TABLE(of, sc2731_charger_of_match); + + static struct platform_driver sc2731_charger_driver = { + .driver = { +diff --git a/drivers/power/supply/sc27xx_fuel_gauge.c b/drivers/power/supply/sc27xx_fuel_gauge.c +index 9c627618c2249..1ae8374e1cebe 100644 +--- a/drivers/power/supply/sc27xx_fuel_gauge.c ++++ b/drivers/power/supply/sc27xx_fuel_gauge.c +@@ -1342,6 +1342,7 @@ static const struct of_device_id sc27xx_fgu_of_match[] = { + { .compatible = "sprd,sc2731-fgu", }, + { } + }; ++MODULE_DEVICE_TABLE(of, sc27xx_fgu_of_match); + + static struct platform_driver sc27xx_fgu_driver = { + .probe = sc27xx_fgu_probe, +diff --git a/drivers/pwm/pwm-img.c b/drivers/pwm/pwm-img.c +index 6faf5b5a55842..37200850cdc6d 100644 +--- a/drivers/pwm/pwm-img.c ++++ b/drivers/pwm/pwm-img.c +@@ -156,7 +156,7 @@ static int img_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm) + struct img_pwm_chip *pwm_chip = to_img_pwm_chip(chip); + int ret; + +- ret = pm_runtime_get_sync(chip->dev); ++ ret = pm_runtime_resume_and_get(chip->dev); + if (ret < 0) + return ret; + +diff --git a/drivers/pwm/pwm-imx1.c b/drivers/pwm/pwm-imx1.c +index 727e0d3e249ea..cd48136e5a53b 100644 +--- a/drivers/pwm/pwm-imx1.c ++++ b/drivers/pwm/pwm-imx1.c +@@ -169,8 +169,6 @@ static int pwm_imx1_remove(struct platform_device *pdev) + { + struct pwm_imx1_chip *imx = platform_get_drvdata(pdev); + +- pwm_imx1_clk_disable_unprepare(&imx->chip); +- + return pwmchip_remove(&imx->chip); + } + +diff --git a/drivers/pwm/pwm-spear.c b/drivers/pwm/pwm-spear.c +index f63b54aae1b48..7467e03d2fb53 100644 +--- a/drivers/pwm/pwm-spear.c ++++ b/drivers/pwm/pwm-spear.c +@@ -229,10 +229,6 @@ static int spear_pwm_probe(struct platform_device *pdev) + static int spear_pwm_remove(struct platform_device *pdev) + { + struct spear_pwm_chip *pc = platform_get_drvdata(pdev); +- int i; +- +- for (i = 0; i < NUM_PWM; i++) +- pwm_disable(&pc->chip.pwms[i]); + + /* clk was prepared in probe, hence unprepare it here */ + clk_unprepare(pc->clk); +diff --git a/drivers/pwm/pwm-tegra.c b/drivers/pwm/pwm-tegra.c +index 55bc63d5a0ae1..6d8e324864fa7 100644 +--- a/drivers/pwm/pwm-tegra.c ++++ b/drivers/pwm/pwm-tegra.c +@@ -301,7 +301,6 @@ static int tegra_pwm_probe(struct platform_device *pdev) + static int tegra_pwm_remove(struct platform_device *pdev) + { + struct tegra_pwm_chip *pc = platform_get_drvdata(pdev); +- unsigned int i; + int err; + + if (WARN_ON(!pc)) +@@ -311,18 +310,6 @@ static int tegra_pwm_remove(struct platform_device *pdev) + if (err < 0) + return err; + +- for (i = 0; i < pc->chip.npwm; i++) { +- struct pwm_device *pwm = &pc->chip.pwms[i]; +- +- if (!pwm_is_enabled(pwm)) +- if (clk_prepare_enable(pc->clk) < 0) +- continue; +- +- pwm_writel(pc, i, 0); +- +- clk_disable_unprepare(pc->clk); +- } +- + reset_control_assert(pc->rst); + clk_disable_unprepare(pc->clk); + +diff --git a/drivers/remoteproc/remoteproc_cdev.c b/drivers/remoteproc/remoteproc_cdev.c +index b19ea3057bde4..ff92ed25d8b0a 100644 +--- a/drivers/remoteproc/remoteproc_cdev.c ++++ b/drivers/remoteproc/remoteproc_cdev.c +@@ -111,7 +111,7 @@ int rproc_char_device_add(struct rproc *rproc) + + void rproc_char_device_remove(struct rproc *rproc) + { +- __unregister_chrdev(MAJOR(rproc->dev.devt), rproc->index, 1, "remoteproc"); ++ cdev_del(&rproc->cdev); + } + + void __init rproc_init_cdev(void) +diff --git a/drivers/remoteproc/remoteproc_core.c b/drivers/remoteproc/remoteproc_core.c +index ab150765d1243..d9d2a240dd589 100644 +--- a/drivers/remoteproc/remoteproc_core.c ++++ b/drivers/remoteproc/remoteproc_core.c +@@ -2357,7 +2357,6 @@ int rproc_del(struct rproc *rproc) + mutex_unlock(&rproc->lock); + + rproc_delete_debug_dir(rproc); +- rproc_char_device_remove(rproc); + + /* the rproc is downref'ed as soon as it's removed from the klist */ + mutex_lock(&rproc_list_mutex); +@@ -2368,6 +2367,7 @@ int rproc_del(struct rproc *rproc) + synchronize_rcu(); + + device_del(&rproc->dev); ++ rproc_char_device_remove(rproc); + + return 0; + } +diff --git a/drivers/remoteproc/ti_k3_r5_remoteproc.c b/drivers/remoteproc/ti_k3_r5_remoteproc.c +index 62b5a4c294562..914db1d1f6381 100644 +--- a/drivers/remoteproc/ti_k3_r5_remoteproc.c ++++ b/drivers/remoteproc/ti_k3_r5_remoteproc.c +@@ -1272,9 +1272,9 @@ static int k3_r5_core_of_init(struct platform_device *pdev) + + core->tsp = k3_r5_core_of_get_tsp(dev, core->ti_sci); + if (IS_ERR(core->tsp)) { ++ ret = PTR_ERR(core->tsp); + dev_err(dev, "failed to construct ti-sci proc control, ret = %d\n", + ret); +- ret = PTR_ERR(core->tsp); + goto err; + } + +diff --git a/drivers/reset/Kconfig b/drivers/reset/Kconfig +index 4171c6f763858..c5dc1503de790 100644 +--- a/drivers/reset/Kconfig ++++ b/drivers/reset/Kconfig +@@ -59,7 +59,8 @@ config RESET_BRCMSTB + config RESET_BRCMSTB_RESCAL + bool "Broadcom STB RESCAL reset controller" + depends on HAS_IOMEM +- default ARCH_BRCMSTB || COMPILE_TEST ++ depends on ARCH_BRCMSTB || COMPILE_TEST ++ default ARCH_BRCMSTB + help + This enables the RESCAL reset controller for SATA, PCIe0, or PCIe1 on + BCM7216. +@@ -82,6 +83,7 @@ config RESET_IMX7 + + config RESET_INTEL_GW + bool "Intel Reset Controller Driver" ++ depends on X86 || COMPILE_TEST + depends on OF && HAS_IOMEM + select REGMAP_MMIO + help +diff --git a/drivers/reset/core.c b/drivers/reset/core.c +index dbf881b586d9d..fd7e1a3525f45 100644 +--- a/drivers/reset/core.c ++++ b/drivers/reset/core.c +@@ -640,7 +640,10 @@ static struct reset_control *__reset_control_get_internal( + if (!rstc) + return ERR_PTR(-ENOMEM); + +- try_module_get(rcdev->owner); ++ if (!try_module_get(rcdev->owner)) { ++ kfree(rstc); ++ return ERR_PTR(-ENODEV); ++ } + + rstc->rcdev = rcdev; + list_add(&rstc->list, &rcdev->reset_control_head); +diff --git a/drivers/reset/reset-a10sr.c b/drivers/reset/reset-a10sr.c +index 7eacc89382f8a..99b3bc8382f35 100644 +--- a/drivers/reset/reset-a10sr.c ++++ b/drivers/reset/reset-a10sr.c +@@ -118,6 +118,7 @@ static struct platform_driver a10sr_reset_driver = { + .probe = a10sr_reset_probe, + .driver = { + .name = "altr_a10sr_reset", ++ .of_match_table = a10sr_reset_of_match, + }, + }; + module_platform_driver(a10sr_reset_driver); +diff --git a/drivers/reset/reset-brcmstb.c b/drivers/reset/reset-brcmstb.c +index f213264c8567b..42c9d5241c530 100644 +--- a/drivers/reset/reset-brcmstb.c ++++ b/drivers/reset/reset-brcmstb.c +@@ -111,6 +111,7 @@ static const struct of_device_id brcmstb_reset_of_match[] = { + { .compatible = "brcm,brcmstb-reset" }, + { /* sentinel */ } + }; ++MODULE_DEVICE_TABLE(of, brcmstb_reset_of_match); + + static struct platform_driver brcmstb_reset_driver = { + .probe = brcmstb_reset_probe, +diff --git a/drivers/rtc/proc.c b/drivers/rtc/proc.c +index 73344598fc1be..cbcdbb19d848e 100644 +--- a/drivers/rtc/proc.c ++++ b/drivers/rtc/proc.c +@@ -23,8 +23,8 @@ static bool is_rtc_hctosys(struct rtc_device *rtc) + int size; + char name[NAME_SIZE]; + +- size = scnprintf(name, NAME_SIZE, "rtc%d", rtc->id); +- if (size > NAME_SIZE) ++ size = snprintf(name, NAME_SIZE, "rtc%d", rtc->id); ++ if (size >= NAME_SIZE) + return false; + + return !strncmp(name, CONFIG_RTC_HCTOSYS_DEVICE, NAME_SIZE); +diff --git a/drivers/s390/char/sclp_vt220.c b/drivers/s390/char/sclp_vt220.c +index 047f812d1a1c8..71ed1bf155984 100644 +--- a/drivers/s390/char/sclp_vt220.c ++++ b/drivers/s390/char/sclp_vt220.c +@@ -35,8 +35,8 @@ + #define SCLP_VT220_MINOR 65 + #define SCLP_VT220_DRIVER_NAME "sclp_vt220" + #define SCLP_VT220_DEVICE_NAME "ttysclp" +-#define SCLP_VT220_CONSOLE_NAME "ttyS" +-#define SCLP_VT220_CONSOLE_INDEX 1 /* console=ttyS1 */ ++#define SCLP_VT220_CONSOLE_NAME "ttysclp" ++#define SCLP_VT220_CONSOLE_INDEX 0 /* console=ttysclp0 */ + + /* Representation of a single write request */ + struct sclp_vt220_request { +diff --git a/drivers/s390/scsi/zfcp_sysfs.c b/drivers/s390/scsi/zfcp_sysfs.c +index 8d9662e8b7179..3c7f5ecf5511d 100644 +--- a/drivers/s390/scsi/zfcp_sysfs.c ++++ b/drivers/s390/scsi/zfcp_sysfs.c +@@ -487,6 +487,7 @@ static ssize_t zfcp_sysfs_port_fc_security_show(struct device *dev, + if (0 == (status & ZFCP_STATUS_COMMON_OPEN) || + 0 == (status & ZFCP_STATUS_COMMON_UNBLOCKED) || + 0 == (status & ZFCP_STATUS_PORT_PHYS_OPEN) || ++ 0 != (status & ZFCP_STATUS_PORT_LINK_TEST) || + 0 != (status & ZFCP_STATUS_COMMON_ERP_FAILED) || + 0 != (status & ZFCP_STATUS_COMMON_ACCESS_BOXED)) + i = sprintf(buf, "unknown\n"); +diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c +index 4b79661275c90..42e494a7106cd 100644 +--- a/drivers/scsi/arcmsr/arcmsr_hba.c ++++ b/drivers/scsi/arcmsr/arcmsr_hba.c +@@ -1923,8 +1923,12 @@ static void arcmsr_post_ccb(struct AdapterControlBlock *acb, struct CommandContr + + if (ccb->arc_cdb_size <= 0x300) + arc_cdb_size = (ccb->arc_cdb_size - 1) >> 6 | 1; +- else +- arc_cdb_size = (((ccb->arc_cdb_size + 0xff) >> 8) + 2) << 1 | 1; ++ else { ++ arc_cdb_size = ((ccb->arc_cdb_size + 0xff) >> 8) + 2; ++ if (arc_cdb_size > 0xF) ++ arc_cdb_size = 0xF; ++ arc_cdb_size = (arc_cdb_size << 1) | 1; ++ } + ccb_post_stamp = (ccb->smid | arc_cdb_size); + writel(0, &pmu->inbound_queueport_high); + writel(ccb_post_stamp, &pmu->inbound_queueport_low); +@@ -2415,10 +2419,17 @@ static void arcmsr_hbaD_doorbell_isr(struct AdapterControlBlock *pACB) + + static void arcmsr_hbaE_doorbell_isr(struct AdapterControlBlock *pACB) + { +- uint32_t outbound_doorbell, in_doorbell, tmp; ++ uint32_t outbound_doorbell, in_doorbell, tmp, i; + struct MessageUnit_E __iomem *reg = pACB->pmuE; + +- in_doorbell = readl(®->iobound_doorbell); ++ if (pACB->adapter_type == ACB_ADAPTER_TYPE_F) { ++ for (i = 0; i < 5; i++) { ++ in_doorbell = readl(®->iobound_doorbell); ++ if (in_doorbell != 0) ++ break; ++ } ++ } else ++ in_doorbell = readl(®->iobound_doorbell); + outbound_doorbell = in_doorbell ^ pACB->in_doorbell; + do { + writel(0, ®->host_int_status); /* clear interrupt */ +diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c +index e9658a67d9da0..207e3f53c638d 100644 +--- a/drivers/scsi/be2iscsi/be_main.c ++++ b/drivers/scsi/be2iscsi/be_main.c +@@ -416,7 +416,7 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev) + "beiscsi_hba_alloc - iscsi_host_alloc failed\n"); + return NULL; + } +- shost->max_id = BE2_MAX_SESSIONS; ++ shost->max_id = BE2_MAX_SESSIONS - 1; + shost->max_channel = 0; + shost->max_cmd_len = BEISCSI_MAX_CMD_LEN; + shost->max_lun = BEISCSI_NUM_MAX_LUN; +@@ -5318,7 +5318,7 @@ static int beiscsi_enable_port(struct beiscsi_hba *phba) + /* Re-enable UER. If different TPE occurs then it is recoverable. */ + beiscsi_set_uer_feature(phba); + +- phba->shost->max_id = phba->params.cxns_per_ctrl; ++ phba->shost->max_id = phba->params.cxns_per_ctrl - 1; + phba->shost->can_queue = phba->params.ios_per_ctrl; + ret = beiscsi_init_port(phba); + if (ret < 0) { +@@ -5745,6 +5745,7 @@ free_hba: + pci_disable_msix(phba->pcidev); + pci_dev_put(phba->pcidev); + iscsi_host_free(phba->shost); ++ pci_disable_pcie_error_reporting(pcidev); + pci_set_drvdata(pcidev, NULL); + disable_pci: + pci_release_regions(pcidev); +diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c +index 2ad85c6b99fd2..8cf2f9a7cfdc2 100644 +--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c ++++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c +@@ -791,7 +791,7 @@ struct bnx2i_hba *bnx2i_alloc_hba(struct cnic_dev *cnic) + return NULL; + shost->dma_boundary = cnic->pcidev->dma_mask; + shost->transportt = bnx2i_scsi_xport_template; +- shost->max_id = ISCSI_MAX_CONNS_PER_HBA; ++ shost->max_id = ISCSI_MAX_CONNS_PER_HBA - 1; + shost->max_channel = 0; + shost->max_lun = 512; + shost->max_cmd_len = 16; +diff --git a/drivers/scsi/cxgbi/libcxgbi.c b/drivers/scsi/cxgbi/libcxgbi.c +index f6bcae829c29b..506b561670af0 100644 +--- a/drivers/scsi/cxgbi/libcxgbi.c ++++ b/drivers/scsi/cxgbi/libcxgbi.c +@@ -337,7 +337,7 @@ void cxgbi_hbas_remove(struct cxgbi_device *cdev) + EXPORT_SYMBOL_GPL(cxgbi_hbas_remove); + + int cxgbi_hbas_add(struct cxgbi_device *cdev, u64 max_lun, +- unsigned int max_id, struct scsi_host_template *sht, ++ unsigned int max_conns, struct scsi_host_template *sht, + struct scsi_transport_template *stt) + { + struct cxgbi_hba *chba; +@@ -357,7 +357,7 @@ int cxgbi_hbas_add(struct cxgbi_device *cdev, u64 max_lun, + + shost->transportt = stt; + shost->max_lun = max_lun; +- shost->max_id = max_id; ++ shost->max_id = max_conns - 1; + shost->max_channel = 0; + shost->max_cmd_len = SCSI_MAX_VARLEN_CDB_SIZE; + +diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c +index 5eff3368143d3..19a3b3c9909c6 100644 +--- a/drivers/scsi/device_handler/scsi_dh_alua.c ++++ b/drivers/scsi/device_handler/scsi_dh_alua.c +@@ -516,7 +516,8 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg) + struct alua_port_group *tmp_pg; + int len, k, off, bufflen = ALUA_RTPG_SIZE; + unsigned char *desc, *buff; +- unsigned err, retval; ++ unsigned err; ++ int retval; + unsigned int tpg_desc_tbl_off; + unsigned char orig_transition_tmo; + unsigned long flags; +@@ -556,12 +557,12 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg) + kfree(buff); + return SCSI_DH_OK; + } +- if (!scsi_sense_valid(&sense_hdr)) { ++ if (retval < 0 || !scsi_sense_valid(&sense_hdr)) { + sdev_printk(KERN_INFO, sdev, + "%s: rtpg failed, result %d\n", + ALUA_DH_NAME, retval); + kfree(buff); +- if (driver_byte(retval) == DRIVER_ERROR) ++ if (retval < 0) + return SCSI_DH_DEV_TEMP_BUSY; + return SCSI_DH_IO; + } +@@ -783,11 +784,11 @@ static unsigned alua_stpg(struct scsi_device *sdev, struct alua_port_group *pg) + retval = submit_stpg(sdev, pg->group_id, &sense_hdr); + + if (retval) { +- if (!scsi_sense_valid(&sense_hdr)) { ++ if (retval < 0 || !scsi_sense_valid(&sense_hdr)) { + sdev_printk(KERN_INFO, sdev, + "%s: stpg failed, result %d", + ALUA_DH_NAME, retval); +- if (driver_byte(retval) == DRIVER_ERROR) ++ if (retval < 0) + return SCSI_DH_DEV_TEMP_BUSY; + } else { + sdev_printk(KERN_INFO, sdev, "%s: stpg failed\n", +diff --git a/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c +index 3e359ac752fd2..3cba7bfba2965 100644 +--- a/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c ++++ b/drivers/scsi/hisi_sas/hisi_sas_v1_hw.c +@@ -1649,7 +1649,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (irq < 0) { + dev_err(dev, "irq init: fail map phy interrupt %d\n", + idx); +- return -ENOENT; ++ return irq; + } + + rc = devm_request_irq(dev, irq, phy_interrupts[j], 0, +@@ -1657,7 +1657,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (rc) { + dev_err(dev, "irq init: could not request phy interrupt %d, rc=%d\n", + irq, rc); +- return -ENOENT; ++ return rc; + } + } + } +@@ -1668,7 +1668,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (irq < 0) { + dev_err(dev, "irq init: could not map cq interrupt %d\n", + idx); +- return -ENOENT; ++ return irq; + } + + rc = devm_request_irq(dev, irq, cq_interrupt_v1_hw, 0, +@@ -1676,7 +1676,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (rc) { + dev_err(dev, "irq init: could not request cq interrupt %d, rc=%d\n", + irq, rc); +- return -ENOENT; ++ return rc; + } + } + +@@ -1686,7 +1686,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (irq < 0) { + dev_err(dev, "irq init: could not map fatal interrupt %d\n", + idx); +- return -ENOENT; ++ return irq; + } + + rc = devm_request_irq(dev, irq, fatal_interrupts[i], 0, +@@ -1694,7 +1694,7 @@ static int interrupt_init_v1_hw(struct hisi_hba *hisi_hba) + if (rc) { + dev_err(dev, "irq init: could not request fatal interrupt %d, rc=%d\n", + irq, rc); +- return -ENOENT; ++ return rc; + } + } + +diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c +index b93dd8ef4ac82..da3920a19d53d 100644 +--- a/drivers/scsi/hosts.c ++++ b/drivers/scsi/hosts.c +@@ -220,6 +220,9 @@ int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev, + goto fail; + } + ++ shost->cmd_per_lun = min_t(short, shost->cmd_per_lun, ++ shost->can_queue); ++ + error = scsi_init_sense_cache(shost); + if (error) + goto fail; +@@ -490,6 +493,7 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize) + shost_printk(KERN_WARNING, shost, + "error handler thread failed to spawn, error = %ld\n", + PTR_ERR(shost->ehandler)); ++ shost->ehandler = NULL; + goto fail; + } + +diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c +index 2aaf836786548..dfe906307e55d 100644 +--- a/drivers/scsi/libiscsi.c ++++ b/drivers/scsi/libiscsi.c +@@ -230,11 +230,11 @@ static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) + */ + static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) + { +- struct iscsi_conn *conn = task->conn; +- struct iscsi_tm *tmf = &conn->tmhdr; ++ struct iscsi_session *session = task->conn->session; ++ struct iscsi_tm *tmf = &session->tmhdr; + u64 hdr_lun; + +- if (conn->tmf_state == TMF_INITIAL) ++ if (session->tmf_state == TMF_INITIAL) + return 0; + + if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC) +@@ -254,24 +254,19 @@ static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) + * Fail all SCSI cmd PDUs + */ + if (opcode != ISCSI_OP_SCSI_DATA_OUT) { +- iscsi_conn_printk(KERN_INFO, conn, +- "task [op %x itt " +- "0x%x/0x%x] " +- "rejected.\n", +- opcode, task->itt, +- task->hdr_itt); ++ iscsi_session_printk(KERN_INFO, session, ++ "task [op %x itt 0x%x/0x%x] rejected.\n", ++ opcode, task->itt, task->hdr_itt); + return -EACCES; + } + /* + * And also all data-out PDUs in response to R2T + * if fast_abort is set. + */ +- if (conn->session->fast_abort) { +- iscsi_conn_printk(KERN_INFO, conn, +- "task [op %x itt " +- "0x%x/0x%x] fast abort.\n", +- opcode, task->itt, +- task->hdr_itt); ++ if (session->fast_abort) { ++ iscsi_session_printk(KERN_INFO, session, ++ "task [op %x itt 0x%x/0x%x] fast abort.\n", ++ opcode, task->itt, task->hdr_itt); + return -EACCES; + } + break; +@@ -284,7 +279,7 @@ static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) + */ + if (opcode == ISCSI_OP_SCSI_DATA_OUT && + task->hdr_itt == tmf->rtt) { +- ISCSI_DBG_SESSION(conn->session, ++ ISCSI_DBG_SESSION(session, + "Preventing task %x/%x from sending " + "data-out due to abort task in " + "progress\n", task->itt, +@@ -936,20 +931,21 @@ iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, + static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) + { + struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; ++ struct iscsi_session *session = conn->session; + + conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; + conn->tmfrsp_pdus_cnt++; + +- if (conn->tmf_state != TMF_QUEUED) ++ if (session->tmf_state != TMF_QUEUED) + return; + + if (tmf->response == ISCSI_TMF_RSP_COMPLETE) +- conn->tmf_state = TMF_SUCCESS; ++ session->tmf_state = TMF_SUCCESS; + else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) +- conn->tmf_state = TMF_NOT_FOUND; ++ session->tmf_state = TMF_NOT_FOUND; + else +- conn->tmf_state = TMF_FAILED; +- wake_up(&conn->ehwait); ++ session->tmf_state = TMF_FAILED; ++ wake_up(&session->ehwait); + } + + static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) +@@ -1361,7 +1357,6 @@ void iscsi_session_failure(struct iscsi_session *session, + enum iscsi_err err) + { + struct iscsi_conn *conn; +- struct device *dev; + + spin_lock_bh(&session->frwd_lock); + conn = session->leadconn; +@@ -1370,10 +1365,8 @@ void iscsi_session_failure(struct iscsi_session *session, + return; + } + +- dev = get_device(&conn->cls_conn->dev); ++ iscsi_get_conn(conn->cls_conn); + spin_unlock_bh(&session->frwd_lock); +- if (!dev) +- return; + /* + * if the host is being removed bypass the connection + * recovery initialization because we are going to kill +@@ -1383,7 +1376,7 @@ void iscsi_session_failure(struct iscsi_session *session, + iscsi_conn_error_event(conn->cls_conn, err); + else + iscsi_conn_failure(conn, err); +- put_device(dev); ++ iscsi_put_conn(conn->cls_conn); + } + EXPORT_SYMBOL_GPL(iscsi_session_failure); + +@@ -1829,15 +1822,14 @@ EXPORT_SYMBOL_GPL(iscsi_target_alloc); + + static void iscsi_tmf_timedout(struct timer_list *t) + { +- struct iscsi_conn *conn = from_timer(conn, t, tmf_timer); +- struct iscsi_session *session = conn->session; ++ struct iscsi_session *session = from_timer(session, t, tmf_timer); + + spin_lock(&session->frwd_lock); +- if (conn->tmf_state == TMF_QUEUED) { +- conn->tmf_state = TMF_TIMEDOUT; ++ if (session->tmf_state == TMF_QUEUED) { ++ session->tmf_state = TMF_TIMEDOUT; + ISCSI_DBG_EH(session, "tmf timedout\n"); + /* unblock eh_abort() */ +- wake_up(&conn->ehwait); ++ wake_up(&session->ehwait); + } + spin_unlock(&session->frwd_lock); + } +@@ -1860,8 +1852,8 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, + return -EPERM; + } + conn->tmfcmd_pdus_cnt++; +- conn->tmf_timer.expires = timeout * HZ + jiffies; +- add_timer(&conn->tmf_timer); ++ session->tmf_timer.expires = timeout * HZ + jiffies; ++ add_timer(&session->tmf_timer); + ISCSI_DBG_EH(session, "tmf set timeout\n"); + + spin_unlock_bh(&session->frwd_lock); +@@ -1875,12 +1867,12 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, + * 3) session is terminated or restarted or userspace has + * given up on recovery + */ +- wait_event_interruptible(conn->ehwait, age != session->age || ++ wait_event_interruptible(session->ehwait, age != session->age || + session->state != ISCSI_STATE_LOGGED_IN || +- conn->tmf_state != TMF_QUEUED); ++ session->tmf_state != TMF_QUEUED); + if (signal_pending(current)) + flush_signals(current); +- del_timer_sync(&conn->tmf_timer); ++ del_timer_sync(&session->tmf_timer); + + mutex_lock(&session->eh_mutex); + spin_lock_bh(&session->frwd_lock); +@@ -2312,17 +2304,17 @@ int iscsi_eh_abort(struct scsi_cmnd *sc) + } + + /* only have one tmf outstanding at a time */ +- if (conn->tmf_state != TMF_INITIAL) ++ if (session->tmf_state != TMF_INITIAL) + goto failed; +- conn->tmf_state = TMF_QUEUED; ++ session->tmf_state = TMF_QUEUED; + +- hdr = &conn->tmhdr; ++ hdr = &session->tmhdr; + iscsi_prep_abort_task_pdu(task, hdr); + + if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) + goto failed; + +- switch (conn->tmf_state) { ++ switch (session->tmf_state) { + case TMF_SUCCESS: + spin_unlock_bh(&session->frwd_lock); + /* +@@ -2337,7 +2329,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc) + */ + spin_lock_bh(&session->frwd_lock); + fail_scsi_task(task, DID_ABORT); +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + memset(hdr, 0, sizeof(*hdr)); + spin_unlock_bh(&session->frwd_lock); + iscsi_start_tx(conn); +@@ -2348,7 +2340,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc) + goto failed_unlocked; + case TMF_NOT_FOUND: + if (!sc->SCp.ptr) { +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + memset(hdr, 0, sizeof(*hdr)); + /* task completed before tmf abort response */ + ISCSI_DBG_EH(session, "sc completed while abort in " +@@ -2357,7 +2349,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc) + } + fallthrough; + default: +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + goto failed; + } + +@@ -2416,11 +2408,11 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc) + conn = session->leadconn; + + /* only have one tmf outstanding at a time */ +- if (conn->tmf_state != TMF_INITIAL) ++ if (session->tmf_state != TMF_INITIAL) + goto unlock; +- conn->tmf_state = TMF_QUEUED; ++ session->tmf_state = TMF_QUEUED; + +- hdr = &conn->tmhdr; ++ hdr = &session->tmhdr; + iscsi_prep_lun_reset_pdu(sc, hdr); + + if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, +@@ -2429,7 +2421,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc) + goto unlock; + } + +- switch (conn->tmf_state) { ++ switch (session->tmf_state) { + case TMF_SUCCESS: + break; + case TMF_TIMEDOUT: +@@ -2437,7 +2429,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc) + iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); + goto done; + default: +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + goto unlock; + } + +@@ -2449,7 +2441,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc) + spin_lock_bh(&session->frwd_lock); + memset(hdr, 0, sizeof(*hdr)); + fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + spin_unlock_bh(&session->frwd_lock); + + iscsi_start_tx(conn); +@@ -2472,8 +2464,7 @@ void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) + spin_lock_bh(&session->frwd_lock); + if (session->state != ISCSI_STATE_LOGGED_IN) { + session->state = ISCSI_STATE_RECOVERY_FAILED; +- if (session->leadconn) +- wake_up(&session->leadconn->ehwait); ++ wake_up(&session->ehwait); + } + spin_unlock_bh(&session->frwd_lock); + } +@@ -2518,7 +2509,7 @@ failed: + iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); + + ISCSI_DBG_EH(session, "wait for relogin\n"); +- wait_event_interruptible(conn->ehwait, ++ wait_event_interruptible(session->ehwait, + session->state == ISCSI_STATE_TERMINATE || + session->state == ISCSI_STATE_LOGGED_IN || + session->state == ISCSI_STATE_RECOVERY_FAILED); +@@ -2579,11 +2570,11 @@ static int iscsi_eh_target_reset(struct scsi_cmnd *sc) + conn = session->leadconn; + + /* only have one tmf outstanding at a time */ +- if (conn->tmf_state != TMF_INITIAL) ++ if (session->tmf_state != TMF_INITIAL) + goto unlock; +- conn->tmf_state = TMF_QUEUED; ++ session->tmf_state = TMF_QUEUED; + +- hdr = &conn->tmhdr; ++ hdr = &session->tmhdr; + iscsi_prep_tgt_reset_pdu(sc, hdr); + + if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, +@@ -2592,7 +2583,7 @@ static int iscsi_eh_target_reset(struct scsi_cmnd *sc) + goto unlock; + } + +- switch (conn->tmf_state) { ++ switch (session->tmf_state) { + case TMF_SUCCESS: + break; + case TMF_TIMEDOUT: +@@ -2600,7 +2591,7 @@ static int iscsi_eh_target_reset(struct scsi_cmnd *sc) + iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); + goto done; + default: +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + goto unlock; + } + +@@ -2612,7 +2603,7 @@ static int iscsi_eh_target_reset(struct scsi_cmnd *sc) + spin_lock_bh(&session->frwd_lock); + memset(hdr, 0, sizeof(*hdr)); + fail_scsi_tasks(conn, -1, DID_ERROR); +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + spin_unlock_bh(&session->frwd_lock); + + iscsi_start_tx(conn); +@@ -2942,7 +2933,10 @@ iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, + session->tt = iscsit; + session->dd_data = cls_session->dd_data + sizeof(*session); + ++ session->tmf_state = TMF_INITIAL; ++ timer_setup(&session->tmf_timer, iscsi_tmf_timedout, 0); + mutex_init(&session->eh_mutex); ++ + spin_lock_init(&session->frwd_lock); + spin_lock_init(&session->back_lock); + +@@ -3046,7 +3040,6 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, + conn->c_stage = ISCSI_CONN_INITIAL_STAGE; + conn->id = conn_idx; + conn->exp_statsn = 0; +- conn->tmf_state = TMF_INITIAL; + + timer_setup(&conn->transport_timer, iscsi_check_transport_timeouts, 0); + +@@ -3071,8 +3064,7 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, + goto login_task_data_alloc_fail; + conn->login_task->data = conn->data = data; + +- timer_setup(&conn->tmf_timer, iscsi_tmf_timedout, 0); +- init_waitqueue_head(&conn->ehwait); ++ init_waitqueue_head(&session->ehwait); + + return cls_conn; + +@@ -3107,7 +3099,7 @@ void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) + * leading connection? then give up on recovery. + */ + session->state = ISCSI_STATE_TERMINATE; +- wake_up(&conn->ehwait); ++ wake_up(&session->ehwait); + } + spin_unlock_bh(&session->frwd_lock); + +@@ -3182,7 +3174,7 @@ int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) + * commands after successful recovery + */ + conn->stop_stage = 0; +- conn->tmf_state = TMF_INITIAL; ++ session->tmf_state = TMF_INITIAL; + session->age++; + if (session->age == 16) + session->age = 0; +@@ -3196,7 +3188,7 @@ int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) + spin_unlock_bh(&session->frwd_lock); + + iscsi_unblock_session(session->cls_session); +- wake_up(&conn->ehwait); ++ wake_up(&session->ehwait); + return 0; + } + EXPORT_SYMBOL_GPL(iscsi_conn_start); +@@ -3290,7 +3282,7 @@ void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) + spin_lock_bh(&session->frwd_lock); + fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); + fail_mgmt_tasks(session, conn); +- memset(&conn->tmhdr, 0, sizeof(conn->tmhdr)); ++ memset(&session->tmhdr, 0, sizeof(session->tmhdr)); + spin_unlock_bh(&session->frwd_lock); + mutex_unlock(&session->eh_mutex); + } +diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c +index 5c4172e8c81b2..3b72aea9d15d5 100644 +--- a/drivers/scsi/lpfc/lpfc_els.c ++++ b/drivers/scsi/lpfc/lpfc_els.c +@@ -1175,6 +1175,15 @@ stop_rr_fcf_flogi: + phba->fcf.fcf_redisc_attempted = 0; /* reset */ + goto out; + } ++ } else if (vport->port_state > LPFC_FLOGI && ++ vport->fc_flag & FC_PT2PT) { ++ /* ++ * In a p2p topology, it is possible that discovery has ++ * already progressed, and this completion can be ignored. ++ * Recheck the indicated topology. ++ */ ++ if (!sp->cmn.fPort) ++ goto out; + } + + flogifail: +diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c +index 7551743835fc0..c063a6d2b690f 100644 +--- a/drivers/scsi/lpfc/lpfc_sli.c ++++ b/drivers/scsi/lpfc/lpfc_sli.c +@@ -7962,7 +7962,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba) + "0393 Error %d during rpi post operation\n", + rc); + rc = -ENODEV; +- goto out_destroy_queue; ++ goto out_free_iocblist; + } + lpfc_sli4_node_prep(phba); + +@@ -8128,8 +8128,9 @@ out_io_buff_free: + out_unset_queue: + /* Unset all the queues set up in this routine when error out */ + lpfc_sli4_queue_unset(phba); +-out_destroy_queue: ++out_free_iocblist: + lpfc_free_iocb_list(phba); ++out_destroy_queue: + lpfc_sli4_queue_destroy(phba); + out_stop_timers: + lpfc_stop_hba_timers(phba); +diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h +index 0f808d63580ee..69fed93184680 100644 +--- a/drivers/scsi/megaraid/megaraid_sas.h ++++ b/drivers/scsi/megaraid/megaraid_sas.h +@@ -2259,6 +2259,15 @@ enum MR_PERF_MODE { + (mode) == MR_LATENCY_PERF_MODE ? "Latency" : \ + "Unknown") + ++enum MEGASAS_LD_TARGET_ID_STATUS { ++ LD_TARGET_ID_INITIAL, ++ LD_TARGET_ID_ACTIVE, ++ LD_TARGET_ID_DELETED, ++}; ++ ++#define MEGASAS_TARGET_ID(sdev) \ ++ (((sdev->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL) + sdev->id) ++ + struct megasas_instance { + + unsigned int *reply_map; +@@ -2323,6 +2332,9 @@ struct megasas_instance { + struct megasas_pd_list pd_list[MEGASAS_MAX_PD]; + struct megasas_pd_list local_pd_list[MEGASAS_MAX_PD]; + u8 ld_ids[MEGASAS_MAX_LD_IDS]; ++ u8 ld_tgtid_status[MEGASAS_MAX_LD_IDS]; ++ u8 ld_ids_prev[MEGASAS_MAX_LD_IDS]; ++ u8 ld_ids_from_raidmap[MEGASAS_MAX_LD_IDS]; + s8 init_id; + + u16 max_num_sge; +diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c +index 63a4f48bdc755..c9c8a5e4925cd 100644 +--- a/drivers/scsi/megaraid/megaraid_sas_base.c ++++ b/drivers/scsi/megaraid/megaraid_sas_base.c +@@ -132,6 +132,8 @@ static int megasas_register_aen(struct megasas_instance *instance, + u32 seq_num, u32 class_locale_word); + static void megasas_get_pd_info(struct megasas_instance *instance, + struct scsi_device *sdev); ++static void ++megasas_set_ld_removed_by_fw(struct megasas_instance *instance); + + /* + * PCI ID table for all supported controllers +@@ -426,6 +428,12 @@ megasas_decode_evt(struct megasas_instance *instance) + (class_locale.members.locale), + format_class(class_locale.members.class), + evt_detail->description); ++ ++ if (megasas_dbg_lvl & LD_PD_DEBUG) ++ dev_info(&instance->pdev->dev, ++ "evt_detail.args.ld.target_id/index %d/%d\n", ++ evt_detail->args.ld.target_id, evt_detail->args.ld.ld_index); ++ + } + + /* +@@ -1769,6 +1777,7 @@ megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd) + { + struct megasas_instance *instance; + struct MR_PRIV_DEVICE *mr_device_priv_data; ++ u32 ld_tgt_id; + + instance = (struct megasas_instance *) + scmd->device->host->hostdata; +@@ -1795,17 +1804,21 @@ megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd) + } + } + +- if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) { ++ mr_device_priv_data = scmd->device->hostdata; ++ if (!mr_device_priv_data || ++ (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)) { + scmd->result = DID_NO_CONNECT << 16; + scmd->scsi_done(scmd); + return 0; + } + +- mr_device_priv_data = scmd->device->hostdata; +- if (!mr_device_priv_data) { +- scmd->result = DID_NO_CONNECT << 16; +- scmd->scsi_done(scmd); +- return 0; ++ if (MEGASAS_IS_LOGICAL(scmd->device)) { ++ ld_tgt_id = MEGASAS_TARGET_ID(scmd->device); ++ if (instance->ld_tgtid_status[ld_tgt_id] == LD_TARGET_ID_DELETED) { ++ scmd->result = DID_NO_CONNECT << 16; ++ scmd->scsi_done(scmd); ++ return 0; ++ } + } + + if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) +@@ -2085,7 +2098,7 @@ static int megasas_slave_configure(struct scsi_device *sdev) + + static int megasas_slave_alloc(struct scsi_device *sdev) + { +- u16 pd_index = 0; ++ u16 pd_index = 0, ld_tgt_id; + struct megasas_instance *instance ; + struct MR_PRIV_DEVICE *mr_device_priv_data; + +@@ -2110,6 +2123,14 @@ scan_target: + GFP_KERNEL); + if (!mr_device_priv_data) + return -ENOMEM; ++ ++ if (MEGASAS_IS_LOGICAL(sdev)) { ++ ld_tgt_id = MEGASAS_TARGET_ID(sdev); ++ instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_ACTIVE; ++ if (megasas_dbg_lvl & LD_PD_DEBUG) ++ sdev_printk(KERN_INFO, sdev, "LD target ID %d created.\n", ld_tgt_id); ++ } ++ + sdev->hostdata = mr_device_priv_data; + + atomic_set(&mr_device_priv_data->r1_ldio_hint, +@@ -2119,6 +2140,19 @@ scan_target: + + static void megasas_slave_destroy(struct scsi_device *sdev) + { ++ u16 ld_tgt_id; ++ struct megasas_instance *instance; ++ ++ instance = megasas_lookup_instance(sdev->host->host_no); ++ ++ if (MEGASAS_IS_LOGICAL(sdev)) { ++ ld_tgt_id = MEGASAS_TARGET_ID(sdev); ++ instance->ld_tgtid_status[ld_tgt_id] = LD_TARGET_ID_DELETED; ++ if (megasas_dbg_lvl & LD_PD_DEBUG) ++ sdev_printk(KERN_INFO, sdev, ++ "LD target ID %d removed from OS stack\n", ld_tgt_id); ++ } ++ + kfree(sdev->hostdata); + sdev->hostdata = NULL; + } +@@ -3491,6 +3525,22 @@ megasas_complete_abort(struct megasas_instance *instance, + } + } + ++static void ++megasas_set_ld_removed_by_fw(struct megasas_instance *instance) ++{ ++ uint i; ++ ++ for (i = 0; (i < MEGASAS_MAX_LD_IDS); i++) { ++ if (instance->ld_ids_prev[i] != 0xff && ++ instance->ld_ids_from_raidmap[i] == 0xff) { ++ if (megasas_dbg_lvl & LD_PD_DEBUG) ++ dev_info(&instance->pdev->dev, ++ "LD target ID %d removed from RAID map\n", i); ++ instance->ld_tgtid_status[i] = LD_TARGET_ID_DELETED; ++ } ++ } ++} ++ + /** + * megasas_complete_cmd - Completes a command + * @instance: Adapter soft state +@@ -3653,9 +3703,13 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd, + fusion->fast_path_io = 0; + } + ++ if (instance->adapter_type >= INVADER_SERIES) ++ megasas_set_ld_removed_by_fw(instance); ++ + megasas_sync_map_info(instance); + spin_unlock_irqrestore(instance->host->host_lock, + flags); ++ + break; + } + if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO || +@@ -7478,11 +7532,16 @@ static int megasas_probe_one(struct pci_dev *pdev, + return 0; + + fail_start_aen: ++ instance->unload = 1; ++ scsi_remove_host(instance->host); + fail_io_attach: + megasas_mgmt_info.count--; + megasas_mgmt_info.max_index--; + megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL; + ++ if (instance->requestorId && !instance->skip_heartbeat_timer_del) ++ del_timer_sync(&instance->sriov_heartbeat_timer); ++ + instance->instancet->disable_intr(instance); + megasas_destroy_irqs(instance); + +@@ -7490,8 +7549,16 @@ fail_io_attach: + megasas_release_fusion(instance); + else + megasas_release_mfi(instance); ++ + if (instance->msix_vectors) + pci_free_irq_vectors(instance->pdev); ++ instance->msix_vectors = 0; ++ ++ if (instance->fw_crash_state != UNAVAILABLE) ++ megasas_free_host_crash_buffer(instance); ++ ++ if (instance->adapter_type != MFI_SERIES) ++ megasas_fusion_stop_watchdog(instance); + fail_init_mfi: + scsi_host_put(host); + fail_alloc_instance: +@@ -8751,8 +8818,10 @@ megasas_aen_polling(struct work_struct *work) + union megasas_evt_class_locale class_locale; + int event_type = 0; + u32 seq_num; ++ u16 ld_target_id; + int error; + u8 dcmd_ret = DCMD_SUCCESS; ++ struct scsi_device *sdev1; + + if (!instance) { + printk(KERN_ERR "invalid instance!\n"); +@@ -8775,12 +8844,23 @@ megasas_aen_polling(struct work_struct *work) + break; + + case MR_EVT_LD_OFFLINE: +- case MR_EVT_CFG_CLEARED: + case MR_EVT_LD_DELETED: ++ ld_target_id = instance->evt_detail->args.ld.target_id; ++ sdev1 = scsi_device_lookup(instance->host, ++ MEGASAS_MAX_PD_CHANNELS + ++ (ld_target_id / MEGASAS_MAX_DEV_PER_CHANNEL), ++ (ld_target_id - MEGASAS_MAX_DEV_PER_CHANNEL), ++ 0); ++ if (sdev1) ++ megasas_remove_scsi_device(sdev1); ++ ++ event_type = SCAN_VD_CHANNEL; ++ break; + case MR_EVT_LD_CREATED: + event_type = SCAN_VD_CHANNEL; + break; + ++ case MR_EVT_CFG_CLEARED: + case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED: + case MR_EVT_FOREIGN_CFG_IMPORTED: + case MR_EVT_LD_STATE_CHANGE: +diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c +index b6c08d6200335..83f69c33b01a9 100644 +--- a/drivers/scsi/megaraid/megaraid_sas_fp.c ++++ b/drivers/scsi/megaraid/megaraid_sas_fp.c +@@ -349,6 +349,10 @@ u8 MR_ValidateMapInfo(struct megasas_instance *instance, u64 map_id) + + num_lds = le16_to_cpu(drv_map->raidMap.ldCount); + ++ memcpy(instance->ld_ids_prev, ++ instance->ld_ids_from_raidmap, ++ sizeof(instance->ld_ids_from_raidmap)); ++ memset(instance->ld_ids_from_raidmap, 0xff, MEGASAS_MAX_LD_IDS); + /*Convert Raid capability values to CPU arch */ + for (i = 0; (num_lds > 0) && (i < MAX_LOGICAL_DRIVES_EXT); i++) { + ld = MR_TargetIdToLdGet(i, drv_map); +@@ -359,7 +363,7 @@ u8 MR_ValidateMapInfo(struct megasas_instance *instance, u64 map_id) + + raid = MR_LdRaidGet(ld, drv_map); + le32_to_cpus((u32 *)&raid->capability); +- ++ instance->ld_ids_from_raidmap[i] = i; + num_lds--; + } + +diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c +index 73295cf74cbe3..5abb84ebc0ed3 100644 +--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c ++++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c +@@ -3676,6 +3676,7 @@ static void megasas_sync_irqs(unsigned long instance_addr) + if (irq_ctx->irq_poll_scheduled) { + irq_ctx->irq_poll_scheduled = false; + enable_irq(irq_ctx->os_irq); ++ complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx); + } + } + } +@@ -3707,6 +3708,7 @@ int megasas_irqpoll(struct irq_poll *irqpoll, int budget) + irq_poll_complete(irqpoll); + irq_ctx->irq_poll_scheduled = false; + enable_irq(irq_ctx->os_irq); ++ complete_cmd_fusion(instance, irq_ctx->MSIxIndex, irq_ctx); + } + + return num_entries; +@@ -3723,6 +3725,7 @@ megasas_complete_cmd_dpc_fusion(unsigned long instance_addr) + { + struct megasas_instance *instance = + (struct megasas_instance *)instance_addr; ++ struct megasas_irq_context *irq_ctx = NULL; + u32 count, MSIxIndex; + + count = instance->msix_vectors > 0 ? instance->msix_vectors : 1; +@@ -3731,8 +3734,10 @@ megasas_complete_cmd_dpc_fusion(unsigned long instance_addr) + if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) + return; + +- for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++) +- complete_cmd_fusion(instance, MSIxIndex, NULL); ++ for (MSIxIndex = 0 ; MSIxIndex < count; MSIxIndex++) { ++ irq_ctx = &instance->irq_context[MSIxIndex]; ++ complete_cmd_fusion(instance, MSIxIndex, irq_ctx); ++ } + } + + /** +@@ -5201,6 +5206,7 @@ megasas_alloc_fusion_context(struct megasas_instance *instance) + if (!fusion->log_to_span) { + dev_err(&instance->pdev->dev, "Failed from %s %d\n", + __func__, __LINE__); ++ kfree(instance->ctrl_context); + return -ENOMEM; + } + } +diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c +index 7824e77bc6e26..15d1f1fbeee75 100644 +--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c ++++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c +@@ -3696,6 +3696,28 @@ _scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc) + ioc->fw_events_cleanup = 1; + while ((fw_event = dequeue_next_fw_event(ioc)) || + (fw_event = ioc->current_event)) { ++ ++ /* ++ * Don't call cancel_work_sync() for current_event ++ * other than MPT3SAS_REMOVE_UNRESPONDING_DEVICES; ++ * otherwise we may observe deadlock if current ++ * hard reset issued as part of processing the current_event. ++ * ++ * Orginal logic of cleaning the current_event is added ++ * for handling the back to back host reset issued by the user. ++ * i.e. during back to back host reset, driver use to process ++ * the two instances of MPT3SAS_REMOVE_UNRESPONDING_DEVICES ++ * event back to back and this made the drives to unregister ++ * the devices from SML. ++ */ ++ ++ if (fw_event == ioc->current_event && ++ ioc->current_event->event != ++ MPT3SAS_REMOVE_UNRESPONDING_DEVICES) { ++ ioc->current_event = NULL; ++ continue; ++ } ++ + /* + * Wait on the fw_event to complete. If this returns 1, then + * the event was never executed, and we need a put for the +diff --git a/drivers/scsi/qedi/qedi.h b/drivers/scsi/qedi/qedi.h +index c342defc3f522..ce199a7a16b80 100644 +--- a/drivers/scsi/qedi/qedi.h ++++ b/drivers/scsi/qedi/qedi.h +@@ -284,6 +284,7 @@ struct qedi_ctx { + #define QEDI_IN_RECOVERY 5 + #define QEDI_IN_OFFLINE 6 + #define QEDI_IN_SHUTDOWN 7 ++#define QEDI_BLOCK_IO 8 + + u8 mac[ETH_ALEN]; + u32 src_ip[4]; +diff --git a/drivers/scsi/qedi/qedi_fw.c b/drivers/scsi/qedi/qedi_fw.c +index 440ddd2309f1d..4c87640e6a911 100644 +--- a/drivers/scsi/qedi/qedi_fw.c ++++ b/drivers/scsi/qedi/qedi_fw.c +@@ -73,7 +73,6 @@ static void qedi_process_logout_resp(struct qedi_ctx *qedi, + spin_unlock(&qedi_conn->list_lock); + + cmd->state = RESPONSE_RECEIVED; +- qedi_clear_task_idx(qedi, cmd->task_id); + __iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr, NULL, 0); + + spin_unlock(&session->back_lock); +@@ -138,7 +137,6 @@ static void qedi_process_text_resp(struct qedi_ctx *qedi, + spin_unlock(&qedi_conn->list_lock); + + cmd->state = RESPONSE_RECEIVED; +- qedi_clear_task_idx(qedi, cmd->task_id); + + __iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr_ptr, + qedi_conn->gen_pdu.resp_buf, +@@ -161,16 +159,9 @@ static void qedi_tmf_resp_work(struct work_struct *work) + set_bit(QEDI_CONN_FW_CLEANUP, &qedi_conn->flags); + resp_hdr_ptr = (struct iscsi_tm_rsp *)qedi_cmd->tmf_resp_buf; + +- iscsi_block_session(session->cls_session); + rval = qedi_cleanup_all_io(qedi, qedi_conn, qedi_cmd->task, true); +- if (rval) { +- qedi_clear_task_idx(qedi, qedi_cmd->task_id); +- iscsi_unblock_session(session->cls_session); ++ if (rval) + goto exit_tmf_resp; +- } +- +- iscsi_unblock_session(session->cls_session); +- qedi_clear_task_idx(qedi, qedi_cmd->task_id); + + spin_lock(&session->back_lock); + __iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr_ptr, NULL, 0); +@@ -245,8 +236,6 @@ static void qedi_process_tmf_resp(struct qedi_ctx *qedi, + goto unblock_sess; + } + +- qedi_clear_task_idx(qedi, qedi_cmd->task_id); +- + __iscsi_complete_pdu(conn, (struct iscsi_hdr *)resp_hdr_ptr, NULL, 0); + kfree(resp_hdr_ptr); + +@@ -314,7 +303,6 @@ static void qedi_process_login_resp(struct qedi_ctx *qedi, + "Freeing tid=0x%x for cid=0x%x\n", + cmd->task_id, qedi_conn->iscsi_conn_id); + cmd->state = RESPONSE_RECEIVED; +- qedi_clear_task_idx(qedi, cmd->task_id); + } + + static void qedi_get_rq_bdq_buf(struct qedi_ctx *qedi, +@@ -468,7 +456,6 @@ static int qedi_process_nopin_mesg(struct qedi_ctx *qedi, + } + + spin_unlock(&qedi_conn->list_lock); +- qedi_clear_task_idx(qedi, cmd->task_id); + } + + done: +@@ -673,7 +660,6 @@ static void qedi_scsi_completion(struct qedi_ctx *qedi, + if (qedi_io_tracing) + qedi_trace_io(qedi, task, cmd->task_id, QEDI_IO_TRACE_RSP); + +- qedi_clear_task_idx(qedi, cmd->task_id); + __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, + conn->data, datalen); + error: +@@ -730,7 +716,6 @@ static void qedi_process_nopin_local_cmpl(struct qedi_ctx *qedi, + cqe->itid, cmd->task_id); + + cmd->state = RESPONSE_RECEIVED; +- qedi_clear_task_idx(qedi, cmd->task_id); + + spin_lock_bh(&session->back_lock); + __iscsi_put_task(task); +@@ -748,7 +733,6 @@ static void qedi_process_cmd_cleanup_resp(struct qedi_ctx *qedi, + itt_t protoitt = 0; + int found = 0; + struct qedi_cmd *qedi_cmd = NULL; +- u32 rtid = 0; + u32 iscsi_cid; + struct qedi_conn *qedi_conn; + struct qedi_cmd *dbg_cmd; +@@ -779,7 +763,6 @@ static void qedi_process_cmd_cleanup_resp(struct qedi_ctx *qedi, + found = 1; + mtask = qedi_cmd->task; + tmf_hdr = (struct iscsi_tm *)mtask->hdr; +- rtid = work->rtid; + + list_del_init(&work->list); + kfree(work); +@@ -821,8 +804,6 @@ static void qedi_process_cmd_cleanup_resp(struct qedi_ctx *qedi, + if (qedi_cmd->state == CLEANUP_WAIT_FAILED) + qedi_cmd->state = CLEANUP_RECV; + +- qedi_clear_task_idx(qedi_conn->qedi, rtid); +- + spin_lock(&qedi_conn->list_lock); + if (likely(dbg_cmd->io_cmd_in_list)) { + dbg_cmd->io_cmd_in_list = false; +@@ -856,7 +837,6 @@ static void qedi_process_cmd_cleanup_resp(struct qedi_ctx *qedi, + QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_TID, + "Freeing tid=0x%x for cid=0x%x\n", + cqe->itid, qedi_conn->iscsi_conn_id); +- qedi_clear_task_idx(qedi_conn->qedi, cqe->itid); + + } else { + qedi_get_proto_itt(qedi, cqe->itid, &ptmp_itt); +@@ -1453,7 +1433,7 @@ abort_ret: + + ldel_exit: + spin_lock_bh(&qedi_conn->tmf_work_lock); +- if (!qedi_cmd->list_tmf_work) { ++ if (qedi_cmd->list_tmf_work) { + list_del_init(&list_work->list); + qedi_cmd->list_tmf_work = NULL; + kfree(list_work); +diff --git a/drivers/scsi/qedi/qedi_iscsi.c b/drivers/scsi/qedi/qedi_iscsi.c +index 087c7ff28cd52..5f7e62f19d83a 100644 +--- a/drivers/scsi/qedi/qedi_iscsi.c ++++ b/drivers/scsi/qedi/qedi_iscsi.c +@@ -330,12 +330,22 @@ free_conn: + + void qedi_mark_device_missing(struct iscsi_cls_session *cls_session) + { +- iscsi_block_session(cls_session); ++ struct iscsi_session *session = cls_session->dd_data; ++ struct qedi_conn *qedi_conn = session->leadconn->dd_data; ++ ++ spin_lock_bh(&session->frwd_lock); ++ set_bit(QEDI_BLOCK_IO, &qedi_conn->qedi->flags); ++ spin_unlock_bh(&session->frwd_lock); + } + + void qedi_mark_device_available(struct iscsi_cls_session *cls_session) + { +- iscsi_unblock_session(cls_session); ++ struct iscsi_session *session = cls_session->dd_data; ++ struct qedi_conn *qedi_conn = session->leadconn->dd_data; ++ ++ spin_lock_bh(&session->frwd_lock); ++ clear_bit(QEDI_BLOCK_IO, &qedi_conn->qedi->flags); ++ spin_unlock_bh(&session->frwd_lock); + } + + static int qedi_bind_conn_to_iscsi_cid(struct qedi_ctx *qedi, +@@ -783,7 +793,6 @@ static int qedi_mtask_xmit(struct iscsi_conn *conn, struct iscsi_task *task) + } + + cmd->conn = conn->dd_data; +- cmd->scsi_cmd = NULL; + return qedi_iscsi_send_generic_request(task); + } + +@@ -794,9 +803,16 @@ static int qedi_task_xmit(struct iscsi_task *task) + struct qedi_cmd *cmd = task->dd_data; + struct scsi_cmnd *sc = task->sc; + ++ /* Clear now so in cleanup_task we know it didn't make it */ ++ cmd->scsi_cmd = NULL; ++ cmd->task_id = U16_MAX; ++ + if (test_bit(QEDI_IN_SHUTDOWN, &qedi_conn->qedi->flags)) + return -ENODEV; + ++ if (test_bit(QEDI_BLOCK_IO, &qedi_conn->qedi->flags)) ++ return -EACCES; ++ + cmd->state = 0; + cmd->task = NULL; + cmd->use_slowpath = false; +@@ -1394,13 +1410,24 @@ static umode_t qedi_attr_is_visible(int param_type, int param) + + static void qedi_cleanup_task(struct iscsi_task *task) + { +- if (!task->sc || task->state == ISCSI_TASK_PENDING) { ++ struct qedi_cmd *cmd; ++ ++ if (task->state == ISCSI_TASK_PENDING) { + QEDI_INFO(NULL, QEDI_LOG_IO, "Returning ref_cnt=%d\n", + refcount_read(&task->refcount)); + return; + } + +- qedi_iscsi_unmap_sg_list(task->dd_data); ++ if (task->sc) ++ qedi_iscsi_unmap_sg_list(task->dd_data); ++ ++ cmd = task->dd_data; ++ if (cmd->task_id != U16_MAX) ++ qedi_clear_task_idx(iscsi_host_priv(task->conn->session->host), ++ cmd->task_id); ++ ++ cmd->task_id = U16_MAX; ++ cmd->scsi_cmd = NULL; + } + + struct iscsi_transport qedi_iscsi_transport = { +diff --git a/drivers/scsi/qedi/qedi_main.c b/drivers/scsi/qedi/qedi_main.c +index 69c5b5ee2169b..b33eff9ea80ba 100644 +--- a/drivers/scsi/qedi/qedi_main.c ++++ b/drivers/scsi/qedi/qedi_main.c +@@ -642,7 +642,7 @@ static struct qedi_ctx *qedi_host_alloc(struct pci_dev *pdev) + goto exit_setup_shost; + } + +- shost->max_id = QEDI_MAX_ISCSI_CONNS_PER_HBA; ++ shost->max_id = QEDI_MAX_ISCSI_CONNS_PER_HBA - 1; + shost->max_channel = 0; + shost->max_lun = ~0; + shost->max_cmd_len = 16; +diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c +index e172c660dcd53..1b02556f9ec00 100644 +--- a/drivers/scsi/scsi_lib.c ++++ b/drivers/scsi/scsi_lib.c +@@ -2081,9 +2081,7 @@ EXPORT_SYMBOL_GPL(scsi_mode_select); + * @sshdr: place to put sense data (or NULL if no sense to be collected). + * must be SCSI_SENSE_BUFFERSIZE big. + * +- * Returns zero if unsuccessful, or the header offset (either 4 +- * or 8 depending on whether a six or ten byte command was +- * issued) if successful. ++ * Returns zero if successful, or a negative error number on failure + */ + int + scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, +@@ -2130,6 +2128,8 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, + + result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len, + sshdr, timeout, retries, NULL); ++ if (result < 0) ++ return result; + + /* This code looks awful: what it's doing is making sure an + * ILLEGAL REQUEST sense return identifies the actual command +@@ -2174,13 +2174,15 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, + data->block_descriptor_length = buffer[3]; + } + data->header_length = header_length; ++ result = 0; + } else if ((status_byte(result) == CHECK_CONDITION) && + scsi_sense_valid(sshdr) && + sshdr->sense_key == UNIT_ATTENTION && retry_count) { + retry_count--; + goto retry; + } +- ++ if (result > 0) ++ result = -EIO; + return result; + } + EXPORT_SYMBOL(scsi_mode_sense); +diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c +index 6ce1cc992d1d0..b07105ae7c917 100644 +--- a/drivers/scsi/scsi_transport_iscsi.c ++++ b/drivers/scsi/scsi_transport_iscsi.c +@@ -2459,6 +2459,18 @@ int iscsi_destroy_conn(struct iscsi_cls_conn *conn) + } + EXPORT_SYMBOL_GPL(iscsi_destroy_conn); + ++void iscsi_put_conn(struct iscsi_cls_conn *conn) ++{ ++ put_device(&conn->dev); ++} ++EXPORT_SYMBOL_GPL(iscsi_put_conn); ++ ++void iscsi_get_conn(struct iscsi_cls_conn *conn) ++{ ++ get_device(&conn->dev); ++} ++EXPORT_SYMBOL_GPL(iscsi_get_conn); ++ + /* + * iscsi interface functions + */ +diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c +index c9abed8429c9a..4a96fb05731d2 100644 +--- a/drivers/scsi/scsi_transport_sas.c ++++ b/drivers/scsi/scsi_transport_sas.c +@@ -1229,16 +1229,15 @@ int sas_read_port_mode_page(struct scsi_device *sdev) + char *buffer = kzalloc(BUF_SIZE, GFP_KERNEL), *msdata; + struct sas_end_device *rdev = sas_sdev_to_rdev(sdev); + struct scsi_mode_data mode_data; +- int res, error; ++ int error; + + if (!buffer) + return -ENOMEM; + +- res = scsi_mode_sense(sdev, 1, 0x19, buffer, BUF_SIZE, 30*HZ, 3, +- &mode_data, NULL); ++ error = scsi_mode_sense(sdev, 1, 0x19, buffer, BUF_SIZE, 30*HZ, 3, ++ &mode_data, NULL); + +- error = -EINVAL; +- if (!scsi_status_is_good(res)) ++ if (error) + goto out; + + msdata = buffer + mode_data.header_length + +diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c +index a0356f3707b86..3431ac12b7308 100644 +--- a/drivers/scsi/sd.c ++++ b/drivers/scsi/sd.c +@@ -2683,18 +2683,18 @@ sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer) + * 5: Illegal Request, Sense Code 24: Invalid field in + * CDB. + */ +- if (!scsi_status_is_good(res)) ++ if (res < 0) + res = sd_do_mode_sense(sdkp, 0, 0, buffer, 4, &data, NULL); + + /* + * Third attempt: ask 255 bytes, as we did earlier. + */ +- if (!scsi_status_is_good(res)) ++ if (res < 0) + res = sd_do_mode_sense(sdkp, 0, 0x3F, buffer, 255, + &data, NULL); + } + +- if (!scsi_status_is_good(res)) { ++ if (res < 0) { + sd_first_printk(KERN_WARNING, sdkp, + "Test WP failed, assume Write Enabled\n"); + } else { +@@ -2755,7 +2755,7 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer) + res = sd_do_mode_sense(sdkp, dbd, modepage, buffer, first_len, + &data, &sshdr); + +- if (!scsi_status_is_good(res)) ++ if (res < 0) + goto bad_sense; + + if (!data.header_length) { +@@ -2787,7 +2787,7 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer) + res = sd_do_mode_sense(sdkp, dbd, modepage, buffer, len, + &data, &sshdr); + +- if (scsi_status_is_good(res)) { ++ if (!res) { + int offset = data.header_length + data.block_descriptor_length; + + while (offset < len) { +@@ -2905,7 +2905,7 @@ static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer) + res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT, + sdkp->max_retries, &data, &sshdr); + +- if (!scsi_status_is_good(res) || !data.header_length || ++ if (res < 0 || !data.header_length || + data.length < 6) { + sd_first_printk(KERN_WARNING, sdkp, + "getting Control mode page failed, assume no ATO\n"); +diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c +index 7815ed642d434..1a94c7b1de2df 100644 +--- a/drivers/scsi/sr.c ++++ b/drivers/scsi/sr.c +@@ -913,7 +913,7 @@ static void get_capabilities(struct scsi_cd *cd) + rc = scsi_mode_sense(cd->device, 0, 0x2a, buffer, ms_len, + SR_TIMEOUT, 3, &data, NULL); + +- if (!scsi_status_is_good(rc) || data.length > ms_len || ++ if (rc < 0 || data.length > ms_len || + data.header_length + data.block_descriptor_length > data.length) { + /* failed, drive doesn't have capabilities mode page */ + cd->cdi.speed = 1; +diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c +index 6bc5453cea8a7..181d7b372fd0d 100644 +--- a/drivers/scsi/storvsc_drv.c ++++ b/drivers/scsi/storvsc_drv.c +@@ -1005,17 +1005,40 @@ static void storvsc_handle_error(struct vmscsi_request *vm_srb, + struct storvsc_scan_work *wrk; + void (*process_err_fn)(struct work_struct *work); + struct hv_host_device *host_dev = shost_priv(host); +- bool do_work = false; + +- switch (SRB_STATUS(vm_srb->srb_status)) { +- case SRB_STATUS_ERROR: ++ /* ++ * In some situations, Hyper-V sets multiple bits in the ++ * srb_status, such as ABORTED and ERROR. So process them ++ * individually, with the most specific bits first. ++ */ ++ ++ if (vm_srb->srb_status & SRB_STATUS_INVALID_LUN) { ++ set_host_byte(scmnd, DID_NO_CONNECT); ++ process_err_fn = storvsc_remove_lun; ++ goto do_work; ++ } ++ ++ if (vm_srb->srb_status & SRB_STATUS_ABORTED) { ++ if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID && ++ /* Capacity data has changed */ ++ (asc == 0x2a) && (ascq == 0x9)) { ++ process_err_fn = storvsc_device_scan; ++ /* ++ * Retry the I/O that triggered this. ++ */ ++ set_host_byte(scmnd, DID_REQUEUE); ++ goto do_work; ++ } ++ } ++ ++ if (vm_srb->srb_status & SRB_STATUS_ERROR) { + /* + * Let upper layer deal with error when + * sense message is present. + */ +- + if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID) +- break; ++ return; ++ + /* + * If there is an error; offline the device since all + * error recovery strategies would have already been +@@ -1028,37 +1051,19 @@ static void storvsc_handle_error(struct vmscsi_request *vm_srb, + set_host_byte(scmnd, DID_PASSTHROUGH); + break; + /* +- * On Some Windows hosts TEST_UNIT_READY command can return +- * SRB_STATUS_ERROR, let the upper level code deal with it +- * based on the sense information. ++ * On some Hyper-V hosts TEST_UNIT_READY command can ++ * return SRB_STATUS_ERROR. Let the upper level code ++ * deal with it based on the sense information. + */ + case TEST_UNIT_READY: + break; + default: + set_host_byte(scmnd, DID_ERROR); + } +- break; +- case SRB_STATUS_INVALID_LUN: +- set_host_byte(scmnd, DID_NO_CONNECT); +- do_work = true; +- process_err_fn = storvsc_remove_lun; +- break; +- case SRB_STATUS_ABORTED: +- if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID && +- (asc == 0x2a) && (ascq == 0x9)) { +- do_work = true; +- process_err_fn = storvsc_device_scan; +- /* +- * Retry the I/O that triggered this. +- */ +- set_host_byte(scmnd, DID_REQUEUE); +- } +- break; + } ++ return; + +- if (!do_work) +- return; +- ++do_work: + /* + * We need to schedule work to process this error; schedule it. + */ +diff --git a/drivers/soc/mediatek/mtk-pm-domains.c b/drivers/soc/mediatek/mtk-pm-domains.c +index 0af00efa0ef83..b762bc40f56bd 100644 +--- a/drivers/soc/mediatek/mtk-pm-domains.c ++++ b/drivers/soc/mediatek/mtk-pm-domains.c +@@ -211,7 +211,7 @@ static int scpsys_power_on(struct generic_pm_domain *genpd) + if (ret) + return ret; + +- ret = clk_bulk_enable(pd->num_clks, pd->clks); ++ ret = clk_bulk_prepare_enable(pd->num_clks, pd->clks); + if (ret) + goto err_reg; + +@@ -229,7 +229,7 @@ static int scpsys_power_on(struct generic_pm_domain *genpd) + regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_ISO_BIT); + regmap_set_bits(scpsys->base, pd->data->ctl_offs, PWR_RST_B_BIT); + +- ret = clk_bulk_enable(pd->num_subsys_clks, pd->subsys_clks); ++ ret = clk_bulk_prepare_enable(pd->num_subsys_clks, pd->subsys_clks); + if (ret) + goto err_pwr_ack; + +@@ -246,9 +246,9 @@ static int scpsys_power_on(struct generic_pm_domain *genpd) + err_disable_sram: + scpsys_sram_disable(pd); + err_disable_subsys_clks: +- clk_bulk_disable(pd->num_subsys_clks, pd->subsys_clks); ++ clk_bulk_disable_unprepare(pd->num_subsys_clks, pd->subsys_clks); + err_pwr_ack: +- clk_bulk_disable(pd->num_clks, pd->clks); ++ clk_bulk_disable_unprepare(pd->num_clks, pd->clks); + err_reg: + scpsys_regulator_disable(pd->supply); + return ret; +@@ -269,7 +269,7 @@ static int scpsys_power_off(struct generic_pm_domain *genpd) + if (ret < 0) + return ret; + +- clk_bulk_disable(pd->num_subsys_clks, pd->subsys_clks); ++ clk_bulk_disable_unprepare(pd->num_subsys_clks, pd->subsys_clks); + + /* subsys power off */ + regmap_clear_bits(scpsys->base, pd->data->ctl_offs, PWR_RST_B_BIT); +@@ -284,7 +284,7 @@ static int scpsys_power_off(struct generic_pm_domain *genpd) + if (ret < 0) + return ret; + +- clk_bulk_disable(pd->num_clks, pd->clks); ++ clk_bulk_disable_unprepare(pd->num_clks, pd->clks); + + scpsys_regulator_disable(pd->supply); + +@@ -297,6 +297,7 @@ generic_pm_domain *scpsys_add_one_domain(struct scpsys *scpsys, struct device_no + const struct scpsys_domain_data *domain_data; + struct scpsys_domain *pd; + struct device_node *root_node = scpsys->dev->of_node; ++ struct device_node *smi_node; + struct property *prop; + const char *clk_name; + int i, ret, num_clks; +@@ -352,9 +353,13 @@ generic_pm_domain *scpsys_add_one_domain(struct scpsys *scpsys, struct device_no + if (IS_ERR(pd->infracfg)) + return ERR_CAST(pd->infracfg); + +- pd->smi = syscon_regmap_lookup_by_phandle_optional(node, "mediatek,smi"); +- if (IS_ERR(pd->smi)) +- return ERR_CAST(pd->smi); ++ smi_node = of_parse_phandle(node, "mediatek,smi", 0); ++ if (smi_node) { ++ pd->smi = device_node_to_regmap(smi_node); ++ of_node_put(smi_node); ++ if (IS_ERR(pd->smi)) ++ return ERR_CAST(pd->smi); ++ } + + num_clks = of_clk_get_parent_count(node); + if (num_clks > 0) { +@@ -405,14 +410,6 @@ generic_pm_domain *scpsys_add_one_domain(struct scpsys *scpsys, struct device_no + pd->subsys_clks[i].clk = clk; + } + +- ret = clk_bulk_prepare(pd->num_clks, pd->clks); +- if (ret) +- goto err_put_subsys_clocks; +- +- ret = clk_bulk_prepare(pd->num_subsys_clks, pd->subsys_clks); +- if (ret) +- goto err_unprepare_clocks; +- + /* + * Initially turn on all domains to make the domains usable + * with !CONFIG_PM and to get the hardware in sync with the +@@ -427,7 +424,7 @@ generic_pm_domain *scpsys_add_one_domain(struct scpsys *scpsys, struct device_no + ret = scpsys_power_on(&pd->genpd); + if (ret < 0) { + dev_err(scpsys->dev, "%pOF: failed to power on domain: %d\n", node, ret); +- goto err_unprepare_clocks; ++ goto err_put_subsys_clocks; + } + } + +@@ -435,7 +432,7 @@ generic_pm_domain *scpsys_add_one_domain(struct scpsys *scpsys, struct device_no + ret = -EINVAL; + dev_err(scpsys->dev, + "power domain with id %d already exists, check your device-tree\n", id); +- goto err_unprepare_subsys_clocks; ++ goto err_put_subsys_clocks; + } + + if (!pd->data->name) +@@ -455,10 +452,6 @@ generic_pm_domain *scpsys_add_one_domain(struct scpsys *scpsys, struct device_no + + return scpsys->pd_data.domains[id]; + +-err_unprepare_subsys_clocks: +- clk_bulk_unprepare(pd->num_subsys_clks, pd->subsys_clks); +-err_unprepare_clocks: +- clk_bulk_unprepare(pd->num_clks, pd->clks); + err_put_subsys_clocks: + clk_bulk_put(pd->num_subsys_clks, pd->subsys_clks); + err_put_clocks: +@@ -537,10 +530,7 @@ static void scpsys_remove_one_domain(struct scpsys_domain *pd) + "failed to remove domain '%s' : %d - state may be inconsistent\n", + pd->genpd.name, ret); + +- clk_bulk_unprepare(pd->num_clks, pd->clks); + clk_bulk_put(pd->num_clks, pd->clks); +- +- clk_bulk_unprepare(pd->num_subsys_clks, pd->subsys_clks); + clk_bulk_put(pd->num_subsys_clks, pd->subsys_clks); + } + +diff --git a/drivers/staging/rtl8723bs/hal/odm.h b/drivers/staging/rtl8723bs/hal/odm.h +index 16e8f66a31714..a8d232245227b 100644 +--- a/drivers/staging/rtl8723bs/hal/odm.h ++++ b/drivers/staging/rtl8723bs/hal/odm.h +@@ -197,10 +197,7 @@ typedef struct _ODM_RATE_ADAPTIVE { + + #define AVG_THERMAL_NUM 8 + #define IQK_Matrix_REG_NUM 8 +-#define IQK_Matrix_Settings_NUM (14 + 24 + 21) /* Channels_2_4G_NUM +- * + Channels_5G_20M_NUM +- * + Channels_5G +- */ ++#define IQK_Matrix_Settings_NUM 14 /* Channels_2_4G_NUM */ + + #define DM_Type_ByFW 0 + #define DM_Type_ByDriver 1 +diff --git a/drivers/thermal/rcar_gen3_thermal.c b/drivers/thermal/rcar_gen3_thermal.c +index 75c69fe6e9553..c02922d2d1d5d 100644 +--- a/drivers/thermal/rcar_gen3_thermal.c ++++ b/drivers/thermal/rcar_gen3_thermal.c +@@ -142,7 +142,7 @@ static void rcar_gen3_thermal_calc_coefs(struct rcar_gen3_thermal_tsc *tsc, + * Division is not scaled in BSP and if scaled it might overflow + * the dividend (4095 * 4095 << 14 > INT_MAX) so keep it unscaled + */ +- tsc->tj_t = (FIXPT_INT((ptat[1] - ptat[2]) * 157) ++ tsc->tj_t = (FIXPT_INT((ptat[1] - ptat[2]) * (ths_tj_1 - TJ_3)) + / (ptat[0] - ptat[2])) + FIXPT_INT(TJ_3); + + tsc->coef.a1 = FIXPT_DIV(FIXPT_INT(thcode[1] - thcode[2]), +diff --git a/drivers/thermal/sprd_thermal.c b/drivers/thermal/sprd_thermal.c +index 3682edb2f4669..fe06cccf14b38 100644 +--- a/drivers/thermal/sprd_thermal.c ++++ b/drivers/thermal/sprd_thermal.c +@@ -532,6 +532,7 @@ static const struct of_device_id sprd_thermal_of_match[] = { + { .compatible = "sprd,ums512-thermal", .data = &ums512_data }, + { }, + }; ++MODULE_DEVICE_TABLE(of, sprd_thermal_of_match); + + static const struct dev_pm_ops sprd_thermal_pm_ops = { + SET_SYSTEM_SLEEP_PM_OPS(sprd_thm_suspend, sprd_thm_resume) +diff --git a/drivers/tty/serial/8250/serial_cs.c b/drivers/tty/serial/8250/serial_cs.c +index 1cc749903d127..ff6a95a352260 100644 +--- a/drivers/tty/serial/8250/serial_cs.c ++++ b/drivers/tty/serial/8250/serial_cs.c +@@ -306,6 +306,7 @@ static int serial_resume(struct pcmcia_device *link) + static int serial_probe(struct pcmcia_device *link) + { + struct serial_info *info; ++ int ret; + + dev_dbg(&link->dev, "serial_attach()\n"); + +@@ -320,7 +321,15 @@ static int serial_probe(struct pcmcia_device *link) + if (do_sound) + link->config_flags |= CONF_ENABLE_SPKR; + +- return serial_config(link); ++ ret = serial_config(link); ++ if (ret) ++ goto free_info; ++ ++ return 0; ++ ++free_info: ++ kfree(info); ++ return ret; + } + + static void serial_detach(struct pcmcia_device *link) +diff --git a/drivers/tty/serial/fsl_lpuart.c b/drivers/tty/serial/fsl_lpuart.c +index 9c78e43e669d7..0d7ea144a4a6d 100644 +--- a/drivers/tty/serial/fsl_lpuart.c ++++ b/drivers/tty/serial/fsl_lpuart.c +@@ -1571,6 +1571,9 @@ static void lpuart_tx_dma_startup(struct lpuart_port *sport) + u32 uartbaud; + int ret; + ++ if (uart_console(&sport->port)) ++ goto err; ++ + if (!sport->dma_tx_chan) + goto err; + +@@ -1600,6 +1603,9 @@ static void lpuart_rx_dma_startup(struct lpuart_port *sport) + int ret; + unsigned char cr3; + ++ if (uart_console(&sport->port)) ++ goto err; ++ + if (!sport->dma_rx_chan) + goto err; + +@@ -2404,6 +2410,9 @@ lpuart32_console_get_options(struct lpuart_port *sport, int *baud, + + bd = lpuart32_read(&sport->port, UARTBAUD); + bd &= UARTBAUD_SBR_MASK; ++ if (!bd) ++ return; ++ + sbr = bd; + uartclk = lpuart_get_baud_clk_rate(sport); + /* +diff --git a/drivers/tty/serial/uartlite.c b/drivers/tty/serial/uartlite.c +index f42ccc40ffa64..a5f15f22d9efe 100644 +--- a/drivers/tty/serial/uartlite.c ++++ b/drivers/tty/serial/uartlite.c +@@ -505,21 +505,23 @@ static void ulite_console_write(struct console *co, const char *s, + + static int ulite_console_setup(struct console *co, char *options) + { +- struct uart_port *port; ++ struct uart_port *port = NULL; + int baud = 9600; + int bits = 8; + int parity = 'n'; + int flow = 'n'; + +- +- port = console_port; ++ if (co->index >= 0 && co->index < ULITE_NR_UARTS) ++ port = ulite_ports + co->index; + + /* Has the device been initialized yet? */ +- if (!port->mapbase) { ++ if (!port || !port->mapbase) { + pr_debug("console on ttyUL%i not present\n", co->index); + return -ENODEV; + } + ++ console_port = port; ++ + /* not initialized yet? */ + if (!port->membase) { + if (ulite_request_port(port)) +@@ -655,17 +657,6 @@ static int ulite_assign(struct device *dev, int id, u32 base, int irq, + + dev_set_drvdata(dev, port); + +-#ifdef CONFIG_SERIAL_UARTLITE_CONSOLE +- /* +- * If console hasn't been found yet try to assign this port +- * because it is required to be assigned for console setup function. +- * If register_console() don't assign value, then console_port pointer +- * is cleanup. +- */ +- if (ulite_uart_driver.cons->index == -1) +- console_port = port; +-#endif +- + /* Register the port */ + rc = uart_add_one_port(&ulite_uart_driver, port); + if (rc) { +@@ -675,12 +666,6 @@ static int ulite_assign(struct device *dev, int id, u32 base, int irq, + return rc; + } + +-#ifdef CONFIG_SERIAL_UARTLITE_CONSOLE +- /* This is not port which is used for console that's why clean it up */ +- if (ulite_uart_driver.cons->index == -1) +- console_port = NULL; +-#endif +- + return 0; + } + +diff --git a/drivers/usb/common/usb-conn-gpio.c b/drivers/usb/common/usb-conn-gpio.c +index 6c4e3a19f42cb..c9545a4eff664 100644 +--- a/drivers/usb/common/usb-conn-gpio.c ++++ b/drivers/usb/common/usb-conn-gpio.c +@@ -149,14 +149,32 @@ static int usb_charger_get_property(struct power_supply *psy, + return 0; + } + +-static int usb_conn_probe(struct platform_device *pdev) ++static int usb_conn_psy_register(struct usb_conn_info *info) + { +- struct device *dev = &pdev->dev; +- struct power_supply_desc *desc; +- struct usb_conn_info *info; ++ struct device *dev = info->dev; ++ struct power_supply_desc *desc = &info->desc; + struct power_supply_config cfg = { + .of_node = dev->of_node, + }; ++ ++ desc->name = "usb-charger"; ++ desc->properties = usb_charger_properties; ++ desc->num_properties = ARRAY_SIZE(usb_charger_properties); ++ desc->get_property = usb_charger_get_property; ++ desc->type = POWER_SUPPLY_TYPE_USB; ++ cfg.drv_data = info; ++ ++ info->charger = devm_power_supply_register(dev, desc, &cfg); ++ if (IS_ERR(info->charger)) ++ dev_err(dev, "Unable to register charger\n"); ++ ++ return PTR_ERR_OR_ZERO(info->charger); ++} ++ ++static int usb_conn_probe(struct platform_device *pdev) ++{ ++ struct device *dev = &pdev->dev; ++ struct usb_conn_info *info; + bool need_vbus = true; + int ret = 0; + +@@ -218,6 +236,10 @@ static int usb_conn_probe(struct platform_device *pdev) + return PTR_ERR(info->role_sw); + } + ++ ret = usb_conn_psy_register(info); ++ if (ret) ++ goto put_role_sw; ++ + if (info->id_gpiod) { + info->id_irq = gpiod_to_irq(info->id_gpiod); + if (info->id_irq < 0) { +@@ -252,20 +274,6 @@ static int usb_conn_probe(struct platform_device *pdev) + } + } + +- desc = &info->desc; +- desc->name = "usb-charger"; +- desc->properties = usb_charger_properties; +- desc->num_properties = ARRAY_SIZE(usb_charger_properties); +- desc->get_property = usb_charger_get_property; +- desc->type = POWER_SUPPLY_TYPE_USB; +- cfg.drv_data = info; +- +- info->charger = devm_power_supply_register(dev, desc, &cfg); +- if (IS_ERR(info->charger)) { +- dev_err(dev, "Unable to register charger\n"); +- return PTR_ERR(info->charger); +- } +- + platform_set_drvdata(pdev, info); + + /* Perform initial detection */ +diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c +index 19789e94bbd00..45ec5ac9876e4 100644 +--- a/drivers/usb/dwc3/dwc3-pci.c ++++ b/drivers/usb/dwc3/dwc3-pci.c +@@ -36,7 +36,7 @@ + #define PCI_DEVICE_ID_INTEL_CNPH 0xa36e + #define PCI_DEVICE_ID_INTEL_CNPV 0xa3b0 + #define PCI_DEVICE_ID_INTEL_ICLLP 0x34ee +-#define PCI_DEVICE_ID_INTEL_EHLLP 0x4b7e ++#define PCI_DEVICE_ID_INTEL_EHL 0x4b7e + #define PCI_DEVICE_ID_INTEL_TGPLP 0xa0ee + #define PCI_DEVICE_ID_INTEL_TGPH 0x43ee + #define PCI_DEVICE_ID_INTEL_JSP 0x4dee +@@ -167,7 +167,7 @@ static int dwc3_pci_quirks(struct dwc3_pci *dwc) + if (pdev->vendor == PCI_VENDOR_ID_INTEL) { + if (pdev->device == PCI_DEVICE_ID_INTEL_BXT || + pdev->device == PCI_DEVICE_ID_INTEL_BXT_M || +- pdev->device == PCI_DEVICE_ID_INTEL_EHLLP) { ++ pdev->device == PCI_DEVICE_ID_INTEL_EHL) { + guid_parse(PCI_INTEL_BXT_DSM_GUID, &dwc->guid); + dwc->has_dsm_for_pm = true; + } +@@ -375,8 +375,8 @@ static const struct pci_device_id dwc3_pci_id_table[] = { + { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_ICLLP), + (kernel_ulong_t) &dwc3_pci_intel_swnode, }, + +- { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_EHLLP), +- (kernel_ulong_t) &dwc3_pci_intel_swnode }, ++ { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_EHL), ++ (kernel_ulong_t) &dwc3_pci_intel_swnode, }, + + { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_TGPLP), + (kernel_ulong_t) &dwc3_pci_intel_swnode, }, +diff --git a/drivers/usb/gadget/function/f_hid.c b/drivers/usb/gadget/function/f_hid.c +index e556993081170..a82b3de1a54be 100644 +--- a/drivers/usb/gadget/function/f_hid.c ++++ b/drivers/usb/gadget/function/f_hid.c +@@ -88,7 +88,7 @@ static struct usb_interface_descriptor hidg_interface_desc = { + static struct hid_descriptor hidg_desc = { + .bLength = sizeof hidg_desc, + .bDescriptorType = HID_DT_HID, +- .bcdHID = 0x0101, ++ .bcdHID = cpu_to_le16(0x0101), + .bCountryCode = 0x00, + .bNumDescriptors = 0x1, + /*.desc[0].bDescriptorType = DYNAMIC */ +diff --git a/drivers/usb/gadget/legacy/hid.c b/drivers/usb/gadget/legacy/hid.c +index c4eda7fe7ab45..5b27d289443fe 100644 +--- a/drivers/usb/gadget/legacy/hid.c ++++ b/drivers/usb/gadget/legacy/hid.c +@@ -171,8 +171,10 @@ static int hid_bind(struct usb_composite_dev *cdev) + struct usb_descriptor_header *usb_desc; + + usb_desc = usb_otg_descriptor_alloc(gadget); +- if (!usb_desc) ++ if (!usb_desc) { ++ status = -ENOMEM; + goto put; ++ } + usb_otg_descriptor_init(gadget, usb_desc); + otg_desc[0] = usb_desc; + otg_desc[1] = NULL; +diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c +index 0d2f1c37ab745..73cdaa3f30675 100644 +--- a/drivers/usb/host/xhci.c ++++ b/drivers/usb/host/xhci.c +@@ -1362,12 +1362,17 @@ static void xhci_unmap_temp_buf(struct usb_hcd *hcd, struct urb *urb) + urb->transfer_buffer_length, + dir); + +- if (usb_urb_dir_in(urb)) ++ if (usb_urb_dir_in(urb)) { + len = sg_pcopy_from_buffer(urb->sg, urb->num_sgs, + urb->transfer_buffer, + buf_len, + 0); +- ++ if (len != buf_len) { ++ xhci_dbg(hcd_to_xhci(hcd), ++ "Copy from tmp buf to urb sg list failed\n"); ++ urb->actual_length = len; ++ } ++ } + urb->transfer_flags &= ~URB_DMA_MAP_SINGLE; + kfree(urb->transfer_buffer); + urb->transfer_buffer = NULL; +diff --git a/drivers/vdpa/mlx5/core/mr.c b/drivers/vdpa/mlx5/core/mr.c +index 800cfd1967ada..cfa56a58b271b 100644 +--- a/drivers/vdpa/mlx5/core/mr.c ++++ b/drivers/vdpa/mlx5/core/mr.c +@@ -219,11 +219,6 @@ static void destroy_indirect_key(struct mlx5_vdpa_dev *mvdev, struct mlx5_vdpa_m + mlx5_vdpa_destroy_mkey(mvdev, &mkey->mkey); + } + +-static struct device *get_dma_device(struct mlx5_vdpa_dev *mvdev) +-{ +- return &mvdev->mdev->pdev->dev; +-} +- + static int map_direct_mr(struct mlx5_vdpa_dev *mvdev, struct mlx5_vdpa_direct_mr *mr, + struct vhost_iotlb *iotlb) + { +@@ -239,7 +234,7 @@ static int map_direct_mr(struct mlx5_vdpa_dev *mvdev, struct mlx5_vdpa_direct_mr + u64 pa; + u64 paend; + struct scatterlist *sg; +- struct device *dma = get_dma_device(mvdev); ++ struct device *dma = mvdev->vdev.dma_dev; + + for (map = vhost_iotlb_itree_first(iotlb, mr->start, mr->end - 1); + map; map = vhost_iotlb_itree_next(map, start, mr->end - 1)) { +@@ -298,7 +293,7 @@ err_map: + + static void unmap_direct_mr(struct mlx5_vdpa_dev *mvdev, struct mlx5_vdpa_direct_mr *mr) + { +- struct device *dma = get_dma_device(mvdev); ++ struct device *dma = mvdev->vdev.dma_dev; + + destroy_direct_mr(mvdev, mr); + dma_unmap_sg_attrs(dma, mr->sg_head.sgl, mr->nsg, DMA_BIDIRECTIONAL, 0); +diff --git a/drivers/vdpa/mlx5/net/mlx5_vnet.c b/drivers/vdpa/mlx5/net/mlx5_vnet.c +index a0e86c5d7cd7a..68fd117fd7a50 100644 +--- a/drivers/vdpa/mlx5/net/mlx5_vnet.c ++++ b/drivers/vdpa/mlx5/net/mlx5_vnet.c +@@ -611,8 +611,8 @@ static void cq_destroy(struct mlx5_vdpa_net *ndev, u16 idx) + mlx5_db_free(ndev->mvdev.mdev, &vcq->db); + } + +-static int umem_size(struct mlx5_vdpa_net *ndev, struct mlx5_vdpa_virtqueue *mvq, int num, +- struct mlx5_vdpa_umem **umemp) ++static void set_umem_size(struct mlx5_vdpa_net *ndev, struct mlx5_vdpa_virtqueue *mvq, int num, ++ struct mlx5_vdpa_umem **umemp) + { + struct mlx5_core_dev *mdev = ndev->mvdev.mdev; + int p_a; +@@ -635,7 +635,7 @@ static int umem_size(struct mlx5_vdpa_net *ndev, struct mlx5_vdpa_virtqueue *mvq + *umemp = &mvq->umem3; + break; + } +- return p_a * mvq->num_ent + p_b; ++ (*umemp)->size = p_a * mvq->num_ent + p_b; + } + + static void umem_frag_buf_free(struct mlx5_vdpa_net *ndev, struct mlx5_vdpa_umem *umem) +@@ -651,15 +651,10 @@ static int create_umem(struct mlx5_vdpa_net *ndev, struct mlx5_vdpa_virtqueue *m + void *in; + int err; + __be64 *pas; +- int size; + struct mlx5_vdpa_umem *umem; + +- size = umem_size(ndev, mvq, num, &umem); +- if (size < 0) +- return size; +- +- umem->size = size; +- err = umem_frag_buf_alloc(ndev, umem, size); ++ set_umem_size(ndev, mvq, num, &umem); ++ err = umem_frag_buf_alloc(ndev, umem, umem->size); + if (err) + return err; + +@@ -829,9 +824,9 @@ static int create_virtqueue(struct mlx5_vdpa_net *ndev, struct mlx5_vdpa_virtque + MLX5_SET(virtio_q, vq_ctx, umem_1_id, mvq->umem1.id); + MLX5_SET(virtio_q, vq_ctx, umem_1_size, mvq->umem1.size); + MLX5_SET(virtio_q, vq_ctx, umem_2_id, mvq->umem2.id); +- MLX5_SET(virtio_q, vq_ctx, umem_2_size, mvq->umem1.size); ++ MLX5_SET(virtio_q, vq_ctx, umem_2_size, mvq->umem2.size); + MLX5_SET(virtio_q, vq_ctx, umem_3_id, mvq->umem3.id); +- MLX5_SET(virtio_q, vq_ctx, umem_3_size, mvq->umem1.size); ++ MLX5_SET(virtio_q, vq_ctx, umem_3_size, mvq->umem3.size); + MLX5_SET(virtio_q, vq_ctx, pd, ndev->mvdev.res.pdn); + if (MLX5_CAP_DEV_VDPA_EMULATION(ndev->mvdev.mdev, eth_frame_offload_type)) + MLX5_SET(virtio_q, vq_ctx, virtio_version_1_0, 1); +@@ -1772,6 +1767,14 @@ out: + mutex_unlock(&ndev->reslock); + } + ++static void clear_vqs_ready(struct mlx5_vdpa_net *ndev) ++{ ++ int i; ++ ++ for (i = 0; i < ndev->mvdev.max_vqs; i++) ++ ndev->vqs[i].ready = false; ++} ++ + static void mlx5_vdpa_set_status(struct vdpa_device *vdev, u8 status) + { + struct mlx5_vdpa_dev *mvdev = to_mvdev(vdev); +@@ -1782,6 +1785,7 @@ static void mlx5_vdpa_set_status(struct vdpa_device *vdev, u8 status) + if (!status) { + mlx5_vdpa_info(mvdev, "performing device reset\n"); + teardown_driver(ndev); ++ clear_vqs_ready(ndev); + mlx5_vdpa_destroy_mr(&ndev->mvdev); + ndev->mvdev.status = 0; + ndev->mvdev.mlx_features = 0; +@@ -2022,7 +2026,7 @@ static int mlx5v_probe(struct auxiliary_device *adev, + goto err_mtu; + } + +- mvdev->vdev.dma_dev = mdev->device; ++ mvdev->vdev.dma_dev = &mdev->pdev->dev; + err = mlx5_vdpa_alloc_resources(&ndev->mvdev); + if (err) + goto err_mpfs; +diff --git a/drivers/video/backlight/lm3630a_bl.c b/drivers/video/backlight/lm3630a_bl.c +index 662029d6a3dc9..419b0334cf087 100644 +--- a/drivers/video/backlight/lm3630a_bl.c ++++ b/drivers/video/backlight/lm3630a_bl.c +@@ -190,7 +190,7 @@ static int lm3630a_bank_a_update_status(struct backlight_device *bl) + if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0) { + lm3630a_pwm_ctrl(pchip, bl->props.brightness, + bl->props.max_brightness); +- return bl->props.brightness; ++ return 0; + } + + /* disable sleep */ +@@ -210,8 +210,8 @@ static int lm3630a_bank_a_update_status(struct backlight_device *bl) + return 0; + + out_i2c_err: +- dev_err(pchip->dev, "i2c failed to access\n"); +- return bl->props.brightness; ++ dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret)); ++ return ret; + } + + static int lm3630a_bank_a_get_brightness(struct backlight_device *bl) +@@ -267,7 +267,7 @@ static int lm3630a_bank_b_update_status(struct backlight_device *bl) + if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) { + lm3630a_pwm_ctrl(pchip, bl->props.brightness, + bl->props.max_brightness); +- return bl->props.brightness; ++ return 0; + } + + /* disable sleep */ +@@ -287,8 +287,8 @@ static int lm3630a_bank_b_update_status(struct backlight_device *bl) + return 0; + + out_i2c_err: +- dev_err(pchip->dev, "i2c failed to access REG_CTRL\n"); +- return bl->props.brightness; ++ dev_err(pchip->dev, "i2c failed to access (%pe)\n", ERR_PTR(ret)); ++ return ret; + } + + static int lm3630a_bank_b_get_brightness(struct backlight_device *bl) +diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c +index 06f5805de2dee..199c5e85f56e3 100644 +--- a/drivers/video/fbdev/core/fbmem.c ++++ b/drivers/video/fbdev/core/fbmem.c +@@ -970,13 +970,11 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var) + fb_var_to_videomode(&mode2, &info->var); + /* make sure we don't delete the videomode of current var */ + ret = fb_mode_is_equal(&mode1, &mode2); +- +- if (!ret) +- fbcon_mode_deleted(info, &mode1); +- +- if (!ret) +- fb_delete_videomode(&mode1, &info->modelist); +- ++ if (!ret) { ++ ret = fbcon_mode_deleted(info, &mode1); ++ if (!ret) ++ fb_delete_videomode(&mode1, &info->modelist); ++ } + + return ret ? -EINVAL : 0; + } +diff --git a/drivers/virtio/virtio_mem.c b/drivers/virtio/virtio_mem.c +index 10ec60d81e847..3bf08b5bb3595 100644 +--- a/drivers/virtio/virtio_mem.c ++++ b/drivers/virtio/virtio_mem.c +@@ -2420,6 +2420,10 @@ static int virtio_mem_init(struct virtio_mem *vm) + dev_warn(&vm->vdev->dev, + "Some device memory is not addressable/pluggable. This can make some memory unusable.\n"); + ++ /* Prepare the offline threshold - make sure we can add two blocks. */ ++ vm->offline_threshold = max_t(uint64_t, 2 * memory_block_size_bytes(), ++ VIRTIO_MEM_DEFAULT_OFFLINE_THRESHOLD); ++ + /* + * We want subblocks to span at least MAX_ORDER_NR_PAGES and + * pageblock_nr_pages pages. This: +@@ -2466,14 +2470,11 @@ static int virtio_mem_init(struct virtio_mem *vm) + vm->bbm.bb_size - 1; + vm->bbm.first_bb_id = virtio_mem_phys_to_bb_id(vm, addr); + vm->bbm.next_bb_id = vm->bbm.first_bb_id; +- } + +- /* Prepare the offline threshold - make sure we can add two blocks. */ +- vm->offline_threshold = max_t(uint64_t, 2 * memory_block_size_bytes(), +- VIRTIO_MEM_DEFAULT_OFFLINE_THRESHOLD); +- /* In BBM, we also want at least two big blocks. */ +- vm->offline_threshold = max_t(uint64_t, 2 * vm->bbm.bb_size, +- vm->offline_threshold); ++ /* Make sure we can add two big blocks. */ ++ vm->offline_threshold = max_t(uint64_t, 2 * vm->bbm.bb_size, ++ vm->offline_threshold); ++ } + + dev_info(&vm->vdev->dev, "start address: 0x%llx", vm->addr); + dev_info(&vm->vdev->dev, "region size: 0x%llx", vm->region_size); +diff --git a/drivers/w1/slaves/w1_ds2438.c b/drivers/w1/slaves/w1_ds2438.c +index 5cfb0ae23e916..5698566b0ee01 100644 +--- a/drivers/w1/slaves/w1_ds2438.c ++++ b/drivers/w1/slaves/w1_ds2438.c +@@ -62,13 +62,13 @@ static int w1_ds2438_get_page(struct w1_slave *sl, int pageno, u8 *buf) + if (w1_reset_select_slave(sl)) + continue; + w1_buf[0] = W1_DS2438_RECALL_MEMORY; +- w1_buf[1] = 0x00; ++ w1_buf[1] = (u8)pageno; + w1_write_block(sl->master, w1_buf, 2); + + if (w1_reset_select_slave(sl)) + continue; + w1_buf[0] = W1_DS2438_READ_SCRATCH; +- w1_buf[1] = 0x00; ++ w1_buf[1] = (u8)pageno; + w1_write_block(sl->master, w1_buf, 2); + + count = w1_read_block(sl->master, buf, DS2438_PAGE_SIZE + 1); +diff --git a/drivers/watchdog/aspeed_wdt.c b/drivers/watchdog/aspeed_wdt.c +index 7e00960651fa2..507fd815d7679 100644 +--- a/drivers/watchdog/aspeed_wdt.c ++++ b/drivers/watchdog/aspeed_wdt.c +@@ -147,7 +147,7 @@ static int aspeed_wdt_set_timeout(struct watchdog_device *wdd, + + wdd->timeout = timeout; + +- actual = min(timeout, wdd->max_hw_heartbeat_ms * 1000); ++ actual = min(timeout, wdd->max_hw_heartbeat_ms / 1000); + + writel(actual * WDT_RATE_1MHZ, wdt->base + WDT_RELOAD_VALUE); + writel(WDT_RESTART_MAGIC, wdt->base + WDT_RESTART); +diff --git a/drivers/watchdog/iTCO_wdt.c b/drivers/watchdog/iTCO_wdt.c +index bf31d7b67a697..3f1324871cfd6 100644 +--- a/drivers/watchdog/iTCO_wdt.c ++++ b/drivers/watchdog/iTCO_wdt.c +@@ -71,6 +71,8 @@ + #define TCOBASE(p) ((p)->tco_res->start) + /* SMI Control and Enable Register */ + #define SMI_EN(p) ((p)->smi_res->start) ++#define TCO_EN (1 << 13) ++#define GBL_SMI_EN (1 << 0) + + #define TCO_RLD(p) (TCOBASE(p) + 0x00) /* TCO Timer Reload/Curr. Value */ + #define TCOv1_TMR(p) (TCOBASE(p) + 0x01) /* TCOv1 Timer Initial Value*/ +@@ -355,8 +357,12 @@ static int iTCO_wdt_set_timeout(struct watchdog_device *wd_dev, unsigned int t) + + tmrval = seconds_to_ticks(p, t); + +- /* For TCO v1 the timer counts down twice before rebooting */ +- if (p->iTCO_version == 1) ++ /* ++ * If TCO SMIs are off, the timer counts down twice before rebooting. ++ * Otherwise, the BIOS generally reboots when the SMI triggers. ++ */ ++ if (p->smi_res && ++ (SMI_EN(p) & (TCO_EN | GBL_SMI_EN)) != (TCO_EN | GBL_SMI_EN)) + tmrval /= 2; + + /* from the specs: */ +@@ -521,7 +527,7 @@ static int iTCO_wdt_probe(struct platform_device *pdev) + * Disables TCO logic generating an SMI# + */ + val32 = inl(SMI_EN(p)); +- val32 &= 0xffffdfff; /* Turn off SMI clearing watchdog */ ++ val32 &= ~TCO_EN; /* Turn off SMI clearing watchdog */ + outl(val32, SMI_EN(p)); + } + +diff --git a/drivers/watchdog/imx_sc_wdt.c b/drivers/watchdog/imx_sc_wdt.c +index e9ee22a7cb456..8ac021748d160 100644 +--- a/drivers/watchdog/imx_sc_wdt.c ++++ b/drivers/watchdog/imx_sc_wdt.c +@@ -183,16 +183,12 @@ static int imx_sc_wdt_probe(struct platform_device *pdev) + watchdog_stop_on_reboot(wdog); + watchdog_stop_on_unregister(wdog); + +- ret = devm_watchdog_register_device(dev, wdog); +- if (ret) +- return ret; +- + ret = imx_scu_irq_group_enable(SC_IRQ_GROUP_WDOG, + SC_IRQ_WDOG, + true); + if (ret) { + dev_warn(dev, "Enable irq failed, pretimeout NOT supported\n"); +- return 0; ++ goto register_device; + } + + imx_sc_wdd->wdt_notifier.notifier_call = imx_sc_wdt_notify; +@@ -203,7 +199,7 @@ static int imx_sc_wdt_probe(struct platform_device *pdev) + false); + dev_warn(dev, + "Register irq notifier failed, pretimeout NOT supported\n"); +- return 0; ++ goto register_device; + } + + ret = devm_add_action_or_reset(dev, imx_sc_wdt_action, +@@ -213,7 +209,8 @@ static int imx_sc_wdt_probe(struct platform_device *pdev) + else + dev_warn(dev, "Add action failed, pretimeout NOT supported\n"); + +- return 0; ++register_device: ++ return devm_watchdog_register_device(dev, wdog); + } + + static int __maybe_unused imx_sc_wdt_suspend(struct device *dev) +diff --git a/drivers/watchdog/jz4740_wdt.c b/drivers/watchdog/jz4740_wdt.c +index bdf9564efa29e..395bde79e2920 100644 +--- a/drivers/watchdog/jz4740_wdt.c ++++ b/drivers/watchdog/jz4740_wdt.c +@@ -176,9 +176,9 @@ static int jz4740_wdt_probe(struct platform_device *pdev) + watchdog_set_drvdata(jz4740_wdt, drvdata); + + drvdata->map = device_node_to_regmap(dev->parent->of_node); +- if (!drvdata->map) { ++ if (IS_ERR(drvdata->map)) { + dev_err(dev, "regmap not found\n"); +- return -EINVAL; ++ return PTR_ERR(drvdata->map); + } + + return devm_watchdog_register_device(dev, &drvdata->wdt); +diff --git a/drivers/watchdog/keembay_wdt.c b/drivers/watchdog/keembay_wdt.c +index 547d3fea33ff6..dd192b8dff551 100644 +--- a/drivers/watchdog/keembay_wdt.c ++++ b/drivers/watchdog/keembay_wdt.c +@@ -23,12 +23,14 @@ + #define TIM_WDOG_EN 0x8 + #define TIM_SAFE 0xc + +-#define WDT_ISR_MASK GENMASK(9, 8) ++#define WDT_TH_INT_MASK BIT(8) ++#define WDT_TO_INT_MASK BIT(9) + #define WDT_ISR_CLEAR 0x8200ff18 + #define WDT_UNLOCK 0xf1d0dead + #define WDT_LOAD_MAX U32_MAX + #define WDT_LOAD_MIN 1 + #define WDT_TIMEOUT 5 ++#define WDT_PRETIMEOUT 4 + + static unsigned int timeout = WDT_TIMEOUT; + module_param(timeout, int, 0); +@@ -82,7 +84,6 @@ static int keembay_wdt_start(struct watchdog_device *wdog) + { + struct keembay_wdt *wdt = watchdog_get_drvdata(wdog); + +- keembay_wdt_set_timeout_reg(wdog); + keembay_wdt_writel(wdt, TIM_WDOG_EN, 1); + + return 0; +@@ -108,6 +109,7 @@ static int keembay_wdt_set_timeout(struct watchdog_device *wdog, u32 t) + { + wdog->timeout = t; + keembay_wdt_set_timeout_reg(wdog); ++ keembay_wdt_set_pretimeout_reg(wdog); + + return 0; + } +@@ -139,8 +141,7 @@ static irqreturn_t keembay_wdt_to_isr(int irq, void *dev_id) + struct keembay_wdt *wdt = dev_id; + struct arm_smccc_res res; + +- keembay_wdt_writel(wdt, TIM_WATCHDOG, 1); +- arm_smccc_smc(WDT_ISR_CLEAR, WDT_ISR_MASK, 0, 0, 0, 0, 0, 0, &res); ++ arm_smccc_smc(WDT_ISR_CLEAR, WDT_TO_INT_MASK, 0, 0, 0, 0, 0, 0, &res); + dev_crit(wdt->wdd.parent, "Intel Keem Bay non-sec wdt timeout.\n"); + emergency_restart(); + +@@ -152,7 +153,9 @@ static irqreturn_t keembay_wdt_th_isr(int irq, void *dev_id) + struct keembay_wdt *wdt = dev_id; + struct arm_smccc_res res; + +- arm_smccc_smc(WDT_ISR_CLEAR, WDT_ISR_MASK, 0, 0, 0, 0, 0, 0, &res); ++ keembay_wdt_set_pretimeout(&wdt->wdd, 0x0); ++ ++ arm_smccc_smc(WDT_ISR_CLEAR, WDT_TH_INT_MASK, 0, 0, 0, 0, 0, 0, &res); + dev_crit(wdt->wdd.parent, "Intel Keem Bay non-sec wdt pre-timeout.\n"); + watchdog_notify_pretimeout(&wdt->wdd); + +@@ -224,11 +227,13 @@ static int keembay_wdt_probe(struct platform_device *pdev) + wdt->wdd.min_timeout = WDT_LOAD_MIN; + wdt->wdd.max_timeout = WDT_LOAD_MAX / wdt->rate; + wdt->wdd.timeout = WDT_TIMEOUT; ++ wdt->wdd.pretimeout = WDT_PRETIMEOUT; + + watchdog_set_drvdata(&wdt->wdd, wdt); + watchdog_set_nowayout(&wdt->wdd, nowayout); + watchdog_init_timeout(&wdt->wdd, timeout, dev); + keembay_wdt_set_timeout(&wdt->wdd, wdt->wdd.timeout); ++ keembay_wdt_set_pretimeout(&wdt->wdd, wdt->wdd.pretimeout); + + ret = devm_watchdog_register_device(dev, &wdt->wdd); + if (ret) +diff --git a/drivers/watchdog/lpc18xx_wdt.c b/drivers/watchdog/lpc18xx_wdt.c +index 78cf11c949416..60b6d74f267dd 100644 +--- a/drivers/watchdog/lpc18xx_wdt.c ++++ b/drivers/watchdog/lpc18xx_wdt.c +@@ -292,7 +292,7 @@ static int lpc18xx_wdt_remove(struct platform_device *pdev) + struct lpc18xx_wdt_dev *lpc18xx_wdt = platform_get_drvdata(pdev); + + dev_warn(&pdev->dev, "I quit now, hardware will probably reboot!\n"); +- del_timer(&lpc18xx_wdt->timer); ++ del_timer_sync(&lpc18xx_wdt->timer); + + return 0; + } +diff --git a/drivers/watchdog/sbc60xxwdt.c b/drivers/watchdog/sbc60xxwdt.c +index a947a63fb44ae..7b974802dfc7c 100644 +--- a/drivers/watchdog/sbc60xxwdt.c ++++ b/drivers/watchdog/sbc60xxwdt.c +@@ -146,7 +146,7 @@ static void wdt_startup(void) + static void wdt_turnoff(void) + { + /* Stop the timer */ +- del_timer(&timer); ++ del_timer_sync(&timer); + inb_p(wdt_stop); + pr_info("Watchdog timer is now disabled...\n"); + } +diff --git a/drivers/watchdog/sc520_wdt.c b/drivers/watchdog/sc520_wdt.c +index e66e6b905964b..ca65468f4b9ce 100644 +--- a/drivers/watchdog/sc520_wdt.c ++++ b/drivers/watchdog/sc520_wdt.c +@@ -186,7 +186,7 @@ static int wdt_startup(void) + static int wdt_turnoff(void) + { + /* Stop the timer */ +- del_timer(&timer); ++ del_timer_sync(&timer); + + /* Stop the watchdog */ + wdt_config(0); +diff --git a/drivers/watchdog/w83877f_wdt.c b/drivers/watchdog/w83877f_wdt.c +index 5772cc5d37804..f2650863fd027 100644 +--- a/drivers/watchdog/w83877f_wdt.c ++++ b/drivers/watchdog/w83877f_wdt.c +@@ -166,7 +166,7 @@ static void wdt_startup(void) + static void wdt_turnoff(void) + { + /* Stop the timer */ +- del_timer(&timer); ++ del_timer_sync(&timer); + + wdt_change(WDT_DISABLE); + +diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c +index 595fd083c4ad1..1947fa34577bc 100644 +--- a/fs/btrfs/block-group.c ++++ b/fs/btrfs/block-group.c +@@ -2101,6 +2101,13 @@ error: + return ret; + } + ++/* ++ * This function, insert_block_group_item(), belongs to the phase 2 of chunk ++ * allocation. ++ * ++ * See the comment at btrfs_chunk_alloc() for details about the chunk allocation ++ * phases. ++ */ + static int insert_block_group_item(struct btrfs_trans_handle *trans, + struct btrfs_block_group *block_group) + { +@@ -2123,15 +2130,19 @@ static int insert_block_group_item(struct btrfs_trans_handle *trans, + return btrfs_insert_item(trans, root, &key, &bgi, sizeof(bgi)); + } + ++/* ++ * This function, btrfs_create_pending_block_groups(), belongs to the phase 2 of ++ * chunk allocation. ++ * ++ * See the comment at btrfs_chunk_alloc() for details about the chunk allocation ++ * phases. ++ */ + void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans) + { + struct btrfs_fs_info *fs_info = trans->fs_info; + struct btrfs_block_group *block_group; + int ret = 0; + +- if (!trans->can_flush_pending_bgs) +- return; +- + while (!list_empty(&trans->new_bgs)) { + int index; + +@@ -2146,6 +2157,13 @@ void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans) + ret = insert_block_group_item(trans, block_group); + if (ret) + btrfs_abort_transaction(trans, ret); ++ if (!block_group->chunk_item_inserted) { ++ mutex_lock(&fs_info->chunk_mutex); ++ ret = btrfs_chunk_alloc_add_chunk_item(trans, block_group); ++ mutex_unlock(&fs_info->chunk_mutex); ++ if (ret) ++ btrfs_abort_transaction(trans, ret); ++ } + ret = btrfs_finish_chunk_alloc(trans, block_group->start, + block_group->length); + if (ret) +@@ -2169,8 +2187,9 @@ next: + btrfs_trans_release_chunk_metadata(trans); + } + +-int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used, +- u64 type, u64 chunk_offset, u64 size) ++struct btrfs_block_group *btrfs_make_block_group(struct btrfs_trans_handle *trans, ++ u64 bytes_used, u64 type, ++ u64 chunk_offset, u64 size) + { + struct btrfs_fs_info *fs_info = trans->fs_info; + struct btrfs_block_group *cache; +@@ -2180,7 +2199,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used, + + cache = btrfs_create_block_group_cache(fs_info, chunk_offset); + if (!cache) +- return -ENOMEM; ++ return ERR_PTR(-ENOMEM); + + cache->length = size; + set_free_space_tree_thresholds(cache); +@@ -2194,7 +2213,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used, + ret = btrfs_load_block_group_zone_info(cache, true); + if (ret) { + btrfs_put_block_group(cache); +- return ret; ++ return ERR_PTR(ret); + } + + ret = exclude_super_stripes(cache); +@@ -2202,7 +2221,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used, + /* We may have excluded something, so call this just in case */ + btrfs_free_excluded_extents(cache); + btrfs_put_block_group(cache); +- return ret; ++ return ERR_PTR(ret); + } + + add_new_free_space(cache, chunk_offset, chunk_offset + size); +@@ -2229,7 +2248,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used, + if (ret) { + btrfs_remove_free_space_cache(cache); + btrfs_put_block_group(cache); +- return ret; ++ return ERR_PTR(ret); + } + + /* +@@ -2248,7 +2267,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used, + btrfs_update_delayed_refs_rsv(trans); + + set_avail_alloc_bits(fs_info, type); +- return 0; ++ return cache; + } + + /* +@@ -3124,11 +3143,203 @@ int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans, u64 type) + return btrfs_chunk_alloc(trans, alloc_flags, CHUNK_ALLOC_FORCE); + } + ++static int do_chunk_alloc(struct btrfs_trans_handle *trans, u64 flags) ++{ ++ struct btrfs_block_group *bg; ++ int ret; ++ ++ /* ++ * Check if we have enough space in the system space info because we ++ * will need to update device items in the chunk btree and insert a new ++ * chunk item in the chunk btree as well. This will allocate a new ++ * system block group if needed. ++ */ ++ check_system_chunk(trans, flags); ++ ++ bg = btrfs_alloc_chunk(trans, flags); ++ if (IS_ERR(bg)) { ++ ret = PTR_ERR(bg); ++ goto out; ++ } ++ ++ /* ++ * If this is a system chunk allocation then stop right here and do not ++ * add the chunk item to the chunk btree. This is to prevent a deadlock ++ * because this system chunk allocation can be triggered while COWing ++ * some extent buffer of the chunk btree and while holding a lock on a ++ * parent extent buffer, in which case attempting to insert the chunk ++ * item (or update the device item) would result in a deadlock on that ++ * parent extent buffer. In this case defer the chunk btree updates to ++ * the second phase of chunk allocation and keep our reservation until ++ * the second phase completes. ++ * ++ * This is a rare case and can only be triggered by the very few cases ++ * we have where we need to touch the chunk btree outside chunk allocation ++ * and chunk removal. These cases are basically adding a device, removing ++ * a device or resizing a device. ++ */ ++ if (flags & BTRFS_BLOCK_GROUP_SYSTEM) ++ return 0; ++ ++ ret = btrfs_chunk_alloc_add_chunk_item(trans, bg); ++ /* ++ * Normally we are not expected to fail with -ENOSPC here, since we have ++ * previously reserved space in the system space_info and allocated one ++ * new system chunk if necessary. However there are two exceptions: ++ * ++ * 1) We may have enough free space in the system space_info but all the ++ * existing system block groups have a profile which can not be used ++ * for extent allocation. ++ * ++ * This happens when mounting in degraded mode. For example we have a ++ * RAID1 filesystem with 2 devices, lose one device and mount the fs ++ * using the other device in degraded mode. If we then allocate a chunk, ++ * we may have enough free space in the existing system space_info, but ++ * none of the block groups can be used for extent allocation since they ++ * have a RAID1 profile, and because we are in degraded mode with a ++ * single device, we are forced to allocate a new system chunk with a ++ * SINGLE profile. Making check_system_chunk() iterate over all system ++ * block groups and check if they have a usable profile and enough space ++ * can be slow on very large filesystems, so we tolerate the -ENOSPC and ++ * try again after forcing allocation of a new system chunk. Like this ++ * we avoid paying the cost of that search in normal circumstances, when ++ * we were not mounted in degraded mode; ++ * ++ * 2) We had enough free space info the system space_info, and one suitable ++ * block group to allocate from when we called check_system_chunk() ++ * above. However right after we called it, the only system block group ++ * with enough free space got turned into RO mode by a running scrub, ++ * and in this case we have to allocate a new one and retry. We only ++ * need do this allocate and retry once, since we have a transaction ++ * handle and scrub uses the commit root to search for block groups. ++ */ ++ if (ret == -ENOSPC) { ++ const u64 sys_flags = btrfs_system_alloc_profile(trans->fs_info); ++ struct btrfs_block_group *sys_bg; ++ ++ sys_bg = btrfs_alloc_chunk(trans, sys_flags); ++ if (IS_ERR(sys_bg)) { ++ ret = PTR_ERR(sys_bg); ++ btrfs_abort_transaction(trans, ret); ++ goto out; ++ } ++ ++ ret = btrfs_chunk_alloc_add_chunk_item(trans, sys_bg); ++ if (ret) { ++ btrfs_abort_transaction(trans, ret); ++ goto out; ++ } ++ ++ ret = btrfs_chunk_alloc_add_chunk_item(trans, bg); ++ if (ret) { ++ btrfs_abort_transaction(trans, ret); ++ goto out; ++ } ++ } else if (ret) { ++ btrfs_abort_transaction(trans, ret); ++ goto out; ++ } ++out: ++ btrfs_trans_release_chunk_metadata(trans); ++ ++ return ret; ++} ++ + /* +- * If force is CHUNK_ALLOC_FORCE: ++ * Chunk allocation is done in 2 phases: ++ * ++ * 1) Phase 1 - through btrfs_chunk_alloc() we allocate device extents for ++ * the chunk, the chunk mapping, create its block group and add the items ++ * that belong in the chunk btree to it - more specifically, we need to ++ * update device items in the chunk btree and add a new chunk item to it. ++ * ++ * 2) Phase 2 - through btrfs_create_pending_block_groups(), we add the block ++ * group item to the extent btree and the device extent items to the devices ++ * btree. ++ * ++ * This is done to prevent deadlocks. For example when COWing a node from the ++ * extent btree we are holding a write lock on the node's parent and if we ++ * trigger chunk allocation and attempted to insert the new block group item ++ * in the extent btree right way, we could deadlock because the path for the ++ * insertion can include that parent node. At first glance it seems impossible ++ * to trigger chunk allocation after starting a transaction since tasks should ++ * reserve enough transaction units (metadata space), however while that is true ++ * most of the time, chunk allocation may still be triggered for several reasons: ++ * ++ * 1) When reserving metadata, we check if there is enough free space in the ++ * metadata space_info and therefore don't trigger allocation of a new chunk. ++ * However later when the task actually tries to COW an extent buffer from ++ * the extent btree or from the device btree for example, it is forced to ++ * allocate a new block group (chunk) because the only one that had enough ++ * free space was just turned to RO mode by a running scrub for example (or ++ * device replace, block group reclaim thread, etc), so we can not use it ++ * for allocating an extent and end up being forced to allocate a new one; ++ * ++ * 2) Because we only check that the metadata space_info has enough free bytes, ++ * we end up not allocating a new metadata chunk in that case. However if ++ * the filesystem was mounted in degraded mode, none of the existing block ++ * groups might be suitable for extent allocation due to their incompatible ++ * profile (for e.g. mounting a 2 devices filesystem, where all block groups ++ * use a RAID1 profile, in degraded mode using a single device). In this case ++ * when the task attempts to COW some extent buffer of the extent btree for ++ * example, it will trigger allocation of a new metadata block group with a ++ * suitable profile (SINGLE profile in the example of the degraded mount of ++ * the RAID1 filesystem); ++ * ++ * 3) The task has reserved enough transaction units / metadata space, but when ++ * it attempts to COW an extent buffer from the extent or device btree for ++ * example, it does not find any free extent in any metadata block group, ++ * therefore forced to try to allocate a new metadata block group. ++ * This is because some other task allocated all available extents in the ++ * meanwhile - this typically happens with tasks that don't reserve space ++ * properly, either intentionally or as a bug. One example where this is ++ * done intentionally is fsync, as it does not reserve any transaction units ++ * and ends up allocating a variable number of metadata extents for log ++ * tree extent buffers. ++ * ++ * We also need this 2 phases setup when adding a device to a filesystem with ++ * a seed device - we must create new metadata and system chunks without adding ++ * any of the block group items to the chunk, extent and device btrees. If we ++ * did not do it this way, we would get ENOSPC when attempting to update those ++ * btrees, since all the chunks from the seed device are read-only. ++ * ++ * Phase 1 does the updates and insertions to the chunk btree because if we had ++ * it done in phase 2 and have a thundering herd of tasks allocating chunks in ++ * parallel, we risk having too many system chunks allocated by many tasks if ++ * many tasks reach phase 1 without the previous ones completing phase 2. In the ++ * extreme case this leads to exhaustion of the system chunk array in the ++ * superblock. This is easier to trigger if using a btree node/leaf size of 64K ++ * and with RAID filesystems (so we have more device items in the chunk btree). ++ * This has happened before and commit eafa4fd0ad0607 ("btrfs: fix exhaustion of ++ * the system chunk array due to concurrent allocations") provides more details. ++ * ++ * For allocation of system chunks, we defer the updates and insertions into the ++ * chunk btree to phase 2. This is to prevent deadlocks on extent buffers because ++ * if the chunk allocation is triggered while COWing an extent buffer of the ++ * chunk btree, we are holding a lock on the parent of that extent buffer and ++ * doing the chunk btree updates and insertions can require locking that parent. ++ * This is for the very few and rare cases where we update the chunk btree that ++ * are not chunk allocation or chunk removal: adding a device, removing a device ++ * or resizing a device. ++ * ++ * The reservation of system space, done through check_system_chunk(), as well ++ * as all the updates and insertions into the chunk btree must be done while ++ * holding fs_info->chunk_mutex. This is important to guarantee that while COWing ++ * an extent buffer from the chunks btree we never trigger allocation of a new ++ * system chunk, which would result in a deadlock (trying to lock twice an ++ * extent buffer of the chunk btree, first time before triggering the chunk ++ * allocation and the second time during chunk allocation while attempting to ++ * update the chunks btree). The system chunk array is also updated while holding ++ * that mutex. The same logic applies to removing chunks - we must reserve system ++ * space, update the chunk btree and the system chunk array in the superblock ++ * while holding fs_info->chunk_mutex. ++ * ++ * This function, btrfs_chunk_alloc(), belongs to phase 1. ++ * ++ * If @force is CHUNK_ALLOC_FORCE: + * - return 1 if it successfully allocates a chunk, + * - return errors including -ENOSPC otherwise. +- * If force is NOT CHUNK_ALLOC_FORCE: ++ * If @force is NOT CHUNK_ALLOC_FORCE: + * - return 0 if it doesn't need to allocate a new chunk, + * - return 1 if it successfully allocates a chunk, + * - return errors including -ENOSPC otherwise. +@@ -3145,6 +3356,13 @@ int btrfs_chunk_alloc(struct btrfs_trans_handle *trans, u64 flags, + /* Don't re-enter if we're already allocating a chunk */ + if (trans->allocating_chunk) + return -ENOSPC; ++ /* ++ * If we are removing a chunk, don't re-enter or we would deadlock. ++ * System space reservation and system chunk allocation is done by the ++ * chunk remove operation (btrfs_remove_chunk()). ++ */ ++ if (trans->removing_chunk) ++ return -ENOSPC; + + space_info = btrfs_find_space_info(fs_info, flags); + ASSERT(space_info); +@@ -3208,13 +3426,7 @@ int btrfs_chunk_alloc(struct btrfs_trans_handle *trans, u64 flags, + force_metadata_allocation(fs_info); + } + +- /* +- * Check if we have enough space in SYSTEM chunk because we may need +- * to update devices. +- */ +- check_system_chunk(trans, flags); +- +- ret = btrfs_alloc_chunk(trans, flags); ++ ret = do_chunk_alloc(trans, flags); + trans->allocating_chunk = false; + + spin_lock(&space_info->lock); +@@ -3233,22 +3445,6 @@ out: + space_info->chunk_alloc = 0; + spin_unlock(&space_info->lock); + mutex_unlock(&fs_info->chunk_mutex); +- /* +- * When we allocate a new chunk we reserve space in the chunk block +- * reserve to make sure we can COW nodes/leafs in the chunk tree or +- * add new nodes/leafs to it if we end up needing to do it when +- * inserting the chunk item and updating device items as part of the +- * second phase of chunk allocation, performed by +- * btrfs_finish_chunk_alloc(). So make sure we don't accumulate a +- * large number of new block groups to create in our transaction +- * handle's new_bgs list to avoid exhausting the chunk block reserve +- * in extreme cases - like having a single transaction create many new +- * block groups when starting to write out the free space caches of all +- * the block groups that were made dirty during the lifetime of the +- * transaction. +- */ +- if (trans->chunk_bytes_reserved >= (u64)SZ_2M) +- btrfs_create_pending_block_groups(trans); + + return ret; + } +@@ -3269,7 +3465,6 @@ static u64 get_profile_num_devs(struct btrfs_fs_info *fs_info, u64 type) + */ + void check_system_chunk(struct btrfs_trans_handle *trans, u64 type) + { +- struct btrfs_transaction *cur_trans = trans->transaction; + struct btrfs_fs_info *fs_info = trans->fs_info; + struct btrfs_space_info *info; + u64 left; +@@ -3284,7 +3479,6 @@ void check_system_chunk(struct btrfs_trans_handle *trans, u64 type) + lockdep_assert_held(&fs_info->chunk_mutex); + + info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM); +-again: + spin_lock(&info->lock); + left = info->total_bytes - btrfs_space_info_used(info, true); + spin_unlock(&info->lock); +@@ -3303,76 +3497,39 @@ again: + + if (left < thresh) { + u64 flags = btrfs_system_alloc_profile(fs_info); +- u64 reserved = atomic64_read(&cur_trans->chunk_bytes_reserved); +- +- /* +- * If there's not available space for the chunk tree (system +- * space) and there are other tasks that reserved space for +- * creating a new system block group, wait for them to complete +- * the creation of their system block group and release excess +- * reserved space. We do this because: +- * +- * *) We can end up allocating more system chunks than necessary +- * when there are multiple tasks that are concurrently +- * allocating block groups, which can lead to exhaustion of +- * the system array in the superblock; +- * +- * *) If we allocate extra and unnecessary system block groups, +- * despite being empty for a long time, and possibly forever, +- * they end not being added to the list of unused block groups +- * because that typically happens only when deallocating the +- * last extent from a block group - which never happens since +- * we never allocate from them in the first place. The few +- * exceptions are when mounting a filesystem or running scrub, +- * which add unused block groups to the list of unused block +- * groups, to be deleted by the cleaner kthread. +- * And even when they are added to the list of unused block +- * groups, it can take a long time until they get deleted, +- * since the cleaner kthread might be sleeping or busy with +- * other work (deleting subvolumes, running delayed iputs, +- * defrag scheduling, etc); +- * +- * This is rare in practice, but can happen when too many tasks +- * are allocating blocks groups in parallel (via fallocate()) +- * and before the one that reserved space for a new system block +- * group finishes the block group creation and releases the space +- * reserved in excess (at btrfs_create_pending_block_groups()), +- * other tasks end up here and see free system space temporarily +- * not enough for updating the chunk tree. +- * +- * We unlock the chunk mutex before waiting for such tasks and +- * lock it again after the wait, otherwise we would deadlock. +- * It is safe to do so because allocating a system chunk is the +- * first thing done while allocating a new block group. +- */ +- if (reserved > trans->chunk_bytes_reserved) { +- const u64 min_needed = reserved - thresh; +- +- mutex_unlock(&fs_info->chunk_mutex); +- wait_event(cur_trans->chunk_reserve_wait, +- atomic64_read(&cur_trans->chunk_bytes_reserved) <= +- min_needed); +- mutex_lock(&fs_info->chunk_mutex); +- goto again; +- } ++ struct btrfs_block_group *bg; + + /* + * Ignore failure to create system chunk. We might end up not + * needing it, as we might not need to COW all nodes/leafs from + * the paths we visit in the chunk tree (they were already COWed + * or created in the current transaction for example). ++ * ++ * Also, if our caller is allocating a system chunk, do not ++ * attempt to insert the chunk item in the chunk btree, as we ++ * could deadlock on an extent buffer since our caller may be ++ * COWing an extent buffer from the chunk btree. + */ +- ret = btrfs_alloc_chunk(trans, flags); ++ bg = btrfs_alloc_chunk(trans, flags); ++ if (IS_ERR(bg)) { ++ ret = PTR_ERR(bg); ++ } else if (!(type & BTRFS_BLOCK_GROUP_SYSTEM)) { ++ /* ++ * If we fail to add the chunk item here, we end up ++ * trying again at phase 2 of chunk allocation, at ++ * btrfs_create_pending_block_groups(). So ignore ++ * any error here. ++ */ ++ btrfs_chunk_alloc_add_chunk_item(trans, bg); ++ } + } + + if (!ret) { + ret = btrfs_block_rsv_add(fs_info->chunk_root, + &fs_info->chunk_block_rsv, + thresh, BTRFS_RESERVE_NO_FLUSH); +- if (!ret) { +- atomic64_add(thresh, &cur_trans->chunk_bytes_reserved); ++ if (!ret) + trans->chunk_bytes_reserved += thresh; +- } + } + } + +diff --git a/fs/btrfs/block-group.h b/fs/btrfs/block-group.h +index 3ecc3372a5cea..3359c2ad18320 100644 +--- a/fs/btrfs/block-group.h ++++ b/fs/btrfs/block-group.h +@@ -97,6 +97,7 @@ struct btrfs_block_group { + unsigned int removed:1; + unsigned int to_copy:1; + unsigned int relocating_repair:1; ++ unsigned int chunk_item_inserted:1; + + int disk_cache_state; + +@@ -265,8 +266,9 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, + void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info); + void btrfs_mark_bg_unused(struct btrfs_block_group *bg); + int btrfs_read_block_groups(struct btrfs_fs_info *info); +-int btrfs_make_block_group(struct btrfs_trans_handle *trans, u64 bytes_used, +- u64 type, u64 chunk_offset, u64 size); ++struct btrfs_block_group *btrfs_make_block_group(struct btrfs_trans_handle *trans, ++ u64 bytes_used, u64 type, ++ u64 chunk_offset, u64 size); + void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans); + int btrfs_inc_block_group_ro(struct btrfs_block_group *cache, + bool do_chunk_alloc); +diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c +index 8f48553d861ec..4e3c71253a5eb 100644 +--- a/fs/btrfs/ctree.c ++++ b/fs/btrfs/ctree.c +@@ -954,49 +954,6 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, + return 0; + } + +-static struct extent_buffer *alloc_tree_block_no_bg_flush( +- struct btrfs_trans_handle *trans, +- struct btrfs_root *root, +- u64 parent_start, +- const struct btrfs_disk_key *disk_key, +- int level, +- u64 hint, +- u64 empty_size, +- enum btrfs_lock_nesting nest) +-{ +- struct btrfs_fs_info *fs_info = root->fs_info; +- struct extent_buffer *ret; +- +- /* +- * If we are COWing a node/leaf from the extent, chunk, device or free +- * space trees, make sure that we do not finish block group creation of +- * pending block groups. We do this to avoid a deadlock. +- * COWing can result in allocation of a new chunk, and flushing pending +- * block groups (btrfs_create_pending_block_groups()) can be triggered +- * when finishing allocation of a new chunk. Creation of a pending block +- * group modifies the extent, chunk, device and free space trees, +- * therefore we could deadlock with ourselves since we are holding a +- * lock on an extent buffer that btrfs_create_pending_block_groups() may +- * try to COW later. +- * For similar reasons, we also need to delay flushing pending block +- * groups when splitting a leaf or node, from one of those trees, since +- * we are holding a write lock on it and its parent or when inserting a +- * new root node for one of those trees. +- */ +- if (root == fs_info->extent_root || +- root == fs_info->chunk_root || +- root == fs_info->dev_root || +- root == fs_info->free_space_root) +- trans->can_flush_pending_bgs = false; +- +- ret = btrfs_alloc_tree_block(trans, root, parent_start, +- root->root_key.objectid, disk_key, level, +- hint, empty_size, nest); +- trans->can_flush_pending_bgs = true; +- +- return ret; +-} +- + /* + * does the dirty work in cow of a single block. The parent block (if + * supplied) is updated to point to the new cow copy. The new buffer is marked +@@ -1045,8 +1002,9 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans, + if ((root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) && parent) + parent_start = parent->start; + +- cow = alloc_tree_block_no_bg_flush(trans, root, parent_start, &disk_key, +- level, search_start, empty_size, nest); ++ cow = btrfs_alloc_tree_block(trans, root, parent_start, ++ root->root_key.objectid, &disk_key, level, ++ search_start, empty_size, nest); + if (IS_ERR(cow)) + return PTR_ERR(cow); + +@@ -3340,9 +3298,9 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans, + else + btrfs_node_key(lower, &lower_key, 0); + +- c = alloc_tree_block_no_bg_flush(trans, root, 0, &lower_key, level, +- root->node->start, 0, +- BTRFS_NESTING_NEW_ROOT); ++ c = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid, ++ &lower_key, level, root->node->start, 0, ++ BTRFS_NESTING_NEW_ROOT); + if (IS_ERR(c)) + return PTR_ERR(c); + +@@ -3471,8 +3429,9 @@ static noinline int split_node(struct btrfs_trans_handle *trans, + mid = (c_nritems + 1) / 2; + btrfs_node_key(c, &disk_key, mid); + +- split = alloc_tree_block_no_bg_flush(trans, root, 0, &disk_key, level, +- c->start, 0, BTRFS_NESTING_SPLIT); ++ split = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid, ++ &disk_key, level, c->start, 0, ++ BTRFS_NESTING_SPLIT); + if (IS_ERR(split)) + return PTR_ERR(split); + +@@ -4263,10 +4222,10 @@ again: + * BTRFS_NESTING_SPLIT_THE_SPLITTENING if we need to, but for now just + * use BTRFS_NESTING_NEW_ROOT. + */ +- right = alloc_tree_block_no_bg_flush(trans, root, 0, &disk_key, 0, +- l->start, 0, num_doubles ? +- BTRFS_NESTING_NEW_ROOT : +- BTRFS_NESTING_SPLIT); ++ right = btrfs_alloc_tree_block(trans, root, 0, root->root_key.objectid, ++ &disk_key, 0, l->start, 0, ++ num_doubles ? BTRFS_NESTING_NEW_ROOT : ++ BTRFS_NESTING_SPLIT); + if (IS_ERR(right)) + return PTR_ERR(right); + +diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c +index 1b22ded1a7994..b30a776a0b25c 100644 +--- a/fs/btrfs/inode.c ++++ b/fs/btrfs/inode.c +@@ -2271,13 +2271,127 @@ bool btrfs_bio_fits_in_ordered_extent(struct page *page, struct bio *bio, + return ret; + } + ++/* ++ * Split an extent_map at [start, start + len] ++ * ++ * This function is intended to be used only for extract_ordered_extent(). ++ */ ++static int split_zoned_em(struct btrfs_inode *inode, u64 start, u64 len, ++ u64 pre, u64 post) ++{ ++ struct extent_map_tree *em_tree = &inode->extent_tree; ++ struct extent_map *em; ++ struct extent_map *split_pre = NULL; ++ struct extent_map *split_mid = NULL; ++ struct extent_map *split_post = NULL; ++ int ret = 0; ++ int modified; ++ unsigned long flags; ++ ++ /* Sanity check */ ++ if (pre == 0 && post == 0) ++ return 0; ++ ++ split_pre = alloc_extent_map(); ++ if (pre) ++ split_mid = alloc_extent_map(); ++ if (post) ++ split_post = alloc_extent_map(); ++ if (!split_pre || (pre && !split_mid) || (post && !split_post)) { ++ ret = -ENOMEM; ++ goto out; ++ } ++ ++ ASSERT(pre + post < len); ++ ++ lock_extent(&inode->io_tree, start, start + len - 1); ++ write_lock(&em_tree->lock); ++ em = lookup_extent_mapping(em_tree, start, len); ++ if (!em) { ++ ret = -EIO; ++ goto out_unlock; ++ } ++ ++ ASSERT(em->len == len); ++ ASSERT(!test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)); ++ ASSERT(em->block_start < EXTENT_MAP_LAST_BYTE); ++ ++ flags = em->flags; ++ clear_bit(EXTENT_FLAG_PINNED, &em->flags); ++ clear_bit(EXTENT_FLAG_LOGGING, &flags); ++ modified = !list_empty(&em->list); ++ ++ /* First, replace the em with a new extent_map starting from * em->start */ ++ split_pre->start = em->start; ++ split_pre->len = (pre ? pre : em->len - post); ++ split_pre->orig_start = split_pre->start; ++ split_pre->block_start = em->block_start; ++ split_pre->block_len = split_pre->len; ++ split_pre->orig_block_len = split_pre->block_len; ++ split_pre->ram_bytes = split_pre->len; ++ split_pre->flags = flags; ++ split_pre->compress_type = em->compress_type; ++ split_pre->generation = em->generation; ++ ++ replace_extent_mapping(em_tree, em, split_pre, modified); ++ ++ /* ++ * Now we only have an extent_map at: ++ * [em->start, em->start + pre] if pre != 0 ++ * [em->start, em->start + em->len - post] if pre == 0 ++ */ ++ ++ if (pre) { ++ /* Insert the middle extent_map */ ++ split_mid->start = em->start + pre; ++ split_mid->len = em->len - pre - post; ++ split_mid->orig_start = split_mid->start; ++ split_mid->block_start = em->block_start + pre; ++ split_mid->block_len = split_mid->len; ++ split_mid->orig_block_len = split_mid->block_len; ++ split_mid->ram_bytes = split_mid->len; ++ split_mid->flags = flags; ++ split_mid->compress_type = em->compress_type; ++ split_mid->generation = em->generation; ++ add_extent_mapping(em_tree, split_mid, modified); ++ } ++ ++ if (post) { ++ split_post->start = em->start + em->len - post; ++ split_post->len = post; ++ split_post->orig_start = split_post->start; ++ split_post->block_start = em->block_start + em->len - post; ++ split_post->block_len = split_post->len; ++ split_post->orig_block_len = split_post->block_len; ++ split_post->ram_bytes = split_post->len; ++ split_post->flags = flags; ++ split_post->compress_type = em->compress_type; ++ split_post->generation = em->generation; ++ add_extent_mapping(em_tree, split_post, modified); ++ } ++ ++ /* Once for us */ ++ free_extent_map(em); ++ /* Once for the tree */ ++ free_extent_map(em); ++ ++out_unlock: ++ write_unlock(&em_tree->lock); ++ unlock_extent(&inode->io_tree, start, start + len - 1); ++out: ++ free_extent_map(split_pre); ++ free_extent_map(split_mid); ++ free_extent_map(split_post); ++ ++ return ret; ++} ++ + static blk_status_t extract_ordered_extent(struct btrfs_inode *inode, + struct bio *bio, loff_t file_offset) + { + struct btrfs_ordered_extent *ordered; +- struct extent_map *em = NULL, *em_new = NULL; +- struct extent_map_tree *em_tree = &inode->extent_tree; + u64 start = (u64)bio->bi_iter.bi_sector << SECTOR_SHIFT; ++ u64 file_len; + u64 len = bio->bi_iter.bi_size; + u64 end = start + len; + u64 ordered_end; +@@ -2317,41 +2431,16 @@ static blk_status_t extract_ordered_extent(struct btrfs_inode *inode, + goto out; + } + ++ file_len = ordered->num_bytes; + pre = start - ordered->disk_bytenr; + post = ordered_end - end; + + ret = btrfs_split_ordered_extent(ordered, pre, post); + if (ret) + goto out; +- +- read_lock(&em_tree->lock); +- em = lookup_extent_mapping(em_tree, ordered->file_offset, len); +- if (!em) { +- read_unlock(&em_tree->lock); +- ret = -EIO; +- goto out; +- } +- read_unlock(&em_tree->lock); +- +- ASSERT(!test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)); +- /* +- * We cannot reuse em_new here but have to create a new one, as +- * unpin_extent_cache() expects the start of the extent map to be the +- * logical offset of the file, which does not hold true anymore after +- * splitting. +- */ +- em_new = create_io_em(inode, em->start + pre, len, +- em->start + pre, em->block_start + pre, len, +- len, len, BTRFS_COMPRESS_NONE, +- BTRFS_ORDERED_REGULAR); +- if (IS_ERR(em_new)) { +- ret = PTR_ERR(em_new); +- goto out; +- } +- free_extent_map(em_new); ++ ret = split_zoned_em(inode, file_offset, file_len, pre, post); + + out: +- free_extent_map(em); + btrfs_put_ordered_extent(ordered); + + return errno_to_blk_status(ret); +diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c +index 81c8567dffee9..f16a482092e77 100644 +--- a/fs/btrfs/transaction.c ++++ b/fs/btrfs/transaction.c +@@ -254,23 +254,21 @@ static inline int extwriter_counter_read(struct btrfs_transaction *trans) + } + + /* +- * To be called after all the new block groups attached to the transaction +- * handle have been created (btrfs_create_pending_block_groups()). ++ * To be called after doing the chunk btree updates right after allocating a new ++ * chunk (after btrfs_chunk_alloc_add_chunk_item() is called), when removing a ++ * chunk after all chunk btree updates and after finishing the second phase of ++ * chunk allocation (btrfs_create_pending_block_groups()) in case some block ++ * group had its chunk item insertion delayed to the second phase. + */ + void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans) + { + struct btrfs_fs_info *fs_info = trans->fs_info; +- struct btrfs_transaction *cur_trans = trans->transaction; + + if (!trans->chunk_bytes_reserved) + return; + +- WARN_ON_ONCE(!list_empty(&trans->new_bgs)); +- + btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv, + trans->chunk_bytes_reserved, NULL); +- atomic64_sub(trans->chunk_bytes_reserved, &cur_trans->chunk_bytes_reserved); +- cond_wake_up(&cur_trans->chunk_reserve_wait); + trans->chunk_bytes_reserved = 0; + } + +@@ -386,8 +384,6 @@ loop: + spin_lock_init(&cur_trans->dropped_roots_lock); + INIT_LIST_HEAD(&cur_trans->releasing_ebs); + spin_lock_init(&cur_trans->releasing_ebs_lock); +- atomic64_set(&cur_trans->chunk_bytes_reserved, 0); +- init_waitqueue_head(&cur_trans->chunk_reserve_wait); + list_add_tail(&cur_trans->list, &fs_info->trans_list); + extent_io_tree_init(fs_info, &cur_trans->dirty_pages, + IO_TREE_TRANS_DIRTY_PAGES, fs_info->btree_inode); +@@ -702,7 +698,6 @@ again: + h->fs_info = root->fs_info; + + h->type = type; +- h->can_flush_pending_bgs = true; + INIT_LIST_HEAD(&h->new_bgs); + + smp_mb(); +diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h +index c49e2266b28ba..21b36f6e9322b 100644 +--- a/fs/btrfs/transaction.h ++++ b/fs/btrfs/transaction.h +@@ -96,13 +96,6 @@ struct btrfs_transaction { + + spinlock_t releasing_ebs_lock; + struct list_head releasing_ebs; +- +- /* +- * The number of bytes currently reserved, by all transaction handles +- * attached to this transaction, for metadata extents of the chunk tree. +- */ +- atomic64_t chunk_bytes_reserved; +- wait_queue_head_t chunk_reserve_wait; + }; + + #define __TRANS_FREEZABLE (1U << 0) +@@ -141,7 +134,7 @@ struct btrfs_trans_handle { + short aborted; + bool adding_csums; + bool allocating_chunk; +- bool can_flush_pending_bgs; ++ bool removing_chunk; + bool reloc_reserved; + bool in_fsync; + struct btrfs_root *root; +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index f4b0aecdaac72..fae59c8f86405 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -3173,7 +3173,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans, + if (!log_root_tree->node) { + ret = btrfs_alloc_log_tree_node(trans, log_root_tree); + if (ret) { +- mutex_unlock(&fs_info->tree_log_mutex); ++ mutex_unlock(&fs_info->tree_root->log_mutex); + goto out; + } + } +diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c +index 3912eda7905f6..58152ac000290 100644 +--- a/fs/btrfs/volumes.c ++++ b/fs/btrfs/volumes.c +@@ -1744,19 +1744,14 @@ again: + extent = btrfs_item_ptr(leaf, path->slots[0], + struct btrfs_dev_extent); + } else { +- btrfs_handle_fs_error(fs_info, ret, "Slot search failed"); + goto out; + } + + *dev_extent_len = btrfs_dev_extent_length(leaf, extent); + + ret = btrfs_del_item(trans, root, path); +- if (ret) { +- btrfs_handle_fs_error(fs_info, ret, +- "Failed to remove dev extent item"); +- } else { ++ if (ret == 0) + set_bit(BTRFS_TRANS_HAVE_FREE_BGS, &trans->transaction->flags); +- } + out: + btrfs_free_path(path); + return ret; +@@ -2941,7 +2936,7 @@ static int btrfs_del_sys_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset) + u32 cur; + struct btrfs_key key; + +- mutex_lock(&fs_info->chunk_mutex); ++ lockdep_assert_held(&fs_info->chunk_mutex); + array_size = btrfs_super_sys_array_size(super_copy); + + ptr = super_copy->sys_chunk_array; +@@ -2971,7 +2966,6 @@ static int btrfs_del_sys_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset) + cur += len; + } + } +- mutex_unlock(&fs_info->chunk_mutex); + return ret; + } + +@@ -3011,6 +3005,29 @@ struct extent_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info, + return em; + } + ++static int remove_chunk_item(struct btrfs_trans_handle *trans, ++ struct map_lookup *map, u64 chunk_offset) ++{ ++ int i; ++ ++ /* ++ * Removing chunk items and updating the device items in the chunks btree ++ * requires holding the chunk_mutex. ++ * See the comment at btrfs_chunk_alloc() for the details. ++ */ ++ lockdep_assert_held(&trans->fs_info->chunk_mutex); ++ ++ for (i = 0; i < map->num_stripes; i++) { ++ int ret; ++ ++ ret = btrfs_update_device(trans, map->stripes[i].dev); ++ if (ret) ++ return ret; ++ } ++ ++ return btrfs_free_chunk(trans, chunk_offset); ++} ++ + int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset) + { + struct btrfs_fs_info *fs_info = trans->fs_info; +@@ -3031,14 +3048,16 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset) + return PTR_ERR(em); + } + map = em->map_lookup; +- mutex_lock(&fs_info->chunk_mutex); +- check_system_chunk(trans, map->type); +- mutex_unlock(&fs_info->chunk_mutex); + + /* +- * Take the device list mutex to prevent races with the final phase of +- * a device replace operation that replaces the device object associated +- * with map stripes (dev-replace.c:btrfs_dev_replace_finishing()). ++ * First delete the device extent items from the devices btree. ++ * We take the device_list_mutex to avoid racing with the finishing phase ++ * of a device replace operation. See the comment below before acquiring ++ * fs_info->chunk_mutex. Note that here we do not acquire the chunk_mutex ++ * because that can result in a deadlock when deleting the device extent ++ * items from the devices btree - COWing an extent buffer from the btree ++ * may result in allocating a new metadata chunk, which would attempt to ++ * lock again fs_info->chunk_mutex. + */ + mutex_lock(&fs_devices->device_list_mutex); + for (i = 0; i < map->num_stripes; i++) { +@@ -3060,18 +3079,73 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset) + btrfs_clear_space_info_full(fs_info); + mutex_unlock(&fs_info->chunk_mutex); + } ++ } ++ mutex_unlock(&fs_devices->device_list_mutex); + +- ret = btrfs_update_device(trans, device); ++ /* ++ * We acquire fs_info->chunk_mutex for 2 reasons: ++ * ++ * 1) Just like with the first phase of the chunk allocation, we must ++ * reserve system space, do all chunk btree updates and deletions, and ++ * update the system chunk array in the superblock while holding this ++ * mutex. This is for similar reasons as explained on the comment at ++ * the top of btrfs_chunk_alloc(); ++ * ++ * 2) Prevent races with the final phase of a device replace operation ++ * that replaces the device object associated with the map's stripes, ++ * because the device object's id can change at any time during that ++ * final phase of the device replace operation ++ * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the ++ * replaced device and then see it with an ID of ++ * BTRFS_DEV_REPLACE_DEVID, which would cause a failure when updating ++ * the device item, which does not exists on the chunk btree. ++ * The finishing phase of device replace acquires both the ++ * device_list_mutex and the chunk_mutex, in that order, so we are ++ * safe by just acquiring the chunk_mutex. ++ */ ++ trans->removing_chunk = true; ++ mutex_lock(&fs_info->chunk_mutex); ++ ++ check_system_chunk(trans, map->type); ++ ++ ret = remove_chunk_item(trans, map, chunk_offset); ++ /* ++ * Normally we should not get -ENOSPC since we reserved space before ++ * through the call to check_system_chunk(). ++ * ++ * Despite our system space_info having enough free space, we may not ++ * be able to allocate extents from its block groups, because all have ++ * an incompatible profile, which will force us to allocate a new system ++ * block group with the right profile, or right after we called ++ * check_system_space() above, a scrub turned the only system block group ++ * with enough free space into RO mode. ++ * This is explained with more detail at do_chunk_alloc(). ++ * ++ * So if we get -ENOSPC, allocate a new system chunk and retry once. ++ */ ++ if (ret == -ENOSPC) { ++ const u64 sys_flags = btrfs_system_alloc_profile(fs_info); ++ struct btrfs_block_group *sys_bg; ++ ++ sys_bg = btrfs_alloc_chunk(trans, sys_flags); ++ if (IS_ERR(sys_bg)) { ++ ret = PTR_ERR(sys_bg); ++ btrfs_abort_transaction(trans, ret); ++ goto out; ++ } ++ ++ ret = btrfs_chunk_alloc_add_chunk_item(trans, sys_bg); + if (ret) { +- mutex_unlock(&fs_devices->device_list_mutex); + btrfs_abort_transaction(trans, ret); + goto out; + } +- } +- mutex_unlock(&fs_devices->device_list_mutex); + +- ret = btrfs_free_chunk(trans, chunk_offset); +- if (ret) { ++ ret = remove_chunk_item(trans, map, chunk_offset); ++ if (ret) { ++ btrfs_abort_transaction(trans, ret); ++ goto out; ++ } ++ } else if (ret) { + btrfs_abort_transaction(trans, ret); + goto out; + } +@@ -3086,6 +3160,15 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset) + } + } + ++ mutex_unlock(&fs_info->chunk_mutex); ++ trans->removing_chunk = false; ++ ++ /* ++ * We are done with chunk btree updates and deletions, so release the ++ * system space we previously reserved (with check_system_chunk()). ++ */ ++ btrfs_trans_release_chunk_metadata(trans); ++ + ret = btrfs_remove_block_group(trans, chunk_offset, em); + if (ret) { + btrfs_abort_transaction(trans, ret); +@@ -3093,6 +3176,10 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset) + } + + out: ++ if (trans->removing_chunk) { ++ mutex_unlock(&fs_info->chunk_mutex); ++ trans->removing_chunk = false; ++ } + /* once for us */ + free_extent_map(em); + return ret; +@@ -4851,13 +4938,12 @@ static int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info, + u32 array_size; + u8 *ptr; + +- mutex_lock(&fs_info->chunk_mutex); ++ lockdep_assert_held(&fs_info->chunk_mutex); ++ + array_size = btrfs_super_sys_array_size(super_copy); + if (array_size + item_size + sizeof(disk_key) +- > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) { +- mutex_unlock(&fs_info->chunk_mutex); ++ > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) + return -EFBIG; +- } + + ptr = super_copy->sys_chunk_array + array_size; + btrfs_cpu_key_to_disk(&disk_key, key); +@@ -4866,7 +4952,6 @@ static int btrfs_add_system_chunk(struct btrfs_fs_info *fs_info, + memcpy(ptr, chunk, item_size); + item_size += sizeof(disk_key); + btrfs_set_super_sys_array_size(super_copy, array_size + item_size); +- mutex_unlock(&fs_info->chunk_mutex); + + return 0; + } +@@ -5216,13 +5301,14 @@ static int decide_stripe_size(struct btrfs_fs_devices *fs_devices, + } + } + +-static int create_chunk(struct btrfs_trans_handle *trans, ++static struct btrfs_block_group *create_chunk(struct btrfs_trans_handle *trans, + struct alloc_chunk_ctl *ctl, + struct btrfs_device_info *devices_info) + { + struct btrfs_fs_info *info = trans->fs_info; + struct map_lookup *map = NULL; + struct extent_map_tree *em_tree; ++ struct btrfs_block_group *block_group; + struct extent_map *em; + u64 start = ctl->start; + u64 type = ctl->type; +@@ -5232,7 +5318,7 @@ static int create_chunk(struct btrfs_trans_handle *trans, + + map = kmalloc(map_lookup_size(ctl->num_stripes), GFP_NOFS); + if (!map) +- return -ENOMEM; ++ return ERR_PTR(-ENOMEM); + map->num_stripes = ctl->num_stripes; + + for (i = 0; i < ctl->ndevs; ++i) { +@@ -5254,7 +5340,7 @@ static int create_chunk(struct btrfs_trans_handle *trans, + em = alloc_extent_map(); + if (!em) { + kfree(map); +- return -ENOMEM; ++ return ERR_PTR(-ENOMEM); + } + set_bit(EXTENT_FLAG_FS_MAPPING, &em->flags); + em->map_lookup = map; +@@ -5270,12 +5356,12 @@ static int create_chunk(struct btrfs_trans_handle *trans, + if (ret) { + write_unlock(&em_tree->lock); + free_extent_map(em); +- return ret; ++ return ERR_PTR(ret); + } + write_unlock(&em_tree->lock); + +- ret = btrfs_make_block_group(trans, 0, type, start, ctl->chunk_size); +- if (ret) ++ block_group = btrfs_make_block_group(trans, 0, type, start, ctl->chunk_size); ++ if (IS_ERR(block_group)) + goto error_del_extent; + + for (i = 0; i < map->num_stripes; i++) { +@@ -5295,7 +5381,7 @@ static int create_chunk(struct btrfs_trans_handle *trans, + check_raid56_incompat_flag(info, type); + check_raid1c34_incompat_flag(info, type); + +- return 0; ++ return block_group; + + error_del_extent: + write_lock(&em_tree->lock); +@@ -5307,34 +5393,36 @@ error_del_extent: + /* One for the tree reference */ + free_extent_map(em); + +- return ret; ++ return block_group; + } + +-int btrfs_alloc_chunk(struct btrfs_trans_handle *trans, u64 type) ++struct btrfs_block_group *btrfs_alloc_chunk(struct btrfs_trans_handle *trans, ++ u64 type) + { + struct btrfs_fs_info *info = trans->fs_info; + struct btrfs_fs_devices *fs_devices = info->fs_devices; + struct btrfs_device_info *devices_info = NULL; + struct alloc_chunk_ctl ctl; ++ struct btrfs_block_group *block_group; + int ret; + + lockdep_assert_held(&info->chunk_mutex); + + if (!alloc_profile_is_valid(type, 0)) { + ASSERT(0); +- return -EINVAL; ++ return ERR_PTR(-EINVAL); + } + + if (list_empty(&fs_devices->alloc_list)) { + if (btrfs_test_opt(info, ENOSPC_DEBUG)) + btrfs_debug(info, "%s: no writable device", __func__); +- return -ENOSPC; ++ return ERR_PTR(-ENOSPC); + } + + if (!(type & BTRFS_BLOCK_GROUP_TYPE_MASK)) { + btrfs_err(info, "invalid chunk type 0x%llx requested", type); + ASSERT(0); +- return -EINVAL; ++ return ERR_PTR(-EINVAL); + } + + ctl.start = find_next_chunk(info); +@@ -5344,46 +5432,43 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans, u64 type) + devices_info = kcalloc(fs_devices->rw_devices, sizeof(*devices_info), + GFP_NOFS); + if (!devices_info) +- return -ENOMEM; ++ return ERR_PTR(-ENOMEM); + + ret = gather_device_info(fs_devices, &ctl, devices_info); +- if (ret < 0) ++ if (ret < 0) { ++ block_group = ERR_PTR(ret); + goto out; ++ } + + ret = decide_stripe_size(fs_devices, &ctl, devices_info); +- if (ret < 0) ++ if (ret < 0) { ++ block_group = ERR_PTR(ret); + goto out; ++ } + +- ret = create_chunk(trans, &ctl, devices_info); ++ block_group = create_chunk(trans, &ctl, devices_info); + + out: + kfree(devices_info); +- return ret; ++ return block_group; + } + + /* +- * Chunk allocation falls into two parts. The first part does work +- * that makes the new allocated chunk usable, but does not do any operation +- * that modifies the chunk tree. The second part does the work that +- * requires modifying the chunk tree. This division is important for the +- * bootstrap process of adding storage to a seed btrfs. ++ * This function, btrfs_finish_chunk_alloc(), belongs to phase 2. ++ * ++ * See the comment at btrfs_chunk_alloc() for details about the chunk allocation ++ * phases. + */ + int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans, + u64 chunk_offset, u64 chunk_size) + { + struct btrfs_fs_info *fs_info = trans->fs_info; +- struct btrfs_root *extent_root = fs_info->extent_root; +- struct btrfs_root *chunk_root = fs_info->chunk_root; +- struct btrfs_key key; + struct btrfs_device *device; +- struct btrfs_chunk *chunk; +- struct btrfs_stripe *stripe; + struct extent_map *em; + struct map_lookup *map; +- size_t item_size; + u64 dev_offset; + u64 stripe_size; +- int i = 0; ++ int i; + int ret = 0; + + em = btrfs_get_chunk_map(fs_info, chunk_offset, chunk_size); +@@ -5391,53 +5476,117 @@ int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans, + return PTR_ERR(em); + + map = em->map_lookup; +- item_size = btrfs_chunk_item_size(map->num_stripes); + stripe_size = em->orig_block_len; + +- chunk = kzalloc(item_size, GFP_NOFS); +- if (!chunk) { +- ret = -ENOMEM; +- goto out; +- } +- + /* + * Take the device list mutex to prevent races with the final phase of + * a device replace operation that replaces the device object associated + * with the map's stripes, because the device object's id can change + * at any time during that final phase of the device replace operation +- * (dev-replace.c:btrfs_dev_replace_finishing()). ++ * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the ++ * replaced device and then see it with an ID of BTRFS_DEV_REPLACE_DEVID, ++ * resulting in persisting a device extent item with such ID. + */ + mutex_lock(&fs_info->fs_devices->device_list_mutex); + for (i = 0; i < map->num_stripes; i++) { + device = map->stripes[i].dev; + dev_offset = map->stripes[i].physical; + +- ret = btrfs_update_device(trans, device); +- if (ret) +- break; + ret = btrfs_alloc_dev_extent(trans, device, chunk_offset, + dev_offset, stripe_size); + if (ret) + break; + } +- if (ret) { +- mutex_unlock(&fs_info->fs_devices->device_list_mutex); ++ mutex_unlock(&fs_info->fs_devices->device_list_mutex); ++ ++ free_extent_map(em); ++ return ret; ++} ++ ++/* ++ * This function, btrfs_chunk_alloc_add_chunk_item(), typically belongs to the ++ * phase 1 of chunk allocation. It belongs to phase 2 only when allocating system ++ * chunks. ++ * ++ * See the comment at btrfs_chunk_alloc() for details about the chunk allocation ++ * phases. ++ */ ++int btrfs_chunk_alloc_add_chunk_item(struct btrfs_trans_handle *trans, ++ struct btrfs_block_group *bg) ++{ ++ struct btrfs_fs_info *fs_info = trans->fs_info; ++ struct btrfs_root *extent_root = fs_info->extent_root; ++ struct btrfs_root *chunk_root = fs_info->chunk_root; ++ struct btrfs_key key; ++ struct btrfs_chunk *chunk; ++ struct btrfs_stripe *stripe; ++ struct extent_map *em; ++ struct map_lookup *map; ++ size_t item_size; ++ int i; ++ int ret; ++ ++ /* ++ * We take the chunk_mutex for 2 reasons: ++ * ++ * 1) Updates and insertions in the chunk btree must be done while holding ++ * the chunk_mutex, as well as updating the system chunk array in the ++ * superblock. See the comment on top of btrfs_chunk_alloc() for the ++ * details; ++ * ++ * 2) To prevent races with the final phase of a device replace operation ++ * that replaces the device object associated with the map's stripes, ++ * because the device object's id can change at any time during that ++ * final phase of the device replace operation ++ * (dev-replace.c:btrfs_dev_replace_finishing()), so we could grab the ++ * replaced device and then see it with an ID of BTRFS_DEV_REPLACE_DEVID, ++ * which would cause a failure when updating the device item, which does ++ * not exists, or persisting a stripe of the chunk item with such ID. ++ * Here we can't use the device_list_mutex because our caller already ++ * has locked the chunk_mutex, and the final phase of device replace ++ * acquires both mutexes - first the device_list_mutex and then the ++ * chunk_mutex. Using any of those two mutexes protects us from a ++ * concurrent device replace. ++ */ ++ lockdep_assert_held(&fs_info->chunk_mutex); ++ ++ em = btrfs_get_chunk_map(fs_info, bg->start, bg->length); ++ if (IS_ERR(em)) { ++ ret = PTR_ERR(em); ++ btrfs_abort_transaction(trans, ret); ++ return ret; ++ } ++ ++ map = em->map_lookup; ++ item_size = btrfs_chunk_item_size(map->num_stripes); ++ ++ chunk = kzalloc(item_size, GFP_NOFS); ++ if (!chunk) { ++ ret = -ENOMEM; ++ btrfs_abort_transaction(trans, ret); + goto out; + } + ++ for (i = 0; i < map->num_stripes; i++) { ++ struct btrfs_device *device = map->stripes[i].dev; ++ ++ ret = btrfs_update_device(trans, device); ++ if (ret) ++ goto out; ++ } ++ + stripe = &chunk->stripe; + for (i = 0; i < map->num_stripes; i++) { +- device = map->stripes[i].dev; +- dev_offset = map->stripes[i].physical; ++ struct btrfs_device *device = map->stripes[i].dev; ++ const u64 dev_offset = map->stripes[i].physical; + + btrfs_set_stack_stripe_devid(stripe, device->devid); + btrfs_set_stack_stripe_offset(stripe, dev_offset); + memcpy(stripe->dev_uuid, device->uuid, BTRFS_UUID_SIZE); + stripe++; + } +- mutex_unlock(&fs_info->fs_devices->device_list_mutex); + +- btrfs_set_stack_chunk_length(chunk, chunk_size); ++ btrfs_set_stack_chunk_length(chunk, bg->length); + btrfs_set_stack_chunk_owner(chunk, extent_root->root_key.objectid); + btrfs_set_stack_chunk_stripe_len(chunk, map->stripe_len); + btrfs_set_stack_chunk_type(chunk, map->type); +@@ -5449,15 +5598,18 @@ int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans, + + key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID; + key.type = BTRFS_CHUNK_ITEM_KEY; +- key.offset = chunk_offset; ++ key.offset = bg->start; + + ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size); +- if (ret == 0 && map->type & BTRFS_BLOCK_GROUP_SYSTEM) { +- /* +- * TODO: Cleanup of inserted chunk root in case of +- * failure. +- */ ++ if (ret) ++ goto out; ++ ++ bg->chunk_item_inserted = 1; ++ ++ if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { + ret = btrfs_add_system_chunk(fs_info, &key, chunk, item_size); ++ if (ret) ++ goto out; + } + + out: +@@ -5470,16 +5622,41 @@ static noinline int init_first_rw_device(struct btrfs_trans_handle *trans) + { + struct btrfs_fs_info *fs_info = trans->fs_info; + u64 alloc_profile; +- int ret; ++ struct btrfs_block_group *meta_bg; ++ struct btrfs_block_group *sys_bg; ++ ++ /* ++ * When adding a new device for sprouting, the seed device is read-only ++ * so we must first allocate a metadata and a system chunk. But before ++ * adding the block group items to the extent, device and chunk btrees, ++ * we must first: ++ * ++ * 1) Create both chunks without doing any changes to the btrees, as ++ * otherwise we would get -ENOSPC since the block groups from the ++ * seed device are read-only; ++ * ++ * 2) Add the device item for the new sprout device - finishing the setup ++ * of a new block group requires updating the device item in the chunk ++ * btree, so it must exist when we attempt to do it. The previous step ++ * ensures this does not fail with -ENOSPC. ++ * ++ * After that we can add the block group items to their btrees: ++ * update existing device item in the chunk btree, add a new block group ++ * item to the extent btree, add a new chunk item to the chunk btree and ++ * finally add the new device extent items to the devices btree. ++ */ + + alloc_profile = btrfs_metadata_alloc_profile(fs_info); +- ret = btrfs_alloc_chunk(trans, alloc_profile); +- if (ret) +- return ret; ++ meta_bg = btrfs_alloc_chunk(trans, alloc_profile); ++ if (IS_ERR(meta_bg)) ++ return PTR_ERR(meta_bg); + + alloc_profile = btrfs_system_alloc_profile(fs_info); +- ret = btrfs_alloc_chunk(trans, alloc_profile); +- return ret; ++ sys_bg = btrfs_alloc_chunk(trans, alloc_profile); ++ if (IS_ERR(sys_bg)) ++ return PTR_ERR(sys_bg); ++ ++ return 0; + } + + static inline int btrfs_chunk_max_errors(struct map_lookup *map) +@@ -7359,10 +7536,18 @@ int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info) + total_dev++; + } else if (found_key.type == BTRFS_CHUNK_ITEM_KEY) { + struct btrfs_chunk *chunk; ++ ++ /* ++ * We are only called at mount time, so no need to take ++ * fs_info->chunk_mutex. Plus, to avoid lockdep warnings, ++ * we always lock first fs_info->chunk_mutex before ++ * acquiring any locks on the chunk tree. This is a ++ * requirement for chunk allocation, see the comment on ++ * top of btrfs_chunk_alloc() for details. ++ */ ++ ASSERT(!test_bit(BTRFS_FS_OPEN, &fs_info->flags)); + chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk); +- mutex_lock(&fs_info->chunk_mutex); + ret = read_one_chunk(&found_key, leaf, chunk); +- mutex_unlock(&fs_info->chunk_mutex); + if (ret) + goto error; + } +diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h +index d4c3e0dd32b87..b7c34019f827f 100644 +--- a/fs/btrfs/volumes.h ++++ b/fs/btrfs/volumes.h +@@ -447,7 +447,8 @@ int btrfs_get_io_geometry(struct btrfs_fs_info *fs_info, struct extent_map *map, + struct btrfs_io_geometry *io_geom); + int btrfs_read_sys_array(struct btrfs_fs_info *fs_info); + int btrfs_read_chunk_tree(struct btrfs_fs_info *fs_info); +-int btrfs_alloc_chunk(struct btrfs_trans_handle *trans, u64 type); ++struct btrfs_block_group *btrfs_alloc_chunk(struct btrfs_trans_handle *trans, ++ u64 type); + void btrfs_mapping_tree_free(struct extent_map_tree *tree); + blk_status_t btrfs_map_bio(struct btrfs_fs_info *fs_info, struct bio *bio, + int mirror_num); +@@ -505,6 +506,8 @@ unsigned long btrfs_full_stripe_len(struct btrfs_fs_info *fs_info, + u64 logical); + int btrfs_finish_chunk_alloc(struct btrfs_trans_handle *trans, + u64 chunk_offset, u64 chunk_size); ++int btrfs_chunk_alloc_add_chunk_item(struct btrfs_trans_handle *trans, ++ struct btrfs_block_group *bg); + int btrfs_remove_chunk(struct btrfs_trans_handle *trans, u64 chunk_offset); + struct extent_map *btrfs_get_chunk_map(struct btrfs_fs_info *fs_info, + u64 logical, u64 length); +diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c +index c000fe338f7e0..c54317c10f58d 100644 +--- a/fs/ceph/addr.c ++++ b/fs/ceph/addr.c +@@ -78,10 +78,6 @@ static int ceph_set_page_dirty(struct page *page) + struct inode *inode; + struct ceph_inode_info *ci; + struct ceph_snap_context *snapc; +- int ret; +- +- if (unlikely(!mapping)) +- return !TestSetPageDirty(page); + + if (PageDirty(page)) { + dout("%p set_page_dirty %p idx %lu -- already dirty\n", +@@ -127,11 +123,7 @@ static int ceph_set_page_dirty(struct page *page) + page->private = (unsigned long)snapc; + SetPagePrivate(page); + +- ret = __set_page_dirty_nobuffers(page); +- WARN_ON(!PageLocked(page)); +- WARN_ON(!page->mapping); +- +- return ret; ++ return __set_page_dirty_nobuffers(page); + } + + /* +diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c +index 6b1ce4efb591c..6988fe10b1a77 100644 +--- a/fs/cifs/cifs_dfs_ref.c ++++ b/fs/cifs/cifs_dfs_ref.c +@@ -173,7 +173,7 @@ char *cifs_compose_mount_options(const char *sb_mountdata, + } + } + +- rc = dns_resolve_server_name_to_ip(name, &srvIP); ++ rc = dns_resolve_server_name_to_ip(name, &srvIP, NULL); + if (rc < 0) { + cifs_dbg(FYI, "%s: Failed to resolve server part of %s to IP: %d\n", + __func__, name, rc); +@@ -208,6 +208,10 @@ char *cifs_compose_mount_options(const char *sb_mountdata, + else + noff = tkn_e - (sb_mountdata + off) + 1; + ++ if (strncasecmp(sb_mountdata + off, "cruid=", 6) == 0) { ++ off += noff; ++ continue; ++ } + if (strncasecmp(sb_mountdata + off, "unc=", 4) == 0) { + off += noff; + continue; +diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h +index 723b97002d8dd..1192aa80cb9a8 100644 +--- a/fs/cifs/cifsglob.h ++++ b/fs/cifs/cifsglob.h +@@ -84,6 +84,9 @@ + #define SMB_ECHO_INTERVAL_MAX 600 + #define SMB_ECHO_INTERVAL_DEFAULT 60 + ++/* dns resolution interval in seconds */ ++#define SMB_DNS_RESOLVE_INTERVAL_DEFAULT 600 ++ + /* maximum number of PDUs in one compound */ + #define MAX_COMPOUND 5 + +@@ -654,6 +657,7 @@ struct TCP_Server_Info { + /* point to the SMBD connection if RDMA is used instead of socket */ + struct smbd_connection *smbd_conn; + struct delayed_work echo; /* echo ping workqueue job */ ++ struct delayed_work resolve; /* dns resolution workqueue job */ + char *smallbuf; /* pointer to current "small" buffer */ + char *bigbuf; /* pointer to current "big" buffer */ + /* Total size of this PDU. Only valid from cifs_demultiplex_thread */ +diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c +index 09a3939f25bf6..4e42fc5e2ee94 100644 +--- a/fs/cifs/connect.c ++++ b/fs/cifs/connect.c +@@ -92,6 +92,8 @@ static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server) + int rc; + int len; + char *unc, *ipaddr = NULL; ++ time64_t expiry, now; ++ unsigned long ttl = SMB_DNS_RESOLVE_INTERVAL_DEFAULT; + + if (!server->hostname) + return -EINVAL; +@@ -105,13 +107,13 @@ static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server) + } + scnprintf(unc, len, "\\\\%s", server->hostname); + +- rc = dns_resolve_server_name_to_ip(unc, &ipaddr); ++ rc = dns_resolve_server_name_to_ip(unc, &ipaddr, &expiry); + kfree(unc); + + if (rc < 0) { + cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n", + __func__, server->hostname, rc); +- return rc; ++ goto requeue_resolve; + } + + spin_lock(&cifs_tcp_ses_lock); +@@ -120,7 +122,45 @@ static int reconn_set_ipaddr_from_hostname(struct TCP_Server_Info *server) + spin_unlock(&cifs_tcp_ses_lock); + kfree(ipaddr); + +- return !rc ? -1 : 0; ++ /* rc == 1 means success here */ ++ if (rc) { ++ now = ktime_get_real_seconds(); ++ if (expiry && expiry > now) ++ /* ++ * To make sure we don't use the cached entry, retry 1s ++ * after expiry. ++ */ ++ ttl = (expiry - now + 1); ++ } ++ rc = !rc ? -1 : 0; ++ ++requeue_resolve: ++ cifs_dbg(FYI, "%s: next dns resolution scheduled for %lu seconds in the future\n", ++ __func__, ttl); ++ mod_delayed_work(cifsiod_wq, &server->resolve, (ttl * HZ)); ++ ++ return rc; ++} ++ ++ ++static void cifs_resolve_server(struct work_struct *work) ++{ ++ int rc; ++ struct TCP_Server_Info *server = container_of(work, ++ struct TCP_Server_Info, resolve.work); ++ ++ mutex_lock(&server->srv_mutex); ++ ++ /* ++ * Resolve the hostname again to make sure that IP address is up-to-date. ++ */ ++ rc = reconn_set_ipaddr_from_hostname(server); ++ if (rc) { ++ cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n", ++ __func__, rc); ++ } ++ ++ mutex_unlock(&server->srv_mutex); + } + + #ifdef CONFIG_CIFS_DFS_UPCALL +@@ -720,6 +760,7 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server) + spin_unlock(&cifs_tcp_ses_lock); + + cancel_delayed_work_sync(&server->echo); ++ cancel_delayed_work_sync(&server->resolve); + + spin_lock(&GlobalMid_Lock); + server->tcpStatus = CifsExiting; +@@ -1300,6 +1341,7 @@ cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect) + spin_unlock(&cifs_tcp_ses_lock); + + cancel_delayed_work_sync(&server->echo); ++ cancel_delayed_work_sync(&server->resolve); + + if (from_reconnect) + /* +@@ -1382,6 +1424,7 @@ cifs_get_tcp_session(struct smb3_fs_context *ctx) + INIT_LIST_HEAD(&tcp_ses->tcp_ses_list); + INIT_LIST_HEAD(&tcp_ses->smb_ses_list); + INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request); ++ INIT_DELAYED_WORK(&tcp_ses->resolve, cifs_resolve_server); + INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server); + mutex_init(&tcp_ses->reconnect_mutex); + memcpy(&tcp_ses->srcaddr, &ctx->srcaddr, +@@ -1462,6 +1505,12 @@ smbd_connected: + /* queue echo request delayed work */ + queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval); + ++ /* queue dns resolution delayed work */ ++ cifs_dbg(FYI, "%s: next dns resolution scheduled for %d seconds in the future\n", ++ __func__, SMB_DNS_RESOLVE_INTERVAL_DEFAULT); ++ ++ queue_delayed_work(cifsiod_wq, &tcp_ses->resolve, (SMB_DNS_RESOLVE_INTERVAL_DEFAULT * HZ)); ++ + return tcp_ses; + + out_err_crypto_release: +@@ -4136,7 +4185,8 @@ int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const stru + if (!tree) + return -ENOMEM; + +- if (!tcon->dfs_path) { ++ /* If it is not dfs or there was no cached dfs referral, then reconnect to same share */ ++ if (!tcon->dfs_path || dfs_cache_noreq_find(tcon->dfs_path + 1, &ref, &tl)) { + if (tcon->ipc) { + scnprintf(tree, MAX_TREE_SIZE, "\\\\%s\\IPC$", server->hostname); + rc = ops->tree_connect(xid, tcon->ses, tree, tcon, nlsc); +@@ -4146,9 +4196,6 @@ int cifs_tree_connect(const unsigned int xid, struct cifs_tcon *tcon, const stru + goto out; + } + +- rc = dfs_cache_noreq_find(tcon->dfs_path + 1, &ref, &tl); +- if (rc) +- goto out; + isroot = ref.server_type == DFS_TYPE_ROOT; + free_dfs_info_param(&ref); + +diff --git a/fs/cifs/dns_resolve.c b/fs/cifs/dns_resolve.c +index 534cbba72789f..8c78b48faf015 100644 +--- a/fs/cifs/dns_resolve.c ++++ b/fs/cifs/dns_resolve.c +@@ -36,6 +36,7 @@ + * dns_resolve_server_name_to_ip - Resolve UNC server name to ip address. + * @unc: UNC path specifying the server (with '/' as delimiter) + * @ip_addr: Where to return the IP address. ++ * @expiry: Where to return the expiry time for the dns record. + * + * The IP address will be returned in string form, and the caller is + * responsible for freeing it. +@@ -43,7 +44,7 @@ + * Returns length of result on success, -ve on error. + */ + int +-dns_resolve_server_name_to_ip(const char *unc, char **ip_addr) ++dns_resolve_server_name_to_ip(const char *unc, char **ip_addr, time64_t *expiry) + { + struct sockaddr_storage ss; + const char *hostname, *sep; +@@ -78,13 +79,14 @@ dns_resolve_server_name_to_ip(const char *unc, char **ip_addr) + + /* Perform the upcall */ + rc = dns_query(current->nsproxy->net_ns, NULL, hostname, len, +- NULL, ip_addr, NULL, false); ++ NULL, ip_addr, expiry, false); + if (rc < 0) + cifs_dbg(FYI, "%s: unable to resolve: %*.*s\n", + __func__, len, len, hostname); + else +- cifs_dbg(FYI, "%s: resolved: %*.*s to %s\n", +- __func__, len, len, hostname, *ip_addr); ++ cifs_dbg(FYI, "%s: resolved: %*.*s to %s expiry %llu\n", ++ __func__, len, len, hostname, *ip_addr, ++ expiry ? (*expiry) : 0); + return rc; + + name_is_IP_address: +diff --git a/fs/cifs/dns_resolve.h b/fs/cifs/dns_resolve.h +index d3f5d27f4d06e..ff5483d5244d2 100644 +--- a/fs/cifs/dns_resolve.h ++++ b/fs/cifs/dns_resolve.h +@@ -24,7 +24,7 @@ + #define _DNS_RESOLVE_H + + #ifdef __KERNEL__ +-extern int dns_resolve_server_name_to_ip(const char *unc, char **ip_addr); ++extern int dns_resolve_server_name_to_ip(const char *unc, char **ip_addr, time64_t *expiry); + #endif /* KERNEL */ + + #endif /* _DNS_RESOLVE_H */ +diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c +index 82e176720ca6a..f736da72e5e0a 100644 +--- a/fs/cifs/misc.c ++++ b/fs/cifs/misc.c +@@ -1105,7 +1105,7 @@ int match_target_ip(struct TCP_Server_Info *server, + + cifs_dbg(FYI, "%s: target name: %s\n", __func__, target + 2); + +- rc = dns_resolve_server_name_to_ip(target, &tip); ++ rc = dns_resolve_server_name_to_ip(target, &tip, NULL); + if (rc < 0) + goto out; + +diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c +index be799040a4154..b96ecba918990 100644 +--- a/fs/ext4/ext4_jbd2.c ++++ b/fs/ext4/ext4_jbd2.c +@@ -327,6 +327,7 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line, + + set_buffer_meta(bh); + set_buffer_prio(bh); ++ set_buffer_uptodate(bh); + if (ext4_handle_valid(handle)) { + err = jbd2_journal_dirty_metadata(handle, bh); + /* Errors can only happen due to aborted journal or a nasty bug */ +@@ -355,7 +356,6 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line, + err); + } + } else { +- set_buffer_uptodate(bh); + if (inode) + mark_buffer_dirty_inode(bh, inode); + else +diff --git a/fs/ext4/super.c b/fs/ext4/super.c +index 62dd98189e326..265745154945e 100644 +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -705,15 +705,23 @@ static void flush_stashed_error_work(struct work_struct *work) + * ext4 error handling code during handling of previous errors. + */ + if (!sb_rdonly(sbi->s_sb) && journal) { ++ struct buffer_head *sbh = sbi->s_sbh; + handle = jbd2_journal_start(journal, 1); + if (IS_ERR(handle)) + goto write_directly; +- if (jbd2_journal_get_write_access(handle, sbi->s_sbh)) { ++ if (jbd2_journal_get_write_access(handle, sbh)) { + jbd2_journal_stop(handle); + goto write_directly; + } + ext4_update_super(sbi->s_sb); +- if (jbd2_journal_dirty_metadata(handle, sbi->s_sbh)) { ++ if (buffer_write_io_error(sbh) || !buffer_uptodate(sbh)) { ++ ext4_msg(sbi->s_sb, KERN_ERR, "previous I/O error to " ++ "superblock detected"); ++ clear_buffer_write_io_error(sbh); ++ set_buffer_uptodate(sbh); ++ } ++ ++ if (jbd2_journal_dirty_metadata(handle, sbh)) { + jbd2_journal_stop(handle); + goto write_directly; + } +diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c +index a8567cb476213..70d6047ffacfa 100644 +--- a/fs/f2fs/gc.c ++++ b/fs/f2fs/gc.c +@@ -1799,6 +1799,7 @@ static void init_atgc_management(struct f2fs_sb_info *sbi) + am->candidate_ratio = DEF_GC_THREAD_CANDIDATE_RATIO; + am->max_candidate_count = DEF_GC_THREAD_MAX_CANDIDATE_COUNT; + am->age_weight = DEF_GC_THREAD_AGE_WEIGHT; ++ am->age_threshold = DEF_GC_THREAD_AGE_THRESHOLD; + } + + void f2fs_build_gc_manager(struct f2fs_sb_info *sbi) +diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c +index 17bd072a5d393..11aafe93180c0 100644 +--- a/fs/f2fs/namei.c ++++ b/fs/f2fs/namei.c +@@ -153,7 +153,8 @@ fail_drop: + return ERR_PTR(err); + } + +-static inline int is_extension_exist(const unsigned char *s, const char *sub) ++static inline int is_extension_exist(const unsigned char *s, const char *sub, ++ bool tmp_ext) + { + size_t slen = strlen(s); + size_t sublen = strlen(sub); +@@ -169,6 +170,13 @@ static inline int is_extension_exist(const unsigned char *s, const char *sub) + if (slen < sublen + 2) + return 0; + ++ if (!tmp_ext) { ++ /* file has no temp extension */ ++ if (s[slen - sublen - 1] != '.') ++ return 0; ++ return !strncasecmp(s + slen - sublen, sub, sublen); ++ } ++ + for (i = 1; i < slen - sublen; i++) { + if (s[i] != '.') + continue; +@@ -194,7 +202,7 @@ static inline void set_file_temperature(struct f2fs_sb_info *sbi, struct inode * + hot_count = sbi->raw_super->hot_ext_count; + + for (i = 0; i < cold_count + hot_count; i++) { +- if (is_extension_exist(name, extlist[i])) ++ if (is_extension_exist(name, extlist[i], true)) + break; + } + +@@ -295,7 +303,7 @@ static void set_compress_inode(struct f2fs_sb_info *sbi, struct inode *inode, + hot_count = sbi->raw_super->hot_ext_count; + + for (i = cold_count; i < cold_count + hot_count; i++) { +- if (is_extension_exist(name, extlist[i])) { ++ if (is_extension_exist(name, extlist[i], false)) { + up_read(&sbi->sb_lock); + return; + } +@@ -306,7 +314,7 @@ static void set_compress_inode(struct f2fs_sb_info *sbi, struct inode *inode, + ext = F2FS_OPTION(sbi).extensions; + + for (i = 0; i < ext_cnt; i++) { +- if (!is_extension_exist(name, ext[i])) ++ if (!is_extension_exist(name, ext[i], false)) + continue; + + set_compress_context(inode); +diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c +index 1f7bc4b3f6aec..a4b4b8297ec39 100644 +--- a/fs/f2fs/super.c ++++ b/fs/f2fs/super.c +@@ -4281,4 +4281,5 @@ module_exit(exit_f2fs_fs) + MODULE_AUTHOR("Samsung Electronics's Praesto Team"); + MODULE_DESCRIPTION("Flash Friendly File System"); + MODULE_LICENSE("GPL"); ++MODULE_SOFTDEP("pre: crc32"); + +diff --git a/fs/io_uring.c b/fs/io_uring.c +index 58ac04cca587f..044d265f74ab1 100644 +--- a/fs/io_uring.c ++++ b/fs/io_uring.c +@@ -2023,7 +2023,7 @@ static void __io_req_task_submit(struct io_kiocb *req) + + /* ctx stays valid until unlock, even if we drop all ours ctx->refs */ + mutex_lock(&ctx->uring_lock); +- if (!(current->flags & PF_EXITING) && !current->in_execve) ++ if (!(req->task->flags & PF_EXITING) && !req->task->in_execve) + __io_queue_sqe(req); + else + __io_req_task_cancel(req, -EFAULT); +@@ -5727,12 +5727,9 @@ static void io_async_find_and_cancel(struct io_ring_ctx *ctx, + int ret; + + ret = io_async_cancel_one(req->task->io_uring, sqe_addr, ctx); +- if (ret != -ENOENT) { +- spin_lock_irqsave(&ctx->completion_lock, flags); +- goto done; +- } +- + spin_lock_irqsave(&ctx->completion_lock, flags); ++ if (ret != -ENOENT) ++ goto done; + ret = io_timeout_cancel(ctx, sqe_addr); + if (ret != -ENOENT) + goto done; +@@ -5747,7 +5744,6 @@ done: + + if (ret < 0) + req_set_fail_links(req); +- io_put_req(req); + } + + static int io_async_cancel_prep(struct io_kiocb *req, +@@ -6310,7 +6306,6 @@ static enum hrtimer_restart io_link_timeout_fn(struct hrtimer *timer) + io_put_req_deferred(req, 1); + } else { + io_req_complete_post(req, -ETIME, 0); +- io_put_req_deferred(req, 1); + } + return HRTIMER_NORESTART; + } +diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c +index 9330eff210e0c..78fd136ac13b9 100644 +--- a/fs/jfs/jfs_logmgr.c ++++ b/fs/jfs/jfs_logmgr.c +@@ -1324,6 +1324,7 @@ int lmLogInit(struct jfs_log * log) + } else { + if (!uuid_equal(&logsuper->uuid, &log->uuid)) { + jfs_warn("wrong uuid on JFS log device"); ++ rc = -EINVAL; + goto errout20; + } + log->size = le32_to_cpu(logsuper->size); +diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c +index 04bf8066980c1..d6ac2c4f88b6b 100644 +--- a/fs/nfs/delegation.c ++++ b/fs/nfs/delegation.c +@@ -75,6 +75,13 @@ void nfs_mark_delegation_referenced(struct nfs_delegation *delegation) + set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags); + } + ++static void nfs_mark_return_delegation(struct nfs_server *server, ++ struct nfs_delegation *delegation) ++{ ++ set_bit(NFS_DELEGATION_RETURN, &delegation->flags); ++ set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); ++} ++ + static bool + nfs4_is_valid_delegation(const struct nfs_delegation *delegation, + fmode_t flags) +@@ -293,6 +300,7 @@ nfs_start_delegation_return_locked(struct nfs_inode *nfsi) + goto out; + spin_lock(&delegation->lock); + if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) { ++ clear_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags); + /* Refcount matched in nfs_end_delegation_return() */ + ret = nfs_get_delegation(delegation); + } +@@ -314,16 +322,17 @@ nfs_start_delegation_return(struct nfs_inode *nfsi) + return delegation; + } + +-static void +-nfs_abort_delegation_return(struct nfs_delegation *delegation, +- struct nfs_client *clp) ++static void nfs_abort_delegation_return(struct nfs_delegation *delegation, ++ struct nfs_client *clp, int err) + { + + spin_lock(&delegation->lock); + clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags); +- set_bit(NFS_DELEGATION_RETURN, &delegation->flags); ++ if (err == -EAGAIN) { ++ set_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags); ++ set_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state); ++ } + spin_unlock(&delegation->lock); +- set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state); + } + + static struct nfs_delegation * +@@ -528,7 +537,7 @@ static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation + } while (err == 0); + + if (err) { +- nfs_abort_delegation_return(delegation, clp); ++ nfs_abort_delegation_return(delegation, clp, err); + goto out; + } + +@@ -557,6 +566,7 @@ static bool nfs_delegation_need_return(struct nfs_delegation *delegation) + if (ret) + clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags); + if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags) || ++ test_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags) || + test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) + ret = false; + +@@ -636,6 +646,38 @@ out: + return err; + } + ++static bool nfs_server_clear_delayed_delegations(struct nfs_server *server) ++{ ++ struct nfs_delegation *d; ++ bool ret = false; ++ ++ list_for_each_entry_rcu (d, &server->delegations, super_list) { ++ if (!test_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags)) ++ continue; ++ nfs_mark_return_delegation(server, d); ++ clear_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags); ++ ret = true; ++ } ++ return ret; ++} ++ ++static bool nfs_client_clear_delayed_delegations(struct nfs_client *clp) ++{ ++ struct nfs_server *server; ++ bool ret = false; ++ ++ if (!test_and_clear_bit(NFS4CLNT_DELEGRETURN_DELAYED, &clp->cl_state)) ++ goto out; ++ rcu_read_lock(); ++ list_for_each_entry_rcu (server, &clp->cl_superblocks, client_link) { ++ if (nfs_server_clear_delayed_delegations(server)) ++ ret = true; ++ } ++ rcu_read_unlock(); ++out: ++ return ret; ++} ++ + /** + * nfs_client_return_marked_delegations - return previously marked delegations + * @clp: nfs_client to process +@@ -648,8 +690,14 @@ out: + */ + int nfs_client_return_marked_delegations(struct nfs_client *clp) + { +- return nfs_client_for_each_server(clp, +- nfs_server_return_marked_delegations, NULL); ++ int err = nfs_client_for_each_server( ++ clp, nfs_server_return_marked_delegations, NULL); ++ if (err) ++ return err; ++ /* If a return was delayed, sleep to prevent hard looping */ ++ if (nfs_client_clear_delayed_delegations(clp)) ++ ssleep(1); ++ return 0; + } + + /** +@@ -764,13 +812,6 @@ static void nfs_mark_return_if_closed_delegation(struct nfs_server *server, + set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); + } + +-static void nfs_mark_return_delegation(struct nfs_server *server, +- struct nfs_delegation *delegation) +-{ +- set_bit(NFS_DELEGATION_RETURN, &delegation->flags); +- set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state); +-} +- + static bool nfs_server_mark_return_all_delegations(struct nfs_server *server) + { + struct nfs_delegation *delegation; +diff --git a/fs/nfs/delegation.h b/fs/nfs/delegation.h +index 9b00a0b7f8321..26f57a99da84e 100644 +--- a/fs/nfs/delegation.h ++++ b/fs/nfs/delegation.h +@@ -36,6 +36,7 @@ enum { + NFS_DELEGATION_REVOKED, + NFS_DELEGATION_TEST_EXPIRED, + NFS_DELEGATION_INODE_FREEING, ++ NFS_DELEGATION_RETURN_DELAYED, + }; + + int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred, +diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c +index 2d30a4da49fa0..2e894fec036b0 100644 +--- a/fs/nfs/direct.c ++++ b/fs/nfs/direct.c +@@ -700,8 +700,8 @@ static void nfs_direct_write_completion(struct nfs_pgio_header *hdr) + { + struct nfs_direct_req *dreq = hdr->dreq; + struct nfs_commit_info cinfo; +- bool request_commit = false; + struct nfs_page *req = nfs_list_entry(hdr->pages.next); ++ int flags = NFS_ODIRECT_DONE; + + nfs_init_cinfo_from_dreq(&cinfo, dreq); + +@@ -713,15 +713,9 @@ static void nfs_direct_write_completion(struct nfs_pgio_header *hdr) + + nfs_direct_count_bytes(dreq, hdr); + if (hdr->good_bytes != 0 && nfs_write_need_commit(hdr)) { +- switch (dreq->flags) { +- case 0: ++ if (!dreq->flags) + dreq->flags = NFS_ODIRECT_DO_COMMIT; +- request_commit = true; +- break; +- case NFS_ODIRECT_RESCHED_WRITES: +- case NFS_ODIRECT_DO_COMMIT: +- request_commit = true; +- } ++ flags = dreq->flags; + } + spin_unlock(&dreq->lock); + +@@ -729,12 +723,15 @@ static void nfs_direct_write_completion(struct nfs_pgio_header *hdr) + + req = nfs_list_entry(hdr->pages.next); + nfs_list_remove_request(req); +- if (request_commit) { ++ if (flags == NFS_ODIRECT_DO_COMMIT) { + kref_get(&req->wb_kref); + memcpy(&req->wb_verf, &hdr->verf.verifier, + sizeof(req->wb_verf)); + nfs_mark_request_commit(req, hdr->lseg, &cinfo, + hdr->ds_commit_idx); ++ } else if (flags == NFS_ODIRECT_RESCHED_WRITES) { ++ kref_get(&req->wb_kref); ++ nfs_mark_request_commit(req, NULL, &cinfo, 0); + } + nfs_unlock_and_release_request(req); + } +diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c +index c4c021c6ebbd8..d743629e05e12 100644 +--- a/fs/nfs/fscache.c ++++ b/fs/nfs/fscache.c +@@ -385,12 +385,15 @@ static void nfs_readpage_from_fscache_complete(struct page *page, + "NFS: readpage_from_fscache_complete (0x%p/0x%p/%d)\n", + page, context, error); + +- /* if the read completes with an error, we just unlock the page and let +- * the VM reissue the readpage */ +- if (!error) { ++ /* ++ * If the read completes with an error, mark the page with PG_checked, ++ * unlock the page, and let the VM reissue the readpage. ++ */ ++ if (!error) + SetPageUptodate(page); +- unlock_page(page); +- } ++ else ++ SetPageChecked(page); ++ unlock_page(page); + } + + /* +@@ -405,6 +408,11 @@ int __nfs_readpage_from_fscache(struct nfs_open_context *ctx, + "NFS: readpage_from_fscache(fsc:%p/p:%p(i:%lx f:%lx)/0x%p)\n", + nfs_i_fscache(inode), page, page->index, page->flags, inode); + ++ if (PageChecked(page)) { ++ ClearPageChecked(page); ++ return 1; ++ } ++ + ret = fscache_read_or_alloc_page(nfs_i_fscache(inode), + page, + nfs_readpage_from_fscache_complete, +diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c +index ae8bc84e39fb3..6b1f2bf65bee9 100644 +--- a/fs/nfs/inode.c ++++ b/fs/nfs/inode.c +@@ -1079,6 +1079,7 @@ EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context); + void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx) + { + filp->private_data = get_nfs_open_context(ctx); ++ set_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags); + if (list_empty(&ctx->list)) + nfs_inode_attach_open_context(ctx); + } +@@ -1098,6 +1099,8 @@ struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct + continue; + if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode) + continue; ++ if (!test_bit(NFS_CONTEXT_FILE_OPEN, &pos->flags)) ++ continue; + ctx = get_nfs_open_context(pos); + if (ctx) + break; +@@ -1113,6 +1116,7 @@ void nfs_file_clear_open_context(struct file *filp) + if (ctx) { + struct inode *inode = d_inode(ctx->dentry); + ++ clear_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags); + /* + * We fatal error on write before. Try to writeback + * every page again. +diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c +index 5c4e23abc3451..2299446b3b89b 100644 +--- a/fs/nfs/nfs3proc.c ++++ b/fs/nfs/nfs3proc.c +@@ -385,7 +385,7 @@ nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, + break; + + case NFS3_CREATE_UNCHECKED: +- goto out; ++ goto out_release_acls; + } + nfs_fattr_init(data->res.dir_attr); + nfs_fattr_init(data->res.fattr); +@@ -751,7 +751,7 @@ nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, + break; + default: + status = -EINVAL; +- goto out; ++ goto out_release_acls; + } + + d_alias = nfs3_do_create(dir, dentry, data); +diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h +index 543d916f79abb..3e344bec3647b 100644 +--- a/fs/nfs/nfs4_fs.h ++++ b/fs/nfs/nfs4_fs.h +@@ -45,6 +45,7 @@ enum nfs4_client_state { + NFS4CLNT_RECALL_RUNNING, + NFS4CLNT_RECALL_ANY_LAYOUT_READ, + NFS4CLNT_RECALL_ANY_LAYOUT_RW, ++ NFS4CLNT_DELEGRETURN_DELAYED, + }; + + #define NFS4_RENEW_TIMEOUT 0x01 +diff --git a/fs/nfs/nfs4client.c b/fs/nfs/nfs4client.c +index 42719384e25fe..28431acd1230b 100644 +--- a/fs/nfs/nfs4client.c ++++ b/fs/nfs/nfs4client.c +@@ -197,8 +197,11 @@ void nfs40_shutdown_client(struct nfs_client *clp) + + struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init) + { +- int err; ++ char buf[INET6_ADDRSTRLEN + 1]; ++ const char *ip_addr = cl_init->ip_addr; + struct nfs_client *clp = nfs_alloc_client(cl_init); ++ int err; ++ + if (IS_ERR(clp)) + return clp; + +@@ -222,6 +225,44 @@ struct nfs_client *nfs4_alloc_client(const struct nfs_client_initdata *cl_init) + init_waitqueue_head(&clp->cl_lock_waitq); + #endif + INIT_LIST_HEAD(&clp->pending_cb_stateids); ++ ++ if (cl_init->minorversion != 0) ++ __set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags); ++ __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags); ++ __set_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags); ++ ++ /* ++ * Set up the connection to the server before we add add to the ++ * global list. ++ */ ++ err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_GSS_KRB5I); ++ if (err == -EINVAL) ++ err = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX); ++ if (err < 0) ++ goto error; ++ ++ /* If no clientaddr= option was specified, find a usable cb address */ ++ if (ip_addr == NULL) { ++ struct sockaddr_storage cb_addr; ++ struct sockaddr *sap = (struct sockaddr *)&cb_addr; ++ ++ err = rpc_localaddr(clp->cl_rpcclient, sap, sizeof(cb_addr)); ++ if (err < 0) ++ goto error; ++ err = rpc_ntop(sap, buf, sizeof(buf)); ++ if (err < 0) ++ goto error; ++ ip_addr = (const char *)buf; ++ } ++ strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr)); ++ ++ err = nfs_idmap_new(clp); ++ if (err < 0) { ++ dprintk("%s: failed to create idmapper. Error = %d\n", ++ __func__, err); ++ goto error; ++ } ++ __set_bit(NFS_CS_IDMAP, &clp->cl_res_state); + return clp; + + error: +@@ -372,8 +413,6 @@ static int nfs4_init_client_minor_version(struct nfs_client *clp) + struct nfs_client *nfs4_init_client(struct nfs_client *clp, + const struct nfs_client_initdata *cl_init) + { +- char buf[INET6_ADDRSTRLEN + 1]; +- const char *ip_addr = cl_init->ip_addr; + struct nfs_client *old; + int error; + +@@ -381,43 +420,6 @@ struct nfs_client *nfs4_init_client(struct nfs_client *clp, + /* the client is initialised already */ + return clp; + +- /* Check NFS protocol revision and initialize RPC op vector */ +- clp->rpc_ops = &nfs_v4_clientops; +- +- if (clp->cl_minorversion != 0) +- __set_bit(NFS_CS_INFINITE_SLOTS, &clp->cl_flags); +- __set_bit(NFS_CS_DISCRTRY, &clp->cl_flags); +- __set_bit(NFS_CS_NO_RETRANS_TIMEOUT, &clp->cl_flags); +- +- error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_GSS_KRB5I); +- if (error == -EINVAL) +- error = nfs_create_rpc_client(clp, cl_init, RPC_AUTH_UNIX); +- if (error < 0) +- goto error; +- +- /* If no clientaddr= option was specified, find a usable cb address */ +- if (ip_addr == NULL) { +- struct sockaddr_storage cb_addr; +- struct sockaddr *sap = (struct sockaddr *)&cb_addr; +- +- error = rpc_localaddr(clp->cl_rpcclient, sap, sizeof(cb_addr)); +- if (error < 0) +- goto error; +- error = rpc_ntop(sap, buf, sizeof(buf)); +- if (error < 0) +- goto error; +- ip_addr = (const char *)buf; +- } +- strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr)); +- +- error = nfs_idmap_new(clp); +- if (error < 0) { +- dprintk("%s: failed to create idmapper. Error = %d\n", +- __func__, error); +- goto error; +- } +- __set_bit(NFS_CS_IDMAP, &clp->cl_res_state); +- + error = nfs4_init_client_minor_version(clp); + if (error < 0) + goto error; +diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c +index a5e3628a52733..2da35a31508c7 100644 +--- a/fs/nfs/pnfs.c ++++ b/fs/nfs/pnfs.c +@@ -966,10 +966,8 @@ void + pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo, const nfs4_stateid *new, + const struct cred *cred, bool update_barrier) + { +- u32 oldseq, newseq, new_barrier = 0; +- +- oldseq = be32_to_cpu(lo->plh_stateid.seqid); +- newseq = be32_to_cpu(new->seqid); ++ u32 oldseq = be32_to_cpu(lo->plh_stateid.seqid); ++ u32 newseq = be32_to_cpu(new->seqid); + + if (!pnfs_layout_is_valid(lo)) { + pnfs_set_layout_cred(lo, cred); +@@ -979,19 +977,21 @@ pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo, const nfs4_stateid *new, + clear_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags); + return; + } +- if (pnfs_seqid_is_newer(newseq, oldseq)) { ++ ++ if (pnfs_seqid_is_newer(newseq, oldseq)) + nfs4_stateid_copy(&lo->plh_stateid, new); +- /* +- * Because of wraparound, we want to keep the barrier +- * "close" to the current seqids. +- */ +- new_barrier = newseq - atomic_read(&lo->plh_outstanding); +- } +- if (update_barrier) +- new_barrier = be32_to_cpu(new->seqid); +- else if (new_barrier == 0) ++ ++ if (update_barrier) { ++ pnfs_barrier_update(lo, newseq); + return; +- pnfs_barrier_update(lo, new_barrier); ++ } ++ /* ++ * Because of wraparound, we want to keep the barrier ++ * "close" to the current seqids. We really only want to ++ * get here from a layoutget call. ++ */ ++ if (atomic_read(&lo->plh_outstanding) == 1) ++ pnfs_barrier_update(lo, be32_to_cpu(lo->plh_stateid.seqid)); + } + + static bool +@@ -2014,7 +2014,7 @@ lookup_again: + * If the layout segment list is empty, but there are outstanding + * layoutget calls, then they might be subject to a layoutrecall. + */ +- if (list_empty(&lo->plh_segs) && ++ if ((list_empty(&lo->plh_segs) || !pnfs_layout_is_valid(lo)) && + atomic_read(&lo->plh_outstanding) != 0) { + spin_unlock(&ino->i_lock); + lseg = ERR_PTR(wait_var_event_killable(&lo->plh_outstanding, +@@ -2390,11 +2390,13 @@ pnfs_layout_process(struct nfs4_layoutget *lgp) + goto out_forget; + } + ++ if (!pnfs_layout_is_valid(lo) && !pnfs_is_first_layoutget(lo)) ++ goto out_forget; ++ + if (nfs4_stateid_match_other(&lo->plh_stateid, &res->stateid)) { + /* existing state ID, make sure the sequence number matches. */ + if (pnfs_layout_stateid_blocked(lo, &res->stateid)) { +- if (!pnfs_layout_is_valid(lo) && +- pnfs_is_first_layoutget(lo)) ++ if (!pnfs_layout_is_valid(lo)) + lo->plh_barrier = 0; + dprintk("%s forget reply due to sequence\n", __func__); + goto out_forget; +@@ -2415,8 +2417,6 @@ pnfs_layout_process(struct nfs4_layoutget *lgp) + goto out_forget; + } else { + /* We have a completely new layout */ +- if (!pnfs_is_first_layoutget(lo)) +- goto out_forget; + pnfs_set_layout_stateid(lo, &res->stateid, lgp->cred, true); + } + +diff --git a/fs/nfs/pnfs_nfs.c b/fs/nfs/pnfs_nfs.c +index 49d3389bd8130..1c2c0d08614ee 100644 +--- a/fs/nfs/pnfs_nfs.c ++++ b/fs/nfs/pnfs_nfs.c +@@ -805,19 +805,16 @@ out: + } + EXPORT_SYMBOL_GPL(nfs4_pnfs_ds_add); + +-static void nfs4_wait_ds_connect(struct nfs4_pnfs_ds *ds) ++static int nfs4_wait_ds_connect(struct nfs4_pnfs_ds *ds) + { + might_sleep(); +- wait_on_bit(&ds->ds_state, NFS4DS_CONNECTING, +- TASK_KILLABLE); ++ return wait_on_bit(&ds->ds_state, NFS4DS_CONNECTING, TASK_KILLABLE); + } + + static void nfs4_clear_ds_conn_bit(struct nfs4_pnfs_ds *ds) + { + smp_mb__before_atomic(); +- clear_bit(NFS4DS_CONNECTING, &ds->ds_state); +- smp_mb__after_atomic(); +- wake_up_bit(&ds->ds_state, NFS4DS_CONNECTING); ++ clear_and_wake_up_bit(NFS4DS_CONNECTING, &ds->ds_state); + } + + static struct nfs_client *(*get_v3_ds_connect)( +@@ -993,30 +990,33 @@ int nfs4_pnfs_ds_connect(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds, + { + int err; + +-again: +- err = 0; +- if (test_and_set_bit(NFS4DS_CONNECTING, &ds->ds_state) == 0) { +- if (version == 3) { +- err = _nfs4_pnfs_v3_ds_connect(mds_srv, ds, timeo, +- retrans); +- } else if (version == 4) { +- err = _nfs4_pnfs_v4_ds_connect(mds_srv, ds, timeo, +- retrans, minor_version); +- } else { +- dprintk("%s: unsupported DS version %d\n", __func__, +- version); +- err = -EPROTONOSUPPORT; +- } ++ do { ++ err = nfs4_wait_ds_connect(ds); ++ if (err || ds->ds_clp) ++ goto out; ++ if (nfs4_test_deviceid_unavailable(devid)) ++ return -ENODEV; ++ } while (test_and_set_bit(NFS4DS_CONNECTING, &ds->ds_state) != 0); + +- nfs4_clear_ds_conn_bit(ds); +- } else { +- nfs4_wait_ds_connect(ds); ++ if (ds->ds_clp) ++ goto connect_done; + +- /* what was waited on didn't connect AND didn't mark unavail */ +- if (!ds->ds_clp && !nfs4_test_deviceid_unavailable(devid)) +- goto again; ++ switch (version) { ++ case 3: ++ err = _nfs4_pnfs_v3_ds_connect(mds_srv, ds, timeo, retrans); ++ break; ++ case 4: ++ err = _nfs4_pnfs_v4_ds_connect(mds_srv, ds, timeo, retrans, ++ minor_version); ++ break; ++ default: ++ dprintk("%s: unsupported DS version %d\n", __func__, version); ++ err = -EPROTONOSUPPORT; + } + ++connect_done: ++ nfs4_clear_ds_conn_bit(ds); ++out: + /* + * At this point the ds->ds_clp should be ready, but it might have + * hit an error. +diff --git a/fs/nfs/read.c b/fs/nfs/read.c +index d2b6dce1f99f7..d13a22fc94a7d 100644 +--- a/fs/nfs/read.c ++++ b/fs/nfs/read.c +@@ -363,22 +363,23 @@ int nfs_readpage(struct file *file, struct page *page) + } else + desc.ctx = get_nfs_open_context(nfs_file_open_context(file)); + ++ xchg(&desc.ctx->error, 0); + if (!IS_SYNC(inode)) { + ret = nfs_readpage_from_fscache(desc.ctx, inode, page); + if (ret == 0) +- goto out; ++ goto out_wait; + } + +- xchg(&desc.ctx->error, 0); + nfs_pageio_init_read(&desc.pgio, inode, false, + &nfs_async_read_completion_ops); + + ret = readpage_async_filler(&desc, page); ++ if (ret) ++ goto out; + +- if (!ret) +- nfs_pageio_complete_read(&desc.pgio, inode); +- ++ nfs_pageio_complete_read(&desc.pgio, inode); + ret = desc.pgio.pg_error < 0 ? desc.pgio.pg_error : 0; ++out_wait: + if (!ret) { + ret = wait_on_page_locked_killable(page); + if (!PageUptodate(page) && !ret) +diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c +index 886e50ed07c20..f8f528ce58358 100644 +--- a/fs/nfsd/nfs4state.c ++++ b/fs/nfsd/nfs4state.c +@@ -7150,7 +7150,6 @@ nfs4_client_to_reclaim(struct xdr_netobj name, struct xdr_netobj princhash, + unsigned int strhashval; + struct nfs4_client_reclaim *crp; + +- trace_nfsd_clid_reclaim(nn, name.len, name.data); + crp = alloc_reclaim(); + if (crp) { + strhashval = clientstr_hashval(name); +@@ -7200,8 +7199,6 @@ nfsd4_find_reclaim_client(struct xdr_netobj name, struct nfsd_net *nn) + unsigned int strhashval; + struct nfs4_client_reclaim *crp = NULL; + +- trace_nfsd_clid_find(nn, name.len, name.data); +- + strhashval = clientstr_hashval(name); + list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) { + if (compare_blob(&crp->cr_name, &name) == 0) { +diff --git a/fs/nfsd/trace.h b/fs/nfsd/trace.h +index 92a0973dd6713..02a7954702296 100644 +--- a/fs/nfsd/trace.h ++++ b/fs/nfsd/trace.h +@@ -512,35 +512,6 @@ DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ + DEFINE_NET_EVENT(grace_start); + DEFINE_NET_EVENT(grace_complete); + +-DECLARE_EVENT_CLASS(nfsd_clid_class, +- TP_PROTO(const struct nfsd_net *nn, +- unsigned int namelen, +- const unsigned char *namedata), +- TP_ARGS(nn, namelen, namedata), +- TP_STRUCT__entry( +- __field(unsigned long long, boot_time) +- __field(unsigned int, namelen) +- __dynamic_array(unsigned char, name, namelen) +- ), +- TP_fast_assign( +- __entry->boot_time = nn->boot_time; +- __entry->namelen = namelen; +- memcpy(__get_dynamic_array(name), namedata, namelen); +- ), +- TP_printk("boot_time=%16llx nfs4_clientid=%.*s", +- __entry->boot_time, __entry->namelen, __get_str(name)) +-) +- +-#define DEFINE_CLID_EVENT(name) \ +-DEFINE_EVENT(nfsd_clid_class, nfsd_clid_##name, \ +- TP_PROTO(const struct nfsd_net *nn, \ +- unsigned int namelen, \ +- const unsigned char *namedata), \ +- TP_ARGS(nn, namelen, namedata)) +- +-DEFINE_CLID_EVENT(find); +-DEFINE_CLID_EVENT(reclaim); +- + TRACE_EVENT(nfsd_clid_inuse_err, + TP_PROTO(const struct nfs4_client *clp), + TP_ARGS(clp), +diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c +index fd6be35a1642c..f83a1d1225050 100644 +--- a/fs/nfsd/vfs.c ++++ b/fs/nfsd/vfs.c +@@ -1123,6 +1123,19 @@ out: + } + + #ifdef CONFIG_NFSD_V3 ++static int ++nfsd_filemap_write_and_wait_range(struct nfsd_file *nf, loff_t offset, ++ loff_t end) ++{ ++ struct address_space *mapping = nf->nf_file->f_mapping; ++ int ret = filemap_fdatawrite_range(mapping, offset, end); ++ ++ if (ret) ++ return ret; ++ filemap_fdatawait_range_keep_errors(mapping, offset, end); ++ return 0; ++} ++ + /* + * Commit all pending writes to stable storage. + * +@@ -1153,10 +1166,11 @@ nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp, + if (err) + goto out; + if (EX_ISSYNC(fhp->fh_export)) { +- int err2; ++ int err2 = nfsd_filemap_write_and_wait_range(nf, offset, end); + + down_write(&nf->nf_rwsem); +- err2 = vfs_fsync_range(nf->nf_file, offset, end, 0); ++ if (!err2) ++ err2 = vfs_fsync_range(nf->nf_file, offset, end, 0); + switch (err2) { + case 0: + nfsd_copy_boot_verifier(verf, net_generic(nf->nf_net, +diff --git a/fs/orangefs/super.c b/fs/orangefs/super.c +index ee5efdc35cc1e..2f2e430461b21 100644 +--- a/fs/orangefs/super.c ++++ b/fs/orangefs/super.c +@@ -209,7 +209,7 @@ static int orangefs_statfs(struct dentry *dentry, struct kstatfs *buf) + buf->f_bavail = (sector_t) new_op->downcall.resp.statfs.blocks_avail; + buf->f_files = (sector_t) new_op->downcall.resp.statfs.files_total; + buf->f_ffree = (sector_t) new_op->downcall.resp.statfs.files_avail; +- buf->f_frsize = sb->s_blocksize; ++ buf->f_frsize = 0; + + out_op_release: + op_release(new_op); +diff --git a/fs/seq_file.c b/fs/seq_file.c +index cb11a34fb8714..1cfae052439d9 100644 +--- a/fs/seq_file.c ++++ b/fs/seq_file.c +@@ -32,6 +32,9 @@ static void seq_set_overflow(struct seq_file *m) + + static void *seq_buf_alloc(unsigned long size) + { ++ if (unlikely(size > MAX_RW_COUNT)) ++ return NULL; ++ + return kvmalloc(size, GFP_KERNEL_ACCOUNT); + } + +diff --git a/fs/ubifs/dir.c b/fs/ubifs/dir.c +index d9d8d7794eff2..af1ea5fcd38db 100644 +--- a/fs/ubifs/dir.c ++++ b/fs/ubifs/dir.c +@@ -1337,7 +1337,10 @@ static int do_rename(struct inode *old_dir, struct dentry *old_dentry, + goto out_release; + } + ++ spin_lock(&whiteout->i_lock); + whiteout->i_state |= I_LINKABLE; ++ spin_unlock(&whiteout->i_lock); ++ + whiteout_ui = ubifs_inode(whiteout); + whiteout_ui->data = dev; + whiteout_ui->data_len = ubifs_encode_dev(dev, MKDEV(0, 0)); +@@ -1430,7 +1433,11 @@ static int do_rename(struct inode *old_dir, struct dentry *old_dentry, + + inc_nlink(whiteout); + mark_inode_dirty(whiteout); ++ ++ spin_lock(&whiteout->i_lock); + whiteout->i_state &= ~I_LINKABLE; ++ spin_unlock(&whiteout->i_lock); ++ + iput(whiteout); + } + +diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c +index 2857e64d673d1..230717384a38e 100644 +--- a/fs/ubifs/journal.c ++++ b/fs/ubifs/journal.c +@@ -882,6 +882,7 @@ int ubifs_jnl_write_inode(struct ubifs_info *c, const struct inode *inode) + struct ubifs_dent_node *xent, *pxent = NULL; + + if (ui->xattr_cnt > ubifs_xattr_max_cnt(c)) { ++ err = -EPERM; + ubifs_err(c, "Cannot delete inode, it has too much xattrs!"); + goto out_release; + } +diff --git a/include/linux/compiler-clang.h b/include/linux/compiler-clang.h +index d217c382b02de..4d87b36dbc8c5 100644 +--- a/include/linux/compiler-clang.h ++++ b/include/linux/compiler-clang.h +@@ -13,6 +13,12 @@ + /* all clang versions usable with the kernel support KASAN ABI version 5 */ + #define KASAN_ABI_VERSION 5 + ++/* ++ * Note: Checking __has_feature(*_sanitizer) is only true if the feature is ++ * enabled. Therefore it is not required to additionally check defined(CONFIG_*) ++ * to avoid adding redundant attributes in other configurations. ++ */ ++ + #if __has_feature(address_sanitizer) || __has_feature(hwaddress_sanitizer) + /* Emulate GCC's __SANITIZE_ADDRESS__ flag */ + #define __SANITIZE_ADDRESS__ +@@ -45,6 +51,17 @@ + #define __no_sanitize_undefined + #endif + ++/* ++ * Support for __has_feature(coverage_sanitizer) was added in Clang 13 together ++ * with no_sanitize("coverage"). Prior versions of Clang support coverage ++ * instrumentation, but cannot be queried for support by the preprocessor. ++ */ ++#if __has_feature(coverage_sanitizer) ++#define __no_sanitize_coverage __attribute__((no_sanitize("coverage"))) ++#else ++#define __no_sanitize_coverage ++#endif ++ + /* + * Not all versions of clang implement the type-generic versions + * of the builtin overflow checkers. Fortunately, clang implements +diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h +index 48750243db4c8..c6ab0dcb9c0c7 100644 +--- a/include/linux/compiler-gcc.h ++++ b/include/linux/compiler-gcc.h +@@ -126,6 +126,12 @@ + #define __no_sanitize_undefined + #endif + ++#if defined(CONFIG_KCOV) && __has_attribute(__no_sanitize_coverage__) ++#define __no_sanitize_coverage __attribute__((no_sanitize_coverage)) ++#else ++#define __no_sanitize_coverage ++#endif ++ + #if GCC_VERSION >= 50100 + #define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1 + #endif +diff --git a/include/linux/compiler_types.h b/include/linux/compiler_types.h +index e5dd5a4ae9460..652217da3b7cd 100644 +--- a/include/linux/compiler_types.h ++++ b/include/linux/compiler_types.h +@@ -210,7 +210,7 @@ struct ftrace_likely_data { + /* Section for code which can't be instrumented at all */ + #define noinstr \ + noinline notrace __attribute((__section__(".noinstr.text"))) \ +- __no_kcsan __no_sanitize_address ++ __no_kcsan __no_sanitize_address __no_sanitize_coverage + + #endif /* __KERNEL__ */ + +diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h +index eadaabd18dc7d..be9eadd23659e 100644 +--- a/include/linux/nfs_fs.h ++++ b/include/linux/nfs_fs.h +@@ -84,6 +84,7 @@ struct nfs_open_context { + #define NFS_CONTEXT_RESEND_WRITES (1) + #define NFS_CONTEXT_BAD (2) + #define NFS_CONTEXT_UNLOCK (3) ++#define NFS_CONTEXT_FILE_OPEN (4) + int error; + + struct list_head list; +diff --git a/include/linux/pci-ecam.h b/include/linux/pci-ecam.h +index 65d3d83015c39..944da75ff25cf 100644 +--- a/include/linux/pci-ecam.h ++++ b/include/linux/pci-ecam.h +@@ -55,6 +55,7 @@ struct pci_ecam_ops { + struct pci_config_window { + struct resource res; + struct resource busr; ++ unsigned int bus_shift; + void *priv; + const struct pci_ecam_ops *ops; + union { +diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h +index bd04f722714f6..d11bee5d9347f 100644 +--- a/include/linux/rcupdate.h ++++ b/include/linux/rcupdate.h +@@ -315,7 +315,7 @@ static inline int rcu_read_lock_any_held(void) + #define RCU_LOCKDEP_WARN(c, s) \ + do { \ + static bool __section(".data.unlikely") __warned; \ +- if (debug_lockdep_rcu_enabled() && !__warned && (c)) { \ ++ if ((c) && debug_lockdep_rcu_enabled() && !__warned) { \ + __warned = true; \ + lockdep_rcu_suspicious(__FILE__, __LINE__, s); \ + } \ +diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h +index 3f6a0fcaa10cf..ae60f838ebb92 100644 +--- a/include/linux/sched/signal.h ++++ b/include/linux/sched/signal.h +@@ -537,6 +537,17 @@ static inline int kill_cad_pid(int sig, int priv) + #define SEND_SIG_NOINFO ((struct kernel_siginfo *) 0) + #define SEND_SIG_PRIV ((struct kernel_siginfo *) 1) + ++static inline int __on_sig_stack(unsigned long sp) ++{ ++#ifdef CONFIG_STACK_GROWSUP ++ return sp >= current->sas_ss_sp && ++ sp - current->sas_ss_sp < current->sas_ss_size; ++#else ++ return sp > current->sas_ss_sp && ++ sp - current->sas_ss_sp <= current->sas_ss_size; ++#endif ++} ++ + /* + * True if we are on the alternate signal stack. + */ +@@ -554,13 +565,7 @@ static inline int on_sig_stack(unsigned long sp) + if (current->sas_ss_flags & SS_AUTODISARM) + return 0; + +-#ifdef CONFIG_STACK_GROWSUP +- return sp >= current->sas_ss_sp && +- sp - current->sas_ss_sp < current->sas_ss_size; +-#else +- return sp > current->sas_ss_sp && +- sp - current->sas_ss_sp <= current->sas_ss_size; +-#endif ++ return __on_sig_stack(sp); + } + + static inline int sas_ss_flags(unsigned long sp) +diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h +index 091f284bd6e93..2bb452a8f134c 100644 +--- a/include/scsi/libiscsi.h ++++ b/include/scsi/libiscsi.h +@@ -195,12 +195,6 @@ struct iscsi_conn { + unsigned long suspend_tx; /* suspend Tx */ + unsigned long suspend_rx; /* suspend Rx */ + +- /* abort */ +- wait_queue_head_t ehwait; /* used in eh_abort() */ +- struct iscsi_tm tmhdr; +- struct timer_list tmf_timer; +- int tmf_state; /* see TMF_INITIAL, etc.*/ +- + /* negotiated params */ + unsigned max_recv_dlength; /* initiator_max_recv_dsl*/ + unsigned max_xmit_dlength; /* target_max_recv_dsl */ +@@ -270,6 +264,11 @@ struct iscsi_session { + * and recv lock. + */ + struct mutex eh_mutex; ++ /* abort */ ++ wait_queue_head_t ehwait; /* used in eh_abort() */ ++ struct iscsi_tm tmhdr; ++ struct timer_list tmf_timer; ++ int tmf_state; /* see TMF_INITIAL, etc.*/ + + /* iSCSI session-wide sequencing */ + uint32_t cmdsn; +diff --git a/include/scsi/scsi_transport_iscsi.h b/include/scsi/scsi_transport_iscsi.h +index 3974329d4d023..c5d7810fd7926 100644 +--- a/include/scsi/scsi_transport_iscsi.h ++++ b/include/scsi/scsi_transport_iscsi.h +@@ -443,6 +443,8 @@ extern void iscsi_remove_session(struct iscsi_cls_session *session); + extern void iscsi_free_session(struct iscsi_cls_session *session); + extern struct iscsi_cls_conn *iscsi_create_conn(struct iscsi_cls_session *sess, + int dd_size, uint32_t cid); ++extern void iscsi_put_conn(struct iscsi_cls_conn *conn); ++extern void iscsi_get_conn(struct iscsi_cls_conn *conn); + extern int iscsi_destroy_conn(struct iscsi_cls_conn *conn); + extern void iscsi_unblock_session(struct iscsi_cls_session *session); + extern void iscsi_block_session(struct iscsi_cls_session *session); +diff --git a/kernel/cgroup/cgroup-v1.c b/kernel/cgroup/cgroup-v1.c +index f6dddb3a8f4a2..04eb28f7735fb 100644 +--- a/kernel/cgroup/cgroup-v1.c ++++ b/kernel/cgroup/cgroup-v1.c +@@ -912,6 +912,8 @@ int cgroup1_parse_param(struct fs_context *fc, struct fs_parameter *param) + opt = fs_parse(fc, cgroup1_fs_parameters, param, &result); + if (opt == -ENOPARAM) { + if (strcmp(param->key, "source") == 0) { ++ if (param->type != fs_value_is_string) ++ return invalf(fc, "Non-string source"); + if (fc->source) + return invalf(fc, "Multiple sources not supported"); + fc->source = param->string; +diff --git a/kernel/jump_label.c b/kernel/jump_label.c +index ba39fbb1f8e73..af520ca263603 100644 +--- a/kernel/jump_label.c ++++ b/kernel/jump_label.c +@@ -316,14 +316,16 @@ static int addr_conflict(struct jump_entry *entry, void *start, void *end) + } + + static int __jump_label_text_reserved(struct jump_entry *iter_start, +- struct jump_entry *iter_stop, void *start, void *end) ++ struct jump_entry *iter_stop, void *start, void *end, bool init) + { + struct jump_entry *iter; + + iter = iter_start; + while (iter < iter_stop) { +- if (addr_conflict(iter, start, end)) +- return 1; ++ if (init || !jump_entry_is_init(iter)) { ++ if (addr_conflict(iter, start, end)) ++ return 1; ++ } + iter++; + } + +@@ -561,7 +563,7 @@ static int __jump_label_mod_text_reserved(void *start, void *end) + + ret = __jump_label_text_reserved(mod->jump_entries, + mod->jump_entries + mod->num_jump_entries, +- start, end); ++ start, end, mod->state == MODULE_STATE_COMING); + + module_put(mod); + +@@ -786,8 +788,9 @@ early_initcall(jump_label_init_module); + */ + int jump_label_text_reserved(void *start, void *end) + { ++ bool init = system_state < SYSTEM_RUNNING; + int ret = __jump_label_text_reserved(__start___jump_table, +- __stop___jump_table, start, end); ++ __stop___jump_table, start, end, init); + + if (ret) + return ret; +diff --git a/kernel/kprobes.c b/kernel/kprobes.c +index 745f08fdd7a69..c6b4c66b8fa27 100644 +--- a/kernel/kprobes.c ++++ b/kernel/kprobes.c +@@ -35,6 +35,7 @@ + #include + #include + #include ++#include + #include + + #include +@@ -1569,6 +1570,7 @@ static int check_kprobe_address_safe(struct kprobe *p, + if (!kernel_text_address((unsigned long) p->addr) || + within_kprobe_blacklist((unsigned long) p->addr) || + jump_label_text_reserved(p->addr, p->addr) || ++ static_call_text_reserved(p->addr, p->addr) || + find_bug((unsigned long)p->addr)) { + ret = -EINVAL; + goto out; +diff --git a/kernel/module.c b/kernel/module.c +index 260d6f3f6d68f..f928037a1b567 100644 +--- a/kernel/module.c ++++ b/kernel/module.c +@@ -4410,9 +4410,10 @@ int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *, + ret = fn(data, kallsyms_symbol_name(kallsyms, i), + mod, kallsyms_symbol_value(sym)); + if (ret != 0) +- break; ++ goto out; + } + } ++out: + mutex_unlock(&module_mutex); + return ret; + } +diff --git a/kernel/rcu/rcu.h b/kernel/rcu/rcu.h +index bf0827d4b6593..cfd06fb5ba6d0 100644 +--- a/kernel/rcu/rcu.h ++++ b/kernel/rcu/rcu.h +@@ -308,6 +308,8 @@ static inline void rcu_init_levelspread(int *levelspread, const int *levelcnt) + } + } + ++extern void rcu_init_geometry(void); ++ + /* Returns a pointer to the first leaf rcu_node structure. */ + #define rcu_first_leaf_node() (rcu_state.level[rcu_num_lvls - 1]) + +diff --git a/kernel/rcu/srcutree.c b/kernel/rcu/srcutree.c +index e26547b34ad33..072e47288f1f4 100644 +--- a/kernel/rcu/srcutree.c ++++ b/kernel/rcu/srcutree.c +@@ -90,6 +90,9 @@ static void init_srcu_struct_nodes(struct srcu_struct *ssp, bool is_static) + struct srcu_node *snp; + struct srcu_node *snp_first; + ++ /* Initialize geometry if it has not already been initialized. */ ++ rcu_init_geometry(); ++ + /* Work out the overall tree geometry. */ + ssp->level[0] = &ssp->node[0]; + for (i = 1; i < rcu_num_lvls; i++) +diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c +index a274622ed6fa2..33bdbe0629d5c 100644 +--- a/kernel/rcu/tree.c ++++ b/kernel/rcu/tree.c +@@ -4502,11 +4502,25 @@ static void __init rcu_init_one(void) + * replace the definitions in tree.h because those are needed to size + * the ->node array in the rcu_state structure. + */ +-static void __init rcu_init_geometry(void) ++void rcu_init_geometry(void) + { + ulong d; + int i; ++ static unsigned long old_nr_cpu_ids; + int rcu_capacity[RCU_NUM_LVLS]; ++ static bool initialized; ++ ++ if (initialized) { ++ /* ++ * Warn if setup_nr_cpu_ids() had not yet been invoked, ++ * unless nr_cpus_ids == NR_CPUS, in which case who cares? ++ */ ++ WARN_ON_ONCE(old_nr_cpu_ids != nr_cpu_ids); ++ return; ++ } ++ ++ old_nr_cpu_ids = nr_cpu_ids; ++ initialized = true; + + /* + * Initialize any unspecified boot parameters. +diff --git a/kernel/rcu/update.c b/kernel/rcu/update.c +index b95ae86c40a7d..dd94a602a6d25 100644 +--- a/kernel/rcu/update.c ++++ b/kernel/rcu/update.c +@@ -277,7 +277,7 @@ EXPORT_SYMBOL_GPL(rcu_callback_map); + + noinstr int notrace debug_lockdep_rcu_enabled(void) + { +- return rcu_scheduler_active != RCU_SCHEDULER_INACTIVE && debug_locks && ++ return rcu_scheduler_active != RCU_SCHEDULER_INACTIVE && READ_ONCE(debug_locks) && + current->lockdep_recursion == 0; + } + EXPORT_SYMBOL_GPL(debug_lockdep_rcu_enabled); +diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h +index e4e4f47cee6a4..eee49ce2d5960 100644 +--- a/kernel/sched/sched.h ++++ b/kernel/sched/sched.h +@@ -2524,20 +2524,27 @@ static __always_inline + unsigned long uclamp_rq_util_with(struct rq *rq, unsigned long util, + struct task_struct *p) + { +- unsigned long min_util; +- unsigned long max_util; ++ unsigned long min_util = 0; ++ unsigned long max_util = 0; + + if (!static_branch_likely(&sched_uclamp_used)) + return util; + +- min_util = READ_ONCE(rq->uclamp[UCLAMP_MIN].value); +- max_util = READ_ONCE(rq->uclamp[UCLAMP_MAX].value); +- + if (p) { +- min_util = max(min_util, uclamp_eff_value(p, UCLAMP_MIN)); +- max_util = max(max_util, uclamp_eff_value(p, UCLAMP_MAX)); ++ min_util = uclamp_eff_value(p, UCLAMP_MIN); ++ max_util = uclamp_eff_value(p, UCLAMP_MAX); ++ ++ /* ++ * Ignore last runnable task's max clamp, as this task will ++ * reset it. Similarly, no need to read the rq's min clamp. ++ */ ++ if (rq->uclamp_flags & UCLAMP_FLAG_IDLE) ++ goto out; + } + ++ min_util = max_t(unsigned long, min_util, READ_ONCE(rq->uclamp[UCLAMP_MIN].value)); ++ max_util = max_t(unsigned long, max_util, READ_ONCE(rq->uclamp[UCLAMP_MAX].value)); ++out: + /* + * Since CPU's {min,max}_util clamps are MAX aggregated considering + * RUNNABLE tasks with _different_ clamps, we can end up with an +diff --git a/kernel/static_call.c b/kernel/static_call.c +index 2c5950b0b90ef..7eba4912e529d 100644 +--- a/kernel/static_call.c ++++ b/kernel/static_call.c +@@ -292,13 +292,15 @@ static int addr_conflict(struct static_call_site *site, void *start, void *end) + + static int __static_call_text_reserved(struct static_call_site *iter_start, + struct static_call_site *iter_stop, +- void *start, void *end) ++ void *start, void *end, bool init) + { + struct static_call_site *iter = iter_start; + + while (iter < iter_stop) { +- if (addr_conflict(iter, start, end)) +- return 1; ++ if (init || !static_call_is_init(iter)) { ++ if (addr_conflict(iter, start, end)) ++ return 1; ++ } + iter++; + } + +@@ -324,7 +326,7 @@ static int __static_call_mod_text_reserved(void *start, void *end) + + ret = __static_call_text_reserved(mod->static_call_sites, + mod->static_call_sites + mod->num_static_call_sites, +- start, end); ++ start, end, mod->state == MODULE_STATE_COMING); + + module_put(mod); + +@@ -459,8 +461,9 @@ static inline int __static_call_mod_text_reserved(void *start, void *end) + + int static_call_text_reserved(void *start, void *end) + { ++ bool init = system_state < SYSTEM_RUNNING; + int ret = __static_call_text_reserved(__start_static_call_sites, +- __stop_static_call_sites, start, end); ++ __stop_static_call_sites, start, end, init); + + if (ret) + return ret; +diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_hist.c +index a696120b9f1ee..64ddd97d088aa 100644 +--- a/kernel/trace/trace_events_hist.c ++++ b/kernel/trace/trace_events_hist.c +@@ -1673,7 +1673,9 @@ static struct hist_field *create_hist_field(struct hist_trigger_data *hist_data, + if (WARN_ON_ONCE(!field)) + goto out; + +- if (is_string_field(field)) { ++ /* Pointers to strings are just pointers and dangerous to dereference */ ++ if (is_string_field(field) && ++ (field->filter_type != FILTER_PTR_STRING)) { + flags |= HIST_FIELD_FL_STRING; + + hist_field->size = MAX_FILTER_STR_VAL; +@@ -4469,8 +4471,6 @@ static inline void add_to_key(char *compound_key, void *key, + field = key_field->field; + if (field->filter_type == FILTER_DYN_STRING) + size = *(u32 *)(rec + field->offset) >> 16; +- else if (field->filter_type == FILTER_PTR_STRING) +- size = strlen(key); + else if (field->filter_type == FILTER_STATIC_STRING) + size = field->size; + +diff --git a/lib/decompress_unlz4.c b/lib/decompress_unlz4.c +index c0cfcfd486be0..e6327391b6b66 100644 +--- a/lib/decompress_unlz4.c ++++ b/lib/decompress_unlz4.c +@@ -112,6 +112,9 @@ STATIC inline int INIT unlz4(u8 *input, long in_len, + error("data corrupted"); + goto exit_2; + } ++ } else if (size < 4) { ++ /* empty or end-of-file */ ++ goto exit_3; + } + + chunksize = get_unaligned_le32(inp); +@@ -125,6 +128,10 @@ STATIC inline int INIT unlz4(u8 *input, long in_len, + continue; + } + ++ if (!fill && chunksize == 0) { ++ /* empty or end-of-file */ ++ goto exit_3; ++ } + + if (posp) + *posp += 4; +@@ -184,6 +191,7 @@ STATIC inline int INIT unlz4(u8 *input, long in_len, + } + } + ++exit_3: + ret = 0; + exit_2: + if (!input) +diff --git a/mm/hugetlb.c b/mm/hugetlb.c +index dbf44b92651b7..e7e4a3aac3862 100644 +--- a/mm/hugetlb.c ++++ b/mm/hugetlb.c +@@ -5029,8 +5029,9 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma, + continue; + } + +- refs = min3(pages_per_huge_page(h) - pfn_offset, +- (vma->vm_end - vaddr) >> PAGE_SHIFT, remainder); ++ /* vaddr may not be aligned to PAGE_SIZE */ ++ refs = min3(pages_per_huge_page(h) - pfn_offset, remainder, ++ (vma->vm_end - ALIGN_DOWN(vaddr, PAGE_SIZE)) >> PAGE_SHIFT); + + if (pages || vmas) + record_subpages_vmas(mem_map_offset(page, pfn_offset), +diff --git a/net/bridge/br_multicast.c b/net/bridge/br_multicast.c +index 226bb05c3b42d..869f1608c98a3 100644 +--- a/net/bridge/br_multicast.c ++++ b/net/bridge/br_multicast.c +@@ -3087,7 +3087,9 @@ static void br_multicast_pim(struct net_bridge *br, + pim_hdr_type(pimhdr) != PIM_TYPE_HELLO) + return; + ++ spin_lock(&br->multicast_lock); + br_multicast_mark_router(br, port); ++ spin_unlock(&br->multicast_lock); + } + + static int br_ip4_multicast_mrd_rcv(struct net_bridge *br, +@@ -3098,7 +3100,9 @@ static int br_ip4_multicast_mrd_rcv(struct net_bridge *br, + igmp_hdr(skb)->type != IGMP_MRDISC_ADV) + return -ENOMSG; + ++ spin_lock(&br->multicast_lock); + br_multicast_mark_router(br, port); ++ spin_unlock(&br->multicast_lock); + + return 0; + } +@@ -3166,7 +3170,9 @@ static void br_ip6_multicast_mrd_rcv(struct net_bridge *br, + if (icmp6_hdr(skb)->icmp6_type != ICMPV6_MRDISC_ADV) + return; + ++ spin_lock(&br->multicast_lock); + br_multicast_mark_router(br, port); ++ spin_unlock(&br->multicast_lock); + } + + static int br_multicast_ipv6_rcv(struct net_bridge *br, +diff --git a/net/sunrpc/xdr.c b/net/sunrpc/xdr.c +index 3964ff74ee518..ca10ba2626f27 100644 +--- a/net/sunrpc/xdr.c ++++ b/net/sunrpc/xdr.c +@@ -1230,10 +1230,9 @@ static unsigned int xdr_set_page_base(struct xdr_stream *xdr, + void *kaddr; + + maxlen = xdr->buf->page_len; +- if (base >= maxlen) { +- base = maxlen; +- maxlen = 0; +- } else ++ if (base >= maxlen) ++ return 0; ++ else + maxlen -= base; + if (len > maxlen) + len = maxlen; +diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c +index e35760f238a40..87cb0e36eadeb 100644 +--- a/net/sunrpc/xprtsock.c ++++ b/net/sunrpc/xprtsock.c +@@ -1680,7 +1680,8 @@ static int xs_bind(struct sock_xprt *transport, struct socket *sock) + err = kernel_bind(sock, (struct sockaddr *)&myaddr, + transport->xprt.addrlen); + if (err == 0) { +- transport->srcport = port; ++ if (transport->xprt.reuseport) ++ transport->srcport = port; + break; + } + last = port; +diff --git a/sound/ac97/bus.c b/sound/ac97/bus.c +index d9077e91382bf..6ddf646cda659 100644 +--- a/sound/ac97/bus.c ++++ b/sound/ac97/bus.c +@@ -520,7 +520,7 @@ static int ac97_bus_remove(struct device *dev) + struct ac97_codec_driver *adrv = to_ac97_driver(dev->driver); + int ret; + +- ret = pm_runtime_get_sync(dev); ++ ret = pm_runtime_resume_and_get(dev); + if (ret < 0) + return ret; + +diff --git a/sound/firewire/Kconfig b/sound/firewire/Kconfig +index 9897bd26a4388..12664c3a14141 100644 +--- a/sound/firewire/Kconfig ++++ b/sound/firewire/Kconfig +@@ -38,7 +38,7 @@ config SND_OXFW + * Mackie(Loud) Onyx 1640i (former model) + * Mackie(Loud) Onyx Satellite + * Mackie(Loud) Tapco Link.Firewire +- * Mackie(Loud) d.4 pro ++ * Mackie(Loud) d.2 pro/d.4 pro (built-in FireWire card with OXFW971 ASIC) + * Mackie(Loud) U.420/U.420d + * TASCAM FireOne + * Stanton Controllers & Systems 1 Deck/Mixer +@@ -84,7 +84,7 @@ config SND_BEBOB + * PreSonus FIREBOX/FIREPOD/FP10/Inspire1394 + * BridgeCo RDAudio1/Audio5 + * Mackie Onyx 1220/1620/1640 (FireWire I/O Card) +- * Mackie d.2 (FireWire Option) and d.2 Pro ++ * Mackie d.2 (optional FireWire card with DM1000 ASIC) + * Stanton FinalScratch 2 (ScratchAmp) + * Tascam IF-FW/DM + * Behringer XENIX UFX 1204/1604 +@@ -110,6 +110,7 @@ config SND_BEBOB + * M-Audio Ozonic/NRV10/ProfireLightBridge + * M-Audio FireWire 1814/ProjectMix IO + * Digidesign Mbox 2 Pro ++ * ToneWeal FW66 + + To compile this driver as a module, choose M here: the module + will be called snd-bebob. +diff --git a/sound/firewire/bebob/bebob.c b/sound/firewire/bebob/bebob.c +index daeecfa8b9aac..67fa0f2178b01 100644 +--- a/sound/firewire/bebob/bebob.c ++++ b/sound/firewire/bebob/bebob.c +@@ -59,6 +59,7 @@ static DECLARE_BITMAP(devices_used, SNDRV_CARDS); + #define VEN_MAUDIO1 0x00000d6c + #define VEN_MAUDIO2 0x000007f5 + #define VEN_DIGIDESIGN 0x00a07e ++#define OUI_SHOUYO 0x002327 + + #define MODEL_FOCUSRITE_SAFFIRE_BOTH 0x00000000 + #define MODEL_MAUDIO_AUDIOPHILE_BOTH 0x00010060 +@@ -387,7 +388,7 @@ static const struct ieee1394_device_id bebob_id_table[] = { + SND_BEBOB_DEV_ENTRY(VEN_BRIDGECO, 0x00010049, &spec_normal), + /* Mackie, Onyx 1220/1620/1640 (Firewire I/O Card) */ + SND_BEBOB_DEV_ENTRY(VEN_MACKIE2, 0x00010065, &spec_normal), +- // Mackie, d.2 (Firewire option card) and d.2 Pro (the card is built-in). ++ // Mackie, d.2 (optional Firewire card with DM1000). + SND_BEBOB_DEV_ENTRY(VEN_MACKIE1, 0x00010067, &spec_normal), + /* Stanton, ScratchAmp */ + SND_BEBOB_DEV_ENTRY(VEN_STANTON, 0x00000001, &spec_normal), +@@ -486,6 +487,8 @@ static const struct ieee1394_device_id bebob_id_table[] = { + &maudio_special_spec), + /* Digidesign Mbox 2 Pro */ + SND_BEBOB_DEV_ENTRY(VEN_DIGIDESIGN, 0x0000a9, &spec_normal), ++ // Toneweal FW66. ++ SND_BEBOB_DEV_ENTRY(OUI_SHOUYO, 0x020002, &spec_normal), + /* IDs are unknown but able to be supported */ + /* Apogee, Mini-ME Firewire */ + /* Apogee, Mini-DAC Firewire */ +diff --git a/sound/firewire/motu/motu-protocol-v2.c b/sound/firewire/motu/motu-protocol-v2.c +index 784073aa10265..f0a0ecad4d74a 100644 +--- a/sound/firewire/motu/motu-protocol-v2.c ++++ b/sound/firewire/motu/motu-protocol-v2.c +@@ -86,24 +86,23 @@ static int detect_clock_source_optical_model(struct snd_motu *motu, u32 data, + *src = SND_MOTU_CLOCK_SOURCE_INTERNAL; + break; + case 1: ++ *src = SND_MOTU_CLOCK_SOURCE_ADAT_ON_OPT; ++ break; ++ case 2: + { + __be32 reg; + + // To check the configuration of optical interface. +- int err = snd_motu_transaction_read(motu, V2_IN_OUT_CONF_OFFSET, +- ®, sizeof(reg)); ++ int err = snd_motu_transaction_read(motu, V2_IN_OUT_CONF_OFFSET, ®, sizeof(reg)); + if (err < 0) + return err; + +- if (be32_to_cpu(reg) & 0x00000200) ++ if (((data & V2_OPT_IN_IFACE_MASK) >> V2_OPT_IN_IFACE_SHIFT) == V2_OPT_IFACE_MODE_SPDIF) + *src = SND_MOTU_CLOCK_SOURCE_SPDIF_ON_OPT; + else +- *src = SND_MOTU_CLOCK_SOURCE_ADAT_ON_OPT; ++ *src = SND_MOTU_CLOCK_SOURCE_SPDIF_ON_COAX; + break; + } +- case 2: +- *src = SND_MOTU_CLOCK_SOURCE_SPDIF_ON_COAX; +- break; + case 3: + *src = SND_MOTU_CLOCK_SOURCE_SPH; + break; +diff --git a/sound/firewire/oxfw/oxfw.c b/sound/firewire/oxfw/oxfw.c +index 9eea25c46dc7e..5490637d278a4 100644 +--- a/sound/firewire/oxfw/oxfw.c ++++ b/sound/firewire/oxfw/oxfw.c +@@ -355,7 +355,7 @@ static const struct ieee1394_device_id oxfw_id_table[] = { + * Onyx-i series (former models): 0x081216 + * Mackie Onyx Satellite: 0x00200f + * Tapco LINK.firewire 4x6: 0x000460 +- * d.4 pro: Unknown ++ * d.2 pro/d.4 pro (built-in card): Unknown + * U.420: Unknown + * U.420d: Unknown + */ +diff --git a/sound/isa/cmi8330.c b/sound/isa/cmi8330.c +index bc112df10fc57..d1ac9fc994916 100644 +--- a/sound/isa/cmi8330.c ++++ b/sound/isa/cmi8330.c +@@ -547,7 +547,7 @@ static int snd_cmi8330_probe(struct snd_card *card, int dev) + } + if (acard->sb->hardware != SB_HW_16) { + snd_printk(KERN_ERR PFX "SB16 not found during probe\n"); +- return err; ++ return -ENODEV; + } + + snd_wss_out(acard->wss, CS4231_MISC_INFO, 0x40); /* switch on MODE2 */ +diff --git a/sound/isa/sb/sb16_csp.c b/sound/isa/sb/sb16_csp.c +index 4789345a8fdde..c98ccd421a2ec 100644 +--- a/sound/isa/sb/sb16_csp.c ++++ b/sound/isa/sb/sb16_csp.c +@@ -1072,10 +1072,14 @@ static void snd_sb_qsound_destroy(struct snd_sb_csp * p) + card = p->chip->card; + + down_write(&card->controls_rwsem); +- if (p->qsound_switch) ++ if (p->qsound_switch) { + snd_ctl_remove(card, p->qsound_switch); +- if (p->qsound_space) ++ p->qsound_switch = NULL; ++ } ++ if (p->qsound_space) { + snd_ctl_remove(card, p->qsound_space); ++ p->qsound_space = NULL; ++ } + up_write(&card->controls_rwsem); + + /* cancel pending transfer of QSound parameters */ +diff --git a/sound/mips/snd-n64.c b/sound/mips/snd-n64.c +index e35e93157755f..463a6fe589eb2 100644 +--- a/sound/mips/snd-n64.c ++++ b/sound/mips/snd-n64.c +@@ -338,6 +338,10 @@ static int __init n64audio_probe(struct platform_device *pdev) + strcpy(card->longname, "N64 Audio"); + + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); ++ if (!res) { ++ err = -EINVAL; ++ goto fail_dma_alloc; ++ } + if (devm_request_irq(&pdev->dev, res->start, n64audio_isr, + IRQF_SHARED, "N64 Audio", priv)) { + err = -EBUSY; +diff --git a/sound/pci/hda/hda_tegra.c b/sound/pci/hda/hda_tegra.c +index 6f2b743b9d75c..6c6dc3fcde607 100644 +--- a/sound/pci/hda/hda_tegra.c ++++ b/sound/pci/hda/hda_tegra.c +@@ -262,6 +262,9 @@ static int hda_tegra_first_init(struct azx *chip, struct platform_device *pdev) + const char *sname, *drv_name = "tegra-hda"; + struct device_node *np = pdev->dev.of_node; + ++ if (irq_id < 0) ++ return irq_id; ++ + err = hda_tegra_init_chip(chip, pdev); + if (err) + return err; +diff --git a/sound/ppc/powermac.c b/sound/ppc/powermac.c +index 9fb51ebafde16..8088f77d5a74b 100644 +--- a/sound/ppc/powermac.c ++++ b/sound/ppc/powermac.c +@@ -76,7 +76,11 @@ static int snd_pmac_probe(struct platform_device *devptr) + sprintf(card->shortname, "PowerMac %s", name_ext); + sprintf(card->longname, "%s (Dev %d) Sub-frame %d", + card->shortname, chip->device_id, chip->subframe); +- if ( snd_pmac_tumbler_init(chip) < 0 || snd_pmac_tumbler_post_init() < 0) ++ err = snd_pmac_tumbler_init(chip); ++ if (err < 0) ++ goto __error; ++ err = snd_pmac_tumbler_post_init(); ++ if (err < 0) + goto __error; + break; + case PMAC_AWACS: +diff --git a/sound/soc/fsl/fsl_xcvr.c b/sound/soc/fsl/fsl_xcvr.c +index 070e3f32859fa..244a35122fbce 100644 +--- a/sound/soc/fsl/fsl_xcvr.c ++++ b/sound/soc/fsl/fsl_xcvr.c +@@ -1205,6 +1205,10 @@ static int fsl_xcvr_probe(struct platform_device *pdev) + + rx_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rxfifo"); + tx_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "txfifo"); ++ if (!rx_res || !tx_res) { ++ dev_err(dev, "could not find rxfifo or txfifo resource\n"); ++ return -EINVAL; ++ } + xcvr->dma_prms_rx.chan_name = "rx"; + xcvr->dma_prms_tx.chan_name = "tx"; + xcvr->dma_prms_rx.addr = rx_res->start; +diff --git a/sound/soc/img/img-i2s-in.c b/sound/soc/img/img-i2s-in.c +index 0843235d73c91..fd3432a1d6ab8 100644 +--- a/sound/soc/img/img-i2s-in.c ++++ b/sound/soc/img/img-i2s-in.c +@@ -464,7 +464,7 @@ static int img_i2s_in_probe(struct platform_device *pdev) + if (ret) + goto err_pm_disable; + } +- ret = pm_runtime_get_sync(&pdev->dev); ++ ret = pm_runtime_resume_and_get(&pdev->dev); + if (ret < 0) + goto err_suspend; + +diff --git a/sound/soc/intel/boards/kbl_da7219_max98357a.c b/sound/soc/intel/boards/kbl_da7219_max98357a.c +index dc3d897ad2802..36f1f49e0b76b 100644 +--- a/sound/soc/intel/boards/kbl_da7219_max98357a.c ++++ b/sound/soc/intel/boards/kbl_da7219_max98357a.c +@@ -594,7 +594,7 @@ static int kabylake_audio_probe(struct platform_device *pdev) + + static const struct platform_device_id kbl_board_ids[] = { + { +- .name = "kbl_da7219_max98357a", ++ .name = "kbl_da7219_mx98357a", + .driver_data = + (kernel_ulong_t)&kabylake_audio_card_da7219_m98357a, + }, +@@ -616,4 +616,4 @@ module_platform_driver(kabylake_audio) + MODULE_DESCRIPTION("Audio Machine driver-DA7219 & MAX98357A in I2S mode"); + MODULE_AUTHOR("Naveen Manohar "); + MODULE_LICENSE("GPL v2"); +-MODULE_ALIAS("platform:kbl_da7219_max98357a"); ++MODULE_ALIAS("platform:kbl_da7219_mx98357a"); +diff --git a/sound/soc/intel/boards/sof_da7219_max98373.c b/sound/soc/intel/boards/sof_da7219_max98373.c +index f3cb0773e70ee..8d1ad892e86b6 100644 +--- a/sound/soc/intel/boards/sof_da7219_max98373.c ++++ b/sound/soc/intel/boards/sof_da7219_max98373.c +@@ -440,6 +440,7 @@ static const struct platform_device_id board_ids[] = { + }, + { } + }; ++MODULE_DEVICE_TABLE(platform, board_ids); + + static struct platform_driver audio = { + .probe = audio_probe, +diff --git a/sound/soc/intel/boards/sof_rt5682.c b/sound/soc/intel/boards/sof_rt5682.c +index 55505e207bc00..56e92a1ff34d0 100644 +--- a/sound/soc/intel/boards/sof_rt5682.c ++++ b/sound/soc/intel/boards/sof_rt5682.c +@@ -942,6 +942,7 @@ static const struct platform_device_id board_ids[] = { + }, + { } + }; ++MODULE_DEVICE_TABLE(platform, board_ids); + + static struct platform_driver sof_audio = { + .probe = sof_audio_probe, +diff --git a/sound/soc/intel/boards/sof_sdw.c b/sound/soc/intel/boards/sof_sdw.c +index dfad2ad129abb..5827a16773c90 100644 +--- a/sound/soc/intel/boards/sof_sdw.c ++++ b/sound/soc/intel/boards/sof_sdw.c +@@ -354,6 +354,7 @@ static struct sof_sdw_codec_info codec_info_list[] = { + .part_id = 0x714, + .version_id = 3, + .direction = {false, true}, ++ .ignore_pch_dmic = true, + .dai_name = "rt715-aif2", + .init = sof_sdw_rt715_sdca_init, + }, +@@ -361,6 +362,7 @@ static struct sof_sdw_codec_info codec_info_list[] = { + .part_id = 0x715, + .version_id = 3, + .direction = {false, true}, ++ .ignore_pch_dmic = true, + .dai_name = "rt715-aif2", + .init = sof_sdw_rt715_sdca_init, + }, +@@ -368,6 +370,7 @@ static struct sof_sdw_codec_info codec_info_list[] = { + .part_id = 0x714, + .version_id = 2, + .direction = {false, true}, ++ .ignore_pch_dmic = true, + .dai_name = "rt715-aif2", + .init = sof_sdw_rt715_init, + }, +@@ -375,6 +378,7 @@ static struct sof_sdw_codec_info codec_info_list[] = { + .part_id = 0x715, + .version_id = 2, + .direction = {false, true}, ++ .ignore_pch_dmic = true, + .dai_name = "rt715-aif2", + .init = sof_sdw_rt715_init, + }, +@@ -730,7 +734,8 @@ static int create_sdw_dailink(struct device *dev, int *be_index, + int *cpu_id, bool *group_generated, + struct snd_soc_codec_conf *codec_conf, + int codec_count, +- int *codec_conf_index) ++ int *codec_conf_index, ++ bool *ignore_pch_dmic) + { + const struct snd_soc_acpi_link_adr *link_next; + struct snd_soc_dai_link_component *codecs; +@@ -783,6 +788,9 @@ static int create_sdw_dailink(struct device *dev, int *be_index, + if (codec_index < 0) + return codec_index; + ++ if (codec_info_list[codec_index].ignore_pch_dmic) ++ *ignore_pch_dmic = true; ++ + cpu_dai_index = *cpu_id; + for_each_pcm_streams(stream) { + char *name, *cpu_name; +@@ -914,6 +922,7 @@ static int sof_card_dai_links_create(struct device *dev, + const struct snd_soc_acpi_link_adr *adr_link; + struct snd_soc_dai_link_component *cpus; + struct snd_soc_codec_conf *codec_conf; ++ bool ignore_pch_dmic = false; + int codec_conf_count; + int codec_conf_index = 0; + bool group_generated[SDW_MAX_GROUPS]; +@@ -1020,7 +1029,8 @@ static int sof_card_dai_links_create(struct device *dev, + sdw_cpu_dai_num, cpus, adr_link, + &cpu_id, group_generated, + codec_conf, codec_conf_count, +- &codec_conf_index); ++ &codec_conf_index, ++ &ignore_pch_dmic); + if (ret < 0) { + dev_err(dev, "failed to create dai link %d", be_id); + return -ENOMEM; +@@ -1088,6 +1098,10 @@ SSP: + DMIC: + /* dmic */ + if (dmic_num > 0) { ++ if (ignore_pch_dmic) { ++ dev_warn(dev, "Ignoring PCH DMIC\n"); ++ goto HDMI; ++ } + cpus[cpu_id].dai_name = "DMIC01 Pin"; + init_dai_link(dev, links + link_id, be_id, "dmic01", + 0, 1, // DMIC only supports capture +@@ -1106,6 +1120,7 @@ DMIC: + INC_ID(be_id, cpu_id, link_id); + } + ++HDMI: + /* HDMI */ + if (hdmi_num > 0) { + idisp_components = devm_kcalloc(dev, hdmi_num, +diff --git a/sound/soc/intel/boards/sof_sdw_common.h b/sound/soc/intel/boards/sof_sdw_common.h +index f3cb6796363e7..ea60e8ed215c5 100644 +--- a/sound/soc/intel/boards/sof_sdw_common.h ++++ b/sound/soc/intel/boards/sof_sdw_common.h +@@ -56,6 +56,7 @@ struct sof_sdw_codec_info { + int amp_num; + const u8 acpi_id[ACPI_ID_LEN]; + const bool direction[2]; // playback & capture support ++ const bool ignore_pch_dmic; + const char *dai_name; + const struct snd_soc_ops *ops; + +diff --git a/sound/soc/intel/common/soc-acpi-intel-kbl-match.c b/sound/soc/intel/common/soc-acpi-intel-kbl-match.c +index 47dadc9d5d2a0..ba5ff468c265a 100644 +--- a/sound/soc/intel/common/soc-acpi-intel-kbl-match.c ++++ b/sound/soc/intel/common/soc-acpi-intel-kbl-match.c +@@ -113,7 +113,7 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_kbl_machines[] = { + }, + { + .id = "DLGS7219", +- .drv_name = "kbl_da7219_max98373", ++ .drv_name = "kbl_da7219_mx98373", + .fw_filename = "intel/dsp_fw_kbl.bin", + .machine_quirk = snd_soc_acpi_codec_list, + .quirk_data = &kbl_7219_98373_codecs, +diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c +index 6680c12716d44..6d4b08e918dec 100644 +--- a/sound/soc/soc-core.c ++++ b/sound/soc/soc-core.c +@@ -2796,7 +2796,7 @@ int snd_soc_of_parse_audio_routing(struct snd_soc_card *card, + if (!routes) { + dev_err(card->dev, + "ASoC: Could not allocate DAPM route table\n"); +- return -EINVAL; ++ return -ENOMEM; + } + + for (i = 0; i < num_routes; i++) { +diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c +index 14d85ca1e4357..4a25a1e39831f 100644 +--- a/sound/soc/soc-pcm.c ++++ b/sound/soc/soc-pcm.c +@@ -1695,7 +1695,7 @@ static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream, + struct snd_soc_dpcm *dpcm; + struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream); + struct snd_soc_dai *fe_cpu_dai; +- int err; ++ int err = 0; + int i; + + /* apply symmetry for FE */ +diff --git a/sound/usb/mixer_scarlett_gen2.c b/sound/usb/mixer_scarlett_gen2.c +index bca3e7fe27df6..38f4a2a37e0f7 100644 +--- a/sound/usb/mixer_scarlett_gen2.c ++++ b/sound/usb/mixer_scarlett_gen2.c +@@ -254,10 +254,10 @@ static const struct scarlett2_device_info s6i6_gen2_info = { + .pad_input_count = 2, + + .line_out_descrs = { +- "Monitor L", +- "Monitor R", +- "Headphones L", +- "Headphones R", ++ "Headphones 1 L", ++ "Headphones 1 R", ++ "Headphones 2 L", ++ "Headphones 2 R", + }, + + .ports = { +@@ -356,7 +356,7 @@ static const struct scarlett2_device_info s18i8_gen2_info = { + }, + [SCARLETT2_PORT_TYPE_PCM] = { + .id = 0x600, +- .num = { 20, 18, 18, 14, 10 }, ++ .num = { 8, 18, 18, 14, 10 }, + .src_descr = "PCM %d", + .src_num_offset = 1, + .dst_descr = "PCM %02d Capture" +@@ -1033,11 +1033,10 @@ static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl, + struct usb_mixer_interface *mixer = elem->head.mixer; + struct scarlett2_mixer_data *private = mixer->private_data; + +- if (private->vol_updated) { +- mutex_lock(&private->data_mutex); ++ mutex_lock(&private->data_mutex); ++ if (private->vol_updated) + scarlett2_update_volumes(mixer); +- mutex_unlock(&private->data_mutex); +- } ++ mutex_unlock(&private->data_mutex); + + ucontrol->value.integer.value[0] = private->master_vol; + return 0; +@@ -1051,11 +1050,10 @@ static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl, + struct scarlett2_mixer_data *private = mixer->private_data; + int index = elem->control; + +- if (private->vol_updated) { +- mutex_lock(&private->data_mutex); ++ mutex_lock(&private->data_mutex); ++ if (private->vol_updated) + scarlett2_update_volumes(mixer); +- mutex_unlock(&private->data_mutex); +- } ++ mutex_unlock(&private->data_mutex); + + ucontrol->value.integer.value[0] = private->vol[index]; + return 0; +@@ -1186,6 +1184,8 @@ static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl, + /* Send SW/HW switch change to the device */ + err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH, + index, val); ++ if (err == 0) ++ err = 1; + + unlock: + mutex_unlock(&private->data_mutex); +@@ -1246,6 +1246,8 @@ static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl, + /* Send switch change to the device */ + err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH, + index, val); ++ if (err == 0) ++ err = 1; + + unlock: + mutex_unlock(&private->data_mutex); +@@ -1296,6 +1298,8 @@ static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl, + /* Send switch change to the device */ + err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH, + index, val); ++ if (err == 0) ++ err = 1; + + unlock: + mutex_unlock(&private->data_mutex); +@@ -1319,11 +1323,10 @@ static int scarlett2_button_ctl_get(struct snd_kcontrol *kctl, + struct usb_mixer_interface *mixer = elem->head.mixer; + struct scarlett2_mixer_data *private = mixer->private_data; + +- if (private->vol_updated) { +- mutex_lock(&private->data_mutex); ++ mutex_lock(&private->data_mutex); ++ if (private->vol_updated) + scarlett2_update_volumes(mixer); +- mutex_unlock(&private->data_mutex); +- } ++ mutex_unlock(&private->data_mutex); + + ucontrol->value.enumerated.item[0] = private->buttons[elem->control]; + return 0; +@@ -1352,6 +1355,8 @@ static int scarlett2_button_ctl_put(struct snd_kcontrol *kctl, + /* Send switch change to the device */ + err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_BUTTONS, + index, val); ++ if (err == 0) ++ err = 1; + + unlock: + mutex_unlock(&private->data_mutex); +diff --git a/sound/usb/usx2y/usX2Yhwdep.c b/sound/usb/usx2y/usX2Yhwdep.c +index 22412cd69e985..10868c3fb6561 100644 +--- a/sound/usb/usx2y/usX2Yhwdep.c ++++ b/sound/usb/usx2y/usX2Yhwdep.c +@@ -29,7 +29,7 @@ static vm_fault_t snd_us428ctls_vm_fault(struct vm_fault *vmf) + vmf->pgoff); + + offset = vmf->pgoff << PAGE_SHIFT; +- vaddr = (char *)((struct usX2Ydev *)vmf->vma->vm_private_data)->us428ctls_sharedmem + offset; ++ vaddr = (char *)((struct usx2ydev *)vmf->vma->vm_private_data)->us428ctls_sharedmem + offset; + page = virt_to_page(vaddr); + get_page(page); + vmf->page = page; +@@ -47,7 +47,7 @@ static const struct vm_operations_struct us428ctls_vm_ops = { + static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area) + { + unsigned long size = (unsigned long)(area->vm_end - area->vm_start); +- struct usX2Ydev *us428 = hw->private_data; ++ struct usx2ydev *us428 = hw->private_data; + + // FIXME this hwdep interface is used twice: fpga download and mmap for controlling Lights etc. Maybe better using 2 hwdep devs? + // so as long as the device isn't fully initialised yet we return -EBUSY here. +@@ -66,7 +66,7 @@ static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct v + if (!us428->us428ctls_sharedmem) + return -ENOMEM; + memset(us428->us428ctls_sharedmem, -1, sizeof(struct us428ctls_sharedmem)); +- us428->us428ctls_sharedmem->CtlSnapShotLast = -2; ++ us428->us428ctls_sharedmem->ctl_snapshot_last = -2; + } + area->vm_ops = &us428ctls_vm_ops; + area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; +@@ -77,21 +77,21 @@ static int snd_us428ctls_mmap(struct snd_hwdep * hw, struct file *filp, struct v + static __poll_t snd_us428ctls_poll(struct snd_hwdep *hw, struct file *file, poll_table *wait) + { + __poll_t mask = 0; +- struct usX2Ydev *us428 = hw->private_data; ++ struct usx2ydev *us428 = hw->private_data; + struct us428ctls_sharedmem *shm = us428->us428ctls_sharedmem; + if (us428->chip_status & USX2Y_STAT_CHIP_HUP) + return EPOLLHUP; + + poll_wait(file, &us428->us428ctls_wait_queue_head, wait); + +- if (shm != NULL && shm->CtlSnapShotLast != shm->CtlSnapShotRed) ++ if (shm != NULL && shm->ctl_snapshot_last != shm->ctl_snapshot_red) + mask |= EPOLLIN; + + return mask; + } + + +-static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw, ++static int snd_usx2y_hwdep_dsp_status(struct snd_hwdep *hw, + struct snd_hwdep_dsp_status *info) + { + static const char * const type_ids[USX2Y_TYPE_NUMS] = { +@@ -99,7 +99,7 @@ static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw, + [USX2Y_TYPE_224] = "us224", + [USX2Y_TYPE_428] = "us428", + }; +- struct usX2Ydev *us428 = hw->private_data; ++ struct usx2ydev *us428 = hw->private_data; + int id = -1; + + switch (le16_to_cpu(us428->dev->descriptor.idProduct)) { +@@ -124,7 +124,7 @@ static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw, + } + + +-static int usX2Y_create_usbmidi(struct snd_card *card) ++static int usx2y_create_usbmidi(struct snd_card *card) + { + static const struct snd_usb_midi_endpoint_info quirk_data_1 = { + .out_ep = 0x06, +@@ -152,28 +152,28 @@ static int usX2Y_create_usbmidi(struct snd_card *card) + .type = QUIRK_MIDI_FIXED_ENDPOINT, + .data = &quirk_data_2 + }; +- struct usb_device *dev = usX2Y(card)->dev; ++ struct usb_device *dev = usx2y(card)->dev; + struct usb_interface *iface = usb_ifnum_to_if(dev, 0); + const struct snd_usb_audio_quirk *quirk = + le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ? + &quirk_2 : &quirk_1; + +- snd_printdd("usX2Y_create_usbmidi \n"); +- return snd_usbmidi_create(card, iface, &usX2Y(card)->midi_list, quirk); ++ snd_printdd("usx2y_create_usbmidi \n"); ++ return snd_usbmidi_create(card, iface, &usx2y(card)->midi_list, quirk); + } + +-static int usX2Y_create_alsa_devices(struct snd_card *card) ++static int usx2y_create_alsa_devices(struct snd_card *card) + { + int err; + + do { +- if ((err = usX2Y_create_usbmidi(card)) < 0) { +- snd_printk(KERN_ERR "usX2Y_create_alsa_devices: usX2Y_create_usbmidi error %i \n", err); ++ if ((err = usx2y_create_usbmidi(card)) < 0) { ++ snd_printk(KERN_ERR "usx2y_create_alsa_devices: usx2y_create_usbmidi error %i \n", err); + break; + } +- if ((err = usX2Y_audio_create(card)) < 0) ++ if ((err = usx2y_audio_create(card)) < 0) + break; +- if ((err = usX2Y_hwdep_pcm_new(card)) < 0) ++ if ((err = usx2y_hwdep_pcm_new(card)) < 0) + break; + if ((err = snd_card_register(card)) < 0) + break; +@@ -182,10 +182,10 @@ static int usX2Y_create_alsa_devices(struct snd_card *card) + return err; + } + +-static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw, ++static int snd_usx2y_hwdep_dsp_load(struct snd_hwdep *hw, + struct snd_hwdep_dsp_image *dsp) + { +- struct usX2Ydev *priv = hw->private_data; ++ struct usx2ydev *priv = hw->private_data; + struct usb_device* dev = priv->dev; + int lret, err; + char *buf; +@@ -206,19 +206,19 @@ static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw, + return err; + if (dsp->index == 1) { + msleep(250); // give the device some time +- err = usX2Y_AsyncSeq04_init(priv); ++ err = usx2y_async_seq04_init(priv); + if (err) { +- snd_printk(KERN_ERR "usX2Y_AsyncSeq04_init error \n"); ++ snd_printk(KERN_ERR "usx2y_async_seq04_init error \n"); + return err; + } +- err = usX2Y_In04_init(priv); ++ err = usx2y_in04_init(priv); + if (err) { +- snd_printk(KERN_ERR "usX2Y_In04_init error \n"); ++ snd_printk(KERN_ERR "usx2y_in04_init error \n"); + return err; + } +- err = usX2Y_create_alsa_devices(hw->card); ++ err = usx2y_create_alsa_devices(hw->card); + if (err) { +- snd_printk(KERN_ERR "usX2Y_create_alsa_devices error %i \n", err); ++ snd_printk(KERN_ERR "usx2y_create_alsa_devices error %i \n", err); + snd_card_free(hw->card); + return err; + } +@@ -229,7 +229,7 @@ static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw, + } + + +-int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device) ++int usx2y_hwdep_new(struct snd_card *card, struct usb_device* device) + { + int err; + struct snd_hwdep *hw; +@@ -238,9 +238,9 @@ int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device) + return err; + + hw->iface = SNDRV_HWDEP_IFACE_USX2Y; +- hw->private_data = usX2Y(card); +- hw->ops.dsp_status = snd_usX2Y_hwdep_dsp_status; +- hw->ops.dsp_load = snd_usX2Y_hwdep_dsp_load; ++ hw->private_data = usx2y(card); ++ hw->ops.dsp_status = snd_usx2y_hwdep_dsp_status; ++ hw->ops.dsp_load = snd_usx2y_hwdep_dsp_load; + hw->ops.mmap = snd_us428ctls_mmap; + hw->ops.poll = snd_us428ctls_poll; + hw->exclusive = 1; +diff --git a/sound/usb/usx2y/usX2Yhwdep.h b/sound/usb/usx2y/usX2Yhwdep.h +index 457199b5ed03b..34cef625712c6 100644 +--- a/sound/usb/usx2y/usX2Yhwdep.h ++++ b/sound/usb/usx2y/usX2Yhwdep.h +@@ -2,6 +2,6 @@ + #ifndef USX2YHWDEP_H + #define USX2YHWDEP_H + +-int usX2Y_hwdep_new(struct snd_card *card, struct usb_device* device); ++int usx2y_hwdep_new(struct snd_card *card, struct usb_device* device); + + #endif +diff --git a/sound/usb/usx2y/usb_stream.c b/sound/usb/usx2y/usb_stream.c +index 091c071b270af..cff684942c4f0 100644 +--- a/sound/usb/usx2y/usb_stream.c ++++ b/sound/usb/usx2y/usb_stream.c +@@ -142,8 +142,11 @@ void usb_stream_free(struct usb_stream_kernel *sk) + if (!s) + return; + +- free_pages_exact(sk->write_page, s->write_size); +- sk->write_page = NULL; ++ if (sk->write_page) { ++ free_pages_exact(sk->write_page, s->write_size); ++ sk->write_page = NULL; ++ } ++ + free_pages_exact(s, s->read_size); + sk->s = NULL; + } +diff --git a/sound/usb/usx2y/usbus428ctldefs.h b/sound/usb/usx2y/usbus428ctldefs.h +index 5a7518ea3aeb4..7366a940ffbba 100644 +--- a/sound/usb/usx2y/usbus428ctldefs.h ++++ b/sound/usb/usx2y/usbus428ctldefs.h +@@ -4,28 +4,28 @@ + * Copyright (c) 2003 by Karsten Wiese + */ + +-enum E_In84{ +- eFader0 = 0, +- eFader1, +- eFader2, +- eFader3, +- eFader4, +- eFader5, +- eFader6, +- eFader7, +- eFaderM, +- eTransport, +- eModifier = 10, +- eFilterSelect, +- eSelect, +- eMute, ++enum E_IN84 { ++ E_FADER_0 = 0, ++ E_FADER_1, ++ E_FADER_2, ++ E_FADER_3, ++ E_FADER_4, ++ E_FADER_5, ++ E_FADER_6, ++ E_FADER_7, ++ E_FADER_M, ++ E_TRANSPORT, ++ E_MODIFIER = 10, ++ E_FILTER_SELECT, ++ E_SELECT, ++ E_MUTE, + +- eSwitch = 15, +- eWheelGain, +- eWheelFreq, +- eWheelQ, +- eWheelPan, +- eWheel = 20 ++ E_SWITCH = 15, ++ E_WHEEL_GAIN, ++ E_WHEEL_FREQ, ++ E_WHEEL_Q, ++ E_WHEEL_PAN, ++ E_WHEEL = 20 + }; + + #define T_RECORD 1 +@@ -39,53 +39,53 @@ enum E_In84{ + + + struct us428_ctls { +- unsigned char Fader[9]; +- unsigned char Transport; +- unsigned char Modifier; +- unsigned char FilterSelect; +- unsigned char Select; +- unsigned char Mute; +- unsigned char UNKNOWN; +- unsigned char Switch; +- unsigned char Wheel[5]; ++ unsigned char fader[9]; ++ unsigned char transport; ++ unsigned char modifier; ++ unsigned char filters_elect; ++ unsigned char select; ++ unsigned char mute; ++ unsigned char unknown; ++ unsigned char wswitch; ++ unsigned char wheel[5]; + }; + +-struct us428_setByte { +- unsigned char Offset, +- Value; ++struct us428_set_byte { ++ unsigned char offset, ++ value; + }; + + enum { +- eLT_Volume = 0, +- eLT_Light ++ ELT_VOLUME = 0, ++ ELT_LIGHT + }; + +-struct usX2Y_volume { +- unsigned char Channel, +- LH, +- LL, +- RH, +- RL; ++struct usx2y_volume { ++ unsigned char channel, ++ lh, ++ ll, ++ rh, ++ rl; + }; + + struct us428_lights { +- struct us428_setByte Light[7]; ++ struct us428_set_byte light[7]; + }; + + struct us428_p4out { + char type; + union { +- struct usX2Y_volume vol; ++ struct usx2y_volume vol; + struct us428_lights lights; + } val; + }; + +-#define N_us428_ctl_BUFS 16 +-#define N_us428_p4out_BUFS 16 +-struct us428ctls_sharedmem{ +- struct us428_ctls CtlSnapShot[N_us428_ctl_BUFS]; +- int CtlSnapShotDiffersAt[N_us428_ctl_BUFS]; +- int CtlSnapShotLast, CtlSnapShotRed; +- struct us428_p4out p4out[N_us428_p4out_BUFS]; +- int p4outLast, p4outSent; ++#define N_US428_CTL_BUFS 16 ++#define N_US428_P4OUT_BUFS 16 ++struct us428ctls_sharedmem { ++ struct us428_ctls ctl_snapshot[N_US428_CTL_BUFS]; ++ int ctl_snapshot_differs_at[N_US428_CTL_BUFS]; ++ int ctl_snapshot_last, ctl_snapshot_red; ++ struct us428_p4out p4out[N_US428_P4OUT_BUFS]; ++ int p4out_last, p4out_sent; + }; +diff --git a/sound/usb/usx2y/usbusx2y.c b/sound/usb/usx2y/usbusx2y.c +index 3cd28d24f0a73..cdbb27a96e040 100644 +--- a/sound/usb/usx2y/usbusx2y.c ++++ b/sound/usb/usx2y/usbusx2y.c +@@ -17,7 +17,7 @@ + + 2004-10-26 Karsten Wiese + Version 0.8.6: +- wake_up() process waiting in usX2Y_urbs_start() on error. ++ wake_up() process waiting in usx2y_urbs_start() on error. + + 2004-10-21 Karsten Wiese + Version 0.8.5: +@@ -48,7 +48,7 @@ + 2004-06-12 Karsten Wiese + Version 0.6.3: + Made it thus the following rule is enforced: +- "All pcm substreams of one usX2Y have to operate at the same rate & format." ++ "All pcm substreams of one usx2y have to operate at the same rate & format." + + 2004-04-06 Karsten Wiese + Version 0.6.0: +@@ -150,161 +150,161 @@ module_param_array(enable, bool, NULL, 0444); + MODULE_PARM_DESC(enable, "Enable "NAME_ALLCAPS"."); + + +-static int snd_usX2Y_card_used[SNDRV_CARDS]; ++static int snd_usx2y_card_used[SNDRV_CARDS]; + +-static void usX2Y_usb_disconnect(struct usb_device* usb_device, void* ptr); +-static void snd_usX2Y_card_private_free(struct snd_card *card); ++static void usx2y_usb_disconnect(struct usb_device* usb_device, void* ptr); ++static void snd_usx2y_card_private_free(struct snd_card *card); + + /* + * pipe 4 is used for switching the lamps, setting samplerate, volumes .... + */ +-static void i_usX2Y_Out04Int(struct urb *urb) ++static void i_usx2y_out04_int(struct urb *urb) + { + #ifdef CONFIG_SND_DEBUG + if (urb->status) { + int i; +- struct usX2Ydev *usX2Y = urb->context; +- for (i = 0; i < 10 && usX2Y->AS04.urb[i] != urb; i++); +- snd_printdd("i_usX2Y_Out04Int() urb %i status=%i\n", i, urb->status); ++ struct usx2ydev *usx2y = urb->context; ++ for (i = 0; i < 10 && usx2y->as04.urb[i] != urb; i++); ++ snd_printdd("i_usx2y_out04_int() urb %i status=%i\n", i, urb->status); + } + #endif + } + +-static void i_usX2Y_In04Int(struct urb *urb) ++static void i_usx2y_in04_int(struct urb *urb) + { + int err = 0; +- struct usX2Ydev *usX2Y = urb->context; +- struct us428ctls_sharedmem *us428ctls = usX2Y->us428ctls_sharedmem; ++ struct usx2ydev *usx2y = urb->context; ++ struct us428ctls_sharedmem *us428ctls = usx2y->us428ctls_sharedmem; + +- usX2Y->In04IntCalls++; ++ usx2y->in04_int_calls++; + + if (urb->status) { + snd_printdd("Interrupt Pipe 4 came back with status=%i\n", urb->status); + return; + } + +- // printk("%i:0x%02X ", 8, (int)((unsigned char*)usX2Y->In04Buf)[8]); Master volume shows 0 here if fader is at max during boot ?!? ++ // printk("%i:0x%02X ", 8, (int)((unsigned char*)usx2y->in04_buf)[8]); Master volume shows 0 here if fader is at max during boot ?!? + if (us428ctls) { + int diff = -1; +- if (-2 == us428ctls->CtlSnapShotLast) { ++ if (-2 == us428ctls->ctl_snapshot_last) { + diff = 0; +- memcpy(usX2Y->In04Last, usX2Y->In04Buf, sizeof(usX2Y->In04Last)); +- us428ctls->CtlSnapShotLast = -1; ++ memcpy(usx2y->in04_last, usx2y->in04_buf, sizeof(usx2y->in04_last)); ++ us428ctls->ctl_snapshot_last = -1; + } else { + int i; + for (i = 0; i < 21; i++) { +- if (usX2Y->In04Last[i] != ((char*)usX2Y->In04Buf)[i]) { ++ if (usx2y->in04_last[i] != ((char*)usx2y->in04_buf)[i]) { + if (diff < 0) + diff = i; +- usX2Y->In04Last[i] = ((char*)usX2Y->In04Buf)[i]; ++ usx2y->in04_last[i] = ((char*)usx2y->in04_buf)[i]; + } + } + } + if (0 <= diff) { +- int n = us428ctls->CtlSnapShotLast + 1; +- if (n >= N_us428_ctl_BUFS || n < 0) ++ int n = us428ctls->ctl_snapshot_last + 1; ++ if (n >= N_US428_CTL_BUFS || n < 0) + n = 0; +- memcpy(us428ctls->CtlSnapShot + n, usX2Y->In04Buf, sizeof(us428ctls->CtlSnapShot[0])); +- us428ctls->CtlSnapShotDiffersAt[n] = diff; +- us428ctls->CtlSnapShotLast = n; +- wake_up(&usX2Y->us428ctls_wait_queue_head); ++ memcpy(us428ctls->ctl_snapshot + n, usx2y->in04_buf, sizeof(us428ctls->ctl_snapshot[0])); ++ us428ctls->ctl_snapshot_differs_at[n] = diff; ++ us428ctls->ctl_snapshot_last = n; ++ wake_up(&usx2y->us428ctls_wait_queue_head); + } + } + + +- if (usX2Y->US04) { +- if (0 == usX2Y->US04->submitted) ++ if (usx2y->us04) { ++ if (0 == usx2y->us04->submitted) + do { +- err = usb_submit_urb(usX2Y->US04->urb[usX2Y->US04->submitted++], GFP_ATOMIC); +- } while (!err && usX2Y->US04->submitted < usX2Y->US04->len); ++ err = usb_submit_urb(usx2y->us04->urb[usx2y->us04->submitted++], GFP_ATOMIC); ++ } while (!err && usx2y->us04->submitted < usx2y->us04->len); + } else +- if (us428ctls && us428ctls->p4outLast >= 0 && us428ctls->p4outLast < N_us428_p4out_BUFS) { +- if (us428ctls->p4outLast != us428ctls->p4outSent) { +- int j, send = us428ctls->p4outSent + 1; +- if (send >= N_us428_p4out_BUFS) ++ if (us428ctls && us428ctls->p4out_last >= 0 && us428ctls->p4out_last < N_US428_P4OUT_BUFS) { ++ if (us428ctls->p4out_last != us428ctls->p4out_sent) { ++ int j, send = us428ctls->p4out_sent + 1; ++ if (send >= N_US428_P4OUT_BUFS) + send = 0; +- for (j = 0; j < URBS_AsyncSeq && !err; ++j) +- if (0 == usX2Y->AS04.urb[j]->status) { ++ for (j = 0; j < URBS_ASYNC_SEQ && !err; ++j) ++ if (0 == usx2y->as04.urb[j]->status) { + struct us428_p4out *p4out = us428ctls->p4out + send; // FIXME if more than 1 p4out is new, 1 gets lost. +- usb_fill_bulk_urb(usX2Y->AS04.urb[j], usX2Y->dev, +- usb_sndbulkpipe(usX2Y->dev, 0x04), &p4out->val.vol, +- p4out->type == eLT_Light ? sizeof(struct us428_lights) : 5, +- i_usX2Y_Out04Int, usX2Y); +- err = usb_submit_urb(usX2Y->AS04.urb[j], GFP_ATOMIC); +- us428ctls->p4outSent = send; ++ usb_fill_bulk_urb(usx2y->as04.urb[j], usx2y->dev, ++ usb_sndbulkpipe(usx2y->dev, 0x04), &p4out->val.vol, ++ p4out->type == ELT_LIGHT ? sizeof(struct us428_lights) : 5, ++ i_usx2y_out04_int, usx2y); ++ err = usb_submit_urb(usx2y->as04.urb[j], GFP_ATOMIC); ++ us428ctls->p4out_sent = send; + break; + } + } + } + + if (err) +- snd_printk(KERN_ERR "In04Int() usb_submit_urb err=%i\n", err); ++ snd_printk(KERN_ERR "in04_int() usb_submit_urb err=%i\n", err); + +- urb->dev = usX2Y->dev; ++ urb->dev = usx2y->dev; + usb_submit_urb(urb, GFP_ATOMIC); + } + + /* + * Prepare some urbs + */ +-int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y) ++int usx2y_async_seq04_init(struct usx2ydev *usx2y) + { + int err = 0, + i; + +- usX2Y->AS04.buffer = kmalloc_array(URBS_AsyncSeq, +- URB_DataLen_AsyncSeq, GFP_KERNEL); +- if (NULL == usX2Y->AS04.buffer) { ++ usx2y->as04.buffer = kmalloc_array(URBS_ASYNC_SEQ, ++ URB_DATA_LEN_ASYNC_SEQ, GFP_KERNEL); ++ if (NULL == usx2y->as04.buffer) { + err = -ENOMEM; + } else +- for (i = 0; i < URBS_AsyncSeq; ++i) { +- if (NULL == (usX2Y->AS04.urb[i] = usb_alloc_urb(0, GFP_KERNEL))) { ++ for (i = 0; i < URBS_ASYNC_SEQ; ++i) { ++ if (NULL == (usx2y->as04.urb[i] = usb_alloc_urb(0, GFP_KERNEL))) { + err = -ENOMEM; + break; + } +- usb_fill_bulk_urb( usX2Y->AS04.urb[i], usX2Y->dev, +- usb_sndbulkpipe(usX2Y->dev, 0x04), +- usX2Y->AS04.buffer + URB_DataLen_AsyncSeq*i, 0, +- i_usX2Y_Out04Int, usX2Y ++ usb_fill_bulk_urb( usx2y->as04.urb[i], usx2y->dev, ++ usb_sndbulkpipe(usx2y->dev, 0x04), ++ usx2y->as04.buffer + URB_DATA_LEN_ASYNC_SEQ*i, 0, ++ i_usx2y_out04_int, usx2y + ); +- err = usb_urb_ep_type_check(usX2Y->AS04.urb[i]); ++ err = usb_urb_ep_type_check(usx2y->as04.urb[i]); + if (err < 0) + break; + } + return err; + } + +-int usX2Y_In04_init(struct usX2Ydev *usX2Y) ++int usx2y_in04_init(struct usx2ydev *usx2y) + { +- if (! (usX2Y->In04urb = usb_alloc_urb(0, GFP_KERNEL))) ++ if (! (usx2y->in04_urb = usb_alloc_urb(0, GFP_KERNEL))) + return -ENOMEM; + +- if (! (usX2Y->In04Buf = kmalloc(21, GFP_KERNEL))) ++ if (! (usx2y->in04_buf = kmalloc(21, GFP_KERNEL))) + return -ENOMEM; + +- init_waitqueue_head(&usX2Y->In04WaitQueue); +- usb_fill_int_urb(usX2Y->In04urb, usX2Y->dev, usb_rcvintpipe(usX2Y->dev, 0x4), +- usX2Y->In04Buf, 21, +- i_usX2Y_In04Int, usX2Y, ++ init_waitqueue_head(&usx2y->in04_wait_queue); ++ usb_fill_int_urb(usx2y->in04_urb, usx2y->dev, usb_rcvintpipe(usx2y->dev, 0x4), ++ usx2y->in04_buf, 21, ++ i_usx2y_in04_int, usx2y, + 10); +- if (usb_urb_ep_type_check(usX2Y->In04urb)) ++ if (usb_urb_ep_type_check(usx2y->in04_urb)) + return -EINVAL; +- return usb_submit_urb(usX2Y->In04urb, GFP_KERNEL); ++ return usb_submit_urb(usx2y->in04_urb, GFP_KERNEL); + } + +-static void usX2Y_unlinkSeq(struct snd_usX2Y_AsyncSeq *S) ++static void usx2y_unlinkseq(struct snd_usx2y_async_seq *s) + { + int i; +- for (i = 0; i < URBS_AsyncSeq; ++i) { +- usb_kill_urb(S->urb[i]); +- usb_free_urb(S->urb[i]); +- S->urb[i] = NULL; ++ for (i = 0; i < URBS_ASYNC_SEQ; ++i) { ++ usb_kill_urb(s->urb[i]); ++ usb_free_urb(s->urb[i]); ++ s->urb[i] = NULL; + } +- kfree(S->buffer); ++ kfree(s->buffer); + } + + +-static const struct usb_device_id snd_usX2Y_usb_id_table[] = { ++static const struct usb_device_id snd_usx2y_usb_id_table[] = { + { + .match_flags = USB_DEVICE_ID_MATCH_DEVICE, + .idVendor = 0x1604, +@@ -323,7 +323,7 @@ static const struct usb_device_id snd_usX2Y_usb_id_table[] = { + { /* terminator */ } + }; + +-static int usX2Y_create_card(struct usb_device *device, ++static int usx2y_create_card(struct usb_device *device, + struct usb_interface *intf, + struct snd_card **cardp) + { +@@ -332,20 +332,20 @@ static int usX2Y_create_card(struct usb_device *device, + int err; + + for (dev = 0; dev < SNDRV_CARDS; ++dev) +- if (enable[dev] && !snd_usX2Y_card_used[dev]) ++ if (enable[dev] && !snd_usx2y_card_used[dev]) + break; + if (dev >= SNDRV_CARDS) + return -ENODEV; + err = snd_card_new(&intf->dev, index[dev], id[dev], THIS_MODULE, +- sizeof(struct usX2Ydev), &card); ++ sizeof(struct usx2ydev), &card); + if (err < 0) + return err; +- snd_usX2Y_card_used[usX2Y(card)->card_index = dev] = 1; +- card->private_free = snd_usX2Y_card_private_free; +- usX2Y(card)->dev = device; +- init_waitqueue_head(&usX2Y(card)->prepare_wait_queue); +- mutex_init(&usX2Y(card)->pcm_mutex); +- INIT_LIST_HEAD(&usX2Y(card)->midi_list); ++ snd_usx2y_card_used[usx2y(card)->card_index = dev] = 1; ++ card->private_free = snd_usx2y_card_private_free; ++ usx2y(card)->dev = device; ++ init_waitqueue_head(&usx2y(card)->prepare_wait_queue); ++ mutex_init(&usx2y(card)->pcm_mutex); ++ INIT_LIST_HEAD(&usx2y(card)->midi_list); + strcpy(card->driver, "USB "NAME_ALLCAPS""); + sprintf(card->shortname, "TASCAM "NAME_ALLCAPS""); + sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)", +@@ -353,14 +353,14 @@ static int usX2Y_create_card(struct usb_device *device, + le16_to_cpu(device->descriptor.idVendor), + le16_to_cpu(device->descriptor.idProduct), + 0,//us428(card)->usbmidi.ifnum, +- usX2Y(card)->dev->bus->busnum, usX2Y(card)->dev->devnum ++ usx2y(card)->dev->bus->busnum, usx2y(card)->dev->devnum + ); + *cardp = card; + return 0; + } + + +-static int usX2Y_usb_probe(struct usb_device *device, ++static int usx2y_usb_probe(struct usb_device *device, + struct usb_interface *intf, + const struct usb_device_id *device_id, + struct snd_card **cardp) +@@ -375,10 +375,10 @@ static int usX2Y_usb_probe(struct usb_device *device, + le16_to_cpu(device->descriptor.idProduct) != USB_ID_US428)) + return -EINVAL; + +- err = usX2Y_create_card(device, intf, &card); ++ err = usx2y_create_card(device, intf, &card); + if (err < 0) + return err; +- if ((err = usX2Y_hwdep_new(card, device)) < 0 || ++ if ((err = usx2y_hwdep_new(card, device)) < 0 || + (err = snd_card_register(card)) < 0) { + snd_card_free(card); + return err; +@@ -390,64 +390,64 @@ static int usX2Y_usb_probe(struct usb_device *device, + /* + * new 2.5 USB kernel API + */ +-static int snd_usX2Y_probe(struct usb_interface *intf, const struct usb_device_id *id) ++static int snd_usx2y_probe(struct usb_interface *intf, const struct usb_device_id *id) + { + struct snd_card *card; + int err; + +- err = usX2Y_usb_probe(interface_to_usbdev(intf), intf, id, &card); ++ err = usx2y_usb_probe(interface_to_usbdev(intf), intf, id, &card); + if (err < 0) + return err; + dev_set_drvdata(&intf->dev, card); + return 0; + } + +-static void snd_usX2Y_disconnect(struct usb_interface *intf) ++static void snd_usx2y_disconnect(struct usb_interface *intf) + { +- usX2Y_usb_disconnect(interface_to_usbdev(intf), ++ usx2y_usb_disconnect(interface_to_usbdev(intf), + usb_get_intfdata(intf)); + } + +-MODULE_DEVICE_TABLE(usb, snd_usX2Y_usb_id_table); +-static struct usb_driver snd_usX2Y_usb_driver = { ++MODULE_DEVICE_TABLE(usb, snd_usx2y_usb_id_table); ++static struct usb_driver snd_usx2y_usb_driver = { + .name = "snd-usb-usx2y", +- .probe = snd_usX2Y_probe, +- .disconnect = snd_usX2Y_disconnect, +- .id_table = snd_usX2Y_usb_id_table, ++ .probe = snd_usx2y_probe, ++ .disconnect = snd_usx2y_disconnect, ++ .id_table = snd_usx2y_usb_id_table, + }; + +-static void snd_usX2Y_card_private_free(struct snd_card *card) ++static void snd_usx2y_card_private_free(struct snd_card *card) + { +- kfree(usX2Y(card)->In04Buf); +- usb_free_urb(usX2Y(card)->In04urb); +- if (usX2Y(card)->us428ctls_sharedmem) +- free_pages_exact(usX2Y(card)->us428ctls_sharedmem, +- sizeof(*usX2Y(card)->us428ctls_sharedmem)); +- if (usX2Y(card)->card_index >= 0 && usX2Y(card)->card_index < SNDRV_CARDS) +- snd_usX2Y_card_used[usX2Y(card)->card_index] = 0; ++ kfree(usx2y(card)->in04_buf); ++ usb_free_urb(usx2y(card)->in04_urb); ++ if (usx2y(card)->us428ctls_sharedmem) ++ free_pages_exact(usx2y(card)->us428ctls_sharedmem, ++ sizeof(*usx2y(card)->us428ctls_sharedmem)); ++ if (usx2y(card)->card_index >= 0 && usx2y(card)->card_index < SNDRV_CARDS) ++ snd_usx2y_card_used[usx2y(card)->card_index] = 0; + } + + /* + * Frees the device. + */ +-static void usX2Y_usb_disconnect(struct usb_device *device, void* ptr) ++static void usx2y_usb_disconnect(struct usb_device *device, void* ptr) + { + if (ptr) { + struct snd_card *card = ptr; +- struct usX2Ydev *usX2Y = usX2Y(card); ++ struct usx2ydev *usx2y = usx2y(card); + struct list_head *p; +- usX2Y->chip_status = USX2Y_STAT_CHIP_HUP; +- usX2Y_unlinkSeq(&usX2Y->AS04); +- usb_kill_urb(usX2Y->In04urb); ++ usx2y->chip_status = USX2Y_STAT_CHIP_HUP; ++ usx2y_unlinkseq(&usx2y->as04); ++ usb_kill_urb(usx2y->in04_urb); + snd_card_disconnect(card); + /* release the midi resources */ +- list_for_each(p, &usX2Y->midi_list) { ++ list_for_each(p, &usx2y->midi_list) { + snd_usbmidi_disconnect(p); + } +- if (usX2Y->us428ctls_sharedmem) +- wake_up(&usX2Y->us428ctls_wait_queue_head); ++ if (usx2y->us428ctls_sharedmem) ++ wake_up(&usx2y->us428ctls_wait_queue_head); + snd_card_free(card); + } + } + +-module_usb_driver(snd_usX2Y_usb_driver); ++module_usb_driver(snd_usx2y_usb_driver); +diff --git a/sound/usb/usx2y/usbusx2y.h b/sound/usb/usx2y/usbusx2y.h +index 144b85f57bd2a..c330af628bccd 100644 +--- a/sound/usb/usx2y/usbusx2y.h ++++ b/sound/usb/usx2y/usbusx2y.h +@@ -8,14 +8,14 @@ + #define NRURBS 2 + + +-#define URBS_AsyncSeq 10 +-#define URB_DataLen_AsyncSeq 32 +-struct snd_usX2Y_AsyncSeq { +- struct urb *urb[URBS_AsyncSeq]; ++#define URBS_ASYNC_SEQ 10 ++#define URB_DATA_LEN_ASYNC_SEQ 32 ++struct snd_usx2y_async_seq { ++ struct urb *urb[URBS_ASYNC_SEQ]; + char *buffer; + }; + +-struct snd_usX2Y_urbSeq { ++struct snd_usx2y_urb_seq { + int submitted; + int len; + struct urb *urb[]; +@@ -23,17 +23,17 @@ struct snd_usX2Y_urbSeq { + + #include "usx2yhwdeppcm.h" + +-struct usX2Ydev { ++struct usx2ydev { + struct usb_device *dev; + int card_index; + int stride; +- struct urb *In04urb; +- void *In04Buf; +- char In04Last[24]; +- unsigned In04IntCalls; +- struct snd_usX2Y_urbSeq *US04; +- wait_queue_head_t In04WaitQueue; +- struct snd_usX2Y_AsyncSeq AS04; ++ struct urb *in04_urb; ++ void *in04_buf; ++ char in04_last[24]; ++ unsigned in04_int_calls; ++ struct snd_usx2y_urb_seq *us04; ++ wait_queue_head_t in04_wait_queue; ++ struct snd_usx2y_async_seq as04; + unsigned int rate, + format; + int chip_status; +@@ -41,9 +41,9 @@ struct usX2Ydev { + struct us428ctls_sharedmem *us428ctls_sharedmem; + int wait_iso_frame; + wait_queue_head_t us428ctls_wait_queue_head; +- struct snd_usX2Y_hwdep_pcm_shm *hwdep_pcm_shm; +- struct snd_usX2Y_substream *subs[4]; +- struct snd_usX2Y_substream * volatile prepare_subs; ++ struct snd_usx2y_hwdep_pcm_shm *hwdep_pcm_shm; ++ struct snd_usx2y_substream *subs[4]; ++ struct snd_usx2y_substream * volatile prepare_subs; + wait_queue_head_t prepare_wait_queue; + struct list_head midi_list; + struct list_head pcm_list; +@@ -51,21 +51,21 @@ struct usX2Ydev { + }; + + +-struct snd_usX2Y_substream { +- struct usX2Ydev *usX2Y; ++struct snd_usx2y_substream { ++ struct usx2ydev *usx2y; + struct snd_pcm_substream *pcm_substream; + + int endpoint; + unsigned int maxpacksize; /* max packet size in bytes */ + + atomic_t state; +-#define state_STOPPED 0 +-#define state_STARTING1 1 +-#define state_STARTING2 2 +-#define state_STARTING3 3 +-#define state_PREPARED 4 +-#define state_PRERUNNING 6 +-#define state_RUNNING 8 ++#define STATE_STOPPED 0 ++#define STATE_STARTING1 1 ++#define STATE_STARTING2 2 ++#define STATE_STARTING3 3 ++#define STATE_PREPARED 4 ++#define STATE_PRERUNNING 6 ++#define STATE_RUNNING 8 + + int hwptr; /* free frame position in the buffer (only for playback) */ + int hwptr_done; /* processed frame position in the buffer */ +@@ -77,12 +77,12 @@ struct snd_usX2Y_substream { + }; + + +-#define usX2Y(c) ((struct usX2Ydev *)(c)->private_data) ++#define usx2y(c) ((struct usx2ydev *)(c)->private_data) + +-int usX2Y_audio_create(struct snd_card *card); ++int usx2y_audio_create(struct snd_card *card); + +-int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y); +-int usX2Y_In04_init(struct usX2Ydev *usX2Y); ++int usx2y_async_seq04_init(struct usx2ydev *usx2y); ++int usx2y_in04_init(struct usx2ydev *usx2y); + + #define NAME_ALLCAPS "US-X2Y" + +diff --git a/sound/usb/usx2y/usbusx2yaudio.c b/sound/usb/usx2y/usbusx2yaudio.c +index ecaf41265dcd0..8033bb7255d5c 100644 +--- a/sound/usb/usx2y/usbusx2yaudio.c ++++ b/sound/usb/usx2y/usbusx2yaudio.c +@@ -54,13 +54,13 @@ + #endif + + +-static int usX2Y_urb_capt_retire(struct snd_usX2Y_substream *subs) ++static int usx2y_urb_capt_retire(struct snd_usx2y_substream *subs) + { + struct urb *urb = subs->completed_urb; + struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; + unsigned char *cp; + int i, len, lens = 0, hwptr_done = subs->hwptr_done; +- struct usX2Ydev *usX2Y = subs->usX2Y; ++ struct usx2ydev *usx2y = subs->usx2y; + + for (i = 0; i < nr_of_packs(); i++) { + cp = (unsigned char*)urb->transfer_buffer + urb->iso_frame_desc[i].offset; +@@ -70,7 +70,7 @@ static int usX2Y_urb_capt_retire(struct snd_usX2Y_substream *subs) + urb->iso_frame_desc[i].status); + return urb->iso_frame_desc[i].status; + } +- len = urb->iso_frame_desc[i].actual_length / usX2Y->stride; ++ len = urb->iso_frame_desc[i].actual_length / usx2y->stride; + if (! len) { + snd_printd("0 == len ERROR!\n"); + continue; +@@ -79,12 +79,12 @@ static int usX2Y_urb_capt_retire(struct snd_usX2Y_substream *subs) + /* copy a data chunk */ + if ((hwptr_done + len) > runtime->buffer_size) { + int cnt = runtime->buffer_size - hwptr_done; +- int blen = cnt * usX2Y->stride; +- memcpy(runtime->dma_area + hwptr_done * usX2Y->stride, cp, blen); +- memcpy(runtime->dma_area, cp + blen, len * usX2Y->stride - blen); ++ int blen = cnt * usx2y->stride; ++ memcpy(runtime->dma_area + hwptr_done * usx2y->stride, cp, blen); ++ memcpy(runtime->dma_area, cp + blen, len * usx2y->stride - blen); + } else { +- memcpy(runtime->dma_area + hwptr_done * usX2Y->stride, cp, +- len * usX2Y->stride); ++ memcpy(runtime->dma_area + hwptr_done * usx2y->stride, cp, ++ len * usx2y->stride); + } + lens += len; + if ((hwptr_done += len) >= runtime->buffer_size) +@@ -110,18 +110,18 @@ static int usX2Y_urb_capt_retire(struct snd_usX2Y_substream *subs) + * it directly from the buffer. thus the data is once copied to + * a temporary buffer and urb points to that. + */ +-static int usX2Y_urb_play_prepare(struct snd_usX2Y_substream *subs, ++static int usx2y_urb_play_prepare(struct snd_usx2y_substream *subs, + struct urb *cap_urb, + struct urb *urb) + { + int count, counts, pack; +- struct usX2Ydev *usX2Y = subs->usX2Y; ++ struct usx2ydev *usx2y = subs->usx2y; + struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; + + count = 0; + for (pack = 0; pack < nr_of_packs(); pack++) { + /* calculate the size of a packet */ +- counts = cap_urb->iso_frame_desc[pack].actual_length / usX2Y->stride; ++ counts = cap_urb->iso_frame_desc[pack].actual_length / usx2y->stride; + count += counts; + if (counts < 43 || counts > 50) { + snd_printk(KERN_ERR "should not be here with counts=%i\n", counts); +@@ -134,7 +134,7 @@ static int usX2Y_urb_play_prepare(struct snd_usX2Y_substream *subs, + 0; + urb->iso_frame_desc[pack].length = cap_urb->iso_frame_desc[pack].actual_length; + } +- if (atomic_read(&subs->state) >= state_PRERUNNING) ++ if (atomic_read(&subs->state) >= STATE_PRERUNNING) + if (subs->hwptr + count > runtime->buffer_size) { + /* err, the transferred area goes over buffer boundary. + * copy the data to the temp buffer. +@@ -143,20 +143,20 @@ static int usX2Y_urb_play_prepare(struct snd_usX2Y_substream *subs, + len = runtime->buffer_size - subs->hwptr; + urb->transfer_buffer = subs->tmpbuf; + memcpy(subs->tmpbuf, runtime->dma_area + +- subs->hwptr * usX2Y->stride, len * usX2Y->stride); +- memcpy(subs->tmpbuf + len * usX2Y->stride, +- runtime->dma_area, (count - len) * usX2Y->stride); ++ subs->hwptr * usx2y->stride, len * usx2y->stride); ++ memcpy(subs->tmpbuf + len * usx2y->stride, ++ runtime->dma_area, (count - len) * usx2y->stride); + subs->hwptr += count; + subs->hwptr -= runtime->buffer_size; + } else { + /* set the buffer pointer */ +- urb->transfer_buffer = runtime->dma_area + subs->hwptr * usX2Y->stride; ++ urb->transfer_buffer = runtime->dma_area + subs->hwptr * usx2y->stride; + if ((subs->hwptr += count) >= runtime->buffer_size) + subs->hwptr -= runtime->buffer_size; + } + else + urb->transfer_buffer = subs->tmpbuf; +- urb->transfer_buffer_length = count * usX2Y->stride; ++ urb->transfer_buffer_length = count * usx2y->stride; + return 0; + } + +@@ -165,10 +165,10 @@ static int usX2Y_urb_play_prepare(struct snd_usX2Y_substream *subs, + * + * update the current position and call callback if a period is processed. + */ +-static void usX2Y_urb_play_retire(struct snd_usX2Y_substream *subs, struct urb *urb) ++static void usx2y_urb_play_retire(struct snd_usx2y_substream *subs, struct urb *urb) + { + struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; +- int len = urb->actual_length / subs->usX2Y->stride; ++ int len = urb->actual_length / subs->usx2y->stride; + + subs->transfer_done += len; + subs->hwptr_done += len; +@@ -180,14 +180,14 @@ static void usX2Y_urb_play_retire(struct snd_usX2Y_substream *subs, struct urb * + } + } + +-static int usX2Y_urb_submit(struct snd_usX2Y_substream *subs, struct urb *urb, int frame) ++static int usx2y_urb_submit(struct snd_usx2y_substream *subs, struct urb *urb, int frame) + { + int err; + if (!urb) + return -ENODEV; + urb->start_frame = (frame + NRURBS * nr_of_packs()); // let hcd do rollover sanity checks + urb->hcpriv = NULL; +- urb->dev = subs->usX2Y->dev; /* we need to set this at each time */ ++ urb->dev = subs->usx2y->dev; /* we need to set this at each time */ + if ((err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) { + snd_printk(KERN_ERR "usb_submit_urb() returned %i\n", err); + return err; +@@ -195,8 +195,8 @@ static int usX2Y_urb_submit(struct snd_usX2Y_substream *subs, struct urb *urb, i + return 0; + } + +-static inline int usX2Y_usbframe_complete(struct snd_usX2Y_substream *capsubs, +- struct snd_usX2Y_substream *playbacksubs, ++static inline int usx2y_usbframe_complete(struct snd_usx2y_substream *capsubs, ++ struct snd_usx2y_substream *playbacksubs, + int frame) + { + int err, state; +@@ -204,25 +204,25 @@ static inline int usX2Y_usbframe_complete(struct snd_usX2Y_substream *capsubs, + + state = atomic_read(&playbacksubs->state); + if (NULL != urb) { +- if (state == state_RUNNING) +- usX2Y_urb_play_retire(playbacksubs, urb); +- else if (state >= state_PRERUNNING) ++ if (state == STATE_RUNNING) ++ usx2y_urb_play_retire(playbacksubs, urb); ++ else if (state >= STATE_PRERUNNING) + atomic_inc(&playbacksubs->state); + } else { + switch (state) { +- case state_STARTING1: ++ case STATE_STARTING1: + urb = playbacksubs->urb[0]; + atomic_inc(&playbacksubs->state); + break; +- case state_STARTING2: ++ case STATE_STARTING2: + urb = playbacksubs->urb[1]; + atomic_inc(&playbacksubs->state); + break; + } + } + if (urb) { +- if ((err = usX2Y_urb_play_prepare(playbacksubs, capsubs->completed_urb, urb)) || +- (err = usX2Y_urb_submit(playbacksubs, urb, frame))) { ++ if ((err = usx2y_urb_play_prepare(playbacksubs, capsubs->completed_urb, urb)) || ++ (err = usx2y_urb_submit(playbacksubs, urb, frame))) { + return err; + } + } +@@ -230,13 +230,13 @@ static inline int usX2Y_usbframe_complete(struct snd_usX2Y_substream *capsubs, + playbacksubs->completed_urb = NULL; + + state = atomic_read(&capsubs->state); +- if (state >= state_PREPARED) { +- if (state == state_RUNNING) { +- if ((err = usX2Y_urb_capt_retire(capsubs))) ++ if (state >= STATE_PREPARED) { ++ if (state == STATE_RUNNING) { ++ if ((err = usx2y_urb_capt_retire(capsubs))) + return err; +- } else if (state >= state_PRERUNNING) ++ } else if (state >= STATE_PRERUNNING) + atomic_inc(&capsubs->state); +- if ((err = usX2Y_urb_submit(capsubs, capsubs->completed_urb, frame))) ++ if ((err = usx2y_urb_submit(capsubs, capsubs->completed_urb, frame))) + return err; + } + capsubs->completed_urb = NULL; +@@ -244,21 +244,21 @@ static inline int usX2Y_usbframe_complete(struct snd_usX2Y_substream *capsubs, + } + + +-static void usX2Y_clients_stop(struct usX2Ydev *usX2Y) ++static void usx2y_clients_stop(struct usx2ydev *usx2y) + { + int s, u; + + for (s = 0; s < 4; s++) { +- struct snd_usX2Y_substream *subs = usX2Y->subs[s]; ++ struct snd_usx2y_substream *subs = usx2y->subs[s]; + if (subs) { + snd_printdd("%i %p state=%i\n", s, subs, atomic_read(&subs->state)); +- atomic_set(&subs->state, state_STOPPED); ++ atomic_set(&subs->state, STATE_STOPPED); + } + } + for (s = 0; s < 4; s++) { +- struct snd_usX2Y_substream *subs = usX2Y->subs[s]; ++ struct snd_usx2y_substream *subs = usx2y->subs[s]; + if (subs) { +- if (atomic_read(&subs->state) >= state_PRERUNNING) ++ if (atomic_read(&subs->state) >= STATE_PRERUNNING) + snd_pcm_stop_xrun(subs->pcm_substream); + for (u = 0; u < NRURBS; u++) { + struct urb *urb = subs->urb[u]; +@@ -268,60 +268,60 @@ static void usX2Y_clients_stop(struct usX2Ydev *usX2Y) + } + } + } +- usX2Y->prepare_subs = NULL; +- wake_up(&usX2Y->prepare_wait_queue); ++ usx2y->prepare_subs = NULL; ++ wake_up(&usx2y->prepare_wait_queue); + } + +-static void usX2Y_error_urb_status(struct usX2Ydev *usX2Y, +- struct snd_usX2Y_substream *subs, struct urb *urb) ++static void usx2y_error_urb_status(struct usx2ydev *usx2y, ++ struct snd_usx2y_substream *subs, struct urb *urb) + { + snd_printk(KERN_ERR "ep=%i stalled with status=%i\n", subs->endpoint, urb->status); + urb->status = 0; +- usX2Y_clients_stop(usX2Y); ++ usx2y_clients_stop(usx2y); + } + +-static void i_usX2Y_urb_complete(struct urb *urb) ++static void i_usx2y_urb_complete(struct urb *urb) + { +- struct snd_usX2Y_substream *subs = urb->context; +- struct usX2Ydev *usX2Y = subs->usX2Y; ++ struct snd_usx2y_substream *subs = urb->context; ++ struct usx2ydev *usx2y = subs->usx2y; + +- if (unlikely(atomic_read(&subs->state) < state_PREPARED)) { ++ if (unlikely(atomic_read(&subs->state) < STATE_PREPARED)) { + snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", +- usb_get_current_frame_number(usX2Y->dev), ++ usb_get_current_frame_number(usx2y->dev), + subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", + urb->status, urb->start_frame); + return; + } + if (unlikely(urb->status)) { +- usX2Y_error_urb_status(usX2Y, subs, urb); ++ usx2y_error_urb_status(usx2y, subs, urb); + return; + } + + subs->completed_urb = urb; + + { +- struct snd_usX2Y_substream *capsubs = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE], +- *playbacksubs = usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; ++ struct snd_usx2y_substream *capsubs = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE], ++ *playbacksubs = usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; + if (capsubs->completed_urb && +- atomic_read(&capsubs->state) >= state_PREPARED && ++ atomic_read(&capsubs->state) >= STATE_PREPARED && + (playbacksubs->completed_urb || +- atomic_read(&playbacksubs->state) < state_PREPARED)) { +- if (!usX2Y_usbframe_complete(capsubs, playbacksubs, urb->start_frame)) +- usX2Y->wait_iso_frame += nr_of_packs(); ++ atomic_read(&playbacksubs->state) < STATE_PREPARED)) { ++ if (!usx2y_usbframe_complete(capsubs, playbacksubs, urb->start_frame)) ++ usx2y->wait_iso_frame += nr_of_packs(); + else { + snd_printdd("\n"); +- usX2Y_clients_stop(usX2Y); ++ usx2y_clients_stop(usx2y); + } + } + } + } + +-static void usX2Y_urbs_set_complete(struct usX2Ydev * usX2Y, ++static void usx2y_urbs_set_complete(struct usx2ydev * usx2y, + void (*complete)(struct urb *)) + { + int s, u; + for (s = 0; s < 4; s++) { +- struct snd_usX2Y_substream *subs = usX2Y->subs[s]; ++ struct snd_usx2y_substream *subs = usx2y->subs[s]; + if (NULL != subs) + for (u = 0; u < NRURBS; u++) { + struct urb * urb = subs->urb[u]; +@@ -331,30 +331,30 @@ static void usX2Y_urbs_set_complete(struct usX2Ydev * usX2Y, + } + } + +-static void usX2Y_subs_startup_finish(struct usX2Ydev * usX2Y) ++static void usx2y_subs_startup_finish(struct usx2ydev * usx2y) + { +- usX2Y_urbs_set_complete(usX2Y, i_usX2Y_urb_complete); +- usX2Y->prepare_subs = NULL; ++ usx2y_urbs_set_complete(usx2y, i_usx2y_urb_complete); ++ usx2y->prepare_subs = NULL; + } + +-static void i_usX2Y_subs_startup(struct urb *urb) ++static void i_usx2y_subs_startup(struct urb *urb) + { +- struct snd_usX2Y_substream *subs = urb->context; +- struct usX2Ydev *usX2Y = subs->usX2Y; +- struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs; ++ struct snd_usx2y_substream *subs = urb->context; ++ struct usx2ydev *usx2y = subs->usx2y; ++ struct snd_usx2y_substream *prepare_subs = usx2y->prepare_subs; + if (NULL != prepare_subs) + if (urb->start_frame == prepare_subs->urb[0]->start_frame) { +- usX2Y_subs_startup_finish(usX2Y); ++ usx2y_subs_startup_finish(usx2y); + atomic_inc(&prepare_subs->state); +- wake_up(&usX2Y->prepare_wait_queue); ++ wake_up(&usx2y->prepare_wait_queue); + } + +- i_usX2Y_urb_complete(urb); ++ i_usx2y_urb_complete(urb); + } + +-static void usX2Y_subs_prepare(struct snd_usX2Y_substream *subs) ++static void usx2y_subs_prepare(struct snd_usx2y_substream *subs) + { +- snd_printdd("usX2Y_substream_prepare(%p) ep=%i urb0=%p urb1=%p\n", ++ snd_printdd("usx2y_substream_prepare(%p) ep=%i urb0=%p urb1=%p\n", + subs, subs->endpoint, subs->urb[0], subs->urb[1]); + /* reset the pointer */ + subs->hwptr = 0; +@@ -363,7 +363,7 @@ static void usX2Y_subs_prepare(struct snd_usX2Y_substream *subs) + } + + +-static void usX2Y_urb_release(struct urb **urb, int free_tb) ++static void usx2y_urb_release(struct urb **urb, int free_tb) + { + if (*urb) { + usb_kill_urb(*urb); +@@ -376,13 +376,13 @@ static void usX2Y_urb_release(struct urb **urb, int free_tb) + /* + * release a substreams urbs + */ +-static void usX2Y_urbs_release(struct snd_usX2Y_substream *subs) ++static void usx2y_urbs_release(struct snd_usx2y_substream *subs) + { + int i; +- snd_printdd("usX2Y_urbs_release() %i\n", subs->endpoint); ++ snd_printdd("usx2y_urbs_release() %i\n", subs->endpoint); + for (i = 0; i < NRURBS; i++) +- usX2Y_urb_release(subs->urb + i, +- subs != subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]); ++ usx2y_urb_release(subs->urb + i, ++ subs != subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]); + + kfree(subs->tmpbuf); + subs->tmpbuf = NULL; +@@ -390,12 +390,12 @@ static void usX2Y_urbs_release(struct snd_usX2Y_substream *subs) + /* + * initialize a substream's urbs + */ +-static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs) ++static int usx2y_urbs_allocate(struct snd_usx2y_substream *subs) + { + int i; + unsigned int pipe; +- int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; +- struct usb_device *dev = subs->usX2Y->dev; ++ int is_playback = subs == subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; ++ struct usb_device *dev = subs->usx2y->dev; + + pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) : + usb_rcvisocpipe(dev, subs->endpoint); +@@ -417,7 +417,7 @@ static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs) + } + *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL); + if (NULL == *purb) { +- usX2Y_urbs_release(subs); ++ usx2y_urbs_release(subs); + return -ENOMEM; + } + if (!is_playback && !(*purb)->transfer_buffer) { +@@ -426,7 +426,7 @@ static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs) + kmalloc_array(subs->maxpacksize, + nr_of_packs(), GFP_KERNEL); + if (NULL == (*purb)->transfer_buffer) { +- usX2Y_urbs_release(subs); ++ usx2y_urbs_release(subs); + return -ENOMEM; + } + } +@@ -435,43 +435,43 @@ static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs) + (*purb)->number_of_packets = nr_of_packs(); + (*purb)->context = subs; + (*purb)->interval = 1; +- (*purb)->complete = i_usX2Y_subs_startup; ++ (*purb)->complete = i_usx2y_subs_startup; + } + return 0; + } + +-static void usX2Y_subs_startup(struct snd_usX2Y_substream *subs) ++static void usx2y_subs_startup(struct snd_usx2y_substream *subs) + { +- struct usX2Ydev *usX2Y = subs->usX2Y; +- usX2Y->prepare_subs = subs; ++ struct usx2ydev *usx2y = subs->usx2y; ++ usx2y->prepare_subs = subs; + subs->urb[0]->start_frame = -1; + wmb(); +- usX2Y_urbs_set_complete(usX2Y, i_usX2Y_subs_startup); ++ usx2y_urbs_set_complete(usx2y, i_usx2y_subs_startup); + } + +-static int usX2Y_urbs_start(struct snd_usX2Y_substream *subs) ++static int usx2y_urbs_start(struct snd_usx2y_substream *subs) + { + int i, err; +- struct usX2Ydev *usX2Y = subs->usX2Y; ++ struct usx2ydev *usx2y = subs->usx2y; + +- if ((err = usX2Y_urbs_allocate(subs)) < 0) ++ if ((err = usx2y_urbs_allocate(subs)) < 0) + return err; + subs->completed_urb = NULL; + for (i = 0; i < 4; i++) { +- struct snd_usX2Y_substream *subs = usX2Y->subs[i]; +- if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED) ++ struct snd_usx2y_substream *subs = usx2y->subs[i]; ++ if (subs != NULL && atomic_read(&subs->state) >= STATE_PREPARED) + goto start; + } + + start: +- usX2Y_subs_startup(subs); ++ usx2y_subs_startup(subs); + for (i = 0; i < NRURBS; i++) { + struct urb *urb = subs->urb[i]; + if (usb_pipein(urb->pipe)) { + unsigned long pack; + if (0 == i) +- atomic_set(&subs->state, state_STARTING3); +- urb->dev = usX2Y->dev; ++ atomic_set(&subs->state, STATE_STARTING3); ++ urb->dev = usx2y->dev; + for (pack = 0; pack < nr_of_packs(); pack++) { + urb->iso_frame_desc[pack].offset = subs->maxpacksize * pack; + urb->iso_frame_desc[pack].length = subs->maxpacksize; +@@ -483,22 +483,22 @@ static int usX2Y_urbs_start(struct snd_usX2Y_substream *subs) + goto cleanup; + } else + if (i == 0) +- usX2Y->wait_iso_frame = urb->start_frame; ++ usx2y->wait_iso_frame = urb->start_frame; + urb->transfer_flags = 0; + } else { +- atomic_set(&subs->state, state_STARTING1); ++ atomic_set(&subs->state, STATE_STARTING1); + break; + } + } + err = 0; +- wait_event(usX2Y->prepare_wait_queue, NULL == usX2Y->prepare_subs); +- if (atomic_read(&subs->state) != state_PREPARED) ++ wait_event(usx2y->prepare_wait_queue, NULL == usx2y->prepare_subs); ++ if (atomic_read(&subs->state) != STATE_PREPARED) + err = -EPIPE; + + cleanup: + if (err) { +- usX2Y_subs_startup_finish(usX2Y); +- usX2Y_clients_stop(usX2Y); // something is completely wroong > stop evrything ++ usx2y_subs_startup_finish(usx2y); ++ usx2y_clients_stop(usx2y); // something is completely wroong > stop evrything + } + return err; + } +@@ -506,33 +506,33 @@ static int usX2Y_urbs_start(struct snd_usX2Y_substream *subs) + /* + * return the current pcm pointer. just return the hwptr_done value. + */ +-static snd_pcm_uframes_t snd_usX2Y_pcm_pointer(struct snd_pcm_substream *substream) ++static snd_pcm_uframes_t snd_usx2y_pcm_pointer(struct snd_pcm_substream *substream) + { +- struct snd_usX2Y_substream *subs = substream->runtime->private_data; ++ struct snd_usx2y_substream *subs = substream->runtime->private_data; + return subs->hwptr_done; + } + /* + * start/stop substream + */ +-static int snd_usX2Y_pcm_trigger(struct snd_pcm_substream *substream, int cmd) ++static int snd_usx2y_pcm_trigger(struct snd_pcm_substream *substream, int cmd) + { +- struct snd_usX2Y_substream *subs = substream->runtime->private_data; ++ struct snd_usx2y_substream *subs = substream->runtime->private_data; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: +- snd_printdd("snd_usX2Y_pcm_trigger(START)\n"); +- if (atomic_read(&subs->state) == state_PREPARED && +- atomic_read(&subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]->state) >= state_PREPARED) { +- atomic_set(&subs->state, state_PRERUNNING); ++ snd_printdd("snd_usx2y_pcm_trigger(START)\n"); ++ if (atomic_read(&subs->state) == STATE_PREPARED && ++ atomic_read(&subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]->state) >= STATE_PREPARED) { ++ atomic_set(&subs->state, STATE_PRERUNNING); + } else { + snd_printdd("\n"); + return -EPIPE; + } + break; + case SNDRV_PCM_TRIGGER_STOP: +- snd_printdd("snd_usX2Y_pcm_trigger(STOP)\n"); +- if (atomic_read(&subs->state) >= state_PRERUNNING) +- atomic_set(&subs->state, state_PREPARED); ++ snd_printdd("snd_usx2y_pcm_trigger(STOP)\n"); ++ if (atomic_read(&subs->state) >= STATE_PRERUNNING) ++ atomic_set(&subs->state, STATE_PREPARED); + break; + default: + return -EINVAL; +@@ -553,7 +553,7 @@ static const struct s_c2 + { + char c1, c2; + } +- SetRate44100[] = ++ setrate_44100[] = + { + { 0x14, 0x08}, // this line sets 44100, well actually a little less + { 0x18, 0x40}, // only tascam / frontier design knows the further lines ....... +@@ -589,7 +589,7 @@ static const struct s_c2 + { 0x18, 0x7C}, + { 0x18, 0x7E} + }; +-static const struct s_c2 SetRate48000[] = ++static const struct s_c2 setrate_48000[] = + { + { 0x14, 0x09}, // this line sets 48000, well actually a little less + { 0x18, 0x40}, // only tascam / frontier design knows the further lines ....... +@@ -625,26 +625,26 @@ static const struct s_c2 SetRate48000[] = + { 0x18, 0x7C}, + { 0x18, 0x7E} + }; +-#define NOOF_SETRATE_URBS ARRAY_SIZE(SetRate48000) ++#define NOOF_SETRATE_URBS ARRAY_SIZE(setrate_48000) + +-static void i_usX2Y_04Int(struct urb *urb) ++static void i_usx2y_04int(struct urb *urb) + { +- struct usX2Ydev *usX2Y = urb->context; ++ struct usx2ydev *usx2y = urb->context; + + if (urb->status) +- snd_printk(KERN_ERR "snd_usX2Y_04Int() urb->status=%i\n", urb->status); +- if (0 == --usX2Y->US04->len) +- wake_up(&usX2Y->In04WaitQueue); ++ snd_printk(KERN_ERR "snd_usx2y_04int() urb->status=%i\n", urb->status); ++ if (0 == --usx2y->us04->len) ++ wake_up(&usx2y->in04_wait_queue); + } + +-static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate) ++static int usx2y_rate_set(struct usx2ydev *usx2y, int rate) + { + int err = 0, i; +- struct snd_usX2Y_urbSeq *us = NULL; ++ struct snd_usx2y_urb_seq *us = NULL; + int *usbdata = NULL; +- const struct s_c2 *ra = rate == 48000 ? SetRate48000 : SetRate44100; ++ const struct s_c2 *ra = rate == 48000 ? setrate_48000 : setrate_44100; + +- if (usX2Y->rate != rate) { ++ if (usx2y->rate != rate) { + us = kzalloc(sizeof(*us) + sizeof(struct urb*) * NOOF_SETRATE_URBS, GFP_KERNEL); + if (NULL == us) { + err = -ENOMEM; +@@ -663,17 +663,17 @@ static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate) + } + ((char*)(usbdata + i))[0] = ra[i].c1; + ((char*)(usbdata + i))[1] = ra[i].c2; +- usb_fill_bulk_urb(us->urb[i], usX2Y->dev, usb_sndbulkpipe(usX2Y->dev, 4), +- usbdata + i, 2, i_usX2Y_04Int, usX2Y); ++ usb_fill_bulk_urb(us->urb[i], usx2y->dev, usb_sndbulkpipe(usx2y->dev, 4), ++ usbdata + i, 2, i_usx2y_04int, usx2y); + } + err = usb_urb_ep_type_check(us->urb[0]); + if (err < 0) + goto cleanup; + us->submitted = 0; + us->len = NOOF_SETRATE_URBS; +- usX2Y->US04 = us; +- wait_event_timeout(usX2Y->In04WaitQueue, 0 == us->len, HZ); +- usX2Y->US04 = NULL; ++ usx2y->us04 = us; ++ wait_event_timeout(usx2y->in04_wait_queue, 0 == us->len, HZ); ++ usx2y->us04 = NULL; + if (us->len) + err = -ENODEV; + cleanup: +@@ -690,11 +690,11 @@ static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate) + } + usb_free_urb(urb); + } +- usX2Y->US04 = NULL; ++ usx2y->us04 = NULL; + kfree(usbdata); + kfree(us); + if (!err) +- usX2Y->rate = rate; ++ usx2y->rate = rate; + } + } + +@@ -702,53 +702,53 @@ static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate) + } + + +-static int usX2Y_format_set(struct usX2Ydev *usX2Y, snd_pcm_format_t format) ++static int usx2y_format_set(struct usx2ydev *usx2y, snd_pcm_format_t format) + { + int alternate, err; + struct list_head* p; + if (format == SNDRV_PCM_FORMAT_S24_3LE) { + alternate = 2; +- usX2Y->stride = 6; ++ usx2y->stride = 6; + } else { + alternate = 1; +- usX2Y->stride = 4; ++ usx2y->stride = 4; + } +- list_for_each(p, &usX2Y->midi_list) { ++ list_for_each(p, &usx2y->midi_list) { + snd_usbmidi_input_stop(p); + } +- usb_kill_urb(usX2Y->In04urb); +- if ((err = usb_set_interface(usX2Y->dev, 0, alternate))) { ++ usb_kill_urb(usx2y->in04_urb); ++ if ((err = usb_set_interface(usx2y->dev, 0, alternate))) { + snd_printk(KERN_ERR "usb_set_interface error \n"); + return err; + } +- usX2Y->In04urb->dev = usX2Y->dev; +- err = usb_submit_urb(usX2Y->In04urb, GFP_KERNEL); +- list_for_each(p, &usX2Y->midi_list) { ++ usx2y->in04_urb->dev = usx2y->dev; ++ err = usb_submit_urb(usx2y->in04_urb, GFP_KERNEL); ++ list_for_each(p, &usx2y->midi_list) { + snd_usbmidi_input_start(p); + } +- usX2Y->format = format; +- usX2Y->rate = 0; ++ usx2y->format = format; ++ usx2y->rate = 0; + return err; + } + + +-static int snd_usX2Y_pcm_hw_params(struct snd_pcm_substream *substream, ++static int snd_usx2y_pcm_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *hw_params) + { + int err = 0; + unsigned int rate = params_rate(hw_params); + snd_pcm_format_t format = params_format(hw_params); + struct snd_card *card = substream->pstr->pcm->card; +- struct usX2Ydev *dev = usX2Y(card); ++ struct usx2ydev *dev = usx2y(card); + int i; + +- mutex_lock(&usX2Y(card)->pcm_mutex); +- snd_printdd("snd_usX2Y_hw_params(%p, %p)\n", substream, hw_params); +- /* all pcm substreams off one usX2Y have to operate at the same ++ mutex_lock(&usx2y(card)->pcm_mutex); ++ snd_printdd("snd_usx2y_hw_params(%p, %p)\n", substream, hw_params); ++ /* all pcm substreams off one usx2y have to operate at the same + * rate & format + */ + for (i = 0; i < dev->pcm_devs * 2; i++) { +- struct snd_usX2Y_substream *subs = dev->subs[i]; ++ struct snd_usx2y_substream *subs = dev->subs[i]; + struct snd_pcm_substream *test_substream; + + if (!subs) +@@ -767,39 +767,39 @@ static int snd_usX2Y_pcm_hw_params(struct snd_pcm_substream *substream, + } + + error: +- mutex_unlock(&usX2Y(card)->pcm_mutex); ++ mutex_unlock(&usx2y(card)->pcm_mutex); + return err; + } + + /* + * free the buffer + */ +-static int snd_usX2Y_pcm_hw_free(struct snd_pcm_substream *substream) ++static int snd_usx2y_pcm_hw_free(struct snd_pcm_substream *substream) + { + struct snd_pcm_runtime *runtime = substream->runtime; +- struct snd_usX2Y_substream *subs = runtime->private_data; +- mutex_lock(&subs->usX2Y->pcm_mutex); +- snd_printdd("snd_usX2Y_hw_free(%p)\n", substream); ++ struct snd_usx2y_substream *subs = runtime->private_data; ++ mutex_lock(&subs->usx2y->pcm_mutex); ++ snd_printdd("snd_usx2y_hw_free(%p)\n", substream); + + if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) { +- struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; +- atomic_set(&subs->state, state_STOPPED); +- usX2Y_urbs_release(subs); ++ struct snd_usx2y_substream *cap_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; ++ atomic_set(&subs->state, STATE_STOPPED); ++ usx2y_urbs_release(subs); + if (!cap_subs->pcm_substream || + !cap_subs->pcm_substream->runtime || + !cap_subs->pcm_substream->runtime->status || + cap_subs->pcm_substream->runtime->status->state < SNDRV_PCM_STATE_PREPARED) { +- atomic_set(&cap_subs->state, state_STOPPED); +- usX2Y_urbs_release(cap_subs); ++ atomic_set(&cap_subs->state, STATE_STOPPED); ++ usx2y_urbs_release(cap_subs); + } + } else { +- struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; +- if (atomic_read(&playback_subs->state) < state_PREPARED) { +- atomic_set(&subs->state, state_STOPPED); +- usX2Y_urbs_release(subs); ++ struct snd_usx2y_substream *playback_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; ++ if (atomic_read(&playback_subs->state) < STATE_PREPARED) { ++ atomic_set(&subs->state, STATE_STOPPED); ++ usx2y_urbs_release(subs); + } + } +- mutex_unlock(&subs->usX2Y->pcm_mutex); ++ mutex_unlock(&subs->usx2y->pcm_mutex); + return 0; + } + /* +@@ -807,40 +807,40 @@ static int snd_usX2Y_pcm_hw_free(struct snd_pcm_substream *substream) + * + * set format and initialize urbs + */ +-static int snd_usX2Y_pcm_prepare(struct snd_pcm_substream *substream) ++static int snd_usx2y_pcm_prepare(struct snd_pcm_substream *substream) + { + struct snd_pcm_runtime *runtime = substream->runtime; +- struct snd_usX2Y_substream *subs = runtime->private_data; +- struct usX2Ydev *usX2Y = subs->usX2Y; +- struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; ++ struct snd_usx2y_substream *subs = runtime->private_data; ++ struct usx2ydev *usx2y = subs->usx2y; ++ struct snd_usx2y_substream *capsubs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; + int err = 0; +- snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream); ++ snd_printdd("snd_usx2y_pcm_prepare(%p)\n", substream); + +- mutex_lock(&usX2Y->pcm_mutex); +- usX2Y_subs_prepare(subs); ++ mutex_lock(&usx2y->pcm_mutex); ++ usx2y_subs_prepare(subs); + // Start hardware streams + // SyncStream first.... +- if (atomic_read(&capsubs->state) < state_PREPARED) { +- if (usX2Y->format != runtime->format) +- if ((err = usX2Y_format_set(usX2Y, runtime->format)) < 0) ++ if (atomic_read(&capsubs->state) < STATE_PREPARED) { ++ if (usx2y->format != runtime->format) ++ if ((err = usx2y_format_set(usx2y, runtime->format)) < 0) + goto up_prepare_mutex; +- if (usX2Y->rate != runtime->rate) +- if ((err = usX2Y_rate_set(usX2Y, runtime->rate)) < 0) ++ if (usx2y->rate != runtime->rate) ++ if ((err = usx2y_rate_set(usx2y, runtime->rate)) < 0) + goto up_prepare_mutex; + snd_printdd("starting capture pipe for %s\n", subs == capsubs ? "self" : "playpipe"); +- if (0 > (err = usX2Y_urbs_start(capsubs))) ++ if (0 > (err = usx2y_urbs_start(capsubs))) + goto up_prepare_mutex; + } + +- if (subs != capsubs && atomic_read(&subs->state) < state_PREPARED) +- err = usX2Y_urbs_start(subs); ++ if (subs != capsubs && atomic_read(&subs->state) < STATE_PREPARED) ++ err = usx2y_urbs_start(subs); + + up_prepare_mutex: +- mutex_unlock(&usX2Y->pcm_mutex); ++ mutex_unlock(&usx2y->pcm_mutex); + return err; + } + +-static const struct snd_pcm_hardware snd_usX2Y_2c = ++static const struct snd_pcm_hardware snd_usx2y_2c = + { + .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | + SNDRV_PCM_INFO_BLOCK_TRANSFER | +@@ -862,16 +862,16 @@ static const struct snd_pcm_hardware snd_usX2Y_2c = + + + +-static int snd_usX2Y_pcm_open(struct snd_pcm_substream *substream) ++static int snd_usx2y_pcm_open(struct snd_pcm_substream *substream) + { +- struct snd_usX2Y_substream *subs = ((struct snd_usX2Y_substream **) ++ struct snd_usx2y_substream *subs = ((struct snd_usx2y_substream **) + snd_pcm_substream_chip(substream))[substream->stream]; + struct snd_pcm_runtime *runtime = substream->runtime; + +- if (subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS) ++ if (subs->usx2y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS) + return -EBUSY; + +- runtime->hw = snd_usX2Y_2c; ++ runtime->hw = snd_usx2y_2c; + runtime->private_data = subs; + subs->pcm_substream = substream; + snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000); +@@ -880,10 +880,10 @@ static int snd_usX2Y_pcm_open(struct snd_pcm_substream *substream) + + + +-static int snd_usX2Y_pcm_close(struct snd_pcm_substream *substream) ++static int snd_usx2y_pcm_close(struct snd_pcm_substream *substream) + { + struct snd_pcm_runtime *runtime = substream->runtime; +- struct snd_usX2Y_substream *subs = runtime->private_data; ++ struct snd_usx2y_substream *subs = runtime->private_data; + + subs->pcm_substream = NULL; + +@@ -891,75 +891,75 @@ static int snd_usX2Y_pcm_close(struct snd_pcm_substream *substream) + } + + +-static const struct snd_pcm_ops snd_usX2Y_pcm_ops = ++static const struct snd_pcm_ops snd_usx2y_pcm_ops = + { +- .open = snd_usX2Y_pcm_open, +- .close = snd_usX2Y_pcm_close, +- .hw_params = snd_usX2Y_pcm_hw_params, +- .hw_free = snd_usX2Y_pcm_hw_free, +- .prepare = snd_usX2Y_pcm_prepare, +- .trigger = snd_usX2Y_pcm_trigger, +- .pointer = snd_usX2Y_pcm_pointer, ++ .open = snd_usx2y_pcm_open, ++ .close = snd_usx2y_pcm_close, ++ .hw_params = snd_usx2y_pcm_hw_params, ++ .hw_free = snd_usx2y_pcm_hw_free, ++ .prepare = snd_usx2y_pcm_prepare, ++ .trigger = snd_usx2y_pcm_trigger, ++ .pointer = snd_usx2y_pcm_pointer, + }; + + + /* + * free a usb stream instance + */ +-static void usX2Y_audio_stream_free(struct snd_usX2Y_substream **usX2Y_substream) ++static void usx2y_audio_stream_free(struct snd_usx2y_substream **usx2y_substream) + { + int stream; + + for_each_pcm_streams(stream) { +- kfree(usX2Y_substream[stream]); +- usX2Y_substream[stream] = NULL; ++ kfree(usx2y_substream[stream]); ++ usx2y_substream[stream] = NULL; + } + } + +-static void snd_usX2Y_pcm_private_free(struct snd_pcm *pcm) ++static void snd_usx2y_pcm_private_free(struct snd_pcm *pcm) + { +- struct snd_usX2Y_substream **usX2Y_stream = pcm->private_data; +- if (usX2Y_stream) +- usX2Y_audio_stream_free(usX2Y_stream); ++ struct snd_usx2y_substream **usx2y_stream = pcm->private_data; ++ if (usx2y_stream) ++ usx2y_audio_stream_free(usx2y_stream); + } + +-static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint, int capture_endpoint) ++static int usx2y_audio_stream_new(struct snd_card *card, int playback_endpoint, int capture_endpoint) + { + struct snd_pcm *pcm; + int err, i; +- struct snd_usX2Y_substream **usX2Y_substream = +- usX2Y(card)->subs + 2 * usX2Y(card)->pcm_devs; ++ struct snd_usx2y_substream **usx2y_substream = ++ usx2y(card)->subs + 2 * usx2y(card)->pcm_devs; + + for (i = playback_endpoint ? SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE; + i <= SNDRV_PCM_STREAM_CAPTURE; ++i) { +- usX2Y_substream[i] = kzalloc(sizeof(struct snd_usX2Y_substream), GFP_KERNEL); +- if (!usX2Y_substream[i]) ++ usx2y_substream[i] = kzalloc(sizeof(struct snd_usx2y_substream), GFP_KERNEL); ++ if (!usx2y_substream[i]) + return -ENOMEM; + +- usX2Y_substream[i]->usX2Y = usX2Y(card); ++ usx2y_substream[i]->usx2y = usx2y(card); + } + + if (playback_endpoint) +- usX2Y_substream[SNDRV_PCM_STREAM_PLAYBACK]->endpoint = playback_endpoint; +- usX2Y_substream[SNDRV_PCM_STREAM_CAPTURE]->endpoint = capture_endpoint; ++ usx2y_substream[SNDRV_PCM_STREAM_PLAYBACK]->endpoint = playback_endpoint; ++ usx2y_substream[SNDRV_PCM_STREAM_CAPTURE]->endpoint = capture_endpoint; + +- err = snd_pcm_new(card, NAME_ALLCAPS" Audio", usX2Y(card)->pcm_devs, ++ err = snd_pcm_new(card, NAME_ALLCAPS" Audio", usx2y(card)->pcm_devs, + playback_endpoint ? 1 : 0, 1, + &pcm); + if (err < 0) { +- usX2Y_audio_stream_free(usX2Y_substream); ++ usx2y_audio_stream_free(usx2y_substream); + return err; + } + + if (playback_endpoint) +- snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usX2Y_pcm_ops); +- snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usX2Y_pcm_ops); ++ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usx2y_pcm_ops); ++ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usx2y_pcm_ops); + +- pcm->private_data = usX2Y_substream; +- pcm->private_free = snd_usX2Y_pcm_private_free; ++ pcm->private_data = usx2y_substream; ++ pcm->private_free = snd_usx2y_pcm_private_free; + pcm->info_flags = 0; + +- sprintf(pcm->name, NAME_ALLCAPS" Audio #%d", usX2Y(card)->pcm_devs); ++ sprintf(pcm->name, NAME_ALLCAPS" Audio #%d", usx2y(card)->pcm_devs); + + if (playback_endpoint) { + snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream, +@@ -972,7 +972,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint, + SNDRV_DMA_TYPE_CONTINUOUS, + NULL, + 64*1024, 128*1024); +- usX2Y(card)->pcm_devs++; ++ usx2y(card)->pcm_devs++; + + return 0; + } +@@ -980,18 +980,18 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint, + /* + * create a chip instance and set its names. + */ +-int usX2Y_audio_create(struct snd_card *card) ++int usx2y_audio_create(struct snd_card *card) + { + int err = 0; + +- INIT_LIST_HEAD(&usX2Y(card)->pcm_list); ++ INIT_LIST_HEAD(&usx2y(card)->pcm_list); + +- if (0 > (err = usX2Y_audio_stream_new(card, 0xA, 0x8))) ++ if (0 > (err = usx2y_audio_stream_new(card, 0xA, 0x8))) + return err; +- if (le16_to_cpu(usX2Y(card)->dev->descriptor.idProduct) == USB_ID_US428) +- if (0 > (err = usX2Y_audio_stream_new(card, 0, 0xA))) ++ if (le16_to_cpu(usx2y(card)->dev->descriptor.idProduct) == USB_ID_US428) ++ if (0 > (err = usx2y_audio_stream_new(card, 0, 0xA))) + return err; +- if (le16_to_cpu(usX2Y(card)->dev->descriptor.idProduct) != USB_ID_US122) +- err = usX2Y_rate_set(usX2Y(card), 44100); // Lets us428 recognize output-volume settings, disturbs us122. ++ if (le16_to_cpu(usx2y(card)->dev->descriptor.idProduct) != USB_ID_US122) ++ err = usx2y_rate_set(usx2y(card), 44100); // Lets us428 recognize output-volume settings, disturbs us122. + return err; + } +diff --git a/sound/usb/usx2y/usx2yhwdeppcm.c b/sound/usb/usx2y/usx2yhwdeppcm.c +index 8253669c6a7d7..399470e51c411 100644 +--- a/sound/usb/usx2y/usx2yhwdeppcm.c ++++ b/sound/usb/usx2y/usx2yhwdeppcm.c +@@ -47,17 +47,17 @@ + #include + + +-static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs) ++static int usx2y_usbpcm_urb_capt_retire(struct snd_usx2y_substream *subs) + { + struct urb *urb = subs->completed_urb; + struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; + int i, lens = 0, hwptr_done = subs->hwptr_done; +- struct usX2Ydev *usX2Y = subs->usX2Y; +- if (0 > usX2Y->hwdep_pcm_shm->capture_iso_start) { //FIXME +- int head = usX2Y->hwdep_pcm_shm->captured_iso_head + 1; +- if (head >= ARRAY_SIZE(usX2Y->hwdep_pcm_shm->captured_iso)) ++ struct usx2ydev *usx2y = subs->usx2y; ++ if (0 > usx2y->hwdep_pcm_shm->capture_iso_start) { //FIXME ++ int head = usx2y->hwdep_pcm_shm->captured_iso_head + 1; ++ if (head >= ARRAY_SIZE(usx2y->hwdep_pcm_shm->captured_iso)) + head = 0; +- usX2Y->hwdep_pcm_shm->capture_iso_start = head; ++ usx2y->hwdep_pcm_shm->capture_iso_start = head; + snd_printdd("cap start %i\n", head); + } + for (i = 0; i < nr_of_packs(); i++) { +@@ -65,7 +65,7 @@ static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs) + snd_printk(KERN_ERR "active frame status %i. Most probably some hardware problem.\n", urb->iso_frame_desc[i].status); + return urb->iso_frame_desc[i].status; + } +- lens += urb->iso_frame_desc[i].actual_length / usX2Y->stride; ++ lens += urb->iso_frame_desc[i].actual_length / usx2y->stride; + } + if ((hwptr_done += lens) >= runtime->buffer_size) + hwptr_done -= runtime->buffer_size; +@@ -79,10 +79,10 @@ static int usX2Y_usbpcm_urb_capt_retire(struct snd_usX2Y_substream *subs) + return 0; + } + +-static inline int usX2Y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime, +- struct usX2Ydev * usX2Y) ++static inline int usx2y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime, ++ struct usx2ydev * usx2y) + { +- return (runtime->buffer_size * 1000) / usX2Y->rate + 1; //FIXME: so far only correct period_size == 2^x ? ++ return (runtime->buffer_size * 1000) / usx2y->rate + 1; //FIXME: so far only correct period_size == 2^x ? + } + + /* +@@ -95,17 +95,17 @@ static inline int usX2Y_iso_frames_per_buffer(struct snd_pcm_runtime *runtime, + * it directly from the buffer. thus the data is once copied to + * a temporary buffer and urb points to that. + */ +-static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs, ++static int usx2y_hwdep_urb_play_prepare(struct snd_usx2y_substream *subs, + struct urb *urb) + { + int count, counts, pack; +- struct usX2Ydev *usX2Y = subs->usX2Y; +- struct snd_usX2Y_hwdep_pcm_shm *shm = usX2Y->hwdep_pcm_shm; ++ struct usx2ydev *usx2y = subs->usx2y; ++ struct snd_usx2y_hwdep_pcm_shm *shm = usx2y->hwdep_pcm_shm; + struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime; + + if (0 > shm->playback_iso_start) { + shm->playback_iso_start = shm->captured_iso_head - +- usX2Y_iso_frames_per_buffer(runtime, usX2Y); ++ usx2y_iso_frames_per_buffer(runtime, usx2y); + if (0 > shm->playback_iso_start) + shm->playback_iso_start += ARRAY_SIZE(shm->captured_iso); + shm->playback_iso_head = shm->playback_iso_start; +@@ -114,7 +114,7 @@ static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs, + count = 0; + for (pack = 0; pack < nr_of_packs(); pack++) { + /* calculate the size of a packet */ +- counts = shm->captured_iso[shm->playback_iso_head].length / usX2Y->stride; ++ counts = shm->captured_iso[shm->playback_iso_head].length / usx2y->stride; + if (counts < 43 || counts > 50) { + snd_printk(KERN_ERR "should not be here with counts=%i\n", counts); + return -EPIPE; +@@ -122,26 +122,26 @@ static int usX2Y_hwdep_urb_play_prepare(struct snd_usX2Y_substream *subs, + /* set up descriptor */ + urb->iso_frame_desc[pack].offset = shm->captured_iso[shm->playback_iso_head].offset; + urb->iso_frame_desc[pack].length = shm->captured_iso[shm->playback_iso_head].length; +- if (atomic_read(&subs->state) != state_RUNNING) ++ if (atomic_read(&subs->state) != STATE_RUNNING) + memset((char *)urb->transfer_buffer + urb->iso_frame_desc[pack].offset, 0, + urb->iso_frame_desc[pack].length); + if (++shm->playback_iso_head >= ARRAY_SIZE(shm->captured_iso)) + shm->playback_iso_head = 0; + count += counts; + } +- urb->transfer_buffer_length = count * usX2Y->stride; ++ urb->transfer_buffer_length = count * usx2y->stride; + return 0; + } + + +-static inline void usX2Y_usbpcm_urb_capt_iso_advance(struct snd_usX2Y_substream *subs, ++static inline void usx2y_usbpcm_urb_capt_iso_advance(struct snd_usx2y_substream *subs, + struct urb *urb) + { + int pack; + for (pack = 0; pack < nr_of_packs(); ++pack) { + struct usb_iso_packet_descriptor *desc = urb->iso_frame_desc + pack; + if (NULL != subs) { +- struct snd_usX2Y_hwdep_pcm_shm *shm = subs->usX2Y->hwdep_pcm_shm; ++ struct snd_usx2y_hwdep_pcm_shm *shm = subs->usx2y->hwdep_pcm_shm; + int head = shm->captured_iso_head + 1; + if (head >= ARRAY_SIZE(shm->captured_iso)) + head = 0; +@@ -157,9 +157,9 @@ static inline void usX2Y_usbpcm_urb_capt_iso_advance(struct snd_usX2Y_substream + } + } + +-static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *capsubs, +- struct snd_usX2Y_substream *capsubs2, +- struct snd_usX2Y_substream *playbacksubs, ++static inline int usx2y_usbpcm_usbframe_complete(struct snd_usx2y_substream *capsubs, ++ struct snd_usx2y_substream *capsubs2, ++ struct snd_usx2y_substream *playbacksubs, + int frame) + { + int err, state; +@@ -167,25 +167,25 @@ static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *cap + + state = atomic_read(&playbacksubs->state); + if (NULL != urb) { +- if (state == state_RUNNING) +- usX2Y_urb_play_retire(playbacksubs, urb); +- else if (state >= state_PRERUNNING) ++ if (state == STATE_RUNNING) ++ usx2y_urb_play_retire(playbacksubs, urb); ++ else if (state >= STATE_PRERUNNING) + atomic_inc(&playbacksubs->state); + } else { + switch (state) { +- case state_STARTING1: ++ case STATE_STARTING1: + urb = playbacksubs->urb[0]; + atomic_inc(&playbacksubs->state); + break; +- case state_STARTING2: ++ case STATE_STARTING2: + urb = playbacksubs->urb[1]; + atomic_inc(&playbacksubs->state); + break; + } + } + if (urb) { +- if ((err = usX2Y_hwdep_urb_play_prepare(playbacksubs, urb)) || +- (err = usX2Y_urb_submit(playbacksubs, urb, frame))) { ++ if ((err = usx2y_hwdep_urb_play_prepare(playbacksubs, urb)) || ++ (err = usx2y_urb_submit(playbacksubs, urb, frame))) { + return err; + } + } +@@ -193,19 +193,19 @@ static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *cap + playbacksubs->completed_urb = NULL; + + state = atomic_read(&capsubs->state); +- if (state >= state_PREPARED) { +- if (state == state_RUNNING) { +- if ((err = usX2Y_usbpcm_urb_capt_retire(capsubs))) ++ if (state >= STATE_PREPARED) { ++ if (state == STATE_RUNNING) { ++ if ((err = usx2y_usbpcm_urb_capt_retire(capsubs))) + return err; +- } else if (state >= state_PRERUNNING) ++ } else if (state >= STATE_PRERUNNING) + atomic_inc(&capsubs->state); +- usX2Y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb); ++ usx2y_usbpcm_urb_capt_iso_advance(capsubs, capsubs->completed_urb); + if (NULL != capsubs2) +- usX2Y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb); +- if ((err = usX2Y_urb_submit(capsubs, capsubs->completed_urb, frame))) ++ usx2y_usbpcm_urb_capt_iso_advance(NULL, capsubs2->completed_urb); ++ if ((err = usx2y_urb_submit(capsubs, capsubs->completed_urb, frame))) + return err; + if (NULL != capsubs2) +- if ((err = usX2Y_urb_submit(capsubs2, capsubs2->completed_urb, frame))) ++ if ((err = usx2y_urb_submit(capsubs2, capsubs2->completed_urb, frame))) + return err; + } + capsubs->completed_urb = NULL; +@@ -215,42 +215,42 @@ static inline int usX2Y_usbpcm_usbframe_complete(struct snd_usX2Y_substream *cap + } + + +-static void i_usX2Y_usbpcm_urb_complete(struct urb *urb) ++static void i_usx2y_usbpcm_urb_complete(struct urb *urb) + { +- struct snd_usX2Y_substream *subs = urb->context; +- struct usX2Ydev *usX2Y = subs->usX2Y; +- struct snd_usX2Y_substream *capsubs, *capsubs2, *playbacksubs; ++ struct snd_usx2y_substream *subs = urb->context; ++ struct usx2ydev *usx2y = subs->usx2y; ++ struct snd_usx2y_substream *capsubs, *capsubs2, *playbacksubs; + +- if (unlikely(atomic_read(&subs->state) < state_PREPARED)) { ++ if (unlikely(atomic_read(&subs->state) < STATE_PREPARED)) { + snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n", +- usb_get_current_frame_number(usX2Y->dev), ++ usb_get_current_frame_number(usx2y->dev), + subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out", + urb->status, urb->start_frame); + return; + } + if (unlikely(urb->status)) { +- usX2Y_error_urb_status(usX2Y, subs, urb); ++ usx2y_error_urb_status(usx2y, subs, urb); + return; + } + + subs->completed_urb = urb; +- capsubs = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; +- capsubs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; +- playbacksubs = usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; +- if (capsubs->completed_urb && atomic_read(&capsubs->state) >= state_PREPARED && ++ capsubs = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; ++ capsubs2 = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; ++ playbacksubs = usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; ++ if (capsubs->completed_urb && atomic_read(&capsubs->state) >= STATE_PREPARED && + (NULL == capsubs2 || capsubs2->completed_urb) && +- (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < state_PREPARED)) { +- if (!usX2Y_usbpcm_usbframe_complete(capsubs, capsubs2, playbacksubs, urb->start_frame)) +- usX2Y->wait_iso_frame += nr_of_packs(); ++ (playbacksubs->completed_urb || atomic_read(&playbacksubs->state) < STATE_PREPARED)) { ++ if (!usx2y_usbpcm_usbframe_complete(capsubs, capsubs2, playbacksubs, urb->start_frame)) ++ usx2y->wait_iso_frame += nr_of_packs(); + else { + snd_printdd("\n"); +- usX2Y_clients_stop(usX2Y); ++ usx2y_clients_stop(usx2y); + } + } + } + + +-static void usX2Y_hwdep_urb_release(struct urb **urb) ++static void usx2y_hwdep_urb_release(struct urb **urb) + { + usb_kill_urb(*urb); + usb_free_urb(*urb); +@@ -260,49 +260,49 @@ static void usX2Y_hwdep_urb_release(struct urb **urb) + /* + * release a substream + */ +-static void usX2Y_usbpcm_urbs_release(struct snd_usX2Y_substream *subs) ++static void usx2y_usbpcm_urbs_release(struct snd_usx2y_substream *subs) + { + int i; +- snd_printdd("snd_usX2Y_urbs_release() %i\n", subs->endpoint); ++ snd_printdd("snd_usx2y_urbs_release() %i\n", subs->endpoint); + for (i = 0; i < NRURBS; i++) +- usX2Y_hwdep_urb_release(subs->urb + i); ++ usx2y_hwdep_urb_release(subs->urb + i); + } + +-static void usX2Y_usbpcm_subs_startup_finish(struct usX2Ydev * usX2Y) ++static void usx2y_usbpcm_subs_startup_finish(struct usx2ydev * usx2y) + { +- usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_urb_complete); +- usX2Y->prepare_subs = NULL; ++ usx2y_urbs_set_complete(usx2y, i_usx2y_usbpcm_urb_complete); ++ usx2y->prepare_subs = NULL; + } + +-static void i_usX2Y_usbpcm_subs_startup(struct urb *urb) ++static void i_usx2y_usbpcm_subs_startup(struct urb *urb) + { +- struct snd_usX2Y_substream *subs = urb->context; +- struct usX2Ydev *usX2Y = subs->usX2Y; +- struct snd_usX2Y_substream *prepare_subs = usX2Y->prepare_subs; ++ struct snd_usx2y_substream *subs = urb->context; ++ struct usx2ydev *usx2y = subs->usx2y; ++ struct snd_usx2y_substream *prepare_subs = usx2y->prepare_subs; + if (NULL != prepare_subs && + urb->start_frame == prepare_subs->urb[0]->start_frame) { + atomic_inc(&prepare_subs->state); +- if (prepare_subs == usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]) { +- struct snd_usX2Y_substream *cap_subs2 = usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; ++ if (prepare_subs == usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]) { ++ struct snd_usx2y_substream *cap_subs2 = usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; + if (cap_subs2 != NULL) + atomic_inc(&cap_subs2->state); + } +- usX2Y_usbpcm_subs_startup_finish(usX2Y); +- wake_up(&usX2Y->prepare_wait_queue); ++ usx2y_usbpcm_subs_startup_finish(usx2y); ++ wake_up(&usx2y->prepare_wait_queue); + } + +- i_usX2Y_usbpcm_urb_complete(urb); ++ i_usx2y_usbpcm_urb_complete(urb); + } + + /* + * initialize a substream's urbs + */ +-static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs) ++static int usx2y_usbpcm_urbs_allocate(struct snd_usx2y_substream *subs) + { + int i; + unsigned int pipe; +- int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; +- struct usb_device *dev = subs->usX2Y->dev; ++ int is_playback = subs == subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; ++ struct usb_device *dev = subs->usx2y->dev; + + pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) : + usb_rcvisocpipe(dev, subs->endpoint); +@@ -319,21 +319,21 @@ static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs) + } + *purb = usb_alloc_urb(nr_of_packs(), GFP_KERNEL); + if (NULL == *purb) { +- usX2Y_usbpcm_urbs_release(subs); ++ usx2y_usbpcm_urbs_release(subs); + return -ENOMEM; + } + (*purb)->transfer_buffer = is_playback ? +- subs->usX2Y->hwdep_pcm_shm->playback : ( ++ subs->usx2y->hwdep_pcm_shm->playback : ( + subs->endpoint == 0x8 ? +- subs->usX2Y->hwdep_pcm_shm->capture0x8 : +- subs->usX2Y->hwdep_pcm_shm->capture0xA); ++ subs->usx2y->hwdep_pcm_shm->capture0x8 : ++ subs->usx2y->hwdep_pcm_shm->capture0xA); + + (*purb)->dev = dev; + (*purb)->pipe = pipe; + (*purb)->number_of_packets = nr_of_packs(); + (*purb)->context = subs; + (*purb)->interval = 1; +- (*purb)->complete = i_usX2Y_usbpcm_subs_startup; ++ (*purb)->complete = i_usx2y_usbpcm_subs_startup; + } + return 0; + } +@@ -341,91 +341,91 @@ static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs) + /* + * free the buffer + */ +-static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream) ++static int snd_usx2y_usbpcm_hw_free(struct snd_pcm_substream *substream) + { + struct snd_pcm_runtime *runtime = substream->runtime; +- struct snd_usX2Y_substream *subs = runtime->private_data, +- *cap_subs2 = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; +- mutex_lock(&subs->usX2Y->pcm_mutex); +- snd_printdd("snd_usX2Y_usbpcm_hw_free(%p)\n", substream); ++ struct snd_usx2y_substream *subs = runtime->private_data, ++ *cap_subs2 = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE + 2]; ++ mutex_lock(&subs->usx2y->pcm_mutex); ++ snd_printdd("snd_usx2y_usbpcm_hw_free(%p)\n", substream); + + if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) { +- struct snd_usX2Y_substream *cap_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; +- atomic_set(&subs->state, state_STOPPED); +- usX2Y_usbpcm_urbs_release(subs); ++ struct snd_usx2y_substream *cap_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; ++ atomic_set(&subs->state, STATE_STOPPED); ++ usx2y_usbpcm_urbs_release(subs); + if (!cap_subs->pcm_substream || + !cap_subs->pcm_substream->runtime || + !cap_subs->pcm_substream->runtime->status || + cap_subs->pcm_substream->runtime->status->state < SNDRV_PCM_STATE_PREPARED) { +- atomic_set(&cap_subs->state, state_STOPPED); ++ atomic_set(&cap_subs->state, STATE_STOPPED); + if (NULL != cap_subs2) +- atomic_set(&cap_subs2->state, state_STOPPED); +- usX2Y_usbpcm_urbs_release(cap_subs); ++ atomic_set(&cap_subs2->state, STATE_STOPPED); ++ usx2y_usbpcm_urbs_release(cap_subs); + if (NULL != cap_subs2) +- usX2Y_usbpcm_urbs_release(cap_subs2); ++ usx2y_usbpcm_urbs_release(cap_subs2); + } + } else { +- struct snd_usX2Y_substream *playback_subs = subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK]; +- if (atomic_read(&playback_subs->state) < state_PREPARED) { +- atomic_set(&subs->state, state_STOPPED); ++ struct snd_usx2y_substream *playback_subs = subs->usx2y->subs[SNDRV_PCM_STREAM_PLAYBACK]; ++ if (atomic_read(&playback_subs->state) < STATE_PREPARED) { ++ atomic_set(&subs->state, STATE_STOPPED); + if (NULL != cap_subs2) +- atomic_set(&cap_subs2->state, state_STOPPED); +- usX2Y_usbpcm_urbs_release(subs); ++ atomic_set(&cap_subs2->state, STATE_STOPPED); ++ usx2y_usbpcm_urbs_release(subs); + if (NULL != cap_subs2) +- usX2Y_usbpcm_urbs_release(cap_subs2); ++ usx2y_usbpcm_urbs_release(cap_subs2); + } + } +- mutex_unlock(&subs->usX2Y->pcm_mutex); ++ mutex_unlock(&subs->usx2y->pcm_mutex); + return 0; + } + +-static void usX2Y_usbpcm_subs_startup(struct snd_usX2Y_substream *subs) ++static void usx2y_usbpcm_subs_startup(struct snd_usx2y_substream *subs) + { +- struct usX2Ydev * usX2Y = subs->usX2Y; +- usX2Y->prepare_subs = subs; ++ struct usx2ydev * usx2y = subs->usx2y; ++ usx2y->prepare_subs = subs; + subs->urb[0]->start_frame = -1; +- smp_wmb(); // Make sure above modifications are seen by i_usX2Y_subs_startup() +- usX2Y_urbs_set_complete(usX2Y, i_usX2Y_usbpcm_subs_startup); ++ smp_wmb(); // Make sure above modifications are seen by i_usx2y_subs_startup() ++ usx2y_urbs_set_complete(usx2y, i_usx2y_usbpcm_subs_startup); + } + +-static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) ++static int usx2y_usbpcm_urbs_start(struct snd_usx2y_substream *subs) + { + int p, u, err, + stream = subs->pcm_substream->stream; +- struct usX2Ydev *usX2Y = subs->usX2Y; ++ struct usx2ydev *usx2y = subs->usx2y; + + if (SNDRV_PCM_STREAM_CAPTURE == stream) { +- usX2Y->hwdep_pcm_shm->captured_iso_head = -1; +- usX2Y->hwdep_pcm_shm->captured_iso_frames = 0; ++ usx2y->hwdep_pcm_shm->captured_iso_head = -1; ++ usx2y->hwdep_pcm_shm->captured_iso_frames = 0; + } + + for (p = 0; 3 >= (stream + p); p += 2) { +- struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p]; ++ struct snd_usx2y_substream *subs = usx2y->subs[stream + p]; + if (subs != NULL) { +- if ((err = usX2Y_usbpcm_urbs_allocate(subs)) < 0) ++ if ((err = usx2y_usbpcm_urbs_allocate(subs)) < 0) + return err; + subs->completed_urb = NULL; + } + } + + for (p = 0; p < 4; p++) { +- struct snd_usX2Y_substream *subs = usX2Y->subs[p]; +- if (subs != NULL && atomic_read(&subs->state) >= state_PREPARED) ++ struct snd_usx2y_substream *subs = usx2y->subs[p]; ++ if (subs != NULL && atomic_read(&subs->state) >= STATE_PREPARED) + goto start; + } + + start: +- usX2Y_usbpcm_subs_startup(subs); ++ usx2y_usbpcm_subs_startup(subs); + for (u = 0; u < NRURBS; u++) { + for (p = 0; 3 >= (stream + p); p += 2) { +- struct snd_usX2Y_substream *subs = usX2Y->subs[stream + p]; ++ struct snd_usx2y_substream *subs = usx2y->subs[stream + p]; + if (subs != NULL) { + struct urb *urb = subs->urb[u]; + if (usb_pipein(urb->pipe)) { + unsigned long pack; + if (0 == u) +- atomic_set(&subs->state, state_STARTING3); +- urb->dev = usX2Y->dev; ++ atomic_set(&subs->state, STATE_STARTING3); ++ urb->dev = usx2y->dev; + for (pack = 0; pack < nr_of_packs(); pack++) { + urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs()); + urb->iso_frame_desc[pack].length = subs->maxpacksize; +@@ -438,25 +438,25 @@ static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) + } else { + snd_printdd("%i\n", urb->start_frame); + if (u == 0) +- usX2Y->wait_iso_frame = urb->start_frame; ++ usx2y->wait_iso_frame = urb->start_frame; + } + urb->transfer_flags = 0; + } else { +- atomic_set(&subs->state, state_STARTING1); ++ atomic_set(&subs->state, STATE_STARTING1); + break; + } + } + } + } + err = 0; +- wait_event(usX2Y->prepare_wait_queue, NULL == usX2Y->prepare_subs); +- if (atomic_read(&subs->state) != state_PREPARED) ++ wait_event(usx2y->prepare_wait_queue, NULL == usx2y->prepare_subs); ++ if (atomic_read(&subs->state) != STATE_PREPARED) + err = -EPIPE; + + cleanup: + if (err) { +- usX2Y_subs_startup_finish(usX2Y); // Call it now +- usX2Y_clients_stop(usX2Y); // something is completely wroong > stop evrything ++ usx2y_subs_startup_finish(usx2y); // Call it now ++ usx2y_clients_stop(usx2y); // something is completely wroong > stop evrything + } + return err; + } +@@ -466,69 +466,69 @@ static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs) + * + * set format and initialize urbs + */ +-static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream) ++static int snd_usx2y_usbpcm_prepare(struct snd_pcm_substream *substream) + { + struct snd_pcm_runtime *runtime = substream->runtime; +- struct snd_usX2Y_substream *subs = runtime->private_data; +- struct usX2Ydev *usX2Y = subs->usX2Y; +- struct snd_usX2Y_substream *capsubs = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE]; ++ struct snd_usx2y_substream *subs = runtime->private_data; ++ struct usx2ydev *usx2y = subs->usx2y; ++ struct snd_usx2y_substream *capsubs = subs->usx2y->subs[SNDRV_PCM_STREAM_CAPTURE]; + int err = 0; +- snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream); ++ snd_printdd("snd_usx2y_pcm_prepare(%p)\n", substream); + +- if (NULL == usX2Y->hwdep_pcm_shm) { +- usX2Y->hwdep_pcm_shm = alloc_pages_exact(sizeof(struct snd_usX2Y_hwdep_pcm_shm), ++ if (NULL == usx2y->hwdep_pcm_shm) { ++ usx2y->hwdep_pcm_shm = alloc_pages_exact(sizeof(struct snd_usx2y_hwdep_pcm_shm), + GFP_KERNEL); +- if (!usX2Y->hwdep_pcm_shm) ++ if (!usx2y->hwdep_pcm_shm) + return -ENOMEM; +- memset(usX2Y->hwdep_pcm_shm, 0, sizeof(struct snd_usX2Y_hwdep_pcm_shm)); ++ memset(usx2y->hwdep_pcm_shm, 0, sizeof(struct snd_usx2y_hwdep_pcm_shm)); + } + +- mutex_lock(&usX2Y->pcm_mutex); +- usX2Y_subs_prepare(subs); ++ mutex_lock(&usx2y->pcm_mutex); ++ usx2y_subs_prepare(subs); + // Start hardware streams + // SyncStream first.... +- if (atomic_read(&capsubs->state) < state_PREPARED) { +- if (usX2Y->format != runtime->format) +- if ((err = usX2Y_format_set(usX2Y, runtime->format)) < 0) ++ if (atomic_read(&capsubs->state) < STATE_PREPARED) { ++ if (usx2y->format != runtime->format) ++ if ((err = usx2y_format_set(usx2y, runtime->format)) < 0) + goto up_prepare_mutex; +- if (usX2Y->rate != runtime->rate) +- if ((err = usX2Y_rate_set(usX2Y, runtime->rate)) < 0) ++ if (usx2y->rate != runtime->rate) ++ if ((err = usx2y_rate_set(usx2y, runtime->rate)) < 0) + goto up_prepare_mutex; + snd_printdd("starting capture pipe for %s\n", subs == capsubs ? + "self" : "playpipe"); +- if (0 > (err = usX2Y_usbpcm_urbs_start(capsubs))) ++ if (0 > (err = usx2y_usbpcm_urbs_start(capsubs))) + goto up_prepare_mutex; + } + + if (subs != capsubs) { +- usX2Y->hwdep_pcm_shm->playback_iso_start = -1; +- if (atomic_read(&subs->state) < state_PREPARED) { +- while (usX2Y_iso_frames_per_buffer(runtime, usX2Y) > +- usX2Y->hwdep_pcm_shm->captured_iso_frames) { ++ usx2y->hwdep_pcm_shm->playback_iso_start = -1; ++ if (atomic_read(&subs->state) < STATE_PREPARED) { ++ while (usx2y_iso_frames_per_buffer(runtime, usx2y) > ++ usx2y->hwdep_pcm_shm->captured_iso_frames) { + snd_printdd("Wait: iso_frames_per_buffer=%i," + "captured_iso_frames=%i\n", +- usX2Y_iso_frames_per_buffer(runtime, usX2Y), +- usX2Y->hwdep_pcm_shm->captured_iso_frames); ++ usx2y_iso_frames_per_buffer(runtime, usx2y), ++ usx2y->hwdep_pcm_shm->captured_iso_frames); + if (msleep_interruptible(10)) { + err = -ERESTARTSYS; + goto up_prepare_mutex; + } + } +- if (0 > (err = usX2Y_usbpcm_urbs_start(subs))) ++ if (0 > (err = usx2y_usbpcm_urbs_start(subs))) + goto up_prepare_mutex; + } + snd_printdd("Ready: iso_frames_per_buffer=%i,captured_iso_frames=%i\n", +- usX2Y_iso_frames_per_buffer(runtime, usX2Y), +- usX2Y->hwdep_pcm_shm->captured_iso_frames); ++ usx2y_iso_frames_per_buffer(runtime, usx2y), ++ usx2y->hwdep_pcm_shm->captured_iso_frames); + } else +- usX2Y->hwdep_pcm_shm->capture_iso_start = -1; ++ usx2y->hwdep_pcm_shm->capture_iso_start = -1; + + up_prepare_mutex: +- mutex_unlock(&usX2Y->pcm_mutex); ++ mutex_unlock(&usx2y->pcm_mutex); + return err; + } + +-static const struct snd_pcm_hardware snd_usX2Y_4c = ++static const struct snd_pcm_hardware snd_usx2y_4c = + { + .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | + SNDRV_PCM_INFO_BLOCK_TRANSFER | +@@ -549,17 +549,17 @@ static const struct snd_pcm_hardware snd_usX2Y_4c = + + + +-static int snd_usX2Y_usbpcm_open(struct snd_pcm_substream *substream) ++static int snd_usx2y_usbpcm_open(struct snd_pcm_substream *substream) + { +- struct snd_usX2Y_substream *subs = ((struct snd_usX2Y_substream **) ++ struct snd_usx2y_substream *subs = ((struct snd_usx2y_substream **) + snd_pcm_substream_chip(substream))[substream->stream]; + struct snd_pcm_runtime *runtime = substream->runtime; + +- if (!(subs->usX2Y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS)) ++ if (!(subs->usx2y->chip_status & USX2Y_STAT_CHIP_MMAP_PCM_URBS)) + return -EBUSY; + +- runtime->hw = SNDRV_PCM_STREAM_PLAYBACK == substream->stream ? snd_usX2Y_2c : +- (subs->usX2Y->subs[3] ? snd_usX2Y_4c : snd_usX2Y_2c); ++ runtime->hw = SNDRV_PCM_STREAM_PLAYBACK == substream->stream ? snd_usx2y_2c : ++ (subs->usx2y->subs[3] ? snd_usx2y_4c : snd_usx2y_2c); + runtime->private_data = subs; + subs->pcm_substream = substream; + snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 1000, 200000); +@@ -567,35 +567,35 @@ static int snd_usX2Y_usbpcm_open(struct snd_pcm_substream *substream) + } + + +-static int snd_usX2Y_usbpcm_close(struct snd_pcm_substream *substream) ++static int snd_usx2y_usbpcm_close(struct snd_pcm_substream *substream) + { + struct snd_pcm_runtime *runtime = substream->runtime; +- struct snd_usX2Y_substream *subs = runtime->private_data; ++ struct snd_usx2y_substream *subs = runtime->private_data; + + subs->pcm_substream = NULL; + return 0; + } + + +-static const struct snd_pcm_ops snd_usX2Y_usbpcm_ops = ++static const struct snd_pcm_ops snd_usx2y_usbpcm_ops = + { +- .open = snd_usX2Y_usbpcm_open, +- .close = snd_usX2Y_usbpcm_close, +- .hw_params = snd_usX2Y_pcm_hw_params, +- .hw_free = snd_usX2Y_usbpcm_hw_free, +- .prepare = snd_usX2Y_usbpcm_prepare, +- .trigger = snd_usX2Y_pcm_trigger, +- .pointer = snd_usX2Y_pcm_pointer, ++ .open = snd_usx2y_usbpcm_open, ++ .close = snd_usx2y_usbpcm_close, ++ .hw_params = snd_usx2y_pcm_hw_params, ++ .hw_free = snd_usx2y_usbpcm_hw_free, ++ .prepare = snd_usx2y_usbpcm_prepare, ++ .trigger = snd_usx2y_pcm_trigger, ++ .pointer = snd_usx2y_pcm_pointer, + }; + + +-static int usX2Y_pcms_busy_check(struct snd_card *card) ++static int usx2y_pcms_busy_check(struct snd_card *card) + { +- struct usX2Ydev *dev = usX2Y(card); ++ struct usx2ydev *dev = usx2y(card); + int i; + + for (i = 0; i < dev->pcm_devs * 2; i++) { +- struct snd_usX2Y_substream *subs = dev->subs[i]; ++ struct snd_usx2y_substream *subs = dev->subs[i]; + if (subs && subs->pcm_substream && + SUBSTREAM_BUSY(subs->pcm_substream)) + return -EBUSY; +@@ -603,102 +603,102 @@ static int usX2Y_pcms_busy_check(struct snd_card *card) + return 0; + } + +-static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file) ++static int snd_usx2y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file) + { + struct snd_card *card = hw->card; + int err; + +- mutex_lock(&usX2Y(card)->pcm_mutex); +- err = usX2Y_pcms_busy_check(card); ++ mutex_lock(&usx2y(card)->pcm_mutex); ++ err = usx2y_pcms_busy_check(card); + if (!err) +- usX2Y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS; +- mutex_unlock(&usX2Y(card)->pcm_mutex); ++ usx2y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS; ++ mutex_unlock(&usx2y(card)->pcm_mutex); + return err; + } + + +-static int snd_usX2Y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file) ++static int snd_usx2y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file) + { + struct snd_card *card = hw->card; + int err; + +- mutex_lock(&usX2Y(card)->pcm_mutex); +- err = usX2Y_pcms_busy_check(card); ++ mutex_lock(&usx2y(card)->pcm_mutex); ++ err = usx2y_pcms_busy_check(card); + if (!err) +- usX2Y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS; +- mutex_unlock(&usX2Y(card)->pcm_mutex); ++ usx2y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS; ++ mutex_unlock(&usx2y(card)->pcm_mutex); + return err; + } + + +-static void snd_usX2Y_hwdep_pcm_vm_open(struct vm_area_struct *area) ++static void snd_usx2y_hwdep_pcm_vm_open(struct vm_area_struct *area) + { + } + + +-static void snd_usX2Y_hwdep_pcm_vm_close(struct vm_area_struct *area) ++static void snd_usx2y_hwdep_pcm_vm_close(struct vm_area_struct *area) + { + } + + +-static vm_fault_t snd_usX2Y_hwdep_pcm_vm_fault(struct vm_fault *vmf) ++static vm_fault_t snd_usx2y_hwdep_pcm_vm_fault(struct vm_fault *vmf) + { + unsigned long offset; + void *vaddr; + + offset = vmf->pgoff << PAGE_SHIFT; +- vaddr = (char *)((struct usX2Ydev *)vmf->vma->vm_private_data)->hwdep_pcm_shm + offset; ++ vaddr = (char *)((struct usx2ydev *)vmf->vma->vm_private_data)->hwdep_pcm_shm + offset; + vmf->page = virt_to_page(vaddr); + get_page(vmf->page); + return 0; + } + + +-static const struct vm_operations_struct snd_usX2Y_hwdep_pcm_vm_ops = { +- .open = snd_usX2Y_hwdep_pcm_vm_open, +- .close = snd_usX2Y_hwdep_pcm_vm_close, +- .fault = snd_usX2Y_hwdep_pcm_vm_fault, ++static const struct vm_operations_struct snd_usx2y_hwdep_pcm_vm_ops = { ++ .open = snd_usx2y_hwdep_pcm_vm_open, ++ .close = snd_usx2y_hwdep_pcm_vm_close, ++ .fault = snd_usx2y_hwdep_pcm_vm_fault, + }; + + +-static int snd_usX2Y_hwdep_pcm_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area) ++static int snd_usx2y_hwdep_pcm_mmap(struct snd_hwdep * hw, struct file *filp, struct vm_area_struct *area) + { + unsigned long size = (unsigned long)(area->vm_end - area->vm_start); +- struct usX2Ydev *usX2Y = hw->private_data; ++ struct usx2ydev *usx2y = hw->private_data; + +- if (!(usX2Y->chip_status & USX2Y_STAT_CHIP_INIT)) ++ if (!(usx2y->chip_status & USX2Y_STAT_CHIP_INIT)) + return -EBUSY; + + /* if userspace tries to mmap beyond end of our buffer, fail */ +- if (size > PAGE_ALIGN(sizeof(struct snd_usX2Y_hwdep_pcm_shm))) { +- snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(struct snd_usX2Y_hwdep_pcm_shm)); ++ if (size > PAGE_ALIGN(sizeof(struct snd_usx2y_hwdep_pcm_shm))) { ++ snd_printd("%lu > %lu\n", size, (unsigned long)sizeof(struct snd_usx2y_hwdep_pcm_shm)); + return -EINVAL; + } + +- if (!usX2Y->hwdep_pcm_shm) { ++ if (!usx2y->hwdep_pcm_shm) { + return -ENODEV; + } +- area->vm_ops = &snd_usX2Y_hwdep_pcm_vm_ops; ++ area->vm_ops = &snd_usx2y_hwdep_pcm_vm_ops; + area->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP; + area->vm_private_data = hw->private_data; + return 0; + } + + +-static void snd_usX2Y_hwdep_pcm_private_free(struct snd_hwdep *hwdep) ++static void snd_usx2y_hwdep_pcm_private_free(struct snd_hwdep *hwdep) + { +- struct usX2Ydev *usX2Y = hwdep->private_data; +- if (NULL != usX2Y->hwdep_pcm_shm) +- free_pages_exact(usX2Y->hwdep_pcm_shm, sizeof(struct snd_usX2Y_hwdep_pcm_shm)); ++ struct usx2ydev *usx2y = hwdep->private_data; ++ if (NULL != usx2y->hwdep_pcm_shm) ++ free_pages_exact(usx2y->hwdep_pcm_shm, sizeof(struct snd_usx2y_hwdep_pcm_shm)); + } + + +-int usX2Y_hwdep_pcm_new(struct snd_card *card) ++int usx2y_hwdep_pcm_new(struct snd_card *card) + { + int err; + struct snd_hwdep *hw; + struct snd_pcm *pcm; +- struct usb_device *dev = usX2Y(card)->dev; ++ struct usb_device *dev = usx2y(card)->dev; + if (1 != nr_of_packs()) + return 0; + +@@ -706,11 +706,11 @@ int usX2Y_hwdep_pcm_new(struct snd_card *card) + return err; + + hw->iface = SNDRV_HWDEP_IFACE_USX2Y_PCM; +- hw->private_data = usX2Y(card); +- hw->private_free = snd_usX2Y_hwdep_pcm_private_free; +- hw->ops.open = snd_usX2Y_hwdep_pcm_open; +- hw->ops.release = snd_usX2Y_hwdep_pcm_release; +- hw->ops.mmap = snd_usX2Y_hwdep_pcm_mmap; ++ hw->private_data = usx2y(card); ++ hw->private_free = snd_usx2y_hwdep_pcm_private_free; ++ hw->ops.open = snd_usx2y_hwdep_pcm_open; ++ hw->ops.release = snd_usx2y_hwdep_pcm_release; ++ hw->ops.mmap = snd_usx2y_hwdep_pcm_mmap; + hw->exclusive = 1; + sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm", dev->bus->busnum, dev->devnum); + +@@ -718,10 +718,10 @@ int usX2Y_hwdep_pcm_new(struct snd_card *card) + if (err < 0) { + return err; + } +- snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usX2Y_usbpcm_ops); +- snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usX2Y_usbpcm_ops); ++ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_usx2y_usbpcm_ops); ++ snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_usx2y_usbpcm_ops); + +- pcm->private_data = usX2Y(card)->subs; ++ pcm->private_data = usx2y(card)->subs; + pcm->info_flags = 0; + + sprintf(pcm->name, NAME_ALLCAPS" hwdep Audio"); +@@ -739,7 +739,7 @@ int usX2Y_hwdep_pcm_new(struct snd_card *card) + + #else + +-int usX2Y_hwdep_pcm_new(struct snd_card *card) ++int usx2y_hwdep_pcm_new(struct snd_card *card) + { + return 0; + } +diff --git a/sound/usb/usx2y/usx2yhwdeppcm.h b/sound/usb/usx2y/usx2yhwdeppcm.h +index eb5a46466f0e6..731b1c5a34741 100644 +--- a/sound/usb/usx2y/usx2yhwdeppcm.h ++++ b/sound/usb/usx2y/usx2yhwdeppcm.h +@@ -4,7 +4,7 @@ + #define MAXSTRIDE 3 + + #define SSS (((MAXPACK*MAXBUFFERMS*MAXSTRIDE + 4096) / 4096) * 4096) +-struct snd_usX2Y_hwdep_pcm_shm { ++struct snd_usx2y_hwdep_pcm_shm { + char playback[SSS]; + char capture0x8[SSS]; + char capture0xA[SSS]; +@@ -20,4 +20,4 @@ struct snd_usX2Y_hwdep_pcm_shm { + int capture_iso_start; + }; + +-int usX2Y_hwdep_pcm_new(struct snd_card *card); ++int usx2y_hwdep_pcm_new(struct snd_card *card); +diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c +index 23dc5014e7119..a61be9c075656 100644 +--- a/tools/perf/util/scripting-engines/trace-event-python.c ++++ b/tools/perf/util/scripting-engines/trace-event-python.c +@@ -687,7 +687,7 @@ static void set_sample_datasrc_in_dict(PyObject *dict, + _PyUnicode_FromString(decode)); + } + +-static int regs_map(struct regs_dump *regs, uint64_t mask, char *bf, int size) ++static void regs_map(struct regs_dump *regs, uint64_t mask, char *bf, int size) + { + unsigned int i = 0, r; + int printed = 0; +@@ -695,7 +695,7 @@ static int regs_map(struct regs_dump *regs, uint64_t mask, char *bf, int size) + bf[0] = 0; + + if (!regs || !regs->regs) +- return 0; ++ return; + + for_each_set_bit(r, (unsigned long *) &mask, sizeof(mask) * 8) { + u64 val = regs->regs[i++]; +@@ -704,8 +704,6 @@ static int regs_map(struct regs_dump *regs, uint64_t mask, char *bf, int size) + "%5s:0x%" PRIx64 " ", + perf_reg_name(r), val); + } +- +- return printed; + } + + static void set_regs_in_dict(PyObject *dict, +@@ -713,7 +711,16 @@ static void set_regs_in_dict(PyObject *dict, + struct evsel *evsel) + { + struct perf_event_attr *attr = &evsel->core.attr; +- char bf[512]; ++ ++ /* ++ * Here value 28 is a constant size which can be used to print ++ * one register value and its corresponds to: ++ * 16 chars is to specify 64 bit register in hexadecimal. ++ * 2 chars is for appending "0x" to the hexadecimal value and ++ * 10 chars is for register name. ++ */ ++ int size = __sw_hweight64(attr->sample_regs_intr) * 28; ++ char bf[size]; + + regs_map(&sample->intr_regs, attr->sample_regs_intr, bf, sizeof(bf)); + +diff --git a/tools/testing/selftests/powerpc/pmu/ebb/no_handler_test.c b/tools/testing/selftests/powerpc/pmu/ebb/no_handler_test.c +index fc5bf4870d8e6..01e827c31169d 100644 +--- a/tools/testing/selftests/powerpc/pmu/ebb/no_handler_test.c ++++ b/tools/testing/selftests/powerpc/pmu/ebb/no_handler_test.c +@@ -50,8 +50,6 @@ static int no_handler_test(void) + + event_close(&event); + +- dump_ebb_state(); +- + /* The real test is that we never took an EBB at 0x0 */ + + return 0; +diff --git a/tools/testing/selftests/timers/rtcpie.c b/tools/testing/selftests/timers/rtcpie.c +index 47b5bad1b3933..4ef2184f15588 100644 +--- a/tools/testing/selftests/timers/rtcpie.c ++++ b/tools/testing/selftests/timers/rtcpie.c +@@ -18,6 +18,8 @@ + #include + #include + ++#include "../kselftest.h" ++ + /* + * This expects the new RTC class driver framework, working with + * clocks that will often not be clones of what the PC-AT had. +@@ -35,8 +37,14 @@ int main(int argc, char **argv) + switch (argc) { + case 2: + rtc = argv[1]; +- /* FALLTHROUGH */ ++ break; + case 1: ++ fd = open(default_rtc, O_RDONLY); ++ if (fd == -1) { ++ printf("Default RTC %s does not exist. Test Skipped!\n", default_rtc); ++ exit(KSFT_SKIP); ++ } ++ close(fd); + break; + default: + fprintf(stderr, "usage: rtctest [rtcdev] [d]\n"); +diff --git a/virt/kvm/coalesced_mmio.c b/virt/kvm/coalesced_mmio.c +index f08f5e82460b1..0be80c213f7f2 100644 +--- a/virt/kvm/coalesced_mmio.c ++++ b/virt/kvm/coalesced_mmio.c +@@ -186,7 +186,6 @@ int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm, + coalesced_mmio_in_range(dev, zone->addr, zone->size)) { + r = kvm_io_bus_unregister_dev(kvm, + zone->pio ? KVM_PIO_BUS : KVM_MMIO_BUS, &dev->dev); +- kvm_iodevice_destructor(&dev->dev); + + /* + * On failure, unregister destroys all devices on the +@@ -196,6 +195,7 @@ int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm, + */ + if (r) + break; ++ kvm_iodevice_destructor(&dev->dev); + } + } + diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 3b6070f..0000000 --- a/LICENSE +++ /dev/null @@ -1,311 +0,0 @@ -GNU GENERAL PUBLIC LICENSE -Version 2, June 1991 - -Copyright (C) 1989, 1991 Free Software Foundation, Inc. -51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA - -Everyone is permitted to copy and distribute verbatim copies of this license -document, but changing it is not allowed. - -Preamble - -The licenses for most software are designed to take away your freedom to share -and change it. By contrast, the GNU General Public License is intended to -guarantee your freedom to share and change free software--to make sure the -software is free for all its users. This General Public License applies to -most of the Free Software Foundation's software and to any other program whose -authors commit to using it. (Some other Free Software Foundation software -is covered by the GNU Lesser General Public License instead.) You can apply -it to your programs, too. - -When we speak of free software, we are referring to freedom, not price. Our -General Public Licenses are designed to make sure that you have the freedom -to distribute copies of free software (and charge for this service if you -wish), that you receive source code or can get it if you want it, that you -can change the software or use pieces of it in new free programs; and that -you know you can do these things. - -To protect your rights, we need to make restrictions that forbid anyone to -deny you these rights or to ask you to surrender the rights. These restrictions -translate to certain responsibilities for you if you distribute copies of -the software, or if you modify it. - -For example, if you distribute copies of such a program, whether gratis or -for a fee, you must give the recipients all the rights that you have. You -must make sure that they, too, receive or can get the source code. And you -must show them these terms so they know their rights. - -We protect your rights with two steps: (1) copyright the software, and (2) -offer you this license which gives you legal permission to copy, distribute -and/or modify the software. - -Also, for each author's protection and ours, we want to make certain that -everyone understands that there is no warranty for this free software. If -the software is modified by someone else and passed on, we want its recipients -to know that what they have is not the original, so that any problems introduced -by others will not reflect on the original authors' reputations. - -Finally, any free program is threatened constantly by software patents. We -wish to avoid the danger that redistributors of a free program will individually -obtain patent licenses, in effect making the program proprietary. To prevent -this, we have made it clear that any patent must be licensed for everyone's -free use or not licensed at all. - -The precise terms and conditions for copying, distribution and modification -follow. - -TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - -0. This License applies to any program or other work which contains a notice -placed by the copyright holder saying it may be distributed under the terms -of this General Public License. The "Program", below, refers to any such program -or work, and a "work based on the Program" means either the Program or any -derivative work under copyright law: that is to say, a work containing the -Program or a portion of it, either verbatim or with modifications and/or translated -into another language. (Hereinafter, translation is included without limitation -in the term "modification".) Each licensee is addressed as "you". - -Activities other than copying, distribution and modification are not covered -by this License; they are outside its scope. The act of running the Program -is not restricted, and the output from the Program is covered only if its -contents constitute a work based on the Program (independent of having been -made by running the Program). Whether that is true depends on what the Program -does. - -1. You may copy and distribute verbatim copies of the Program's source code -as you receive it, in any medium, provided that you conspicuously and appropriately -publish on each copy an appropriate copyright notice and disclaimer of warranty; -keep intact all the notices that refer to this License and to the absence -of any warranty; and give any other recipients of the Program a copy of this -License along with the Program. - -You may charge a fee for the physical act of transferring a copy, and you -may at your option offer warranty protection in exchange for a fee. - -2. You may modify your copy or copies of the Program or any portion of it, -thus forming a work based on the Program, and copy and distribute such modifications -or work under the terms of Section 1 above, provided that you also meet all -of these conditions: - -a) You must cause the modified files to carry prominent notices stating that -you changed the files and the date of any change. - -b) You must cause any work that you distribute or publish, that in whole or -in part contains or is derived from the Program or any part thereof, to be -licensed as a whole at no charge to all third parties under the terms of this -License. - -c) If the modified program normally reads commands interactively when run, -you must cause it, when started running for such interactive use in the most -ordinary way, to print or display an announcement including an appropriate -copyright notice and a notice that there is no warranty (or else, saying that -you provide a warranty) and that users may redistribute the program under -these conditions, and telling the user how to view a copy of this License. -(Exception: if the Program itself is interactive but does not normally print -such an announcement, your work based on the Program is not required to print -an announcement.) - -These requirements apply to the modified work as a whole. If identifiable -sections of that work are not derived from the Program, and can be reasonably -considered independent and separate works in themselves, then this License, -and its terms, do not apply to those sections when you distribute them as -separate works. But when you distribute the same sections as part of a whole -which is a work based on the Program, the distribution of the whole must be -on the terms of this License, whose permissions for other licensees extend -to the entire whole, and thus to each and every part regardless of who wrote -it. - -Thus, it is not the intent of this section to claim rights or contest your -rights to work written entirely by you; rather, the intent is to exercise -the right to control the distribution of derivative or collective works based -on the Program. - -In addition, mere aggregation of another work not based on the Program with -the Program (or with a work based on the Program) on a volume of a storage -or distribution medium does not bring the other work under the scope of this -License. - -3. You may copy and distribute the Program (or a work based on it, under Section -2) in object code or executable form under the terms of Sections 1 and 2 above -provided that you also do one of the following: - -a) Accompany it with the complete corresponding machine-readable source code, -which must be distributed under the terms of Sections 1 and 2 above on a medium -customarily used for software interchange; or, - -b) Accompany it with a written offer, valid for at least three years, to give -any third party, for a charge no more than your cost of physically performing -source distribution, a complete machine-readable copy of the corresponding -source code, to be distributed under the terms of Sections 1 and 2 above on -a medium customarily used for software interchange; or, - -c) Accompany it with the information you received as to the offer to distribute -corresponding source code. (This alternative is allowed only for noncommercial -distribution and only if you received the program in object code or executable -form with such an offer, in accord with Subsection b above.) - -The source code for a work means the preferred form of the work for making -modifications to it. For an executable work, complete source code means all -the source code for all modules it contains, plus any associated interface -definition files, plus the scripts used to control compilation and installation -of the executable. However, as a special exception, the source code distributed -need not include anything that is normally distributed (in either source or -binary form) with the major components (compiler, kernel, and so on) of the -operating system on which the executable runs, unless that component itself -accompanies the executable. - -If distribution of executable or object code is made by offering access to -copy from a designated place, then offering equivalent access to copy the -source code from the same place counts as distribution of the source code, -even though third parties are not compelled to copy the source along with -the object code. - -4. You may not copy, modify, sublicense, or distribute the Program except -as expressly provided under this License. Any attempt otherwise to copy, modify, -sublicense or distribute the Program is void, and will automatically terminate -your rights under this License. However, parties who have received copies, -or rights, from you under this License will not have their licenses terminated -so long as such parties remain in full compliance. - -5. You are not required to accept this License, since you have not signed -it. However, nothing else grants you permission to modify or distribute the -Program or its derivative works. These actions are prohibited by law if you -do not accept this License. Therefore, by modifying or distributing the Program -(or any work based on the Program), you indicate your acceptance of this License -to do so, and all its terms and conditions for copying, distributing or modifying -the Program or works based on it. - -6. Each time you redistribute the Program (or any work based on the Program), -the recipient automatically receives a license from the original licensor -to copy, distribute or modify the Program subject to these terms and conditions. -You may not impose any further restrictions on the recipients' exercise of -the rights granted herein. You are not responsible for enforcing compliance -by third parties to this License. - -7. If, as a consequence of a court judgment or allegation of patent infringement -or for any other reason (not limited to patent issues), conditions are imposed -on you (whether by court order, agreement or otherwise) that contradict the -conditions of this License, they do not excuse you from the conditions of -this License. If you cannot distribute so as to satisfy simultaneously your -obligations under this License and any other pertinent obligations, then as -a consequence you may not distribute the Program at all. For example, if a -patent license would not permit royalty-free redistribution of the Program -by all those who receive copies directly or indirectly through you, then the -only way you could satisfy both it and this License would be to refrain entirely -from distribution of the Program. - -If any portion of this section is held invalid or unenforceable under any -particular circumstance, the balance of the section is intended to apply and -the section as a whole is intended to apply in other circumstances. - -It is not the purpose of this section to induce you to infringe any patents -or other property right claims or to contest validity of any such claims; -this section has the sole purpose of protecting the integrity of the free -software distribution system, which is implemented by public license practices. -Many people have made generous contributions to the wide range of software -distributed through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing to -distribute software through any other system and a licensee cannot impose -that choice. - -This section is intended to make thoroughly clear what is believed to be a -consequence of the rest of this License. - -8. If the distribution and/or use of the Program is restricted in certain -countries either by patents or by copyrighted interfaces, the original copyright -holder who places the Program under this License may add an explicit geographical -distribution limitation excluding those countries, so that distribution is -permitted only in or among countries not thus excluded. In such case, this -License incorporates the limitation as if written in the body of this License. - -9. The Free Software Foundation may publish revised and/or new versions of -the General Public License from time to time. Such new versions will be similar -in spirit to the present version, but may differ in detail to address new -problems or concerns. - -Each version is given a distinguishing version number. If the Program specifies -a version number of this License which applies to it and "any later version", -you have the option of following the terms and conditions either of that version -or of any later version published by the Free Software Foundation. If the -Program does not specify a version number of this License, you may choose -any version ever published by the Free Software Foundation. - -10. If you wish to incorporate parts of the Program into other free programs -whose distribution conditions are different, write to the author to ask for -permission. For software which is copyrighted by the Free Software Foundation, -write to the Free Software Foundation; we sometimes make exceptions for this. -Our decision will be guided by the two goals of preserving the free status -of all derivatives of our free software and of promoting the sharing and reuse -of software generally. - -NO WARRANTY - -11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR -THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE -STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM -"AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, -BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS -FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE -OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME -THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - -12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE -THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY -GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE -OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA -OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES -OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH -HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. - -END OF TERMS AND CONDITIONS - -How to Apply These Terms to Your New Programs - -If you develop a new program, and you want it to be of the greatest possible -use to the public, the best way to achieve this is to make it free software -which everyone can redistribute and change under these terms. - -To do so, attach the following notices to the program. It is safest to attach -them to the start of each source file to most effectively convey the exclusion -of warranty; and each file should have at least the "copyright" line and a -pointer to where the full notice is found. - -one line to give the program's name and an idea of what it does. Copyright -(C) yyyy name of author - -This program is free software; you can redistribute it and/or modify it under -the terms of the GNU General Public License as published by the Free Software -Foundation; either version 2 of the License, or (at your option) any later -version. - -This program is distributed in the hope that it will be useful, but WITHOUT -ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with -this program; if not, write to the Free Software Foundation, Inc., 51 Franklin -Street, Fifth Floor, Boston, MA 02110-1301, USA. Also add information on how -to contact you by electronic and paper mail. - -If the program is interactive, make it output a short notice like this when -it starts in an interactive mode: - -Gnomovision version 69, Copyright (C) year name of author Gnomovision comes -with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, -and you are welcome to redistribute it under certain conditions; type `show -c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, the commands you use may be -called something other than `show w' and `show c'; they could even be mouse-clicks -or menu items--whatever suits your program. - -You should also get your employer (if you work as a programmer) or your school, -if any, to sign a "copyright disclaimer" for the program, if necessary. Here -is a sample; alter the names: - -Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' -(which makes passes at compilers) written by James Hacker. - -signature of Ty Coon, 1 April 1989 Ty Coon, President of Vice diff --git a/PKGBUILD b/PKGBUILD index 02d6481..21b2296 100644 --- a/PKGBUILD +++ b/PKGBUILD @@ -1,11 +1,11 @@ # Contributor: Danct12 # Maintainer: Danct12 -# Modified by Caleb Fontenot (CCF_100) + buildarch=8 pkgbase=linux-pine64 _desc="Pine64 PinePhone" -pkgver=5.13 +pkgver=5.12.19 pkgrel=1 arch=('aarch64') url="https://github.com/megous/linux" @@ -14,7 +14,7 @@ makedepends=('xmlto' 'docbook-xsl' 'kmod' 'inetutils' 'bc' 'git' 'uboot-tools' ' options=('!strip') # Source -_commit="3eeeb82a1599049c86fe8720e2665fe00cfbe4a1" +_commit="c405805c3561a0b09809a5f236378c32be007163" source=("linux-$_commit.tar.gz::https://github.com/megous/linux/archive/${_commit}.tar.gz" 'config' 'enable-hdmi-output-pinetab.patch' @@ -26,6 +26,7 @@ source=("linux-$_commit.tar.gz::https://github.com/megous/linux/archive/${_commi '0002-dts-add-pinetab-dev-old-display-panel.patch' '0013-fix-pogopin-i2c.patch' 'dts-pinephone-drop-modem-power-node.patch' + '5.12.17-19.diff' 'linux.preset' '60-linux.hook' '90-linux.hook' @@ -44,48 +45,48 @@ source=("linux-$_commit.tar.gz::https://github.com/megous/linux/archive/${_commi '0010-bootsplash.patch' '0011-bootsplash.patch' '0012-bootsplash.patch' - 'ec25.patch' - 'cacule-5.13.patch' - 'rdb-5.13.patch') + 'cacule-5.12.patch' + 'rdb-5.12.patch') prepare() { cd linux-$_commit + # 5.12.17 -> 5.12.19 + patch -p1 -N -i "../5.12.17-19.diff" || true + # PinePhone patches - #patch -p1 -N < ../0013-fix-pogopin-i2c.patch - #patch -p1 -N < ../dts-pinephone-drop-modem-power-node.patch + patch -p1 -N < ../0013-fix-pogopin-i2c.patch + patch -p1 -N < ../dts-pinephone-drop-modem-power-node.patch # camera patch -p1 -N < ../media-ov5640-Implement-autofocus.patch # PineTab patches - #patch -p1 -N < ../pinetab-bluetooth.patch - #patch -p1 -N < ../pinetab-accelerometer.patch - #patch -p1 -N < ../0002-dts-add-pinetab-dev-old-display-panel.patch - #patch -p1 -N < ../enable-jack-detection-pinetab.patch - #patch -p1 -N < ../enable-hdmi-output-pinetab.patch + patch -p1 -N < ../pinetab-bluetooth.patch + patch -p1 -N < ../pinetab-accelerometer.patch + patch -p1 -N < ../0002-dts-add-pinetab-dev-old-display-panel.patch + patch -p1 -N < ../enable-jack-detection-pinetab.patch + patch -p1 -N < ../enable-hdmi-output-pinetab.patch - # bootsplash stuffs (took from glorious manjaro arm) + # bootsplash stuffs patch -Np1 -i "${srcdir}/0001-revert-fbcon-remove-now-unusued-softback_lines-cursor-argument.patch" patch -Np1 -i "${srcdir}/0002-revert-fbcon-remove-no-op-fbcon_set_origin.patch" patch -Np1 -i "${srcdir}/0003-revert-fbcon-remove-soft-scrollback-code.patch" - #patch -Np1 -i "${srcdir}/0001-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0002-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0003-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0004-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0005-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0006-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0007-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0008-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0009-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0010-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0011-bootsplash.patch" - #patch -Np1 -i "${srcdir}/0012-bootsplash.patch" + patch -Np1 -i "${srcdir}/0001-bootsplash.patch" + patch -Np1 -i "${srcdir}/0002-bootsplash.patch" + patch -Np1 -i "${srcdir}/0003-bootsplash.patch" + patch -Np1 -i "${srcdir}/0004-bootsplash.patch" + patch -Np1 -i "${srcdir}/0005-bootsplash.patch" + patch -Np1 -i "${srcdir}/0006-bootsplash.patch" + patch -Np1 -i "${srcdir}/0007-bootsplash.patch" + patch -Np1 -i "${srcdir}/0008-bootsplash.patch" + patch -Np1 -i "${srcdir}/0009-bootsplash.patch" + patch -Np1 -i "${srcdir}/0010-bootsplash.patch" + patch -Np1 -i "${srcdir}/0011-bootsplash.patch" + patch -Np1 -i "${srcdir}/0012-bootsplash.patch" # CacULE - patch -Np1 -i "${srcdir}/cacule-5.13.patch" - patch -Np1 -i "${srcdir}/rdb-5.13.patch" - # FOSS Modem stuff - patch -Np1 -i "${srcdir}/ec25.patch" + patch -Np1 -i "${srcdir}/cacule-5.12.patch" + patch -Np1 -i "${srcdir}/rdb-5.12.patch" cat "${srcdir}/config" > ./.config # add pkgrel to extraversion @@ -93,7 +94,7 @@ prepare() { # don't run depmod on 'make install'. We'll do this ourselves in packaging sed -i '2iexit 0' scripts/depmod.sh - + # Fix DistCC compatibility sed -i '/HAVE_GCC_PLUGINS/d' arch/x86/Kconfig } @@ -247,20 +248,20 @@ _package-headers() { # Fix permissions chmod -R u=rwX,go=rX "${_builddir}" - #echo "Stripping build tools..." - #local _binary _strip - #while read -rd '' _binary; do - #case "$(file -bi "${_binary}")" in - #*application/x-sharedlib*) _strip="${STRIP_SHARED}" ;; # Libraries (.so) - #*application/x-archive*) _strip="${STRIP_STATIC}" ;; # Libraries (.a) - #*application/x-executable*) _strip="${STRIP_BINARIES}" ;; # Binaries - #*) continue ;; - #esac - #strip ${_strip} "${_binary}" - #done < <(find "${_builddir}/scripts" -type f -perm -u+w -print0 2>/dev/null) + echo "Stripping build tools..." + local _binary _strip + while read -rd '' _binary; do + case "$(file -bi "${_binary}")" in + *application/x-sharedlib*) _strip="${STRIP_SHARED}" ;; # Libraries (.so) + *application/x-archive*) _strip="${STRIP_STATIC}" ;; # Libraries (.a) + *application/x-executable*) _strip="${STRIP_BINARIES}" ;; # Binaries + *) continue ;; + esac + strip ${_strip} "${_binary}" + done < <(find "${_builddir}/scripts" -type f -perm -u+w -print0 2>/dev/null) - #echo "Stripping vmlinux..." - #${CROSS_COMPILE}strip -v ${STRIP_STATIC} "${_builddir}/vmlinux" + echo "Stripping vmlinux..." + ${CROSS_COMPILE}strip -v ${STRIP_STATIC} "${_builddir}/vmlinux" } pkgname=("$pkgbase" "$pkgbase-headers") @@ -271,7 +272,7 @@ for _p in "${pkgname[@]}"; do }" done -md5sums=('SKIP' +md5sums=('8959691f8cba631e5a2eca74898b8f3c' 'SKIP' '979a787cf84bef9c60da78e72ec96550' 'f79300740a7350d2d24ab5e120831b52' @@ -282,6 +283,7 @@ md5sums=('SKIP' '3182f25beb0b76e8abd2e9de8213351d' 'c2b0ee1805e10cba7072cbcae67830b2' '10d200e0a964f24cdb744678a758e22b' + 'c846408cdabe7978a687fa3648f3c96f' '86d4a35722b5410e3b29fc92dae15d4b' 'ce6c81ad1ad1f8b333fd6077d47abdaf' '3dc88030a8f2f5a5f97266d99b149f77' @@ -300,6 +302,5 @@ md5sums=('SKIP' '1922e3a7727d2bf51641b98d6d354738' 'd6b7e4e43e42128cf950251e0d0aee23' 'ecfd8a30c480149005fcf349e4d06f4b' - 'SKIP' - 'SKIP' - 'SKIP') + 'SKIP' + 'SKIP') diff --git a/README.md b/README.md index 935330f..1c88382 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,10 @@ -pinephone-linux +# pinephone-linux -This is a PKGBUILD modified from https://github.com/dreemurrs-embedded/Pine64-Arch/tree/master/PKGBUILDS/pine64/linux-pine64\ +This is a PKGBUILD modified from https://github.com/dreemurrs-embedded/Pine64-Arch/tree/master/PKGBUILDS/pine64/linux-pine64 \ \ Added patches include:\ - CacULE\ - eg25 modem patches to support higher audio bitrates + +On github? Main repository is at https://ccf100.duckdns.org/gitea/CCF_100/pinephone-linux \ +Github Mirror: https://github.com/CCF100/pinephone-linux diff --git a/cacule-5.13.patch b/cacule-5.13.patch deleted file mode 100644 index b08df63..0000000 --- a/cacule-5.13.patch +++ /dev/null @@ -1,1299 +0,0 @@ -diff --git a/Documentation/admin-guide/sysctl/kernel.rst b/Documentation/admin-guide/sysctl/kernel.rst -index 68b21395a743..3f4b9c6911be 100644 ---- a/Documentation/admin-guide/sysctl/kernel.rst -+++ b/Documentation/admin-guide/sysctl/kernel.rst -@@ -1088,6 +1088,10 @@ Model available). If your platform happens to meet the - requirements for EAS but you do not want to use it, change - this value to 0. - -+sched_interactivity_factor (CacULE scheduler only) -+================================================== -+Sets the value *m* for interactivity score calculations. See -+Figure 1 in https://web.cs.ucdavis.edu/~roper/ecs150/ULE.pdf - - sched_schedstats - ================ -diff --git a/Documentation/scheduler/sched-CacULE.rst b/Documentation/scheduler/sched-CacULE.rst -new file mode 100644 -index 000000000000..82b0847c468a ---- /dev/null -+++ b/Documentation/scheduler/sched-CacULE.rst -@@ -0,0 +1,76 @@ -+====================================== -+The CacULE Scheduler by Hamad Al Marri. -+====================================== -+ -+1. Overview -+============= -+ -+The CacULE CPU scheduler is based on interactivity score mechanism. -+The interactivity score is inspired by the ULE scheduler (FreeBSD -+scheduler). -+ -+1.1 About CacULE Scheduler -+-------------------------- -+ -+ - Each CPU has its own runqueue. -+ -+ - NORMAL runqueue is a linked list of sched_entities (instead of RB-Tree). -+ -+ - RT and other runqueues are just the same as the CFS's. -+ -+ - Wake up tasks preempt currently running tasks if its interactivity score value -+ is higher. -+ -+ -+1.2. Complexity -+---------------- -+ -+The complexity of Enqueue and Dequeue a task is O(1). -+ -+The complexity of pick the next task is in O(n), where n is the number of tasks -+in a runqueue (each CPU has its own runqueue). -+ -+Note: O(n) sounds scary, but usually for a machine with 4 CPUS where it is used -+for desktop or mobile jobs, the maximum number of runnable tasks might not -+exceeds 10 (at the pick next run time) - the idle tasks are excluded since they -+are dequeued when sleeping and enqueued when they wake up. -+ -+ -+2. The CacULE Interactivity Score -+======================================================= -+ -+The interactivity score is inspired by the ULE scheduler (FreeBSD scheduler). -+For more information see: https://web.cs.ucdavis.edu/~roper/ecs150/ULE.pdf -+CacULE doesn't replace CFS with ULE, it only changes the CFS' pick next task -+mechanism to ULE's interactivity score mechanism for picking next task to run. -+ -+ -+2.3 sched_interactivity_factor -+================= -+Sets the value *m* for interactivity score calculations. See Figure 1 in -+https://web.cs.ucdavis.edu/~roper/ecs150/ULE.pdf -+The default value of in CacULE is 10 which means that the Maximum Interactive -+Score is 20 (since m = Maximum Interactive Score / 2). -+You can tune sched_interactivity_factor with sysctl command: -+ -+ sysctl kernel.sched_interactivity_factor=50 -+ -+This command changes the sched_interactivity_factor from 10 to 50. -+ -+ -+3. Scheduling policies -+======================= -+ -+CacULE some CFS, implements three scheduling policies: -+ -+ - SCHED_NORMAL (traditionally called SCHED_OTHER): The scheduling -+ policy that is used for regular tasks. -+ -+ - SCHED_BATCH: Does not preempt nearly as often as regular tasks -+ would, thereby allowing tasks to run longer and make better use of -+ caches but at the cost of interactivity. This is well suited for -+ batch jobs. -+ -+ - SCHED_IDLE: This is even weaker than nice 19, but its not a true -+ idle timer scheduler in order to avoid to get into priority -+ inversion problems which would deadlock the machine. -diff --git a/include/linux/sched.h b/include/linux/sched.h -index d2c881384517..0be8e440d720 100644 ---- a/include/linux/sched.h -+++ b/include/linux/sched.h -@@ -450,10 +450,22 @@ struct sched_statistics { - #endif - }; - -+#ifdef CONFIG_CACULE_SCHED -+struct cacule_node { -+ struct cacule_node* next; -+ struct cacule_node* prev; -+ u64 cacule_start_time; -+ u64 vruntime; -+}; -+#endif -+ - struct sched_entity { - /* For load-balancing: */ - struct load_weight load; - struct rb_node run_node; -+#ifdef CONFIG_CACULE_SCHED -+ struct cacule_node cacule_node; -+#endif - struct list_head group_node; - unsigned int on_rq; - -diff --git a/include/linux/sched/sysctl.h b/include/linux/sched/sysctl.h -index db2c0f34aaaf..5a66fc5826fc 100644 ---- a/include/linux/sched/sysctl.h -+++ b/include/linux/sched/sysctl.h -@@ -32,6 +32,12 @@ extern unsigned int sysctl_sched_latency; - extern unsigned int sysctl_sched_min_granularity; - extern unsigned int sysctl_sched_wakeup_granularity; - -+#ifdef CONFIG_CACULE_SCHED -+extern unsigned int interactivity_factor; -+extern unsigned int interactivity_threshold; -+extern unsigned int cacule_max_lifetime; -+#endif -+ - enum sched_tunable_scaling { - SCHED_TUNABLESCALING_NONE, - SCHED_TUNABLESCALING_LOG, -diff --git a/init/Kconfig b/init/Kconfig -index a61c92066c2e..089e3bfe5dbc 100644 ---- a/init/Kconfig -+++ b/init/Kconfig -@@ -834,6 +834,17 @@ config UCLAMP_BUCKETS_COUNT - - endmenu - -+config CACULE_SCHED -+ bool "CacULE CPU scheduler" -+ default y -+ help -+ The CacULE CPU scheduler is based on interactivity score mechanism. -+ The interactivity score is inspired by the ULE scheduler (FreeBSD -+ scheduler). -+ -+ If unsure, say Y here. -+ -+ - # - # For architectures that want to enable the support for NUMA-affine scheduler - # balancing logic: -@@ -1231,6 +1242,7 @@ config SCHED_AUTOGROUP - select CGROUPS - select CGROUP_SCHED - select FAIR_GROUP_SCHED -+ default y - help - This option optimizes the scheduler for common desktop workloads by - automatically creating and populating task groups. This separation -diff --git a/kernel/Kconfig.hz b/kernel/Kconfig.hz -index 38ef6d06888e..865f8dbddca8 100644 ---- a/kernel/Kconfig.hz -+++ b/kernel/Kconfig.hz -@@ -46,6 +46,9 @@ choice - 1000 Hz is the preferred choice for desktop systems and other - systems requiring fast interactive responses to events. - -+ config HZ_2000 -+ bool "2000 HZ" -+ - endchoice - - config HZ -@@ -54,6 +57,7 @@ config HZ - default 250 if HZ_250 - default 300 if HZ_300 - default 1000 if HZ_1000 -+ default 2000 if HZ_2000 - - config SCHED_HRTICK - def_bool HIGH_RES_TIMERS -diff --git a/kernel/sched/core.c b/kernel/sched/core.c -index 5226cc26a095..8505beec4e99 100644 ---- a/kernel/sched/core.c -+++ b/kernel/sched/core.c -@@ -3574,6 +3574,11 @@ static void __sched_fork(unsigned long clone_flags, struct task_struct *p) - p->se.prev_sum_exec_runtime = 0; - p->se.nr_migrations = 0; - p->se.vruntime = 0; -+ -+#ifdef CONFIG_CACULE_SCHED -+ p->se.cacule_node.vruntime = 0; -+#endif -+ - INIT_LIST_HEAD(&p->se.group_node); - - #ifdef CONFIG_FAIR_GROUP_SCHED -@@ -3859,6 +3864,10 @@ void wake_up_new_task(struct task_struct *p) - update_rq_clock(rq); - post_init_entity_util_avg(p); - -+#ifdef CONFIG_CACULE_SCHED -+ p->se.cacule_node.cacule_start_time = sched_clock(); -+#endif -+ - activate_task(rq, p, ENQUEUE_NOCLOCK); - trace_sched_wakeup_new(p); - check_preempt_curr(rq, p, WF_FORK); -@@ -8103,6 +8112,10 @@ void __init sched_init(void) - BUG_ON(&dl_sched_class + 1 != &stop_sched_class); - #endif - -+#ifdef CONFIG_CACULE_SCHED -+ printk(KERN_INFO "CacULE CPU scheduler v5.13 by Hamad Al Marri."); -+#endif -+ - wait_bit_init(); - - #ifdef CONFIG_FAIR_GROUP_SCHED -diff --git a/kernel/sched/debug.c b/kernel/sched/debug.c -index 9c882f20803e..1af3163f5b73 100644 ---- a/kernel/sched/debug.c -+++ b/kernel/sched/debug.c -@@ -560,8 +560,11 @@ static void print_rq(struct seq_file *m, struct rq *rq, int rq_cpu) - - void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq) - { -- s64 MIN_vruntime = -1, min_vruntime, max_vruntime = -1, -- spread, rq0_min_vruntime, spread0; -+ s64 MIN_vruntime = -1, max_vruntime = -1, -+#if !defined(CONFIG_CACULE_SCHED) -+ min_vruntime, rq0_min_vruntime, spread0, -+#endif -+ spread; - struct rq *rq = cpu_rq(cpu); - struct sched_entity *last; - unsigned long flags; -@@ -582,21 +585,27 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq) - last = __pick_last_entity(cfs_rq); - if (last) - max_vruntime = last->vruntime; -+#if !defined(CONFIG_CACULE_SCHED) - min_vruntime = cfs_rq->min_vruntime; - rq0_min_vruntime = cpu_rq(0)->cfs.min_vruntime; -+#endif - raw_spin_unlock_irqrestore(&rq->lock, flags); - SEQ_printf(m, " .%-30s: %Ld.%06ld\n", "MIN_vruntime", - SPLIT_NS(MIN_vruntime)); -+#if !defined(CONFIG_CACULE_SCHED) - SEQ_printf(m, " .%-30s: %Ld.%06ld\n", "min_vruntime", - SPLIT_NS(min_vruntime)); -+#endif - SEQ_printf(m, " .%-30s: %Ld.%06ld\n", "max_vruntime", - SPLIT_NS(max_vruntime)); - spread = max_vruntime - MIN_vruntime; - SEQ_printf(m, " .%-30s: %Ld.%06ld\n", "spread", - SPLIT_NS(spread)); -+#if !defined(CONFIG_CACULE_SCHED) - spread0 = min_vruntime - rq0_min_vruntime; - SEQ_printf(m, " .%-30s: %Ld.%06ld\n", "spread0", - SPLIT_NS(spread0)); -+#endif - SEQ_printf(m, " .%-30s: %d\n", "nr_spread_over", - cfs_rq->nr_spread_over); - SEQ_printf(m, " .%-30s: %d\n", "nr_running", cfs_rq->nr_running); -diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c -index 3248e24a90b0..5bc521731064 100644 ---- a/kernel/sched/fair.c -+++ b/kernel/sched/fair.c -@@ -19,9 +19,25 @@ - * - * Adaptive scheduling granularity, math enhancements by Peter Zijlstra - * Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra -+ * -+ * CacULE enhancements CPU cache and scheduler based on -+ * Interactivity Score. -+ * (C) 2020 Hamad Al Marri - */ - #include "sched.h" - -+#ifdef CONFIG_CACULE_SCHED -+unsigned int __read_mostly cacule_max_lifetime = 22000; // in ms -+unsigned int __read_mostly interactivity_factor = 32768; -+ -+#ifdef CONFIG_FAIR_GROUP_SCHED -+unsigned int __read_mostly interactivity_threshold = 0; -+#else -+unsigned int __read_mostly interactivity_threshold = 1000; -+#endif -+ -+#endif -+ - /* - * Targeted preemption latency for CPU-bound tasks: - * -@@ -82,7 +98,11 @@ unsigned int sysctl_sched_child_runs_first __read_mostly; - unsigned int sysctl_sched_wakeup_granularity = 1000000UL; - static unsigned int normalized_sysctl_sched_wakeup_granularity = 1000000UL; - -+#ifdef CONFIG_CACULE_SCHED -+const_debug unsigned int sysctl_sched_migration_cost = 200000UL; -+#else - const_debug unsigned int sysctl_sched_migration_cost = 500000UL; -+#endif - - int sched_thermal_decay_shift; - static int __init setup_sched_thermal_decay_shift(char *str) -@@ -263,6 +283,14 @@ static u64 __calc_delta(u64 delta_exec, unsigned long weight, struct load_weight - - const struct sched_class fair_sched_class; - -+ -+#ifdef CONFIG_CACULE_SCHED -+static inline struct sched_entity *se_of(struct cacule_node *cn) -+{ -+ return container_of(cn, struct sched_entity, cacule_node); -+} -+#endif -+ - /************************************************************** - * CFS operations on generic schedulable entities: - */ -@@ -522,7 +550,7 @@ void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec); - /************************************************************** - * Scheduling class tree data structure manipulation methods: - */ -- -+#if !defined(CONFIG_CACULE_SCHED) - static inline u64 max_vruntime(u64 max_vruntime, u64 vruntime) - { - s64 delta = (s64)(vruntime - max_vruntime); -@@ -585,7 +613,170 @@ static inline bool __entity_less(struct rb_node *a, const struct rb_node *b) - { - return entity_before(__node_2_se(a), __node_2_se(b)); - } -+#endif /* CONFIG_CACULE_SCHED */ -+ -+#ifdef CONFIG_CACULE_SCHED -+static unsigned int -+calc_interactivity(u64 now, struct cacule_node *se) -+{ -+ u64 l_se, vr_se, sleep_se = 1ULL, u64_factor_m, _2m; -+ unsigned int score_se; -+ -+ /* -+ * in case of vruntime==0, logical OR with 1 would -+ * make sure that the least sig. bit is 1 -+ */ -+ l_se = now - se->cacule_start_time; -+ vr_se = se->vruntime | 1; -+ u64_factor_m = interactivity_factor; -+ _2m = u64_factor_m << 1; -+ -+ /* safety check */ -+ if (likely(l_se > vr_se)) -+ sleep_se = (l_se - vr_se) | 1; -+ -+ if (sleep_se >= vr_se) -+ score_se = u64_factor_m / (sleep_se / vr_se); -+ else -+ score_se = _2m - (u64_factor_m / (vr_se / sleep_se)); -+ -+ return score_se; -+} -+ -+static inline int is_interactive(struct cacule_node *cn) -+{ -+ if (!interactivity_threshold || se_of(cn)->vruntime == 0) -+ return 0; -+ -+ return calc_interactivity(sched_clock(), cn) < interactivity_threshold; -+} -+ -+static inline int -+entity_before_cached(u64 now, unsigned int score_curr, struct cacule_node *se) -+{ -+ unsigned int score_se; -+ int diff; -+ -+ score_se = calc_interactivity(now, se); -+ diff = score_se - score_curr; -+ -+ if (diff <= 0) -+ return 1; -+ -+ return -1; -+} -+ -+/* -+ * Does se have lower interactivity score value (i.e. interactive) than curr? If yes, return 1, -+ * otherwise return -1 -+ * se is before curr if se has lower interactivity score value -+ * the lower score, the more interactive -+ */ -+static inline int -+entity_before(u64 now, struct cacule_node *curr, struct cacule_node *se) -+{ -+ unsigned int score_curr, score_se; -+ int diff; -+ -+ score_curr = calc_interactivity(now, curr); -+ score_se = calc_interactivity(now, se); -+ -+ diff = score_se - score_curr; -+ -+ if (diff < 0) -+ return 1; -+ -+ return -1; -+} - -+/* -+ * Enqueue an entity -+ */ -+static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *_se) -+{ -+ struct cacule_node *se = &(_se->cacule_node); -+ struct cacule_node *iter, *next = NULL; -+ u64 now = sched_clock(); -+ unsigned int score_se = calc_interactivity(now, se); -+ -+ se->next = NULL; -+ se->prev = NULL; -+ -+ if (likely(cfs_rq->head)) { -+ -+ // start from tail -+ iter = cfs_rq->tail; -+ -+ // does se have higher IS than iter? -+ while (iter && entity_before_cached(now, score_se, iter) == -1) { -+ next = iter; -+ iter = iter->prev; -+ } -+ -+ // se in tail position -+ if (iter == cfs_rq->tail) { -+ cfs_rq->tail->next = se; -+ se->prev = cfs_rq->tail; -+ -+ cfs_rq->tail = se; -+ } -+ // else if not head no tail, insert se after iter -+ else if (iter) { -+ se->next = next; -+ se->prev = iter; -+ -+ iter->next = se; -+ next->prev = se; -+ } -+ // insert se at head -+ else { -+ se->next = cfs_rq->head; -+ cfs_rq->head->prev = se; -+ -+ // lastly reset the head -+ cfs_rq->head = se; -+ } -+ } else { -+ // if empty rq -+ cfs_rq->head = se; -+ cfs_rq->tail = se; -+ } -+} -+ -+static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *_se) -+{ -+ struct cacule_node *se = &(_se->cacule_node); -+ -+ // if only one se in rq -+ if (cfs_rq->head == cfs_rq->tail) { -+ cfs_rq->head = NULL; -+ cfs_rq->tail = NULL; -+ -+ } else if (se == cfs_rq->head) { -+ // if it is the head -+ cfs_rq->head = cfs_rq->head->next; -+ cfs_rq->head->prev = NULL; -+ } else if (se == cfs_rq->tail) { -+ // if it is the tail -+ cfs_rq->tail = cfs_rq->tail->prev; -+ cfs_rq->tail->next = NULL; -+ } else { -+ // if in the middle -+ struct cacule_node *prev = se->prev; -+ struct cacule_node *next = se->next; -+ -+ prev->next = next; -+ -+ if (next) -+ next->prev = prev; -+ } -+} -+ -+struct sched_entity *__pick_first_entity(struct cfs_rq *cfs_rq) -+{ -+ return se_of(cfs_rq->head); -+} -+#else - /* - * Enqueue an entity into the rb-tree: - */ -@@ -618,16 +809,24 @@ static struct sched_entity *__pick_next_entity(struct sched_entity *se) - - return __node_2_se(next); - } -+#endif /* CONFIG_CACULE_SCHED */ - - #ifdef CONFIG_SCHED_DEBUG - struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq) - { -+#ifdef CONFIG_CACULE_SCHED -+ if (!cfs_rq->tail) -+ return NULL; -+ -+ return se_of(cfs_rq->tail); -+#else - struct rb_node *last = rb_last(&cfs_rq->tasks_timeline.rb_root); - - if (!last) - return NULL; - - return __node_2_se(last); -+#endif /* CONFIG_CACULE_SCHED */ - } - - /************************************************************** -@@ -717,6 +916,7 @@ static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se) - return slice; - } - -+#if !defined(CONFIG_CACULE_SCHED) - /* - * We calculate the vruntime slice of a to-be-inserted task. - * -@@ -726,6 +926,7 @@ static u64 sched_vslice(struct cfs_rq *cfs_rq, struct sched_entity *se) - { - return calc_delta_fair(sched_slice(cfs_rq, se), se); - } -+#endif /* CONFIG_CACULE_SCHED */ - - #include "pelt.h" - #ifdef CONFIG_SMP -@@ -833,14 +1034,51 @@ static void update_tg_load_avg(struct cfs_rq *cfs_rq) - } - #endif /* CONFIG_SMP */ - -+#ifdef CONFIG_CACULE_SCHED -+static void normalize_lifetime(u64 now, struct sched_entity *se) -+{ -+ struct cacule_node *cn = &se->cacule_node; -+ u64 max_life_ns, life_time; -+ s64 diff; -+ -+ /* -+ * left shift 20 bits is approximately = * 1000000 -+ * we don't need the precision of life time -+ * Ex. for 30s, with left shift (20bits) == 31.457s -+ */ -+ max_life_ns = ((u64) cacule_max_lifetime) << 20; -+ life_time = now - cn->cacule_start_time; -+ diff = life_time - max_life_ns; -+ -+ if (diff > 0) { -+ // multiply life_time by 1024 for more precision -+ u64 old_hrrn_x = (life_time << 7) / ((cn->vruntime >> 3) | 1); -+ -+ // reset life to half max_life (i.e ~15s) -+ cn->cacule_start_time = now - (max_life_ns >> 1); -+ -+ // avoid division by zero -+ if (old_hrrn_x == 0) old_hrrn_x = 1; -+ -+ // reset vruntime based on old hrrn ratio -+ cn->vruntime = (max_life_ns << 9) / old_hrrn_x; -+ } -+} -+#endif /* CONFIG_CACULE_SCHED */ -+ - /* - * Update the current task's runtime statistics. - */ - static void update_curr(struct cfs_rq *cfs_rq) - { - struct sched_entity *curr = cfs_rq->curr; -+#ifdef CONFIG_CACULE_SCHED -+ u64 now = sched_clock(); -+ u64 delta_exec, delta_fair; -+#else - u64 now = rq_clock_task(rq_of(cfs_rq)); - u64 delta_exec; -+#endif - - if (unlikely(!curr)) - return; -@@ -857,8 +1095,15 @@ static void update_curr(struct cfs_rq *cfs_rq) - curr->sum_exec_runtime += delta_exec; - schedstat_add(cfs_rq->exec_clock, delta_exec); - -+#ifdef CONFIG_CACULE_SCHED -+ delta_fair = calc_delta_fair(delta_exec, curr); -+ curr->vruntime += delta_fair; -+ curr->cacule_node.vruntime += delta_fair; -+ normalize_lifetime(now, curr); -+#else - curr->vruntime += calc_delta_fair(delta_exec, curr); - update_min_vruntime(cfs_rq); -+#endif - - if (entity_is_task(curr)) { - struct task_struct *curtask = task_of(curr); -@@ -1026,7 +1271,6 @@ update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - static inline void - update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - { -- - if (!schedstat_enabled()) - return; - -@@ -1058,7 +1302,11 @@ update_stats_curr_start(struct cfs_rq *cfs_rq, struct sched_entity *se) - /* - * We are starting a new run period: - */ -+#ifdef CONFIG_CACULE_SCHED -+ se->exec_start = sched_clock(); -+#else - se->exec_start = rq_clock_task(rq_of(cfs_rq)); -+#endif - } - - /************************************************** -@@ -4121,7 +4369,7 @@ static inline void update_misfit_status(struct task_struct *p, struct rq *rq) {} - - static void check_spread(struct cfs_rq *cfs_rq, struct sched_entity *se) - { --#ifdef CONFIG_SCHED_DEBUG -+#if defined(CONFIG_SCHED_DEBUG) && !defined(CONFIG_CACULE_SCHED) - s64 d = se->vruntime - cfs_rq->min_vruntime; - - if (d < 0) -@@ -4132,6 +4380,7 @@ static void check_spread(struct cfs_rq *cfs_rq, struct sched_entity *se) - #endif - } - -+#if !defined(CONFIG_CACULE_SCHED) - static void - place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial) - { -@@ -4163,6 +4412,7 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial) - /* ensure we never gain time by being placed backwards. */ - se->vruntime = max_vruntime(se->vruntime, vruntime); - } -+#endif /* CONFIG_CACULE_SCHED */ - - static void check_enqueue_throttle(struct cfs_rq *cfs_rq); - -@@ -4221,18 +4471,23 @@ static inline bool cfs_bandwidth_used(void); - static void - enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - { -+#if !defined(CONFIG_CACULE_SCHED) - bool renorm = !(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_MIGRATED); -+#endif - bool curr = cfs_rq->curr == se; - -+#if !defined(CONFIG_CACULE_SCHED) - /* - * If we're the current task, we must renormalise before calling - * update_curr(). - */ - if (renorm && curr) - se->vruntime += cfs_rq->min_vruntime; -+#endif - - update_curr(cfs_rq); - -+#if !defined(CONFIG_CACULE_SCHED) - /* - * Otherwise, renormalise after, such that we're placed at the current - * moment in time, instead of some random moment in the past. Being -@@ -4241,6 +4496,7 @@ enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - */ - if (renorm && !curr) - se->vruntime += cfs_rq->min_vruntime; -+#endif - - /* - * When enqueuing a sched_entity, we must: -@@ -4255,8 +4511,10 @@ enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - update_cfs_group(se); - account_entity_enqueue(cfs_rq, se); - -+#if !defined(CONFIG_CACULE_SCHED) - if (flags & ENQUEUE_WAKEUP) - place_entity(cfs_rq, se, 0); -+#endif - - check_schedstat_required(); - update_stats_enqueue(cfs_rq, se, flags); -@@ -4277,6 +4535,7 @@ enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - check_enqueue_throttle(cfs_rq); - } - -+#if !defined(CONFIG_CACULE_SCHED) - static void __clear_buddies_last(struct sched_entity *se) - { - for_each_sched_entity(se) { -@@ -4321,6 +4580,7 @@ static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se) - if (cfs_rq->skip == se) - __clear_buddies_skip(se); - } -+#endif /* !CONFIG_CACULE_SCHED */ - - static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq); - -@@ -4345,13 +4605,16 @@ dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - - update_stats_dequeue(cfs_rq, se, flags); - -+#if !defined(CONFIG_CACULE_SCHED) - clear_buddies(cfs_rq, se); -+#endif - - if (se != cfs_rq->curr) - __dequeue_entity(cfs_rq, se); - se->on_rq = 0; - account_entity_dequeue(cfs_rq, se); - -+#if !defined(CONFIG_CACULE_SCHED) - /* - * Normalize after update_curr(); which will also have moved - * min_vruntime if @se is the one holding it back. But before doing -@@ -4360,12 +4623,14 @@ dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - */ - if (!(flags & DEQUEUE_SLEEP)) - se->vruntime -= cfs_rq->min_vruntime; -+#endif - - /* return excess runtime on last dequeue */ - return_cfs_rq_runtime(cfs_rq); - - update_cfs_group(se); - -+#if !defined(CONFIG_CACULE_SCHED) - /* - * Now advance min_vruntime if @se was the entity holding it back, - * except when: DEQUEUE_SAVE && !DEQUEUE_MOVE, in this case we'll be -@@ -4374,8 +4639,21 @@ dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - */ - if ((flags & (DEQUEUE_SAVE | DEQUEUE_MOVE)) != DEQUEUE_SAVE) - update_min_vruntime(cfs_rq); -+#endif - } - -+#ifdef CONFIG_CACULE_SCHED -+/* -+ * Preempt the current task with a newly woken task if needed: -+ */ -+static void -+check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr) -+{ -+ // does head have higher IS than curr -+ if (entity_before(sched_clock(), &curr->cacule_node, cfs_rq->head) == 1) -+ resched_curr(rq_of(cfs_rq)); -+} -+#else - /* - * Preempt the current task with a newly woken task if needed: - */ -@@ -4415,6 +4693,7 @@ check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr) - if (delta > ideal_runtime) - resched_curr(rq_of(cfs_rq)); - } -+#endif /* CONFIG_CACULE_SCHED */ - - static void - set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) -@@ -4449,6 +4728,21 @@ set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) - se->prev_sum_exec_runtime = se->sum_exec_runtime; - } - -+#ifdef CONFIG_CACULE_SCHED -+static struct sched_entity * -+pick_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *curr) -+{ -+ struct cacule_node *se = cfs_rq->head; -+ -+ if (unlikely(!se)) -+ se = &curr->cacule_node; -+ else if (unlikely(curr -+ && entity_before(sched_clock(), se, &curr->cacule_node) == 1)) -+ se = &curr->cacule_node; -+ -+ return se_of(se); -+} -+#else - static int - wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se); - -@@ -4509,6 +4803,7 @@ pick_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *curr) - - return se; - } -+#endif /* CONFIG_CACULE_SCHED */ - - static bool check_cfs_rq_runtime(struct cfs_rq *cfs_rq); - -@@ -5611,7 +5906,9 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) - hrtick_update(rq); - } - -+#if !defined(CONFIG_CACULE_SCHED) - static void set_next_buddy(struct sched_entity *se); -+#endif - - /* - * The dequeue_task method is called before nr_running is -@@ -5643,12 +5940,14 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags) - if (cfs_rq->load.weight) { - /* Avoid re-evaluating load for this entity: */ - se = parent_entity(se); -+#if !defined(CONFIG_CACULE_SCHED) - /* - * Bias pick_next to pick a task from this cfs_rq, as - * p is sleeping when it is within its sched_slice. - */ - if (task_sleep && se && !throttled_hierarchy(cfs_rq)) - set_next_buddy(se); -+#endif - break; - } - flags |= DEQUEUE_SLEEP; -@@ -5764,6 +6063,7 @@ static unsigned long capacity_of(int cpu) - return cpu_rq(cpu)->cpu_capacity; - } - -+#if !defined(CONFIG_CACULE_SCHED) - static void record_wakee(struct task_struct *p) - { - /* -@@ -5810,6 +6110,7 @@ static int wake_wide(struct task_struct *p) - return 0; - return 1; - } -+#endif /* CONFIG_CACULE_SCHED */ - - /* - * The purpose of wake_affine() is to quickly determine on which CPU we can run -@@ -6512,6 +6813,7 @@ static unsigned long cpu_util_without(int cpu, struct task_struct *p) - return min_t(unsigned long, util, capacity_orig_of(cpu)); - } - -+#if !defined(CONFIG_CACULE_SCHED) - /* - * Predicts what cpu_util(@cpu) would return if @p was migrated (and enqueued) - * to @dst_cpu. -@@ -6761,6 +7063,57 @@ static int find_energy_efficient_cpu(struct task_struct *p, int prev_cpu) - - return -1; - } -+#endif /* CONFIG_CACULE_SCHED */ -+ -+#ifdef CONFIG_CACULE_SCHED -+static int -+find_least_IS_cpu(struct task_struct *p) -+{ -+ struct cfs_rq *cfs_rq; -+ unsigned int max_IS = 0; -+ unsigned int IS, IS_c, IS_h; -+ struct sched_entity *curr_se; -+ struct cacule_node *cn, *head; -+ int cpu_i; -+ int new_cpu = -1; -+ -+ for_each_online_cpu(cpu_i) { -+ if (!cpumask_test_cpu(cpu_i, p->cpus_ptr)) -+ continue; -+ -+ cn = NULL; -+ cfs_rq = &cpu_rq(cpu_i)->cfs; -+ -+ curr_se = cfs_rq->curr; -+ head = cfs_rq->head; -+ -+ if (!curr_se && head) -+ cn = head; -+ else if (curr_se && !head) -+ cn = &curr_se->cacule_node; -+ else if (curr_se && head) { -+ IS_c = calc_interactivity(sched_clock(), &curr_se->cacule_node); -+ IS_h = calc_interactivity(sched_clock(), head); -+ -+ IS = IS_c > IS_h? IS_c : IS_h; -+ goto compare; -+ } -+ -+ if (!cn) -+ return cpu_i; -+ -+ IS = calc_interactivity(sched_clock(), cn); -+ -+compare: -+ if (IS > max_IS) { -+ max_IS = IS; -+ new_cpu = cpu_i; -+ } -+ } -+ -+ return new_cpu; -+} -+#endif - - /* - * select_task_rq_fair: Select target runqueue for the waking task in domains -@@ -6785,6 +7138,26 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags) - /* SD_flags and WF_flags share the first nibble */ - int sd_flag = wake_flags & 0xF; - -+#ifdef CONFIG_CACULE_SCHED -+ struct sched_entity *se = &p->se; -+ -+ if (!is_interactive(&se->cacule_node)) -+ goto cfs_way; -+ -+ // check first if the prev cpu -+ // has 0 tasks -+ if (cpumask_test_cpu(prev_cpu, p->cpus_ptr) && -+ cpu_rq(prev_cpu)->cfs.nr_running == 0) -+ return prev_cpu; -+ -+ new_cpu = find_least_IS_cpu(p); -+ -+ if (new_cpu != -1) -+ return new_cpu; -+ -+ new_cpu = prev_cpu; -+cfs_way: -+#else - if (wake_flags & WF_TTWU) { - record_wakee(p); - -@@ -6797,6 +7170,7 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags) - - want_affine = !wake_wide(p) && cpumask_test_cpu(cpu, p->cpus_ptr); - } -+#endif /* CONFIG_CACULE_SCHED */ - - rcu_read_lock(); - for_each_domain(cpu, tmp) { -@@ -6843,6 +7217,7 @@ static void detach_entity_cfs_rq(struct sched_entity *se); - */ - static void migrate_task_rq_fair(struct task_struct *p, int new_cpu) - { -+#if !defined(CONFIG_CACULE_SCHED) - /* - * As blocked tasks retain absolute vruntime the migration needs to - * deal with this by subtracting the old and adding the new -@@ -6868,6 +7243,7 @@ static void migrate_task_rq_fair(struct task_struct *p, int new_cpu) - - se->vruntime -= min_vruntime; - } -+#endif /* CONFIG_CACULE_SCHED */ - - if (p->on_rq == TASK_ON_RQ_MIGRATING) { - /* -@@ -6913,6 +7289,7 @@ balance_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) - } - #endif /* CONFIG_SMP */ - -+#if !defined(CONFIG_CACULE_SCHED) - static unsigned long wakeup_gran(struct sched_entity *se) - { - unsigned long gran = sysctl_sched_wakeup_granularity; -@@ -6991,6 +7368,7 @@ static void set_skip_buddy(struct sched_entity *se) - for_each_sched_entity(se) - cfs_rq_of(se)->skip = se; - } -+#endif /* CONFIG_CACULE_SCHED */ - - /* - * Preempt the current task with a newly woken task if needed: -@@ -6999,9 +7377,12 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_ - { - struct task_struct *curr = rq->curr; - struct sched_entity *se = &curr->se, *pse = &p->se; -+ -+#if !defined(CONFIG_CACULE_SCHED) - struct cfs_rq *cfs_rq = task_cfs_rq(curr); - int scale = cfs_rq->nr_running >= sched_nr_latency; - int next_buddy_marked = 0; -+#endif /* CONFIG_CACULE_SCHED */ - - if (unlikely(se == pse)) - return; -@@ -7015,10 +7396,12 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_ - if (unlikely(throttled_hierarchy(cfs_rq_of(pse)))) - return; - -+#if !defined(CONFIG_CACULE_SCHED) - if (sched_feat(NEXT_BUDDY) && scale && !(wake_flags & WF_FORK)) { - set_next_buddy(pse); - next_buddy_marked = 1; - } -+#endif /* CONFIG_CACULE_SCHED */ - - /* - * We can come here with TIF_NEED_RESCHED already set from new task -@@ -7048,6 +7431,11 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_ - find_matching_se(&se, &pse); - update_curr(cfs_rq_of(se)); - BUG_ON(!pse); -+ -+#ifdef CONFIG_CACULE_SCHED -+ if (entity_before(sched_clock(), &se->cacule_node, &pse->cacule_node) == 1) -+ goto preempt; -+#else - if (wakeup_preempt_entity(se, pse) == 1) { - /* - * Bias pick_next to pick the sched entity that is -@@ -7057,11 +7445,14 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_ - set_next_buddy(pse); - goto preempt; - } -+#endif /* CONFIG_CACULE_SCHED */ - - return; - - preempt: - resched_curr(rq); -+ -+#if !defined(CONFIG_CACULE_SCHED) - /* - * Only set the backward buddy when the current task is still - * on the rq. This can happen when a wakeup gets interleaved -@@ -7076,6 +7467,7 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_ - - if (sched_feat(LAST_BUDDY) && scale && entity_is_task(se)) - set_last_buddy(se); -+#endif /* CONFIG_CACULE_SCHED */ - } - - struct task_struct * -@@ -7250,7 +7642,10 @@ static void yield_task_fair(struct rq *rq) - { - struct task_struct *curr = rq->curr; - struct cfs_rq *cfs_rq = task_cfs_rq(curr); -+ -+#if !defined(CONFIG_CACULE_SCHED) - struct sched_entity *se = &curr->se; -+#endif - - /* - * Are we the only task in the tree? -@@ -7258,7 +7653,9 @@ static void yield_task_fair(struct rq *rq) - if (unlikely(rq->nr_running == 1)) - return; - -+#if !defined(CONFIG_CACULE_SCHED) - clear_buddies(cfs_rq, se); -+#endif - - if (curr->policy != SCHED_BATCH) { - update_rq_clock(rq); -@@ -7274,7 +7671,9 @@ static void yield_task_fair(struct rq *rq) - rq_clock_skip_update(rq); - } - -+#if !defined(CONFIG_CACULE_SCHED) - set_skip_buddy(se); -+#endif - } - - static bool yield_to_task_fair(struct rq *rq, struct task_struct *p) -@@ -7285,8 +7684,10 @@ static bool yield_to_task_fair(struct rq *rq, struct task_struct *p) - if (!se->on_rq || throttled_hierarchy(cfs_rq_of(se))) - return false; - -+#if !defined(CONFIG_CACULE_SCHED) - /* Tell the scheduler that we'd really like pse to run next. */ - set_next_buddy(se); -+#endif - - yield_task_fair(rq); - -@@ -7513,6 +7914,7 @@ static int task_hot(struct task_struct *p, struct lb_env *env) - if (env->sd->flags & SD_SHARE_CPUCAPACITY) - return 0; - -+#if !defined(CONFIG_CACULE_SCHED) - /* - * Buddy candidates are cache hot: - */ -@@ -7520,6 +7922,7 @@ static int task_hot(struct task_struct *p, struct lb_env *env) - (&p->se == cfs_rq_of(&p->se)->next || - &p->se == cfs_rq_of(&p->se)->last)) - return 1; -+#endif - - if (sysctl_sched_migration_cost == -1) - return 1; -@@ -10547,9 +10950,11 @@ static void nohz_newidle_balance(struct rq *this_rq) - if (!housekeeping_cpu(this_cpu, HK_FLAG_SCHED)) - return; - -+#if !defined(CONFIG_CACULE_SCHED) - /* Will wake up very soon. No time for doing anything else*/ - if (this_rq->avg_idle < sysctl_sched_migration_cost) - return; -+#endif - - /* Don't need to update blocked load of idle CPUs*/ - if (!READ_ONCE(nohz.has_blocked) || -@@ -10612,7 +11017,10 @@ static int newidle_balance(struct rq *this_rq, struct rq_flags *rf) - */ - rq_unpin_lock(this_rq, rf); - -- if (this_rq->avg_idle < sysctl_sched_migration_cost || -+ if ( -+#if !defined(CONFIG_CACULE_SCHED) -+ this_rq->avg_idle < sysctl_sched_migration_cost || -+#endif - !READ_ONCE(this_rq->rd->overload)) { - - rcu_read_lock(); -@@ -10780,11 +11188,28 @@ static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued) - update_overutilized_status(task_rq(curr)); - } - -+#ifdef CONFIG_CACULE_SCHED - /* - * called on fork with the child task as argument from the parent's context - * - child not yet on the tasklist - * - preemption disabled - */ -+ static void task_fork_fair(struct task_struct *p) -+{ -+ struct cfs_rq *cfs_rq; -+ struct rq *rq = this_rq(); -+ struct rq_flags rf; -+ -+ rq_lock(rq, &rf); -+ update_rq_clock(rq); -+ -+ cfs_rq = task_cfs_rq(current); -+ if (cfs_rq->curr) -+ update_curr(cfs_rq); -+ -+ rq_unlock(rq, &rf); -+} -+#else - static void task_fork_fair(struct task_struct *p) - { - struct cfs_rq *cfs_rq; -@@ -10815,6 +11240,7 @@ static void task_fork_fair(struct task_struct *p) - se->vruntime -= cfs_rq->min_vruntime; - rq_unlock(rq, &rf); - } -+#endif /* CONFIG_CACULE_SCHED */ - - /* - * Priority of the task has changed. Check to see if we preempt -@@ -10933,6 +11359,8 @@ static void attach_entity_cfs_rq(struct sched_entity *se) - static void detach_task_cfs_rq(struct task_struct *p) - { - struct sched_entity *se = &p->se; -+ -+#if !defined(CONFIG_CACULE_SCHED) - struct cfs_rq *cfs_rq = cfs_rq_of(se); - - if (!vruntime_normalized(p)) { -@@ -10943,6 +11371,7 @@ static void detach_task_cfs_rq(struct task_struct *p) - place_entity(cfs_rq, se, 0); - se->vruntime -= cfs_rq->min_vruntime; - } -+#endif - - detach_entity_cfs_rq(se); - } -@@ -10950,12 +11379,17 @@ static void detach_task_cfs_rq(struct task_struct *p) - static void attach_task_cfs_rq(struct task_struct *p) - { - struct sched_entity *se = &p->se; -+ -+#if !defined(CONFIG_CACULE_SCHED) - struct cfs_rq *cfs_rq = cfs_rq_of(se); -+#endif - - attach_entity_cfs_rq(se); - -+#if !defined(CONFIG_CACULE_SCHED) - if (!vruntime_normalized(p)) - se->vruntime += cfs_rq->min_vruntime; -+#endif - } - - static void switched_from_fair(struct rq *rq, struct task_struct *p) -@@ -11011,13 +11445,22 @@ static void set_next_task_fair(struct rq *rq, struct task_struct *p, bool first) - void init_cfs_rq(struct cfs_rq *cfs_rq) - { - cfs_rq->tasks_timeline = RB_ROOT_CACHED; -+ -+#if !defined(CONFIG_CACULE_SCHED) - cfs_rq->min_vruntime = (u64)(-(1LL << 20)); - #ifndef CONFIG_64BIT - cfs_rq->min_vruntime_copy = cfs_rq->min_vruntime; - #endif -+#endif /* CONFIG_CACULE_SCHED */ -+ - #ifdef CONFIG_SMP - raw_spin_lock_init(&cfs_rq->removed.lock); - #endif -+ -+#ifdef CONFIG_CACULE_SCHED -+ cfs_rq->head = NULL; -+ cfs_rq->tail = NULL; -+#endif - } - - #ifdef CONFIG_FAIR_GROUP_SCHED -diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h -index a189bec13729..0affe3be7c21 100644 ---- a/kernel/sched/sched.h -+++ b/kernel/sched/sched.h -@@ -525,10 +525,13 @@ struct cfs_rq { - unsigned int idle_h_nr_running; /* SCHED_IDLE */ - - u64 exec_clock; -+ -+#if !defined(CONFIG_CACULE_SCHED) - u64 min_vruntime; - #ifndef CONFIG_64BIT - u64 min_vruntime_copy; - #endif -+#endif /* CONFIG_CACULE_SCHED */ - - struct rb_root_cached tasks_timeline; - -@@ -537,9 +540,15 @@ struct cfs_rq { - * It is set to NULL otherwise (i.e when none are currently running). - */ - struct sched_entity *curr; -+#ifdef CONFIG_CACULE_SCHED -+ struct cacule_node *head; -+ struct cacule_node *tail; -+ -+#else - struct sched_entity *next; - struct sched_entity *last; - struct sched_entity *skip; -+#endif // CONFIG_CACULE_SCHED - - #ifdef CONFIG_SCHED_DEBUG - unsigned int nr_spread_over; -diff --git a/kernel/sysctl.c b/kernel/sysctl.c -index d4a78e08f6d8..e8cdedf74fed 100644 ---- a/kernel/sysctl.c -+++ b/kernel/sysctl.c -@@ -1736,6 +1736,29 @@ static struct ctl_table kern_table[] = { - .mode = 0644, - .proc_handler = proc_dointvec, - }, -+#ifdef CONFIG_CACULE_SCHED -+ { -+ .procname = "sched_interactivity_factor", -+ .data = &interactivity_factor, -+ .maxlen = sizeof(unsigned int), -+ .mode = 0644, -+ .proc_handler = proc_dointvec, -+ }, -+ { -+ .procname = "sched_interactivity_threshold", -+ .data = &interactivity_threshold, -+ .maxlen = sizeof(unsigned int), -+ .mode = 0644, -+ .proc_handler = proc_dointvec, -+ }, -+ { -+ .procname = "sched_max_lifetime_ms", -+ .data = &cacule_max_lifetime, -+ .maxlen = sizeof(unsigned int), -+ .mode = 0644, -+ .proc_handler = proc_dointvec, -+ }, -+#endif - #ifdef CONFIG_SCHEDSTATS - { - .procname = "sched_schedstats", diff --git a/config b/config index 9251351..2f92893 100644 --- a/config +++ b/config @@ -1,15 +1,16 @@ # # Automatically generated file; DO NOT EDIT. -# Linux/arm64 5.12.6-1 Kernel Configuration +# Linux/arm64 5.12.19-1 Kernel Configuration # -CONFIG_CC_VERSION_TEXT="aarch64-linux-gnu-gcc (GCC) 9.3.0" +CONFIG_CC_VERSION_TEXT="aarch64-unknown-linux-gnu-gcc (GCC) 10.2.0" CONFIG_CC_IS_GCC=y -CONFIG_GCC_VERSION=90300 +CONFIG_GCC_VERSION=100200 CONFIG_CLANG_VERSION=0 CONFIG_LD_IS_BFD=y -CONFIG_LD_VERSION=23601 +CONFIG_LD_VERSION=23500 CONFIG_LLD_VERSION=0 CONFIG_CC_CAN_LINK=y +CONFIG_CC_CAN_LINK_STATIC=y CONFIG_CC_HAS_ASM_GOTO=y CONFIG_CC_HAS_ASM_INLINE=y CONFIG_IRQ_WORK=y @@ -74,8 +75,8 @@ CONFIG_TICK_ONESHOT=y CONFIG_NO_HZ_COMMON=y # CONFIG_HZ_PERIODIC is not set CONFIG_NO_HZ_IDLE=y -CONFIG_NO_HZ_FULL=y -CONFIG_NO_HZ=y +# CONFIG_NO_HZ_FULL is not set +# CONFIG_NO_HZ is not set CONFIG_HIGH_RES_TIMERS=y # end of Timers subsystem @@ -453,6 +454,7 @@ CONFIG_ARM64_TLB_RANGE=y # CONFIG_AS_HAS_ARMV8_5=y CONFIG_ARM64_BTI=y +CONFIG_ARM64_BTI_KERNEL=y CONFIG_CC_HAS_BRANCH_PROT_PAC_RET_BTI=y CONFIG_ARM64_E0PD=y CONFIG_ARCH_RANDOM=y @@ -1474,6 +1476,7 @@ CONFIG_BLK_DEV_NBD=m # NVME Support # # CONFIG_NVME_FC is not set +# CONFIG_NVME_TCP is not set # CONFIG_NVME_TARGET is not set # end of NVME Support @@ -2431,6 +2434,7 @@ CONFIG_AXP288_FUEL_GAUGE=y # CONFIG_CHARGER_BQ256XX is not set # CONFIG_CHARGER_SMB347 is not set # CONFIG_BATTERY_GAUGE_LTC2941 is not set +# CONFIG_BATTERY_RT5033 is not set # CONFIG_CHARGER_RT9455 is not set # CONFIG_CHARGER_UCS1002 is not set # CONFIG_CHARGER_BD99954 is not set @@ -5064,8 +5068,6 @@ CONFIG_PARTITION_PERCPU=y # CONFIG_IPACK_BUS is not set CONFIG_ARCH_HAS_RESET_CONTROLLER=y CONFIG_RESET_CONTROLLER=y -# CONFIG_RESET_BRCMSTB_RESCAL is not set -# CONFIG_RESET_INTEL_GW is not set CONFIG_RESET_SIMPLE=y CONFIG_RESET_SUNXI=y # CONFIG_RESET_TI_SYSCON is not set @@ -5840,7 +5842,6 @@ CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y # CONFIG_DEBUG_INFO_DWARF4 is not set # CONFIG_DEBUG_INFO_DWARF5 is not set # CONFIG_DEBUG_INFO_BTF is not set -CONFIG_PAHOLE_HAS_SPLIT_BTF=y # CONFIG_GDB_SCRIPTS is not set CONFIG_FRAME_WARN=2048 # CONFIG_STRIP_ASM_SYMS is not set diff --git a/ec25.patch b/ec25.patch deleted file mode 100644 index eeb862b..0000000 --- a/ec25.patch +++ /dev/null @@ -1,116 +0,0 @@ -diff --git a/sound/soc/codecs/ec25.c b/sound/soc/codecs/ec25.c -index 7c96aa7a79d0..20687ec386ef 100644 ---- a/sound/soc/codecs/ec25.c -+++ b/sound/soc/codecs/ec25.c -@@ -3,6 +3,50 @@ - #include - #include - -+u32 curr_sample_rate; -+ -+static const char *const avail_sample_rates[] = {"8000", "16000", "48000"}; -+static const struct soc_enum ec25_enum[] = { -+ SOC_ENUM_SINGLE_EXT(3, avail_sample_rates), -+}; -+ -+static int ec25_sample_rate_get(struct snd_kcontrol *kcontrol, -+ struct snd_ctl_elem_value *ucontrol) -+{ -+ pr_info("%s: Forced sample rate = %i\n", -+ __func__, curr_sample_rate); -+ ucontrol->value.integer.value[0] = curr_sample_rate; -+ return 0; -+} -+ -+static int ec25_sample_rate_set(struct snd_kcontrol *kcontrol, -+ struct snd_ctl_elem_value *ucontrol) -+{ -+ switch (ucontrol->value.integer.value[0]) { -+ case 0: -+ curr_sample_rate = 8000; -+ break; -+ case 1: -+ curr_sample_rate = 16000; -+ break; -+ case 2: -+ curr_sample_rate = 48000; -+ break; -+ default: -+ curr_sample_rate = 8000; -+ break; -+ } -+ pr_info("%s: Forced sample rate = %i\n", -+ __func__, curr_sample_rate); -+ return 0; -+} -+ -+static const struct snd_kcontrol_new ec25_controls[] = { -+ SOC_ENUM_EXT("EC25 Sample Rate", ec25_enum[0], -+ ec25_sample_rate_get, -+ ec25_sample_rate_set), -+}; -+ - static const struct snd_soc_dapm_widget ec25_dapm_widgets[] = { - SND_SOC_DAPM_OUTPUT("AOUT"), - SND_SOC_DAPM_INPUT("AIN"), -@@ -22,23 +66,50 @@ static const struct snd_soc_component_driver ec25_component_driver = { - .num_dapm_routes = ARRAY_SIZE(ec25_dapm_routes), - .endianness = 1, - .non_legacy_dai_naming = 1, -+ .controls = ec25_controls, -+ .num_controls = ARRAY_SIZE(ec25_controls), -+}; -+ -+static int ec25_startup(struct snd_pcm_substream *substream, -+ struct snd_soc_dai *dai) -+{ -+ struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); -+ /* HACK: This is a const pointer, but we know the underlying data is not const. */ -+ struct snd_soc_pcm_stream *params = (struct snd_soc_pcm_stream *)rtd->dai_link->params; -+ struct snd_soc_pcm_stream *stream = snd_soc_dai_get_pcm_stream(dai, substream->stream); -+ -+ if (stream->rates & snd_pcm_rate_to_rate_bit(curr_sample_rate)) { -+ dev_info(dai->dev, "Setting sample rate to %u\n", curr_sample_rate); -+ params->rate_min = curr_sample_rate; -+ params->rate_max = curr_sample_rate; -+ } -+ -+ return 0; -+} -+static const struct snd_soc_dai_ops ec25_dai_ops = { -+ .startup = ec25_startup, - }; - - static struct snd_soc_dai_driver ec25_dais[] = { - { - .name = "ec25", -+ .ops = &ec25_dai_ops, - .capture = { - .stream_name = "Capture", - .channels_min = 1, - .channels_max = 1, -- .rates = SNDRV_PCM_RATE_8000, -+ .rates = SNDRV_PCM_RATE_8000 | -+ SNDRV_PCM_RATE_16000 | -+ SNDRV_PCM_RATE_48000, - .formats = SNDRV_PCM_FMTBIT_S16_LE, - }, - .playback = { - .stream_name = "Playback", - .channels_min = 1, - .channels_max = 1, -- .rates = SNDRV_PCM_RATE_8000, -+ .rates = SNDRV_PCM_RATE_8000 | -+ SNDRV_PCM_RATE_16000 | -+ SNDRV_PCM_RATE_48000, - .formats = SNDRV_PCM_FMTBIT_S16_LE, - }, - .symmetric_rates = 1, -@@ -69,6 +140,7 @@ static struct snd_soc_dai_driver ec25_dais[] = { - - static int ec25_codec_probe(struct platform_device *pdev) - { -+ curr_sample_rate = 8000; - return devm_snd_soc_register_component(&pdev->dev, &ec25_component_driver, - ec25_dais, ARRAY_SIZE(ec25_dais)); - } diff --git a/linux-pine64-5.12.14-1-aarch64.pkg.tar.xz b/linux-pine64-5.12.14-1-aarch64.pkg.tar.xz deleted file mode 100644 index 4dfc282..0000000 Binary files a/linux-pine64-5.12.14-1-aarch64.pkg.tar.xz and /dev/null differ diff --git a/linux-pine64-headers-5.12.14-1-aarch64.pkg.tar.xz b/linux-pine64-headers-5.12.14-1-aarch64.pkg.tar.xz deleted file mode 100644 index 4353f6a..0000000 Binary files a/linux-pine64-headers-5.12.14-1-aarch64.pkg.tar.xz and /dev/null differ diff --git a/rdb-5.13.patch b/rdb-5.13.patch deleted file mode 100644 index 607e272..0000000 --- a/rdb-5.13.patch +++ /dev/null @@ -1,1295 +0,0 @@ -diff --git a/init/Kconfig b/init/Kconfig -index 719c94612548..7f8309213c68 100644 ---- a/init/Kconfig -+++ b/init/Kconfig -@@ -843,6 +843,40 @@ config CACULE_SCHED - - If unsure, say Y here. - -+config CACULE_RDB -+ bool "RDB (Response Driven Balancer)" -+ default y -+ depends on CACULE_SCHED -+ help -+ This is an experimental load balancer for CacULE. It is a lightweight -+ load balancer which is a replacement of CFS load balancer. It migrates -+ tasks based on their interactivity scores. -+ -+ If unsure, say Y here. -+ -+config RDB_INTERVAL -+ int "RDB load balancer interval" -+ default 19 -+ depends on CACULE_RDB -+ help -+ This is an interval to control load balance time period. -+ The trigger_load_balance runs in every tick. For High HZ values, the -+ load balance could be overwhelming. RDB load balance includes rq locking -+ which can reduce the performance. The balance interval can help to avoid -+ running load balance on every tick. For example, RDB_INTERVAL=3 will -+ only run load balance every 3ms. Setting RDB_INTERVAL depends on HZ. -+ If you want load balancer run every 2ms while HZ=500 then it is not -+ needed and better to set RDB_INTERVAL=0 since 500HZ already (1000ms -+ / 500HZ = 2ms). However, if you have 1000HZ and want to avoid load -+ balancer from running every 1ms, you could set RDB_INTERVAL=4ms for -+ example to make load balancer run every 4ms. Less RDB_INTERVAL values -+ (or 0 to disable) could make sure tasks are balanced ASAP, but with -+ the cost of locking/blocking time. High RDB_INTERVAL values can relax -+ balancing locking but with the cost of imbalanced workload for that -+ period of time (i.e. if RDB_INTERVAL=100ms) there will be no balancing -+ for 100ms (except for newidle_balance which is not effected by RDB_INTERVAL). -+ -+ If in doubt, use the default value. - - # - # For architectures that want to enable the support for NUMA-affine scheduler -@@ -961,6 +995,7 @@ config CGROUP_WRITEBACK - - menuconfig CGROUP_SCHED - bool "CPU controller" -+ depends on !CACULE_RDB - default n - help - This feature lets CPU scheduler recognize task groups and control CPU -@@ -1238,10 +1273,10 @@ config CHECKPOINT_RESTORE - - config SCHED_AUTOGROUP - bool "Automatic process group scheduling" -+ depends on !CACULE_RDB - select CGROUPS - select CGROUP_SCHED - select FAIR_GROUP_SCHED -- default y - help - This option optimizes the scheduler for common desktop workloads by - automatically creating and populating task groups. This separation -diff --git a/kernel/sched/core.c b/kernel/sched/core.c -index 8505beec4e99..1a09237a3dfe 100644 ---- a/kernel/sched/core.c -+++ b/kernel/sched/core.c -@@ -8112,8 +8112,11 @@ void __init sched_init(void) - BUG_ON(&dl_sched_class + 1 != &stop_sched_class); - #endif - --#ifdef CONFIG_CACULE_SCHED -- printk(KERN_INFO "CacULE CPU scheduler v5.13 by Hamad Al Marri."); -+#ifdef CONFIG_CACULE_RDB -+ /* -+ * This patch is on top cacule-5.13.patch -+ */ -+ printk(KERN_INFO "CacULE CPU scheduler (RDB) v5.13 by Hamad Al Marri."); - #endif - - wait_bit_init(); -diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c -index b7649507f511..0b663012a644 100644 ---- a/kernel/sched/fair.c -+++ b/kernel/sched/fair.c -@@ -742,6 +742,10 @@ static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *_se) - cfs_rq->head = NULL; - cfs_rq->tail = NULL; - -+#ifdef CONFIG_CACULE_RDB -+ WRITE_ONCE(cfs_rq->IS_head, ~0); -+#endif -+ - } else if (se == cfs_rq->head) { - // if it is the head - cfs_rq->head = cfs_rq->head->next; -@@ -1114,6 +1118,7 @@ static void update_curr_fair(struct rq *rq) - static inline void - update_stats_wait_start(struct cfs_rq *cfs_rq, struct sched_entity *se) - { -+#if !defined(CONFIG_CACULE_RDB) - u64 wait_start, prev_wait_start; - - if (!schedstat_enabled()) -@@ -1127,11 +1132,13 @@ update_stats_wait_start(struct cfs_rq *cfs_rq, struct sched_entity *se) - wait_start -= prev_wait_start; - - __schedstat_set(se->statistics.wait_start, wait_start); -+#endif - } - - static inline void - update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se) - { -+#if !defined(CONFIG_CACULE_RDB) - struct task_struct *p; - u64 delta; - -@@ -1168,11 +1175,13 @@ update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se) - __schedstat_inc(se->statistics.wait_count); - __schedstat_add(se->statistics.wait_sum, delta); - __schedstat_set(se->statistics.wait_start, 0); -+#endif - } - - static inline void - update_stats_enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se) - { -+#if !defined(CONFIG_CACULE_RDB) - struct task_struct *tsk = NULL; - u64 sleep_start, block_start; - -@@ -1236,6 +1245,7 @@ update_stats_enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se) - account_scheduler_latency(tsk, delta >> 10, 0); - } - } -+#endif - } - - /* -@@ -1244,6 +1254,7 @@ update_stats_enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se) - static inline void - update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - { -+#if !defined(CONFIG_CACULE_RDB) - if (!schedstat_enabled()) - return; - -@@ -1256,11 +1267,13 @@ update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - - if (flags & ENQUEUE_WAKEUP) - update_stats_enqueue_sleeper(cfs_rq, se); -+#endif - } - - static inline void - update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - { -+#if !defined(CONFIG_CACULE_RDB) - if (!schedstat_enabled()) - return; - -@@ -1281,6 +1294,7 @@ update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - __schedstat_set(se->statistics.block_start, - rq_clock(rq_of(cfs_rq))); - } -+#endif - } - - /* -@@ -3311,15 +3325,19 @@ account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se) - static inline void - enqueue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) - { -+#if !defined(CONFIG_CACULE_RDB) - cfs_rq->avg.load_avg += se->avg.load_avg; - cfs_rq->avg.load_sum += se_weight(se) * se->avg.load_sum; -+#endif - } - - static inline void - dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) - { -+#if !defined(CONFIG_CACULE_RDB) - sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); - sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); -+#endif - } - #else - static inline void -@@ -3574,6 +3592,7 @@ static inline void update_tg_load_avg(struct cfs_rq *cfs_rq) - void set_task_rq_fair(struct sched_entity *se, - struct cfs_rq *prev, struct cfs_rq *next) - { -+#if !defined(CONFIG_CACULE_RDB) - u64 p_last_update_time; - u64 n_last_update_time; - -@@ -3613,6 +3632,7 @@ void set_task_rq_fair(struct sched_entity *se, - #endif - __update_load_avg_blocked_se(p_last_update_time, se); - se->avg.last_update_time = n_last_update_time; -+#endif - } - - -@@ -3892,6 +3912,9 @@ static inline void add_tg_cfs_propagate(struct cfs_rq *cfs_rq, long runnable_sum - static inline int - update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq) - { -+#ifdef CONFIG_CACULE_RDB -+ return 0; -+#else - unsigned long removed_load = 0, removed_util = 0, removed_runnable = 0; - struct sched_avg *sa = &cfs_rq->avg; - int decayed = 0; -@@ -3937,8 +3960,10 @@ update_cfs_rq_load_avg(u64 now, struct cfs_rq *cfs_rq) - #endif - - return decayed; -+#endif - } - -+#if !defined(CONFIG_CACULE_RDB) - /** - * attach_entity_load_avg - attach this entity to its cfs_rq load avg - * @cfs_rq: cfs_rq to attach to -@@ -4016,6 +4041,7 @@ static void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s - - trace_pelt_cfs_tp(cfs_rq); - } -+#endif - - /* - * Optional action to be done while updating the load average -@@ -4027,6 +4053,7 @@ static void detach_entity_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s - /* Update task and its cfs_rq load average */ - static inline void update_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - { -+#if !defined(CONFIG_CACULE_RDB) - u64 now = cfs_rq_clock_pelt(cfs_rq); - int decayed; - -@@ -4058,8 +4085,10 @@ static inline void update_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *s - if (flags & UPDATE_TG) - update_tg_load_avg(cfs_rq); - } -+#endif - } - -+#if !defined(CONFIG_CACULE_RDB) - #ifndef CONFIG_64BIT - static inline u64 cfs_rq_last_update_time(struct cfs_rq *cfs_rq) - { -@@ -4080,6 +4109,7 @@ static inline u64 cfs_rq_last_update_time(struct cfs_rq *cfs_rq) - return cfs_rq->avg.last_update_time; - } - #endif -+#endif - - /* - * Synchronize entity load avg of dequeued entity without locking -@@ -4087,11 +4117,13 @@ static inline u64 cfs_rq_last_update_time(struct cfs_rq *cfs_rq) - */ - static void sync_entity_load_avg(struct sched_entity *se) - { -+#if !defined(CONFIG_CACULE_RDB) - struct cfs_rq *cfs_rq = cfs_rq_of(se); - u64 last_update_time; - - last_update_time = cfs_rq_last_update_time(cfs_rq); - __update_load_avg_blocked_se(last_update_time, se); -+#endif - } - - /* -@@ -4100,6 +4132,7 @@ static void sync_entity_load_avg(struct sched_entity *se) - */ - static void remove_entity_load_avg(struct sched_entity *se) - { -+#if !defined(CONFIG_CACULE_RDB) - struct cfs_rq *cfs_rq = cfs_rq_of(se); - unsigned long flags; - -@@ -4117,6 +4150,7 @@ static void remove_entity_load_avg(struct sched_entity *se) - cfs_rq->removed.load_avg += se->avg.load_avg; - cfs_rq->removed.runnable_avg += se->avg.runnable_avg; - raw_spin_unlock_irqrestore(&cfs_rq->removed.lock, flags); -+#endif - } - - static inline unsigned long cfs_rq_runnable_avg(struct cfs_rq *cfs_rq) -@@ -4404,10 +4438,13 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial) - } - #endif /* CONFIG_CACULE_SCHED */ - -+#if !defined(CONFIG_CACULE_RDB) - static void check_enqueue_throttle(struct cfs_rq *cfs_rq); -+#endif - - static inline void check_schedstat_required(void) - { -+#if !defined(CONFIG_CACULE_RDB) - #ifdef CONFIG_SCHEDSTATS - if (schedstat_enabled()) - return; -@@ -4424,6 +4461,7 @@ static inline void check_schedstat_required(void) - "kernel.sched_schedstats=1\n"); - } - #endif -+#endif - } - - static inline bool cfs_bandwidth_used(void); -@@ -4513,6 +4551,7 @@ enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - __enqueue_entity(cfs_rq, se); - se->on_rq = 1; - -+#if !defined(CONFIG_CACULE_RDB) - /* - * When bandwidth control is enabled, cfs might have been removed - * because of a parent been throttled but cfs->nr_running > 1. Try to -@@ -4523,6 +4562,7 @@ enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - - if (cfs_rq->nr_running == 1) - check_enqueue_throttle(cfs_rq); -+#endif - } - - #if !defined(CONFIG_CACULE_SCHED) -@@ -5053,6 +5093,9 @@ static int tg_throttle_down(struct task_group *tg, void *data) - - static bool throttle_cfs_rq(struct cfs_rq *cfs_rq) - { -+#ifdef CONFIG_CACULE_RDB -+ return false; -+#else - struct rq *rq = rq_of(cfs_rq); - struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg); - struct sched_entity *se; -@@ -5130,10 +5173,12 @@ static bool throttle_cfs_rq(struct cfs_rq *cfs_rq) - cfs_rq->throttled = 1; - cfs_rq->throttled_clock = rq_clock(rq); - return true; -+#endif - } - - void unthrottle_cfs_rq(struct cfs_rq *cfs_rq) - { -+#if !defined(CONFIG_CACULE_RDB) - struct rq *rq = rq_of(cfs_rq); - struct cfs_bandwidth *cfs_b = tg_cfs_bandwidth(cfs_rq->tg); - struct sched_entity *se; -@@ -5215,6 +5260,7 @@ void unthrottle_cfs_rq(struct cfs_rq *cfs_rq) - /* Determine whether we need to wake up potentially idle CPU: */ - if (rq->curr == rq->idle && rq->cfs.nr_running) - resched_curr(rq); -+#endif - } - - static void distribute_cfs_runtime(struct cfs_bandwidth *cfs_b) -@@ -5667,7 +5713,11 @@ static inline bool cfs_bandwidth_used(void) - - static void account_cfs_rq_runtime(struct cfs_rq *cfs_rq, u64 delta_exec) {} - static bool check_cfs_rq_runtime(struct cfs_rq *cfs_rq) { return false; } -+ -+#if !defined(CONFIG_CACULE_RDB) - static void check_enqueue_throttle(struct cfs_rq *cfs_rq) {} -+#endif -+ - static inline void sync_throttle(struct task_group *tg, int cpu) {} - static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq) {} - -@@ -5798,7 +5848,9 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) - { - struct cfs_rq *cfs_rq; - struct sched_entity *se = &p->se; -+#if !defined(CONFIG_CACULE_RDB) - int idle_h_nr_running = task_has_idle_policy(p); -+#endif - int task_new = !(flags & ENQUEUE_WAKEUP); - - /* -@@ -5817,6 +5869,13 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) - if (p->in_iowait) - cpufreq_update_util(rq, SCHED_CPUFREQ_IOWAIT); - -+#ifdef CONFIG_CACULE_RDB -+ if (!se->on_rq) { -+ cfs_rq = cfs_rq_of(se); -+ enqueue_entity(cfs_rq, se, flags); -+ cfs_rq->h_nr_running++; -+ } -+#else - for_each_sched_entity(se) { - if (se->on_rq) - break; -@@ -5854,6 +5913,7 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) - if (throttled_hierarchy(cfs_rq)) - list_add_leaf_cfs_rq(cfs_rq); - } -+#endif - - /* At this point se is NULL and we are at root level*/ - add_nr_running(rq, 1); -@@ -5875,6 +5935,7 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) - if (!task_new) - update_overutilized_status(rq); - -+#if !defined(CONFIG_CACULE_RDB) - enqueue_throttle: - if (cfs_bandwidth_used()) { - /* -@@ -5890,6 +5951,7 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags) - break; - } - } -+#endif - - assert_list_leaf_cfs_rq(rq); - -@@ -5910,6 +5972,12 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags) - struct cfs_rq *cfs_rq; - struct sched_entity *se = &p->se; - int task_sleep = flags & DEQUEUE_SLEEP; -+ -+#ifdef CONFIG_CACULE_RDB -+ cfs_rq = cfs_rq_of(se); -+ dequeue_entity(cfs_rq, se, flags); -+ cfs_rq->h_nr_running--; -+#else - int idle_h_nr_running = task_has_idle_policy(p); - bool was_sched_idle = sched_idle_rq(rq); - -@@ -5958,15 +6026,18 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags) - goto dequeue_throttle; - - } -+#endif - - /* At this point se is NULL and we are at root level*/ - sub_nr_running(rq, 1); - -+#if !defined(CONFIG_CACULE_RDB) - /* balance early to pull high priority tasks */ - if (unlikely(!was_sched_idle && sched_idle_rq(rq))) - rq->next_balance = jiffies; - - dequeue_throttle: -+#endif - util_est_update(&rq->cfs, p, task_sleep); - hrtick_update(rq); - } -@@ -6102,6 +6173,7 @@ static int wake_wide(struct task_struct *p) - } - #endif /* CONFIG_CACULE_SCHED */ - -+#if !defined(CONFIG_CACULE_RDB) - /* - * The purpose of wake_affine() is to quickly determine on which CPU we can run - * soonest. For the purpose of speed we only consider the waking and previous -@@ -6203,6 +6275,7 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p, - schedstat_inc(p->se.statistics.nr_wakeups_affine); - return target; - } -+#endif - - static struct sched_group * - find_idlest_group(struct sched_domain *sd, struct task_struct *p, int this_cpu); -@@ -7120,13 +7193,15 @@ find_least_IS_cpu(struct task_struct *p) - static int - select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags) - { -+#if !defined(CONFIG_CACULE_RDB) - int sync = (wake_flags & WF_SYNC) && !(current->flags & PF_EXITING); - struct sched_domain *tmp, *sd = NULL; - int cpu = smp_processor_id(); -- int new_cpu = prev_cpu; - int want_affine = 0; - /* SD_flags and WF_flags share the first nibble */ - int sd_flag = wake_flags & 0xF; -+#endif -+ int new_cpu = prev_cpu; - - #ifdef CONFIG_CACULE_SCHED - struct sched_entity *se = &p->se; -@@ -7147,7 +7222,7 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags) - - new_cpu = prev_cpu; - cfs_way: --#else -+#else /* CONFIG_CACULE_SCHED */ - if (wake_flags & WF_TTWU) { - record_wakee(p); - -@@ -7162,6 +7237,9 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags) - } - #endif /* CONFIG_CACULE_SCHED */ - -+#ifdef CONFIG_CACULE_RDB -+ return select_idle_sibling(p, prev_cpu, prev_cpu); -+#else - rcu_read_lock(); - for_each_domain(cpu, tmp) { - /* -@@ -7196,9 +7274,12 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags) - rcu_read_unlock(); - - return new_cpu; -+#endif /* CONFIG_CACULE_RDB */ - } - -+#if !defined(CONFIG_CACULE_RDB) - static void detach_entity_cfs_rq(struct sched_entity *se); -+#endif - - /* - * Called immediately before a task is migrated to a new CPU; task_cpu(p) and -@@ -7235,6 +7316,7 @@ static void migrate_task_rq_fair(struct task_struct *p, int new_cpu) - } - #endif /* CONFIG_CACULE_SCHED */ - -+#if !defined(CONFIG_CACULE_RDB) - if (p->on_rq == TASK_ON_RQ_MIGRATING) { - /* - * In case of TASK_ON_RQ_MIGRATING we in fact hold the 'old' -@@ -7254,6 +7336,7 @@ static void migrate_task_rq_fair(struct task_struct *p, int new_cpu) - */ - remove_entity_load_avg(&p->se); - } -+#endif - - /* Tell new CPU we are migrated */ - p->se.avg.last_update_time = 0; -@@ -7553,11 +7636,23 @@ pick_next_task_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf - if (prev) - put_prev_task(rq, prev); - -+#ifdef CONFIG_CACULE_RDB -+ se = pick_next_entity(cfs_rq, NULL); -+ set_next_entity(cfs_rq, se); -+ -+ if (cfs_rq->head) { -+ unsigned int IS_head = calc_interactivity(sched_clock(), cfs_rq->head); -+ WRITE_ONCE(cfs_rq->IS_head, IS_head); -+ } else { -+ WRITE_ONCE(cfs_rq->IS_head, ~0); -+ } -+#else - do { - se = pick_next_entity(cfs_rq, NULL); - set_next_entity(cfs_rq, se); - cfs_rq = group_cfs_rq(se); - } while (cfs_rq); -+#endif - - p = task_of(se); - -@@ -7579,6 +7674,10 @@ done: __maybe_unused; - return p; - - idle: -+#ifdef CONFIG_CACULE_RDB -+ WRITE_ONCE(cfs_rq->IS_head, ~0); -+#endif -+ - if (!rf) - return NULL; - -@@ -7885,6 +7984,7 @@ struct lb_env { - struct list_head tasks; - }; - -+#if !defined(CONFIG_CACULE_RDB) - /* - * Is this task likely cache-hot: - */ -@@ -8306,6 +8406,7 @@ static void attach_tasks(struct lb_env *env) - - rq_unlock(env->dst_rq, &rf); - } -+#endif - - #ifdef CONFIG_NO_HZ_COMMON - static inline bool cfs_rq_has_blocked(struct cfs_rq *cfs_rq) -@@ -8355,6 +8456,7 @@ static inline void update_blocked_load_tick(struct rq *rq) {} - static inline void update_blocked_load_status(struct rq *rq, bool has_blocked) {} - #endif - -+#if !defined(CONFIG_CACULE_RDB) - static bool __update_blocked_others(struct rq *rq, bool *done) - { - const struct sched_class *curr_class; -@@ -8380,6 +8482,7 @@ static bool __update_blocked_others(struct rq *rq, bool *done) - - return decayed; - } -+#endif - - #ifdef CONFIG_FAIR_GROUP_SCHED - -@@ -8487,6 +8590,7 @@ static unsigned long task_h_load(struct task_struct *p) - cfs_rq_load_avg(cfs_rq) + 1); - } - #else -+#if !defined(CONFIG_CACULE_RDB) - static bool __update_blocked_fair(struct rq *rq, bool *done) - { - struct cfs_rq *cfs_rq = &rq->cfs; -@@ -8498,6 +8602,7 @@ static bool __update_blocked_fair(struct rq *rq, bool *done) - - return decayed; - } -+#endif - - static unsigned long task_h_load(struct task_struct *p) - { -@@ -8505,6 +8610,7 @@ static unsigned long task_h_load(struct task_struct *p) - } - #endif - -+#if !defined(CONFIG_CACULE_RDB) - static void update_blocked_averages(int cpu) - { - bool decayed = false, done = true; -@@ -8523,6 +8629,7 @@ static void update_blocked_averages(int cpu) - cpufreq_update_util(rq, 0); - rq_unlock_irqrestore(rq, &rf); - } -+#endif - - /********** Helpers for find_busiest_group ************************/ - -@@ -9626,6 +9733,7 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s - * different in groups. - */ - -+#if !defined(CONFIG_CACULE_RDB) - /** - * find_busiest_group - Returns the busiest group within the sched_domain - * if there is an imbalance. -@@ -9894,6 +10002,7 @@ static struct rq *find_busiest_queue(struct lb_env *env, - - return busiest; - } -+#endif - - /* - * Max backoff if we encounter pinned tasks. Pretty arbitrary value, but -@@ -9930,6 +10039,7 @@ imbalanced_active_balance(struct lb_env *env) - return 0; - } - -+#if !defined(CONFIG_CACULE_RDB) - static int need_active_balance(struct lb_env *env) - { - struct sched_domain *sd = env->sd; -@@ -10262,6 +10372,7 @@ static int load_balance(int this_cpu, struct rq *this_rq, - out: - return ld_moved; - } -+#endif - - static inline unsigned long - get_sd_balance_interval(struct sched_domain *sd, int cpu_busy) -@@ -10300,6 +10411,7 @@ update_next_balance(struct sched_domain *sd, unsigned long *next_balance) - *next_balance = next; - } - -+#if !defined(CONFIG_CACULE_RDB) - /* - * active_load_balance_cpu_stop is run by the CPU stopper. It pushes - * running tasks off the busiest CPU onto idle CPUs. It requires at -@@ -10385,6 +10497,7 @@ static int active_load_balance_cpu_stop(void *data) - } - - static DEFINE_SPINLOCK(balancing); -+#endif - - /* - * Scale the max load_balance interval with the number of CPUs in the system. -@@ -10395,6 +10508,7 @@ void update_max_interval(void) - max_load_balance_interval = HZ*num_online_cpus()/10; - } - -+#if !defined(CONFIG_CACULE_RDB) - /* - * It checks each scheduling domain to see if it is due to be balanced, - * and initiates a balancing operation if so. -@@ -10487,6 +10601,7 @@ static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle) - rq->next_balance = next_balance; - - } -+#endif - - static inline int on_null_domain(struct rq *rq) - { -@@ -10520,6 +10635,7 @@ static inline int find_new_ilb(void) - return nr_cpu_ids; - } - -+#if !defined(CONFIG_CACULE_RDB) - /* - * Kick a CPU to do the nohz balancing, if it is time for it. We pick any - * idle CPU in the HK_FLAG_MISC housekeeping set (if there is one). -@@ -10670,6 +10786,7 @@ static void nohz_balancer_kick(struct rq *rq) - if (flags) - kick_ilb(flags); - } -+#endif /* CONFIG_CACULE_RDB */ - - static void set_cpu_sd_state_busy(int cpu) - { -@@ -10777,6 +10894,7 @@ void nohz_balance_enter_idle(int cpu) - WRITE_ONCE(nohz.has_blocked, 1); - } - -+#if !defined(CONFIG_CACULE_RDB) - static bool update_nohz_stats(struct rq *rq) - { - unsigned int cpu = rq->cpu; -@@ -10955,8 +11073,10 @@ static void nohz_newidle_balance(struct rq *this_rq) - */ - atomic_or(NOHZ_NEWILB_KICK, nohz_flags(this_cpu)); - } -+#endif - - #else /* !CONFIG_NO_HZ_COMMON */ -+#if !defined(CONFIG_CACULE_RDB) - static inline void nohz_balancer_kick(struct rq *rq) { } - - static inline bool nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle) -@@ -10965,8 +11085,130 @@ static inline bool nohz_idle_balance(struct rq *this_rq, enum cpu_idle_type idle - } - - static inline void nohz_newidle_balance(struct rq *this_rq) { } -+#endif -+ - #endif /* CONFIG_NO_HZ_COMMON */ - -+#ifdef CONFIG_CACULE_RDB -+static int -+can_migrate_task(struct task_struct *p, int dst_cpu, struct rq *src_rq) -+{ -+ if (task_running(src_rq, p)) -+ return 0; -+ -+ if (!cpumask_test_cpu(dst_cpu, p->cpus_ptr)) -+ return 0; -+ -+ if (p->se.exec_start == 0) -+ return 0; -+ -+ return 1; -+} -+ -+static void push_to_unlock(struct rq *this_rq, -+ struct rq *dst_rq, -+ struct task_struct *p, -+ int dst_cpu) -+{ -+ struct rq_flags rf; -+ -+ // detach task -+ deactivate_task(this_rq, p, DEQUEUE_NOCLOCK); -+ set_task_cpu(p, dst_cpu); -+ -+ // unlock this rq -+ raw_spin_unlock(&this_rq->lock); -+ -+ /* push to */ -+ rq_lock_irqsave(dst_rq, &rf); -+ update_rq_clock(dst_rq); -+ -+ activate_task(dst_rq, p, ENQUEUE_NOCLOCK); -+ check_preempt_curr(dst_rq, p, 0); -+ -+ // unlock src rq -+ rq_unlock(dst_rq, &rf); -+ local_irq_restore(rf.flags); -+} -+ -+static void pull_from_unlock(struct rq *this_rq, -+ struct rq *src_rq, -+ struct rq_flags *rf, -+ struct task_struct *p, -+ int dst_cpu) -+{ -+ // detach task -+ deactivate_task(src_rq, p, DEQUEUE_NOCLOCK); -+ set_task_cpu(p, dst_cpu); -+ -+ // unlock src rq -+ rq_unlock(src_rq, rf); -+ local_irq_restore(rf->flags); -+ -+ // lock this rq -+ raw_spin_lock(&this_rq->lock); -+ update_rq_clock(this_rq); -+ -+ activate_task(this_rq, p, ENQUEUE_NOCLOCK); -+ check_preempt_curr(this_rq, p, 0); -+ -+ // unlock this rq -+ raw_spin_unlock(&this_rq->lock); -+} -+ -+static inline struct rq * -+find_max_IS_rq(struct cfs_rq *cfs_rq, int dst_cpu) -+{ -+ struct rq *tmp_rq, *max_rq = NULL; -+ int cpu; -+ u32 max_IS = cfs_rq->IS_head; -+ u32 local_IS; -+ -+ // find max hrrn -+ for_each_online_cpu(cpu) { -+ if (cpu == dst_cpu) -+ continue; -+ -+ tmp_rq = cpu_rq(cpu); -+ -+ if (tmp_rq->cfs.nr_running < 2 || !tmp_rq->cfs.head) -+ continue; -+ -+ local_IS = READ_ONCE(tmp_rq->cfs.IS_head); -+ -+ if (local_IS < max_IS) { -+ max_IS = local_IS; -+ max_rq = tmp_rq; -+ } -+ } -+ -+ return max_rq; -+} -+ -+static int try_pull_from(struct rq *src_rq, struct rq *this_rq) -+{ -+ struct rq_flags rf; -+ int dst_cpu = cpu_of(this_rq); -+ struct task_struct *p; -+ -+ rq_lock_irqsave(src_rq, &rf); -+ update_rq_clock(src_rq); -+ -+ if (src_rq->cfs.head && src_rq->cfs.nr_running > 1) { -+ p = task_of(se_of(src_rq->cfs.head)); -+ -+ if (can_migrate_task(p, dst_cpu, src_rq)) { -+ pull_from_unlock(this_rq, src_rq, &rf, p, dst_cpu); -+ return 1; -+ } -+ } -+ -+ rq_unlock(src_rq, &rf); -+ local_irq_restore(rf.flags); -+ -+ return 0; -+} -+ - /* - * newidle_balance is called by schedule() if this_cpu is about to become - * idle. Attempts to pull tasks from other CPUs. -@@ -10977,6 +11219,105 @@ static inline void nohz_newidle_balance(struct rq *this_rq) { } - * > 0 - success, new (fair) tasks present - */ - static int newidle_balance(struct rq *this_rq, struct rq_flags *rf) -+{ -+ int this_cpu = this_rq->cpu; -+ struct task_struct *p = NULL; -+ struct rq *src_rq; -+ int src_cpu; -+ struct rq_flags src_rf; -+ int pulled_task = 0; -+ int cores_round = 1; -+ -+ update_misfit_status(NULL, this_rq); -+ /* -+ * We must set idle_stamp _before_ calling idle_balance(), such that we -+ * measure the duration of idle_balance() as idle time. -+ */ -+ this_rq->idle_stamp = rq_clock(this_rq); -+ -+ /* -+ * Do not pull tasks towards !active CPUs... -+ */ -+ if (!cpu_active(this_cpu)) -+ return 0; -+ -+ /* -+ * This is OK, because current is on_cpu, which avoids it being picked -+ * for load-balance and preemption/IRQs are still disabled avoiding -+ * further scheduler activity on it and we're being very careful to -+ * re-start the picking loop. -+ */ -+ rq_unpin_lock(this_rq, rf); -+ raw_spin_unlock(&this_rq->lock); -+ -+again: -+ for_each_online_cpu(src_cpu) { -+ -+ if (src_cpu == this_cpu) -+ continue; -+ -+ if (cores_round && !cpus_share_cache(src_cpu, this_cpu)) -+ continue; -+ -+ src_rq = cpu_rq(src_cpu); -+ -+ rq_lock_irqsave(src_rq, &src_rf); -+ update_rq_clock(src_rq); -+ -+ if (src_rq->cfs.nr_running < 2 || !(src_rq->cfs.head)) -+ goto next; -+ -+ p = task_of(se_of(src_rq->cfs.head)); -+ -+ if (can_migrate_task(p, this_cpu, src_rq)) { -+ pull_from_unlock(this_rq, src_rq, &src_rf, p, this_cpu); -+ -+ pulled_task = 1; -+ goto out; -+ } -+ -+next: -+ rq_unlock(src_rq, &src_rf); -+ local_irq_restore(src_rf.flags); -+ -+ /* -+ * Stop searching for tasks to pull if there are -+ * now runnable tasks on this rq. -+ */ -+ if (pulled_task || this_rq->nr_running > 0) -+ goto out; -+ } -+ -+ if (cores_round) { -+ // now search for all cpus -+ cores_round = 0; -+ goto again; -+ } -+ -+out: -+ raw_spin_lock(&this_rq->lock); -+ -+ /* -+ * While browsing the domains, we released the rq lock, a task could -+ * have been enqueued in the meantime. Since we're not going idle, -+ * pretend we pulled a task. -+ */ -+ if (this_rq->cfs.h_nr_running && !pulled_task) -+ pulled_task = 1; -+ -+ /* Is there a task of a high priority class? */ -+ if (this_rq->nr_running != this_rq->cfs.h_nr_running) -+ pulled_task = -1; -+ -+ if (pulled_task) -+ this_rq->idle_stamp = 0; -+ -+ rq_repin_lock(this_rq, rf); -+ -+ return pulled_task; -+} -+#else -+static int newidle_balance(struct rq *this_rq, struct rq_flags *rf) - { - unsigned long next_balance = jiffies + HZ; - int this_cpu = this_rq->cpu; -@@ -11130,6 +11471,214 @@ void trigger_load_balance(struct rq *rq) - - nohz_balancer_kick(rq); - } -+#endif -+ -+#ifdef CONFIG_CACULE_RDB -+static int -+idle_try_pull_any(struct cfs_rq *cfs_rq) -+{ -+ struct task_struct *p = NULL; -+ struct rq *this_rq = rq_of(cfs_rq), *src_rq; -+ int dst_cpu = cpu_of(this_rq); -+ int src_cpu; -+ struct rq_flags rf; -+ int pulled = 0; -+ int cores_round = 1; -+ -+again: -+ for_each_online_cpu(src_cpu) { -+ -+ if (src_cpu == dst_cpu) -+ continue; -+ -+ if (cores_round && !cpus_share_cache(src_cpu, dst_cpu)) -+ continue; -+ -+ src_rq = cpu_rq(src_cpu); -+ -+ rq_lock_irqsave(src_rq, &rf); -+ update_rq_clock(src_rq); -+ -+ if (src_rq->cfs.nr_running < 2 || !(src_rq->cfs.head)) -+ goto next; -+ -+ p = task_of(se_of(src_rq->cfs.head)); -+ -+ if (can_migrate_task(p, dst_cpu, src_rq)) { -+ pull_from_unlock(this_rq, src_rq, &rf, p, dst_cpu); -+ pulled = 1; -+ goto out; -+ } -+ -+next: -+ rq_unlock(src_rq, &rf); -+ local_irq_restore(rf.flags); -+ } -+ -+ if (cores_round) { -+ // now search for all cpus -+ cores_round = 0; -+ goto again; -+ } -+ -+out: -+ return pulled; -+} -+ -+ -+static int -+try_pull_higher_IS(struct cfs_rq *cfs_rq) -+{ -+ struct rq *this_rq = rq_of(cfs_rq), *max_rq; -+ int dst_cpu = cpu_of(this_rq); -+ -+ max_rq = find_max_IS_rq(cfs_rq, dst_cpu); -+ -+ if (!max_rq) -+ return 0; -+ -+ if (try_pull_from(max_rq, this_rq)) -+ return 1; -+ -+ return 0; -+} -+ -+static void try_push_any(struct rq *this_rq) -+{ -+ struct task_struct *p = NULL; -+ struct rq *dst_rq; -+ int dst_cpu; -+ int src_cpu = cpu_of(this_rq); -+ int cores_round = 1; -+ -+again: -+ for_each_online_cpu(dst_cpu) { -+ -+ if (dst_cpu == src_cpu) -+ continue; -+ -+ if (cores_round && !cpus_share_cache(src_cpu, dst_cpu)) -+ continue; -+ -+ dst_rq = cpu_rq(dst_cpu); -+ -+ if (dst_rq->cfs.nr_running >= this_rq->cfs.nr_running - 1) -+ continue; -+ -+ // lock this rq -+ raw_spin_lock(&this_rq->lock); -+ update_rq_clock(this_rq); -+ -+ if (!this_rq->cfs.head) { -+ // unlock this rq -+ raw_spin_unlock(&this_rq->lock); -+ return; -+ } -+ -+ p = task_of(se_of(this_rq->cfs.head)); -+ -+ if (can_migrate_task(p, dst_cpu, this_rq)) { -+ push_to_unlock(this_rq, dst_rq, p, dst_cpu); -+ return; -+ } -+ -+ // unlock this rq -+ raw_spin_unlock(&this_rq->lock); -+ } -+ -+ if (cores_round) { -+ // now search for all cpus -+ cores_round = 0; -+ goto again; -+ } -+} -+ -+static void try_pull_any(struct rq *this_rq) -+{ -+ struct task_struct *p = NULL; -+ struct rq *src_rq; -+ int dst_cpu = cpu_of(this_rq); -+ int src_cpu; -+ struct rq_flags src_rf; -+ int cores_round = 1; -+ unsigned int this_head = this_rq->cfs.IS_head; -+ -+again: -+ for_each_online_cpu(src_cpu) { -+ -+ if (src_cpu == dst_cpu) -+ continue; -+ -+ if (cores_round && !cpus_share_cache(src_cpu, dst_cpu)) -+ continue; -+ -+ src_rq = cpu_rq(src_cpu); -+ -+ if (src_rq->cfs.nr_running < 2 || !(src_rq->cfs.head) -+ || READ_ONCE(src_rq->cfs.IS_head) >= this_head) -+ continue; -+ -+ rq_lock_irqsave(src_rq, &src_rf); -+ update_rq_clock(src_rq); -+ -+ if (src_rq->cfs.nr_running < 2 || !(src_rq->cfs.head) -+ || src_rq->cfs.IS_head >= this_head) -+ goto next; -+ -+ p = task_of(se_of(src_rq->cfs.head)); -+ -+ if (can_migrate_task(p, dst_cpu, src_rq)) { -+ pull_from_unlock(this_rq, src_rq, &src_rf, p, dst_cpu); -+ return; -+ } -+ -+next: -+ rq_unlock(src_rq, &src_rf); -+ local_irq_restore(src_rf.flags); -+ } -+ -+ if (cores_round) { -+ // now search for all cpus -+ cores_round = 0; -+ goto again; -+ } -+} -+ -+static inline void -+active_balance(struct rq *rq) -+{ -+ struct cfs_rq *cfs_rq = &rq->cfs; -+ -+ if (!cfs_rq->head || cfs_rq->nr_running < 2) -+ try_pull_higher_IS(&rq->cfs); -+ else { -+ try_push_any(rq); -+ try_pull_any(rq); -+ } -+} -+ -+void trigger_load_balance(struct rq *rq) -+{ -+ unsigned long interval; -+ -+#ifdef CONFIG_RDB_INTERVAL -+ if (time_before(jiffies, rq->next_balance)) -+ return; -+#endif -+ -+ if (rq->idle_balance) -+ idle_try_pull_any(&rq->cfs); -+ else { -+ active_balance(rq); -+ -+#ifdef CONFIG_RDB_INTERVAL -+ /* scale ms to jiffies */ -+ interval = msecs_to_jiffies(CONFIG_RDB_INTERVAL); -+ rq->next_balance = jiffies + interval; -+#endif -+ } -+} -+#endif - - static void rq_online_fair(struct rq *rq) - { -@@ -11308,9 +11857,12 @@ static void propagate_entity_cfs_rq(struct sched_entity *se) - } - } - #else -+#if !defined(CONFIG_CACULE_RDB) - static void propagate_entity_cfs_rq(struct sched_entity *se) { } - #endif -+#endif - -+#if !defined(CONFIG_CACULE_RDB) - static void detach_entity_cfs_rq(struct sched_entity *se) - { - struct cfs_rq *cfs_rq = cfs_rq_of(se); -@@ -11321,9 +11873,11 @@ static void detach_entity_cfs_rq(struct sched_entity *se) - update_tg_load_avg(cfs_rq); - propagate_entity_cfs_rq(se); - } -+#endif - - static void attach_entity_cfs_rq(struct sched_entity *se) - { -+#if !defined(CONFIG_CACULE_RDB) - struct cfs_rq *cfs_rq = cfs_rq_of(se); - - #ifdef CONFIG_FAIR_GROUP_SCHED -@@ -11339,10 +11893,12 @@ static void attach_entity_cfs_rq(struct sched_entity *se) - attach_entity_load_avg(cfs_rq, se); - update_tg_load_avg(cfs_rq); - propagate_entity_cfs_rq(se); -+#endif - } - - static void detach_task_cfs_rq(struct task_struct *p) - { -+#if !defined(CONFIG_CACULE_RDB) - struct sched_entity *se = &p->se; - - #if !defined(CONFIG_CACULE_SCHED) -@@ -11359,10 +11915,12 @@ static void detach_task_cfs_rq(struct task_struct *p) - #endif - - detach_entity_cfs_rq(se); -+#endif - } - - static void attach_task_cfs_rq(struct task_struct *p) - { -+#if !defined(CONFIG_CACULE_RDB) - struct sched_entity *se = &p->se; - - #if !defined(CONFIG_CACULE_SCHED) -@@ -11375,6 +11933,7 @@ static void attach_task_cfs_rq(struct task_struct *p) - if (!vruntime_normalized(p)) - se->vruntime += cfs_rq->min_vruntime; - #endif -+#endif - } - - static void switched_from_fair(struct rq *rq, struct task_struct *p) -@@ -11770,7 +12329,9 @@ void show_numa_stats(struct task_struct *p, struct seq_file *m) - __init void init_sched_fair_class(void) - { - #ifdef CONFIG_SMP -+#if !defined(CONFIG_CACULE_RDB) - open_softirq(SCHED_SOFTIRQ, run_rebalance_domains); -+#endif - - #ifdef CONFIG_NO_HZ_COMMON - nohz.next_balance = jiffies; -diff --git a/kernel/sched/idle.c b/kernel/sched/idle.c -index 7ca3d3d86c2a..a7422dea8a9f 100644 ---- a/kernel/sched/idle.c -+++ b/kernel/sched/idle.c -@@ -262,10 +262,12 @@ static void do_idle(void) - { - int cpu = smp_processor_id(); - -+#if !defined(CONFIG_CACULE_RDB) - /* - * Check if we need to update blocked load - */ - nohz_run_idle_balance(cpu); -+#endif - - /* - * If the arch has a polling bit, we maintain an invariant: -diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h -index 0affe3be7c21..576909c92fb5 100644 ---- a/kernel/sched/sched.h -+++ b/kernel/sched/sched.h -@@ -544,6 +544,10 @@ struct cfs_rq { - struct cacule_node *head; - struct cacule_node *tail; - -+#ifdef CONFIG_CACULE_RDB -+ unsigned int IS_head; -+#endif -+ - #else - struct sched_entity *next; - struct sched_entity *last; -@@ -951,7 +955,6 @@ struct rq { - struct cfs_rq cfs; - struct rt_rq rt; - struct dl_rq dl; -- - #ifdef CONFIG_FAIR_GROUP_SCHED - /* list of leaf cfs_rq on this CPU: */ - struct list_head leaf_cfs_rq_list;