Merge 4.19.178 into android-4.19-stable
Changes in 4.19.178
HID: make arrays usage and value to be the same
USB: quirks: sort quirk entries
usb: quirks: add quirk to start video capture on ELMO L-12F document camera reliable
ntfs: check for valid standard information attribute
arm64: tegra: Add power-domain for Tegra210 HDA
scripts: use pkg-config to locate libcrypto
scripts: set proper OpenSSL include dir also for sign-file
block: add helper for checking if queue is registered
block: split .sysfs_lock into two locks
block: fix race between switching elevator and removing queues
block: don't release queue's sysfs lock during switching elevator
NET: usb: qmi_wwan: Adding support for Cinterion MV31
cifs: Set CIFS_MOUNT_USE_PREFIX_PATH flag on setting cifs_sb->prepath.
scripts/recordmcount.pl: support big endian for ARCH sh
jump_label/lockdep: Assert we hold the hotplug lock for _cpuslocked() operations
locking/static_key: Fix false positive warnings on concurrent dec/inc
vmlinux.lds.h: add DWARF v5 sections
kdb: Make memory allocations more robust
PCI: qcom: Use PHY_REFCLK_USE_PAD only for ipq8064
bfq: Avoid false bfq queue merging
ALSA: usb-audio: Fix PCM buffer allocation in non-vmalloc mode
MIPS: vmlinux.lds.S: add missing PAGE_ALIGNED_DATA() section
random: fix the RNDRESEEDCRNG ioctl
ath10k: Fix error handling in case of CE pipe init failure
Bluetooth: btqcomsmd: Fix a resource leak in error handling paths in the probe function
Bluetooth: Fix initializing response id after clearing struct
ARM: dts: exynos: correct PMIC interrupt trigger level on Artik 5
ARM: dts: exynos: correct PMIC interrupt trigger level on Monk
ARM: dts: exynos: correct PMIC interrupt trigger level on Rinato
ARM: dts: exynos: correct PMIC interrupt trigger level on Spring
ARM: dts: exynos: correct PMIC interrupt trigger level on Arndale Octa
ARM: dts: exynos: correct PMIC interrupt trigger level on Odroid XU3 family
arm64: dts: exynos: correct PMIC interrupt trigger level on TM2
arm64: dts: exynos: correct PMIC interrupt trigger level on Espresso
bpf: Avoid warning when re-casting __bpf_call_base into __bpf_call_base_args
arm64: dts: allwinner: A64: properly connect USB PHY to port 0
arm64: dts: allwinner: Drop non-removable from SoPine/LTS SD card
arm64: dts: allwinner: A64: Limit MMC2 bus frequency to 150 MHz
cpufreq: brcmstb-avs-cpufreq: Free resources in error path
cpufreq: brcmstb-avs-cpufreq: Fix resource leaks in ->remove()
ACPICA: Fix exception code class checks
usb: gadget: u_audio: Free requests only after callback
Bluetooth: drop HCI device reference before return
Bluetooth: Put HCI device if inquiry procedure interrupts
memory: ti-aemif: Drop child node when jumping out loop
ARM: dts: Configure missing thermal interrupt for 4430
usb: dwc2: Do not update data length if it is 0 on inbound transfers
usb: dwc2: Abort transaction after errors with unknown reason
usb: dwc2: Make "trimming xfer length" a debug message
staging: rtl8723bs: wifi_regd.c: Fix incorrect number of regulatory rules
ARM: dts: armada388-helios4: assign pinctrl to LEDs
ARM: dts: armada388-helios4: assign pinctrl to each fan
arm64: dts: msm8916: Fix reserved and rfsa nodes unit address
ARM: s3c: fix fiq for clang IAS
soc: aspeed: snoop: Add clock control logic
bpf_lru_list: Read double-checked variable once without lock
ath9k: fix data bus crash when setting nf_override via debugfs
ibmvnic: Set to CLOSED state even on error
bnxt_en: reverse order of TX disable and carrier off
xen/netback: fix spurious event detection for common event case
mac80211: fix potential overflow when multiplying to u32 integers
bpf: Fix bpf_fib_lookup helper MTU check for SKB ctx
tcp: fix SO_RCVLOWAT related hangs under mem pressure
cxgb4/chtls/cxgbit: Keeping the max ofld immediate data size same in cxgb4 and ulds
b43: N-PHY: Fix the update of coef for the PHY revision >= 3case
ibmvnic: add memory barrier to protect long term buffer
ibmvnic: skip send_request_unmap for timeout reset
net: amd-xgbe: Reset the PHY rx data path when mailbox command timeout
net: amd-xgbe: Fix NETDEV WATCHDOG transmit queue timeout warning
net: amd-xgbe: Reset link when the link never comes back
net: amd-xgbe: Fix network fluctuations when using 1G BELFUSE SFP
net: mvneta: Remove per-cpu queue mapping for Armada 3700
fbdev: aty: SPARC64 requires FB_ATY_CT
drm/gma500: Fix error return code in psb_driver_load()
gma500: clean up error handling in init
crypto: sun4i-ss - fix kmap usage
drm/amdgpu: Fix macro name _AMDGPU_TRACE_H_ in preprocessor if condition
MIPS: c-r4k: Fix section mismatch for loongson2_sc_init
MIPS: lantiq: Explicitly compare LTQ_EBU_PCC_ISTAT against 0
media: i2c: ov5670: Fix PIXEL_RATE minimum value
media: camss: missing error code in msm_video_register()
media: vsp1: Fix an error handling path in the probe function
media: em28xx: Fix use-after-free in em28xx_alloc_urbs
media: media/pci: Fix memleak in empress_init
media: tm6000: Fix memleak in tm6000_start_stream
ASoC: cs42l56: fix up error handling in probe
crypto: bcm - Rename struct device_private to bcm_device_private
drm/amd/display: Fix 10/12 bpc setup in DCE output bit depth reduction.
media: lmedm04: Fix misuse of comma
media: qm1d1c0042: fix error return code in qm1d1c0042_init()
media: cx25821: Fix a bug when reallocating some dma memory
media: pxa_camera: declare variable when DEBUG is defined
media: uvcvideo: Accept invalid bFormatIndex and bFrameIndex values
crypto: talitos - Work around SEC6 ERRATA (AES-CTR mode data size error)
ata: ahci_brcm: Add back regulators management
ASoC: cpcap: fix microphone timeslot mask
f2fs: fix to avoid inconsistent quota data
drm/amdgpu: Prevent shift wrapping in amdgpu_read_mask()
Drivers: hv: vmbus: Avoid use-after-free in vmbus_onoffer_rescind()
btrfs: clarify error returns values in __load_free_space_cache
hwrng: timeriomem - Fix cooldown period calculation
crypto: ecdh_helper - Ensure 'len >= secret.len' in decode_key()
ima: Free IMA measurement buffer on error
ima: Free IMA measurement buffer after kexec syscall
fs/jfs: fix potential integer overflow on shift of a int
jffs2: fix use after free in jffs2_sum_write_data()
capabilities: Don't allow writing ambiguous v3 file capabilities
clk: meson: clk-pll: fix initializing the old rate (fallback) for a PLL
quota: Fix memory leak when handling corrupted quota file
spi: cadence-quadspi: Abort read if dummy cycles required are too many
clk: sunxi-ng: h6: Fix CEC clock
HID: core: detect and skip invalid inputs to snto32()
dmaengine: fsldma: Fix a resource leak in the remove function
dmaengine: fsldma: Fix a resource leak in an error handling path of the probe function
dmaengine: owl-dma: Fix a resource leak in the remove function
dmaengine: hsu: disable spurious interrupt
mfd: bd9571mwv: Use devm_mfd_add_devices()
fdt: Properly handle "no-map" field in the memory region
of/fdt: Make sure no-map does not remove already reserved regions
power: reset: at91-sama5d2_shdwc: fix wkupdbc mask
rtc: s5m: select REGMAP_I2C
clocksource/drivers/mxs_timer: Add missing semicolon when DEBUG is defined
RDMA/mlx5: Use the correct obj_id upon DEVX TIR creation
clk: sunxi-ng: h6: Fix clock divider range on some clocks
regulator: axp20x: Fix reference cout leak
certs: Fix blacklist flag type confusion
spi: atmel: Put allocated master before return
regulator: s5m8767: Drop regulators OF node reference
isofs: release buffer head before return
auxdisplay: ht16k33: Fix refresh rate handling
IB/umad: Return EIO in case of when device disassociated
IB/umad: Return EPOLLERR in case of when device disassociated
KVM: PPC: Make the VMX instruction emulation routines static
powerpc/47x: Disable 256k page size
mmc: usdhi6rol0: Fix a resource leak in the error handling path of the probe
mmc: renesas_sdhi_internal_dmac: Fix DMA buffer alignment from 8 to 128-bytes
ARM: 9046/1: decompressor: Do not clear SCTLR.nTLSMD for ARMv7+ cores
amba: Fix resource leak for drivers without .remove
tracepoint: Do not fail unregistering a probe due to memory failure
perf tools: Fix DSO filtering when not finding a map for a sampled address
RDMA/rxe: Fix coding error in rxe_recv.c
RDMA/rxe: Correct skb on loopback path
spi: stm32: properly handle 0 byte transfer
mfd: wm831x-auxadc: Prevent use after free in wm831x_auxadc_read_irq()
powerpc/pseries/dlpar: handle ibm, configure-connector delay status
powerpc/8xx: Fix software emulation interrupt
clk: qcom: gcc-msm8998: Fix Alpha PLL type for all GPLLs
spi: pxa2xx: Fix the controller numbering for Wildcat Point
Input: sur40 - fix an error code in sur40_probe()
perf intel-pt: Fix missing CYC processing in PSB
perf test: Fix unaligned access in sample parsing test
Input: elo - fix an error code in elo_connect()
sparc64: only select COMPAT_BINFMT_ELF if BINFMT_ELF is set
misc: eeprom_93xx46: Fix module alias to enable module autoprobe
misc: eeprom_93xx46: Add module alias to avoid breaking support for non device tree users
pwm: rockchip: rockchip_pwm_probe(): Remove superfluous clk_unprepare()
VMCI: Use set_page_dirty_lock() when unregistering guest memory
PCI: Align checking of syscall user config accessors
drm/msm/dsi: Correct io_start for MSM8994 (20nm PHY)
ext4: fix potential htree index checksum corruption
regmap: sdw: use _no_pm functions in regmap_read/write
i40e: Fix flow for IPv6 next header (extension header)
i40e: Add zero-initialization of AQ command structures
i40e: Fix overwriting flow control settings during driver loading
i40e: Fix VFs not created
i40e: Fix add TC filter for IPv6
net/mlx4_core: Add missed mlx4_free_cmd_mailbox()
vxlan: move debug check after netdev unregister
ocfs2: fix a use after free on error
mm/memory.c: fix potential pte_unmap_unlock pte error
mm/hugetlb: fix potential double free in hugetlb_register_node() error path
r8169: fix jumbo packet handling on RTL8168e
arm64: Add missing ISB after invalidating TLB in __primary_switch
i2c: brcmstb: Fix brcmstd_send_i2c_cmd condition
mm/rmap: fix potential pte_unmap on an not mapped pte
scsi: bnx2fc: Fix Kconfig warning & CNIC build errors
blk-settings: align max_sectors on "logical_block_size" boundary
ACPI: property: Fix fwnode string properties matching
ACPI: configfs: add missing check after configfs_register_default_group()
HID: wacom: Ignore attempts to overwrite the touch_max value from HID
Input: raydium_ts_i2c - do not send zero length
Input: xpad - add support for PowerA Enhanced Wired Controller for Xbox Series X|S
Input: joydev - prevent potential read overflow in ioctl
Input: i8042 - add ASUS Zenbook Flip to noselftest list
USB: serial: option: update interface mapping for ZTE P685M
usb: musb: Fix runtime PM race in musb_queue_resume_work
usb: dwc3: gadget: Fix setting of DEPCFG.bInterval_m1
usb: dwc3: gadget: Fix dep->interval for fullspeed interrupt
USB: serial: ftdi_sio: fix FTX sub-integer prescaler
USB: serial: mos7840: fix error code in mos7840_write()
USB: serial: mos7720: fix error code in mos7720_write()
ALSA: hda/realtek: modify EAPD in the ALC886
tpm_tis: Fix check_locality for correct locality acquisition
tpm_tis: Clean up locality release
KEYS: trusted: Fix migratable=1 failing
btrfs: abort the transaction if we fail to inc ref in btrfs_copy_root
btrfs: fix reloc root leak with 0 ref reloc roots on recovery
btrfs: fix extent buffer leak on failure to copy root
crypto: arm64/sha - add missing module aliases
crypto: sun4i-ss - checking sg length is not sufficient
crypto: sun4i-ss - handle BigEndian for cipher
seccomp: Add missing return in non-void function
misc: rtsx: init of rts522a add OCP power off when no card is present
drivers/misc/vmw_vmci: restrict too big queue size in qp_host_alloc_queue
pstore: Fix typo in compression option name
dts64: mt7622: fix slow sd card access
staging/mt7621-dma: mtk-hsdma.c->hsdma-mt7621.c
staging: gdm724x: Fix DMA from stack
staging: rtl8188eu: Add Edimax EW-7811UN V2 to device table
media: ipu3-cio2: Fix mbus_code processing in cio2_subdev_set_fmt()
x86/reboot: Force all cpus to exit VMX root if VMX is supported
floppy: reintroduce O_NDELAY fix
arm64: uprobe: Return EOPNOTSUPP for AARCH32 instruction probing
watchdog: mei_wdt: request stop on unregister
mtd: spi-nor: hisi-sfc: Put child node np on error path
fs/affs: release old buffer head on error path
seq_file: document how per-entry resources are managed.
x86: fix seq_file iteration for pat/memtype.c
hugetlb: fix copy_huge_page_from_user contig page struct assumption
libnvdimm/dimm: Avoid race between probe and available_slots_show()
arm64: Extend workaround for erratum 1024718 to all versions of Cortex-A55
module: Ignore _GLOBAL_OFFSET_TABLE_ when warning for undefined symbols
mmc: sdhci-esdhc-imx: fix kernel panic when remove module
gpio: pcf857x: Fix missing first interrupt
printk: fix deadlock when kernel panic
cpufreq: intel_pstate: Get per-CPU max freq via MSR_HWP_CAPABILITIES if available
f2fs: fix out-of-repair __setattr_copy()
sparc32: fix a user-triggerable oops in clear_user()
gfs2: Don't skip dlm unlock if glock has an lvb
dm: fix deadlock when swapping to encrypted device
dm era: Recover committed writeset after crash
dm era: Verify the data block size hasn't changed
dm era: Fix bitset memory leaks
dm era: Use correct value size in equality function of writeset tree
dm era: Reinitialize bitset cache before digesting a new writeset
dm era: only resize metadata in preresume
icmp: introduce helper for nat'd source address in network device context
icmp: allow icmpv6_ndo_send to work with CONFIG_IPV6=n
gtp: use icmp_ndo_send helper
sunvnet: use icmp_ndo_send helper
xfrm: interface: use icmp_ndo_send helper
ipv6: icmp6: avoid indirect call for icmpv6_send()
ipv6: silence compilation warning for non-IPV6 builds
net: icmp: pass zeroed opts from icmp{,v6}_ndo_send before sending
dm era: Update in-core bitset after committing the metadata
net: qrtr: Fix memory leak in qrtr_tun_open
ARM: dts: aspeed: Add LCLK to lpc-snoop
Linux 4.19.178
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
Change-Id: I8c07c10dd29a1233f238b533622d7b32bd22bdb0
This commit is contained in:
Greg Kroah-Hartman
commit
6455a150fa
@ -192,6 +192,12 @@ between the calls to start() and stop(), so holding a lock during that time
|
||||
is a reasonable thing to do. The seq_file code will also avoid taking any
|
||||
other locks while the iterator is active.
|
||||
|
||||
The iterater value returned by start() or next() is guaranteed to be
|
||||
passed to a subsequent next() or stop() call. This allows resources
|
||||
such as locks that were taken to be reliably released. There is *no*
|
||||
guarantee that the iterator will be passed to show(), though in practice
|
||||
it often will be.
|
||||
|
||||
|
||||
Formatted output
|
||||
|
||||
|
||||
2
Makefile
2
Makefile
@ -1,7 +1,7 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 19
|
||||
SUBLEVEL = 177
|
||||
SUBLEVEL = 178
|
||||
EXTRAVERSION =
|
||||
NAME = "People's Front"
|
||||
|
||||
|
||||
@ -1090,9 +1090,9 @@ __armv4_mmu_cache_off:
|
||||
__armv7_mmu_cache_off:
|
||||
mrc p15, 0, r0, c1, c0
|
||||
#ifdef CONFIG_MMU
|
||||
bic r0, r0, #0x000d
|
||||
bic r0, r0, #0x0005
|
||||
#else
|
||||
bic r0, r0, #0x000c
|
||||
bic r0, r0, #0x0004
|
||||
#endif
|
||||
mcr p15, 0, r0, c1, c0 @ turn MMU and cache off
|
||||
mov r12, lr
|
||||
|
||||
@ -70,6 +70,9 @@
|
||||
|
||||
system-leds {
|
||||
compatible = "gpio-leds";
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&helios_system_led_pins>;
|
||||
|
||||
status-led {
|
||||
label = "helios4:green:status";
|
||||
gpios = <&gpio0 24 GPIO_ACTIVE_LOW>;
|
||||
@ -86,6 +89,9 @@
|
||||
|
||||
io-leds {
|
||||
compatible = "gpio-leds";
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&helios_io_led_pins>;
|
||||
|
||||
sata1-led {
|
||||
label = "helios4:green:ata1";
|
||||
gpios = <&gpio1 17 GPIO_ACTIVE_LOW>;
|
||||
@ -121,11 +127,15 @@
|
||||
fan1: j10-pwm {
|
||||
compatible = "pwm-fan";
|
||||
pwms = <&gpio1 9 40000>; /* Target freq:25 kHz */
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&helios_fan1_pins>;
|
||||
};
|
||||
|
||||
fan2: j17-pwm {
|
||||
compatible = "pwm-fan";
|
||||
pwms = <&gpio1 23 40000>; /* Target freq:25 kHz */
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&helios_fan2_pins>;
|
||||
};
|
||||
|
||||
usb2_phy: usb2-phy {
|
||||
@ -291,16 +301,22 @@
|
||||
"mpp39", "mpp40";
|
||||
marvell,function = "sd0";
|
||||
};
|
||||
helios_led_pins: helios-led-pins {
|
||||
marvell,pins = "mpp24", "mpp25",
|
||||
"mpp49", "mpp50",
|
||||
helios_system_led_pins: helios-system-led-pins {
|
||||
marvell,pins = "mpp24", "mpp25";
|
||||
marvell,function = "gpio";
|
||||
};
|
||||
helios_io_led_pins: helios-io-led-pins {
|
||||
marvell,pins = "mpp49", "mpp50",
|
||||
"mpp52", "mpp53",
|
||||
"mpp54";
|
||||
marvell,function = "gpio";
|
||||
};
|
||||
helios_fan_pins: helios-fan-pins {
|
||||
marvell,pins = "mpp41", "mpp43",
|
||||
"mpp48", "mpp55";
|
||||
helios_fan1_pins: helios_fan1_pins {
|
||||
marvell,pins = "mpp41", "mpp43";
|
||||
marvell,function = "gpio";
|
||||
};
|
||||
helios_fan2_pins: helios_fan2_pins {
|
||||
marvell,pins = "mpp48", "mpp55";
|
||||
marvell,function = "gpio";
|
||||
};
|
||||
microsom_spi1_cs_pins: spi1-cs-pins {
|
||||
|
||||
@ -312,6 +312,7 @@
|
||||
compatible = "aspeed,ast2400-ibt-bmc";
|
||||
reg = <0xc0 0x18>;
|
||||
interrupts = <8>;
|
||||
clocks = <&syscon ASPEED_CLK_GATE_LCLK>;
|
||||
status = "disabled";
|
||||
};
|
||||
};
|
||||
|
||||
@ -372,6 +372,7 @@
|
||||
compatible = "aspeed,ast2500-ibt-bmc";
|
||||
reg = <0xc0 0x18>;
|
||||
interrupts = <8>;
|
||||
clocks = <&syscon ASPEED_CLK_GATE_LCLK>;
|
||||
status = "disabled";
|
||||
};
|
||||
};
|
||||
|
||||
@ -68,7 +68,7 @@
|
||||
s2mps14_pmic@66 {
|
||||
compatible = "samsung,s2mps14-pmic";
|
||||
interrupt-parent = <&gpx3>;
|
||||
interrupts = <5 IRQ_TYPE_NONE>;
|
||||
interrupts = <5 IRQ_TYPE_LEVEL_LOW>;
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&s2mps14_irq>;
|
||||
reg = <0x66>;
|
||||
|
||||
@ -188,7 +188,7 @@
|
||||
s2mps14_pmic@66 {
|
||||
compatible = "samsung,s2mps14-pmic";
|
||||
interrupt-parent = <&gpx0>;
|
||||
interrupts = <7 IRQ_TYPE_NONE>;
|
||||
interrupts = <7 IRQ_TYPE_LEVEL_LOW>;
|
||||
reg = <0x66>;
|
||||
wakeup-source;
|
||||
|
||||
|
||||
@ -253,7 +253,7 @@
|
||||
s2mps14_pmic@66 {
|
||||
compatible = "samsung,s2mps14-pmic";
|
||||
interrupt-parent = <&gpx0>;
|
||||
interrupts = <7 IRQ_TYPE_NONE>;
|
||||
interrupts = <7 IRQ_TYPE_LEVEL_LOW>;
|
||||
reg = <0x66>;
|
||||
wakeup-source;
|
||||
|
||||
|
||||
@ -108,7 +108,7 @@
|
||||
compatible = "samsung,s5m8767-pmic";
|
||||
reg = <0x66>;
|
||||
interrupt-parent = <&gpx3>;
|
||||
interrupts = <2 IRQ_TYPE_NONE>;
|
||||
interrupts = <2 IRQ_TYPE_LEVEL_LOW>;
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&s5m8767_irq &s5m8767_dvs &s5m8767_ds>;
|
||||
wakeup-source;
|
||||
|
||||
@ -84,7 +84,7 @@
|
||||
reg = <0x66>;
|
||||
|
||||
interrupt-parent = <&gpx3>;
|
||||
interrupts = <2 IRQ_TYPE_EDGE_FALLING>;
|
||||
interrupts = <2 IRQ_TYPE_LEVEL_LOW>;
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&s2mps11_irq>;
|
||||
|
||||
|
||||
@ -136,7 +136,7 @@
|
||||
samsung,s2mps11-acokb-ground;
|
||||
|
||||
interrupt-parent = <&gpx0>;
|
||||
interrupts = <4 IRQ_TYPE_EDGE_FALLING>;
|
||||
interrupts = <4 IRQ_TYPE_LEVEL_LOW>;
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&s2mps11_irq>;
|
||||
|
||||
|
||||
@ -33,10 +33,12 @@
|
||||
};
|
||||
|
||||
ocp {
|
||||
/* 4430 has only gpio_86 tshut and no talert interrupt */
|
||||
bandgap: bandgap@4a002260 {
|
||||
reg = <0x4a002260 0x4
|
||||
0x4a00232C 0x4>;
|
||||
compatible = "ti,omap4430-bandgap";
|
||||
gpios = <&gpio3 22 GPIO_ACTIVE_HIGH>;
|
||||
|
||||
#thermal-sensor-cells = <0>;
|
||||
};
|
||||
|
||||
@ -481,7 +481,7 @@ config ARM64_ERRATUM_1024718
|
||||
help
|
||||
This option adds work around for Arm Cortex-A55 Erratum 1024718.
|
||||
|
||||
Affected Cortex-A55 cores (r0p0, r0p1, r1p0) could cause incorrect
|
||||
Affected Cortex-A55 cores (all revisions) could cause incorrect
|
||||
update of the hardware dirty bit when the DBM/AP bits are updated
|
||||
without a break-before-make. The work around is to disable the usage
|
||||
of hardware DBM locally on the affected cores. CPUs not affected by
|
||||
|
||||
@ -67,8 +67,6 @@
|
||||
};
|
||||
|
||||
&ehci0 {
|
||||
phys = <&usbphy 0>;
|
||||
phy-names = "usb";
|
||||
status = "okay";
|
||||
};
|
||||
|
||||
@ -107,6 +105,7 @@
|
||||
pinctrl-0 = <&mmc2_pins>;
|
||||
vmmc-supply = <®_dcdc1>;
|
||||
vqmmc-supply = <®_eldo1>;
|
||||
max-frequency = <200000000>;
|
||||
bus-width = <8>;
|
||||
non-removable;
|
||||
cap-mmc-hw-reset;
|
||||
@ -115,8 +114,6 @@
|
||||
};
|
||||
|
||||
&ohci0 {
|
||||
phys = <&usbphy 0>;
|
||||
phy-names = "usb";
|
||||
status = "okay";
|
||||
};
|
||||
|
||||
|
||||
@ -51,7 +51,6 @@
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&mmc0_pins>;
|
||||
vmmc-supply = <®_dcdc1>;
|
||||
non-removable;
|
||||
disable-wp;
|
||||
bus-width = <4>;
|
||||
cd-gpios = <&pio 5 6 GPIO_ACTIVE_LOW>; /* PF6 */
|
||||
|
||||
@ -264,7 +264,7 @@
|
||||
resets = <&ccu RST_BUS_MMC2>;
|
||||
reset-names = "ahb";
|
||||
interrupts = <GIC_SPI 62 IRQ_TYPE_LEVEL_HIGH>;
|
||||
max-frequency = <200000000>;
|
||||
max-frequency = <150000000>;
|
||||
status = "disabled";
|
||||
#address-cells = <1>;
|
||||
#size-cells = <0>;
|
||||
@ -312,6 +312,8 @@
|
||||
<&ccu CLK_USB_OHCI0>;
|
||||
resets = <&ccu RST_BUS_OHCI0>,
|
||||
<&ccu RST_BUS_EHCI0>;
|
||||
phys = <&usbphy 0>;
|
||||
phy-names = "usb";
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
@ -322,6 +324,8 @@
|
||||
clocks = <&ccu CLK_BUS_OHCI0>,
|
||||
<&ccu CLK_USB_OHCI0>;
|
||||
resets = <&ccu RST_BUS_OHCI0>;
|
||||
phys = <&usbphy 0>;
|
||||
phy-names = "usb";
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
|
||||
@ -378,7 +378,7 @@
|
||||
s2mps13-pmic@66 {
|
||||
compatible = "samsung,s2mps13-pmic";
|
||||
interrupt-parent = <&gpa0>;
|
||||
interrupts = <7 IRQ_TYPE_NONE>;
|
||||
interrupts = <7 IRQ_TYPE_LEVEL_LOW>;
|
||||
reg = <0x66>;
|
||||
samsung,s2mps11-wrstbi-ground;
|
||||
|
||||
|
||||
@ -85,7 +85,7 @@
|
||||
s2mps15_pmic@66 {
|
||||
compatible = "samsung,s2mps15-pmic";
|
||||
reg = <0x66>;
|
||||
interrupts = <2 IRQ_TYPE_NONE>;
|
||||
interrupts = <2 IRQ_TYPE_LEVEL_LOW>;
|
||||
interrupt-parent = <&gpa0>;
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&pmic_irq>;
|
||||
|
||||
@ -641,6 +641,8 @@
|
||||
clocks = <&pericfg CLK_PERI_MSDC30_1_PD>,
|
||||
<&topckgen CLK_TOP_AXI_SEL>;
|
||||
clock-names = "source", "hclk";
|
||||
resets = <&pericfg MT7622_PERI_MSDC1_SW_RST>;
|
||||
reset-names = "hrst";
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
|
||||
@ -826,6 +826,7 @@
|
||||
<&tegra_car 128>, /* hda2hdmi */
|
||||
<&tegra_car 111>; /* hda2codec_2x */
|
||||
reset-names = "hda", "hda2hdmi", "hda2codec_2x";
|
||||
power-domains = <&pd_sor>;
|
||||
status = "disabled";
|
||||
};
|
||||
|
||||
|
||||
@ -64,7 +64,7 @@
|
||||
no-map;
|
||||
};
|
||||
|
||||
reserved@8668000 {
|
||||
reserved@86680000 {
|
||||
reg = <0x0 0x86680000 0x0 0x80000>;
|
||||
no-map;
|
||||
};
|
||||
@ -77,7 +77,7 @@
|
||||
qcom,client-id = <1>;
|
||||
};
|
||||
|
||||
rfsa@867e00000 {
|
||||
rfsa@867e0000 {
|
||||
reg = <0x0 0x867e0000 0x0 0x20000>;
|
||||
no-map;
|
||||
};
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
MODULE_DESCRIPTION("SHA1 secure hash using ARMv8 Crypto Extensions");
|
||||
MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_ALIAS_CRYPTO("sha1");
|
||||
|
||||
struct sha1_ce_state {
|
||||
struct sha1_state sst;
|
||||
|
||||
@ -21,6 +21,8 @@
|
||||
MODULE_DESCRIPTION("SHA-224/SHA-256 secure hash using ARMv8 Crypto Extensions");
|
||||
MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_ALIAS_CRYPTO("sha224");
|
||||
MODULE_ALIAS_CRYPTO("sha256");
|
||||
|
||||
struct sha256_ce_state {
|
||||
struct sha256_state sst;
|
||||
|
||||
@ -22,6 +22,10 @@
|
||||
MODULE_DESCRIPTION("SHA3 secure hash using ARMv8 Crypto Extensions");
|
||||
MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_ALIAS_CRYPTO("sha3-224");
|
||||
MODULE_ALIAS_CRYPTO("sha3-256");
|
||||
MODULE_ALIAS_CRYPTO("sha3-384");
|
||||
MODULE_ALIAS_CRYPTO("sha3-512");
|
||||
|
||||
asmlinkage void sha3_ce_transform(u64 *st, const u8 *data, int blocks,
|
||||
int md_len);
|
||||
|
||||
@ -22,6 +22,8 @@
|
||||
MODULE_DESCRIPTION("SHA-384/SHA-512 secure hash using ARMv8 Crypto Extensions");
|
||||
MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_ALIAS_CRYPTO("sha384");
|
||||
MODULE_ALIAS_CRYPTO("sha512");
|
||||
|
||||
asmlinkage void sha512_ce_transform(struct sha512_state *sst, u8 const *src,
|
||||
int blocks);
|
||||
|
||||
@ -1012,7 +1012,7 @@ static bool cpu_has_broken_dbm(void)
|
||||
/* List of CPUs which have broken DBM support. */
|
||||
static const struct midr_range cpus[] = {
|
||||
#ifdef CONFIG_ARM64_ERRATUM_1024718
|
||||
MIDR_RANGE(MIDR_CORTEX_A55, 0, 0, 1, 0), // A55 r0p0 -r1p0
|
||||
MIDR_ALL_VERSIONS(MIDR_CORTEX_A55),
|
||||
#endif
|
||||
{},
|
||||
};
|
||||
|
||||
@ -960,6 +960,7 @@ __primary_switch:
|
||||
|
||||
tlbi vmalle1 // Remove any stale TLB entries
|
||||
dsb nsh
|
||||
isb
|
||||
|
||||
msr sctlr_el1, x19 // re-enable the MMU
|
||||
isb
|
||||
|
||||
@ -41,7 +41,7 @@ int arch_uprobe_analyze_insn(struct arch_uprobe *auprobe, struct mm_struct *mm,
|
||||
|
||||
/* TODO: Currently we do not support AARCH32 instruction probing */
|
||||
if (mm->context.flags & MMCF_AARCH32)
|
||||
return -ENOTSUPP;
|
||||
return -EOPNOTSUPP;
|
||||
else if (!IS_ALIGNED(addr, AARCH64_INSN_SIZE))
|
||||
return -EINVAL;
|
||||
|
||||
|
||||
@ -93,6 +93,7 @@ SECTIONS
|
||||
|
||||
INIT_TASK_DATA(THREAD_SIZE)
|
||||
NOSAVE_DATA
|
||||
PAGE_ALIGNED_DATA(PAGE_SIZE)
|
||||
CACHELINE_ALIGNED_DATA(1 << CONFIG_MIPS_L1_CACHE_SHIFT)
|
||||
READ_MOSTLY_DATA(1 << CONFIG_MIPS_L1_CACHE_SHIFT)
|
||||
DATA_DATA
|
||||
|
||||
@ -244,7 +244,7 @@ static void ltq_hw_irq_handler(struct irq_desc *desc)
|
||||
generic_handle_irq(irq_linear_revmap(ltq_domain, hwirq));
|
||||
|
||||
/* if this is a EBU irq, we need to ack it or get a deadlock */
|
||||
if ((irq == LTQ_ICU_EBU_IRQ) && (module == 0) && LTQ_EBU_PCC_ISTAT)
|
||||
if (irq == LTQ_ICU_EBU_IRQ && !module && LTQ_EBU_PCC_ISTAT != 0)
|
||||
ltq_ebu_w32(ltq_ebu_r32(LTQ_EBU_PCC_ISTAT) | 0x10,
|
||||
LTQ_EBU_PCC_ISTAT);
|
||||
}
|
||||
|
||||
@ -1673,7 +1673,7 @@ static int probe_scache(void)
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void __init loongson2_sc_init(void)
|
||||
static void loongson2_sc_init(void)
|
||||
{
|
||||
struct cpuinfo_mips *c = ¤t_cpu_data;
|
||||
|
||||
|
||||
@ -709,7 +709,7 @@ config PPC_64K_PAGES
|
||||
|
||||
config PPC_256K_PAGES
|
||||
bool "256k page size"
|
||||
depends on 44x && !STDBINUTILS
|
||||
depends on 44x && !STDBINUTILS && !PPC_47x
|
||||
help
|
||||
Make the page size 256k.
|
||||
|
||||
|
||||
@ -269,7 +269,7 @@ SystemCall:
|
||||
/* On the MPC8xx, this is a software emulation interrupt. It occurs
|
||||
* for all unimplemented and illegal instructions.
|
||||
*/
|
||||
EXCEPTION(0x1000, SoftEmu, program_check_exception, EXC_XFER_STD)
|
||||
EXCEPTION(0x1000, SoftEmu, emulation_assist_interrupt, EXC_XFER_STD)
|
||||
|
||||
. = 0x1100
|
||||
/*
|
||||
|
||||
@ -1497,7 +1497,7 @@ int kvmppc_handle_vmx_load(struct kvm_run *run, struct kvm_vcpu *vcpu,
|
||||
return emulated;
|
||||
}
|
||||
|
||||
int kvmppc_get_vmx_dword(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
static int kvmppc_get_vmx_dword(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
{
|
||||
union kvmppc_one_reg reg;
|
||||
int vmx_offset = 0;
|
||||
@ -1515,7 +1515,7 @@ int kvmppc_get_vmx_dword(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
return result;
|
||||
}
|
||||
|
||||
int kvmppc_get_vmx_word(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
static int kvmppc_get_vmx_word(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
{
|
||||
union kvmppc_one_reg reg;
|
||||
int vmx_offset = 0;
|
||||
@ -1533,7 +1533,7 @@ int kvmppc_get_vmx_word(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
return result;
|
||||
}
|
||||
|
||||
int kvmppc_get_vmx_hword(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
static int kvmppc_get_vmx_hword(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
{
|
||||
union kvmppc_one_reg reg;
|
||||
int vmx_offset = 0;
|
||||
@ -1551,7 +1551,7 @@ int kvmppc_get_vmx_hword(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
return result;
|
||||
}
|
||||
|
||||
int kvmppc_get_vmx_byte(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
static int kvmppc_get_vmx_byte(struct kvm_vcpu *vcpu, int index, u64 *val)
|
||||
{
|
||||
union kvmppc_one_reg reg;
|
||||
int vmx_offset = 0;
|
||||
|
||||
@ -132,7 +132,6 @@ void dlpar_free_cc_nodes(struct device_node *dn)
|
||||
#define NEXT_PROPERTY 3
|
||||
#define PREV_PARENT 4
|
||||
#define MORE_MEMORY 5
|
||||
#define CALL_AGAIN -2
|
||||
#define ERR_CFG_USE -9003
|
||||
|
||||
struct device_node *dlpar_configure_connector(__be32 drc_index,
|
||||
@ -173,6 +172,9 @@ struct device_node *dlpar_configure_connector(__be32 drc_index,
|
||||
|
||||
spin_unlock(&rtas_data_buf_lock);
|
||||
|
||||
if (rtas_busy_delay(rc))
|
||||
continue;
|
||||
|
||||
switch (rc) {
|
||||
case COMPLETE:
|
||||
break;
|
||||
@ -221,9 +223,6 @@ struct device_node *dlpar_configure_connector(__be32 drc_index,
|
||||
last_dn = last_dn->parent;
|
||||
break;
|
||||
|
||||
case CALL_AGAIN:
|
||||
break;
|
||||
|
||||
case MORE_MEMORY:
|
||||
case ERR_CFG_USE:
|
||||
default:
|
||||
|
||||
@ -554,7 +554,7 @@ config COMPAT
|
||||
bool
|
||||
depends on SPARC64
|
||||
default y
|
||||
select COMPAT_BINFMT_ELF
|
||||
select COMPAT_BINFMT_ELF if BINFMT_ELF
|
||||
select HAVE_UID16
|
||||
select ARCH_WANT_OLD_COMPAT_IPC
|
||||
select COMPAT_OLD_SIGACTION
|
||||
|
||||
@ -142,6 +142,7 @@ __bzero:
|
||||
ZERO_LAST_BLOCKS(%o0, 0x48, %g2)
|
||||
ZERO_LAST_BLOCKS(%o0, 0x08, %g2)
|
||||
13:
|
||||
EXT(12b, 13b, 21f)
|
||||
be 8f
|
||||
andcc %o1, 4, %g0
|
||||
|
||||
|
||||
@ -538,29 +538,20 @@ static void emergency_vmx_disable_all(void)
|
||||
local_irq_disable();
|
||||
|
||||
/*
|
||||
* We need to disable VMX on all CPUs before rebooting, otherwise
|
||||
* we risk hanging up the machine, because the CPU ignore INIT
|
||||
* signals when VMX is enabled.
|
||||
* Disable VMX on all CPUs before rebooting, otherwise we risk hanging
|
||||
* the machine, because the CPU blocks INIT when it's in VMX root.
|
||||
*
|
||||
* We can't take any locks and we may be on an inconsistent
|
||||
* state, so we use NMIs as IPIs to tell the other CPUs to disable
|
||||
* VMX and halt.
|
||||
* We can't take any locks and we may be on an inconsistent state, so
|
||||
* use NMIs as IPIs to tell the other CPUs to exit VMX root and halt.
|
||||
*
|
||||
* For safety, we will avoid running the nmi_shootdown_cpus()
|
||||
* stuff unnecessarily, but we don't have a way to check
|
||||
* if other CPUs have VMX enabled. So we will call it only if the
|
||||
* CPU we are running on has VMX enabled.
|
||||
*
|
||||
* We will miss cases where VMX is not enabled on all CPUs. This
|
||||
* shouldn't do much harm because KVM always enable VMX on all
|
||||
* CPUs anyway. But we can miss it on the small window where KVM
|
||||
* is still enabling VMX.
|
||||
* Do the NMI shootdown even if VMX if off on _this_ CPU, as that
|
||||
* doesn't prevent a different CPU from being in VMX root operation.
|
||||
*/
|
||||
if (cpu_has_vmx() && cpu_vmx_enabled()) {
|
||||
/* Disable VMX on this CPU. */
|
||||
cpu_vmxoff();
|
||||
if (cpu_has_vmx()) {
|
||||
/* Safely force _this_ CPU out of VMX root operation. */
|
||||
__cpu_emergency_vmxoff();
|
||||
|
||||
/* Halt and disable VMX on the other CPUs */
|
||||
/* Halt and exit VMX root operation on the other CPUs. */
|
||||
nmi_shootdown_cpus(vmxoff_nmi);
|
||||
|
||||
}
|
||||
|
||||
@ -1131,12 +1131,14 @@ static void *memtype_seq_start(struct seq_file *seq, loff_t *pos)
|
||||
|
||||
static void *memtype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
||||
{
|
||||
kfree(v);
|
||||
++*pos;
|
||||
return memtype_get_idx(*pos);
|
||||
}
|
||||
|
||||
static void memtype_seq_stop(struct seq_file *seq, void *v)
|
||||
{
|
||||
kfree(v);
|
||||
}
|
||||
|
||||
static int memtype_seq_show(struct seq_file *seq, void *v)
|
||||
@ -1145,7 +1147,6 @@ static int memtype_seq_show(struct seq_file *seq, void *v)
|
||||
|
||||
seq_printf(seq, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry->type),
|
||||
print_entry->start, print_entry->end);
|
||||
kfree(print_entry);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -2478,6 +2478,7 @@ static void __bfq_set_in_service_queue(struct bfq_data *bfqd,
|
||||
}
|
||||
|
||||
bfqd->in_service_queue = bfqq;
|
||||
bfqd->in_serv_last_pos = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -1061,6 +1061,7 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id,
|
||||
mutex_init(&q->blk_trace_mutex);
|
||||
#endif
|
||||
mutex_init(&q->sysfs_lock);
|
||||
mutex_init(&q->sysfs_dir_lock);
|
||||
spin_lock_init(&q->__queue_lock);
|
||||
|
||||
if (!q->mq_ops)
|
||||
|
||||
@ -264,7 +264,7 @@ void blk_mq_unregister_dev(struct device *dev, struct request_queue *q)
|
||||
struct blk_mq_hw_ctx *hctx;
|
||||
int i;
|
||||
|
||||
lockdep_assert_held(&q->sysfs_lock);
|
||||
lockdep_assert_held(&q->sysfs_dir_lock);
|
||||
|
||||
queue_for_each_hw_ctx(q, hctx, i)
|
||||
blk_mq_unregister_hctx(hctx);
|
||||
@ -312,7 +312,7 @@ int __blk_mq_register_dev(struct device *dev, struct request_queue *q)
|
||||
int ret, i;
|
||||
|
||||
WARN_ON_ONCE(!q->kobj.parent);
|
||||
lockdep_assert_held(&q->sysfs_lock);
|
||||
lockdep_assert_held(&q->sysfs_dir_lock);
|
||||
|
||||
ret = kobject_add(&q->mq_kobj, kobject_get(&dev->kobj), "%s", "mq");
|
||||
if (ret < 0)
|
||||
@ -358,7 +358,7 @@ void blk_mq_sysfs_unregister(struct request_queue *q)
|
||||
struct blk_mq_hw_ctx *hctx;
|
||||
int i;
|
||||
|
||||
mutex_lock(&q->sysfs_lock);
|
||||
mutex_lock(&q->sysfs_dir_lock);
|
||||
if (!q->mq_sysfs_init_done)
|
||||
goto unlock;
|
||||
|
||||
@ -366,7 +366,7 @@ void blk_mq_sysfs_unregister(struct request_queue *q)
|
||||
blk_mq_unregister_hctx(hctx);
|
||||
|
||||
unlock:
|
||||
mutex_unlock(&q->sysfs_lock);
|
||||
mutex_unlock(&q->sysfs_dir_lock);
|
||||
}
|
||||
|
||||
int blk_mq_sysfs_register(struct request_queue *q)
|
||||
@ -374,7 +374,7 @@ int blk_mq_sysfs_register(struct request_queue *q)
|
||||
struct blk_mq_hw_ctx *hctx;
|
||||
int i, ret = 0;
|
||||
|
||||
mutex_lock(&q->sysfs_lock);
|
||||
mutex_lock(&q->sysfs_dir_lock);
|
||||
if (!q->mq_sysfs_init_done)
|
||||
goto unlock;
|
||||
|
||||
@ -385,7 +385,7 @@ int blk_mq_sysfs_register(struct request_queue *q)
|
||||
}
|
||||
|
||||
unlock:
|
||||
mutex_unlock(&q->sysfs_lock);
|
||||
mutex_unlock(&q->sysfs_dir_lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -513,6 +513,14 @@ void blk_queue_io_opt(struct request_queue *q, unsigned int opt)
|
||||
}
|
||||
EXPORT_SYMBOL(blk_queue_io_opt);
|
||||
|
||||
static unsigned int blk_round_down_sectors(unsigned int sectors, unsigned int lbs)
|
||||
{
|
||||
sectors = round_down(sectors, lbs >> SECTOR_SHIFT);
|
||||
if (sectors < PAGE_SIZE >> SECTOR_SHIFT)
|
||||
sectors = PAGE_SIZE >> SECTOR_SHIFT;
|
||||
return sectors;
|
||||
}
|
||||
|
||||
/**
|
||||
* blk_queue_stack_limits - inherit underlying queue limits for stacked drivers
|
||||
* @t: the stacking driver (top)
|
||||
@ -639,6 +647,10 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
|
||||
ret = -1;
|
||||
}
|
||||
|
||||
t->max_sectors = blk_round_down_sectors(t->max_sectors, t->logical_block_size);
|
||||
t->max_hw_sectors = blk_round_down_sectors(t->max_hw_sectors, t->logical_block_size);
|
||||
t->max_dev_sectors = blk_round_down_sectors(t->max_dev_sectors, t->logical_block_size);
|
||||
|
||||
/* Discard alignment and granularity */
|
||||
if (b->discard_granularity) {
|
||||
alignment = queue_limit_discard_alignment(b, start);
|
||||
|
||||
@ -892,14 +892,14 @@ int blk_register_queue(struct gendisk *disk)
|
||||
int ret;
|
||||
struct device *dev = disk_to_dev(disk);
|
||||
struct request_queue *q = disk->queue;
|
||||
bool has_elevator = false;
|
||||
|
||||
if (WARN_ON(!q))
|
||||
return -ENXIO;
|
||||
|
||||
WARN_ONCE(test_bit(QUEUE_FLAG_REGISTERED, &q->queue_flags),
|
||||
WARN_ONCE(blk_queue_registered(q),
|
||||
"%s is registering an already registered queue\n",
|
||||
kobject_name(&dev->kobj));
|
||||
queue_flag_set_unlocked(QUEUE_FLAG_REGISTERED, q);
|
||||
|
||||
/*
|
||||
* SCSI probing may synchronously create and destroy a lot of
|
||||
@ -920,8 +920,7 @@ int blk_register_queue(struct gendisk *disk)
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* Prevent changes through sysfs until registration is completed. */
|
||||
mutex_lock(&q->sysfs_lock);
|
||||
mutex_lock(&q->sysfs_dir_lock);
|
||||
|
||||
ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
|
||||
if (ret < 0) {
|
||||
@ -934,26 +933,37 @@ int blk_register_queue(struct gendisk *disk)
|
||||
blk_mq_debugfs_register(q);
|
||||
}
|
||||
|
||||
kobject_uevent(&q->kobj, KOBJ_ADD);
|
||||
|
||||
wbt_enable_default(q);
|
||||
|
||||
blk_throtl_register_queue(q);
|
||||
|
||||
mutex_lock(&q->sysfs_lock);
|
||||
/*
|
||||
* The flag of QUEUE_FLAG_REGISTERED isn't set yet, so elevator
|
||||
* switch won't happen at all.
|
||||
*/
|
||||
if (q->request_fn || (q->mq_ops && q->elevator)) {
|
||||
ret = elv_register_queue(q);
|
||||
ret = elv_register_queue(q, false);
|
||||
if (ret) {
|
||||
mutex_unlock(&q->sysfs_lock);
|
||||
kobject_uevent(&q->kobj, KOBJ_REMOVE);
|
||||
mutex_unlock(&q->sysfs_dir_lock);
|
||||
kobject_del(&q->kobj);
|
||||
blk_trace_remove_sysfs(dev);
|
||||
kobject_put(&dev->kobj);
|
||||
return ret;
|
||||
}
|
||||
has_elevator = true;
|
||||
}
|
||||
|
||||
blk_queue_flag_set(QUEUE_FLAG_REGISTERED, q);
|
||||
wbt_enable_default(q);
|
||||
blk_throtl_register_queue(q);
|
||||
|
||||
/* Now everything is ready and send out KOBJ_ADD uevent */
|
||||
kobject_uevent(&q->kobj, KOBJ_ADD);
|
||||
if (has_elevator)
|
||||
kobject_uevent(&q->elevator->kobj, KOBJ_ADD);
|
||||
mutex_unlock(&q->sysfs_lock);
|
||||
|
||||
ret = 0;
|
||||
unlock:
|
||||
mutex_unlock(&q->sysfs_lock);
|
||||
mutex_unlock(&q->sysfs_dir_lock);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(blk_register_queue);
|
||||
@ -973,7 +983,7 @@ void blk_unregister_queue(struct gendisk *disk)
|
||||
return;
|
||||
|
||||
/* Return early if disk->queue was never registered. */
|
||||
if (!test_bit(QUEUE_FLAG_REGISTERED, &q->queue_flags))
|
||||
if (!blk_queue_registered(q))
|
||||
return;
|
||||
|
||||
/*
|
||||
@ -982,25 +992,30 @@ void blk_unregister_queue(struct gendisk *disk)
|
||||
* concurrent elv_iosched_store() calls.
|
||||
*/
|
||||
mutex_lock(&q->sysfs_lock);
|
||||
|
||||
blk_queue_flag_clear(QUEUE_FLAG_REGISTERED, q);
|
||||
mutex_unlock(&q->sysfs_lock);
|
||||
|
||||
mutex_lock(&q->sysfs_dir_lock);
|
||||
/*
|
||||
* Remove the sysfs attributes before unregistering the queue data
|
||||
* structures that can be modified through sysfs.
|
||||
*/
|
||||
if (q->mq_ops)
|
||||
blk_mq_unregister_dev(disk_to_dev(disk), q);
|
||||
mutex_unlock(&q->sysfs_lock);
|
||||
|
||||
kobject_uevent(&q->kobj, KOBJ_REMOVE);
|
||||
kobject_del(&q->kobj);
|
||||
blk_trace_remove_sysfs(disk_to_dev(disk));
|
||||
|
||||
mutex_lock(&q->sysfs_lock);
|
||||
if (q->request_fn || (q->mq_ops && q->elevator))
|
||||
/*
|
||||
* q->kobj has been removed, so it is safe to check if elevator
|
||||
* exists without holding q->sysfs_lock.
|
||||
*/
|
||||
if (q->request_fn || q->elevator)
|
||||
elv_unregister_queue(q);
|
||||
mutex_unlock(&q->sysfs_lock);
|
||||
mutex_unlock(&q->sysfs_dir_lock);
|
||||
|
||||
kobject_put(&disk_to_dev(disk)->kobj);
|
||||
}
|
||||
|
||||
@ -708,7 +708,7 @@ void wbt_enable_default(struct request_queue *q)
|
||||
return;
|
||||
|
||||
/* Queue not registered? Maybe shutting down... */
|
||||
if (!test_bit(QUEUE_FLAG_REGISTERED, &q->queue_flags))
|
||||
if (!blk_queue_registered(q))
|
||||
return;
|
||||
|
||||
if ((q->mq_ops && IS_ENABLED(CONFIG_BLK_WBT_MQ)) ||
|
||||
|
||||
@ -244,7 +244,7 @@ int elevator_init_mq(struct request_queue *q);
|
||||
int elevator_switch_mq(struct request_queue *q,
|
||||
struct elevator_type *new_e);
|
||||
void elevator_exit(struct request_queue *, struct elevator_queue *);
|
||||
int elv_register_queue(struct request_queue *q);
|
||||
int elv_register_queue(struct request_queue *q, bool uevent);
|
||||
void elv_unregister_queue(struct request_queue *q);
|
||||
|
||||
struct hd_struct *__disk_get_part(struct gendisk *disk, int partno);
|
||||
|
||||
@ -833,13 +833,16 @@ static struct kobj_type elv_ktype = {
|
||||
.release = elevator_release,
|
||||
};
|
||||
|
||||
int elv_register_queue(struct request_queue *q)
|
||||
/*
|
||||
* elv_register_queue is called from either blk_register_queue or
|
||||
* elevator_switch, elevator switch is prevented from being happen
|
||||
* in the two paths, so it is safe to not hold q->sysfs_lock.
|
||||
*/
|
||||
int elv_register_queue(struct request_queue *q, bool uevent)
|
||||
{
|
||||
struct elevator_queue *e = q->elevator;
|
||||
int error;
|
||||
|
||||
lockdep_assert_held(&q->sysfs_lock);
|
||||
|
||||
error = kobject_add(&e->kobj, &q->kobj, "%s", "iosched");
|
||||
if (!error) {
|
||||
struct elv_fs_entry *attr = e->type->elevator_attrs;
|
||||
@ -850,7 +853,9 @@ int elv_register_queue(struct request_queue *q)
|
||||
attr++;
|
||||
}
|
||||
}
|
||||
kobject_uevent(&e->kobj, KOBJ_ADD);
|
||||
if (uevent)
|
||||
kobject_uevent(&e->kobj, KOBJ_ADD);
|
||||
|
||||
e->registered = 1;
|
||||
if (!e->uses_mq && e->type->ops.sq.elevator_registered_fn)
|
||||
e->type->ops.sq.elevator_registered_fn(q);
|
||||
@ -858,15 +863,19 @@ int elv_register_queue(struct request_queue *q)
|
||||
return error;
|
||||
}
|
||||
|
||||
/*
|
||||
* elv_unregister_queue is called from either blk_unregister_queue or
|
||||
* elevator_switch, elevator switch is prevented from being happen
|
||||
* in the two paths, so it is safe to not hold q->sysfs_lock.
|
||||
*/
|
||||
void elv_unregister_queue(struct request_queue *q)
|
||||
{
|
||||
lockdep_assert_held(&q->sysfs_lock);
|
||||
|
||||
if (q) {
|
||||
struct elevator_queue *e = q->elevator;
|
||||
|
||||
kobject_uevent(&e->kobj, KOBJ_REMOVE);
|
||||
kobject_del(&e->kobj);
|
||||
|
||||
e->registered = 0;
|
||||
/* Re-enable throttling in case elevator disabled it */
|
||||
wbt_enable_default(q);
|
||||
@ -942,6 +951,7 @@ int elevator_switch_mq(struct request_queue *q,
|
||||
if (q->elevator) {
|
||||
if (q->elevator->registered)
|
||||
elv_unregister_queue(q);
|
||||
|
||||
ioc_clear_queue(q);
|
||||
elevator_exit(q, q->elevator);
|
||||
}
|
||||
@ -951,7 +961,7 @@ int elevator_switch_mq(struct request_queue *q,
|
||||
goto out;
|
||||
|
||||
if (new_e) {
|
||||
ret = elv_register_queue(q);
|
||||
ret = elv_register_queue(q, true);
|
||||
if (ret) {
|
||||
elevator_exit(q, q->elevator);
|
||||
goto out;
|
||||
@ -1047,7 +1057,7 @@ static int elevator_switch(struct request_queue *q, struct elevator_type *new_e)
|
||||
if (err)
|
||||
goto fail_init;
|
||||
|
||||
err = elv_register_queue(q);
|
||||
err = elv_register_queue(q, true);
|
||||
if (err)
|
||||
goto fail_register;
|
||||
|
||||
@ -1067,7 +1077,7 @@ fail_init:
|
||||
/* switch failed, restore and re-register old elevator */
|
||||
if (old) {
|
||||
q->elevator = old;
|
||||
elv_register_queue(q);
|
||||
elv_register_queue(q, true);
|
||||
blk_queue_bypass_end(q);
|
||||
}
|
||||
|
||||
@ -1083,7 +1093,7 @@ static int __elevator_change(struct request_queue *q, const char *name)
|
||||
struct elevator_type *e;
|
||||
|
||||
/* Make sure queue is not in the middle of being removed */
|
||||
if (!test_bit(QUEUE_FLAG_REGISTERED, &q->queue_flags))
|
||||
if (!blk_queue_registered(q))
|
||||
return -ENOENT;
|
||||
|
||||
/*
|
||||
|
||||
@ -157,7 +157,7 @@ static int __init blacklist_init(void)
|
||||
KEY_USR_VIEW | KEY_USR_READ |
|
||||
KEY_USR_SEARCH,
|
||||
KEY_ALLOC_NOT_IN_QUOTA |
|
||||
KEY_FLAG_KEEP,
|
||||
KEY_ALLOC_SET_KEEP,
|
||||
NULL, NULL);
|
||||
if (IS_ERR(blacklist_keyring))
|
||||
panic("Can't allocate system blacklist keyring\n");
|
||||
|
||||
@ -71,6 +71,9 @@ int crypto_ecdh_decode_key(const char *buf, unsigned int len,
|
||||
if (secret.type != CRYPTO_KPP_SECRET_TYPE_ECDH)
|
||||
return -EINVAL;
|
||||
|
||||
if (unlikely(len < secret.len))
|
||||
return -EINVAL;
|
||||
|
||||
ptr = ecdh_unpack_data(¶ms->curve_id, ptr, sizeof(params->curve_id));
|
||||
ptr = ecdh_unpack_data(¶ms->key_size, ptr, sizeof(params->key_size));
|
||||
if (secret.len != crypto_ecdh_key_len(params))
|
||||
|
||||
@ -269,7 +269,12 @@ static int __init acpi_configfs_init(void)
|
||||
|
||||
acpi_table_group = configfs_register_default_group(root, "table",
|
||||
&acpi_tables_type);
|
||||
return PTR_ERR_OR_ZERO(acpi_table_group);
|
||||
if (IS_ERR(acpi_table_group)) {
|
||||
configfs_unregister_subsystem(&acpi_configfs);
|
||||
return PTR_ERR(acpi_table_group);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
module_init(acpi_configfs_init);
|
||||
|
||||
|
||||
@ -720,9 +720,6 @@ static int acpi_data_prop_read_single(const struct acpi_device_data *data,
|
||||
const union acpi_object *obj;
|
||||
int ret;
|
||||
|
||||
if (!val)
|
||||
return -EINVAL;
|
||||
|
||||
if (proptype >= DEV_PROP_U8 && proptype <= DEV_PROP_U64) {
|
||||
ret = acpi_data_get_property(data, propname, ACPI_TYPE_INTEGER, &obj);
|
||||
if (ret)
|
||||
@ -732,28 +729,43 @@ static int acpi_data_prop_read_single(const struct acpi_device_data *data,
|
||||
case DEV_PROP_U8:
|
||||
if (obj->integer.value > U8_MAX)
|
||||
return -EOVERFLOW;
|
||||
*(u8 *)val = obj->integer.value;
|
||||
|
||||
if (val)
|
||||
*(u8 *)val = obj->integer.value;
|
||||
|
||||
break;
|
||||
case DEV_PROP_U16:
|
||||
if (obj->integer.value > U16_MAX)
|
||||
return -EOVERFLOW;
|
||||
*(u16 *)val = obj->integer.value;
|
||||
|
||||
if (val)
|
||||
*(u16 *)val = obj->integer.value;
|
||||
|
||||
break;
|
||||
case DEV_PROP_U32:
|
||||
if (obj->integer.value > U32_MAX)
|
||||
return -EOVERFLOW;
|
||||
*(u32 *)val = obj->integer.value;
|
||||
|
||||
if (val)
|
||||
*(u32 *)val = obj->integer.value;
|
||||
|
||||
break;
|
||||
default:
|
||||
*(u64 *)val = obj->integer.value;
|
||||
if (val)
|
||||
*(u64 *)val = obj->integer.value;
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (!val)
|
||||
return 1;
|
||||
} else if (proptype == DEV_PROP_STRING) {
|
||||
ret = acpi_data_get_property(data, propname, ACPI_TYPE_STRING, &obj);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
*(char **)val = obj->string.pointer;
|
||||
if (val)
|
||||
*(char **)val = obj->string.pointer;
|
||||
|
||||
return 1;
|
||||
} else {
|
||||
@ -767,7 +779,7 @@ int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!adev)
|
||||
if (!adev || !val)
|
||||
return -EINVAL;
|
||||
|
||||
ret = acpi_data_prop_read_single(&adev->data, propname, proptype, val);
|
||||
@ -861,10 +873,20 @@ static int acpi_data_prop_read(const struct acpi_device_data *data,
|
||||
const union acpi_object *items;
|
||||
int ret;
|
||||
|
||||
if (val && nval == 1) {
|
||||
if (nval == 1 || !val) {
|
||||
ret = acpi_data_prop_read_single(data, propname, proptype, val);
|
||||
if (ret >= 0)
|
||||
/*
|
||||
* The overflow error means that the property is there and it is
|
||||
* single-value, but its type does not match, so return.
|
||||
*/
|
||||
if (ret >= 0 || ret == -EOVERFLOW)
|
||||
return ret;
|
||||
|
||||
/*
|
||||
* Reading this property as a single-value one failed, but its
|
||||
* value may still be represented as one-element array, so
|
||||
* continue.
|
||||
*/
|
||||
}
|
||||
|
||||
ret = acpi_data_get_property_array(data, propname, ACPI_TYPE_ANY, &obj);
|
||||
|
||||
@ -284,10 +284,11 @@ static int amba_remove(struct device *dev)
|
||||
{
|
||||
struct amba_device *pcdev = to_amba_device(dev);
|
||||
struct amba_driver *drv = to_amba_driver(dev->driver);
|
||||
int ret;
|
||||
int ret = 0;
|
||||
|
||||
pm_runtime_get_sync(dev);
|
||||
ret = drv->remove(pcdev);
|
||||
if (drv->remove)
|
||||
ret = drv->remove(pcdev);
|
||||
pm_runtime_put_noidle(dev);
|
||||
|
||||
/* Undo the runtime PM settings in amba_probe() */
|
||||
@ -304,7 +305,9 @@ static int amba_remove(struct device *dev)
|
||||
static void amba_shutdown(struct device *dev)
|
||||
{
|
||||
struct amba_driver *drv = to_amba_driver(dev->driver);
|
||||
drv->shutdown(to_amba_device(dev));
|
||||
|
||||
if (drv->shutdown)
|
||||
drv->shutdown(to_amba_device(dev));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -317,12 +320,13 @@ static void amba_shutdown(struct device *dev)
|
||||
*/
|
||||
int amba_driver_register(struct amba_driver *drv)
|
||||
{
|
||||
drv->drv.bus = &amba_bustype;
|
||||
if (!drv->probe)
|
||||
return -EINVAL;
|
||||
|
||||
#define SETFN(fn) if (drv->fn) drv->drv.fn = amba_##fn
|
||||
SETFN(probe);
|
||||
SETFN(remove);
|
||||
SETFN(shutdown);
|
||||
drv->drv.bus = &amba_bustype;
|
||||
drv->drv.probe = amba_probe;
|
||||
drv->drv.remove = amba_remove;
|
||||
drv->drv.shutdown = amba_shutdown;
|
||||
|
||||
return driver_register(&drv->drv);
|
||||
}
|
||||
|
||||
@ -370,6 +370,10 @@ static int brcm_ahci_resume(struct device *dev)
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = ahci_platform_enable_regulators(hpriv);
|
||||
if (ret)
|
||||
goto out_disable_clks;
|
||||
|
||||
brcm_sata_init(priv);
|
||||
brcm_sata_phys_enable(priv);
|
||||
brcm_sata_alpm_init(hpriv);
|
||||
@ -399,6 +403,8 @@ out_disable_platform_phys:
|
||||
ahci_platform_disable_phys(hpriv);
|
||||
out_disable_phys:
|
||||
brcm_sata_phys_disable(priv);
|
||||
ahci_platform_disable_regulators(hpriv);
|
||||
out_disable_clks:
|
||||
ahci_platform_disable_clks(hpriv);
|
||||
return ret;
|
||||
}
|
||||
@ -471,6 +477,10 @@ static int brcm_ahci_probe(struct platform_device *pdev)
|
||||
if (ret)
|
||||
goto out_reset;
|
||||
|
||||
ret = ahci_platform_enable_regulators(hpriv);
|
||||
if (ret)
|
||||
goto out_disable_clks;
|
||||
|
||||
/* Must be first so as to configure endianness including that
|
||||
* of the standard AHCI register space.
|
||||
*/
|
||||
@ -480,7 +490,7 @@ static int brcm_ahci_probe(struct platform_device *pdev)
|
||||
priv->port_mask = brcm_ahci_get_portmask(hpriv, priv);
|
||||
if (!priv->port_mask) {
|
||||
ret = -ENODEV;
|
||||
goto out_disable_clks;
|
||||
goto out_disable_regulators;
|
||||
}
|
||||
|
||||
/* Must be done before ahci_platform_enable_phys() */
|
||||
@ -505,6 +515,8 @@ out_disable_platform_phys:
|
||||
ahci_platform_disable_phys(hpriv);
|
||||
out_disable_phys:
|
||||
brcm_sata_phys_disable(priv);
|
||||
out_disable_regulators:
|
||||
ahci_platform_disable_regulators(hpriv);
|
||||
out_disable_clks:
|
||||
ahci_platform_disable_clks(hpriv);
|
||||
out_reset:
|
||||
|
||||
@ -117,8 +117,7 @@ static void ht16k33_fb_queue(struct ht16k33_priv *priv)
|
||||
{
|
||||
struct ht16k33_fbdev *fbdev = &priv->fbdev;
|
||||
|
||||
schedule_delayed_work(&fbdev->work,
|
||||
msecs_to_jiffies(HZ / fbdev->refresh_rate));
|
||||
schedule_delayed_work(&fbdev->work, HZ / fbdev->refresh_rate);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -12,7 +12,7 @@ static int regmap_sdw_write(void *context, unsigned int reg, unsigned int val)
|
||||
struct device *dev = context;
|
||||
struct sdw_slave *slave = dev_to_sdw_dev(dev);
|
||||
|
||||
return sdw_write(slave, reg, val);
|
||||
return sdw_write_no_pm(slave, reg, val);
|
||||
}
|
||||
|
||||
static int regmap_sdw_read(void *context, unsigned int reg, unsigned int *val)
|
||||
@ -21,7 +21,7 @@ static int regmap_sdw_read(void *context, unsigned int reg, unsigned int *val)
|
||||
struct sdw_slave *slave = dev_to_sdw_dev(dev);
|
||||
int read;
|
||||
|
||||
read = sdw_read(slave, reg);
|
||||
read = sdw_read_no_pm(slave, reg);
|
||||
if (read < 0)
|
||||
return read;
|
||||
|
||||
|
||||
@ -4074,21 +4074,22 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
|
||||
if (UFDCS->rawcmd == 1)
|
||||
UFDCS->rawcmd = 2;
|
||||
|
||||
if (!(mode & FMODE_NDELAY)) {
|
||||
if (mode & (FMODE_READ|FMODE_WRITE)) {
|
||||
UDRS->last_checked = 0;
|
||||
clear_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
|
||||
check_disk_change(bdev);
|
||||
if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags))
|
||||
goto out;
|
||||
if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags))
|
||||
goto out;
|
||||
}
|
||||
res = -EROFS;
|
||||
if ((mode & FMODE_WRITE) &&
|
||||
!test_bit(FD_DISK_WRITABLE_BIT, &UDRS->flags))
|
||||
if (mode & (FMODE_READ|FMODE_WRITE)) {
|
||||
UDRS->last_checked = 0;
|
||||
clear_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
|
||||
check_disk_change(bdev);
|
||||
if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags))
|
||||
goto out;
|
||||
if (test_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags))
|
||||
goto out;
|
||||
}
|
||||
|
||||
res = -EROFS;
|
||||
|
||||
if ((mode & FMODE_WRITE) &&
|
||||
!test_bit(FD_DISK_WRITABLE_BIT, &UDRS->flags))
|
||||
goto out;
|
||||
|
||||
mutex_unlock(&open_lock);
|
||||
mutex_unlock(&floppy_mutex);
|
||||
return 0;
|
||||
|
||||
@ -166,8 +166,10 @@ static int btqcomsmd_probe(struct platform_device *pdev)
|
||||
|
||||
btq->cmd_channel = qcom_wcnss_open_channel(wcnss, "APPS_RIVA_BT_CMD",
|
||||
btqcomsmd_cmd_callback, btq);
|
||||
if (IS_ERR(btq->cmd_channel))
|
||||
return PTR_ERR(btq->cmd_channel);
|
||||
if (IS_ERR(btq->cmd_channel)) {
|
||||
ret = PTR_ERR(btq->cmd_channel);
|
||||
goto destroy_acl_channel;
|
||||
}
|
||||
|
||||
/* The local-bd-address property is usually injected by the
|
||||
* bootloader which has access to the allocated BD address.
|
||||
@ -179,8 +181,10 @@ static int btqcomsmd_probe(struct platform_device *pdev)
|
||||
}
|
||||
|
||||
hdev = hci_alloc_dev();
|
||||
if (!hdev)
|
||||
return -ENOMEM;
|
||||
if (!hdev) {
|
||||
ret = -ENOMEM;
|
||||
goto destroy_cmd_channel;
|
||||
}
|
||||
|
||||
hci_set_drvdata(hdev, btq);
|
||||
btq->hdev = hdev;
|
||||
@ -194,14 +198,21 @@ static int btqcomsmd_probe(struct platform_device *pdev)
|
||||
hdev->set_bdaddr = qca_set_bdaddr_rome;
|
||||
|
||||
ret = hci_register_dev(hdev);
|
||||
if (ret < 0) {
|
||||
hci_free_dev(hdev);
|
||||
return ret;
|
||||
}
|
||||
if (ret < 0)
|
||||
goto hci_free_dev;
|
||||
|
||||
platform_set_drvdata(pdev, btq);
|
||||
|
||||
return 0;
|
||||
|
||||
hci_free_dev:
|
||||
hci_free_dev(hdev);
|
||||
destroy_cmd_channel:
|
||||
rpmsg_destroy_ept(btq->cmd_channel);
|
||||
destroy_acl_channel:
|
||||
rpmsg_destroy_ept(btq->acl_channel);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int btqcomsmd_remove(struct platform_device *pdev)
|
||||
|
||||
@ -72,7 +72,7 @@ static int timeriomem_rng_read(struct hwrng *hwrng, void *data,
|
||||
*/
|
||||
if (retval > 0)
|
||||
usleep_range(period_us,
|
||||
period_us + min(1, period_us / 100));
|
||||
period_us + max(1, period_us / 100));
|
||||
|
||||
*(u32 *)data = readl(priv->io_base);
|
||||
retval += sizeof(u32);
|
||||
|
||||
@ -1943,7 +1943,7 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
|
||||
return -EPERM;
|
||||
if (crng_init < 2)
|
||||
return -ENODATA;
|
||||
crng_reseed(&primary_crng, NULL);
|
||||
crng_reseed(&primary_crng, &input_pool);
|
||||
crng_global_init_time = jiffies - 1;
|
||||
return 0;
|
||||
default:
|
||||
|
||||
@ -129,7 +129,8 @@ static bool check_locality(struct tpm_chip *chip, int l)
|
||||
if (rc < 0)
|
||||
return false;
|
||||
|
||||
if ((access & (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) ==
|
||||
if ((access & (TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID
|
||||
| TPM_ACCESS_REQUEST_USE)) ==
|
||||
(TPM_ACCESS_ACTIVE_LOCALITY | TPM_ACCESS_VALID)) {
|
||||
priv->locality = l;
|
||||
return true;
|
||||
@ -138,58 +139,13 @@ static bool check_locality(struct tpm_chip *chip, int l)
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool locality_inactive(struct tpm_chip *chip, int l)
|
||||
{
|
||||
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
|
||||
int rc;
|
||||
u8 access;
|
||||
|
||||
rc = tpm_tis_read8(priv, TPM_ACCESS(l), &access);
|
||||
if (rc < 0)
|
||||
return false;
|
||||
|
||||
if ((access & (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY))
|
||||
== TPM_ACCESS_VALID)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static int release_locality(struct tpm_chip *chip, int l)
|
||||
{
|
||||
struct tpm_tis_data *priv = dev_get_drvdata(&chip->dev);
|
||||
unsigned long stop, timeout;
|
||||
long rc;
|
||||
|
||||
tpm_tis_write8(priv, TPM_ACCESS(l), TPM_ACCESS_ACTIVE_LOCALITY);
|
||||
|
||||
stop = jiffies + chip->timeout_a;
|
||||
|
||||
if (chip->flags & TPM_CHIP_FLAG_IRQ) {
|
||||
again:
|
||||
timeout = stop - jiffies;
|
||||
if ((long)timeout <= 0)
|
||||
return -1;
|
||||
|
||||
rc = wait_event_interruptible_timeout(priv->int_queue,
|
||||
(locality_inactive(chip, l)),
|
||||
timeout);
|
||||
|
||||
if (rc > 0)
|
||||
return 0;
|
||||
|
||||
if (rc == -ERESTARTSYS && freezing(current)) {
|
||||
clear_thread_flag(TIF_SIGPENDING);
|
||||
goto again;
|
||||
}
|
||||
} else {
|
||||
do {
|
||||
if (locality_inactive(chip, l))
|
||||
return 0;
|
||||
tpm_msleep(TPM_TIMEOUT);
|
||||
} while (time_before(jiffies, stop));
|
||||
}
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int request_locality(struct tpm_chip *chip, int l)
|
||||
|
||||
@ -197,7 +197,7 @@ static int meson_clk_pll_set_rate(struct clk_hw *hw, unsigned long rate,
|
||||
if (parent_rate == 0 || rate == 0)
|
||||
return -EINVAL;
|
||||
|
||||
old_rate = rate;
|
||||
old_rate = clk_hw_get_rate(hw);
|
||||
|
||||
pllt = meson_clk_get_pll_settings(rate, pll);
|
||||
if (!pllt)
|
||||
|
||||
@ -124,7 +124,7 @@ static struct pll_vco fabia_vco[] = {
|
||||
|
||||
static struct clk_alpha_pll gpll0 = {
|
||||
.offset = 0x0,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.vco_table = fabia_vco,
|
||||
.num_vco = ARRAY_SIZE(fabia_vco),
|
||||
.clkr = {
|
||||
@ -134,58 +134,58 @@ static struct clk_alpha_pll gpll0 = {
|
||||
.name = "gpll0",
|
||||
.parent_names = (const char *[]){ "xo" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_ops,
|
||||
.ops = &clk_alpha_pll_fixed_fabia_ops,
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll0_out_even = {
|
||||
.offset = 0x0,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll0_out_even",
|
||||
.parent_names = (const char *[]){ "gpll0" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll0_out_main = {
|
||||
.offset = 0x0,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll0_out_main",
|
||||
.parent_names = (const char *[]){ "gpll0" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll0_out_odd = {
|
||||
.offset = 0x0,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll0_out_odd",
|
||||
.parent_names = (const char *[]){ "gpll0" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll0_out_test = {
|
||||
.offset = 0x0,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll0_out_test",
|
||||
.parent_names = (const char *[]){ "gpll0" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll gpll1 = {
|
||||
.offset = 0x1000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.vco_table = fabia_vco,
|
||||
.num_vco = ARRAY_SIZE(fabia_vco),
|
||||
.clkr = {
|
||||
@ -195,58 +195,58 @@ static struct clk_alpha_pll gpll1 = {
|
||||
.name = "gpll1",
|
||||
.parent_names = (const char *[]){ "xo" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_ops,
|
||||
.ops = &clk_alpha_pll_fixed_fabia_ops,
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll1_out_even = {
|
||||
.offset = 0x1000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll1_out_even",
|
||||
.parent_names = (const char *[]){ "gpll1" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll1_out_main = {
|
||||
.offset = 0x1000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll1_out_main",
|
||||
.parent_names = (const char *[]){ "gpll1" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll1_out_odd = {
|
||||
.offset = 0x1000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll1_out_odd",
|
||||
.parent_names = (const char *[]){ "gpll1" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll1_out_test = {
|
||||
.offset = 0x1000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll1_out_test",
|
||||
.parent_names = (const char *[]){ "gpll1" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll gpll2 = {
|
||||
.offset = 0x2000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.vco_table = fabia_vco,
|
||||
.num_vco = ARRAY_SIZE(fabia_vco),
|
||||
.clkr = {
|
||||
@ -256,58 +256,58 @@ static struct clk_alpha_pll gpll2 = {
|
||||
.name = "gpll2",
|
||||
.parent_names = (const char *[]){ "xo" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_ops,
|
||||
.ops = &clk_alpha_pll_fixed_fabia_ops,
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll2_out_even = {
|
||||
.offset = 0x2000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll2_out_even",
|
||||
.parent_names = (const char *[]){ "gpll2" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll2_out_main = {
|
||||
.offset = 0x2000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll2_out_main",
|
||||
.parent_names = (const char *[]){ "gpll2" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll2_out_odd = {
|
||||
.offset = 0x2000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll2_out_odd",
|
||||
.parent_names = (const char *[]){ "gpll2" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll2_out_test = {
|
||||
.offset = 0x2000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll2_out_test",
|
||||
.parent_names = (const char *[]){ "gpll2" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll gpll3 = {
|
||||
.offset = 0x3000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.vco_table = fabia_vco,
|
||||
.num_vco = ARRAY_SIZE(fabia_vco),
|
||||
.clkr = {
|
||||
@ -317,58 +317,58 @@ static struct clk_alpha_pll gpll3 = {
|
||||
.name = "gpll3",
|
||||
.parent_names = (const char *[]){ "xo" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_ops,
|
||||
.ops = &clk_alpha_pll_fixed_fabia_ops,
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll3_out_even = {
|
||||
.offset = 0x3000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll3_out_even",
|
||||
.parent_names = (const char *[]){ "gpll3" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll3_out_main = {
|
||||
.offset = 0x3000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll3_out_main",
|
||||
.parent_names = (const char *[]){ "gpll3" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll3_out_odd = {
|
||||
.offset = 0x3000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll3_out_odd",
|
||||
.parent_names = (const char *[]){ "gpll3" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll3_out_test = {
|
||||
.offset = 0x3000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll3_out_test",
|
||||
.parent_names = (const char *[]){ "gpll3" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll gpll4 = {
|
||||
.offset = 0x77000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.vco_table = fabia_vco,
|
||||
.num_vco = ARRAY_SIZE(fabia_vco),
|
||||
.clkr = {
|
||||
@ -378,52 +378,52 @@ static struct clk_alpha_pll gpll4 = {
|
||||
.name = "gpll4",
|
||||
.parent_names = (const char *[]){ "xo" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_ops,
|
||||
.ops = &clk_alpha_pll_fixed_fabia_ops,
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll4_out_even = {
|
||||
.offset = 0x77000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll4_out_even",
|
||||
.parent_names = (const char *[]){ "gpll4" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll4_out_main = {
|
||||
.offset = 0x77000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll4_out_main",
|
||||
.parent_names = (const char *[]){ "gpll4" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll4_out_odd = {
|
||||
.offset = 0x77000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll4_out_odd",
|
||||
.parent_names = (const char *[]){ "gpll4" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
static struct clk_alpha_pll_postdiv gpll4_out_test = {
|
||||
.offset = 0x77000,
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
|
||||
.regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA],
|
||||
.clkr.hw.init = &(struct clk_init_data){
|
||||
.name = "gpll4_out_test",
|
||||
.parent_names = (const char *[]){ "gpll4" },
|
||||
.num_parents = 1,
|
||||
.ops = &clk_alpha_pll_postdiv_ops,
|
||||
.ops = &clk_alpha_pll_postdiv_fabia_ops,
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
@ -223,7 +223,7 @@ static const char * const psi_ahb1_ahb2_parents[] = { "osc24M", "osc32k",
|
||||
static SUNXI_CCU_MP_WITH_MUX(psi_ahb1_ahb2_clk, "psi-ahb1-ahb2",
|
||||
psi_ahb1_ahb2_parents,
|
||||
0x510,
|
||||
0, 5, /* M */
|
||||
0, 2, /* M */
|
||||
8, 2, /* P */
|
||||
24, 2, /* mux */
|
||||
0);
|
||||
@ -232,19 +232,19 @@ static const char * const ahb3_apb1_apb2_parents[] = { "osc24M", "osc32k",
|
||||
"psi-ahb1-ahb2",
|
||||
"pll-periph0" };
|
||||
static SUNXI_CCU_MP_WITH_MUX(ahb3_clk, "ahb3", ahb3_apb1_apb2_parents, 0x51c,
|
||||
0, 5, /* M */
|
||||
0, 2, /* M */
|
||||
8, 2, /* P */
|
||||
24, 2, /* mux */
|
||||
0);
|
||||
|
||||
static SUNXI_CCU_MP_WITH_MUX(apb1_clk, "apb1", ahb3_apb1_apb2_parents, 0x520,
|
||||
0, 5, /* M */
|
||||
0, 2, /* M */
|
||||
8, 2, /* P */
|
||||
24, 2, /* mux */
|
||||
0);
|
||||
|
||||
static SUNXI_CCU_MP_WITH_MUX(apb2_clk, "apb2", ahb3_apb1_apb2_parents, 0x524,
|
||||
0, 5, /* M */
|
||||
0, 2, /* M */
|
||||
8, 2, /* P */
|
||||
24, 2, /* mux */
|
||||
0);
|
||||
@ -662,7 +662,7 @@ static struct ccu_mux hdmi_cec_clk = {
|
||||
|
||||
.common = {
|
||||
.reg = 0xb10,
|
||||
.features = CCU_FEATURE_VARIABLE_PREDIV,
|
||||
.features = CCU_FEATURE_FIXED_PREDIV,
|
||||
.hw.init = CLK_HW_INIT_PARENTS("hdmi-cec",
|
||||
hdmi_cec_parents,
|
||||
&ccu_mux_ops,
|
||||
|
||||
@ -138,10 +138,7 @@ static void mxs_irq_clear(char *state)
|
||||
|
||||
/* Clear pending interrupt */
|
||||
timrot_irq_acknowledge();
|
||||
|
||||
#ifdef DEBUG
|
||||
pr_info("%s: changing mode to %s\n", __func__, state)
|
||||
#endif /* DEBUG */
|
||||
pr_debug("%s: changing mode to %s\n", __func__, state);
|
||||
}
|
||||
|
||||
static int mxs_shutdown(struct clock_event_device *evt)
|
||||
|
||||
@ -566,6 +566,16 @@ unmap_base:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void brcm_avs_prepare_uninit(struct platform_device *pdev)
|
||||
{
|
||||
struct private_data *priv;
|
||||
|
||||
priv = platform_get_drvdata(pdev);
|
||||
|
||||
iounmap(priv->avs_intr_base);
|
||||
iounmap(priv->base);
|
||||
}
|
||||
|
||||
static int brcm_avs_cpufreq_init(struct cpufreq_policy *policy)
|
||||
{
|
||||
struct cpufreq_frequency_table *freq_table;
|
||||
@ -701,21 +711,21 @@ static int brcm_avs_cpufreq_probe(struct platform_device *pdev)
|
||||
|
||||
brcm_avs_driver.driver_data = pdev;
|
||||
|
||||
return cpufreq_register_driver(&brcm_avs_driver);
|
||||
ret = cpufreq_register_driver(&brcm_avs_driver);
|
||||
if (ret)
|
||||
brcm_avs_prepare_uninit(pdev);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int brcm_avs_cpufreq_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct private_data *priv;
|
||||
int ret;
|
||||
|
||||
ret = cpufreq_unregister_driver(&brcm_avs_driver);
|
||||
if (ret)
|
||||
return ret;
|
||||
WARN_ON(ret);
|
||||
|
||||
priv = platform_get_drvdata(pdev);
|
||||
iounmap(priv->base);
|
||||
iounmap(priv->avs_intr_base);
|
||||
brcm_avs_prepare_uninit(pdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1420,11 +1420,9 @@ static void intel_pstate_max_within_limits(struct cpudata *cpu)
|
||||
static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
|
||||
{
|
||||
cpu->pstate.min_pstate = pstate_funcs.get_min();
|
||||
cpu->pstate.max_pstate = pstate_funcs.get_max();
|
||||
cpu->pstate.max_pstate_physical = pstate_funcs.get_max_physical();
|
||||
cpu->pstate.turbo_pstate = pstate_funcs.get_turbo();
|
||||
cpu->pstate.scaling = pstate_funcs.get_scaling();
|
||||
cpu->pstate.max_freq = cpu->pstate.max_pstate * cpu->pstate.scaling;
|
||||
|
||||
if (hwp_active && !hwp_mode_bdw) {
|
||||
unsigned int phy_max, current_max;
|
||||
@ -1432,9 +1430,12 @@ static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
|
||||
intel_pstate_get_hwp_max(cpu->cpu, &phy_max, ¤t_max);
|
||||
cpu->pstate.turbo_freq = phy_max * cpu->pstate.scaling;
|
||||
cpu->pstate.turbo_pstate = phy_max;
|
||||
cpu->pstate.max_pstate = HWP_GUARANTEED_PERF(READ_ONCE(cpu->hwp_cap_cached));
|
||||
} else {
|
||||
cpu->pstate.turbo_freq = cpu->pstate.turbo_pstate * cpu->pstate.scaling;
|
||||
cpu->pstate.max_pstate = pstate_funcs.get_max();
|
||||
}
|
||||
cpu->pstate.max_freq = cpu->pstate.max_pstate * cpu->pstate.scaling;
|
||||
|
||||
if (pstate_funcs.get_aperf_mperf_shift)
|
||||
cpu->aperf_mperf_shift = pstate_funcs.get_aperf_mperf_shift();
|
||||
|
||||
@ -52,7 +52,7 @@
|
||||
|
||||
/* ================= Device Structure ================== */
|
||||
|
||||
struct device_private iproc_priv;
|
||||
struct bcm_device_private iproc_priv;
|
||||
|
||||
/* ==================== Parameters ===================== */
|
||||
|
||||
|
||||
@ -431,7 +431,7 @@ struct spu_hw {
|
||||
u32 num_chan;
|
||||
};
|
||||
|
||||
struct device_private {
|
||||
struct bcm_device_private {
|
||||
struct platform_device *pdev;
|
||||
|
||||
struct spu_hw spu;
|
||||
@ -478,6 +478,6 @@ struct device_private {
|
||||
struct mbox_chan **mbox;
|
||||
};
|
||||
|
||||
extern struct device_private iproc_priv;
|
||||
extern struct bcm_device_private iproc_priv;
|
||||
|
||||
#endif
|
||||
|
||||
@ -400,7 +400,7 @@ char *spu_alg_name(enum spu_cipher_alg alg, enum spu_cipher_mode mode)
|
||||
static ssize_t spu_debugfs_read(struct file *filp, char __user *ubuf,
|
||||
size_t count, loff_t *offp)
|
||||
{
|
||||
struct device_private *ipriv;
|
||||
struct bcm_device_private *ipriv;
|
||||
char *buf;
|
||||
ssize_t ret, out_offset, out_count;
|
||||
int i;
|
||||
|
||||
@ -53,9 +53,6 @@
|
||||
#define MIN_RCV_WND (24 * 1024U)
|
||||
#define LOOPBACK(x) (((x) & htonl(0xff000000)) == htonl(0x7f000000))
|
||||
|
||||
/* ulp_mem_io + ulptx_idata + payload + padding */
|
||||
#define MAX_IMM_ULPTX_WR_LEN (32 + 8 + 256 + 8)
|
||||
|
||||
/* for TX: a skb must have a headroom of at least TX_HEADER_LEN bytes */
|
||||
#define TX_HEADER_LEN \
|
||||
(sizeof(struct fw_ofld_tx_data_wr) + sizeof(struct sge_opaque_hdr))
|
||||
|
||||
@ -34,6 +34,8 @@ static int sun4i_ss_opti_poll(struct skcipher_request *areq)
|
||||
unsigned int ileft = areq->cryptlen;
|
||||
unsigned int oleft = areq->cryptlen;
|
||||
unsigned int todo;
|
||||
unsigned long pi = 0, po = 0; /* progress for in and out */
|
||||
bool miter_err;
|
||||
struct sg_mapping_iter mi, mo;
|
||||
unsigned int oi, oo; /* offset for in and out */
|
||||
unsigned long flags;
|
||||
@ -53,50 +55,62 @@ static int sun4i_ss_opti_poll(struct skcipher_request *areq)
|
||||
|
||||
spin_lock_irqsave(&ss->slock, flags);
|
||||
|
||||
for (i = 0; i < op->keylen; i += 4)
|
||||
writel(*(op->key + i / 4), ss->base + SS_KEY0 + i);
|
||||
for (i = 0; i < op->keylen / 4; i++)
|
||||
writesl(ss->base + SS_KEY0 + i * 4, &op->key[i], 1);
|
||||
|
||||
if (areq->iv) {
|
||||
for (i = 0; i < 4 && i < ivsize / 4; i++) {
|
||||
v = *(u32 *)(areq->iv + i * 4);
|
||||
writel(v, ss->base + SS_IV0 + i * 4);
|
||||
writesl(ss->base + SS_IV0 + i * 4, &v, 1);
|
||||
}
|
||||
}
|
||||
writel(mode, ss->base + SS_CTL);
|
||||
|
||||
sg_miter_start(&mi, areq->src, sg_nents(areq->src),
|
||||
SG_MITER_FROM_SG | SG_MITER_ATOMIC);
|
||||
sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),
|
||||
SG_MITER_TO_SG | SG_MITER_ATOMIC);
|
||||
sg_miter_next(&mi);
|
||||
sg_miter_next(&mo);
|
||||
if (!mi.addr || !mo.addr) {
|
||||
dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
|
||||
err = -EINVAL;
|
||||
goto release_ss;
|
||||
}
|
||||
|
||||
ileft = areq->cryptlen / 4;
|
||||
oleft = areq->cryptlen / 4;
|
||||
oi = 0;
|
||||
oo = 0;
|
||||
do {
|
||||
todo = min(rx_cnt, ileft);
|
||||
todo = min_t(size_t, todo, (mi.length - oi) / 4);
|
||||
if (todo) {
|
||||
ileft -= todo;
|
||||
writesl(ss->base + SS_RXFIFO, mi.addr + oi, todo);
|
||||
oi += todo * 4;
|
||||
}
|
||||
if (oi == mi.length) {
|
||||
sg_miter_next(&mi);
|
||||
oi = 0;
|
||||
if (ileft) {
|
||||
sg_miter_start(&mi, areq->src, sg_nents(areq->src),
|
||||
SG_MITER_FROM_SG | SG_MITER_ATOMIC);
|
||||
if (pi)
|
||||
sg_miter_skip(&mi, pi);
|
||||
miter_err = sg_miter_next(&mi);
|
||||
if (!miter_err || !mi.addr) {
|
||||
dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
|
||||
err = -EINVAL;
|
||||
goto release_ss;
|
||||
}
|
||||
todo = min(rx_cnt, ileft);
|
||||
todo = min_t(size_t, todo, (mi.length - oi) / 4);
|
||||
if (todo) {
|
||||
ileft -= todo;
|
||||
writesl(ss->base + SS_RXFIFO, mi.addr + oi, todo);
|
||||
oi += todo * 4;
|
||||
}
|
||||
if (oi == mi.length) {
|
||||
pi += mi.length;
|
||||
oi = 0;
|
||||
}
|
||||
sg_miter_stop(&mi);
|
||||
}
|
||||
|
||||
spaces = readl(ss->base + SS_FCSR);
|
||||
rx_cnt = SS_RXFIFO_SPACES(spaces);
|
||||
tx_cnt = SS_TXFIFO_SPACES(spaces);
|
||||
|
||||
sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),
|
||||
SG_MITER_TO_SG | SG_MITER_ATOMIC);
|
||||
if (po)
|
||||
sg_miter_skip(&mo, po);
|
||||
miter_err = sg_miter_next(&mo);
|
||||
if (!miter_err || !mo.addr) {
|
||||
dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
|
||||
err = -EINVAL;
|
||||
goto release_ss;
|
||||
}
|
||||
todo = min(tx_cnt, oleft);
|
||||
todo = min_t(size_t, todo, (mo.length - oo) / 4);
|
||||
if (todo) {
|
||||
@ -105,9 +119,10 @@ static int sun4i_ss_opti_poll(struct skcipher_request *areq)
|
||||
oo += todo * 4;
|
||||
}
|
||||
if (oo == mo.length) {
|
||||
sg_miter_next(&mo);
|
||||
oo = 0;
|
||||
po += mo.length;
|
||||
}
|
||||
sg_miter_stop(&mo);
|
||||
} while (oleft);
|
||||
|
||||
if (areq->iv) {
|
||||
@ -118,8 +133,6 @@ static int sun4i_ss_opti_poll(struct skcipher_request *areq)
|
||||
}
|
||||
|
||||
release_ss:
|
||||
sg_miter_stop(&mi);
|
||||
sg_miter_stop(&mo);
|
||||
writel(0, ss->base + SS_CTL);
|
||||
spin_unlock_irqrestore(&ss->slock, flags);
|
||||
return err;
|
||||
@ -148,6 +161,8 @@ static int sun4i_ss_cipher_poll(struct skcipher_request *areq)
|
||||
unsigned int oleft = areq->cryptlen;
|
||||
unsigned int todo;
|
||||
struct sg_mapping_iter mi, mo;
|
||||
unsigned long pi = 0, po = 0; /* progress for in and out */
|
||||
bool miter_err;
|
||||
unsigned int oi, oo; /* offset for in and out */
|
||||
char buf[4 * SS_RX_MAX];/* buffer for linearize SG src */
|
||||
char bufo[4 * SS_TX_MAX]; /* buffer for linearize SG dst */
|
||||
@ -174,12 +189,12 @@ static int sun4i_ss_cipher_poll(struct skcipher_request *areq)
|
||||
* we can use the SS optimized function
|
||||
*/
|
||||
while (in_sg && no_chunk == 1) {
|
||||
if (in_sg->length % 4)
|
||||
if ((in_sg->length | in_sg->offset) & 3u)
|
||||
no_chunk = 0;
|
||||
in_sg = sg_next(in_sg);
|
||||
}
|
||||
while (out_sg && no_chunk == 1) {
|
||||
if (out_sg->length % 4)
|
||||
if ((out_sg->length | out_sg->offset) & 3u)
|
||||
no_chunk = 0;
|
||||
out_sg = sg_next(out_sg);
|
||||
}
|
||||
@ -189,28 +204,17 @@ static int sun4i_ss_cipher_poll(struct skcipher_request *areq)
|
||||
|
||||
spin_lock_irqsave(&ss->slock, flags);
|
||||
|
||||
for (i = 0; i < op->keylen; i += 4)
|
||||
writel(*(op->key + i / 4), ss->base + SS_KEY0 + i);
|
||||
for (i = 0; i < op->keylen / 4; i++)
|
||||
writesl(ss->base + SS_KEY0 + i * 4, &op->key[i], 1);
|
||||
|
||||
if (areq->iv) {
|
||||
for (i = 0; i < 4 && i < ivsize / 4; i++) {
|
||||
v = *(u32 *)(areq->iv + i * 4);
|
||||
writel(v, ss->base + SS_IV0 + i * 4);
|
||||
writesl(ss->base + SS_IV0 + i * 4, &v, 1);
|
||||
}
|
||||
}
|
||||
writel(mode, ss->base + SS_CTL);
|
||||
|
||||
sg_miter_start(&mi, areq->src, sg_nents(areq->src),
|
||||
SG_MITER_FROM_SG | SG_MITER_ATOMIC);
|
||||
sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),
|
||||
SG_MITER_TO_SG | SG_MITER_ATOMIC);
|
||||
sg_miter_next(&mi);
|
||||
sg_miter_next(&mo);
|
||||
if (!mi.addr || !mo.addr) {
|
||||
dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
|
||||
err = -EINVAL;
|
||||
goto release_ss;
|
||||
}
|
||||
ileft = areq->cryptlen;
|
||||
oleft = areq->cryptlen;
|
||||
oi = 0;
|
||||
@ -218,6 +222,16 @@ static int sun4i_ss_cipher_poll(struct skcipher_request *areq)
|
||||
|
||||
while (oleft) {
|
||||
if (ileft) {
|
||||
sg_miter_start(&mi, areq->src, sg_nents(areq->src),
|
||||
SG_MITER_FROM_SG | SG_MITER_ATOMIC);
|
||||
if (pi)
|
||||
sg_miter_skip(&mi, pi);
|
||||
miter_err = sg_miter_next(&mi);
|
||||
if (!miter_err || !mi.addr) {
|
||||
dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
|
||||
err = -EINVAL;
|
||||
goto release_ss;
|
||||
}
|
||||
/*
|
||||
* todo is the number of consecutive 4byte word that we
|
||||
* can read from current SG
|
||||
@ -250,31 +264,38 @@ static int sun4i_ss_cipher_poll(struct skcipher_request *areq)
|
||||
}
|
||||
}
|
||||
if (oi == mi.length) {
|
||||
sg_miter_next(&mi);
|
||||
pi += mi.length;
|
||||
oi = 0;
|
||||
}
|
||||
sg_miter_stop(&mi);
|
||||
}
|
||||
|
||||
spaces = readl(ss->base + SS_FCSR);
|
||||
rx_cnt = SS_RXFIFO_SPACES(spaces);
|
||||
tx_cnt = SS_TXFIFO_SPACES(spaces);
|
||||
dev_dbg(ss->dev,
|
||||
"%x %u/%zu %u/%u cnt=%u %u/%zu %u/%u cnt=%u %u\n",
|
||||
mode,
|
||||
oi, mi.length, ileft, areq->cryptlen, rx_cnt,
|
||||
oo, mo.length, oleft, areq->cryptlen, tx_cnt, ob);
|
||||
|
||||
if (!tx_cnt)
|
||||
continue;
|
||||
sg_miter_start(&mo, areq->dst, sg_nents(areq->dst),
|
||||
SG_MITER_TO_SG | SG_MITER_ATOMIC);
|
||||
if (po)
|
||||
sg_miter_skip(&mo, po);
|
||||
miter_err = sg_miter_next(&mo);
|
||||
if (!miter_err || !mo.addr) {
|
||||
dev_err_ratelimited(ss->dev, "ERROR: sg_miter return null\n");
|
||||
err = -EINVAL;
|
||||
goto release_ss;
|
||||
}
|
||||
/* todo in 4bytes word */
|
||||
todo = min(tx_cnt, oleft / 4);
|
||||
todo = min_t(size_t, todo, (mo.length - oo) / 4);
|
||||
|
||||
if (todo) {
|
||||
readsl(ss->base + SS_TXFIFO, mo.addr + oo, todo);
|
||||
oleft -= todo * 4;
|
||||
oo += todo * 4;
|
||||
if (oo == mo.length) {
|
||||
sg_miter_next(&mo);
|
||||
po += mo.length;
|
||||
oo = 0;
|
||||
}
|
||||
} else {
|
||||
@ -299,12 +320,14 @@ static int sun4i_ss_cipher_poll(struct skcipher_request *areq)
|
||||
obo += todo;
|
||||
oo += todo;
|
||||
if (oo == mo.length) {
|
||||
po += mo.length;
|
||||
sg_miter_next(&mo);
|
||||
oo = 0;
|
||||
}
|
||||
} while (obo < obl);
|
||||
/* bufo must be fully used here */
|
||||
}
|
||||
sg_miter_stop(&mo);
|
||||
}
|
||||
if (areq->iv) {
|
||||
for (i = 0; i < 4 && i < ivsize / 4; i++) {
|
||||
@ -314,8 +337,6 @@ static int sun4i_ss_cipher_poll(struct skcipher_request *areq)
|
||||
}
|
||||
|
||||
release_ss:
|
||||
sg_miter_stop(&mi);
|
||||
sg_miter_stop(&mo);
|
||||
writel(0, ss->base + SS_CTL);
|
||||
spin_unlock_irqrestore(&ss->slock, flags);
|
||||
|
||||
|
||||
@ -1066,11 +1066,12 @@ static void ipsec_esp_decrypt_hwauth_done(struct device *dev,
|
||||
*/
|
||||
static int sg_to_link_tbl_offset(struct scatterlist *sg, int sg_count,
|
||||
unsigned int offset, int datalen, int elen,
|
||||
struct talitos_ptr *link_tbl_ptr)
|
||||
struct talitos_ptr *link_tbl_ptr, int align)
|
||||
{
|
||||
int n_sg = elen ? sg_count + 1 : sg_count;
|
||||
int count = 0;
|
||||
int cryptlen = datalen + elen;
|
||||
int padding = ALIGN(cryptlen, align) - cryptlen;
|
||||
|
||||
while (cryptlen && sg && n_sg--) {
|
||||
unsigned int len = sg_dma_len(sg);
|
||||
@ -1094,7 +1095,7 @@ static int sg_to_link_tbl_offset(struct scatterlist *sg, int sg_count,
|
||||
offset += datalen;
|
||||
}
|
||||
to_talitos_ptr(link_tbl_ptr + count,
|
||||
sg_dma_address(sg) + offset, len, 0);
|
||||
sg_dma_address(sg) + offset, sg_next(sg) ? len : len + padding, 0);
|
||||
to_talitos_ptr_ext_set(link_tbl_ptr + count, 0, 0);
|
||||
count++;
|
||||
cryptlen -= len;
|
||||
@ -1117,10 +1118,11 @@ static int talitos_sg_map_ext(struct device *dev, struct scatterlist *src,
|
||||
unsigned int len, struct talitos_edesc *edesc,
|
||||
struct talitos_ptr *ptr, int sg_count,
|
||||
unsigned int offset, int tbl_off, int elen,
|
||||
bool force)
|
||||
bool force, int align)
|
||||
{
|
||||
struct talitos_private *priv = dev_get_drvdata(dev);
|
||||
bool is_sec1 = has_ftr_sec1(priv);
|
||||
int aligned_len = ALIGN(len, align);
|
||||
|
||||
if (!src) {
|
||||
to_talitos_ptr(ptr, 0, 0, is_sec1);
|
||||
@ -1128,22 +1130,22 @@ static int talitos_sg_map_ext(struct device *dev, struct scatterlist *src,
|
||||
}
|
||||
to_talitos_ptr_ext_set(ptr, elen, is_sec1);
|
||||
if (sg_count == 1 && !force) {
|
||||
to_talitos_ptr(ptr, sg_dma_address(src) + offset, len, is_sec1);
|
||||
to_talitos_ptr(ptr, sg_dma_address(src) + offset, aligned_len, is_sec1);
|
||||
return sg_count;
|
||||
}
|
||||
if (is_sec1) {
|
||||
to_talitos_ptr(ptr, edesc->dma_link_tbl + offset, len, is_sec1);
|
||||
to_talitos_ptr(ptr, edesc->dma_link_tbl + offset, aligned_len, is_sec1);
|
||||
return sg_count;
|
||||
}
|
||||
sg_count = sg_to_link_tbl_offset(src, sg_count, offset, len, elen,
|
||||
&edesc->link_tbl[tbl_off]);
|
||||
&edesc->link_tbl[tbl_off], align);
|
||||
if (sg_count == 1 && !force) {
|
||||
/* Only one segment now, so no link tbl needed*/
|
||||
copy_talitos_ptr(ptr, &edesc->link_tbl[tbl_off], is_sec1);
|
||||
return sg_count;
|
||||
}
|
||||
to_talitos_ptr(ptr, edesc->dma_link_tbl +
|
||||
tbl_off * sizeof(struct talitos_ptr), len, is_sec1);
|
||||
tbl_off * sizeof(struct talitos_ptr), aligned_len, is_sec1);
|
||||
to_talitos_ptr_ext_or(ptr, DESC_PTR_LNKTBL_JUMP, is_sec1);
|
||||
|
||||
return sg_count;
|
||||
@ -1155,7 +1157,7 @@ static int talitos_sg_map(struct device *dev, struct scatterlist *src,
|
||||
unsigned int offset, int tbl_off)
|
||||
{
|
||||
return talitos_sg_map_ext(dev, src, len, edesc, ptr, sg_count, offset,
|
||||
tbl_off, 0, false);
|
||||
tbl_off, 0, false, 1);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1224,7 +1226,7 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
|
||||
|
||||
ret = talitos_sg_map_ext(dev, areq->src, cryptlen, edesc, &desc->ptr[4],
|
||||
sg_count, areq->assoclen, tbl_off, elen,
|
||||
false);
|
||||
false, 1);
|
||||
|
||||
if (ret > 1) {
|
||||
tbl_off += ret;
|
||||
@ -1244,7 +1246,7 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
|
||||
elen = 0;
|
||||
ret = talitos_sg_map_ext(dev, areq->dst, cryptlen, edesc, &desc->ptr[5],
|
||||
sg_count, areq->assoclen, tbl_off, elen,
|
||||
is_ipsec_esp && !encrypt);
|
||||
is_ipsec_esp && !encrypt, 1);
|
||||
tbl_off += ret;
|
||||
|
||||
/* ICV data */
|
||||
@ -1554,6 +1556,8 @@ static int common_nonsnoop(struct talitos_edesc *edesc,
|
||||
bool sync_needed = false;
|
||||
struct talitos_private *priv = dev_get_drvdata(dev);
|
||||
bool is_sec1 = has_ftr_sec1(priv);
|
||||
bool is_ctr = (desc->hdr & DESC_HDR_SEL0_MASK) == DESC_HDR_SEL0_AESU &&
|
||||
(desc->hdr & DESC_HDR_MODE0_AESU_MASK) == DESC_HDR_MODE0_AESU_CTR;
|
||||
|
||||
/* first DWORD empty */
|
||||
|
||||
@ -1574,8 +1578,8 @@ static int common_nonsnoop(struct talitos_edesc *edesc,
|
||||
/*
|
||||
* cipher in
|
||||
*/
|
||||
sg_count = talitos_sg_map(dev, areq->src, cryptlen, edesc,
|
||||
&desc->ptr[3], sg_count, 0, 0);
|
||||
sg_count = talitos_sg_map_ext(dev, areq->src, cryptlen, edesc, &desc->ptr[3],
|
||||
sg_count, 0, 0, 0, false, is_ctr ? 16 : 1);
|
||||
if (sg_count > 1)
|
||||
sync_needed = true;
|
||||
|
||||
|
||||
@ -377,6 +377,7 @@ static inline bool has_ftr_sec1(struct talitos_private *priv)
|
||||
|
||||
/* primary execution unit mode (MODE0) and derivatives */
|
||||
#define DESC_HDR_MODE0_ENCRYPT cpu_to_be32(0x00100000)
|
||||
#define DESC_HDR_MODE0_AESU_MASK cpu_to_be32(0x00600000)
|
||||
#define DESC_HDR_MODE0_AESU_CBC cpu_to_be32(0x00200000)
|
||||
#define DESC_HDR_MODE0_AESU_CTR cpu_to_be32(0x00600000)
|
||||
#define DESC_HDR_MODE0_DEU_CBC cpu_to_be32(0x00400000)
|
||||
|
||||
@ -1218,6 +1218,7 @@ static int fsldma_of_probe(struct platform_device *op)
|
||||
{
|
||||
struct fsldma_device *fdev;
|
||||
struct device_node *child;
|
||||
unsigned int i;
|
||||
int err;
|
||||
|
||||
fdev = kzalloc(sizeof(*fdev), GFP_KERNEL);
|
||||
@ -1296,6 +1297,10 @@ static int fsldma_of_probe(struct platform_device *op)
|
||||
return 0;
|
||||
|
||||
out_free_fdev:
|
||||
for (i = 0; i < FSL_DMA_MAX_CHANS_PER_DEVICE; i++) {
|
||||
if (fdev->chan[i])
|
||||
fsl_dma_chan_remove(fdev->chan[i]);
|
||||
}
|
||||
irq_dispose_mapping(fdev->irq);
|
||||
iounmap(fdev->regs);
|
||||
out_free:
|
||||
@ -1318,6 +1323,7 @@ static int fsldma_of_remove(struct platform_device *op)
|
||||
if (fdev->chan[i])
|
||||
fsl_dma_chan_remove(fdev->chan[i]);
|
||||
}
|
||||
irq_dispose_mapping(fdev->irq);
|
||||
|
||||
iounmap(fdev->regs);
|
||||
kfree(fdev);
|
||||
|
||||
@ -29,22 +29,12 @@
|
||||
static irqreturn_t hsu_pci_irq(int irq, void *dev)
|
||||
{
|
||||
struct hsu_dma_chip *chip = dev;
|
||||
struct pci_dev *pdev = to_pci_dev(chip->dev);
|
||||
u32 dmaisr;
|
||||
u32 status;
|
||||
unsigned short i;
|
||||
int ret = 0;
|
||||
int err;
|
||||
|
||||
/*
|
||||
* On Intel Tangier B0 and Anniedale the interrupt line, disregarding
|
||||
* to have different numbers, is shared between HSU DMA and UART IPs.
|
||||
* Thus on such SoCs we are expecting that IRQ handler is called in
|
||||
* UART driver only.
|
||||
*/
|
||||
if (pdev->device == PCI_DEVICE_ID_INTEL_MRFLD_HSU_DMA)
|
||||
return IRQ_HANDLED;
|
||||
|
||||
dmaisr = readl(chip->regs + HSU_PCI_DMAISR);
|
||||
for (i = 0; i < chip->hsu->nr_channels; i++) {
|
||||
if (dmaisr & 0x1) {
|
||||
@ -108,6 +98,17 @@ static int hsu_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
|
||||
if (ret)
|
||||
goto err_register_irq;
|
||||
|
||||
/*
|
||||
* On Intel Tangier B0 and Anniedale the interrupt line, disregarding
|
||||
* to have different numbers, is shared between HSU DMA and UART IPs.
|
||||
* Thus on such SoCs we are expecting that IRQ handler is called in
|
||||
* UART driver only. Instead of handling the spurious interrupt
|
||||
* from HSU DMA here and waste CPU time and delay HSU UART interrupt
|
||||
* handling, disable the interrupt entirely.
|
||||
*/
|
||||
if (pdev->device == PCI_DEVICE_ID_INTEL_MRFLD_HSU_DMA)
|
||||
disable_irq_nosync(chip->irq);
|
||||
|
||||
pci_set_drvdata(pdev, chip);
|
||||
|
||||
return 0;
|
||||
|
||||
@ -932,6 +932,7 @@ static int owl_dma_remove(struct platform_device *pdev)
|
||||
owl_dma_free(od);
|
||||
|
||||
clk_disable_unprepare(od->clk);
|
||||
dma_pool_destroy(od->lli_pool);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -357,7 +357,7 @@ static int pcf857x_probe(struct i2c_client *client,
|
||||
* reset state. Otherwise it flags pins to be driven low.
|
||||
*/
|
||||
gpio->out = ~n_latch;
|
||||
gpio->status = gpio->out;
|
||||
gpio->status = gpio->read(gpio->client);
|
||||
|
||||
status = devm_gpiochip_add_data(&client->dev, &gpio->chip, gpio);
|
||||
if (status < 0)
|
||||
|
||||
@ -617,7 +617,7 @@ static ssize_t amdgpu_get_pp_dpm_sclk(struct device *dev,
|
||||
static ssize_t amdgpu_read_mask(const char *buf, size_t count, uint32_t *mask)
|
||||
{
|
||||
int ret;
|
||||
long level;
|
||||
unsigned long level;
|
||||
char *sub_str = NULL;
|
||||
char *tmp;
|
||||
char buf_cpy[AMDGPU_MASK_BUF_MAX + 1];
|
||||
@ -633,8 +633,8 @@ static ssize_t amdgpu_read_mask(const char *buf, size_t count, uint32_t *mask)
|
||||
while (tmp[0]) {
|
||||
sub_str = strsep(&tmp, delimiter);
|
||||
if (strlen(sub_str)) {
|
||||
ret = kstrtol(sub_str, 0, &level);
|
||||
if (ret)
|
||||
ret = kstrtoul(sub_str, 0, &level);
|
||||
if (ret || level > 31)
|
||||
return -EINVAL;
|
||||
*mask |= 1 << level;
|
||||
} else
|
||||
|
||||
@ -21,7 +21,7 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#if !defined(_AMDGPU_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
|
||||
#if !defined(_AMDGPU_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)
|
||||
#define _AMDGPU_TRACE_H_
|
||||
|
||||
#include <linux/stringify.h>
|
||||
|
||||
@ -429,12 +429,12 @@ static void set_clamp(
|
||||
clamp_max = 0x3FC0;
|
||||
break;
|
||||
case COLOR_DEPTH_101010:
|
||||
/* 10bit MSB aligned on 14 bit bus '11 1111 1111 1100' */
|
||||
clamp_max = 0x3FFC;
|
||||
/* 10bit MSB aligned on 14 bit bus '11 1111 1111 0000' */
|
||||
clamp_max = 0x3FF0;
|
||||
break;
|
||||
case COLOR_DEPTH_121212:
|
||||
/* 12bit MSB aligned on 14 bit bus '11 1111 1111 1111' */
|
||||
clamp_max = 0x3FFF;
|
||||
/* 12bit MSB aligned on 14 bit bus '11 1111 1111 1100' */
|
||||
clamp_max = 0x3FFC;
|
||||
break;
|
||||
default:
|
||||
clamp_max = 0x3FC0;
|
||||
|
||||
@ -279,11 +279,8 @@ int oaktrail_hdmi_i2c_init(struct pci_dev *dev)
|
||||
hdmi_dev = pci_get_drvdata(dev);
|
||||
|
||||
i2c_dev = kzalloc(sizeof(struct hdmi_i2c_dev), GFP_KERNEL);
|
||||
if (i2c_dev == NULL) {
|
||||
DRM_ERROR("Can't allocate interface\n");
|
||||
ret = -ENOMEM;
|
||||
goto exit;
|
||||
}
|
||||
if (!i2c_dev)
|
||||
return -ENOMEM;
|
||||
|
||||
i2c_dev->adap = &oaktrail_hdmi_i2c_adapter;
|
||||
i2c_dev->status = I2C_STAT_INIT;
|
||||
@ -300,16 +297,23 @@ int oaktrail_hdmi_i2c_init(struct pci_dev *dev)
|
||||
oaktrail_hdmi_i2c_adapter.name, hdmi_dev);
|
||||
if (ret) {
|
||||
DRM_ERROR("Failed to request IRQ for I2C controller\n");
|
||||
goto err;
|
||||
goto free_dev;
|
||||
}
|
||||
|
||||
/* Adapter registration */
|
||||
ret = i2c_add_numbered_adapter(&oaktrail_hdmi_i2c_adapter);
|
||||
return ret;
|
||||
if (ret) {
|
||||
DRM_ERROR("Failed to add I2C adapter\n");
|
||||
goto free_irq;
|
||||
}
|
||||
|
||||
err:
|
||||
return 0;
|
||||
|
||||
free_irq:
|
||||
free_irq(dev->irq, hdmi_dev);
|
||||
free_dev:
|
||||
kfree(i2c_dev);
|
||||
exit:
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@ -316,6 +316,8 @@ static int psb_driver_load(struct drm_device *dev, unsigned long flags)
|
||||
if (ret)
|
||||
goto out_err;
|
||||
|
||||
ret = -ENOMEM;
|
||||
|
||||
dev_priv->mmu = psb_mmu_driver_init(dev, 1, 0, 0);
|
||||
if (!dev_priv->mmu)
|
||||
goto out_err;
|
||||
|
||||
@ -147,7 +147,7 @@ const struct msm_dsi_phy_cfg dsi_phy_20nm_cfgs = {
|
||||
.disable = dsi_20nm_phy_disable,
|
||||
.init = msm_dsi_phy_init_common,
|
||||
},
|
||||
.io_start = { 0xfd998300, 0xfd9a0300 },
|
||||
.io_start = { 0xfd998500, 0xfd9a0500 },
|
||||
.num_dsi_phy = 2,
|
||||
};
|
||||
|
||||
|
||||
@ -93,7 +93,7 @@ EXPORT_SYMBOL_GPL(hid_register_report);
|
||||
* Register a new field for this report.
|
||||
*/
|
||||
|
||||
static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)
|
||||
static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages)
|
||||
{
|
||||
struct hid_field *field;
|
||||
|
||||
@ -104,7 +104,7 @@ static struct hid_field *hid_register_field(struct hid_report *report, unsigned
|
||||
|
||||
field = kzalloc((sizeof(struct hid_field) +
|
||||
usages * sizeof(struct hid_usage) +
|
||||
values * sizeof(unsigned)), GFP_KERNEL);
|
||||
usages * sizeof(unsigned)), GFP_KERNEL);
|
||||
if (!field)
|
||||
return NULL;
|
||||
|
||||
@ -300,7 +300,7 @@ static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsign
|
||||
usages = max_t(unsigned, parser->local.usage_index,
|
||||
parser->global.report_count);
|
||||
|
||||
field = hid_register_field(report, usages, parser->global.report_count);
|
||||
field = hid_register_field(report, usages);
|
||||
if (!field)
|
||||
return 0;
|
||||
|
||||
@ -1128,6 +1128,9 @@ EXPORT_SYMBOL_GPL(hid_open_report);
|
||||
|
||||
static s32 snto32(__u32 value, unsigned n)
|
||||
{
|
||||
if (!value || !n)
|
||||
return 0;
|
||||
|
||||
switch (n) {
|
||||
case 8: return ((__s8)value);
|
||||
case 16: return ((__s16)value);
|
||||
|
||||
@ -2557,7 +2557,12 @@ static void wacom_wac_finger_event(struct hid_device *hdev,
|
||||
wacom_wac->hid_data.tipswitch = value;
|
||||
break;
|
||||
case HID_DG_CONTACTMAX:
|
||||
features->touch_max = value;
|
||||
if (!features->touch_max) {
|
||||
features->touch_max = value;
|
||||
} else {
|
||||
hid_warn(hdev, "%s: ignoring attempt to overwrite non-zero touch_max "
|
||||
"%d -> %d\n", __func__, features->touch_max, value);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@ -1001,8 +1001,7 @@ static void vmbus_onoffer_rescind(struct vmbus_channel_message_header *hdr)
|
||||
vmbus_device_unregister(channel->device_obj);
|
||||
put_device(dev);
|
||||
}
|
||||
}
|
||||
if (channel->primary_channel != NULL) {
|
||||
} else if (channel->primary_channel != NULL) {
|
||||
/*
|
||||
* Sub-channel is being rescinded. Following is the channel
|
||||
* close sequence when initiated from the driveri (refer to
|
||||
|
||||
@ -318,7 +318,7 @@ static int brcmstb_send_i2c_cmd(struct brcmstb_i2c_dev *dev,
|
||||
goto cmd_out;
|
||||
}
|
||||
|
||||
if ((CMD_RD || CMD_WR) &&
|
||||
if ((cmd == CMD_RD || cmd == CMD_WR) &&
|
||||
bsc_readl(dev, iic_enable) & BSC_IIC_EN_NOACK_MASK) {
|
||||
rc = -EREMOTEIO;
|
||||
dev_dbg(dev->device, "controller received NOACK intr for %s\n",
|
||||
|
||||
@ -366,6 +366,11 @@ static ssize_t ib_umad_read(struct file *filp, char __user *buf,
|
||||
|
||||
mutex_lock(&file->mutex);
|
||||
|
||||
if (file->agents_dead) {
|
||||
mutex_unlock(&file->mutex);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
while (list_empty(&file->recv_list)) {
|
||||
mutex_unlock(&file->mutex);
|
||||
|
||||
@ -379,6 +384,11 @@ static ssize_t ib_umad_read(struct file *filp, char __user *buf,
|
||||
mutex_lock(&file->mutex);
|
||||
}
|
||||
|
||||
if (file->agents_dead) {
|
||||
mutex_unlock(&file->mutex);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
packet = list_entry(file->recv_list.next, struct ib_umad_packet, list);
|
||||
list_del(&packet->list);
|
||||
|
||||
@ -508,7 +518,7 @@ static ssize_t ib_umad_write(struct file *filp, const char __user *buf,
|
||||
|
||||
agent = __get_agent(file, packet->mad.hdr.id);
|
||||
if (!agent) {
|
||||
ret = -EINVAL;
|
||||
ret = -EIO;
|
||||
goto err_up;
|
||||
}
|
||||
|
||||
@ -637,10 +647,14 @@ static __poll_t ib_umad_poll(struct file *filp, struct poll_table_struct *wait)
|
||||
/* we will always be able to post a MAD send */
|
||||
__poll_t mask = EPOLLOUT | EPOLLWRNORM;
|
||||
|
||||
mutex_lock(&file->mutex);
|
||||
poll_wait(filp, &file->recv_wait, wait);
|
||||
|
||||
if (!list_empty(&file->recv_list))
|
||||
mask |= EPOLLIN | EPOLLRDNORM;
|
||||
if (file->agents_dead)
|
||||
mask = EPOLLERR;
|
||||
mutex_unlock(&file->mutex);
|
||||
|
||||
return mask;
|
||||
}
|
||||
@ -1257,6 +1271,7 @@ static void ib_umad_kill_port(struct ib_umad_port *port)
|
||||
list_for_each_entry(file, &port->file_list, port_list) {
|
||||
mutex_lock(&file->mutex);
|
||||
file->agents_dead = 1;
|
||||
wake_up_interruptible(&file->recv_wait);
|
||||
mutex_unlock(&file->mutex);
|
||||
|
||||
for (id = 0; id < IB_UMAD_MAX_AGENTS; ++id)
|
||||
|
||||
@ -572,7 +572,9 @@ static void devx_obj_build_destroy_cmd(void *in, void *out, void *din,
|
||||
MLX5_SET(general_obj_in_cmd_hdr, din, opcode, MLX5_CMD_OP_DESTROY_RQT);
|
||||
break;
|
||||
case MLX5_CMD_OP_CREATE_TIR:
|
||||
MLX5_SET(general_obj_in_cmd_hdr, din, opcode, MLX5_CMD_OP_DESTROY_TIR);
|
||||
*obj_id = MLX5_GET(create_tir_out, out, tirn);
|
||||
MLX5_SET(destroy_tir_in, din, opcode, MLX5_CMD_OP_DESTROY_TIR);
|
||||
MLX5_SET(destroy_tir_in, din, tirn, *obj_id);
|
||||
break;
|
||||
case MLX5_CMD_OP_CREATE_TIS:
|
||||
MLX5_SET(general_obj_in_cmd_hdr, din, opcode, MLX5_CMD_OP_DESTROY_TIS);
|
||||
|
||||
@ -500,6 +500,11 @@ int rxe_send(struct rxe_pkt_info *pkt, struct sk_buff *skb)
|
||||
|
||||
void rxe_loopback(struct sk_buff *skb)
|
||||
{
|
||||
if (skb->protocol == htons(ETH_P_IP))
|
||||
skb_pull(skb, sizeof(struct iphdr));
|
||||
else
|
||||
skb_pull(skb, sizeof(struct ipv6hdr));
|
||||
|
||||
rxe_rcv(skb);
|
||||
}
|
||||
|
||||
|
||||
@ -36,21 +36,26 @@
|
||||
#include "rxe.h"
|
||||
#include "rxe_loc.h"
|
||||
|
||||
/* check that QP matches packet opcode type and is in a valid state */
|
||||
static int check_type_state(struct rxe_dev *rxe, struct rxe_pkt_info *pkt,
|
||||
struct rxe_qp *qp)
|
||||
{
|
||||
unsigned int pkt_type;
|
||||
|
||||
if (unlikely(!qp->valid))
|
||||
goto err1;
|
||||
|
||||
pkt_type = pkt->opcode & 0xe0;
|
||||
|
||||
switch (qp_type(qp)) {
|
||||
case IB_QPT_RC:
|
||||
if (unlikely((pkt->opcode & IB_OPCODE_RC) != 0)) {
|
||||
if (unlikely(pkt_type != IB_OPCODE_RC)) {
|
||||
pr_warn_ratelimited("bad qp type\n");
|
||||
goto err1;
|
||||
}
|
||||
break;
|
||||
case IB_QPT_UC:
|
||||
if (unlikely(!(pkt->opcode & IB_OPCODE_UC))) {
|
||||
if (unlikely(pkt_type != IB_OPCODE_UC)) {
|
||||
pr_warn_ratelimited("bad qp type\n");
|
||||
goto err1;
|
||||
}
|
||||
@ -58,7 +63,7 @@ static int check_type_state(struct rxe_dev *rxe, struct rxe_pkt_info *pkt,
|
||||
case IB_QPT_UD:
|
||||
case IB_QPT_SMI:
|
||||
case IB_QPT_GSI:
|
||||
if (unlikely(!(pkt->opcode & IB_OPCODE_UD))) {
|
||||
if (unlikely(pkt_type != IB_OPCODE_UD)) {
|
||||
pr_warn_ratelimited("bad qp type\n");
|
||||
goto err1;
|
||||
}
|
||||
|
||||
@ -460,7 +460,7 @@ static int joydev_handle_JSIOCSAXMAP(struct joydev *joydev,
|
||||
if (IS_ERR(abspam))
|
||||
return PTR_ERR(abspam);
|
||||
|
||||
for (i = 0; i < joydev->nabs; i++) {
|
||||
for (i = 0; i < len && i < joydev->nabs; i++) {
|
||||
if (abspam[i] > ABS_MAX) {
|
||||
retval = -EINVAL;
|
||||
goto out;
|
||||
@ -484,6 +484,9 @@ static int joydev_handle_JSIOCSBTNMAP(struct joydev *joydev,
|
||||
int i;
|
||||
int retval = 0;
|
||||
|
||||
if (len % sizeof(*keypam))
|
||||
return -EINVAL;
|
||||
|
||||
len = min(len, sizeof(joydev->keypam));
|
||||
|
||||
/* Validate the map. */
|
||||
@ -491,7 +494,7 @@ static int joydev_handle_JSIOCSBTNMAP(struct joydev *joydev,
|
||||
if (IS_ERR(keypam))
|
||||
return PTR_ERR(keypam);
|
||||
|
||||
for (i = 0; i < joydev->nkey; i++) {
|
||||
for (i = 0; i < (len / 2) && i < joydev->nkey; i++) {
|
||||
if (keypam[i] > KEY_MAX || keypam[i] < BTN_MISC) {
|
||||
retval = -EINVAL;
|
||||
goto out;
|
||||
|
||||
@ -319,6 +319,7 @@ static const struct xpad_device {
|
||||
{ 0x1bad, 0xfd00, "Razer Onza TE", 0, XTYPE_XBOX360 },
|
||||
{ 0x1bad, 0xfd01, "Razer Onza", 0, XTYPE_XBOX360 },
|
||||
{ 0x20d6, 0x2001, "BDA Xbox Series X Wired Controller", 0, XTYPE_XBOXONE },
|
||||
{ 0x20d6, 0x2009, "PowerA Enhanced Wired Controller for Xbox Series X|S", 0, XTYPE_XBOXONE },
|
||||
{ 0x20d6, 0x281f, "PowerA Wired Controller For Xbox 360", 0, XTYPE_XBOX360 },
|
||||
{ 0x2e24, 0x0652, "Hyperkin Duke X-Box One pad", 0, XTYPE_XBOXONE },
|
||||
{ 0x24c6, 0x5000, "Razer Atrox Arcade Stick", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
|
||||
|
||||
@ -592,6 +592,10 @@ static const struct dmi_system_id i8042_dmi_noselftest_table[] = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
|
||||
DMI_MATCH(DMI_CHASSIS_TYPE, "10"), /* Notebook */
|
||||
},
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
|
||||
DMI_MATCH(DMI_CHASSIS_TYPE, "31"), /* Convertible Notebook */
|
||||
},
|
||||
},
|
||||
{ }
|
||||
};
|
||||
|
||||
@ -345,8 +345,10 @@ static int elo_connect(struct serio *serio, struct serio_driver *drv)
|
||||
switch (elo->id) {
|
||||
|
||||
case 0: /* 10-byte protocol */
|
||||
if (elo_setup_10(elo))
|
||||
if (elo_setup_10(elo)) {
|
||||
err = -EIO;
|
||||
goto fail3;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
|
||||
@ -419,6 +419,7 @@ static int raydium_i2c_write_object(struct i2c_client *client,
|
||||
enum raydium_bl_ack state)
|
||||
{
|
||||
int error;
|
||||
static const u8 cmd[] = { 0xFF, 0x39 };
|
||||
|
||||
error = raydium_i2c_send(client, RM_CMD_BOOT_WRT, data, len);
|
||||
if (error) {
|
||||
@ -427,7 +428,7 @@ static int raydium_i2c_write_object(struct i2c_client *client,
|
||||
return error;
|
||||
}
|
||||
|
||||
error = raydium_i2c_send(client, RM_CMD_BOOT_ACK, NULL, 0);
|
||||
error = raydium_i2c_send(client, RM_CMD_BOOT_ACK, cmd, sizeof(cmd));
|
||||
if (error) {
|
||||
dev_err(&client->dev, "Ack obj command failed: %d\n", error);
|
||||
return error;
|
||||
|
||||
@ -778,6 +778,7 @@ static int sur40_probe(struct usb_interface *interface,
|
||||
dev_err(&interface->dev,
|
||||
"Unable to register video controls.");
|
||||
v4l2_ctrl_handler_free(&sur40->hdl);
|
||||
error = sur40->hdl.error;
|
||||
goto err_unreg_v4l2;
|
||||
}
|
||||
|
||||
|
||||
@ -110,6 +110,10 @@ struct mapped_device {
|
||||
/* zero-length flush that will be cloned and submitted to targets */
|
||||
struct bio flush_bio;
|
||||
|
||||
int swap_bios;
|
||||
struct semaphore swap_bios_semaphore;
|
||||
struct mutex swap_bios_lock;
|
||||
|
||||
struct dm_stats stats;
|
||||
|
||||
struct kthread_worker kworker;
|
||||
|
||||
@ -2861,6 +2861,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
|
||||
wake_up_process(cc->write_thread);
|
||||
|
||||
ti->num_flush_bios = 1;
|
||||
ti->limit_swap_bios = true;
|
||||
|
||||
return 0;
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user