This is the 4.14.81 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAlvrIsYACgkQONu9yGCS
aT7AahAAn0IfSox3VzHgWzpZJts8jGyziMbP15hjSJjYlZSrrxUVKW3H5Kf0CUmR
33GaUM3CbfWAlQdqcgHbIoydQwY38Rggmuc/zonC+Bo0tPjfYGGGF6iFfNnwe+1L
nwYa2G/iPH776/+JkkSYbSsYnu5jHqGdkpai5zA5BFXd0HgD1vjRlsh7oKi2hwzk
ktWPVNQjucBOmXcG2hDzP685hj/e49trHzkCxwZG0CDJBbWHN8c5gxaTGf8QstuS
JvRts1Uh7w2kUkMh0oGcsFsEXJtupiAwUR36CqWA/kIfGBT+3D0XLCmWsDEqMxKQ
XWJXMAL/gPXi2b8bJaL4jyvuKwF4auWOWWP0rwRzyZKwHk2Mxa1aAc7QM6KgKoLx
DG4m+OLcCVFtHZDb70EXtl8qPtF6CBsY/EqbC1vaaFtwj0s3ytS/P6S37oPyJhC6
JF5O+k9cz9/C+2rkKrrzGnVrXoVlySczHxORkkdcTksRj/fxZ9j0C/+r5ZJbDy7k
8dzDJaThzLxS9nnD0ctGNIHzBr1iubyWGWN6dWHT2JlpcF9l1o6zlV3uIAnGiO+R
Qa3kNhIGKP265wqn/wGZpQX1aK4cO8e9FEaOQNpKzP4AB9whUpf/unDe9M/LVqRM
PEESzW8XLMaFL6WJlz3ZvO+C0LiUkbwAadLtsMaOGLcSh90C3jc=
=vsAz
-----END PGP SIGNATURE-----
Merge 4.14.81 into android-4.14
Changes in 4.14.81
mtd: spi-nor: fsl-quadspi: fix read error for flash size larger than 16MB
spi: bcm-qspi: switch back to reading flash using smaller chunks
bcache: trace missed reading by cache_missed
bcache: fix miss key refill->end in writeback
hwmon: (pmbus) Fix page count auto-detection.
jffs2: free jffs2_sb_info through jffs2_kill_sb()
cpufreq: conservative: Take limits changes into account properly
pcmcia: Implement CLKRUN protocol disabling for Ricoh bridges
ipmi: Fix timer race with module unload
parisc: Fix address in HPMC IVA
parisc: Fix map_pages() to not overwrite existing pte entries
parisc: Fix exported address of os_hpmc handler
ALSA: hda - Add quirk for ASUS G751 laptop
ALSA: hda - Fix headphone pin config for ASUS G751
ALSA: hda/realtek - Fix the problem of the front MIC on the Lenovo M715
ALSA: hda - Add mic quirk for the Lenovo G50-30 (17aa:3905)
ALSA: ca0106: Disable IZD on SB0570 DAC to fix audio pops
x86/speculation: Enable cross-hyperthread spectre v2 STIBP mitigation
x86/xen: Fix boot loader version reported for PVH guests
x86/corruption-check: Fix panic in memory_corruption_check() when boot option without value is provided
x86/mm/pat: Disable preemption around __flush_tlb_all()
x86/speculation: Support Enhanced IBRS on future CPUs
ARM: dts: exynos: Disable pull control for MAX8997 interrupts on Origen
bpf: do not blindly change rlimit in reuseport net selftest
Revert "perf tools: Fix PMU term format max value calculation"
xfrm: policy: use hlist rcu variants on insert
perf vendor events intel: Fix wrong filter_band* values for uncore events
sparc: Fix single-pcr perf event counter management.
sparc: Throttle perf events properly.
sparc64: Make proc_id signed.
sched/fair: Fix the min_vruntime update logic in dequeue_entity()
perf tools: Fix use of alternatives to find JDIR
perf cpu_map: Align cpu map synthesized events properly.
x86/fpu: Remove second definition of fpu in __fpu__restore_sig()
net: qla3xxx: Remove overflowing shift statement
selftests: ftrace: Add synthetic event syntax testcase
i2c: rcar: cleanup DMA for all kinds of failure
locking/lockdep: Fix debug_locks off performance problem
ataflop: fix error handling during setup
swim: fix cleanup on setup error
nfp: devlink port split support for 1x100G CXP NIC
tun: Consistently configure generic netdev params via rtnetlink
s390/sthyi: Fix machine name validity indication
hwmon: (pwm-fan) Set fan speed to 0 on suspend
lightnvm: pblk: fix two sleep-in-atomic-context bugs
spi: spi-ep93xx: Use dma_data_direction for ep93xx_spi_dma_{finish,prepare}
perf tools: Free temporary 'sys' string in read_event_files()
perf tools: Cleanup trace-event-info 'tdata' leak
perf strbuf: Match va_{add,copy} with va_end
cpupower: Fix coredump on VMWare
mmc: sdhci-pci-o2micro: Add quirk for O2 Micro dev 0x8620 rev 0x01
iwlwifi: pcie: avoid empty free RB queue
iwlwifi: mvm: clear HW_RESTART_REQUESTED when stopping the interface
x86/olpc: Indicate that legacy PC XO-1 platform should not register RTC
ACPI / processor: Fix the return value of acpi_processor_ids_walk()
cpufreq: dt: Try freeing static OPPs only if we have added them
mtd: rawnand: atmel: Fix potential NULL pointer dereference
signal: Introduce COMPAT_SIGMINSTKSZ for use in compat_sys_sigaltstack
Bluetooth: btbcm: Add entry for BCM4335C0 UART bluetooth
x86: boot: Fix EFI stub alignment
pinctrl: qcom: spmi-mpp: Fix err handling of pmic_mpp_set_mux
brcmfmac: fix for proper support of 160MHz bandwidth
net: phy: phylink: ensure the carrier is off when starting phylink
block, bfq: correctly charge and reset entity service in all cases
kprobes: Return error if we fail to reuse kprobe instead of BUG_ON()
ACPI / LPSS: Add alternative ACPI HIDs for Cherry Trail DMA controllers
pinctrl: qcom: spmi-mpp: Fix drive strength setting
pinctrl: spmi-mpp: Fix pmic_mpp_config_get() to be compliant
pinctrl: ssbi-gpio: Fix pm8xxx_pin_config_get() to be compliant
net: dsa: mv88e6xxx: Fix writing to a PHY page.
iwlwifi: mvm: fix BAR seq ctrl reporting
ixgbevf: VF2VF TCP RSS
ath10k: schedule hardware restart if WMI command times out
thermal: da9062/61: Prevent hardware access during system suspend
cgroup, netclassid: add a preemption point to write_classid
scsi: esp_scsi: Track residual for PIO transfers
UAPI: ndctl: Fix g++-unsupported initialisation in headers
KVM: nVMX: Clear reserved bits of #DB exit qualification
scsi: megaraid_sas: fix a missing-check bug
RDMA/core: Do not expose unsupported counters
IB/ipoib: Clear IPCB before icmp_send
RDMA/bnxt_re: Fix recursive lock warning in debug kernel
usb: host: ohci-at91: fix request of irq for optional gpio
PCI: mediatek: Fix mtk_pcie_find_port() endpoint/port matching logic
tpm: suppress transmit cmd error logs when TPM 1.2 is disabled/deactivated
Drivers: hv: vmbus: Use cpumask_var_t for on-stack cpu mask
VMCI: Resource wildcard match fixed
PCI / ACPI: Enable wake automatically for power managed bridges
usb: gadget: udc: atmel: handle at91sam9rl PMC
ext4: fix argument checking in EXT4_IOC_MOVE_EXT
MD: fix invalid stored role for a disk
f2fs: fix to recover inode's i_flags during POR
PCI/MSI: Warn and return error if driver enables MSI/MSI-X twice
coresight: etb10: Fix handling of perf mode
PCI: dwc: pci-dra7xx: Enable errata i870 for both EP and RC mode
crypto: caam - fix implicit casts in endianness helpers
usb: chipidea: Prevent unbalanced IRQ disable
driver/dma/ioat: Call del_timer_sync() without holding prep_lock
uio: ensure class is registered before devices
scsi: lpfc: Correct soft lockup when running mds diagnostics
scsi: lpfc: Correct race with abort on completion path
f2fs: report error if quota off error during umount
signal: Always deliver the kernel's SIGKILL and SIGSTOP to a pid namespace init
mfd: menelaus: Fix possible race condition and leak
dmaengine: dma-jz4780: Return error if not probed from DT
IB/rxe: fix for duplicate request processing and ack psns
ALSA: hda: Check the non-cached stream buffers more explicitly
cpupower: Fix AMD Family 0x17 msr_pstate size
Revert "f2fs: fix to clear PG_checked flag in set_page_dirty()"
f2fs: fix to account IO correctly
ARM: dts: exynos: Remove "cooling-{min|max}-level" for CPU nodes
arm: dts: exynos: Add missing cooling device properties for CPUs
ARM: dts: exynos: Convert exynos5250.dtsi to opp-v2 bindings
ARM: dts: exynos: Mark 1 GHz CPU OPP as suspend OPP on Exynos5250
xen-swiotlb: use actually allocated size on check physical continuous
tpm: Restore functionality to xen vtpm driver.
xen/blkfront: avoid NULL blkfront_info dereference on device removal
xen/balloon: Support xend-based toolstack
xen: fix race in xen_qlock_wait()
xen: make xen_qlock_wait() nestable
xen/pvh: increase early stack size
xen/pvh: don't try to unplug emulated devices
libertas: don't set URB_ZERO_PACKET on IN USB transfer
usbip:vudc: BUG kmalloc-2048 (Not tainted): Poison overwritten
usb: gadget: udc: renesas_usb3: Fix b-device mode for "workaround"
iwlwifi: mvm: check return value of rs_rate_from_ucode_rate()
net/ipv4: defensive cipso option parsing
dmaengine: ppc4xx: fix off-by-one build failure
dmaengine: stm32-dma: fix incomplete configuration in cyclic mode
libnvdimm: Hold reference on parent while scheduling async init
libnvdimm, region: Fail badblocks listing for inactive regions
ASoC: intel: skylake: Add missing break in skl_tplg_get_token()
IB/mlx5: Fix MR cache initialization
jbd2: fix use after free in jbd2_log_do_checkpoint()
gfs2_meta: ->mount() can get NULL dev_name
ext4: initialize retries variable in ext4_da_write_inline_data_begin()
ext4: fix setattr project check in fssetxattr ioctl
ext4: propagate error from dquot_initialize() in EXT4_IOC_FSSETXATTR
ext4: fix use-after-free race in ext4_remount()'s error path
HID: hiddev: fix potential Spectre v1
EDAC, amd64: Add Family 17h, models 10h-2fh support
EDAC, {i7core,sb,skx}_edac: Fix uncorrected error counting
EDAC, skx_edac: Fix logical channel intermediate decoding
ARM: dts: dra7: Fix up unaligned access setting for PCIe EP
PCI/ASPM: Fix link_state teardown on device removal
PCI: Add Device IDs for Intel GPU "spurious interrupt" quirk
PCI: vmd: White list for fast interrupt handlers
signal/GenWQE: Fix sending of SIGKILL
signal: Guard against negative signal numbers in copy_siginfo_from_user32
crypto: lrw - Fix out-of bounds access on counter overflow
crypto: tcrypt - fix ghash-generic speed test
mm: /proc/pid/smaps_rollup: fix NULL pointer deref in smaps_pte_range()
ima: fix showing large 'violations' or 'runtime_measurements_count'
hugetlbfs: dirty pages as they are added to pagecache
mm/rmap: map_pte() was not handling private ZONE_DEVICE page properly
KVM: arm64: Fix caching of host MDCR_EL2 value
kbuild: fix kernel/bounds.c 'W=1' warning
iio: ad5064: Fix regulator handling
iio: adc: imx25-gcq: Fix leak of device_node in mx25_gcq_setup_cfgs()
iio: adc: at91: fix acking DRDY irq on simple conversions
iio: adc: at91: fix wrong channel number in triggered buffer mode
w1: omap-hdq: fix missing bus unregister at removal
smb3: allow stats which track session and share reconnects to be reset
smb3: do not attempt cifs operation in smb3 query info error path
smb3: on kerberos mount if server doesn't specify auth type use krb5
printk: Fix panic caused by passing log_buf_len to command line
genirq: Fix race on spurious interrupt detection
NFSv4.1: Fix the r/wsize checking
nfs: Fix a missed page unlock after pg_doio()
nfsd: Fix an Oops in free_session()
lockd: fix access beyond unterminated strings in prints
dm ioctl: harden copy_params()'s copy_from_user() from malicious users
dm zoned: fix metadata block ref counting
dm zoned: fix various dmz_get_mblock() issues
powerpc/msi: Fix compile error on mpc83xx
MIPS: OCTEON: fix out of bounds array access on CN68XX
iommu/arm-smmu: Ensure that page-table updates are visible before TLBI
TC: Set DMA masks for devices
media: v4l2-tpg: fix kernel oops when enabling HFLIP and OSD
kgdboc: Passing ekgdboc to command line causes panic
xen: fix xen_qlock_wait()
xen-blkfront: fix kernel panic with negotiate_mq error path
media: em28xx: use a default format if TRY_FMT fails
media: tvp5150: avoid going past array on v4l2_querymenu()
media: em28xx: fix input name for Terratec AV 350
media: em28xx: make v4l2-compliance happier by starting sequence on zero
media: media colorspaces*.rst: rename AdobeRGB to opRGB
arm64: lse: remove -fcall-used-x0 flag
rpmsg: smd: fix memory leak on channel create
Cramfs: fix abad comparison when wrap-arounds occur
ARM: dts: socfpga: Fix SDRAM node address for Arria10
arm64: dts: stratix10: Correct System Manager register size
soc/tegra: pmc: Fix child-node lookup
selftests/powerpc: Fix ptrace tm failure
btrfs: qgroup: Avoid calling qgroup functions if qgroup is not enabled
btrfs: Handle owner mismatch gracefully when walking up tree
btrfs: locking: Add extra check in btrfs_init_new_buffer() to avoid deadlock
btrfs: fix error handling in free_log_tree
btrfs: Enhance btrfs_trim_fs function to handle error better
btrfs: Ensure btrfs_trim_fs can trim the whole filesystem
btrfs: iterate all devices during trim, instead of fs_devices::alloc_list
btrfs: don't attempt to trim devices that don't support it
btrfs: wait on caching when putting the bg cache
btrfs: protect space cache inode alloc with GFP_NOFS
btrfs: reset max_extent_size on clear in a bitmap
btrfs: make sure we create all new block groups
Btrfs: fix warning when replaying log after fsync of a tmpfile
Btrfs: fix wrong dentries after fsync of file that got its parent replaced
btrfs: qgroup: Dirty all qgroups before rescan
Btrfs: fix null pointer dereference on compressed write path error
Btrfs: fix assertion on fsync of regular file when using no-holes feature
btrfs: set max_extent_size properly
btrfs: don't use ctl->free_space for max_extent_size
btrfs: only free reserved extent if we didn't insert it
btrfs: don't run delayed_iputs in commit
btrfs: move the dio_sem higher up the callchain
Btrfs: fix use-after-free during inode eviction
Btrfs: fix use-after-free when dumping free space
Btrfs: fix fsync after hole punching when using no-holes feature
net: sched: Remove TCA_OPTIONS from policy
bpf: wait for running BPF programs when updating map-in-map
MD: fix invalid stored role for a disk - try2
Linux 4.14.81
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
commit
4e76528bd4
218 changed files with 1814 additions and 666 deletions
|
|
@ -226,16 +226,6 @@ xvYCC
|
|||
|
||||
:author: International Electrotechnical Commission (http://www.iec.ch)
|
||||
|
||||
.. _adobergb:
|
||||
|
||||
AdobeRGB
|
||||
========
|
||||
|
||||
|
||||
:title: Adobe© RGB (1998) Color Image Encoding Version 2005-05
|
||||
|
||||
:author: Adobe Systems Incorporated (http://www.adobe.com)
|
||||
|
||||
.. _oprgb:
|
||||
|
||||
opRGB
|
||||
|
|
|
|||
|
|
@ -51,8 +51,8 @@ whole range, 0-255, dividing the angular value by 1.41. The enum
|
|||
- See :ref:`col-rec709`.
|
||||
* - ``V4L2_COLORSPACE_SRGB``
|
||||
- See :ref:`col-srgb`.
|
||||
* - ``V4L2_COLORSPACE_ADOBERGB``
|
||||
- See :ref:`col-adobergb`.
|
||||
* - ``V4L2_COLORSPACE_OPRGB``
|
||||
- See :ref:`col-oprgb`.
|
||||
* - ``V4L2_COLORSPACE_BT2020``
|
||||
- See :ref:`col-bt2020`.
|
||||
* - ``V4L2_COLORSPACE_DCI_P3``
|
||||
|
|
@ -90,8 +90,8 @@ whole range, 0-255, dividing the angular value by 1.41. The enum
|
|||
- Use the Rec. 709 transfer function.
|
||||
* - ``V4L2_XFER_FUNC_SRGB``
|
||||
- Use the sRGB transfer function.
|
||||
* - ``V4L2_XFER_FUNC_ADOBERGB``
|
||||
- Use the AdobeRGB transfer function.
|
||||
* - ``V4L2_XFER_FUNC_OPRGB``
|
||||
- Use the opRGB transfer function.
|
||||
* - ``V4L2_XFER_FUNC_SMPTE240M``
|
||||
- Use the SMPTE 240M transfer function.
|
||||
* - ``V4L2_XFER_FUNC_NONE``
|
||||
|
|
|
|||
|
|
@ -290,15 +290,14 @@ Y' is clamped to the range [0…1] and Cb and Cr are clamped to the range
|
|||
170M/BT.601. The Y'CbCr quantization is limited range.
|
||||
|
||||
|
||||
.. _col-adobergb:
|
||||
.. _col-oprgb:
|
||||
|
||||
Colorspace Adobe RGB (V4L2_COLORSPACE_ADOBERGB)
|
||||
Colorspace opRGB (V4L2_COLORSPACE_OPRGB)
|
||||
===============================================
|
||||
|
||||
The :ref:`adobergb` standard defines the colorspace used by computer
|
||||
graphics that use the AdobeRGB colorspace. This is also known as the
|
||||
:ref:`oprgb` standard. The default transfer function is
|
||||
``V4L2_XFER_FUNC_ADOBERGB``. The default Y'CbCr encoding is
|
||||
The :ref:`oprgb` standard defines the colorspace used by computer
|
||||
graphics that use the opRGB colorspace. The default transfer function is
|
||||
``V4L2_XFER_FUNC_OPRGB``. The default Y'CbCr encoding is
|
||||
``V4L2_YCBCR_ENC_601``. The default Y'CbCr quantization is limited
|
||||
range.
|
||||
|
||||
|
|
@ -312,7 +311,7 @@ The chromaticities of the primary colors and the white reference are:
|
|||
|
||||
.. tabularcolumns:: |p{4.4cm}|p{4.4cm}|p{8.7cm}|
|
||||
|
||||
.. flat-table:: Adobe RGB Chromaticities
|
||||
.. flat-table:: opRGB Chromaticities
|
||||
:header-rows: 1
|
||||
:stub-columns: 0
|
||||
:widths: 1 1 2
|
||||
|
|
|
|||
2
Makefile
2
Makefile
|
|
@ -1,7 +1,7 @@
|
|||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 14
|
||||
SUBLEVEL = 80
|
||||
SUBLEVEL = 81
|
||||
EXTRAVERSION =
|
||||
NAME = Petit Gorille
|
||||
|
||||
|
|
|
|||
|
|
@ -333,7 +333,7 @@
|
|||
ti,hwmods = "pcie1";
|
||||
phys = <&pcie1_phy>;
|
||||
phy-names = "pcie-phy0";
|
||||
ti,syscon-unaligned-access = <&scm_conf1 0x14 2>;
|
||||
ti,syscon-unaligned-access = <&scm_conf1 0x14 1>;
|
||||
status = "disabled";
|
||||
};
|
||||
};
|
||||
|
|
|
|||
|
|
@ -82,6 +82,22 @@
|
|||
compatible = "arm,cortex-a7";
|
||||
reg = <1>;
|
||||
clock-frequency = <1000000000>;
|
||||
clocks = <&cmu CLK_ARM_CLK>;
|
||||
clock-names = "cpu";
|
||||
#cooling-cells = <2>;
|
||||
|
||||
operating-points = <
|
||||
1000000 1150000
|
||||
900000 1112500
|
||||
800000 1075000
|
||||
700000 1037500
|
||||
600000 1000000
|
||||
500000 962500
|
||||
400000 925000
|
||||
300000 887500
|
||||
200000 850000
|
||||
100000 850000
|
||||
>;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -152,6 +152,8 @@
|
|||
reg = <0x66>;
|
||||
interrupt-parent = <&gpx0>;
|
||||
interrupts = <4 IRQ_TYPE_NONE>, <3 IRQ_TYPE_NONE>;
|
||||
pinctrl-names = "default";
|
||||
pinctrl-0 = <&max8997_irq>;
|
||||
|
||||
max8997,pmic-buck1-dvs-voltage = <1350000>;
|
||||
max8997,pmic-buck2-dvs-voltage = <1100000>;
|
||||
|
|
@ -289,6 +291,13 @@
|
|||
};
|
||||
};
|
||||
|
||||
&pinctrl_1 {
|
||||
max8997_irq: max8997-irq {
|
||||
samsung,pins = "gpx0-3", "gpx0-4";
|
||||
samsung,pin-pud = <EXYNOS_PIN_PULL_NONE>;
|
||||
};
|
||||
};
|
||||
|
||||
&sdhci_0 {
|
||||
bus-width = <4>;
|
||||
pinctrl-0 = <&sd0_clk &sd0_cmd &sd0_bus4 &sd0_cd>;
|
||||
|
|
|
|||
|
|
@ -52,8 +52,6 @@
|
|||
400000 975000
|
||||
200000 950000
|
||||
>;
|
||||
cooling-min-level = <4>;
|
||||
cooling-max-level = <2>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -61,6 +59,19 @@
|
|||
device_type = "cpu";
|
||||
compatible = "arm,cortex-a9";
|
||||
reg = <0x901>;
|
||||
clocks = <&clock CLK_ARM_CLK>;
|
||||
clock-names = "cpu";
|
||||
clock-latency = <160000>;
|
||||
|
||||
operating-points = <
|
||||
1200000 1250000
|
||||
1000000 1150000
|
||||
800000 1075000
|
||||
500000 975000
|
||||
400000 975000
|
||||
200000 950000
|
||||
>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -45,8 +45,6 @@
|
|||
clocks = <&clock CLK_ARM_CLK>;
|
||||
clock-names = "cpu";
|
||||
operating-points-v2 = <&cpu0_opp_table>;
|
||||
cooling-min-level = <13>;
|
||||
cooling-max-level = <7>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -57,38 +57,106 @@
|
|||
device_type = "cpu";
|
||||
compatible = "arm,cortex-a15";
|
||||
reg = <0>;
|
||||
clock-frequency = <1700000000>;
|
||||
clocks = <&clock CLK_ARM_CLK>;
|
||||
clock-names = "cpu";
|
||||
clock-latency = <140000>;
|
||||
|
||||
operating-points = <
|
||||
1700000 1300000
|
||||
1600000 1250000
|
||||
1500000 1225000
|
||||
1400000 1200000
|
||||
1300000 1150000
|
||||
1200000 1125000
|
||||
1100000 1100000
|
||||
1000000 1075000
|
||||
900000 1050000
|
||||
800000 1025000
|
||||
700000 1012500
|
||||
600000 1000000
|
||||
500000 975000
|
||||
400000 950000
|
||||
300000 937500
|
||||
200000 925000
|
||||
>;
|
||||
cooling-min-level = <15>;
|
||||
cooling-max-level = <9>;
|
||||
operating-points-v2 = <&cpu0_opp_table>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
cpu@1 {
|
||||
device_type = "cpu";
|
||||
compatible = "arm,cortex-a15";
|
||||
reg = <1>;
|
||||
clock-frequency = <1700000000>;
|
||||
clocks = <&clock CLK_ARM_CLK>;
|
||||
clock-names = "cpu";
|
||||
operating-points-v2 = <&cpu0_opp_table>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
};
|
||||
|
||||
cpu0_opp_table: opp_table0 {
|
||||
compatible = "operating-points-v2";
|
||||
opp-shared;
|
||||
|
||||
opp-200000000 {
|
||||
opp-hz = /bits/ 64 <200000000>;
|
||||
opp-microvolt = <925000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-300000000 {
|
||||
opp-hz = /bits/ 64 <300000000>;
|
||||
opp-microvolt = <937500>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-400000000 {
|
||||
opp-hz = /bits/ 64 <400000000>;
|
||||
opp-microvolt = <950000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-500000000 {
|
||||
opp-hz = /bits/ 64 <500000000>;
|
||||
opp-microvolt = <975000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-600000000 {
|
||||
opp-hz = /bits/ 64 <600000000>;
|
||||
opp-microvolt = <1000000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-700000000 {
|
||||
opp-hz = /bits/ 64 <700000000>;
|
||||
opp-microvolt = <1012500>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-800000000 {
|
||||
opp-hz = /bits/ 64 <800000000>;
|
||||
opp-microvolt = <1025000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-900000000 {
|
||||
opp-hz = /bits/ 64 <900000000>;
|
||||
opp-microvolt = <1050000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-1000000000 {
|
||||
opp-hz = /bits/ 64 <1000000000>;
|
||||
opp-microvolt = <1075000>;
|
||||
clock-latency-ns = <140000>;
|
||||
opp-suspend;
|
||||
};
|
||||
opp-1100000000 {
|
||||
opp-hz = /bits/ 64 <1100000000>;
|
||||
opp-microvolt = <1100000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-1200000000 {
|
||||
opp-hz = /bits/ 64 <1200000000>;
|
||||
opp-microvolt = <1125000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-1300000000 {
|
||||
opp-hz = /bits/ 64 <1300000000>;
|
||||
opp-microvolt = <1150000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-1400000000 {
|
||||
opp-hz = /bits/ 64 <1400000000>;
|
||||
opp-microvolt = <1200000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-1500000000 {
|
||||
opp-hz = /bits/ 64 <1500000000>;
|
||||
opp-microvolt = <1225000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-1600000000 {
|
||||
opp-hz = /bits/ 64 <1600000000>;
|
||||
opp-microvolt = <1250000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
opp-1700000000 {
|
||||
opp-hz = /bits/ 64 <1700000000>;
|
||||
opp-microvolt = <1300000>;
|
||||
clock-latency-ns = <140000>;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -33,8 +33,6 @@
|
|||
clock-frequency = <1800000000>;
|
||||
cci-control-port = <&cci_control1>;
|
||||
operating-points-v2 = <&cluster_a15_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <11>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -45,8 +43,6 @@
|
|||
clock-frequency = <1800000000>;
|
||||
cci-control-port = <&cci_control1>;
|
||||
operating-points-v2 = <&cluster_a15_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <11>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -57,8 +53,6 @@
|
|||
clock-frequency = <1800000000>;
|
||||
cci-control-port = <&cci_control1>;
|
||||
operating-points-v2 = <&cluster_a15_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <11>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -69,8 +63,6 @@
|
|||
clock-frequency = <1800000000>;
|
||||
cci-control-port = <&cci_control1>;
|
||||
operating-points-v2 = <&cluster_a15_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <11>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -82,8 +74,6 @@
|
|||
clock-frequency = <1000000000>;
|
||||
cci-control-port = <&cci_control0>;
|
||||
operating-points-v2 = <&cluster_a7_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <7>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -94,8 +84,6 @@
|
|||
clock-frequency = <1000000000>;
|
||||
cci-control-port = <&cci_control0>;
|
||||
operating-points-v2 = <&cluster_a7_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <7>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -106,8 +94,6 @@
|
|||
clock-frequency = <1000000000>;
|
||||
cci-control-port = <&cci_control0>;
|
||||
operating-points-v2 = <&cluster_a7_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <7>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -118,8 +104,6 @@
|
|||
clock-frequency = <1000000000>;
|
||||
cci-control-port = <&cci_control0>;
|
||||
operating-points-v2 = <&cluster_a7_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <7>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
};
|
||||
|
|
|
|||
|
|
@ -32,8 +32,6 @@
|
|||
clock-frequency = <1000000000>;
|
||||
cci-control-port = <&cci_control0>;
|
||||
operating-points-v2 = <&cluster_a7_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <11>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -44,8 +42,6 @@
|
|||
clock-frequency = <1000000000>;
|
||||
cci-control-port = <&cci_control0>;
|
||||
operating-points-v2 = <&cluster_a7_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <11>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -56,8 +52,6 @@
|
|||
clock-frequency = <1000000000>;
|
||||
cci-control-port = <&cci_control0>;
|
||||
operating-points-v2 = <&cluster_a7_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <11>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -68,8 +62,6 @@
|
|||
clock-frequency = <1000000000>;
|
||||
cci-control-port = <&cci_control0>;
|
||||
operating-points-v2 = <&cluster_a7_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <11>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -81,8 +73,6 @@
|
|||
clock-frequency = <1800000000>;
|
||||
cci-control-port = <&cci_control1>;
|
||||
operating-points-v2 = <&cluster_a15_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <15>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -93,8 +83,6 @@
|
|||
clock-frequency = <1800000000>;
|
||||
cci-control-port = <&cci_control1>;
|
||||
operating-points-v2 = <&cluster_a15_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <15>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -105,8 +93,6 @@
|
|||
clock-frequency = <1800000000>;
|
||||
cci-control-port = <&cci_control1>;
|
||||
operating-points-v2 = <&cluster_a15_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <15>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
|
||||
|
|
@ -117,8 +103,6 @@
|
|||
clock-frequency = <1800000000>;
|
||||
cci-control-port = <&cci_control1>;
|
||||
operating-points-v2 = <&cluster_a15_opp_table>;
|
||||
cooling-min-level = <0>;
|
||||
cooling-max-level = <15>;
|
||||
#cooling-cells = <2>; /* min followed by max */
|
||||
};
|
||||
};
|
||||
|
|
|
|||
|
|
@ -601,7 +601,7 @@
|
|||
status = "disabled";
|
||||
};
|
||||
|
||||
sdr: sdr@ffc25000 {
|
||||
sdr: sdr@ffcfb100 {
|
||||
compatible = "altr,sdr-ctl", "syscon";
|
||||
reg = <0xffcfb100 0x80>;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -249,7 +249,7 @@
|
|||
|
||||
sysmgr: sysmgr@ffd12000 {
|
||||
compatible = "altr,sys-mgr", "syscon";
|
||||
reg = <0xffd12000 0x1000>;
|
||||
reg = <0xffd12000 0x228>;
|
||||
};
|
||||
|
||||
/* Local timer */
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ lib-y := bitops.o clear_user.o delay.o copy_from_user.o \
|
|||
# when supported by the CPU. Result and argument registers are handled
|
||||
# correctly, based on the function prototype.
|
||||
lib-$(CONFIG_ARM64_LSE_ATOMICS) += atomic_ll_sc.o
|
||||
CFLAGS_atomic_ll_sc.o := -fcall-used-x0 -ffixed-x1 -ffixed-x2 \
|
||||
CFLAGS_atomic_ll_sc.o := -ffixed-x1 -ffixed-x2 \
|
||||
-ffixed-x3 -ffixed-x4 -ffixed-x5 -ffixed-x6 \
|
||||
-ffixed-x7 -fcall-saved-x8 -fcall-saved-x9 \
|
||||
-fcall-saved-x10 -fcall-saved-x11 -fcall-saved-x12 \
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ void (*cvmx_override_pko_queue_priority) (int pko_port,
|
|||
void (*cvmx_override_ipd_port_setup) (int ipd_port);
|
||||
|
||||
/* Port count per interface */
|
||||
static int interface_port_count[5];
|
||||
static int interface_port_count[9];
|
||||
|
||||
/**
|
||||
* Return the number of interfaces the chip has. Each interface
|
||||
|
|
|
|||
|
|
@ -185,7 +185,7 @@
|
|||
bv,n 0(%r3)
|
||||
nop
|
||||
.word 0 /* checksum (will be patched) */
|
||||
.word PA(os_hpmc) /* address of handler */
|
||||
.word 0 /* address of handler */
|
||||
.word 0 /* length of handler */
|
||||
.endm
|
||||
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ END(hpmc_pim_data)
|
|||
|
||||
.import intr_save, code
|
||||
.align 16
|
||||
ENTRY_CFI(os_hpmc)
|
||||
ENTRY(os_hpmc)
|
||||
.os_hpmc:
|
||||
|
||||
/*
|
||||
|
|
@ -302,7 +302,6 @@ os_hpmc_6:
|
|||
b .
|
||||
nop
|
||||
.align 16 /* make function length multiple of 16 bytes */
|
||||
ENDPROC_CFI(os_hpmc)
|
||||
.os_hpmc_end:
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -836,7 +836,8 @@ void __init initialize_ivt(const void *iva)
|
|||
if (pdc_instr(&instr) == PDC_OK)
|
||||
ivap[0] = instr;
|
||||
|
||||
/* Compute Checksum for HPMC handler */
|
||||
/* Setup IVA and compute checksum for HPMC handler */
|
||||
ivap[6] = (u32)__pa(os_hpmc);
|
||||
length = os_hpmc_size;
|
||||
ivap[7] = length;
|
||||
|
||||
|
|
|
|||
|
|
@ -495,12 +495,8 @@ static void __init map_pages(unsigned long start_vaddr,
|
|||
pte = pte_mkhuge(pte);
|
||||
}
|
||||
|
||||
if (address >= end_paddr) {
|
||||
if (force)
|
||||
break;
|
||||
else
|
||||
pte_val(pte) = 0;
|
||||
}
|
||||
if (address >= end_paddr)
|
||||
break;
|
||||
|
||||
set_pte(pg_table, pte);
|
||||
|
||||
|
|
|
|||
|
|
@ -393,7 +393,14 @@ extern struct bus_type mpic_subsys;
|
|||
#define MPIC_REGSET_TSI108 MPIC_REGSET(1) /* Tsi108/109 PIC */
|
||||
|
||||
/* Get the version of primary MPIC */
|
||||
#ifdef CONFIG_MPIC
|
||||
extern u32 fsl_mpic_primary_get_version(void);
|
||||
#else
|
||||
static inline u32 fsl_mpic_primary_get_version(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Allocate the controller structure and setup the linux irq descs
|
||||
* for the range if interrupts passed in. No HW initialization is
|
||||
|
|
|
|||
|
|
@ -174,17 +174,19 @@ static void fill_hdr(struct sthyi_sctns *sctns)
|
|||
static void fill_stsi_mac(struct sthyi_sctns *sctns,
|
||||
struct sysinfo_1_1_1 *sysinfo)
|
||||
{
|
||||
sclp_ocf_cpc_name_copy(sctns->mac.infmname);
|
||||
if (*(u64 *)sctns->mac.infmname != 0)
|
||||
sctns->mac.infmval1 |= MAC_NAME_VLD;
|
||||
|
||||
if (stsi(sysinfo, 1, 1, 1))
|
||||
return;
|
||||
|
||||
sclp_ocf_cpc_name_copy(sctns->mac.infmname);
|
||||
|
||||
memcpy(sctns->mac.infmtype, sysinfo->type, sizeof(sctns->mac.infmtype));
|
||||
memcpy(sctns->mac.infmmanu, sysinfo->manufacturer, sizeof(sctns->mac.infmmanu));
|
||||
memcpy(sctns->mac.infmpman, sysinfo->plant, sizeof(sctns->mac.infmpman));
|
||||
memcpy(sctns->mac.infmseq, sysinfo->sequence, sizeof(sctns->mac.infmseq));
|
||||
|
||||
sctns->mac.infmval1 |= MAC_ID_VLD | MAC_NAME_VLD;
|
||||
sctns->mac.infmval1 |= MAC_ID_VLD;
|
||||
}
|
||||
|
||||
static void fill_stsi_par(struct sthyi_sctns *sctns,
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ typedef struct {
|
|||
unsigned short sock_id; /* physical package */
|
||||
unsigned short core_id;
|
||||
unsigned short max_cache_id; /* groupings of highest shared cache */
|
||||
unsigned short proc_id; /* strand (aka HW thread) id */
|
||||
signed short proc_id; /* strand (aka HW thread) id */
|
||||
} cpuinfo_sparc;
|
||||
|
||||
DECLARE_PER_CPU(cpuinfo_sparc, __cpu_data);
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@
|
|||
#include <asm/cpudata.h>
|
||||
#include <linux/uaccess.h>
|
||||
#include <linux/atomic.h>
|
||||
#include <linux/sched/clock.h>
|
||||
#include <asm/nmi.h>
|
||||
#include <asm/pcr.h>
|
||||
#include <asm/cacheflush.h>
|
||||
|
|
@ -927,6 +928,8 @@ static void read_in_all_counters(struct cpu_hw_events *cpuc)
|
|||
sparc_perf_event_update(cp, &cp->hw,
|
||||
cpuc->current_idx[i]);
|
||||
cpuc->current_idx[i] = PIC_NO_INDEX;
|
||||
if (cp->hw.state & PERF_HES_STOPPED)
|
||||
cp->hw.state |= PERF_HES_ARCH;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -959,10 +962,12 @@ static void calculate_single_pcr(struct cpu_hw_events *cpuc)
|
|||
|
||||
enc = perf_event_get_enc(cpuc->events[i]);
|
||||
cpuc->pcr[0] &= ~mask_for_index(idx);
|
||||
if (hwc->state & PERF_HES_STOPPED)
|
||||
if (hwc->state & PERF_HES_ARCH) {
|
||||
cpuc->pcr[0] |= nop_for_index(idx);
|
||||
else
|
||||
} else {
|
||||
cpuc->pcr[0] |= event_encoding(enc, idx);
|
||||
hwc->state = 0;
|
||||
}
|
||||
}
|
||||
out:
|
||||
cpuc->pcr[0] |= cpuc->event[0]->hw.config_base;
|
||||
|
|
@ -988,6 +993,9 @@ static void calculate_multiple_pcrs(struct cpu_hw_events *cpuc)
|
|||
|
||||
cpuc->current_idx[i] = idx;
|
||||
|
||||
if (cp->hw.state & PERF_HES_ARCH)
|
||||
continue;
|
||||
|
||||
sparc_pmu_start(cp, PERF_EF_RELOAD);
|
||||
}
|
||||
out:
|
||||
|
|
@ -1079,6 +1087,8 @@ static void sparc_pmu_start(struct perf_event *event, int flags)
|
|||
event->hw.state = 0;
|
||||
|
||||
sparc_pmu_enable_event(cpuc, &event->hw, idx);
|
||||
|
||||
perf_event_update_userpage(event);
|
||||
}
|
||||
|
||||
static void sparc_pmu_stop(struct perf_event *event, int flags)
|
||||
|
|
@ -1371,9 +1381,9 @@ static int sparc_pmu_add(struct perf_event *event, int ef_flags)
|
|||
cpuc->events[n0] = event->hw.event_base;
|
||||
cpuc->current_idx[n0] = PIC_NO_INDEX;
|
||||
|
||||
event->hw.state = PERF_HES_UPTODATE;
|
||||
event->hw.state = PERF_HES_UPTODATE | PERF_HES_STOPPED;
|
||||
if (!(ef_flags & PERF_EF_START))
|
||||
event->hw.state |= PERF_HES_STOPPED;
|
||||
event->hw.state |= PERF_HES_ARCH;
|
||||
|
||||
/*
|
||||
* If group events scheduling transaction was started,
|
||||
|
|
@ -1603,6 +1613,8 @@ static int __kprobes perf_event_nmi_handler(struct notifier_block *self,
|
|||
struct perf_sample_data data;
|
||||
struct cpu_hw_events *cpuc;
|
||||
struct pt_regs *regs;
|
||||
u64 finish_clock;
|
||||
u64 start_clock;
|
||||
int i;
|
||||
|
||||
if (!atomic_read(&active_events))
|
||||
|
|
@ -1616,6 +1628,8 @@ static int __kprobes perf_event_nmi_handler(struct notifier_block *self,
|
|||
return NOTIFY_DONE;
|
||||
}
|
||||
|
||||
start_clock = sched_clock();
|
||||
|
||||
regs = args->regs;
|
||||
|
||||
cpuc = this_cpu_ptr(&cpu_hw_events);
|
||||
|
|
@ -1654,6 +1668,10 @@ static int __kprobes perf_event_nmi_handler(struct notifier_block *self,
|
|||
sparc_pmu_stop(event, 0);
|
||||
}
|
||||
|
||||
finish_clock = sched_clock();
|
||||
|
||||
perf_sample_event_took(finish_clock - start_clock);
|
||||
|
||||
return NOTIFY_STOP;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -391,6 +391,13 @@ int main(int argc, char ** argv)
|
|||
die("Unable to mmap '%s': %m", argv[2]);
|
||||
/* Number of 16-byte paragraphs, including space for a 4-byte CRC */
|
||||
sys_size = (sz + 15 + 4) / 16;
|
||||
#ifdef CONFIG_EFI_STUB
|
||||
/*
|
||||
* COFF requires minimum 32-byte alignment of sections, and
|
||||
* adding a signature is problematic without that alignment.
|
||||
*/
|
||||
sys_size = (sys_size + 1) & ~1;
|
||||
#endif
|
||||
|
||||
/* Patch the setup code with the appropriate size parameters */
|
||||
buf[0x1f1] = setup_sectors-1;
|
||||
|
|
|
|||
|
|
@ -220,6 +220,7 @@
|
|||
#define X86_FEATURE_STIBP ( 7*32+27) /* Single Thread Indirect Branch Predictors */
|
||||
#define X86_FEATURE_ZEN ( 7*32+28) /* "" CPU is AMD family 0x17 (Zen) */
|
||||
#define X86_FEATURE_L1TF_PTEINV ( 7*32+29) /* "" L1TF workaround PTE inversion */
|
||||
#define X86_FEATURE_IBRS_ENHANCED ( 7*32+30) /* Enhanced IBRS */
|
||||
|
||||
/* Virtualization flags: Linux defined, word 8 */
|
||||
#define X86_FEATURE_TPR_SHADOW ( 8*32+ 0) /* Intel TPR Shadow */
|
||||
|
|
|
|||
|
|
@ -174,6 +174,7 @@ enum {
|
|||
|
||||
#define DR6_BD (1 << 13)
|
||||
#define DR6_BS (1 << 14)
|
||||
#define DR6_BT (1 << 15)
|
||||
#define DR6_RTM (1 << 16)
|
||||
#define DR6_FIXED_1 0xfffe0ff0
|
||||
#define DR6_INIT 0xffff0ff0
|
||||
|
|
|
|||
|
|
@ -215,6 +215,7 @@ enum spectre_v2_mitigation {
|
|||
SPECTRE_V2_RETPOLINE_GENERIC,
|
||||
SPECTRE_V2_RETPOLINE_AMD,
|
||||
SPECTRE_V2_IBRS,
|
||||
SPECTRE_V2_IBRS_ENHANCED,
|
||||
};
|
||||
|
||||
/* The Speculative Store Bypass disable variants */
|
||||
|
|
|
|||
|
|
@ -466,6 +466,12 @@ static inline void __native_flush_tlb_one_user(unsigned long addr)
|
|||
*/
|
||||
static inline void __flush_tlb_all(void)
|
||||
{
|
||||
/*
|
||||
* This is to catch users with enabled preemption and the PGE feature
|
||||
* and don't trigger the warning in __native_flush_tlb().
|
||||
*/
|
||||
VM_WARN_ON_ONCE(preemptible());
|
||||
|
||||
if (boot_cpu_has(X86_FEATURE_PGE)) {
|
||||
__flush_tlb_global();
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -31,6 +31,11 @@ static __init int set_corruption_check(char *arg)
|
|||
ssize_t ret;
|
||||
unsigned long val;
|
||||
|
||||
if (!arg) {
|
||||
pr_err("memory_corruption_check config string not provided\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = kstrtoul(arg, 10, &val);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
|
@ -45,6 +50,11 @@ static __init int set_corruption_check_period(char *arg)
|
|||
ssize_t ret;
|
||||
unsigned long val;
|
||||
|
||||
if (!arg) {
|
||||
pr_err("memory_corruption_check_period config string not provided\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ret = kstrtoul(arg, 10, &val);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
|
@ -59,6 +69,11 @@ static __init int set_corruption_check_size(char *arg)
|
|||
char *end;
|
||||
unsigned size;
|
||||
|
||||
if (!arg) {
|
||||
pr_err("memory_corruption_check_size config string not provided\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
size = memparse(arg, &end);
|
||||
|
||||
if (*end == '\0')
|
||||
|
|
|
|||
|
|
@ -34,12 +34,10 @@ static void __init spectre_v2_select_mitigation(void);
|
|||
static void __init ssb_select_mitigation(void);
|
||||
static void __init l1tf_select_mitigation(void);
|
||||
|
||||
/*
|
||||
* Our boot-time value of the SPEC_CTRL MSR. We read it once so that any
|
||||
* writes to SPEC_CTRL contain whatever reserved bits have been set.
|
||||
*/
|
||||
u64 __ro_after_init x86_spec_ctrl_base;
|
||||
/* The base value of the SPEC_CTRL MSR that always has to be preserved. */
|
||||
u64 x86_spec_ctrl_base;
|
||||
EXPORT_SYMBOL_GPL(x86_spec_ctrl_base);
|
||||
static DEFINE_MUTEX(spec_ctrl_mutex);
|
||||
|
||||
/*
|
||||
* The vendor and possibly platform specific bits which can be modified in
|
||||
|
|
@ -140,6 +138,7 @@ static const char *spectre_v2_strings[] = {
|
|||
[SPECTRE_V2_RETPOLINE_MINIMAL_AMD] = "Vulnerable: Minimal AMD ASM retpoline",
|
||||
[SPECTRE_V2_RETPOLINE_GENERIC] = "Mitigation: Full generic retpoline",
|
||||
[SPECTRE_V2_RETPOLINE_AMD] = "Mitigation: Full AMD retpoline",
|
||||
[SPECTRE_V2_IBRS_ENHANCED] = "Mitigation: Enhanced IBRS",
|
||||
};
|
||||
|
||||
#undef pr_fmt
|
||||
|
|
@ -322,6 +321,46 @@ static enum spectre_v2_mitigation_cmd __init spectre_v2_parse_cmdline(void)
|
|||
return cmd;
|
||||
}
|
||||
|
||||
static bool stibp_needed(void)
|
||||
{
|
||||
if (spectre_v2_enabled == SPECTRE_V2_NONE)
|
||||
return false;
|
||||
|
||||
if (!boot_cpu_has(X86_FEATURE_STIBP))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static void update_stibp_msr(void *info)
|
||||
{
|
||||
wrmsrl(MSR_IA32_SPEC_CTRL, x86_spec_ctrl_base);
|
||||
}
|
||||
|
||||
void arch_smt_update(void)
|
||||
{
|
||||
u64 mask;
|
||||
|
||||
if (!stibp_needed())
|
||||
return;
|
||||
|
||||
mutex_lock(&spec_ctrl_mutex);
|
||||
mask = x86_spec_ctrl_base;
|
||||
if (cpu_smt_control == CPU_SMT_ENABLED)
|
||||
mask |= SPEC_CTRL_STIBP;
|
||||
else
|
||||
mask &= ~SPEC_CTRL_STIBP;
|
||||
|
||||
if (mask != x86_spec_ctrl_base) {
|
||||
pr_info("Spectre v2 cross-process SMT mitigation: %s STIBP\n",
|
||||
cpu_smt_control == CPU_SMT_ENABLED ?
|
||||
"Enabling" : "Disabling");
|
||||
x86_spec_ctrl_base = mask;
|
||||
on_each_cpu(update_stibp_msr, NULL, 1);
|
||||
}
|
||||
mutex_unlock(&spec_ctrl_mutex);
|
||||
}
|
||||
|
||||
static void __init spectre_v2_select_mitigation(void)
|
||||
{
|
||||
enum spectre_v2_mitigation_cmd cmd = spectre_v2_parse_cmdline();
|
||||
|
|
@ -341,6 +380,13 @@ static void __init spectre_v2_select_mitigation(void)
|
|||
|
||||
case SPECTRE_V2_CMD_FORCE:
|
||||
case SPECTRE_V2_CMD_AUTO:
|
||||
if (boot_cpu_has(X86_FEATURE_IBRS_ENHANCED)) {
|
||||
mode = SPECTRE_V2_IBRS_ENHANCED;
|
||||
/* Force it so VMEXIT will restore correctly */
|
||||
x86_spec_ctrl_base |= SPEC_CTRL_IBRS;
|
||||
wrmsrl(MSR_IA32_SPEC_CTRL, x86_spec_ctrl_base);
|
||||
goto specv2_set_mode;
|
||||
}
|
||||
if (IS_ENABLED(CONFIG_RETPOLINE))
|
||||
goto retpoline_auto;
|
||||
break;
|
||||
|
|
@ -378,6 +424,7 @@ retpoline_auto:
|
|||
setup_force_cpu_cap(X86_FEATURE_RETPOLINE);
|
||||
}
|
||||
|
||||
specv2_set_mode:
|
||||
spectre_v2_enabled = mode;
|
||||
pr_info("%s\n", spectre_v2_strings[mode]);
|
||||
|
||||
|
|
@ -400,12 +447,22 @@ retpoline_auto:
|
|||
|
||||
/*
|
||||
* Retpoline means the kernel is safe because it has no indirect
|
||||
* branches. But firmware isn't, so use IBRS to protect that.
|
||||
* branches. Enhanced IBRS protects firmware too, so, enable restricted
|
||||
* speculation around firmware calls only when Enhanced IBRS isn't
|
||||
* supported.
|
||||
*
|
||||
* Use "mode" to check Enhanced IBRS instead of boot_cpu_has(), because
|
||||
* the user might select retpoline on the kernel command line and if
|
||||
* the CPU supports Enhanced IBRS, kernel might un-intentionally not
|
||||
* enable IBRS around firmware calls.
|
||||
*/
|
||||
if (boot_cpu_has(X86_FEATURE_IBRS)) {
|
||||
if (boot_cpu_has(X86_FEATURE_IBRS) && mode != SPECTRE_V2_IBRS_ENHANCED) {
|
||||
setup_force_cpu_cap(X86_FEATURE_USE_IBRS_FW);
|
||||
pr_info("Enabling Restricted Speculation for firmware calls\n");
|
||||
}
|
||||
|
||||
/* Enable STIBP if appropriate */
|
||||
arch_smt_update();
|
||||
}
|
||||
|
||||
#undef pr_fmt
|
||||
|
|
@ -798,6 +855,8 @@ static ssize_t l1tf_show_state(char *buf)
|
|||
static ssize_t cpu_show_common(struct device *dev, struct device_attribute *attr,
|
||||
char *buf, unsigned int bug)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!boot_cpu_has_bug(bug))
|
||||
return sprintf(buf, "Not affected\n");
|
||||
|
||||
|
|
@ -812,10 +871,12 @@ static ssize_t cpu_show_common(struct device *dev, struct device_attribute *attr
|
|||
return sprintf(buf, "Mitigation: __user pointer sanitization\n");
|
||||
|
||||
case X86_BUG_SPECTRE_V2:
|
||||
return sprintf(buf, "%s%s%s%s\n", spectre_v2_strings[spectre_v2_enabled],
|
||||
ret = sprintf(buf, "%s%s%s%s%s\n", spectre_v2_strings[spectre_v2_enabled],
|
||||
boot_cpu_has(X86_FEATURE_USE_IBPB) ? ", IBPB" : "",
|
||||
boot_cpu_has(X86_FEATURE_USE_IBRS_FW) ? ", IBRS_FW" : "",
|
||||
(x86_spec_ctrl_base & SPEC_CTRL_STIBP) ? ", STIBP" : "",
|
||||
spectre_v2_module_string());
|
||||
return ret;
|
||||
|
||||
case X86_BUG_SPEC_STORE_BYPASS:
|
||||
return sprintf(buf, "%s\n", ssb_strings[ssb_mode]);
|
||||
|
|
|
|||
|
|
@ -967,6 +967,9 @@ static void __init cpu_set_bug_bits(struct cpuinfo_x86 *c)
|
|||
setup_force_cpu_bug(X86_BUG_SPECTRE_V1);
|
||||
setup_force_cpu_bug(X86_BUG_SPECTRE_V2);
|
||||
|
||||
if (ia32_cap & ARCH_CAP_IBRS_ALL)
|
||||
setup_force_cpu_cap(X86_FEATURE_IBRS_ENHANCED);
|
||||
|
||||
if (x86_match_cpu(cpu_no_meltdown))
|
||||
return;
|
||||
|
||||
|
|
|
|||
|
|
@ -314,7 +314,6 @@ static int __fpu__restore_sig(void __user *buf, void __user *buf_fx, int size)
|
|||
* thread's fpu state, reconstruct fxstate from the fsave
|
||||
* header. Validate and sanitize the copied state.
|
||||
*/
|
||||
struct fpu *fpu = &tsk->thread.fpu;
|
||||
struct user_i387_ia32_struct env;
|
||||
int err = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -2733,10 +2733,13 @@ static int nested_vmx_check_exception(struct kvm_vcpu *vcpu, unsigned long *exit
|
|||
}
|
||||
} else {
|
||||
if (vmcs12->exception_bitmap & (1u << nr)) {
|
||||
if (nr == DB_VECTOR)
|
||||
if (nr == DB_VECTOR) {
|
||||
*exit_qual = vcpu->arch.dr6;
|
||||
else
|
||||
*exit_qual &= ~(DR6_FIXED_1 | DR6_BT);
|
||||
*exit_qual ^= DR6_RTM;
|
||||
} else {
|
||||
*exit_qual = 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2037,9 +2037,13 @@ void __kernel_map_pages(struct page *page, int numpages, int enable)
|
|||
|
||||
/*
|
||||
* We should perform an IPI and flush all tlbs,
|
||||
* but that can deadlock->flush only current cpu:
|
||||
* but that can deadlock->flush only current cpu.
|
||||
* Preemption needs to be disabled around __flush_tlb_all() due to
|
||||
* CR3 reload in __native_flush_tlb().
|
||||
*/
|
||||
preempt_disable();
|
||||
__flush_tlb_all();
|
||||
preempt_enable();
|
||||
|
||||
arch_flush_lazy_mmu_mode();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@
|
|||
|
||||
#include <asm/msr.h>
|
||||
#include <asm/olpc.h>
|
||||
#include <asm/x86_init.h>
|
||||
|
||||
static void rtc_wake_on(struct device *dev)
|
||||
{
|
||||
|
|
@ -75,6 +76,8 @@ static int __init xo1_rtc_init(void)
|
|||
if (r)
|
||||
return r;
|
||||
|
||||
x86_platform.legacy.rtc = 0;
|
||||
|
||||
device_init_wakeup(&xo1_rtc_device.dev, 1);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ static void __init init_pvh_bootparams(void)
|
|||
* Version 2.12 supports Xen entry point but we will use default x86/PC
|
||||
* environment (i.e. hardware_subarch 0).
|
||||
*/
|
||||
pvh_bootparams.hdr.version = 0x212;
|
||||
pvh_bootparams.hdr.version = (2 << 8) | 12;
|
||||
pvh_bootparams.hdr.type_of_loader = (9 << 4) | 0; /* Xen loader */
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -146,6 +146,10 @@ void xen_unplug_emulated_devices(void)
|
|||
{
|
||||
int r;
|
||||
|
||||
/* PVH guests don't have emulated devices. */
|
||||
if (xen_pvh_domain())
|
||||
return;
|
||||
|
||||
/* user explicitly requested no unplug */
|
||||
if (xen_emul_unplug & XEN_UNPLUG_NEVER)
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@
|
|||
#include <linux/log2.h>
|
||||
#include <linux/gfp.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/atomic.h>
|
||||
|
||||
#include <asm/paravirt.h>
|
||||
|
||||
|
|
@ -20,6 +21,7 @@
|
|||
|
||||
static DEFINE_PER_CPU(int, lock_kicker_irq) = -1;
|
||||
static DEFINE_PER_CPU(char *, irq_name);
|
||||
static DEFINE_PER_CPU(atomic_t, xen_qlock_wait_nest);
|
||||
static bool xen_pvspin = true;
|
||||
|
||||
#include <asm/qspinlock.h>
|
||||
|
|
@ -41,33 +43,24 @@ static void xen_qlock_kick(int cpu)
|
|||
static void xen_qlock_wait(u8 *byte, u8 val)
|
||||
{
|
||||
int irq = __this_cpu_read(lock_kicker_irq);
|
||||
atomic_t *nest_cnt = this_cpu_ptr(&xen_qlock_wait_nest);
|
||||
|
||||
/* If kicker interrupts not initialized yet, just spin */
|
||||
if (irq == -1)
|
||||
if (irq == -1 || in_nmi())
|
||||
return;
|
||||
|
||||
/* clear pending */
|
||||
xen_clear_irq_pending(irq);
|
||||
barrier();
|
||||
/* Detect reentry. */
|
||||
atomic_inc(nest_cnt);
|
||||
|
||||
/*
|
||||
* We check the byte value after clearing pending IRQ to make sure
|
||||
* that we won't miss a wakeup event because of the clearing.
|
||||
*
|
||||
* The sync_clear_bit() call in xen_clear_irq_pending() is atomic.
|
||||
* So it is effectively a memory barrier for x86.
|
||||
*/
|
||||
if (READ_ONCE(*byte) != val)
|
||||
return;
|
||||
/* If irq pending already and no nested call clear it. */
|
||||
if (atomic_read(nest_cnt) == 1 && xen_test_irq_pending(irq)) {
|
||||
xen_clear_irq_pending(irq);
|
||||
} else if (READ_ONCE(*byte) == val) {
|
||||
/* Block until irq becomes pending (or a spurious wakeup) */
|
||||
xen_poll_irq(irq);
|
||||
}
|
||||
|
||||
/*
|
||||
* If an interrupt happens here, it will leave the wakeup irq
|
||||
* pending, which will cause xen_poll_irq() to return
|
||||
* immediately.
|
||||
*/
|
||||
|
||||
/* Block until irq becomes pending (or perhaps a spurious wakeup) */
|
||||
xen_poll_irq(irq);
|
||||
atomic_dec(nest_cnt);
|
||||
}
|
||||
|
||||
static irqreturn_t dummy_handler(int irq, void *dev_id)
|
||||
|
|
|
|||
|
|
@ -178,7 +178,7 @@ canary:
|
|||
.fill 48, 1, 0
|
||||
|
||||
early_stack:
|
||||
.fill 256, 1, 0
|
||||
.fill BOOT_STACK_SIZE, 1, 0
|
||||
early_stack_end:
|
||||
|
||||
ELFNOTE(Xen, XEN_ELFNOTE_PHYS32_ENTRY,
|
||||
|
|
|
|||
|
|
@ -1172,10 +1172,17 @@ bool __bfq_deactivate_entity(struct bfq_entity *entity, bool ins_into_idle_tree)
|
|||
st = bfq_entity_service_tree(entity);
|
||||
is_in_service = entity == sd->in_service_entity;
|
||||
|
||||
if (is_in_service) {
|
||||
bfq_calc_finish(entity, entity->service);
|
||||
bfq_calc_finish(entity, entity->service);
|
||||
|
||||
if (is_in_service)
|
||||
sd->in_service_entity = NULL;
|
||||
}
|
||||
else
|
||||
/*
|
||||
* Non in-service entity: nobody will take care of
|
||||
* resetting its service counter on expiration. Do it
|
||||
* now.
|
||||
*/
|
||||
entity->service = 0;
|
||||
|
||||
if (entity->tree == &st->active)
|
||||
bfq_active_extract(st, entity);
|
||||
|
|
|
|||
|
|
@ -139,7 +139,12 @@ static inline int get_index128(be128 *block)
|
|||
return x + ffz(val);
|
||||
}
|
||||
|
||||
return x;
|
||||
/*
|
||||
* If we get here, then x == 128 and we are incrementing the counter
|
||||
* from all ones to all zeros. This means we must return index 127, i.e.
|
||||
* the one corresponding to key2*{ 1,...,1 }.
|
||||
*/
|
||||
return 127;
|
||||
}
|
||||
|
||||
static int post_crypt(struct skcipher_request *req)
|
||||
|
|
|
|||
|
|
@ -727,6 +727,9 @@ static void test_ahash_speed_common(const char *algo, unsigned int secs,
|
|||
break;
|
||||
}
|
||||
|
||||
if (speed[i].klen)
|
||||
crypto_ahash_setkey(tfm, tvmem[0], speed[i].klen);
|
||||
|
||||
pr_info("test%3u "
|
||||
"(%5u byte blocks,%5u bytes per update,%4u updates): ",
|
||||
i, speed[i].blen, speed[i].plen, speed[i].blen / speed[i].plen);
|
||||
|
|
|
|||
|
|
@ -326,9 +326,11 @@ static const struct acpi_device_id acpi_lpss_device_ids[] = {
|
|||
{ "INT33FC", },
|
||||
|
||||
/* Braswell LPSS devices */
|
||||
{ "80862286", LPSS_ADDR(lpss_dma_desc) },
|
||||
{ "80862288", LPSS_ADDR(bsw_pwm_dev_desc) },
|
||||
{ "8086228A", LPSS_ADDR(bsw_uart_dev_desc) },
|
||||
{ "8086228E", LPSS_ADDR(bsw_spi_dev_desc) },
|
||||
{ "808622C0", LPSS_ADDR(lpss_dma_desc) },
|
||||
{ "808622C1", LPSS_ADDR(bsw_i2c_dev_desc) },
|
||||
|
||||
/* Broadwell LPSS devices */
|
||||
|
|
|
|||
|
|
@ -642,7 +642,7 @@ static acpi_status __init acpi_processor_ids_walk(acpi_handle handle,
|
|||
|
||||
status = acpi_get_type(handle, &acpi_type);
|
||||
if (ACPI_FAILURE(status))
|
||||
return false;
|
||||
return status;
|
||||
|
||||
switch (acpi_type) {
|
||||
case ACPI_TYPE_PROCESSOR:
|
||||
|
|
@ -662,11 +662,12 @@ static acpi_status __init acpi_processor_ids_walk(acpi_handle handle,
|
|||
}
|
||||
|
||||
processor_validated_ids_update(uid);
|
||||
return true;
|
||||
return AE_OK;
|
||||
|
||||
err:
|
||||
/* Exit on error, but don't abort the namespace walk */
|
||||
acpi_handle_info(handle, "Invalid processor object\n");
|
||||
return false;
|
||||
return AE_OK;
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1935,6 +1935,11 @@ static int __init atari_floppy_init (void)
|
|||
unit[i].disk = alloc_disk(1);
|
||||
if (!unit[i].disk)
|
||||
goto Enomem;
|
||||
|
||||
unit[i].disk->queue = blk_init_queue(do_fd_request,
|
||||
&ataflop_lock);
|
||||
if (!unit[i].disk->queue)
|
||||
goto Enomem;
|
||||
}
|
||||
|
||||
if (UseTrackbuffer < 0)
|
||||
|
|
@ -1966,10 +1971,6 @@ static int __init atari_floppy_init (void)
|
|||
sprintf(unit[i].disk->disk_name, "fd%d", i);
|
||||
unit[i].disk->fops = &floppy_fops;
|
||||
unit[i].disk->private_data = &unit[i];
|
||||
unit[i].disk->queue = blk_init_queue(do_fd_request,
|
||||
&ataflop_lock);
|
||||
if (!unit[i].disk->queue)
|
||||
goto Enomem;
|
||||
set_capacity(unit[i].disk, MAX_DISK_SIZE * 2);
|
||||
add_disk(unit[i].disk);
|
||||
}
|
||||
|
|
@ -1984,13 +1985,17 @@ static int __init atari_floppy_init (void)
|
|||
|
||||
return 0;
|
||||
Enomem:
|
||||
while (i--) {
|
||||
struct request_queue *q = unit[i].disk->queue;
|
||||
do {
|
||||
struct gendisk *disk = unit[i].disk;
|
||||
|
||||
put_disk(unit[i].disk);
|
||||
if (q)
|
||||
blk_cleanup_queue(q);
|
||||
}
|
||||
if (disk) {
|
||||
if (disk->queue) {
|
||||
blk_cleanup_queue(disk->queue);
|
||||
disk->queue = NULL;
|
||||
}
|
||||
put_disk(unit[i].disk);
|
||||
}
|
||||
} while (i--);
|
||||
|
||||
unregister_blkdev(FLOPPY_MAJOR, "fd");
|
||||
return -ENOMEM;
|
||||
|
|
|
|||
|
|
@ -887,8 +887,17 @@ static int swim_floppy_init(struct swim_priv *swd)
|
|||
|
||||
exit_put_disks:
|
||||
unregister_blkdev(FLOPPY_MAJOR, "fd");
|
||||
while (drive--)
|
||||
put_disk(swd->unit[drive].disk);
|
||||
do {
|
||||
struct gendisk *disk = swd->unit[drive].disk;
|
||||
|
||||
if (disk) {
|
||||
if (disk->queue) {
|
||||
blk_cleanup_queue(disk->queue);
|
||||
disk->queue = NULL;
|
||||
}
|
||||
put_disk(disk);
|
||||
}
|
||||
} while (drive--);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1910,6 +1910,7 @@ static int negotiate_mq(struct blkfront_info *info)
|
|||
info->rinfo = kzalloc(sizeof(struct blkfront_ring_info) * info->nr_rings, GFP_KERNEL);
|
||||
if (!info->rinfo) {
|
||||
xenbus_dev_fatal(info->xbdev, -ENOMEM, "allocating ring_info structure");
|
||||
info->nr_rings = 0;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
|
|
@ -2471,6 +2472,9 @@ static int blkfront_remove(struct xenbus_device *xbdev)
|
|||
|
||||
dev_dbg(&xbdev->dev, "%s removed", xbdev->nodename);
|
||||
|
||||
if (!info)
|
||||
return 0;
|
||||
|
||||
blkif_free(info, 0);
|
||||
|
||||
mutex_lock(&info->mutex);
|
||||
|
|
|
|||
|
|
@ -325,6 +325,7 @@ static const struct {
|
|||
{ 0x4103, "BCM4330B1" }, /* 002.001.003 */
|
||||
{ 0x410e, "BCM43341B0" }, /* 002.001.014 */
|
||||
{ 0x4406, "BCM4324B3" }, /* 002.004.006 */
|
||||
{ 0x6109, "BCM4335C0" }, /* 003.001.009 */
|
||||
{ 0x610c, "BCM4354" }, /* 003.001.012 */
|
||||
{ 0x2209, "BCM43430A1" }, /* 001.002.009 */
|
||||
{ }
|
||||
|
|
|
|||
|
|
@ -621,8 +621,9 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
|
|||
flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
|
||||
ssif_info->waiting_alert = true;
|
||||
ssif_info->rtc_us_timer = SSIF_MSG_USEC;
|
||||
mod_timer(&ssif_info->retry_timer,
|
||||
jiffies + SSIF_MSG_JIFFIES);
|
||||
if (!ssif_info->stopping)
|
||||
mod_timer(&ssif_info->retry_timer,
|
||||
jiffies + SSIF_MSG_JIFFIES);
|
||||
ipmi_ssif_unlock_cond(ssif_info, flags);
|
||||
return;
|
||||
}
|
||||
|
|
@ -954,8 +955,9 @@ static void msg_written_handler(struct ssif_info *ssif_info, int result,
|
|||
ssif_info->waiting_alert = true;
|
||||
ssif_info->retries_left = SSIF_RECV_RETRIES;
|
||||
ssif_info->rtc_us_timer = SSIF_MSG_PART_USEC;
|
||||
mod_timer(&ssif_info->retry_timer,
|
||||
jiffies + SSIF_MSG_PART_JIFFIES);
|
||||
if (!ssif_info->stopping)
|
||||
mod_timer(&ssif_info->retry_timer,
|
||||
jiffies + SSIF_MSG_PART_JIFFIES);
|
||||
ipmi_ssif_unlock_cond(ssif_info, flags);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -653,7 +653,8 @@ ssize_t tpm_transmit_cmd(struct tpm_chip *chip, struct tpm_space *space,
|
|||
return len;
|
||||
|
||||
err = be32_to_cpu(header->return_code);
|
||||
if (err != 0 && desc)
|
||||
if (err != 0 && err != TPM_ERR_DISABLED && err != TPM_ERR_DEACTIVATED
|
||||
&& desc)
|
||||
dev_err(&chip->dev, "A TPM error (%d) occurred %s\n", err,
|
||||
desc);
|
||||
if (err)
|
||||
|
|
|
|||
|
|
@ -203,7 +203,7 @@ static int setup_ring(struct xenbus_device *dev, struct tpm_private *priv)
|
|||
return -ENOMEM;
|
||||
}
|
||||
|
||||
rv = xenbus_grant_ring(dev, &priv->shr, 1, &gref);
|
||||
rv = xenbus_grant_ring(dev, priv->shr, 1, &gref);
|
||||
if (rv < 0)
|
||||
return rv;
|
||||
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ struct private_data {
|
|||
struct device *cpu_dev;
|
||||
struct thermal_cooling_device *cdev;
|
||||
const char *reg_name;
|
||||
bool have_static_opps;
|
||||
};
|
||||
|
||||
static struct freq_attr *cpufreq_dt_attr[] = {
|
||||
|
|
@ -204,6 +205,15 @@ static int cpufreq_init(struct cpufreq_policy *policy)
|
|||
}
|
||||
}
|
||||
|
||||
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv) {
|
||||
ret = -ENOMEM;
|
||||
goto out_put_regulator;
|
||||
}
|
||||
|
||||
priv->reg_name = name;
|
||||
priv->opp_table = opp_table;
|
||||
|
||||
/*
|
||||
* Initialize OPP tables for all policy->cpus. They will be shared by
|
||||
* all CPUs which have marked their CPUs shared with OPP bindings.
|
||||
|
|
@ -214,7 +224,8 @@ static int cpufreq_init(struct cpufreq_policy *policy)
|
|||
*
|
||||
* OPPs might be populated at runtime, don't check for error here
|
||||
*/
|
||||
dev_pm_opp_of_cpumask_add_table(policy->cpus);
|
||||
if (!dev_pm_opp_of_cpumask_add_table(policy->cpus))
|
||||
priv->have_static_opps = true;
|
||||
|
||||
/*
|
||||
* But we need OPP table to function so if it is not there let's
|
||||
|
|
@ -240,19 +251,10 @@ static int cpufreq_init(struct cpufreq_policy *policy)
|
|||
__func__, ret);
|
||||
}
|
||||
|
||||
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv) {
|
||||
ret = -ENOMEM;
|
||||
goto out_free_opp;
|
||||
}
|
||||
|
||||
priv->reg_name = name;
|
||||
priv->opp_table = opp_table;
|
||||
|
||||
ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
|
||||
if (ret) {
|
||||
dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
|
||||
goto out_free_priv;
|
||||
goto out_free_opp;
|
||||
}
|
||||
|
||||
priv->cpu_dev = cpu_dev;
|
||||
|
|
@ -288,10 +290,11 @@ static int cpufreq_init(struct cpufreq_policy *policy)
|
|||
|
||||
out_free_cpufreq_table:
|
||||
dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
|
||||
out_free_priv:
|
||||
kfree(priv);
|
||||
out_free_opp:
|
||||
dev_pm_opp_of_cpumask_remove_table(policy->cpus);
|
||||
if (priv->have_static_opps)
|
||||
dev_pm_opp_of_cpumask_remove_table(policy->cpus);
|
||||
kfree(priv);
|
||||
out_put_regulator:
|
||||
if (name)
|
||||
dev_pm_opp_put_regulators(opp_table);
|
||||
out_put_clk:
|
||||
|
|
@ -306,7 +309,8 @@ static int cpufreq_exit(struct cpufreq_policy *policy)
|
|||
|
||||
cpufreq_cooling_unregister(priv->cdev);
|
||||
dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
|
||||
dev_pm_opp_of_cpumask_remove_table(policy->related_cpus);
|
||||
if (priv->have_static_opps)
|
||||
dev_pm_opp_of_cpumask_remove_table(policy->related_cpus);
|
||||
if (priv->reg_name)
|
||||
dev_pm_opp_put_regulators(priv->opp_table);
|
||||
|
||||
|
|
|
|||
|
|
@ -80,8 +80,10 @@ static unsigned int cs_dbs_update(struct cpufreq_policy *policy)
|
|||
* changed in the meantime, so fall back to current frequency in that
|
||||
* case.
|
||||
*/
|
||||
if (requested_freq > policy->max || requested_freq < policy->min)
|
||||
if (requested_freq > policy->max || requested_freq < policy->min) {
|
||||
requested_freq = policy->cur;
|
||||
dbs_info->requested_freq = requested_freq;
|
||||
}
|
||||
|
||||
freq_step = get_freq_step(cs_tuners, policy);
|
||||
|
||||
|
|
@ -92,7 +94,7 @@ static unsigned int cs_dbs_update(struct cpufreq_policy *policy)
|
|||
if (policy_dbs->idle_periods < UINT_MAX) {
|
||||
unsigned int freq_steps = policy_dbs->idle_periods * freq_step;
|
||||
|
||||
if (requested_freq > freq_steps)
|
||||
if (requested_freq > policy->min + freq_steps)
|
||||
requested_freq -= freq_steps;
|
||||
else
|
||||
requested_freq = policy->min;
|
||||
|
|
|
|||
|
|
@ -70,22 +70,22 @@
|
|||
extern bool caam_little_end;
|
||||
extern bool caam_imx;
|
||||
|
||||
#define caam_to_cpu(len) \
|
||||
static inline u##len caam##len ## _to_cpu(u##len val) \
|
||||
{ \
|
||||
if (caam_little_end) \
|
||||
return le##len ## _to_cpu(val); \
|
||||
else \
|
||||
return be##len ## _to_cpu(val); \
|
||||
#define caam_to_cpu(len) \
|
||||
static inline u##len caam##len ## _to_cpu(u##len val) \
|
||||
{ \
|
||||
if (caam_little_end) \
|
||||
return le##len ## _to_cpu((__force __le##len)val); \
|
||||
else \
|
||||
return be##len ## _to_cpu((__force __be##len)val); \
|
||||
}
|
||||
|
||||
#define cpu_to_caam(len) \
|
||||
static inline u##len cpu_to_caam##len(u##len val) \
|
||||
{ \
|
||||
if (caam_little_end) \
|
||||
return cpu_to_le##len(val); \
|
||||
else \
|
||||
return cpu_to_be##len(val); \
|
||||
#define cpu_to_caam(len) \
|
||||
static inline u##len cpu_to_caam##len(u##len val) \
|
||||
{ \
|
||||
if (caam_little_end) \
|
||||
return (__force u##len)cpu_to_le##len(val); \
|
||||
else \
|
||||
return (__force u##len)cpu_to_be##len(val); \
|
||||
}
|
||||
|
||||
caam_to_cpu(16)
|
||||
|
|
|
|||
|
|
@ -754,6 +754,11 @@ static int jz4780_dma_probe(struct platform_device *pdev)
|
|||
struct resource *res;
|
||||
int i, ret;
|
||||
|
||||
if (!dev->of_node) {
|
||||
dev_err(dev, "This driver must be probed from devicetree\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
jzdma = devm_kzalloc(dev, sizeof(*jzdma), GFP_KERNEL);
|
||||
if (!jzdma)
|
||||
return -ENOMEM;
|
||||
|
|
|
|||
|
|
@ -1205,8 +1205,15 @@ static void ioat_shutdown(struct pci_dev *pdev)
|
|||
|
||||
spin_lock_bh(&ioat_chan->prep_lock);
|
||||
set_bit(IOAT_CHAN_DOWN, &ioat_chan->state);
|
||||
del_timer_sync(&ioat_chan->timer);
|
||||
spin_unlock_bh(&ioat_chan->prep_lock);
|
||||
/*
|
||||
* Synchronization rule for del_timer_sync():
|
||||
* - The caller must not hold locks which would prevent
|
||||
* completion of the timer's handler.
|
||||
* So prep_lock cannot be held before calling it.
|
||||
*/
|
||||
del_timer_sync(&ioat_chan->timer);
|
||||
|
||||
/* this should quiesce then reset */
|
||||
ioat_reset_hw(ioat_chan);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4360,7 +4360,7 @@ static ssize_t enable_store(struct device_driver *dev, const char *buf,
|
|||
}
|
||||
static DRIVER_ATTR_RW(enable);
|
||||
|
||||
static ssize_t poly_store(struct device_driver *dev, char *buf)
|
||||
static ssize_t poly_show(struct device_driver *dev, char *buf)
|
||||
{
|
||||
ssize_t size = 0;
|
||||
u32 reg;
|
||||
|
|
|
|||
|
|
@ -429,6 +429,8 @@ static void stm32_dma_dump_reg(struct stm32_dma_chan *chan)
|
|||
dev_dbg(chan2dev(chan), "SFCR: 0x%08x\n", sfcr);
|
||||
}
|
||||
|
||||
static void stm32_dma_configure_next_sg(struct stm32_dma_chan *chan);
|
||||
|
||||
static void stm32_dma_start_transfer(struct stm32_dma_chan *chan)
|
||||
{
|
||||
struct stm32_dma_device *dmadev = stm32_dma_get_dev(chan);
|
||||
|
|
@ -471,6 +473,9 @@ static void stm32_dma_start_transfer(struct stm32_dma_chan *chan)
|
|||
if (status)
|
||||
stm32_dma_irq_clear(chan, status);
|
||||
|
||||
if (chan->desc->cyclic)
|
||||
stm32_dma_configure_next_sg(chan);
|
||||
|
||||
stm32_dma_dump_reg(chan);
|
||||
|
||||
/* Start DMA */
|
||||
|
|
@ -564,8 +569,7 @@ static void stm32_dma_issue_pending(struct dma_chan *c)
|
|||
if (vchan_issue_pending(&chan->vchan) && !chan->desc && !chan->busy) {
|
||||
dev_dbg(chan2dev(chan), "vchan %p: issued\n", &chan->vchan);
|
||||
stm32_dma_start_transfer(chan);
|
||||
if (chan->desc->cyclic)
|
||||
stm32_dma_configure_next_sg(chan);
|
||||
|
||||
}
|
||||
spin_unlock_irqrestore(&chan->vchan.lock, flags);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2200,6 +2200,15 @@ static struct amd64_family_type family_types[] = {
|
|||
.dbam_to_cs = f17_base_addr_to_cs_size,
|
||||
}
|
||||
},
|
||||
[F17_M10H_CPUS] = {
|
||||
.ctl_name = "F17h_M10h",
|
||||
.f0_id = PCI_DEVICE_ID_AMD_17H_M10H_DF_F0,
|
||||
.f6_id = PCI_DEVICE_ID_AMD_17H_M10H_DF_F6,
|
||||
.ops = {
|
||||
.early_channel_count = f17_early_channel_count,
|
||||
.dbam_to_cs = f17_base_addr_to_cs_size,
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -3188,6 +3197,11 @@ static struct amd64_family_type *per_family_init(struct amd64_pvt *pvt)
|
|||
break;
|
||||
|
||||
case 0x17:
|
||||
if (pvt->model >= 0x10 && pvt->model <= 0x2f) {
|
||||
fam_type = &family_types[F17_M10H_CPUS];
|
||||
pvt->ops = &family_types[F17_M10H_CPUS].ops;
|
||||
break;
|
||||
}
|
||||
fam_type = &family_types[F17_CPUS];
|
||||
pvt->ops = &family_types[F17_CPUS].ops;
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -115,6 +115,8 @@
|
|||
#define PCI_DEVICE_ID_AMD_16H_M30H_NB_F2 0x1582
|
||||
#define PCI_DEVICE_ID_AMD_17H_DF_F0 0x1460
|
||||
#define PCI_DEVICE_ID_AMD_17H_DF_F6 0x1466
|
||||
#define PCI_DEVICE_ID_AMD_17H_M10H_DF_F0 0x15e8
|
||||
#define PCI_DEVICE_ID_AMD_17H_M10H_DF_F6 0x15ee
|
||||
|
||||
/*
|
||||
* Function 1 - Address Map
|
||||
|
|
@ -281,6 +283,7 @@ enum amd_families {
|
|||
F16_CPUS,
|
||||
F16_M30H_CPUS,
|
||||
F17_CPUS,
|
||||
F17_M10H_CPUS,
|
||||
NUM_FAMILIES,
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1711,6 +1711,7 @@ static void i7core_mce_output_error(struct mem_ctl_info *mci,
|
|||
u32 errnum = find_first_bit(&error, 32);
|
||||
|
||||
if (uncorrected_error) {
|
||||
core_err_cnt = 1;
|
||||
if (ripv)
|
||||
tp_event = HW_EVENT_ERR_FATAL;
|
||||
else
|
||||
|
|
|
|||
|
|
@ -2891,6 +2891,7 @@ static void sbridge_mce_output_error(struct mem_ctl_info *mci,
|
|||
recoverable = GET_BITFIELD(m->status, 56, 56);
|
||||
|
||||
if (uncorrected_error) {
|
||||
core_err_cnt = 1;
|
||||
if (ripv) {
|
||||
type = "FATAL";
|
||||
tp_event = HW_EVENT_ERR_FATAL;
|
||||
|
|
|
|||
|
|
@ -604,7 +604,7 @@ sad_found:
|
|||
break;
|
||||
case 2:
|
||||
lchan = (addr >> shift) % 2;
|
||||
lchan = (lchan << 1) | ~lchan;
|
||||
lchan = (lchan << 1) | !lchan;
|
||||
break;
|
||||
case 3:
|
||||
lchan = ((addr >> shift) % 2) << 1;
|
||||
|
|
@ -895,6 +895,7 @@ static void skx_mce_output_error(struct mem_ctl_info *mci,
|
|||
recoverable = GET_BITFIELD(m->status, 56, 56);
|
||||
|
||||
if (uncorrected_error) {
|
||||
core_err_cnt = 1;
|
||||
if (ripv) {
|
||||
type = "FATAL";
|
||||
tp_event = HW_EVENT_ERR_FATAL;
|
||||
|
|
|
|||
|
|
@ -512,14 +512,24 @@ static noinline int hiddev_ioctl_usage(struct hiddev *hiddev, unsigned int cmd,
|
|||
if (cmd == HIDIOCGCOLLECTIONINDEX) {
|
||||
if (uref->usage_index >= field->maxusage)
|
||||
goto inval;
|
||||
uref->usage_index =
|
||||
array_index_nospec(uref->usage_index,
|
||||
field->maxusage);
|
||||
} else if (uref->usage_index >= field->report_count)
|
||||
goto inval;
|
||||
}
|
||||
|
||||
if ((cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) &&
|
||||
(uref_multi->num_values > HID_MAX_MULTI_USAGES ||
|
||||
uref->usage_index + uref_multi->num_values > field->report_count))
|
||||
goto inval;
|
||||
if (cmd == HIDIOCGUSAGES || cmd == HIDIOCSUSAGES) {
|
||||
if (uref_multi->num_values > HID_MAX_MULTI_USAGES ||
|
||||
uref->usage_index + uref_multi->num_values >
|
||||
field->report_count)
|
||||
goto inval;
|
||||
|
||||
uref->usage_index =
|
||||
array_index_nospec(uref->usage_index,
|
||||
field->report_count -
|
||||
uref_multi->num_values);
|
||||
}
|
||||
|
||||
switch (cmd) {
|
||||
case HIDIOCGUSAGE:
|
||||
|
|
|
|||
|
|
@ -599,16 +599,18 @@ static void init_vp_index(struct vmbus_channel *channel, u16 dev_type)
|
|||
bool perf_chn = vmbus_devs[dev_type].perf_device;
|
||||
struct vmbus_channel *primary = channel->primary_channel;
|
||||
int next_node;
|
||||
struct cpumask available_mask;
|
||||
cpumask_var_t available_mask;
|
||||
struct cpumask *alloced_mask;
|
||||
|
||||
if ((vmbus_proto_version == VERSION_WS2008) ||
|
||||
(vmbus_proto_version == VERSION_WIN7) || (!perf_chn)) {
|
||||
(vmbus_proto_version == VERSION_WIN7) || (!perf_chn) ||
|
||||
!alloc_cpumask_var(&available_mask, GFP_KERNEL)) {
|
||||
/*
|
||||
* Prior to win8, all channel interrupts are
|
||||
* delivered on cpu 0.
|
||||
* Also if the channel is not a performance critical
|
||||
* channel, bind it to cpu 0.
|
||||
* In case alloc_cpumask_var() fails, bind it to cpu 0.
|
||||
*/
|
||||
channel->numa_node = 0;
|
||||
channel->target_cpu = 0;
|
||||
|
|
@ -646,7 +648,7 @@ static void init_vp_index(struct vmbus_channel *channel, u16 dev_type)
|
|||
cpumask_clear(alloced_mask);
|
||||
}
|
||||
|
||||
cpumask_xor(&available_mask, alloced_mask,
|
||||
cpumask_xor(available_mask, alloced_mask,
|
||||
cpumask_of_node(primary->numa_node));
|
||||
|
||||
cur_cpu = -1;
|
||||
|
|
@ -664,10 +666,10 @@ static void init_vp_index(struct vmbus_channel *channel, u16 dev_type)
|
|||
}
|
||||
|
||||
while (true) {
|
||||
cur_cpu = cpumask_next(cur_cpu, &available_mask);
|
||||
cur_cpu = cpumask_next(cur_cpu, available_mask);
|
||||
if (cur_cpu >= nr_cpu_ids) {
|
||||
cur_cpu = -1;
|
||||
cpumask_copy(&available_mask,
|
||||
cpumask_copy(available_mask,
|
||||
cpumask_of_node(primary->numa_node));
|
||||
continue;
|
||||
}
|
||||
|
|
@ -697,6 +699,8 @@ static void init_vp_index(struct vmbus_channel *channel, u16 dev_type)
|
|||
|
||||
channel->target_cpu = cur_cpu;
|
||||
channel->target_vp = hv_cpu_number_to_vp_number(cur_cpu);
|
||||
|
||||
free_cpumask_var(available_mask);
|
||||
}
|
||||
|
||||
static void vmbus_wait_for_unload(void)
|
||||
|
|
|
|||
|
|
@ -118,6 +118,8 @@ static int pmbus_identify(struct i2c_client *client,
|
|||
} else {
|
||||
info->pages = 1;
|
||||
}
|
||||
|
||||
pmbus_clear_faults(client);
|
||||
}
|
||||
|
||||
if (pmbus_check_byte_register(client, 0, PMBUS_VOUT_MODE)) {
|
||||
|
|
|
|||
|
|
@ -1802,7 +1802,10 @@ static int pmbus_init_common(struct i2c_client *client, struct pmbus_data *data,
|
|||
if (ret >= 0 && (ret & PB_CAPABILITY_ERROR_CHECK))
|
||||
client->flags |= I2C_CLIENT_PEC;
|
||||
|
||||
pmbus_clear_faults(client);
|
||||
if (data->info->pages)
|
||||
pmbus_clear_faults(client);
|
||||
else
|
||||
pmbus_clear_fault_page(client, -1);
|
||||
|
||||
if (info->identify) {
|
||||
ret = (*info->identify)(client, info);
|
||||
|
|
|
|||
|
|
@ -290,9 +290,19 @@ static int pwm_fan_remove(struct platform_device *pdev)
|
|||
static int pwm_fan_suspend(struct device *dev)
|
||||
{
|
||||
struct pwm_fan_ctx *ctx = dev_get_drvdata(dev);
|
||||
struct pwm_args args;
|
||||
int ret;
|
||||
|
||||
pwm_get_args(ctx->pwm, &args);
|
||||
|
||||
if (ctx->pwm_value) {
|
||||
ret = pwm_config(ctx->pwm, 0, args.period);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (ctx->pwm_value)
|
||||
pwm_disable(ctx->pwm);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -155,6 +155,10 @@ static int etb_enable(struct coresight_device *csdev, u32 mode)
|
|||
if (val == CS_MODE_PERF)
|
||||
return -EBUSY;
|
||||
|
||||
/* Don't let perf disturb sysFS sessions */
|
||||
if (val == CS_MODE_SYSFS && mode == CS_MODE_PERF)
|
||||
return -EBUSY;
|
||||
|
||||
/* Nothing to do, the tracer is already enabled. */
|
||||
if (val == CS_MODE_SYSFS)
|
||||
goto out;
|
||||
|
|
|
|||
|
|
@ -761,8 +761,12 @@ static int rcar_i2c_master_xfer(struct i2c_adapter *adap,
|
|||
|
||||
time_left = wait_event_timeout(priv->wait, priv->flags & ID_DONE,
|
||||
num * adap->timeout);
|
||||
if (!time_left) {
|
||||
|
||||
/* cleanup DMA if it couldn't complete properly due to an error */
|
||||
if (priv->dma_direction != DMA_NONE)
|
||||
rcar_i2c_cleanup_dma(priv);
|
||||
|
||||
if (!time_left) {
|
||||
rcar_i2c_init(priv);
|
||||
ret = -ETIMEDOUT;
|
||||
} else if (priv->flags & ID_NACK) {
|
||||
|
|
|
|||
|
|
@ -248,12 +248,14 @@ static irqreturn_t at91_adc_trigger_handler(int irq, void *p)
|
|||
struct iio_poll_func *pf = p;
|
||||
struct iio_dev *idev = pf->indio_dev;
|
||||
struct at91_adc_state *st = iio_priv(idev);
|
||||
struct iio_chan_spec const *chan;
|
||||
int i, j = 0;
|
||||
|
||||
for (i = 0; i < idev->masklength; i++) {
|
||||
if (!test_bit(i, idev->active_scan_mask))
|
||||
continue;
|
||||
st->buffer[j] = at91_adc_readl(st, AT91_ADC_CHAN(st, i));
|
||||
chan = idev->channels + i;
|
||||
st->buffer[j] = at91_adc_readl(st, AT91_ADC_CHAN(st, chan->channel));
|
||||
j++;
|
||||
}
|
||||
|
||||
|
|
@ -279,6 +281,8 @@ static void handle_adc_eoc_trigger(int irq, struct iio_dev *idev)
|
|||
iio_trigger_poll(idev->trig);
|
||||
} else {
|
||||
st->last_value = at91_adc_readl(st, AT91_ADC_CHAN(st, st->chnb));
|
||||
/* Needed to ACK the DRDY interruption */
|
||||
at91_adc_readl(st, AT91_ADC_LCDR);
|
||||
st->done = true;
|
||||
wake_up_interruptible(&st->wq_data_avail);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -209,12 +209,14 @@ static int mx25_gcq_setup_cfgs(struct platform_device *pdev,
|
|||
ret = of_property_read_u32(child, "reg", ®);
|
||||
if (ret) {
|
||||
dev_err(dev, "Failed to get reg property\n");
|
||||
of_node_put(child);
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (reg >= MX25_NUM_CFGS) {
|
||||
dev_err(dev,
|
||||
"reg value is greater than the number of available configuration registers\n");
|
||||
of_node_put(child);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
@ -228,6 +230,7 @@ static int mx25_gcq_setup_cfgs(struct platform_device *pdev,
|
|||
if (IS_ERR(priv->vref[refp])) {
|
||||
dev_err(dev, "Error, trying to use external voltage reference without a vref-%s regulator.",
|
||||
mx25_gcq_refp_names[refp]);
|
||||
of_node_put(child);
|
||||
return PTR_ERR(priv->vref[refp]);
|
||||
}
|
||||
priv->channel_vref_mv[reg] =
|
||||
|
|
@ -240,6 +243,7 @@ static int mx25_gcq_setup_cfgs(struct platform_device *pdev,
|
|||
break;
|
||||
default:
|
||||
dev_err(dev, "Invalid positive reference %d\n", refp);
|
||||
of_node_put(child);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
@ -254,10 +258,12 @@ static int mx25_gcq_setup_cfgs(struct platform_device *pdev,
|
|||
|
||||
if ((refp & MX25_ADCQ_CFG_REFP_MASK) != refp) {
|
||||
dev_err(dev, "Invalid fsl,adc-refp property value\n");
|
||||
of_node_put(child);
|
||||
return -EINVAL;
|
||||
}
|
||||
if ((refn & MX25_ADCQ_CFG_REFN_MASK) != refn) {
|
||||
dev_err(dev, "Invalid fsl,adc-refn property value\n");
|
||||
of_node_put(child);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -809,6 +809,40 @@ static int ad5064_set_config(struct ad5064_state *st, unsigned int val)
|
|||
return ad5064_write(st, cmd, 0, val, 0);
|
||||
}
|
||||
|
||||
static int ad5064_request_vref(struct ad5064_state *st, struct device *dev)
|
||||
{
|
||||
unsigned int i;
|
||||
int ret;
|
||||
|
||||
for (i = 0; i < ad5064_num_vref(st); ++i)
|
||||
st->vref_reg[i].supply = ad5064_vref_name(st, i);
|
||||
|
||||
if (!st->chip_info->internal_vref)
|
||||
return devm_regulator_bulk_get(dev, ad5064_num_vref(st),
|
||||
st->vref_reg);
|
||||
|
||||
/*
|
||||
* This assumes that when the regulator has an internal VREF
|
||||
* there is only one external VREF connection, which is
|
||||
* currently the case for all supported devices.
|
||||
*/
|
||||
st->vref_reg[0].consumer = devm_regulator_get_optional(dev, "vref");
|
||||
if (!IS_ERR(st->vref_reg[0].consumer))
|
||||
return 0;
|
||||
|
||||
ret = PTR_ERR(st->vref_reg[0].consumer);
|
||||
if (ret != -ENODEV)
|
||||
return ret;
|
||||
|
||||
/* If no external regulator was supplied use the internal VREF */
|
||||
st->use_internal_vref = true;
|
||||
ret = ad5064_set_config(st, AD5064_CONFIG_INT_VREF_ENABLE);
|
||||
if (ret)
|
||||
dev_err(dev, "Failed to enable internal vref: %d\n", ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ad5064_probe(struct device *dev, enum ad5064_type type,
|
||||
const char *name, ad5064_write_func write)
|
||||
{
|
||||
|
|
@ -829,22 +863,11 @@ static int ad5064_probe(struct device *dev, enum ad5064_type type,
|
|||
st->dev = dev;
|
||||
st->write = write;
|
||||
|
||||
for (i = 0; i < ad5064_num_vref(st); ++i)
|
||||
st->vref_reg[i].supply = ad5064_vref_name(st, i);
|
||||
ret = ad5064_request_vref(st, dev);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = devm_regulator_bulk_get(dev, ad5064_num_vref(st),
|
||||
st->vref_reg);
|
||||
if (ret) {
|
||||
if (!st->chip_info->internal_vref)
|
||||
return ret;
|
||||
st->use_internal_vref = true;
|
||||
ret = ad5064_set_config(st, AD5064_CONFIG_INT_VREF_ENABLE);
|
||||
if (ret) {
|
||||
dev_err(dev, "Failed to enable internal vref: %d\n",
|
||||
ret);
|
||||
return ret;
|
||||
}
|
||||
} else {
|
||||
if (!st->use_internal_vref) {
|
||||
ret = regulator_bulk_enable(ad5064_num_vref(st), st->vref_reg);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
|
|
|||
|
|
@ -489,7 +489,7 @@ static ssize_t show_pma_counter(struct ib_port *p, struct port_attribute *attr,
|
|||
ret = get_perf_mad(p->ibdev, p->port_num, tab_attr->attr_id, &data,
|
||||
40 + offset / 8, sizeof(data));
|
||||
if (ret < 0)
|
||||
return sprintf(buf, "N/A (no PMA)\n");
|
||||
return ret;
|
||||
|
||||
switch (width) {
|
||||
case 4:
|
||||
|
|
@ -1012,10 +1012,12 @@ static int add_port(struct ib_device *device, int port_num,
|
|||
goto err_put;
|
||||
}
|
||||
|
||||
p->pma_table = get_counter_table(device, port_num);
|
||||
ret = sysfs_create_group(&p->kobj, p->pma_table);
|
||||
if (ret)
|
||||
goto err_put_gid_attrs;
|
||||
if (device->process_mad) {
|
||||
p->pma_table = get_counter_table(device, port_num);
|
||||
ret = sysfs_create_group(&p->kobj, p->pma_table);
|
||||
if (ret)
|
||||
goto err_put_gid_attrs;
|
||||
}
|
||||
|
||||
p->gid_group.name = "gids";
|
||||
p->gid_group.attrs = alloc_group_attrs(show_port_gid, attr.gid_tbl_len);
|
||||
|
|
@ -1128,7 +1130,8 @@ err_free_gid:
|
|||
p->gid_group.attrs = NULL;
|
||||
|
||||
err_remove_pma:
|
||||
sysfs_remove_group(&p->kobj, p->pma_table);
|
||||
if (p->pma_table)
|
||||
sysfs_remove_group(&p->kobj, p->pma_table);
|
||||
|
||||
err_put_gid_attrs:
|
||||
kobject_put(&p->gid_attr_group->kobj);
|
||||
|
|
@ -1240,7 +1243,9 @@ static void free_port_list_attributes(struct ib_device *device)
|
|||
kfree(port->hw_stats);
|
||||
free_hsag(&port->kobj, port->hw_stats_ag);
|
||||
}
|
||||
sysfs_remove_group(p, port->pma_table);
|
||||
|
||||
if (port->pma_table)
|
||||
sysfs_remove_group(p, port->pma_table);
|
||||
sysfs_remove_group(p, &port->pkey_group);
|
||||
sysfs_remove_group(p, &port->gid_group);
|
||||
sysfs_remove_group(&port->gid_attr_group->kobj,
|
||||
|
|
|
|||
|
|
@ -311,8 +311,17 @@ static int bnxt_qplib_process_qp_event(struct bnxt_qplib_rcfw *rcfw,
|
|||
bnxt_qplib_release_cq_locks(qp, &flags);
|
||||
break;
|
||||
default:
|
||||
/* Command Response */
|
||||
spin_lock_irqsave(&cmdq->lock, flags);
|
||||
/*
|
||||
* Command Response
|
||||
* cmdq->lock needs to be acquired to synchronie
|
||||
* the command send and completion reaping. This function
|
||||
* is always called with creq->lock held. Using
|
||||
* the nested variant of spin_lock.
|
||||
*
|
||||
*/
|
||||
|
||||
spin_lock_irqsave_nested(&cmdq->lock, flags,
|
||||
SINGLE_DEPTH_NESTING);
|
||||
cookie = le16_to_cpu(qp_event->cookie);
|
||||
mcookie = qp_event->cookie;
|
||||
blocked = cookie & RCFW_CMD_IS_BLOCKING;
|
||||
|
|
|
|||
|
|
@ -675,7 +675,6 @@ int mlx5_mr_cache_init(struct mlx5_ib_dev *dev)
|
|||
init_completion(&ent->compl);
|
||||
INIT_WORK(&ent->work, cache_work_func);
|
||||
INIT_DELAYED_WORK(&ent->dwork, delayed_cache_work_func);
|
||||
queue_work(cache->wq, &ent->work);
|
||||
|
||||
if (i > MR_CACHE_LAST_STD_ENTRY) {
|
||||
mlx5_odp_init_mr_cache_entry(ent);
|
||||
|
|
@ -694,6 +693,7 @@ int mlx5_mr_cache_init(struct mlx5_ib_dev *dev)
|
|||
ent->limit = dev->mdev->profile->mr_cache[i].limit;
|
||||
else
|
||||
ent->limit = 0;
|
||||
queue_work(cache->wq, &ent->work);
|
||||
}
|
||||
|
||||
err = mlx5_mr_cache_debugfs_init(dev);
|
||||
|
|
|
|||
|
|
@ -683,6 +683,7 @@ static enum resp_states read_reply(struct rxe_qp *qp,
|
|||
rxe_advance_resp_resource(qp);
|
||||
|
||||
res->type = RXE_READ_MASK;
|
||||
res->replay = 0;
|
||||
|
||||
res->read.va = qp->resp.va;
|
||||
res->read.va_org = qp->resp.va;
|
||||
|
|
@ -753,7 +754,8 @@ static enum resp_states read_reply(struct rxe_qp *qp,
|
|||
state = RESPST_DONE;
|
||||
} else {
|
||||
qp->resp.res = NULL;
|
||||
qp->resp.opcode = -1;
|
||||
if (!res->replay)
|
||||
qp->resp.opcode = -1;
|
||||
if (psn_compare(res->cur_psn, qp->resp.psn) >= 0)
|
||||
qp->resp.psn = res->cur_psn;
|
||||
state = RESPST_CLEANUP;
|
||||
|
|
@ -815,6 +817,7 @@ static enum resp_states execute(struct rxe_qp *qp, struct rxe_pkt_info *pkt)
|
|||
|
||||
/* next expected psn, read handles this separately */
|
||||
qp->resp.psn = (pkt->psn + 1) & BTH_PSN_MASK;
|
||||
qp->resp.ack_psn = qp->resp.psn;
|
||||
|
||||
qp->resp.opcode = pkt->opcode;
|
||||
qp->resp.status = IB_WC_SUCCESS;
|
||||
|
|
@ -1071,7 +1074,7 @@ static enum resp_states duplicate_request(struct rxe_qp *qp,
|
|||
struct rxe_pkt_info *pkt)
|
||||
{
|
||||
enum resp_states rc;
|
||||
u32 prev_psn = (qp->resp.psn - 1) & BTH_PSN_MASK;
|
||||
u32 prev_psn = (qp->resp.ack_psn - 1) & BTH_PSN_MASK;
|
||||
|
||||
if (pkt->mask & RXE_SEND_MASK ||
|
||||
pkt->mask & RXE_WRITE_MASK) {
|
||||
|
|
@ -1114,6 +1117,7 @@ static enum resp_states duplicate_request(struct rxe_qp *qp,
|
|||
res->state = (pkt->psn == res->first_psn) ?
|
||||
rdatm_res_state_new :
|
||||
rdatm_res_state_replay;
|
||||
res->replay = 1;
|
||||
|
||||
/* Reset the resource, except length. */
|
||||
res->read.va_org = iova;
|
||||
|
|
|
|||
|
|
@ -173,6 +173,7 @@ enum rdatm_res_state {
|
|||
|
||||
struct resp_res {
|
||||
int type;
|
||||
int replay;
|
||||
u32 first_psn;
|
||||
u32 last_psn;
|
||||
u32 cur_psn;
|
||||
|
|
@ -197,6 +198,7 @@ struct rxe_resp_info {
|
|||
enum rxe_qp_state state;
|
||||
u32 msn;
|
||||
u32 psn;
|
||||
u32 ack_psn;
|
||||
int opcode;
|
||||
int drop_msg;
|
||||
int goto_error;
|
||||
|
|
|
|||
|
|
@ -1427,11 +1427,15 @@ static void ipoib_cm_skb_reap(struct work_struct *work)
|
|||
spin_unlock_irqrestore(&priv->lock, flags);
|
||||
netif_tx_unlock_bh(dev);
|
||||
|
||||
if (skb->protocol == htons(ETH_P_IP))
|
||||
if (skb->protocol == htons(ETH_P_IP)) {
|
||||
memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
|
||||
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
|
||||
}
|
||||
#if IS_ENABLED(CONFIG_IPV6)
|
||||
else if (skb->protocol == htons(ETH_P_IPV6))
|
||||
else if (skb->protocol == htons(ETH_P_IPV6)) {
|
||||
memset(IP6CB(skb), 0, sizeof(*IP6CB(skb)));
|
||||
icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
|
||||
}
|
||||
#endif
|
||||
dev_kfree_skb_any(skb);
|
||||
|
||||
|
|
|
|||
|
|
@ -475,6 +475,9 @@ static void arm_smmu_tlb_inv_range_nosync(unsigned long iova, size_t size,
|
|||
bool stage1 = cfg->cbar != CBAR_TYPE_S2_TRANS;
|
||||
void __iomem *reg = ARM_SMMU_CB(smmu_domain->smmu, cfg->cbndx);
|
||||
|
||||
if (smmu_domain->smmu->features & ARM_SMMU_FEAT_COHERENT_WALK)
|
||||
wmb();
|
||||
|
||||
if (stage1) {
|
||||
reg += leaf ? ARM_SMMU_CB_S1_TLBIVAL : ARM_SMMU_CB_S1_TLBIVA;
|
||||
|
||||
|
|
@ -516,6 +519,9 @@ static void arm_smmu_tlb_inv_vmid_nosync(unsigned long iova, size_t size,
|
|||
struct arm_smmu_domain *smmu_domain = cookie;
|
||||
void __iomem *base = ARM_SMMU_GR0(smmu_domain->smmu);
|
||||
|
||||
if (smmu_domain->smmu->features & ARM_SMMU_FEAT_COHERENT_WALK)
|
||||
wmb();
|
||||
|
||||
writel_relaxed(smmu_domain->cfg.vmid, base + ARM_SMMU_GR0_TLBIVMID);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1001,12 +1001,14 @@ next:
|
|||
}
|
||||
}
|
||||
|
||||
spin_lock(&l_mg->free_lock);
|
||||
if (!open_lines) {
|
||||
spin_lock(&l_mg->free_lock);
|
||||
WARN_ON_ONCE(!test_and_clear_bit(meta_line,
|
||||
&l_mg->meta_bitmap));
|
||||
spin_unlock(&l_mg->free_lock);
|
||||
pblk_line_replace_data(pblk);
|
||||
} else {
|
||||
spin_lock(&l_mg->free_lock);
|
||||
/* Allocate next line for preparation */
|
||||
l_mg->data_next = pblk_line_get(pblk);
|
||||
if (l_mg->data_next) {
|
||||
|
|
@ -1014,8 +1016,8 @@ next:
|
|||
l_mg->data_next->type = PBLK_LINETYPE_DATA;
|
||||
is_next = 1;
|
||||
}
|
||||
spin_unlock(&l_mg->free_lock);
|
||||
}
|
||||
spin_unlock(&l_mg->free_lock);
|
||||
|
||||
if (is_next) {
|
||||
pblk_line_erase(pblk, l_mg->data_next);
|
||||
|
|
|
|||
|
|
@ -2371,7 +2371,7 @@ static int refill_keybuf_fn(struct btree_op *op, struct btree *b,
|
|||
struct keybuf *buf = refill->buf;
|
||||
int ret = MAP_CONTINUE;
|
||||
|
||||
if (bkey_cmp(k, refill->end) >= 0) {
|
||||
if (bkey_cmp(k, refill->end) > 0) {
|
||||
ret = MAP_DONE;
|
||||
goto out;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -792,7 +792,7 @@ static void cached_dev_read_done_bh(struct closure *cl)
|
|||
|
||||
bch_mark_cache_accounting(s->iop.c, s->d,
|
||||
!s->cache_missed, s->iop.bypass);
|
||||
trace_bcache_read(s->orig_bio, !s->cache_miss, s->iop.bypass);
|
||||
trace_bcache_read(s->orig_bio, !s->cache_missed, s->iop.bypass);
|
||||
|
||||
if (s->iop.status)
|
||||
continue_at_nobarrier(cl, cached_dev_read_error, bcache_wq);
|
||||
|
|
|
|||
|
|
@ -1719,8 +1719,7 @@ static void free_params(struct dm_ioctl *param, size_t param_size, int param_fla
|
|||
}
|
||||
|
||||
static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl *param_kernel,
|
||||
int ioctl_flags,
|
||||
struct dm_ioctl **param, int *param_flags)
|
||||
int ioctl_flags, struct dm_ioctl **param, int *param_flags)
|
||||
{
|
||||
struct dm_ioctl *dmi;
|
||||
int secure_data;
|
||||
|
|
@ -1761,18 +1760,13 @@ static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl *param_kern
|
|||
|
||||
*param_flags |= DM_PARAMS_MALLOC;
|
||||
|
||||
if (copy_from_user(dmi, user, param_kernel->data_size))
|
||||
goto bad;
|
||||
/* Copy from param_kernel (which was already copied from user) */
|
||||
memcpy(dmi, param_kernel, minimum_data_size);
|
||||
|
||||
if (copy_from_user(&dmi->data, (char __user *)user + minimum_data_size,
|
||||
param_kernel->data_size - minimum_data_size))
|
||||
goto bad;
|
||||
data_copied:
|
||||
/*
|
||||
* Abort if something changed the ioctl data while it was being copied.
|
||||
*/
|
||||
if (dmi->data_size != param_kernel->data_size) {
|
||||
DMERR("rejecting ioctl: data size modified while processing parameters");
|
||||
goto bad;
|
||||
}
|
||||
|
||||
/* Wipe the user buffer so we do not return it to userspace */
|
||||
if (secure_data && clear_user(user, param_kernel->data_size))
|
||||
goto bad;
|
||||
|
|
|
|||
|
|
@ -99,7 +99,7 @@ struct dmz_mblock {
|
|||
struct rb_node node;
|
||||
struct list_head link;
|
||||
sector_t no;
|
||||
atomic_t ref;
|
||||
unsigned int ref;
|
||||
unsigned long state;
|
||||
struct page *page;
|
||||
void *data;
|
||||
|
|
@ -296,7 +296,7 @@ static struct dmz_mblock *dmz_alloc_mblock(struct dmz_metadata *zmd,
|
|||
|
||||
RB_CLEAR_NODE(&mblk->node);
|
||||
INIT_LIST_HEAD(&mblk->link);
|
||||
atomic_set(&mblk->ref, 0);
|
||||
mblk->ref = 0;
|
||||
mblk->state = 0;
|
||||
mblk->no = mblk_no;
|
||||
mblk->data = page_address(mblk->page);
|
||||
|
|
@ -339,10 +339,11 @@ static void dmz_insert_mblock(struct dmz_metadata *zmd, struct dmz_mblock *mblk)
|
|||
}
|
||||
|
||||
/*
|
||||
* Lookup a metadata block in the rbtree.
|
||||
* Lookup a metadata block in the rbtree. If the block is found, increment
|
||||
* its reference count.
|
||||
*/
|
||||
static struct dmz_mblock *dmz_lookup_mblock(struct dmz_metadata *zmd,
|
||||
sector_t mblk_no)
|
||||
static struct dmz_mblock *dmz_get_mblock_fast(struct dmz_metadata *zmd,
|
||||
sector_t mblk_no)
|
||||
{
|
||||
struct rb_root *root = &zmd->mblk_rbtree;
|
||||
struct rb_node *node = root->rb_node;
|
||||
|
|
@ -350,8 +351,17 @@ static struct dmz_mblock *dmz_lookup_mblock(struct dmz_metadata *zmd,
|
|||
|
||||
while (node) {
|
||||
mblk = container_of(node, struct dmz_mblock, node);
|
||||
if (mblk->no == mblk_no)
|
||||
if (mblk->no == mblk_no) {
|
||||
/*
|
||||
* If this is the first reference to the block,
|
||||
* remove it from the LRU list.
|
||||
*/
|
||||
mblk->ref++;
|
||||
if (mblk->ref == 1 &&
|
||||
!test_bit(DMZ_META_DIRTY, &mblk->state))
|
||||
list_del_init(&mblk->link);
|
||||
return mblk;
|
||||
}
|
||||
node = (mblk->no < mblk_no) ? node->rb_left : node->rb_right;
|
||||
}
|
||||
|
||||
|
|
@ -382,32 +392,47 @@ static void dmz_mblock_bio_end_io(struct bio *bio)
|
|||
}
|
||||
|
||||
/*
|
||||
* Read a metadata block from disk.
|
||||
* Read an uncached metadata block from disk and add it to the cache.
|
||||
*/
|
||||
static struct dmz_mblock *dmz_fetch_mblock(struct dmz_metadata *zmd,
|
||||
sector_t mblk_no)
|
||||
static struct dmz_mblock *dmz_get_mblock_slow(struct dmz_metadata *zmd,
|
||||
sector_t mblk_no)
|
||||
{
|
||||
struct dmz_mblock *mblk;
|
||||
struct dmz_mblock *mblk, *m;
|
||||
sector_t block = zmd->sb[zmd->mblk_primary].block + mblk_no;
|
||||
struct bio *bio;
|
||||
|
||||
/* Get block and insert it */
|
||||
/* Get a new block and a BIO to read it */
|
||||
mblk = dmz_alloc_mblock(zmd, mblk_no);
|
||||
if (!mblk)
|
||||
return NULL;
|
||||
|
||||
spin_lock(&zmd->mblk_lock);
|
||||
atomic_inc(&mblk->ref);
|
||||
set_bit(DMZ_META_READING, &mblk->state);
|
||||
dmz_insert_mblock(zmd, mblk);
|
||||
spin_unlock(&zmd->mblk_lock);
|
||||
|
||||
bio = bio_alloc(GFP_NOIO, 1);
|
||||
if (!bio) {
|
||||
dmz_free_mblock(zmd, mblk);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
spin_lock(&zmd->mblk_lock);
|
||||
|
||||
/*
|
||||
* Make sure that another context did not start reading
|
||||
* the block already.
|
||||
*/
|
||||
m = dmz_get_mblock_fast(zmd, mblk_no);
|
||||
if (m) {
|
||||
spin_unlock(&zmd->mblk_lock);
|
||||
dmz_free_mblock(zmd, mblk);
|
||||
bio_put(bio);
|
||||
return m;
|
||||
}
|
||||
|
||||
mblk->ref++;
|
||||
set_bit(DMZ_META_READING, &mblk->state);
|
||||
dmz_insert_mblock(zmd, mblk);
|
||||
|
||||
spin_unlock(&zmd->mblk_lock);
|
||||
|
||||
/* Submit read BIO */
|
||||
bio->bi_iter.bi_sector = dmz_blk2sect(block);
|
||||
bio_set_dev(bio, zmd->dev->bdev);
|
||||
bio->bi_private = mblk;
|
||||
|
|
@ -484,7 +509,8 @@ static void dmz_release_mblock(struct dmz_metadata *zmd,
|
|||
|
||||
spin_lock(&zmd->mblk_lock);
|
||||
|
||||
if (atomic_dec_and_test(&mblk->ref)) {
|
||||
mblk->ref--;
|
||||
if (mblk->ref == 0) {
|
||||
if (test_bit(DMZ_META_ERROR, &mblk->state)) {
|
||||
rb_erase(&mblk->node, &zmd->mblk_rbtree);
|
||||
dmz_free_mblock(zmd, mblk);
|
||||
|
|
@ -508,18 +534,12 @@ static struct dmz_mblock *dmz_get_mblock(struct dmz_metadata *zmd,
|
|||
|
||||
/* Check rbtree */
|
||||
spin_lock(&zmd->mblk_lock);
|
||||
mblk = dmz_lookup_mblock(zmd, mblk_no);
|
||||
if (mblk) {
|
||||
/* Cache hit: remove block from LRU list */
|
||||
if (atomic_inc_return(&mblk->ref) == 1 &&
|
||||
!test_bit(DMZ_META_DIRTY, &mblk->state))
|
||||
list_del_init(&mblk->link);
|
||||
}
|
||||
mblk = dmz_get_mblock_fast(zmd, mblk_no);
|
||||
spin_unlock(&zmd->mblk_lock);
|
||||
|
||||
if (!mblk) {
|
||||
/* Cache miss: read the block from disk */
|
||||
mblk = dmz_fetch_mblock(zmd, mblk_no);
|
||||
mblk = dmz_get_mblock_slow(zmd, mblk_no);
|
||||
if (!mblk)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
|
@ -753,7 +773,7 @@ int dmz_flush_metadata(struct dmz_metadata *zmd)
|
|||
|
||||
spin_lock(&zmd->mblk_lock);
|
||||
clear_bit(DMZ_META_DIRTY, &mblk->state);
|
||||
if (atomic_read(&mblk->ref) == 0)
|
||||
if (mblk->ref == 0)
|
||||
list_add_tail(&mblk->link, &zmd->mblk_lru_list);
|
||||
spin_unlock(&zmd->mblk_lock);
|
||||
}
|
||||
|
|
@ -2308,7 +2328,7 @@ static void dmz_cleanup_metadata(struct dmz_metadata *zmd)
|
|||
mblk = list_first_entry(&zmd->mblk_dirty_list,
|
||||
struct dmz_mblock, link);
|
||||
dmz_dev_warn(zmd->dev, "mblock %llu still in dirty list (ref %u)",
|
||||
(u64)mblk->no, atomic_read(&mblk->ref));
|
||||
(u64)mblk->no, mblk->ref);
|
||||
list_del_init(&mblk->link);
|
||||
rb_erase(&mblk->node, &zmd->mblk_rbtree);
|
||||
dmz_free_mblock(zmd, mblk);
|
||||
|
|
@ -2326,8 +2346,8 @@ static void dmz_cleanup_metadata(struct dmz_metadata *zmd)
|
|||
root = &zmd->mblk_rbtree;
|
||||
rbtree_postorder_for_each_entry_safe(mblk, next, root, node) {
|
||||
dmz_dev_warn(zmd->dev, "mblock %llu ref %u still in rbtree",
|
||||
(u64)mblk->no, atomic_read(&mblk->ref));
|
||||
atomic_set(&mblk->ref, 0);
|
||||
(u64)mblk->no, mblk->ref);
|
||||
mblk->ref = 0;
|
||||
dmz_free_mblock(zmd, mblk);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1725,6 +1725,7 @@ static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)
|
|||
*/
|
||||
if (rdev->saved_raid_disk >= 0 &&
|
||||
rdev->saved_raid_disk >= first &&
|
||||
rdev->saved_raid_disk < conf->raid_disks &&
|
||||
conf->mirrors[rdev->saved_raid_disk].rdev == NULL)
|
||||
first = last = rdev->saved_raid_disk;
|
||||
|
||||
|
|
|
|||
|
|
@ -1775,6 +1775,7 @@ static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)
|
|||
first = last = rdev->raid_disk;
|
||||
|
||||
if (rdev->saved_raid_disk >= first &&
|
||||
rdev->saved_raid_disk < conf->geo.raid_disks &&
|
||||
conf->mirrors[rdev->saved_raid_disk].rdev == NULL)
|
||||
mirror = rdev->saved_raid_disk;
|
||||
else
|
||||
|
|
|
|||
|
|
@ -1765,7 +1765,7 @@ typedef struct { u16 __; u8 _; } __packed x24;
|
|||
pos[7] = (chr & (0x01 << 0) ? fg : bg); \
|
||||
} \
|
||||
\
|
||||
pos += (tpg->hflip ? -8 : 8) / hdiv; \
|
||||
pos += (tpg->hflip ? -8 : 8) / (int)hdiv; \
|
||||
} \
|
||||
} \
|
||||
} while (0)
|
||||
|
|
|
|||
|
|
@ -1530,7 +1530,7 @@ static int tvp5150_probe(struct i2c_client *c,
|
|||
27000000, 1, 27000000);
|
||||
v4l2_ctrl_new_std_menu_items(&core->hdl, &tvp5150_ctrl_ops,
|
||||
V4L2_CID_TEST_PATTERN,
|
||||
ARRAY_SIZE(tvp5150_test_patterns),
|
||||
ARRAY_SIZE(tvp5150_test_patterns) - 1,
|
||||
0, 0, tvp5150_test_patterns);
|
||||
sd->ctrl_handler = &core->hdl;
|
||||
if (core->hdl.error) {
|
||||
|
|
|
|||
|
|
@ -2112,13 +2112,13 @@ struct em28xx_board em28xx_boards[] = {
|
|||
.input = { {
|
||||
.type = EM28XX_VMUX_COMPOSITE,
|
||||
.vmux = TVP5150_COMPOSITE1,
|
||||
.amux = EM28XX_AUDIO_SRC_LINE,
|
||||
.amux = EM28XX_AMUX_LINE_IN,
|
||||
.gpio = terratec_av350_unmute_gpio,
|
||||
|
||||
}, {
|
||||
.type = EM28XX_VMUX_SVIDEO,
|
||||
.vmux = TVP5150_SVIDEO,
|
||||
.amux = EM28XX_AUDIO_SRC_LINE,
|
||||
.amux = EM28XX_AMUX_LINE_IN,
|
||||
.gpio = terratec_av350_unmute_gpio,
|
||||
} },
|
||||
},
|
||||
|
|
|
|||
|
|
@ -900,6 +900,8 @@ static int em28xx_enable_analog_tuner(struct em28xx *dev)
|
|||
if (!mdev || !v4l2->decoder)
|
||||
return 0;
|
||||
|
||||
dev->v4l2->field_count = 0;
|
||||
|
||||
/*
|
||||
* This will find the tuner that is connected into the decoder.
|
||||
* Technically, this is not 100% correct, as the device may be
|
||||
|
|
@ -1445,9 +1447,9 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
|
|||
|
||||
fmt = format_by_fourcc(f->fmt.pix.pixelformat);
|
||||
if (!fmt) {
|
||||
em28xx_videodbg("Fourcc format (%08x) invalid.\n",
|
||||
f->fmt.pix.pixelformat);
|
||||
return -EINVAL;
|
||||
fmt = &format[0];
|
||||
em28xx_videodbg("Fourcc format (%08x) invalid. Using default (%08x).\n",
|
||||
f->fmt.pix.pixelformat, fmt->fourcc);
|
||||
}
|
||||
|
||||
if (dev->board.is_em2800) {
|
||||
|
|
|
|||
|
|
@ -1094,6 +1094,7 @@ static void menelaus_rtc_alarm_work(struct menelaus_chip *m)
|
|||
static inline void menelaus_rtc_init(struct menelaus_chip *m)
|
||||
{
|
||||
int alarm = (m->client->irq > 0);
|
||||
int err;
|
||||
|
||||
/* assume 32KDETEN pin is pulled high */
|
||||
if (!(menelaus_read_reg(MENELAUS_OSC_CTRL) & 0x80)) {
|
||||
|
|
@ -1101,6 +1102,12 @@ static inline void menelaus_rtc_init(struct menelaus_chip *m)
|
|||
return;
|
||||
}
|
||||
|
||||
m->rtc = devm_rtc_allocate_device(&m->client->dev);
|
||||
if (IS_ERR(m->rtc))
|
||||
return;
|
||||
|
||||
m->rtc->ops = &menelaus_rtc_ops;
|
||||
|
||||
/* support RTC alarm; it can issue wakeups */
|
||||
if (alarm) {
|
||||
if (menelaus_add_irq_work(MENELAUS_RTCALM_IRQ,
|
||||
|
|
@ -1125,10 +1132,8 @@ static inline void menelaus_rtc_init(struct menelaus_chip *m)
|
|||
menelaus_write_reg(MENELAUS_RTC_CTRL, m->rtc_control);
|
||||
}
|
||||
|
||||
m->rtc = rtc_device_register(DRIVER_NAME,
|
||||
&m->client->dev,
|
||||
&menelaus_rtc_ops, THIS_MODULE);
|
||||
if (IS_ERR(m->rtc)) {
|
||||
err = rtc_register_device(m->rtc);
|
||||
if (err) {
|
||||
if (alarm) {
|
||||
menelaus_remove_irq_work(MENELAUS_RTCALM_IRQ);
|
||||
device_init_wakeup(&m->client->dev, 0);
|
||||
|
|
|
|||
|
|
@ -403,7 +403,7 @@ struct genwqe_file {
|
|||
struct file *filp;
|
||||
|
||||
struct fasync_struct *async_queue;
|
||||
struct task_struct *owner;
|
||||
struct pid *opener;
|
||||
struct list_head list; /* entry in list of open files */
|
||||
|
||||
spinlock_t map_lock; /* lock for dma_mappings */
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ static void genwqe_add_file(struct genwqe_dev *cd, struct genwqe_file *cfile)
|
|||
{
|
||||
unsigned long flags;
|
||||
|
||||
cfile->owner = current;
|
||||
cfile->opener = get_pid(task_tgid(current));
|
||||
spin_lock_irqsave(&cd->file_lock, flags);
|
||||
list_add(&cfile->list, &cd->file_list);
|
||||
spin_unlock_irqrestore(&cd->file_lock, flags);
|
||||
|
|
@ -65,6 +65,7 @@ static int genwqe_del_file(struct genwqe_dev *cd, struct genwqe_file *cfile)
|
|||
spin_lock_irqsave(&cd->file_lock, flags);
|
||||
list_del(&cfile->list);
|
||||
spin_unlock_irqrestore(&cd->file_lock, flags);
|
||||
put_pid(cfile->opener);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -275,7 +276,7 @@ static int genwqe_kill_fasync(struct genwqe_dev *cd, int sig)
|
|||
return files;
|
||||
}
|
||||
|
||||
static int genwqe_force_sig(struct genwqe_dev *cd, int sig)
|
||||
static int genwqe_terminate(struct genwqe_dev *cd)
|
||||
{
|
||||
unsigned int files = 0;
|
||||
unsigned long flags;
|
||||
|
|
@ -283,7 +284,7 @@ static int genwqe_force_sig(struct genwqe_dev *cd, int sig)
|
|||
|
||||
spin_lock_irqsave(&cd->file_lock, flags);
|
||||
list_for_each_entry(cfile, &cd->file_list, list) {
|
||||
force_sig(sig, cfile->owner);
|
||||
kill_pid(cfile->opener, SIGKILL, 1);
|
||||
files++;
|
||||
}
|
||||
spin_unlock_irqrestore(&cd->file_lock, flags);
|
||||
|
|
@ -1356,7 +1357,7 @@ static int genwqe_inform_and_stop_processes(struct genwqe_dev *cd)
|
|||
dev_warn(&pci_dev->dev,
|
||||
"[%s] send SIGKILL and wait ...\n", __func__);
|
||||
|
||||
rc = genwqe_force_sig(cd, SIGKILL); /* force terminate */
|
||||
rc = genwqe_terminate(cd);
|
||||
if (rc) {
|
||||
/* Give kill_timout more seconds to end processes */
|
||||
for (i = 0; (i < genwqe_kill_timeout) &&
|
||||
|
|
|
|||
|
|
@ -113,5 +113,5 @@ module_exit(vmci_drv_exit);
|
|||
|
||||
MODULE_AUTHOR("VMware, Inc.");
|
||||
MODULE_DESCRIPTION("VMware Virtual Machine Communication Interface.");
|
||||
MODULE_VERSION("1.1.5.0-k");
|
||||
MODULE_VERSION("1.1.6.0-k");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
|
|
|||
|
|
@ -57,7 +57,8 @@ static struct vmci_resource *vmci_resource_lookup(struct vmci_handle handle,
|
|||
|
||||
if (r->type == type &&
|
||||
rid == handle.resource &&
|
||||
(cid == handle.context || cid == VMCI_INVALID_ID)) {
|
||||
(cid == handle.context || cid == VMCI_INVALID_ID ||
|
||||
handle.context == VMCI_INVALID_ID)) {
|
||||
resource = r;
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -334,6 +334,9 @@ int sdhci_pci_o2_probe(struct sdhci_pci_chip *chip)
|
|||
pci_write_config_byte(chip->pdev, O2_SD_LOCK_WP, scratch);
|
||||
break;
|
||||
case PCI_DEVICE_ID_O2_SEABIRD0:
|
||||
if (chip->pdev->revision == 0x01)
|
||||
chip->quirks |= SDHCI_QUIRK_DELAY_AFTER_POWER;
|
||||
/* fall through */
|
||||
case PCI_DEVICE_ID_O2_SEABIRD1:
|
||||
/* UnLock WP */
|
||||
ret = pci_read_config_byte(chip->pdev,
|
||||
|
|
|
|||
|
|
@ -2079,6 +2079,10 @@ atmel_hsmc_nand_controller_legacy_init(struct atmel_hsmc_nand_controller *nc)
|
|||
nand_np = dev->of_node;
|
||||
nfc_np = of_find_compatible_node(dev->of_node, NULL,
|
||||
"atmel,sama5d3-nfc");
|
||||
if (!nfc_np) {
|
||||
dev_err(dev, "Could not find device node for sama5d3-nfc\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
nc->clk = of_clk_get(nfc_np, 0);
|
||||
if (IS_ERR(nc->clk)) {
|
||||
|
|
|
|||
|
|
@ -468,6 +468,7 @@ static int fsl_qspi_get_seqid(struct fsl_qspi *q, u8 cmd)
|
|||
{
|
||||
switch (cmd) {
|
||||
case SPINOR_OP_READ_1_1_4:
|
||||
case SPINOR_OP_READ_1_1_4_4B:
|
||||
return SEQID_READ;
|
||||
case SPINOR_OP_WREN:
|
||||
return SEQID_WREN;
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue