mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-05 19:31:57 -04:00
This is the 5.4.292 stable release
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAmf3uc8ACgkQONu9yGCS
aT7cOA/+IMZpVcP8BeutEqLl9O0SXf4QS9LT8u/eQKy3b26p8otQXOkElhGmchBv
cvb7+ZuJQGUcjfhW0CsHGx/vKfDz3qbbLaXH/F0sRvZxkYApX35pkSDOtcE3jAHn
klQejHzoFlom8d951VUpQukwGXPoVfPExdXMWNg4RCrn1pcDnb3JjmEyhDRu5Sna
fA1JeQ54UReNPUnXOHyixy+xoOLGBdikqVzV8SIqKNuzBloXIbSA831BGocFffrW
xng8XIemuCEuK552/Ex8AJfUiY/q6XGH2OYy46g4oEG85xoyseGlQJqsnziOxDGX
VYbdYGmtTZB7Tv2fwjpKsyluexoQEXmxVbu8CuGn/X0B1d48tRl40ROBMoAnOOhZ
j7gjZG9TK9G7+fQSEpS8bLwknRndQWlbxSRMVEGAqIDcxF09+Hkkycu82siCtKz2
JYQnKsv7We/m7EI+3uAh50zZrLU6NL+wVnkGlQy17RTQYYshZpSs6GYvB4OjJ5vx
OXovZA2IKDnWA336viL265etHsUf2agNIyWiMr/5Tp4RgirN2WSQubZjNhp/FdjR
e3MxVPrUxBD/QyGs2KuZo/rA/SuYDtMxdoogrYQO1cbpvBCcsyYvnczhAUcjVgKq
C+iGTOAs+EEHWYol/CWuOJAkG/0O7Uj2U+cDdQQgeKD9SCSzohA=
=wRcs
-----END PGP SIGNATURE-----
Merge 5.4.292 into android11-5.4-lts
Changes in 5.4.292
vlan: fix memory leak in vlan_newlink()
clockevents/drivers/i8253: Fix stop sequence for timer 0
sched/isolation: Prevent boot crash when the boot CPU is nohz_full
Revert "sctp: sysctl: cookie_hmac_alg: avoid using current->nsproxy"
Revert "sctp: sysctl: auth_enable: avoid using current->nsproxy"
sctp: sysctl: cookie_hmac_alg: avoid using current->nsproxy
sctp: sysctl: auth_enable: avoid using current->nsproxy
pinctrl: bcm281xx: Fix incorrect regmap max_registers value
netpoll: Fix use correct return type for ndo_start_xmit()
netpoll: remove dev argument from netpoll_send_skb_on_dev()
netpoll: move netpoll_send_skb() out of line
netpoll: netpoll_send_skb() returns transmit status
netpoll: hold rcu read lock in __netpoll_send_skb()
drivers/hv: Replace binary semaphore with mutex
Drivers: hv: vmbus: Don't release fb_mmio resource in vmbus_free_mmio()
netfilter: nf_conncount: Fully initialize struct nf_conncount_tuple in insert_tree()
ipvs: prevent integer overflow in do_ip_vs_get_ctl()
net_sched: Prevent creation of classes with TC_H_ROOT
netfilter: nft_exthdr: fix offset with ipv4_find_option()
net/mlx5e: Prevent bridge link show failure for non-eswitch-allowed devices
nvme-fc: go straight to connecting state when initializing
hrtimers: Mark is_migration_base() with __always_inline
powercap: call put_device() on an error path in powercap_register_control_type()
iscsi_ibft: Fix UBSAN shift-out-of-bounds warning in ibft_attr_show_nic()
scsi: qla1280: Fix kernel oops when debug level > 2
ACPI: resource: IRQ override for Eluktronics MECH-17
HID: intel-ish-hid: fix the length of MNG_SYNC_FW_CLOCK in doorbell
HID: ignore non-functional sensor in HP 5MP Camera
s390/cio: Fix CHPID "configure" attribute caching
ASoC: rsnd: don't indicate warning on rsnd_kctrl_accept_runtime()
nvmet-rdma: recheck queue state is LIVE in state lock in recv done
sctp: Fix undefined behavior in left shift operation
nvme: only allow entering LIVE from CONNECTING state
fuse: don't truncate cached, mutated symlink
x86/irq: Define trace events conditionally
drm/nouveau: Do not override forced connector status
block: fix 'kmem_cache of name 'bio-108' already exists'
USB: serial: ftdi_sio: add support for Altera USB Blaster 3
USB: serial: option: add Telit Cinterion FE990B compositions
USB: serial: option: fix Telit Cinterion FE990A name
USB: serial: option: match on interface class for Telit FN990B
x86/microcode/AMD: Fix out-of-bounds on systems with CPU-less NUMA nodes
drm/atomic: Filter out redundant DPMS calls
drm/amd/display: Assign normalized_pix_clk when color depth = 14
qlcnic: fix memory leak issues in qlcnic_sriov_common.c
drm/gma500: Add NULL check for pci_gfx_root in mid_get_vbt_data()
ASoC: codecs: wm0010: Fix error handling path in wm0010_spi_probe()
i2c: ali1535: Fix an error handling path in ali1535_probe()
i2c: ali15x3: Fix an error handling path in ali15x3_probe()
i2c: sis630: Fix an error handling path in sis630_probe()
firmware: imx-scu: fix OF node leak in .probe()
xfrm_output: Force software GSO only in tunnel mode
RDMA/bnxt_re: Avoid clearing VLAN_ID mask in modify qp path
RDMA/hns: Fix wrong value of max_sge_rd
Bluetooth: Fix error code in chan_alloc_skb_cb()
ipv6: Fix memleak of nhc_pcpu_rth_output in fib_check_nh_v6_gw().
ipv6: Set errno after ip_fib_metrics_init() in ip6_route_info_create().
net: atm: fix use after free in lec_send()
net/neighbor: add missing policy for NDTPA_QUEUE_LENBYTES
i2c: omap: fix IRQ storms
drm/v3d: Don't run jobs that have errors flagged in its fence
mmc: atmel-mci: Add missing clk_disable_unprepare()
ARM: shmobile: smp: Enforce shmobile_smp_* alignment
batman-adv: Ignore own maximum aggregation size during RX
drm/radeon: fix uninitialized size issue in radeon_vce_cs_parse()
ALSA: usb-audio: Add quirk for Plantronics headsets to fix control names
HID: hid-plantronics: Add mic mute mapping and generalize quirks
atm: Fix NULL pointer dereference
ARM: 9350/1: fault: Implement copy_from_kernel_nofault_allowed()
ARM: 9351/1: fault: Add "cut here" line for prefetch aborts
ARM: Remove address checking for MMUless devices
netfilter: socket: Lookup orig tuple for IPv6 SNAT
counter: stm32-lptimer-cnt: fix error handling when enabling
tty: serial: 8250: Add some more device IDs
net: usb: qmi_wwan: add Telit Cinterion FN990B composition
net: usb: qmi_wwan: add Telit Cinterion FE990B composition
net: usb: usbnet: restore usb%d name exception for local mac addresses
memstick: rtsx_usb_ms: Fix slab-use-after-free in rtsx_usb_ms_drv_remove
serial: 8250_dma: terminate correct DMA in tx_dma_flush()
x86/mm/pat: cpa-test: fix length for CPA_ARRAY test
cpufreq: governor: Fix negative 'idle_time' handling in dbs_update()
x86/fpu: Avoid copying dynamic FP state from init_task in arch_dup_task_struct()
x86/platform: Only allow CONFIG_EISA for 32-bit
selinux: Chain up tool resolving errors in install_policy.sh
EDAC/ie31200: Fix the size of EDAC_MC_LAYER_CHIP_SELECT layer
EDAC/ie31200: Fix the DIMM size mask for several SoCs
EDAC/ie31200: Fix the error path order of ie31200_init()
thermal: int340x: Add NULL check for adev
PM: sleep: Fix handling devices with direct_complete set on errors
lockdep: Don't disable interrupts on RT in disable_irq_nosync_lockdep.*()
perf/ring_buffer: Allow the EPOLLRDNORM flag for poll
ALSA: hda/realtek: Always honor no_shutup_pins
drm/mediatek: mtk_hdmi: Fix typo for aud_sampe_size member
PCI/ASPM: Fix link state exit during switch upstream function removal
PCI/portdrv: Only disable pciehp interrupts early when needed
PCI: Remove stray put_device() in pci_register_host_bridge()
PCI: pciehp: Don't enable HPIE when resuming in poll mode
fbdev: au1100fb: Move a variable assignment behind a null pointer check
mdacon: rework dependency list
fbdev: sm501fb: Add some geometry checks.
clk: amlogic: gxbb: drop incorrect flag on 32k clock
bpf: Use preempt_count() directly in bpf_send_signal_common()
lib: 842: Improve error handling in sw842_compress()
pinctrl: renesas: rza2: Fix missing of_node_put() call
clk: rockchip: rk3328: fix wrong clk_ref_usb3otg parent
IB/mad: Check available slots before posting receive WRs
clk: amlogic: g12b: fix cluster A parent data
clk: amlogic: gxbb: drop non existing 32k clock parent
clk: amlogic: g12a: fix mmc A peripheral clock
x86/entry: Fix ORC unwinder for PUSH_REGS with save_ret=1
power: supply: max77693: Fix wrong conversion of charge input threshold value
RDMA/mlx5: Fix mlx5_poll_one() cur_qp update flow
mfd: sm501: Switch to BIT() to mitigate integer overflows
x86/dumpstack: Fix inaccurate unwinding from exception stacks due to misplaced assignment
isofs: fix KMSAN uninit-value bug in do_isofs_readdir()
coresight: catu: Fix number of pages while using 64k pages
iio: accel: mma8452: Ensure error return on failure to matching oversampling ratio
perf units: Fix insufficient array space
kexec: initialize ELF lowest address to ULONG_MAX
ocfs2: validate l_tree_depth to avoid out-of-bounds access
perf python: Fixup description of sample.id event member
perf python: Decrement the refcount of just created event on failure
perf python: Check if there is space to copy all the event
fs/procfs: fix the comment above proc_pid_wchan()
objtool, media: dib8000: Prevent divide-by-zero in dib8000_set_dds()
ring-buffer: Fix bytes_dropped calculation issue
octeontx2-af: Fix mbox INTR handler when num VFs > 64
sched/smt: Always inline sched_smt_active()
wifi: iwlwifi: fw: allocate chained SG tables for dump
affs: generate OFS sequence numbers starting at 1
affs: don't write overlarge OFS data block size fields
sched/deadline: Use online cpus for validating runtime
locking/semaphore: Use wake_q to wake up processes outside lock critical section
can: statistics: use atomic access in hot path
hwmon: (nct6775-core) Fix out of bounds access for NCT679{8,9}
spufs: fix a leak on spufs_new_file() failure
spufs: fix a leak in spufs_create_context()
ntb_hw_switchtec: Fix shift-out-of-bounds in switchtec_ntb_mw_set_trans
ntb: intel: Fix using link status DB's
netlabel: Fix NULL pointer exception caused by CALIPSO on IPv4 sockets
net_sched: skbprio: Remove overly strict queue assertions
vsock: avoid timeout during connect() if the socket is closing
ipv6: fix omitted netlink attributes when using RTEXT_FILTER_SKIP_STATS
net: dsa: mv88e6xxx: propperly shutdown PPU re-enable timer on destroy
arcnet: Add NULL check in com20020pci_probe()
can: flexcan: only change CAN state when link up in system PM
ntb_perf: Delete duplicate dmaengine_unmap_put() call in perf_copy_chunk()
x86/tsc: Always save/restore TSC sched_clock() on suspend/resume
x86/mm: Fix flush_tlb_range() when used for zapping normal PMDs
ACPI: resource: Skip IRQ override on ASUS Vivobook 14 X1404VAP
mmc: sdhci-pxav3: set NEED_RSP_BUSY capability
tracing: Fix use-after-free in print_graph_function_flags during tracer switching
jfs: fix slab-out-of-bounds read in ea_get()
jfs: add index corruption check to DT_GETPAGE()
Linux 5.4.292
Change-Id: I9386a675acdf4384f0d612b6fc80c59bd6bb739f
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
commit
9b78f083cb
148 changed files with 1002 additions and 535 deletions
|
|
@ -129,11 +129,8 @@ adaptive-tick CPUs: At least one non-adaptive-tick CPU must remain
|
|||
online to handle timekeeping tasks in order to ensure that system
|
||||
calls like gettimeofday() returns accurate values on adaptive-tick CPUs.
|
||||
(This is not an issue for CONFIG_NO_HZ_IDLE=y because there are no running
|
||||
user processes to observe slight drifts in clock rate.) Therefore, the
|
||||
boot CPU is prohibited from entering adaptive-ticks mode. Specifying a
|
||||
"nohz_full=" mask that includes the boot CPU will result in a boot-time
|
||||
error message, and the boot CPU will be removed from the mask. Note that
|
||||
this means that your system must have at least two CPUs in order for
|
||||
user processes to observe slight drifts in clock rate.) Note that this
|
||||
means that your system must have at least two CPUs in order for
|
||||
CONFIG_NO_HZ_FULL=y to do anything for you.
|
||||
|
||||
Finally, adaptive-ticks CPUs must have their RCU callbacks offloaded.
|
||||
|
|
|
|||
2
Makefile
2
Makefile
|
|
@ -1,7 +1,7 @@
|
|||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 5
|
||||
PATCHLEVEL = 4
|
||||
SUBLEVEL = 291
|
||||
SUBLEVEL = 292
|
||||
EXTRAVERSION =
|
||||
NAME = Kleptomaniac Octopus
|
||||
|
||||
|
|
|
|||
|
|
@ -136,6 +136,7 @@ ENDPROC(shmobile_smp_sleep)
|
|||
.long shmobile_smp_arg - 1b
|
||||
|
||||
.bss
|
||||
.align 2
|
||||
.globl shmobile_smp_mpidr
|
||||
shmobile_smp_mpidr:
|
||||
.space NR_CPUS * 4
|
||||
|
|
|
|||
|
|
@ -27,6 +27,13 @@
|
|||
|
||||
#ifdef CONFIG_MMU
|
||||
|
||||
bool copy_from_kernel_nofault_allowed(const void *unsafe_src, size_t size)
|
||||
{
|
||||
unsigned long addr = (unsigned long)unsafe_src;
|
||||
|
||||
return addr >= TASK_SIZE && ULONG_MAX - addr >= size;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is useful to dump out the page tables associated with
|
||||
* 'addr' in mm 'mm'.
|
||||
|
|
@ -563,6 +570,7 @@ do_PrefetchAbort(unsigned long addr, unsigned int ifsr, struct pt_regs *regs)
|
|||
if (!inf->fn(addr, ifsr | FSR_LNX_PF, regs))
|
||||
return;
|
||||
|
||||
pr_alert("8<--- cut here ---\n");
|
||||
pr_alert("Unhandled prefetch abort: %s (0x%03x) at 0x%08lx\n",
|
||||
inf->name, ifsr, addr);
|
||||
|
||||
|
|
|
|||
|
|
@ -189,8 +189,10 @@ static int spufs_fill_dir(struct dentry *dir,
|
|||
return -ENOMEM;
|
||||
ret = spufs_new_file(dir->d_sb, dentry, files->ops,
|
||||
files->mode & mode, files->size, ctx);
|
||||
if (ret)
|
||||
if (ret) {
|
||||
dput(dentry);
|
||||
return ret;
|
||||
}
|
||||
files++;
|
||||
}
|
||||
return 0;
|
||||
|
|
@ -438,8 +440,11 @@ spufs_create_context(struct inode *inode, struct dentry *dentry,
|
|||
}
|
||||
|
||||
ret = spufs_mkdir(inode, dentry, flags, mode & 0777);
|
||||
if (ret)
|
||||
if (ret) {
|
||||
if (neighbor)
|
||||
put_spu_context(neighbor);
|
||||
goto out_aff_unlock;
|
||||
}
|
||||
|
||||
if (affinity) {
|
||||
spufs_set_affinity(flags, SPUFS_I(d_inode(dentry))->i_ctx,
|
||||
|
|
|
|||
|
|
@ -162,7 +162,7 @@ config X86
|
|||
select HAVE_DYNAMIC_FTRACE_WITH_REGS
|
||||
select HAVE_EBPF_JIT
|
||||
select HAVE_EFFICIENT_UNALIGNED_ACCESS
|
||||
select HAVE_EISA
|
||||
select HAVE_EISA if X86_32
|
||||
select HAVE_EXIT_THREAD
|
||||
select HAVE_FAST_GUP
|
||||
select HAVE_FENTRY if X86_64 || DYNAMIC_FTRACE
|
||||
|
|
|
|||
|
|
@ -104,6 +104,8 @@ For 32-bit we have the following conventions - kernel is built with
|
|||
pushq %rsi /* pt_regs->si */
|
||||
movq 8(%rsp), %rsi /* temporarily store the return address in %rsi */
|
||||
movq %rdi, 8(%rsp) /* pt_regs->di (overwriting original return address) */
|
||||
/* We just clobbered the return address - use the IRET frame for unwinding: */
|
||||
UNWIND_HINT_IRET_REGS offset=3*8
|
||||
.else
|
||||
pushq %rdi /* pt_regs->di */
|
||||
pushq %rsi /* pt_regs->si */
|
||||
|
|
|
|||
|
|
@ -572,7 +572,7 @@ struct flush_tlb_info {
|
|||
flush_tlb_mm_range((vma)->vm_mm, start, end, \
|
||||
((vma)->vm_flags & VM_HUGETLB) \
|
||||
? huge_page_shift(hstate_vma(vma)) \
|
||||
: PAGE_SHIFT, false)
|
||||
: PAGE_SHIFT, true)
|
||||
|
||||
extern void flush_tlb_all(void);
|
||||
extern void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
|
||||
|
|
|
|||
|
|
@ -862,7 +862,7 @@ static enum ucode_state load_microcode_amd(u8 family, const u8 *data, size_t siz
|
|||
return ret;
|
||||
}
|
||||
|
||||
for_each_node(nid) {
|
||||
for_each_node_with_cpus(nid) {
|
||||
cpu = cpumask_first(cpumask_of_node(nid));
|
||||
c = &cpu_data(cpu);
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,6 @@
|
|||
#include <linux/interrupt.h>
|
||||
#include <linux/irq.h>
|
||||
#include <linux/kexec.h>
|
||||
#include <linux/i8253.h>
|
||||
#include <linux/random.h>
|
||||
#include <asm/processor.h>
|
||||
#include <asm/hypervisor.h>
|
||||
|
|
@ -310,16 +309,6 @@ static void __init ms_hyperv_init_platform(void)
|
|||
if (efi_enabled(EFI_BOOT))
|
||||
x86_platform.get_nmi_reason = hv_get_nmi_reason;
|
||||
|
||||
/*
|
||||
* Hyper-V VMs have a PIT emulation quirk such that zeroing the
|
||||
* counter register during PIT shutdown restarts the PIT. So it
|
||||
* continues to interrupt @18.2 HZ. Setting i8253_clear_counter
|
||||
* to false tells pit_shutdown() not to zero the counter so that
|
||||
* the PIT really is shutdown. Generation 2 VMs don't have a PIT,
|
||||
* and setting this value has no effect.
|
||||
*/
|
||||
i8253_clear_counter_on_shutdown = false;
|
||||
|
||||
#if IS_ENABLED(CONFIG_HYPERV)
|
||||
/*
|
||||
* Setup the hook to get control post apic initialization.
|
||||
|
|
|
|||
|
|
@ -171,6 +171,7 @@ void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
|
|||
printk("%sCall Trace:\n", log_lvl);
|
||||
|
||||
unwind_start(&state, task, regs, stack);
|
||||
stack = stack ?: get_stack_pointer(task, regs);
|
||||
regs = unwind_get_entry_regs(&state, &partial);
|
||||
|
||||
/*
|
||||
|
|
@ -189,9 +190,7 @@ void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
|
|||
* - hardirq stack
|
||||
* - entry stack
|
||||
*/
|
||||
for (stack = stack ?: get_stack_pointer(task, regs);
|
||||
stack;
|
||||
stack = stack_info.next_sp) {
|
||||
for (; stack; stack = stack_info.next_sp) {
|
||||
const char *stack_name;
|
||||
|
||||
stack = PTR_ALIGN(stack, sizeof(long));
|
||||
|
|
|
|||
|
|
@ -20,8 +20,10 @@
|
|||
#include <asm/hw_irq.h>
|
||||
#include <asm/desc.h>
|
||||
|
||||
#if defined(CONFIG_X86_LOCAL_APIC) || defined(CONFIG_X86_THERMAL_VECTOR)
|
||||
#define CREATE_TRACE_POINTS
|
||||
#include <asm/trace/irq_vectors.h>
|
||||
#endif
|
||||
|
||||
DEFINE_PER_CPU_SHARED_ALIGNED(irq_cpustat_t, irq_stat);
|
||||
EXPORT_PER_CPU_SYMBOL(irq_stat);
|
||||
|
|
|
|||
|
|
@ -96,7 +96,12 @@ EXPORT_PER_CPU_SYMBOL_GPL(__tss_limit_invalid);
|
|||
*/
|
||||
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
||||
{
|
||||
memcpy(dst, src, arch_task_struct_size);
|
||||
/* init_task is not dynamically sized (incomplete FPU state) */
|
||||
if (unlikely(src == &init_task))
|
||||
memcpy_and_pad(dst, arch_task_struct_size, src, sizeof(init_task), 0);
|
||||
else
|
||||
memcpy(dst, src, arch_task_struct_size);
|
||||
|
||||
#ifdef CONFIG_VM86
|
||||
dst->thread.vm86 = NULL;
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -912,7 +912,7 @@ static unsigned long long cyc2ns_suspend;
|
|||
|
||||
void tsc_save_sched_clock_state(void)
|
||||
{
|
||||
if (!sched_clock_stable())
|
||||
if (!static_branch_likely(&__use_tsc) && !sched_clock_stable())
|
||||
return;
|
||||
|
||||
cyc2ns_suspend = sched_clock();
|
||||
|
|
@ -932,7 +932,7 @@ void tsc_restore_sched_clock_state(void)
|
|||
unsigned long flags;
|
||||
int cpu;
|
||||
|
||||
if (!sched_clock_stable())
|
||||
if (!static_branch_likely(&__use_tsc) && !sched_clock_stable())
|
||||
return;
|
||||
|
||||
local_irq_save(flags);
|
||||
|
|
|
|||
|
|
@ -184,7 +184,7 @@ static int pageattr_test(void)
|
|||
break;
|
||||
|
||||
case 1:
|
||||
err = change_page_attr_set(addrs, len[1], PAGE_CPA_TEST, 1);
|
||||
err = change_page_attr_set(addrs, len[i], PAGE_CPA_TEST, 1);
|
||||
break;
|
||||
|
||||
case 2:
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ struct bio_slab {
|
|||
struct kmem_cache *slab;
|
||||
unsigned int slab_ref;
|
||||
unsigned int slab_size;
|
||||
char name[8];
|
||||
char name[12];
|
||||
};
|
||||
static DEFINE_MUTEX(bio_slab_lock);
|
||||
static struct bio_slab *bio_slabs;
|
||||
|
|
|
|||
|
|
@ -442,6 +442,13 @@ static const struct dmi_system_id asus_laptop[] = {
|
|||
DMI_MATCH(DMI_BOARD_NAME, "B2402CBA"),
|
||||
},
|
||||
},
|
||||
{
|
||||
/* Asus Vivobook X1404VAP */
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
|
||||
DMI_MATCH(DMI_BOARD_NAME, "X1404VAP"),
|
||||
},
|
||||
},
|
||||
{
|
||||
/* Asus Vivobook X1504VAP */
|
||||
.matches = {
|
||||
|
|
@ -482,6 +489,12 @@ static const struct dmi_system_id asus_laptop[] = {
|
|||
DMI_MATCH(DMI_BOARD_NAME, "RP-15"),
|
||||
},
|
||||
},
|
||||
{
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "Eluktronics Inc."),
|
||||
DMI_MATCH(DMI_BOARD_NAME, "MECH-17"),
|
||||
},
|
||||
},
|
||||
{
|
||||
/* TongFang GM6XGxX/TUXEDO Stellaris 16 Gen5 AMD */
|
||||
.matches = {
|
||||
|
|
|
|||
|
|
@ -969,6 +969,9 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
|
|||
if (dev->power.syscore)
|
||||
goto Complete;
|
||||
|
||||
if (!dev->power.is_suspended)
|
||||
goto Complete;
|
||||
|
||||
if (dev->power.direct_complete) {
|
||||
/* Match the pm_runtime_disable() in __device_suspend(). */
|
||||
pm_runtime_enable(dev);
|
||||
|
|
@ -987,9 +990,6 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
|
|||
*/
|
||||
dev->power.is_prepared = false;
|
||||
|
||||
if (!dev->power.is_suspended)
|
||||
goto Unlock;
|
||||
|
||||
if (dev->pm_domain) {
|
||||
info = "power domain ";
|
||||
callback = pm_op(&dev->pm_domain->ops, state);
|
||||
|
|
@ -1029,7 +1029,6 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
|
|||
error = dpm_run_callback(callback, dev, state, info);
|
||||
dev->power.is_suspended = false;
|
||||
|
||||
Unlock:
|
||||
device_unlock(dev);
|
||||
dpm_watchdog_clear(&wd);
|
||||
|
||||
|
|
@ -1763,6 +1762,7 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
|
|||
pm_runtime_disable(dev);
|
||||
if (pm_runtime_status_suspended(dev)) {
|
||||
pm_dev_dbg(dev, state, "direct-complete ");
|
||||
dev->power.is_suspended = true;
|
||||
goto Complete;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1135,8 +1135,18 @@ static struct clk_regmap g12a_cpu_clk_div16_en = {
|
|||
.hw.init = &(struct clk_init_data) {
|
||||
.name = "cpu_clk_div16_en",
|
||||
.ops = &clk_regmap_gate_ro_ops,
|
||||
.parent_hws = (const struct clk_hw *[]) {
|
||||
&g12a_cpu_clk.hw
|
||||
.parent_data = &(const struct clk_parent_data) {
|
||||
/*
|
||||
* Note:
|
||||
* G12A and G12B have different cpu clocks (with
|
||||
* different struct clk_hw). We fallback to the global
|
||||
* naming string mechanism so this clock picks
|
||||
* up the appropriate one. Same goes for the other
|
||||
* clock using cpu cluster A clock output and present
|
||||
* on both G12 variant.
|
||||
*/
|
||||
.name = "cpu_clk",
|
||||
.index = -1,
|
||||
},
|
||||
.num_parents = 1,
|
||||
/*
|
||||
|
|
@ -1201,7 +1211,10 @@ static struct clk_regmap g12a_cpu_clk_apb_div = {
|
|||
.hw.init = &(struct clk_init_data){
|
||||
.name = "cpu_clk_apb_div",
|
||||
.ops = &clk_regmap_divider_ro_ops,
|
||||
.parent_hws = (const struct clk_hw *[]) { &g12a_cpu_clk.hw },
|
||||
.parent_data = &(const struct clk_parent_data) {
|
||||
.name = "cpu_clk",
|
||||
.index = -1,
|
||||
},
|
||||
.num_parents = 1,
|
||||
},
|
||||
};
|
||||
|
|
@ -1235,7 +1248,10 @@ static struct clk_regmap g12a_cpu_clk_atb_div = {
|
|||
.hw.init = &(struct clk_init_data){
|
||||
.name = "cpu_clk_atb_div",
|
||||
.ops = &clk_regmap_divider_ro_ops,
|
||||
.parent_hws = (const struct clk_hw *[]) { &g12a_cpu_clk.hw },
|
||||
.parent_data = &(const struct clk_parent_data) {
|
||||
.name = "cpu_clk",
|
||||
.index = -1,
|
||||
},
|
||||
.num_parents = 1,
|
||||
},
|
||||
};
|
||||
|
|
@ -1269,7 +1285,10 @@ static struct clk_regmap g12a_cpu_clk_axi_div = {
|
|||
.hw.init = &(struct clk_init_data){
|
||||
.name = "cpu_clk_axi_div",
|
||||
.ops = &clk_regmap_divider_ro_ops,
|
||||
.parent_hws = (const struct clk_hw *[]) { &g12a_cpu_clk.hw },
|
||||
.parent_data = &(const struct clk_parent_data) {
|
||||
.name = "cpu_clk",
|
||||
.index = -1,
|
||||
},
|
||||
.num_parents = 1,
|
||||
},
|
||||
};
|
||||
|
|
@ -1304,13 +1323,6 @@ static struct clk_regmap g12a_cpu_clk_trace_div = {
|
|||
.name = "cpu_clk_trace_div",
|
||||
.ops = &clk_regmap_divider_ro_ops,
|
||||
.parent_data = &(const struct clk_parent_data) {
|
||||
/*
|
||||
* Note:
|
||||
* G12A and G12B have different cpu_clks (with
|
||||
* different struct clk_hw). We fallback to the global
|
||||
* naming string mechanism so cpu_clk_trace_div picks
|
||||
* up the appropriate one.
|
||||
*/
|
||||
.name = "cpu_clk",
|
||||
.index = -1,
|
||||
},
|
||||
|
|
@ -3898,7 +3910,7 @@ static MESON_GATE(g12a_spicc_1, HHI_GCLK_MPEG0, 14);
|
|||
static MESON_GATE(g12a_hiu_reg, HHI_GCLK_MPEG0, 19);
|
||||
static MESON_GATE(g12a_mipi_dsi_phy, HHI_GCLK_MPEG0, 20);
|
||||
static MESON_GATE(g12a_assist_misc, HHI_GCLK_MPEG0, 23);
|
||||
static MESON_GATE(g12a_emmc_a, HHI_GCLK_MPEG0, 4);
|
||||
static MESON_GATE(g12a_emmc_a, HHI_GCLK_MPEG0, 24);
|
||||
static MESON_GATE(g12a_emmc_b, HHI_GCLK_MPEG0, 25);
|
||||
static MESON_GATE(g12a_emmc_c, HHI_GCLK_MPEG0, 26);
|
||||
static MESON_GATE(g12a_audio_codec, HHI_GCLK_MPEG0, 28);
|
||||
|
|
|
|||
|
|
@ -1265,14 +1265,13 @@ static struct clk_regmap gxbb_cts_i958 = {
|
|||
},
|
||||
};
|
||||
|
||||
/*
|
||||
* This table skips a clock named 'cts_slow_oscin' in the documentation
|
||||
* This clock does not exist yet in this controller or the AO one
|
||||
*/
|
||||
static u32 gxbb_32k_clk_parents_val_table[] = { 0, 2, 3 };
|
||||
static const struct clk_parent_data gxbb_32k_clk_parent_data[] = {
|
||||
{ .fw_name = "xtal", },
|
||||
/*
|
||||
* FIXME: This clock is provided by the ao clock controller but the
|
||||
* clock is not yet part of the binding of this controller, so string
|
||||
* name must be use to set this parent.
|
||||
*/
|
||||
{ .name = "cts_slow_oscin", .index = -1 },
|
||||
{ .hw = &gxbb_fclk_div3.hw },
|
||||
{ .hw = &gxbb_fclk_div5.hw },
|
||||
};
|
||||
|
|
@ -1282,6 +1281,7 @@ static struct clk_regmap gxbb_32k_clk_sel = {
|
|||
.offset = HHI_32K_CLK_CNTL,
|
||||
.mask = 0x3,
|
||||
.shift = 16,
|
||||
.table = gxbb_32k_clk_parents_val_table,
|
||||
},
|
||||
.hw.init = &(struct clk_init_data){
|
||||
.name = "32k_clk_sel",
|
||||
|
|
@ -1305,7 +1305,7 @@ static struct clk_regmap gxbb_32k_clk_div = {
|
|||
&gxbb_32k_clk_sel.hw
|
||||
},
|
||||
.num_parents = 1,
|
||||
.flags = CLK_SET_RATE_PARENT | CLK_DIVIDER_ROUND_CLOSEST,
|
||||
.flags = CLK_SET_RATE_PARENT,
|
||||
},
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -200,7 +200,7 @@ PNAME(mux_aclk_peri_pre_p) = { "cpll_peri",
|
|||
"gpll_peri",
|
||||
"hdmiphy_peri" };
|
||||
PNAME(mux_ref_usb3otg_src_p) = { "xin24m",
|
||||
"clk_usb3otg_ref" };
|
||||
"clk_ref_usb3otg_src" };
|
||||
PNAME(mux_xin24m_32k_p) = { "xin24m",
|
||||
"clk_rtc32k" };
|
||||
PNAME(mux_mac2io_src_p) = { "clk_mac2io_src",
|
||||
|
|
|
|||
|
|
@ -20,13 +20,6 @@
|
|||
DEFINE_RAW_SPINLOCK(i8253_lock);
|
||||
EXPORT_SYMBOL(i8253_lock);
|
||||
|
||||
/*
|
||||
* Handle PIT quirk in pit_shutdown() where zeroing the counter register
|
||||
* restarts the PIT, negating the shutdown. On platforms with the quirk,
|
||||
* platform specific code can set this to false.
|
||||
*/
|
||||
bool i8253_clear_counter_on_shutdown __ro_after_init = true;
|
||||
|
||||
#ifdef CONFIG_CLKSRC_I8253
|
||||
/*
|
||||
* Since the PIT overflows every tick, its not very useful
|
||||
|
|
@ -112,12 +105,33 @@ void clockevent_i8253_disable(void)
|
|||
{
|
||||
raw_spin_lock(&i8253_lock);
|
||||
|
||||
/*
|
||||
* Writing the MODE register should stop the counter, according to
|
||||
* the datasheet. This appears to work on real hardware (well, on
|
||||
* modern Intel and AMD boxes; I didn't dig the Pegasos out of the
|
||||
* shed).
|
||||
*
|
||||
* However, some virtual implementations differ, and the MODE change
|
||||
* doesn't have any effect until either the counter is written (KVM
|
||||
* in-kernel PIT) or the next interrupt (QEMU). And in those cases,
|
||||
* it may not stop the *count*, only the interrupts. Although in
|
||||
* the virt case, that probably doesn't matter, as the value of the
|
||||
* counter will only be calculated on demand if the guest reads it;
|
||||
* it's the interrupts which cause steal time.
|
||||
*
|
||||
* Hyper-V apparently has a bug where even in mode 0, the IRQ keeps
|
||||
* firing repeatedly if the counter is running. But it *does* do the
|
||||
* right thing when the MODE register is written.
|
||||
*
|
||||
* So: write the MODE and then load the counter, which ensures that
|
||||
* the IRQ is stopped on those buggy virt implementations. And then
|
||||
* write the MODE again, which is the right way to stop it.
|
||||
*/
|
||||
outb_p(0x30, PIT_MODE);
|
||||
outb_p(0, PIT_CH0);
|
||||
outb_p(0, PIT_CH0);
|
||||
|
||||
if (i8253_clear_counter_on_shutdown) {
|
||||
outb_p(0, PIT_CH0);
|
||||
outb_p(0, PIT_CH0);
|
||||
}
|
||||
outb_p(0x30, PIT_MODE);
|
||||
|
||||
raw_spin_unlock(&i8253_lock);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,37 +58,43 @@ static int stm32_lptim_set_enable_state(struct stm32_lptim_cnt *priv,
|
|||
return 0;
|
||||
}
|
||||
|
||||
ret = clk_enable(priv->clk);
|
||||
if (ret)
|
||||
goto disable_cnt;
|
||||
|
||||
/* LP timer must be enabled before writing CMP & ARR */
|
||||
ret = regmap_write(priv->regmap, STM32_LPTIM_ARR, priv->ceiling);
|
||||
if (ret)
|
||||
return ret;
|
||||
goto disable_clk;
|
||||
|
||||
ret = regmap_write(priv->regmap, STM32_LPTIM_CMP, 0);
|
||||
if (ret)
|
||||
return ret;
|
||||
goto disable_clk;
|
||||
|
||||
/* ensure CMP & ARR registers are properly written */
|
||||
ret = regmap_read_poll_timeout(priv->regmap, STM32_LPTIM_ISR, val,
|
||||
(val & STM32_LPTIM_CMPOK_ARROK) == STM32_LPTIM_CMPOK_ARROK,
|
||||
100, 1000);
|
||||
if (ret)
|
||||
return ret;
|
||||
goto disable_clk;
|
||||
|
||||
ret = regmap_write(priv->regmap, STM32_LPTIM_ICR,
|
||||
STM32_LPTIM_CMPOKCF_ARROKCF);
|
||||
if (ret)
|
||||
return ret;
|
||||
goto disable_clk;
|
||||
|
||||
ret = clk_enable(priv->clk);
|
||||
if (ret) {
|
||||
regmap_write(priv->regmap, STM32_LPTIM_CR, 0);
|
||||
return ret;
|
||||
}
|
||||
priv->enabled = true;
|
||||
|
||||
/* Start LP timer in continuous mode */
|
||||
return regmap_update_bits(priv->regmap, STM32_LPTIM_CR,
|
||||
STM32_LPTIM_CNTSTRT, STM32_LPTIM_CNTSTRT);
|
||||
|
||||
disable_clk:
|
||||
clk_disable(priv->clk);
|
||||
disable_cnt:
|
||||
regmap_write(priv->regmap, STM32_LPTIM_CR, 0);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int stm32_lptim_setup(struct stm32_lptim_cnt *priv, int enable)
|
||||
|
|
|
|||
|
|
@ -145,7 +145,23 @@ unsigned int dbs_update(struct cpufreq_policy *policy)
|
|||
time_elapsed = update_time - j_cdbs->prev_update_time;
|
||||
j_cdbs->prev_update_time = update_time;
|
||||
|
||||
idle_time = cur_idle_time - j_cdbs->prev_cpu_idle;
|
||||
/*
|
||||
* cur_idle_time could be smaller than j_cdbs->prev_cpu_idle if
|
||||
* it's obtained from get_cpu_idle_time_jiffy() when NOHZ is
|
||||
* off, where idle_time is calculated by the difference between
|
||||
* time elapsed in jiffies and "busy time" obtained from CPU
|
||||
* statistics. If a CPU is 100% busy, the time elapsed and busy
|
||||
* time should grow with the same amount in two consecutive
|
||||
* samples, but in practice there could be a tiny difference,
|
||||
* making the accumulated idle time decrease sometimes. Hence,
|
||||
* in this case, idle_time should be regarded as 0 in order to
|
||||
* make the further process correct.
|
||||
*/
|
||||
if (cur_idle_time > j_cdbs->prev_cpu_idle)
|
||||
idle_time = cur_idle_time - j_cdbs->prev_cpu_idle;
|
||||
else
|
||||
idle_time = 0;
|
||||
|
||||
j_cdbs->prev_cpu_idle = cur_idle_time;
|
||||
|
||||
if (ignore_nice) {
|
||||
|
|
@ -162,7 +178,7 @@ unsigned int dbs_update(struct cpufreq_policy *policy)
|
|||
* calls, so the previous load value can be used then.
|
||||
*/
|
||||
load = j_cdbs->prev_load;
|
||||
} else if (unlikely((int)idle_time > 2 * sampling_rate &&
|
||||
} else if (unlikely(idle_time > 2 * sampling_rate &&
|
||||
j_cdbs->prev_load)) {
|
||||
/*
|
||||
* If the CPU had gone completely idle and a task has
|
||||
|
|
@ -189,30 +205,15 @@ unsigned int dbs_update(struct cpufreq_policy *policy)
|
|||
load = j_cdbs->prev_load;
|
||||
j_cdbs->prev_load = 0;
|
||||
} else {
|
||||
if (time_elapsed >= idle_time) {
|
||||
if (time_elapsed > idle_time)
|
||||
load = 100 * (time_elapsed - idle_time) / time_elapsed;
|
||||
} else {
|
||||
/*
|
||||
* That can happen if idle_time is returned by
|
||||
* get_cpu_idle_time_jiffy(). In that case
|
||||
* idle_time is roughly equal to the difference
|
||||
* between time_elapsed and "busy time" obtained
|
||||
* from CPU statistics. Then, the "busy time"
|
||||
* can end up being greater than time_elapsed
|
||||
* (for example, if jiffies_64 and the CPU
|
||||
* statistics are updated by different CPUs),
|
||||
* so idle_time may in fact be negative. That
|
||||
* means, though, that the CPU was busy all
|
||||
* the time (on the rough average) during the
|
||||
* last sampling interval and 100 can be
|
||||
* returned as the load.
|
||||
*/
|
||||
load = (int)idle_time < 0 ? 100 : 0;
|
||||
}
|
||||
else
|
||||
load = 0;
|
||||
|
||||
j_cdbs->prev_load = load;
|
||||
}
|
||||
|
||||
if (unlikely((int)idle_time > 2 * sampling_rate)) {
|
||||
if (unlikely(idle_time > 2 * sampling_rate)) {
|
||||
unsigned int periods = idle_time / sampling_rate;
|
||||
|
||||
if (periods < idle_periods)
|
||||
|
|
|
|||
|
|
@ -83,8 +83,6 @@
|
|||
(((did) & PCI_DEVICE_ID_INTEL_IE31200_HB_CFL_MASK) == \
|
||||
PCI_DEVICE_ID_INTEL_IE31200_HB_CFL_MASK))
|
||||
|
||||
#define IE31200_DIMMS 4
|
||||
#define IE31200_RANKS 8
|
||||
#define IE31200_RANKS_PER_CHANNEL 4
|
||||
#define IE31200_DIMMS_PER_CHANNEL 2
|
||||
#define IE31200_CHANNELS 2
|
||||
|
|
@ -156,6 +154,7 @@
|
|||
#define IE31200_MAD_DIMM_0_OFFSET 0x5004
|
||||
#define IE31200_MAD_DIMM_0_OFFSET_SKL 0x500C
|
||||
#define IE31200_MAD_DIMM_SIZE GENMASK_ULL(7, 0)
|
||||
#define IE31200_MAD_DIMM_SIZE_SKL GENMASK_ULL(5, 0)
|
||||
#define IE31200_MAD_DIMM_A_RANK BIT(17)
|
||||
#define IE31200_MAD_DIMM_A_RANK_SHIFT 17
|
||||
#define IE31200_MAD_DIMM_A_RANK_SKL BIT(10)
|
||||
|
|
@ -370,7 +369,7 @@ static void __iomem *ie31200_map_mchbar(struct pci_dev *pdev)
|
|||
static void __skl_populate_dimm_info(struct dimm_data *dd, u32 addr_decode,
|
||||
int chan)
|
||||
{
|
||||
dd->size = (addr_decode >> (chan << 4)) & IE31200_MAD_DIMM_SIZE;
|
||||
dd->size = (addr_decode >> (chan << 4)) & IE31200_MAD_DIMM_SIZE_SKL;
|
||||
dd->dual_rank = (addr_decode & (IE31200_MAD_DIMM_A_RANK_SKL << (chan << 4))) ? 1 : 0;
|
||||
dd->x16_width = ((addr_decode & (IE31200_MAD_DIMM_A_WIDTH_SKL << (chan << 4))) >>
|
||||
(IE31200_MAD_DIMM_A_WIDTH_SKL_SHIFT + (chan << 4)));
|
||||
|
|
@ -419,7 +418,7 @@ static int ie31200_probe1(struct pci_dev *pdev, int dev_idx)
|
|||
|
||||
nr_channels = how_many_channels(pdev);
|
||||
layers[0].type = EDAC_MC_LAYER_CHIP_SELECT;
|
||||
layers[0].size = IE31200_DIMMS;
|
||||
layers[0].size = IE31200_RANKS_PER_CHANNEL;
|
||||
layers[0].is_virt_csrow = true;
|
||||
layers[1].type = EDAC_MC_LAYER_CHANNEL;
|
||||
layers[1].size = nr_channels;
|
||||
|
|
@ -612,7 +611,7 @@ static int __init ie31200_init(void)
|
|||
|
||||
pci_rc = pci_register_driver(&ie31200_driver);
|
||||
if (pci_rc < 0)
|
||||
goto fail0;
|
||||
return pci_rc;
|
||||
|
||||
if (!mci_pdev) {
|
||||
ie31200_registered = 0;
|
||||
|
|
@ -623,11 +622,13 @@ static int __init ie31200_init(void)
|
|||
if (mci_pdev)
|
||||
break;
|
||||
}
|
||||
|
||||
if (!mci_pdev) {
|
||||
edac_dbg(0, "ie31200 pci_get_device fail\n");
|
||||
pci_rc = -ENODEV;
|
||||
goto fail1;
|
||||
goto fail0;
|
||||
}
|
||||
|
||||
pci_rc = ie31200_init_one(mci_pdev, &ie31200_pci_tbl[i]);
|
||||
if (pci_rc < 0) {
|
||||
edac_dbg(0, "ie31200 init fail\n");
|
||||
|
|
@ -635,12 +636,12 @@ static int __init ie31200_init(void)
|
|||
goto fail1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
return 0;
|
||||
fail1:
|
||||
pci_unregister_driver(&ie31200_driver);
|
||||
fail0:
|
||||
pci_dev_put(mci_pdev);
|
||||
fail0:
|
||||
pci_unregister_driver(&ie31200_driver);
|
||||
|
||||
return pci_rc;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -266,6 +266,7 @@ static int imx_scu_probe(struct platform_device *pdev)
|
|||
return ret;
|
||||
|
||||
sc_ipc->fast_ipc = of_device_is_compatible(args.np, "fsl,imx8-mu-scu");
|
||||
of_node_put(args.np);
|
||||
|
||||
num_channel = sc_ipc->fast_ipc ? 2 : SCU_MU_CHAN_NUM;
|
||||
for (i = 0; i < num_channel; i++) {
|
||||
|
|
|
|||
|
|
@ -311,7 +311,10 @@ static ssize_t ibft_attr_show_nic(void *data, int type, char *buf)
|
|||
str += sprintf_ipaddr(str, nic->ip_addr);
|
||||
break;
|
||||
case ISCSI_BOOT_ETH_SUBNET_MASK:
|
||||
val = cpu_to_be32(~((1 << (32-nic->subnet_mask_prefix))-1));
|
||||
if (nic->subnet_mask_prefix > 32)
|
||||
val = cpu_to_be32(~0);
|
||||
else
|
||||
val = cpu_to_be32(~((1 << (32-nic->subnet_mask_prefix))-1));
|
||||
str += sprintf(str, "%pI4", &val);
|
||||
break;
|
||||
case ISCSI_BOOT_ETH_PREFIX_LEN:
|
||||
|
|
|
|||
|
|
@ -1834,10 +1834,13 @@ static int get_norm_pix_clk(const struct dc_crtc_timing *timing)
|
|||
break;
|
||||
case COLOR_DEPTH_121212:
|
||||
normalized_pix_clk = (pix_clk * 36) / 24;
|
||||
break;
|
||||
break;
|
||||
case COLOR_DEPTH_141414:
|
||||
normalized_pix_clk = (pix_clk * 42) / 24;
|
||||
break;
|
||||
case COLOR_DEPTH_161616:
|
||||
normalized_pix_clk = (pix_clk * 48) / 24;
|
||||
break;
|
||||
break;
|
||||
default:
|
||||
ASSERT(0);
|
||||
break;
|
||||
|
|
|
|||
|
|
@ -929,6 +929,10 @@ int drm_atomic_connector_commit_dpms(struct drm_atomic_state *state,
|
|||
|
||||
if (mode != DRM_MODE_DPMS_ON)
|
||||
mode = DRM_MODE_DPMS_OFF;
|
||||
|
||||
if (connector->dpms == mode)
|
||||
goto out;
|
||||
|
||||
connector->dpms = mode;
|
||||
|
||||
crtc = connector->state->crtc;
|
||||
|
|
|
|||
|
|
@ -944,6 +944,10 @@ static const struct drm_prop_enum_list dp_colorspaces[] = {
|
|||
* implemented in the DRM core. This is the only standard connector
|
||||
* property that userspace can change.
|
||||
*
|
||||
* On atomic drivers any DPMS setproperty ioctl where the value does not
|
||||
* change is completely skipped, otherwise a full atomic commit will occur.
|
||||
* On legacy drivers the exact behavior is driver specific.
|
||||
*
|
||||
* Note that this property cannot be set through the MODE_ATOMIC ioctl,
|
||||
* userspace must use "ACTIVE" on the CRTC instead.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -277,6 +277,11 @@ static void mid_get_vbt_data(struct drm_psb_private *dev_priv)
|
|||
0, PCI_DEVFN(2, 0));
|
||||
int ret = -1;
|
||||
|
||||
if (pci_gfx_root == NULL) {
|
||||
WARN_ON(1);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Get the address of the platform config vbt */
|
||||
pci_read_config_dword(pci_gfx_root, 0xFC, &addr);
|
||||
pci_dev_put(pci_gfx_root);
|
||||
|
|
|
|||
|
|
@ -135,7 +135,7 @@ enum hdmi_aud_channel_swap_type {
|
|||
|
||||
struct hdmi_audio_param {
|
||||
enum hdmi_audio_coding_type aud_codec;
|
||||
enum hdmi_audio_sample_size aud_sampe_size;
|
||||
enum hdmi_audio_sample_size aud_sample_size;
|
||||
enum hdmi_aud_input_type aud_input_type;
|
||||
enum hdmi_aud_i2s_fmt aud_i2s_fmt;
|
||||
enum hdmi_aud_mclk aud_mclk;
|
||||
|
|
@ -1085,7 +1085,7 @@ static int mtk_hdmi_output_init(struct mtk_hdmi *hdmi)
|
|||
|
||||
hdmi->csp = HDMI_COLORSPACE_RGB;
|
||||
aud_param->aud_codec = HDMI_AUDIO_CODING_TYPE_PCM;
|
||||
aud_param->aud_sampe_size = HDMI_AUDIO_SAMPLE_SIZE_16;
|
||||
aud_param->aud_sample_size = HDMI_AUDIO_SAMPLE_SIZE_16;
|
||||
aud_param->aud_input_type = HDMI_AUD_INPUT_I2S;
|
||||
aud_param->aud_i2s_fmt = HDMI_I2S_MODE_I2S_24BIT;
|
||||
aud_param->aud_mclk = HDMI_AUD_MCLK_128FS;
|
||||
|
|
@ -1587,14 +1587,14 @@ static int mtk_hdmi_audio_hw_params(struct device *dev, void *data,
|
|||
switch (daifmt->fmt) {
|
||||
case HDMI_I2S:
|
||||
hdmi_params.aud_codec = HDMI_AUDIO_CODING_TYPE_PCM;
|
||||
hdmi_params.aud_sampe_size = HDMI_AUDIO_SAMPLE_SIZE_16;
|
||||
hdmi_params.aud_sample_size = HDMI_AUDIO_SAMPLE_SIZE_16;
|
||||
hdmi_params.aud_input_type = HDMI_AUD_INPUT_I2S;
|
||||
hdmi_params.aud_i2s_fmt = HDMI_I2S_MODE_I2S_24BIT;
|
||||
hdmi_params.aud_mclk = HDMI_AUD_MCLK_128FS;
|
||||
break;
|
||||
case HDMI_SPDIF:
|
||||
hdmi_params.aud_codec = HDMI_AUDIO_CODING_TYPE_PCM;
|
||||
hdmi_params.aud_sampe_size = HDMI_AUDIO_SAMPLE_SIZE_16;
|
||||
hdmi_params.aud_sample_size = HDMI_AUDIO_SAMPLE_SIZE_16;
|
||||
hdmi_params.aud_input_type = HDMI_AUD_INPUT_SPDIF;
|
||||
break;
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -759,7 +759,6 @@ nouveau_connector_force(struct drm_connector *connector)
|
|||
if (!nv_encoder) {
|
||||
NV_ERROR(drm, "can't find encoder to force %s on!\n",
|
||||
connector->name);
|
||||
connector->status = connector_status_disconnected;
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -558,7 +558,7 @@ int radeon_vce_cs_parse(struct radeon_cs_parser *p)
|
|||
{
|
||||
int session_idx = -1;
|
||||
bool destroyed = false, created = false, allocated = false;
|
||||
uint32_t tmp, handle = 0;
|
||||
uint32_t tmp = 0, handle = 0;
|
||||
uint32_t *size = &tmp;
|
||||
int i, r = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -188,11 +188,15 @@ v3d_tfu_job_run(struct drm_sched_job *sched_job)
|
|||
struct drm_device *dev = &v3d->drm;
|
||||
struct dma_fence *fence;
|
||||
|
||||
if (unlikely(job->base.base.s_fence->finished.error))
|
||||
return NULL;
|
||||
|
||||
v3d->tfu_job = job;
|
||||
|
||||
fence = v3d_fence_create(v3d, V3D_TFU);
|
||||
if (IS_ERR(fence))
|
||||
return NULL;
|
||||
|
||||
v3d->tfu_job = job;
|
||||
if (job->base.irq_fence)
|
||||
dma_fence_put(job->base.irq_fence);
|
||||
job->base.irq_fence = dma_fence_get(fence);
|
||||
|
|
@ -226,6 +230,9 @@ v3d_csd_job_run(struct drm_sched_job *sched_job)
|
|||
struct dma_fence *fence;
|
||||
int i;
|
||||
|
||||
if (unlikely(job->base.base.s_fence->finished.error))
|
||||
return NULL;
|
||||
|
||||
v3d->csd_job = job;
|
||||
|
||||
v3d_invalidate_caches(v3d);
|
||||
|
|
|
|||
|
|
@ -1010,6 +1010,7 @@
|
|||
#define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001 0x3001
|
||||
#define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3003 0x3003
|
||||
#define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3008 0x3008
|
||||
#define USB_DEVICE_ID_QUANTA_HP_5MP_CAMERA_5473 0x5473
|
||||
|
||||
#define I2C_VENDOR_ID_RAYDIUM 0x2386
|
||||
#define I2C_PRODUCT_ID_RAYDIUM_4B33 0x4b33
|
||||
|
|
|
|||
|
|
@ -6,9 +6,6 @@
|
|||
* Copyright (c) 2015-2018 Terry Junge <terry.junge@plantronics.com>
|
||||
*/
|
||||
|
||||
/*
|
||||
*/
|
||||
|
||||
#include "hid-ids.h"
|
||||
|
||||
#include <linux/hid.h>
|
||||
|
|
@ -23,30 +20,28 @@
|
|||
|
||||
#define PLT_VOL_UP 0x00b1
|
||||
#define PLT_VOL_DOWN 0x00b2
|
||||
#define PLT_MIC_MUTE 0x00b5
|
||||
|
||||
#define PLT1_VOL_UP (PLT_HID_1_0_PAGE | PLT_VOL_UP)
|
||||
#define PLT1_VOL_DOWN (PLT_HID_1_0_PAGE | PLT_VOL_DOWN)
|
||||
#define PLT1_MIC_MUTE (PLT_HID_1_0_PAGE | PLT_MIC_MUTE)
|
||||
#define PLT2_VOL_UP (PLT_HID_2_0_PAGE | PLT_VOL_UP)
|
||||
#define PLT2_VOL_DOWN (PLT_HID_2_0_PAGE | PLT_VOL_DOWN)
|
||||
#define PLT2_MIC_MUTE (PLT_HID_2_0_PAGE | PLT_MIC_MUTE)
|
||||
#define HID_TELEPHONY_MUTE (HID_UP_TELEPHONY | 0x2f)
|
||||
#define HID_CONSUMER_MUTE (HID_UP_CONSUMER | 0xe2)
|
||||
|
||||
#define PLT_DA60 0xda60
|
||||
#define PLT_BT300_MIN 0x0413
|
||||
#define PLT_BT300_MAX 0x0418
|
||||
|
||||
|
||||
#define PLT_ALLOW_CONSUMER (field->application == HID_CP_CONSUMERCONTROL && \
|
||||
(usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)
|
||||
|
||||
#define PLT_QUIRK_DOUBLE_VOLUME_KEYS BIT(0)
|
||||
#define PLT_QUIRK_FOLLOWED_OPPOSITE_VOLUME_KEYS BIT(1)
|
||||
|
||||
#define PLT_DOUBLE_KEY_TIMEOUT 5 /* ms */
|
||||
#define PLT_FOLLOWED_OPPOSITE_KEY_TIMEOUT 220 /* ms */
|
||||
|
||||
struct plt_drv_data {
|
||||
unsigned long device_type;
|
||||
unsigned long last_volume_key_ts;
|
||||
u32 quirks;
|
||||
unsigned long last_key_ts;
|
||||
unsigned long double_key_to;
|
||||
__u16 last_key;
|
||||
};
|
||||
|
||||
static int plantronics_input_mapping(struct hid_device *hdev,
|
||||
|
|
@ -58,34 +53,43 @@ static int plantronics_input_mapping(struct hid_device *hdev,
|
|||
unsigned short mapped_key;
|
||||
struct plt_drv_data *drv_data = hid_get_drvdata(hdev);
|
||||
unsigned long plt_type = drv_data->device_type;
|
||||
int allow_mute = usage->hid == HID_TELEPHONY_MUTE;
|
||||
int allow_consumer = field->application == HID_CP_CONSUMERCONTROL &&
|
||||
(usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER &&
|
||||
usage->hid != HID_CONSUMER_MUTE;
|
||||
|
||||
/* special case for PTT products */
|
||||
if (field->application == HID_GD_JOYSTICK)
|
||||
goto defaulted;
|
||||
|
||||
/* handle volume up/down mapping */
|
||||
/* non-standard types or multi-HID interfaces - plt_type is PID */
|
||||
if (!(plt_type & HID_USAGE_PAGE)) {
|
||||
switch (plt_type) {
|
||||
case PLT_DA60:
|
||||
if (PLT_ALLOW_CONSUMER)
|
||||
if (allow_consumer)
|
||||
goto defaulted;
|
||||
goto ignored;
|
||||
if (usage->hid == HID_CONSUMER_MUTE) {
|
||||
mapped_key = KEY_MICMUTE;
|
||||
goto mapped;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if (PLT_ALLOW_CONSUMER)
|
||||
if (allow_consumer || allow_mute)
|
||||
goto defaulted;
|
||||
}
|
||||
goto ignored;
|
||||
}
|
||||
/* handle standard types - plt_type is 0xffa0uuuu or 0xffa2uuuu */
|
||||
/* 'basic telephony compliant' - allow default consumer page map */
|
||||
else if ((plt_type & HID_USAGE) >= PLT_BASIC_TELEPHONY &&
|
||||
(plt_type & HID_USAGE) != PLT_BASIC_EXCEPTION) {
|
||||
if (PLT_ALLOW_CONSUMER)
|
||||
goto defaulted;
|
||||
}
|
||||
/* not 'basic telephony' - apply legacy mapping */
|
||||
/* only map if the field is in the device's primary vendor page */
|
||||
else if (!((field->application ^ plt_type) & HID_USAGE_PAGE)) {
|
||||
|
||||
/* handle standard consumer control mapping */
|
||||
/* and standard telephony mic mute mapping */
|
||||
if (allow_consumer || allow_mute)
|
||||
goto defaulted;
|
||||
|
||||
/* handle vendor unique types - plt_type is 0xffa0uuuu or 0xffa2uuuu */
|
||||
/* if not 'basic telephony compliant' - map vendor unique controls */
|
||||
if (!((plt_type & HID_USAGE) >= PLT_BASIC_TELEPHONY &&
|
||||
(plt_type & HID_USAGE) != PLT_BASIC_EXCEPTION) &&
|
||||
!((field->application ^ plt_type) & HID_USAGE_PAGE))
|
||||
switch (usage->hid) {
|
||||
case PLT1_VOL_UP:
|
||||
case PLT2_VOL_UP:
|
||||
|
|
@ -95,8 +99,11 @@ static int plantronics_input_mapping(struct hid_device *hdev,
|
|||
case PLT2_VOL_DOWN:
|
||||
mapped_key = KEY_VOLUMEDOWN;
|
||||
goto mapped;
|
||||
case PLT1_MIC_MUTE:
|
||||
case PLT2_MIC_MUTE:
|
||||
mapped_key = KEY_MICMUTE;
|
||||
goto mapped;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Future mapping of call control or other usages,
|
||||
|
|
@ -105,6 +112,8 @@ static int plantronics_input_mapping(struct hid_device *hdev,
|
|||
*/
|
||||
|
||||
ignored:
|
||||
hid_dbg(hdev, "usage: %08x (appl: %08x) - ignored\n",
|
||||
usage->hid, field->application);
|
||||
return -1;
|
||||
|
||||
defaulted:
|
||||
|
|
@ -123,38 +132,26 @@ static int plantronics_event(struct hid_device *hdev, struct hid_field *field,
|
|||
struct hid_usage *usage, __s32 value)
|
||||
{
|
||||
struct plt_drv_data *drv_data = hid_get_drvdata(hdev);
|
||||
unsigned long prev_tsto, cur_ts;
|
||||
__u16 prev_key, cur_key;
|
||||
|
||||
if (drv_data->quirks & PLT_QUIRK_DOUBLE_VOLUME_KEYS) {
|
||||
unsigned long prev_ts, cur_ts;
|
||||
/* Usages are filtered in plantronics_usages. */
|
||||
|
||||
/* Usages are filtered in plantronics_usages. */
|
||||
/* HZ too low for ms resolution - double key detection disabled */
|
||||
/* or it is a key release - handle key presses only. */
|
||||
if (!drv_data->double_key_to || !value)
|
||||
return 0;
|
||||
|
||||
if (!value) /* Handle key presses only. */
|
||||
return 0;
|
||||
prev_tsto = drv_data->last_key_ts + drv_data->double_key_to;
|
||||
cur_ts = drv_data->last_key_ts = jiffies;
|
||||
prev_key = drv_data->last_key;
|
||||
cur_key = drv_data->last_key = usage->code;
|
||||
|
||||
prev_ts = drv_data->last_volume_key_ts;
|
||||
cur_ts = jiffies;
|
||||
if (jiffies_to_msecs(cur_ts - prev_ts) <= PLT_DOUBLE_KEY_TIMEOUT)
|
||||
return 1; /* Ignore the repeated key. */
|
||||
|
||||
drv_data->last_volume_key_ts = cur_ts;
|
||||
/* If the same key occurs in <= double_key_to -- ignore it */
|
||||
if (prev_key == cur_key && time_before_eq(cur_ts, prev_tsto)) {
|
||||
hid_dbg(hdev, "double key %d ignored\n", cur_key);
|
||||
return 1; /* Ignore the repeated key. */
|
||||
}
|
||||
if (drv_data->quirks & PLT_QUIRK_FOLLOWED_OPPOSITE_VOLUME_KEYS) {
|
||||
unsigned long prev_ts, cur_ts;
|
||||
|
||||
/* Usages are filtered in plantronics_usages. */
|
||||
|
||||
if (!value) /* Handle key presses only. */
|
||||
return 0;
|
||||
|
||||
prev_ts = drv_data->last_volume_key_ts;
|
||||
cur_ts = jiffies;
|
||||
if (jiffies_to_msecs(cur_ts - prev_ts) <= PLT_FOLLOWED_OPPOSITE_KEY_TIMEOUT)
|
||||
return 1; /* Ignore the followed opposite volume key. */
|
||||
|
||||
drv_data->last_volume_key_ts = cur_ts;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -196,12 +193,16 @@ static int plantronics_probe(struct hid_device *hdev,
|
|||
ret = hid_parse(hdev);
|
||||
if (ret) {
|
||||
hid_err(hdev, "parse failed\n");
|
||||
goto err;
|
||||
return ret;
|
||||
}
|
||||
|
||||
drv_data->device_type = plantronics_device_type(hdev);
|
||||
drv_data->quirks = id->driver_data;
|
||||
drv_data->last_volume_key_ts = jiffies - msecs_to_jiffies(PLT_DOUBLE_KEY_TIMEOUT);
|
||||
drv_data->double_key_to = msecs_to_jiffies(PLT_DOUBLE_KEY_TIMEOUT);
|
||||
drv_data->last_key_ts = jiffies - drv_data->double_key_to;
|
||||
|
||||
/* if HZ does not allow ms resolution - disable double key detection */
|
||||
if (drv_data->double_key_to < PLT_DOUBLE_KEY_TIMEOUT)
|
||||
drv_data->double_key_to = 0;
|
||||
|
||||
hid_set_drvdata(hdev, drv_data);
|
||||
|
||||
|
|
@ -210,29 +211,10 @@ static int plantronics_probe(struct hid_device *hdev,
|
|||
if (ret)
|
||||
hid_err(hdev, "hw start failed\n");
|
||||
|
||||
err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct hid_device_id plantronics_devices[] = {
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
|
||||
USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3210_SERIES),
|
||||
.driver_data = PLT_QUIRK_DOUBLE_VOLUME_KEYS },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
|
||||
USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3220_SERIES),
|
||||
.driver_data = PLT_QUIRK_DOUBLE_VOLUME_KEYS },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
|
||||
USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3215_SERIES),
|
||||
.driver_data = PLT_QUIRK_DOUBLE_VOLUME_KEYS },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
|
||||
USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3225_SERIES),
|
||||
.driver_data = PLT_QUIRK_DOUBLE_VOLUME_KEYS },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
|
||||
USB_DEVICE_ID_PLANTRONICS_BLACKWIRE_3325_SERIES),
|
||||
.driver_data = PLT_QUIRK_FOLLOWED_OPPOSITE_VOLUME_KEYS },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS,
|
||||
USB_DEVICE_ID_PLANTRONICS_ENCOREPRO_500_SERIES),
|
||||
.driver_data = PLT_QUIRK_FOLLOWED_OPPOSITE_VOLUME_KEYS },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_PLANTRONICS, HID_ANY_ID) },
|
||||
{ }
|
||||
};
|
||||
|
|
@ -241,6 +223,14 @@ MODULE_DEVICE_TABLE(hid, plantronics_devices);
|
|||
static const struct hid_usage_id plantronics_usages[] = {
|
||||
{ HID_CP_VOLUMEUP, EV_KEY, HID_ANY_ID },
|
||||
{ HID_CP_VOLUMEDOWN, EV_KEY, HID_ANY_ID },
|
||||
{ HID_TELEPHONY_MUTE, EV_KEY, HID_ANY_ID },
|
||||
{ HID_CONSUMER_MUTE, EV_KEY, HID_ANY_ID },
|
||||
{ PLT2_VOL_UP, EV_KEY, HID_ANY_ID },
|
||||
{ PLT2_VOL_DOWN, EV_KEY, HID_ANY_ID },
|
||||
{ PLT2_MIC_MUTE, EV_KEY, HID_ANY_ID },
|
||||
{ PLT1_VOL_UP, EV_KEY, HID_ANY_ID },
|
||||
{ PLT1_VOL_DOWN, EV_KEY, HID_ANY_ID },
|
||||
{ PLT1_MIC_MUTE, EV_KEY, HID_ANY_ID },
|
||||
{ HID_TERMINATOR, HID_TERMINATOR, HID_TERMINATOR }
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -878,6 +878,7 @@ static const struct hid_device_id hid_ignore_list[] = {
|
|||
{ HID_USB_DEVICE(USB_VENDOR_ID_SYNAPTICS, USB_DEVICE_ID_SYNAPTICS_DPAD) },
|
||||
#endif
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },
|
||||
{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_HP_5MP_CAMERA_5473) },
|
||||
{ }
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -549,14 +549,14 @@ static void fw_reset_work_fn(struct work_struct *unused)
|
|||
static void _ish_sync_fw_clock(struct ishtp_device *dev)
|
||||
{
|
||||
static unsigned long prev_sync;
|
||||
uint64_t usec;
|
||||
struct ipc_time_update_msg time = {};
|
||||
|
||||
if (prev_sync && jiffies - prev_sync < 20 * HZ)
|
||||
return;
|
||||
|
||||
prev_sync = jiffies;
|
||||
usec = ktime_to_us(ktime_get_boottime());
|
||||
ipc_send_mng_msg(dev, MNG_SYNC_FW_CLOCK, &usec, sizeof(uint64_t));
|
||||
/* The fields of time would be updated while sending message */
|
||||
ipc_send_mng_msg(dev, MNG_SYNC_FW_CLOCK, &time, sizeof(time));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ static struct notifier_block hyperv_panic_block = {
|
|||
static const char *fb_mmio_name = "fb_range";
|
||||
static struct resource *fb_mmio;
|
||||
static struct resource *hyperv_mmio;
|
||||
static DEFINE_SEMAPHORE(hyperv_mmio_lock);
|
||||
static DEFINE_MUTEX(hyperv_mmio_lock);
|
||||
|
||||
static int vmbus_exists(void)
|
||||
{
|
||||
|
|
@ -2082,7 +2082,7 @@ int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
|
|||
int retval;
|
||||
|
||||
retval = -ENXIO;
|
||||
down(&hyperv_mmio_lock);
|
||||
mutex_lock(&hyperv_mmio_lock);
|
||||
|
||||
/*
|
||||
* If overlaps with frame buffers are allowed, then first attempt to
|
||||
|
|
@ -2137,7 +2137,7 @@ int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
|
|||
}
|
||||
|
||||
exit:
|
||||
up(&hyperv_mmio_lock);
|
||||
mutex_unlock(&hyperv_mmio_lock);
|
||||
return retval;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(vmbus_allocate_mmio);
|
||||
|
|
@ -2154,15 +2154,28 @@ void vmbus_free_mmio(resource_size_t start, resource_size_t size)
|
|||
{
|
||||
struct resource *iter;
|
||||
|
||||
down(&hyperv_mmio_lock);
|
||||
mutex_lock(&hyperv_mmio_lock);
|
||||
|
||||
/*
|
||||
* If all bytes of the MMIO range to be released are within the
|
||||
* special case fb_mmio shadow region, skip releasing the shadow
|
||||
* region since no corresponding __request_region() was done
|
||||
* in vmbus_allocate_mmio().
|
||||
*/
|
||||
if (fb_mmio && start >= fb_mmio->start &&
|
||||
(start + size - 1 <= fb_mmio->end))
|
||||
goto skip_shadow_release;
|
||||
|
||||
for (iter = hyperv_mmio; iter; iter = iter->sibling) {
|
||||
if ((iter->start >= start + size) || (iter->end <= start))
|
||||
continue;
|
||||
|
||||
__release_region(iter, start, size);
|
||||
}
|
||||
|
||||
skip_shadow_release:
|
||||
release_mem_region(start, size);
|
||||
up(&hyperv_mmio_lock);
|
||||
mutex_unlock(&hyperv_mmio_lock);
|
||||
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(vmbus_free_mmio);
|
||||
|
|
|
|||
|
|
@ -420,8 +420,8 @@ static const s8 NCT6776_BEEP_BITS[] = {
|
|||
static const u16 NCT6776_REG_TOLERANCE_H[] = {
|
||||
0x10c, 0x20c, 0x30c, 0x80c, 0x90c, 0xa0c, 0xb0c };
|
||||
|
||||
static const u8 NCT6776_REG_PWM_MODE[] = { 0x04, 0, 0, 0, 0, 0 };
|
||||
static const u8 NCT6776_PWM_MODE_MASK[] = { 0x01, 0, 0, 0, 0, 0 };
|
||||
static const u8 NCT6776_REG_PWM_MODE[] = { 0x04, 0, 0, 0, 0, 0, 0 };
|
||||
static const u8 NCT6776_PWM_MODE_MASK[] = { 0x01, 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
static const u16 NCT6776_REG_FAN_MIN[] = {
|
||||
0x63a, 0x63c, 0x63e, 0x640, 0x642, 0x64a, 0x64c };
|
||||
|
|
|
|||
|
|
@ -267,7 +267,7 @@ catu_init_sg_table(struct device *catu_dev, int node,
|
|||
* Each table can address upto 1MB and we can have
|
||||
* CATU_PAGES_PER_SYSPAGE tables in a system page.
|
||||
*/
|
||||
nr_tpages = DIV_ROUND_UP(size, SZ_1M) / CATU_PAGES_PER_SYSPAGE;
|
||||
nr_tpages = DIV_ROUND_UP(size, CATU_PAGES_PER_SYSPAGE * SZ_1M);
|
||||
catu_table = tmc_alloc_sg_table(catu_dev, node, nr_tpages,
|
||||
size >> PAGE_SHIFT, pages);
|
||||
if (IS_ERR(catu_table))
|
||||
|
|
|
|||
|
|
@ -490,6 +490,8 @@ MODULE_DEVICE_TABLE(pci, ali1535_ids);
|
|||
|
||||
static int ali1535_probe(struct pci_dev *dev, const struct pci_device_id *id)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (ali1535_setup(dev)) {
|
||||
dev_warn(&dev->dev,
|
||||
"ALI1535 not detected, module not inserted.\n");
|
||||
|
|
@ -501,7 +503,15 @@ static int ali1535_probe(struct pci_dev *dev, const struct pci_device_id *id)
|
|||
|
||||
snprintf(ali1535_adapter.name, sizeof(ali1535_adapter.name),
|
||||
"SMBus ALI1535 adapter at %04x", ali1535_offset);
|
||||
return i2c_add_adapter(&ali1535_adapter);
|
||||
ret = i2c_add_adapter(&ali1535_adapter);
|
||||
if (ret)
|
||||
goto release_region;
|
||||
|
||||
return 0;
|
||||
|
||||
release_region:
|
||||
release_region(ali1535_smba, ALI1535_SMB_IOSIZE);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void ali1535_remove(struct pci_dev *dev)
|
||||
|
|
|
|||
|
|
@ -473,6 +473,8 @@ MODULE_DEVICE_TABLE (pci, ali15x3_ids);
|
|||
|
||||
static int ali15x3_probe(struct pci_dev *dev, const struct pci_device_id *id)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (ali15x3_setup(dev)) {
|
||||
dev_err(&dev->dev,
|
||||
"ALI15X3 not detected, module not inserted.\n");
|
||||
|
|
@ -484,7 +486,15 @@ static int ali15x3_probe(struct pci_dev *dev, const struct pci_device_id *id)
|
|||
|
||||
snprintf(ali15x3_adapter.name, sizeof(ali15x3_adapter.name),
|
||||
"SMBus ALI15X3 adapter at %04x", ali15x3_smba);
|
||||
return i2c_add_adapter(&ali15x3_adapter);
|
||||
ret = i2c_add_adapter(&ali15x3_adapter);
|
||||
if (ret)
|
||||
goto release_region;
|
||||
|
||||
return 0;
|
||||
|
||||
release_region:
|
||||
release_region(ali15x3_smba, ALI15X3_SMB_IOSIZE);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void ali15x3_remove(struct pci_dev *dev)
|
||||
|
|
|
|||
|
|
@ -1049,23 +1049,6 @@ static int omap_i2c_transmit_data(struct omap_i2c_dev *omap, u8 num_bytes,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static irqreturn_t
|
||||
omap_i2c_isr(int irq, void *dev_id)
|
||||
{
|
||||
struct omap_i2c_dev *omap = dev_id;
|
||||
irqreturn_t ret = IRQ_HANDLED;
|
||||
u16 mask;
|
||||
u16 stat;
|
||||
|
||||
stat = omap_i2c_read_reg(omap, OMAP_I2C_STAT_REG);
|
||||
mask = omap_i2c_read_reg(omap, OMAP_I2C_IE_REG) & ~OMAP_I2C_STAT_NACK;
|
||||
|
||||
if (stat & mask)
|
||||
ret = IRQ_WAKE_THREAD;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int omap_i2c_xfer_data(struct omap_i2c_dev *omap)
|
||||
{
|
||||
u16 bits;
|
||||
|
|
@ -1096,8 +1079,13 @@ static int omap_i2c_xfer_data(struct omap_i2c_dev *omap)
|
|||
}
|
||||
|
||||
if (stat & OMAP_I2C_STAT_NACK) {
|
||||
err |= OMAP_I2C_STAT_NACK;
|
||||
omap->cmd_err |= OMAP_I2C_STAT_NACK;
|
||||
omap_i2c_ack_stat(omap, OMAP_I2C_STAT_NACK);
|
||||
|
||||
if (!(stat & ~OMAP_I2C_STAT_NACK)) {
|
||||
err = -EAGAIN;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (stat & OMAP_I2C_STAT_AL) {
|
||||
|
|
@ -1480,7 +1468,7 @@ omap_i2c_probe(struct platform_device *pdev)
|
|||
IRQF_NO_SUSPEND, pdev->name, omap);
|
||||
else
|
||||
r = devm_request_threaded_irq(&pdev->dev, omap->irq,
|
||||
omap_i2c_isr, omap_i2c_isr_thread,
|
||||
NULL, omap_i2c_isr_thread,
|
||||
IRQF_NO_SUSPEND | IRQF_ONESHOT,
|
||||
pdev->name, omap);
|
||||
|
||||
|
|
|
|||
|
|
@ -509,6 +509,8 @@ MODULE_DEVICE_TABLE(pci, sis630_ids);
|
|||
|
||||
static int sis630_probe(struct pci_dev *dev, const struct pci_device_id *id)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (sis630_setup(dev)) {
|
||||
dev_err(&dev->dev,
|
||||
"SIS630 compatible bus not detected, "
|
||||
|
|
@ -522,7 +524,15 @@ static int sis630_probe(struct pci_dev *dev, const struct pci_device_id *id)
|
|||
snprintf(sis630_adapter.name, sizeof(sis630_adapter.name),
|
||||
"SMBus SIS630 adapter at %04x", smbus_base + SMB_STS);
|
||||
|
||||
return i2c_add_adapter(&sis630_adapter);
|
||||
ret = i2c_add_adapter(&sis630_adapter);
|
||||
if (ret)
|
||||
goto release_region;
|
||||
|
||||
return 0;
|
||||
|
||||
release_region:
|
||||
release_region(smbus_base + SMB_STS, SIS630_SMB_IOREGION);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void sis630_remove(struct pci_dev *dev)
|
||||
|
|
|
|||
|
|
@ -710,7 +710,7 @@ static int mma8452_write_raw(struct iio_dev *indio_dev,
|
|||
int val, int val2, long mask)
|
||||
{
|
||||
struct mma8452_data *data = iio_priv(indio_dev);
|
||||
int i, ret;
|
||||
int i, j, ret;
|
||||
|
||||
ret = iio_device_claim_direct_mode(indio_dev);
|
||||
if (ret)
|
||||
|
|
@ -770,14 +770,18 @@ static int mma8452_write_raw(struct iio_dev *indio_dev,
|
|||
break;
|
||||
|
||||
case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
|
||||
ret = mma8452_get_odr_index(data);
|
||||
j = mma8452_get_odr_index(data);
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(mma8452_os_ratio); i++) {
|
||||
if (mma8452_os_ratio[i][ret] == val) {
|
||||
if (mma8452_os_ratio[i][j] == val) {
|
||||
ret = mma8452_set_power_mode(data, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == ARRAY_SIZE(mma8452_os_ratio)) {
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ret = -EINVAL;
|
||||
|
|
|
|||
|
|
@ -2926,11 +2926,11 @@ static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
|
|||
struct ib_mad_private *mad)
|
||||
{
|
||||
unsigned long flags;
|
||||
int post, ret;
|
||||
struct ib_mad_private *mad_priv;
|
||||
struct ib_sge sg_list;
|
||||
struct ib_recv_wr recv_wr;
|
||||
struct ib_mad_queue *recv_queue = &qp_info->recv_queue;
|
||||
int ret = 0;
|
||||
|
||||
/* Initialize common scatter list fields */
|
||||
sg_list.lkey = qp_info->port_priv->pd->local_dma_lkey;
|
||||
|
|
@ -2940,7 +2940,7 @@ static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
|
|||
recv_wr.sg_list = &sg_list;
|
||||
recv_wr.num_sge = 1;
|
||||
|
||||
do {
|
||||
while (true) {
|
||||
/* Allocate and map receive buffer */
|
||||
if (mad) {
|
||||
mad_priv = mad;
|
||||
|
|
@ -2948,10 +2948,8 @@ static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
|
|||
} else {
|
||||
mad_priv = alloc_mad_private(port_mad_size(qp_info->port_priv),
|
||||
GFP_ATOMIC);
|
||||
if (!mad_priv) {
|
||||
ret = -ENOMEM;
|
||||
break;
|
||||
}
|
||||
if (!mad_priv)
|
||||
return -ENOMEM;
|
||||
}
|
||||
sg_list.length = mad_priv_dma_size(mad_priv);
|
||||
sg_list.addr = ib_dma_map_single(qp_info->port_priv->device,
|
||||
|
|
@ -2960,37 +2958,41 @@ static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info,
|
|||
DMA_FROM_DEVICE);
|
||||
if (unlikely(ib_dma_mapping_error(qp_info->port_priv->device,
|
||||
sg_list.addr))) {
|
||||
kfree(mad_priv);
|
||||
ret = -ENOMEM;
|
||||
break;
|
||||
goto free_mad_priv;
|
||||
}
|
||||
mad_priv->header.mapping = sg_list.addr;
|
||||
mad_priv->header.mad_list.mad_queue = recv_queue;
|
||||
mad_priv->header.mad_list.cqe.done = ib_mad_recv_done;
|
||||
recv_wr.wr_cqe = &mad_priv->header.mad_list.cqe;
|
||||
|
||||
/* Post receive WR */
|
||||
spin_lock_irqsave(&recv_queue->lock, flags);
|
||||
post = (++recv_queue->count < recv_queue->max_active);
|
||||
list_add_tail(&mad_priv->header.mad_list.list, &recv_queue->list);
|
||||
if (recv_queue->count >= recv_queue->max_active) {
|
||||
/* Fully populated the receive queue */
|
||||
spin_unlock_irqrestore(&recv_queue->lock, flags);
|
||||
break;
|
||||
}
|
||||
recv_queue->count++;
|
||||
list_add_tail(&mad_priv->header.mad_list.list,
|
||||
&recv_queue->list);
|
||||
spin_unlock_irqrestore(&recv_queue->lock, flags);
|
||||
|
||||
ret = ib_post_recv(qp_info->qp, &recv_wr, NULL);
|
||||
if (ret) {
|
||||
spin_lock_irqsave(&recv_queue->lock, flags);
|
||||
list_del(&mad_priv->header.mad_list.list);
|
||||
recv_queue->count--;
|
||||
spin_unlock_irqrestore(&recv_queue->lock, flags);
|
||||
ib_dma_unmap_single(qp_info->port_priv->device,
|
||||
mad_priv->header.mapping,
|
||||
mad_priv_dma_size(mad_priv),
|
||||
DMA_FROM_DEVICE);
|
||||
kfree(mad_priv);
|
||||
dev_err(&qp_info->port_priv->device->dev,
|
||||
"ib_post_recv failed: %d\n", ret);
|
||||
break;
|
||||
}
|
||||
} while (post);
|
||||
}
|
||||
|
||||
ib_dma_unmap_single(qp_info->port_priv->device,
|
||||
mad_priv->header.mapping,
|
||||
mad_priv_dma_size(mad_priv), DMA_FROM_DEVICE);
|
||||
free_mad_priv:
|
||||
kfree(mad_priv);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1105,8 +1105,6 @@ static void __modify_flags_from_init_state(struct bnxt_qplib_qp *qp)
|
|||
qp->path_mtu =
|
||||
CMDQ_MODIFY_QP_PATH_MTU_MTU_2048;
|
||||
}
|
||||
qp->modify_flags &=
|
||||
~CMDQ_MODIFY_QP_MODIFY_MASK_VLAN_ID;
|
||||
/* Bono FW require the max_dest_rd_atomic to be >= 1 */
|
||||
if (qp->max_dest_rd_atomic < 1)
|
||||
qp->max_dest_rd_atomic = 1;
|
||||
|
|
|
|||
|
|
@ -198,7 +198,7 @@ static int hns_roce_query_device(struct ib_device *ib_dev,
|
|||
IB_DEVICE_RC_RNR_NAK_GEN;
|
||||
props->max_send_sge = hr_dev->caps.max_sq_sg;
|
||||
props->max_recv_sge = hr_dev->caps.max_rq_sg;
|
||||
props->max_sge_rd = 1;
|
||||
props->max_sge_rd = hr_dev->caps.max_sq_sg;
|
||||
props->max_cq = hr_dev->caps.num_cqs;
|
||||
props->max_cqe = hr_dev->caps.max_cqes;
|
||||
props->max_mr = hr_dev->caps.num_mtpts;
|
||||
|
|
|
|||
|
|
@ -483,7 +483,7 @@ repoll:
|
|||
}
|
||||
|
||||
qpn = ntohl(cqe64->sop_drop_qpn) & 0xffffff;
|
||||
if (!*cur_qp || (qpn != (*cur_qp)->ibqp.qp_num)) {
|
||||
if (!*cur_qp || (qpn != (*cur_qp)->trans_qp.base.mqp.qpn)) {
|
||||
/* We do not have to take the QP table lock here,
|
||||
* because CQs will be locked while QPs are removed
|
||||
* from the table.
|
||||
|
|
|
|||
|
|
@ -2701,8 +2701,11 @@ static void dib8000_set_dds(struct dib8000_state *state, s32 offset_khz)
|
|||
u8 ratio;
|
||||
|
||||
if (state->revision == 0x8090) {
|
||||
u32 internal = dib8000_read32(state, 23) / 1000;
|
||||
|
||||
ratio = 4;
|
||||
unit_khz_dds_val = (1<<26) / (dib8000_read32(state, 23) / 1000);
|
||||
|
||||
unit_khz_dds_val = (1<<26) / (internal ?: 1);
|
||||
if (offset_khz < 0)
|
||||
dds = (1 << 26) - (abs_offset_khz * unit_khz_dds_val);
|
||||
else
|
||||
|
|
|
|||
|
|
@ -813,6 +813,7 @@ static int rtsx_usb_ms_drv_remove(struct platform_device *pdev)
|
|||
|
||||
host->eject = true;
|
||||
cancel_work_sync(&host->handle_req);
|
||||
cancel_delayed_work_sync(&host->poll_card);
|
||||
|
||||
mutex_lock(&host->host_mutex);
|
||||
if (host->req) {
|
||||
|
|
|
|||
|
|
@ -920,7 +920,7 @@ static void sm501_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
|
|||
{
|
||||
struct sm501_gpio_chip *smchip = gpiochip_get_data(chip);
|
||||
struct sm501_gpio *smgpio = smchip->ourgpio;
|
||||
unsigned long bit = 1 << offset;
|
||||
unsigned long bit = BIT(offset);
|
||||
void __iomem *regs = smchip->regbase;
|
||||
unsigned long save;
|
||||
unsigned long val;
|
||||
|
|
@ -946,7 +946,7 @@ static int sm501_gpio_input(struct gpio_chip *chip, unsigned offset)
|
|||
struct sm501_gpio_chip *smchip = gpiochip_get_data(chip);
|
||||
struct sm501_gpio *smgpio = smchip->ourgpio;
|
||||
void __iomem *regs = smchip->regbase;
|
||||
unsigned long bit = 1 << offset;
|
||||
unsigned long bit = BIT(offset);
|
||||
unsigned long save;
|
||||
unsigned long ddr;
|
||||
|
||||
|
|
@ -971,7 +971,7 @@ static int sm501_gpio_output(struct gpio_chip *chip,
|
|||
{
|
||||
struct sm501_gpio_chip *smchip = gpiochip_get_data(chip);
|
||||
struct sm501_gpio *smgpio = smchip->ourgpio;
|
||||
unsigned long bit = 1 << offset;
|
||||
unsigned long bit = BIT(offset);
|
||||
void __iomem *regs = smchip->regbase;
|
||||
unsigned long save;
|
||||
unsigned long val;
|
||||
|
|
|
|||
|
|
@ -2502,8 +2502,10 @@ static int atmci_probe(struct platform_device *pdev)
|
|||
/* Get MCI capabilities and set operations according to it */
|
||||
atmci_get_cap(host);
|
||||
ret = atmci_configure_dma(host);
|
||||
if (ret == -EPROBE_DEFER)
|
||||
if (ret == -EPROBE_DEFER) {
|
||||
clk_disable_unprepare(host->mck);
|
||||
goto err_dma_probe_defer;
|
||||
}
|
||||
if (ret == 0) {
|
||||
host->prepare_data = &atmci_prepare_data_dma;
|
||||
host->submit_data = &atmci_submit_data_dma;
|
||||
|
|
|
|||
|
|
@ -401,6 +401,7 @@ static int sdhci_pxav3_probe(struct platform_device *pdev)
|
|||
if (!IS_ERR(pxa->clk_core))
|
||||
clk_prepare_enable(pxa->clk_core);
|
||||
|
||||
host->mmc->caps |= MMC_CAP_NEED_RSP_BUSY;
|
||||
/* enable 1/8V DDR capable */
|
||||
host->mmc->caps |= MMC_CAP_1_8V_DDR;
|
||||
|
||||
|
|
|
|||
|
|
@ -250,18 +250,33 @@ static int com20020pci_probe(struct pci_dev *pdev,
|
|||
card->tx_led.default_trigger = devm_kasprintf(&pdev->dev,
|
||||
GFP_KERNEL, "arc%d-%d-tx",
|
||||
dev->dev_id, i);
|
||||
if (!card->tx_led.default_trigger) {
|
||||
ret = -ENOMEM;
|
||||
goto err_free_arcdev;
|
||||
}
|
||||
card->tx_led.name = devm_kasprintf(&pdev->dev, GFP_KERNEL,
|
||||
"pci:green:tx:%d-%d",
|
||||
dev->dev_id, i);
|
||||
|
||||
if (!card->tx_led.name) {
|
||||
ret = -ENOMEM;
|
||||
goto err_free_arcdev;
|
||||
}
|
||||
card->tx_led.dev = &dev->dev;
|
||||
card->recon_led.brightness_set = led_recon_set;
|
||||
card->recon_led.default_trigger = devm_kasprintf(&pdev->dev,
|
||||
GFP_KERNEL, "arc%d-%d-recon",
|
||||
dev->dev_id, i);
|
||||
if (!card->recon_led.default_trigger) {
|
||||
ret = -ENOMEM;
|
||||
goto err_free_arcdev;
|
||||
}
|
||||
card->recon_led.name = devm_kasprintf(&pdev->dev, GFP_KERNEL,
|
||||
"pci:red:recon:%d-%d",
|
||||
dev->dev_id, i);
|
||||
if (!card->recon_led.name) {
|
||||
ret = -ENOMEM;
|
||||
goto err_free_arcdev;
|
||||
}
|
||||
card->recon_led.dev = &dev->dev;
|
||||
|
||||
ret = devm_led_classdev_register(&pdev->dev, &card->tx_led);
|
||||
|
|
|
|||
|
|
@ -1723,8 +1723,9 @@ static int __maybe_unused flexcan_suspend(struct device *device)
|
|||
}
|
||||
netif_stop_queue(dev);
|
||||
netif_device_detach(dev);
|
||||
|
||||
priv->can.state = CAN_STATE_SLEEPING;
|
||||
}
|
||||
priv->can.state = CAN_STATE_SLEEPING;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -1735,7 +1736,6 @@ static int __maybe_unused flexcan_resume(struct device *device)
|
|||
struct flexcan_priv *priv = netdev_priv(dev);
|
||||
int err = 0;
|
||||
|
||||
priv->can.state = CAN_STATE_ERROR_ACTIVE;
|
||||
if (netif_running(dev)) {
|
||||
netif_device_attach(dev);
|
||||
netif_start_queue(dev);
|
||||
|
|
@ -1747,6 +1747,8 @@ static int __maybe_unused flexcan_resume(struct device *device)
|
|||
} else {
|
||||
err = flexcan_chip_enable(priv);
|
||||
}
|
||||
|
||||
priv->can.state = CAN_STATE_ERROR_ACTIVE;
|
||||
}
|
||||
|
||||
return err;
|
||||
|
|
|
|||
|
|
@ -5151,13 +5151,13 @@ static int mv88e6xxx_probe(struct mdio_device *mdiodev)
|
|||
err = mv88e6xxx_switch_reset(chip);
|
||||
mv88e6xxx_reg_unlock(chip);
|
||||
if (err)
|
||||
goto out;
|
||||
goto out_phy;
|
||||
|
||||
if (np) {
|
||||
chip->irq = of_irq_get(np, 0);
|
||||
if (chip->irq == -EPROBE_DEFER) {
|
||||
err = chip->irq;
|
||||
goto out;
|
||||
goto out_phy;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -5176,7 +5176,7 @@ static int mv88e6xxx_probe(struct mdio_device *mdiodev)
|
|||
mv88e6xxx_reg_unlock(chip);
|
||||
|
||||
if (err)
|
||||
goto out;
|
||||
goto out_phy;
|
||||
|
||||
if (chip->info->g2_irqs > 0) {
|
||||
err = mv88e6xxx_g2_irq_setup(chip);
|
||||
|
|
@ -5216,6 +5216,8 @@ out_g1_irq:
|
|||
mv88e6xxx_g1_irq_free(chip);
|
||||
else
|
||||
mv88e6xxx_irq_poll_free(chip);
|
||||
out_phy:
|
||||
mv88e6xxx_phy_destroy(chip);
|
||||
out:
|
||||
if (pdata)
|
||||
dev_put(pdata->netdev);
|
||||
|
|
@ -5233,7 +5235,6 @@ static void mv88e6xxx_remove(struct mdio_device *mdiodev)
|
|||
mv88e6xxx_ptp_free(chip);
|
||||
}
|
||||
|
||||
mv88e6xxx_phy_destroy(chip);
|
||||
mv88e6xxx_unregister_switch(chip);
|
||||
mv88e6xxx_mdios_unregister(chip);
|
||||
|
||||
|
|
@ -5247,6 +5248,8 @@ static void mv88e6xxx_remove(struct mdio_device *mdiodev)
|
|||
mv88e6xxx_g1_irq_free(chip);
|
||||
else
|
||||
mv88e6xxx_irq_poll_free(chip);
|
||||
|
||||
mv88e6xxx_phy_destroy(chip);
|
||||
}
|
||||
|
||||
static const struct of_device_id mv88e6xxx_of_match[] = {
|
||||
|
|
|
|||
|
|
@ -197,7 +197,10 @@ static void mv88e6xxx_phy_ppu_state_init(struct mv88e6xxx_chip *chip)
|
|||
|
||||
static void mv88e6xxx_phy_ppu_state_destroy(struct mv88e6xxx_chip *chip)
|
||||
{
|
||||
mutex_lock(&chip->ppu_mutex);
|
||||
del_timer_sync(&chip->ppu_timer);
|
||||
cancel_work_sync(&chip->ppu_work);
|
||||
mutex_unlock(&chip->ppu_mutex);
|
||||
}
|
||||
|
||||
int mv88e6185_phy_ppu_read(struct mv88e6xxx_chip *chip, struct mii_bus *bus,
|
||||
|
|
|
|||
|
|
@ -1740,7 +1740,7 @@ static irqreturn_t rvu_mbox_intr_handler(int irq, void *rvu_irq)
|
|||
rvupf_write64(rvu, RVU_PF_VFPF_MBOX_INTX(1), intr);
|
||||
|
||||
rvu_queue_work(&rvu->afvf_wq_info, 64, vfs, intr);
|
||||
vfs -= 64;
|
||||
vfs = 64;
|
||||
}
|
||||
|
||||
intr = rvupf_read64(rvu, RVU_PF_VFPF_MBOX_INTX(0));
|
||||
|
|
|
|||
|
|
@ -4684,11 +4684,9 @@ static int mlx5e_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
|
|||
struct mlx5e_priv *priv = netdev_priv(dev);
|
||||
struct mlx5_core_dev *mdev = priv->mdev;
|
||||
u8 mode, setting;
|
||||
int err;
|
||||
|
||||
err = mlx5_eswitch_get_vepa(mdev->priv.eswitch, &setting);
|
||||
if (err)
|
||||
return err;
|
||||
if (mlx5_eswitch_get_vepa(mdev->priv.eswitch, &setting))
|
||||
return -EOPNOTSUPP;
|
||||
mode = setting ? BRIDGE_MODE_VEPA : BRIDGE_MODE_VEB;
|
||||
return ndo_dflt_bridge_getlink(skb, pid, seq, dev,
|
||||
mode,
|
||||
|
|
|
|||
|
|
@ -455,8 +455,10 @@ static int qlcnic_sriov_set_guest_vlan_mode(struct qlcnic_adapter *adapter,
|
|||
|
||||
num_vlans = sriov->num_allowed_vlans;
|
||||
sriov->allowed_vlans = kcalloc(num_vlans, sizeof(u16), GFP_KERNEL);
|
||||
if (!sriov->allowed_vlans)
|
||||
if (!sriov->allowed_vlans) {
|
||||
qlcnic_sriov_free_vlans(adapter);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
vlans = (u16 *)&cmd->rsp.arg[3];
|
||||
for (i = 0; i < num_vlans; i++)
|
||||
|
|
@ -2174,8 +2176,10 @@ int qlcnic_sriov_alloc_vlans(struct qlcnic_adapter *adapter)
|
|||
vf = &sriov->vf_info[i];
|
||||
vf->sriov_vlans = kcalloc(sriov->num_allowed_vlans,
|
||||
sizeof(*vf->sriov_vlans), GFP_KERNEL);
|
||||
if (!vf->sriov_vlans)
|
||||
if (!vf->sriov_vlans) {
|
||||
qlcnic_sriov_free_vlans(adapter);
|
||||
return -ENOMEM;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
|||
|
|
@ -1328,9 +1328,11 @@ static const struct usb_device_id products[] = {
|
|||
{QMI_QUIRK_SET_DTR(0x1bc7, 0x10a0, 0)}, /* Telit FN920C04 */
|
||||
{QMI_QUIRK_SET_DTR(0x1bc7, 0x10a4, 0)}, /* Telit FN920C04 */
|
||||
{QMI_QUIRK_SET_DTR(0x1bc7, 0x10a9, 0)}, /* Telit FN920C04 */
|
||||
{QMI_QUIRK_SET_DTR(0x1bc7, 0x10b0, 0)}, /* Telit FE990B */
|
||||
{QMI_QUIRK_SET_DTR(0x1bc7, 0x10c0, 0)}, /* Telit FE910C04 */
|
||||
{QMI_QUIRK_SET_DTR(0x1bc7, 0x10c4, 0)}, /* Telit FE910C04 */
|
||||
{QMI_QUIRK_SET_DTR(0x1bc7, 0x10c8, 0)}, /* Telit FE910C04 */
|
||||
{QMI_QUIRK_SET_DTR(0x1bc7, 0x10d0, 0)}, /* Telit FN990B */
|
||||
{QMI_FIXED_INTF(0x1bc7, 0x1100, 3)}, /* Telit ME910 */
|
||||
{QMI_FIXED_INTF(0x1bc7, 0x1101, 3)}, /* Telit ME910 dual modem */
|
||||
{QMI_FIXED_INTF(0x1bc7, 0x1200, 5)}, /* Telit LE920 */
|
||||
|
|
|
|||
|
|
@ -167,6 +167,17 @@ int usbnet_get_ethernet_addr(struct usbnet *dev, int iMACAddress)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(usbnet_get_ethernet_addr);
|
||||
|
||||
static bool usbnet_needs_usb_name_format(struct usbnet *dev, struct net_device *net)
|
||||
{
|
||||
/* Point to point devices which don't have a real MAC address
|
||||
* (or report a fake local one) have historically used the usb%d
|
||||
* naming. Preserve this..
|
||||
*/
|
||||
return (dev->driver_info->flags & FLAG_POINTTOPOINT) != 0 &&
|
||||
(is_zero_ether_addr(net->dev_addr) ||
|
||||
is_local_ether_addr(net->dev_addr));
|
||||
}
|
||||
|
||||
static void intr_complete (struct urb *urb)
|
||||
{
|
||||
struct usbnet *dev = urb->context;
|
||||
|
|
@ -1737,13 +1748,11 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
|
|||
if (status < 0)
|
||||
goto out1;
|
||||
|
||||
// heuristic: "usb%d" for links we know are two-host,
|
||||
// else "eth%d" when there's reasonable doubt. userspace
|
||||
// can rename the link if it knows better.
|
||||
/* heuristic: rename to "eth%d" if we are not sure this link
|
||||
* is two-host (these links keep "usb%d")
|
||||
*/
|
||||
if ((dev->driver_info->flags & FLAG_ETHER) != 0 &&
|
||||
((dev->driver_info->flags & FLAG_POINTTOPOINT) == 0 ||
|
||||
/* somebody touched it*/
|
||||
!is_zero_ether_addr(net->dev_addr)))
|
||||
!usbnet_needs_usb_name_format(dev, net))
|
||||
strscpy(net->name, "eth%d", sizeof(net->name));
|
||||
/* WLAN devices should always be named "wlan%d" */
|
||||
if ((dev->driver_info->flags & FLAG_WLAN) != 0)
|
||||
|
|
|
|||
|
|
@ -619,41 +619,71 @@ static void iwl_dump_prph(struct iwl_fw_runtime *fwrt,
|
|||
}
|
||||
|
||||
/*
|
||||
* alloc_sgtable - allocates scallerlist table in the given size,
|
||||
* fills it with pages and returns it
|
||||
* alloc_sgtable - allocates (chained) scatterlist in the given size,
|
||||
* fills it with pages and returns it
|
||||
* @size: the size (in bytes) of the table
|
||||
*/
|
||||
static struct scatterlist *alloc_sgtable(int size)
|
||||
*/
|
||||
static struct scatterlist *alloc_sgtable(ssize_t size)
|
||||
{
|
||||
int alloc_size, nents, i;
|
||||
struct page *new_page;
|
||||
struct scatterlist *iter;
|
||||
struct scatterlist *table;
|
||||
struct scatterlist *result = NULL, *prev;
|
||||
int nents, i, n_prev;
|
||||
|
||||
nents = DIV_ROUND_UP(size, PAGE_SIZE);
|
||||
table = kcalloc(nents, sizeof(*table), GFP_KERNEL);
|
||||
if (!table)
|
||||
return NULL;
|
||||
sg_init_table(table, nents);
|
||||
iter = table;
|
||||
for_each_sg(table, iter, sg_nents(table), i) {
|
||||
new_page = alloc_page(GFP_KERNEL);
|
||||
if (!new_page) {
|
||||
/* release all previous allocated pages in the table */
|
||||
iter = table;
|
||||
for_each_sg(table, iter, sg_nents(table), i) {
|
||||
new_page = sg_page(iter);
|
||||
if (new_page)
|
||||
__free_page(new_page);
|
||||
}
|
||||
kfree(table);
|
||||
|
||||
#define N_ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(*result))
|
||||
/*
|
||||
* We need an additional entry for table chaining,
|
||||
* this ensures the loop can finish i.e. we can
|
||||
* fit at least two entries per page (obviously,
|
||||
* many more really fit.)
|
||||
*/
|
||||
BUILD_BUG_ON(N_ENTRIES_PER_PAGE < 2);
|
||||
|
||||
while (nents > 0) {
|
||||
struct scatterlist *new, *iter;
|
||||
int n_fill, n_alloc;
|
||||
|
||||
if (nents <= N_ENTRIES_PER_PAGE) {
|
||||
/* last needed table */
|
||||
n_fill = nents;
|
||||
n_alloc = nents;
|
||||
nents = 0;
|
||||
} else {
|
||||
/* fill a page with entries */
|
||||
n_alloc = N_ENTRIES_PER_PAGE;
|
||||
/* reserve one for chaining */
|
||||
n_fill = n_alloc - 1;
|
||||
nents -= n_fill;
|
||||
}
|
||||
|
||||
new = kcalloc(n_alloc, sizeof(*new), GFP_KERNEL);
|
||||
if (!new) {
|
||||
if (result)
|
||||
_devcd_free_sgtable(result);
|
||||
return NULL;
|
||||
}
|
||||
alloc_size = min_t(int, size, PAGE_SIZE);
|
||||
size -= PAGE_SIZE;
|
||||
sg_set_page(iter, new_page, alloc_size, 0);
|
||||
sg_init_table(new, n_alloc);
|
||||
|
||||
if (!result)
|
||||
result = new;
|
||||
else
|
||||
sg_chain(prev, n_prev, new);
|
||||
prev = new;
|
||||
n_prev = n_alloc;
|
||||
|
||||
for_each_sg(new, iter, n_fill, i) {
|
||||
struct page *new_page = alloc_page(GFP_KERNEL);
|
||||
|
||||
if (!new_page) {
|
||||
_devcd_free_sgtable(result);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
sg_set_page(iter, new_page, PAGE_SIZE, 0);
|
||||
}
|
||||
}
|
||||
return table;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static void iwl_fw_get_prph_len(struct iwl_fw_runtime *fwrt,
|
||||
|
|
|
|||
|
|
@ -215,6 +215,9 @@ static int gen3_init_ntb(struct intel_ntb_dev *ndev)
|
|||
}
|
||||
|
||||
ndev->db_valid_mask = BIT_ULL(ndev->db_count) - 1;
|
||||
/* Make sure we are not using DB's used for link status */
|
||||
if (ndev->hwerr_flags & NTB_HWERR_MSIX_VECTOR32_BAD)
|
||||
ndev->db_valid_mask &= ~ndev->db_link_mask;
|
||||
|
||||
ndev->reg->db_iowrite(ndev->db_valid_mask,
|
||||
ndev->self_mmio +
|
||||
|
|
|
|||
|
|
@ -288,7 +288,7 @@ static int switchtec_ntb_mw_set_trans(struct ntb_dev *ntb, int pidx, int widx,
|
|||
if (xlate_pos < 12)
|
||||
return -EINVAL;
|
||||
|
||||
if (!IS_ALIGNED(addr, BIT_ULL(xlate_pos))) {
|
||||
if (xlate_pos >= 0 && !IS_ALIGNED(addr, BIT_ULL(xlate_pos))) {
|
||||
/*
|
||||
* In certain circumstances we can get a buffer that is
|
||||
* not aligned to its size. (Most of the time
|
||||
|
|
|
|||
|
|
@ -838,10 +838,8 @@ static int perf_copy_chunk(struct perf_thread *pthr,
|
|||
dma_set_unmap(tx, unmap);
|
||||
|
||||
ret = dma_submit_error(dmaengine_submit(tx));
|
||||
if (ret) {
|
||||
dmaengine_unmap_put(unmap);
|
||||
if (ret)
|
||||
goto err_free_resource;
|
||||
}
|
||||
|
||||
dmaengine_unmap_put(unmap);
|
||||
|
||||
|
|
|
|||
|
|
@ -351,8 +351,6 @@ bool nvme_change_ctrl_state(struct nvme_ctrl *ctrl,
|
|||
switch (new_state) {
|
||||
case NVME_CTRL_LIVE:
|
||||
switch (old_state) {
|
||||
case NVME_CTRL_NEW:
|
||||
case NVME_CTRL_RESETTING:
|
||||
case NVME_CTRL_CONNECTING:
|
||||
changed = true;
|
||||
/* FALLTHRU */
|
||||
|
|
|
|||
|
|
@ -3164,8 +3164,7 @@ nvme_fc_init_ctrl(struct device *dev, struct nvmf_ctrl_options *opts,
|
|||
list_add_tail(&ctrl->ctrl_list, &rport->ctrl_list);
|
||||
spin_unlock_irqrestore(&rport->lock, flags);
|
||||
|
||||
if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_RESETTING) ||
|
||||
!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING)) {
|
||||
if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING)) {
|
||||
dev_err(ctrl->ctrl.device,
|
||||
"NVME-FC{%d}: failed to init ctrl state\n", ctrl->cnum);
|
||||
goto fail_ctrl;
|
||||
|
|
|
|||
|
|
@ -777,6 +777,27 @@ out_err:
|
|||
nvmet_req_complete(&cmd->req, status);
|
||||
}
|
||||
|
||||
static bool nvmet_rdma_recv_not_live(struct nvmet_rdma_queue *queue,
|
||||
struct nvmet_rdma_rsp *rsp)
|
||||
{
|
||||
unsigned long flags;
|
||||
bool ret = true;
|
||||
|
||||
spin_lock_irqsave(&queue->state_lock, flags);
|
||||
/*
|
||||
* recheck queue state is not live to prevent a race condition
|
||||
* with RDMA_CM_EVENT_ESTABLISHED handler.
|
||||
*/
|
||||
if (queue->state == NVMET_RDMA_Q_LIVE)
|
||||
ret = false;
|
||||
else if (queue->state == NVMET_RDMA_Q_CONNECTING)
|
||||
list_add_tail(&rsp->wait_list, &queue->rsp_wait_list);
|
||||
else
|
||||
nvmet_rdma_put_rsp(rsp);
|
||||
spin_unlock_irqrestore(&queue->state_lock, flags);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void nvmet_rdma_recv_done(struct ib_cq *cq, struct ib_wc *wc)
|
||||
{
|
||||
struct nvmet_rdma_cmd *cmd =
|
||||
|
|
@ -818,17 +839,9 @@ static void nvmet_rdma_recv_done(struct ib_cq *cq, struct ib_wc *wc)
|
|||
rsp->req.port = queue->port;
|
||||
rsp->n_rdma = 0;
|
||||
|
||||
if (unlikely(queue->state != NVMET_RDMA_Q_LIVE)) {
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&queue->state_lock, flags);
|
||||
if (queue->state == NVMET_RDMA_Q_CONNECTING)
|
||||
list_add_tail(&rsp->wait_list, &queue->rsp_wait_list);
|
||||
else
|
||||
nvmet_rdma_put_rsp(rsp);
|
||||
spin_unlock_irqrestore(&queue->state_lock, flags);
|
||||
if (unlikely(queue->state != NVMET_RDMA_Q_LIVE) &&
|
||||
nvmet_rdma_recv_not_live(queue, rsp))
|
||||
return;
|
||||
}
|
||||
|
||||
nvmet_rdma_handle_command(queue, rsp);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -765,7 +765,9 @@ void pcie_enable_interrupt(struct controller *ctrl)
|
|||
{
|
||||
u16 mask;
|
||||
|
||||
mask = PCI_EXP_SLTCTL_HPIE | PCI_EXP_SLTCTL_DLLSCE;
|
||||
mask = PCI_EXP_SLTCTL_DLLSCE;
|
||||
if (!pciehp_poll_mode)
|
||||
mask |= PCI_EXP_SLTCTL_HPIE;
|
||||
pcie_write_cmd(ctrl, mask, mask);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1012,16 +1012,16 @@ void pcie_aspm_exit_link_state(struct pci_dev *pdev)
|
|||
parent_link = link->parent;
|
||||
|
||||
/*
|
||||
* link->downstream is a pointer to the pci_dev of function 0. If
|
||||
* we remove that function, the pci_dev is about to be deallocated,
|
||||
* so we can't use link->downstream again. Free the link state to
|
||||
* avoid this.
|
||||
* Free the parent link state, no later than function 0 (i.e.
|
||||
* link->downstream) being removed.
|
||||
*
|
||||
* If we're removing a non-0 function, it's possible we could
|
||||
* retain the link state, but PCIe r6.0, sec 7.5.3.7, recommends
|
||||
* programming the same ASPM Control value for all functions of
|
||||
* multi-function devices, so disable ASPM for all of them.
|
||||
* Do not free the link state any earlier. If function 0 is a
|
||||
* switch upstream port, this link state is parent_link to all
|
||||
* subordinate ones.
|
||||
*/
|
||||
if (pdev != link->downstream)
|
||||
goto out;
|
||||
|
||||
pcie_config_aspm_link(link, 0);
|
||||
list_del(&link->sibling);
|
||||
free_link_state(link);
|
||||
|
|
@ -1032,6 +1032,7 @@ void pcie_aspm_exit_link_state(struct pci_dev *pdev)
|
|||
pcie_config_aspm_path(parent_link);
|
||||
}
|
||||
|
||||
out:
|
||||
mutex_unlock(&aspm_lock);
|
||||
up_read(&pci_bus_sem);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -214,10 +214,12 @@ static int get_port_device_capability(struct pci_dev *dev)
|
|||
|
||||
/*
|
||||
* Disable hot-plug interrupts in case they have been enabled
|
||||
* by the BIOS and the hot-plug service driver is not loaded.
|
||||
* by the BIOS and the hot-plug service driver won't be loaded
|
||||
* to handle them.
|
||||
*/
|
||||
pcie_capability_clear_word(dev, PCI_EXP_SLTCTL,
|
||||
PCI_EXP_SLTCTL_CCIE | PCI_EXP_SLTCTL_HPIE);
|
||||
if (!IS_ENABLED(CONFIG_HOTPLUG_PCI_PCIE))
|
||||
pcie_capability_clear_word(dev, PCI_EXP_SLTCTL,
|
||||
PCI_EXP_SLTCTL_CCIE | PCI_EXP_SLTCTL_HPIE);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PCIEAER
|
||||
|
|
|
|||
|
|
@ -869,10 +869,9 @@ static int pci_register_host_bridge(struct pci_host_bridge *bridge)
|
|||
goto free;
|
||||
|
||||
err = device_add(&bridge->dev);
|
||||
if (err) {
|
||||
put_device(&bridge->dev);
|
||||
if (err)
|
||||
goto free;
|
||||
}
|
||||
|
||||
bus->bridge = get_device(&bridge->dev);
|
||||
device_enable_async_suspend(bus->bridge);
|
||||
pci_set_bus_of_node(bus);
|
||||
|
|
|
|||
|
|
@ -981,7 +981,7 @@ static const struct regmap_config bcm281xx_pinctrl_regmap_config = {
|
|||
.reg_bits = 32,
|
||||
.reg_stride = 4,
|
||||
.val_bits = 32,
|
||||
.max_register = BCM281XX_PIN_VC_CAM3_SDA,
|
||||
.max_register = BCM281XX_PIN_VC_CAM3_SDA * 4,
|
||||
};
|
||||
|
||||
static int bcm281xx_pinctrl_get_groups_count(struct pinctrl_dev *pctldev)
|
||||
|
|
|
|||
|
|
@ -253,6 +253,8 @@ static int rza2_gpio_register(struct rza2_pinctrl_priv *priv)
|
|||
return ret;
|
||||
}
|
||||
|
||||
of_node_put(of_args.np);
|
||||
|
||||
if ((of_args.args[0] != 0) ||
|
||||
(of_args.args[1] != 0) ||
|
||||
(of_args.args[2] != priv->npins)) {
|
||||
|
|
|
|||
|
|
@ -556,7 +556,7 @@ static int max77693_set_charge_input_threshold_volt(struct max77693_charger *chg
|
|||
case 4700000:
|
||||
case 4800000:
|
||||
case 4900000:
|
||||
data = (uvolt - 4700000) / 100000;
|
||||
data = ((uvolt - 4700000) / 100000) + 1;
|
||||
break;
|
||||
default:
|
||||
dev_err(chg->dev, "Wrong value for charge input voltage regulation threshold\n");
|
||||
|
|
|
|||
|
|
@ -627,8 +627,7 @@ struct powercap_control_type *powercap_register_control_type(
|
|||
dev_set_name(&control_type->dev, "%s", name);
|
||||
result = device_register(&control_type->dev);
|
||||
if (result) {
|
||||
if (control_type->allocated)
|
||||
kfree(control_type);
|
||||
put_device(&control_type->dev);
|
||||
return ERR_PTR(result);
|
||||
}
|
||||
idr_init(&control_type->idr);
|
||||
|
|
|
|||
|
|
@ -646,7 +646,8 @@ static int info_update(void)
|
|||
if (time_after(jiffies, chp_info_expires)) {
|
||||
/* Data is too old, update. */
|
||||
rc = sclp_chp_read_info(&chp_info);
|
||||
chp_info_expires = jiffies + CHP_INFO_UPDATE_INTERVAL ;
|
||||
if (!rc)
|
||||
chp_info_expires = jiffies + CHP_INFO_UPDATE_INTERVAL;
|
||||
}
|
||||
mutex_unlock(&info_lock);
|
||||
|
||||
|
|
|
|||
|
|
@ -2871,7 +2871,7 @@ qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
|
|||
dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
|
||||
cpu_to_le32(upper_32_bits(dma_handle)),
|
||||
cpu_to_le32(lower_32_bits(dma_handle)),
|
||||
cpu_to_le32(sg_dma_len(sg_next(s))));
|
||||
cpu_to_le32(sg_dma_len(s)));
|
||||
remseg--;
|
||||
}
|
||||
dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
|
||||
|
|
|
|||
|
|
@ -45,6 +45,9 @@ static int int3402_thermal_probe(struct platform_device *pdev)
|
|||
struct int3402_thermal_data *d;
|
||||
int ret;
|
||||
|
||||
if (!adev)
|
||||
return -ENODEV;
|
||||
|
||||
if (!acpi_has_method(adev->handle, "_TMP"))
|
||||
return -ENODEV;
|
||||
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ void serial8250_tx_dma_flush(struct uart_8250_port *p)
|
|||
*/
|
||||
dma->tx_size = 0;
|
||||
|
||||
dmaengine_terminate_async(dma->rxchan);
|
||||
dmaengine_terminate_async(dma->txchan);
|
||||
}
|
||||
|
||||
int serial8250_rx_dma(struct uart_8250_port *p)
|
||||
|
|
|
|||
|
|
@ -5151,6 +5151,14 @@ static const struct pci_device_id serial_pci_tbl[] = {
|
|||
PCI_ANY_ID, PCI_ANY_ID,
|
||||
0, 0,
|
||||
pbn_b2_2_115200 },
|
||||
{ PCI_VENDOR_ID_INTASHIELD, 0x0BA2,
|
||||
PCI_ANY_ID, PCI_ANY_ID,
|
||||
0, 0,
|
||||
pbn_b2_2_115200 },
|
||||
{ PCI_VENDOR_ID_INTASHIELD, 0x0BA3,
|
||||
PCI_ANY_ID, PCI_ANY_ID,
|
||||
0, 0,
|
||||
pbn_b2_2_115200 },
|
||||
/*
|
||||
* Brainboxes UC-235/246
|
||||
*/
|
||||
|
|
@ -5331,6 +5339,14 @@ static const struct pci_device_id serial_pci_tbl[] = {
|
|||
PCI_ANY_ID, PCI_ANY_ID,
|
||||
0, 0,
|
||||
pbn_b2_4_115200 },
|
||||
{ PCI_VENDOR_ID_INTASHIELD, 0x0C42,
|
||||
PCI_ANY_ID, PCI_ANY_ID,
|
||||
0, 0,
|
||||
pbn_b2_4_115200 },
|
||||
{ PCI_VENDOR_ID_INTASHIELD, 0x0C43,
|
||||
PCI_ANY_ID, PCI_ANY_ID,
|
||||
0, 0,
|
||||
pbn_b2_4_115200 },
|
||||
/*
|
||||
* Brainboxes UC-420
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -1057,6 +1057,20 @@ static const struct usb_device_id id_table_combined[] = {
|
|||
.driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
|
||||
/* GMC devices */
|
||||
{ USB_DEVICE(GMC_VID, GMC_Z216C_PID) },
|
||||
/* Altera USB Blaster 3 */
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_6022_PID, 1) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_6025_PID, 2) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_6026_PID, 2) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_6026_PID, 3) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_6029_PID, 2) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_602A_PID, 2) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_602A_PID, 3) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_602C_PID, 1) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_602D_PID, 1) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_602D_PID, 2) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_602E_PID, 1) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_602E_PID, 2) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(ALTERA_VID, ALTERA_UB3_602E_PID, 3) },
|
||||
{ } /* Terminating entry */
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1605,3 +1605,16 @@
|
|||
*/
|
||||
#define GMC_VID 0x1cd7
|
||||
#define GMC_Z216C_PID 0x0217 /* GMC Z216C Adapter IR-USB */
|
||||
|
||||
/*
|
||||
* Altera USB Blaster 3 (http://www.altera.com).
|
||||
*/
|
||||
#define ALTERA_VID 0x09fb
|
||||
#define ALTERA_UB3_6022_PID 0x6022
|
||||
#define ALTERA_UB3_6025_PID 0x6025
|
||||
#define ALTERA_UB3_6026_PID 0x6026
|
||||
#define ALTERA_UB3_6029_PID 0x6029
|
||||
#define ALTERA_UB3_602A_PID 0x602a
|
||||
#define ALTERA_UB3_602C_PID 0x602c
|
||||
#define ALTERA_UB3_602D_PID 0x602d
|
||||
#define ALTERA_UB3_602E_PID 0x602e
|
||||
|
|
|
|||
|
|
@ -1368,13 +1368,13 @@ static const struct usb_device_id option_ids[] = {
|
|||
.driver_info = NCTRL(0) | RSVD(1) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1075, 0xff), /* Telit FN990A (PCIe) */
|
||||
.driver_info = RSVD(0) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1080, 0xff), /* Telit FE990 (rmnet) */
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1080, 0xff), /* Telit FE990A (rmnet) */
|
||||
.driver_info = NCTRL(0) | RSVD(1) | RSVD(2) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1081, 0xff), /* Telit FE990 (MBIM) */
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1081, 0xff), /* Telit FE990A (MBIM) */
|
||||
.driver_info = NCTRL(0) | RSVD(1) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1082, 0xff), /* Telit FE990 (RNDIS) */
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1082, 0xff), /* Telit FE990A (RNDIS) */
|
||||
.driver_info = NCTRL(2) | RSVD(3) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1083, 0xff), /* Telit FE990 (ECM) */
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1083, 0xff), /* Telit FE990A (ECM) */
|
||||
.driver_info = NCTRL(0) | RSVD(1) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10a0, 0xff), /* Telit FN20C04 (rmnet) */
|
||||
.driver_info = RSVD(0) | NCTRL(3) },
|
||||
|
|
@ -1388,28 +1388,44 @@ static const struct usb_device_id option_ids[] = {
|
|||
.driver_info = RSVD(0) | NCTRL(2) | RSVD(3) | RSVD(4) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10aa, 0xff), /* Telit FN920C04 (MBIM) */
|
||||
.driver_info = NCTRL(3) | RSVD(4) | RSVD(5) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b0, 0xff, 0xff, 0x30), /* Telit FE990B (rmnet) */
|
||||
.driver_info = NCTRL(5) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b0, 0xff, 0xff, 0x40) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b0, 0xff, 0xff, 0x60) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b1, 0xff, 0xff, 0x30), /* Telit FE990B (MBIM) */
|
||||
.driver_info = NCTRL(6) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b1, 0xff, 0xff, 0x40) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b1, 0xff, 0xff, 0x60) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b2, 0xff, 0xff, 0x30), /* Telit FE990B (RNDIS) */
|
||||
.driver_info = NCTRL(6) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b2, 0xff, 0xff, 0x40) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b2, 0xff, 0xff, 0x60) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b3, 0xff, 0xff, 0x30), /* Telit FE990B (ECM) */
|
||||
.driver_info = NCTRL(6) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b3, 0xff, 0xff, 0x40) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10b3, 0xff, 0xff, 0x60) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10c0, 0xff), /* Telit FE910C04 (rmnet) */
|
||||
.driver_info = RSVD(0) | NCTRL(3) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10c4, 0xff), /* Telit FE910C04 (rmnet) */
|
||||
.driver_info = RSVD(0) | NCTRL(3) },
|
||||
{ USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x10c8, 0xff), /* Telit FE910C04 (rmnet) */
|
||||
.driver_info = RSVD(0) | NCTRL(2) | RSVD(3) | RSVD(4) },
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d0, 0x60) }, /* Telit FN990B (rmnet) */
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d0, 0x40) },
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d0, 0x30),
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d0, 0xff, 0xff, 0x30), /* Telit FN990B (rmnet) */
|
||||
.driver_info = NCTRL(5) },
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d1, 0x60) }, /* Telit FN990B (MBIM) */
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d1, 0x40) },
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d1, 0x30),
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d0, 0xff, 0xff, 0x40) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d0, 0xff, 0xff, 0x60) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d1, 0xff, 0xff, 0x30), /* Telit FN990B (MBIM) */
|
||||
.driver_info = NCTRL(6) },
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d2, 0x60) }, /* Telit FN990B (RNDIS) */
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d2, 0x40) },
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d2, 0x30),
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d1, 0xff, 0xff, 0x40) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d1, 0xff, 0xff, 0x60) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d2, 0xff, 0xff, 0x30), /* Telit FN990B (RNDIS) */
|
||||
.driver_info = NCTRL(6) },
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d3, 0x60) }, /* Telit FN990B (ECM) */
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d3, 0x40) },
|
||||
{ USB_DEVICE_INTERFACE_PROTOCOL(TELIT_VENDOR_ID, 0x10d3, 0x30),
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d2, 0xff, 0xff, 0x40) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d2, 0xff, 0xff, 0x60) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d3, 0xff, 0xff, 0x30), /* Telit FN990B (ECM) */
|
||||
.driver_info = NCTRL(6) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d3, 0xff, 0xff, 0x40) },
|
||||
{ USB_DEVICE_AND_INTERFACE_INFO(TELIT_VENDOR_ID, 0x10d3, 0xff, 0xff, 0x60) },
|
||||
{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_ME910),
|
||||
.driver_info = NCTRL(0) | RSVD(1) | RSVD(3) },
|
||||
{ USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_ME910_DUAL_MODEM),
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ config VGA_CONSOLE
|
|||
Say Y.
|
||||
|
||||
config MDA_CONSOLE
|
||||
depends on !M68K && !PARISC && ISA
|
||||
depends on VGA_CONSOLE && ISA
|
||||
tristate "MDA text console (dual-headed)"
|
||||
---help---
|
||||
Say Y here if you have an old MDA or monochrome Hercules graphics
|
||||
|
|
|
|||
|
|
@ -137,13 +137,15 @@ static int au1100fb_fb_blank(int blank_mode, struct fb_info *fbi)
|
|||
*/
|
||||
int au1100fb_setmode(struct au1100fb_device *fbdev)
|
||||
{
|
||||
struct fb_info *info = &fbdev->info;
|
||||
struct fb_info *info;
|
||||
u32 words;
|
||||
int index;
|
||||
|
||||
if (!fbdev)
|
||||
return -EINVAL;
|
||||
|
||||
info = &fbdev->info;
|
||||
|
||||
/* Update var-dependent FB info */
|
||||
if (panel_is_active(fbdev->panel) || panel_is_color(fbdev->panel)) {
|
||||
if (info->var.bits_per_pixel <= 8) {
|
||||
|
|
|
|||
|
|
@ -326,6 +326,13 @@ static int sm501fb_check_var(struct fb_var_screeninfo *var,
|
|||
if (var->xres_virtual > 4096 || var->yres_virtual > 2048)
|
||||
return -EINVAL;
|
||||
|
||||
/* geometry sanity checks */
|
||||
if (var->xres + var->xoffset > var->xres_virtual)
|
||||
return -EINVAL;
|
||||
|
||||
if (var->yres + var->yoffset > var->yres_virtual)
|
||||
return -EINVAL;
|
||||
|
||||
/* can cope with 8,16 or 32bpp */
|
||||
|
||||
if (var->bits_per_pixel <= 8)
|
||||
|
|
|
|||
|
|
@ -596,7 +596,7 @@ affs_extent_file_ofs(struct inode *inode, u32 newsize)
|
|||
BUG_ON(tmp > bsize);
|
||||
AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA);
|
||||
AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino);
|
||||
AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx);
|
||||
AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx + 1);
|
||||
AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp);
|
||||
affs_fix_checksum(sb, bh);
|
||||
bh->b_state &= ~(1UL << BH_New);
|
||||
|
|
@ -724,7 +724,8 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
|
|||
tmp = min(bsize - boff, to - from);
|
||||
BUG_ON(boff + tmp > bsize || tmp > bsize);
|
||||
memcpy(AFFS_DATA(bh) + boff, data + from, tmp);
|
||||
be32_add_cpu(&AFFS_DATA_HEAD(bh)->size, tmp);
|
||||
AFFS_DATA_HEAD(bh)->size = cpu_to_be32(
|
||||
max(boff + tmp, be32_to_cpu(AFFS_DATA_HEAD(bh)->size)));
|
||||
affs_fix_checksum(sb, bh);
|
||||
mark_buffer_dirty_inode(bh, inode);
|
||||
written += tmp;
|
||||
|
|
@ -746,7 +747,7 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
|
|||
if (buffer_new(bh)) {
|
||||
AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA);
|
||||
AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino);
|
||||
AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx);
|
||||
AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx + 1);
|
||||
AFFS_DATA_HEAD(bh)->size = cpu_to_be32(bsize);
|
||||
AFFS_DATA_HEAD(bh)->next = 0;
|
||||
bh->b_state &= ~(1UL << BH_New);
|
||||
|
|
@ -780,7 +781,7 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
|
|||
if (buffer_new(bh)) {
|
||||
AFFS_DATA_HEAD(bh)->ptype = cpu_to_be32(T_DATA);
|
||||
AFFS_DATA_HEAD(bh)->key = cpu_to_be32(inode->i_ino);
|
||||
AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx);
|
||||
AFFS_DATA_HEAD(bh)->sequence = cpu_to_be32(bidx + 1);
|
||||
AFFS_DATA_HEAD(bh)->size = cpu_to_be32(tmp);
|
||||
AFFS_DATA_HEAD(bh)->next = 0;
|
||||
bh->b_state &= ~(1UL << BH_New);
|
||||
|
|
|
|||
|
|
@ -1312,7 +1312,7 @@ static const char *fuse_get_link(struct dentry *dentry, struct inode *inode,
|
|||
goto out_err;
|
||||
|
||||
if (fc->cache_symlinks)
|
||||
return page_get_link(dentry, inode, callback);
|
||||
return page_get_link_raw(dentry, inode, callback);
|
||||
|
||||
err = -ECHILD;
|
||||
if (!dentry)
|
||||
|
|
|
|||
|
|
@ -147,7 +147,8 @@ static int do_isofs_readdir(struct inode *inode, struct file *file,
|
|||
de = tmpde;
|
||||
}
|
||||
/* Basic sanity check, whether name doesn't exceed dir entry */
|
||||
if (de_len < de->name_len[0] +
|
||||
if (de_len < sizeof(struct iso_directory_record) ||
|
||||
de_len < de->name_len[0] +
|
||||
sizeof(struct iso_directory_record)) {
|
||||
printk(KERN_NOTICE "iso9660: Corrupted directory entry"
|
||||
" in block %lu of inode %lu\n", block,
|
||||
|
|
|
|||
|
|
@ -117,7 +117,8 @@ do { \
|
|||
if (!(RC)) { \
|
||||
if (((P)->header.nextindex > \
|
||||
(((BN) == 0) ? DTROOTMAXSLOT : (P)->header.maxslot)) || \
|
||||
((BN) && ((P)->header.maxslot > DTPAGEMAXSLOT))) { \
|
||||
((BN) && (((P)->header.maxslot > DTPAGEMAXSLOT) || \
|
||||
((P)->header.stblindex >= DTPAGEMAXSLOT)))) { \
|
||||
BT_PUTPAGE(MP); \
|
||||
jfs_error((IP)->i_sb, \
|
||||
"DT_GETPAGE: dtree page corrupt\n"); \
|
||||
|
|
|
|||
|
|
@ -559,11 +559,16 @@ static int ea_get(struct inode *inode, struct ea_buffer *ea_buf, int min_size)
|
|||
|
||||
size_check:
|
||||
if (EALIST_SIZE(ea_buf->xattr) != ea_size) {
|
||||
int size = clamp_t(int, ea_size, 0, EALIST_SIZE(ea_buf->xattr));
|
||||
if (unlikely(EALIST_SIZE(ea_buf->xattr) > INT_MAX)) {
|
||||
printk(KERN_ERR "ea_get: extended attribute size too large: %u > INT_MAX\n",
|
||||
EALIST_SIZE(ea_buf->xattr));
|
||||
} else {
|
||||
int size = clamp_t(int, ea_size, 0, EALIST_SIZE(ea_buf->xattr));
|
||||
|
||||
printk(KERN_ERR "ea_get: invalid extended attribute\n");
|
||||
print_hex_dump(KERN_ERR, "", DUMP_PREFIX_ADDRESS, 16, 1,
|
||||
ea_buf->xattr, size, 1);
|
||||
printk(KERN_ERR "ea_get: invalid extended attribute\n");
|
||||
print_hex_dump(KERN_ERR, "", DUMP_PREFIX_ADDRESS, 16, 1,
|
||||
ea_buf->xattr, size, 1);
|
||||
}
|
||||
ea_release(inode, ea_buf);
|
||||
rc = -EIO;
|
||||
goto clean_up;
|
||||
|
|
|
|||
24
fs/namei.c
24
fs/namei.c
|
|
@ -4943,10 +4943,9 @@ const char *vfs_get_link(struct dentry *dentry, struct delayed_call *done)
|
|||
EXPORT_SYMBOL(vfs_get_link);
|
||||
|
||||
/* get the link contents into pagecache */
|
||||
const char *page_get_link(struct dentry *dentry, struct inode *inode,
|
||||
struct delayed_call *callback)
|
||||
static char *__page_get_link(struct dentry *dentry, struct inode *inode,
|
||||
struct delayed_call *callback)
|
||||
{
|
||||
char *kaddr;
|
||||
struct page *page;
|
||||
struct address_space *mapping = inode->i_mapping;
|
||||
|
||||
|
|
@ -4965,8 +4964,23 @@ const char *page_get_link(struct dentry *dentry, struct inode *inode,
|
|||
}
|
||||
set_delayed_call(callback, page_put_link, page);
|
||||
BUG_ON(mapping_gfp_mask(mapping) & __GFP_HIGHMEM);
|
||||
kaddr = page_address(page);
|
||||
nd_terminate_link(kaddr, inode->i_size, PAGE_SIZE - 1);
|
||||
return page_address(page);
|
||||
}
|
||||
|
||||
const char *page_get_link_raw(struct dentry *dentry, struct inode *inode,
|
||||
struct delayed_call *callback)
|
||||
{
|
||||
return __page_get_link(dentry, inode, callback);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(page_get_link_raw);
|
||||
|
||||
const char *page_get_link(struct dentry *dentry, struct inode *inode,
|
||||
struct delayed_call *callback)
|
||||
{
|
||||
char *kaddr = __page_get_link(dentry, inode, callback);
|
||||
|
||||
if (!IS_ERR(kaddr))
|
||||
nd_terminate_link(kaddr, inode->i_size, PAGE_SIZE - 1);
|
||||
return kaddr;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1799,6 +1799,14 @@ static int __ocfs2_find_path(struct ocfs2_caching_info *ci,
|
|||
|
||||
el = root_el;
|
||||
while (el->l_tree_depth) {
|
||||
if (unlikely(le16_to_cpu(el->l_tree_depth) >= OCFS2_MAX_PATH_DEPTH)) {
|
||||
ocfs2_error(ocfs2_metadata_cache_get_super(ci),
|
||||
"Owner %llu has invalid tree depth %u in extent list\n",
|
||||
(unsigned long long)ocfs2_metadata_cache_owner(ci),
|
||||
le16_to_cpu(el->l_tree_depth));
|
||||
ret = -EROFS;
|
||||
goto out;
|
||||
}
|
||||
if (le16_to_cpu(el->l_next_free_rec) == 0) {
|
||||
ocfs2_error(ocfs2_metadata_cache_get_super(ci),
|
||||
"Owner %llu has empty extent list at depth %u\n",
|
||||
|
|
|
|||
|
|
@ -414,7 +414,7 @@ static const struct file_operations proc_pid_cmdline_ops = {
|
|||
#ifdef CONFIG_KALLSYMS
|
||||
/*
|
||||
* Provides a wchan file via kallsyms in a proper one-value-per-file format.
|
||||
* Returns the resolved symbol. If that fails, simply return the address.
|
||||
* Returns the resolved symbol to user space.
|
||||
*/
|
||||
static int proc_pid_wchan(struct seq_file *m, struct pid_namespace *ns,
|
||||
struct pid *pid, struct task_struct *task)
|
||||
|
|
|
|||
|
|
@ -3317,6 +3317,8 @@ extern const struct file_operations generic_ro_fops;
|
|||
|
||||
extern int readlink_copy(char __user *, int, const char *);
|
||||
extern int page_readlink(struct dentry *, char __user *, int);
|
||||
extern const char *page_get_link_raw(struct dentry *, struct inode *,
|
||||
struct delayed_call *);
|
||||
extern const char *page_get_link(struct dentry *, struct inode *,
|
||||
struct delayed_call *);
|
||||
extern void page_put_link(void *);
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue