Linux 5.4.50
-----BEGIN PGP SIGNATURE-----
iQIzBAABCgAdFiEE4n5dijQDou9mhzu83qZv95d3LNwFAl77nuMACgkQ3qZv95d3
LNw0EA//UhQOd/8ZlP33Iis58gUfuGU9sWmej6A8Tio2gdkG4g2c/dQjbxrMQT8b
Vr1DJCthisT7pBJpQbhejwsfl5qRsrjBYFyUomCjeM8/0fF0+8JX0tSXX0/JM5Bg
vOE4tV/kga+c5cbOD/FbLGH0vX4j20BnGXjHb9hyWY/gVp2gEcRzO3Ou0shZCXKJ
9NnhNB2gIm7BCRgz+cClPmZQjG59WazJu9I/Fk58ojdOp+E5gFibyBoeOylGR/W/
tjRm3Sz6D3uF0RSpGfAilqt2duwfjHTh0LxWlBX9C4OBWdJjYh1uUZ24tTvjxnCm
lbgL4BbkOsVMp02jWhDDCe+pEPfT7EpLD6USivj8XFDLh8FK0eoaRQZRQ/hGK/Yj
ZmVJRzNavf3xbz72Hz6aHdHmaxp180P8X8KtRDLT4ik+Kkf8gJVps3T5wTR9C60R
htFVTDxEF+jE/EUCRh3sD4MrV114lpoJ5LlTPzJ87WCMHMjTZ8As/Ty/PLPg7KO6
ngI3y72cnvW/UfLPmdtaLx40gzEAYnw9+E30ebyKU6b8kY5idhuzd0AZnidsmeZa
CzmZFZSCqqMO9vLo24VKxfKk3ufRiHxDU/nHqdGgOG18RlCmhWD0GXamsmeku3PB
1et/jXilpW9aIp/BJozeOdlGr82otk/4Ss+z/RtvvIkTbppgXlY=
=6X7m
-----END PGP SIGNATURE-----
Merge 5.4.50 into android-5.4-stable
Changes in 5.4.50
block/bio-integrity: don't free 'buf' if bio_integrity_add_page() failed
enetc: Fix tx rings bitmap iteration range, irq handling
geneve: allow changing DF behavior after creation
ibmveth: Fix max MTU limit
mld: fix memory leak in ipv6_mc_destroy_dev()
mvpp2: ethtool rxtx stats fix
net: bridge: enfore alignment for ethernet address
net: core: reduce recursion limit value
net: Do not clear the sock TX queue in sk_set_socket()
net: fix memleak in register_netdevice()
net: Fix the arp error in some cases
net: increment xmit_recursion level in dev_direct_xmit()
net: usb: ax88179_178a: fix packet alignment padding
openvswitch: take into account de-fragmentation/gso_size in execute_check_pkt_len
rocker: fix incorrect error handling in dma_rings_init
rxrpc: Fix notification call on completion of discarded calls
sctp: Don't advertise IPv4 addresses if ipv6only is set on the socket
tcp: don't ignore ECN CWR on pure ACK
tcp: grow window for OOO packets only for SACK flows
tg3: driver sleeps indefinitely when EEH errors exceed eeh_max_freezes
ip6_gre: fix use-after-free in ip6gre_tunnel_lookup()
net: phy: Check harder for errors in get_phy_id()
ip_tunnel: fix use-after-free in ip_tunnel_lookup()
sch_cake: don't try to reallocate or unshare skb unconditionally
sch_cake: don't call diffserv parsing code when it is not needed
sch_cake: fix a few style nits
tcp_cubic: fix spurious HYSTART_DELAY exit upon drop in min RTT
Revert "i2c: tegra: Fix suspending in active runtime PM state"
btrfs: fix a block group ref counter leak after failure to remove block group
net: sched: export __netdev_watchdog_up()
fix a braino in "sparc32: fix register window handling in genregs32_[gs]et()"
ALSA: usb-audio: Fix potential use-after-free of streams
binder: fix null deref of proc->context
USB: ohci-sm501: Add missed iounmap() in remove
usb: dwc2: Postponed gadget registration to the udc class driver
usb: add USB_QUIRK_DELAY_INIT for Logitech C922
USB: ehci: reopen solution for Synopsys HC bug
usb: host: xhci-mtk: avoid runtime suspend when removing hcd
xhci: Poll for U0 after disabling USB2 LPM
usb: host: ehci-exynos: Fix error check in exynos_ehci_probe()
usb: typec: tcpci_rt1711h: avoid screaming irq causing boot hangs
ALSA: usb-audio: Add implicit feedback quirk for SSL2+.
ALSA: usb-audio: add quirk for Denon DCD-1500RE
ALSA: usb-audio: add quirk for Samsung USBC Headset (AKG)
ALSA: usb-audio: Fix OOB access of mixer element list
usb: cdns3: trace: using correct dir value
usb: cdns3: ep0: fix the test mode set incorrectly
usb: cdns3: ep0: add spinlock for cdns3_check_new_setup
scsi: qla2xxx: Keep initiator ports after RSCN
scsi: zfcp: Fix panic on ERP timeout for previously dismissed ERP action
cifs: Fix cached_fid refcnt leak in open_shroot
cifs/smb3: Fix data inconsistent when punch hole
cifs/smb3: Fix data inconsistent when zero file range
xhci: Fix incorrect EP_STATE_MASK
xhci: Fix enumeration issue when setting max packet size for FS devices.
xhci: Return if xHCI doesn't support LPM
cdc-acm: Add DISABLE_ECHO quirk for Microchip/SMSC chip
loop: replace kill_bdev with invalidate_bdev
IB/mad: Fix use after free when destroying MAD agent
IB/hfi1: Fix module use count flaw due to leftover module put calls
bus: ti-sysc: Flush posted write on enable and disable
bus: ti-sysc: Ignore clockactivity unless specified as a quirk
ARM: OMAP2+: Fix legacy mode dss_reset
xfrm: Fix double ESP trailer insertion in IPsec crypto offload.
ASoC: q6asm: handle EOS correctly
efi/tpm: Verify event log header before parsing
efi/esrt: Fix reference count leak in esre_create_sysfs_entry.
ASoc: q6afe: add support to get port direction
ASoC: qcom: common: set correct directions for dailinks
regualtor: pfuze100: correct sw1a/sw2 on pfuze3000
RDMA/siw: Fix pointer-to-int-cast warning in siw_rx_pbl()
ASoC: fsl_ssi: Fix bclk calculation for mono channel
samples/bpf: xdp_redirect_cpu: Set MAX_CPUS according to NR_CPUS
bpf, xdp, samples: Fix null pointer dereference in *_user code
ARM: dts: am335x-pocketbeagle: Fix mmc0 Write Protect
ARM: dts: Fix duovero smsc interrupt for suspend
x86/resctrl: Fix a NULL vs IS_ERR() static checker warning in rdt_cdp_peer_get()
regmap: Fix memory leak from regmap_register_patch
devmap: Use bpf_map_area_alloc() for allocating hash buckets
bpf: Don't return EINVAL from {get,set}sockopt when optlen > PAGE_SIZE
ARM: dts: NSP: Correct FA2 mailbox node
rxrpc: Fix handling of rwind from an ACK packet
RDMA/rvt: Fix potential memory leak caused by rvt_alloc_rq
RDMA/qedr: Fix KASAN: use-after-free in ucma_event_handler+0x532
RDMA/cma: Protect bind_list and listen_list while finding matching cm id
ASoC: rockchip: Fix a reference count leak.
s390/qeth: fix error handling for isolation mode cmds
RDMA/mad: Fix possible memory leak in ib_mad_post_receive_mads()
selftests/net: report etf errors correctly
iommu/vt-d: Enable PCI ACS for platform opt in hint
iommu/vt-d: Update scalable mode paging structure coherency
net: qed: fix left elements count calculation
net: qed: fix async event callbacks unregistering
net: qede: stop adding events on an already destroyed workqueue
net: qed: fix NVMe login fails over VFs
net: qed: fix excessive QM ILT lines consumption
net: qede: fix PTP initialization on recovery
net: qede: fix use-after-free on recovery and AER handling
cxgb4: move handling L2T ARP failures to caller
ARM: imx5: add missing put_device() call in imx_suspend_alloc_ocram()
scsi: lpfc: Avoid another null dereference in lpfc_sli4_hba_unset()
usb: gadget: udc: Potential Oops in error handling code
usb: renesas_usbhs: getting residue from callback_result
nvme: don't protect ns mutation with ns->head->lock
netfilter: ipset: fix unaligned atomic access
net: bcmgenet: use hardware padding of runt frames
clk: sifive: allocate sufficient memory for struct __prci_data
i2c: fsi: Fix the port number field in status register
i2c: core: check returned size of emulated smbus block read
afs: Fix storage of cell names
sched/deadline: Initialize ->dl_boosted
sched/core: Fix PI boosting between RT and DEADLINE tasks
sata_rcar: handle pm_runtime_get_sync failure cases
ata/libata: Fix usage of page address by page_address in ata_scsi_mode_select_xlat function
drm/amd/display: Use kfree() to free rgb_user in calculate_user_regamma_ramp()
riscv/atomic: Fix sign extension for RV64I
hwrng: ks-sa - Fix runtime PM imbalance on error
ibmvnic: Harden device login requests
net: alx: fix race condition in alx_remove
test_objagg: Fix potential memory leak in error handling
pinctrl: qcom: spmi-gpio: fix warning about irq chip reusage
pinctrl: tegra: Use noirq suspend/resume callbacks
s390/ptrace: pass invalid syscall numbers to tracing
s390/ptrace: fix setting syscall number
s390/vdso: Use $(LD) instead of $(CC) to link vDSO
s390/vdso: fix vDSO clock_getres()
arm64: sve: Fix build failure when ARM64_SVE=y and SYSCTL=n
kbuild: improve cc-option to clean up all temporary files
recordmcount: support >64k sections
kprobes: Suppress the suspicious RCU warning on kprobes
blktrace: break out of blktrace setup on concurrent calls
block: update hctx map when use multiple maps
RISC-V: Don't allow write+exec only page mapping request in mmap
ALSA: hda: Add NVIDIA codec IDs 9a & 9d through a0 to patch table
ALSA: hda/realtek - Add quirk for MSI GE63 laptop
ALSA: hda/realtek: Add mute LED and micmute LED support for HP systems
ACPI: sysfs: Fix pm_profile_attr type
ACPI: configfs: Disallow loading ACPI tables when locked down
erofs: fix partially uninitialized misuse in z_erofs_onlinepage_fixup
KVM: X86: Fix MSR range of APIC registers in X2APIC mode
KVM: nVMX: Plumb L2 GPA through to PML emulation
KVM: VMX: Stop context switching MSR_IA32_UMWAIT_CONTROL
x86/cpu: Use pinning mask for CR4 bits needing to be 0
x86/asm/64: Align start of __clear_user() loop to 16-bytes
btrfs: fix bytes_may_use underflow when running balance and scrub in parallel
btrfs: fix data block group relocation failure due to concurrent scrub
btrfs: check if a log root exists before locking the log_mutex on unlink
btrfs: fix failure of RWF_NOWAIT write into prealloc extent beyond eof
mm/slab: use memzero_explicit() in kzfree()
ocfs2: avoid inode removal while nfsd is accessing it
ocfs2: load global_inode_alloc
ocfs2: fix value of OCFS2_INVALID_SLOT
ocfs2: fix panic on nfs server over ocfs2
mm/memcontrol.c: add missed css_put()
arm64: perf: Report the PC value in REGS_ABI_32 mode
arm64: dts: imx8mm-evk: correct ldo1/ldo2 voltage range
arm64: dts: imx8mn-ddr4-evk: correct ldo1/ldo2 voltage range
tracing: Fix event trigger to accept redundant spaces
ring-buffer: Zero out time extend if it is nested and not absolute
drm/amd: fix potential memleak in err branch
drm: rcar-du: Fix build error
drm/radeon: fix fb_div check in ni_init_smc_spll_table()
drm/amdgpu: add fw release for sdma v5_0
Staging: rtl8723bs: prevent buffer overflow in update_sta_support_rate()
sunrpc: fixed rollback in rpc_gssd_dummy_populate()
SUNRPC: Properly set the @subbuf parameter of xdr_buf_subsegment()
pNFS/flexfiles: Fix list corruption if the mirror count changes
NFSv4 fix CLOSE not waiting for direct IO compeletion
xprtrdma: Fix handling of RDMA_ERROR replies
dm writecache: correct uncommitted_block when discarding uncommitted entry
dm writecache: add cond_resched to loop in persistent_memory_claim()
xfs: add agf freeblocks verify in xfs_agf_verify
Revert "tty: hvc: Fix data abort due to race in hvc_open"
Linux 5.4.50
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
Change-Id: I3bfeaba86876d3c2f91979d3e98d894a2b70fe1a
This commit is contained in:
Greg Kroah-Hartman
commit
a200ad52ff
2
Makefile
2
Makefile
@ -1,7 +1,7 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 5
|
||||
PATCHLEVEL = 4
|
||||
SUBLEVEL = 49
|
||||
SUBLEVEL = 50
|
||||
EXTRAVERSION =
|
||||
NAME = Kleptomaniac Octopus
|
||||
|
||||
|
||||
@ -88,7 +88,6 @@
|
||||
AM33XX_PADCONF(AM335X_PIN_MMC0_DAT3, PIN_INPUT_PULLUP, MUX_MODE0)
|
||||
AM33XX_PADCONF(AM335X_PIN_MMC0_CMD, PIN_INPUT_PULLUP, MUX_MODE0)
|
||||
AM33XX_PADCONF(AM335X_PIN_MMC0_CLK, PIN_INPUT_PULLUP, MUX_MODE0)
|
||||
AM33XX_PADCONF(AM335X_PIN_MCASP0_ACLKR, PIN_INPUT, MUX_MODE4) /* (B12) mcasp0_aclkr.mmc0_sdwp */
|
||||
>;
|
||||
};
|
||||
|
||||
|
||||
@ -257,10 +257,10 @@
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
mailbox: mailbox@25000 {
|
||||
mailbox: mailbox@25c00 {
|
||||
compatible = "brcm,iproc-fa2-mbox";
|
||||
reg = <0x25000 0x445>;
|
||||
interrupts = <GIC_SPI 150 IRQ_TYPE_LEVEL_HIGH>;
|
||||
reg = <0x25c00 0x400>;
|
||||
interrupts = <GIC_SPI 151 IRQ_TYPE_LEVEL_HIGH>;
|
||||
#mbox-cells = <1>;
|
||||
brcm,rx-status-len = <32>;
|
||||
brcm,use-bcm-hdr;
|
||||
|
||||
@ -139,7 +139,7 @@
|
||||
ethernet@gpmc {
|
||||
reg = <5 0 0xff>;
|
||||
interrupt-parent = <&gpio2>;
|
||||
interrupts = <12 IRQ_TYPE_EDGE_FALLING>; /* gpio_44 */
|
||||
interrupts = <12 IRQ_TYPE_LEVEL_LOW>; /* gpio_44 */
|
||||
|
||||
phy-mode = "mii";
|
||||
|
||||
|
||||
@ -295,14 +295,14 @@ static int __init imx_suspend_alloc_ocram(
|
||||
if (!ocram_pool) {
|
||||
pr_warn("%s: ocram pool unavailable!\n", __func__);
|
||||
ret = -ENODEV;
|
||||
goto put_node;
|
||||
goto put_device;
|
||||
}
|
||||
|
||||
ocram_base = gen_pool_alloc(ocram_pool, size);
|
||||
if (!ocram_base) {
|
||||
pr_warn("%s: unable to alloc ocram!\n", __func__);
|
||||
ret = -ENOMEM;
|
||||
goto put_node;
|
||||
goto put_device;
|
||||
}
|
||||
|
||||
phys = gen_pool_virt_to_phys(ocram_pool, ocram_base);
|
||||
@ -312,6 +312,8 @@ static int __init imx_suspend_alloc_ocram(
|
||||
if (virt_out)
|
||||
*virt_out = virt;
|
||||
|
||||
put_device:
|
||||
put_device(&pdev->dev);
|
||||
put_node:
|
||||
of_node_put(node);
|
||||
|
||||
|
||||
@ -3535,7 +3535,7 @@ static const struct omap_hwmod_reset dra7_reset_quirks[] = {
|
||||
};
|
||||
|
||||
static const struct omap_hwmod_reset omap_reset_quirks[] = {
|
||||
{ .match = "dss", .len = 3, .reset = omap_dss_reset, },
|
||||
{ .match = "dss_core", .len = 8, .reset = omap_dss_reset, },
|
||||
{ .match = "hdq1w", .len = 5, .reset = omap_hdq1w_reset, },
|
||||
{ .match = "i2c", .len = 3, .reset = omap_i2c_reset, },
|
||||
{ .match = "wd_timer", .len = 8, .reset = omap2_wd_timer_reset, },
|
||||
|
||||
@ -231,7 +231,7 @@
|
||||
|
||||
ldo1_reg: LDO1 {
|
||||
regulator-name = "LDO1";
|
||||
regulator-min-microvolt = <3000000>;
|
||||
regulator-min-microvolt = <1600000>;
|
||||
regulator-max-microvolt = <3300000>;
|
||||
regulator-boot-on;
|
||||
regulator-always-on;
|
||||
@ -239,7 +239,7 @@
|
||||
|
||||
ldo2_reg: LDO2 {
|
||||
regulator-name = "LDO2";
|
||||
regulator-min-microvolt = <900000>;
|
||||
regulator-min-microvolt = <800000>;
|
||||
regulator-max-microvolt = <900000>;
|
||||
regulator-boot-on;
|
||||
regulator-always-on;
|
||||
|
||||
@ -268,7 +268,7 @@
|
||||
|
||||
ldo1_reg: LDO1 {
|
||||
regulator-name = "LDO1";
|
||||
regulator-min-microvolt = <3000000>;
|
||||
regulator-min-microvolt = <1600000>;
|
||||
regulator-max-microvolt = <3300000>;
|
||||
regulator-boot-on;
|
||||
regulator-always-on;
|
||||
@ -276,7 +276,7 @@
|
||||
|
||||
ldo2_reg: LDO2 {
|
||||
regulator-name = "LDO2";
|
||||
regulator-min-microvolt = <900000>;
|
||||
regulator-min-microvolt = <800000>;
|
||||
regulator-max-microvolt = <900000>;
|
||||
regulator-boot-on;
|
||||
regulator-always-on;
|
||||
|
||||
@ -338,7 +338,7 @@ static unsigned int find_supported_vector_length(unsigned int vl)
|
||||
return sve_vl_from_vq(__bit_to_vq(bit));
|
||||
}
|
||||
|
||||
#ifdef CONFIG_SYSCTL
|
||||
#if defined(CONFIG_ARM64_SVE) && defined(CONFIG_SYSCTL)
|
||||
|
||||
static int sve_proc_do_default_vl(struct ctl_table *table, int write,
|
||||
void __user *buffer, size_t *lenp,
|
||||
@ -384,9 +384,9 @@ static int __init sve_sysctl_init(void)
|
||||
return 0;
|
||||
}
|
||||
|
||||
#else /* ! CONFIG_SYSCTL */
|
||||
#else /* ! (CONFIG_ARM64_SVE && CONFIG_SYSCTL) */
|
||||
static int __init sve_sysctl_init(void) { return 0; }
|
||||
#endif /* ! CONFIG_SYSCTL */
|
||||
#endif /* ! (CONFIG_ARM64_SVE && CONFIG_SYSCTL) */
|
||||
|
||||
#define ZREG(sve_state, vq, n) ((char *)(sve_state) + \
|
||||
(SVE_SIG_ZREG_OFFSET(vq, n) - SVE_SIG_REGS_OFFSET))
|
||||
|
||||
@ -15,15 +15,34 @@ u64 perf_reg_value(struct pt_regs *regs, int idx)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* Compat (i.e. 32 bit) mode:
|
||||
* - PC has been set in the pt_regs struct in kernel_entry,
|
||||
* - Handle SP and LR here.
|
||||
* Our handling of compat tasks (PERF_SAMPLE_REGS_ABI_32) is weird, but
|
||||
* we're stuck with it for ABI compatability reasons.
|
||||
*
|
||||
* For a 32-bit consumer inspecting a 32-bit task, then it will look at
|
||||
* the first 16 registers (see arch/arm/include/uapi/asm/perf_regs.h).
|
||||
* These correspond directly to a prefix of the registers saved in our
|
||||
* 'struct pt_regs', with the exception of the PC, so we copy that down
|
||||
* (x15 corresponds to SP_hyp in the architecture).
|
||||
*
|
||||
* So far, so good.
|
||||
*
|
||||
* The oddity arises when a 64-bit consumer looks at a 32-bit task and
|
||||
* asks for registers beyond PERF_REG_ARM_MAX. In this case, we return
|
||||
* SP_usr, LR_usr and PC in the positions where the AArch64 SP, LR and
|
||||
* PC registers would normally live. The initial idea was to allow a
|
||||
* 64-bit unwinder to unwind a 32-bit task and, although it's not clear
|
||||
* how well that works in practice, somebody might be relying on it.
|
||||
*
|
||||
* At the time we make a sample, we don't know whether the consumer is
|
||||
* 32-bit or 64-bit, so we have to cater for both possibilities.
|
||||
*/
|
||||
if (compat_user_mode(regs)) {
|
||||
if ((u32)idx == PERF_REG_ARM64_SP)
|
||||
return regs->compat_sp;
|
||||
if ((u32)idx == PERF_REG_ARM64_LR)
|
||||
return regs->compat_lr;
|
||||
if (idx == 15)
|
||||
return regs->pc;
|
||||
}
|
||||
|
||||
if ((u32)idx == PERF_REG_ARM64_SP)
|
||||
|
||||
@ -179,7 +179,7 @@
|
||||
" bnez %1, 0b\n" \
|
||||
"1:\n" \
|
||||
: "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) \
|
||||
: "rJ" (__old), "rJ" (__new) \
|
||||
: "rJ" ((long)__old), "rJ" (__new) \
|
||||
: "memory"); \
|
||||
break; \
|
||||
case 8: \
|
||||
@ -224,7 +224,7 @@
|
||||
RISCV_ACQUIRE_BARRIER \
|
||||
"1:\n" \
|
||||
: "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) \
|
||||
: "rJ" (__old), "rJ" (__new) \
|
||||
: "rJ" ((long)__old), "rJ" (__new) \
|
||||
: "memory"); \
|
||||
break; \
|
||||
case 8: \
|
||||
@ -270,7 +270,7 @@
|
||||
" bnez %1, 0b\n" \
|
||||
"1:\n" \
|
||||
: "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) \
|
||||
: "rJ" (__old), "rJ" (__new) \
|
||||
: "rJ" ((long)__old), "rJ" (__new) \
|
||||
: "memory"); \
|
||||
break; \
|
||||
case 8: \
|
||||
@ -316,7 +316,7 @@
|
||||
" fence rw, rw\n" \
|
||||
"1:\n" \
|
||||
: "=&r" (__ret), "=&r" (__rc), "+A" (*__ptr) \
|
||||
: "rJ" (__old), "rJ" (__new) \
|
||||
: "rJ" ((long)__old), "rJ" (__new) \
|
||||
: "memory"); \
|
||||
break; \
|
||||
case 8: \
|
||||
|
||||
@ -8,6 +8,7 @@
|
||||
#include <linux/syscalls.h>
|
||||
#include <asm/unistd.h>
|
||||
#include <asm/cacheflush.h>
|
||||
#include <asm-generic/mman-common.h>
|
||||
|
||||
static long riscv_sys_mmap(unsigned long addr, unsigned long len,
|
||||
unsigned long prot, unsigned long flags,
|
||||
@ -16,6 +17,11 @@ static long riscv_sys_mmap(unsigned long addr, unsigned long len,
|
||||
{
|
||||
if (unlikely(offset & (~PAGE_MASK >> page_shift_offset)))
|
||||
return -EINVAL;
|
||||
|
||||
if ((prot & PROT_WRITE) && (prot & PROT_EXEC))
|
||||
if (unlikely(!(prot & PROT_READ)))
|
||||
return -EINVAL;
|
||||
|
||||
return ksys_mmap_pgoff(addr, len, prot, flags, fd,
|
||||
offset >> (PAGE_SHIFT - page_shift_offset));
|
||||
}
|
||||
|
||||
@ -36,6 +36,7 @@ struct vdso_data {
|
||||
__u32 tk_shift; /* Shift used for xtime_nsec 0x60 */
|
||||
__u32 ts_dir; /* TOD steering direction 0x64 */
|
||||
__u64 ts_end; /* TOD steering end 0x68 */
|
||||
__u32 hrtimer_res; /* hrtimer resolution 0x70 */
|
||||
};
|
||||
|
||||
struct vdso_per_cpu_data {
|
||||
|
||||
@ -76,6 +76,7 @@ int main(void)
|
||||
OFFSET(__VDSO_TK_SHIFT, vdso_data, tk_shift);
|
||||
OFFSET(__VDSO_TS_DIR, vdso_data, ts_dir);
|
||||
OFFSET(__VDSO_TS_END, vdso_data, ts_end);
|
||||
OFFSET(__VDSO_CLOCK_REALTIME_RES, vdso_data, hrtimer_res);
|
||||
OFFSET(__VDSO_ECTG_BASE, vdso_per_cpu_data, ectg_timer_base);
|
||||
OFFSET(__VDSO_ECTG_USER, vdso_per_cpu_data, ectg_user_time);
|
||||
OFFSET(__VDSO_CPU_NR, vdso_per_cpu_data, cpu_nr);
|
||||
@ -87,7 +88,6 @@ int main(void)
|
||||
DEFINE(__CLOCK_REALTIME_COARSE, CLOCK_REALTIME_COARSE);
|
||||
DEFINE(__CLOCK_MONOTONIC_COARSE, CLOCK_MONOTONIC_COARSE);
|
||||
DEFINE(__CLOCK_THREAD_CPUTIME_ID, CLOCK_THREAD_CPUTIME_ID);
|
||||
DEFINE(__CLOCK_REALTIME_RES, MONOTONIC_RES_NSEC);
|
||||
DEFINE(__CLOCK_COARSE_RES, LOW_RES_NSEC);
|
||||
BLANK();
|
||||
/* idle data offsets */
|
||||
|
||||
@ -368,9 +368,9 @@ ENTRY(system_call)
|
||||
jnz .Lsysc_nr_ok
|
||||
# svc 0: system call number in %r1
|
||||
llgfr %r1,%r1 # clear high word in r1
|
||||
sth %r1,__PT_INT_CODE+2(%r11)
|
||||
cghi %r1,NR_syscalls
|
||||
jnl .Lsysc_nr_ok
|
||||
sth %r1,__PT_INT_CODE+2(%r11)
|
||||
slag %r8,%r1,3
|
||||
.Lsysc_nr_ok:
|
||||
xc __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
|
||||
|
||||
@ -324,6 +324,25 @@ static inline void __poke_user_per(struct task_struct *child,
|
||||
child->thread.per_user.end = data;
|
||||
}
|
||||
|
||||
static void fixup_int_code(struct task_struct *child, addr_t data)
|
||||
{
|
||||
struct pt_regs *regs = task_pt_regs(child);
|
||||
int ilc = regs->int_code >> 16;
|
||||
u16 insn;
|
||||
|
||||
if (ilc > 6)
|
||||
return;
|
||||
|
||||
if (ptrace_access_vm(child, regs->psw.addr - (regs->int_code >> 16),
|
||||
&insn, sizeof(insn), FOLL_FORCE) != sizeof(insn))
|
||||
return;
|
||||
|
||||
/* double check that tracee stopped on svc instruction */
|
||||
if ((insn >> 8) != 0xa)
|
||||
return;
|
||||
|
||||
regs->int_code = 0x20000 | (data & 0xffff);
|
||||
}
|
||||
/*
|
||||
* Write a word to the user area of a process at location addr. This
|
||||
* operation does have an additional problem compared to peek_user.
|
||||
@ -335,7 +354,9 @@ static int __poke_user(struct task_struct *child, addr_t addr, addr_t data)
|
||||
struct user *dummy = NULL;
|
||||
addr_t offset;
|
||||
|
||||
|
||||
if (addr < (addr_t) &dummy->regs.acrs) {
|
||||
struct pt_regs *regs = task_pt_regs(child);
|
||||
/*
|
||||
* psw and gprs are stored on the stack
|
||||
*/
|
||||
@ -353,7 +374,11 @@ static int __poke_user(struct task_struct *child, addr_t addr, addr_t data)
|
||||
/* Invalid addressing mode bits */
|
||||
return -EINVAL;
|
||||
}
|
||||
*(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr) = data;
|
||||
|
||||
if (test_pt_regs_flag(regs, PIF_SYSCALL) &&
|
||||
addr == offsetof(struct user, regs.gprs[2]))
|
||||
fixup_int_code(child, data);
|
||||
*(addr_t *)((addr_t) ®s->psw + addr) = data;
|
||||
|
||||
} else if (addr < (addr_t) (&dummy->regs.orig_gpr2)) {
|
||||
/*
|
||||
@ -719,6 +744,10 @@ static int __poke_user_compat(struct task_struct *child,
|
||||
regs->psw.mask = (regs->psw.mask & ~PSW_MASK_BA) |
|
||||
(__u64)(tmp & PSW32_ADDR_AMODE);
|
||||
} else {
|
||||
|
||||
if (test_pt_regs_flag(regs, PIF_SYSCALL) &&
|
||||
addr == offsetof(struct compat_user, regs.gprs[2]))
|
||||
fixup_int_code(child, data);
|
||||
/* gpr 0-15 */
|
||||
*(__u32*)((addr_t) ®s->psw + addr*2 + 4) = tmp;
|
||||
}
|
||||
@ -844,11 +873,9 @@ asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
|
||||
* call number to gprs[2].
|
||||
*/
|
||||
if (test_thread_flag(TIF_SYSCALL_TRACE) &&
|
||||
(tracehook_report_syscall_entry(regs) ||
|
||||
regs->gprs[2] >= NR_syscalls)) {
|
||||
tracehook_report_syscall_entry(regs)) {
|
||||
/*
|
||||
* Tracing decided this syscall should not happen or the
|
||||
* debugger stored an invalid system call number. Skip
|
||||
* Tracing decided this syscall should not happen. Skip
|
||||
* the system call and the system call restart handling.
|
||||
*/
|
||||
clear_pt_regs_flag(regs, PIF_SYSCALL);
|
||||
|
||||
@ -310,6 +310,7 @@ void update_vsyscall(struct timekeeper *tk)
|
||||
|
||||
vdso_data->tk_mult = tk->tkr_mono.mult;
|
||||
vdso_data->tk_shift = tk->tkr_mono.shift;
|
||||
vdso_data->hrtimer_res = hrtimer_resolution;
|
||||
smp_wmb();
|
||||
++vdso_data->tb_update_count;
|
||||
}
|
||||
|
||||
@ -18,8 +18,8 @@ KBUILD_AFLAGS_64 += -m64 -s
|
||||
|
||||
KBUILD_CFLAGS_64 := $(filter-out -m64,$(KBUILD_CFLAGS))
|
||||
KBUILD_CFLAGS_64 += -m64 -fPIC -shared -fno-common -fno-builtin
|
||||
KBUILD_CFLAGS_64 += -nostdlib -Wl,-soname=linux-vdso64.so.1 \
|
||||
-Wl,--hash-style=both
|
||||
ldflags-y := -fPIC -shared -nostdlib -soname=linux-vdso64.so.1 \
|
||||
--hash-style=both --build-id -T
|
||||
|
||||
$(targets:%=$(obj)/%.dbg): KBUILD_CFLAGS = $(KBUILD_CFLAGS_64)
|
||||
$(targets:%=$(obj)/%.dbg): KBUILD_AFLAGS = $(KBUILD_AFLAGS_64)
|
||||
@ -37,8 +37,8 @@ KASAN_SANITIZE := n
|
||||
$(obj)/vdso64_wrapper.o : $(obj)/vdso64.so
|
||||
|
||||
# link rule for the .so file, .lds has to be first
|
||||
$(obj)/vdso64.so.dbg: $(src)/vdso64.lds $(obj-vdso64) FORCE
|
||||
$(call if_changed,vdso64ld)
|
||||
$(obj)/vdso64.so.dbg: $(obj)/vdso64.lds $(obj-vdso64) FORCE
|
||||
$(call if_changed,ld)
|
||||
|
||||
# strip rule for the .so file
|
||||
$(obj)/%.so: OBJCOPYFLAGS := -S
|
||||
@ -50,8 +50,6 @@ $(obj-vdso64): %.o: %.S FORCE
|
||||
$(call if_changed_dep,vdso64as)
|
||||
|
||||
# actual build commands
|
||||
quiet_cmd_vdso64ld = VDSO64L $@
|
||||
cmd_vdso64ld = $(CC) $(c_flags) -Wl,-T $(filter %.lds %.o,$^) -o $@
|
||||
quiet_cmd_vdso64as = VDSO64A $@
|
||||
cmd_vdso64as = $(CC) $(a_flags) -c -o $@ $<
|
||||
|
||||
|
||||
@ -17,12 +17,14 @@
|
||||
.type __kernel_clock_getres,@function
|
||||
__kernel_clock_getres:
|
||||
CFI_STARTPROC
|
||||
larl %r1,4f
|
||||
larl %r1,3f
|
||||
lg %r0,0(%r1)
|
||||
cghi %r2,__CLOCK_REALTIME_COARSE
|
||||
je 0f
|
||||
cghi %r2,__CLOCK_MONOTONIC_COARSE
|
||||
je 0f
|
||||
larl %r1,3f
|
||||
larl %r1,_vdso_data
|
||||
llgf %r0,__VDSO_CLOCK_REALTIME_RES(%r1)
|
||||
cghi %r2,__CLOCK_REALTIME
|
||||
je 0f
|
||||
cghi %r2,__CLOCK_MONOTONIC
|
||||
@ -36,7 +38,6 @@ __kernel_clock_getres:
|
||||
jz 2f
|
||||
0: ltgr %r3,%r3
|
||||
jz 1f /* res == NULL */
|
||||
lg %r0,0(%r1)
|
||||
xc 0(8,%r3),0(%r3) /* set tp->tv_sec to zero */
|
||||
stg %r0,8(%r3) /* store tp->tv_usec */
|
||||
1: lghi %r2,0
|
||||
@ -45,6 +46,5 @@ __kernel_clock_getres:
|
||||
svc 0
|
||||
br %r14
|
||||
CFI_ENDPROC
|
||||
3: .quad __CLOCK_REALTIME_RES
|
||||
4: .quad __CLOCK_COARSE_RES
|
||||
3: .quad __CLOCK_COARSE_RES
|
||||
.size __kernel_clock_getres,.-__kernel_clock_getres
|
||||
|
||||
@ -168,12 +168,17 @@ static int genregs32_set(struct task_struct *target,
|
||||
if (ret || !count)
|
||||
return ret;
|
||||
ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
|
||||
®s->y,
|
||||
®s->npc,
|
||||
34 * sizeof(u32), 35 * sizeof(u32));
|
||||
if (ret || !count)
|
||||
return ret;
|
||||
ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
|
||||
®s->y,
|
||||
35 * sizeof(u32), 36 * sizeof(u32));
|
||||
if (ret || !count)
|
||||
return ret;
|
||||
return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
|
||||
35 * sizeof(u32), 38 * sizeof(u32));
|
||||
36 * sizeof(u32), 38 * sizeof(u32));
|
||||
}
|
||||
|
||||
static int fpregs32_get(struct task_struct *target,
|
||||
|
||||
@ -1160,7 +1160,7 @@ struct kvm_x86_ops {
|
||||
void (*enable_log_dirty_pt_masked)(struct kvm *kvm,
|
||||
struct kvm_memory_slot *slot,
|
||||
gfn_t offset, unsigned long mask);
|
||||
int (*write_log_dirty)(struct kvm_vcpu *vcpu);
|
||||
int (*write_log_dirty)(struct kvm_vcpu *vcpu, gpa_t l2_gpa);
|
||||
|
||||
/* pmu operations of sub-arch */
|
||||
const struct kvm_pmu_ops *pmu_ops;
|
||||
|
||||
@ -366,6 +366,9 @@ out:
|
||||
cr4_clear_bits(X86_CR4_UMIP);
|
||||
}
|
||||
|
||||
/* These bits should not change their value after CPU init is finished. */
|
||||
static const unsigned long cr4_pinned_mask =
|
||||
X86_CR4_SMEP | X86_CR4_SMAP | X86_CR4_UMIP | X86_CR4_FSGSBASE;
|
||||
static DEFINE_STATIC_KEY_FALSE_RO(cr_pinning);
|
||||
static unsigned long cr4_pinned_bits __ro_after_init;
|
||||
|
||||
@ -390,20 +393,20 @@ EXPORT_SYMBOL(native_write_cr0);
|
||||
|
||||
void native_write_cr4(unsigned long val)
|
||||
{
|
||||
unsigned long bits_missing = 0;
|
||||
unsigned long bits_changed = 0;
|
||||
|
||||
set_register:
|
||||
asm volatile("mov %0,%%cr4": "+r" (val), "+m" (cr4_pinned_bits));
|
||||
|
||||
if (static_branch_likely(&cr_pinning)) {
|
||||
if (unlikely((val & cr4_pinned_bits) != cr4_pinned_bits)) {
|
||||
bits_missing = ~val & cr4_pinned_bits;
|
||||
val |= bits_missing;
|
||||
if (unlikely((val & cr4_pinned_mask) != cr4_pinned_bits)) {
|
||||
bits_changed = (val & cr4_pinned_mask) ^ cr4_pinned_bits;
|
||||
val = (val & ~cr4_pinned_mask) | cr4_pinned_bits;
|
||||
goto set_register;
|
||||
}
|
||||
/* Warn after we've set the missing bits. */
|
||||
WARN_ONCE(bits_missing, "CR4 bits went missing: %lx!?\n",
|
||||
bits_missing);
|
||||
/* Warn after we've corrected the changed bits. */
|
||||
WARN_ONCE(bits_changed, "pinned CR4 bits changed: 0x%lx!?\n",
|
||||
bits_changed);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL(native_write_cr4);
|
||||
@ -415,7 +418,7 @@ void cr4_init(void)
|
||||
if (boot_cpu_has(X86_FEATURE_PCID))
|
||||
cr4 |= X86_CR4_PCIDE;
|
||||
if (static_branch_likely(&cr_pinning))
|
||||
cr4 |= cr4_pinned_bits;
|
||||
cr4 = (cr4 & ~cr4_pinned_mask) | cr4_pinned_bits;
|
||||
|
||||
__write_cr4(cr4);
|
||||
|
||||
@ -430,10 +433,7 @@ void cr4_init(void)
|
||||
*/
|
||||
static void __init setup_cr_pinning(void)
|
||||
{
|
||||
unsigned long mask;
|
||||
|
||||
mask = (X86_CR4_SMEP | X86_CR4_SMAP | X86_CR4_UMIP);
|
||||
cr4_pinned_bits = this_cpu_read(cpu_tlbstate.cr4) & mask;
|
||||
cr4_pinned_bits = this_cpu_read(cpu_tlbstate.cr4) & cr4_pinned_mask;
|
||||
static_key_enable(&cr_pinning.key);
|
||||
}
|
||||
|
||||
|
||||
@ -1027,6 +1027,7 @@ static int rdt_cdp_peer_get(struct rdt_resource *r, struct rdt_domain *d,
|
||||
_d_cdp = rdt_find_domain(_r_cdp, d->id, NULL);
|
||||
if (WARN_ON(IS_ERR_OR_NULL(_d_cdp))) {
|
||||
_r_cdp = NULL;
|
||||
_d_cdp = NULL;
|
||||
ret = -EINVAL;
|
||||
}
|
||||
|
||||
|
||||
@ -17,12 +17,6 @@
|
||||
*/
|
||||
static u32 umwait_control_cached = UMWAIT_CTRL_VAL(100000, UMWAIT_C02_ENABLE);
|
||||
|
||||
u32 get_umwait_control_msr(void)
|
||||
{
|
||||
return umwait_control_cached;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(get_umwait_control_msr);
|
||||
|
||||
/*
|
||||
* Cache the original IA32_UMWAIT_CONTROL MSR value which is configured by
|
||||
* hardware or BIOS before kernel boot.
|
||||
|
||||
@ -1819,10 +1819,10 @@ void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm,
|
||||
* Emulate arch specific page modification logging for the
|
||||
* nested hypervisor
|
||||
*/
|
||||
int kvm_arch_write_log_dirty(struct kvm_vcpu *vcpu)
|
||||
int kvm_arch_write_log_dirty(struct kvm_vcpu *vcpu, gpa_t l2_gpa)
|
||||
{
|
||||
if (kvm_x86_ops->write_log_dirty)
|
||||
return kvm_x86_ops->write_log_dirty(vcpu);
|
||||
return kvm_x86_ops->write_log_dirty(vcpu, l2_gpa);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -209,7 +209,7 @@ void kvm_mmu_gfn_disallow_lpage(struct kvm_memory_slot *slot, gfn_t gfn);
|
||||
void kvm_mmu_gfn_allow_lpage(struct kvm_memory_slot *slot, gfn_t gfn);
|
||||
bool kvm_mmu_slot_gfn_write_protect(struct kvm *kvm,
|
||||
struct kvm_memory_slot *slot, u64 gfn);
|
||||
int kvm_arch_write_log_dirty(struct kvm_vcpu *vcpu);
|
||||
int kvm_arch_write_log_dirty(struct kvm_vcpu *vcpu, gpa_t l2_gpa);
|
||||
|
||||
int kvm_mmu_post_init_vm(struct kvm *kvm);
|
||||
void kvm_mmu_pre_destroy_vm(struct kvm *kvm);
|
||||
|
||||
@ -220,7 +220,7 @@ static inline unsigned FNAME(gpte_access)(u64 gpte)
|
||||
static int FNAME(update_accessed_dirty_bits)(struct kvm_vcpu *vcpu,
|
||||
struct kvm_mmu *mmu,
|
||||
struct guest_walker *walker,
|
||||
int write_fault)
|
||||
gpa_t addr, int write_fault)
|
||||
{
|
||||
unsigned level, index;
|
||||
pt_element_t pte, orig_pte;
|
||||
@ -245,7 +245,7 @@ static int FNAME(update_accessed_dirty_bits)(struct kvm_vcpu *vcpu,
|
||||
!(pte & PT_GUEST_DIRTY_MASK)) {
|
||||
trace_kvm_mmu_set_dirty_bit(table_gfn, index, sizeof(pte));
|
||||
#if PTTYPE == PTTYPE_EPT
|
||||
if (kvm_arch_write_log_dirty(vcpu))
|
||||
if (kvm_arch_write_log_dirty(vcpu, addr))
|
||||
return -EINVAL;
|
||||
#endif
|
||||
pte |= PT_GUEST_DIRTY_MASK;
|
||||
@ -442,7 +442,8 @@ retry_walk:
|
||||
(PT_GUEST_DIRTY_SHIFT - PT_GUEST_ACCESSED_SHIFT);
|
||||
|
||||
if (unlikely(!accessed_dirty)) {
|
||||
ret = FNAME(update_accessed_dirty_bits)(vcpu, mmu, walker, write_fault);
|
||||
ret = FNAME(update_accessed_dirty_bits)(vcpu, mmu, walker,
|
||||
addr, write_fault);
|
||||
if (unlikely(ret < 0))
|
||||
goto error;
|
||||
else if (ret)
|
||||
|
||||
@ -6427,23 +6427,6 @@ static void atomic_switch_perf_msrs(struct vcpu_vmx *vmx)
|
||||
msrs[i].host, false);
|
||||
}
|
||||
|
||||
static void atomic_switch_umwait_control_msr(struct vcpu_vmx *vmx)
|
||||
{
|
||||
u32 host_umwait_control;
|
||||
|
||||
if (!vmx_has_waitpkg(vmx))
|
||||
return;
|
||||
|
||||
host_umwait_control = get_umwait_control_msr();
|
||||
|
||||
if (vmx->msr_ia32_umwait_control != host_umwait_control)
|
||||
add_atomic_switch_msr(vmx, MSR_IA32_UMWAIT_CONTROL,
|
||||
vmx->msr_ia32_umwait_control,
|
||||
host_umwait_control, false);
|
||||
else
|
||||
clear_atomic_switch_msr(vmx, MSR_IA32_UMWAIT_CONTROL);
|
||||
}
|
||||
|
||||
static void vmx_update_hv_timer(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
struct vcpu_vmx *vmx = to_vmx(vcpu);
|
||||
@ -6533,7 +6516,6 @@ static void vmx_vcpu_run(struct kvm_vcpu *vcpu)
|
||||
pt_guest_enter(vmx);
|
||||
|
||||
atomic_switch_perf_msrs(vmx);
|
||||
atomic_switch_umwait_control_msr(vmx);
|
||||
|
||||
if (enable_preemption_timer)
|
||||
vmx_update_hv_timer(vcpu);
|
||||
@ -7272,11 +7254,11 @@ static void vmx_flush_log_dirty(struct kvm *kvm)
|
||||
kvm_flush_pml_buffers(kvm);
|
||||
}
|
||||
|
||||
static int vmx_write_pml_buffer(struct kvm_vcpu *vcpu)
|
||||
static int vmx_write_pml_buffer(struct kvm_vcpu *vcpu, gpa_t gpa)
|
||||
{
|
||||
struct vmcs12 *vmcs12;
|
||||
struct vcpu_vmx *vmx = to_vmx(vcpu);
|
||||
gpa_t gpa, dst;
|
||||
gpa_t dst;
|
||||
|
||||
if (is_guest_mode(vcpu)) {
|
||||
WARN_ON_ONCE(vmx->nested.pml_full);
|
||||
@ -7295,7 +7277,7 @@ static int vmx_write_pml_buffer(struct kvm_vcpu *vcpu)
|
||||
return 1;
|
||||
}
|
||||
|
||||
gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS) & ~0xFFFull;
|
||||
gpa &= ~0xFFFull;
|
||||
dst = vmcs12->pml_address + sizeof(u64) * vmcs12->guest_pml_index;
|
||||
|
||||
if (kvm_write_guest_page(vcpu->kvm, gpa_to_gfn(dst), &gpa,
|
||||
|
||||
@ -14,8 +14,6 @@
|
||||
extern const u32 vmx_msr_index[];
|
||||
extern u64 host_efer;
|
||||
|
||||
extern u32 get_umwait_control_msr(void);
|
||||
|
||||
#define MSR_TYPE_R 1
|
||||
#define MSR_TYPE_W 2
|
||||
#define MSR_TYPE_RW 3
|
||||
|
||||
@ -2753,7 +2753,7 @@ int kvm_set_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info)
|
||||
return kvm_mtrr_set_msr(vcpu, msr, data);
|
||||
case MSR_IA32_APICBASE:
|
||||
return kvm_set_apic_base(vcpu, msr_info);
|
||||
case APIC_BASE_MSR ... APIC_BASE_MSR + 0x3ff:
|
||||
case APIC_BASE_MSR ... APIC_BASE_MSR + 0xff:
|
||||
return kvm_x2apic_msr_write(vcpu, msr, data);
|
||||
case MSR_IA32_TSCDEADLINE:
|
||||
kvm_set_lapic_tscdeadline_msr(vcpu, data);
|
||||
@ -3057,7 +3057,7 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr_info)
|
||||
case MSR_IA32_APICBASE:
|
||||
msr_info->data = kvm_get_apic_base(vcpu);
|
||||
break;
|
||||
case APIC_BASE_MSR ... APIC_BASE_MSR + 0x3ff:
|
||||
case APIC_BASE_MSR ... APIC_BASE_MSR + 0xff:
|
||||
return kvm_x2apic_msr_read(vcpu, msr_info->index, &msr_info->data);
|
||||
break;
|
||||
case MSR_IA32_TSCDEADLINE:
|
||||
|
||||
@ -24,6 +24,7 @@ unsigned long __clear_user(void __user *addr, unsigned long size)
|
||||
asm volatile(
|
||||
" testq %[size8],%[size8]\n"
|
||||
" jz 4f\n"
|
||||
" .align 16\n"
|
||||
"0: movq $0,(%[dst])\n"
|
||||
" addq $8,%[dst]\n"
|
||||
" decl %%ecx ; jnz 0b\n"
|
||||
|
||||
@ -278,7 +278,6 @@ bool bio_integrity_prep(struct bio *bio)
|
||||
|
||||
if (ret == 0) {
|
||||
printk(KERN_ERR "could not attach integrity payload\n");
|
||||
kfree(buf);
|
||||
status = BLK_STS_RESOURCE;
|
||||
goto err_end_io;
|
||||
}
|
||||
|
||||
@ -3279,7 +3279,9 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set,
|
||||
|
||||
if (set->nr_maps == 1 && nr_hw_queues > nr_cpu_ids)
|
||||
nr_hw_queues = nr_cpu_ids;
|
||||
if (nr_hw_queues < 1 || nr_hw_queues == set->nr_hw_queues)
|
||||
if (nr_hw_queues < 1)
|
||||
return;
|
||||
if (set->nr_maps == 1 && nr_hw_queues == set->nr_hw_queues)
|
||||
return;
|
||||
|
||||
list_for_each_entry(q, &set->tag_list, tag_set_list)
|
||||
|
||||
@ -11,6 +11,7 @@
|
||||
#include <linux/module.h>
|
||||
#include <linux/configfs.h>
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/security.h>
|
||||
|
||||
#include "acpica/accommon.h"
|
||||
#include "acpica/actables.h"
|
||||
@ -28,7 +29,10 @@ static ssize_t acpi_table_aml_write(struct config_item *cfg,
|
||||
{
|
||||
const struct acpi_table_header *header = data;
|
||||
struct acpi_table *table;
|
||||
int ret;
|
||||
int ret = security_locked_down(LOCKDOWN_ACPI_TABLES);
|
||||
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
table = container_of(cfg, struct acpi_table, cfg);
|
||||
|
||||
|
||||
@ -938,13 +938,13 @@ static void __exit interrupt_stats_exit(void)
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
acpi_show_profile(struct device *dev, struct device_attribute *attr,
|
||||
acpi_show_profile(struct kobject *kobj, struct kobj_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
return sprintf(buf, "%d\n", acpi_gbl_FADT.preferred_profile);
|
||||
}
|
||||
|
||||
static const struct device_attribute pm_profile_attr =
|
||||
static const struct kobj_attribute pm_profile_attr =
|
||||
__ATTR(pm_profile, S_IRUGO, acpi_show_profile, NULL);
|
||||
|
||||
static ssize_t hotplug_enabled_show(struct kobject *kobj,
|
||||
|
||||
@ -3978,12 +3978,13 @@ static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc)
|
||||
{
|
||||
struct scsi_cmnd *scmd = qc->scsicmd;
|
||||
const u8 *cdb = scmd->cmnd;
|
||||
const u8 *p;
|
||||
u8 pg, spg;
|
||||
unsigned six_byte, pg_len, hdr_len, bd_len;
|
||||
int len;
|
||||
u16 fp = (u16)-1;
|
||||
u8 bp = 0xff;
|
||||
u8 buffer[64];
|
||||
const u8 *p = buffer;
|
||||
|
||||
VPRINTK("ENTER\n");
|
||||
|
||||
@ -4017,12 +4018,14 @@ static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc)
|
||||
if (!scsi_sg_count(scmd) || scsi_sglist(scmd)->length < len)
|
||||
goto invalid_param_len;
|
||||
|
||||
p = page_address(sg_page(scsi_sglist(scmd)));
|
||||
|
||||
/* Move past header and block descriptors. */
|
||||
if (len < hdr_len)
|
||||
goto invalid_param_len;
|
||||
|
||||
if (!sg_copy_to_buffer(scsi_sglist(scmd), scsi_sg_count(scmd),
|
||||
buffer, sizeof(buffer)))
|
||||
goto invalid_param_len;
|
||||
|
||||
if (six_byte)
|
||||
bd_len = p[3];
|
||||
else
|
||||
|
||||
@ -905,7 +905,7 @@ static int sata_rcar_probe(struct platform_device *pdev)
|
||||
pm_runtime_enable(dev);
|
||||
ret = pm_runtime_get_sync(dev);
|
||||
if (ret < 0)
|
||||
goto err_pm_disable;
|
||||
goto err_pm_put;
|
||||
|
||||
host = ata_host_alloc(dev, 1);
|
||||
if (!host) {
|
||||
@ -935,7 +935,6 @@ static int sata_rcar_probe(struct platform_device *pdev)
|
||||
|
||||
err_pm_put:
|
||||
pm_runtime_put(dev);
|
||||
err_pm_disable:
|
||||
pm_runtime_disable(dev);
|
||||
return ret;
|
||||
}
|
||||
@ -989,8 +988,10 @@ static int sata_rcar_resume(struct device *dev)
|
||||
int ret;
|
||||
|
||||
ret = pm_runtime_get_sync(dev);
|
||||
if (ret < 0)
|
||||
if (ret < 0) {
|
||||
pm_runtime_put(dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (priv->type == RCAR_GEN3_SATA) {
|
||||
sata_rcar_init_module(priv);
|
||||
@ -1015,8 +1016,10 @@ static int sata_rcar_restore(struct device *dev)
|
||||
int ret;
|
||||
|
||||
ret = pm_runtime_get_sync(dev);
|
||||
if (ret < 0)
|
||||
if (ret < 0) {
|
||||
pm_runtime_put(dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
sata_rcar_setup_port(host);
|
||||
|
||||
|
||||
@ -1356,6 +1356,7 @@ void regmap_exit(struct regmap *map)
|
||||
if (map->hwlock)
|
||||
hwspin_lock_free(map->hwlock);
|
||||
kfree_const(map->name);
|
||||
kfree(map->patch);
|
||||
kfree(map);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(regmap_exit);
|
||||
|
||||
@ -1286,7 +1286,7 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
|
||||
if (lo->lo_offset != info->lo_offset ||
|
||||
lo->lo_sizelimit != info->lo_sizelimit) {
|
||||
sync_blockdev(lo->lo_device);
|
||||
kill_bdev(lo->lo_device);
|
||||
invalidate_bdev(lo->lo_device);
|
||||
}
|
||||
|
||||
/* I/O need to be drained during transfer transition */
|
||||
@ -1562,11 +1562,11 @@ static int loop_set_block_size(struct loop_device *lo, unsigned long arg)
|
||||
return 0;
|
||||
|
||||
sync_blockdev(lo->lo_device);
|
||||
kill_bdev(lo->lo_device);
|
||||
invalidate_bdev(lo->lo_device);
|
||||
|
||||
blk_mq_freeze_queue(lo->lo_queue);
|
||||
|
||||
/* kill_bdev should have truncated all the pages */
|
||||
/* invalidate_bdev should have truncated all the pages */
|
||||
if (lo->lo_device->bd_inode->i_mapping->nrpages) {
|
||||
err = -EAGAIN;
|
||||
pr_warn("%s: loop%d (%s) has still dirty pages (nrpages=%lu)\n",
|
||||
|
||||
@ -880,10 +880,13 @@ static int sysc_enable_module(struct device *dev)
|
||||
regbits = ddata->cap->regbits;
|
||||
reg = sysc_read(ddata, ddata->offsets[SYSC_SYSCONFIG]);
|
||||
|
||||
/* Set CLOCKACTIVITY, we only use it for ick */
|
||||
/*
|
||||
* Set CLOCKACTIVITY, we only use it for ick. And we only configure it
|
||||
* based on the SYSC_QUIRK_USE_CLOCKACT flag, not based on the hardware
|
||||
* capabilities. See the old HWMOD_SET_DEFAULT_CLOCKACT flag.
|
||||
*/
|
||||
if (regbits->clkact_shift >= 0 &&
|
||||
(ddata->cfg.quirks & SYSC_QUIRK_USE_CLOCKACT ||
|
||||
ddata->cfg.sysc_val & BIT(regbits->clkact_shift)))
|
||||
(ddata->cfg.quirks & SYSC_QUIRK_USE_CLOCKACT))
|
||||
reg |= SYSC_CLOCACT_ICK << regbits->clkact_shift;
|
||||
|
||||
/* Set SIDLE mode */
|
||||
@ -938,6 +941,9 @@ set_autoidle:
|
||||
sysc_write(ddata, ddata->offsets[SYSC_SYSCONFIG], reg);
|
||||
}
|
||||
|
||||
/* Flush posted write */
|
||||
sysc_read(ddata, ddata->offsets[SYSC_SYSCONFIG]);
|
||||
|
||||
if (ddata->module_enable_quirk)
|
||||
ddata->module_enable_quirk(ddata);
|
||||
|
||||
@ -1018,6 +1024,9 @@ set_sidle:
|
||||
reg |= 1 << regbits->autoidle_shift;
|
||||
sysc_write(ddata, ddata->offsets[SYSC_SYSCONFIG], reg);
|
||||
|
||||
/* Flush posted write */
|
||||
sysc_read(ddata, ddata->offsets[SYSC_SYSCONFIG]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -208,6 +208,7 @@ static int ks_sa_rng_probe(struct platform_device *pdev)
|
||||
ret = pm_runtime_get_sync(dev);
|
||||
if (ret < 0) {
|
||||
dev_err(dev, "Failed to enable SA power-domain\n");
|
||||
pm_runtime_put_noidle(dev);
|
||||
pm_runtime_disable(dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -586,7 +586,10 @@ static int sifive_fu540_prci_probe(struct platform_device *pdev)
|
||||
struct __prci_data *pd;
|
||||
int r;
|
||||
|
||||
pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL);
|
||||
pd = devm_kzalloc(dev,
|
||||
struct_size(pd, hw_clks.hws,
|
||||
ARRAY_SIZE(__prci_init_clocks)),
|
||||
GFP_KERNEL);
|
||||
if (!pd)
|
||||
return -ENOMEM;
|
||||
|
||||
|
||||
@ -181,7 +181,7 @@ static int esre_create_sysfs_entry(void *esre, int entry_num)
|
||||
rc = kobject_init_and_add(&entry->kobj, &esre1_ktype, NULL,
|
||||
"entry%d", entry_num);
|
||||
if (rc) {
|
||||
kfree(entry);
|
||||
kobject_put(&entry->kobj);
|
||||
return rc;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1273,8 +1273,12 @@ static int sdma_v5_0_sw_fini(void *handle)
|
||||
struct amdgpu_device *adev = (struct amdgpu_device *)handle;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < adev->sdma.num_instances; i++)
|
||||
for (i = 0; i < adev->sdma.num_instances; i++) {
|
||||
if (adev->sdma.instance[i].fw != NULL)
|
||||
release_firmware(adev->sdma.instance[i].fw);
|
||||
|
||||
amdgpu_ring_fini(&adev->sdma.instance[i].ring);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -312,6 +312,7 @@ struct kfd_process *kfd_create_process(struct file *filep)
|
||||
(int)process->lead_thread->pid);
|
||||
if (ret) {
|
||||
pr_warn("Creating procfs pid directory failed");
|
||||
kobject_put(process->kobj);
|
||||
goto out;
|
||||
}
|
||||
|
||||
|
||||
@ -1862,7 +1862,7 @@ bool calculate_user_regamma_ramp(struct dc_transfer_func *output_tf,
|
||||
|
||||
kfree(rgb_regamma);
|
||||
rgb_regamma_alloc_fail:
|
||||
kvfree(rgb_user);
|
||||
kfree(rgb_user);
|
||||
rgb_user_alloc_fail:
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -2128,7 +2128,7 @@ static int ni_init_smc_spll_table(struct radeon_device *rdev)
|
||||
if (clk_s & ~(SMC_NISLANDS_SPLL_DIV_TABLE_CLKS_MASK >> SMC_NISLANDS_SPLL_DIV_TABLE_CLKS_SHIFT))
|
||||
ret = -EINVAL;
|
||||
|
||||
if (clk_s & ~(SMC_NISLANDS_SPLL_DIV_TABLE_CLKS_MASK >> SMC_NISLANDS_SPLL_DIV_TABLE_CLKS_SHIFT))
|
||||
if (fb_div & ~(SMC_NISLANDS_SPLL_DIV_TABLE_FBDIV_MASK >> SMC_NISLANDS_SPLL_DIV_TABLE_FBDIV_SHIFT))
|
||||
ret = -EINVAL;
|
||||
|
||||
if (clk_v & ~(SMC_NISLANDS_SPLL_DIV_TABLE_CLKV_MASK >> SMC_NISLANDS_SPLL_DIV_TABLE_CLKV_SHIFT))
|
||||
|
||||
@ -23,6 +23,7 @@ config DRM_RCAR_DW_HDMI
|
||||
config DRM_RCAR_LVDS
|
||||
tristate "R-Car DU LVDS Encoder Support"
|
||||
depends on DRM && DRM_BRIDGE && OF
|
||||
select DRM_KMS_HELPER
|
||||
select DRM_PANEL
|
||||
select OF_FLATTREE
|
||||
select OF_OVERLAY
|
||||
|
||||
@ -98,7 +98,7 @@
|
||||
#define I2C_STAT_DAT_REQ BIT(25)
|
||||
#define I2C_STAT_CMD_COMP BIT(24)
|
||||
#define I2C_STAT_STOP_ERR BIT(23)
|
||||
#define I2C_STAT_MAX_PORT GENMASK(19, 16)
|
||||
#define I2C_STAT_MAX_PORT GENMASK(22, 16)
|
||||
#define I2C_STAT_ANY_INT BIT(15)
|
||||
#define I2C_STAT_SCL_IN BIT(11)
|
||||
#define I2C_STAT_SDA_IN BIT(10)
|
||||
|
||||
@ -1719,14 +1719,9 @@ static int tegra_i2c_remove(struct platform_device *pdev)
|
||||
static int __maybe_unused tegra_i2c_suspend(struct device *dev)
|
||||
{
|
||||
struct tegra_i2c_dev *i2c_dev = dev_get_drvdata(dev);
|
||||
int err;
|
||||
|
||||
i2c_mark_adapter_suspended(&i2c_dev->adapter);
|
||||
|
||||
err = pm_runtime_force_suspend(dev);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1747,10 +1742,6 @@ static int __maybe_unused tegra_i2c_resume(struct device *dev)
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = pm_runtime_force_resume(dev);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
i2c_mark_adapter_resumed(&i2c_dev->adapter);
|
||||
|
||||
return 0;
|
||||
|
||||
@ -495,6 +495,13 @@ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
|
||||
break;
|
||||
case I2C_SMBUS_BLOCK_DATA:
|
||||
case I2C_SMBUS_BLOCK_PROC_CALL:
|
||||
if (msg[1].buf[0] > I2C_SMBUS_BLOCK_MAX) {
|
||||
dev_err(&adapter->dev,
|
||||
"Invalid block size returned: %d\n",
|
||||
msg[1].buf[0]);
|
||||
status = -EPROTO;
|
||||
goto cleanup;
|
||||
}
|
||||
for (i = 0; i < msg[1].buf[0] + 1; i++)
|
||||
data->block[i] = msg[1].buf[i];
|
||||
break;
|
||||
|
||||
@ -1631,6 +1631,8 @@ static struct rdma_id_private *cma_find_listener(
|
||||
{
|
||||
struct rdma_id_private *id_priv, *id_priv_dev;
|
||||
|
||||
lockdep_assert_held(&lock);
|
||||
|
||||
if (!bind_list)
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
@ -1677,6 +1679,7 @@ cma_ib_id_from_event(struct ib_cm_id *cm_id,
|
||||
}
|
||||
}
|
||||
|
||||
mutex_lock(&lock);
|
||||
/*
|
||||
* Net namespace might be getting deleted while route lookup,
|
||||
* cm_id lookup is in progress. Therefore, perform netdevice
|
||||
@ -1718,6 +1721,7 @@ cma_ib_id_from_event(struct ib_cm_id *cm_id,
|
||||
id_priv = cma_find_listener(bind_list, cm_id, ib_event, req, *net_dev);
|
||||
err:
|
||||
rcu_read_unlock();
|
||||
mutex_unlock(&lock);
|
||||
if (IS_ERR(id_priv) && *net_dev) {
|
||||
dev_put(*net_dev);
|
||||
*net_dev = NULL;
|
||||
@ -2473,6 +2477,8 @@ static void cma_listen_on_dev(struct rdma_id_private *id_priv,
|
||||
struct net *net = id_priv->id.route.addr.dev_addr.net;
|
||||
int ret;
|
||||
|
||||
lockdep_assert_held(&lock);
|
||||
|
||||
if (cma_family(id_priv) == AF_IB && !rdma_cap_ib_cm(cma_dev->device, 1))
|
||||
return;
|
||||
|
||||
@ -3245,6 +3251,8 @@ static void cma_bind_port(struct rdma_bind_list *bind_list,
|
||||
u64 sid, mask;
|
||||
__be16 port;
|
||||
|
||||
lockdep_assert_held(&lock);
|
||||
|
||||
addr = cma_src_addr(id_priv);
|
||||
port = htons(bind_list->port);
|
||||
|
||||
@ -3273,6 +3281,8 @@ static int cma_alloc_port(enum rdma_ucm_port_space ps,
|
||||
struct rdma_bind_list *bind_list;
|
||||
int ret;
|
||||
|
||||
lockdep_assert_held(&lock);
|
||||
|
||||
bind_list = kzalloc(sizeof *bind_list, GFP_KERNEL);
|
||||
if (!bind_list)
|
||||
return -ENOMEM;
|
||||
@ -3299,6 +3309,8 @@ static int cma_port_is_unique(struct rdma_bind_list *bind_list,
|
||||
struct sockaddr *saddr = cma_src_addr(id_priv);
|
||||
__be16 dport = cma_port(daddr);
|
||||
|
||||
lockdep_assert_held(&lock);
|
||||
|
||||
hlist_for_each_entry(cur_id, &bind_list->owners, node) {
|
||||
struct sockaddr *cur_daddr = cma_dst_addr(cur_id);
|
||||
struct sockaddr *cur_saddr = cma_src_addr(cur_id);
|
||||
@ -3338,6 +3350,8 @@ static int cma_alloc_any_port(enum rdma_ucm_port_space ps,
|
||||
unsigned int rover;
|
||||
struct net *net = id_priv->id.route.addr.dev_addr.net;
|
||||
|
||||
lockdep_assert_held(&lock);
|
||||
|
||||
inet_get_local_port_range(net, &low, &high);
|
||||
remaining = (high - low) + 1;
|
||||
rover = prandom_u32() % remaining + low;
|
||||
@ -3385,6 +3399,8 @@ static int cma_check_port(struct rdma_bind_list *bind_list,
|
||||
struct rdma_id_private *cur_id;
|
||||
struct sockaddr *addr, *cur_addr;
|
||||
|
||||
lockdep_assert_held(&lock);
|
||||
|
||||
addr = cma_src_addr(id_priv);
|
||||
hlist_for_each_entry(cur_id, &bind_list->owners, node) {
|
||||
if (id_priv == cur_id)
|
||||
@ -3415,6 +3431,8 @@ static int cma_use_port(enum rdma_ucm_port_space ps,
|
||||
unsigned short snum;
|
||||
int ret;
|
||||
|
||||
lockdep_assert_held(&lock);
|
||||
|
||||
snum = ntohs(cma_port(cma_src_addr(id_priv)));
|
||||
if (snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
|
||||
return -EACCES;
|
||||
|
||||
@ -639,10 +639,10 @@ static void unregister_mad_agent(struct ib_mad_agent_private *mad_agent_priv)
|
||||
xa_erase(&ib_mad_clients, mad_agent_priv->agent.hi_tid);
|
||||
|
||||
flush_workqueue(port_priv->wq);
|
||||
ib_cancel_rmpp_recvs(mad_agent_priv);
|
||||
|
||||
deref_mad_agent(mad_agent_priv);
|
||||
wait_for_completion(&mad_agent_priv->comp);
|
||||
ib_cancel_rmpp_recvs(mad_agent_priv);
|
||||
|
||||
ib_mad_agent_security_cleanup(&mad_agent_priv->agent);
|
||||
|
||||
@ -2960,6 +2960,7 @@ static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
|
||||
DMA_FROM_DEVICE);
|
||||
if (unlikely(ib_dma_mapping_error(qp_info->port_priv->device,
|
||||
sg_list.addr))) {
|
||||
kfree(mad_priv);
|
||||
ret = -ENOMEM;
|
||||
break;
|
||||
}
|
||||
|
||||
@ -985,15 +985,10 @@ static ssize_t qsfp2_debugfs_read(struct file *file, char __user *buf,
|
||||
static int __i2c_debugfs_open(struct inode *in, struct file *fp, u32 target)
|
||||
{
|
||||
struct hfi1_pportdata *ppd;
|
||||
int ret;
|
||||
|
||||
ppd = private2ppd(fp);
|
||||
|
||||
ret = acquire_chip_resource(ppd->dd, i2c_target(target), 0);
|
||||
if (ret) /* failed - release the module */
|
||||
module_put(THIS_MODULE);
|
||||
|
||||
return ret;
|
||||
return acquire_chip_resource(ppd->dd, i2c_target(target), 0);
|
||||
}
|
||||
|
||||
static int i2c1_debugfs_open(struct inode *in, struct file *fp)
|
||||
@ -1013,7 +1008,6 @@ static int __i2c_debugfs_release(struct inode *in, struct file *fp, u32 target)
|
||||
ppd = private2ppd(fp);
|
||||
|
||||
release_chip_resource(ppd->dd, i2c_target(target));
|
||||
module_put(THIS_MODULE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1031,18 +1025,10 @@ static int i2c2_debugfs_release(struct inode *in, struct file *fp)
|
||||
static int __qsfp_debugfs_open(struct inode *in, struct file *fp, u32 target)
|
||||
{
|
||||
struct hfi1_pportdata *ppd;
|
||||
int ret;
|
||||
|
||||
if (!try_module_get(THIS_MODULE))
|
||||
return -ENODEV;
|
||||
|
||||
ppd = private2ppd(fp);
|
||||
|
||||
ret = acquire_chip_resource(ppd->dd, i2c_target(target), 0);
|
||||
if (ret) /* failed - release the module */
|
||||
module_put(THIS_MODULE);
|
||||
|
||||
return ret;
|
||||
return acquire_chip_resource(ppd->dd, i2c_target(target), 0);
|
||||
}
|
||||
|
||||
static int qsfp1_debugfs_open(struct inode *in, struct file *fp)
|
||||
@ -1062,7 +1048,6 @@ static int __qsfp_debugfs_release(struct inode *in, struct file *fp, u32 target)
|
||||
ppd = private2ppd(fp);
|
||||
|
||||
release_chip_resource(ppd->dd, i2c_target(target));
|
||||
module_put(THIS_MODULE);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -150,8 +150,17 @@ qedr_iw_issue_event(void *context,
|
||||
if (params->cm_info) {
|
||||
event.ird = params->cm_info->ird;
|
||||
event.ord = params->cm_info->ord;
|
||||
event.private_data_len = params->cm_info->private_data_len;
|
||||
event.private_data = (void *)params->cm_info->private_data;
|
||||
/* Only connect_request and reply have valid private data
|
||||
* the rest of the events this may be left overs from
|
||||
* connection establishment. CONNECT_REQUEST is issued via
|
||||
* qedr_iw_mpa_request
|
||||
*/
|
||||
if (event_type == IW_CM_EVENT_CONNECT_REPLY) {
|
||||
event.private_data_len =
|
||||
params->cm_info->private_data_len;
|
||||
event.private_data =
|
||||
(void *)params->cm_info->private_data;
|
||||
}
|
||||
}
|
||||
|
||||
if (ep->cm_id)
|
||||
|
||||
@ -1196,7 +1196,7 @@ struct ib_qp *rvt_create_qp(struct ib_pd *ibpd,
|
||||
err = alloc_ud_wq_attr(qp, rdi->dparms.node);
|
||||
if (err) {
|
||||
ret = (ERR_PTR(err));
|
||||
goto bail_driver_priv;
|
||||
goto bail_rq_rvt;
|
||||
}
|
||||
|
||||
err = alloc_qpn(rdi, &rdi->qp_dev->qpn_table,
|
||||
@ -1300,9 +1300,11 @@ bail_qpn:
|
||||
rvt_free_qpn(&rdi->qp_dev->qpn_table, qp->ibqp.qp_num);
|
||||
|
||||
bail_rq_wq:
|
||||
rvt_free_rq(&qp->r_rq);
|
||||
free_ud_wq_attr(qp);
|
||||
|
||||
bail_rq_rvt:
|
||||
rvt_free_rq(&qp->r_rq);
|
||||
|
||||
bail_driver_priv:
|
||||
rdi->driver_f.qp_priv_free(rdi, qp);
|
||||
|
||||
|
||||
@ -139,7 +139,8 @@ static int siw_rx_pbl(struct siw_rx_stream *srx, int *pbl_idx,
|
||||
break;
|
||||
|
||||
bytes = min(bytes, len);
|
||||
if (siw_rx_kva(srx, (void *)buf_addr, bytes) == bytes) {
|
||||
if (siw_rx_kva(srx, (void *)(uintptr_t)buf_addr, bytes) ==
|
||||
bytes) {
|
||||
copied += bytes;
|
||||
offset += bytes;
|
||||
len -= bytes;
|
||||
|
||||
@ -898,7 +898,8 @@ int __init detect_intel_iommu(void)
|
||||
if (!ret)
|
||||
ret = dmar_walk_dmar_table((struct acpi_table_dmar *)dmar_tbl,
|
||||
&validate_drhd_cb);
|
||||
if (!ret && !no_iommu && !iommu_detected && !dmar_disabled) {
|
||||
if (!ret && !no_iommu && !iommu_detected &&
|
||||
(!dmar_disabled || dmar_platform_optin())) {
|
||||
iommu_detected = 1;
|
||||
/* Make sure ACS will be enabled */
|
||||
pci_request_acs();
|
||||
|
||||
@ -611,6 +611,12 @@ struct intel_iommu *domain_get_iommu(struct dmar_domain *domain)
|
||||
return g_iommus[iommu_id];
|
||||
}
|
||||
|
||||
static inline bool iommu_paging_structure_coherency(struct intel_iommu *iommu)
|
||||
{
|
||||
return sm_supported(iommu) ?
|
||||
ecap_smpwc(iommu->ecap) : ecap_coherent(iommu->ecap);
|
||||
}
|
||||
|
||||
static void domain_update_iommu_coherency(struct dmar_domain *domain)
|
||||
{
|
||||
struct dmar_drhd_unit *drhd;
|
||||
@ -622,7 +628,7 @@ static void domain_update_iommu_coherency(struct dmar_domain *domain)
|
||||
|
||||
for_each_domain_iommu(i, domain) {
|
||||
found = true;
|
||||
if (!ecap_coherent(g_iommus[i]->ecap)) {
|
||||
if (!iommu_paging_structure_coherency(g_iommus[i])) {
|
||||
domain->iommu_coherency = 0;
|
||||
break;
|
||||
}
|
||||
@ -633,7 +639,7 @@ static void domain_update_iommu_coherency(struct dmar_domain *domain)
|
||||
/* No hardware attached; use lowest common denominator */
|
||||
rcu_read_lock();
|
||||
for_each_active_iommu(iommu, drhd) {
|
||||
if (!ecap_coherent(iommu->ecap)) {
|
||||
if (!iommu_paging_structure_coherency(iommu)) {
|
||||
domain->iommu_coherency = 0;
|
||||
break;
|
||||
}
|
||||
@ -2090,7 +2096,8 @@ static int domain_context_mapping_one(struct dmar_domain *domain,
|
||||
|
||||
context_set_fault_enable(context);
|
||||
context_set_present(context);
|
||||
domain_flush_cache(domain, context, sizeof(*context));
|
||||
if (!ecap_coherent(iommu->ecap))
|
||||
clflush_cache_range(context, sizeof(*context));
|
||||
|
||||
/*
|
||||
* It's a non-present to present mapping. If hardware doesn't cache
|
||||
|
||||
@ -279,6 +279,8 @@ static int persistent_memory_claim(struct dm_writecache *wc)
|
||||
while (daa-- && i < p) {
|
||||
pages[i++] = pfn_t_to_page(pfn);
|
||||
pfn.val++;
|
||||
if (!(i & 15))
|
||||
cond_resched();
|
||||
}
|
||||
} while (i < p);
|
||||
wc->memory_map = vmap(pages, p, VM_MAP, PAGE_KERNEL);
|
||||
@ -805,6 +807,8 @@ static void writecache_discard(struct dm_writecache *wc, sector_t start, sector_
|
||||
writecache_wait_for_ios(wc, WRITE);
|
||||
discarded_something = true;
|
||||
}
|
||||
if (!writecache_entry_is_committed(wc, e))
|
||||
wc->uncommitted_blocks--;
|
||||
writecache_free_entry(wc, e);
|
||||
}
|
||||
|
||||
|
||||
@ -1249,8 +1249,12 @@ out_disable_adv_intr:
|
||||
|
||||
static void __alx_stop(struct alx_priv *alx)
|
||||
{
|
||||
alx_halt(alx);
|
||||
alx_free_irq(alx);
|
||||
|
||||
cancel_work_sync(&alx->link_check_wk);
|
||||
cancel_work_sync(&alx->reset_wk);
|
||||
|
||||
alx_halt(alx);
|
||||
alx_free_rings(alx);
|
||||
alx_free_napis(alx);
|
||||
}
|
||||
@ -1858,9 +1862,6 @@ static void alx_remove(struct pci_dev *pdev)
|
||||
struct alx_priv *alx = pci_get_drvdata(pdev);
|
||||
struct alx_hw *hw = &alx->hw;
|
||||
|
||||
cancel_work_sync(&alx->link_check_wk);
|
||||
cancel_work_sync(&alx->reset_wk);
|
||||
|
||||
/* restore permanent mac address */
|
||||
alx_set_macaddr(hw, hw->perm_addr);
|
||||
|
||||
|
||||
@ -1591,11 +1591,6 @@ static netdev_tx_t bcmgenet_xmit(struct sk_buff *skb, struct net_device *dev)
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (skb_padto(skb, ETH_ZLEN)) {
|
||||
ret = NETDEV_TX_OK;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Retain how many bytes will be sent on the wire, without TSB inserted
|
||||
* by transmit checksum offload
|
||||
*/
|
||||
@ -1644,6 +1639,9 @@ static netdev_tx_t bcmgenet_xmit(struct sk_buff *skb, struct net_device *dev)
|
||||
len_stat = (size << DMA_BUFLENGTH_SHIFT) |
|
||||
(priv->hw_params->qtag_mask << DMA_TX_QTAG_SHIFT);
|
||||
|
||||
/* Note: if we ever change from DMA_TX_APPEND_CRC below we
|
||||
* will need to restore software padding of "runt" packets
|
||||
*/
|
||||
if (!i) {
|
||||
len_stat |= DMA_TX_APPEND_CRC | DMA_SOP;
|
||||
if (skb->ip_summed == CHECKSUM_PARTIAL)
|
||||
|
||||
@ -18176,8 +18176,8 @@ static pci_ers_result_t tg3_io_error_detected(struct pci_dev *pdev,
|
||||
|
||||
rtnl_lock();
|
||||
|
||||
/* We probably don't have netdev yet */
|
||||
if (!netdev || !netif_running(netdev))
|
||||
/* Could be second call or maybe we don't have netdev yet */
|
||||
if (!netdev || tp->pcierr_recovery || !netif_running(netdev))
|
||||
goto done;
|
||||
|
||||
/* We needn't recover from permanent error */
|
||||
|
||||
@ -506,41 +506,20 @@ u64 cxgb4_select_ntuple(struct net_device *dev,
|
||||
}
|
||||
EXPORT_SYMBOL(cxgb4_select_ntuple);
|
||||
|
||||
/*
|
||||
* Called when address resolution fails for an L2T entry to handle packets
|
||||
* on the arpq head. If a packet specifies a failure handler it is invoked,
|
||||
* otherwise the packet is sent to the device.
|
||||
*/
|
||||
static void handle_failed_resolution(struct adapter *adap, struct l2t_entry *e)
|
||||
{
|
||||
struct sk_buff *skb;
|
||||
|
||||
while ((skb = __skb_dequeue(&e->arpq)) != NULL) {
|
||||
const struct l2t_skb_cb *cb = L2T_SKB_CB(skb);
|
||||
|
||||
spin_unlock(&e->lock);
|
||||
if (cb->arp_err_handler)
|
||||
cb->arp_err_handler(cb->handle, skb);
|
||||
else
|
||||
t4_ofld_send(adap, skb);
|
||||
spin_lock(&e->lock);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Called when the host's neighbor layer makes a change to some entry that is
|
||||
* loaded into the HW L2 table.
|
||||
*/
|
||||
void t4_l2t_update(struct adapter *adap, struct neighbour *neigh)
|
||||
{
|
||||
struct l2t_entry *e;
|
||||
struct sk_buff_head *arpq = NULL;
|
||||
struct l2t_data *d = adap->l2t;
|
||||
unsigned int addr_len = neigh->tbl->key_len;
|
||||
u32 *addr = (u32 *) neigh->primary_key;
|
||||
int ifidx = neigh->dev->ifindex;
|
||||
int hash = addr_hash(d, addr, addr_len, ifidx);
|
||||
int hash, ifidx = neigh->dev->ifindex;
|
||||
struct sk_buff_head *arpq = NULL;
|
||||
struct l2t_data *d = adap->l2t;
|
||||
struct l2t_entry *e;
|
||||
|
||||
hash = addr_hash(d, addr, addr_len, ifidx);
|
||||
read_lock_bh(&d->lock);
|
||||
for (e = d->l2tab[hash].first; e; e = e->next)
|
||||
if (!addreq(e, addr) && e->ifindex == ifidx) {
|
||||
@ -573,8 +552,25 @@ void t4_l2t_update(struct adapter *adap, struct neighbour *neigh)
|
||||
write_l2e(adap, e, 0);
|
||||
}
|
||||
|
||||
if (arpq)
|
||||
handle_failed_resolution(adap, e);
|
||||
if (arpq) {
|
||||
struct sk_buff *skb;
|
||||
|
||||
/* Called when address resolution fails for an L2T
|
||||
* entry to handle packets on the arpq head. If a
|
||||
* packet specifies a failure handler it is invoked,
|
||||
* otherwise the packet is sent to the device.
|
||||
*/
|
||||
while ((skb = __skb_dequeue(&e->arpq)) != NULL) {
|
||||
const struct l2t_skb_cb *cb = L2T_SKB_CB(skb);
|
||||
|
||||
spin_unlock(&e->lock);
|
||||
if (cb->arp_err_handler)
|
||||
cb->arp_err_handler(cb->handle, skb);
|
||||
else
|
||||
t4_ofld_send(adap, skb);
|
||||
spin_lock(&e->lock);
|
||||
}
|
||||
}
|
||||
spin_unlock_bh(&e->lock);
|
||||
}
|
||||
|
||||
|
||||
@ -254,7 +254,7 @@ static irqreturn_t enetc_msix(int irq, void *data)
|
||||
/* disable interrupts */
|
||||
enetc_wr_reg(v->rbier, 0);
|
||||
|
||||
for_each_set_bit(i, &v->tx_rings_map, v->count_tx_rings)
|
||||
for_each_set_bit(i, &v->tx_rings_map, ENETC_MAX_NUM_TXQS)
|
||||
enetc_wr_reg(v->tbier_base + ENETC_BDR_OFF(i), 0);
|
||||
|
||||
napi_schedule_irqoff(&v->napi);
|
||||
@ -290,7 +290,7 @@ static int enetc_poll(struct napi_struct *napi, int budget)
|
||||
/* enable interrupts */
|
||||
enetc_wr_reg(v->rbier, ENETC_RBIER_RXTIE);
|
||||
|
||||
for_each_set_bit(i, &v->tx_rings_map, v->count_tx_rings)
|
||||
for_each_set_bit(i, &v->tx_rings_map, ENETC_MAX_NUM_TXQS)
|
||||
enetc_wr_reg(v->tbier_base + ENETC_BDR_OFF(i),
|
||||
ENETC_TBIER_TXTIE);
|
||||
|
||||
|
||||
@ -1682,7 +1682,7 @@ static int ibmveth_probe(struct vio_dev *dev, const struct vio_device_id *id)
|
||||
}
|
||||
|
||||
netdev->min_mtu = IBMVETH_MIN_MTU;
|
||||
netdev->max_mtu = ETH_MAX_MTU;
|
||||
netdev->max_mtu = ETH_MAX_MTU - IBMVETH_BUFF_OH;
|
||||
|
||||
memcpy(netdev->dev_addr, mac_addr_p, ETH_ALEN);
|
||||
|
||||
|
||||
@ -779,12 +779,13 @@ static int ibmvnic_login(struct net_device *netdev)
|
||||
struct ibmvnic_adapter *adapter = netdev_priv(netdev);
|
||||
unsigned long timeout = msecs_to_jiffies(30000);
|
||||
int retry_count = 0;
|
||||
int retries = 10;
|
||||
bool retry;
|
||||
int rc;
|
||||
|
||||
do {
|
||||
retry = false;
|
||||
if (retry_count > IBMVNIC_MAX_QUEUES) {
|
||||
if (retry_count > retries) {
|
||||
netdev_warn(netdev, "Login attempts exceeded\n");
|
||||
return -1;
|
||||
}
|
||||
@ -799,11 +800,23 @@ static int ibmvnic_login(struct net_device *netdev)
|
||||
|
||||
if (!wait_for_completion_timeout(&adapter->init_done,
|
||||
timeout)) {
|
||||
netdev_warn(netdev, "Login timed out\n");
|
||||
return -1;
|
||||
netdev_warn(netdev, "Login timed out, retrying...\n");
|
||||
retry = true;
|
||||
adapter->init_done_rc = 0;
|
||||
retry_count++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (adapter->init_done_rc == PARTIALSUCCESS) {
|
||||
if (adapter->init_done_rc == ABORTED) {
|
||||
netdev_warn(netdev, "Login aborted, retrying...\n");
|
||||
retry = true;
|
||||
adapter->init_done_rc = 0;
|
||||
retry_count++;
|
||||
/* FW or device may be busy, so
|
||||
* wait a bit before retrying login
|
||||
*/
|
||||
msleep(500);
|
||||
} else if (adapter->init_done_rc == PARTIALSUCCESS) {
|
||||
retry_count++;
|
||||
release_sub_crqs(adapter, 1);
|
||||
|
||||
|
||||
@ -1541,7 +1541,7 @@ static void mvpp2_read_stats(struct mvpp2_port *port)
|
||||
for (q = 0; q < port->ntxqs; q++)
|
||||
for (i = 0; i < ARRAY_SIZE(mvpp2_ethtool_txq_regs); i++)
|
||||
*pstats++ += mvpp2_read_index(port->priv,
|
||||
MVPP22_CTRS_TX_CTR(port->id, i),
|
||||
MVPP22_CTRS_TX_CTR(port->id, q),
|
||||
mvpp2_ethtool_txq_regs[i].offset);
|
||||
|
||||
/* Rxqs are numbered from 0 from the user standpoint, but not from the
|
||||
@ -1550,7 +1550,7 @@ static void mvpp2_read_stats(struct mvpp2_port *port)
|
||||
for (q = 0; q < port->nrxqs; q++)
|
||||
for (i = 0; i < ARRAY_SIZE(mvpp2_ethtool_rxq_regs); i++)
|
||||
*pstats++ += mvpp2_read_index(port->priv,
|
||||
port->first_rxq + i,
|
||||
port->first_rxq + q,
|
||||
mvpp2_ethtool_rxq_regs[i].offset);
|
||||
}
|
||||
|
||||
|
||||
@ -396,7 +396,7 @@ static void qed_cxt_qm_iids(struct qed_hwfn *p_hwfn,
|
||||
vf_tids += segs[NUM_TASK_PF_SEGMENTS].count;
|
||||
}
|
||||
|
||||
iids->vf_cids += vf_cids * p_mngr->vf_count;
|
||||
iids->vf_cids = vf_cids;
|
||||
iids->tids += vf_tids * p_mngr->vf_count;
|
||||
|
||||
DP_VERBOSE(p_hwfn, QED_MSG_ILT,
|
||||
|
||||
@ -1368,6 +1368,8 @@ static void qed_dbg_user_data_free(struct qed_hwfn *p_hwfn)
|
||||
|
||||
void qed_resc_free(struct qed_dev *cdev)
|
||||
{
|
||||
struct qed_rdma_info *rdma_info;
|
||||
struct qed_hwfn *p_hwfn;
|
||||
int i;
|
||||
|
||||
if (IS_VF(cdev)) {
|
||||
@ -1385,7 +1387,8 @@ void qed_resc_free(struct qed_dev *cdev)
|
||||
qed_llh_free(cdev);
|
||||
|
||||
for_each_hwfn(cdev, i) {
|
||||
struct qed_hwfn *p_hwfn = &cdev->hwfns[i];
|
||||
p_hwfn = cdev->hwfns + i;
|
||||
rdma_info = p_hwfn->p_rdma_info;
|
||||
|
||||
qed_cxt_mngr_free(p_hwfn);
|
||||
qed_qm_info_free(p_hwfn);
|
||||
@ -1404,8 +1407,10 @@ void qed_resc_free(struct qed_dev *cdev)
|
||||
qed_ooo_free(p_hwfn);
|
||||
}
|
||||
|
||||
if (QED_IS_RDMA_PERSONALITY(p_hwfn))
|
||||
if (QED_IS_RDMA_PERSONALITY(p_hwfn) && rdma_info) {
|
||||
qed_spq_unregister_async_cb(p_hwfn, rdma_info->proto);
|
||||
qed_rdma_info_free(p_hwfn);
|
||||
}
|
||||
|
||||
qed_iov_free(p_hwfn);
|
||||
qed_l2_free(p_hwfn);
|
||||
|
||||
@ -2832,8 +2832,6 @@ int qed_iwarp_stop(struct qed_hwfn *p_hwfn)
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
qed_spq_unregister_async_cb(p_hwfn, PROTOCOLID_IWARP);
|
||||
|
||||
return qed_iwarp_ll2_stop(p_hwfn);
|
||||
}
|
||||
|
||||
|
||||
@ -113,7 +113,6 @@ void qed_roce_stop(struct qed_hwfn *p_hwfn)
|
||||
break;
|
||||
}
|
||||
}
|
||||
qed_spq_unregister_async_cb(p_hwfn, PROTOCOLID_ROCE);
|
||||
}
|
||||
|
||||
static void qed_rdma_copy_gids(struct qed_rdma_qp *qp, __le32 *src_gid,
|
||||
|
||||
@ -81,12 +81,17 @@ static void qed_vf_pf_req_end(struct qed_hwfn *p_hwfn, int req_status)
|
||||
mutex_unlock(&(p_hwfn->vf_iov_info->mutex));
|
||||
}
|
||||
|
||||
#define QED_VF_CHANNEL_USLEEP_ITERATIONS 90
|
||||
#define QED_VF_CHANNEL_USLEEP_DELAY 100
|
||||
#define QED_VF_CHANNEL_MSLEEP_ITERATIONS 10
|
||||
#define QED_VF_CHANNEL_MSLEEP_DELAY 25
|
||||
|
||||
static int qed_send_msg2pf(struct qed_hwfn *p_hwfn, u8 *done, u32 resp_size)
|
||||
{
|
||||
union vfpf_tlvs *p_req = p_hwfn->vf_iov_info->vf2pf_request;
|
||||
struct ustorm_trigger_vf_zone trigger;
|
||||
struct ustorm_vf_zone *zone_data;
|
||||
int rc = 0, time = 100;
|
||||
int iter, rc = 0;
|
||||
|
||||
zone_data = (struct ustorm_vf_zone *)PXP_VF_BAR0_START_USDM_ZONE_B;
|
||||
|
||||
@ -126,11 +131,19 @@ static int qed_send_msg2pf(struct qed_hwfn *p_hwfn, u8 *done, u32 resp_size)
|
||||
REG_WR(p_hwfn, (uintptr_t)&zone_data->trigger, *((u32 *)&trigger));
|
||||
|
||||
/* When PF would be done with the response, it would write back to the
|
||||
* `done' address. Poll until then.
|
||||
* `done' address from a coherent DMA zone. Poll until then.
|
||||
*/
|
||||
while ((!*done) && time) {
|
||||
msleep(25);
|
||||
time--;
|
||||
|
||||
iter = QED_VF_CHANNEL_USLEEP_ITERATIONS;
|
||||
while (!*done && iter--) {
|
||||
udelay(QED_VF_CHANNEL_USLEEP_DELAY);
|
||||
dma_rmb();
|
||||
}
|
||||
|
||||
iter = QED_VF_CHANNEL_MSLEEP_ITERATIONS;
|
||||
while (!*done && iter--) {
|
||||
msleep(QED_VF_CHANNEL_MSLEEP_DELAY);
|
||||
dma_rmb();
|
||||
}
|
||||
|
||||
if (!*done) {
|
||||
|
||||
@ -1158,7 +1158,7 @@ static int __qede_probe(struct pci_dev *pdev, u32 dp_module, u8 dp_level,
|
||||
|
||||
/* PTP not supported on VFs */
|
||||
if (!is_vf)
|
||||
qede_ptp_enable(edev, (mode == QEDE_PROBE_NORMAL));
|
||||
qede_ptp_enable(edev);
|
||||
|
||||
edev->ops->register_ops(cdev, &qede_ll_ops, edev);
|
||||
|
||||
@ -1247,6 +1247,7 @@ static void __qede_remove(struct pci_dev *pdev, enum qede_remove_mode mode)
|
||||
if (system_state == SYSTEM_POWER_OFF)
|
||||
return;
|
||||
qed_ops->common->remove(cdev);
|
||||
edev->cdev = NULL;
|
||||
|
||||
/* Since this can happen out-of-sync with other flows,
|
||||
* don't release the netdevice until after slowpath stop
|
||||
|
||||
@ -411,6 +411,7 @@ void qede_ptp_disable(struct qede_dev *edev)
|
||||
if (ptp->tx_skb) {
|
||||
dev_kfree_skb_any(ptp->tx_skb);
|
||||
ptp->tx_skb = NULL;
|
||||
clear_bit_unlock(QEDE_FLAGS_PTP_TX_IN_PRORGESS, &edev->flags);
|
||||
}
|
||||
|
||||
/* Disable PTP in HW */
|
||||
@ -422,7 +423,7 @@ void qede_ptp_disable(struct qede_dev *edev)
|
||||
edev->ptp = NULL;
|
||||
}
|
||||
|
||||
static int qede_ptp_init(struct qede_dev *edev, bool init_tc)
|
||||
static int qede_ptp_init(struct qede_dev *edev)
|
||||
{
|
||||
struct qede_ptp *ptp;
|
||||
int rc;
|
||||
@ -443,25 +444,19 @@ static int qede_ptp_init(struct qede_dev *edev, bool init_tc)
|
||||
/* Init work queue for Tx timestamping */
|
||||
INIT_WORK(&ptp->work, qede_ptp_task);
|
||||
|
||||
/* Init cyclecounter and timecounter. This is done only in the first
|
||||
* load. If done in every load, PTP application will fail when doing
|
||||
* unload / load (e.g. MTU change) while it is running.
|
||||
*/
|
||||
if (init_tc) {
|
||||
memset(&ptp->cc, 0, sizeof(ptp->cc));
|
||||
ptp->cc.read = qede_ptp_read_cc;
|
||||
ptp->cc.mask = CYCLECOUNTER_MASK(64);
|
||||
ptp->cc.shift = 0;
|
||||
ptp->cc.mult = 1;
|
||||
/* Init cyclecounter and timecounter */
|
||||
memset(&ptp->cc, 0, sizeof(ptp->cc));
|
||||
ptp->cc.read = qede_ptp_read_cc;
|
||||
ptp->cc.mask = CYCLECOUNTER_MASK(64);
|
||||
ptp->cc.shift = 0;
|
||||
ptp->cc.mult = 1;
|
||||
|
||||
timecounter_init(&ptp->tc, &ptp->cc,
|
||||
ktime_to_ns(ktime_get_real()));
|
||||
}
|
||||
timecounter_init(&ptp->tc, &ptp->cc, ktime_to_ns(ktime_get_real()));
|
||||
|
||||
return rc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int qede_ptp_enable(struct qede_dev *edev, bool init_tc)
|
||||
int qede_ptp_enable(struct qede_dev *edev)
|
||||
{
|
||||
struct qede_ptp *ptp;
|
||||
int rc;
|
||||
@ -482,7 +477,7 @@ int qede_ptp_enable(struct qede_dev *edev, bool init_tc)
|
||||
|
||||
edev->ptp = ptp;
|
||||
|
||||
rc = qede_ptp_init(edev, init_tc);
|
||||
rc = qede_ptp_init(edev);
|
||||
if (rc)
|
||||
goto err1;
|
||||
|
||||
|
||||
@ -41,7 +41,7 @@ void qede_ptp_rx_ts(struct qede_dev *edev, struct sk_buff *skb);
|
||||
void qede_ptp_tx_ts(struct qede_dev *edev, struct sk_buff *skb);
|
||||
int qede_ptp_hw_ts(struct qede_dev *edev, struct ifreq *req);
|
||||
void qede_ptp_disable(struct qede_dev *edev);
|
||||
int qede_ptp_enable(struct qede_dev *edev, bool init_tc);
|
||||
int qede_ptp_enable(struct qede_dev *edev);
|
||||
int qede_ptp_get_ts_info(struct qede_dev *edev, struct ethtool_ts_info *ts);
|
||||
|
||||
static inline void qede_ptp_record_rx_ts(struct qede_dev *edev,
|
||||
|
||||
@ -105,6 +105,7 @@ static void qede_rdma_destroy_wq(struct qede_dev *edev)
|
||||
|
||||
qede_rdma_cleanup_event(edev);
|
||||
destroy_workqueue(edev->rdma_info.rdma_wq);
|
||||
edev->rdma_info.rdma_wq = NULL;
|
||||
}
|
||||
|
||||
int qede_rdma_dev_add(struct qede_dev *edev, bool recovery)
|
||||
@ -325,7 +326,7 @@ static void qede_rdma_add_event(struct qede_dev *edev,
|
||||
if (edev->rdma_info.exp_recovery)
|
||||
return;
|
||||
|
||||
if (!edev->rdma_info.qedr_dev)
|
||||
if (!edev->rdma_info.qedr_dev || !edev->rdma_info.rdma_wq)
|
||||
return;
|
||||
|
||||
/* We don't want the cleanup flow to start while we're allocating and
|
||||
|
||||
@ -647,10 +647,10 @@ static int rocker_dma_rings_init(struct rocker *rocker)
|
||||
err_dma_event_ring_bufs_alloc:
|
||||
rocker_dma_ring_destroy(rocker, &rocker->event_ring);
|
||||
err_dma_event_ring_create:
|
||||
rocker_dma_cmd_ring_waits_free(rocker);
|
||||
err_dma_cmd_ring_waits_alloc:
|
||||
rocker_dma_ring_bufs_free(rocker, &rocker->cmd_ring,
|
||||
PCI_DMA_BIDIRECTIONAL);
|
||||
err_dma_cmd_ring_waits_alloc:
|
||||
rocker_dma_cmd_ring_waits_free(rocker);
|
||||
err_dma_cmd_ring_bufs_alloc:
|
||||
rocker_dma_ring_destroy(rocker, &rocker->cmd_ring);
|
||||
return err;
|
||||
|
||||
@ -1649,6 +1649,7 @@ static int geneve_changelink(struct net_device *dev, struct nlattr *tb[],
|
||||
geneve->collect_md = metadata;
|
||||
geneve->use_udp6_rx_checksums = use_udp6_rx_checksums;
|
||||
geneve->ttl_inherit = ttl_inherit;
|
||||
geneve->df = df;
|
||||
geneve_unquiesce(geneve, gs4, gs6);
|
||||
|
||||
return 0;
|
||||
|
||||
@ -797,8 +797,10 @@ static int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id,
|
||||
|
||||
/* Grab the bits from PHYIR2, and put them in the lower half */
|
||||
phy_reg = mdiobus_read(bus, addr, MII_PHYSID2);
|
||||
if (phy_reg < 0)
|
||||
return -EIO;
|
||||
if (phy_reg < 0) {
|
||||
/* returning -ENODEV doesn't stop bus scanning */
|
||||
return (phy_reg == -EIO || phy_reg == -ENODEV) ? -ENODEV : -EIO;
|
||||
}
|
||||
|
||||
*phy_id |= phy_reg;
|
||||
|
||||
|
||||
@ -1387,10 +1387,10 @@ static int ax88179_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
|
||||
}
|
||||
|
||||
if (pkt_cnt == 0) {
|
||||
/* Skip IP alignment psudo header */
|
||||
skb_pull(skb, 2);
|
||||
skb->len = pkt_len;
|
||||
skb_set_tail_pointer(skb, pkt_len);
|
||||
/* Skip IP alignment pseudo header */
|
||||
skb_pull(skb, 2);
|
||||
skb_set_tail_pointer(skb, skb->len);
|
||||
skb->truesize = pkt_len + sizeof(struct sk_buff);
|
||||
ax88179_rx_checksum(skb, pkt_hdr);
|
||||
return 1;
|
||||
@ -1399,8 +1399,9 @@ static int ax88179_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
|
||||
ax_skb = skb_clone(skb, GFP_ATOMIC);
|
||||
if (ax_skb) {
|
||||
ax_skb->len = pkt_len;
|
||||
ax_skb->data = skb->data + 2;
|
||||
skb_set_tail_pointer(ax_skb, pkt_len);
|
||||
/* Skip IP alignment pseudo header */
|
||||
skb_pull(ax_skb, 2);
|
||||
skb_set_tail_pointer(ax_skb, ax_skb->len);
|
||||
ax_skb->truesize = pkt_len + sizeof(struct sk_buff);
|
||||
ax88179_rx_checksum(ax_skb, pkt_hdr);
|
||||
usbnet_skb_return(dev, ax_skb);
|
||||
|
||||
@ -413,11 +413,10 @@ static void nvme_mpath_set_live(struct nvme_ns *ns)
|
||||
{
|
||||
struct nvme_ns_head *head = ns->head;
|
||||
|
||||
lockdep_assert_held(&ns->head->lock);
|
||||
|
||||
if (!head->disk)
|
||||
return;
|
||||
|
||||
mutex_lock(&head->lock);
|
||||
if (!(head->disk->flags & GENHD_FL_UP))
|
||||
device_add_disk(&head->subsys->dev, head->disk,
|
||||
nvme_ns_id_attr_groups);
|
||||
@ -430,9 +429,10 @@ static void nvme_mpath_set_live(struct nvme_ns *ns)
|
||||
__nvme_find_path(head, node);
|
||||
srcu_read_unlock(&head->srcu, srcu_idx);
|
||||
}
|
||||
mutex_unlock(&head->lock);
|
||||
|
||||
synchronize_srcu(&ns->head->srcu);
|
||||
kblockd_schedule_work(&ns->head->requeue_work);
|
||||
synchronize_srcu(&head->srcu);
|
||||
kblockd_schedule_work(&head->requeue_work);
|
||||
}
|
||||
|
||||
static int nvme_parse_ana_log(struct nvme_ctrl *ctrl, void *data,
|
||||
@ -483,14 +483,12 @@ static inline bool nvme_state_is_live(enum nvme_ana_state state)
|
||||
static void nvme_update_ns_ana_state(struct nvme_ana_group_desc *desc,
|
||||
struct nvme_ns *ns)
|
||||
{
|
||||
mutex_lock(&ns->head->lock);
|
||||
ns->ana_grpid = le32_to_cpu(desc->grpid);
|
||||
ns->ana_state = desc->state;
|
||||
clear_bit(NVME_NS_ANA_PENDING, &ns->flags);
|
||||
|
||||
if (nvme_state_is_live(ns->ana_state))
|
||||
nvme_mpath_set_live(ns);
|
||||
mutex_unlock(&ns->head->lock);
|
||||
}
|
||||
|
||||
static int nvme_update_ana_state(struct nvme_ctrl *ctrl,
|
||||
@ -661,10 +659,8 @@ void nvme_mpath_add_disk(struct nvme_ns *ns, struct nvme_id_ns *id)
|
||||
nvme_parse_ana_log(ns->ctrl, ns, nvme_set_ns_ana_state);
|
||||
mutex_unlock(&ns->ctrl->ana_lock);
|
||||
} else {
|
||||
mutex_lock(&ns->head->lock);
|
||||
ns->ana_state = NVME_ANA_OPTIMIZED;
|
||||
nvme_mpath_set_live(ns);
|
||||
mutex_unlock(&ns->head->lock);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -170,6 +170,7 @@ struct pmic_gpio_state {
|
||||
struct regmap *map;
|
||||
struct pinctrl_dev *ctrl;
|
||||
struct gpio_chip chip;
|
||||
struct irq_chip irq;
|
||||
};
|
||||
|
||||
static const struct pinconf_generic_params pmic_gpio_bindings[] = {
|
||||
@ -917,16 +918,6 @@ static int pmic_gpio_populate(struct pmic_gpio_state *state,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct irq_chip pmic_gpio_irq_chip = {
|
||||
.name = "spmi-gpio",
|
||||
.irq_ack = irq_chip_ack_parent,
|
||||
.irq_mask = irq_chip_mask_parent,
|
||||
.irq_unmask = irq_chip_unmask_parent,
|
||||
.irq_set_type = irq_chip_set_type_parent,
|
||||
.irq_set_wake = irq_chip_set_wake_parent,
|
||||
.flags = IRQCHIP_MASK_ON_SUSPEND,
|
||||
};
|
||||
|
||||
static int pmic_gpio_domain_translate(struct irq_domain *domain,
|
||||
struct irq_fwspec *fwspec,
|
||||
unsigned long *hwirq,
|
||||
@ -1053,8 +1044,16 @@ static int pmic_gpio_probe(struct platform_device *pdev)
|
||||
if (!parent_domain)
|
||||
return -ENXIO;
|
||||
|
||||
state->irq.name = "spmi-gpio",
|
||||
state->irq.irq_ack = irq_chip_ack_parent,
|
||||
state->irq.irq_mask = irq_chip_mask_parent,
|
||||
state->irq.irq_unmask = irq_chip_unmask_parent,
|
||||
state->irq.irq_set_type = irq_chip_set_type_parent,
|
||||
state->irq.irq_set_wake = irq_chip_set_wake_parent,
|
||||
state->irq.flags = IRQCHIP_MASK_ON_SUSPEND,
|
||||
|
||||
girq = &state->chip.irq;
|
||||
girq->chip = &pmic_gpio_irq_chip;
|
||||
girq->chip = &state->irq;
|
||||
girq->default_type = IRQ_TYPE_NONE;
|
||||
girq->handler = handle_level_irq;
|
||||
girq->fwnode = of_node_to_fwnode(state->dev->of_node);
|
||||
|
||||
@ -685,8 +685,8 @@ static int tegra_pinctrl_resume(struct device *dev)
|
||||
}
|
||||
|
||||
const struct dev_pm_ops tegra_pinctrl_pm = {
|
||||
.suspend = &tegra_pinctrl_suspend,
|
||||
.resume = &tegra_pinctrl_resume
|
||||
.suspend_noirq = &tegra_pinctrl_suspend,
|
||||
.resume_noirq = &tegra_pinctrl_resume
|
||||
};
|
||||
|
||||
static bool gpio_node_has_range(const char *compatible)
|
||||
|
||||
@ -209,6 +209,19 @@ static const struct regulator_ops pfuze100_swb_regulator_ops = {
|
||||
|
||||
};
|
||||
|
||||
static const struct regulator_ops pfuze3000_sw_regulator_ops = {
|
||||
.enable = regulator_enable_regmap,
|
||||
.disable = regulator_disable_regmap,
|
||||
.is_enabled = regulator_is_enabled_regmap,
|
||||
.list_voltage = regulator_list_voltage_table,
|
||||
.map_voltage = regulator_map_voltage_ascend,
|
||||
.set_voltage_sel = regulator_set_voltage_sel_regmap,
|
||||
.get_voltage_sel = regulator_get_voltage_sel_regmap,
|
||||
.set_voltage_time_sel = regulator_set_voltage_time_sel,
|
||||
.set_ramp_delay = pfuze100_set_ramp_delay,
|
||||
|
||||
};
|
||||
|
||||
#define PFUZE100_FIXED_REG(_chip, _name, base, voltage) \
|
||||
[_chip ## _ ## _name] = { \
|
||||
.desc = { \
|
||||
@ -318,23 +331,28 @@ static const struct regulator_ops pfuze100_swb_regulator_ops = {
|
||||
.stby_mask = 0x20, \
|
||||
}
|
||||
|
||||
|
||||
#define PFUZE3000_SW2_REG(_chip, _name, base, min, max, step) { \
|
||||
.desc = { \
|
||||
.name = #_name,\
|
||||
.n_voltages = ((max) - (min)) / (step) + 1, \
|
||||
.ops = &pfuze100_sw_regulator_ops, \
|
||||
.type = REGULATOR_VOLTAGE, \
|
||||
.id = _chip ## _ ## _name, \
|
||||
.owner = THIS_MODULE, \
|
||||
.min_uV = (min), \
|
||||
.uV_step = (step), \
|
||||
.vsel_reg = (base) + PFUZE100_VOL_OFFSET, \
|
||||
.vsel_mask = 0x7, \
|
||||
}, \
|
||||
.stby_reg = (base) + PFUZE100_STANDBY_OFFSET, \
|
||||
.stby_mask = 0x7, \
|
||||
}
|
||||
/* No linar case for the some switches of PFUZE3000 */
|
||||
#define PFUZE3000_SW_REG(_chip, _name, base, mask, voltages) \
|
||||
[_chip ## _ ## _name] = { \
|
||||
.desc = { \
|
||||
.name = #_name, \
|
||||
.n_voltages = ARRAY_SIZE(voltages), \
|
||||
.ops = &pfuze3000_sw_regulator_ops, \
|
||||
.type = REGULATOR_VOLTAGE, \
|
||||
.id = _chip ## _ ## _name, \
|
||||
.owner = THIS_MODULE, \
|
||||
.volt_table = voltages, \
|
||||
.vsel_reg = (base) + PFUZE100_VOL_OFFSET, \
|
||||
.vsel_mask = (mask), \
|
||||
.enable_reg = (base) + PFUZE100_MODE_OFFSET, \
|
||||
.enable_mask = 0xf, \
|
||||
.enable_val = 0x8, \
|
||||
.enable_time = 500, \
|
||||
}, \
|
||||
.stby_reg = (base) + PFUZE100_STANDBY_OFFSET, \
|
||||
.stby_mask = (mask), \
|
||||
.sw_reg = true, \
|
||||
}
|
||||
|
||||
#define PFUZE3000_SW3_REG(_chip, _name, base, min, max, step) { \
|
||||
.desc = { \
|
||||
@ -391,9 +409,9 @@ static struct pfuze_regulator pfuze200_regulators[] = {
|
||||
};
|
||||
|
||||
static struct pfuze_regulator pfuze3000_regulators[] = {
|
||||
PFUZE100_SWB_REG(PFUZE3000, SW1A, PFUZE100_SW1ABVOL, 0x1f, pfuze3000_sw1a),
|
||||
PFUZE3000_SW_REG(PFUZE3000, SW1A, PFUZE100_SW1ABVOL, 0x1f, pfuze3000_sw1a),
|
||||
PFUZE100_SW_REG(PFUZE3000, SW1B, PFUZE100_SW1CVOL, 700000, 1475000, 25000),
|
||||
PFUZE100_SWB_REG(PFUZE3000, SW2, PFUZE100_SW2VOL, 0x7, pfuze3000_sw2lo),
|
||||
PFUZE3000_SW_REG(PFUZE3000, SW2, PFUZE100_SW2VOL, 0x7, pfuze3000_sw2lo),
|
||||
PFUZE3000_SW3_REG(PFUZE3000, SW3, PFUZE100_SW3AVOL, 900000, 1650000, 50000),
|
||||
PFUZE100_SWB_REG(PFUZE3000, SWBST, PFUZE100_SWBSTCON1, 0x3, pfuze100_swbst),
|
||||
PFUZE100_SWB_REG(PFUZE3000, VSNVS, PFUZE100_VSNVSVOL, 0x7, pfuze100_vsnvs),
|
||||
@ -407,8 +425,8 @@ static struct pfuze_regulator pfuze3000_regulators[] = {
|
||||
};
|
||||
|
||||
static struct pfuze_regulator pfuze3001_regulators[] = {
|
||||
PFUZE100_SWB_REG(PFUZE3001, SW1, PFUZE100_SW1ABVOL, 0x1f, pfuze3000_sw1a),
|
||||
PFUZE100_SWB_REG(PFUZE3001, SW2, PFUZE100_SW2VOL, 0x7, pfuze3000_sw2lo),
|
||||
PFUZE3000_SW_REG(PFUZE3001, SW1, PFUZE100_SW1ABVOL, 0x1f, pfuze3000_sw1a),
|
||||
PFUZE3000_SW_REG(PFUZE3001, SW2, PFUZE100_SW2VOL, 0x7, pfuze3000_sw2lo),
|
||||
PFUZE3000_SW3_REG(PFUZE3001, SW3, PFUZE100_SW3AVOL, 900000, 1650000, 50000),
|
||||
PFUZE100_SWB_REG(PFUZE3001, VSNVS, PFUZE100_VSNVSVOL, 0x7, pfuze100_vsnvs),
|
||||
PFUZE100_VGEN_REG(PFUZE3001, VLDO1, PFUZE100_VGEN1VOL, 1800000, 3300000, 100000),
|
||||
|
||||
@ -4163,9 +4163,6 @@ static int qeth_setadpparms_set_access_ctrl_cb(struct qeth_card *card,
|
||||
int fallback = *(int *)reply->param;
|
||||
|
||||
QETH_CARD_TEXT(card, 4, "setaccb");
|
||||
if (cmd->hdr.return_code)
|
||||
return -EIO;
|
||||
qeth_setadpparms_inspect_rc(cmd);
|
||||
|
||||
access_ctrl_req = &cmd->data.setadapterparms.data.set_access_ctrl;
|
||||
QETH_CARD_TEXT_(card, 2, "rc=%d",
|
||||
@ -4175,7 +4172,7 @@ static int qeth_setadpparms_set_access_ctrl_cb(struct qeth_card *card,
|
||||
QETH_DBF_MESSAGE(3, "ERR:SET_ACCESS_CTRL(%#x) on device %x: %#x\n",
|
||||
access_ctrl_req->subcmd_code, CARD_DEVID(card),
|
||||
cmd->data.setadapterparms.hdr.return_code);
|
||||
switch (cmd->data.setadapterparms.hdr.return_code) {
|
||||
switch (qeth_setadpparms_inspect_rc(cmd)) {
|
||||
case SET_ACCESS_CTRL_RC_SUCCESS:
|
||||
if (card->options.isolation == ISOLATION_MODE_NONE) {
|
||||
dev_info(&card->gdev->dev,
|
||||
|
||||
@ -576,7 +576,10 @@ static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
|
||||
ZFCP_STATUS_ERP_TIMEDOUT)) {
|
||||
req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
|
||||
zfcp_dbf_rec_run("erscf_1", act);
|
||||
req->erp_action = NULL;
|
||||
/* lock-free concurrent access with
|
||||
* zfcp_erp_timeout_handler()
|
||||
*/
|
||||
WRITE_ONCE(req->erp_action, NULL);
|
||||
}
|
||||
if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
|
||||
zfcp_dbf_rec_run("erscf_2", act);
|
||||
@ -612,8 +615,14 @@ void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
|
||||
void zfcp_erp_timeout_handler(struct timer_list *t)
|
||||
{
|
||||
struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
|
||||
struct zfcp_erp_action *act = fsf_req->erp_action;
|
||||
struct zfcp_erp_action *act;
|
||||
|
||||
if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
|
||||
return;
|
||||
/* lock-free concurrent access with zfcp_erp_strategy_check_fsfreq() */
|
||||
act = READ_ONCE(fsf_req->erp_action);
|
||||
if (!act)
|
||||
return;
|
||||
zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
|
||||
}
|
||||
|
||||
|
||||
@ -11542,7 +11542,8 @@ lpfc_sli4_hba_unset(struct lpfc_hba *phba)
|
||||
lpfc_sli4_xri_exchange_busy_wait(phba);
|
||||
|
||||
/* per-phba callback de-registration for hotplug event */
|
||||
lpfc_cpuhp_remove(phba);
|
||||
if (phba->pport)
|
||||
lpfc_cpuhp_remove(phba);
|
||||
|
||||
/* Disable PCI subsystem interrupt */
|
||||
lpfc_sli4_disable_intr(phba);
|
||||
|
||||
@ -3638,7 +3638,9 @@ void qla24xx_async_gnnft_done(scsi_qla_host_t *vha, srb_t *sp)
|
||||
qla2x00_clear_loop_id(fcport);
|
||||
fcport->flags |= FCF_FABRIC_DEVICE;
|
||||
} else if (fcport->d_id.b24 != rp->id.b24 ||
|
||||
fcport->scan_needed) {
|
||||
(fcport->scan_needed &&
|
||||
fcport->port_type != FCT_INITIATOR &&
|
||||
fcport->port_type != FCT_NVME_INITIATOR)) {
|
||||
qlt_schedule_sess_for_deletion(fcport);
|
||||
}
|
||||
fcport->d_id.b24 = rp->id.b24;
|
||||
|
||||
@ -1845,12 +1845,14 @@ int update_sta_support_rate(struct adapter *padapter, u8 *pvar_ie, uint var_ie_l
|
||||
pIE = (struct ndis_80211_var_ie *)rtw_get_ie(pvar_ie, _SUPPORTEDRATES_IE_, &ie_len, var_ie_len);
|
||||
if (!pIE)
|
||||
return _FAIL;
|
||||
if (ie_len > sizeof(pmlmeinfo->FW_sta_info[cam_idx].SupportedRates))
|
||||
return _FAIL;
|
||||
|
||||
memcpy(pmlmeinfo->FW_sta_info[cam_idx].SupportedRates, pIE->data, ie_len);
|
||||
supportRateNum = ie_len;
|
||||
|
||||
pIE = (struct ndis_80211_var_ie *)rtw_get_ie(pvar_ie, _EXT_SUPPORTEDRATES_IE_, &ie_len, var_ie_len);
|
||||
if (pIE)
|
||||
if (pIE && (ie_len <= sizeof(pmlmeinfo->FW_sta_info[cam_idx].SupportedRates) - supportRateNum))
|
||||
memcpy((pmlmeinfo->FW_sta_info[cam_idx].SupportedRates + supportRateNum), pIE->data, ie_len);
|
||||
|
||||
return _SUCCESS;
|
||||
|
||||
@ -75,8 +75,6 @@ static LIST_HEAD(hvc_structs);
|
||||
*/
|
||||
static DEFINE_MUTEX(hvc_structs_mutex);
|
||||
|
||||
/* Mutex to serialize hvc_open */
|
||||
static DEFINE_MUTEX(hvc_open_mutex);
|
||||
/*
|
||||
* This value is used to assign a tty->index value to a hvc_struct based
|
||||
* upon order of exposure via hvc_probe(), when we can not match it to
|
||||
@ -348,24 +346,16 @@ static int hvc_install(struct tty_driver *driver, struct tty_struct *tty)
|
||||
*/
|
||||
static int hvc_open(struct tty_struct *tty, struct file * filp)
|
||||
{
|
||||
struct hvc_struct *hp;
|
||||
struct hvc_struct *hp = tty->driver_data;
|
||||
unsigned long flags;
|
||||
int rc = 0;
|
||||
|
||||
mutex_lock(&hvc_open_mutex);
|
||||
|
||||
hp = tty->driver_data;
|
||||
if (!hp) {
|
||||
rc = -EIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&hp->port.lock, flags);
|
||||
/* Check and then increment for fast path open. */
|
||||
if (hp->port.count++ > 0) {
|
||||
spin_unlock_irqrestore(&hp->port.lock, flags);
|
||||
hvc_kick();
|
||||
goto out;
|
||||
return 0;
|
||||
} /* else count == 0 */
|
||||
spin_unlock_irqrestore(&hp->port.lock, flags);
|
||||
|
||||
@ -393,8 +383,6 @@ static int hvc_open(struct tty_struct *tty, struct file * filp)
|
||||
/* Force wakeup of the polling thread */
|
||||
hvc_kick();
|
||||
|
||||
out:
|
||||
mutex_unlock(&hvc_open_mutex);
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
@ -327,7 +327,8 @@ static int cdns3_ep0_feature_handle_device(struct cdns3_device *priv_dev,
|
||||
if (!set || (tmode & 0xff) != 0)
|
||||
return -EINVAL;
|
||||
|
||||
switch (tmode >> 8) {
|
||||
tmode >>= 8;
|
||||
switch (tmode) {
|
||||
case TEST_J:
|
||||
case TEST_K:
|
||||
case TEST_SE0_NAK:
|
||||
@ -711,15 +712,17 @@ static int cdns3_gadget_ep0_queue(struct usb_ep *ep,
|
||||
int ret = 0;
|
||||
u8 zlp = 0;
|
||||
|
||||
spin_lock_irqsave(&priv_dev->lock, flags);
|
||||
trace_cdns3_ep0_queue(priv_dev, request);
|
||||
|
||||
/* cancel the request if controller receive new SETUP packet. */
|
||||
if (cdns3_check_new_setup(priv_dev))
|
||||
if (cdns3_check_new_setup(priv_dev)) {
|
||||
spin_unlock_irqrestore(&priv_dev->lock, flags);
|
||||
return -ECONNRESET;
|
||||
}
|
||||
|
||||
/* send STATUS stage. Should be called only for SET_CONFIGURATION */
|
||||
if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE) {
|
||||
spin_lock_irqsave(&priv_dev->lock, flags);
|
||||
cdns3_select_ep(priv_dev, 0x00);
|
||||
|
||||
erdy_sent = !priv_dev->hw_configured_flag;
|
||||
@ -744,7 +747,6 @@ static int cdns3_gadget_ep0_queue(struct usb_ep *ep,
|
||||
return 0;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&priv_dev->lock, flags);
|
||||
if (!list_empty(&priv_ep->pending_req_list)) {
|
||||
dev_err(priv_dev->dev,
|
||||
"can't handle multiple requests for ep0\n");
|
||||
|
||||
@ -150,7 +150,7 @@ DECLARE_EVENT_CLASS(cdns3_log_ep0_irq,
|
||||
__dynamic_array(char, str, CDNS3_MSG_MAX)
|
||||
),
|
||||
TP_fast_assign(
|
||||
__entry->ep_dir = priv_dev->ep0_data_dir;
|
||||
__entry->ep_dir = priv_dev->selected_ep;
|
||||
__entry->ep_sts = ep_sts;
|
||||
),
|
||||
TP_printk("%s", cdns3_decode_ep0_irq(__get_str(str),
|
||||
|
||||
@ -1689,6 +1689,8 @@ static int acm_pre_reset(struct usb_interface *intf)
|
||||
|
||||
static const struct usb_device_id acm_ids[] = {
|
||||
/* quirky and broken devices */
|
||||
{ USB_DEVICE(0x0424, 0x274e), /* Microchip Technology, Inc. (formerly SMSC) */
|
||||
.driver_info = DISABLE_ECHO, }, /* DISABLE ECHO in termios flag */
|
||||
{ USB_DEVICE(0x076d, 0x0006), /* Denso Cradle CU-321 */
|
||||
.driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
|
||||
{ USB_DEVICE(0x17ef, 0x7000), /* Lenovo USB modem */
|
||||
|
||||
@ -218,11 +218,12 @@ static const struct usb_device_id usb_quirk_list[] = {
|
||||
/* Logitech HD Webcam C270 */
|
||||
{ USB_DEVICE(0x046d, 0x0825), .driver_info = USB_QUIRK_RESET_RESUME },
|
||||
|
||||
/* Logitech HD Pro Webcams C920, C920-C, C925e and C930e */
|
||||
/* Logitech HD Pro Webcams C920, C920-C, C922, C925e and C930e */
|
||||
{ USB_DEVICE(0x046d, 0x082d), .driver_info = USB_QUIRK_DELAY_INIT },
|
||||
{ USB_DEVICE(0x046d, 0x0841), .driver_info = USB_QUIRK_DELAY_INIT },
|
||||
{ USB_DEVICE(0x046d, 0x0843), .driver_info = USB_QUIRK_DELAY_INIT },
|
||||
{ USB_DEVICE(0x046d, 0x085b), .driver_info = USB_QUIRK_DELAY_INIT },
|
||||
{ USB_DEVICE(0x046d, 0x085c), .driver_info = USB_QUIRK_DELAY_INIT },
|
||||
|
||||
/* Logitech ConferenceCam CC3000e */
|
||||
{ USB_DEVICE(0x046d, 0x0847), .driver_info = USB_QUIRK_DELAY_INIT },
|
||||
|
||||
@ -4886,12 +4886,6 @@ int dwc2_gadget_init(struct dwc2_hsotg *hsotg)
|
||||
epnum, 0);
|
||||
}
|
||||
|
||||
ret = usb_add_gadget_udc(dev, &hsotg->gadget);
|
||||
if (ret) {
|
||||
dwc2_hsotg_ep_free_request(&hsotg->eps_out[0]->ep,
|
||||
hsotg->ctrl_req);
|
||||
return ret;
|
||||
}
|
||||
dwc2_hsotg_dump(hsotg);
|
||||
|
||||
return 0;
|
||||
|
||||
@ -507,6 +507,17 @@ static int dwc2_driver_probe(struct platform_device *dev)
|
||||
if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL)
|
||||
dwc2_lowlevel_hw_disable(hsotg);
|
||||
|
||||
#if IS_ENABLED(CONFIG_USB_DWC2_PERIPHERAL) || \
|
||||
IS_ENABLED(CONFIG_USB_DWC2_DUAL_ROLE)
|
||||
/* Postponed adding a new gadget to the udc class driver list */
|
||||
if (hsotg->gadget_enabled) {
|
||||
retval = usb_add_gadget_udc(hsotg->dev, &hsotg->gadget);
|
||||
if (retval) {
|
||||
dwc2_hsotg_remove(hsotg);
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
#endif /* CONFIG_USB_DWC2_PERIPHERAL || CONFIG_USB_DWC2_DUAL_ROLE */
|
||||
return 0;
|
||||
|
||||
error:
|
||||
|
||||
@ -2313,7 +2313,8 @@ static int mv_udc_probe(struct platform_device *pdev)
|
||||
return 0;
|
||||
|
||||
err_create_workqueue:
|
||||
destroy_workqueue(udc->qwork);
|
||||
if (udc->qwork)
|
||||
destroy_workqueue(udc->qwork);
|
||||
err_destroy_dma:
|
||||
dma_pool_destroy(udc->dtd_pool);
|
||||
err_free_dma:
|
||||
|
||||
@ -203,9 +203,8 @@ static int exynos_ehci_probe(struct platform_device *pdev)
|
||||
hcd->rsrc_len = resource_size(res);
|
||||
|
||||
irq = platform_get_irq(pdev, 0);
|
||||
if (!irq) {
|
||||
dev_err(&pdev->dev, "Failed to get IRQ\n");
|
||||
err = -ENODEV;
|
||||
if (irq < 0) {
|
||||
err = irq;
|
||||
goto fail_io;
|
||||
}
|
||||
|
||||
|
||||
@ -216,6 +216,13 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
|
||||
ehci_info(ehci, "applying MosChip frame-index workaround\n");
|
||||
ehci->frame_index_bug = 1;
|
||||
break;
|
||||
case PCI_VENDOR_ID_HUAWEI:
|
||||
/* Synopsys HC bug */
|
||||
if (pdev->device == 0xa239) {
|
||||
ehci_info(ehci, "applying Synopsys HC workaround\n");
|
||||
ehci->has_synopsys_hc_bug = 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/* optional debug port, normally in the first BAR */
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user