This is the 4.19.61 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAl06qFcACgkQONu9yGCS
aT6O9A/+JZqoVYnItpOnT8Hu//0mYEKvREWqsoTJNpZJhLWtGjPTT9ospHNpVgfC
GUkFqngWzXHpzCgTYHUV3Mm+SIiVXCM3nkCU1+2YOsPzrKo/lJSfFt3wOYGpKO5V
qratAQLra5TqR0teR00aQblqKqfmrux05uL9dNcVIwve813m00jFALcpjrXnanpP
tx5cqCo3uHOou5XLraHx/CMPnfJI/mLegBUTM4DxAmN2vG4gQck2gnrU7s1eg4cy
1Fqh0Oo2Ycj5p9yoGss02JqR3wGZHOEmF55j2JcTZAPvW6/c55iPd52Trn8kPOHB
Awq/VwJmP4p10a4TWoZpv7VqpL3PzO8/AW7QWOER8QnDzfOTHGae7YT8LVp5Xqj5
1NqowuP/Tm0yaZSaDLqkdvhVqTi0oGL8OCYLErpeR9PQ3P+p3paaswopsPqnXURj
Q4Pahe1vm9WG2NpKh2bHVmmVkQmvwuxxxnaa31HI/IyLd5bYFV1/LbEa/XrSK36W
VJtO+0AjERO9uTVP/YDloDkQ4R3+3W+m520jYsgf1OwY7v/Kc6iLb7cDwci/ZWMy
YSMm8hrO0nzuT0SI25TKLDvxjGbANKvxytzOQMOTb8NsIWwaoEKWh+4r9XkdUXNa
+dx72I5J2Be+3hk+eaDNzCdEae5pgVTxBpwJbzI4RfnK1Doa4uE=
=hJdd
-----END PGP SIGNATURE-----
Merge 4.19.61 into android-4.19-q
Changes in 4.19.61
MIPS: ath79: fix ar933x uart parity mode
MIPS: fix build on non-linux hosts
arm64/efi: Mark __efistub_stext_offset as an absolute symbol explicitly
scsi: iscsi: set auth_protocol back to NULL if CHAP_A value is not supported
dmaengine: imx-sdma: fix use-after-free on probe error path
wil6210: fix potential out-of-bounds read
ath10k: Do not send probe response template for mesh
ath9k: Check for errors when reading SREV register
ath6kl: add some bounds checking
ath10k: add peer id check in ath10k_peer_find_by_id
wil6210: fix spurious interrupts in 3-msi
ath: DFS JP domain W56 fixed pulse type 3 RADAR detection
regmap: debugfs: Fix memory leak in regmap_debugfs_init
batman-adv: fix for leaked TVLV handler.
media: dvb: usb: fix use after free in dvb_usb_device_exit
media: spi: IR LED: add missing of table registration
crypto: talitos - fix skcipher failure due to wrong output IV
media: ov7740: avoid invalid framesize setting
media: marvell-ccic: fix DMA s/g desc number calculation
media: vpss: fix a potential NULL pointer dereference
media: media_device_enum_links32: clean a reserved field
net: stmmac: dwmac1000: Clear unused address entries
net: stmmac: dwmac4/5: Clear unused address entries
qed: Set the doorbell address correctly
signal/pid_namespace: Fix reboot_pid_ns to use send_sig not force_sig
af_key: fix leaks in key_pol_get_resp and dump_sp.
xfrm: Fix xfrm sel prefix length validation
fscrypt: clean up some BUG_ON()s in block encryption/decryption
perf annotate TUI browser: Do not use member from variable within its own initialization
media: mc-device.c: don't memset __user pointer contents
media: saa7164: fix remove_proc_entry warning
media: staging: media: davinci_vpfe: - Fix for memory leak if decoder initialization fails.
net: phy: Check against net_device being NULL
crypto: talitos - properly handle split ICV.
crypto: talitos - Align SEC1 accesses to 32 bits boundaries.
tua6100: Avoid build warnings.
batman-adv: Fix duplicated OGMs on NETDEV_UP
locking/lockdep: Fix merging of hlocks with non-zero references
media: wl128x: Fix some error handling in fm_v4l2_init_video_device()
net: hns3: set ops to null when unregister ad_dev
cpupower : frequency-set -r option misses the last cpu in related cpu list
arm64: mm: make CONFIG_ZONE_DMA32 configurable
perf jvmti: Address gcc string overflow warning for strncpy()
net: stmmac: dwmac4: fix flow control issue
net: stmmac: modify default value of tx-frames
crypto: inside-secure - do not rely on the hardware last bit for result descriptors
net: fec: Do not use netdev messages too early
net: axienet: Fix race condition causing TX hang
s390/qdio: handle PENDING state for QEBSM devices
RAS/CEC: Fix pfn insertion
net: sfp: add mutex to prevent concurrent state checks
ipset: Fix memory accounting for hash types on resize
perf cs-etm: Properly set the value of 'old' and 'head' in snapshot mode
perf test 6: Fix missing kvm module load for s390
perf report: Fix OOM error in TUI mode on s390
irqchip/meson-gpio: Add support for Meson-G12A SoC
media: uvcvideo: Fix access to uninitialized fields on probe error
media: fdp1: Support M3N and E3 platforms
iommu: Fix a leak in iommu_insert_resv_region
gpio: omap: fix lack of irqstatus_raw0 for OMAP4
gpio: omap: ensure irq is enabled before wakeup
regmap: fix bulk writes on paged registers
bpf: silence warning messages in core
media: s5p-mfc: fix reading min scratch buffer size on MFC v6/v7
selinux: fix empty write to keycreate file
x86/cpu: Add Ice Lake NNPI to Intel family
ASoC: meson: axg-tdm: fix sample clock inversion
rcu: Force inlining of rcu_read_lock()
x86/cpufeatures: Add FDP_EXCPTN_ONLY and ZERO_FCS_FDS
qed: iWARP - Fix tc for MPA ll2 connection
net: hns3: fix for skb leak when doing selftest
block: null_blk: fix race condition for null_del_dev
blkcg, writeback: dead memcgs shouldn't contribute to writeback ownership arbitration
xfrm: fix sa selector validation
sched/core: Add __sched tag for io_schedule()
sched/fair: Fix "runnable_avg_yN_inv" not used warnings
perf/x86/intel/uncore: Handle invalid event coding for free-running counter
x86/atomic: Fix smp_mb__{before,after}_atomic()
perf evsel: Make perf_evsel__name() accept a NULL argument
vhost_net: disable zerocopy by default
ipoib: correcly show a VF hardware address
x86/cacheinfo: Fix a -Wtype-limits warning
blk-iolatency: only account submitted bios
ACPICA: Clear status of GPEs on first direct enable
EDAC/sysfs: Fix memory leak when creating a csrow object
nvme: fix possible io failures when removing multipathed ns
nvme-pci: properly report state change failure in nvme_reset_work
nvme-pci: set the errno on ctrl state change error
lightnvm: pblk: fix freeing of merged pages
arm64: Do not enable IRQs for ct_user_exit
ipsec: select crypto ciphers for xfrm_algo
ipvs: defer hook registration to avoid leaks
media: s5p-mfc: Make additional clocks optional
media: i2c: fix warning same module names
ntp: Limit TAI-UTC offset
timer_list: Guard procfs specific code
acpi/arm64: ignore 5.1 FADTs that are reported as 5.0
media: coda: fix mpeg2 sequence number handling
media: coda: fix last buffer handling in V4L2_ENC_CMD_STOP
media: coda: increment sequence offset for the last returned frame
media: vimc: cap: check v4l2_fill_pixfmt return value
media: hdpvr: fix locking and a missing msleep
net: stmmac: sun8i: force select external PHY when no internal one
rtlwifi: rtl8192cu: fix error handle when usb probe failed
mt7601u: do not schedule rx_tasklet when the device has been disconnected
x86/build: Add 'set -e' to mkcapflags.sh to delete broken capflags.c
mt7601u: fix possible memory leak when the device is disconnected
ipvs: fix tinfo memory leak in start_sync_thread
ath10k: add missing error handling
ath10k: fix PCIE device wake up failed
perf tools: Increase MAX_NR_CPUS and MAX_CACHES
ASoC: Intel: hdac_hdmi: Set ops to NULL on remove
libata: don't request sense data on !ZAC ATA devices
clocksource/drivers/exynos_mct: Increase priority over ARM arch timer
xsk: Properly terminate assignment in xskq_produce_flush_desc
rslib: Fix decoding of shortened codes
rslib: Fix handling of of caller provided syndrome
ixgbe: Check DDM existence in transceiver before access
crypto: serpent - mark __serpent_setkey_sbox noinline
crypto: asymmetric_keys - select CRYPTO_HASH where needed
wil6210: drop old event after wmi_call timeout
EDAC: Fix global-out-of-bounds write when setting edac_mc_poll_msec
bcache: check CACHE_SET_IO_DISABLE in allocator code
bcache: check CACHE_SET_IO_DISABLE bit in bch_journal()
bcache: acquire bch_register_lock later in cached_dev_free()
bcache: check c->gc_thread by IS_ERR_OR_NULL in cache_set_flush()
bcache: fix potential deadlock in cached_def_free()
net: hns3: fix a -Wformat-nonliteral compile warning
net: hns3: add some error checking in hclge_tm module
ath10k: destroy sdio workqueue while remove sdio module
net: mvpp2: prs: Don't override the sign bit in SRAM parser shift
igb: clear out skb->tstamp after reading the txtime
iwlwifi: mvm: Drop large non sta frames
bpf: fix uapi bpf_prog_info fields alignment
perf stat: Make metric event lookup more robust
perf stat: Fix group lookup for metric group
bnx2x: Prevent ptp_task to be rescheduled indefinitely
net: usb: asix: init MAC address buffers
rxrpc: Fix oops in tracepoint
bpf, libbpf, smatch: Fix potential NULL pointer dereference
selftests: bpf: fix inlines in test_lwt_seg6local
bonding: validate ip header before check IPPROTO_IGMP
gpiolib: Fix references to gpiod_[gs]et_*value_cansleep() variants
tools: bpftool: Fix json dump crash on powerpc
Bluetooth: hci_bcsp: Fix memory leak in rx_skb
Bluetooth: Add new 13d3:3491 QCA_ROME device
Bluetooth: Add new 13d3:3501 QCA_ROME device
Bluetooth: 6lowpan: search for destination address in all peers
perf tests: Fix record+probe_libc_inet_pton.sh for powerpc64
Bluetooth: Check state in l2cap_disconnect_rsp
gtp: add missing gtp_encap_disable_sock() in gtp_encap_enable()
Bluetooth: validate BLE connection interval updates
gtp: fix suspicious RCU usage
gtp: fix Illegal context switch in RCU read-side critical section.
gtp: fix use-after-free in gtp_encap_destroy()
gtp: fix use-after-free in gtp_newlink()
net: mvmdio: defer probe of orion-mdio if a clock is not ready
iavf: fix dereference of null rx_buffer pointer
floppy: fix div-by-zero in setup_format_params
floppy: fix out-of-bounds read in next_valid_format
floppy: fix invalid pointer dereference in drive_name
floppy: fix out-of-bounds read in copy_buffer
xen: let alloc_xenballooned_pages() fail if not enough memory free
scsi: NCR5380: Reduce goto statements in NCR5380_select()
scsi: NCR5380: Always re-enable reselection interrupt
Revert "scsi: ncr5380: Increase register polling limit"
scsi: core: Fix race on creating sense cache
scsi: megaraid_sas: Fix calculation of target ID
scsi: mac_scsi: Increase PIO/PDMA transfer length threshold
scsi: mac_scsi: Fix pseudo DMA implementation, take 2
crypto: ghash - fix unaligned memory access in ghash_setkey()
crypto: ccp - Validate the the error value used to index error messages
crypto: arm64/sha1-ce - correct digest for empty data in finup
crypto: arm64/sha2-ce - correct digest for empty data in finup
crypto: chacha20poly1305 - fix atomic sleep when using async algorithm
crypto: crypto4xx - fix AES CTR blocksize value
crypto: crypto4xx - fix blocksize for cfb and ofb
crypto: crypto4xx - block ciphers should only accept complete blocks
crypto: ccp - memset structure fields to zero before reuse
crypto: ccp/gcm - use const time tag comparison.
crypto: crypto4xx - fix a potential double free in ppc4xx_trng_probe
Revert "bcache: set CACHE_SET_IO_DISABLE in bch_cached_dev_error()"
bcache: Revert "bcache: fix high CPU occupancy during journal"
bcache: Revert "bcache: free heap cache_set->flush_btree in bch_journal_free"
bcache: ignore read-ahead request failure on backing device
bcache: fix mistaken sysfs entry for io_error counter
bcache: destroy dc->writeback_write_wq if failed to create dc->writeback_thread
Input: gtco - bounds check collection indent level
Input: alps - don't handle ALPS cs19 trackpoint-only device
Input: synaptics - whitelist Lenovo T580 SMBus intertouch
Input: alps - fix a mismatch between a condition check and its comment
regulator: s2mps11: Fix buck7 and buck8 wrong voltages
arm64: tegra: Update Jetson TX1 GPU regulator timings
iwlwifi: pcie: don't service an interrupt that was masked
iwlwifi: pcie: fix ALIVE interrupt handling for gen2 devices w/o MSI-X
iwlwifi: don't WARN when calling iwl_get_shared_mem_conf with RF-Kill
iwlwifi: fix RF-Kill interrupt while FW load for gen2 devices
NFSv4: Handle the special Linux file open access mode
pnfs/flexfiles: Fix PTR_ERR() dereferences in ff_layout_track_ds_error
pNFS: Fix a typo in pnfs_update_layout
pnfs: Fix a problem where we gratuitously start doing I/O through the MDS
lib/scatterlist: Fix mapping iterator when sg->offset is greater than PAGE_SIZE
ASoC: dapm: Adapt for debugfs API change
raid5-cache: Need to do start() part job after adding journal device
ALSA: seq: Break too long mutex context in the write loop
ALSA: hda/realtek - Fixed Headphone Mic can't record on Dell platform
ALSA: hda/realtek: apply ALC891 headset fixup to one Dell machine
media: v4l2: Test type instead of cfg->type in v4l2_ctrl_new_custom()
media: coda: Remove unbalanced and unneeded mutex unlock
media: videobuf2-core: Prevent size alignment wrapping buffer size to 0
media: videobuf2-dma-sg: Prevent size from overflowing
KVM: x86/vPMU: refine kvm_pmu err msg when event creation failed
arm64: tegra: Fix AGIC register range
fs/proc/proc_sysctl.c: fix the default values of i_uid/i_gid on /proc/sys inodes.
kconfig: fix missing choice values in auto.conf
drm/nouveau/i2c: Enable i2c pads & busses during preinit
padata: use smp_mb in padata_reorder to avoid orphaned padata jobs
dm zoned: fix zone state management race
xen/events: fix binding user event channels to cpus
9p/xen: Add cleanup path in p9_trans_xen_init
9p/virtio: Add cleanup path in p9_virtio_init
x86/boot: Fix memory leak in default_get_smp_config()
perf/x86/intel: Fix spurious NMI on fixed counter
perf/x86/amd/uncore: Do not set 'ThreadMask' and 'SliceMask' for non-L3 PMCs
perf/x86/amd/uncore: Set the thread mask for F17h L3 PMCs
drm/edid: parse CEA blocks embedded in DisplayID
intel_th: pci: Add Ice Lake NNPI support
PCI: hv: Fix a use-after-free bug in hv_eject_device_work()
PCI: Do not poll for PME if the device is in D3cold
PCI: qcom: Ensure that PERST is asserted for at least 100 ms
Btrfs: fix data loss after inode eviction, renaming it, and fsync it
Btrfs: fix fsync not persisting dentry deletions due to inode evictions
Btrfs: add missing inode version, ctime and mtime updates when punching hole
IB/mlx5: Report correctly tag matching rendezvous capability
HID: wacom: generic: only switch the mode on devices with LEDs
HID: wacom: generic: Correct pad syncing
HID: wacom: correct touch resolution x/y typo
libnvdimm/pfn: fix fsdax-mode namespace info-block zero-fields
coda: pass the host file in vma->vm_file on mmap
include/asm-generic/bug.h: fix "cut here" for WARN_ON for __WARN_TAINT architectures
xfs: fix pagecache truncation prior to reflink
xfs: flush removing page cache in xfs_reflink_remap_prep
xfs: don't overflow xattr listent buffer
xfs: rename m_inotbt_nores to m_finobt_nores
xfs: don't ever put nlink > 0 inodes on the unlinked list
xfs: reserve blocks for ifree transaction during log recovery
xfs: fix reporting supported extra file attributes for statx()
xfs: serialize unaligned dio writes against all other dio writes
xfs: abort unaligned nowait directio early
gpu: ipu-v3: ipu-ic: Fix saturation bit offset in TPMEM
crypto: caam - limit output IV to CBC to work around CTR mode DMA issue
parisc: Ensure userspace privilege for ptraced processes in regset functions
parisc: Fix kernel panic due invalid values in IAOQ0 or IAOQ1
powerpc/32s: fix suspend/resume when IBATs 4-7 are used
powerpc/watchpoint: Restore NV GPRs while returning from exception
powerpc/powernv/npu: Fix reference leak
powerpc/pseries: Fix oops in hotplug memory notifier
mmc: sdhci-msm: fix mutex while in spinlock
eCryptfs: fix a couple type promotion bugs
mtd: rawnand: mtk: Correct low level time calculation of r/w cycle
mtd: spinand: read returns badly if the last page has bitflips
intel_th: msu: Fix single mode with disabled IOMMU
Bluetooth: Add SMP workaround Microsoft Surface Precision Mouse bug
usb: Handle USB3 remote wakeup for LPM enabled devices correctly
blk-throttle: fix zero wait time for iops throttled group
blk-iolatency: clear use_delay when io.latency is set to zero
blkcg: update blkcg_print_stat() to handle larger outputs
net: mvmdio: allow up to four clocks to be specified for orion-mdio
dt-bindings: allow up to four clocks for orion-mdio
dm bufio: fix deadlock with loop device
Linux 4.19.61
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
Change-Id: Iac73da7ad6363743eb8c31f204ebd579950f8654
This commit is contained in:
Greg Kroah-Hartman
commit
92e72d9a99
@ -177,6 +177,9 @@ These helper barriers exist because architectures have varying implicit
|
||||
ordering on their SMP atomic primitives. For example our TSO architectures
|
||||
provide full ordered atomics and these barriers are no-ops.
|
||||
|
||||
NOTE: when the atomic RmW ops are fully ordered, they should also imply a
|
||||
compiler barrier.
|
||||
|
||||
Thus:
|
||||
|
||||
atomic_fetch_add();
|
||||
|
||||
@ -16,7 +16,7 @@ Required properties:
|
||||
|
||||
Optional properties:
|
||||
- interrupts: interrupt line number for the SMI error/done interrupt
|
||||
- clocks: phandle for up to three required clocks for the MDIO instance
|
||||
- clocks: phandle for up to four required clocks for the MDIO instance
|
||||
|
||||
The child nodes of the MDIO driver are the individual PHY devices
|
||||
connected to this MDIO bus. They must have a "reg" property given the
|
||||
|
||||
@ -20,7 +20,8 @@ void calc_runnable_avg_yN_inv(void)
|
||||
int i;
|
||||
unsigned int x;
|
||||
|
||||
printf("static const u32 runnable_avg_yN_inv[] = {");
|
||||
/* To silence -Wunused-but-set-variable warnings. */
|
||||
printf("static const u32 runnable_avg_yN_inv[] __maybe_unused = {");
|
||||
for (i = 0; i < HALFLIFE; i++) {
|
||||
x = ((1UL<<32)-1)*pow(y, i);
|
||||
|
||||
|
||||
2
Makefile
2
Makefile
@ -1,7 +1,7 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 4
|
||||
PATCHLEVEL = 19
|
||||
SUBLEVEL = 60
|
||||
SUBLEVEL = 61
|
||||
EXTRAVERSION =
|
||||
NAME = "People's Front"
|
||||
|
||||
|
||||
@ -252,7 +252,8 @@ config GENERIC_CALIBRATE_DELAY
|
||||
def_bool y
|
||||
|
||||
config ZONE_DMA32
|
||||
def_bool y
|
||||
bool "Support DMA32 zone" if EXPERT
|
||||
default y
|
||||
|
||||
config HAVE_GENERIC_GUP
|
||||
def_bool y
|
||||
|
||||
@ -330,7 +330,8 @@
|
||||
regulator-max-microvolt = <1320000>;
|
||||
enable-gpios = <&pmic 6 GPIO_ACTIVE_HIGH>;
|
||||
regulator-ramp-delay = <80>;
|
||||
regulator-enable-ramp-delay = <1000>;
|
||||
regulator-enable-ramp-delay = <2000>;
|
||||
regulator-settling-time-us = <160>;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
@ -1119,7 +1119,7 @@
|
||||
compatible = "nvidia,tegra210-agic";
|
||||
#interrupt-cells = <3>;
|
||||
interrupt-controller;
|
||||
reg = <0x702f9000 0x2000>,
|
||||
reg = <0x702f9000 0x1000>,
|
||||
<0x702fa000 0x2000>;
|
||||
interrupts = <GIC_SPI 102 (GIC_CPU_MASK_SIMPLE(4) | IRQ_TYPE_LEVEL_HIGH)>;
|
||||
clocks = <&tegra_car TEGRA210_CLK_APE>;
|
||||
|
||||
@ -62,7 +62,7 @@ static int sha1_ce_finup(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int len, u8 *out)
|
||||
{
|
||||
struct sha1_ce_state *sctx = shash_desc_ctx(desc);
|
||||
bool finalize = !sctx->sst.count && !(len % SHA1_BLOCK_SIZE);
|
||||
bool finalize = !sctx->sst.count && !(len % SHA1_BLOCK_SIZE) && len;
|
||||
|
||||
if (!may_use_simd())
|
||||
return crypto_sha1_finup(desc, data, len, out);
|
||||
|
||||
@ -67,7 +67,7 @@ static int sha256_ce_finup(struct shash_desc *desc, const u8 *data,
|
||||
unsigned int len, u8 *out)
|
||||
{
|
||||
struct sha256_ce_state *sctx = shash_desc_ctx(desc);
|
||||
bool finalize = !sctx->sst.count && !(len % SHA256_BLOCK_SIZE);
|
||||
bool finalize = !sctx->sst.count && !(len % SHA256_BLOCK_SIZE) && len;
|
||||
|
||||
if (!may_use_simd()) {
|
||||
if (len)
|
||||
|
||||
@ -154,10 +154,14 @@ static int __init acpi_fadt_sanity_check(void)
|
||||
*/
|
||||
if (table->revision < 5 ||
|
||||
(table->revision == 5 && fadt->minor_revision < 1)) {
|
||||
pr_err("Unsupported FADT revision %d.%d, should be 5.1+\n",
|
||||
pr_err(FW_BUG "Unsupported FADT revision %d.%d, should be 5.1+\n",
|
||||
table->revision, fadt->minor_revision);
|
||||
ret = -EINVAL;
|
||||
goto out;
|
||||
|
||||
if (!fadt->arm_boot_flags) {
|
||||
ret = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
pr_err("FADT has ARM boot flags set, assuming 5.1\n");
|
||||
}
|
||||
|
||||
if (!(fadt->flags & ACPI_FADT_HW_REDUCED)) {
|
||||
|
||||
@ -824,7 +824,7 @@ el0_dbg:
|
||||
mov x1, x25
|
||||
mov x2, sp
|
||||
bl do_debug_exception
|
||||
enable_daif
|
||||
enable_da_f
|
||||
ct_user_exit
|
||||
b ret_to_user
|
||||
el0_inv:
|
||||
@ -876,7 +876,7 @@ el0_error_naked:
|
||||
enable_dbg
|
||||
mov x0, sp
|
||||
bl do_serror
|
||||
enable_daif
|
||||
enable_da_f
|
||||
ct_user_exit
|
||||
b ret_to_user
|
||||
ENDPROC(el0_error)
|
||||
|
||||
@ -73,7 +73,11 @@
|
||||
|
||||
#ifdef CONFIG_EFI
|
||||
|
||||
__efistub_stext_offset = stext - _text;
|
||||
/*
|
||||
* Use ABSOLUTE() to avoid ld.lld treating this as a relative symbol:
|
||||
* https://github.com/ClangBuiltLinux/linux/issues/561
|
||||
*/
|
||||
__efistub_stext_offset = ABSOLUTE(stext - _text);
|
||||
|
||||
/*
|
||||
* The EFI stub has its own symbol namespace prefixed by __efistub_, to
|
||||
|
||||
@ -233,8 +233,9 @@ static void __init zone_sizes_init(unsigned long min, unsigned long max)
|
||||
{
|
||||
unsigned long max_zone_pfns[MAX_NR_ZONES] = {0};
|
||||
|
||||
if (IS_ENABLED(CONFIG_ZONE_DMA32))
|
||||
max_zone_pfns[ZONE_DMA32] = PFN_DOWN(max_zone_dma_phys());
|
||||
#ifdef CONFIG_ZONE_DMA32
|
||||
max_zone_pfns[ZONE_DMA32] = PFN_DOWN(max_zone_dma_phys());
|
||||
#endif
|
||||
max_zone_pfns[ZONE_NORMAL] = max;
|
||||
|
||||
free_area_init_nodes(max_zone_pfns);
|
||||
|
||||
@ -78,6 +78,8 @@ OBJCOPYFLAGS_piggy.o := --add-section=.image=$(obj)/vmlinux.bin.z \
|
||||
$(obj)/piggy.o: $(obj)/dummy.o $(obj)/vmlinux.bin.z FORCE
|
||||
$(call if_changed,objcopy)
|
||||
|
||||
HOSTCFLAGS_calc_vmlinuz_load_addr.o += $(LINUXINCLUDE)
|
||||
|
||||
# Calculate the load address of the compressed kernel image
|
||||
hostprogs-y := calc_vmlinuz_load_addr
|
||||
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "../../../../include/linux/sizes.h"
|
||||
#include <linux/sizes.h>
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
|
||||
@ -27,8 +27,8 @@
|
||||
#define AR933X_UART_CS_PARITY_S 0
|
||||
#define AR933X_UART_CS_PARITY_M 0x3
|
||||
#define AR933X_UART_CS_PARITY_NONE 0
|
||||
#define AR933X_UART_CS_PARITY_ODD 1
|
||||
#define AR933X_UART_CS_PARITY_EVEN 2
|
||||
#define AR933X_UART_CS_PARITY_ODD 2
|
||||
#define AR933X_UART_CS_PARITY_EVEN 3
|
||||
#define AR933X_UART_CS_IF_MODE_S 2
|
||||
#define AR933X_UART_CS_IF_MODE_M 0x3
|
||||
#define AR933X_UART_CS_IF_MODE_NONE 0
|
||||
|
||||
@ -167,6 +167,9 @@ long arch_ptrace(struct task_struct *child, long request,
|
||||
if ((addr & (sizeof(unsigned long)-1)) ||
|
||||
addr >= sizeof(struct pt_regs))
|
||||
break;
|
||||
if (addr == PT_IAOQ0 || addr == PT_IAOQ1) {
|
||||
data |= 3; /* ensure userspace privilege */
|
||||
}
|
||||
if ((addr >= PT_GR1 && addr <= PT_GR31) ||
|
||||
addr == PT_IAOQ0 || addr == PT_IAOQ1 ||
|
||||
(addr >= PT_FR0 && addr <= PT_FR31 + 4) ||
|
||||
@ -228,16 +231,18 @@ long arch_ptrace(struct task_struct *child, long request,
|
||||
|
||||
static compat_ulong_t translate_usr_offset(compat_ulong_t offset)
|
||||
{
|
||||
if (offset < 0)
|
||||
return sizeof(struct pt_regs);
|
||||
else if (offset <= 32*4) /* gr[0..31] */
|
||||
return offset * 2 + 4;
|
||||
else if (offset <= 32*4+32*8) /* gr[0..31] + fr[0..31] */
|
||||
return offset + 32*4;
|
||||
else if (offset < sizeof(struct pt_regs)/2 + 32*4)
|
||||
return offset * 2 + 4 - 32*8;
|
||||
compat_ulong_t pos;
|
||||
|
||||
if (offset < 32*4) /* gr[0..31] */
|
||||
pos = offset * 2 + 4;
|
||||
else if (offset < 32*4+32*8) /* fr[0] ... fr[31] */
|
||||
pos = (offset - 32*4) + PT_FR0;
|
||||
else if (offset < sizeof(struct pt_regs)/2 + 32*4) /* sr[0] ... ipsw */
|
||||
pos = (offset - 32*4 - 32*8) * 2 + PT_SR0 + 4;
|
||||
else
|
||||
return sizeof(struct pt_regs);
|
||||
pos = sizeof(struct pt_regs);
|
||||
|
||||
return pos;
|
||||
}
|
||||
|
||||
long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
|
||||
@ -281,9 +286,12 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
|
||||
addr = translate_usr_offset(addr);
|
||||
if (addr >= sizeof(struct pt_regs))
|
||||
break;
|
||||
if (addr == PT_IAOQ0+4 || addr == PT_IAOQ1+4) {
|
||||
data |= 3; /* ensure userspace privilege */
|
||||
}
|
||||
if (addr >= PT_FR0 && addr <= PT_FR31 + 4) {
|
||||
/* Special case, fp regs are 64 bits anyway */
|
||||
*(__u64 *) ((char *) task_regs(child) + addr) = data;
|
||||
*(__u32 *) ((char *) task_regs(child) + addr) = data;
|
||||
ret = 0;
|
||||
}
|
||||
else if ((addr >= PT_GR1+4 && addr <= PT_GR31+4) ||
|
||||
@ -496,7 +504,8 @@ static void set_reg(struct pt_regs *regs, int num, unsigned long val)
|
||||
return;
|
||||
case RI(iaoq[0]):
|
||||
case RI(iaoq[1]):
|
||||
regs->iaoq[num - RI(iaoq[0])] = val;
|
||||
/* set 2 lowest bits to ensure userspace privilege: */
|
||||
regs->iaoq[num - RI(iaoq[0])] = val | 3;
|
||||
return;
|
||||
case RI(sar): regs->sar = val;
|
||||
return;
|
||||
|
||||
@ -1745,7 +1745,7 @@ handle_page_fault:
|
||||
addi r3,r1,STACK_FRAME_OVERHEAD
|
||||
bl do_page_fault
|
||||
cmpdi r3,0
|
||||
beq+ 12f
|
||||
beq+ ret_from_except_lite
|
||||
bl save_nvgprs
|
||||
mr r5,r3
|
||||
addi r3,r1,STACK_FRAME_OVERHEAD
|
||||
@ -1760,7 +1760,12 @@ handle_dabr_fault:
|
||||
ld r5,_DSISR(r1)
|
||||
addi r3,r1,STACK_FRAME_OVERHEAD
|
||||
bl do_break
|
||||
12: b ret_from_except_lite
|
||||
/*
|
||||
* do_break() may have changed the NV GPRS while handling a breakpoint.
|
||||
* If so, we need to restore them with their updated values. Don't use
|
||||
* ret_from_except_lite here.
|
||||
*/
|
||||
b ret_from_except
|
||||
|
||||
|
||||
#ifdef CONFIG_PPC_BOOK3S_64
|
||||
|
||||
@ -25,11 +25,19 @@
|
||||
#define SL_IBAT2 0x48
|
||||
#define SL_DBAT3 0x50
|
||||
#define SL_IBAT3 0x58
|
||||
#define SL_TB 0x60
|
||||
#define SL_R2 0x68
|
||||
#define SL_CR 0x6c
|
||||
#define SL_LR 0x70
|
||||
#define SL_R12 0x74 /* r12 to r31 */
|
||||
#define SL_DBAT4 0x60
|
||||
#define SL_IBAT4 0x68
|
||||
#define SL_DBAT5 0x70
|
||||
#define SL_IBAT5 0x78
|
||||
#define SL_DBAT6 0x80
|
||||
#define SL_IBAT6 0x88
|
||||
#define SL_DBAT7 0x90
|
||||
#define SL_IBAT7 0x98
|
||||
#define SL_TB 0xa0
|
||||
#define SL_R2 0xa8
|
||||
#define SL_CR 0xac
|
||||
#define SL_LR 0xb0
|
||||
#define SL_R12 0xb4 /* r12 to r31 */
|
||||
#define SL_SIZE (SL_R12 + 80)
|
||||
|
||||
.section .data
|
||||
@ -114,6 +122,41 @@ _GLOBAL(swsusp_arch_suspend)
|
||||
mfibatl r4,3
|
||||
stw r4,SL_IBAT3+4(r11)
|
||||
|
||||
BEGIN_MMU_FTR_SECTION
|
||||
mfspr r4,SPRN_DBAT4U
|
||||
stw r4,SL_DBAT4(r11)
|
||||
mfspr r4,SPRN_DBAT4L
|
||||
stw r4,SL_DBAT4+4(r11)
|
||||
mfspr r4,SPRN_DBAT5U
|
||||
stw r4,SL_DBAT5(r11)
|
||||
mfspr r4,SPRN_DBAT5L
|
||||
stw r4,SL_DBAT5+4(r11)
|
||||
mfspr r4,SPRN_DBAT6U
|
||||
stw r4,SL_DBAT6(r11)
|
||||
mfspr r4,SPRN_DBAT6L
|
||||
stw r4,SL_DBAT6+4(r11)
|
||||
mfspr r4,SPRN_DBAT7U
|
||||
stw r4,SL_DBAT7(r11)
|
||||
mfspr r4,SPRN_DBAT7L
|
||||
stw r4,SL_DBAT7+4(r11)
|
||||
mfspr r4,SPRN_IBAT4U
|
||||
stw r4,SL_IBAT4(r11)
|
||||
mfspr r4,SPRN_IBAT4L
|
||||
stw r4,SL_IBAT4+4(r11)
|
||||
mfspr r4,SPRN_IBAT5U
|
||||
stw r4,SL_IBAT5(r11)
|
||||
mfspr r4,SPRN_IBAT5L
|
||||
stw r4,SL_IBAT5+4(r11)
|
||||
mfspr r4,SPRN_IBAT6U
|
||||
stw r4,SL_IBAT6(r11)
|
||||
mfspr r4,SPRN_IBAT6L
|
||||
stw r4,SL_IBAT6+4(r11)
|
||||
mfspr r4,SPRN_IBAT7U
|
||||
stw r4,SL_IBAT7(r11)
|
||||
mfspr r4,SPRN_IBAT7L
|
||||
stw r4,SL_IBAT7+4(r11)
|
||||
END_MMU_FTR_SECTION_IFSET(MMU_FTR_USE_HIGH_BATS)
|
||||
|
||||
#if 0
|
||||
/* Backup various CPU config stuffs */
|
||||
bl __save_cpu_setup
|
||||
@ -279,27 +322,41 @@ END_FTR_SECTION_IFSET(CPU_FTR_ALTIVEC)
|
||||
mtibatu 3,r4
|
||||
lwz r4,SL_IBAT3+4(r11)
|
||||
mtibatl 3,r4
|
||||
#endif
|
||||
|
||||
BEGIN_MMU_FTR_SECTION
|
||||
li r4,0
|
||||
lwz r4,SL_DBAT4(r11)
|
||||
mtspr SPRN_DBAT4U,r4
|
||||
lwz r4,SL_DBAT4+4(r11)
|
||||
mtspr SPRN_DBAT4L,r4
|
||||
lwz r4,SL_DBAT5(r11)
|
||||
mtspr SPRN_DBAT5U,r4
|
||||
lwz r4,SL_DBAT5+4(r11)
|
||||
mtspr SPRN_DBAT5L,r4
|
||||
lwz r4,SL_DBAT6(r11)
|
||||
mtspr SPRN_DBAT6U,r4
|
||||
lwz r4,SL_DBAT6+4(r11)
|
||||
mtspr SPRN_DBAT6L,r4
|
||||
lwz r4,SL_DBAT7(r11)
|
||||
mtspr SPRN_DBAT7U,r4
|
||||
lwz r4,SL_DBAT7+4(r11)
|
||||
mtspr SPRN_DBAT7L,r4
|
||||
lwz r4,SL_IBAT4(r11)
|
||||
mtspr SPRN_IBAT4U,r4
|
||||
lwz r4,SL_IBAT4+4(r11)
|
||||
mtspr SPRN_IBAT4L,r4
|
||||
lwz r4,SL_IBAT5(r11)
|
||||
mtspr SPRN_IBAT5U,r4
|
||||
lwz r4,SL_IBAT5+4(r11)
|
||||
mtspr SPRN_IBAT5L,r4
|
||||
lwz r4,SL_IBAT6(r11)
|
||||
mtspr SPRN_IBAT6U,r4
|
||||
lwz r4,SL_IBAT6+4(r11)
|
||||
mtspr SPRN_IBAT6L,r4
|
||||
lwz r4,SL_IBAT7(r11)
|
||||
mtspr SPRN_IBAT7U,r4
|
||||
lwz r4,SL_IBAT7+4(r11)
|
||||
mtspr SPRN_IBAT7L,r4
|
||||
END_MMU_FTR_SECTION_IFSET(MMU_FTR_USE_HIGH_BATS)
|
||||
#endif
|
||||
|
||||
/* Flush all TLBs */
|
||||
lis r4,0x1000
|
||||
|
||||
@ -38,10 +38,18 @@
|
||||
#define SL_IBAT2 0x48
|
||||
#define SL_DBAT3 0x50
|
||||
#define SL_IBAT3 0x58
|
||||
#define SL_TB 0x60
|
||||
#define SL_R2 0x68
|
||||
#define SL_CR 0x6c
|
||||
#define SL_R12 0x70 /* r12 to r31 */
|
||||
#define SL_DBAT4 0x60
|
||||
#define SL_IBAT4 0x68
|
||||
#define SL_DBAT5 0x70
|
||||
#define SL_IBAT5 0x78
|
||||
#define SL_DBAT6 0x80
|
||||
#define SL_IBAT6 0x88
|
||||
#define SL_DBAT7 0x90
|
||||
#define SL_IBAT7 0x98
|
||||
#define SL_TB 0xa0
|
||||
#define SL_R2 0xa8
|
||||
#define SL_CR 0xac
|
||||
#define SL_R12 0xb0 /* r12 to r31 */
|
||||
#define SL_SIZE (SL_R12 + 80)
|
||||
|
||||
.section .text
|
||||
@ -126,6 +134,41 @@ _GLOBAL(low_sleep_handler)
|
||||
mfibatl r4,3
|
||||
stw r4,SL_IBAT3+4(r1)
|
||||
|
||||
BEGIN_MMU_FTR_SECTION
|
||||
mfspr r4,SPRN_DBAT4U
|
||||
stw r4,SL_DBAT4(r1)
|
||||
mfspr r4,SPRN_DBAT4L
|
||||
stw r4,SL_DBAT4+4(r1)
|
||||
mfspr r4,SPRN_DBAT5U
|
||||
stw r4,SL_DBAT5(r1)
|
||||
mfspr r4,SPRN_DBAT5L
|
||||
stw r4,SL_DBAT5+4(r1)
|
||||
mfspr r4,SPRN_DBAT6U
|
||||
stw r4,SL_DBAT6(r1)
|
||||
mfspr r4,SPRN_DBAT6L
|
||||
stw r4,SL_DBAT6+4(r1)
|
||||
mfspr r4,SPRN_DBAT7U
|
||||
stw r4,SL_DBAT7(r1)
|
||||
mfspr r4,SPRN_DBAT7L
|
||||
stw r4,SL_DBAT7+4(r1)
|
||||
mfspr r4,SPRN_IBAT4U
|
||||
stw r4,SL_IBAT4(r1)
|
||||
mfspr r4,SPRN_IBAT4L
|
||||
stw r4,SL_IBAT4+4(r1)
|
||||
mfspr r4,SPRN_IBAT5U
|
||||
stw r4,SL_IBAT5(r1)
|
||||
mfspr r4,SPRN_IBAT5L
|
||||
stw r4,SL_IBAT5+4(r1)
|
||||
mfspr r4,SPRN_IBAT6U
|
||||
stw r4,SL_IBAT6(r1)
|
||||
mfspr r4,SPRN_IBAT6L
|
||||
stw r4,SL_IBAT6+4(r1)
|
||||
mfspr r4,SPRN_IBAT7U
|
||||
stw r4,SL_IBAT7(r1)
|
||||
mfspr r4,SPRN_IBAT7L
|
||||
stw r4,SL_IBAT7+4(r1)
|
||||
END_MMU_FTR_SECTION_IFSET(MMU_FTR_USE_HIGH_BATS)
|
||||
|
||||
/* Backup various CPU config stuffs */
|
||||
bl __save_cpu_setup
|
||||
|
||||
@ -326,22 +369,37 @@ grackle_wake_up:
|
||||
mtibatl 3,r4
|
||||
|
||||
BEGIN_MMU_FTR_SECTION
|
||||
li r4,0
|
||||
lwz r4,SL_DBAT4(r1)
|
||||
mtspr SPRN_DBAT4U,r4
|
||||
lwz r4,SL_DBAT4+4(r1)
|
||||
mtspr SPRN_DBAT4L,r4
|
||||
lwz r4,SL_DBAT5(r1)
|
||||
mtspr SPRN_DBAT5U,r4
|
||||
lwz r4,SL_DBAT5+4(r1)
|
||||
mtspr SPRN_DBAT5L,r4
|
||||
lwz r4,SL_DBAT6(r1)
|
||||
mtspr SPRN_DBAT6U,r4
|
||||
lwz r4,SL_DBAT6+4(r1)
|
||||
mtspr SPRN_DBAT6L,r4
|
||||
lwz r4,SL_DBAT7(r1)
|
||||
mtspr SPRN_DBAT7U,r4
|
||||
lwz r4,SL_DBAT7+4(r1)
|
||||
mtspr SPRN_DBAT7L,r4
|
||||
lwz r4,SL_IBAT4(r1)
|
||||
mtspr SPRN_IBAT4U,r4
|
||||
lwz r4,SL_IBAT4+4(r1)
|
||||
mtspr SPRN_IBAT4L,r4
|
||||
lwz r4,SL_IBAT5(r1)
|
||||
mtspr SPRN_IBAT5U,r4
|
||||
lwz r4,SL_IBAT5+4(r1)
|
||||
mtspr SPRN_IBAT5L,r4
|
||||
lwz r4,SL_IBAT6(r1)
|
||||
mtspr SPRN_IBAT6U,r4
|
||||
lwz r4,SL_IBAT6+4(r1)
|
||||
mtspr SPRN_IBAT6L,r4
|
||||
lwz r4,SL_IBAT7(r1)
|
||||
mtspr SPRN_IBAT7U,r4
|
||||
lwz r4,SL_IBAT7+4(r1)
|
||||
mtspr SPRN_IBAT7L,r4
|
||||
END_MMU_FTR_SECTION_IFSET(MMU_FTR_USE_HIGH_BATS)
|
||||
|
||||
|
||||
@ -56,9 +56,22 @@ static struct dentry *atsd_threshold_dentry;
|
||||
static struct pci_dev *get_pci_dev(struct device_node *dn)
|
||||
{
|
||||
struct pci_dn *pdn = PCI_DN(dn);
|
||||
struct pci_dev *pdev;
|
||||
|
||||
return pci_get_domain_bus_and_slot(pci_domain_nr(pdn->phb->bus),
|
||||
pdev = pci_get_domain_bus_and_slot(pci_domain_nr(pdn->phb->bus),
|
||||
pdn->busno, pdn->devfn);
|
||||
|
||||
/*
|
||||
* pci_get_domain_bus_and_slot() increased the reference count of
|
||||
* the PCI device, but callers don't need that actually as the PE
|
||||
* already holds a reference to the device. Since callers aren't
|
||||
* aware of the reference count change, call pci_dev_put() now to
|
||||
* avoid leaks.
|
||||
*/
|
||||
if (pdev)
|
||||
pci_dev_put(pdev);
|
||||
|
||||
return pdev;
|
||||
}
|
||||
|
||||
/* Given a NPU device get the associated PCI device. */
|
||||
|
||||
@ -1012,6 +1012,9 @@ static int pseries_update_drconf_memory(struct of_reconfig_data *pr)
|
||||
if (!memblock_size)
|
||||
return -EINVAL;
|
||||
|
||||
if (!pr->old_prop)
|
||||
return 0;
|
||||
|
||||
p = (__be32 *) pr->old_prop->value;
|
||||
if (!p)
|
||||
return -EINVAL;
|
||||
|
||||
@ -210,15 +210,22 @@ static int amd_uncore_event_init(struct perf_event *event)
|
||||
hwc->config = event->attr.config & AMD64_RAW_EVENT_MASK_NB;
|
||||
hwc->idx = -1;
|
||||
|
||||
if (event->cpu < 0)
|
||||
return -EINVAL;
|
||||
|
||||
/*
|
||||
* SliceMask and ThreadMask need to be set for certain L3 events in
|
||||
* Family 17h. For other events, the two fields do not affect the count.
|
||||
*/
|
||||
if (l3_mask)
|
||||
hwc->config |= (AMD64_L3_SLICE_MASK | AMD64_L3_THREAD_MASK);
|
||||
if (l3_mask && is_llc_event(event)) {
|
||||
int thread = 2 * (cpu_data(event->cpu).cpu_core_id % 4);
|
||||
|
||||
if (event->cpu < 0)
|
||||
return -EINVAL;
|
||||
if (smp_num_siblings > 1)
|
||||
thread += cpu_data(event->cpu).apicid & 1;
|
||||
|
||||
hwc->config |= (1ULL << (AMD64_L3_THREAD_SHIFT + thread) &
|
||||
AMD64_L3_THREAD_MASK) | AMD64_L3_SLICE_MASK;
|
||||
}
|
||||
|
||||
uncore = event_to_amd_uncore(event);
|
||||
if (!uncore)
|
||||
|
||||
@ -2074,12 +2074,10 @@ static void intel_pmu_disable_event(struct perf_event *event)
|
||||
cpuc->intel_ctrl_host_mask &= ~(1ull << hwc->idx);
|
||||
cpuc->intel_cp_status &= ~(1ull << hwc->idx);
|
||||
|
||||
if (unlikely(hwc->config_base == MSR_ARCH_PERFMON_FIXED_CTR_CTRL)) {
|
||||
if (unlikely(hwc->config_base == MSR_ARCH_PERFMON_FIXED_CTR_CTRL))
|
||||
intel_pmu_disable_fixed(hwc);
|
||||
return;
|
||||
}
|
||||
|
||||
x86_pmu_disable_event(event);
|
||||
else
|
||||
x86_pmu_disable_event(event);
|
||||
|
||||
/*
|
||||
* Needs to be called after x86_pmu_disable_event,
|
||||
|
||||
@ -402,6 +402,16 @@ static inline bool is_freerunning_event(struct perf_event *event)
|
||||
(((cfg >> 8) & 0xff) >= UNCORE_FREERUNNING_UMASK_START);
|
||||
}
|
||||
|
||||
/* Check and reject invalid config */
|
||||
static inline int uncore_freerunning_hw_config(struct intel_uncore_box *box,
|
||||
struct perf_event *event)
|
||||
{
|
||||
if (is_freerunning_event(event))
|
||||
return 0;
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static inline void uncore_disable_box(struct intel_uncore_box *box)
|
||||
{
|
||||
if (box->pmu->type->ops->disable_box)
|
||||
|
||||
@ -3585,6 +3585,7 @@ static struct uncore_event_desc skx_uncore_iio_freerunning_events[] = {
|
||||
|
||||
static struct intel_uncore_ops skx_uncore_iio_freerunning_ops = {
|
||||
.read_counter = uncore_msr_read_counter,
|
||||
.hw_config = uncore_freerunning_hw_config,
|
||||
};
|
||||
|
||||
static struct attribute *skx_uncore_iio_freerunning_formats_attr[] = {
|
||||
|
||||
@ -54,7 +54,7 @@ static __always_inline void arch_atomic_add(int i, atomic_t *v)
|
||||
{
|
||||
asm volatile(LOCK_PREFIX "addl %1,%0"
|
||||
: "+m" (v->counter)
|
||||
: "ir" (i));
|
||||
: "ir" (i) : "memory");
|
||||
}
|
||||
|
||||
/**
|
||||
@ -68,7 +68,7 @@ static __always_inline void arch_atomic_sub(int i, atomic_t *v)
|
||||
{
|
||||
asm volatile(LOCK_PREFIX "subl %1,%0"
|
||||
: "+m" (v->counter)
|
||||
: "ir" (i));
|
||||
: "ir" (i) : "memory");
|
||||
}
|
||||
|
||||
/**
|
||||
@ -95,7 +95,7 @@ static __always_inline bool arch_atomic_sub_and_test(int i, atomic_t *v)
|
||||
static __always_inline void arch_atomic_inc(atomic_t *v)
|
||||
{
|
||||
asm volatile(LOCK_PREFIX "incl %0"
|
||||
: "+m" (v->counter));
|
||||
: "+m" (v->counter) :: "memory");
|
||||
}
|
||||
#define arch_atomic_inc arch_atomic_inc
|
||||
|
||||
@ -108,7 +108,7 @@ static __always_inline void arch_atomic_inc(atomic_t *v)
|
||||
static __always_inline void arch_atomic_dec(atomic_t *v)
|
||||
{
|
||||
asm volatile(LOCK_PREFIX "decl %0"
|
||||
: "+m" (v->counter));
|
||||
: "+m" (v->counter) :: "memory");
|
||||
}
|
||||
#define arch_atomic_dec arch_atomic_dec
|
||||
|
||||
|
||||
@ -45,7 +45,7 @@ static __always_inline void arch_atomic64_add(long i, atomic64_t *v)
|
||||
{
|
||||
asm volatile(LOCK_PREFIX "addq %1,%0"
|
||||
: "=m" (v->counter)
|
||||
: "er" (i), "m" (v->counter));
|
||||
: "er" (i), "m" (v->counter) : "memory");
|
||||
}
|
||||
|
||||
/**
|
||||
@ -59,7 +59,7 @@ static inline void arch_atomic64_sub(long i, atomic64_t *v)
|
||||
{
|
||||
asm volatile(LOCK_PREFIX "subq %1,%0"
|
||||
: "=m" (v->counter)
|
||||
: "er" (i), "m" (v->counter));
|
||||
: "er" (i), "m" (v->counter) : "memory");
|
||||
}
|
||||
|
||||
/**
|
||||
@ -87,7 +87,7 @@ static __always_inline void arch_atomic64_inc(atomic64_t *v)
|
||||
{
|
||||
asm volatile(LOCK_PREFIX "incq %0"
|
||||
: "=m" (v->counter)
|
||||
: "m" (v->counter));
|
||||
: "m" (v->counter) : "memory");
|
||||
}
|
||||
#define arch_atomic64_inc arch_atomic64_inc
|
||||
|
||||
@ -101,7 +101,7 @@ static __always_inline void arch_atomic64_dec(atomic64_t *v)
|
||||
{
|
||||
asm volatile(LOCK_PREFIX "decq %0"
|
||||
: "=m" (v->counter)
|
||||
: "m" (v->counter));
|
||||
: "m" (v->counter) : "memory");
|
||||
}
|
||||
#define arch_atomic64_dec arch_atomic64_dec
|
||||
|
||||
|
||||
@ -80,8 +80,8 @@ do { \
|
||||
})
|
||||
|
||||
/* Atomic operations are already serializing on x86 */
|
||||
#define __smp_mb__before_atomic() barrier()
|
||||
#define __smp_mb__after_atomic() barrier()
|
||||
#define __smp_mb__before_atomic() do { } while (0)
|
||||
#define __smp_mb__after_atomic() do { } while (0)
|
||||
|
||||
#include <asm-generic/barrier.h>
|
||||
|
||||
|
||||
@ -239,12 +239,14 @@
|
||||
#define X86_FEATURE_BMI1 ( 9*32+ 3) /* 1st group bit manipulation extensions */
|
||||
#define X86_FEATURE_HLE ( 9*32+ 4) /* Hardware Lock Elision */
|
||||
#define X86_FEATURE_AVX2 ( 9*32+ 5) /* AVX2 instructions */
|
||||
#define X86_FEATURE_FDP_EXCPTN_ONLY ( 9*32+ 6) /* "" FPU data pointer updated only on x87 exceptions */
|
||||
#define X86_FEATURE_SMEP ( 9*32+ 7) /* Supervisor Mode Execution Protection */
|
||||
#define X86_FEATURE_BMI2 ( 9*32+ 8) /* 2nd group bit manipulation extensions */
|
||||
#define X86_FEATURE_ERMS ( 9*32+ 9) /* Enhanced REP MOVSB/STOSB instructions */
|
||||
#define X86_FEATURE_INVPCID ( 9*32+10) /* Invalidate Processor Context ID */
|
||||
#define X86_FEATURE_RTM ( 9*32+11) /* Restricted Transactional Memory */
|
||||
#define X86_FEATURE_CQM ( 9*32+12) /* Cache QoS Monitoring */
|
||||
#define X86_FEATURE_ZERO_FCS_FDS ( 9*32+13) /* "" Zero out FPU CS and FPU DS */
|
||||
#define X86_FEATURE_MPX ( 9*32+14) /* Memory Protection Extension */
|
||||
#define X86_FEATURE_RDT_A ( 9*32+15) /* Resource Director Technology Allocation */
|
||||
#define X86_FEATURE_AVX512F ( 9*32+16) /* AVX-512 Foundation */
|
||||
|
||||
@ -56,6 +56,7 @@
|
||||
#define INTEL_FAM6_ICELAKE_XEON_D 0x6C
|
||||
#define INTEL_FAM6_ICELAKE_DESKTOP 0x7D
|
||||
#define INTEL_FAM6_ICELAKE_MOBILE 0x7E
|
||||
#define INTEL_FAM6_ICELAKE_NNPI 0x9D
|
||||
|
||||
/* "Small Core" Processors (Atom) */
|
||||
|
||||
|
||||
@ -651,8 +651,7 @@ void cacheinfo_amd_init_llc_id(struct cpuinfo_x86 *c, int cpu, u8 node_id)
|
||||
if (c->x86 < 0x17) {
|
||||
/* LLC is at the node level. */
|
||||
per_cpu(cpu_llc_id, cpu) = node_id;
|
||||
} else if (c->x86 == 0x17 &&
|
||||
c->x86_model >= 0 && c->x86_model <= 0x1F) {
|
||||
} else if (c->x86 == 0x17 && c->x86_model <= 0x1F) {
|
||||
/*
|
||||
* LLC is at the core complex level.
|
||||
* Core complex ID is ApicId[3] for these processors.
|
||||
|
||||
@ -4,6 +4,8 @@
|
||||
# Generate the x86_cap/bug_flags[] arrays from include/asm/cpufeatures.h
|
||||
#
|
||||
|
||||
set -e
|
||||
|
||||
IN=$1
|
||||
OUT=$2
|
||||
|
||||
|
||||
@ -547,17 +547,15 @@ void __init default_get_smp_config(unsigned int early)
|
||||
* local APIC has default address
|
||||
*/
|
||||
mp_lapic_addr = APIC_DEFAULT_PHYS_BASE;
|
||||
return;
|
||||
goto out;
|
||||
}
|
||||
|
||||
pr_info("Default MP configuration #%d\n", mpf->feature1);
|
||||
construct_default_ISA_mptable(mpf->feature1);
|
||||
|
||||
} else if (mpf->physptr) {
|
||||
if (check_physptr(mpf, early)) {
|
||||
early_memunmap(mpf, sizeof(*mpf));
|
||||
return;
|
||||
}
|
||||
if (check_physptr(mpf, early))
|
||||
goto out;
|
||||
} else
|
||||
BUG();
|
||||
|
||||
@ -566,7 +564,7 @@ void __init default_get_smp_config(unsigned int early)
|
||||
/*
|
||||
* Only use the first configuration found.
|
||||
*/
|
||||
|
||||
out:
|
||||
early_memunmap(mpf, sizeof(*mpf));
|
||||
}
|
||||
|
||||
|
||||
@ -131,8 +131,8 @@ static void pmc_reprogram_counter(struct kvm_pmc *pmc, u32 type,
|
||||
intr ? kvm_perf_overflow_intr :
|
||||
kvm_perf_overflow, pmc);
|
||||
if (IS_ERR(event)) {
|
||||
printk_once("kvm_pmu: event creation failed %ld\n",
|
||||
PTR_ERR(event));
|
||||
pr_debug_ratelimited("kvm_pmu: event creation failed %ld for pmc->idx = %d\n",
|
||||
PTR_ERR(event), pmc->idx);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@ -1016,8 +1016,12 @@ static int blkcg_print_stat(struct seq_file *sf, void *v)
|
||||
}
|
||||
next:
|
||||
if (has_stats) {
|
||||
off += scnprintf(buf+off, size-off, "\n");
|
||||
seq_commit(sf, off);
|
||||
if (off < size - 1) {
|
||||
off += scnprintf(buf+off, size-off, "\n");
|
||||
seq_commit(sf, off);
|
||||
} else {
|
||||
seq_commit(sf, -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -567,6 +567,10 @@ static void blkcg_iolatency_done_bio(struct rq_qos *rqos, struct bio *bio)
|
||||
if (!blkg)
|
||||
return;
|
||||
|
||||
/* We didn't actually submit this bio, don't account it. */
|
||||
if (bio->bi_status == BLK_STS_AGAIN)
|
||||
return;
|
||||
|
||||
iolat = blkg_to_lat(bio->bi_blkg);
|
||||
if (!iolat)
|
||||
return;
|
||||
@ -744,8 +748,10 @@ static int iolatency_set_min_lat_nsec(struct blkcg_gq *blkg, u64 val)
|
||||
|
||||
if (!oldval && val)
|
||||
return 1;
|
||||
if (oldval && !val)
|
||||
if (oldval && !val) {
|
||||
blkcg_clear_delay(blkg);
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -892,13 +892,10 @@ static bool tg_with_in_iops_limit(struct throtl_grp *tg, struct bio *bio,
|
||||
unsigned long jiffy_elapsed, jiffy_wait, jiffy_elapsed_rnd;
|
||||
u64 tmp;
|
||||
|
||||
jiffy_elapsed = jiffy_elapsed_rnd = jiffies - tg->slice_start[rw];
|
||||
jiffy_elapsed = jiffies - tg->slice_start[rw];
|
||||
|
||||
/* Slice has just started. Consider one slice interval */
|
||||
if (!jiffy_elapsed)
|
||||
jiffy_elapsed_rnd = tg->td->throtl_slice;
|
||||
|
||||
jiffy_elapsed_rnd = roundup(jiffy_elapsed_rnd, tg->td->throtl_slice);
|
||||
/* Round up to the next throttle slice, wait time must be nonzero */
|
||||
jiffy_elapsed_rnd = roundup(jiffy_elapsed + 1, tg->td->throtl_slice);
|
||||
|
||||
/*
|
||||
* jiffy_elapsed_rnd should not be a big value as minimum iops can be
|
||||
|
||||
@ -15,6 +15,7 @@ config ASYMMETRIC_PUBLIC_KEY_SUBTYPE
|
||||
select MPILIB
|
||||
select CRYPTO_HASH_INFO
|
||||
select CRYPTO_AKCIPHER
|
||||
select CRYPTO_HASH
|
||||
help
|
||||
This option provides support for asymmetric public key type handling.
|
||||
If signature generation and/or verification are to be used,
|
||||
@ -34,6 +35,7 @@ config X509_CERTIFICATE_PARSER
|
||||
config PKCS7_MESSAGE_PARSER
|
||||
tristate "PKCS#7 message parser"
|
||||
depends on X509_CERTIFICATE_PARSER
|
||||
select CRYPTO_HASH
|
||||
select ASN1
|
||||
select OID_REGISTRY
|
||||
help
|
||||
@ -56,6 +58,7 @@ config SIGNED_PE_FILE_VERIFICATION
|
||||
bool "Support for PE file signature verification"
|
||||
depends on PKCS7_MESSAGE_PARSER=y
|
||||
depends on SYSTEM_DATA_VERIFICATION
|
||||
select CRYPTO_HASH
|
||||
select ASN1
|
||||
select OID_REGISTRY
|
||||
help
|
||||
|
||||
@ -67,6 +67,8 @@ struct chachapoly_req_ctx {
|
||||
unsigned int cryptlen;
|
||||
/* Actual AD, excluding IV */
|
||||
unsigned int assoclen;
|
||||
/* request flags, with MAY_SLEEP cleared if needed */
|
||||
u32 flags;
|
||||
union {
|
||||
struct poly_req poly;
|
||||
struct chacha_req chacha;
|
||||
@ -76,8 +78,12 @@ struct chachapoly_req_ctx {
|
||||
static inline void async_done_continue(struct aead_request *req, int err,
|
||||
int (*cont)(struct aead_request *))
|
||||
{
|
||||
if (!err)
|
||||
if (!err) {
|
||||
struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
|
||||
|
||||
rctx->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
|
||||
err = cont(req);
|
||||
}
|
||||
|
||||
if (err != -EINPROGRESS && err != -EBUSY)
|
||||
aead_request_complete(req, err);
|
||||
@ -144,7 +150,7 @@ static int chacha_decrypt(struct aead_request *req)
|
||||
dst = scatterwalk_ffwd(rctx->dst, req->dst, req->assoclen);
|
||||
}
|
||||
|
||||
skcipher_request_set_callback(&creq->req, aead_request_flags(req),
|
||||
skcipher_request_set_callback(&creq->req, rctx->flags,
|
||||
chacha_decrypt_done, req);
|
||||
skcipher_request_set_tfm(&creq->req, ctx->chacha);
|
||||
skcipher_request_set_crypt(&creq->req, src, dst,
|
||||
@ -188,7 +194,7 @@ static int poly_tail(struct aead_request *req)
|
||||
memcpy(&preq->tail.cryptlen, &len, sizeof(len));
|
||||
sg_set_buf(preq->src, &preq->tail, sizeof(preq->tail));
|
||||
|
||||
ahash_request_set_callback(&preq->req, aead_request_flags(req),
|
||||
ahash_request_set_callback(&preq->req, rctx->flags,
|
||||
poly_tail_done, req);
|
||||
ahash_request_set_tfm(&preq->req, ctx->poly);
|
||||
ahash_request_set_crypt(&preq->req, preq->src,
|
||||
@ -219,7 +225,7 @@ static int poly_cipherpad(struct aead_request *req)
|
||||
sg_init_table(preq->src, 1);
|
||||
sg_set_buf(preq->src, &preq->pad, padlen);
|
||||
|
||||
ahash_request_set_callback(&preq->req, aead_request_flags(req),
|
||||
ahash_request_set_callback(&preq->req, rctx->flags,
|
||||
poly_cipherpad_done, req);
|
||||
ahash_request_set_tfm(&preq->req, ctx->poly);
|
||||
ahash_request_set_crypt(&preq->req, preq->src, NULL, padlen);
|
||||
@ -250,7 +256,7 @@ static int poly_cipher(struct aead_request *req)
|
||||
sg_init_table(rctx->src, 2);
|
||||
crypt = scatterwalk_ffwd(rctx->src, crypt, req->assoclen);
|
||||
|
||||
ahash_request_set_callback(&preq->req, aead_request_flags(req),
|
||||
ahash_request_set_callback(&preq->req, rctx->flags,
|
||||
poly_cipher_done, req);
|
||||
ahash_request_set_tfm(&preq->req, ctx->poly);
|
||||
ahash_request_set_crypt(&preq->req, crypt, NULL, rctx->cryptlen);
|
||||
@ -280,7 +286,7 @@ static int poly_adpad(struct aead_request *req)
|
||||
sg_init_table(preq->src, 1);
|
||||
sg_set_buf(preq->src, preq->pad, padlen);
|
||||
|
||||
ahash_request_set_callback(&preq->req, aead_request_flags(req),
|
||||
ahash_request_set_callback(&preq->req, rctx->flags,
|
||||
poly_adpad_done, req);
|
||||
ahash_request_set_tfm(&preq->req, ctx->poly);
|
||||
ahash_request_set_crypt(&preq->req, preq->src, NULL, padlen);
|
||||
@ -304,7 +310,7 @@ static int poly_ad(struct aead_request *req)
|
||||
struct poly_req *preq = &rctx->u.poly;
|
||||
int err;
|
||||
|
||||
ahash_request_set_callback(&preq->req, aead_request_flags(req),
|
||||
ahash_request_set_callback(&preq->req, rctx->flags,
|
||||
poly_ad_done, req);
|
||||
ahash_request_set_tfm(&preq->req, ctx->poly);
|
||||
ahash_request_set_crypt(&preq->req, req->src, NULL, rctx->assoclen);
|
||||
@ -331,7 +337,7 @@ static int poly_setkey(struct aead_request *req)
|
||||
sg_init_table(preq->src, 1);
|
||||
sg_set_buf(preq->src, rctx->key, sizeof(rctx->key));
|
||||
|
||||
ahash_request_set_callback(&preq->req, aead_request_flags(req),
|
||||
ahash_request_set_callback(&preq->req, rctx->flags,
|
||||
poly_setkey_done, req);
|
||||
ahash_request_set_tfm(&preq->req, ctx->poly);
|
||||
ahash_request_set_crypt(&preq->req, preq->src, NULL, sizeof(rctx->key));
|
||||
@ -355,7 +361,7 @@ static int poly_init(struct aead_request *req)
|
||||
struct poly_req *preq = &rctx->u.poly;
|
||||
int err;
|
||||
|
||||
ahash_request_set_callback(&preq->req, aead_request_flags(req),
|
||||
ahash_request_set_callback(&preq->req, rctx->flags,
|
||||
poly_init_done, req);
|
||||
ahash_request_set_tfm(&preq->req, ctx->poly);
|
||||
|
||||
@ -393,7 +399,7 @@ static int poly_genkey(struct aead_request *req)
|
||||
|
||||
chacha_iv(creq->iv, req, 0);
|
||||
|
||||
skcipher_request_set_callback(&creq->req, aead_request_flags(req),
|
||||
skcipher_request_set_callback(&creq->req, rctx->flags,
|
||||
poly_genkey_done, req);
|
||||
skcipher_request_set_tfm(&creq->req, ctx->chacha);
|
||||
skcipher_request_set_crypt(&creq->req, creq->src, creq->src,
|
||||
@ -433,7 +439,7 @@ static int chacha_encrypt(struct aead_request *req)
|
||||
dst = scatterwalk_ffwd(rctx->dst, req->dst, req->assoclen);
|
||||
}
|
||||
|
||||
skcipher_request_set_callback(&creq->req, aead_request_flags(req),
|
||||
skcipher_request_set_callback(&creq->req, rctx->flags,
|
||||
chacha_encrypt_done, req);
|
||||
skcipher_request_set_tfm(&creq->req, ctx->chacha);
|
||||
skcipher_request_set_crypt(&creq->req, src, dst,
|
||||
@ -451,6 +457,7 @@ static int chachapoly_encrypt(struct aead_request *req)
|
||||
struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
|
||||
|
||||
rctx->cryptlen = req->cryptlen;
|
||||
rctx->flags = aead_request_flags(req);
|
||||
|
||||
/* encrypt call chain:
|
||||
* - chacha_encrypt/done()
|
||||
@ -472,6 +479,7 @@ static int chachapoly_decrypt(struct aead_request *req)
|
||||
struct chachapoly_req_ctx *rctx = aead_request_ctx(req);
|
||||
|
||||
rctx->cryptlen = req->cryptlen - POLY1305_DIGEST_SIZE;
|
||||
rctx->flags = aead_request_flags(req);
|
||||
|
||||
/* decrypt call chain:
|
||||
* - poly_genkey/done()
|
||||
|
||||
@ -34,6 +34,7 @@ static int ghash_setkey(struct crypto_shash *tfm,
|
||||
const u8 *key, unsigned int keylen)
|
||||
{
|
||||
struct ghash_ctx *ctx = crypto_shash_ctx(tfm);
|
||||
be128 k;
|
||||
|
||||
if (keylen != GHASH_BLOCK_SIZE) {
|
||||
crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
|
||||
@ -42,7 +43,12 @@ static int ghash_setkey(struct crypto_shash *tfm,
|
||||
|
||||
if (ctx->gf128)
|
||||
gf128mul_free_4k(ctx->gf128);
|
||||
ctx->gf128 = gf128mul_init_4k_lle((be128 *)key);
|
||||
|
||||
BUILD_BUG_ON(sizeof(k) != GHASH_BLOCK_SIZE);
|
||||
memcpy(&k, key, GHASH_BLOCK_SIZE); /* avoid violating alignment rules */
|
||||
ctx->gf128 = gf128mul_init_4k_lle(&k);
|
||||
memzero_explicit(&k, GHASH_BLOCK_SIZE);
|
||||
|
||||
if (!ctx->gf128)
|
||||
return -ENOMEM;
|
||||
|
||||
|
||||
@ -229,7 +229,13 @@
|
||||
x4 ^= x2; \
|
||||
})
|
||||
|
||||
static void __serpent_setkey_sbox(u32 r0, u32 r1, u32 r2, u32 r3, u32 r4, u32 *k)
|
||||
/*
|
||||
* both gcc and clang have misoptimized this function in the past,
|
||||
* producing horrible object code from spilling temporary variables
|
||||
* on the stack. Forcing this part out of line avoids that.
|
||||
*/
|
||||
static noinline void __serpent_setkey_sbox(u32 r0, u32 r1, u32 r2,
|
||||
u32 r3, u32 r4, u32 *k)
|
||||
{
|
||||
k += 100;
|
||||
S3(r3, r4, r0, r1, r2); store_and_load_keys(r1, r2, r4, r3, 28, 24);
|
||||
|
||||
@ -69,7 +69,8 @@ acpi_status
|
||||
acpi_ev_mask_gpe(struct acpi_gpe_event_info *gpe_event_info, u8 is_masked);
|
||||
|
||||
acpi_status
|
||||
acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info);
|
||||
acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info,
|
||||
u8 clear_on_enable);
|
||||
|
||||
acpi_status
|
||||
acpi_ev_remove_gpe_reference(struct acpi_gpe_event_info *gpe_event_info);
|
||||
|
||||
@ -146,6 +146,7 @@ acpi_ev_mask_gpe(struct acpi_gpe_event_info *gpe_event_info, u8 is_masked)
|
||||
* FUNCTION: acpi_ev_add_gpe_reference
|
||||
*
|
||||
* PARAMETERS: gpe_event_info - Add a reference to this GPE
|
||||
* clear_on_enable - Clear GPE status before enabling it
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
@ -155,7 +156,8 @@ acpi_ev_mask_gpe(struct acpi_gpe_event_info *gpe_event_info, u8 is_masked)
|
||||
******************************************************************************/
|
||||
|
||||
acpi_status
|
||||
acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
|
||||
acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info,
|
||||
u8 clear_on_enable)
|
||||
{
|
||||
acpi_status status = AE_OK;
|
||||
|
||||
@ -170,6 +172,10 @@ acpi_ev_add_gpe_reference(struct acpi_gpe_event_info *gpe_event_info)
|
||||
|
||||
/* Enable on first reference */
|
||||
|
||||
if (clear_on_enable) {
|
||||
(void)acpi_hw_clear_gpe(gpe_event_info);
|
||||
}
|
||||
|
||||
status = acpi_ev_update_gpe_enable_mask(gpe_event_info);
|
||||
if (ACPI_SUCCESS(status)) {
|
||||
status = acpi_ev_enable_gpe(gpe_event_info);
|
||||
|
||||
@ -453,7 +453,7 @@ acpi_ev_initialize_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
|
||||
continue;
|
||||
}
|
||||
|
||||
status = acpi_ev_add_gpe_reference(gpe_event_info);
|
||||
status = acpi_ev_add_gpe_reference(gpe_event_info, FALSE);
|
||||
if (ACPI_FAILURE(status)) {
|
||||
ACPI_EXCEPTION((AE_INFO, status,
|
||||
"Could not enable GPE 0x%02X",
|
||||
|
||||
@ -971,7 +971,7 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
|
||||
ACPI_GPE_DISPATCH_METHOD) ||
|
||||
(ACPI_GPE_DISPATCH_TYPE(handler->original_flags) ==
|
||||
ACPI_GPE_DISPATCH_NOTIFY)) && handler->originally_enabled) {
|
||||
(void)acpi_ev_add_gpe_reference(gpe_event_info);
|
||||
(void)acpi_ev_add_gpe_reference(gpe_event_info, FALSE);
|
||||
if (ACPI_GPE_IS_POLLING_NEEDED(gpe_event_info)) {
|
||||
|
||||
/* Poll edge triggered GPEs to handle existing events */
|
||||
|
||||
@ -108,7 +108,7 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
|
||||
if (gpe_event_info) {
|
||||
if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
|
||||
ACPI_GPE_DISPATCH_NONE) {
|
||||
status = acpi_ev_add_gpe_reference(gpe_event_info);
|
||||
status = acpi_ev_add_gpe_reference(gpe_event_info, TRUE);
|
||||
if (ACPI_SUCCESS(status) &&
|
||||
ACPI_GPE_IS_POLLING_NEEDED(gpe_event_info)) {
|
||||
|
||||
|
||||
@ -1490,7 +1490,7 @@ static int ata_eh_read_log_10h(struct ata_device *dev,
|
||||
tf->hob_lbah = buf[10];
|
||||
tf->nsect = buf[12];
|
||||
tf->hob_nsect = buf[13];
|
||||
if (ata_id_has_ncq_autosense(dev->id))
|
||||
if (dev->class == ATA_DEV_ZAC && ata_id_has_ncq_autosense(dev->id))
|
||||
tf->auxiliary = buf[14] << 16 | buf[15] << 8 | buf[16];
|
||||
|
||||
return 0;
|
||||
@ -1737,7 +1737,8 @@ void ata_eh_analyze_ncq_error(struct ata_link *link)
|
||||
memcpy(&qc->result_tf, &tf, sizeof(tf));
|
||||
qc->result_tf.flags = ATA_TFLAG_ISADDR | ATA_TFLAG_LBA | ATA_TFLAG_LBA48;
|
||||
qc->err_mask |= AC_ERR_DEV | AC_ERR_NCQ;
|
||||
if ((qc->result_tf.command & ATA_SENSE) || qc->result_tf.auxiliary) {
|
||||
if (dev->class == ATA_DEV_ZAC &&
|
||||
((qc->result_tf.command & ATA_SENSE) || qc->result_tf.auxiliary)) {
|
||||
char sense_key, asc, ascq;
|
||||
|
||||
sense_key = (qc->result_tf.auxiliary >> 16) & 0xff;
|
||||
@ -1791,10 +1792,11 @@ static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc,
|
||||
}
|
||||
|
||||
switch (qc->dev->class) {
|
||||
case ATA_DEV_ATA:
|
||||
case ATA_DEV_ZAC:
|
||||
if (stat & ATA_SENSE)
|
||||
ata_eh_request_sense(qc, qc->scsicmd);
|
||||
/* fall through */
|
||||
case ATA_DEV_ATA:
|
||||
if (err & ATA_ICRC)
|
||||
qc->err_mask |= AC_ERR_ATA_BUS;
|
||||
if (err & (ATA_UNC | ATA_AMNF))
|
||||
|
||||
@ -575,6 +575,8 @@ void regmap_debugfs_init(struct regmap *map, const char *name)
|
||||
}
|
||||
|
||||
if (!strcmp(name, "dummy")) {
|
||||
kfree(map->debugfs_name);
|
||||
|
||||
map->debugfs_name = kasprintf(GFP_KERNEL, "dummy%d",
|
||||
dummy_index);
|
||||
name = map->debugfs_name;
|
||||
|
||||
@ -1618,6 +1618,8 @@ static int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
|
||||
map->format.reg_bytes +
|
||||
map->format.pad_bytes,
|
||||
val, val_len);
|
||||
else
|
||||
ret = -ENOTSUPP;
|
||||
|
||||
/* If that didn't work fall back on linearising by hand. */
|
||||
if (ret == -ENOTSUPP) {
|
||||
|
||||
@ -2119,6 +2119,9 @@ static void setup_format_params(int track)
|
||||
raw_cmd->kernel_data = floppy_track_buffer;
|
||||
raw_cmd->length = 4 * F_SECT_PER_TRACK;
|
||||
|
||||
if (!F_SECT_PER_TRACK)
|
||||
return;
|
||||
|
||||
/* allow for about 30ms for data transport per track */
|
||||
head_shift = (F_SECT_PER_TRACK + 5) / 6;
|
||||
|
||||
@ -3241,8 +3244,12 @@ static int set_geometry(unsigned int cmd, struct floppy_struct *g,
|
||||
int cnt;
|
||||
|
||||
/* sanity checking for parameters. */
|
||||
if (g->sect <= 0 ||
|
||||
g->head <= 0 ||
|
||||
if ((int)g->sect <= 0 ||
|
||||
(int)g->head <= 0 ||
|
||||
/* check for overflow in max_sector */
|
||||
(int)(g->sect * g->head) <= 0 ||
|
||||
/* check for zero in F_SECT_PER_TRACK */
|
||||
(unsigned char)((g->sect << 2) >> FD_SIZECODE(g)) == 0 ||
|
||||
g->track <= 0 || g->track > UDP->tracks >> STRETCH(g) ||
|
||||
/* check if reserved bits are set */
|
||||
(g->stretch & ~(FD_STRETCH | FD_SWAPSIDES | FD_SECTBASEMASK)) != 0)
|
||||
@ -3386,6 +3393,24 @@ static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool valid_floppy_drive_params(const short autodetect[8],
|
||||
int native_format)
|
||||
{
|
||||
size_t floppy_type_size = ARRAY_SIZE(floppy_type);
|
||||
size_t i = 0;
|
||||
|
||||
for (i = 0; i < 8; ++i) {
|
||||
if (autodetect[i] < 0 ||
|
||||
autodetect[i] >= floppy_type_size)
|
||||
return false;
|
||||
}
|
||||
|
||||
if (native_format < 0 || native_format >= floppy_type_size)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
|
||||
unsigned long param)
|
||||
{
|
||||
@ -3512,6 +3537,9 @@ static int fd_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int
|
||||
SUPBOUND(size, strlen((const char *)outparam) + 1);
|
||||
break;
|
||||
case FDSETDRVPRM:
|
||||
if (!valid_floppy_drive_params(inparam.dp.autodetect,
|
||||
inparam.dp.native_format))
|
||||
return -EINVAL;
|
||||
*UDP = inparam.dp;
|
||||
break;
|
||||
case FDGETDRVPRM:
|
||||
@ -3709,6 +3737,8 @@ static int compat_setdrvprm(int drive,
|
||||
return -EPERM;
|
||||
if (copy_from_user(&v, arg, sizeof(struct compat_floppy_drive_params)))
|
||||
return -EFAULT;
|
||||
if (!valid_floppy_drive_params(v.autodetect, v.native_format))
|
||||
return -EINVAL;
|
||||
mutex_lock(&floppy_mutex);
|
||||
UDP->cmos = v.cmos;
|
||||
UDP->max_dtr = v.max_dtr;
|
||||
|
||||
@ -321,11 +321,12 @@ static ssize_t nullb_device_power_store(struct config_item *item,
|
||||
set_bit(NULLB_DEV_FL_CONFIGURED, &dev->flags);
|
||||
dev->power = newp;
|
||||
} else if (dev->power && !newp) {
|
||||
mutex_lock(&lock);
|
||||
dev->power = newp;
|
||||
null_del_dev(dev->nullb);
|
||||
mutex_unlock(&lock);
|
||||
clear_bit(NULLB_DEV_FL_UP, &dev->flags);
|
||||
if (test_and_clear_bit(NULLB_DEV_FL_UP, &dev->flags)) {
|
||||
mutex_lock(&lock);
|
||||
dev->power = newp;
|
||||
null_del_dev(dev->nullb);
|
||||
mutex_unlock(&lock);
|
||||
}
|
||||
clear_bit(NULLB_DEV_FL_CONFIGURED, &dev->flags);
|
||||
}
|
||||
|
||||
|
||||
@ -277,7 +277,9 @@ static const struct usb_device_id blacklist_table[] = {
|
||||
{ USB_DEVICE(0x04ca, 0x3015), .driver_info = BTUSB_QCA_ROME },
|
||||
{ USB_DEVICE(0x04ca, 0x3016), .driver_info = BTUSB_QCA_ROME },
|
||||
{ USB_DEVICE(0x04ca, 0x301a), .driver_info = BTUSB_QCA_ROME },
|
||||
{ USB_DEVICE(0x13d3, 0x3491), .driver_info = BTUSB_QCA_ROME },
|
||||
{ USB_DEVICE(0x13d3, 0x3496), .driver_info = BTUSB_QCA_ROME },
|
||||
{ USB_DEVICE(0x13d3, 0x3501), .driver_info = BTUSB_QCA_ROME },
|
||||
|
||||
/* Broadcom BCM2035 */
|
||||
{ USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
|
||||
|
||||
@ -759,6 +759,11 @@ static int bcsp_close(struct hci_uart *hu)
|
||||
skb_queue_purge(&bcsp->rel);
|
||||
skb_queue_purge(&bcsp->unrel);
|
||||
|
||||
if (bcsp->rx_skb) {
|
||||
kfree_skb(bcsp->rx_skb);
|
||||
bcsp->rx_skb = NULL;
|
||||
}
|
||||
|
||||
kfree(bcsp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -211,7 +211,7 @@ static void exynos4_frc_resume(struct clocksource *cs)
|
||||
|
||||
static struct clocksource mct_frc = {
|
||||
.name = "mct-frc",
|
||||
.rating = 400,
|
||||
.rating = 450, /* use value higher than ARM arch timer */
|
||||
.read = exynos4_frc_read,
|
||||
.mask = CLOCKSOURCE_MASK(32),
|
||||
.flags = CLOCK_SOURCE_IS_CONTINUOUS,
|
||||
@ -466,7 +466,7 @@ static int exynos4_mct_starting_cpu(unsigned int cpu)
|
||||
evt->set_state_oneshot_stopped = set_state_shutdown;
|
||||
evt->tick_resume = set_state_shutdown;
|
||||
evt->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
|
||||
evt->rating = 450;
|
||||
evt->rating = 500; /* use value higher than ARM arch timer */
|
||||
|
||||
exynos4_mct_write(TICK_BASE_CNT, mevt->base + MCT_L_TCNTB_OFFSET);
|
||||
|
||||
|
||||
@ -76,12 +76,16 @@ static void set_dynamic_sa_command_1(struct dynamic_sa_ctl *sa, u32 cm,
|
||||
}
|
||||
|
||||
static inline int crypto4xx_crypt(struct skcipher_request *req,
|
||||
const unsigned int ivlen, bool decrypt)
|
||||
const unsigned int ivlen, bool decrypt,
|
||||
bool check_blocksize)
|
||||
{
|
||||
struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(req);
|
||||
struct crypto4xx_ctx *ctx = crypto_skcipher_ctx(cipher);
|
||||
__le32 iv[AES_IV_SIZE];
|
||||
|
||||
if (check_blocksize && !IS_ALIGNED(req->cryptlen, AES_BLOCK_SIZE))
|
||||
return -EINVAL;
|
||||
|
||||
if (ivlen)
|
||||
crypto4xx_memcpy_to_le32(iv, req->iv, ivlen);
|
||||
|
||||
@ -90,24 +94,34 @@ static inline int crypto4xx_crypt(struct skcipher_request *req,
|
||||
ctx->sa_len, 0, NULL);
|
||||
}
|
||||
|
||||
int crypto4xx_encrypt_noiv(struct skcipher_request *req)
|
||||
int crypto4xx_encrypt_noiv_block(struct skcipher_request *req)
|
||||
{
|
||||
return crypto4xx_crypt(req, 0, false);
|
||||
return crypto4xx_crypt(req, 0, false, true);
|
||||
}
|
||||
|
||||
int crypto4xx_encrypt_iv(struct skcipher_request *req)
|
||||
int crypto4xx_encrypt_iv_stream(struct skcipher_request *req)
|
||||
{
|
||||
return crypto4xx_crypt(req, AES_IV_SIZE, false);
|
||||
return crypto4xx_crypt(req, AES_IV_SIZE, false, false);
|
||||
}
|
||||
|
||||
int crypto4xx_decrypt_noiv(struct skcipher_request *req)
|
||||
int crypto4xx_decrypt_noiv_block(struct skcipher_request *req)
|
||||
{
|
||||
return crypto4xx_crypt(req, 0, true);
|
||||
return crypto4xx_crypt(req, 0, true, true);
|
||||
}
|
||||
|
||||
int crypto4xx_decrypt_iv(struct skcipher_request *req)
|
||||
int crypto4xx_decrypt_iv_stream(struct skcipher_request *req)
|
||||
{
|
||||
return crypto4xx_crypt(req, AES_IV_SIZE, true);
|
||||
return crypto4xx_crypt(req, AES_IV_SIZE, true, false);
|
||||
}
|
||||
|
||||
int crypto4xx_encrypt_iv_block(struct skcipher_request *req)
|
||||
{
|
||||
return crypto4xx_crypt(req, AES_IV_SIZE, false, true);
|
||||
}
|
||||
|
||||
int crypto4xx_decrypt_iv_block(struct skcipher_request *req)
|
||||
{
|
||||
return crypto4xx_crypt(req, AES_IV_SIZE, true, true);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -278,8 +292,8 @@ crypto4xx_ctr_crypt(struct skcipher_request *req, bool encrypt)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return encrypt ? crypto4xx_encrypt_iv(req)
|
||||
: crypto4xx_decrypt_iv(req);
|
||||
return encrypt ? crypto4xx_encrypt_iv_stream(req)
|
||||
: crypto4xx_decrypt_iv_stream(req);
|
||||
}
|
||||
|
||||
static int crypto4xx_sk_setup_fallback(struct crypto4xx_ctx *ctx,
|
||||
|
||||
@ -1153,8 +1153,8 @@ static struct crypto4xx_alg_common crypto4xx_alg[] = {
|
||||
.max_keysize = AES_MAX_KEY_SIZE,
|
||||
.ivsize = AES_IV_SIZE,
|
||||
.setkey = crypto4xx_setkey_aes_cbc,
|
||||
.encrypt = crypto4xx_encrypt_iv,
|
||||
.decrypt = crypto4xx_decrypt_iv,
|
||||
.encrypt = crypto4xx_encrypt_iv_block,
|
||||
.decrypt = crypto4xx_decrypt_iv_block,
|
||||
.init = crypto4xx_sk_init,
|
||||
.exit = crypto4xx_sk_exit,
|
||||
} },
|
||||
@ -1173,8 +1173,8 @@ static struct crypto4xx_alg_common crypto4xx_alg[] = {
|
||||
.max_keysize = AES_MAX_KEY_SIZE,
|
||||
.ivsize = AES_IV_SIZE,
|
||||
.setkey = crypto4xx_setkey_aes_cfb,
|
||||
.encrypt = crypto4xx_encrypt_iv,
|
||||
.decrypt = crypto4xx_decrypt_iv,
|
||||
.encrypt = crypto4xx_encrypt_iv_stream,
|
||||
.decrypt = crypto4xx_decrypt_iv_stream,
|
||||
.init = crypto4xx_sk_init,
|
||||
.exit = crypto4xx_sk_exit,
|
||||
} },
|
||||
@ -1186,7 +1186,7 @@ static struct crypto4xx_alg_common crypto4xx_alg[] = {
|
||||
.cra_flags = CRYPTO_ALG_NEED_FALLBACK |
|
||||
CRYPTO_ALG_ASYNC |
|
||||
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
||||
.cra_blocksize = AES_BLOCK_SIZE,
|
||||
.cra_blocksize = 1,
|
||||
.cra_ctxsize = sizeof(struct crypto4xx_ctx),
|
||||
.cra_module = THIS_MODULE,
|
||||
},
|
||||
@ -1206,7 +1206,7 @@ static struct crypto4xx_alg_common crypto4xx_alg[] = {
|
||||
.cra_priority = CRYPTO4XX_CRYPTO_PRIORITY,
|
||||
.cra_flags = CRYPTO_ALG_ASYNC |
|
||||
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
||||
.cra_blocksize = AES_BLOCK_SIZE,
|
||||
.cra_blocksize = 1,
|
||||
.cra_ctxsize = sizeof(struct crypto4xx_ctx),
|
||||
.cra_module = THIS_MODULE,
|
||||
},
|
||||
@ -1226,15 +1226,15 @@ static struct crypto4xx_alg_common crypto4xx_alg[] = {
|
||||
.cra_priority = CRYPTO4XX_CRYPTO_PRIORITY,
|
||||
.cra_flags = CRYPTO_ALG_ASYNC |
|
||||
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
||||
.cra_blocksize = AES_BLOCK_SIZE,
|
||||
.cra_blocksize = 1,
|
||||
.cra_ctxsize = sizeof(struct crypto4xx_ctx),
|
||||
.cra_module = THIS_MODULE,
|
||||
},
|
||||
.min_keysize = AES_MIN_KEY_SIZE,
|
||||
.max_keysize = AES_MAX_KEY_SIZE,
|
||||
.setkey = crypto4xx_setkey_aes_ecb,
|
||||
.encrypt = crypto4xx_encrypt_noiv,
|
||||
.decrypt = crypto4xx_decrypt_noiv,
|
||||
.encrypt = crypto4xx_encrypt_noiv_block,
|
||||
.decrypt = crypto4xx_decrypt_noiv_block,
|
||||
.init = crypto4xx_sk_init,
|
||||
.exit = crypto4xx_sk_exit,
|
||||
} },
|
||||
@ -1245,7 +1245,7 @@ static struct crypto4xx_alg_common crypto4xx_alg[] = {
|
||||
.cra_priority = CRYPTO4XX_CRYPTO_PRIORITY,
|
||||
.cra_flags = CRYPTO_ALG_ASYNC |
|
||||
CRYPTO_ALG_KERN_DRIVER_ONLY,
|
||||
.cra_blocksize = AES_BLOCK_SIZE,
|
||||
.cra_blocksize = 1,
|
||||
.cra_ctxsize = sizeof(struct crypto4xx_ctx),
|
||||
.cra_module = THIS_MODULE,
|
||||
},
|
||||
@ -1253,8 +1253,8 @@ static struct crypto4xx_alg_common crypto4xx_alg[] = {
|
||||
.max_keysize = AES_MAX_KEY_SIZE,
|
||||
.ivsize = AES_IV_SIZE,
|
||||
.setkey = crypto4xx_setkey_aes_ofb,
|
||||
.encrypt = crypto4xx_encrypt_iv,
|
||||
.decrypt = crypto4xx_decrypt_iv,
|
||||
.encrypt = crypto4xx_encrypt_iv_stream,
|
||||
.decrypt = crypto4xx_decrypt_iv_stream,
|
||||
.init = crypto4xx_sk_init,
|
||||
.exit = crypto4xx_sk_exit,
|
||||
} },
|
||||
|
||||
@ -179,10 +179,12 @@ int crypto4xx_setkey_rfc3686(struct crypto_skcipher *cipher,
|
||||
const u8 *key, unsigned int keylen);
|
||||
int crypto4xx_encrypt_ctr(struct skcipher_request *req);
|
||||
int crypto4xx_decrypt_ctr(struct skcipher_request *req);
|
||||
int crypto4xx_encrypt_iv(struct skcipher_request *req);
|
||||
int crypto4xx_decrypt_iv(struct skcipher_request *req);
|
||||
int crypto4xx_encrypt_noiv(struct skcipher_request *req);
|
||||
int crypto4xx_decrypt_noiv(struct skcipher_request *req);
|
||||
int crypto4xx_encrypt_iv_stream(struct skcipher_request *req);
|
||||
int crypto4xx_decrypt_iv_stream(struct skcipher_request *req);
|
||||
int crypto4xx_encrypt_iv_block(struct skcipher_request *req);
|
||||
int crypto4xx_decrypt_iv_block(struct skcipher_request *req);
|
||||
int crypto4xx_encrypt_noiv_block(struct skcipher_request *req);
|
||||
int crypto4xx_decrypt_noiv_block(struct skcipher_request *req);
|
||||
int crypto4xx_rfc3686_encrypt(struct skcipher_request *req);
|
||||
int crypto4xx_rfc3686_decrypt(struct skcipher_request *req);
|
||||
int crypto4xx_sha1_alg_init(struct crypto_tfm *tfm);
|
||||
|
||||
@ -111,7 +111,6 @@ void ppc4xx_trng_probe(struct crypto4xx_core_device *core_dev)
|
||||
return;
|
||||
|
||||
err_out:
|
||||
of_node_put(trng);
|
||||
iounmap(dev->trng_base);
|
||||
kfree(rng);
|
||||
dev->trng_base = NULL;
|
||||
|
||||
@ -887,6 +887,7 @@ static void ablkcipher_encrypt_done(struct device *jrdev, u32 *desc, u32 err,
|
||||
struct ablkcipher_request *req = context;
|
||||
struct ablkcipher_edesc *edesc;
|
||||
struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req);
|
||||
struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher);
|
||||
int ivsize = crypto_ablkcipher_ivsize(ablkcipher);
|
||||
|
||||
#ifdef DEBUG
|
||||
@ -911,10 +912,11 @@ static void ablkcipher_encrypt_done(struct device *jrdev, u32 *desc, u32 err,
|
||||
|
||||
/*
|
||||
* The crypto API expects us to set the IV (req->info) to the last
|
||||
* ciphertext block. This is used e.g. by the CTS mode.
|
||||
* ciphertext block when running in CBC mode.
|
||||
*/
|
||||
scatterwalk_map_and_copy(req->info, req->dst, req->nbytes - ivsize,
|
||||
ivsize, 0);
|
||||
if ((ctx->cdata.algtype & OP_ALG_AAI_MASK) == OP_ALG_AAI_CBC)
|
||||
scatterwalk_map_and_copy(req->info, req->dst, req->nbytes -
|
||||
ivsize, ivsize, 0);
|
||||
|
||||
/* In case initial IV was generated, copy it in GIVCIPHER request */
|
||||
if (edesc->iv_dir == DMA_FROM_DEVICE) {
|
||||
@ -1651,10 +1653,11 @@ static int ablkcipher_decrypt(struct ablkcipher_request *req)
|
||||
|
||||
/*
|
||||
* The crypto API expects us to set the IV (req->info) to the last
|
||||
* ciphertext block.
|
||||
* ciphertext block when running in CBC mode.
|
||||
*/
|
||||
scatterwalk_map_and_copy(req->info, req->src, req->nbytes - ivsize,
|
||||
ivsize, 0);
|
||||
if ((ctx->cdata.algtype & OP_ALG_AAI_MASK) == OP_ALG_AAI_CBC)
|
||||
scatterwalk_map_and_copy(req->info, req->src, req->nbytes -
|
||||
ivsize, ivsize, 0);
|
||||
|
||||
/* Create and submit job descriptor*/
|
||||
init_ablkcipher_job(ctx->sh_desc_dec, ctx->sh_desc_dec_dma, edesc, req);
|
||||
|
||||
@ -35,56 +35,62 @@ struct ccp_tasklet_data {
|
||||
};
|
||||
|
||||
/* Human-readable error strings */
|
||||
#define CCP_MAX_ERROR_CODE 64
|
||||
static char *ccp_error_codes[] = {
|
||||
"",
|
||||
"ERR 01: ILLEGAL_ENGINE",
|
||||
"ERR 02: ILLEGAL_KEY_ID",
|
||||
"ERR 03: ILLEGAL_FUNCTION_TYPE",
|
||||
"ERR 04: ILLEGAL_FUNCTION_MODE",
|
||||
"ERR 05: ILLEGAL_FUNCTION_ENCRYPT",
|
||||
"ERR 06: ILLEGAL_FUNCTION_SIZE",
|
||||
"ERR 07: Zlib_MISSING_INIT_EOM",
|
||||
"ERR 08: ILLEGAL_FUNCTION_RSVD",
|
||||
"ERR 09: ILLEGAL_BUFFER_LENGTH",
|
||||
"ERR 10: VLSB_FAULT",
|
||||
"ERR 11: ILLEGAL_MEM_ADDR",
|
||||
"ERR 12: ILLEGAL_MEM_SEL",
|
||||
"ERR 13: ILLEGAL_CONTEXT_ID",
|
||||
"ERR 14: ILLEGAL_KEY_ADDR",
|
||||
"ERR 15: 0xF Reserved",
|
||||
"ERR 16: Zlib_ILLEGAL_MULTI_QUEUE",
|
||||
"ERR 17: Zlib_ILLEGAL_JOBID_CHANGE",
|
||||
"ERR 18: CMD_TIMEOUT",
|
||||
"ERR 19: IDMA0_AXI_SLVERR",
|
||||
"ERR 20: IDMA0_AXI_DECERR",
|
||||
"ERR 21: 0x15 Reserved",
|
||||
"ERR 22: IDMA1_AXI_SLAVE_FAULT",
|
||||
"ERR 23: IDMA1_AIXI_DECERR",
|
||||
"ERR 24: 0x18 Reserved",
|
||||
"ERR 25: ZLIBVHB_AXI_SLVERR",
|
||||
"ERR 26: ZLIBVHB_AXI_DECERR",
|
||||
"ERR 27: 0x1B Reserved",
|
||||
"ERR 27: ZLIB_UNEXPECTED_EOM",
|
||||
"ERR 27: ZLIB_EXTRA_DATA",
|
||||
"ERR 30: ZLIB_BTYPE",
|
||||
"ERR 31: ZLIB_UNDEFINED_SYMBOL",
|
||||
"ERR 32: ZLIB_UNDEFINED_DISTANCE_S",
|
||||
"ERR 33: ZLIB_CODE_LENGTH_SYMBOL",
|
||||
"ERR 34: ZLIB _VHB_ILLEGAL_FETCH",
|
||||
"ERR 35: ZLIB_UNCOMPRESSED_LEN",
|
||||
"ERR 36: ZLIB_LIMIT_REACHED",
|
||||
"ERR 37: ZLIB_CHECKSUM_MISMATCH0",
|
||||
"ERR 38: ODMA0_AXI_SLVERR",
|
||||
"ERR 39: ODMA0_AXI_DECERR",
|
||||
"ERR 40: 0x28 Reserved",
|
||||
"ERR 41: ODMA1_AXI_SLVERR",
|
||||
"ERR 42: ODMA1_AXI_DECERR",
|
||||
"ERR 43: LSB_PARITY_ERR",
|
||||
"ILLEGAL_ENGINE",
|
||||
"ILLEGAL_KEY_ID",
|
||||
"ILLEGAL_FUNCTION_TYPE",
|
||||
"ILLEGAL_FUNCTION_MODE",
|
||||
"ILLEGAL_FUNCTION_ENCRYPT",
|
||||
"ILLEGAL_FUNCTION_SIZE",
|
||||
"Zlib_MISSING_INIT_EOM",
|
||||
"ILLEGAL_FUNCTION_RSVD",
|
||||
"ILLEGAL_BUFFER_LENGTH",
|
||||
"VLSB_FAULT",
|
||||
"ILLEGAL_MEM_ADDR",
|
||||
"ILLEGAL_MEM_SEL",
|
||||
"ILLEGAL_CONTEXT_ID",
|
||||
"ILLEGAL_KEY_ADDR",
|
||||
"0xF Reserved",
|
||||
"Zlib_ILLEGAL_MULTI_QUEUE",
|
||||
"Zlib_ILLEGAL_JOBID_CHANGE",
|
||||
"CMD_TIMEOUT",
|
||||
"IDMA0_AXI_SLVERR",
|
||||
"IDMA0_AXI_DECERR",
|
||||
"0x15 Reserved",
|
||||
"IDMA1_AXI_SLAVE_FAULT",
|
||||
"IDMA1_AIXI_DECERR",
|
||||
"0x18 Reserved",
|
||||
"ZLIBVHB_AXI_SLVERR",
|
||||
"ZLIBVHB_AXI_DECERR",
|
||||
"0x1B Reserved",
|
||||
"ZLIB_UNEXPECTED_EOM",
|
||||
"ZLIB_EXTRA_DATA",
|
||||
"ZLIB_BTYPE",
|
||||
"ZLIB_UNDEFINED_SYMBOL",
|
||||
"ZLIB_UNDEFINED_DISTANCE_S",
|
||||
"ZLIB_CODE_LENGTH_SYMBOL",
|
||||
"ZLIB _VHB_ILLEGAL_FETCH",
|
||||
"ZLIB_UNCOMPRESSED_LEN",
|
||||
"ZLIB_LIMIT_REACHED",
|
||||
"ZLIB_CHECKSUM_MISMATCH0",
|
||||
"ODMA0_AXI_SLVERR",
|
||||
"ODMA0_AXI_DECERR",
|
||||
"0x28 Reserved",
|
||||
"ODMA1_AXI_SLVERR",
|
||||
"ODMA1_AXI_DECERR",
|
||||
};
|
||||
|
||||
void ccp_log_error(struct ccp_device *d, int e)
|
||||
void ccp_log_error(struct ccp_device *d, unsigned int e)
|
||||
{
|
||||
dev_err(d->dev, "CCP error: %s (0x%x)\n", ccp_error_codes[e], e);
|
||||
if (WARN_ON(e >= CCP_MAX_ERROR_CODE))
|
||||
return;
|
||||
|
||||
if (e < ARRAY_SIZE(ccp_error_codes))
|
||||
dev_err(d->dev, "CCP error %d: %s\n", e, ccp_error_codes[e]);
|
||||
else
|
||||
dev_err(d->dev, "CCP error %d: Unknown Error\n", e);
|
||||
}
|
||||
|
||||
/* List of CCPs, CCP count, read-write access lock, and access functions
|
||||
|
||||
@ -632,7 +632,7 @@ struct ccp5_desc {
|
||||
void ccp_add_device(struct ccp_device *ccp);
|
||||
void ccp_del_device(struct ccp_device *ccp);
|
||||
|
||||
extern void ccp_log_error(struct ccp_device *, int);
|
||||
extern void ccp_log_error(struct ccp_device *, unsigned int);
|
||||
|
||||
struct ccp_device *ccp_alloc_struct(struct sp_device *sp);
|
||||
bool ccp_queues_suspended(struct ccp_device *ccp);
|
||||
|
||||
@ -625,6 +625,7 @@ static int ccp_run_aes_gcm_cmd(struct ccp_cmd_queue *cmd_q,
|
||||
|
||||
unsigned long long *final;
|
||||
unsigned int dm_offset;
|
||||
unsigned int jobid;
|
||||
unsigned int ilen;
|
||||
bool in_place = true; /* Default value */
|
||||
int ret;
|
||||
@ -663,9 +664,11 @@ static int ccp_run_aes_gcm_cmd(struct ccp_cmd_queue *cmd_q,
|
||||
p_tag = scatterwalk_ffwd(sg_tag, p_inp, ilen);
|
||||
}
|
||||
|
||||
jobid = CCP_NEW_JOBID(cmd_q->ccp);
|
||||
|
||||
memset(&op, 0, sizeof(op));
|
||||
op.cmd_q = cmd_q;
|
||||
op.jobid = CCP_NEW_JOBID(cmd_q->ccp);
|
||||
op.jobid = jobid;
|
||||
op.sb_key = cmd_q->sb_key; /* Pre-allocated */
|
||||
op.sb_ctx = cmd_q->sb_ctx; /* Pre-allocated */
|
||||
op.init = 1;
|
||||
@ -816,6 +819,13 @@ static int ccp_run_aes_gcm_cmd(struct ccp_cmd_queue *cmd_q,
|
||||
final[0] = cpu_to_be64(aes->aad_len * 8);
|
||||
final[1] = cpu_to_be64(ilen * 8);
|
||||
|
||||
memset(&op, 0, sizeof(op));
|
||||
op.cmd_q = cmd_q;
|
||||
op.jobid = jobid;
|
||||
op.sb_key = cmd_q->sb_key; /* Pre-allocated */
|
||||
op.sb_ctx = cmd_q->sb_ctx; /* Pre-allocated */
|
||||
op.init = 1;
|
||||
op.u.aes.type = aes->type;
|
||||
op.u.aes.mode = CCP_AES_MODE_GHASH;
|
||||
op.u.aes.action = CCP_AES_GHASHFINAL;
|
||||
op.src.type = CCP_MEMTYPE_SYSTEM;
|
||||
@ -843,7 +853,8 @@ static int ccp_run_aes_gcm_cmd(struct ccp_cmd_queue *cmd_q,
|
||||
if (ret)
|
||||
goto e_tag;
|
||||
|
||||
ret = memcmp(tag.address, final_wa.address, AES_BLOCK_SIZE);
|
||||
ret = crypto_memneq(tag.address, final_wa.address,
|
||||
AES_BLOCK_SIZE) ? -EBADMSG : 0;
|
||||
ccp_dm_free(&tag);
|
||||
}
|
||||
|
||||
|
||||
@ -51,6 +51,8 @@ struct safexcel_cipher_ctx {
|
||||
|
||||
struct safexcel_cipher_req {
|
||||
enum safexcel_cipher_direction direction;
|
||||
/* Number of result descriptors associated to the request */
|
||||
unsigned int rdescs;
|
||||
bool needs_inv;
|
||||
};
|
||||
|
||||
@ -333,7 +335,10 @@ static int safexcel_handle_req_result(struct safexcel_crypto_priv *priv, int rin
|
||||
|
||||
*ret = 0;
|
||||
|
||||
do {
|
||||
if (unlikely(!sreq->rdescs))
|
||||
return 0;
|
||||
|
||||
while (sreq->rdescs--) {
|
||||
rdesc = safexcel_ring_next_rptr(priv, &priv->ring[ring].rdr);
|
||||
if (IS_ERR(rdesc)) {
|
||||
dev_err(priv->dev,
|
||||
@ -346,7 +351,7 @@ static int safexcel_handle_req_result(struct safexcel_crypto_priv *priv, int rin
|
||||
*ret = safexcel_rdesc_check_errors(priv, rdesc);
|
||||
|
||||
ndesc++;
|
||||
} while (!rdesc->last_seg);
|
||||
}
|
||||
|
||||
safexcel_complete(priv, ring);
|
||||
|
||||
@ -501,6 +506,7 @@ cdesc_rollback:
|
||||
static int safexcel_handle_inv_result(struct safexcel_crypto_priv *priv,
|
||||
int ring,
|
||||
struct crypto_async_request *base,
|
||||
struct safexcel_cipher_req *sreq,
|
||||
bool *should_complete, int *ret)
|
||||
{
|
||||
struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(base->tfm);
|
||||
@ -509,7 +515,10 @@ static int safexcel_handle_inv_result(struct safexcel_crypto_priv *priv,
|
||||
|
||||
*ret = 0;
|
||||
|
||||
do {
|
||||
if (unlikely(!sreq->rdescs))
|
||||
return 0;
|
||||
|
||||
while (sreq->rdescs--) {
|
||||
rdesc = safexcel_ring_next_rptr(priv, &priv->ring[ring].rdr);
|
||||
if (IS_ERR(rdesc)) {
|
||||
dev_err(priv->dev,
|
||||
@ -522,7 +531,7 @@ static int safexcel_handle_inv_result(struct safexcel_crypto_priv *priv,
|
||||
*ret = safexcel_rdesc_check_errors(priv, rdesc);
|
||||
|
||||
ndesc++;
|
||||
} while (!rdesc->last_seg);
|
||||
}
|
||||
|
||||
safexcel_complete(priv, ring);
|
||||
|
||||
@ -564,7 +573,7 @@ static int safexcel_skcipher_handle_result(struct safexcel_crypto_priv *priv,
|
||||
|
||||
if (sreq->needs_inv) {
|
||||
sreq->needs_inv = false;
|
||||
err = safexcel_handle_inv_result(priv, ring, async,
|
||||
err = safexcel_handle_inv_result(priv, ring, async, sreq,
|
||||
should_complete, ret);
|
||||
} else {
|
||||
err = safexcel_handle_req_result(priv, ring, async, req->src,
|
||||
@ -587,7 +596,7 @@ static int safexcel_aead_handle_result(struct safexcel_crypto_priv *priv,
|
||||
|
||||
if (sreq->needs_inv) {
|
||||
sreq->needs_inv = false;
|
||||
err = safexcel_handle_inv_result(priv, ring, async,
|
||||
err = safexcel_handle_inv_result(priv, ring, async, sreq,
|
||||
should_complete, ret);
|
||||
} else {
|
||||
err = safexcel_handle_req_result(priv, ring, async, req->src,
|
||||
@ -633,6 +642,8 @@ static int safexcel_skcipher_send(struct crypto_async_request *async, int ring,
|
||||
ret = safexcel_send_req(async, ring, sreq, req->src,
|
||||
req->dst, req->cryptlen, 0, 0, req->iv,
|
||||
commands, results);
|
||||
|
||||
sreq->rdescs = *results;
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -655,6 +666,7 @@ static int safexcel_aead_send(struct crypto_async_request *async, int ring,
|
||||
req->cryptlen, req->assoclen,
|
||||
crypto_aead_authsize(tfm), req->iv,
|
||||
commands, results);
|
||||
sreq->rdescs = *results;
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@ -1001,7 +1001,6 @@ static void ipsec_esp_encrypt_done(struct device *dev,
|
||||
unsigned int authsize = crypto_aead_authsize(authenc);
|
||||
unsigned int ivsize = crypto_aead_ivsize(authenc);
|
||||
struct talitos_edesc *edesc;
|
||||
struct scatterlist *sg;
|
||||
void *icvdata;
|
||||
|
||||
edesc = container_of(desc, struct talitos_edesc, desc);
|
||||
@ -1015,9 +1014,8 @@ static void ipsec_esp_encrypt_done(struct device *dev,
|
||||
else
|
||||
icvdata = &edesc->link_tbl[edesc->src_nents +
|
||||
edesc->dst_nents + 2];
|
||||
sg = sg_last(areq->dst, edesc->dst_nents);
|
||||
memcpy((char *)sg_virt(sg) + sg->length - authsize,
|
||||
icvdata, authsize);
|
||||
sg_pcopy_from_buffer(areq->dst, edesc->dst_nents ? : 1, icvdata,
|
||||
authsize, areq->assoclen + areq->cryptlen);
|
||||
}
|
||||
|
||||
dma_unmap_single(dev, edesc->iv_dma, ivsize, DMA_TO_DEVICE);
|
||||
@ -1035,7 +1033,6 @@ static void ipsec_esp_decrypt_swauth_done(struct device *dev,
|
||||
struct crypto_aead *authenc = crypto_aead_reqtfm(req);
|
||||
unsigned int authsize = crypto_aead_authsize(authenc);
|
||||
struct talitos_edesc *edesc;
|
||||
struct scatterlist *sg;
|
||||
char *oicv, *icv;
|
||||
struct talitos_private *priv = dev_get_drvdata(dev);
|
||||
bool is_sec1 = has_ftr_sec1(priv);
|
||||
@ -1045,9 +1042,18 @@ static void ipsec_esp_decrypt_swauth_done(struct device *dev,
|
||||
ipsec_esp_unmap(dev, edesc, req);
|
||||
|
||||
if (!err) {
|
||||
char icvdata[SHA512_DIGEST_SIZE];
|
||||
int nents = edesc->dst_nents ? : 1;
|
||||
unsigned int len = req->assoclen + req->cryptlen;
|
||||
|
||||
/* auth check */
|
||||
sg = sg_last(req->dst, edesc->dst_nents ? : 1);
|
||||
icv = (char *)sg_virt(sg) + sg->length - authsize;
|
||||
if (nents > 1) {
|
||||
sg_pcopy_to_buffer(req->dst, nents, icvdata, authsize,
|
||||
len - authsize);
|
||||
icv = icvdata;
|
||||
} else {
|
||||
icv = (char *)sg_virt(req->dst) + len - authsize;
|
||||
}
|
||||
|
||||
if (edesc->dma_len) {
|
||||
if (is_sec1)
|
||||
@ -1463,7 +1469,6 @@ static int aead_decrypt(struct aead_request *req)
|
||||
struct talitos_ctx *ctx = crypto_aead_ctx(authenc);
|
||||
struct talitos_private *priv = dev_get_drvdata(ctx->dev);
|
||||
struct talitos_edesc *edesc;
|
||||
struct scatterlist *sg;
|
||||
void *icvdata;
|
||||
|
||||
req->cryptlen -= authsize;
|
||||
@ -1497,9 +1502,8 @@ static int aead_decrypt(struct aead_request *req)
|
||||
else
|
||||
icvdata = &edesc->link_tbl[0];
|
||||
|
||||
sg = sg_last(req->src, edesc->src_nents ? : 1);
|
||||
|
||||
memcpy(icvdata, (char *)sg_virt(sg) + sg->length - authsize, authsize);
|
||||
sg_pcopy_to_buffer(req->src, edesc->src_nents ? : 1, icvdata, authsize,
|
||||
req->assoclen + req->cryptlen - authsize);
|
||||
|
||||
return ipsec_esp(edesc, req, ipsec_esp_decrypt_swauth_done);
|
||||
}
|
||||
@ -1553,11 +1557,15 @@ static void ablkcipher_done(struct device *dev,
|
||||
int err)
|
||||
{
|
||||
struct ablkcipher_request *areq = context;
|
||||
struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
|
||||
struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
|
||||
unsigned int ivsize = crypto_ablkcipher_ivsize(cipher);
|
||||
struct talitos_edesc *edesc;
|
||||
|
||||
edesc = container_of(desc, struct talitos_edesc, desc);
|
||||
|
||||
common_nonsnoop_unmap(dev, edesc, areq);
|
||||
memcpy(areq->info, ctx->iv, ivsize);
|
||||
|
||||
kfree(edesc);
|
||||
|
||||
@ -3185,7 +3193,10 @@ static struct talitos_crypto_alg *talitos_alg_alloc(struct device *dev,
|
||||
alg->cra_priority = t_alg->algt.priority;
|
||||
else
|
||||
alg->cra_priority = TALITOS_CRA_PRIORITY;
|
||||
alg->cra_alignmask = 0;
|
||||
if (has_ftr_sec1(priv))
|
||||
alg->cra_alignmask = 3;
|
||||
else
|
||||
alg->cra_alignmask = 0;
|
||||
alg->cra_ctxsize = sizeof(struct talitos_ctx);
|
||||
alg->cra_flags |= CRYPTO_ALG_KERN_DRIVER_ONLY;
|
||||
|
||||
|
||||
@ -2039,27 +2039,6 @@ static int sdma_probe(struct platform_device *pdev)
|
||||
if (pdata && pdata->script_addrs)
|
||||
sdma_add_scripts(sdma, pdata->script_addrs);
|
||||
|
||||
if (pdata) {
|
||||
ret = sdma_get_firmware(sdma, pdata->fw_name);
|
||||
if (ret)
|
||||
dev_warn(&pdev->dev, "failed to get firmware from platform data\n");
|
||||
} else {
|
||||
/*
|
||||
* Because that device tree does not encode ROM script address,
|
||||
* the RAM script in firmware is mandatory for device tree
|
||||
* probe, otherwise it fails.
|
||||
*/
|
||||
ret = of_property_read_string(np, "fsl,sdma-ram-script-name",
|
||||
&fw_name);
|
||||
if (ret)
|
||||
dev_warn(&pdev->dev, "failed to get firmware name\n");
|
||||
else {
|
||||
ret = sdma_get_firmware(sdma, fw_name);
|
||||
if (ret)
|
||||
dev_warn(&pdev->dev, "failed to get firmware from device tree\n");
|
||||
}
|
||||
}
|
||||
|
||||
sdma->dma_device.dev = &pdev->dev;
|
||||
|
||||
sdma->dma_device.device_alloc_chan_resources = sdma_alloc_chan_resources;
|
||||
@ -2103,6 +2082,33 @@ static int sdma_probe(struct platform_device *pdev)
|
||||
of_node_put(spba_bus);
|
||||
}
|
||||
|
||||
/*
|
||||
* Kick off firmware loading as the very last step:
|
||||
* attempt to load firmware only if we're not on the error path, because
|
||||
* the firmware callback requires a fully functional and allocated sdma
|
||||
* instance.
|
||||
*/
|
||||
if (pdata) {
|
||||
ret = sdma_get_firmware(sdma, pdata->fw_name);
|
||||
if (ret)
|
||||
dev_warn(&pdev->dev, "failed to get firmware from platform data\n");
|
||||
} else {
|
||||
/*
|
||||
* Because that device tree does not encode ROM script address,
|
||||
* the RAM script in firmware is mandatory for device tree
|
||||
* probe, otherwise it fails.
|
||||
*/
|
||||
ret = of_property_read_string(np, "fsl,sdma-ram-script-name",
|
||||
&fw_name);
|
||||
if (ret) {
|
||||
dev_warn(&pdev->dev, "failed to get firmware name\n");
|
||||
} else {
|
||||
ret = sdma_get_firmware(sdma, fw_name);
|
||||
if (ret)
|
||||
dev_warn(&pdev->dev, "failed to get firmware from device tree\n");
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err_register:
|
||||
|
||||
@ -26,7 +26,7 @@
|
||||
static int edac_mc_log_ue = 1;
|
||||
static int edac_mc_log_ce = 1;
|
||||
static int edac_mc_panic_on_ue;
|
||||
static int edac_mc_poll_msec = 1000;
|
||||
static unsigned int edac_mc_poll_msec = 1000;
|
||||
|
||||
/* Getter functions for above */
|
||||
int edac_mc_get_log_ue(void)
|
||||
@ -45,30 +45,30 @@ int edac_mc_get_panic_on_ue(void)
|
||||
}
|
||||
|
||||
/* this is temporary */
|
||||
int edac_mc_get_poll_msec(void)
|
||||
unsigned int edac_mc_get_poll_msec(void)
|
||||
{
|
||||
return edac_mc_poll_msec;
|
||||
}
|
||||
|
||||
static int edac_set_poll_msec(const char *val, const struct kernel_param *kp)
|
||||
{
|
||||
unsigned long l;
|
||||
unsigned int i;
|
||||
int ret;
|
||||
|
||||
if (!val)
|
||||
return -EINVAL;
|
||||
|
||||
ret = kstrtoul(val, 0, &l);
|
||||
ret = kstrtouint(val, 0, &i);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (l < 1000)
|
||||
if (i < 1000)
|
||||
return -EINVAL;
|
||||
|
||||
*((unsigned long *)kp->arg) = l;
|
||||
*((unsigned int *)kp->arg) = i;
|
||||
|
||||
/* notify edac_mc engine to reset the poll period */
|
||||
edac_mc_reset_delay_period(l);
|
||||
edac_mc_reset_delay_period(i);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -82,7 +82,7 @@ MODULE_PARM_DESC(edac_mc_log_ue,
|
||||
module_param(edac_mc_log_ce, int, 0644);
|
||||
MODULE_PARM_DESC(edac_mc_log_ce,
|
||||
"Log correctable error to console: 0=off 1=on");
|
||||
module_param_call(edac_mc_poll_msec, edac_set_poll_msec, param_get_int,
|
||||
module_param_call(edac_mc_poll_msec, edac_set_poll_msec, param_get_uint,
|
||||
&edac_mc_poll_msec, 0644);
|
||||
MODULE_PARM_DESC(edac_mc_poll_msec, "Polling period in milliseconds");
|
||||
|
||||
@ -404,6 +404,8 @@ static inline int nr_pages_per_csrow(struct csrow_info *csrow)
|
||||
static int edac_create_csrow_object(struct mem_ctl_info *mci,
|
||||
struct csrow_info *csrow, int index)
|
||||
{
|
||||
int err;
|
||||
|
||||
csrow->dev.type = &csrow_attr_type;
|
||||
csrow->dev.bus = mci->bus;
|
||||
csrow->dev.groups = csrow_dev_groups;
|
||||
@ -416,7 +418,11 @@ static int edac_create_csrow_object(struct mem_ctl_info *mci,
|
||||
edac_dbg(0, "creating (virtual) csrow node %s\n",
|
||||
dev_name(&csrow->dev));
|
||||
|
||||
return device_add(&csrow->dev);
|
||||
err = device_add(&csrow->dev);
|
||||
if (err)
|
||||
put_device(&csrow->dev);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Create a CSROW object under specifed edac_mc_device */
|
||||
|
||||
@ -36,7 +36,7 @@ extern int edac_mc_get_log_ue(void);
|
||||
extern int edac_mc_get_log_ce(void);
|
||||
extern int edac_mc_get_panic_on_ue(void);
|
||||
extern int edac_get_poll_msec(void);
|
||||
extern int edac_mc_get_poll_msec(void);
|
||||
extern unsigned int edac_mc_get_poll_msec(void);
|
||||
|
||||
unsigned edac_dimm_info_location(struct dimm_info *dimm, char *buf,
|
||||
unsigned len);
|
||||
|
||||
@ -837,9 +837,9 @@ static void omap_gpio_irq_shutdown(struct irq_data *d)
|
||||
|
||||
raw_spin_lock_irqsave(&bank->lock, flags);
|
||||
bank->irq_usage &= ~(BIT(offset));
|
||||
omap_set_gpio_irqenable(bank, offset, 0);
|
||||
omap_clear_gpio_irqstatus(bank, offset);
|
||||
omap_set_gpio_triggering(bank, offset, IRQ_TYPE_NONE);
|
||||
omap_clear_gpio_irqstatus(bank, offset);
|
||||
omap_set_gpio_irqenable(bank, offset, 0);
|
||||
if (!LINE_USED(bank->mod_usage, offset))
|
||||
omap_clear_gpio_debounce(bank, offset);
|
||||
omap_disable_gpio_module(bank, offset);
|
||||
@ -881,8 +881,8 @@ static void omap_gpio_mask_irq(struct irq_data *d)
|
||||
unsigned long flags;
|
||||
|
||||
raw_spin_lock_irqsave(&bank->lock, flags);
|
||||
omap_set_gpio_irqenable(bank, offset, 0);
|
||||
omap_set_gpio_triggering(bank, offset, IRQ_TYPE_NONE);
|
||||
omap_set_gpio_irqenable(bank, offset, 0);
|
||||
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
||||
}
|
||||
|
||||
@ -894,9 +894,6 @@ static void omap_gpio_unmask_irq(struct irq_data *d)
|
||||
unsigned long flags;
|
||||
|
||||
raw_spin_lock_irqsave(&bank->lock, flags);
|
||||
if (trigger)
|
||||
omap_set_gpio_triggering(bank, offset, trigger);
|
||||
|
||||
omap_set_gpio_irqenable(bank, offset, 1);
|
||||
|
||||
/*
|
||||
@ -904,9 +901,13 @@ static void omap_gpio_unmask_irq(struct irq_data *d)
|
||||
* is cleared, thus after the handler has run. OMAP4 needs this done
|
||||
* after enabing the interrupt to clear the wakeup status.
|
||||
*/
|
||||
if (bank->level_mask & BIT(offset))
|
||||
if (bank->regs->leveldetect0 && bank->regs->wkup_en &&
|
||||
trigger & (IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW))
|
||||
omap_clear_gpio_irqstatus(bank, offset);
|
||||
|
||||
if (trigger)
|
||||
omap_set_gpio_triggering(bank, offset, trigger);
|
||||
|
||||
raw_spin_unlock_irqrestore(&bank->lock, flags);
|
||||
}
|
||||
|
||||
@ -1687,6 +1688,8 @@ static struct omap_gpio_reg_offs omap4_gpio_regs = {
|
||||
.clr_dataout = OMAP4_GPIO_CLEARDATAOUT,
|
||||
.irqstatus = OMAP4_GPIO_IRQSTATUS0,
|
||||
.irqstatus2 = OMAP4_GPIO_IRQSTATUS1,
|
||||
.irqstatus_raw0 = OMAP4_GPIO_IRQSTATUSRAW0,
|
||||
.irqstatus_raw1 = OMAP4_GPIO_IRQSTATUSRAW1,
|
||||
.irqenable = OMAP4_GPIO_IRQSTATUSSET0,
|
||||
.irqenable2 = OMAP4_GPIO_IRQSTATUSSET1,
|
||||
.set_irqenable = OMAP4_GPIO_IRQSTATUSSET0,
|
||||
|
||||
@ -2877,7 +2877,7 @@ int gpiod_get_array_value_complex(bool raw, bool can_sleep,
|
||||
int gpiod_get_raw_value(const struct gpio_desc *desc)
|
||||
{
|
||||
VALIDATE_DESC(desc);
|
||||
/* Should be using gpio_get_value_cansleep() */
|
||||
/* Should be using gpiod_get_raw_value_cansleep() */
|
||||
WARN_ON(desc->gdev->chip->can_sleep);
|
||||
return gpiod_get_raw_value_commit(desc);
|
||||
}
|
||||
@ -2898,7 +2898,7 @@ int gpiod_get_value(const struct gpio_desc *desc)
|
||||
int value;
|
||||
|
||||
VALIDATE_DESC(desc);
|
||||
/* Should be using gpio_get_value_cansleep() */
|
||||
/* Should be using gpiod_get_value_cansleep() */
|
||||
WARN_ON(desc->gdev->chip->can_sleep);
|
||||
|
||||
value = gpiod_get_raw_value_commit(desc);
|
||||
@ -3123,7 +3123,7 @@ int gpiod_set_array_value_complex(bool raw, bool can_sleep,
|
||||
void gpiod_set_raw_value(struct gpio_desc *desc, int value)
|
||||
{
|
||||
VALIDATE_DESC_VOID(desc);
|
||||
/* Should be using gpiod_set_value_cansleep() */
|
||||
/* Should be using gpiod_set_raw_value_cansleep() */
|
||||
WARN_ON(desc->gdev->chip->can_sleep);
|
||||
gpiod_set_raw_value_commit(desc, value);
|
||||
}
|
||||
@ -3164,6 +3164,7 @@ static void gpiod_set_value_nocheck(struct gpio_desc *desc, int value)
|
||||
void gpiod_set_value(struct gpio_desc *desc, int value)
|
||||
{
|
||||
VALIDATE_DESC_VOID(desc);
|
||||
/* Should be using gpiod_set_value_cansleep() */
|
||||
WARN_ON(desc->gdev->chip->can_sleep);
|
||||
gpiod_set_value_nocheck(desc, value);
|
||||
}
|
||||
|
||||
@ -1349,6 +1349,7 @@ MODULE_PARM_DESC(edid_fixup,
|
||||
|
||||
static void drm_get_displayid(struct drm_connector *connector,
|
||||
struct edid *edid);
|
||||
static int validate_displayid(u8 *displayid, int length, int idx);
|
||||
|
||||
static int drm_edid_block_checksum(const u8 *raw_edid)
|
||||
{
|
||||
@ -2932,16 +2933,46 @@ static u8 *drm_find_edid_extension(const struct edid *edid, int ext_id)
|
||||
return edid_ext;
|
||||
}
|
||||
|
||||
static u8 *drm_find_cea_extension(const struct edid *edid)
|
||||
{
|
||||
return drm_find_edid_extension(edid, CEA_EXT);
|
||||
}
|
||||
|
||||
static u8 *drm_find_displayid_extension(const struct edid *edid)
|
||||
{
|
||||
return drm_find_edid_extension(edid, DISPLAYID_EXT);
|
||||
}
|
||||
|
||||
static u8 *drm_find_cea_extension(const struct edid *edid)
|
||||
{
|
||||
int ret;
|
||||
int idx = 1;
|
||||
int length = EDID_LENGTH;
|
||||
struct displayid_block *block;
|
||||
u8 *cea;
|
||||
u8 *displayid;
|
||||
|
||||
/* Look for a top level CEA extension block */
|
||||
cea = drm_find_edid_extension(edid, CEA_EXT);
|
||||
if (cea)
|
||||
return cea;
|
||||
|
||||
/* CEA blocks can also be found embedded in a DisplayID block */
|
||||
displayid = drm_find_displayid_extension(edid);
|
||||
if (!displayid)
|
||||
return NULL;
|
||||
|
||||
ret = validate_displayid(displayid, length, idx);
|
||||
if (ret)
|
||||
return NULL;
|
||||
|
||||
idx += sizeof(struct displayid_hdr);
|
||||
for_each_displayid_db(displayid, block, idx, length) {
|
||||
if (block->tag == DATA_BLOCK_CTA) {
|
||||
cea = (u8 *)block;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return cea;
|
||||
}
|
||||
|
||||
/*
|
||||
* Calculate the alternate clock for the CEA mode
|
||||
* (60Hz vs. 59.94Hz etc.)
|
||||
@ -3665,13 +3696,38 @@ cea_revision(const u8 *cea)
|
||||
static int
|
||||
cea_db_offsets(const u8 *cea, int *start, int *end)
|
||||
{
|
||||
/* Data block offset in CEA extension block */
|
||||
*start = 4;
|
||||
*end = cea[2];
|
||||
if (*end == 0)
|
||||
*end = 127;
|
||||
if (*end < 4 || *end > 127)
|
||||
return -ERANGE;
|
||||
/* DisplayID CTA extension blocks and top-level CEA EDID
|
||||
* block header definitions differ in the following bytes:
|
||||
* 1) Byte 2 of the header specifies length differently,
|
||||
* 2) Byte 3 is only present in the CEA top level block.
|
||||
*
|
||||
* The different definitions for byte 2 follow.
|
||||
*
|
||||
* DisplayID CTA extension block defines byte 2 as:
|
||||
* Number of payload bytes
|
||||
*
|
||||
* CEA EDID block defines byte 2 as:
|
||||
* Byte number (decimal) within this block where the 18-byte
|
||||
* DTDs begin. If no non-DTD data is present in this extension
|
||||
* block, the value should be set to 04h (the byte after next).
|
||||
* If set to 00h, there are no DTDs present in this block and
|
||||
* no non-DTD data.
|
||||
*/
|
||||
if (cea[0] == DATA_BLOCK_CTA) {
|
||||
*start = 3;
|
||||
*end = *start + cea[2];
|
||||
} else if (cea[0] == CEA_EXT) {
|
||||
/* Data block offset in CEA extension block */
|
||||
*start = 4;
|
||||
*end = cea[2];
|
||||
if (*end == 0)
|
||||
*end = 127;
|
||||
if (*end < 4 || *end > 127)
|
||||
return -ERANGE;
|
||||
} else {
|
||||
return -ENOTSUPP;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -5218,6 +5274,9 @@ static int drm_parse_display_id(struct drm_connector *connector,
|
||||
case DATA_BLOCK_TYPE_1_DETAILED_TIMING:
|
||||
/* handled in mode gathering code. */
|
||||
break;
|
||||
case DATA_BLOCK_CTA:
|
||||
/* handled in the cea parser code. */
|
||||
break;
|
||||
default:
|
||||
DRM_DEBUG_KMS("found DisplayID tag 0x%x, unhandled\n", block->tag);
|
||||
break;
|
||||
|
||||
@ -184,6 +184,25 @@ nvkm_i2c_fini(struct nvkm_subdev *subdev, bool suspend)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
nvkm_i2c_preinit(struct nvkm_subdev *subdev)
|
||||
{
|
||||
struct nvkm_i2c *i2c = nvkm_i2c(subdev);
|
||||
struct nvkm_i2c_bus *bus;
|
||||
struct nvkm_i2c_pad *pad;
|
||||
|
||||
/*
|
||||
* We init our i2c busses as early as possible, since they may be
|
||||
* needed by the vbios init scripts on some cards
|
||||
*/
|
||||
list_for_each_entry(pad, &i2c->pad, head)
|
||||
nvkm_i2c_pad_init(pad);
|
||||
list_for_each_entry(bus, &i2c->bus, head)
|
||||
nvkm_i2c_bus_init(bus);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
nvkm_i2c_init(struct nvkm_subdev *subdev)
|
||||
{
|
||||
@ -238,6 +257,7 @@ nvkm_i2c_dtor(struct nvkm_subdev *subdev)
|
||||
static const struct nvkm_subdev_func
|
||||
nvkm_i2c = {
|
||||
.dtor = nvkm_i2c_dtor,
|
||||
.preinit = nvkm_i2c_preinit,
|
||||
.init = nvkm_i2c_init,
|
||||
.fini = nvkm_i2c_fini,
|
||||
.intr = nvkm_i2c_intr,
|
||||
|
||||
@ -257,7 +257,7 @@ static int init_csc(struct ipu_ic *ic,
|
||||
writel(param, base++);
|
||||
|
||||
param = ((a[0] & 0x1fe0) >> 5) | (params->scale << 8) |
|
||||
(params->sat << 9);
|
||||
(params->sat << 10);
|
||||
writel(param, base++);
|
||||
|
||||
param = ((a[1] & 0x1f) << 27) | ((c[0][1] & 0x1ff) << 18) |
|
||||
|
||||
@ -275,6 +275,9 @@ static void wacom_feature_mapping(struct hid_device *hdev,
|
||||
wacom_hid_usage_quirk(hdev, field, usage);
|
||||
|
||||
switch (equivalent_usage) {
|
||||
case WACOM_HID_WD_TOUCH_RING_SETTING:
|
||||
wacom->generic_has_leds = true;
|
||||
break;
|
||||
case HID_DG_CONTACTMAX:
|
||||
/* leave touch_max as is if predefined */
|
||||
if (!features->touch_max) {
|
||||
|
||||
@ -1928,8 +1928,6 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev,
|
||||
features->device_type |= WACOM_DEVICETYPE_PAD;
|
||||
break;
|
||||
case WACOM_HID_WD_BUTTONCENTER:
|
||||
wacom->generic_has_leds = true;
|
||||
/* fall through */
|
||||
case WACOM_HID_WD_BUTTONHOME:
|
||||
case WACOM_HID_WD_BUTTONUP:
|
||||
case WACOM_HID_WD_BUTTONDOWN:
|
||||
@ -2121,14 +2119,12 @@ static void wacom_wac_pad_report(struct hid_device *hdev,
|
||||
bool active = wacom_wac->hid_data.inrange_state != 0;
|
||||
|
||||
/* report prox for expresskey events */
|
||||
if ((wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY) &&
|
||||
wacom_wac->hid_data.pad_input_event_flag) {
|
||||
if (wacom_wac->hid_data.pad_input_event_flag) {
|
||||
input_event(input, EV_ABS, ABS_MISC, active ? PAD_DEVICE_ID : 0);
|
||||
input_sync(input);
|
||||
if (!active)
|
||||
wacom_wac->hid_data.pad_input_event_flag = false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static void wacom_wac_pen_usage_mapping(struct hid_device *hdev,
|
||||
@ -2725,9 +2721,7 @@ static int wacom_wac_collection(struct hid_device *hdev, struct hid_report *repo
|
||||
if (report->type != HID_INPUT_REPORT)
|
||||
return -1;
|
||||
|
||||
if (WACOM_PAD_FIELD(field) && wacom->wacom_wac.pad_input)
|
||||
wacom_wac_pad_report(hdev, report, field);
|
||||
else if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
|
||||
if (WACOM_PEN_FIELD(field) && wacom->wacom_wac.pen_input)
|
||||
wacom_wac_pen_report(hdev, report);
|
||||
else if (WACOM_FINGER_FIELD(field) && wacom->wacom_wac.touch_input)
|
||||
wacom_wac_finger_report(hdev, report);
|
||||
@ -2741,7 +2735,7 @@ void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)
|
||||
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
|
||||
struct hid_field *field;
|
||||
bool pad_in_hid_field = false, pen_in_hid_field = false,
|
||||
finger_in_hid_field = false;
|
||||
finger_in_hid_field = false, true_pad = false;
|
||||
int r;
|
||||
int prev_collection = -1;
|
||||
|
||||
@ -2757,6 +2751,8 @@ void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)
|
||||
pen_in_hid_field = true;
|
||||
if (WACOM_FINGER_FIELD(field))
|
||||
finger_in_hid_field = true;
|
||||
if (wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY)
|
||||
true_pad = true;
|
||||
}
|
||||
|
||||
wacom_wac_battery_pre_report(hdev, report);
|
||||
@ -2780,6 +2776,9 @@ void wacom_wac_report(struct hid_device *hdev, struct hid_report *report)
|
||||
}
|
||||
|
||||
wacom_wac_battery_report(hdev, report);
|
||||
|
||||
if (true_pad && wacom->wacom_wac.pad_input)
|
||||
wacom_wac_pad_report(hdev, report, field);
|
||||
}
|
||||
|
||||
static int wacom_bpt_touch(struct wacom_wac *wacom)
|
||||
@ -3735,7 +3734,7 @@ int wacom_setup_touch_input_capabilities(struct input_dev *input_dev,
|
||||
0, 5920, 4, 0);
|
||||
}
|
||||
input_abs_set_res(input_dev, ABS_MT_POSITION_X, 40);
|
||||
input_abs_set_res(input_dev, ABS_MT_POSITION_X, 40);
|
||||
input_abs_set_res(input_dev, ABS_MT_POSITION_Y, 40);
|
||||
|
||||
/* fall through */
|
||||
|
||||
|
||||
@ -145,6 +145,7 @@
|
||||
#define WACOM_HID_WD_OFFSETBOTTOM (WACOM_HID_UP_WACOMDIGITIZER | 0x0d33)
|
||||
#define WACOM_HID_WD_DATAMODE (WACOM_HID_UP_WACOMDIGITIZER | 0x1002)
|
||||
#define WACOM_HID_WD_DIGITIZERINFO (WACOM_HID_UP_WACOMDIGITIZER | 0x1013)
|
||||
#define WACOM_HID_WD_TOUCH_RING_SETTING (WACOM_HID_UP_WACOMDIGITIZER | 0x1032)
|
||||
#define WACOM_HID_UP_G9 0xff090000
|
||||
#define WACOM_HID_G9_PEN (WACOM_HID_UP_G9 | 0x02)
|
||||
#define WACOM_HID_G9_TOUCHSCREEN (WACOM_HID_UP_G9 | 0x11)
|
||||
|
||||
@ -632,7 +632,7 @@ static int msc_buffer_contig_alloc(struct msc *msc, unsigned long size)
|
||||
goto err_out;
|
||||
|
||||
ret = -ENOMEM;
|
||||
page = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
|
||||
page = alloc_pages(GFP_KERNEL | __GFP_ZERO | GFP_DMA32, order);
|
||||
if (!page)
|
||||
goto err_free_sgt;
|
||||
|
||||
|
||||
@ -170,6 +170,11 @@ static const struct pci_device_id intel_th_pci_id_table[] = {
|
||||
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x02a6),
|
||||
.driver_data = (kernel_ulong_t)&intel_th_2x,
|
||||
},
|
||||
{
|
||||
/* Ice Lake NNPI */
|
||||
PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x45c5),
|
||||
.driver_data = (kernel_ulong_t)&intel_th_2x,
|
||||
},
|
||||
{ 0 },
|
||||
};
|
||||
|
||||
|
||||
@ -939,15 +939,19 @@ static int mlx5_ib_query_device(struct ib_device *ibdev,
|
||||
}
|
||||
|
||||
if (MLX5_CAP_GEN(mdev, tag_matching)) {
|
||||
props->tm_caps.max_rndv_hdr_size = MLX5_TM_MAX_RNDV_MSG_SIZE;
|
||||
props->tm_caps.max_num_tags =
|
||||
(1 << MLX5_CAP_GEN(mdev, log_tag_matching_list_sz)) - 1;
|
||||
props->tm_caps.flags = IB_TM_CAP_RC;
|
||||
props->tm_caps.max_ops =
|
||||
1 << MLX5_CAP_GEN(mdev, log_max_qp_sz);
|
||||
props->tm_caps.max_sge = MLX5_TM_MAX_SGE;
|
||||
}
|
||||
|
||||
if (MLX5_CAP_GEN(mdev, tag_matching) &&
|
||||
MLX5_CAP_GEN(mdev, rndv_offload_rc)) {
|
||||
props->tm_caps.flags = IB_TM_CAP_RNDV_RC;
|
||||
props->tm_caps.max_rndv_hdr_size = MLX5_TM_MAX_RNDV_MSG_SIZE;
|
||||
}
|
||||
|
||||
if (MLX5_CAP_GEN(dev->mdev, cq_moderation)) {
|
||||
props->cq_caps.max_cq_moderation_count =
|
||||
MLX5_MAX_CQ_COUNT;
|
||||
|
||||
@ -1997,6 +1997,7 @@ static int ipoib_get_vf_config(struct net_device *dev, int vf,
|
||||
return err;
|
||||
|
||||
ivf->vf = vf;
|
||||
memcpy(ivf->mac, dev->dev_addr, dev->addr_len);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -24,6 +24,7 @@
|
||||
|
||||
#include "psmouse.h"
|
||||
#include "alps.h"
|
||||
#include "trackpoint.h"
|
||||
|
||||
/*
|
||||
* Definitions for ALPS version 3 and 4 command mode protocol
|
||||
@ -2864,6 +2865,23 @@ static const struct alps_protocol_info *alps_match_table(unsigned char *e7,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static bool alps_is_cs19_trackpoint(struct psmouse *psmouse)
|
||||
{
|
||||
u8 param[2] = { 0 };
|
||||
|
||||
if (ps2_command(&psmouse->ps2dev,
|
||||
param, MAKE_PS2_CMD(0, 2, TP_READ_ID)))
|
||||
return false;
|
||||
|
||||
/*
|
||||
* param[0] contains the trackpoint device variant_id while
|
||||
* param[1] contains the firmware_id. So far all alps
|
||||
* trackpoint-only devices have their variant_ids equal
|
||||
* TP_VARIANT_ALPS and their firmware_ids are in 0x20~0x2f range.
|
||||
*/
|
||||
return param[0] == TP_VARIANT_ALPS && ((param[1] & 0xf0) == 0x20);
|
||||
}
|
||||
|
||||
static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
|
||||
{
|
||||
const struct alps_protocol_info *protocol;
|
||||
@ -3164,6 +3182,20 @@ int alps_detect(struct psmouse *psmouse, bool set_properties)
|
||||
if (error)
|
||||
return error;
|
||||
|
||||
/*
|
||||
* ALPS cs19 is a trackpoint-only device, and uses different
|
||||
* protocol than DualPoint ones, so we return -EINVAL here and let
|
||||
* trackpoint.c drive this device. If the trackpoint driver is not
|
||||
* enabled, the device will fall back to a bare PS/2 mouse.
|
||||
* If ps2_command() fails here, we depend on the immediately
|
||||
* followed psmouse_reset() to reset the device to normal state.
|
||||
*/
|
||||
if (alps_is_cs19_trackpoint(psmouse)) {
|
||||
psmouse_dbg(psmouse,
|
||||
"ALPS CS19 trackpoint-only device detected, ignoring\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Reset the device to make sure it is fully operational:
|
||||
* on some laptops, like certain Dell Latitudes, we may
|
||||
|
||||
@ -179,6 +179,7 @@ static const char * const smbus_pnp_ids[] = {
|
||||
"LEN0093", /* T480 */
|
||||
"LEN0096", /* X280 */
|
||||
"LEN0097", /* X280 -> ALPS trackpoint */
|
||||
"LEN009b", /* T580 */
|
||||
"LEN200f", /* T450s */
|
||||
"LEN2054", /* E480 */
|
||||
"LEN2055", /* E580 */
|
||||
|
||||
@ -78,6 +78,7 @@ Scott Hill shill@gtcocalcomp.com
|
||||
|
||||
/* Max size of a single report */
|
||||
#define REPORT_MAX_SIZE 10
|
||||
#define MAX_COLLECTION_LEVELS 10
|
||||
|
||||
|
||||
/* Bitmask whether pen is in range */
|
||||
@ -223,8 +224,7 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
|
||||
char maintype = 'x';
|
||||
char globtype[12];
|
||||
int indent = 0;
|
||||
char indentstr[10] = "";
|
||||
|
||||
char indentstr[MAX_COLLECTION_LEVELS + 1] = { 0 };
|
||||
|
||||
dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
|
||||
|
||||
@ -350,6 +350,13 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
|
||||
case TAG_MAIN_COL_START:
|
||||
maintype = 'S';
|
||||
|
||||
if (indent == MAX_COLLECTION_LEVELS) {
|
||||
dev_err(ddev, "Collection level %d would exceed limit of %d\n",
|
||||
indent + 1,
|
||||
MAX_COLLECTION_LEVELS);
|
||||
break;
|
||||
}
|
||||
|
||||
if (data == 0) {
|
||||
dev_dbg(ddev, "======>>>>>> Physical\n");
|
||||
strcpy(globtype, "Physical");
|
||||
@ -369,8 +376,15 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
|
||||
break;
|
||||
|
||||
case TAG_MAIN_COL_END:
|
||||
dev_dbg(ddev, "<<<<<<======\n");
|
||||
maintype = 'E';
|
||||
|
||||
if (indent == 0) {
|
||||
dev_err(ddev, "Collection level already at zero\n");
|
||||
break;
|
||||
}
|
||||
|
||||
dev_dbg(ddev, "<<<<<<======\n");
|
||||
|
||||
indent--;
|
||||
for (x = 0; x < indent; x++)
|
||||
indentstr[x] = '-';
|
||||
|
||||
@ -211,18 +211,21 @@ static int iommu_insert_resv_region(struct iommu_resv_region *new,
|
||||
pos = pos->next;
|
||||
} else if ((start >= a) && (end <= b)) {
|
||||
if (new->type == type)
|
||||
goto done;
|
||||
return 0;
|
||||
else
|
||||
pos = pos->next;
|
||||
} else {
|
||||
if (new->type == type) {
|
||||
phys_addr_t new_start = min(a, start);
|
||||
phys_addr_t new_end = max(b, end);
|
||||
int ret;
|
||||
|
||||
list_del(&entry->list);
|
||||
entry->start = new_start;
|
||||
entry->length = new_end - new_start + 1;
|
||||
iommu_insert_resv_region(entry, regions);
|
||||
ret = iommu_insert_resv_region(entry, regions);
|
||||
kfree(entry);
|
||||
return ret;
|
||||
} else {
|
||||
pos = pos->next;
|
||||
}
|
||||
@ -235,7 +238,6 @@ insert:
|
||||
return -ENOMEM;
|
||||
|
||||
list_add_tail(®ion->list, pos);
|
||||
done:
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -73,6 +73,7 @@ static const struct of_device_id meson_irq_gpio_matches[] = {
|
||||
{ .compatible = "amlogic,meson-gxbb-gpio-intc", .data = &gxbb_params },
|
||||
{ .compatible = "amlogic,meson-gxl-gpio-intc", .data = &gxl_params },
|
||||
{ .compatible = "amlogic,meson-axg-gpio-intc", .data = &axg_params },
|
||||
{ .compatible = "amlogic,meson-g12a-gpio-intc", .data = &axg_params },
|
||||
{ }
|
||||
};
|
||||
|
||||
|
||||
@ -288,14 +288,16 @@ void pblk_free_rqd(struct pblk *pblk, struct nvm_rq *rqd, int type)
|
||||
void pblk_bio_free_pages(struct pblk *pblk, struct bio *bio, int off,
|
||||
int nr_pages)
|
||||
{
|
||||
struct bio_vec bv;
|
||||
int i;
|
||||
struct bio_vec *bv;
|
||||
struct page *page;
|
||||
int i, e, nbv = 0;
|
||||
|
||||
WARN_ON(off + nr_pages != bio->bi_vcnt);
|
||||
|
||||
for (i = off; i < nr_pages + off; i++) {
|
||||
bv = bio->bi_io_vec[i];
|
||||
mempool_free(bv.bv_page, &pblk->page_bio_pool);
|
||||
for (i = 0; i < bio->bi_vcnt; i++) {
|
||||
bv = &bio->bi_io_vec[i];
|
||||
page = bv->bv_page;
|
||||
for (e = 0; e < bv->bv_len; e += PBLK_EXPOSED_PAGE_SIZE, nbv++)
|
||||
if (nbv >= off)
|
||||
mempool_free(page++, &pblk->page_bio_pool);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -393,6 +393,11 @@ long bch_bucket_alloc(struct cache *ca, unsigned int reserve, bool wait)
|
||||
struct bucket *b;
|
||||
long r;
|
||||
|
||||
|
||||
/* No allocation if CACHE_SET_IO_DISABLE bit is set */
|
||||
if (unlikely(test_bit(CACHE_SET_IO_DISABLE, &ca->set->flags)))
|
||||
return -1;
|
||||
|
||||
/* fastpath */
|
||||
if (fifo_pop(&ca->free[RESERVE_NONE], r) ||
|
||||
fifo_pop(&ca->free[reserve], r))
|
||||
@ -484,6 +489,10 @@ int __bch_bucket_alloc_set(struct cache_set *c, unsigned int reserve,
|
||||
{
|
||||
int i;
|
||||
|
||||
/* No allocation if CACHE_SET_IO_DISABLE bit is set */
|
||||
if (unlikely(test_bit(CACHE_SET_IO_DISABLE, &c->flags)))
|
||||
return -1;
|
||||
|
||||
lockdep_assert_held(&c->bucket_lock);
|
||||
BUG_ON(!n || n > c->caches_loaded || n > 8);
|
||||
|
||||
|
||||
@ -708,8 +708,6 @@ struct cache_set {
|
||||
|
||||
#define BUCKET_HASH_BITS 12
|
||||
struct hlist_head bucket_hash[1 << BUCKET_HASH_BITS];
|
||||
|
||||
DECLARE_HEAP(struct btree *, flush_btree);
|
||||
};
|
||||
|
||||
struct bbio {
|
||||
|
||||
@ -58,6 +58,18 @@ void bch_count_backing_io_errors(struct cached_dev *dc, struct bio *bio)
|
||||
|
||||
WARN_ONCE(!dc, "NULL pointer of struct cached_dev");
|
||||
|
||||
/*
|
||||
* Read-ahead requests on a degrading and recovering md raid
|
||||
* (e.g. raid6) device might be failured immediately by md
|
||||
* raid code, which is not a real hardware media failure. So
|
||||
* we shouldn't count failed REQ_RAHEAD bio to dc->io_errors.
|
||||
*/
|
||||
if (bio->bi_opf & REQ_RAHEAD) {
|
||||
pr_warn_ratelimited("%s: Read-ahead I/O failed on backing device, ignore",
|
||||
dc->backing_dev_name);
|
||||
return;
|
||||
}
|
||||
|
||||
errors = atomic_add_return(1, &dc->io_errors);
|
||||
if (errors < dc->error_limit)
|
||||
pr_err("%s: IO error on backing device, unrecoverable",
|
||||
|
||||
@ -390,12 +390,6 @@ err:
|
||||
}
|
||||
|
||||
/* Journalling */
|
||||
#define journal_max_cmp(l, r) \
|
||||
(fifo_idx(&c->journal.pin, btree_current_write(l)->journal) < \
|
||||
fifo_idx(&(c)->journal.pin, btree_current_write(r)->journal))
|
||||
#define journal_min_cmp(l, r) \
|
||||
(fifo_idx(&c->journal.pin, btree_current_write(l)->journal) > \
|
||||
fifo_idx(&(c)->journal.pin, btree_current_write(r)->journal))
|
||||
|
||||
static void btree_flush_write(struct cache_set *c)
|
||||
{
|
||||
@ -403,35 +397,25 @@ static void btree_flush_write(struct cache_set *c)
|
||||
* Try to find the btree node with that references the oldest journal
|
||||
* entry, best is our current candidate and is locked if non NULL:
|
||||
*/
|
||||
struct btree *b;
|
||||
int i;
|
||||
struct btree *b, *best;
|
||||
unsigned int i;
|
||||
|
||||
atomic_long_inc(&c->flush_write);
|
||||
|
||||
retry:
|
||||
spin_lock(&c->journal.lock);
|
||||
if (heap_empty(&c->flush_btree)) {
|
||||
for_each_cached_btree(b, c, i)
|
||||
if (btree_current_write(b)->journal) {
|
||||
if (!heap_full(&c->flush_btree))
|
||||
heap_add(&c->flush_btree, b,
|
||||
journal_max_cmp);
|
||||
else if (journal_max_cmp(b,
|
||||
heap_peek(&c->flush_btree))) {
|
||||
c->flush_btree.data[0] = b;
|
||||
heap_sift(&c->flush_btree, 0,
|
||||
journal_max_cmp);
|
||||
}
|
||||
best = NULL;
|
||||
|
||||
for_each_cached_btree(b, c, i)
|
||||
if (btree_current_write(b)->journal) {
|
||||
if (!best)
|
||||
best = b;
|
||||
else if (journal_pin_cmp(c,
|
||||
btree_current_write(best)->journal,
|
||||
btree_current_write(b)->journal)) {
|
||||
best = b;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = c->flush_btree.used / 2 - 1; i >= 0; --i)
|
||||
heap_sift(&c->flush_btree, i, journal_min_cmp);
|
||||
}
|
||||
|
||||
b = NULL;
|
||||
heap_pop(&c->flush_btree, b, journal_min_cmp);
|
||||
spin_unlock(&c->journal.lock);
|
||||
|
||||
b = best;
|
||||
if (b) {
|
||||
mutex_lock(&b->write_lock);
|
||||
if (!btree_current_write(b)->journal) {
|
||||
@ -810,6 +794,10 @@ atomic_t *bch_journal(struct cache_set *c,
|
||||
struct journal_write *w;
|
||||
atomic_t *ret;
|
||||
|
||||
/* No journaling if CACHE_SET_IO_DISABLE set already */
|
||||
if (unlikely(test_bit(CACHE_SET_IO_DISABLE, &c->flags)))
|
||||
return NULL;
|
||||
|
||||
if (!CACHE_SYNC(&c->sb))
|
||||
return NULL;
|
||||
|
||||
@ -854,7 +842,6 @@ void bch_journal_free(struct cache_set *c)
|
||||
free_pages((unsigned long) c->journal.w[1].data, JSET_BITS);
|
||||
free_pages((unsigned long) c->journal.w[0].data, JSET_BITS);
|
||||
free_fifo(&c->journal.pin);
|
||||
free_heap(&c->flush_btree);
|
||||
}
|
||||
|
||||
int bch_journal_alloc(struct cache_set *c)
|
||||
@ -869,8 +856,7 @@ int bch_journal_alloc(struct cache_set *c)
|
||||
j->w[0].c = c;
|
||||
j->w[1].c = c;
|
||||
|
||||
if (!(init_heap(&c->flush_btree, 128, GFP_KERNEL)) ||
|
||||
!(init_fifo(&j->pin, JOURNAL_PIN, GFP_KERNEL)) ||
|
||||
if (!(init_fifo(&j->pin, JOURNAL_PIN, GFP_KERNEL)) ||
|
||||
!(j->w[0].data = (void *) __get_free_pages(GFP_KERNEL, JSET_BITS)) ||
|
||||
!(j->w[1].data = (void *) __get_free_pages(GFP_KERNEL, JSET_BITS)))
|
||||
return -ENOMEM;
|
||||
|
||||
@ -1180,18 +1180,16 @@ static void cached_dev_free(struct closure *cl)
|
||||
{
|
||||
struct cached_dev *dc = container_of(cl, struct cached_dev, disk.cl);
|
||||
|
||||
mutex_lock(&bch_register_lock);
|
||||
|
||||
if (test_and_clear_bit(BCACHE_DEV_WB_RUNNING, &dc->disk.flags))
|
||||
cancel_writeback_rate_update_dwork(dc);
|
||||
|
||||
if (!IS_ERR_OR_NULL(dc->writeback_thread))
|
||||
kthread_stop(dc->writeback_thread);
|
||||
if (dc->writeback_write_wq)
|
||||
destroy_workqueue(dc->writeback_write_wq);
|
||||
if (!IS_ERR_OR_NULL(dc->status_update_thread))
|
||||
kthread_stop(dc->status_update_thread);
|
||||
|
||||
mutex_lock(&bch_register_lock);
|
||||
|
||||
if (atomic_read(&dc->running))
|
||||
bd_unlink_disk_holder(dc->bdev, dc->disk.disk);
|
||||
bcache_device_free(&dc->disk);
|
||||
@ -1425,8 +1423,6 @@ int bch_flash_dev_create(struct cache_set *c, uint64_t size)
|
||||
|
||||
bool bch_cached_dev_error(struct cached_dev *dc)
|
||||
{
|
||||
struct cache_set *c;
|
||||
|
||||
if (!dc || test_bit(BCACHE_DEV_CLOSING, &dc->disk.flags))
|
||||
return false;
|
||||
|
||||
@ -1437,21 +1433,6 @@ bool bch_cached_dev_error(struct cached_dev *dc)
|
||||
pr_err("stop %s: too many IO errors on backing device %s\n",
|
||||
dc->disk.disk->disk_name, dc->backing_dev_name);
|
||||
|
||||
/*
|
||||
* If the cached device is still attached to a cache set,
|
||||
* even dc->io_disable is true and no more I/O requests
|
||||
* accepted, cache device internal I/O (writeback scan or
|
||||
* garbage collection) may still prevent bcache device from
|
||||
* being stopped. So here CACHE_SET_IO_DISABLE should be
|
||||
* set to c->flags too, to make the internal I/O to cache
|
||||
* device rejected and stopped immediately.
|
||||
* If c is NULL, that means the bcache device is not attached
|
||||
* to any cache set, then no CACHE_SET_IO_DISABLE bit to set.
|
||||
*/
|
||||
c = dc->disk.c;
|
||||
if (c && test_and_set_bit(CACHE_SET_IO_DISABLE, &c->flags))
|
||||
pr_info("CACHE_SET_IO_DISABLE already set");
|
||||
|
||||
bcache_device_stop(&dc->disk);
|
||||
return true;
|
||||
}
|
||||
@ -1552,7 +1533,7 @@ static void cache_set_flush(struct closure *cl)
|
||||
kobject_put(&c->internal);
|
||||
kobject_del(&c->kobj);
|
||||
|
||||
if (c->gc_thread)
|
||||
if (!IS_ERR_OR_NULL(c->gc_thread))
|
||||
kthread_stop(c->gc_thread);
|
||||
|
||||
if (!IS_ERR_OR_NULL(c->root))
|
||||
|
||||
@ -175,7 +175,7 @@ SHOW(__bch_cached_dev)
|
||||
var_print(writeback_percent);
|
||||
sysfs_hprint(writeback_rate,
|
||||
wb ? atomic_long_read(&dc->writeback_rate.rate) << 9 : 0);
|
||||
sysfs_hprint(io_errors, atomic_read(&dc->io_errors));
|
||||
sysfs_printf(io_errors, "%i", atomic_read(&dc->io_errors));
|
||||
sysfs_printf(io_error_limit, "%i", dc->error_limit);
|
||||
sysfs_printf(io_disable, "%i", dc->io_disable);
|
||||
var_print(writeback_rate_update_seconds);
|
||||
@ -426,7 +426,7 @@ static struct attribute *bch_cached_dev_files[] = {
|
||||
&sysfs_writeback_rate_p_term_inverse,
|
||||
&sysfs_writeback_rate_minimum,
|
||||
&sysfs_writeback_rate_debug,
|
||||
&sysfs_errors,
|
||||
&sysfs_io_errors,
|
||||
&sysfs_io_error_limit,
|
||||
&sysfs_io_disable,
|
||||
&sysfs_dirty_data,
|
||||
|
||||
@ -113,8 +113,6 @@ do { \
|
||||
|
||||
#define heap_full(h) ((h)->used == (h)->size)
|
||||
|
||||
#define heap_empty(h) ((h)->used == 0)
|
||||
|
||||
#define DECLARE_FIFO(type, name) \
|
||||
struct { \
|
||||
size_t front, back, size, mask; \
|
||||
|
||||
@ -708,6 +708,10 @@ static int bch_writeback_thread(void *arg)
|
||||
}
|
||||
}
|
||||
|
||||
if (dc->writeback_write_wq) {
|
||||
flush_workqueue(dc->writeback_write_wq);
|
||||
destroy_workqueue(dc->writeback_write_wq);
|
||||
}
|
||||
cached_dev_put(dc);
|
||||
wait_for_kthread_stop();
|
||||
|
||||
@ -803,6 +807,7 @@ int bch_cached_dev_writeback_start(struct cached_dev *dc)
|
||||
"bcache_writeback");
|
||||
if (IS_ERR(dc->writeback_thread)) {
|
||||
cached_dev_put(dc);
|
||||
destroy_workqueue(dc->writeback_write_wq);
|
||||
return PTR_ERR(dc->writeback_thread);
|
||||
}
|
||||
|
||||
|
||||
@ -1602,9 +1602,7 @@ dm_bufio_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
|
||||
unsigned long freed;
|
||||
|
||||
c = container_of(shrink, struct dm_bufio_client, shrinker);
|
||||
if (sc->gfp_mask & __GFP_FS)
|
||||
dm_bufio_lock(c);
|
||||
else if (!dm_bufio_trylock(c))
|
||||
if (!dm_bufio_trylock(c))
|
||||
return SHRINK_STOP;
|
||||
|
||||
freed = __scan(c, sc->nr_to_scan, sc->gfp_mask);
|
||||
|
||||
@ -1593,30 +1593,6 @@ struct dm_zone *dmz_get_zone_for_reclaim(struct dmz_metadata *zmd)
|
||||
return zone;
|
||||
}
|
||||
|
||||
/*
|
||||
* Activate a zone (increment its reference count).
|
||||
*/
|
||||
void dmz_activate_zone(struct dm_zone *zone)
|
||||
{
|
||||
set_bit(DMZ_ACTIVE, &zone->flags);
|
||||
atomic_inc(&zone->refcount);
|
||||
}
|
||||
|
||||
/*
|
||||
* Deactivate a zone. This decrement the zone reference counter
|
||||
* and clears the active state of the zone once the count reaches 0,
|
||||
* indicating that all BIOs to the zone have completed. Returns
|
||||
* true if the zone was deactivated.
|
||||
*/
|
||||
void dmz_deactivate_zone(struct dm_zone *zone)
|
||||
{
|
||||
if (atomic_dec_and_test(&zone->refcount)) {
|
||||
WARN_ON(!test_bit(DMZ_ACTIVE, &zone->flags));
|
||||
clear_bit_unlock(DMZ_ACTIVE, &zone->flags);
|
||||
smp_mb__after_atomic();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Get the zone mapping a chunk, if the chunk is mapped already.
|
||||
* If no mapping exist and the operation is WRITE, a zone is
|
||||
|
||||
@ -115,7 +115,6 @@ enum {
|
||||
DMZ_BUF,
|
||||
|
||||
/* Zone internal state */
|
||||
DMZ_ACTIVE,
|
||||
DMZ_RECLAIM,
|
||||
DMZ_SEQ_WRITE_ERR,
|
||||
};
|
||||
@ -128,7 +127,6 @@ enum {
|
||||
#define dmz_is_empty(z) ((z)->wp_block == 0)
|
||||
#define dmz_is_offline(z) test_bit(DMZ_OFFLINE, &(z)->flags)
|
||||
#define dmz_is_readonly(z) test_bit(DMZ_READ_ONLY, &(z)->flags)
|
||||
#define dmz_is_active(z) test_bit(DMZ_ACTIVE, &(z)->flags)
|
||||
#define dmz_in_reclaim(z) test_bit(DMZ_RECLAIM, &(z)->flags)
|
||||
#define dmz_seq_write_err(z) test_bit(DMZ_SEQ_WRITE_ERR, &(z)->flags)
|
||||
|
||||
@ -188,8 +186,30 @@ void dmz_unmap_zone(struct dmz_metadata *zmd, struct dm_zone *zone);
|
||||
unsigned int dmz_nr_rnd_zones(struct dmz_metadata *zmd);
|
||||
unsigned int dmz_nr_unmap_rnd_zones(struct dmz_metadata *zmd);
|
||||
|
||||
void dmz_activate_zone(struct dm_zone *zone);
|
||||
void dmz_deactivate_zone(struct dm_zone *zone);
|
||||
/*
|
||||
* Activate a zone (increment its reference count).
|
||||
*/
|
||||
static inline void dmz_activate_zone(struct dm_zone *zone)
|
||||
{
|
||||
atomic_inc(&zone->refcount);
|
||||
}
|
||||
|
||||
/*
|
||||
* Deactivate a zone. This decrement the zone reference counter
|
||||
* indicating that all BIOs to the zone have completed when the count is 0.
|
||||
*/
|
||||
static inline void dmz_deactivate_zone(struct dm_zone *zone)
|
||||
{
|
||||
atomic_dec(&zone->refcount);
|
||||
}
|
||||
|
||||
/*
|
||||
* Test if a zone is active, that is, has a refcount > 0.
|
||||
*/
|
||||
static inline bool dmz_is_active(struct dm_zone *zone)
|
||||
{
|
||||
return atomic_read(&zone->refcount);
|
||||
}
|
||||
|
||||
int dmz_lock_zone_reclaim(struct dm_zone *zone);
|
||||
void dmz_unlock_zone_reclaim(struct dm_zone *zone);
|
||||
|
||||
@ -7670,7 +7670,7 @@ abort:
|
||||
static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
|
||||
{
|
||||
struct r5conf *conf = mddev->private;
|
||||
int err = -EEXIST;
|
||||
int ret, err = -EEXIST;
|
||||
int disk;
|
||||
struct disk_info *p;
|
||||
int first = 0;
|
||||
@ -7685,7 +7685,14 @@ static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
|
||||
* The array is in readonly mode if journal is missing, so no
|
||||
* write requests running. We should be safe
|
||||
*/
|
||||
log_init(conf, rdev, false);
|
||||
ret = log_init(conf, rdev, false);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = r5l_start(conf->log);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
if (mddev->recovery_disabled == conf->recovery_disabled)
|
||||
|
||||
@ -207,6 +207,10 @@ static int __vb2_buf_mem_alloc(struct vb2_buffer *vb)
|
||||
for (plane = 0; plane < vb->num_planes; ++plane) {
|
||||
unsigned long size = PAGE_ALIGN(vb->planes[plane].length);
|
||||
|
||||
/* Did it wrap around? */
|
||||
if (size < vb->planes[plane].length)
|
||||
goto free;
|
||||
|
||||
mem_priv = call_ptr_memop(vb, alloc,
|
||||
q->alloc_devs[plane] ? : q->dev,
|
||||
q->dma_attrs, size, q->dma_dir, q->gfp_flags);
|
||||
|
||||
@ -59,7 +59,7 @@ static int vb2_dma_sg_alloc_compacted(struct vb2_dma_sg_buf *buf,
|
||||
gfp_t gfp_flags)
|
||||
{
|
||||
unsigned int last_page = 0;
|
||||
int size = buf->size;
|
||||
unsigned long size = buf->size;
|
||||
|
||||
while (size > 0) {
|
||||
struct page *pages;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user