This is the 5.4.132 stable release
-----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAmDu+p0ACgkQONu9yGCS aT5SOw/9F58e4gz7PSTn4A9oCTNodRPe9B9rzf3y1Ol0k7T1aeQoWsPFOkZpNSOJ tdOGEXnwYnLpMC7nuFshWv1uKGAL/weHADyGV6J37AntYFjpEFhJhSH7pGGhDk7V EeIl98luBynPXOKNnDvcrQweeRaHKOInQBT8JJzwwsZbF2oqfOqdU0A787BiRu+3 zoi/mV0upDB443ji/JY0xj+o4jlbsuD0WxEqgkcD2YHL+QvU5Wr0mGys7m5gG9x7 TpKpMic0ILrF1vt/znLL5rOlX497prTvZ74ZXV/DYizeYxqtl/UG3CZjo1uf2yqk pAXA57paz6DY2Ct+3QbJBeuer27bTz6SCClSS1om9AcUk6oNSdULmMdTGvQb0SLU wx1Cy8b2ei04SVl96+McKKZ6ln47LJediGn0qIdwC6O/XHHrLq4u5PkSnQxRU4pA GH1tP5oYy4GzL9RbBeiDJQETFiXwkexSEWVyuSc6BhqQXao9yVzmLQbL1zgjH/zO m/tckZ3vEg+ll8j4QJCisHRyqYhwfru4PsJQH9Q7q6CtIuGOsd0Z/OUcLuF6knXg jDOrDIykE/PnkQ2Dc2RhdONP1ud5j3oBnHvNHs6FDghRKjaixMQzg3g/RNtnAaTj +7Xsfbi6ntpZSDOaY7YNgt+ZH3l4YRnUL/xBA6qIygayz374nzI= =LU0G -----END PGP SIGNATURE----- gpgsig -----BEGIN PGP SIGNATURE----- iQIzBAABCgAdFiEEdQaENiSDAlGTDEbB7G51OISzHs0FAmD25ikACgkQ7G51OISz Hs1dcw/8DKef1hGC5O2WKfpInTYtgnClkyD5/yOnGAPMvMRDGybA3dRejpIEefNM Qol1XICjb0wdBDV0I+n+fnGbBgaX3g0N/pn16pdbbSPBBe1L+d97gZNZznDGHYZu 033qtbxii8e0QTxTvO7nx4L80ZZsyPLchpPxowS/vd1Ezti+pTIU4y43MCc2jYLL KqUBDz72TkPLhgVZdDJ1z9gb+OoJ+sJPaeBrO57hpY/os9SxlMPeY56YrD3Hyfy5 IHZw3bTCDiIXpHBaJG8fvuudaM5M8V3dbD6oXnEPo1Gzb1Y7WR4Z7q28g7arSYjP fMPd243mCXd1V7LpmapxXvFsnbdsA7oauTho50dwmEvxQf9jEgX6thBWAFsrItaS crHdOppS7Lc3FK8cTMxZd6ZyZpaU6sF183tMOteuhtwmF/uoy1LBHqLnAvtfWYrl InGcImgABRkiYBRyODlgC4UNLd49Svon/8HcbBZlmeGIkosXjo5r1itnipgnF/TB /NkHRkixYTBCnJZyx+9Lihqw+HMnHVfjOnIBjbXjzX9ITH/tiMn4y87E+x9vRQqr Td5AKJwiSXSWZBQoX+XNLqXRwjZKHVQe45J4gzL9dhCzi9bwK99BvBPWr8+JyI7w 83YQfkhPju47+KFrEN6DUBxdYrROsJLsjgdTl38IlCi4SKoQSkE= =Li9I -----END PGP SIGNATURE----- Merge tag 'v5.4.132' into 5.4-2.3.x-imx This is the 5.4.132 stable release Conflicts (manual resolve): - drivers/gpu/drm/rockchip/cdn-dp-core.c: Fix merge hiccup when integrating upstream commit450c25b8a4
("drm/rockchip: cdn-dp-core: add missing clk_disable_unprepare() on error in cdn_dp_grf_write()") - drivers/perf/fsl_imx8_ddr_perf.c: Port upstream commit3fea9b708a
("drivers/perf: fix the missed ida_simple_remove() in ddr_perf_probe()") manually to NXP version. Signed-off-by: Andrey Zhizhikin <andrey.zhizhikin@leica-geosystems.com>
This commit is contained in:
commit
e9646ca701
|
@ -42,8 +42,30 @@ Description:
|
|||
modification of EVM-protected metadata and
|
||||
disable all further modification of policy
|
||||
|
||||
Note that once a key has been loaded, it will no longer be
|
||||
possible to enable metadata modification.
|
||||
Echoing a value is additive, the new value is added to the
|
||||
existing initialization flags.
|
||||
|
||||
For example, after::
|
||||
|
||||
echo 2 ><securityfs>/evm
|
||||
|
||||
another echo can be performed::
|
||||
|
||||
echo 1 ><securityfs>/evm
|
||||
|
||||
and the resulting value will be 3.
|
||||
|
||||
Note that once an HMAC key has been loaded, it will no longer
|
||||
be possible to enable metadata modification. Signaling that an
|
||||
HMAC key has been loaded will clear the corresponding flag.
|
||||
For example, if the current value is 6 (2 and 4 set)::
|
||||
|
||||
echo 1 ><securityfs>/evm
|
||||
|
||||
will set the new value to 3 (4 cleared).
|
||||
|
||||
Loading an HMAC key is the only way to disable metadata
|
||||
modification.
|
||||
|
||||
Until key loading has been signaled EVM can not create
|
||||
or validate the 'security.evm' xattr, but returns
|
||||
|
|
|
@ -567,6 +567,12 @@
|
|||
loops can be debugged more effectively on production
|
||||
systems.
|
||||
|
||||
clocksource.max_cswd_read_retries= [KNL]
|
||||
Number of clocksource_watchdog() retries due to
|
||||
external delays before the clock will be marked
|
||||
unstable. Defaults to three retries, that is,
|
||||
four attempts to read the clock under test.
|
||||
|
||||
clearcpuid=BITNUM[,BITNUM...] [X86]
|
||||
Disable CPUID feature X for the kernel. See
|
||||
arch/x86/include/asm/cpufeatures.h for the valid bit
|
||||
|
|
|
@ -38,6 +38,7 @@ Sysfs entries
|
|||
fan[1-12]_input RO fan tachometer speed in RPM
|
||||
fan[1-12]_fault RO fan experienced fault
|
||||
fan[1-6]_target RW desired fan speed in RPM
|
||||
pwm[1-6]_enable RW regulator mode, 0=disabled, 1=manual mode, 2=rpm mode
|
||||
pwm[1-6] RW fan target duty cycle (0-255)
|
||||
pwm[1-6]_enable RW regulator mode, 0=disabled (duty cycle=0%), 1=manual mode, 2=rpm mode
|
||||
pwm[1-6] RW read: current pwm duty cycle,
|
||||
write: target pwm duty cycle (0-255)
|
||||
================== === =======================================================
|
||||
|
|
4
Makefile
4
Makefile
|
@ -1,7 +1,7 @@
|
|||
# SPDX-License-Identifier: GPL-2.0
|
||||
VERSION = 5
|
||||
PATCHLEVEL = 4
|
||||
SUBLEVEL = 131
|
||||
SUBLEVEL = 132
|
||||
EXTRAVERSION =
|
||||
NAME = Kleptomaniac Octopus
|
||||
|
||||
|
@ -937,7 +937,7 @@ LDFLAGS_vmlinux += $(call ld-option, -X,)
|
|||
endif
|
||||
|
||||
ifeq ($(CONFIG_RELR),y)
|
||||
LDFLAGS_vmlinux += --pack-dyn-relocs=relr
|
||||
LDFLAGS_vmlinux += --pack-dyn-relocs=relr --use-android-relr-tags
|
||||
endif
|
||||
|
||||
# make the checker run with the right architecture
|
||||
|
|
|
@ -914,7 +914,7 @@
|
|||
0xffffffff 0x3ffcfe7c 0x1c010101 /* pioA */
|
||||
0x7fffffff 0xfffccc3a 0x3f00cc3a /* pioB */
|
||||
0xffffffff 0x3ff83fff 0xff00ffff /* pioC */
|
||||
0x0003ff00 0x8002a800 0x00000000 /* pioD */
|
||||
0xb003ff00 0x8002a800 0x00000000 /* pioD */
|
||||
0xffffffff 0x7fffffff 0x76fff1bf /* pioE */
|
||||
>;
|
||||
|
||||
|
|
|
@ -773,10 +773,10 @@ static inline void armv7pmu_write_counter(struct perf_event *event, u64 value)
|
|||
pr_err("CPU%u writing wrong counter %d\n",
|
||||
smp_processor_id(), idx);
|
||||
} else if (idx == ARMV7_IDX_CYCLE_COUNTER) {
|
||||
asm volatile("mcr p15, 0, %0, c9, c13, 0" : : "r" (value));
|
||||
asm volatile("mcr p15, 0, %0, c9, c13, 0" : : "r" ((u32)value));
|
||||
} else {
|
||||
armv7_pmnc_select_counter(idx);
|
||||
asm volatile("mcr p15, 0, %0, c9, c13, 2" : : "r" (value));
|
||||
asm volatile("mcr p15, 0, %0, c9, c13, 2" : : "r" ((u32)value));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -134,7 +134,7 @@
|
|||
|
||||
uart0: serial@12000 {
|
||||
compatible = "marvell,armada-3700-uart";
|
||||
reg = <0x12000 0x200>;
|
||||
reg = <0x12000 0x18>;
|
||||
clocks = <&xtalclk>;
|
||||
interrupts =
|
||||
<GIC_SPI 11 IRQ_TYPE_LEVEL_HIGH>,
|
||||
|
|
|
@ -15,10 +15,10 @@
|
|||
.macro __uaccess_ttbr0_disable, tmp1
|
||||
mrs \tmp1, ttbr1_el1 // swapper_pg_dir
|
||||
bic \tmp1, \tmp1, #TTBR_ASID_MASK
|
||||
sub \tmp1, \tmp1, #RESERVED_TTBR0_SIZE // reserved_ttbr0 just before swapper_pg_dir
|
||||
sub \tmp1, \tmp1, #PAGE_SIZE // reserved_pg_dir just before swapper_pg_dir
|
||||
msr ttbr0_el1, \tmp1 // set reserved TTBR0_EL1
|
||||
isb
|
||||
add \tmp1, \tmp1, #RESERVED_TTBR0_SIZE
|
||||
add \tmp1, \tmp1, #PAGE_SIZE
|
||||
msr ttbr1_el1, \tmp1 // set reserved ASID
|
||||
isb
|
||||
.endm
|
||||
|
|
|
@ -89,12 +89,6 @@
|
|||
#define INIT_DIR_SIZE (PAGE_SIZE * EARLY_PAGES(KIMAGE_VADDR + TEXT_OFFSET, _end))
|
||||
#define IDMAP_DIR_SIZE (IDMAP_PGTABLE_LEVELS * PAGE_SIZE)
|
||||
|
||||
#ifdef CONFIG_ARM64_SW_TTBR0_PAN
|
||||
#define RESERVED_TTBR0_SIZE (PAGE_SIZE)
|
||||
#else
|
||||
#define RESERVED_TTBR0_SIZE (0)
|
||||
#endif
|
||||
|
||||
/* Initial memory map size */
|
||||
#if ARM64_SWAPPER_USES_SECTION_MAPS
|
||||
#define SWAPPER_BLOCK_SHIFT SECTION_SHIFT
|
||||
|
|
|
@ -36,11 +36,11 @@ static inline void contextidr_thread_switch(struct task_struct *next)
|
|||
}
|
||||
|
||||
/*
|
||||
* Set TTBR0 to empty_zero_page. No translations will be possible via TTBR0.
|
||||
* Set TTBR0 to reserved_pg_dir. No translations will be possible via TTBR0.
|
||||
*/
|
||||
static inline void cpu_set_reserved_ttbr0(void)
|
||||
{
|
||||
unsigned long ttbr = phys_to_ttbr(__pa_symbol(empty_zero_page));
|
||||
unsigned long ttbr = phys_to_ttbr(__pa_symbol(reserved_pg_dir));
|
||||
|
||||
write_sysreg(ttbr, ttbr0_el1);
|
||||
isb();
|
||||
|
@ -184,9 +184,9 @@ static inline void update_saved_ttbr0(struct task_struct *tsk,
|
|||
return;
|
||||
|
||||
if (mm == &init_mm)
|
||||
ttbr = __pa_symbol(empty_zero_page);
|
||||
ttbr = phys_to_ttbr(__pa_symbol(reserved_pg_dir));
|
||||
else
|
||||
ttbr = virt_to_phys(mm->pgd) | ASID(mm) << 48;
|
||||
ttbr = phys_to_ttbr(virt_to_phys(mm->pgd)) | ASID(mm) << 48;
|
||||
|
||||
WRITE_ONCE(task_thread_info(tsk)->ttbr0, ttbr);
|
||||
}
|
||||
|
|
|
@ -471,6 +471,7 @@ extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
|
|||
extern pgd_t idmap_pg_dir[PTRS_PER_PGD];
|
||||
extern pgd_t idmap_pg_end[];
|
||||
extern pgd_t tramp_pg_dir[PTRS_PER_PGD];
|
||||
extern pgd_t reserved_pg_dir[PTRS_PER_PGD];
|
||||
|
||||
extern void set_swapper_pgd(pgd_t *pgdp, pgd_t pgd);
|
||||
|
||||
|
|
|
@ -112,8 +112,8 @@ static inline void __uaccess_ttbr0_disable(void)
|
|||
local_irq_save(flags);
|
||||
ttbr = read_sysreg(ttbr1_el1);
|
||||
ttbr &= ~TTBR_ASID_MASK;
|
||||
/* reserved_ttbr0 placed before swapper_pg_dir */
|
||||
write_sysreg(ttbr - RESERVED_TTBR0_SIZE, ttbr0_el1);
|
||||
/* reserved_pg_dir placed before swapper_pg_dir */
|
||||
write_sysreg(ttbr - PAGE_SIZE, ttbr0_el1);
|
||||
isb();
|
||||
/* Set reserved ASID */
|
||||
write_sysreg(ttbr, ttbr1_el1);
|
||||
|
|
|
@ -1018,9 +1018,10 @@ ENDPROC(el0_svc)
|
|||
*/
|
||||
.pushsection ".entry.tramp.text", "ax"
|
||||
|
||||
// Move from tramp_pg_dir to swapper_pg_dir
|
||||
.macro tramp_map_kernel, tmp
|
||||
mrs \tmp, ttbr1_el1
|
||||
add \tmp, \tmp, #(PAGE_SIZE + RESERVED_TTBR0_SIZE)
|
||||
add \tmp, \tmp, #(2 * PAGE_SIZE)
|
||||
bic \tmp, \tmp, #USER_ASID_FLAG
|
||||
msr ttbr1_el1, \tmp
|
||||
#ifdef CONFIG_QCOM_FALKOR_ERRATUM_1003
|
||||
|
@ -1037,9 +1038,10 @@ alternative_else_nop_endif
|
|||
#endif /* CONFIG_QCOM_FALKOR_ERRATUM_1003 */
|
||||
.endm
|
||||
|
||||
// Move from swapper_pg_dir to tramp_pg_dir
|
||||
.macro tramp_unmap_kernel, tmp
|
||||
mrs \tmp, ttbr1_el1
|
||||
sub \tmp, \tmp, #(PAGE_SIZE + RESERVED_TTBR0_SIZE)
|
||||
sub \tmp, \tmp, #(2 * PAGE_SIZE)
|
||||
orr \tmp, \tmp, #USER_ASID_FLAG
|
||||
msr ttbr1_el1, \tmp
|
||||
/*
|
||||
|
|
|
@ -356,7 +356,7 @@ void __init setup_arch(char **cmdline_p)
|
|||
* faults in case uaccess_enable() is inadvertently called by the init
|
||||
* thread.
|
||||
*/
|
||||
init_task.thread_info.ttbr0 = __pa_symbol(empty_zero_page);
|
||||
init_task.thread_info.ttbr0 = phys_to_ttbr(__pa_symbol(reserved_pg_dir));
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_VT
|
||||
|
|
|
@ -157,13 +157,11 @@ SECTIONS
|
|||
. += PAGE_SIZE;
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_ARM64_SW_TTBR0_PAN
|
||||
reserved_ttbr0 = .;
|
||||
. += RESERVED_TTBR0_SIZE;
|
||||
#endif
|
||||
reserved_pg_dir = .;
|
||||
. += PAGE_SIZE;
|
||||
|
||||
swapper_pg_dir = .;
|
||||
. += PAGE_SIZE;
|
||||
swapper_pg_end = .;
|
||||
|
||||
. = ALIGN(SEGMENT_ALIGN);
|
||||
__init_begin = .;
|
||||
|
|
|
@ -166,7 +166,7 @@ ENDPROC(cpu_do_switch_mm)
|
|||
.pushsection ".idmap.text", "awx"
|
||||
|
||||
.macro __idmap_cpu_set_reserved_ttbr1, tmp1, tmp2
|
||||
adrp \tmp1, empty_zero_page
|
||||
adrp \tmp1, reserved_pg_dir
|
||||
phys_to_ttbr \tmp2, \tmp1
|
||||
offset_ttbr1 \tmp2, \tmp1
|
||||
msr ttbr1_el1, \tmp2
|
||||
|
|
|
@ -343,7 +343,7 @@ init_record_index_pools(void)
|
|||
|
||||
/* - 2 - */
|
||||
sect_min_size = sal_log_sect_min_sizes[0];
|
||||
for (i = 1; i < sizeof sal_log_sect_min_sizes/sizeof(size_t); i++)
|
||||
for (i = 1; i < ARRAY_SIZE(sal_log_sect_min_sizes); i++)
|
||||
if (sect_min_size > sal_log_sect_min_sizes[i])
|
||||
sect_min_size = sal_log_sect_min_sizes[i];
|
||||
|
||||
|
|
|
@ -23,6 +23,9 @@ config ATARI
|
|||
this kernel on an Atari, say Y here and browse the material
|
||||
available in <file:Documentation/m68k>; otherwise say N.
|
||||
|
||||
config ATARI_KBD_CORE
|
||||
bool
|
||||
|
||||
config MAC
|
||||
bool "Macintosh support"
|
||||
depends on MMU
|
||||
|
|
|
@ -36,7 +36,7 @@ extern pte_t *pkmap_page_table;
|
|||
* easily, subsequent pte tables have to be allocated in one physical
|
||||
* chunk of RAM.
|
||||
*/
|
||||
#ifdef CONFIG_PHYS_ADDR_T_64BIT
|
||||
#if defined(CONFIG_PHYS_ADDR_T_64BIT) || defined(CONFIG_MIPS_HUGE_TLB_SUPPORT)
|
||||
#define LAST_PKMAP 512
|
||||
#else
|
||||
#define LAST_PKMAP 1024
|
||||
|
|
|
@ -99,6 +99,36 @@ static inline int cpu_last_thread_sibling(int cpu)
|
|||
return cpu | (threads_per_core - 1);
|
||||
}
|
||||
|
||||
/*
|
||||
* tlb_thread_siblings are siblings which share a TLB. This is not
|
||||
* architected, is not something a hypervisor could emulate and a future
|
||||
* CPU may change behaviour even in compat mode, so this should only be
|
||||
* used on PowerNV, and only with care.
|
||||
*/
|
||||
static inline int cpu_first_tlb_thread_sibling(int cpu)
|
||||
{
|
||||
if (cpu_has_feature(CPU_FTR_ARCH_300) && (threads_per_core == 8))
|
||||
return cpu & ~0x6; /* Big Core */
|
||||
else
|
||||
return cpu_first_thread_sibling(cpu);
|
||||
}
|
||||
|
||||
static inline int cpu_last_tlb_thread_sibling(int cpu)
|
||||
{
|
||||
if (cpu_has_feature(CPU_FTR_ARCH_300) && (threads_per_core == 8))
|
||||
return cpu | 0x6; /* Big Core */
|
||||
else
|
||||
return cpu_last_thread_sibling(cpu);
|
||||
}
|
||||
|
||||
static inline int cpu_tlb_thread_sibling_step(void)
|
||||
{
|
||||
if (cpu_has_feature(CPU_FTR_ARCH_300) && (threads_per_core == 8))
|
||||
return 2; /* Big Core */
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
static inline u32 get_tensr(void)
|
||||
{
|
||||
#ifdef CONFIG_BOOKE
|
||||
|
|
|
@ -588,6 +588,8 @@ static void nmi_stop_this_cpu(struct pt_regs *regs)
|
|||
/*
|
||||
* IRQs are already hard disabled by the smp_handle_nmi_ipi.
|
||||
*/
|
||||
set_cpu_online(smp_processor_id(), false);
|
||||
|
||||
spin_begin();
|
||||
while (1)
|
||||
spin_cpu_relax();
|
||||
|
@ -603,6 +605,15 @@ void smp_send_stop(void)
|
|||
static void stop_this_cpu(void *dummy)
|
||||
{
|
||||
hard_irq_disable();
|
||||
|
||||
/*
|
||||
* Offlining CPUs in stop_this_cpu can result in scheduler warnings,
|
||||
* (see commit de6e5d38417e), but printk_safe_flush_on_panic() wants
|
||||
* to know other CPUs are offline before it breaks locks to flush
|
||||
* printk buffers, in case we panic()ed while holding the lock.
|
||||
*/
|
||||
set_cpu_online(smp_processor_id(), false);
|
||||
|
||||
spin_begin();
|
||||
while (1)
|
||||
spin_cpu_relax();
|
||||
|
|
|
@ -19,6 +19,7 @@
|
|||
#include <asm/ptrace.h>
|
||||
#include <asm/processor.h>
|
||||
#include <linux/ftrace.h>
|
||||
#include <linux/delay.h>
|
||||
#include <asm/kprobes.h>
|
||||
|
||||
#include <asm/paca.h>
|
||||
|
@ -230,17 +231,31 @@ static void handle_backtrace_ipi(struct pt_regs *regs)
|
|||
|
||||
static void raise_backtrace_ipi(cpumask_t *mask)
|
||||
{
|
||||
struct paca_struct *p;
|
||||
unsigned int cpu;
|
||||
u64 delay_us;
|
||||
|
||||
for_each_cpu(cpu, mask) {
|
||||
if (cpu == smp_processor_id())
|
||||
if (cpu == smp_processor_id()) {
|
||||
handle_backtrace_ipi(NULL);
|
||||
else
|
||||
smp_send_safe_nmi_ipi(cpu, handle_backtrace_ipi, 5 * USEC_PER_SEC);
|
||||
continue;
|
||||
}
|
||||
|
||||
for_each_cpu(cpu, mask) {
|
||||
struct paca_struct *p = paca_ptrs[cpu];
|
||||
delay_us = 5 * USEC_PER_SEC;
|
||||
|
||||
if (smp_send_safe_nmi_ipi(cpu, handle_backtrace_ipi, delay_us)) {
|
||||
// Now wait up to 5s for the other CPU to do its backtrace
|
||||
while (cpumask_test_cpu(cpu, mask) && delay_us) {
|
||||
udelay(1);
|
||||
delay_us--;
|
||||
}
|
||||
|
||||
// Other CPU cleared itself from the mask
|
||||
if (delay_us)
|
||||
continue;
|
||||
}
|
||||
|
||||
p = paca_ptrs[cpu];
|
||||
|
||||
cpumask_clear_cpu(cpu, mask);
|
||||
|
||||
|
|
|
@ -2536,7 +2536,7 @@ static void radix_flush_cpu(struct kvm *kvm, int cpu, struct kvm_vcpu *vcpu)
|
|||
cpumask_t *cpu_in_guest;
|
||||
int i;
|
||||
|
||||
cpu = cpu_first_thread_sibling(cpu);
|
||||
cpu = cpu_first_tlb_thread_sibling(cpu);
|
||||
if (nested) {
|
||||
cpumask_set_cpu(cpu, &nested->need_tlb_flush);
|
||||
cpu_in_guest = &nested->cpu_in_guest;
|
||||
|
@ -2550,9 +2550,10 @@ static void radix_flush_cpu(struct kvm *kvm, int cpu, struct kvm_vcpu *vcpu)
|
|||
* the other side is the first smp_mb() in kvmppc_run_core().
|
||||
*/
|
||||
smp_mb();
|
||||
for (i = 0; i < threads_per_core; ++i)
|
||||
if (cpumask_test_cpu(cpu + i, cpu_in_guest))
|
||||
smp_call_function_single(cpu + i, do_nothing, NULL, 1);
|
||||
for (i = cpu; i <= cpu_last_tlb_thread_sibling(cpu);
|
||||
i += cpu_tlb_thread_sibling_step())
|
||||
if (cpumask_test_cpu(i, cpu_in_guest))
|
||||
smp_call_function_single(i, do_nothing, NULL, 1);
|
||||
}
|
||||
|
||||
static void kvmppc_prepare_radix_vcpu(struct kvm_vcpu *vcpu, int pcpu)
|
||||
|
@ -2583,8 +2584,8 @@ static void kvmppc_prepare_radix_vcpu(struct kvm_vcpu *vcpu, int pcpu)
|
|||
*/
|
||||
if (prev_cpu != pcpu) {
|
||||
if (prev_cpu >= 0 &&
|
||||
cpu_first_thread_sibling(prev_cpu) !=
|
||||
cpu_first_thread_sibling(pcpu))
|
||||
cpu_first_tlb_thread_sibling(prev_cpu) !=
|
||||
cpu_first_tlb_thread_sibling(pcpu))
|
||||
radix_flush_cpu(kvm, prev_cpu, vcpu);
|
||||
if (nested)
|
||||
nested->prev_cpu[vcpu->arch.nested_vcpu_id] = pcpu;
|
||||
|
|
|
@ -847,7 +847,7 @@ void kvmppc_check_need_tlb_flush(struct kvm *kvm, int pcpu,
|
|||
* Thus we make all 4 threads use the same bit.
|
||||
*/
|
||||
if (cpu_has_feature(CPU_FTR_ARCH_300))
|
||||
pcpu = cpu_first_thread_sibling(pcpu);
|
||||
pcpu = cpu_first_tlb_thread_sibling(pcpu);
|
||||
|
||||
if (nested)
|
||||
need_tlb_flush = &nested->need_tlb_flush;
|
||||
|
|
|
@ -51,7 +51,8 @@ void kvmhv_save_hv_regs(struct kvm_vcpu *vcpu, struct hv_guest_state *hr)
|
|||
hr->ppr = vcpu->arch.ppr;
|
||||
}
|
||||
|
||||
static void byteswap_pt_regs(struct pt_regs *regs)
|
||||
/* Use noinline_for_stack due to https://bugs.llvm.org/show_bug.cgi?id=49610 */
|
||||
static noinline_for_stack void byteswap_pt_regs(struct pt_regs *regs)
|
||||
{
|
||||
unsigned long *addr = (unsigned long *) regs;
|
||||
|
||||
|
|
|
@ -67,7 +67,7 @@ static int global_invalidates(struct kvm *kvm)
|
|||
* so use the bit for the first thread to represent the core.
|
||||
*/
|
||||
if (cpu_has_feature(CPU_FTR_ARCH_300))
|
||||
cpu = cpu_first_thread_sibling(cpu);
|
||||
cpu = cpu_first_tlb_thread_sibling(cpu);
|
||||
cpumask_clear_cpu(cpu, &kvm->arch.need_tlb_flush);
|
||||
}
|
||||
|
||||
|
|
|
@ -920,7 +920,7 @@ config CMM_IUCV
|
|||
config APPLDATA_BASE
|
||||
def_bool n
|
||||
prompt "Linux - VM Monitor Stream, base infrastructure"
|
||||
depends on PROC_FS
|
||||
depends on PROC_SYSCTL
|
||||
help
|
||||
This provides a kernel interface for creating and updating z/VM APPLDATA
|
||||
monitor records. The monitor records are updated at certain time
|
||||
|
|
|
@ -318,31 +318,31 @@ static void allow_cpu_feat(unsigned long nr)
|
|||
|
||||
static inline int plo_test_bit(unsigned char nr)
|
||||
{
|
||||
register unsigned long r0 asm("0") = (unsigned long) nr | 0x100;
|
||||
unsigned long function = (unsigned long)nr | 0x100;
|
||||
int cc;
|
||||
|
||||
asm volatile(
|
||||
" lgr 0,%[function]\n"
|
||||
/* Parameter registers are ignored for "test bit" */
|
||||
" plo 0,0,0,0(0)\n"
|
||||
" ipm %0\n"
|
||||
" srl %0,28\n"
|
||||
: "=d" (cc)
|
||||
: "d" (r0)
|
||||
: "cc");
|
||||
: [function] "d" (function)
|
||||
: "cc", "0");
|
||||
return cc == 0;
|
||||
}
|
||||
|
||||
static __always_inline void __insn32_query(unsigned int opcode, u8 *query)
|
||||
{
|
||||
register unsigned long r0 asm("0") = 0; /* query function */
|
||||
register unsigned long r1 asm("1") = (unsigned long) query;
|
||||
|
||||
asm volatile(
|
||||
/* Parameter regs are ignored */
|
||||
" lghi 0,0\n"
|
||||
" lgr 1,%[query]\n"
|
||||
/* Parameter registers are ignored */
|
||||
" .insn rrf,%[opc] << 16,2,4,6,0\n"
|
||||
:
|
||||
: "d" (r0), "a" (r1), [opc] "i" (opcode)
|
||||
: "cc", "memory");
|
||||
: [query] "d" ((unsigned long)query), [opc] "i" (opcode)
|
||||
: "cc", "memory", "0", "1");
|
||||
}
|
||||
|
||||
#define INSN_SORTL 0xb938
|
||||
|
|
|
@ -5099,7 +5099,7 @@ static int handle_vmfunc(struct kvm_vcpu *vcpu)
|
|||
}
|
||||
|
||||
vmcs12 = get_vmcs12(vcpu);
|
||||
if ((vmcs12->vm_function_control & (1 << function)) == 0)
|
||||
if (!(vmcs12->vm_function_control & BIT_ULL(function)))
|
||||
goto fail;
|
||||
|
||||
switch (function) {
|
||||
|
|
|
@ -571,10 +571,14 @@ static inline unsigned int blk_rq_get_max_segments(struct request *rq)
|
|||
static inline int ll_new_hw_segment(struct request *req, struct bio *bio,
|
||||
unsigned int nr_phys_segs)
|
||||
{
|
||||
if (req->nr_phys_segments + nr_phys_segs > blk_rq_get_max_segments(req))
|
||||
if (blk_integrity_merge_bio(req->q, req, bio) == false)
|
||||
goto no_merge;
|
||||
|
||||
if (blk_integrity_merge_bio(req->q, req, bio) == false)
|
||||
/* discard request merge won't add new segment */
|
||||
if (req_op(req) == REQ_OP_DISCARD)
|
||||
return 1;
|
||||
|
||||
if (req->nr_phys_segments + nr_phys_segs > blk_rq_get_max_segments(req))
|
||||
goto no_merge;
|
||||
|
||||
/*
|
||||
|
|
|
@ -7,6 +7,7 @@
|
|||
#include <linux/blk_types.h>
|
||||
#include <linux/atomic.h>
|
||||
#include <linux/wait.h>
|
||||
#include <linux/blk-mq.h>
|
||||
|
||||
#include "blk-mq-debugfs.h"
|
||||
|
||||
|
@ -99,8 +100,21 @@ static inline void rq_wait_init(struct rq_wait *rq_wait)
|
|||
|
||||
static inline void rq_qos_add(struct request_queue *q, struct rq_qos *rqos)
|
||||
{
|
||||
/*
|
||||
* No IO can be in-flight when adding rqos, so freeze queue, which
|
||||
* is fine since we only support rq_qos for blk-mq queue.
|
||||
*
|
||||
* Reuse ->queue_lock for protecting against other concurrent
|
||||
* rq_qos adding/deleting
|
||||
*/
|
||||
blk_mq_freeze_queue(q);
|
||||
|
||||
spin_lock_irq(&q->queue_lock);
|
||||
rqos->next = q->rq_qos;
|
||||
q->rq_qos = rqos;
|
||||
spin_unlock_irq(&q->queue_lock);
|
||||
|
||||
blk_mq_unfreeze_queue(q);
|
||||
|
||||
if (rqos->ops->debugfs_attrs)
|
||||
blk_mq_debugfs_register_rqos(rqos);
|
||||
|
@ -110,12 +124,22 @@ static inline void rq_qos_del(struct request_queue *q, struct rq_qos *rqos)
|
|||
{
|
||||
struct rq_qos **cur;
|
||||
|
||||
/*
|
||||
* See comment in rq_qos_add() about freezing queue & using
|
||||
* ->queue_lock.
|
||||
*/
|
||||
blk_mq_freeze_queue(q);
|
||||
|
||||
spin_lock_irq(&q->queue_lock);
|
||||
for (cur = &q->rq_qos; *cur; cur = &(*cur)->next) {
|
||||
if (*cur == rqos) {
|
||||
*cur = rqos->next;
|
||||
break;
|
||||
}
|
||||
}
|
||||
spin_unlock_irq(&q->queue_lock);
|
||||
|
||||
blk_mq_unfreeze_queue(q);
|
||||
|
||||
blk_mq_debugfs_unregister_rqos(rqos);
|
||||
}
|
||||
|
|
|
@ -77,7 +77,8 @@ enum {
|
|||
|
||||
static inline bool rwb_enabled(struct rq_wb *rwb)
|
||||
{
|
||||
return rwb && rwb->wb_normal != 0;
|
||||
return rwb && rwb->enable_state != WBT_STATE_OFF_DEFAULT &&
|
||||
rwb->wb_normal != 0;
|
||||
}
|
||||
|
||||
static void wb_timestamp(struct rq_wb *rwb, unsigned long *var)
|
||||
|
@ -644,9 +645,13 @@ void wbt_set_write_cache(struct request_queue *q, bool write_cache_on)
|
|||
void wbt_enable_default(struct request_queue *q)
|
||||
{
|
||||
struct rq_qos *rqos = wbt_rq_qos(q);
|
||||
|
||||
/* Throttling already enabled? */
|
||||
if (rqos)
|
||||
if (rqos) {
|
||||
if (RQWB(rqos)->enable_state == WBT_STATE_OFF_DEFAULT)
|
||||
RQWB(rqos)->enable_state = WBT_STATE_ON_DEFAULT;
|
||||
return;
|
||||
}
|
||||
|
||||
/* Queue not registered? Maybe shutting down... */
|
||||
if (!blk_queue_registered(q))
|
||||
|
@ -710,7 +715,7 @@ void wbt_disable_default(struct request_queue *q)
|
|||
rwb = RQWB(rqos);
|
||||
if (rwb->enable_state == WBT_STATE_ON_DEFAULT) {
|
||||
blk_stat_deactivate(rwb->cb);
|
||||
rwb->wb_normal = 0;
|
||||
rwb->enable_state = WBT_STATE_OFF_DEFAULT;
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(wbt_disable_default);
|
||||
|
|
|
@ -34,6 +34,7 @@ enum {
|
|||
enum {
|
||||
WBT_STATE_ON_DEFAULT = 1,
|
||||
WBT_STATE_ON_MANUAL = 2,
|
||||
WBT_STATE_OFF_DEFAULT
|
||||
};
|
||||
|
||||
struct rq_wb {
|
||||
|
|
|
@ -20,12 +20,24 @@
|
|||
|
||||
static const struct crypto_type crypto_shash_type;
|
||||
|
||||
int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
|
||||
static int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
|
||||
unsigned int keylen)
|
||||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(shash_no_setkey);
|
||||
|
||||
/*
|
||||
* Check whether an shash algorithm has a setkey function.
|
||||
*
|
||||
* For CFI compatibility, this must not be an inline function. This is because
|
||||
* when CFI is enabled, modules won't get the same address for shash_no_setkey
|
||||
* (if it were exported, which inlining would require) as the core kernel will.
|
||||
*/
|
||||
bool crypto_shash_alg_has_setkey(struct shash_alg *alg)
|
||||
{
|
||||
return alg->setkey != shash_no_setkey;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(crypto_shash_alg_has_setkey);
|
||||
|
||||
static int shash_setkey_unaligned(struct crypto_shash *tfm, const u8 *key,
|
||||
unsigned int keylen)
|
||||
|
|
|
@ -8,6 +8,11 @@ ccflags-$(CONFIG_ACPI_DEBUG) += -DACPI_DEBUG_OUTPUT
|
|||
#
|
||||
# ACPI Boot-Time Table Parsing
|
||||
#
|
||||
ifeq ($(CONFIG_ACPI_CUSTOM_DSDT),y)
|
||||
tables.o: $(src)/../../include/$(subst $\",,$(CONFIG_ACPI_CUSTOM_DSDT_FILE)) ;
|
||||
|
||||
endif
|
||||
|
||||
obj-$(CONFIG_ACPI) += tables.o
|
||||
obj-$(CONFIG_X86) += blacklist.o
|
||||
|
||||
|
|
|
@ -262,7 +262,7 @@ static uint32_t acpi_pad_idle_cpus_num(void)
|
|||
return ps_tsk_num;
|
||||
}
|
||||
|
||||
static ssize_t acpi_pad_rrtime_store(struct device *dev,
|
||||
static ssize_t rrtime_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t count)
|
||||
{
|
||||
unsigned long num;
|
||||
|
@ -276,16 +276,14 @@ static ssize_t acpi_pad_rrtime_store(struct device *dev,
|
|||
return count;
|
||||
}
|
||||
|
||||
static ssize_t acpi_pad_rrtime_show(struct device *dev,
|
||||
static ssize_t rrtime_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return scnprintf(buf, PAGE_SIZE, "%d\n", round_robin_time);
|
||||
}
|
||||
static DEVICE_ATTR(rrtime, S_IRUGO|S_IWUSR,
|
||||
acpi_pad_rrtime_show,
|
||||
acpi_pad_rrtime_store);
|
||||
static DEVICE_ATTR_RW(rrtime);
|
||||
|
||||
static ssize_t acpi_pad_idlepct_store(struct device *dev,
|
||||
static ssize_t idlepct_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t count)
|
||||
{
|
||||
unsigned long num;
|
||||
|
@ -299,16 +297,14 @@ static ssize_t acpi_pad_idlepct_store(struct device *dev,
|
|||
return count;
|
||||
}
|
||||
|
||||
static ssize_t acpi_pad_idlepct_show(struct device *dev,
|
||||
static ssize_t idlepct_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return scnprintf(buf, PAGE_SIZE, "%d\n", idle_pct);
|
||||
}
|
||||
static DEVICE_ATTR(idlepct, S_IRUGO|S_IWUSR,
|
||||
acpi_pad_idlepct_show,
|
||||
acpi_pad_idlepct_store);
|
||||
static DEVICE_ATTR_RW(idlepct);
|
||||
|
||||
static ssize_t acpi_pad_idlecpus_store(struct device *dev,
|
||||
static ssize_t idlecpus_store(struct device *dev,
|
||||
struct device_attribute *attr, const char *buf, size_t count)
|
||||
{
|
||||
unsigned long num;
|
||||
|
@ -320,16 +316,14 @@ static ssize_t acpi_pad_idlecpus_store(struct device *dev,
|
|||
return count;
|
||||
}
|
||||
|
||||
static ssize_t acpi_pad_idlecpus_show(struct device *dev,
|
||||
static ssize_t idlecpus_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return cpumap_print_to_pagebuf(false, buf,
|
||||
to_cpumask(pad_busy_cpus_bits));
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(idlecpus, S_IRUGO|S_IWUSR,
|
||||
acpi_pad_idlecpus_show,
|
||||
acpi_pad_idlecpus_store);
|
||||
static DEVICE_ATTR_RW(idlecpus);
|
||||
|
||||
static int acpi_pad_add_sysfs(struct acpi_device *device)
|
||||
{
|
||||
|
|
|
@ -237,7 +237,7 @@ static ssize_t time_show(struct device *dev, struct device_attribute *attr,
|
|||
rt.tz, rt.daylight);
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(time, S_IRUSR | S_IWUSR, time_show, time_store);
|
||||
static DEVICE_ATTR_RW(time);
|
||||
|
||||
static struct attribute *acpi_tad_time_attrs[] = {
|
||||
&dev_attr_time.attr,
|
||||
|
@ -446,7 +446,7 @@ static ssize_t ac_alarm_show(struct device *dev, struct device_attribute *attr,
|
|||
return acpi_tad_alarm_read(dev, buf, ACPI_TAD_AC_TIMER);
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(ac_alarm, S_IRUSR | S_IWUSR, ac_alarm_show, ac_alarm_store);
|
||||
static DEVICE_ATTR_RW(ac_alarm);
|
||||
|
||||
static ssize_t ac_policy_store(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
|
@ -462,7 +462,7 @@ static ssize_t ac_policy_show(struct device *dev, struct device_attribute *attr,
|
|||
return acpi_tad_policy_read(dev, buf, ACPI_TAD_AC_TIMER);
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(ac_policy, S_IRUSR | S_IWUSR, ac_policy_show, ac_policy_store);
|
||||
static DEVICE_ATTR_RW(ac_policy);
|
||||
|
||||
static ssize_t ac_status_store(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
|
@ -478,7 +478,7 @@ static ssize_t ac_status_show(struct device *dev, struct device_attribute *attr,
|
|||
return acpi_tad_status_read(dev, buf, ACPI_TAD_AC_TIMER);
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(ac_status, S_IRUSR | S_IWUSR, ac_status_show, ac_status_store);
|
||||
static DEVICE_ATTR_RW(ac_status);
|
||||
|
||||
static struct attribute *acpi_tad_attrs[] = {
|
||||
&dev_attr_caps.attr,
|
||||
|
@ -505,7 +505,7 @@ static ssize_t dc_alarm_show(struct device *dev, struct device_attribute *attr,
|
|||
return acpi_tad_alarm_read(dev, buf, ACPI_TAD_DC_TIMER);
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(dc_alarm, S_IRUSR | S_IWUSR, dc_alarm_show, dc_alarm_store);
|
||||
static DEVICE_ATTR_RW(dc_alarm);
|
||||
|
||||
static ssize_t dc_policy_store(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
|
@ -521,7 +521,7 @@ static ssize_t dc_policy_show(struct device *dev, struct device_attribute *attr,
|
|||
return acpi_tad_policy_read(dev, buf, ACPI_TAD_DC_TIMER);
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(dc_policy, S_IRUSR | S_IWUSR, dc_policy_show, dc_policy_store);
|
||||
static DEVICE_ATTR_RW(dc_policy);
|
||||
|
||||
static ssize_t dc_status_store(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
|
@ -537,7 +537,7 @@ static ssize_t dc_status_show(struct device *dev, struct device_attribute *attr,
|
|||
return acpi_tad_status_read(dev, buf, ACPI_TAD_DC_TIMER);
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(dc_status, S_IRUSR | S_IWUSR, dc_status_show, dc_status_store);
|
||||
static DEVICE_ATTR_RW(dc_status);
|
||||
|
||||
static struct attribute *acpi_tad_dc_attrs[] = {
|
||||
&dev_attr_dc_alarm.attr,
|
||||
|
|
|
@ -375,6 +375,13 @@ acpi_ns_repair_CID(struct acpi_evaluate_info *info,
|
|||
|
||||
(*element_ptr)->common.reference_count =
|
||||
original_ref_count;
|
||||
|
||||
/*
|
||||
* The original_element holds a reference from the package object
|
||||
* that represents _HID. Since a new element was created by _HID,
|
||||
* remove the reference from the _CID package.
|
||||
*/
|
||||
acpi_ut_remove_reference(original_element);
|
||||
}
|
||||
|
||||
element_ptr++;
|
||||
|
|
|
@ -15,40 +15,19 @@
|
|||
static void *bgrt_image;
|
||||
static struct kobject *bgrt_kobj;
|
||||
|
||||
static ssize_t show_version(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return snprintf(buf, PAGE_SIZE, "%d\n", bgrt_tab.version);
|
||||
}
|
||||
static DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
|
||||
#define BGRT_SHOW(_name, _member) \
|
||||
static ssize_t _name##_show(struct kobject *kobj, \
|
||||
struct kobj_attribute *attr, char *buf) \
|
||||
{ \
|
||||
return snprintf(buf, PAGE_SIZE, "%d\n", bgrt_tab._member); \
|
||||
} \
|
||||
struct kobj_attribute bgrt_attr_##_name = __ATTR_RO(_name)
|
||||
|
||||
static ssize_t show_status(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return snprintf(buf, PAGE_SIZE, "%d\n", bgrt_tab.status);
|
||||
}
|
||||
static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
|
||||
|
||||
static ssize_t show_type(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return snprintf(buf, PAGE_SIZE, "%d\n", bgrt_tab.image_type);
|
||||
}
|
||||
static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
|
||||
|
||||
static ssize_t show_xoffset(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return snprintf(buf, PAGE_SIZE, "%d\n", bgrt_tab.image_offset_x);
|
||||
}
|
||||
static DEVICE_ATTR(xoffset, S_IRUGO, show_xoffset, NULL);
|
||||
|
||||
static ssize_t show_yoffset(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return snprintf(buf, PAGE_SIZE, "%d\n", bgrt_tab.image_offset_y);
|
||||
}
|
||||
static DEVICE_ATTR(yoffset, S_IRUGO, show_yoffset, NULL);
|
||||
BGRT_SHOW(version, version);
|
||||
BGRT_SHOW(status, status);
|
||||
BGRT_SHOW(type, image_type);
|
||||
BGRT_SHOW(xoffset, image_offset_x);
|
||||
BGRT_SHOW(yoffset, image_offset_y);
|
||||
|
||||
static ssize_t image_read(struct file *file, struct kobject *kobj,
|
||||
struct bin_attribute *attr, char *buf, loff_t off, size_t count)
|
||||
|
@ -60,11 +39,11 @@ static ssize_t image_read(struct file *file, struct kobject *kobj,
|
|||
static BIN_ATTR_RO(image, 0); /* size gets filled in later */
|
||||
|
||||
static struct attribute *bgrt_attributes[] = {
|
||||
&dev_attr_version.attr,
|
||||
&dev_attr_status.attr,
|
||||
&dev_attr_type.attr,
|
||||
&dev_attr_xoffset.attr,
|
||||
&dev_attr_yoffset.attr,
|
||||
&bgrt_attr_version.attr,
|
||||
&bgrt_attr_status.attr,
|
||||
&bgrt_attr_type.attr,
|
||||
&bgrt_attr_xoffset.attr,
|
||||
&bgrt_attr_yoffset.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
|
|
|
@ -1240,6 +1240,7 @@ static int __init acpi_init(void)
|
|||
|
||||
result = acpi_bus_init();
|
||||
if (result) {
|
||||
kobject_put(acpi_kobj);
|
||||
disable_acpi();
|
||||
return result;
|
||||
}
|
||||
|
|
|
@ -325,11 +325,11 @@ int acpi_device_modalias(struct device *dev, char *buf, int size)
|
|||
EXPORT_SYMBOL_GPL(acpi_device_modalias);
|
||||
|
||||
static ssize_t
|
||||
acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
|
||||
modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
|
||||
{
|
||||
return __acpi_device_modalias(to_acpi_device(dev), buf, 1024);
|
||||
}
|
||||
static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
|
||||
static DEVICE_ATTR_RO(modalias);
|
||||
|
||||
static ssize_t real_power_state_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
|
@ -358,7 +358,7 @@ static ssize_t power_state_show(struct device *dev,
|
|||
static DEVICE_ATTR_RO(power_state);
|
||||
|
||||
static ssize_t
|
||||
acpi_eject_store(struct device *d, struct device_attribute *attr,
|
||||
eject_store(struct device *d, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
{
|
||||
struct acpi_device *acpi_device = to_acpi_device(d);
|
||||
|
@ -387,27 +387,27 @@ acpi_eject_store(struct device *d, struct device_attribute *attr,
|
|||
return status == AE_NO_MEMORY ? -ENOMEM : -EAGAIN;
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
|
||||
static DEVICE_ATTR_WO(eject);
|
||||
|
||||
static ssize_t
|
||||
acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf)
|
||||
hid_show(struct device *dev, struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
||||
|
||||
return sprintf(buf, "%s\n", acpi_device_hid(acpi_dev));
|
||||
}
|
||||
static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
|
||||
static DEVICE_ATTR_RO(hid);
|
||||
|
||||
static ssize_t acpi_device_uid_show(struct device *dev,
|
||||
static ssize_t uid_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
||||
|
||||
return sprintf(buf, "%s\n", acpi_dev->pnp.unique_id);
|
||||
}
|
||||
static DEVICE_ATTR(uid, 0444, acpi_device_uid_show, NULL);
|
||||
static DEVICE_ATTR_RO(uid);
|
||||
|
||||
static ssize_t acpi_device_adr_show(struct device *dev,
|
||||
static ssize_t adr_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
||||
|
@ -417,16 +417,16 @@ static ssize_t acpi_device_adr_show(struct device *dev,
|
|||
else
|
||||
return sprintf(buf, "0x%08llx\n", acpi_dev->pnp.bus_address);
|
||||
}
|
||||
static DEVICE_ATTR(adr, 0444, acpi_device_adr_show, NULL);
|
||||
static DEVICE_ATTR_RO(adr);
|
||||
|
||||
static ssize_t acpi_device_path_show(struct device *dev,
|
||||
static ssize_t path_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
||||
|
||||
return acpi_object_path(acpi_dev->handle, buf);
|
||||
}
|
||||
static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
|
||||
static DEVICE_ATTR_RO(path);
|
||||
|
||||
/* sysfs file that shows description text from the ACPI _STR method */
|
||||
static ssize_t description_show(struct device *dev,
|
||||
|
@ -446,7 +446,7 @@ static ssize_t description_show(struct device *dev,
|
|||
(wchar_t *)acpi_dev->pnp.str_obj->buffer.pointer,
|
||||
acpi_dev->pnp.str_obj->buffer.length,
|
||||
UTF16_LITTLE_ENDIAN, buf,
|
||||
PAGE_SIZE);
|
||||
PAGE_SIZE - 1);
|
||||
|
||||
buf[result++] = '\n';
|
||||
|
||||
|
@ -455,7 +455,7 @@ static ssize_t description_show(struct device *dev,
|
|||
static DEVICE_ATTR_RO(description);
|
||||
|
||||
static ssize_t
|
||||
acpi_device_sun_show(struct device *dev, struct device_attribute *attr,
|
||||
sun_show(struct device *dev, struct device_attribute *attr,
|
||||
char *buf) {
|
||||
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
||||
acpi_status status;
|
||||
|
@ -467,10 +467,10 @@ acpi_device_sun_show(struct device *dev, struct device_attribute *attr,
|
|||
|
||||
return sprintf(buf, "%llu\n", sun);
|
||||
}
|
||||
static DEVICE_ATTR(sun, 0444, acpi_device_sun_show, NULL);
|
||||
static DEVICE_ATTR_RO(sun);
|
||||
|
||||
static ssize_t
|
||||
acpi_device_hrv_show(struct device *dev, struct device_attribute *attr,
|
||||
hrv_show(struct device *dev, struct device_attribute *attr,
|
||||
char *buf) {
|
||||
struct acpi_device *acpi_dev = to_acpi_device(dev);
|
||||
acpi_status status;
|
||||
|
@ -482,7 +482,7 @@ acpi_device_hrv_show(struct device *dev, struct device_attribute *attr,
|
|||
|
||||
return sprintf(buf, "%llu\n", hrv);
|
||||
}
|
||||
static DEVICE_ATTR(hrv, 0444, acpi_device_hrv_show, NULL);
|
||||
static DEVICE_ATTR_RO(hrv);
|
||||
|
||||
static ssize_t status_show(struct device *dev, struct device_attribute *attr,
|
||||
char *buf) {
|
||||
|
|
|
@ -485,7 +485,7 @@ int dock_notify(struct acpi_device *adev, u32 event)
|
|||
/*
|
||||
* show_docked - read method for "docked" file in sysfs
|
||||
*/
|
||||
static ssize_t show_docked(struct device *dev,
|
||||
static ssize_t docked_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct dock_station *dock_station = dev->platform_data;
|
||||
|
@ -494,24 +494,24 @@ static ssize_t show_docked(struct device *dev,
|
|||
acpi_bus_get_device(dock_station->handle, &adev);
|
||||
return snprintf(buf, PAGE_SIZE, "%u\n", acpi_device_enumerated(adev));
|
||||
}
|
||||
static DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL);
|
||||
static DEVICE_ATTR_RO(docked);
|
||||
|
||||
/*
|
||||
* show_flags - read method for flags file in sysfs
|
||||
*/
|
||||
static ssize_t show_flags(struct device *dev,
|
||||
static ssize_t flags_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct dock_station *dock_station = dev->platform_data;
|
||||
return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags);
|
||||
|
||||
}
|
||||
static DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL);
|
||||
static DEVICE_ATTR_RO(flags);
|
||||
|
||||
/*
|
||||
* write_undock - write method for "undock" file in sysfs
|
||||
*/
|
||||
static ssize_t write_undock(struct device *dev, struct device_attribute *attr,
|
||||
static ssize_t undock_store(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t count)
|
||||
{
|
||||
int ret;
|
||||
|
@ -526,12 +526,12 @@ static ssize_t write_undock(struct device *dev, struct device_attribute *attr,
|
|||
acpi_scan_lock_release();
|
||||
return ret ? ret: count;
|
||||
}
|
||||
static DEVICE_ATTR(undock, S_IWUSR, NULL, write_undock);
|
||||
static DEVICE_ATTR_WO(undock);
|
||||
|
||||
/*
|
||||
* show_dock_uid - read method for "uid" file in sysfs
|
||||
*/
|
||||
static ssize_t show_dock_uid(struct device *dev,
|
||||
static ssize_t uid_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
unsigned long long lbuf;
|
||||
|
@ -543,9 +543,9 @@ static ssize_t show_dock_uid(struct device *dev,
|
|||
|
||||
return snprintf(buf, PAGE_SIZE, "%llx\n", lbuf);
|
||||
}
|
||||
static DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL);
|
||||
static DEVICE_ATTR_RO(uid);
|
||||
|
||||
static ssize_t show_dock_type(struct device *dev,
|
||||
static ssize_t type_show(struct device *dev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct dock_station *dock_station = dev->platform_data;
|
||||
|
@ -562,7 +562,7 @@ static ssize_t show_dock_type(struct device *dev,
|
|||
|
||||
return snprintf(buf, PAGE_SIZE, "%s\n", type);
|
||||
}
|
||||
static DEVICE_ATTR(type, S_IRUGO, show_dock_type, NULL);
|
||||
static DEVICE_ATTR_RO(type);
|
||||
|
||||
static struct attribute *dock_attributes[] = {
|
||||
&dev_attr_docked.attr,
|
||||
|
|
|
@ -1826,6 +1826,22 @@ static const struct dmi_system_id ec_dmi_table[] __initconst = {
|
|||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "GL702VMK"),}, NULL},
|
||||
{
|
||||
ec_honor_ecdt_gpe, "ASUSTeK COMPUTER INC. X505BA", {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "X505BA"),}, NULL},
|
||||
{
|
||||
ec_honor_ecdt_gpe, "ASUSTeK COMPUTER INC. X505BP", {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "X505BP"),}, NULL},
|
||||
{
|
||||
ec_honor_ecdt_gpe, "ASUSTeK COMPUTER INC. X542BA", {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "X542BA"),}, NULL},
|
||||
{
|
||||
ec_honor_ecdt_gpe, "ASUSTeK COMPUTER INC. X542BP", {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "X542BP"),}, NULL},
|
||||
{
|
||||
ec_honor_ecdt_gpe, "ASUS X550VXK", {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "X550VXK"),}, NULL},
|
||||
|
|
|
@ -888,15 +888,16 @@ static void acpi_release_power_resource(struct device *dev)
|
|||
kfree(resource);
|
||||
}
|
||||
|
||||
static ssize_t acpi_power_in_use_show(struct device *dev,
|
||||
static ssize_t resource_in_use_show(struct device *dev,
|
||||
struct device_attribute *attr,
|
||||
char *buf) {
|
||||
char *buf)
|
||||
{
|
||||
struct acpi_power_resource *resource;
|
||||
|
||||
resource = to_power_resource(to_acpi_device(dev));
|
||||
return sprintf(buf, "%u\n", !!resource->ref_count);
|
||||
}
|
||||
static DEVICE_ATTR(resource_in_use, 0444, acpi_power_in_use_show, NULL);
|
||||
static DEVICE_ATTR_RO(resource_in_use);
|
||||
|
||||
static void acpi_power_sysfs_remove(struct acpi_device *device)
|
||||
{
|
||||
|
|
|
@ -16,6 +16,7 @@
|
|||
#include <linux/acpi.h>
|
||||
#include <linux/dmi.h>
|
||||
#include <linux/sched.h> /* need_resched() */
|
||||
#include <linux/sort.h>
|
||||
#include <linux/tick.h>
|
||||
#include <linux/cpuidle.h>
|
||||
#include <linux/cpu.h>
|
||||
|
@ -540,10 +541,37 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
|
|||
return;
|
||||
}
|
||||
|
||||
static int acpi_cst_latency_cmp(const void *a, const void *b)
|
||||
{
|
||||
const struct acpi_processor_cx *x = a, *y = b;
|
||||
|
||||
if (!(x->valid && y->valid))
|
||||
return 0;
|
||||
if (x->latency > y->latency)
|
||||
return 1;
|
||||
if (x->latency < y->latency)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
static void acpi_cst_latency_swap(void *a, void *b, int n)
|
||||
{
|
||||
struct acpi_processor_cx *x = a, *y = b;
|
||||
u32 tmp;
|
||||
|
||||
if (!(x->valid && y->valid))
|
||||
return;
|
||||
tmp = x->latency;
|
||||
x->latency = y->latency;
|
||||
y->latency = tmp;
|
||||
}
|
||||
|
||||
static int acpi_processor_power_verify(struct acpi_processor *pr)
|
||||
{
|
||||
unsigned int i;
|
||||
unsigned int working = 0;
|
||||
unsigned int last_latency = 0;
|
||||
unsigned int last_type = 0;
|
||||
bool buggy_latency = false;
|
||||
|
||||
pr->power.timer_broadcast_on_state = INT_MAX;
|
||||
|
||||
|
@ -567,12 +595,24 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)
|
|||
}
|
||||
if (!cx->valid)
|
||||
continue;
|
||||
if (cx->type >= last_type && cx->latency < last_latency)
|
||||
buggy_latency = true;
|
||||
last_latency = cx->latency;
|
||||
last_type = cx->type;
|
||||
|
||||
lapic_timer_check_state(i, pr, cx);
|
||||
tsc_check_state(cx->type);
|
||||
working++;
|
||||
}
|
||||
|
||||
if (buggy_latency) {
|
||||
pr_notice("FW issue: working around C-state latencies out of order\n");
|
||||
sort(&pr->power.states[1], max_cstate,
|
||||
sizeof(struct acpi_processor_cx),
|
||||
acpi_cst_latency_cmp,
|
||||
acpi_cst_latency_swap);
|
||||
}
|
||||
|
||||
lapic_timer_propagate_broadcast(pr);
|
||||
|
||||
return (working);
|
||||
|
|
|
@ -430,6 +430,13 @@ static void acpi_dev_get_irqresource(struct resource *res, u32 gsi,
|
|||
}
|
||||
}
|
||||
|
||||
static bool irq_is_legacy(struct acpi_resource_irq *irq)
|
||||
{
|
||||
return irq->triggering == ACPI_EDGE_SENSITIVE &&
|
||||
irq->polarity == ACPI_ACTIVE_HIGH &&
|
||||
irq->shareable == ACPI_EXCLUSIVE;
|
||||
}
|
||||
|
||||
/**
|
||||
* acpi_dev_resource_interrupt - Extract ACPI interrupt resource information.
|
||||
* @ares: Input ACPI resource object.
|
||||
|
@ -468,7 +475,7 @@ bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
|
|||
}
|
||||
acpi_dev_get_irqresource(res, irq->interrupts[index],
|
||||
irq->triggering, irq->polarity,
|
||||
irq->shareable, true);
|
||||
irq->shareable, irq_is_legacy(irq));
|
||||
break;
|
||||
case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
|
||||
ext_irq = &ares->data.extended_irq;
|
||||
|
|
|
@ -928,7 +928,7 @@ static int ep93xx_pata_probe(struct platform_device *pdev)
|
|||
/* INT[3] (IRQ_EP93XX_EXT3) line connected as pull down */
|
||||
irq = platform_get_irq(pdev, 0);
|
||||
if (irq < 0) {
|
||||
err = -ENXIO;
|
||||
err = irq;
|
||||
goto err_rel_gpio;
|
||||
}
|
||||
|
||||
|
|
|
@ -898,10 +898,11 @@ static int octeon_cf_probe(struct platform_device *pdev)
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
irq_handler = octeon_cf_interrupt;
|
||||
i = platform_get_irq(dma_dev, 0);
|
||||
if (i > 0)
|
||||
if (i > 0) {
|
||||
irq = i;
|
||||
irq_handler = octeon_cf_interrupt;
|
||||
}
|
||||
}
|
||||
of_node_put(dma_node);
|
||||
}
|
||||
|
|
|
@ -115,10 +115,12 @@ static int rb532_pata_driver_probe(struct platform_device *pdev)
|
|||
}
|
||||
|
||||
irq = platform_get_irq(pdev, 0);
|
||||
if (irq <= 0) {
|
||||
if (irq < 0) {
|
||||
dev_err(&pdev->dev, "no IRQ resource found\n");
|
||||
return -ENOENT;
|
||||
return irq;
|
||||
}
|
||||
if (!irq)
|
||||
return -EINVAL;
|
||||
|
||||
gpiod = devm_gpiod_get(&pdev->dev, NULL, GPIOD_IN);
|
||||
if (IS_ERR(gpiod)) {
|
||||
|
|
|
@ -469,10 +469,12 @@ static int ahci_highbank_probe(struct platform_device *pdev)
|
|||
}
|
||||
|
||||
irq = platform_get_irq(pdev, 0);
|
||||
if (irq <= 0) {
|
||||
if (irq < 0) {
|
||||
dev_err(dev, "no irq\n");
|
||||
return -EINVAL;
|
||||
return irq;
|
||||
}
|
||||
if (!irq)
|
||||
return -EINVAL;
|
||||
|
||||
hpriv = devm_kzalloc(dev, sizeof(*hpriv), GFP_KERNEL);
|
||||
if (!hpriv) {
|
||||
|
|
|
@ -134,7 +134,7 @@ static int exynos_trng_probe(struct platform_device *pdev)
|
|||
return PTR_ERR(trng->mem);
|
||||
|
||||
pm_runtime_enable(&pdev->dev);
|
||||
ret = pm_runtime_get_sync(&pdev->dev);
|
||||
ret = pm_runtime_resume_and_get(&pdev->dev);
|
||||
if (ret < 0) {
|
||||
dev_err(&pdev->dev, "Could not get runtime PM.\n");
|
||||
goto err_pm_get;
|
||||
|
@ -167,7 +167,7 @@ err_register:
|
|||
clk_disable_unprepare(trng->clk);
|
||||
|
||||
err_clock:
|
||||
pm_runtime_put_sync(&pdev->dev);
|
||||
pm_runtime_put_noidle(&pdev->dev);
|
||||
|
||||
err_pm_get:
|
||||
pm_runtime_disable(&pdev->dev);
|
||||
|
|
|
@ -544,6 +544,10 @@ static int set_protocol(struct cm4000_dev *dev, struct ptsreq *ptsreq)
|
|||
io_read_num_rec_bytes(iobase, &num_bytes_read);
|
||||
if (num_bytes_read >= 4) {
|
||||
DEBUGP(2, dev, "NumRecBytes = %i\n", num_bytes_read);
|
||||
if (num_bytes_read > 4) {
|
||||
rc = -EIO;
|
||||
goto exit_setprotocol;
|
||||
}
|
||||
break;
|
||||
}
|
||||
usleep_range(10000, 11000);
|
||||
|
|
|
@ -125,8 +125,7 @@ static struct clk_factor_table sd_factor_table[] = {
|
|||
{ 12, 1, 13 }, { 13, 1, 14 }, { 14, 1, 15 }, { 15, 1, 16 },
|
||||
{ 16, 1, 17 }, { 17, 1, 18 }, { 18, 1, 19 }, { 19, 1, 20 },
|
||||
{ 20, 1, 21 }, { 21, 1, 22 }, { 22, 1, 23 }, { 23, 1, 24 },
|
||||
{ 24, 1, 25 }, { 25, 1, 26 }, { 26, 1, 27 }, { 27, 1, 28 },
|
||||
{ 28, 1, 29 }, { 29, 1, 30 }, { 30, 1, 31 }, { 31, 1, 32 },
|
||||
{ 24, 1, 25 },
|
||||
|
||||
/* bit8: /128 */
|
||||
{ 256, 1, 1 * 128 }, { 257, 1, 2 * 128 }, { 258, 1, 3 * 128 }, { 259, 1, 4 * 128 },
|
||||
|
@ -135,14 +134,20 @@ static struct clk_factor_table sd_factor_table[] = {
|
|||
{ 268, 1, 13 * 128 }, { 269, 1, 14 * 128 }, { 270, 1, 15 * 128 }, { 271, 1, 16 * 128 },
|
||||
{ 272, 1, 17 * 128 }, { 273, 1, 18 * 128 }, { 274, 1, 19 * 128 }, { 275, 1, 20 * 128 },
|
||||
{ 276, 1, 21 * 128 }, { 277, 1, 22 * 128 }, { 278, 1, 23 * 128 }, { 279, 1, 24 * 128 },
|
||||
{ 280, 1, 25 * 128 }, { 281, 1, 26 * 128 }, { 282, 1, 27 * 128 }, { 283, 1, 28 * 128 },
|
||||
{ 284, 1, 29 * 128 }, { 285, 1, 30 * 128 }, { 286, 1, 31 * 128 }, { 287, 1, 32 * 128 },
|
||||
{ 280, 1, 25 * 128 },
|
||||
{ 0, 0, 0 },
|
||||
};
|
||||
|
||||
static struct clk_factor_table bisp_factor_table[] = {
|
||||
{ 0, 1, 1 }, { 1, 1, 2 }, { 2, 1, 3 }, { 3, 1, 4 },
|
||||
{ 4, 1, 5 }, { 5, 1, 6 }, { 6, 1, 7 }, { 7, 1, 8 },
|
||||
static struct clk_factor_table de_factor_table[] = {
|
||||
{ 0, 1, 1 }, { 1, 2, 3 }, { 2, 1, 2 }, { 3, 2, 5 },
|
||||
{ 4, 1, 3 }, { 5, 1, 4 }, { 6, 1, 6 }, { 7, 1, 8 },
|
||||
{ 8, 1, 12 },
|
||||
{ 0, 0, 0 },
|
||||
};
|
||||
|
||||
static struct clk_factor_table hde_factor_table[] = {
|
||||
{ 0, 1, 1 }, { 1, 2, 3 }, { 2, 1, 2 }, { 3, 2, 5 },
|
||||
{ 4, 1, 3 }, { 5, 1, 4 }, { 6, 1, 6 }, { 7, 1, 8 },
|
||||
{ 0, 0, 0 },
|
||||
};
|
||||
|
||||
|
@ -156,6 +161,13 @@ static struct clk_div_table rmii_ref_div_table[] = {
|
|||
{ 0, 0 },
|
||||
};
|
||||
|
||||
static struct clk_div_table std12rate_div_table[] = {
|
||||
{ 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 4 },
|
||||
{ 4, 5 }, { 5, 6 }, { 6, 7 }, { 7, 8 },
|
||||
{ 8, 9 }, { 9, 10 }, { 10, 11 }, { 11, 12 },
|
||||
{ 0, 0 },
|
||||
};
|
||||
|
||||
static struct clk_div_table i2s_div_table[] = {
|
||||
{ 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 4 },
|
||||
{ 4, 6 }, { 5, 8 }, { 6, 12 }, { 7, 16 },
|
||||
|
@ -188,39 +200,39 @@ static OWL_DIVIDER(rmii_ref_clk, "rmii_ref_clk", "ethernet_pll_clk", CMU_ETHERNE
|
|||
|
||||
/* factor clocks */
|
||||
static OWL_FACTOR(ahb_clk, "ahb_clk", "h_clk", CMU_BUSCLK1, 2, 2, ahb_factor_table, 0, 0);
|
||||
static OWL_FACTOR(de1_clk, "de_clk1", "de_clk", CMU_DECLK, 0, 3, bisp_factor_table, 0, 0);
|
||||
static OWL_FACTOR(de2_clk, "de_clk2", "de_clk", CMU_DECLK, 4, 3, bisp_factor_table, 0, 0);
|
||||
static OWL_FACTOR(de1_clk, "de_clk1", "de_clk", CMU_DECLK, 0, 4, de_factor_table, 0, 0);
|
||||
static OWL_FACTOR(de2_clk, "de_clk2", "de_clk", CMU_DECLK, 4, 4, de_factor_table, 0, 0);
|
||||
|
||||
/* composite clocks */
|
||||
static OWL_COMP_FACTOR(vce_clk, "vce_clk", hde_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_VCECLK, 4, 2),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN0, 26, 0),
|
||||
OWL_FACTOR_HW(CMU_VCECLK, 0, 3, 0, bisp_factor_table),
|
||||
OWL_FACTOR_HW(CMU_VCECLK, 0, 3, 0, hde_factor_table),
|
||||
0);
|
||||
|
||||
static OWL_COMP_FACTOR(vde_clk, "vde_clk", hde_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_VDECLK, 4, 2),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN0, 25, 0),
|
||||
OWL_FACTOR_HW(CMU_VDECLK, 0, 3, 0, bisp_factor_table),
|
||||
OWL_FACTOR_HW(CMU_VDECLK, 0, 3, 0, hde_factor_table),
|
||||
0);
|
||||
|
||||
static OWL_COMP_FACTOR(bisp_clk, "bisp_clk", bisp_clk_mux_p,
|
||||
static OWL_COMP_DIV(bisp_clk, "bisp_clk", bisp_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_BISPCLK, 4, 1),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN0, 14, 0),
|
||||
OWL_FACTOR_HW(CMU_BISPCLK, 0, 3, 0, bisp_factor_table),
|
||||
OWL_DIVIDER_HW(CMU_BISPCLK, 0, 4, 0, std12rate_div_table),
|
||||
0);
|
||||
|
||||
static OWL_COMP_FACTOR(sensor0_clk, "sensor0_clk", sensor_clk_mux_p,
|
||||
static OWL_COMP_DIV(sensor0_clk, "sensor0_clk", sensor_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_SENSORCLK, 4, 1),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN0, 14, 0),
|
||||
OWL_FACTOR_HW(CMU_SENSORCLK, 0, 3, 0, bisp_factor_table),
|
||||
CLK_IGNORE_UNUSED);
|
||||
OWL_DIVIDER_HW(CMU_SENSORCLK, 0, 4, 0, std12rate_div_table),
|
||||
0);
|
||||
|
||||
static OWL_COMP_FACTOR(sensor1_clk, "sensor1_clk", sensor_clk_mux_p,
|
||||
static OWL_COMP_DIV(sensor1_clk, "sensor1_clk", sensor_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_SENSORCLK, 4, 1),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN0, 14, 0),
|
||||
OWL_FACTOR_HW(CMU_SENSORCLK, 8, 3, 0, bisp_factor_table),
|
||||
CLK_IGNORE_UNUSED);
|
||||
OWL_DIVIDER_HW(CMU_SENSORCLK, 8, 4, 0, std12rate_div_table),
|
||||
0);
|
||||
|
||||
static OWL_COMP_FACTOR(sd0_clk, "sd0_clk", sd_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_SD0CLK, 9, 1),
|
||||
|
@ -300,7 +312,7 @@ static OWL_COMP_FIXED_FACTOR(i2c3_clk, "i2c3_clk", "ethernet_pll_clk",
|
|||
static OWL_COMP_DIV(uart0_clk, "uart0_clk", uart_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_UART0CLK, 16, 1),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN1, 6, 0),
|
||||
OWL_DIVIDER_HW(CMU_UART1CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
OWL_DIVIDER_HW(CMU_UART0CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
CLK_IGNORE_UNUSED);
|
||||
|
||||
static OWL_COMP_DIV(uart1_clk, "uart1_clk", uart_clk_mux_p,
|
||||
|
@ -312,31 +324,31 @@ static OWL_COMP_DIV(uart1_clk, "uart1_clk", uart_clk_mux_p,
|
|||
static OWL_COMP_DIV(uart2_clk, "uart2_clk", uart_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_UART2CLK, 16, 1),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN1, 8, 0),
|
||||
OWL_DIVIDER_HW(CMU_UART1CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
OWL_DIVIDER_HW(CMU_UART2CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
CLK_IGNORE_UNUSED);
|
||||
|
||||
static OWL_COMP_DIV(uart3_clk, "uart3_clk", uart_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_UART3CLK, 16, 1),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN1, 19, 0),
|
||||
OWL_DIVIDER_HW(CMU_UART1CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
OWL_DIVIDER_HW(CMU_UART3CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
CLK_IGNORE_UNUSED);
|
||||
|
||||
static OWL_COMP_DIV(uart4_clk, "uart4_clk", uart_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_UART4CLK, 16, 1),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN1, 20, 0),
|
||||
OWL_DIVIDER_HW(CMU_UART1CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
OWL_DIVIDER_HW(CMU_UART4CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
CLK_IGNORE_UNUSED);
|
||||
|
||||
static OWL_COMP_DIV(uart5_clk, "uart5_clk", uart_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_UART5CLK, 16, 1),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN1, 21, 0),
|
||||
OWL_DIVIDER_HW(CMU_UART1CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
OWL_DIVIDER_HW(CMU_UART5CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
CLK_IGNORE_UNUSED);
|
||||
|
||||
static OWL_COMP_DIV(uart6_clk, "uart6_clk", uart_clk_mux_p,
|
||||
OWL_MUX_HW(CMU_UART6CLK, 16, 1),
|
||||
OWL_GATE_HW(CMU_DEVCLKEN1, 18, 0),
|
||||
OWL_DIVIDER_HW(CMU_UART1CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
OWL_DIVIDER_HW(CMU_UART6CLK, 0, 8, CLK_DIVIDER_ROUND_CLOSEST, NULL),
|
||||
CLK_IGNORE_UNUSED);
|
||||
|
||||
static OWL_COMP_DIV(i2srx_clk, "i2srx_clk", i2s_clk_mux_p,
|
||||
|
|
|
@ -304,6 +304,8 @@ static const struct si5341_reg_default si5341_reg_defaults[] = {
|
|||
{ 0x094A, 0x00 }, /* INx_TO_PFD_EN (disabled) */
|
||||
{ 0x0A02, 0x00 }, /* Not in datasheet */
|
||||
{ 0x0B44, 0x0F }, /* PDIV_ENB (datasheet does not mention what it is) */
|
||||
{ 0x0B57, 0x10 }, /* VCO_RESET_CALCODE (not described in datasheet) */
|
||||
{ 0x0B58, 0x05 }, /* VCO_RESET_CALCODE (not described in datasheet) */
|
||||
};
|
||||
|
||||
/* Read and interpret a 44-bit followed by a 32-bit value in the regmap */
|
||||
|
@ -482,6 +484,9 @@ static unsigned long si5341_synth_clk_recalc_rate(struct clk_hw *hw,
|
|||
SI5341_SYNTH_N_NUM(synth->index), &n_num, &n_den);
|
||||
if (err < 0)
|
||||
return err;
|
||||
/* Check for bogus/uninitialized settings */
|
||||
if (!n_num || !n_den)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* n_num and n_den are shifted left as much as possible, so to prevent
|
||||
|
@ -665,6 +670,9 @@ static long si5341_output_clk_round_rate(struct clk_hw *hw, unsigned long rate,
|
|||
{
|
||||
unsigned long r;
|
||||
|
||||
if (!rate)
|
||||
return 0;
|
||||
|
||||
r = *parent_rate >> 1;
|
||||
|
||||
/* If rate is an even divisor, no changes to parent required */
|
||||
|
@ -693,11 +701,16 @@ static int si5341_output_clk_set_rate(struct clk_hw *hw, unsigned long rate,
|
|||
unsigned long parent_rate)
|
||||
{
|
||||
struct clk_si5341_output *output = to_clk_si5341_output(hw);
|
||||
/* Frequency divider is (r_div + 1) * 2 */
|
||||
u32 r_div = (parent_rate / rate) >> 1;
|
||||
u32 r_div;
|
||||
int err;
|
||||
u8 r[3];
|
||||
|
||||
if (!rate)
|
||||
return -EINVAL;
|
||||
|
||||
/* Frequency divider is (r_div + 1) * 2 */
|
||||
r_div = (parent_rate / rate) >> 1;
|
||||
|
||||
if (r_div <= 1)
|
||||
r_div = 0;
|
||||
else if (r_div >= BIT(24))
|
||||
|
@ -924,7 +937,7 @@ static const struct si5341_reg_default si5341_preamble[] = {
|
|||
{ 0x0B25, 0x00 },
|
||||
{ 0x0502, 0x01 },
|
||||
{ 0x0505, 0x03 },
|
||||
{ 0x0957, 0x1F },
|
||||
{ 0x0957, 0x17 },
|
||||
{ 0x0B4E, 0x1A },
|
||||
};
|
||||
|
||||
|
|
|
@ -1602,7 +1602,7 @@ static struct clk_regmap g12b_cpub_clk_trace = {
|
|||
};
|
||||
|
||||
static const struct pll_mult_range g12a_gp0_pll_mult_range = {
|
||||
.min = 55,
|
||||
.min = 125,
|
||||
.max = 255,
|
||||
};
|
||||
|
||||
|
|
|
@ -1361,9 +1361,14 @@ static int cpufreq_online(unsigned int cpu)
|
|||
goto out_free_policy;
|
||||
}
|
||||
|
||||
/*
|
||||
* The initialization has succeeded and the policy is online.
|
||||
* If there is a problem with its frequency table, take it
|
||||
* offline and drop it.
|
||||
*/
|
||||
ret = cpufreq_table_validate_and_sort(policy);
|
||||
if (ret)
|
||||
goto out_exit_policy;
|
||||
goto out_offline_policy;
|
||||
|
||||
/* related_cpus should at least include policy->cpus. */
|
||||
cpumask_copy(policy->related_cpus, policy->cpus);
|
||||
|
@ -1507,6 +1512,10 @@ out_destroy_policy:
|
|||
|
||||
up_write(&policy->rwsem);
|
||||
|
||||
out_offline_policy:
|
||||
if (cpufreq_driver->offline)
|
||||
cpufreq_driver->offline(policy);
|
||||
|
||||
out_exit_policy:
|
||||
if (cpufreq_driver->exit)
|
||||
cpufreq_driver->exit(policy);
|
||||
|
|
|
@ -306,6 +306,10 @@ int nitrox_register_interrupts(struct nitrox_device *ndev)
|
|||
* Entry 192: NPS_CORE_INT_ACTIVE
|
||||
*/
|
||||
nr_vecs = pci_msix_vec_count(pdev);
|
||||
if (nr_vecs < 0) {
|
||||
dev_err(DEV(ndev), "Error in getting vec count %d\n", nr_vecs);
|
||||
return nr_vecs;
|
||||
}
|
||||
|
||||
/* Enable MSI-X */
|
||||
ret = pci_alloc_irq_vectors(pdev, nr_vecs, nr_vecs, PCI_IRQ_MSIX);
|
||||
|
|
|
@ -213,7 +213,7 @@ static int sp_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
|
|||
if (ret) {
|
||||
dev_err(dev, "dma_set_mask_and_coherent failed (%d)\n",
|
||||
ret);
|
||||
goto e_err;
|
||||
goto free_irqs;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -221,10 +221,12 @@ static int sp_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
|
|||
|
||||
ret = sp_init(sp);
|
||||
if (ret)
|
||||
goto e_err;
|
||||
goto free_irqs;
|
||||
|
||||
return 0;
|
||||
|
||||
free_irqs:
|
||||
sp_free_irqs(sp);
|
||||
e_err:
|
||||
dev_notice(dev, "initialization failed\n");
|
||||
return ret;
|
||||
|
|
|
@ -329,7 +329,7 @@ static void free_buf_chain(struct device *dev, struct buffer_desc *buf,
|
|||
|
||||
buf1 = buf->next;
|
||||
phys1 = buf->phys_next;
|
||||
dma_unmap_single(dev, buf->phys_next, buf->buf_len, buf->dir);
|
||||
dma_unmap_single(dev, buf->phys_addr, buf->buf_len, buf->dir);
|
||||
dma_pool_free(buffer_pool, buf, phys);
|
||||
buf = buf1;
|
||||
phys = phys1;
|
||||
|
|
|
@ -538,13 +538,15 @@ static int nx842_OF_set_defaults(struct nx842_devdata *devdata)
|
|||
* The status field indicates if the device is enabled when the status
|
||||
* is 'okay'. Otherwise the device driver will be disabled.
|
||||
*
|
||||
* @prop - struct property point containing the maxsyncop for the update
|
||||
* @devdata: struct nx842_devdata to use for dev_info
|
||||
* @prop: struct property point containing the maxsyncop for the update
|
||||
*
|
||||
* Returns:
|
||||
* 0 - Device is available
|
||||
* -ENODEV - Device is not available
|
||||
*/
|
||||
static int nx842_OF_upd_status(struct property *prop)
|
||||
static int nx842_OF_upd_status(struct nx842_devdata *devdata,
|
||||
struct property *prop)
|
||||
{
|
||||
const char *status = (const char *)prop->value;
|
||||
|
||||
|
@ -758,7 +760,7 @@ static int nx842_OF_upd(struct property *new_prop)
|
|||
goto out;
|
||||
|
||||
/* Perform property updates */
|
||||
ret = nx842_OF_upd_status(status);
|
||||
ret = nx842_OF_upd_status(new_devdata, status);
|
||||
if (ret)
|
||||
goto error_out;
|
||||
|
||||
|
@ -1071,6 +1073,7 @@ static const struct vio_device_id nx842_vio_driver_ids[] = {
|
|||
{"ibm,compression-v1", "ibm,compression"},
|
||||
{"", ""},
|
||||
};
|
||||
MODULE_DEVICE_TABLE(vio, nx842_vio_driver_ids);
|
||||
|
||||
static struct vio_driver nx842_vio_driver = {
|
||||
.name = KBUILD_MODNAME,
|
||||
|
|
|
@ -364,7 +364,7 @@ static int omap_sham_hw_init(struct omap_sham_dev *dd)
|
|||
{
|
||||
int err;
|
||||
|
||||
err = pm_runtime_get_sync(dd->dev);
|
||||
err = pm_runtime_resume_and_get(dd->dev);
|
||||
if (err < 0) {
|
||||
dev_err(dd->dev, "failed to get sync: %d\n", err);
|
||||
return err;
|
||||
|
@ -2236,7 +2236,7 @@ static int omap_sham_suspend(struct device *dev)
|
|||
|
||||
static int omap_sham_resume(struct device *dev)
|
||||
{
|
||||
int err = pm_runtime_get_sync(dev);
|
||||
int err = pm_runtime_resume_and_get(dev);
|
||||
if (err < 0) {
|
||||
dev_err(dev, "failed to get sync: %d\n", err);
|
||||
return err;
|
||||
|
|
|
@ -1256,7 +1256,11 @@ static int qat_hal_put_rel_wr_xfer(struct icp_qat_fw_loader_handle *handle,
|
|||
pr_err("QAT: bad xfrAddr=0x%x\n", xfr_addr);
|
||||
return -EINVAL;
|
||||
}
|
||||
qat_hal_rd_rel_reg(handle, ae, ctx, ICP_GPB_REL, gprnum, &gprval);
|
||||
status = qat_hal_rd_rel_reg(handle, ae, ctx, ICP_GPB_REL, gprnum, &gprval);
|
||||
if (status) {
|
||||
pr_err("QAT: failed to read register");
|
||||
return status;
|
||||
}
|
||||
gpr_addr = qat_hal_get_reg_addr(ICP_GPB_REL, gprnum);
|
||||
data16low = 0xffff & data;
|
||||
data16hi = 0xffff & (data >> 0x10);
|
||||
|
|
|
@ -385,7 +385,6 @@ static int qat_uclo_init_umem_seg(struct icp_qat_fw_loader_handle *handle,
|
|||
return 0;
|
||||
}
|
||||
|
||||
#define ICP_DH895XCC_PESRAM_BAR_SIZE 0x80000
|
||||
static int qat_uclo_init_ae_memory(struct icp_qat_fw_loader_handle *handle,
|
||||
struct icp_qat_uof_initmem *init_mem)
|
||||
{
|
||||
|
|
|
@ -1009,6 +1009,7 @@ static int hash_hw_final(struct ahash_request *req)
|
|||
goto out;
|
||||
}
|
||||
} else if (req->nbytes == 0 && ctx->keylen > 0) {
|
||||
ret = -EPERM;
|
||||
dev_err(device_data->dev, "%s: Empty message with keylength > 0, NOT supported\n",
|
||||
__func__);
|
||||
goto out;
|
||||
|
|
|
@ -249,6 +249,9 @@ static int __init i10nm_init(void)
|
|||
if (owner && strncmp(owner, EDAC_MOD_STR, sizeof(EDAC_MOD_STR)))
|
||||
return -EBUSY;
|
||||
|
||||
if (cpu_feature_enabled(X86_FEATURE_HYPERVISOR))
|
||||
return -ENODEV;
|
||||
|
||||
id = x86_match_cpu(i10nm_cpuids);
|
||||
if (!id)
|
||||
return -ENODEV;
|
||||
|
|
|
@ -1555,6 +1555,9 @@ static int __init pnd2_init(void)
|
|||
if (owner && strncmp(owner, EDAC_MOD_STR, sizeof(EDAC_MOD_STR)))
|
||||
return -EBUSY;
|
||||
|
||||
if (cpu_feature_enabled(X86_FEATURE_HYPERVISOR))
|
||||
return -ENODEV;
|
||||
|
||||
id = x86_match_cpu(pnd2_cpuids);
|
||||
if (!id)
|
||||
return -ENODEV;
|
||||
|
|
|
@ -3512,6 +3512,9 @@ static int __init sbridge_init(void)
|
|||
if (owner && strncmp(owner, EDAC_MOD_STR, sizeof(EDAC_MOD_STR)))
|
||||
return -EBUSY;
|
||||
|
||||
if (cpu_feature_enabled(X86_FEATURE_HYPERVISOR))
|
||||
return -ENODEV;
|
||||
|
||||
id = x86_match_cpu(sbridge_cpuids);
|
||||
if (!id)
|
||||
return -ENODEV;
|
||||
|
|
|
@ -605,6 +605,9 @@ static int __init skx_init(void)
|
|||
if (owner && strncmp(owner, EDAC_MOD_STR, sizeof(EDAC_MOD_STR)))
|
||||
return -EBUSY;
|
||||
|
||||
if (cpu_feature_enabled(X86_FEATURE_HYPERVISOR))
|
||||
return -ENODEV;
|
||||
|
||||
id = x86_match_cpu(skx_cpuids);
|
||||
if (!id)
|
||||
return -ENODEV;
|
||||
|
|
|
@ -197,6 +197,7 @@ static const struct of_device_id ti_edac_of_match[] = {
|
|||
{ .compatible = "ti,emif-dra7xx", .data = (void *)EMIF_TYPE_DRA7 },
|
||||
{},
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, ti_edac_of_match);
|
||||
|
||||
static int _emif_get_id(struct device_node *node)
|
||||
{
|
||||
|
|
|
@ -729,7 +729,7 @@ static int max8997_muic_probe(struct platform_device *pdev)
|
|||
2, info->status);
|
||||
if (ret) {
|
||||
dev_err(info->dev, "failed to read MUIC register\n");
|
||||
return ret;
|
||||
goto err_irq;
|
||||
}
|
||||
cable_type = max8997_muic_get_cable_type(info,
|
||||
MAX8997_CABLE_GROUP_ADC, &attached);
|
||||
|
@ -784,3 +784,4 @@ module_platform_driver(max8997_muic_driver);
|
|||
MODULE_DESCRIPTION("Maxim MAX8997 Extcon driver");
|
||||
MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("platform:max8997-muic");
|
||||
|
|
|
@ -88,7 +88,6 @@ static struct reg_data sm5502_reg_data[] = {
|
|||
| SM5502_REG_INTM2_MHL_MASK,
|
||||
.invert = true,
|
||||
},
|
||||
{ }
|
||||
};
|
||||
|
||||
/* List of detectable cables */
|
||||
|
|
|
@ -1026,24 +1026,32 @@ static int stratix10_svc_drv_probe(struct platform_device *pdev)
|
|||
|
||||
/* add svc client device(s) */
|
||||
svc = devm_kzalloc(dev, sizeof(*svc), GFP_KERNEL);
|
||||
if (!svc)
|
||||
return -ENOMEM;
|
||||
if (!svc) {
|
||||
ret = -ENOMEM;
|
||||
goto err_free_kfifo;
|
||||
}
|
||||
|
||||
svc->stratix10_svc_rsu = platform_device_alloc(STRATIX10_RSU, 0);
|
||||
if (!svc->stratix10_svc_rsu) {
|
||||
dev_err(dev, "failed to allocate %s device\n", STRATIX10_RSU);
|
||||
return -ENOMEM;
|
||||
ret = -ENOMEM;
|
||||
goto err_free_kfifo;
|
||||
}
|
||||
|
||||
ret = platform_device_add(svc->stratix10_svc_rsu);
|
||||
if (ret) {
|
||||
platform_device_put(svc->stratix10_svc_rsu);
|
||||
return ret;
|
||||
}
|
||||
if (ret)
|
||||
goto err_put_device;
|
||||
|
||||
dev_set_drvdata(dev, svc);
|
||||
|
||||
pr_info("Intel Service Layer Driver Initialized\n");
|
||||
|
||||
return 0;
|
||||
|
||||
err_put_device:
|
||||
platform_device_put(svc->stratix10_svc_rsu);
|
||||
err_free_kfifo:
|
||||
kfifo_free(&controller->svc_fifo);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -718,7 +718,7 @@ static ssize_t cfam_read(struct file *filep, char __user *buf, size_t count,
|
|||
rc = count;
|
||||
fail:
|
||||
*offset = off;
|
||||
return count;
|
||||
return rc;
|
||||
}
|
||||
|
||||
static ssize_t cfam_write(struct file *filep, const char __user *buf,
|
||||
|
@ -755,7 +755,7 @@ static ssize_t cfam_write(struct file *filep, const char __user *buf,
|
|||
rc = count;
|
||||
fail:
|
||||
*offset = off;
|
||||
return count;
|
||||
return rc;
|
||||
}
|
||||
|
||||
static loff_t cfam_llseek(struct file *file, loff_t offset, int whence)
|
||||
|
|
|
@ -445,6 +445,7 @@ int fsi_occ_submit(struct device *dev, const void *request, size_t req_len,
|
|||
goto done;
|
||||
|
||||
if (resp->return_status == OCC_RESP_CMD_IN_PRG ||
|
||||
resp->return_status == OCC_RESP_CRIT_INIT ||
|
||||
resp->seq_no != seq_no) {
|
||||
rc = -ETIMEDOUT;
|
||||
|
||||
|
|
|
@ -325,7 +325,8 @@ static int sbefifo_up_write(struct sbefifo *sbefifo, __be32 word)
|
|||
static int sbefifo_request_reset(struct sbefifo *sbefifo)
|
||||
{
|
||||
struct device *dev = &sbefifo->fsi_dev->dev;
|
||||
u32 status, timeout;
|
||||
unsigned long end_time;
|
||||
u32 status;
|
||||
int rc;
|
||||
|
||||
dev_dbg(dev, "Requesting FIFO reset\n");
|
||||
|
@ -341,7 +342,8 @@ static int sbefifo_request_reset(struct sbefifo *sbefifo)
|
|||
}
|
||||
|
||||
/* Wait for it to complete */
|
||||
for (timeout = 0; timeout < SBEFIFO_RESET_TIMEOUT; timeout++) {
|
||||
end_time = jiffies + msecs_to_jiffies(SBEFIFO_RESET_TIMEOUT);
|
||||
while (!time_after(jiffies, end_time)) {
|
||||
rc = sbefifo_regr(sbefifo, SBEFIFO_UP | SBEFIFO_STS, &status);
|
||||
if (rc) {
|
||||
dev_err(dev, "Failed to read UP fifo status during reset"
|
||||
|
@ -355,7 +357,7 @@ static int sbefifo_request_reset(struct sbefifo *sbefifo)
|
|||
return 0;
|
||||
}
|
||||
|
||||
msleep(1);
|
||||
cond_resched();
|
||||
}
|
||||
dev_err(dev, "FIFO reset timed out\n");
|
||||
|
||||
|
@ -400,7 +402,7 @@ static int sbefifo_cleanup_hw(struct sbefifo *sbefifo)
|
|||
/* The FIFO already contains a reset request from the SBE ? */
|
||||
if (down_status & SBEFIFO_STS_RESET_REQ) {
|
||||
dev_info(dev, "Cleanup: FIFO reset request set, resetting\n");
|
||||
rc = sbefifo_regw(sbefifo, SBEFIFO_UP, SBEFIFO_PERFORM_RESET);
|
||||
rc = sbefifo_regw(sbefifo, SBEFIFO_DOWN, SBEFIFO_PERFORM_RESET);
|
||||
if (rc) {
|
||||
sbefifo->broken = true;
|
||||
dev_err(dev, "Cleanup: Reset reg write failed, rc=%d\n", rc);
|
||||
|
|
|
@ -38,9 +38,10 @@
|
|||
#define SCOM_STATUS_PIB_RESP_MASK 0x00007000
|
||||
#define SCOM_STATUS_PIB_RESP_SHIFT 12
|
||||
|
||||
#define SCOM_STATUS_ANY_ERR (SCOM_STATUS_PROTECTION | \
|
||||
#define SCOM_STATUS_FSI2PIB_ERROR (SCOM_STATUS_PROTECTION | \
|
||||
SCOM_STATUS_PARITY | \
|
||||
SCOM_STATUS_PIB_ABORT | \
|
||||
SCOM_STATUS_PIB_ABORT)
|
||||
#define SCOM_STATUS_ANY_ERR (SCOM_STATUS_FSI2PIB_ERROR | \
|
||||
SCOM_STATUS_PIB_RESP_MASK)
|
||||
/* SCOM address encodings */
|
||||
#define XSCOM_ADDR_IND_FLAG BIT_ULL(63)
|
||||
|
@ -240,13 +241,14 @@ static int handle_fsi2pib_status(struct scom_device *scom, uint32_t status)
|
|||
{
|
||||
uint32_t dummy = -1;
|
||||
|
||||
if (status & SCOM_STATUS_PROTECTION)
|
||||
return -EPERM;
|
||||
if (status & SCOM_STATUS_PARITY) {
|
||||
if (status & SCOM_STATUS_FSI2PIB_ERROR)
|
||||
fsi_device_write(scom->fsi_dev, SCOM_FSI2PIB_RESET_REG, &dummy,
|
||||
sizeof(uint32_t));
|
||||
|
||||
if (status & SCOM_STATUS_PROTECTION)
|
||||
return -EPERM;
|
||||
if (status & SCOM_STATUS_PARITY)
|
||||
return -EIO;
|
||||
}
|
||||
/* Return -EBUSY on PIB abort to force a retry */
|
||||
if (status & SCOM_STATUS_PIB_ABORT)
|
||||
return -EBUSY;
|
||||
|
|
|
@ -58,6 +58,8 @@ int qxl_mode_dumb_create(struct drm_file *file_priv,
|
|||
surf.height = args->height;
|
||||
surf.stride = pitch;
|
||||
surf.format = format;
|
||||
surf.data = 0;
|
||||
|
||||
r = qxl_gem_object_create_with_handle(qdev, file_priv,
|
||||
QXL_GEM_DOMAIN_SURFACE,
|
||||
args->size, &surf, &qobj,
|
||||
|
|
|
@ -72,6 +72,7 @@ static int cdn_dp_grf_write(struct cdn_dp_device *dp,
|
|||
ret = regmap_write(dp->grf, reg, val);
|
||||
if (ret) {
|
||||
DRM_DEV_ERROR(dev, "Could not write to GRF: %d\n", ret);
|
||||
clk_disable_unprepare(dp->grf_clk);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -564,13 +564,8 @@ static const struct dw_mipi_dsi_phy_ops dw_mipi_dsi_rockchip_phy_ops = {
|
|||
.get_lane_mbps = dw_mipi_dsi_get_lane_mbps,
|
||||
};
|
||||
|
||||
static void dw_mipi_dsi_rockchip_config(struct dw_mipi_dsi_rockchip *dsi,
|
||||
int mux)
|
||||
static void dw_mipi_dsi_rockchip_config(struct dw_mipi_dsi_rockchip *dsi)
|
||||
{
|
||||
if (dsi->cdata->lcdsel_grf_reg)
|
||||
regmap_write(dsi->grf_regmap, dsi->cdata->lcdsel_grf_reg,
|
||||
mux ? dsi->cdata->lcdsel_lit : dsi->cdata->lcdsel_big);
|
||||
|
||||
if (dsi->cdata->lanecfg1_grf_reg)
|
||||
regmap_write(dsi->grf_regmap, dsi->cdata->lanecfg1_grf_reg,
|
||||
dsi->cdata->lanecfg1);
|
||||
|
@ -584,6 +579,13 @@ static void dw_mipi_dsi_rockchip_config(struct dw_mipi_dsi_rockchip *dsi,
|
|||
dsi->cdata->enable);
|
||||
}
|
||||
|
||||
static void dw_mipi_dsi_rockchip_set_lcdsel(struct dw_mipi_dsi_rockchip *dsi,
|
||||
int mux)
|
||||
{
|
||||
regmap_write(dsi->grf_regmap, dsi->cdata->lcdsel_grf_reg,
|
||||
mux ? dsi->cdata->lcdsel_lit : dsi->cdata->lcdsel_big);
|
||||
}
|
||||
|
||||
static int
|
||||
dw_mipi_dsi_encoder_atomic_check(struct drm_encoder *encoder,
|
||||
struct drm_crtc_state *crtc_state,
|
||||
|
@ -639,9 +641,9 @@ static void dw_mipi_dsi_encoder_enable(struct drm_encoder *encoder)
|
|||
return;
|
||||
}
|
||||
|
||||
dw_mipi_dsi_rockchip_config(dsi, mux);
|
||||
dw_mipi_dsi_rockchip_set_lcdsel(dsi, mux);
|
||||
if (dsi->slave)
|
||||
dw_mipi_dsi_rockchip_config(dsi->slave, mux);
|
||||
dw_mipi_dsi_rockchip_set_lcdsel(dsi->slave, mux);
|
||||
|
||||
clk_disable_unprepare(dsi->grf_clk);
|
||||
}
|
||||
|
@ -800,6 +802,24 @@ static int dw_mipi_dsi_rockchip_bind(struct device *dev,
|
|||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* With the GRF clock running, write lane and dual-mode configurations
|
||||
* that won't change immediately. If we waited until enable() to do
|
||||
* this, things like panel preparation would not be able to send
|
||||
* commands over DSI.
|
||||
*/
|
||||
ret = clk_prepare_enable(dsi->grf_clk);
|
||||
if (ret) {
|
||||
DRM_DEV_ERROR(dsi->dev, "Failed to enable grf_clk: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
dw_mipi_dsi_rockchip_config(dsi);
|
||||
if (dsi->slave)
|
||||
dw_mipi_dsi_rockchip_config(dsi->slave);
|
||||
|
||||
clk_disable_unprepare(dsi->grf_clk);
|
||||
|
||||
ret = rockchip_dsi_drm_create_encoder(dsi, drm_dev);
|
||||
if (ret) {
|
||||
DRM_DEV_ERROR(dev, "Failed to create drm encoder\n");
|
||||
|
|
|
@ -2299,12 +2299,8 @@ static int hid_device_remove(struct device *dev)
|
|||
{
|
||||
struct hid_device *hdev = to_hid_device(dev);
|
||||
struct hid_driver *hdrv;
|
||||
int ret = 0;
|
||||
|
||||
if (down_interruptible(&hdev->driver_input_lock)) {
|
||||
ret = -EINTR;
|
||||
goto end;
|
||||
}
|
||||
down(&hdev->driver_input_lock);
|
||||
hdev->io_started = false;
|
||||
|
||||
hdrv = hdev->driver;
|
||||
|
@ -2319,8 +2315,8 @@ static int hid_device_remove(struct device *dev)
|
|||
|
||||
if (!hdev->io_started)
|
||||
up(&hdev->driver_input_lock);
|
||||
end:
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
|
||||
|
|
|
@ -122,7 +122,7 @@
|
|||
#define WACOM_HID_WD_TOUCHONOFF (WACOM_HID_UP_WACOMDIGITIZER | 0x0454)
|
||||
#define WACOM_HID_WD_BATTERY_LEVEL (WACOM_HID_UP_WACOMDIGITIZER | 0x043b)
|
||||
#define WACOM_HID_WD_EXPRESSKEY00 (WACOM_HID_UP_WACOMDIGITIZER | 0x0910)
|
||||
#define WACOM_HID_WD_EXPRESSKEYCAP00 (WACOM_HID_UP_WACOMDIGITIZER | 0x0950)
|
||||
#define WACOM_HID_WD_EXPRESSKEYCAP00 (WACOM_HID_UP_WACOMDIGITIZER | 0x0940)
|
||||
#define WACOM_HID_WD_MODE_CHANGE (WACOM_HID_UP_WACOMDIGITIZER | 0x0980)
|
||||
#define WACOM_HID_WD_MUTE_DEVICE (WACOM_HID_UP_WACOMDIGITIZER | 0x0981)
|
||||
#define WACOM_HID_WD_CONTROLPANEL (WACOM_HID_UP_WACOMDIGITIZER | 0x0982)
|
||||
|
|
|
@ -537,8 +537,8 @@ static int hv_timesync_init(struct hv_util_service *srv)
|
|||
*/
|
||||
hv_ptp_clock = ptp_clock_register(&ptp_hyperv_info, NULL);
|
||||
if (IS_ERR_OR_NULL(hv_ptp_clock)) {
|
||||
pr_err("cannot register PTP clock: %ld\n",
|
||||
PTR_ERR(hv_ptp_clock));
|
||||
pr_err("cannot register PTP clock: %d\n",
|
||||
PTR_ERR_OR_ZERO(hv_ptp_clock));
|
||||
hv_ptp_clock = NULL;
|
||||
}
|
||||
|
||||
|
|
|
@ -6,7 +6,6 @@
|
|||
* Copyright (c) 2016, Intel Corporation.
|
||||
*/
|
||||
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/hwmon.h>
|
||||
#include <linux/hwmon-sysfs.h>
|
||||
#include <linux/kernel.h>
|
||||
|
@ -133,20 +132,12 @@ static const struct spi_device_id max31722_spi_id[] = {
|
|||
{"max31723", 0},
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct acpi_device_id __maybe_unused max31722_acpi_id[] = {
|
||||
{"MAX31722", 0},
|
||||
{"MAX31723", 0},
|
||||
{}
|
||||
};
|
||||
|
||||
MODULE_DEVICE_TABLE(spi, max31722_spi_id);
|
||||
|
||||
static struct spi_driver max31722_driver = {
|
||||
.driver = {
|
||||
.name = "max31722",
|
||||
.pm = &max31722_pm_ops,
|
||||
.acpi_match_table = ACPI_PTR(max31722_acpi_id),
|
||||
},
|
||||
.probe = max31722_probe,
|
||||
.remove = max31722_remove,
|
||||
|
|
|
@ -27,6 +27,7 @@
|
|||
|
||||
/* Fan Config register bits */
|
||||
#define MAX31790_FAN_CFG_RPM_MODE 0x80
|
||||
#define MAX31790_FAN_CFG_CTRL_MON 0x10
|
||||
#define MAX31790_FAN_CFG_TACH_INPUT_EN 0x08
|
||||
#define MAX31790_FAN_CFG_TACH_INPUT 0x01
|
||||
|
||||
|
@ -104,7 +105,7 @@ static struct max31790_data *max31790_update_device(struct device *dev)
|
|||
data->tach[NR_CHANNEL + i] = rv;
|
||||
} else {
|
||||
rv = i2c_smbus_read_word_swapped(client,
|
||||
MAX31790_REG_PWMOUT(i));
|
||||
MAX31790_REG_PWM_DUTY_CYCLE(i));
|
||||
if (rv < 0)
|
||||
goto abort;
|
||||
data->pwm[i] = rv;
|
||||
|
@ -170,7 +171,7 @@ static int max31790_read_fan(struct device *dev, u32 attr, int channel,
|
|||
|
||||
switch (attr) {
|
||||
case hwmon_fan_input:
|
||||
sr = get_tach_period(data->fan_dynamics[channel]);
|
||||
sr = get_tach_period(data->fan_dynamics[channel % NR_CHANNEL]);
|
||||
rpm = RPM_FROM_REG(data->tach[channel], sr);
|
||||
*val = rpm;
|
||||
return 0;
|
||||
|
@ -271,12 +272,12 @@ static int max31790_read_pwm(struct device *dev, u32 attr, int channel,
|
|||
*val = data->pwm[channel] >> 8;
|
||||
return 0;
|
||||
case hwmon_pwm_enable:
|
||||
if (fan_config & MAX31790_FAN_CFG_RPM_MODE)
|
||||
*val = 2;
|
||||
else if (fan_config & MAX31790_FAN_CFG_TACH_INPUT_EN)
|
||||
*val = 1;
|
||||
else
|
||||
if (fan_config & MAX31790_FAN_CFG_CTRL_MON)
|
||||
*val = 0;
|
||||
else if (fan_config & MAX31790_FAN_CFG_RPM_MODE)
|
||||
*val = 2;
|
||||
else
|
||||
*val = 1;
|
||||
return 0;
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
|
@ -299,31 +300,41 @@ static int max31790_write_pwm(struct device *dev, u32 attr, int channel,
|
|||
err = -EINVAL;
|
||||
break;
|
||||
}
|
||||
data->pwm[channel] = val << 8;
|
||||
data->valid = false;
|
||||
err = i2c_smbus_write_word_swapped(client,
|
||||
MAX31790_REG_PWMOUT(channel),
|
||||
data->pwm[channel]);
|
||||
val << 8);
|
||||
break;
|
||||
case hwmon_pwm_enable:
|
||||
fan_config = data->fan_config[channel];
|
||||
if (val == 0) {
|
||||
fan_config &= ~(MAX31790_FAN_CFG_TACH_INPUT_EN |
|
||||
MAX31790_FAN_CFG_RPM_MODE);
|
||||
fan_config |= MAX31790_FAN_CFG_CTRL_MON;
|
||||
/*
|
||||
* Disable RPM mode; otherwise disabling fan speed
|
||||
* monitoring is not possible.
|
||||
*/
|
||||
fan_config &= ~MAX31790_FAN_CFG_RPM_MODE;
|
||||
} else if (val == 1) {
|
||||
fan_config = (fan_config |
|
||||
MAX31790_FAN_CFG_TACH_INPUT_EN) &
|
||||
~MAX31790_FAN_CFG_RPM_MODE;
|
||||
fan_config &= ~(MAX31790_FAN_CFG_CTRL_MON | MAX31790_FAN_CFG_RPM_MODE);
|
||||
} else if (val == 2) {
|
||||
fan_config |= MAX31790_FAN_CFG_TACH_INPUT_EN |
|
||||
MAX31790_FAN_CFG_RPM_MODE;
|
||||
fan_config &= ~MAX31790_FAN_CFG_CTRL_MON;
|
||||
/*
|
||||
* The chip sets MAX31790_FAN_CFG_TACH_INPUT_EN on its
|
||||
* own if MAX31790_FAN_CFG_RPM_MODE is set.
|
||||
* Do it here as well to reflect the actual register
|
||||
* value in the cache.
|
||||
*/
|
||||
fan_config |= (MAX31790_FAN_CFG_RPM_MODE | MAX31790_FAN_CFG_TACH_INPUT_EN);
|
||||
} else {
|
||||
err = -EINVAL;
|
||||
break;
|
||||
}
|
||||
data->fan_config[channel] = fan_config;
|
||||
err = i2c_smbus_write_byte_data(client,
|
||||
MAX31790_REG_FAN_CONFIG(channel),
|
||||
if (fan_config != data->fan_config[channel]) {
|
||||
err = i2c_smbus_write_byte_data(client, MAX31790_REG_FAN_CONFIG(channel),
|
||||
fan_config);
|
||||
if (!err)
|
||||
data->fan_config[channel] = fan_config;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
err = -EOPNOTSUPP;
|
||||
|
|
|
@ -119,7 +119,11 @@ struct bma180_data {
|
|||
int scale;
|
||||
int bw;
|
||||
bool pmode;
|
||||
u8 buff[16]; /* 3x 16-bit + 8-bit + padding + timestamp */
|
||||
/* Ensure timestamp is naturally aligned */
|
||||
struct {
|
||||
s16 chan[4];
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
};
|
||||
|
||||
enum bma180_chan {
|
||||
|
@ -675,12 +679,12 @@ static irqreturn_t bma180_trigger_handler(int irq, void *p)
|
|||
mutex_unlock(&data->mutex);
|
||||
goto err;
|
||||
}
|
||||
((s16 *)data->buff)[i++] = ret;
|
||||
data->scan.chan[i++] = ret;
|
||||
}
|
||||
|
||||
mutex_unlock(&data->mutex);
|
||||
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, data->buff, time_ns);
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, &data->scan, time_ns);
|
||||
err:
|
||||
iio_trigger_notify_done(indio_dev->trig);
|
||||
|
||||
|
|
|
@ -73,7 +73,11 @@ static const int bma220_scale_table[][4] = {
|
|||
struct bma220_data {
|
||||
struct spi_device *spi_device;
|
||||
struct mutex lock;
|
||||
s8 buffer[16]; /* 3x8-bit channels + 5x8 padding + 8x8 timestamp */
|
||||
struct {
|
||||
s8 chans[3];
|
||||
/* Ensure timestamp is naturally aligned. */
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
u8 tx_buf[2] ____cacheline_aligned;
|
||||
};
|
||||
|
||||
|
@ -104,12 +108,12 @@ static irqreturn_t bma220_trigger_handler(int irq, void *p)
|
|||
|
||||
mutex_lock(&data->lock);
|
||||
data->tx_buf[0] = BMA220_REG_ACCEL_X | BMA220_READ_MASK;
|
||||
ret = spi_write_then_read(spi, data->tx_buf, 1, data->buffer,
|
||||
ret = spi_write_then_read(spi, data->tx_buf, 1, &data->scan.chans,
|
||||
ARRAY_SIZE(bma220_channels) - 1);
|
||||
if (ret < 0)
|
||||
goto err;
|
||||
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
|
||||
pf->timestamp);
|
||||
err:
|
||||
mutex_unlock(&data->lock);
|
||||
|
|
|
@ -29,8 +29,11 @@ struct accel_3d_state {
|
|||
struct hid_sensor_hub_callbacks callbacks;
|
||||
struct hid_sensor_common common_attributes;
|
||||
struct hid_sensor_hub_attribute_info accel[ACCEL_3D_CHANNEL_MAX];
|
||||
/* Reserve for 3 channels + padding + timestamp */
|
||||
u32 accel_val[ACCEL_3D_CHANNEL_MAX + 3];
|
||||
/* Ensure timestamp is naturally aligned */
|
||||
struct {
|
||||
u32 accel_val[3];
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
int scale_pre_decml;
|
||||
int scale_post_decml;
|
||||
int scale_precision;
|
||||
|
@ -241,8 +244,8 @@ static int accel_3d_proc_event(struct hid_sensor_hub_device *hsdev,
|
|||
accel_state->timestamp = iio_get_time_ns(indio_dev);
|
||||
|
||||
hid_sensor_push_data(indio_dev,
|
||||
accel_state->accel_val,
|
||||
sizeof(accel_state->accel_val),
|
||||
&accel_state->scan,
|
||||
sizeof(accel_state->scan),
|
||||
accel_state->timestamp);
|
||||
|
||||
accel_state->timestamp = 0;
|
||||
|
@ -267,7 +270,7 @@ static int accel_3d_capture_sample(struct hid_sensor_hub_device *hsdev,
|
|||
case HID_USAGE_SENSOR_ACCEL_Y_AXIS:
|
||||
case HID_USAGE_SENSOR_ACCEL_Z_AXIS:
|
||||
offset = usage_id - HID_USAGE_SENSOR_ACCEL_X_AXIS;
|
||||
accel_state->accel_val[CHANNEL_SCAN_INDEX_X + offset] =
|
||||
accel_state->scan.accel_val[CHANNEL_SCAN_INDEX_X + offset] =
|
||||
*(u32 *)raw_data;
|
||||
ret = 0;
|
||||
break;
|
||||
|
|
|
@ -132,12 +132,23 @@ enum kx_acpi_type {
|
|||
ACPI_KIOX010A,
|
||||
};
|
||||
|
||||
enum kxcjk1013_axis {
|
||||
AXIS_X,
|
||||
AXIS_Y,
|
||||
AXIS_Z,
|
||||
AXIS_MAX
|
||||
};
|
||||
|
||||
struct kxcjk1013_data {
|
||||
struct i2c_client *client;
|
||||
struct iio_trigger *dready_trig;
|
||||
struct iio_trigger *motion_trig;
|
||||
struct mutex mutex;
|
||||
s16 buffer[8];
|
||||
/* Ensure timestamp naturally aligned */
|
||||
struct {
|
||||
s16 chans[AXIS_MAX];
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
u8 odr_bits;
|
||||
u8 range;
|
||||
int wake_thres;
|
||||
|
@ -151,13 +162,6 @@ struct kxcjk1013_data {
|
|||
enum kx_acpi_type acpi_type;
|
||||
};
|
||||
|
||||
enum kxcjk1013_axis {
|
||||
AXIS_X,
|
||||
AXIS_Y,
|
||||
AXIS_Z,
|
||||
AXIS_MAX,
|
||||
};
|
||||
|
||||
enum kxcjk1013_mode {
|
||||
STANDBY,
|
||||
OPERATION,
|
||||
|
@ -1078,12 +1082,12 @@ static irqreturn_t kxcjk1013_trigger_handler(int irq, void *p)
|
|||
ret = i2c_smbus_read_i2c_block_data_or_emulated(data->client,
|
||||
KXCJK1013_REG_XOUT_L,
|
||||
AXIS_MAX * 2,
|
||||
(u8 *)data->buffer);
|
||||
(u8 *)data->scan.chans);
|
||||
mutex_unlock(&data->mutex);
|
||||
if (ret < 0)
|
||||
goto err;
|
||||
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
|
||||
data->timestamp);
|
||||
err:
|
||||
iio_trigger_notify_done(indio_dev->trig);
|
||||
|
|
|
@ -56,7 +56,11 @@ struct mxc4005_data {
|
|||
struct mutex mutex;
|
||||
struct regmap *regmap;
|
||||
struct iio_trigger *dready_trig;
|
||||
__be16 buffer[8];
|
||||
/* Ensure timestamp is naturally aligned */
|
||||
struct {
|
||||
__be16 chans[3];
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
bool trigger_enabled;
|
||||
};
|
||||
|
||||
|
@ -135,7 +139,7 @@ static int mxc4005_read_xyz(struct mxc4005_data *data)
|
|||
int ret;
|
||||
|
||||
ret = regmap_bulk_read(data->regmap, MXC4005_REG_XOUT_UPPER,
|
||||
(u8 *) data->buffer, sizeof(data->buffer));
|
||||
data->scan.chans, sizeof(data->scan.chans));
|
||||
if (ret < 0) {
|
||||
dev_err(data->dev, "failed to read axes\n");
|
||||
return ret;
|
||||
|
@ -150,7 +154,7 @@ static int mxc4005_read_axis(struct mxc4005_data *data,
|
|||
__be16 reg;
|
||||
int ret;
|
||||
|
||||
ret = regmap_bulk_read(data->regmap, addr, (u8 *) ®, sizeof(reg));
|
||||
ret = regmap_bulk_read(data->regmap, addr, ®, sizeof(reg));
|
||||
if (ret < 0) {
|
||||
dev_err(data->dev, "failed to read reg %02x\n", addr);
|
||||
return ret;
|
||||
|
@ -301,7 +305,7 @@ static irqreturn_t mxc4005_trigger_handler(int irq, void *private)
|
|||
if (ret < 0)
|
||||
goto err;
|
||||
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
|
||||
pf->timestamp);
|
||||
|
||||
err:
|
||||
|
|
|
@ -103,7 +103,11 @@ struct stk8312_data {
|
|||
u8 mode;
|
||||
struct iio_trigger *dready_trig;
|
||||
bool dready_trigger_on;
|
||||
s8 buffer[16]; /* 3x8-bit channels + 5x8 padding + 64-bit timestamp */
|
||||
/* Ensure timestamp is naturally aligned */
|
||||
struct {
|
||||
s8 chans[3];
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
};
|
||||
|
||||
static IIO_CONST_ATTR(in_accel_scale_available, STK8312_SCALE_AVAIL);
|
||||
|
@ -438,7 +442,7 @@ static irqreturn_t stk8312_trigger_handler(int irq, void *p)
|
|||
ret = i2c_smbus_read_i2c_block_data(data->client,
|
||||
STK8312_REG_XOUT,
|
||||
STK8312_ALL_CHANNEL_SIZE,
|
||||
data->buffer);
|
||||
data->scan.chans);
|
||||
if (ret < STK8312_ALL_CHANNEL_SIZE) {
|
||||
dev_err(&data->client->dev, "register read failed\n");
|
||||
mutex_unlock(&data->lock);
|
||||
|
@ -452,12 +456,12 @@ static irqreturn_t stk8312_trigger_handler(int irq, void *p)
|
|||
mutex_unlock(&data->lock);
|
||||
goto err;
|
||||
}
|
||||
data->buffer[i++] = ret;
|
||||
data->scan.chans[i++] = ret;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&data->lock);
|
||||
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
|
||||
pf->timestamp);
|
||||
err:
|
||||
iio_trigger_notify_done(indio_dev->trig);
|
||||
|
|
|
@ -91,12 +91,11 @@ struct stk8ba50_data {
|
|||
u8 sample_rate_idx;
|
||||
struct iio_trigger *dready_trig;
|
||||
bool dready_trigger_on;
|
||||
/*
|
||||
* 3 x 16-bit channels (10-bit data, 6-bit padding) +
|
||||
* 1 x 16 padding +
|
||||
* 4 x 16 64-bit timestamp
|
||||
*/
|
||||
s16 buffer[8];
|
||||
/* Ensure timestamp is naturally aligned */
|
||||
struct {
|
||||
s16 chans[3];
|
||||
s64 timetamp __aligned(8);
|
||||
} scan;
|
||||
};
|
||||
|
||||
#define STK8BA50_ACCEL_CHANNEL(index, reg, axis) { \
|
||||
|
@ -324,7 +323,7 @@ static irqreturn_t stk8ba50_trigger_handler(int irq, void *p)
|
|||
ret = i2c_smbus_read_i2c_block_data(data->client,
|
||||
STK8BA50_REG_XOUT,
|
||||
STK8BA50_ALL_CHANNEL_SIZE,
|
||||
(u8 *)data->buffer);
|
||||
(u8 *)data->scan.chans);
|
||||
if (ret < STK8BA50_ALL_CHANNEL_SIZE) {
|
||||
dev_err(&data->client->dev, "register read failed\n");
|
||||
goto err;
|
||||
|
@ -337,10 +336,10 @@ static irqreturn_t stk8ba50_trigger_handler(int irq, void *p)
|
|||
if (ret < 0)
|
||||
goto err;
|
||||
|
||||
data->buffer[i++] = ret;
|
||||
data->scan.chans[i++] = ret;
|
||||
}
|
||||
}
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
|
||||
pf->timestamp);
|
||||
err:
|
||||
mutex_unlock(&data->lock);
|
||||
|
|
|
@ -399,7 +399,9 @@ struct at91_adc_state {
|
|||
wait_queue_head_t wq_data_available;
|
||||
struct at91_adc_dma dma_st;
|
||||
struct at91_adc_touch touch_st;
|
||||
u16 buffer[AT91_BUFFER_MAX_HWORDS];
|
||||
struct iio_dev *indio_dev;
|
||||
/* Ensure naturally aligned timestamp */
|
||||
u16 buffer[AT91_BUFFER_MAX_HWORDS] __aligned(8);
|
||||
/*
|
||||
* lock to prevent concurrent 'single conversion' requests through
|
||||
* sysfs.
|
||||
|
@ -624,13 +626,13 @@ static u16 at91_adc_touch_pos(struct at91_adc_state *st, int reg)
|
|||
/* first half of register is the x or y, second half is the scale */
|
||||
val = at91_adc_readl(st, reg);
|
||||
if (!val)
|
||||
dev_dbg(&iio_priv_to_dev(st)->dev, "pos is 0\n");
|
||||
dev_dbg(&st->indio_dev->dev, "pos is 0\n");
|
||||
|
||||
pos = val & AT91_SAMA5D2_XYZ_MASK;
|
||||
result = (pos << AT91_SAMA5D2_MAX_POS_BITS) - pos;
|
||||
scale = (val >> 16) & AT91_SAMA5D2_XYZ_MASK;
|
||||
if (scale == 0) {
|
||||
dev_err(&iio_priv_to_dev(st)->dev, "scale is 0\n");
|
||||
dev_err(&st->indio_dev->dev, "scale is 0\n");
|
||||
return 0;
|
||||
}
|
||||
result /= scale;
|
||||
|
@ -1154,9 +1156,9 @@ static unsigned at91_adc_startup_time(unsigned startup_time_min,
|
|||
return i;
|
||||
}
|
||||
|
||||
static void at91_adc_setup_samp_freq(struct at91_adc_state *st, unsigned freq)
|
||||
static void at91_adc_setup_samp_freq(struct iio_dev *indio_dev, unsigned freq)
|
||||
{
|
||||
struct iio_dev *indio_dev = iio_priv_to_dev(st);
|
||||
struct at91_adc_state *st = iio_priv(indio_dev);
|
||||
unsigned f_per, prescal, startup, mr;
|
||||
|
||||
f_per = clk_get_rate(st->per_clk);
|
||||
|
@ -1225,9 +1227,9 @@ static void at91_adc_pen_detect_interrupt(struct at91_adc_state *st)
|
|||
st->touch_st.touching = true;
|
||||
}
|
||||
|
||||
static void at91_adc_no_pen_detect_interrupt(struct at91_adc_state *st)
|
||||
static void at91_adc_no_pen_detect_interrupt(struct iio_dev *indio_dev)
|
||||
{
|
||||
struct iio_dev *indio_dev = iio_priv_to_dev(st);
|
||||
struct at91_adc_state *st = iio_priv(indio_dev);
|
||||
|
||||
at91_adc_writel(st, AT91_SAMA5D2_TRGR,
|
||||
AT91_SAMA5D2_TRGR_TRGMOD_NO_TRIGGER);
|
||||
|
@ -1247,7 +1249,7 @@ static void at91_adc_workq_handler(struct work_struct *workq)
|
|||
struct at91_adc_touch, workq);
|
||||
struct at91_adc_state *st = container_of(touch_st,
|
||||
struct at91_adc_state, touch_st);
|
||||
struct iio_dev *indio_dev = iio_priv_to_dev(st);
|
||||
struct iio_dev *indio_dev = st->indio_dev;
|
||||
|
||||
iio_push_to_buffers(indio_dev, st->buffer);
|
||||
}
|
||||
|
@ -1268,7 +1270,7 @@ static irqreturn_t at91_adc_interrupt(int irq, void *private)
|
|||
at91_adc_pen_detect_interrupt(st);
|
||||
} else if ((status & AT91_SAMA5D2_IER_NOPEN)) {
|
||||
/* nopen detected IRQ */
|
||||
at91_adc_no_pen_detect_interrupt(st);
|
||||
at91_adc_no_pen_detect_interrupt(indio);
|
||||
} else if ((status & AT91_SAMA5D2_ISR_PENS) &&
|
||||
((status & rdy_mask) == rdy_mask)) {
|
||||
/* periodic trigger IRQ - during pen sense */
|
||||
|
@ -1435,7 +1437,7 @@ static int at91_adc_write_raw(struct iio_dev *indio_dev,
|
|||
val > st->soc_info.max_sample_rate)
|
||||
return -EINVAL;
|
||||
|
||||
at91_adc_setup_samp_freq(st, val);
|
||||
at91_adc_setup_samp_freq(indio_dev, val);
|
||||
return 0;
|
||||
default:
|
||||
return -EINVAL;
|
||||
|
@ -1573,8 +1575,10 @@ static int at91_adc_update_scan_mode(struct iio_dev *indio_dev,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void at91_adc_hw_init(struct at91_adc_state *st)
|
||||
static void at91_adc_hw_init(struct iio_dev *indio_dev)
|
||||
{
|
||||
struct at91_adc_state *st = iio_priv(indio_dev);
|
||||
|
||||
at91_adc_writel(st, AT91_SAMA5D2_CR, AT91_SAMA5D2_CR_SWRST);
|
||||
at91_adc_writel(st, AT91_SAMA5D2_IDR, 0xffffffff);
|
||||
/*
|
||||
|
@ -1584,7 +1588,7 @@ static void at91_adc_hw_init(struct at91_adc_state *st)
|
|||
at91_adc_writel(st, AT91_SAMA5D2_MR,
|
||||
AT91_SAMA5D2_MR_TRANSFER(2) | AT91_SAMA5D2_MR_ANACH);
|
||||
|
||||
at91_adc_setup_samp_freq(st, st->soc_info.min_sample_rate);
|
||||
at91_adc_setup_samp_freq(indio_dev, st->soc_info.min_sample_rate);
|
||||
|
||||
/* configure extended mode register */
|
||||
at91_adc_config_emr(st);
|
||||
|
@ -1667,6 +1671,7 @@ static int at91_adc_probe(struct platform_device *pdev)
|
|||
indio_dev->num_channels = ARRAY_SIZE(at91_adc_channels);
|
||||
|
||||
st = iio_priv(indio_dev);
|
||||
st->indio_dev = indio_dev;
|
||||
|
||||
bitmap_set(&st->touch_st.channels_bitmask,
|
||||
AT91_SAMA5D2_TOUCH_X_CHAN_IDX, 1);
|
||||
|
@ -1778,7 +1783,7 @@ static int at91_adc_probe(struct platform_device *pdev)
|
|||
goto vref_disable;
|
||||
}
|
||||
|
||||
at91_adc_hw_init(st);
|
||||
at91_adc_hw_init(indio_dev);
|
||||
|
||||
ret = clk_prepare_enable(st->per_clk);
|
||||
if (ret)
|
||||
|
@ -1894,7 +1899,7 @@ static __maybe_unused int at91_adc_resume(struct device *dev)
|
|||
if (ret)
|
||||
goto vref_disable_resume;
|
||||
|
||||
at91_adc_hw_init(st);
|
||||
at91_adc_hw_init(indio_dev);
|
||||
|
||||
/* reconfiguring trigger hardware state */
|
||||
if (!iio_buffer_enabled(indio_dev))
|
||||
|
|
|
@ -85,9 +85,9 @@ struct hx711_data {
|
|||
struct mutex lock;
|
||||
/*
|
||||
* triggered buffer
|
||||
* 2x32-bit channel + 64-bit timestamp
|
||||
* 2x32-bit channel + 64-bit naturally aligned timestamp
|
||||
*/
|
||||
u32 buffer[4];
|
||||
u32 buffer[4] __aligned(8);
|
||||
/*
|
||||
* delay after a rising edge on SCK until the data is ready DOUT
|
||||
* this is dependent on the hx711 where the datasheet tells a
|
||||
|
|
|
@ -115,7 +115,8 @@ struct mxs_lradc_adc {
|
|||
struct device *dev;
|
||||
|
||||
void __iomem *base;
|
||||
u32 buffer[10];
|
||||
/* Maximum of 8 channels + 8 byte ts */
|
||||
u32 buffer[10] __aligned(8);
|
||||
struct iio_trigger *trig;
|
||||
struct completion completion;
|
||||
spinlock_t lock;
|
||||
|
|
|
@ -388,10 +388,14 @@ static irqreturn_t ads1015_trigger_handler(int irq, void *p)
|
|||
struct iio_poll_func *pf = p;
|
||||
struct iio_dev *indio_dev = pf->indio_dev;
|
||||
struct ads1015_data *data = iio_priv(indio_dev);
|
||||
s16 buf[8]; /* 1x s16 ADC val + 3x s16 padding + 4x s16 timestamp */
|
||||
/* Ensure natural alignment of timestamp */
|
||||
struct {
|
||||
s16 chan;
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
int chan, ret, res;
|
||||
|
||||
memset(buf, 0, sizeof(buf));
|
||||
memset(&scan, 0, sizeof(scan));
|
||||
|
||||
mutex_lock(&data->lock);
|
||||
chan = find_first_bit(indio_dev->active_scan_mask,
|
||||
|
@ -402,10 +406,10 @@ static irqreturn_t ads1015_trigger_handler(int irq, void *p)
|
|||
goto err;
|
||||
}
|
||||
|
||||
buf[0] = res;
|
||||
scan.chan = res;
|
||||
mutex_unlock(&data->lock);
|
||||
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, buf,
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, &scan,
|
||||
iio_get_time_ns(indio_dev));
|
||||
|
||||
err:
|
||||
|
|
|
@ -383,7 +383,8 @@ static irqreturn_t ads8688_trigger_handler(int irq, void *p)
|
|||
{
|
||||
struct iio_poll_func *pf = p;
|
||||
struct iio_dev *indio_dev = pf->indio_dev;
|
||||
u16 buffer[ADS8688_MAX_CHANNELS + sizeof(s64)/sizeof(u16)];
|
||||
/* Ensure naturally aligned timestamp */
|
||||
u16 buffer[ADS8688_MAX_CHANNELS + sizeof(s64)/sizeof(u16)] __aligned(8);
|
||||
int i, j = 0;
|
||||
|
||||
for (i = 0; i < indio_dev->masklength; i++) {
|
||||
|
|
|
@ -167,7 +167,11 @@ struct vf610_adc {
|
|||
u32 sample_freq_avail[5];
|
||||
|
||||
struct completion completion;
|
||||
u16 buffer[8];
|
||||
/* Ensure the timestamp is naturally aligned */
|
||||
struct {
|
||||
u16 chan;
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
};
|
||||
|
||||
static const u32 vf610_hw_avgs[] = { 1, 4, 8, 16, 32 };
|
||||
|
@ -579,9 +583,9 @@ static irqreturn_t vf610_adc_isr(int irq, void *dev_id)
|
|||
if (coco & VF610_ADC_HS_COCO0) {
|
||||
info->value = vf610_adc_read_data(info);
|
||||
if (iio_buffer_enabled(indio_dev)) {
|
||||
info->buffer[0] = info->value;
|
||||
info->scan.chan = info->value;
|
||||
iio_push_to_buffers_with_timestamp(indio_dev,
|
||||
info->buffer,
|
||||
&info->scan,
|
||||
iio_get_time_ns(indio_dev));
|
||||
iio_trigger_notify_done(indio_dev->trig);
|
||||
} else
|
||||
|
|
|
@ -96,7 +96,11 @@ struct bmg160_data {
|
|||
struct iio_trigger *motion_trig;
|
||||
struct iio_mount_matrix orientation;
|
||||
struct mutex mutex;
|
||||
s16 buffer[8];
|
||||
/* Ensure naturally aligned timestamp */
|
||||
struct {
|
||||
s16 chans[3];
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
u32 dps_range;
|
||||
int ev_enable_state;
|
||||
int slope_thres;
|
||||
|
@ -880,12 +884,12 @@ static irqreturn_t bmg160_trigger_handler(int irq, void *p)
|
|||
|
||||
mutex_lock(&data->mutex);
|
||||
ret = regmap_bulk_read(data->regmap, BMG160_REG_XOUT_L,
|
||||
data->buffer, AXIS_MAX * 2);
|
||||
data->scan.chans, AXIS_MAX * 2);
|
||||
mutex_unlock(&data->mutex);
|
||||
if (ret < 0)
|
||||
goto err;
|
||||
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
|
||||
pf->timestamp);
|
||||
err:
|
||||
iio_trigger_notify_done(indio_dev->trig);
|
||||
|
|
|
@ -33,7 +33,11 @@
|
|||
struct am2315_data {
|
||||
struct i2c_client *client;
|
||||
struct mutex lock;
|
||||
s16 buffer[8]; /* 2x16-bit channels + 2x16 padding + 4x16 timestamp */
|
||||
/* Ensure timestamp is naturally aligned */
|
||||
struct {
|
||||
s16 chans[2];
|
||||
s64 timestamp __aligned(8);
|
||||
} scan;
|
||||
};
|
||||
|
||||
struct am2315_sensor_data {
|
||||
|
@ -167,20 +171,20 @@ static irqreturn_t am2315_trigger_handler(int irq, void *p)
|
|||
|
||||
mutex_lock(&data->lock);
|
||||
if (*(indio_dev->active_scan_mask) == AM2315_ALL_CHANNEL_MASK) {
|
||||
data->buffer[0] = sensor_data.hum_data;
|
||||
data->buffer[1] = sensor_data.temp_data;
|
||||
data->scan.chans[0] = sensor_data.hum_data;
|
||||
data->scan.chans[1] = sensor_data.temp_data;
|
||||
} else {
|
||||
i = 0;
|
||||
for_each_set_bit(bit, indio_dev->active_scan_mask,
|
||||
indio_dev->masklength) {
|
||||
data->buffer[i] = (bit ? sensor_data.temp_data :
|
||||
data->scan.chans[i] = (bit ? sensor_data.temp_data :
|
||||
sensor_data.hum_data);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
mutex_unlock(&data->lock);
|
||||
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
|
||||
iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
|
||||
pf->timestamp);
|
||||
err:
|
||||
iio_trigger_notify_done(indio_dev->trig);
|
||||
|
|
|
@ -651,9 +651,6 @@ static irqreturn_t adis16400_trigger_handler(int irq, void *p)
|
|||
void *buffer;
|
||||
int ret;
|
||||
|
||||
if (!adis->buffer)
|
||||
return -ENOMEM;
|
||||
|
||||
if (!(st->variant->flags & ADIS16400_NO_BURST) &&
|
||||
st->adis.spi->max_speed_hz > ADIS16400_SPI_BURST) {
|
||||
st->adis.spi->max_speed_hz = ADIS16400_SPI_BURST;
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue