This is the 4.19.21 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAlxjFL8ACgkQONu9yGCS
aT643xAAk+mnsrOfU6/LBFjcJUUUYohK01UAU+PRvTjy4uH8rrA4G01xvp11ftIu
jjEikA2582ScR5a2Ww+E4SfqOdKT4z9hOGLTnyI0P4xN9jeVidvu9+C90AYyBYhi
orHm1osVQIj6n9+OQ5db+DzZYbZLbyfCoqNXbq9EoLvNRS3FUUH0y2VXqcz9Ghcj
obpdHTVMKRaFkRWdCglo+3hSpoKrncSVpKrwUXR18GCt8jjZjj39kI9t6UoGNfc7
nN3GOd26U1tpGo6ShZJYu6aPjV+zoYNlsg1o2zn9qJANIdulYe30vqNhWCeJ+/T7
WcT3EHv4pPEO3Lvgfp+l10Nc6IbYdJEFUpAP3CvfP+MvRfKvz8Vo3Nm/BQlr20+q
+MUYJb+wxhlHPRLV192XbnYFkEzZg7vzymoMPL034XheAkOkPbOK0IIVo41p5Rai
LxmOdvhzfAktbtD/VWnLTUbexjs2EJ05bvZRjdPKKIMBNKnAWz4ux3KcHxpdsUF8
KMCKwpJE8KDM4uiaKVdyfMhFeIg37pmy+7Uv9cUFjWwtsL3K+CiAXg8uaSvnajKr
bOhwbFIgxoOI9VRBK8M0wvzouphA0miVbxOY81sdfbMeWNpbCLdb968AFz25llta
rVlWp7bSAUQTsvTkVBv6mrTKPwzO4jnfHYN8yj5gO7pr5fmC2ig=
=L+Mp
-----END PGP SIGNATURE-----
Merge 4.19.21 into android-4.19
Changes in 4.19.21
devres: Align data[] to ARCH_KMALLOC_MINALIGN
drm/bufs: Fix Spectre v1 vulnerability
staging: iio: adc: ad7280a: handle error from __ad7280_read32()
drm/vgem: Fix vgem_init to get drm device available.
pinctrl: bcm2835: Use raw spinlock for RT compatibility
ASoC: Intel: mrfld: fix uninitialized variable access
gpiolib: Fix possible use after free on label
drm/sun4i: Initialize registers in tcon-top driver
genirq/affinity: Spread IRQs to all available NUMA nodes
gpu: ipu-v3: image-convert: Prevent race between run and unprepare
nds32: Fix gcc 8.0 compiler option incompatible.
wil6210: fix reset flow for Talyn-mb
wil6210: fix memory leak in wil_find_tx_bcast_2
ath10k: assign 'n_cipher_suites' for WCN3990
ath9k: dynack: use authentication messages for 'late' ack
scsi: lpfc: Correct LCB RJT handling
scsi: mpt3sas: Call sas_remove_host before removing the target devices
scsi: lpfc: Fix LOGO/PLOGI handling when triggerd by ABTS Timeout event
ARM: 8808/1: kexec:offline panic_smp_self_stop CPU
clk: boston: fix possible memory leak in clk_boston_setup()
dlm: Don't swamp the CPU with callbacks queued during recovery
x86/PCI: Fix Broadcom CNB20LE unintended sign extension (redux)
powerpc/pseries: add of_node_put() in dlpar_detach_node()
crypto: aes_ti - disable interrupts while accessing S-box
drm/vc4: ->x_scaling[1] should never be set to VC4_SCALING_NONE
serial: fsl_lpuart: clear parity enable bit when disable parity
ptp: check gettime64 return code in PTP_SYS_OFFSET ioctl
MIPS: Boston: Disable EG20T prefetch
dpaa2-ptp: defer probe when portal allocation failed
iwlwifi: fw: do not set sgi bits for HE connection
staging:iio:ad2s90: Make probe handle spi_setup failure
fpga: altera-cvp: Fix registration for CvP incapable devices
Tools: hv: kvp: Fix a warning of buffer overflow with gcc 8.0.1
fpga: altera-cvp: fix 'bad IO access' on x86_64
vbox: fix link error with 'gcc -Og'
platform/chrome: don't report EC_MKBP_EVENT_SENSOR_FIFO as wakeup
i40e: prevent overlapping tx_timeout recover
scsi: hisi_sas: change the time of SAS SSP connection
staging: iio: ad7780: update voltage on read
usbnet: smsc95xx: fix rx packet alignment
drm/rockchip: fix for mailbox read size
ARM: OMAP2+: hwmod: Fix some section annotations
drm/amd/display: fix gamma not being applied correctly
drm/amd/display: calculate stream->phy_pix_clk before clock mapping
bpf: libbpf: retry map creation without the name
net/mlx5: EQ, Use the right place to store/read IRQ affinity hint
modpost: validate symbol names also in find_elf_symbol
perf tools: Add Hygon Dhyana support
soc/tegra: Don't leak device tree node reference
media: rc: ensure close() is called on rc_unregister_device
media: video-i2c: avoid accessing released memory area when removing driver
media: mtk-vcodec: Release device nodes in mtk_vcodec_init_enc_pm()
staging: erofs: fix the definition of DBG_BUGON
clk: meson: meson8b: do not use cpu_div3 for cpu_scale_out_sel
clk: meson: meson8b: fix the width of the cpu_scale_div clock
clk: meson: meson8b: mark the CPU clock as CLK_IS_CRITICAL
ptp: Fix pass zero to ERR_PTR() in ptp_clock_register
dmaengine: xilinx_dma: Remove __aligned attribute on zynqmp_dma_desc_ll
powerpc/32: Add .data..Lubsan_data*/.data..Lubsan_type* sections explicitly
iio: adc: meson-saradc: check for devm_kasprintf failure
iio: adc: meson-saradc: fix internal clock names
iio: accel: kxcjk1013: Add KIOX010A ACPI Hardware-ID
media: adv*/tc358743/ths8200: fill in min width/height/pixelclock
ACPI: SPCR: Consider baud rate 0 as preconfigured state
staging: pi433: fix potential null dereference
f2fs: move dir data flush to write checkpoint process
f2fs: fix race between write_checkpoint and write_begin
f2fs: fix wrong return value of f2fs_acl_create
i2c: sh_mobile: add support for r8a77990 (R-Car E3)
arm64: io: Ensure calls to delay routines are ordered against prior readX()
net: aquantia: return 'err' if set MPI_DEINIT state fails
sunvdc: Do not spin in an infinite loop when vio_ldc_send() returns EAGAIN
soc: bcm: brcmstb: Don't leak device tree node reference
nfsd4: fix crash on writing v4_end_grace before nfsd startup
drm: Clear state->acquire_ctx before leaving drm_atomic_helper_commit_duplicated_state()
perf: arm_spe: handle devm_kasprintf() failure
arm64: io: Ensure value passed to __iormb() is held in a 64-bit register
Thermal: do not clear passive state during system sleep
thermal: Fix locking in cooling device sysfs update cur_state
firmware/efi: Add NULL pointer checks in efivars API functions
s390/zcrypt: improve special ap message cmd handling
mt76x0: dfs: fix IBI_R11 configuration on non-radar channels
arm64: ftrace: don't adjust the LR value
drm/v3d: Fix prime imports of buffers from other drivers.
ARM: dts: mmp2: fix TWSI2
ARM: dts: aspeed: add missing memory unit-address
x86/fpu: Add might_fault() to user_insn()
media: i2c: TDA1997x: select CONFIG_HDMI
media: DaVinci-VPBE: fix error handling in vpbe_initialize()
smack: fix access permissions for keyring
xtensa: xtfpga.dtsi: fix dtc warnings about SPI
usb: dwc3: Correct the logic for checking TRB full in __dwc3_prepare_one_trb()
usb: dwc2: Disable power down feature on Samsung SoCs
usb: hub: delay hub autosuspend if USB3 port is still link training
timekeeping: Use proper seqcount initializer
usb: mtu3: fix the issue about SetFeature(U1/U2_Enable)
clk: sunxi-ng: a33: Set CLK_SET_RATE_PARENT for all audio module clocks
media: imx274: select REGMAP_I2C
drm/amdgpu/powerplay: fix clock stretcher limits on polaris (v2)
tipc: fix node keep alive interval calculation
driver core: Move async_synchronize_full call
kobject: return error code if writing /sys/.../uevent fails
IB/hfi1: Unreserve a reserved request when it is completed
usb: dwc3: trace: add missing break statement to make compiler happy
gpio: mt7621: report failure of devm_kasprintf()
gpio: mt7621: pass mediatek_gpio_bank_probe() failure up the stack
pinctrl: sx150x: handle failure case of devm_kstrdup
iommu/amd: Fix amd_iommu=force_isolation
ARM: dts: Fix OMAP4430 SDP Ethernet startup
mips: bpf: fix encoding bug for mm_srlv32_op
media: coda: fix H.264 deblocking filter controls
ARM: dts: Fix up the D-Link DIR-685 MTD partition info
watchdog: renesas_wdt: don't set divider while watchdog is running
ARM: dts: imx51-zii-rdu1: Do not specify "power-gpio" for hpa1
usb: dwc3: gadget: Disable CSP for stream OUT ep
iommu/arm-smmu-v3: Avoid memory corruption from Hisilicon MSI payloads
iommu/arm-smmu: Add support for qcom,smmu-v2 variant
iommu/arm-smmu-v3: Use explicit mb() when moving cons pointer
sata_rcar: fix deferred probing
clk: imx6sl: ensure MMDC CH0 handshake is bypassed
platform/x86: mlx-platform: Fix tachometer registers
cpuidle: big.LITTLE: fix refcount leak
OPP: Use opp_table->regulators to verify no regulator case
tee: optee: avoid possible double list_del()
drm/msm/dsi: fix dsi clock names in DSI 10nm PLL driver
drm/msm: dpu: Only check flush register against pending flushes
lightnvm: pblk: fix resubmission of overwritten write err lbas
lightnvm: pblk: add lock protection to list operations
i2c-axxia: check for error conditions first
phy: sun4i-usb: add support for missing USB PHY index
mlxsw: spectrum_acl: Limit priority value
udf: Fix BUG on corrupted inode
switchtec: Fix SWITCHTEC_IOCTL_EVENT_IDX_ALL flags overwrite
selftests/bpf: use __bpf_constant_htons in test_prog.c
ARM: pxa: avoid section mismatch warning
ASoC: fsl: Fix SND_SOC_EUKREA_TLV320 build error on i.MX8M
KVM: PPC: Book3S: Only report KVM_CAP_SPAPR_TCE_VFIO on powernv machines
mmc: bcm2835: Recover from MMC_SEND_EXT_CSD
mmc: bcm2835: reset host on timeout
mmc: meson-mx-sdio: check devm_kasprintf for failure
memstick: Prevent memstick host from getting runtime suspended during card detection
mmc: sdhci-of-esdhc: Fix timeout checks
mmc: sdhci-omap: Fix timeout checks
mmc: sdhci-xenon: Fix timeout checks
mmc: jz4740: Get CD/WP GPIOs from descriptors
usb: renesas_usbhs: add support for RZ/G2E
btrfs: harden agaist duplicate fsid on scanned devices
serial: sh-sci: Fix locking in sci_submit_rx()
serial: sh-sci: Resume PIO in sci_rx_interrupt() on DMA failure
tty: serial: samsung: Properly set flags in autoCTS mode
perf test: Fix perf_event_attr test failure
perf dso: Fix unchecked usage of strncpy()
perf header: Fix unchecked usage of strncpy()
btrfs: use tagged writepage to mitigate livelock of snapshot
perf probe: Fix unchecked usage of strncpy()
i2c: sh_mobile: Add support for r8a774c0 (RZ/G2E)
bnxt_en: Disable MSIX before re-reserving NQs/CMPL rings.
tools/power/x86/intel_pstate_tracer: Fix non root execution for post processing a trace file
livepatch: check kzalloc return values
arm64: KVM: Skip MMIO insn after emulation
usb: musb: dsps: fix otg state machine
usb: musb: dsps: fix runtime pm for peripheral mode
perf header: Fix up argument to ctime()
perf tools: Cast off_t to s64 to avoid warning on bionic libc
percpu: convert spin_lock_irq to spin_lock_irqsave.
net: hns3: fix incomplete uninitialization of IRQ in the hns3_nic_uninit_vector_data()
drm/amd/display: Add retry to read ddc_clock pin
Bluetooth: hci_bcm: Handle deferred probing for the clock supply
drm/amd/display: fix YCbCr420 blank color
powerpc/uaccess: fix warning/error with access_ok()
mac80211: fix radiotap vendor presence bitmap handling
xfrm6_tunnel: Fix spi check in __xfrm6_tunnel_alloc_spi
mlxsw: spectrum: Properly cleanup LAG uppers when removing port from LAG
scsi: smartpqi: correct host serial num for ssa
scsi: smartpqi: correct volume status
scsi: smartpqi: increase fw status register read timeout
cw1200: Fix concurrency use-after-free bugs in cw1200_hw_scan()
net: hns3: add max vector number check for pf
powerpc/perf: Fix thresholding counter data for unknown type
iwlwifi: mvm: fix setting HE ppe FW config
powerpc/powernv/ioda: Allocate indirect TCE levels of cached userspace addresses on demand
mlx5: update timecounter at least twice per counter overflow
drbd: narrow rcu_read_lock in drbd_sync_handshake
drbd: disconnect, if the wrong UUIDs are attached on a connected peer
drbd: skip spurious timeout (ping-timeo) when failing promote
drbd: Avoid Clang warning about pointless switch statment
drm/amd/display: validate extended dongle caps
video: clps711x-fb: release disp device node in probe()
md: fix raid10 hang issue caused by barrier
fbdev: fbmem: behave better with small rotated displays and many CPUs
i40e: define proper net_device::neigh_priv_len
ice: Do not enable NAPI on q_vectors that have no rings
igb: Fix an issue that PME is not enabled during runtime suspend
ACPI/APEI: Clear GHES block_status before panic()
fbdev: fbcon: Fix unregister crash when more than one framebuffer
powerpc/mm: Fix reporting of kernel execute faults on the 8xx
pinctrl: meson: meson8: fix the GPIO function for the GPIOAO pins
pinctrl: meson: meson8b: fix the GPIO function for the GPIOAO pins
KVM: x86: svm: report MSR_IA32_MCG_EXT_CTL as unsupported
powerpc/fadump: Do not allow hot-remove memory from fadump reserved area.
kvm: Change offset in kvm_write_guest_offset_cached to unsigned
NFS: nfs_compare_mount_options always compare auth flavors.
perf build: Don't unconditionally link the libbfd feature test to -liberty and -lz
hwmon: (lm80) fix a missing check of the status of SMBus read
hwmon: (lm80) fix a missing check of bus read in lm80 probe
seq_buf: Make seq_buf_puts() null-terminate the buffer
crypto: ux500 - Use proper enum in cryp_set_dma_transfer
crypto: ux500 - Use proper enum in hash_set_dma_transfer
MIPS: ralink: Select CONFIG_CPU_MIPSR2_IRQ_VI on MT7620/8
cifs: check ntwrk_buf_start for NULL before dereferencing it
f2fs: fix use-after-free issue when accessing sbi->stat_info
um: Avoid marking pages with "changed protection"
niu: fix missing checks of niu_pci_eeprom_read
f2fs: fix sbi->extent_list corruption issue
cgroup: fix parsing empty mount option string
perf python: Do not force closing original perf descriptor in evlist.get_pollfd()
scripts/decode_stacktrace: only strip base path when a prefix of the path
arch/sh/boards/mach-kfr2r09/setup.c: fix struct mtd_oob_ops build warning
ocfs2: don't clear bh uptodate for block read
ocfs2: improve ocfs2 Makefile
mm/page_alloc.c: don't call kasan_free_pages() at deferred mem init
zram: fix lockdep warning of free block handling
isdn: hisax: hfc_pci: Fix a possible concurrency use-after-free bug in HFCPCI_l1hw()
gdrom: fix a memory leak bug
fsl/fman: Use GFP_ATOMIC in {memac,tgec}_add_hash_mac_address()
block/swim3: Fix -EBUSY error when re-opening device after unmount
thermal: bcm2835: enable hwmon explicitly
kdb: Don't back trace on a cpu that didn't round up
PCI: imx: Enable MSI from downstream components
thermal: generic-adc: Fix adc to temp interpolation
HID: lenovo: Add checks to fix of_led_classdev_register
arm64/sve: ptrace: Fix SVE_PT_REGS_OFFSET definition
kernel/hung_task.c: break RCU locks based on jiffies
proc/sysctl: fix return error for proc_doulongvec_minmax()
kernel/hung_task.c: force console verbose before panic
fs/epoll: drop ovflist branch prediction
exec: load_script: don't blindly truncate shebang string
kernel/kcov.c: mark write_comp_data() as notrace
scripts/gdb: fix lx-version string output
xfs: Fix xqmstats offsets in /proc/fs/xfs/xqmstat
xfs: cancel COW blocks before swapext
xfs: Fix error code in 'xfs_ioc_getbmap()'
xfs: fix overflow in xfs_attr3_leaf_verify
xfs: fix shared extent data corruption due to missing cow reservation
xfs: fix transient reference count error in xfs_buf_resubmit_failed_buffers
xfs: delalloc -> unwritten COW fork allocation can go wrong
fs/xfs: fix f_ffree value for statfs when project quota is set
xfs: fix PAGE_MASK usage in xfs_free_file_space
xfs: fix inverted return from xfs_btree_sblock_verify_crc
thermal: hwmon: inline helpers when CONFIG_THERMAL_HWMON is not set
dccp: fool proof ccid_hc_[rt]x_parse_options()
enic: fix checksum validation for IPv6
lib/test_rhashtable: Make test_insert_dup() allocate its hash table dynamically
net: dp83640: expire old TX-skb
net: dsa: Fix lockdep false positive splat
net: dsa: Fix NULL checking in dsa_slave_set_eee()
net: dsa: mv88e6xxx: Fix counting of ATU violations
net: dsa: slave: Don't propagate flag changes on down slave interfaces
net/mlx5e: Force CHECKSUM_UNNECESSARY for short ethernet frames
net: systemport: Fix WoL with password after deep sleep
rds: fix refcount bug in rds_sock_addref
Revert "net: phy: marvell: avoid pause mode on SGMII-to-Copper for 88e151x"
rxrpc: bad unlock balance in rxrpc_recvmsg
sctp: check and update stream->out_curr when allocating stream_out
sctp: walk the list of asoc safely
skge: potential memory corruption in skge_get_regs()
virtio_net: Account for tx bytes and packets on sending xdp_frames
net/mlx5e: FPGA, fix Innova IPsec TX offload data path performance
xfs: eof trim writeback mapping as soon as it is cached
ALSA: compress: Fix stop handling on compressed capture streams
ALSA: usb-audio: Add support for new T+A USB DAC
ALSA: hda - Serialize codec registrations
ALSA: hda/realtek - Fix lose hp_pins for disable auto mute
ALSA: hda/realtek - Use a common helper for hp pin reference
ALSA: hda/realtek - Headset microphone support for System76 darp5
fuse: call pipe_buf_release() under pipe lock
fuse: decrement NR_WRITEBACK_TEMP on the right page
fuse: handle zero sized retrieve correctly
HID: debug: fix the ring buffer implementation
dmaengine: bcm2835: Fix interrupt race on RT
dmaengine: bcm2835: Fix abort of transactions
dmaengine: imx-dma: fix wrong callback invoke
futex: Handle early deadlock return correctly
irqchip/gic-v3-its: Plug allocation race for devices sharing a DevID
usb: phy: am335x: fix race condition in _probe
usb: dwc3: gadget: Handle 0 xfer length for OUT EP
usb: gadget: udc: net2272: Fix bitwise and boolean operations
usb: gadget: musb: fix short isoc packets with inventra dma
staging: speakup: fix tty-operation NULL derefs
scsi: cxlflash: Prevent deadlock when adapter probe fails
scsi: aic94xx: fix module loading
KVM: x86: work around leak of uninitialized stack contents (CVE-2019-7222)
kvm: fix kvm_ioctl_create_device() reference counting (CVE-2019-6974)
KVM: nVMX: unconditionally cancel preemption timer in free_nested (CVE-2019-7221)
cpu/hotplug: Fix "SMT disabled by BIOS" detection for KVM
perf/x86/intel/uncore: Add Node ID mask
x86/MCE: Initialize mce.bank in the case of a fatal error in mce_no_way_out()
perf/core: Don't WARN() for impossible ring-buffer sizes
perf tests evsel-tp-sched: Fix bitwise operator
serial: fix race between flush_to_ldisc and tty_open
serial: 8250_pci: Make PCI class test non fatal
serial: sh-sci: Do not free irqs that have already been freed
cacheinfo: Keep the old value if of_property_read_u32 fails
IB/hfi1: Add limit test for RC/UC send via loopback
perf/x86/intel: Delay memory deallocation until x86_pmu_dead_cpu()
ath9k: dynack: make ewma estimation faster
ath9k: dynack: check da->enabled first in sampling routines
Linux 4.19.21
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
commit
6e0411bdc2
2
Makefile
2
Makefile
@ -1,7 +1,7 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 19
|
||||
SUBLEVEL = 20
|
||||
SUBLEVEL = 21
|
||||
EXTRAVERSION =
|
||||
NAME = "People's Front"
|
||||
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
bootargs = "console=ttyS4,115200 earlyprintk";
|
||||
};
|
||||
|
||||
memory {
|
||||
memory@80000000 {
|
||||
reg = <0x80000000 0x40000000>;
|
||||
};
|
||||
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
bootargs = "earlyprintk";
|
||||
};
|
||||
|
||||
memory {
|
||||
memory@80000000 {
|
||||
reg = <0x80000000 0x20000000>;
|
||||
};
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
bootargs = "console=ttyS4,115200 earlyprintk";
|
||||
};
|
||||
|
||||
memory {
|
||||
memory@80000000 {
|
||||
reg = <0x80000000 0x40000000>;
|
||||
};
|
||||
|
||||
@ -322,4 +322,3 @@
|
||||
&adc {
|
||||
status = "okay";
|
||||
};
|
||||
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
bootargs = "console=ttyS4,115200 earlyprintk";
|
||||
};
|
||||
|
||||
memory {
|
||||
memory@80000000 {
|
||||
reg = <0x80000000 0x20000000>;
|
||||
};
|
||||
|
||||
|
||||
@ -274,20 +274,16 @@
|
||||
read-only;
|
||||
};
|
||||
/*
|
||||
* Between the boot loader and the rootfs is the kernel
|
||||
* in a custom Storlink format flashed from the boot
|
||||
* menu. The rootfs is in squashfs format.
|
||||
* This firmware image contains the kernel catenated
|
||||
* with the squashfs root filesystem. For some reason
|
||||
* this is called "upgrade" on the vendor system.
|
||||
*/
|
||||
partition@1800c0 {
|
||||
label = "rootfs";
|
||||
reg = <0x001800c0 0x01dbff40>;
|
||||
read-only;
|
||||
};
|
||||
partition@1f40000 {
|
||||
partition@40000 {
|
||||
label = "upgrade";
|
||||
reg = <0x01f40000 0x00040000>;
|
||||
reg = <0x00040000 0x01f40000>;
|
||||
read-only;
|
||||
};
|
||||
/* RGDB, Residental Gateway Database? */
|
||||
partition@1f80000 {
|
||||
label = "rgdb";
|
||||
reg = <0x01f80000 0x00040000>;
|
||||
|
||||
@ -477,6 +477,15 @@
|
||||
};
|
||||
|
||||
&gpio1 {
|
||||
gpio-line-names = "", "", "", "",
|
||||
"", "", "", "",
|
||||
"", "hp-amp-shutdown-b", "", "",
|
||||
"", "", "", "",
|
||||
"", "", "", "",
|
||||
"", "", "", "",
|
||||
"", "", "", "",
|
||||
"", "", "", "";
|
||||
|
||||
unused-sd3-wp-gpio {
|
||||
/*
|
||||
* See pinctrl_esdhc1 below for more details on this
|
||||
@ -501,9 +510,6 @@
|
||||
hpa1: amp@60 {
|
||||
compatible = "ti,tpa6130a2";
|
||||
reg = <0x60>;
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&pinctrl_ampgpio>;
|
||||
power-gpio = <&gpio1 9 GPIO_ACTIVE_HIGH>;
|
||||
Vdd-supply = <®_3p3v>;
|
||||
};
|
||||
|
||||
@ -677,7 +683,10 @@
|
||||
};
|
||||
|
||||
&iomuxc {
|
||||
pinctrl_ampgpio: ampgpiogrp {
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&pinctrl_hog>;
|
||||
|
||||
pinctrl_hog: hoggrp {
|
||||
fsl,pins = <
|
||||
MX51_PAD_GPIO1_9__GPIO1_9 0x5e
|
||||
>;
|
||||
|
||||
@ -220,12 +220,15 @@
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
twsi2: i2c@d4025000 {
|
||||
twsi2: i2c@d4031000 {
|
||||
compatible = "mrvl,mmp-twsi";
|
||||
reg = <0xd4025000 0x1000>;
|
||||
interrupts = <58>;
|
||||
reg = <0xd4031000 0x1000>;
|
||||
interrupt-parent = <&intcmux17>;
|
||||
interrupts = <0>;
|
||||
clocks = <&soc_clocks MMP2_CLK_TWSI1>;
|
||||
resets = <&soc_clocks MMP2_CLK_TWSI1>;
|
||||
#address-cells = <1>;
|
||||
#size-cells = <0>;
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
|
||||
@ -33,6 +33,7 @@
|
||||
gpio = <&gpio2 16 GPIO_ACTIVE_HIGH>; /* gpio line 48 */
|
||||
enable-active-high;
|
||||
regulator-boot-on;
|
||||
startup-delay-us = <25000>;
|
||||
};
|
||||
|
||||
vbat: fixedregulator-vbat {
|
||||
|
||||
@ -693,6 +693,21 @@ void smp_send_stop(void)
|
||||
pr_warn("SMP: failed to stop secondary CPUs\n");
|
||||
}
|
||||
|
||||
/* In case panic() and panic() called at the same time on CPU1 and CPU2,
|
||||
* and CPU 1 calls panic_smp_self_stop() before crash_smp_send_stop()
|
||||
* CPU1 can't receive the ipi irqs from CPU2, CPU1 will be always online,
|
||||
* kdump fails. So split out the panic_smp_self_stop() and add
|
||||
* set_cpu_online(smp_processor_id(), false).
|
||||
*/
|
||||
void panic_smp_self_stop(void)
|
||||
{
|
||||
pr_debug("CPU %u will stop doing anything useful since another CPU has paniced\n",
|
||||
smp_processor_id());
|
||||
set_cpu_online(smp_processor_id(), false);
|
||||
while (1)
|
||||
cpu_relax();
|
||||
}
|
||||
|
||||
/*
|
||||
* not supported here
|
||||
*/
|
||||
|
||||
@ -2397,7 +2397,7 @@ static int __init _init(struct omap_hwmod *oh, void *data)
|
||||
* a stub; implementing this properly requires iclk autoidle usecounting in
|
||||
* the clock code. No return value.
|
||||
*/
|
||||
static void __init _setup_iclk_autoidle(struct omap_hwmod *oh)
|
||||
static void _setup_iclk_autoidle(struct omap_hwmod *oh)
|
||||
{
|
||||
struct omap_hwmod_ocp_if *os;
|
||||
|
||||
@ -2428,7 +2428,7 @@ static void __init _setup_iclk_autoidle(struct omap_hwmod *oh)
|
||||
* reset. Returns 0 upon success or a negative error code upon
|
||||
* failure.
|
||||
*/
|
||||
static int __init _setup_reset(struct omap_hwmod *oh)
|
||||
static int _setup_reset(struct omap_hwmod *oh)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -2489,7 +2489,7 @@ static int __init _setup_reset(struct omap_hwmod *oh)
|
||||
*
|
||||
* No return value.
|
||||
*/
|
||||
static void __init _setup_postsetup(struct omap_hwmod *oh)
|
||||
static void _setup_postsetup(struct omap_hwmod *oh)
|
||||
{
|
||||
u8 postsetup_state;
|
||||
|
||||
|
||||
@ -558,7 +558,7 @@ static struct pxa3xx_u2d_platform_data cm_x300_u2d_platform_data = {
|
||||
.exit = cm_x300_u2d_exit,
|
||||
};
|
||||
|
||||
static void cm_x300_init_u2d(void)
|
||||
static void __init cm_x300_init_u2d(void)
|
||||
{
|
||||
pxa3xx_set_u2d_info(&cm_x300_u2d_platform_data);
|
||||
}
|
||||
|
||||
@ -184,7 +184,7 @@ static struct pxafb_mach_info littleton_lcd_info = {
|
||||
.lcd_conn = LCD_COLOR_TFT_16BPP,
|
||||
};
|
||||
|
||||
static void littleton_init_lcd(void)
|
||||
static void __init littleton_init_lcd(void)
|
||||
{
|
||||
pxa_set_fb_info(NULL, &littleton_lcd_info);
|
||||
}
|
||||
|
||||
@ -559,7 +559,7 @@ static struct pxaohci_platform_data zeus_ohci_platform_data = {
|
||||
.flags = ENABLE_PORT_ALL | POWER_SENSE_LOW,
|
||||
};
|
||||
|
||||
static void zeus_register_ohci(void)
|
||||
static void __init zeus_register_ohci(void)
|
||||
{
|
||||
/* Port 2 is shared between host and client interface. */
|
||||
UP2OCR = UP2OCR_HXOE | UP2OCR_HXS | UP2OCR_DMPDE | UP2OCR_DPPDE;
|
||||
|
||||
@ -106,7 +106,23 @@ static inline u64 __raw_readq(const volatile void __iomem *addr)
|
||||
}
|
||||
|
||||
/* IO barriers */
|
||||
#define __iormb() rmb()
|
||||
#define __iormb(v) \
|
||||
({ \
|
||||
unsigned long tmp; \
|
||||
\
|
||||
rmb(); \
|
||||
\
|
||||
/* \
|
||||
* Create a dummy control dependency from the IO read to any \
|
||||
* later instructions. This ensures that a subsequent call to \
|
||||
* udelay() will be ordered due to the ISB in get_cycles(). \
|
||||
*/ \
|
||||
asm volatile("eor %0, %1, %1\n" \
|
||||
"cbnz %0, ." \
|
||||
: "=r" (tmp) : "r" ((unsigned long)(v)) \
|
||||
: "memory"); \
|
||||
})
|
||||
|
||||
#define __iowmb() wmb()
|
||||
|
||||
#define mmiowb() do { } while (0)
|
||||
@ -131,10 +147,10 @@ static inline u64 __raw_readq(const volatile void __iomem *addr)
|
||||
* following Normal memory access. Writes are ordered relative to any prior
|
||||
* Normal memory access.
|
||||
*/
|
||||
#define readb(c) ({ u8 __v = readb_relaxed(c); __iormb(); __v; })
|
||||
#define readw(c) ({ u16 __v = readw_relaxed(c); __iormb(); __v; })
|
||||
#define readl(c) ({ u32 __v = readl_relaxed(c); __iormb(); __v; })
|
||||
#define readq(c) ({ u64 __v = readq_relaxed(c); __iormb(); __v; })
|
||||
#define readb(c) ({ u8 __v = readb_relaxed(c); __iormb(__v); __v; })
|
||||
#define readw(c) ({ u16 __v = readw_relaxed(c); __iormb(__v); __v; })
|
||||
#define readl(c) ({ u32 __v = readl_relaxed(c); __iormb(__v); __v; })
|
||||
#define readq(c) ({ u64 __v = readq_relaxed(c); __iormb(__v); __v; })
|
||||
|
||||
#define writeb(v,c) ({ __iowmb(); writeb_relaxed((v),(c)); })
|
||||
#define writew(v,c) ({ __iowmb(); writew_relaxed((v),(c)); })
|
||||
@ -185,9 +201,9 @@ extern void __iomem *ioremap_cache(phys_addr_t phys_addr, size_t size);
|
||||
/*
|
||||
* io{read,write}{16,32,64}be() macros
|
||||
*/
|
||||
#define ioread16be(p) ({ __u16 __v = be16_to_cpu((__force __be16)__raw_readw(p)); __iormb(); __v; })
|
||||
#define ioread32be(p) ({ __u32 __v = be32_to_cpu((__force __be32)__raw_readl(p)); __iormb(); __v; })
|
||||
#define ioread64be(p) ({ __u64 __v = be64_to_cpu((__force __be64)__raw_readq(p)); __iormb(); __v; })
|
||||
#define ioread16be(p) ({ __u16 __v = be16_to_cpu((__force __be16)__raw_readw(p)); __iormb(__v); __v; })
|
||||
#define ioread32be(p) ({ __u32 __v = be32_to_cpu((__force __be32)__raw_readl(p)); __iormb(__v); __v; })
|
||||
#define ioread64be(p) ({ __u64 __v = be64_to_cpu((__force __be64)__raw_readq(p)); __iormb(__v); __v; })
|
||||
|
||||
#define iowrite16be(v,p) ({ __iowmb(); __raw_writew((__force __u16)cpu_to_be16(v), p); })
|
||||
#define iowrite32be(v,p) ({ __iowmb(); __raw_writel((__force __u32)cpu_to_be32(v), p); })
|
||||
|
||||
@ -130,7 +130,7 @@ struct user_sve_header {
|
||||
|
||||
/* Offset from the start of struct user_sve_header to the register data */
|
||||
#define SVE_PT_REGS_OFFSET \
|
||||
((sizeof(struct sve_context) + (SVE_VQ_BYTES - 1)) \
|
||||
((sizeof(struct user_sve_header) + (SVE_VQ_BYTES - 1)) \
|
||||
/ SVE_VQ_BYTES * SVE_VQ_BYTES)
|
||||
|
||||
/*
|
||||
|
||||
@ -79,7 +79,6 @@
|
||||
.macro mcount_get_lr reg
|
||||
ldr \reg, [x29]
|
||||
ldr \reg, [\reg, #8]
|
||||
mcount_adjust_addr \reg, \reg
|
||||
.endm
|
||||
|
||||
.macro mcount_get_lr_addr reg
|
||||
|
||||
@ -141,6 +141,12 @@
|
||||
#size-cells = <2>;
|
||||
#interrupt-cells = <1>;
|
||||
|
||||
eg20t_phub@2,0,0 {
|
||||
compatible = "pci8086,8801";
|
||||
reg = <0x00020000 0 0 0 0>;
|
||||
intel,eg20t-prefetch = <0>;
|
||||
};
|
||||
|
||||
eg20t_mac@2,0,1 {
|
||||
compatible = "pci8086,8802";
|
||||
reg = <0x00020100 0 0 0 0>;
|
||||
|
||||
@ -4,8 +4,6 @@
|
||||
|
||||
struct jz4740_mmc_platform_data {
|
||||
int gpio_power;
|
||||
int gpio_card_detect;
|
||||
int gpio_read_only;
|
||||
unsigned card_detect_active_low:1;
|
||||
unsigned read_only_active_low:1;
|
||||
unsigned power_active_low:1;
|
||||
|
||||
@ -369,8 +369,8 @@ enum mm_32a_minor_op {
|
||||
mm_ext_op = 0x02c,
|
||||
mm_pool32axf_op = 0x03c,
|
||||
mm_srl32_op = 0x040,
|
||||
mm_srlv32_op = 0x050,
|
||||
mm_sra_op = 0x080,
|
||||
mm_srlv32_op = 0x090,
|
||||
mm_rotr_op = 0x0c0,
|
||||
mm_lwxs_op = 0x118,
|
||||
mm_addu32_op = 0x150,
|
||||
|
||||
@ -43,7 +43,6 @@
|
||||
#include "clock.h"
|
||||
|
||||
/* GPIOs */
|
||||
#define QI_LB60_GPIO_SD_CD JZ_GPIO_PORTD(0)
|
||||
#define QI_LB60_GPIO_SD_VCC_EN_N JZ_GPIO_PORTD(2)
|
||||
|
||||
#define QI_LB60_GPIO_KEYOUT(x) (JZ_GPIO_PORTC(10) + (x))
|
||||
@ -386,12 +385,18 @@ static struct platform_device qi_lb60_gpio_keys = {
|
||||
};
|
||||
|
||||
static struct jz4740_mmc_platform_data qi_lb60_mmc_pdata = {
|
||||
.gpio_card_detect = QI_LB60_GPIO_SD_CD,
|
||||
.gpio_read_only = -1,
|
||||
.gpio_power = QI_LB60_GPIO_SD_VCC_EN_N,
|
||||
.power_active_low = 1,
|
||||
};
|
||||
|
||||
static struct gpiod_lookup_table qi_lb60_mmc_gpio_table = {
|
||||
.dev_id = "jz4740-mmc.0",
|
||||
.table = {
|
||||
GPIO_LOOKUP("GPIOD", 0, "cd", GPIO_ACTIVE_HIGH),
|
||||
{ },
|
||||
},
|
||||
};
|
||||
|
||||
/* beeper */
|
||||
static struct pwm_lookup qi_lb60_pwm_lookup[] = {
|
||||
PWM_LOOKUP("jz4740-pwm", 4, "pwm-beeper", NULL, 0,
|
||||
@ -500,6 +505,7 @@ static int __init qi_lb60_init_platform_devices(void)
|
||||
gpiod_add_lookup_table(&qi_lb60_audio_gpio_table);
|
||||
gpiod_add_lookup_table(&qi_lb60_nand_gpio_table);
|
||||
gpiod_add_lookup_table(&qi_lb60_spigpio_gpio_table);
|
||||
gpiod_add_lookup_table(&qi_lb60_mmc_gpio_table);
|
||||
|
||||
spi_register_board_info(qi_lb60_spi_board_info,
|
||||
ARRAY_SIZE(qi_lb60_spi_board_info));
|
||||
|
||||
@ -38,6 +38,7 @@ choice
|
||||
|
||||
config SOC_MT7620
|
||||
bool "MT7620/8"
|
||||
select CPU_MIPSR2_IRQ_VI
|
||||
select HW_HAS_PCI
|
||||
|
||||
config SOC_MT7621
|
||||
|
||||
@ -4,4 +4,8 @@ obj-y := extable.o tlb.o \
|
||||
|
||||
obj-$(CONFIG_ALIGNMENT_TRAP) += alignment.o
|
||||
obj-$(CONFIG_HIGHMEM) += highmem.o
|
||||
CFLAGS_proc-n13.o += -fomit-frame-pointer
|
||||
|
||||
ifdef CONFIG_FUNCTION_TRACER
|
||||
CFLAGS_REMOVE_proc.o = $(CC_FLAGS_FTRACE)
|
||||
endif
|
||||
CFLAGS_proc.o += -fomit-frame-pointer
|
||||
|
||||
@ -200,7 +200,7 @@ struct fad_crash_memory_ranges {
|
||||
unsigned long long size;
|
||||
};
|
||||
|
||||
extern int is_fadump_boot_memory_area(u64 addr, ulong size);
|
||||
extern int is_fadump_memory_area(u64 addr, ulong size);
|
||||
extern int early_init_dt_scan_fw_dump(unsigned long node,
|
||||
const char *uname, int depth, void *data);
|
||||
extern int fadump_reserve_mem(void);
|
||||
|
||||
@ -63,7 +63,7 @@ static inline int __access_ok(unsigned long addr, unsigned long size,
|
||||
#endif
|
||||
|
||||
#define access_ok(type, addr, size) \
|
||||
(__chk_user_ptr(addr), \
|
||||
(__chk_user_ptr(addr), (void)(type), \
|
||||
__access_ok((__force unsigned long)(addr), (size), get_fs()))
|
||||
|
||||
/*
|
||||
|
||||
@ -118,13 +118,19 @@ int __init early_init_dt_scan_fw_dump(unsigned long node,
|
||||
|
||||
/*
|
||||
* If fadump is registered, check if the memory provided
|
||||
* falls within boot memory area.
|
||||
* falls within boot memory area and reserved memory area.
|
||||
*/
|
||||
int is_fadump_boot_memory_area(u64 addr, ulong size)
|
||||
int is_fadump_memory_area(u64 addr, ulong size)
|
||||
{
|
||||
u64 d_start = fw_dump.reserve_dump_area_start;
|
||||
u64 d_end = d_start + fw_dump.reserve_dump_area_size;
|
||||
|
||||
if (!fw_dump.dump_registered)
|
||||
return 0;
|
||||
|
||||
if (((addr + size) > d_start) && (addr <= d_end))
|
||||
return 1;
|
||||
|
||||
return (addr + size) > RMA_START && addr <= fw_dump.boot_memory_size;
|
||||
}
|
||||
|
||||
|
||||
@ -296,6 +296,10 @@ SECTIONS
|
||||
#ifdef CONFIG_PPC32
|
||||
.data : AT(ADDR(.data) - LOAD_OFFSET) {
|
||||
DATA_DATA
|
||||
#ifdef CONFIG_UBSAN
|
||||
*(.data..Lubsan_data*)
|
||||
*(.data..Lubsan_type*)
|
||||
#endif
|
||||
*(.data.rel*)
|
||||
*(SDATA_MAIN)
|
||||
*(.sdata2)
|
||||
|
||||
@ -543,8 +543,11 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)
|
||||
#ifdef CONFIG_PPC_BOOK3S_64
|
||||
case KVM_CAP_SPAPR_TCE:
|
||||
case KVM_CAP_SPAPR_TCE_64:
|
||||
/* fallthrough */
|
||||
r = 1;
|
||||
break;
|
||||
case KVM_CAP_SPAPR_TCE_VFIO:
|
||||
r = !!cpu_has_feature(CPU_FTR_HVMODE);
|
||||
break;
|
||||
case KVM_CAP_PPC_RTAS:
|
||||
case KVM_CAP_PPC_FIXUP_HCALL:
|
||||
case KVM_CAP_PPC_ENABLE_HCALL:
|
||||
|
||||
@ -221,7 +221,9 @@ static int mm_fault_error(struct pt_regs *regs, unsigned long addr,
|
||||
static bool bad_kernel_fault(bool is_exec, unsigned long error_code,
|
||||
unsigned long address)
|
||||
{
|
||||
if (is_exec && (error_code & (DSISR_NOEXEC_OR_G | DSISR_KEYFAULT))) {
|
||||
/* NX faults set DSISR_PROTFAULT on the 8xx, DSISR_NOEXEC_OR_G on others */
|
||||
if (is_exec && (error_code & (DSISR_NOEXEC_OR_G | DSISR_KEYFAULT |
|
||||
DSISR_PROTFAULT))) {
|
||||
printk_ratelimited(KERN_CRIT "kernel tried to execute"
|
||||
" exec-protected page (%lx) -"
|
||||
"exploit attempt? (uid: %d)\n",
|
||||
|
||||
@ -226,8 +226,13 @@ void isa207_get_mem_weight(u64 *weight)
|
||||
u64 mmcra = mfspr(SPRN_MMCRA);
|
||||
u64 exp = MMCRA_THR_CTR_EXP(mmcra);
|
||||
u64 mantissa = MMCRA_THR_CTR_MANT(mmcra);
|
||||
u64 sier = mfspr(SPRN_SIER);
|
||||
u64 val = (sier & ISA207_SIER_TYPE_MASK) >> ISA207_SIER_TYPE_SHIFT;
|
||||
|
||||
*weight = mantissa << (2 * exp);
|
||||
if (val == 0 || val == 7)
|
||||
*weight = 0;
|
||||
else
|
||||
*weight = mantissa << (2 * exp);
|
||||
}
|
||||
|
||||
int isa207_get_constraint(u64 event, unsigned long *maskp, unsigned long *valp)
|
||||
|
||||
@ -299,7 +299,7 @@ long pnv_pci_ioda2_table_alloc_pages(int nid, __u64 bus_offset,
|
||||
if (alloc_userspace_copy) {
|
||||
offset = 0;
|
||||
uas = pnv_pci_ioda2_table_do_alloc_pages(nid, level_shift,
|
||||
levels, tce_table_size, &offset,
|
||||
tmplevels, tce_table_size, &offset,
|
||||
&total_allocated_uas);
|
||||
if (!uas)
|
||||
goto free_tces_exit;
|
||||
|
||||
@ -272,6 +272,8 @@ int dlpar_detach_node(struct device_node *dn)
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
of_node_put(dn);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -389,8 +389,11 @@ static bool lmb_is_removable(struct drmem_lmb *lmb)
|
||||
phys_addr = lmb->base_addr;
|
||||
|
||||
#ifdef CONFIG_FA_DUMP
|
||||
/* Don't hot-remove memory that falls in fadump boot memory area */
|
||||
if (is_fadump_boot_memory_area(phys_addr, block_sz))
|
||||
/*
|
||||
* Don't hot-remove memory that falls in fadump boot memory area
|
||||
* and memory that is reserved for capturing old kernel memory.
|
||||
*/
|
||||
if (is_fadump_memory_area(phys_addr, block_sz))
|
||||
return false;
|
||||
#endif
|
||||
|
||||
|
||||
@ -147,8 +147,8 @@ struct ica_xcRB {
|
||||
* @cprb_len: CPRB header length [0x0020]
|
||||
* @cprb_ver_id: CPRB version id. [0x04]
|
||||
* @pad_000: Alignment pad bytes
|
||||
* @flags: Admin cmd [0x80] or functional cmd [0x00]
|
||||
* @func_id: Function id / subtype [0x5434]
|
||||
* @flags: Admin bit [0x80], Special bit [0x20]
|
||||
* @func_id: Function id / subtype [0x5434] "T4"
|
||||
* @source_id: Source id [originator id]
|
||||
* @target_id: Target id [usage/ctrl domain id]
|
||||
* @ret_code: Return code
|
||||
|
||||
@ -25,7 +25,6 @@
|
||||
#include <linux/memblock.h>
|
||||
#include <linux/mfd/tmio.h>
|
||||
#include <linux/mmc/host.h>
|
||||
#include <linux/mtd/onenand.h>
|
||||
#include <linux/mtd/physmap.h>
|
||||
#include <linux/platform_data/lv5207lp.h>
|
||||
#include <linux/platform_device.h>
|
||||
|
||||
@ -197,12 +197,17 @@ static inline pte_t pte_mkold(pte_t pte)
|
||||
|
||||
static inline pte_t pte_wrprotect(pte_t pte)
|
||||
{
|
||||
pte_clear_bits(pte, _PAGE_RW);
|
||||
if (likely(pte_get_bits(pte, _PAGE_RW)))
|
||||
pte_clear_bits(pte, _PAGE_RW);
|
||||
else
|
||||
return pte;
|
||||
return(pte_mknewprot(pte));
|
||||
}
|
||||
|
||||
static inline pte_t pte_mkread(pte_t pte)
|
||||
{
|
||||
if (unlikely(pte_get_bits(pte, _PAGE_USER)))
|
||||
return pte;
|
||||
pte_set_bits(pte, _PAGE_USER);
|
||||
return(pte_mknewprot(pte));
|
||||
}
|
||||
@ -221,6 +226,8 @@ static inline pte_t pte_mkyoung(pte_t pte)
|
||||
|
||||
static inline pte_t pte_mkwrite(pte_t pte)
|
||||
{
|
||||
if (unlikely(pte_get_bits(pte, _PAGE_RW)))
|
||||
return pte;
|
||||
pte_set_bits(pte, _PAGE_RW);
|
||||
return(pte_mknewprot(pte));
|
||||
}
|
||||
|
||||
@ -3439,6 +3439,11 @@ static void free_excl_cntrs(int cpu)
|
||||
}
|
||||
|
||||
static void intel_pmu_cpu_dying(int cpu)
|
||||
{
|
||||
fini_debug_store_on_cpu(cpu);
|
||||
}
|
||||
|
||||
static void intel_pmu_cpu_dead(int cpu)
|
||||
{
|
||||
struct cpu_hw_events *cpuc = &per_cpu(cpu_hw_events, cpu);
|
||||
struct intel_shared_regs *pc;
|
||||
@ -3451,8 +3456,6 @@ static void intel_pmu_cpu_dying(int cpu)
|
||||
}
|
||||
|
||||
free_excl_cntrs(cpu);
|
||||
|
||||
fini_debug_store_on_cpu(cpu);
|
||||
}
|
||||
|
||||
static void intel_pmu_sched_task(struct perf_event_context *ctx,
|
||||
@ -3541,6 +3544,7 @@ static __initconst const struct x86_pmu core_pmu = {
|
||||
.cpu_prepare = intel_pmu_cpu_prepare,
|
||||
.cpu_starting = intel_pmu_cpu_starting,
|
||||
.cpu_dying = intel_pmu_cpu_dying,
|
||||
.cpu_dead = intel_pmu_cpu_dead,
|
||||
};
|
||||
|
||||
static struct attribute *intel_pmu_attrs[];
|
||||
@ -3581,6 +3585,8 @@ static __initconst const struct x86_pmu intel_pmu = {
|
||||
.cpu_prepare = intel_pmu_cpu_prepare,
|
||||
.cpu_starting = intel_pmu_cpu_starting,
|
||||
.cpu_dying = intel_pmu_cpu_dying,
|
||||
.cpu_dead = intel_pmu_cpu_dead,
|
||||
|
||||
.guest_get_msrs = intel_guest_get_msrs,
|
||||
.sched_task = intel_pmu_sched_task,
|
||||
};
|
||||
|
||||
@ -1222,6 +1222,8 @@ static struct pci_driver snbep_uncore_pci_driver = {
|
||||
.id_table = snbep_uncore_pci_ids,
|
||||
};
|
||||
|
||||
#define NODE_ID_MASK 0x7
|
||||
|
||||
/*
|
||||
* build pci bus to socket mapping
|
||||
*/
|
||||
@ -1243,7 +1245,7 @@ static int snbep_pci2phy_map_init(int devid, int nodeid_loc, int idmap_loc, bool
|
||||
err = pci_read_config_dword(ubox_dev, nodeid_loc, &config);
|
||||
if (err)
|
||||
break;
|
||||
nodeid = config;
|
||||
nodeid = config & NODE_ID_MASK;
|
||||
/* get the Node ID mapping */
|
||||
err = pci_read_config_dword(ubox_dev, idmap_loc, &config);
|
||||
if (err)
|
||||
|
||||
@ -106,6 +106,9 @@ extern void fpstate_sanitize_xstate(struct fpu *fpu);
|
||||
#define user_insn(insn, output, input...) \
|
||||
({ \
|
||||
int err; \
|
||||
\
|
||||
might_fault(); \
|
||||
\
|
||||
asm volatile(ASM_STAC "\n" \
|
||||
"1:" #insn "\n\t" \
|
||||
"2: " ASM_CLAC "\n" \
|
||||
|
||||
@ -69,7 +69,7 @@ void __init check_bugs(void)
|
||||
* identify_boot_cpu() initialized SMT support information, let the
|
||||
* core code know.
|
||||
*/
|
||||
cpu_smt_check_topology_early();
|
||||
cpu_smt_check_topology();
|
||||
|
||||
if (!IS_ENABLED(CONFIG_SMP)) {
|
||||
pr_info("CPU: ");
|
||||
|
||||
@ -783,6 +783,7 @@ static int mce_no_way_out(struct mce *m, char **msg, unsigned long *validp,
|
||||
quirk_no_way_out(i, m, regs);
|
||||
|
||||
if (mce_severity(m, mca_cfg.tolerant, &tmp, true) >= MCE_PANIC_SEVERITY) {
|
||||
m->bank = i;
|
||||
mce_read_aux(m, i);
|
||||
*msg = tmp;
|
||||
return 1;
|
||||
|
||||
@ -5837,6 +5837,13 @@ static bool svm_cpu_has_accelerated_tpr(void)
|
||||
|
||||
static bool svm_has_emulated_msr(int index)
|
||||
{
|
||||
switch (index) {
|
||||
case MSR_IA32_MCG_EXT_CTL:
|
||||
return false;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@ -27,6 +27,7 @@
|
||||
#include <linux/mm.h>
|
||||
#include <linux/highmem.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/sched/smt.h>
|
||||
#include <linux/moduleparam.h>
|
||||
#include <linux/mod_devicetable.h>
|
||||
#include <linux/trace_events.h>
|
||||
@ -8469,6 +8470,7 @@ static void free_nested(struct vcpu_vmx *vmx)
|
||||
if (!vmx->nested.vmxon && !vmx->nested.smm.vmxon)
|
||||
return;
|
||||
|
||||
hrtimer_cancel(&vmx->nested.preemption_timer);
|
||||
vmx->nested.vmxon = false;
|
||||
vmx->nested.smm.vmxon = false;
|
||||
free_vpid(vmx->nested.vpid02);
|
||||
@ -11128,7 +11130,7 @@ static int vmx_vm_init(struct kvm *kvm)
|
||||
* Warn upon starting the first VM in a potentially
|
||||
* insecure environment.
|
||||
*/
|
||||
if (cpu_smt_control == CPU_SMT_ENABLED)
|
||||
if (sched_smt_active())
|
||||
pr_warn_once(L1TF_MSG_SMT);
|
||||
if (l1tf_vmx_mitigation == VMENTER_L1D_FLUSH_NEVER)
|
||||
pr_warn_once(L1TF_MSG_L1D);
|
||||
|
||||
@ -4904,6 +4904,13 @@ int kvm_read_guest_virt(struct kvm_vcpu *vcpu,
|
||||
{
|
||||
u32 access = (kvm_x86_ops->get_cpl(vcpu) == 3) ? PFERR_USER_MASK : 0;
|
||||
|
||||
/*
|
||||
* FIXME: this should call handle_emulation_failure if X86EMUL_IO_NEEDED
|
||||
* is returned, but our callers are not ready for that and they blindly
|
||||
* call kvm_inject_page_fault. Ensure that they at least do not leak
|
||||
* uninitialized kernel stack memory into cr2 and error code.
|
||||
*/
|
||||
memset(exception, 0, sizeof(*exception));
|
||||
return kvm_read_guest_virt_helper(addr, val, bytes, vcpu, access,
|
||||
exception);
|
||||
}
|
||||
|
||||
@ -50,8 +50,8 @@ static void __init cnb20le_res(u8 bus, u8 slot, u8 func)
|
||||
word1 = read_pci_config_16(bus, slot, func, 0xc0);
|
||||
word2 = read_pci_config_16(bus, slot, func, 0xc2);
|
||||
if (word1 != word2) {
|
||||
res.start = (word1 << 16) | 0x0000;
|
||||
res.end = (word2 << 16) | 0xffff;
|
||||
res.start = ((resource_size_t) word1 << 16) | 0x0000;
|
||||
res.end = ((resource_size_t) word2 << 16) | 0xffff;
|
||||
res.flags = IORESOURCE_MEM;
|
||||
update_res(info, res.start, res.end, res.flags, 0);
|
||||
}
|
||||
|
||||
@ -103,7 +103,7 @@
|
||||
};
|
||||
};
|
||||
|
||||
spi0: spi-master@0d0a0000 {
|
||||
spi0: spi@0d0a0000 {
|
||||
compatible = "cdns,xtfpga-spi";
|
||||
#address-cells = <1>;
|
||||
#size-cells = <0>;
|
||||
|
||||
@ -1084,7 +1084,8 @@ config CRYPTO_AES_TI
|
||||
8 for decryption), this implementation only uses just two S-boxes of
|
||||
256 bytes each, and attempts to eliminate data dependent latencies by
|
||||
prefetching the entire table into the cache at the start of each
|
||||
block.
|
||||
block. Interrupts are also disabled to avoid races where cachelines
|
||||
are evicted when the CPU is interrupted to do something else.
|
||||
|
||||
config CRYPTO_AES_586
|
||||
tristate "AES cipher algorithms (i586)"
|
||||
|
||||
@ -269,6 +269,7 @@ static void aesti_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
|
||||
const u32 *rkp = ctx->key_enc + 4;
|
||||
int rounds = 6 + ctx->key_length / 4;
|
||||
u32 st0[4], st1[4];
|
||||
unsigned long flags;
|
||||
int round;
|
||||
|
||||
st0[0] = ctx->key_enc[0] ^ get_unaligned_le32(in);
|
||||
@ -276,6 +277,12 @@ static void aesti_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
|
||||
st0[2] = ctx->key_enc[2] ^ get_unaligned_le32(in + 8);
|
||||
st0[3] = ctx->key_enc[3] ^ get_unaligned_le32(in + 12);
|
||||
|
||||
/*
|
||||
* Temporarily disable interrupts to avoid races where cachelines are
|
||||
* evicted when the CPU is interrupted to do something else.
|
||||
*/
|
||||
local_irq_save(flags);
|
||||
|
||||
st0[0] ^= __aesti_sbox[ 0] ^ __aesti_sbox[128];
|
||||
st0[1] ^= __aesti_sbox[32] ^ __aesti_sbox[160];
|
||||
st0[2] ^= __aesti_sbox[64] ^ __aesti_sbox[192];
|
||||
@ -300,6 +307,8 @@ static void aesti_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
|
||||
put_unaligned_le32(subshift(st1, 1) ^ rkp[5], out + 4);
|
||||
put_unaligned_le32(subshift(st1, 2) ^ rkp[6], out + 8);
|
||||
put_unaligned_le32(subshift(st1, 3) ^ rkp[7], out + 12);
|
||||
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
static void aesti_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
|
||||
@ -308,6 +317,7 @@ static void aesti_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
|
||||
const u32 *rkp = ctx->key_dec + 4;
|
||||
int rounds = 6 + ctx->key_length / 4;
|
||||
u32 st0[4], st1[4];
|
||||
unsigned long flags;
|
||||
int round;
|
||||
|
||||
st0[0] = ctx->key_dec[0] ^ get_unaligned_le32(in);
|
||||
@ -315,6 +325,12 @@ static void aesti_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
|
||||
st0[2] = ctx->key_dec[2] ^ get_unaligned_le32(in + 8);
|
||||
st0[3] = ctx->key_dec[3] ^ get_unaligned_le32(in + 12);
|
||||
|
||||
/*
|
||||
* Temporarily disable interrupts to avoid races where cachelines are
|
||||
* evicted when the CPU is interrupted to do something else.
|
||||
*/
|
||||
local_irq_save(flags);
|
||||
|
||||
st0[0] ^= __aesti_inv_sbox[ 0] ^ __aesti_inv_sbox[128];
|
||||
st0[1] ^= __aesti_inv_sbox[32] ^ __aesti_inv_sbox[160];
|
||||
st0[2] ^= __aesti_inv_sbox[64] ^ __aesti_inv_sbox[192];
|
||||
@ -339,6 +355,8 @@ static void aesti_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
|
||||
put_unaligned_le32(inv_subshift(st1, 1) ^ rkp[5], out + 4);
|
||||
put_unaligned_le32(inv_subshift(st1, 2) ^ rkp[6], out + 8);
|
||||
put_unaligned_le32(inv_subshift(st1, 3) ^ rkp[7], out + 12);
|
||||
|
||||
local_irq_restore(flags);
|
||||
}
|
||||
|
||||
static struct crypto_alg aes_alg = {
|
||||
|
||||
@ -691,6 +691,8 @@ static void __ghes_panic(struct ghes *ghes)
|
||||
{
|
||||
__ghes_print_estatus(KERN_EMERG, ghes->generic, ghes->estatus);
|
||||
|
||||
ghes_clear_estatus(ghes);
|
||||
|
||||
/* reboot to log the error! */
|
||||
if (!panic_timeout)
|
||||
panic_timeout = ghes_panic_timeout;
|
||||
|
||||
@ -148,6 +148,13 @@ int __init acpi_parse_spcr(bool enable_earlycon, bool enable_console)
|
||||
}
|
||||
|
||||
switch (table->baud_rate) {
|
||||
case 0:
|
||||
/*
|
||||
* SPCR 1.04 defines 0 as a preconfigured state of UART.
|
||||
* Assume firmware or bootloader configures console correctly.
|
||||
*/
|
||||
baud_rate = 0;
|
||||
break;
|
||||
case 3:
|
||||
baud_rate = 9600;
|
||||
break;
|
||||
@ -196,6 +203,10 @@ int __init acpi_parse_spcr(bool enable_earlycon, bool enable_console)
|
||||
* UART so don't attempt to change to the baud rate state
|
||||
* in the table because driver cannot calculate the dividers
|
||||
*/
|
||||
baud_rate = 0;
|
||||
}
|
||||
|
||||
if (!baud_rate) {
|
||||
snprintf(opts, sizeof(opts), "%s,%s,0x%llx", uart, iotype,
|
||||
table->serial_port.address);
|
||||
} else {
|
||||
|
||||
@ -895,7 +895,9 @@ static int sata_rcar_probe(struct platform_device *pdev)
|
||||
int ret = 0;
|
||||
|
||||
irq = platform_get_irq(pdev, 0);
|
||||
if (irq <= 0)
|
||||
if (irq < 0)
|
||||
return irq;
|
||||
if (!irq)
|
||||
return -EINVAL;
|
||||
|
||||
priv = devm_kzalloc(dev, sizeof(struct sata_rcar_priv), GFP_KERNEL);
|
||||
|
||||
@ -614,8 +614,10 @@ static void remove_probe_files(struct bus_type *bus)
|
||||
static ssize_t uevent_store(struct device_driver *drv, const char *buf,
|
||||
size_t count)
|
||||
{
|
||||
kobject_synth_uevent(&drv->p->kobj, buf, count);
|
||||
return count;
|
||||
int rc;
|
||||
|
||||
rc = kobject_synth_uevent(&drv->p->kobj, buf, count);
|
||||
return rc ? rc : count;
|
||||
}
|
||||
static DRIVER_ATTR_WO(uevent);
|
||||
|
||||
@ -831,8 +833,10 @@ static void klist_devices_put(struct klist_node *n)
|
||||
static ssize_t bus_uevent_store(struct bus_type *bus,
|
||||
const char *buf, size_t count)
|
||||
{
|
||||
kobject_synth_uevent(&bus->p->subsys.kobj, buf, count);
|
||||
return count;
|
||||
int rc;
|
||||
|
||||
rc = kobject_synth_uevent(&bus->p->subsys.kobj, buf, count);
|
||||
return rc ? rc : count;
|
||||
}
|
||||
static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
|
||||
|
||||
|
||||
@ -79,8 +79,7 @@ static void cache_size(struct cacheinfo *this_leaf, struct device_node *np)
|
||||
ct_idx = get_cacheinfo_idx(this_leaf->type);
|
||||
propname = cache_type_info[ct_idx].size_prop;
|
||||
|
||||
if (of_property_read_u32(np, propname, &this_leaf->size))
|
||||
this_leaf->size = 0;
|
||||
of_property_read_u32(np, propname, &this_leaf->size);
|
||||
}
|
||||
|
||||
/* not cache_line_size() because that's a macro in include/linux/cache.h */
|
||||
@ -114,8 +113,7 @@ static void cache_nr_sets(struct cacheinfo *this_leaf, struct device_node *np)
|
||||
ct_idx = get_cacheinfo_idx(this_leaf->type);
|
||||
propname = cache_type_info[ct_idx].nr_sets_prop;
|
||||
|
||||
if (of_property_read_u32(np, propname, &this_leaf->number_of_sets))
|
||||
this_leaf->number_of_sets = 0;
|
||||
of_property_read_u32(np, propname, &this_leaf->number_of_sets);
|
||||
}
|
||||
|
||||
static void cache_associativity(struct cacheinfo *this_leaf)
|
||||
|
||||
@ -1067,8 +1067,14 @@ out:
|
||||
static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
{
|
||||
if (kobject_synth_uevent(&dev->kobj, buf, count))
|
||||
int rc;
|
||||
|
||||
rc = kobject_synth_uevent(&dev->kobj, buf, count);
|
||||
|
||||
if (rc) {
|
||||
dev_err(dev, "uevent: failed to send synthetic uevent\n");
|
||||
return rc;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
@ -926,9 +926,6 @@ static void __device_release_driver(struct device *dev, struct device *parent)
|
||||
|
||||
drv = dev->driver;
|
||||
if (drv) {
|
||||
if (driver_allows_async_probing(drv))
|
||||
async_synchronize_full();
|
||||
|
||||
while (device_links_busy(dev)) {
|
||||
device_unlock(dev);
|
||||
if (parent && dev->bus->need_parent_lock)
|
||||
@ -1034,6 +1031,9 @@ void driver_detach(struct device_driver *drv)
|
||||
struct device_private *dev_prv;
|
||||
struct device *dev;
|
||||
|
||||
if (driver_allows_async_probing(drv))
|
||||
async_synchronize_full();
|
||||
|
||||
for (;;) {
|
||||
spin_lock(&drv->p->klist_devices.k_lock);
|
||||
if (list_empty(&drv->p->klist_devices.k_list)) {
|
||||
|
||||
@ -24,8 +24,14 @@ struct devres_node {
|
||||
|
||||
struct devres {
|
||||
struct devres_node node;
|
||||
/* -- 3 pointers */
|
||||
unsigned long long data[]; /* guarantee ull alignment */
|
||||
/*
|
||||
* Some archs want to perform DMA into kmalloc caches
|
||||
* and need a guaranteed alignment larger than
|
||||
* the alignment of a 64-bit integer.
|
||||
* Thus we use ARCH_KMALLOC_MINALIGN here and get exactly the same
|
||||
* buffer alignment as if it was allocated by plain kmalloc().
|
||||
*/
|
||||
u8 __aligned(ARCH_KMALLOC_MINALIGN) data[];
|
||||
};
|
||||
|
||||
struct devres_group {
|
||||
|
||||
@ -668,14 +668,15 @@ drbd_set_role(struct drbd_device *const device, enum drbd_role new_role, int for
|
||||
if (rv == SS_TWO_PRIMARIES) {
|
||||
/* Maybe the peer is detected as dead very soon...
|
||||
retry at most once more in this case. */
|
||||
int timeo;
|
||||
rcu_read_lock();
|
||||
nc = rcu_dereference(connection->net_conf);
|
||||
timeo = nc ? (nc->ping_timeo + 1) * HZ / 10 : 1;
|
||||
rcu_read_unlock();
|
||||
schedule_timeout_interruptible(timeo);
|
||||
if (try < max_tries)
|
||||
if (try < max_tries) {
|
||||
int timeo;
|
||||
try = max_tries - 1;
|
||||
rcu_read_lock();
|
||||
nc = rcu_dereference(connection->net_conf);
|
||||
timeo = nc ? (nc->ping_timeo + 1) * HZ / 10 : 1;
|
||||
rcu_read_unlock();
|
||||
schedule_timeout_interruptible(timeo);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (rv < SS_SUCCESS) {
|
||||
|
||||
@ -3364,7 +3364,7 @@ static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device,
|
||||
enum drbd_conns rv = C_MASK;
|
||||
enum drbd_disk_state mydisk;
|
||||
struct net_conf *nc;
|
||||
int hg, rule_nr, rr_conflict, tentative;
|
||||
int hg, rule_nr, rr_conflict, tentative, always_asbp;
|
||||
|
||||
mydisk = device->state.disk;
|
||||
if (mydisk == D_NEGOTIATING)
|
||||
@ -3415,8 +3415,12 @@ static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device,
|
||||
|
||||
rcu_read_lock();
|
||||
nc = rcu_dereference(peer_device->connection->net_conf);
|
||||
always_asbp = nc->always_asbp;
|
||||
rr_conflict = nc->rr_conflict;
|
||||
tentative = nc->tentative;
|
||||
rcu_read_unlock();
|
||||
|
||||
if (hg == 100 || (hg == -100 && nc->always_asbp)) {
|
||||
if (hg == 100 || (hg == -100 && always_asbp)) {
|
||||
int pcount = (device->state.role == R_PRIMARY)
|
||||
+ (peer_role == R_PRIMARY);
|
||||
int forced = (hg == -100);
|
||||
@ -3455,9 +3459,6 @@ static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device,
|
||||
"Sync from %s node\n",
|
||||
(hg < 0) ? "peer" : "this");
|
||||
}
|
||||
rr_conflict = nc->rr_conflict;
|
||||
tentative = nc->tentative;
|
||||
rcu_read_unlock();
|
||||
|
||||
if (hg == -100) {
|
||||
/* FIXME this log message is not correct if we end up here
|
||||
@ -4141,7 +4142,7 @@ static int receive_uuids(struct drbd_connection *connection, struct packet_info
|
||||
kfree(device->p_uuid);
|
||||
device->p_uuid = p_uuid;
|
||||
|
||||
if (device->state.conn < C_CONNECTED &&
|
||||
if ((device->state.conn < C_CONNECTED || device->state.pdsk == D_DISKLESS) &&
|
||||
device->state.disk < D_INCONSISTENT &&
|
||||
device->state.role == R_PRIMARY &&
|
||||
(device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) {
|
||||
|
||||
@ -45,6 +45,8 @@ MODULE_VERSION(DRV_MODULE_VERSION);
|
||||
#define WAITING_FOR_GEN_CMD 0x04
|
||||
#define WAITING_FOR_ANY -1
|
||||
|
||||
#define VDC_MAX_RETRIES 10
|
||||
|
||||
static struct workqueue_struct *sunvdc_wq;
|
||||
|
||||
struct vdc_req_entry {
|
||||
@ -431,6 +433,7 @@ static int __vdc_tx_trigger(struct vdc_port *port)
|
||||
.end_idx = dr->prod,
|
||||
};
|
||||
int err, delay;
|
||||
int retries = 0;
|
||||
|
||||
hdr.seq = dr->snd_nxt;
|
||||
delay = 1;
|
||||
@ -443,6 +446,8 @@ static int __vdc_tx_trigger(struct vdc_port *port)
|
||||
udelay(delay);
|
||||
if ((delay <<= 1) > 128)
|
||||
delay = 128;
|
||||
if (retries++ > VDC_MAX_RETRIES)
|
||||
break;
|
||||
} while (err == -EAGAIN);
|
||||
|
||||
if (err == -ENOTCONN)
|
||||
|
||||
@ -1026,7 +1026,11 @@ static void floppy_release(struct gendisk *disk, fmode_t mode)
|
||||
struct swim3 __iomem *sw = fs->swim3;
|
||||
|
||||
mutex_lock(&swim3_mutex);
|
||||
if (fs->ref_count > 0 && --fs->ref_count == 0) {
|
||||
if (fs->ref_count > 0)
|
||||
--fs->ref_count;
|
||||
else if (fs->ref_count == -1)
|
||||
fs->ref_count = 0;
|
||||
if (fs->ref_count == 0) {
|
||||
swim3_action(fs, MOTOR_OFF);
|
||||
out_8(&sw->control_bic, 0xff);
|
||||
swim3_select(fs, RELAX);
|
||||
|
||||
@ -907,6 +907,10 @@ static int bcm_get_resources(struct bcm_device *dev)
|
||||
|
||||
dev->clk = devm_clk_get(dev->dev, NULL);
|
||||
|
||||
/* Handle deferred probing */
|
||||
if (dev->clk == ERR_PTR(-EPROBE_DEFER))
|
||||
return PTR_ERR(dev->clk);
|
||||
|
||||
dev->device_wakeup = devm_gpiod_get_optional(dev->dev, "device-wakeup",
|
||||
GPIOD_OUT_LOW);
|
||||
if (IS_ERR(dev->device_wakeup))
|
||||
|
||||
@ -889,6 +889,7 @@ static void __exit exit_gdrom(void)
|
||||
platform_device_unregister(pd);
|
||||
platform_driver_unregister(&gdrom_driver);
|
||||
kfree(gd.toc);
|
||||
kfree(gd.cd_info);
|
||||
}
|
||||
|
||||
module_init(init_gdrom);
|
||||
|
||||
@ -73,27 +73,32 @@ static void __init clk_boston_setup(struct device_node *np)
|
||||
hw = clk_hw_register_fixed_rate(NULL, "input", NULL, 0, in_freq);
|
||||
if (IS_ERR(hw)) {
|
||||
pr_err("failed to register input clock: %ld\n", PTR_ERR(hw));
|
||||
return;
|
||||
goto error;
|
||||
}
|
||||
onecell->hws[BOSTON_CLK_INPUT] = hw;
|
||||
|
||||
hw = clk_hw_register_fixed_rate(NULL, "sys", "input", 0, sys_freq);
|
||||
if (IS_ERR(hw)) {
|
||||
pr_err("failed to register sys clock: %ld\n", PTR_ERR(hw));
|
||||
return;
|
||||
goto error;
|
||||
}
|
||||
onecell->hws[BOSTON_CLK_SYS] = hw;
|
||||
|
||||
hw = clk_hw_register_fixed_rate(NULL, "cpu", "input", 0, cpu_freq);
|
||||
if (IS_ERR(hw)) {
|
||||
pr_err("failed to register cpu clock: %ld\n", PTR_ERR(hw));
|
||||
return;
|
||||
goto error;
|
||||
}
|
||||
onecell->hws[BOSTON_CLK_CPU] = hw;
|
||||
|
||||
err = of_clk_add_hw_provider(np, of_clk_hw_onecell_get, onecell);
|
||||
if (err)
|
||||
pr_err("failed to add DT provider: %d\n", err);
|
||||
|
||||
return;
|
||||
|
||||
error:
|
||||
kfree(onecell);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -17,6 +17,8 @@
|
||||
|
||||
#include "clk.h"
|
||||
|
||||
#define CCDR 0x4
|
||||
#define BM_CCM_CCDR_MMDC_CH0_MASK (1 << 17)
|
||||
#define CCSR 0xc
|
||||
#define BM_CCSR_PLL1_SW_CLK_SEL (1 << 2)
|
||||
#define CACRR 0x10
|
||||
@ -409,6 +411,10 @@ static void __init imx6sl_clocks_init(struct device_node *ccm_node)
|
||||
clks[IMX6SL_CLK_USDHC3] = imx_clk_gate2("usdhc3", "usdhc3_podf", base + 0x80, 6);
|
||||
clks[IMX6SL_CLK_USDHC4] = imx_clk_gate2("usdhc4", "usdhc4_podf", base + 0x80, 8);
|
||||
|
||||
/* Ensure the MMDC CH0 handshake is bypassed */
|
||||
writel_relaxed(readl_relaxed(base + CCDR) |
|
||||
BM_CCM_CCDR_MMDC_CH0_MASK, base + CCDR);
|
||||
|
||||
imx_check_clocks(clks, ARRAY_SIZE(clks));
|
||||
|
||||
clk_data.clks = clks;
|
||||
|
||||
@ -583,7 +583,7 @@ static struct clk_regmap meson8b_cpu_scale_div = {
|
||||
.data = &(struct clk_regmap_div_data){
|
||||
.offset = HHI_SYS_CPU_CLK_CNTL1,
|
||||
.shift = 20,
|
||||
.width = 9,
|
||||
.width = 10,
|
||||
.table = cpu_scale_table,
|
||||
.flags = CLK_DIVIDER_ALLOW_ZERO,
|
||||
},
|
||||
@ -596,20 +596,27 @@ static struct clk_regmap meson8b_cpu_scale_div = {
|
||||
},
|
||||
};
|
||||
|
||||
static u32 mux_table_cpu_scale_out_sel[] = { 0, 1, 3 };
|
||||
static struct clk_regmap meson8b_cpu_scale_out_sel = {
|
||||
.data = &(struct clk_regmap_mux_data){
|
||||
.offset = HHI_SYS_CPU_CLK_CNTL0,
|
||||
.mask = 0x3,
|
||||
.shift = 2,
|
||||
.table = mux_table_cpu_scale_out_sel,
|
||||
},
|
||||
.hw.init = &(struct clk_init_data){
|
||||
.name = "cpu_scale_out_sel",
|
||||
.ops = &clk_regmap_mux_ro_ops,
|
||||
/*
|
||||
* NOTE: We are skipping the parent with value 0x2 (which is
|
||||
* "cpu_div3") because it results in a duty cycle of 33% which
|
||||
* makes the system unstable and can result in a lockup of the
|
||||
* whole system.
|
||||
*/
|
||||
.parent_names = (const char *[]) { "cpu_in_sel",
|
||||
"cpu_div2",
|
||||
"cpu_div3",
|
||||
"cpu_scale_div" },
|
||||
.num_parents = 4,
|
||||
.num_parents = 3,
|
||||
.flags = CLK_SET_RATE_PARENT,
|
||||
},
|
||||
};
|
||||
@ -627,7 +634,8 @@ static struct clk_regmap meson8b_cpu_clk = {
|
||||
"cpu_scale_out_sel" },
|
||||
.num_parents = 2,
|
||||
.flags = (CLK_SET_RATE_PARENT |
|
||||
CLK_SET_RATE_NO_REPARENT),
|
||||
CLK_SET_RATE_NO_REPARENT |
|
||||
CLK_IS_CRITICAL),
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
@ -366,10 +366,10 @@ static SUNXI_CCU_MP_WITH_MUX_GATE(spi1_clk, "spi1", mod0_default_parents, 0x0a4,
|
||||
static const char * const i2s_parents[] = { "pll-audio-8x", "pll-audio-4x",
|
||||
"pll-audio-2x", "pll-audio" };
|
||||
static SUNXI_CCU_MUX_WITH_GATE(i2s0_clk, "i2s0", i2s_parents,
|
||||
0x0b0, 16, 2, BIT(31), 0);
|
||||
0x0b0, 16, 2, BIT(31), CLK_SET_RATE_PARENT);
|
||||
|
||||
static SUNXI_CCU_MUX_WITH_GATE(i2s1_clk, "i2s1", i2s_parents,
|
||||
0x0b4, 16, 2, BIT(31), 0);
|
||||
0x0b4, 16, 2, BIT(31), CLK_SET_RATE_PARENT);
|
||||
|
||||
/* TODO: the parent for most of the USB clocks is not known */
|
||||
static SUNXI_CCU_GATE(usb_phy0_clk, "usb-phy0", "osc24M",
|
||||
@ -446,7 +446,7 @@ static SUNXI_CCU_M_WITH_GATE(ve_clk, "ve", "pll-ve",
|
||||
static SUNXI_CCU_GATE(ac_dig_clk, "ac-dig", "pll-audio",
|
||||
0x140, BIT(31), CLK_SET_RATE_PARENT);
|
||||
static SUNXI_CCU_GATE(ac_dig_4x_clk, "ac-dig-4x", "pll-audio-4x",
|
||||
0x140, BIT(30), 0);
|
||||
0x140, BIT(30), CLK_SET_RATE_PARENT);
|
||||
static SUNXI_CCU_GATE(avs_clk, "avs", "osc24M",
|
||||
0x144, BIT(31), 0);
|
||||
|
||||
|
||||
@ -167,6 +167,7 @@ static int __init bl_idle_init(void)
|
||||
{
|
||||
int ret;
|
||||
struct device_node *root = of_find_node_by_path("/");
|
||||
const struct of_device_id *match_id;
|
||||
|
||||
if (!root)
|
||||
return -ENODEV;
|
||||
@ -174,7 +175,11 @@ static int __init bl_idle_init(void)
|
||||
/*
|
||||
* Initialize the driver just for a compliant set of machines
|
||||
*/
|
||||
if (!of_match_node(compatible_machine_match, root))
|
||||
match_id = of_match_node(compatible_machine_match, root);
|
||||
|
||||
of_node_put(root);
|
||||
|
||||
if (!match_id)
|
||||
return -ENODEV;
|
||||
|
||||
if (!mcpm_is_available())
|
||||
|
||||
@ -556,7 +556,7 @@ static int cryp_set_dma_transfer(struct cryp_ctx *ctx,
|
||||
desc = dmaengine_prep_slave_sg(channel,
|
||||
ctx->device->dma.sg_src,
|
||||
ctx->device->dma.sg_src_len,
|
||||
direction, DMA_CTRL_ACK);
|
||||
DMA_MEM_TO_DEV, DMA_CTRL_ACK);
|
||||
break;
|
||||
|
||||
case DMA_FROM_DEVICE:
|
||||
@ -580,7 +580,7 @@ static int cryp_set_dma_transfer(struct cryp_ctx *ctx,
|
||||
desc = dmaengine_prep_slave_sg(channel,
|
||||
ctx->device->dma.sg_dst,
|
||||
ctx->device->dma.sg_dst_len,
|
||||
direction,
|
||||
DMA_DEV_TO_MEM,
|
||||
DMA_CTRL_ACK |
|
||||
DMA_PREP_INTERRUPT);
|
||||
|
||||
|
||||
@ -166,7 +166,7 @@ static int hash_set_dma_transfer(struct hash_ctx *ctx, struct scatterlist *sg,
|
||||
__func__);
|
||||
desc = dmaengine_prep_slave_sg(channel,
|
||||
ctx->device->dma.sg, ctx->device->dma.sg_len,
|
||||
direction, DMA_CTRL_ACK | DMA_PREP_INTERRUPT);
|
||||
DMA_MEM_TO_DEV, DMA_CTRL_ACK | DMA_PREP_INTERRUPT);
|
||||
if (!desc) {
|
||||
dev_err(ctx->device->dev,
|
||||
"%s: dmaengine_prep_slave_sg() failed!\n", __func__);
|
||||
|
||||
@ -415,38 +415,32 @@ static void bcm2835_dma_fill_cb_chain_with_sg(
|
||||
}
|
||||
}
|
||||
|
||||
static int bcm2835_dma_abort(void __iomem *chan_base)
|
||||
static int bcm2835_dma_abort(struct bcm2835_chan *c)
|
||||
{
|
||||
unsigned long cs;
|
||||
void __iomem *chan_base = c->chan_base;
|
||||
long int timeout = 10000;
|
||||
|
||||
cs = readl(chan_base + BCM2835_DMA_CS);
|
||||
if (!(cs & BCM2835_DMA_ACTIVE))
|
||||
/*
|
||||
* A zero control block address means the channel is idle.
|
||||
* (The ACTIVE flag in the CS register is not a reliable indicator.)
|
||||
*/
|
||||
if (!readl(chan_base + BCM2835_DMA_ADDR))
|
||||
return 0;
|
||||
|
||||
/* Write 0 to the active bit - Pause the DMA */
|
||||
writel(0, chan_base + BCM2835_DMA_CS);
|
||||
|
||||
/* Wait for any current AXI transfer to complete */
|
||||
while ((cs & BCM2835_DMA_ISPAUSED) && --timeout) {
|
||||
while ((readl(chan_base + BCM2835_DMA_CS) &
|
||||
BCM2835_DMA_WAITING_FOR_WRITES) && --timeout)
|
||||
cpu_relax();
|
||||
cs = readl(chan_base + BCM2835_DMA_CS);
|
||||
}
|
||||
|
||||
/* We'll un-pause when we set of our next DMA */
|
||||
/* Peripheral might be stuck and fail to signal AXI write responses */
|
||||
if (!timeout)
|
||||
return -ETIMEDOUT;
|
||||
|
||||
if (!(cs & BCM2835_DMA_ACTIVE))
|
||||
return 0;
|
||||
|
||||
/* Terminate the control block chain */
|
||||
writel(0, chan_base + BCM2835_DMA_NEXTCB);
|
||||
|
||||
/* Abort the whole DMA */
|
||||
writel(BCM2835_DMA_ABORT | BCM2835_DMA_ACTIVE,
|
||||
chan_base + BCM2835_DMA_CS);
|
||||
dev_err(c->vc.chan.device->dev,
|
||||
"failed to complete outstanding writes\n");
|
||||
|
||||
writel(BCM2835_DMA_RESET, chan_base + BCM2835_DMA_CS);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -485,8 +479,15 @@ static irqreturn_t bcm2835_dma_callback(int irq, void *data)
|
||||
|
||||
spin_lock_irqsave(&c->vc.lock, flags);
|
||||
|
||||
/* Acknowledge interrupt */
|
||||
writel(BCM2835_DMA_INT, c->chan_base + BCM2835_DMA_CS);
|
||||
/*
|
||||
* Clear the INT flag to receive further interrupts. Keep the channel
|
||||
* active in case the descriptor is cyclic or in case the client has
|
||||
* already terminated the descriptor and issued a new one. (May happen
|
||||
* if this IRQ handler is threaded.) If the channel is finished, it
|
||||
* will remain idle despite the ACTIVE flag being set.
|
||||
*/
|
||||
writel(BCM2835_DMA_INT | BCM2835_DMA_ACTIVE,
|
||||
c->chan_base + BCM2835_DMA_CS);
|
||||
|
||||
d = c->desc;
|
||||
|
||||
@ -494,11 +495,7 @@ static irqreturn_t bcm2835_dma_callback(int irq, void *data)
|
||||
if (d->cyclic) {
|
||||
/* call the cyclic callback */
|
||||
vchan_cyclic_callback(&d->vd);
|
||||
|
||||
/* Keep the DMA engine running */
|
||||
writel(BCM2835_DMA_ACTIVE,
|
||||
c->chan_base + BCM2835_DMA_CS);
|
||||
} else {
|
||||
} else if (!readl(c->chan_base + BCM2835_DMA_ADDR)) {
|
||||
vchan_cookie_complete(&c->desc->vd);
|
||||
bcm2835_dma_start_desc(c);
|
||||
}
|
||||
@ -796,7 +793,6 @@ static int bcm2835_dma_terminate_all(struct dma_chan *chan)
|
||||
struct bcm2835_chan *c = to_bcm2835_dma_chan(chan);
|
||||
struct bcm2835_dmadev *d = to_bcm2835_dma_dev(c->vc.chan.device);
|
||||
unsigned long flags;
|
||||
int timeout = 10000;
|
||||
LIST_HEAD(head);
|
||||
|
||||
spin_lock_irqsave(&c->vc.lock, flags);
|
||||
@ -806,27 +802,11 @@ static int bcm2835_dma_terminate_all(struct dma_chan *chan)
|
||||
list_del_init(&c->node);
|
||||
spin_unlock(&d->lock);
|
||||
|
||||
/*
|
||||
* Stop DMA activity: we assume the callback will not be called
|
||||
* after bcm_dma_abort() returns (even if it does, it will see
|
||||
* c->desc is NULL and exit.)
|
||||
*/
|
||||
/* stop DMA activity */
|
||||
if (c->desc) {
|
||||
vchan_terminate_vdesc(&c->desc->vd);
|
||||
c->desc = NULL;
|
||||
bcm2835_dma_abort(c->chan_base);
|
||||
|
||||
/* Wait for stopping */
|
||||
while (--timeout) {
|
||||
if (!(readl(c->chan_base + BCM2835_DMA_CS) &
|
||||
BCM2835_DMA_ACTIVE))
|
||||
break;
|
||||
|
||||
cpu_relax();
|
||||
}
|
||||
|
||||
if (!timeout)
|
||||
dev_err(d->ddev.dev, "DMA transfer could not be terminated\n");
|
||||
bcm2835_dma_abort(c);
|
||||
}
|
||||
|
||||
vchan_get_all_descriptors(&c->vc, &head);
|
||||
|
||||
@ -617,7 +617,7 @@ static void imxdma_tasklet(unsigned long data)
|
||||
{
|
||||
struct imxdma_channel *imxdmac = (void *)data;
|
||||
struct imxdma_engine *imxdma = imxdmac->imxdma;
|
||||
struct imxdma_desc *desc;
|
||||
struct imxdma_desc *desc, *next_desc;
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&imxdma->lock, flags);
|
||||
@ -647,10 +647,10 @@ static void imxdma_tasklet(unsigned long data)
|
||||
list_move_tail(imxdmac->ld_active.next, &imxdmac->ld_free);
|
||||
|
||||
if (!list_empty(&imxdmac->ld_queue)) {
|
||||
desc = list_first_entry(&imxdmac->ld_queue, struct imxdma_desc,
|
||||
node);
|
||||
next_desc = list_first_entry(&imxdmac->ld_queue,
|
||||
struct imxdma_desc, node);
|
||||
list_move_tail(imxdmac->ld_queue.next, &imxdmac->ld_active);
|
||||
if (imxdma_xfer_desc(desc) < 0)
|
||||
if (imxdma_xfer_desc(next_desc) < 0)
|
||||
dev_warn(imxdma->dev, "%s: channel: %d couldn't xfer desc\n",
|
||||
__func__, imxdmac->channel);
|
||||
}
|
||||
|
||||
@ -163,7 +163,7 @@ struct zynqmp_dma_desc_ll {
|
||||
u32 ctrl;
|
||||
u64 nxtdscraddr;
|
||||
u64 rsvd;
|
||||
}; __aligned(64)
|
||||
};
|
||||
|
||||
/**
|
||||
* struct zynqmp_dma_desc_sw - Per Transaction structure
|
||||
|
||||
@ -318,7 +318,12 @@ EXPORT_SYMBOL_GPL(efivar_variable_is_removable);
|
||||
static efi_status_t
|
||||
check_var_size(u32 attributes, unsigned long size)
|
||||
{
|
||||
const struct efivar_operations *fops = __efivars->ops;
|
||||
const struct efivar_operations *fops;
|
||||
|
||||
if (!__efivars)
|
||||
return EFI_UNSUPPORTED;
|
||||
|
||||
fops = __efivars->ops;
|
||||
|
||||
if (!fops->query_variable_store)
|
||||
return EFI_UNSUPPORTED;
|
||||
@ -329,7 +334,12 @@ check_var_size(u32 attributes, unsigned long size)
|
||||
static efi_status_t
|
||||
check_var_size_nonblocking(u32 attributes, unsigned long size)
|
||||
{
|
||||
const struct efivar_operations *fops = __efivars->ops;
|
||||
const struct efivar_operations *fops;
|
||||
|
||||
if (!__efivars)
|
||||
return EFI_UNSUPPORTED;
|
||||
|
||||
fops = __efivars->ops;
|
||||
|
||||
if (!fops->query_variable_store)
|
||||
return EFI_UNSUPPORTED;
|
||||
@ -429,13 +439,18 @@ static void dup_variable_bug(efi_char16_t *str16, efi_guid_t *vendor_guid,
|
||||
int efivar_init(int (*func)(efi_char16_t *, efi_guid_t, unsigned long, void *),
|
||||
void *data, bool duplicates, struct list_head *head)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
const struct efivar_operations *ops;
|
||||
unsigned long variable_name_size = 1024;
|
||||
efi_char16_t *variable_name;
|
||||
efi_status_t status;
|
||||
efi_guid_t vendor_guid;
|
||||
int err = 0;
|
||||
|
||||
if (!__efivars)
|
||||
return -EFAULT;
|
||||
|
||||
ops = __efivars->ops;
|
||||
|
||||
variable_name = kzalloc(variable_name_size, GFP_KERNEL);
|
||||
if (!variable_name) {
|
||||
printk(KERN_ERR "efivars: Memory allocation failed.\n");
|
||||
@ -583,12 +598,14 @@ static void efivar_entry_list_del_unlock(struct efivar_entry *entry)
|
||||
*/
|
||||
int __efivar_entry_delete(struct efivar_entry *entry)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
efi_status_t status;
|
||||
|
||||
status = ops->set_variable(entry->var.VariableName,
|
||||
&entry->var.VendorGuid,
|
||||
0, 0, NULL);
|
||||
if (!__efivars)
|
||||
return -EINVAL;
|
||||
|
||||
status = __efivars->ops->set_variable(entry->var.VariableName,
|
||||
&entry->var.VendorGuid,
|
||||
0, 0, NULL);
|
||||
|
||||
return efi_status_to_err(status);
|
||||
}
|
||||
@ -607,12 +624,17 @@ EXPORT_SYMBOL_GPL(__efivar_entry_delete);
|
||||
*/
|
||||
int efivar_entry_delete(struct efivar_entry *entry)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
const struct efivar_operations *ops;
|
||||
efi_status_t status;
|
||||
|
||||
if (down_interruptible(&efivars_lock))
|
||||
return -EINTR;
|
||||
|
||||
if (!__efivars) {
|
||||
up(&efivars_lock);
|
||||
return -EINVAL;
|
||||
}
|
||||
ops = __efivars->ops;
|
||||
status = ops->set_variable(entry->var.VariableName,
|
||||
&entry->var.VendorGuid,
|
||||
0, 0, NULL);
|
||||
@ -650,13 +672,19 @@ EXPORT_SYMBOL_GPL(efivar_entry_delete);
|
||||
int efivar_entry_set(struct efivar_entry *entry, u32 attributes,
|
||||
unsigned long size, void *data, struct list_head *head)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
const struct efivar_operations *ops;
|
||||
efi_status_t status;
|
||||
efi_char16_t *name = entry->var.VariableName;
|
||||
efi_guid_t vendor = entry->var.VendorGuid;
|
||||
|
||||
if (down_interruptible(&efivars_lock))
|
||||
return -EINTR;
|
||||
|
||||
if (!__efivars) {
|
||||
up(&efivars_lock);
|
||||
return -EINVAL;
|
||||
}
|
||||
ops = __efivars->ops;
|
||||
if (head && efivar_entry_find(name, vendor, head, false)) {
|
||||
up(&efivars_lock);
|
||||
return -EEXIST;
|
||||
@ -687,12 +715,17 @@ static int
|
||||
efivar_entry_set_nonblocking(efi_char16_t *name, efi_guid_t vendor,
|
||||
u32 attributes, unsigned long size, void *data)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
const struct efivar_operations *ops;
|
||||
efi_status_t status;
|
||||
|
||||
if (down_trylock(&efivars_lock))
|
||||
return -EBUSY;
|
||||
|
||||
if (!__efivars) {
|
||||
up(&efivars_lock);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
status = check_var_size_nonblocking(attributes,
|
||||
size + ucs2_strsize(name, 1024));
|
||||
if (status != EFI_SUCCESS) {
|
||||
@ -700,6 +733,7 @@ efivar_entry_set_nonblocking(efi_char16_t *name, efi_guid_t vendor,
|
||||
return -ENOSPC;
|
||||
}
|
||||
|
||||
ops = __efivars->ops;
|
||||
status = ops->set_variable_nonblocking(name, &vendor, attributes,
|
||||
size, data);
|
||||
|
||||
@ -727,9 +761,13 @@ efivar_entry_set_nonblocking(efi_char16_t *name, efi_guid_t vendor,
|
||||
int efivar_entry_set_safe(efi_char16_t *name, efi_guid_t vendor, u32 attributes,
|
||||
bool block, unsigned long size, void *data)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
const struct efivar_operations *ops;
|
||||
efi_status_t status;
|
||||
|
||||
if (!__efivars)
|
||||
return -EINVAL;
|
||||
|
||||
ops = __efivars->ops;
|
||||
if (!ops->query_variable_store)
|
||||
return -ENOSYS;
|
||||
|
||||
@ -829,13 +867,18 @@ EXPORT_SYMBOL_GPL(efivar_entry_find);
|
||||
*/
|
||||
int efivar_entry_size(struct efivar_entry *entry, unsigned long *size)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
const struct efivar_operations *ops;
|
||||
efi_status_t status;
|
||||
|
||||
*size = 0;
|
||||
|
||||
if (down_interruptible(&efivars_lock))
|
||||
return -EINTR;
|
||||
if (!__efivars) {
|
||||
up(&efivars_lock);
|
||||
return -EINVAL;
|
||||
}
|
||||
ops = __efivars->ops;
|
||||
status = ops->get_variable(entry->var.VariableName,
|
||||
&entry->var.VendorGuid, NULL, size, NULL);
|
||||
up(&efivars_lock);
|
||||
@ -861,12 +904,14 @@ EXPORT_SYMBOL_GPL(efivar_entry_size);
|
||||
int __efivar_entry_get(struct efivar_entry *entry, u32 *attributes,
|
||||
unsigned long *size, void *data)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
efi_status_t status;
|
||||
|
||||
status = ops->get_variable(entry->var.VariableName,
|
||||
&entry->var.VendorGuid,
|
||||
attributes, size, data);
|
||||
if (!__efivars)
|
||||
return -EINVAL;
|
||||
|
||||
status = __efivars->ops->get_variable(entry->var.VariableName,
|
||||
&entry->var.VendorGuid,
|
||||
attributes, size, data);
|
||||
|
||||
return efi_status_to_err(status);
|
||||
}
|
||||
@ -882,14 +927,19 @@ EXPORT_SYMBOL_GPL(__efivar_entry_get);
|
||||
int efivar_entry_get(struct efivar_entry *entry, u32 *attributes,
|
||||
unsigned long *size, void *data)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
efi_status_t status;
|
||||
|
||||
if (down_interruptible(&efivars_lock))
|
||||
return -EINTR;
|
||||
status = ops->get_variable(entry->var.VariableName,
|
||||
&entry->var.VendorGuid,
|
||||
attributes, size, data);
|
||||
|
||||
if (!__efivars) {
|
||||
up(&efivars_lock);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
status = __efivars->ops->get_variable(entry->var.VariableName,
|
||||
&entry->var.VendorGuid,
|
||||
attributes, size, data);
|
||||
up(&efivars_lock);
|
||||
|
||||
return efi_status_to_err(status);
|
||||
@ -921,7 +971,7 @@ EXPORT_SYMBOL_GPL(efivar_entry_get);
|
||||
int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes,
|
||||
unsigned long *size, void *data, bool *set)
|
||||
{
|
||||
const struct efivar_operations *ops = __efivars->ops;
|
||||
const struct efivar_operations *ops;
|
||||
efi_char16_t *name = entry->var.VariableName;
|
||||
efi_guid_t *vendor = &entry->var.VendorGuid;
|
||||
efi_status_t status;
|
||||
@ -940,6 +990,11 @@ int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes,
|
||||
if (down_interruptible(&efivars_lock))
|
||||
return -EINTR;
|
||||
|
||||
if (!__efivars) {
|
||||
err = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ensure that the available space hasn't shrunk below the safe level
|
||||
*/
|
||||
@ -956,6 +1011,8 @@ int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes,
|
||||
}
|
||||
}
|
||||
|
||||
ops = __efivars->ops;
|
||||
|
||||
status = ops->set_variable(name, vendor, attributes, *size, data);
|
||||
if (status != EFI_SUCCESS) {
|
||||
err = efi_status_to_err(status);
|
||||
|
||||
@ -403,6 +403,7 @@ static int altera_cvp_probe(struct pci_dev *pdev,
|
||||
struct altera_cvp_conf *conf;
|
||||
struct fpga_manager *mgr;
|
||||
u16 cmd, val;
|
||||
u32 regval;
|
||||
int ret;
|
||||
|
||||
/*
|
||||
@ -416,6 +417,14 @@ static int altera_cvp_probe(struct pci_dev *pdev,
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
pci_read_config_dword(pdev, VSE_CVP_STATUS, ®val);
|
||||
if (!(regval & VSE_CVP_STATUS_CVP_EN)) {
|
||||
dev_err(&pdev->dev,
|
||||
"CVP is disabled for this device: CVP_STATUS Reg 0x%x\n",
|
||||
regval);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
conf = devm_kzalloc(&pdev->dev, sizeof(*conf), GFP_KERNEL);
|
||||
if (!conf)
|
||||
return -ENOMEM;
|
||||
@ -471,7 +480,8 @@ static int altera_cvp_probe(struct pci_dev *pdev,
|
||||
return 0;
|
||||
|
||||
err_unmap:
|
||||
pci_iounmap(pdev, conf->map);
|
||||
if (conf->map)
|
||||
pci_iounmap(pdev, conf->map);
|
||||
pci_release_region(pdev, CVP_BAR);
|
||||
err_disable:
|
||||
cmd &= ~PCI_COMMAND_MEMORY;
|
||||
@ -486,7 +496,8 @@ static void altera_cvp_remove(struct pci_dev *pdev)
|
||||
u16 cmd;
|
||||
|
||||
fpga_mgr_unregister(mgr);
|
||||
pci_iounmap(pdev, conf->map);
|
||||
if (conf->map)
|
||||
pci_iounmap(pdev, conf->map);
|
||||
pci_release_region(pdev, CVP_BAR);
|
||||
pci_read_config_word(pdev, PCI_COMMAND, &cmd);
|
||||
cmd &= ~PCI_COMMAND_MEMORY;
|
||||
|
||||
@ -244,6 +244,8 @@ mediatek_gpio_bank_probe(struct device *dev,
|
||||
rg->chip.of_xlate = mediatek_gpio_xlate;
|
||||
rg->chip.label = devm_kasprintf(dev, GFP_KERNEL, "%s-bank%d",
|
||||
dev_name(dev), bank);
|
||||
if (!rg->chip.label)
|
||||
return -ENOMEM;
|
||||
|
||||
ret = devm_gpiochip_add_data(dev, &rg->chip, mtk);
|
||||
if (ret < 0) {
|
||||
@ -295,6 +297,7 @@ mediatek_gpio_probe(struct platform_device *pdev)
|
||||
struct device_node *np = dev->of_node;
|
||||
struct mtk *mtk;
|
||||
int i;
|
||||
int ret;
|
||||
|
||||
mtk = devm_kzalloc(dev, sizeof(*mtk), GFP_KERNEL);
|
||||
if (!mtk)
|
||||
@ -309,8 +312,11 @@ mediatek_gpio_probe(struct platform_device *pdev)
|
||||
platform_set_drvdata(pdev, mtk);
|
||||
mediatek_gpio_irq_chip.name = dev_name(dev);
|
||||
|
||||
for (i = 0; i < MTK_BANK_CNT; i++)
|
||||
mediatek_gpio_bank_probe(dev, np, i);
|
||||
for (i = 0; i < MTK_BANK_CNT; i++) {
|
||||
ret = mediatek_gpio_bank_probe(dev, np, i);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -2279,6 +2279,12 @@ static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
|
||||
unsigned long flags;
|
||||
unsigned offset;
|
||||
|
||||
if (label) {
|
||||
label = kstrdup_const(label, GFP_KERNEL);
|
||||
if (!label)
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&gpio_lock, flags);
|
||||
|
||||
/* NOTE: gpio_request() can be called in early boot,
|
||||
@ -2289,6 +2295,7 @@ static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
|
||||
desc_set_label(desc, label ? : "?");
|
||||
status = 0;
|
||||
} else {
|
||||
kfree_const(label);
|
||||
status = -EBUSY;
|
||||
goto done;
|
||||
}
|
||||
@ -2305,6 +2312,7 @@ static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
|
||||
|
||||
if (status < 0) {
|
||||
desc_set_label(desc, NULL);
|
||||
kfree_const(label);
|
||||
clear_bit(FLAG_REQUESTED, &desc->flags);
|
||||
goto done;
|
||||
}
|
||||
@ -2400,6 +2408,7 @@ static bool gpiod_free_commit(struct gpio_desc *desc)
|
||||
chip->free(chip, gpio_chip_hwgpio(desc));
|
||||
spin_lock_irqsave(&gpio_lock, flags);
|
||||
}
|
||||
kfree_const(desc->label);
|
||||
desc_set_label(desc, NULL);
|
||||
clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
|
||||
clear_bit(FLAG_REQUESTED, &desc->flags);
|
||||
@ -3221,11 +3230,19 @@ EXPORT_SYMBOL_GPL(gpiod_cansleep);
|
||||
* @desc: gpio to set the consumer name on
|
||||
* @name: the new consumer name
|
||||
*/
|
||||
void gpiod_set_consumer_name(struct gpio_desc *desc, const char *name)
|
||||
int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name)
|
||||
{
|
||||
VALIDATE_DESC_VOID(desc);
|
||||
/* Just overwrite whatever the previous name was */
|
||||
desc->label = name;
|
||||
VALIDATE_DESC(desc);
|
||||
if (name) {
|
||||
name = kstrdup_const(name, GFP_KERNEL);
|
||||
if (!name)
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
kfree_const(desc->label);
|
||||
desc_set_label(desc, name);
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(gpiod_set_consumer_name);
|
||||
|
||||
|
||||
@ -324,7 +324,7 @@ bool dc_link_is_dp_sink_present(struct dc_link *link)
|
||||
{
|
||||
enum gpio_result gpio_result;
|
||||
uint32_t clock_pin = 0;
|
||||
|
||||
uint8_t retry = 0;
|
||||
struct ddc *ddc;
|
||||
|
||||
enum connector_id connector_id =
|
||||
@ -353,11 +353,22 @@ bool dc_link_is_dp_sink_present(struct dc_link *link)
|
||||
return present;
|
||||
}
|
||||
|
||||
/* Read GPIO: DP sink is present if both clock and data pins are zero */
|
||||
/* [anaumov] in DAL2, there was no check for GPIO failure */
|
||||
|
||||
gpio_result = dal_gpio_get_value(ddc->pin_clock, &clock_pin);
|
||||
ASSERT(gpio_result == GPIO_RESULT_OK);
|
||||
/*
|
||||
* Read GPIO: DP sink is present if both clock and data pins are zero
|
||||
*
|
||||
* [W/A] plug-unplug DP cable, sometimes customer board has
|
||||
* one short pulse on clk_pin(1V, < 1ms). DP will be config to HDMI/DVI
|
||||
* then monitor can't br light up. Add retry 3 times
|
||||
* But in real passive dongle, it need additional 3ms to detect
|
||||
*/
|
||||
do {
|
||||
gpio_result = dal_gpio_get_value(ddc->pin_clock, &clock_pin);
|
||||
ASSERT(gpio_result == GPIO_RESULT_OK);
|
||||
if (clock_pin)
|
||||
udelay(1000);
|
||||
else
|
||||
break;
|
||||
} while (retry++ < 3);
|
||||
|
||||
present = (gpio_result == GPIO_RESULT_OK) && !clock_pin;
|
||||
|
||||
|
||||
@ -2240,7 +2240,8 @@ static void get_active_converter_info(
|
||||
translate_dpcd_max_bpc(
|
||||
hdmi_color_caps.bits.MAX_BITS_PER_COLOR_COMPONENT);
|
||||
|
||||
link->dpcd_caps.dongle_caps.extendedCapValid = true;
|
||||
if (link->dpcd_caps.dongle_caps.dp_hdmi_max_pixel_clk != 0)
|
||||
link->dpcd_caps.dongle_caps.extendedCapValid = true;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
@ -1917,6 +1917,8 @@ enum dc_status resource_map_pool_resources(
|
||||
}
|
||||
*/
|
||||
|
||||
calculate_phy_pix_clks(stream);
|
||||
|
||||
/* acquire new resources */
|
||||
pipe_idx = acquire_first_free_pipe(&context->res_ctx, pool, stream);
|
||||
|
||||
|
||||
@ -1268,10 +1268,19 @@ static void program_scaler(const struct dc *dc,
|
||||
pipe_ctx->plane_res.scl_data.lb_params.depth,
|
||||
&pipe_ctx->stream->bit_depth_params);
|
||||
|
||||
if (pipe_ctx->stream_res.tg->funcs->set_overscan_blank_color)
|
||||
if (pipe_ctx->stream_res.tg->funcs->set_overscan_blank_color) {
|
||||
/*
|
||||
* The way 420 is packed, 2 channels carry Y component, 1 channel
|
||||
* alternate between Cb and Cr, so both channels need the pixel
|
||||
* value for Y
|
||||
*/
|
||||
if (pipe_ctx->stream->timing.pixel_encoding == PIXEL_ENCODING_YCBCR420)
|
||||
color.color_r_cr = color.color_g_y;
|
||||
|
||||
pipe_ctx->stream_res.tg->funcs->set_overscan_blank_color(
|
||||
pipe_ctx->stream_res.tg,
|
||||
&color);
|
||||
}
|
||||
|
||||
pipe_ctx->plane_res.xfm->funcs->transform_set_scaler(pipe_ctx->plane_res.xfm,
|
||||
&pipe_ctx->plane_res.scl_data);
|
||||
|
||||
@ -1190,7 +1190,8 @@ static bool dcn10_set_input_transfer_func(struct pipe_ctx *pipe_ctx,
|
||||
tf = plane_state->in_transfer_func;
|
||||
|
||||
if (plane_state->gamma_correction &&
|
||||
!plane_state->gamma_correction->is_identity
|
||||
!dpp_base->ctx->dc->debug.always_use_regamma
|
||||
&& !plane_state->gamma_correction->is_identity
|
||||
&& dce_use_lut(plane_state->format))
|
||||
dpp_base->funcs->dpp_program_input_lut(dpp_base, plane_state->gamma_correction);
|
||||
|
||||
@ -2120,6 +2121,15 @@ static void dcn10_blank_pixel_data(
|
||||
color_space = stream->output_color_space;
|
||||
color_space_to_black_color(dc, color_space, &black_color);
|
||||
|
||||
/*
|
||||
* The way 420 is packed, 2 channels carry Y component, 1 channel
|
||||
* alternate between Cb and Cr, so both channels need the pixel
|
||||
* value for Y
|
||||
*/
|
||||
if (stream->timing.pixel_encoding == PIXEL_ENCODING_YCBCR420)
|
||||
black_color.color_r_cr = black_color.color_g_y;
|
||||
|
||||
|
||||
if (stream_res->tg->funcs->set_blank_color)
|
||||
stream_res->tg->funcs->set_blank_color(
|
||||
stream_res->tg,
|
||||
|
||||
@ -1528,8 +1528,21 @@ static int polaris10_populate_clock_stretcher_data_table(struct pp_hwmgr *hwmgr)
|
||||
efuse = efuse >> 24;
|
||||
|
||||
if (hwmgr->chip_id == CHIP_POLARIS10) {
|
||||
min = 1000;
|
||||
max = 2300;
|
||||
if (hwmgr->is_kicker) {
|
||||
min = 1200;
|
||||
max = 2500;
|
||||
} else {
|
||||
min = 1000;
|
||||
max = 2300;
|
||||
}
|
||||
} else if (hwmgr->chip_id == CHIP_POLARIS11) {
|
||||
if (hwmgr->is_kicker) {
|
||||
min = 900;
|
||||
max = 2100;
|
||||
} else {
|
||||
min = 1100;
|
||||
max = 2100;
|
||||
}
|
||||
} else {
|
||||
min = 1100;
|
||||
max = 2100;
|
||||
|
||||
@ -3192,7 +3192,7 @@ EXPORT_SYMBOL(drm_atomic_helper_suspend);
|
||||
int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
|
||||
struct drm_modeset_acquire_ctx *ctx)
|
||||
{
|
||||
int i;
|
||||
int i, ret;
|
||||
struct drm_plane *plane;
|
||||
struct drm_plane_state *new_plane_state;
|
||||
struct drm_connector *connector;
|
||||
@ -3211,7 +3211,11 @@ int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
|
||||
for_each_new_connector_in_state(state, connector, new_conn_state, i)
|
||||
state->connectors[i].old_state = connector->state;
|
||||
|
||||
return drm_atomic_commit(state);
|
||||
ret = drm_atomic_commit(state);
|
||||
|
||||
state->acquire_ctx = NULL;
|
||||
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL(drm_atomic_helper_commit_duplicated_state);
|
||||
|
||||
|
||||
@ -36,6 +36,8 @@
|
||||
#include <drm/drmP.h>
|
||||
#include "drm_legacy.h"
|
||||
|
||||
#include <linux/nospec.h>
|
||||
|
||||
static struct drm_map_list *drm_find_matching_map(struct drm_device *dev,
|
||||
struct drm_local_map *map)
|
||||
{
|
||||
@ -1417,6 +1419,7 @@ int drm_legacy_freebufs(struct drm_device *dev, void *data,
|
||||
idx, dma->buf_count - 1);
|
||||
return -EINVAL;
|
||||
}
|
||||
idx = array_index_nospec(idx, dma->buf_count);
|
||||
buf = dma->buflist[idx];
|
||||
if (buf->file_priv != file_priv) {
|
||||
DRM_ERROR("Process %d freeing buffer not owned\n",
|
||||
|
||||
@ -331,7 +331,7 @@ static void dpu_encoder_phys_vid_vblank_irq(void *arg, int irq_idx)
|
||||
if (hw_ctl && hw_ctl->ops.get_flush_register)
|
||||
flush_register = hw_ctl->ops.get_flush_register(hw_ctl);
|
||||
|
||||
if (flush_register == 0)
|
||||
if (!(flush_register & hw_ctl->ops.get_pending_flush(hw_ctl)))
|
||||
new_cnt = atomic_add_unless(&phys_enc->pending_kickoff_cnt,
|
||||
-1, 0);
|
||||
spin_unlock_irqrestore(phys_enc->enc_spinlock, lock_flags);
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
* | |
|
||||
* | |
|
||||
* +---------+ | +----------+ | +----+
|
||||
* dsi0vco_clk ---| out_div |--o--| divl_3_0 |--o--| /8 |-- dsi0pllbyte
|
||||
* dsi0vco_clk ---| out_div |--o--| divl_3_0 |--o--| /8 |-- dsi0_phy_pll_out_byteclk
|
||||
* +---------+ | +----------+ | +----+
|
||||
* | |
|
||||
* | | dsi0_pll_by_2_bit_clk
|
||||
@ -25,7 +25,7 @@
|
||||
* | | +----+ | |\ dsi0_pclk_mux
|
||||
* | |--| /2 |--o--| \ |
|
||||
* | | +----+ | \ | +---------+
|
||||
* | --------------| |--o--| div_7_4 |-- dsi0pll
|
||||
* | --------------| |--o--| div_7_4 |-- dsi0_phy_pll_out_dsiclk
|
||||
* |------------------------------| / +---------+
|
||||
* | +-----+ | /
|
||||
* -----------| /4? |--o----------|/
|
||||
@ -690,7 +690,7 @@ static int pll_10nm_register(struct dsi_pll_10nm *pll_10nm)
|
||||
|
||||
hws[num++] = hw;
|
||||
|
||||
snprintf(clk_name, 32, "dsi%dpllbyte", pll_10nm->id);
|
||||
snprintf(clk_name, 32, "dsi%d_phy_pll_out_byteclk", pll_10nm->id);
|
||||
snprintf(parent, 32, "dsi%d_pll_bit_clk", pll_10nm->id);
|
||||
|
||||
/* DSI Byte clock = VCO_CLK / OUT_DIV / BIT_DIV / 8 */
|
||||
@ -739,7 +739,7 @@ static int pll_10nm_register(struct dsi_pll_10nm *pll_10nm)
|
||||
|
||||
hws[num++] = hw;
|
||||
|
||||
snprintf(clk_name, 32, "dsi%dpll", pll_10nm->id);
|
||||
snprintf(clk_name, 32, "dsi%d_phy_pll_out_dsiclk", pll_10nm->id);
|
||||
snprintf(parent, 32, "dsi%d_pclk_mux", pll_10nm->id);
|
||||
|
||||
/* PIX CLK DIV : DIV_CTRL_7_4*/
|
||||
|
||||
@ -147,7 +147,7 @@ static int cdn_dp_mailbox_validate_receive(struct cdn_dp_device *dp,
|
||||
}
|
||||
|
||||
static int cdn_dp_mailbox_read_receive(struct cdn_dp_device *dp,
|
||||
u8 *buff, u8 buff_size)
|
||||
u8 *buff, u16 buff_size)
|
||||
{
|
||||
u32 i;
|
||||
int ret;
|
||||
|
||||
@ -168,6 +168,13 @@ static int sun8i_tcon_top_bind(struct device *dev, struct device *master,
|
||||
goto err_assert_reset;
|
||||
}
|
||||
|
||||
/*
|
||||
* At least on H6, some registers have some bits set by default
|
||||
* which may cause issues. Clear them here.
|
||||
*/
|
||||
writel(0, regs + TCON_TOP_PORT_SEL_REG);
|
||||
writel(0, regs + TCON_TOP_GATE_SRC_REG);
|
||||
|
||||
/*
|
||||
* TCON TOP has two muxes, which select parent clock for each TCON TV
|
||||
* channel clock. Parent could be either TCON TV or TVE clock. For now
|
||||
|
||||
@ -293,6 +293,7 @@ v3d_prime_import_sg_table(struct drm_device *dev,
|
||||
bo->resv = attach->dmabuf->resv;
|
||||
|
||||
bo->sgt = sgt;
|
||||
obj->import_attach = attach;
|
||||
v3d_bo_get_pages(bo);
|
||||
|
||||
v3d_mmu_insert_ptes(bo);
|
||||
|
||||
@ -315,12 +315,14 @@ static int vc4_plane_setup_clipping_and_scaling(struct drm_plane_state *state)
|
||||
vc4_get_scaling_mode(vc4_state->src_h[1],
|
||||
vc4_state->crtc_h);
|
||||
|
||||
/* YUV conversion requires that horizontal scaling be enabled,
|
||||
* even on a plane that's otherwise 1:1. Looks like only PPF
|
||||
* works in that case, so let's pick that one.
|
||||
/* YUV conversion requires that horizontal scaling be enabled
|
||||
* on the UV plane even if vc4_get_scaling_mode() returned
|
||||
* VC4_SCALING_NONE (which can happen when the down-scaling
|
||||
* ratio is 0.5). Let's force it to VC4_SCALING_PPF in this
|
||||
* case.
|
||||
*/
|
||||
if (vc4_state->is_unity)
|
||||
vc4_state->x_scaling[0] = VC4_SCALING_PPF;
|
||||
if (vc4_state->x_scaling[1] == VC4_SCALING_NONE)
|
||||
vc4_state->x_scaling[1] = VC4_SCALING_PPF;
|
||||
} else {
|
||||
vc4_state->is_yuv = false;
|
||||
vc4_state->x_scaling[1] = VC4_SCALING_NONE;
|
||||
|
||||
@ -471,31 +471,31 @@ static int __init vgem_init(void)
|
||||
if (!vgem_device)
|
||||
return -ENOMEM;
|
||||
|
||||
ret = drm_dev_init(&vgem_device->drm, &vgem_driver, NULL);
|
||||
if (ret)
|
||||
goto out_free;
|
||||
|
||||
vgem_device->platform =
|
||||
platform_device_register_simple("vgem", -1, NULL, 0);
|
||||
if (IS_ERR(vgem_device->platform)) {
|
||||
ret = PTR_ERR(vgem_device->platform);
|
||||
goto out_fini;
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
dma_coerce_mask_and_coherent(&vgem_device->platform->dev,
|
||||
DMA_BIT_MASK(64));
|
||||
ret = drm_dev_init(&vgem_device->drm, &vgem_driver,
|
||||
&vgem_device->platform->dev);
|
||||
if (ret)
|
||||
goto out_unregister;
|
||||
|
||||
/* Final step: expose the device/driver to userspace */
|
||||
ret = drm_dev_register(&vgem_device->drm, 0);
|
||||
if (ret)
|
||||
goto out_unregister;
|
||||
goto out_fini;
|
||||
|
||||
return 0;
|
||||
|
||||
out_unregister:
|
||||
platform_device_unregister(vgem_device->platform);
|
||||
out_fini:
|
||||
drm_dev_fini(&vgem_device->drm);
|
||||
out_unregister:
|
||||
platform_device_unregister(vgem_device->platform);
|
||||
out_free:
|
||||
kfree(vgem_device);
|
||||
return ret;
|
||||
|
||||
@ -1524,7 +1524,7 @@ unlock:
|
||||
EXPORT_SYMBOL_GPL(ipu_image_convert_queue);
|
||||
|
||||
/* Abort any active or pending conversions for this context */
|
||||
void ipu_image_convert_abort(struct ipu_image_convert_ctx *ctx)
|
||||
static void __ipu_image_convert_abort(struct ipu_image_convert_ctx *ctx)
|
||||
{
|
||||
struct ipu_image_convert_chan *chan = ctx->chan;
|
||||
struct ipu_image_convert_priv *priv = chan->priv;
|
||||
@ -1551,7 +1551,7 @@ void ipu_image_convert_abort(struct ipu_image_convert_ctx *ctx)
|
||||
|
||||
need_abort = (run_count || active_run);
|
||||
|
||||
ctx->aborting = need_abort;
|
||||
ctx->aborting = true;
|
||||
|
||||
spin_unlock_irqrestore(&chan->irqlock, flags);
|
||||
|
||||
@ -1572,7 +1572,11 @@ void ipu_image_convert_abort(struct ipu_image_convert_ctx *ctx)
|
||||
dev_warn(priv->ipu->dev, "%s: timeout\n", __func__);
|
||||
force_abort(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
void ipu_image_convert_abort(struct ipu_image_convert_ctx *ctx)
|
||||
{
|
||||
__ipu_image_convert_abort(ctx);
|
||||
ctx->aborting = false;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ipu_image_convert_abort);
|
||||
@ -1586,7 +1590,7 @@ void ipu_image_convert_unprepare(struct ipu_image_convert_ctx *ctx)
|
||||
bool put_res;
|
||||
|
||||
/* make sure no runs are hanging around */
|
||||
ipu_image_convert_abort(ctx);
|
||||
__ipu_image_convert_abort(ctx);
|
||||
|
||||
dev_dbg(priv->ipu->dev, "%s: task %u: removing ctx %p\n", __func__,
|
||||
chan->ic_task, ctx);
|
||||
|
||||
@ -30,6 +30,7 @@
|
||||
|
||||
#include <linux/debugfs.h>
|
||||
#include <linux/seq_file.h>
|
||||
#include <linux/kfifo.h>
|
||||
#include <linux/sched/signal.h>
|
||||
#include <linux/export.h>
|
||||
#include <linux/slab.h>
|
||||
@ -661,17 +662,12 @@ EXPORT_SYMBOL_GPL(hid_dump_device);
|
||||
/* enqueue string to 'events' ring buffer */
|
||||
void hid_debug_event(struct hid_device *hdev, char *buf)
|
||||
{
|
||||
unsigned i;
|
||||
struct hid_debug_list *list;
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&hdev->debug_list_lock, flags);
|
||||
list_for_each_entry(list, &hdev->debug_list, node) {
|
||||
for (i = 0; buf[i]; i++)
|
||||
list->hid_debug_buf[(list->tail + i) % HID_DEBUG_BUFSIZE] =
|
||||
buf[i];
|
||||
list->tail = (list->tail + i) % HID_DEBUG_BUFSIZE;
|
||||
}
|
||||
list_for_each_entry(list, &hdev->debug_list, node)
|
||||
kfifo_in(&list->hid_debug_fifo, buf, strlen(buf));
|
||||
spin_unlock_irqrestore(&hdev->debug_list_lock, flags);
|
||||
|
||||
wake_up_interruptible(&hdev->debug_wait);
|
||||
@ -722,8 +718,7 @@ void hid_dump_input(struct hid_device *hdev, struct hid_usage *usage, __s32 valu
|
||||
hid_debug_event(hdev, buf);
|
||||
|
||||
kfree(buf);
|
||||
wake_up_interruptible(&hdev->debug_wait);
|
||||
|
||||
wake_up_interruptible(&hdev->debug_wait);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(hid_dump_input);
|
||||
|
||||
@ -1088,8 +1083,8 @@ static int hid_debug_events_open(struct inode *inode, struct file *file)
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (!(list->hid_debug_buf = kzalloc(HID_DEBUG_BUFSIZE, GFP_KERNEL))) {
|
||||
err = -ENOMEM;
|
||||
err = kfifo_alloc(&list->hid_debug_fifo, HID_DEBUG_FIFOSIZE, GFP_KERNEL);
|
||||
if (err) {
|
||||
kfree(list);
|
||||
goto out;
|
||||
}
|
||||
@ -1109,77 +1104,57 @@ static ssize_t hid_debug_events_read(struct file *file, char __user *buffer,
|
||||
size_t count, loff_t *ppos)
|
||||
{
|
||||
struct hid_debug_list *list = file->private_data;
|
||||
int ret = 0, len;
|
||||
int ret = 0, copied;
|
||||
DECLARE_WAITQUEUE(wait, current);
|
||||
|
||||
mutex_lock(&list->read_mutex);
|
||||
while (ret == 0) {
|
||||
if (list->head == list->tail) {
|
||||
add_wait_queue(&list->hdev->debug_wait, &wait);
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
if (kfifo_is_empty(&list->hid_debug_fifo)) {
|
||||
add_wait_queue(&list->hdev->debug_wait, &wait);
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
|
||||
while (list->head == list->tail) {
|
||||
if (file->f_flags & O_NONBLOCK) {
|
||||
ret = -EAGAIN;
|
||||
break;
|
||||
}
|
||||
if (signal_pending(current)) {
|
||||
ret = -ERESTARTSYS;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!list->hdev || !list->hdev->debug) {
|
||||
ret = -EIO;
|
||||
set_current_state(TASK_RUNNING);
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* allow O_NONBLOCK from other threads */
|
||||
mutex_unlock(&list->read_mutex);
|
||||
schedule();
|
||||
mutex_lock(&list->read_mutex);
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
while (kfifo_is_empty(&list->hid_debug_fifo)) {
|
||||
if (file->f_flags & O_NONBLOCK) {
|
||||
ret = -EAGAIN;
|
||||
break;
|
||||
}
|
||||
|
||||
set_current_state(TASK_RUNNING);
|
||||
remove_wait_queue(&list->hdev->debug_wait, &wait);
|
||||
if (signal_pending(current)) {
|
||||
ret = -ERESTARTSYS;
|
||||
break;
|
||||
}
|
||||
|
||||
/* if list->hdev is NULL we cannot remove_wait_queue().
|
||||
* if list->hdev->debug is 0 then hid_debug_unregister()
|
||||
* was already called and list->hdev is being destroyed.
|
||||
* if we add remove_wait_queue() here we can hit a race.
|
||||
*/
|
||||
if (!list->hdev || !list->hdev->debug) {
|
||||
ret = -EIO;
|
||||
set_current_state(TASK_RUNNING);
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* allow O_NONBLOCK from other threads */
|
||||
mutex_unlock(&list->read_mutex);
|
||||
schedule();
|
||||
mutex_lock(&list->read_mutex);
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
}
|
||||
|
||||
__set_current_state(TASK_RUNNING);
|
||||
remove_wait_queue(&list->hdev->debug_wait, &wait);
|
||||
|
||||
if (ret)
|
||||
goto out;
|
||||
|
||||
/* pass the ringbuffer contents to userspace */
|
||||
copy_rest:
|
||||
if (list->tail == list->head)
|
||||
goto out;
|
||||
if (list->tail > list->head) {
|
||||
len = list->tail - list->head;
|
||||
if (len > count)
|
||||
len = count;
|
||||
|
||||
if (copy_to_user(buffer + ret, &list->hid_debug_buf[list->head], len)) {
|
||||
ret = -EFAULT;
|
||||
goto out;
|
||||
}
|
||||
ret += len;
|
||||
list->head += len;
|
||||
} else {
|
||||
len = HID_DEBUG_BUFSIZE - list->head;
|
||||
if (len > count)
|
||||
len = count;
|
||||
|
||||
if (copy_to_user(buffer, &list->hid_debug_buf[list->head], len)) {
|
||||
ret = -EFAULT;
|
||||
goto out;
|
||||
}
|
||||
list->head = 0;
|
||||
ret += len;
|
||||
count -= len;
|
||||
if (count > 0)
|
||||
goto copy_rest;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* pass the fifo content to userspace, locking is not needed with only
|
||||
* one concurrent reader and one concurrent writer
|
||||
*/
|
||||
ret = kfifo_to_user(&list->hid_debug_fifo, buffer, count, &copied);
|
||||
if (ret)
|
||||
goto out;
|
||||
ret = copied;
|
||||
out:
|
||||
mutex_unlock(&list->read_mutex);
|
||||
return ret;
|
||||
@ -1190,7 +1165,7 @@ static __poll_t hid_debug_events_poll(struct file *file, poll_table *wait)
|
||||
struct hid_debug_list *list = file->private_data;
|
||||
|
||||
poll_wait(file, &list->hdev->debug_wait, wait);
|
||||
if (list->head != list->tail)
|
||||
if (!kfifo_is_empty(&list->hid_debug_fifo))
|
||||
return EPOLLIN | EPOLLRDNORM;
|
||||
if (!list->hdev->debug)
|
||||
return EPOLLERR | EPOLLHUP;
|
||||
@ -1205,7 +1180,7 @@ static int hid_debug_events_release(struct inode *inode, struct file *file)
|
||||
spin_lock_irqsave(&list->hdev->debug_list_lock, flags);
|
||||
list_del(&list->node);
|
||||
spin_unlock_irqrestore(&list->hdev->debug_list_lock, flags);
|
||||
kfree(list->hid_debug_buf);
|
||||
kfifo_free(&list->hid_debug_fifo);
|
||||
kfree(list);
|
||||
|
||||
return 0;
|
||||
@ -1256,4 +1231,3 @@ void hid_debug_exit(void)
|
||||
{
|
||||
debugfs_remove_recursive(hid_debug_root);
|
||||
}
|
||||
|
||||
|
||||
@ -743,7 +743,9 @@ static int lenovo_probe_tpkbd(struct hid_device *hdev)
|
||||
data_pointer->led_mute.brightness_get = lenovo_led_brightness_get_tpkbd;
|
||||
data_pointer->led_mute.brightness_set = lenovo_led_brightness_set_tpkbd;
|
||||
data_pointer->led_mute.dev = dev;
|
||||
led_classdev_register(dev, &data_pointer->led_mute);
|
||||
ret = led_classdev_register(dev, &data_pointer->led_mute);
|
||||
if (ret < 0)
|
||||
goto err;
|
||||
|
||||
data_pointer->led_micmute.name = name_micmute;
|
||||
data_pointer->led_micmute.brightness_get =
|
||||
@ -751,7 +753,11 @@ static int lenovo_probe_tpkbd(struct hid_device *hdev)
|
||||
data_pointer->led_micmute.brightness_set =
|
||||
lenovo_led_brightness_set_tpkbd;
|
||||
data_pointer->led_micmute.dev = dev;
|
||||
led_classdev_register(dev, &data_pointer->led_micmute);
|
||||
ret = led_classdev_register(dev, &data_pointer->led_micmute);
|
||||
if (ret < 0) {
|
||||
led_classdev_unregister(&data_pointer->led_mute);
|
||||
goto err;
|
||||
}
|
||||
|
||||
lenovo_features_set_tpkbd(hdev);
|
||||
|
||||
|
||||
@ -360,9 +360,11 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
|
||||
struct i2c_client *client = data->client;
|
||||
unsigned long min, val;
|
||||
u8 reg;
|
||||
int err = kstrtoul(buf, 10, &val);
|
||||
if (err < 0)
|
||||
return err;
|
||||
int rv;
|
||||
|
||||
rv = kstrtoul(buf, 10, &val);
|
||||
if (rv < 0)
|
||||
return rv;
|
||||
|
||||
/* Save fan_min */
|
||||
mutex_lock(&data->update_lock);
|
||||
@ -390,8 +392,11 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
reg = (lm80_read_value(client, LM80_REG_FANDIV) &
|
||||
~(3 << (2 * (nr + 1)))) | (data->fan_div[nr] << (2 * (nr + 1)));
|
||||
rv = lm80_read_value(client, LM80_REG_FANDIV);
|
||||
if (rv < 0)
|
||||
return rv;
|
||||
reg = (rv & ~(3 << (2 * (nr + 1))))
|
||||
| (data->fan_div[nr] << (2 * (nr + 1)));
|
||||
lm80_write_value(client, LM80_REG_FANDIV, reg);
|
||||
|
||||
/* Restore fan_min */
|
||||
@ -623,6 +628,7 @@ static int lm80_probe(struct i2c_client *client,
|
||||
struct device *dev = &client->dev;
|
||||
struct device *hwmon_dev;
|
||||
struct lm80_data *data;
|
||||
int rv;
|
||||
|
||||
data = devm_kzalloc(dev, sizeof(struct lm80_data), GFP_KERNEL);
|
||||
if (!data)
|
||||
@ -635,8 +641,14 @@ static int lm80_probe(struct i2c_client *client,
|
||||
lm80_init_client(client);
|
||||
|
||||
/* A few vars need to be filled upon startup */
|
||||
data->fan[f_min][0] = lm80_read_value(client, LM80_REG_FAN_MIN(1));
|
||||
data->fan[f_min][1] = lm80_read_value(client, LM80_REG_FAN_MIN(2));
|
||||
rv = lm80_read_value(client, LM80_REG_FAN_MIN(1));
|
||||
if (rv < 0)
|
||||
return rv;
|
||||
data->fan[f_min][0] = rv;
|
||||
rv = lm80_read_value(client, LM80_REG_FAN_MIN(2));
|
||||
if (rv < 0)
|
||||
return rv;
|
||||
data->fan[f_min][1] = rv;
|
||||
|
||||
hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
|
||||
data, lm80_groups);
|
||||
|
||||
@ -296,22 +296,7 @@ static irqreturn_t axxia_i2c_isr(int irq, void *_dev)
|
||||
i2c_int_disable(idev, MST_STATUS_TFL);
|
||||
}
|
||||
|
||||
if (status & MST_STATUS_SCC) {
|
||||
/* Stop completed */
|
||||
i2c_int_disable(idev, ~MST_STATUS_TSS);
|
||||
complete(&idev->msg_complete);
|
||||
} else if (status & MST_STATUS_SNS) {
|
||||
/* Transfer done */
|
||||
i2c_int_disable(idev, ~MST_STATUS_TSS);
|
||||
if (i2c_m_rd(idev->msg) && idev->msg_xfrd < idev->msg->len)
|
||||
axxia_i2c_empty_rx_fifo(idev);
|
||||
complete(&idev->msg_complete);
|
||||
} else if (status & MST_STATUS_TSS) {
|
||||
/* Transfer timeout */
|
||||
idev->msg_err = -ETIMEDOUT;
|
||||
i2c_int_disable(idev, ~MST_STATUS_TSS);
|
||||
complete(&idev->msg_complete);
|
||||
} else if (unlikely(status & MST_STATUS_ERR)) {
|
||||
if (unlikely(status & MST_STATUS_ERR)) {
|
||||
/* Transfer error */
|
||||
i2c_int_disable(idev, ~0);
|
||||
if (status & MST_STATUS_AL)
|
||||
@ -328,6 +313,21 @@ static irqreturn_t axxia_i2c_isr(int irq, void *_dev)
|
||||
readl(idev->base + MST_TX_BYTES_XFRD),
|
||||
readl(idev->base + MST_TX_XFER));
|
||||
complete(&idev->msg_complete);
|
||||
} else if (status & MST_STATUS_SCC) {
|
||||
/* Stop completed */
|
||||
i2c_int_disable(idev, ~MST_STATUS_TSS);
|
||||
complete(&idev->msg_complete);
|
||||
} else if (status & MST_STATUS_SNS) {
|
||||
/* Transfer done */
|
||||
i2c_int_disable(idev, ~MST_STATUS_TSS);
|
||||
if (i2c_m_rd(idev->msg) && idev->msg_xfrd < idev->msg->len)
|
||||
axxia_i2c_empty_rx_fifo(idev);
|
||||
complete(&idev->msg_complete);
|
||||
} else if (status & MST_STATUS_TSS) {
|
||||
/* Transfer timeout */
|
||||
idev->msg_err = -ETIMEDOUT;
|
||||
i2c_int_disable(idev, ~MST_STATUS_TSS);
|
||||
complete(&idev->msg_complete);
|
||||
}
|
||||
|
||||
out:
|
||||
|
||||
@ -800,6 +800,7 @@ static const struct sh_mobile_dt_config r8a7740_dt_config = {
|
||||
static const struct of_device_id sh_mobile_i2c_dt_ids[] = {
|
||||
{ .compatible = "renesas,iic-r8a73a4", .data = &fast_clock_dt_config },
|
||||
{ .compatible = "renesas,iic-r8a7740", .data = &r8a7740_dt_config },
|
||||
{ .compatible = "renesas,iic-r8a774c0", .data = &fast_clock_dt_config },
|
||||
{ .compatible = "renesas,iic-r8a7790", .data = &v2_freq_calc_dt_config },
|
||||
{ .compatible = "renesas,iic-r8a7791", .data = &fast_clock_dt_config },
|
||||
{ .compatible = "renesas,iic-r8a7792", .data = &fast_clock_dt_config },
|
||||
@ -808,6 +809,7 @@ static const struct of_device_id sh_mobile_i2c_dt_ids[] = {
|
||||
{ .compatible = "renesas,rcar-gen2-iic", .data = &fast_clock_dt_config },
|
||||
{ .compatible = "renesas,iic-r8a7795", .data = &fast_clock_dt_config },
|
||||
{ .compatible = "renesas,rcar-gen3-iic", .data = &fast_clock_dt_config },
|
||||
{ .compatible = "renesas,iic-r8a77990", .data = &fast_clock_dt_config },
|
||||
{ .compatible = "renesas,iic-sh73a0", .data = &fast_clock_dt_config },
|
||||
{ .compatible = "renesas,rmobile-iic", .data = &default_dt_config },
|
||||
{},
|
||||
|
||||
@ -1490,6 +1490,7 @@ static const struct acpi_device_id kx_acpi_match[] = {
|
||||
{"KXCJ1008", KXCJ91008},
|
||||
{"KXCJ9000", KXCJ91008},
|
||||
{"KIOX000A", KXCJ91008},
|
||||
{"KIOX010A", KXCJ91008}, /* KXCJ91008 inside the display of a 2-in-1 */
|
||||
{"KXTJ1009", KXTJ21009},
|
||||
{"SMO8500", KXCJ91008},
|
||||
{ },
|
||||
|
||||
@ -587,8 +587,11 @@ static int meson_sar_adc_clk_init(struct iio_dev *indio_dev,
|
||||
struct clk_init_data init;
|
||||
const char *clk_parents[1];
|
||||
|
||||
init.name = devm_kasprintf(&indio_dev->dev, GFP_KERNEL, "%pOF#adc_div",
|
||||
indio_dev->dev.of_node);
|
||||
init.name = devm_kasprintf(&indio_dev->dev, GFP_KERNEL, "%s#adc_div",
|
||||
dev_name(indio_dev->dev.parent));
|
||||
if (!init.name)
|
||||
return -ENOMEM;
|
||||
|
||||
init.flags = 0;
|
||||
init.ops = &clk_divider_ops;
|
||||
clk_parents[0] = __clk_get_name(priv->clkin);
|
||||
@ -606,8 +609,11 @@ static int meson_sar_adc_clk_init(struct iio_dev *indio_dev,
|
||||
if (WARN_ON(IS_ERR(priv->adc_div_clk)))
|
||||
return PTR_ERR(priv->adc_div_clk);
|
||||
|
||||
init.name = devm_kasprintf(&indio_dev->dev, GFP_KERNEL, "%pOF#adc_en",
|
||||
indio_dev->dev.of_node);
|
||||
init.name = devm_kasprintf(&indio_dev->dev, GFP_KERNEL, "%s#adc_en",
|
||||
dev_name(indio_dev->dev.parent));
|
||||
if (!init.name)
|
||||
return -ENOMEM;
|
||||
|
||||
init.flags = CLK_SET_RATE_PARENT;
|
||||
init.ops = &clk_gate_ops;
|
||||
clk_parents[0] = __clk_get_name(priv->adc_div_clk);
|
||||
|
||||
@ -1157,6 +1157,7 @@ void hfi1_rc_send_complete(struct rvt_qp *qp, struct hfi1_opa_header *opah)
|
||||
if (cmp_psn(wqe->lpsn, qp->s_sending_psn) >= 0 &&
|
||||
cmp_psn(qp->s_sending_psn, qp->s_sending_hpsn) <= 0)
|
||||
break;
|
||||
rvt_qp_wqe_unreserve(qp, wqe);
|
||||
s_last = qp->s_last;
|
||||
trace_hfi1_qp_send_completion(qp, wqe, s_last);
|
||||
if (++s_last >= qp->s_size)
|
||||
@ -1209,6 +1210,7 @@ static struct rvt_swqe *do_rc_completion(struct rvt_qp *qp,
|
||||
u32 s_last;
|
||||
|
||||
rvt_put_swqe(wqe);
|
||||
rvt_qp_wqe_unreserve(qp, wqe);
|
||||
s_last = qp->s_last;
|
||||
trace_hfi1_qp_send_completion(qp, wqe, s_last);
|
||||
if (++s_last >= qp->s_size)
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user