Merge branch 'for-miklos' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs into for-next
This commit is contained in:
Коммит
0f7d93416d
|
@ -595,6 +595,10 @@ S: Odd Fixes
|
|||
L: linux-alpha@vger.kernel.org
|
||||
F: arch/alpha/
|
||||
|
||||
ALPS PS/2 TOUCHPAD DRIVER
|
||||
R: Pali Rohár <pali.rohar@gmail.com>
|
||||
F: drivers/input/mouse/alps.*
|
||||
|
||||
ALTERA MAILBOX DRIVER
|
||||
M: Ley Foon Tan <lftan@altera.com>
|
||||
L: nios2-dev@lists.rocketboards.org (moderated for non-subscribers)
|
||||
|
@ -7420,7 +7424,7 @@ F: drivers/scsi/megaraid.*
|
|||
F: drivers/scsi/megaraid/
|
||||
|
||||
MELLANOX ETHERNET DRIVER (mlx4_en)
|
||||
M: Eugenia Emantayev <eugenia@mellanox.com>
|
||||
M: Tariq Toukan <tariqt@mellanox.com>
|
||||
L: netdev@vger.kernel.org
|
||||
S: Supported
|
||||
W: http://www.mellanox.com
|
||||
|
@ -8959,6 +8963,7 @@ L: linux-gpio@vger.kernel.org
|
|||
T: git git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-pinctrl.git
|
||||
S: Maintained
|
||||
F: Documentation/devicetree/bindings/pinctrl/
|
||||
F: Documentation/pinctrl.txt
|
||||
F: drivers/pinctrl/
|
||||
F: include/linux/pinctrl/
|
||||
|
||||
|
|
4
Makefile
4
Makefile
|
@ -1,7 +1,7 @@
|
|||
VERSION = 4
|
||||
PATCHLEVEL = 7
|
||||
SUBLEVEL = 0
|
||||
EXTRAVERSION = -rc5
|
||||
EXTRAVERSION = -rc6
|
||||
NAME = Psychotic Stoned Sheep
|
||||
|
||||
# *DOCUMENTATION*
|
||||
|
@ -363,11 +363,13 @@ CHECK = sparse
|
|||
|
||||
CHECKFLAGS := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ \
|
||||
-Wbitwise -Wno-return-void $(CF)
|
||||
NOSTDINC_FLAGS =
|
||||
CFLAGS_MODULE =
|
||||
AFLAGS_MODULE =
|
||||
LDFLAGS_MODULE =
|
||||
CFLAGS_KERNEL =
|
||||
AFLAGS_KERNEL =
|
||||
LDFLAGS_vmlinux =
|
||||
CFLAGS_GCOV = -fprofile-arcs -ftest-coverage -fno-tree-loop-im -Wno-maybe-uninitialized
|
||||
CFLAGS_KCOV = -fsanitize-coverage=trace-pc
|
||||
|
||||
|
|
|
@ -66,8 +66,6 @@ endif
|
|||
|
||||
endif
|
||||
|
||||
cflags-$(CONFIG_ARC_DW2_UNWIND) += -fasynchronous-unwind-tables
|
||||
|
||||
# By default gcc 4.8 generates dwarf4 which kernel unwinder can't grok
|
||||
ifeq ($(atleast_gcc48),y)
|
||||
cflags-$(CONFIG_ARC_DW2_UNWIND) += -gdwarf-2
|
||||
|
|
|
@ -142,7 +142,7 @@ arc_unwind_core(struct task_struct *tsk, struct pt_regs *regs,
|
|||
* prelogue is setup (callee regs saved and then fp set and not other
|
||||
* way around
|
||||
*/
|
||||
pr_warn("CONFIG_ARC_DW2_UNWIND needs to be enabled\n");
|
||||
pr_warn_once("CONFIG_ARC_DW2_UNWIND needs to be enabled\n");
|
||||
return 0;
|
||||
|
||||
#endif
|
||||
|
|
|
@ -263,6 +263,7 @@ void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu)
|
|||
kvm_timer_vcpu_terminate(vcpu);
|
||||
kvm_vgic_vcpu_destroy(vcpu);
|
||||
kvm_pmu_vcpu_destroy(vcpu);
|
||||
kvm_vcpu_uninit(vcpu);
|
||||
kmem_cache_free(kvm_vcpu_cache, vcpu);
|
||||
}
|
||||
|
||||
|
|
|
@ -24,7 +24,7 @@ struct mm_struct;
|
|||
struct vm_area_struct;
|
||||
|
||||
#define PAGE_NONE __pgprot(_PAGE_PRESENT | _PAGE_NO_READ | \
|
||||
_CACHE_CACHABLE_NONCOHERENT)
|
||||
_page_cachable_default)
|
||||
#define PAGE_SHARED __pgprot(_PAGE_PRESENT | _PAGE_WRITE | \
|
||||
_page_cachable_default)
|
||||
#define PAGE_COPY __pgprot(_PAGE_PRESENT | _PAGE_NO_EXEC | \
|
||||
|
@ -476,7 +476,7 @@ static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
|
|||
pte.pte_low &= (_PAGE_MODIFIED | _PAGE_ACCESSED | _PFNX_MASK);
|
||||
pte.pte_high &= (_PFN_MASK | _CACHE_MASK);
|
||||
pte.pte_low |= pgprot_val(newprot) & ~_PFNX_MASK;
|
||||
pte.pte_high |= pgprot_val(newprot) & ~_PFN_MASK;
|
||||
pte.pte_high |= pgprot_val(newprot) & ~(_PFN_MASK | _CACHE_MASK);
|
||||
return pte;
|
||||
}
|
||||
#elif defined(CONFIG_PHYS_ADDR_T_64BIT) && defined(CONFIG_CPU_MIPS32)
|
||||
|
@ -491,7 +491,8 @@ static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
|
|||
#else
|
||||
static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
|
||||
{
|
||||
return __pte((pte_val(pte) & _PAGE_CHG_MASK) | pgprot_val(newprot));
|
||||
return __pte((pte_val(pte) & _PAGE_CHG_MASK) |
|
||||
(pgprot_val(newprot) & ~_PAGE_CHG_MASK));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -632,7 +633,8 @@ static inline struct page *pmd_page(pmd_t pmd)
|
|||
|
||||
static inline pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
|
||||
{
|
||||
pmd_val(pmd) = (pmd_val(pmd) & _PAGE_CHG_MASK) | pgprot_val(newprot);
|
||||
pmd_val(pmd) = (pmd_val(pmd) & _PAGE_CHG_MASK) |
|
||||
(pgprot_val(newprot) & ~_PAGE_CHG_MASK);
|
||||
return pmd;
|
||||
}
|
||||
|
||||
|
|
|
@ -230,6 +230,7 @@ extern unsigned long __kernel_virt_size;
|
|||
#define KERN_VIRT_SIZE __kernel_virt_size
|
||||
extern struct page *vmemmap;
|
||||
extern unsigned long ioremap_bot;
|
||||
extern unsigned long pci_io_base;
|
||||
#endif /* __ASSEMBLY__ */
|
||||
|
||||
#include <asm/book3s/64/hash.h>
|
||||
|
|
|
@ -647,7 +647,7 @@ static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus,
|
|||
pci_unlock_rescan_remove();
|
||||
}
|
||||
} else if (frozen_bus) {
|
||||
eeh_pe_dev_traverse(pe, eeh_rmv_device, &rmv_data);
|
||||
eeh_pe_dev_traverse(pe, eeh_rmv_device, rmv_data);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -47,7 +47,6 @@ static int __init pcibios_init(void)
|
|||
|
||||
printk(KERN_INFO "PCI: Probing PCI hardware\n");
|
||||
|
||||
pci_io_base = ISA_IO_BASE;
|
||||
/* For now, override phys_mem_access_prot. If we need it,g
|
||||
* later, we may move that initialization to each ppc_md
|
||||
*/
|
||||
|
|
|
@ -1505,6 +1505,16 @@ void start_thread(struct pt_regs *regs, unsigned long start, unsigned long sp)
|
|||
current->thread.regs = regs - 1;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
|
||||
/*
|
||||
* Clear any transactional state, we're exec()ing. The cause is
|
||||
* not important as there will never be a recheckpoint so it's not
|
||||
* user visible.
|
||||
*/
|
||||
if (MSR_TM_SUSPENDED(mfmsr()))
|
||||
tm_reclaim_current(0);
|
||||
#endif
|
||||
|
||||
memset(regs->gpr, 0, sizeof(regs->gpr));
|
||||
regs->ctr = 0;
|
||||
regs->link = 0;
|
||||
|
|
|
@ -110,17 +110,11 @@ _GLOBAL(tm_reclaim)
|
|||
std r3, STK_PARAM(R3)(r1)
|
||||
SAVE_NVGPRS(r1)
|
||||
|
||||
/* We need to setup MSR for VSX register save instructions. Here we
|
||||
* also clear the MSR RI since when we do the treclaim, we won't have a
|
||||
* valid kernel pointer for a while. We clear RI here as it avoids
|
||||
* adding another mtmsr closer to the treclaim. This makes the region
|
||||
* maked as non-recoverable wider than it needs to be but it saves on
|
||||
* inserting another mtmsrd later.
|
||||
*/
|
||||
/* We need to setup MSR for VSX register save instructions. */
|
||||
mfmsr r14
|
||||
mr r15, r14
|
||||
ori r15, r15, MSR_FP
|
||||
li r16, MSR_RI
|
||||
li r16, 0
|
||||
ori r16, r16, MSR_EE /* IRQs hard off */
|
||||
andc r15, r15, r16
|
||||
oris r15, r15, MSR_VEC@h
|
||||
|
@ -176,7 +170,17 @@ dont_backup_fp:
|
|||
1: tdeqi r6, 0
|
||||
EMIT_BUG_ENTRY 1b,__FILE__,__LINE__,0
|
||||
|
||||
/* The moment we treclaim, ALL of our GPRs will switch
|
||||
/* Clear MSR RI since we are about to change r1, EE is already off. */
|
||||
li r4, 0
|
||||
mtmsrd r4, 1
|
||||
|
||||
/*
|
||||
* BE CAREFUL HERE:
|
||||
* At this point we can't take an SLB miss since we have MSR_RI
|
||||
* off. Load only to/from the stack/paca which are in SLB bolted regions
|
||||
* until we turn MSR RI back on.
|
||||
*
|
||||
* The moment we treclaim, ALL of our GPRs will switch
|
||||
* to user register state. (FPRs, CCR etc. also!)
|
||||
* Use an sprg and a tm_scratch in the PACA to shuffle.
|
||||
*/
|
||||
|
@ -197,6 +201,11 @@ dont_backup_fp:
|
|||
|
||||
/* Store the PPR in r11 and reset to decent value */
|
||||
std r11, GPR11(r1) /* Temporary stash */
|
||||
|
||||
/* Reset MSR RI so we can take SLB faults again */
|
||||
li r11, MSR_RI
|
||||
mtmsrd r11, 1
|
||||
|
||||
mfspr r11, SPRN_PPR
|
||||
HMT_MEDIUM
|
||||
|
||||
|
@ -397,11 +406,6 @@ restore_gprs:
|
|||
ld r5, THREAD_TM_DSCR(r3)
|
||||
ld r6, THREAD_TM_PPR(r3)
|
||||
|
||||
/* Clear the MSR RI since we are about to change R1. EE is already off
|
||||
*/
|
||||
li r4, 0
|
||||
mtmsrd r4, 1
|
||||
|
||||
REST_GPR(0, r7) /* GPR0 */
|
||||
REST_2GPRS(2, r7) /* GPR2-3 */
|
||||
REST_GPR(4, r7) /* GPR4 */
|
||||
|
@ -439,10 +443,33 @@ restore_gprs:
|
|||
ld r6, _CCR(r7)
|
||||
mtcr r6
|
||||
|
||||
REST_GPR(1, r7) /* GPR1 */
|
||||
REST_GPR(5, r7) /* GPR5-7 */
|
||||
REST_GPR(6, r7)
|
||||
ld r7, GPR7(r7)
|
||||
|
||||
/*
|
||||
* Store r1 and r5 on the stack so that we can access them
|
||||
* after we clear MSR RI.
|
||||
*/
|
||||
|
||||
REST_GPR(5, r7)
|
||||
std r5, -8(r1)
|
||||
ld r5, GPR1(r7)
|
||||
std r5, -16(r1)
|
||||
|
||||
REST_GPR(7, r7)
|
||||
|
||||
/* Clear MSR RI since we are about to change r1. EE is already off */
|
||||
li r5, 0
|
||||
mtmsrd r5, 1
|
||||
|
||||
/*
|
||||
* BE CAREFUL HERE:
|
||||
* At this point we can't take an SLB miss since we have MSR_RI
|
||||
* off. Load only to/from the stack/paca which are in SLB bolted regions
|
||||
* until we turn MSR RI back on.
|
||||
*/
|
||||
|
||||
ld r5, -8(r1)
|
||||
ld r1, -16(r1)
|
||||
|
||||
/* Commit register state as checkpointed state: */
|
||||
TRECHKPT
|
||||
|
|
|
@ -922,6 +922,10 @@ void __init hash__early_init_mmu(void)
|
|||
vmemmap = (struct page *)H_VMEMMAP_BASE;
|
||||
ioremap_bot = IOREMAP_BASE;
|
||||
|
||||
#ifdef CONFIG_PCI
|
||||
pci_io_base = ISA_IO_BASE;
|
||||
#endif
|
||||
|
||||
/* Initialize the MMU Hash table and create the linear mapping
|
||||
* of memory. Has to be done before SLB initialization as this is
|
||||
* currently where the page size encoding is obtained.
|
||||
|
|
|
@ -328,6 +328,11 @@ void __init radix__early_init_mmu(void)
|
|||
__vmalloc_end = RADIX_VMALLOC_END;
|
||||
vmemmap = (struct page *)RADIX_VMEMMAP_BASE;
|
||||
ioremap_bot = IOREMAP_BASE;
|
||||
|
||||
#ifdef CONFIG_PCI
|
||||
pci_io_base = ISA_IO_BASE;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* For now radix also use the same frag size
|
||||
*/
|
||||
|
|
|
@ -22,7 +22,7 @@ static inline int test_fp_ctl(u32 fpc)
|
|||
" la %0,0\n"
|
||||
"1:\n"
|
||||
EX_TABLE(0b,1b)
|
||||
: "=d" (rc), "=d" (orig_fpc)
|
||||
: "=d" (rc), "=&d" (orig_fpc)
|
||||
: "d" (fpc), "0" (-EINVAL));
|
||||
return rc;
|
||||
}
|
||||
|
|
|
@ -2064,12 +2064,5 @@ void s390_reset_system(void)
|
|||
S390_lowcore.program_new_psw.addr =
|
||||
(unsigned long) s390_base_pgm_handler;
|
||||
|
||||
/*
|
||||
* Clear subchannel ID and number to signal new kernel that no CCW or
|
||||
* SCSI IPL has been done (for kexec and kdump)
|
||||
*/
|
||||
S390_lowcore.subchannel_id = 0;
|
||||
S390_lowcore.subchannel_nr = 0;
|
||||
|
||||
do_reset_calls();
|
||||
}
|
||||
|
|
|
@ -68,30 +68,23 @@ static inline u64 pvclock_scale_delta(u64 delta, u32 mul_frac, int shift)
|
|||
return product;
|
||||
}
|
||||
|
||||
static __always_inline
|
||||
u64 pvclock_get_nsec_offset(const struct pvclock_vcpu_time_info *src)
|
||||
{
|
||||
u64 delta = rdtsc_ordered() - src->tsc_timestamp;
|
||||
return pvclock_scale_delta(delta, src->tsc_to_system_mul,
|
||||
src->tsc_shift);
|
||||
}
|
||||
|
||||
static __always_inline
|
||||
unsigned __pvclock_read_cycles(const struct pvclock_vcpu_time_info *src,
|
||||
cycle_t *cycles, u8 *flags)
|
||||
{
|
||||
unsigned version;
|
||||
cycle_t ret, offset;
|
||||
u8 ret_flags;
|
||||
cycle_t offset;
|
||||
u64 delta;
|
||||
|
||||
version = src->version;
|
||||
/* Make the latest version visible */
|
||||
smp_rmb();
|
||||
|
||||
offset = pvclock_get_nsec_offset(src);
|
||||
ret = src->system_time + offset;
|
||||
ret_flags = src->flags;
|
||||
|
||||
*cycles = ret;
|
||||
*flags = ret_flags;
|
||||
delta = rdtsc_ordered() - src->tsc_timestamp;
|
||||
offset = pvclock_scale_delta(delta, src->tsc_to_system_mul,
|
||||
src->tsc_shift);
|
||||
*cycles = src->system_time + offset;
|
||||
*flags = src->flags;
|
||||
return version;
|
||||
}
|
||||
|
||||
|
|
|
@ -61,11 +61,16 @@ void pvclock_resume(void)
|
|||
u8 pvclock_read_flags(struct pvclock_vcpu_time_info *src)
|
||||
{
|
||||
unsigned version;
|
||||
cycle_t ret;
|
||||
u8 flags;
|
||||
|
||||
do {
|
||||
version = __pvclock_read_cycles(src, &ret, &flags);
|
||||
version = src->version;
|
||||
/* Make the latest version visible */
|
||||
smp_rmb();
|
||||
|
||||
flags = src->flags;
|
||||
/* Make sure that the version double-check is last. */
|
||||
smp_rmb();
|
||||
} while ((src->version & 1) || version != src->version);
|
||||
|
||||
return flags & valid_flags;
|
||||
|
@ -80,6 +85,8 @@ cycle_t pvclock_clocksource_read(struct pvclock_vcpu_time_info *src)
|
|||
|
||||
do {
|
||||
version = __pvclock_read_cycles(src, &ret, &flags);
|
||||
/* Make sure that the version double-check is last. */
|
||||
smp_rmb();
|
||||
} while ((src->version & 1) || version != src->version);
|
||||
|
||||
if (unlikely((flags & PVCLOCK_GUEST_STOPPED) != 0)) {
|
||||
|
|
|
@ -1310,7 +1310,8 @@ void wait_lapic_expire(struct kvm_vcpu *vcpu)
|
|||
|
||||
/* __delay is delay_tsc whenever the hardware has TSC, thus always. */
|
||||
if (guest_tsc < tsc_deadline)
|
||||
__delay(tsc_deadline - guest_tsc);
|
||||
__delay(min(tsc_deadline - guest_tsc,
|
||||
nsec_to_cycles(vcpu, lapic_timer_advance_ns)));
|
||||
}
|
||||
|
||||
static void start_apic_timer(struct kvm_lapic *apic)
|
||||
|
|
|
@ -6671,7 +6671,13 @@ static int get_vmx_mem_address(struct kvm_vcpu *vcpu,
|
|||
|
||||
/* Checks for #GP/#SS exceptions. */
|
||||
exn = false;
|
||||
if (is_protmode(vcpu)) {
|
||||
if (is_long_mode(vcpu)) {
|
||||
/* Long mode: #GP(0)/#SS(0) if the memory address is in a
|
||||
* non-canonical form. This is the only check on the memory
|
||||
* destination for long mode!
|
||||
*/
|
||||
exn = is_noncanonical_address(*ret);
|
||||
} else if (is_protmode(vcpu)) {
|
||||
/* Protected mode: apply checks for segment validity in the
|
||||
* following order:
|
||||
* - segment type check (#GP(0) may be thrown)
|
||||
|
@ -6688,17 +6694,10 @@ static int get_vmx_mem_address(struct kvm_vcpu *vcpu,
|
|||
* execute-only code segment
|
||||
*/
|
||||
exn = ((s.type & 0xa) == 8);
|
||||
}
|
||||
if (exn) {
|
||||
kvm_queue_exception_e(vcpu, GP_VECTOR, 0);
|
||||
return 1;
|
||||
}
|
||||
if (is_long_mode(vcpu)) {
|
||||
/* Long mode: #GP(0)/#SS(0) if the memory address is in a
|
||||
* non-canonical form. This is an only check for long mode.
|
||||
*/
|
||||
exn = is_noncanonical_address(*ret);
|
||||
} else if (is_protmode(vcpu)) {
|
||||
if (exn) {
|
||||
kvm_queue_exception_e(vcpu, GP_VECTOR, 0);
|
||||
return 1;
|
||||
}
|
||||
/* Protected mode: #GP(0)/#SS(0) if the segment is unusable.
|
||||
*/
|
||||
exn = (s.unusable != 0);
|
||||
|
|
|
@ -1244,12 +1244,6 @@ static atomic_t kvm_guest_has_master_clock = ATOMIC_INIT(0);
|
|||
static DEFINE_PER_CPU(unsigned long, cpu_tsc_khz);
|
||||
static unsigned long max_tsc_khz;
|
||||
|
||||
static inline u64 nsec_to_cycles(struct kvm_vcpu *vcpu, u64 nsec)
|
||||
{
|
||||
return pvclock_scale_delta(nsec, vcpu->arch.virtual_tsc_mult,
|
||||
vcpu->arch.virtual_tsc_shift);
|
||||
}
|
||||
|
||||
static u32 adjust_tsc_khz(u32 khz, s32 ppm)
|
||||
{
|
||||
u64 v = (u64)khz * (1000000 + ppm);
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#define ARCH_X86_KVM_X86_H
|
||||
|
||||
#include <linux/kvm_host.h>
|
||||
#include <asm/pvclock.h>
|
||||
#include "kvm_cache_regs.h"
|
||||
|
||||
#define MSR_IA32_CR_PAT_DEFAULT 0x0007040600070406ULL
|
||||
|
@ -195,6 +196,12 @@ extern unsigned int lapic_timer_advance_ns;
|
|||
|
||||
extern struct static_key kvm_no_apic_vcpu;
|
||||
|
||||
static inline u64 nsec_to_cycles(struct kvm_vcpu *vcpu, u64 nsec)
|
||||
{
|
||||
return pvclock_scale_delta(nsec, vcpu->arch.virtual_tsc_mult,
|
||||
vcpu->arch.virtual_tsc_shift);
|
||||
}
|
||||
|
||||
/* Same "calling convention" as do_div:
|
||||
* - divide (n << 32) by base
|
||||
* - put result in n
|
||||
|
|
|
@ -455,6 +455,7 @@ static const int crypto_msg_min[CRYPTO_NR_MSGTYPES] = {
|
|||
[CRYPTO_MSG_NEWALG - CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
|
||||
[CRYPTO_MSG_DELALG - CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
|
||||
[CRYPTO_MSG_UPDATEALG - CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
|
||||
[CRYPTO_MSG_GETALG - CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
|
||||
[CRYPTO_MSG_DELRNG - CRYPTO_MSG_BASE] = 0,
|
||||
};
|
||||
|
||||
|
|
|
@ -928,7 +928,7 @@ static ssize_t format_show(struct device *dev,
|
|||
{
|
||||
struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);
|
||||
|
||||
return sprintf(buf, "0x%04x\n", be16_to_cpu(dcr->code));
|
||||
return sprintf(buf, "0x%04x\n", le16_to_cpu(dcr->code));
|
||||
}
|
||||
static DEVICE_ATTR_RO(format);
|
||||
|
||||
|
@ -961,8 +961,8 @@ static ssize_t format1_show(struct device *dev,
|
|||
continue;
|
||||
if (nfit_dcr->dcr->code == dcr->code)
|
||||
continue;
|
||||
rc = sprintf(buf, "%#x\n",
|
||||
be16_to_cpu(nfit_dcr->dcr->code));
|
||||
rc = sprintf(buf, "0x%04x\n",
|
||||
le16_to_cpu(nfit_dcr->dcr->code));
|
||||
break;
|
||||
}
|
||||
if (rc != ENXIO)
|
||||
|
@ -1131,11 +1131,11 @@ static int acpi_nfit_add_dimm(struct acpi_nfit_desc *acpi_desc,
|
|||
|
||||
/*
|
||||
* Until standardization materializes we need to consider up to 3
|
||||
* different command sets. Note, that checking for function0 (bit0)
|
||||
* tells us if any commands are reachable through this uuid.
|
||||
* different command sets. Note, that checking for zero functions
|
||||
* tells us if any commands might be reachable through this uuid.
|
||||
*/
|
||||
for (i = NVDIMM_FAMILY_INTEL; i <= NVDIMM_FAMILY_HPE2; i++)
|
||||
if (acpi_check_dsm(adev_dimm->handle, to_nfit_uuid(i), 1, 1))
|
||||
if (acpi_check_dsm(adev_dimm->handle, to_nfit_uuid(i), 1, 0))
|
||||
break;
|
||||
|
||||
/* limit the supported commands to those that are publicly documented */
|
||||
|
|
|
@ -53,12 +53,12 @@ enum nfit_uuids {
|
|||
};
|
||||
|
||||
/*
|
||||
* Region format interface codes are stored as an array of bytes in the
|
||||
* NFIT DIMM Control Region structure
|
||||
* Region format interface codes are stored with the interface as the
|
||||
* LSB and the function as the MSB.
|
||||
*/
|
||||
#define NFIT_FIC_BYTE cpu_to_be16(0x101) /* byte-addressable energy backed */
|
||||
#define NFIT_FIC_BLK cpu_to_be16(0x201) /* block-addressable non-energy backed */
|
||||
#define NFIT_FIC_BYTEN cpu_to_be16(0x301) /* byte-addressable non-energy backed */
|
||||
#define NFIT_FIC_BYTE cpu_to_le16(0x101) /* byte-addressable energy backed */
|
||||
#define NFIT_FIC_BLK cpu_to_le16(0x201) /* block-addressable non-energy backed */
|
||||
#define NFIT_FIC_BYTEN cpu_to_le16(0x301) /* byte-addressable non-energy backed */
|
||||
|
||||
enum {
|
||||
NFIT_BLK_READ_FLUSH = 1,
|
||||
|
|
|
@ -839,7 +839,7 @@ void acpi_penalize_isa_irq(int irq, int active)
|
|||
{
|
||||
if ((irq >= 0) && (irq < ARRAY_SIZE(acpi_isa_irq_penalty)))
|
||||
acpi_isa_irq_penalty[irq] = acpi_irq_get_penalty(irq) +
|
||||
active ? PIRQ_PENALTY_ISA_USED : PIRQ_PENALTY_PCI_USING;
|
||||
(active ? PIRQ_PENALTY_ISA_USED : PIRQ_PENALTY_PCI_USING);
|
||||
}
|
||||
|
||||
bool acpi_isa_irq_available(int irq)
|
||||
|
|
|
@ -680,9 +680,6 @@ bool acpi_check_dsm(acpi_handle handle, const u8 *uuid, u64 rev, u64 funcs)
|
|||
u64 mask = 0;
|
||||
union acpi_object *obj;
|
||||
|
||||
if (funcs == 0)
|
||||
return false;
|
||||
|
||||
obj = acpi_evaluate_dsm(handle, uuid, rev, 0, NULL);
|
||||
if (!obj)
|
||||
return false;
|
||||
|
@ -695,6 +692,9 @@ bool acpi_check_dsm(acpi_handle handle, const u8 *uuid, u64 rev, u64 funcs)
|
|||
mask |= (((u64)obj->buffer.pointer[i]) << (i * 8));
|
||||
ACPI_FREE(obj);
|
||||
|
||||
if (funcs == 0)
|
||||
return true;
|
||||
|
||||
/*
|
||||
* Bit 0 indicates whether there's support for any functions other than
|
||||
* function 0 for the specified UUID and revision.
|
||||
|
|
|
@ -137,7 +137,7 @@ static const struct ata_port_info *ahci_seattle_get_port_info(
|
|||
u32 val;
|
||||
|
||||
plat_data = devm_kzalloc(dev, sizeof(*plat_data), GFP_KERNEL);
|
||||
if (IS_ERR(plat_data))
|
||||
if (!plat_data)
|
||||
return &ahci_port_info;
|
||||
|
||||
plat_data->sgpio_ctrl = devm_ioremap_resource(dev,
|
||||
|
|
|
@ -986,7 +986,7 @@ static inline void mv_write_cached_reg(void __iomem *addr, u32 *old, u32 new)
|
|||
* Looks like a lot of fuss, but it avoids an unnecessary
|
||||
* +1 usec read-after-write delay for unaffected registers.
|
||||
*/
|
||||
laddr = (long)addr & 0xffff;
|
||||
laddr = (unsigned long)addr & 0xffff;
|
||||
if (laddr >= 0x300 && laddr <= 0x33c) {
|
||||
laddr &= 0x000f;
|
||||
if (laddr == 0x4 || laddr == 0xc) {
|
||||
|
|
|
@ -144,9 +144,9 @@ static int oxnas_stdclk_probe(struct platform_device *pdev)
|
|||
return -ENOMEM;
|
||||
|
||||
regmap = syscon_node_to_regmap(of_get_parent(np));
|
||||
if (!regmap) {
|
||||
if (IS_ERR(regmap)) {
|
||||
dev_err(&pdev->dev, "failed to have parent regmap\n");
|
||||
return -EINVAL;
|
||||
return PTR_ERR(regmap);
|
||||
}
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(clk_oxnas_init); i++) {
|
||||
|
|
|
@ -321,9 +321,9 @@ struct clk *rockchip_clk_register_cpuclk(const char *name,
|
|||
}
|
||||
|
||||
cclk = clk_register(NULL, &cpuclk->hw);
|
||||
if (IS_ERR(clk)) {
|
||||
if (IS_ERR(cclk)) {
|
||||
pr_err("%s: could not register cpuclk %s\n", __func__, name);
|
||||
ret = PTR_ERR(clk);
|
||||
ret = PTR_ERR(cclk);
|
||||
goto free_rate_table;
|
||||
}
|
||||
|
||||
|
|
|
@ -41,8 +41,6 @@ static unsigned long rockchip_mmc_recalc(struct clk_hw *hw,
|
|||
#define ROCKCHIP_MMC_DEGREE_MASK 0x3
|
||||
#define ROCKCHIP_MMC_DELAYNUM_OFFSET 2
|
||||
#define ROCKCHIP_MMC_DELAYNUM_MASK (0xff << ROCKCHIP_MMC_DELAYNUM_OFFSET)
|
||||
#define ROCKCHIP_MMC_INIT_STATE_RESET 0x1
|
||||
#define ROCKCHIP_MMC_INIT_STATE_SHIFT 1
|
||||
|
||||
#define PSECS_PER_SEC 1000000000000LL
|
||||
|
||||
|
@ -154,6 +152,7 @@ struct clk *rockchip_clk_register_mmc(const char *name,
|
|||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
init.name = name;
|
||||
init.flags = 0;
|
||||
init.num_parents = num_parents;
|
||||
init.parent_names = parent_names;
|
||||
init.ops = &rockchip_mmc_clk_ops;
|
||||
|
@ -162,15 +161,6 @@ struct clk *rockchip_clk_register_mmc(const char *name,
|
|||
mmc_clock->reg = reg;
|
||||
mmc_clock->shift = shift;
|
||||
|
||||
/*
|
||||
* Assert init_state to soft reset the CLKGEN
|
||||
* for mmc tuning phase and degree
|
||||
*/
|
||||
if (mmc_clock->shift == ROCKCHIP_MMC_INIT_STATE_SHIFT)
|
||||
writel(HIWORD_UPDATE(ROCKCHIP_MMC_INIT_STATE_RESET,
|
||||
ROCKCHIP_MMC_INIT_STATE_RESET,
|
||||
mmc_clock->shift), mmc_clock->reg);
|
||||
|
||||
clk = clk_register(NULL, &mmc_clock->hw);
|
||||
if (IS_ERR(clk))
|
||||
kfree(mmc_clock);
|
||||
|
|
|
@ -832,9 +832,9 @@ static struct rockchip_clk_branch rk3399_clk_branches[] __initdata = {
|
|||
RK3399_CLKGATE_CON(13), 1, GFLAGS),
|
||||
|
||||
/* perihp */
|
||||
GATE(0, "cpll_aclk_perihp_src", "gpll", CLK_IGNORE_UNUSED,
|
||||
GATE(0, "cpll_aclk_perihp_src", "cpll", CLK_IGNORE_UNUSED,
|
||||
RK3399_CLKGATE_CON(5), 0, GFLAGS),
|
||||
GATE(0, "gpll_aclk_perihp_src", "cpll", CLK_IGNORE_UNUSED,
|
||||
GATE(0, "gpll_aclk_perihp_src", "gpll", CLK_IGNORE_UNUSED,
|
||||
RK3399_CLKGATE_CON(5), 1, GFLAGS),
|
||||
COMPOSITE(ACLK_PERIHP, "aclk_perihp", mux_aclk_perihp_p, CLK_IGNORE_UNUSED,
|
||||
RK3399_CLKSEL_CON(14), 7, 1, MFLAGS, 0, 5, DFLAGS,
|
||||
|
@ -1466,6 +1466,8 @@ static struct rockchip_clk_branch rk3399_clk_pmu_branches[] __initdata = {
|
|||
|
||||
static const char *const rk3399_cru_critical_clocks[] __initconst = {
|
||||
"aclk_cci_pre",
|
||||
"aclk_gic",
|
||||
"aclk_gic_noc",
|
||||
"pclk_perilp0",
|
||||
"pclk_perilp0",
|
||||
"hclk_perilp0",
|
||||
|
@ -1508,6 +1510,7 @@ static void __init rk3399_clk_init(struct device_node *np)
|
|||
ctx = rockchip_clk_init(np, reg_base, CLK_NR_CLKS);
|
||||
if (IS_ERR(ctx)) {
|
||||
pr_err("%s: rockchip clk init failed\n", __func__);
|
||||
iounmap(reg_base);
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -1553,6 +1556,7 @@ static void __init rk3399_pmu_clk_init(struct device_node *np)
|
|||
ctx = rockchip_clk_init(np, reg_base, CLKPMU_NR_CLKS);
|
||||
if (IS_ERR(ctx)) {
|
||||
pr_err("%s: rockchip pmu clk init failed\n", __func__);
|
||||
iounmap(reg_base);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
@ -56,11 +56,21 @@ static struct cb_id cn_proc_event_id = { CN_IDX_PROC, CN_VAL_PROC };
|
|||
/* proc_event_counts is used as the sequence number of the netlink message */
|
||||
static DEFINE_PER_CPU(__u32, proc_event_counts) = { 0 };
|
||||
|
||||
static inline void get_seq(__u32 *ts, int *cpu)
|
||||
static inline void send_msg(struct cn_msg *msg)
|
||||
{
|
||||
preempt_disable();
|
||||
*ts = __this_cpu_inc_return(proc_event_counts) - 1;
|
||||
*cpu = smp_processor_id();
|
||||
|
||||
msg->seq = __this_cpu_inc_return(proc_event_counts) - 1;
|
||||
((struct proc_event *)msg->data)->cpu = smp_processor_id();
|
||||
|
||||
/*
|
||||
* Preemption remains disabled during send to ensure the messages are
|
||||
* ordered according to their sequence numbers.
|
||||
*
|
||||
* If cn_netlink_send() fails, the data is not sent.
|
||||
*/
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_NOWAIT);
|
||||
|
||||
preempt_enable();
|
||||
}
|
||||
|
||||
|
@ -77,7 +87,6 @@ void proc_fork_connector(struct task_struct *task)
|
|||
msg = buffer_to_cn_msg(buffer);
|
||||
ev = (struct proc_event *)msg->data;
|
||||
memset(&ev->event_data, 0, sizeof(ev->event_data));
|
||||
get_seq(&msg->seq, &ev->cpu);
|
||||
ev->timestamp_ns = ktime_get_ns();
|
||||
ev->what = PROC_EVENT_FORK;
|
||||
rcu_read_lock();
|
||||
|
@ -92,8 +101,7 @@ void proc_fork_connector(struct task_struct *task)
|
|||
msg->ack = 0; /* not used */
|
||||
msg->len = sizeof(*ev);
|
||||
msg->flags = 0; /* not used */
|
||||
/* If cn_netlink_send() failed, the data is not sent */
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
|
||||
send_msg(msg);
|
||||
}
|
||||
|
||||
void proc_exec_connector(struct task_struct *task)
|
||||
|
@ -108,7 +116,6 @@ void proc_exec_connector(struct task_struct *task)
|
|||
msg = buffer_to_cn_msg(buffer);
|
||||
ev = (struct proc_event *)msg->data;
|
||||
memset(&ev->event_data, 0, sizeof(ev->event_data));
|
||||
get_seq(&msg->seq, &ev->cpu);
|
||||
ev->timestamp_ns = ktime_get_ns();
|
||||
ev->what = PROC_EVENT_EXEC;
|
||||
ev->event_data.exec.process_pid = task->pid;
|
||||
|
@ -118,7 +125,7 @@ void proc_exec_connector(struct task_struct *task)
|
|||
msg->ack = 0; /* not used */
|
||||
msg->len = sizeof(*ev);
|
||||
msg->flags = 0; /* not used */
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
|
||||
send_msg(msg);
|
||||
}
|
||||
|
||||
void proc_id_connector(struct task_struct *task, int which_id)
|
||||
|
@ -150,14 +157,13 @@ void proc_id_connector(struct task_struct *task, int which_id)
|
|||
return;
|
||||
}
|
||||
rcu_read_unlock();
|
||||
get_seq(&msg->seq, &ev->cpu);
|
||||
ev->timestamp_ns = ktime_get_ns();
|
||||
|
||||
memcpy(&msg->id, &cn_proc_event_id, sizeof(msg->id));
|
||||
msg->ack = 0; /* not used */
|
||||
msg->len = sizeof(*ev);
|
||||
msg->flags = 0; /* not used */
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
|
||||
send_msg(msg);
|
||||
}
|
||||
|
||||
void proc_sid_connector(struct task_struct *task)
|
||||
|
@ -172,7 +178,6 @@ void proc_sid_connector(struct task_struct *task)
|
|||
msg = buffer_to_cn_msg(buffer);
|
||||
ev = (struct proc_event *)msg->data;
|
||||
memset(&ev->event_data, 0, sizeof(ev->event_data));
|
||||
get_seq(&msg->seq, &ev->cpu);
|
||||
ev->timestamp_ns = ktime_get_ns();
|
||||
ev->what = PROC_EVENT_SID;
|
||||
ev->event_data.sid.process_pid = task->pid;
|
||||
|
@ -182,7 +187,7 @@ void proc_sid_connector(struct task_struct *task)
|
|||
msg->ack = 0; /* not used */
|
||||
msg->len = sizeof(*ev);
|
||||
msg->flags = 0; /* not used */
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
|
||||
send_msg(msg);
|
||||
}
|
||||
|
||||
void proc_ptrace_connector(struct task_struct *task, int ptrace_id)
|
||||
|
@ -197,7 +202,6 @@ void proc_ptrace_connector(struct task_struct *task, int ptrace_id)
|
|||
msg = buffer_to_cn_msg(buffer);
|
||||
ev = (struct proc_event *)msg->data;
|
||||
memset(&ev->event_data, 0, sizeof(ev->event_data));
|
||||
get_seq(&msg->seq, &ev->cpu);
|
||||
ev->timestamp_ns = ktime_get_ns();
|
||||
ev->what = PROC_EVENT_PTRACE;
|
||||
ev->event_data.ptrace.process_pid = task->pid;
|
||||
|
@ -215,7 +219,7 @@ void proc_ptrace_connector(struct task_struct *task, int ptrace_id)
|
|||
msg->ack = 0; /* not used */
|
||||
msg->len = sizeof(*ev);
|
||||
msg->flags = 0; /* not used */
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
|
||||
send_msg(msg);
|
||||
}
|
||||
|
||||
void proc_comm_connector(struct task_struct *task)
|
||||
|
@ -230,7 +234,6 @@ void proc_comm_connector(struct task_struct *task)
|
|||
msg = buffer_to_cn_msg(buffer);
|
||||
ev = (struct proc_event *)msg->data;
|
||||
memset(&ev->event_data, 0, sizeof(ev->event_data));
|
||||
get_seq(&msg->seq, &ev->cpu);
|
||||
ev->timestamp_ns = ktime_get_ns();
|
||||
ev->what = PROC_EVENT_COMM;
|
||||
ev->event_data.comm.process_pid = task->pid;
|
||||
|
@ -241,7 +244,7 @@ void proc_comm_connector(struct task_struct *task)
|
|||
msg->ack = 0; /* not used */
|
||||
msg->len = sizeof(*ev);
|
||||
msg->flags = 0; /* not used */
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
|
||||
send_msg(msg);
|
||||
}
|
||||
|
||||
void proc_coredump_connector(struct task_struct *task)
|
||||
|
@ -256,7 +259,6 @@ void proc_coredump_connector(struct task_struct *task)
|
|||
msg = buffer_to_cn_msg(buffer);
|
||||
ev = (struct proc_event *)msg->data;
|
||||
memset(&ev->event_data, 0, sizeof(ev->event_data));
|
||||
get_seq(&msg->seq, &ev->cpu);
|
||||
ev->timestamp_ns = ktime_get_ns();
|
||||
ev->what = PROC_EVENT_COREDUMP;
|
||||
ev->event_data.coredump.process_pid = task->pid;
|
||||
|
@ -266,7 +268,7 @@ void proc_coredump_connector(struct task_struct *task)
|
|||
msg->ack = 0; /* not used */
|
||||
msg->len = sizeof(*ev);
|
||||
msg->flags = 0; /* not used */
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
|
||||
send_msg(msg);
|
||||
}
|
||||
|
||||
void proc_exit_connector(struct task_struct *task)
|
||||
|
@ -281,7 +283,6 @@ void proc_exit_connector(struct task_struct *task)
|
|||
msg = buffer_to_cn_msg(buffer);
|
||||
ev = (struct proc_event *)msg->data;
|
||||
memset(&ev->event_data, 0, sizeof(ev->event_data));
|
||||
get_seq(&msg->seq, &ev->cpu);
|
||||
ev->timestamp_ns = ktime_get_ns();
|
||||
ev->what = PROC_EVENT_EXIT;
|
||||
ev->event_data.exit.process_pid = task->pid;
|
||||
|
@ -293,7 +294,7 @@ void proc_exit_connector(struct task_struct *task)
|
|||
msg->ack = 0; /* not used */
|
||||
msg->len = sizeof(*ev);
|
||||
msg->flags = 0; /* not used */
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
|
||||
send_msg(msg);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -325,7 +326,7 @@ static void cn_proc_ack(int err, int rcvd_seq, int rcvd_ack)
|
|||
msg->ack = rcvd_ack + 1;
|
||||
msg->len = sizeof(*ev);
|
||||
msg->flags = 0; /* not used */
|
||||
cn_netlink_send(msg, 0, CN_IDX_PROC, GFP_KERNEL);
|
||||
send_msg(msg);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -79,15 +79,16 @@ static const struct of_device_id machines[] __initconst = {
|
|||
static int __init cpufreq_dt_platdev_init(void)
|
||||
{
|
||||
struct device_node *np = of_find_node_by_path("/");
|
||||
const struct of_device_id *match;
|
||||
|
||||
if (!np)
|
||||
return -ENODEV;
|
||||
|
||||
if (!of_match_node(machines, np))
|
||||
match = of_match_node(machines, np);
|
||||
of_node_put(np);
|
||||
if (!match)
|
||||
return -ENODEV;
|
||||
|
||||
of_node_put(of_root);
|
||||
|
||||
return PTR_ERR_OR_ZERO(platform_device_register_simple("cpufreq-dt", -1,
|
||||
NULL, 0));
|
||||
}
|
||||
|
|
|
@ -2261,6 +2261,10 @@ int cpufreq_update_policy(unsigned int cpu)
|
|||
* -> ask driver for current freq and notify governors about a change
|
||||
*/
|
||||
if (cpufreq_driver->get && !cpufreq_driver->setpolicy) {
|
||||
if (cpufreq_suspended) {
|
||||
ret = -EAGAIN;
|
||||
goto unlock;
|
||||
}
|
||||
new_policy.cur = cpufreq_update_current_freq(policy);
|
||||
if (WARN_ON(!new_policy.cur)) {
|
||||
ret = -EIO;
|
||||
|
|
|
@ -1400,6 +1400,9 @@ static void intel_pstate_set_update_util_hook(unsigned int cpu_num)
|
|||
{
|
||||
struct cpudata *cpu = all_cpu_data[cpu_num];
|
||||
|
||||
if (cpu->update_util_set)
|
||||
return;
|
||||
|
||||
/* Prevent intel_pstate_update_util() from using stale data. */
|
||||
cpu->sample.time = 0;
|
||||
cpufreq_add_update_util_hook(cpu_num, &cpu->update_util,
|
||||
|
@ -1440,8 +1443,6 @@ static int intel_pstate_set_policy(struct cpufreq_policy *policy)
|
|||
if (!policy->cpuinfo.max_freq)
|
||||
return -ENODEV;
|
||||
|
||||
intel_pstate_clear_update_util_hook(policy->cpu);
|
||||
|
||||
pr_debug("set_policy cpuinfo.max %u policy->max %u\n",
|
||||
policy->cpuinfo.max_freq, policy->max);
|
||||
|
||||
|
|
|
@ -781,7 +781,7 @@ static int hash_process_data(struct hash_device_data *device_data,
|
|||
&device_data->state);
|
||||
memmove(req_ctx->state.buffer,
|
||||
device_data->state.buffer,
|
||||
HASH_BLOCK_SIZE / sizeof(u32));
|
||||
HASH_BLOCK_SIZE);
|
||||
if (ret) {
|
||||
dev_err(device_data->dev,
|
||||
"%s: hash_resume_state() failed!\n",
|
||||
|
@ -832,7 +832,7 @@ static int hash_process_data(struct hash_device_data *device_data,
|
|||
|
||||
memmove(device_data->state.buffer,
|
||||
req_ctx->state.buffer,
|
||||
HASH_BLOCK_SIZE / sizeof(u32));
|
||||
HASH_BLOCK_SIZE);
|
||||
if (ret) {
|
||||
dev_err(device_data->dev, "%s: hash_save_state() failed!\n",
|
||||
__func__);
|
||||
|
|
|
@ -182,7 +182,7 @@ struct crypto_alg p8_aes_cbc_alg = {
|
|||
.cra_name = "cbc(aes)",
|
||||
.cra_driver_name = "p8_aes_cbc",
|
||||
.cra_module = THIS_MODULE,
|
||||
.cra_priority = 1000,
|
||||
.cra_priority = 2000,
|
||||
.cra_type = &crypto_blkcipher_type,
|
||||
.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_NEED_FALLBACK,
|
||||
.cra_alignmask = 0,
|
||||
|
|
|
@ -166,7 +166,7 @@ struct crypto_alg p8_aes_ctr_alg = {
|
|||
.cra_name = "ctr(aes)",
|
||||
.cra_driver_name = "p8_aes_ctr",
|
||||
.cra_module = THIS_MODULE,
|
||||
.cra_priority = 1000,
|
||||
.cra_priority = 2000,
|
||||
.cra_type = &crypto_blkcipher_type,
|
||||
.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER | CRYPTO_ALG_NEED_FALLBACK,
|
||||
.cra_alignmask = 0,
|
||||
|
|
|
@ -141,7 +141,7 @@ my $vmr = sub {
|
|||
|
||||
# Some ABIs specify vrsave, special-purpose register #256, as reserved
|
||||
# for system use.
|
||||
my $no_vrsave = ($flavour =~ /aix|linux64le/);
|
||||
my $no_vrsave = ($flavour =~ /linux-ppc64le/);
|
||||
my $mtspr = sub {
|
||||
my ($f,$idx,$ra) = @_;
|
||||
if ($idx == 256 && $no_vrsave) {
|
||||
|
|
|
@ -98,7 +98,6 @@ struct tegra_gpio_info {
|
|||
const struct tegra_gpio_soc_config *soc;
|
||||
struct gpio_chip gc;
|
||||
struct irq_chip ic;
|
||||
struct lock_class_key lock_class;
|
||||
u32 bank_count;
|
||||
};
|
||||
|
||||
|
@ -547,6 +546,12 @@ static const struct dev_pm_ops tegra_gpio_pm_ops = {
|
|||
SET_SYSTEM_SLEEP_PM_OPS(tegra_gpio_suspend, tegra_gpio_resume)
|
||||
};
|
||||
|
||||
/*
|
||||
* This lock class tells lockdep that GPIO irqs are in a different category
|
||||
* than their parents, so it won't report false recursion.
|
||||
*/
|
||||
static struct lock_class_key gpio_lock_class;
|
||||
|
||||
static int tegra_gpio_probe(struct platform_device *pdev)
|
||||
{
|
||||
const struct tegra_gpio_soc_config *config;
|
||||
|
@ -660,7 +665,7 @@ static int tegra_gpio_probe(struct platform_device *pdev)
|
|||
|
||||
bank = &tgi->bank_info[GPIO_BANK(gpio)];
|
||||
|
||||
irq_set_lockdep_class(irq, &tgi->lock_class);
|
||||
irq_set_lockdep_class(irq, &gpio_lock_class);
|
||||
irq_set_chip_data(irq, bank);
|
||||
irq_set_chip_and_handler(irq, &tgi->ic, handle_simple_irq);
|
||||
}
|
||||
|
|
|
@ -1106,6 +1106,10 @@ static void amdgpu_uvd_idle_work_handler(struct work_struct *work)
|
|||
if (fences == 0 && handles == 0) {
|
||||
if (adev->pm.dpm_enabled) {
|
||||
amdgpu_dpm_enable_uvd(adev, false);
|
||||
/* just work around for uvd clock remain high even
|
||||
* when uvd dpm disabled on Polaris10 */
|
||||
if (adev->asic_type == CHIP_POLARIS10)
|
||||
amdgpu_asic_set_uvd_clocks(adev, 0, 0);
|
||||
} else {
|
||||
amdgpu_asic_set_uvd_clocks(adev, 0, 0);
|
||||
}
|
||||
|
|
|
@ -47,6 +47,8 @@
|
|||
#include "dce/dce_10_0_d.h"
|
||||
#include "dce/dce_10_0_sh_mask.h"
|
||||
|
||||
#include "smu/smu_7_1_3_d.h"
|
||||
|
||||
#define GFX8_NUM_GFX_RINGS 1
|
||||
#define GFX8_NUM_COMPUTE_RINGS 8
|
||||
|
||||
|
@ -693,6 +695,7 @@ static void gfx_v8_0_init_golden_registers(struct amdgpu_device *adev)
|
|||
amdgpu_program_register_sequence(adev,
|
||||
polaris10_golden_common_all,
|
||||
(const u32)ARRAY_SIZE(polaris10_golden_common_all));
|
||||
WREG32_SMC(ixCG_ACLK_CNTL, 0x0000001C);
|
||||
break;
|
||||
case CHIP_CARRIZO:
|
||||
amdgpu_program_register_sequence(adev,
|
||||
|
|
|
@ -98,6 +98,7 @@
|
|||
#define PCIE_BUS_CLK 10000
|
||||
#define TCLK (PCIE_BUS_CLK / 10)
|
||||
|
||||
#define CEILING_UCHAR(double) ((double-(uint8_t)(double)) > 0 ? (uint8_t)(double+1) : (uint8_t)(double))
|
||||
|
||||
static const uint16_t polaris10_clock_stretcher_lookup_table[2][4] =
|
||||
{ {600, 1050, 3, 0}, {600, 1050, 6, 1} };
|
||||
|
@ -1422,22 +1423,19 @@ static int polaris10_populate_smc_acpi_level(struct pp_hwmgr *hwmgr,
|
|||
|
||||
table->ACPILevel.Flags &= ~PPSMC_SWSTATE_FLAG_DC;
|
||||
|
||||
if (!data->sclk_dpm_key_disabled) {
|
||||
/* Get MinVoltage and Frequency from DPM0,
|
||||
* already converted to SMC_UL */
|
||||
sclk_frequency = data->dpm_table.sclk_table.dpm_levels[0].value;
|
||||
result = polaris10_get_dependency_volt_by_clk(hwmgr,
|
||||
table_info->vdd_dep_on_sclk,
|
||||
table->ACPILevel.SclkFrequency,
|
||||
&table->ACPILevel.MinVoltage, &mvdd);
|
||||
PP_ASSERT_WITH_CODE((0 == result),
|
||||
"Cannot find ACPI VDDC voltage value "
|
||||
"in Clock Dependency Table", );
|
||||
} else {
|
||||
sclk_frequency = data->vbios_boot_state.sclk_bootup_value;
|
||||
table->ACPILevel.MinVoltage =
|
||||
data->vbios_boot_state.vddc_bootup_value * VOLTAGE_SCALE;
|
||||
}
|
||||
|
||||
/* Get MinVoltage and Frequency from DPM0,
|
||||
* already converted to SMC_UL */
|
||||
sclk_frequency = data->dpm_table.sclk_table.dpm_levels[0].value;
|
||||
result = polaris10_get_dependency_volt_by_clk(hwmgr,
|
||||
table_info->vdd_dep_on_sclk,
|
||||
sclk_frequency,
|
||||
&table->ACPILevel.MinVoltage, &mvdd);
|
||||
PP_ASSERT_WITH_CODE((0 == result),
|
||||
"Cannot find ACPI VDDC voltage value "
|
||||
"in Clock Dependency Table",
|
||||
);
|
||||
|
||||
|
||||
result = polaris10_calculate_sclk_params(hwmgr, sclk_frequency, &(table->ACPILevel.SclkSetting));
|
||||
PP_ASSERT_WITH_CODE(result == 0, "Error retrieving Engine Clock dividers from VBIOS.", return result);
|
||||
|
@ -1462,24 +1460,18 @@ static int polaris10_populate_smc_acpi_level(struct pp_hwmgr *hwmgr,
|
|||
CONVERT_FROM_HOST_TO_SMC_US(table->ACPILevel.SclkSetting.Fcw1_frac);
|
||||
CONVERT_FROM_HOST_TO_SMC_US(table->ACPILevel.SclkSetting.Sclk_ss_slew_rate);
|
||||
|
||||
if (!data->mclk_dpm_key_disabled) {
|
||||
/* Get MinVoltage and Frequency from DPM0, already converted to SMC_UL */
|
||||
table->MemoryACPILevel.MclkFrequency =
|
||||
data->dpm_table.mclk_table.dpm_levels[0].value;
|
||||
result = polaris10_get_dependency_volt_by_clk(hwmgr,
|
||||
table_info->vdd_dep_on_mclk,
|
||||
table->MemoryACPILevel.MclkFrequency,
|
||||
&table->MemoryACPILevel.MinVoltage, &mvdd);
|
||||
PP_ASSERT_WITH_CODE((0 == result),
|
||||
"Cannot find ACPI VDDCI voltage value "
|
||||
"in Clock Dependency Table",
|
||||
);
|
||||
} else {
|
||||
table->MemoryACPILevel.MclkFrequency =
|
||||
data->vbios_boot_state.mclk_bootup_value;
|
||||
table->MemoryACPILevel.MinVoltage =
|
||||
data->vbios_boot_state.vddci_bootup_value * VOLTAGE_SCALE;
|
||||
}
|
||||
|
||||
/* Get MinVoltage and Frequency from DPM0, already converted to SMC_UL */
|
||||
table->MemoryACPILevel.MclkFrequency =
|
||||
data->dpm_table.mclk_table.dpm_levels[0].value;
|
||||
result = polaris10_get_dependency_volt_by_clk(hwmgr,
|
||||
table_info->vdd_dep_on_mclk,
|
||||
table->MemoryACPILevel.MclkFrequency,
|
||||
&table->MemoryACPILevel.MinVoltage, &mvdd);
|
||||
PP_ASSERT_WITH_CODE((0 == result),
|
||||
"Cannot find ACPI VDDCI voltage value "
|
||||
"in Clock Dependency Table",
|
||||
);
|
||||
|
||||
us_mvdd = 0;
|
||||
if ((POLARIS10_VOLTAGE_CONTROL_NONE == data->mvdd_control) ||
|
||||
|
@ -1524,6 +1516,7 @@ static int polaris10_populate_smc_vce_level(struct pp_hwmgr *hwmgr,
|
|||
struct phm_ppt_v1_mm_clock_voltage_dependency_table *mm_table =
|
||||
table_info->mm_dep_table;
|
||||
struct polaris10_hwmgr *data = (struct polaris10_hwmgr *)(hwmgr->backend);
|
||||
uint32_t vddci;
|
||||
|
||||
table->VceLevelCount = (uint8_t)(mm_table->count);
|
||||
table->VceBootLevel = 0;
|
||||
|
@ -1533,9 +1526,18 @@ static int polaris10_populate_smc_vce_level(struct pp_hwmgr *hwmgr,
|
|||
table->VceLevel[count].MinVoltage = 0;
|
||||
table->VceLevel[count].MinVoltage |=
|
||||
(mm_table->entries[count].vddc * VOLTAGE_SCALE) << VDDC_SHIFT;
|
||||
|
||||
if (POLARIS10_VOLTAGE_CONTROL_BY_GPIO == data->vddci_control)
|
||||
vddci = (uint32_t)phm_find_closest_vddci(&(data->vddci_voltage_table),
|
||||
mm_table->entries[count].vddc - VDDC_VDDCI_DELTA);
|
||||
else if (POLARIS10_VOLTAGE_CONTROL_BY_SVID2 == data->vddci_control)
|
||||
vddci = mm_table->entries[count].vddc - VDDC_VDDCI_DELTA;
|
||||
else
|
||||
vddci = (data->vbios_boot_state.vddci_bootup_value * VOLTAGE_SCALE) << VDDCI_SHIFT;
|
||||
|
||||
|
||||
table->VceLevel[count].MinVoltage |=
|
||||
((mm_table->entries[count].vddc - data->vddc_vddci_delta) *
|
||||
VOLTAGE_SCALE) << VDDCI_SHIFT;
|
||||
(vddci * VOLTAGE_SCALE) << VDDCI_SHIFT;
|
||||
table->VceLevel[count].MinVoltage |= 1 << PHASES_SHIFT;
|
||||
|
||||
/*retrieve divider value for VBIOS */
|
||||
|
@ -1564,6 +1566,7 @@ static int polaris10_populate_smc_samu_level(struct pp_hwmgr *hwmgr,
|
|||
struct phm_ppt_v1_mm_clock_voltage_dependency_table *mm_table =
|
||||
table_info->mm_dep_table;
|
||||
struct polaris10_hwmgr *data = (struct polaris10_hwmgr *)(hwmgr->backend);
|
||||
uint32_t vddci;
|
||||
|
||||
table->SamuBootLevel = 0;
|
||||
table->SamuLevelCount = (uint8_t)(mm_table->count);
|
||||
|
@ -1574,8 +1577,16 @@ static int polaris10_populate_smc_samu_level(struct pp_hwmgr *hwmgr,
|
|||
table->SamuLevel[count].Frequency = mm_table->entries[count].samclock;
|
||||
table->SamuLevel[count].MinVoltage |= (mm_table->entries[count].vddc *
|
||||
VOLTAGE_SCALE) << VDDC_SHIFT;
|
||||
table->SamuLevel[count].MinVoltage |= ((mm_table->entries[count].vddc -
|
||||
data->vddc_vddci_delta) * VOLTAGE_SCALE) << VDDCI_SHIFT;
|
||||
|
||||
if (POLARIS10_VOLTAGE_CONTROL_BY_GPIO == data->vddci_control)
|
||||
vddci = (uint32_t)phm_find_closest_vddci(&(data->vddci_voltage_table),
|
||||
mm_table->entries[count].vddc - VDDC_VDDCI_DELTA);
|
||||
else if (POLARIS10_VOLTAGE_CONTROL_BY_SVID2 == data->vddci_control)
|
||||
vddci = mm_table->entries[count].vddc - VDDC_VDDCI_DELTA;
|
||||
else
|
||||
vddci = (data->vbios_boot_state.vddci_bootup_value * VOLTAGE_SCALE) << VDDCI_SHIFT;
|
||||
|
||||
table->SamuLevel[count].MinVoltage |= (vddci * VOLTAGE_SCALE) << VDDCI_SHIFT;
|
||||
table->SamuLevel[count].MinVoltage |= 1 << PHASES_SHIFT;
|
||||
|
||||
/* retrieve divider value for VBIOS */
|
||||
|
@ -1658,6 +1669,7 @@ static int polaris10_populate_smc_uvd_level(struct pp_hwmgr *hwmgr,
|
|||
struct phm_ppt_v1_mm_clock_voltage_dependency_table *mm_table =
|
||||
table_info->mm_dep_table;
|
||||
struct polaris10_hwmgr *data = (struct polaris10_hwmgr *)(hwmgr->backend);
|
||||
uint32_t vddci;
|
||||
|
||||
table->UvdLevelCount = (uint8_t)(mm_table->count);
|
||||
table->UvdBootLevel = 0;
|
||||
|
@ -1668,8 +1680,16 @@ static int polaris10_populate_smc_uvd_level(struct pp_hwmgr *hwmgr,
|
|||
table->UvdLevel[count].DclkFrequency = mm_table->entries[count].dclk;
|
||||
table->UvdLevel[count].MinVoltage |= (mm_table->entries[count].vddc *
|
||||
VOLTAGE_SCALE) << VDDC_SHIFT;
|
||||
table->UvdLevel[count].MinVoltage |= ((mm_table->entries[count].vddc -
|
||||
data->vddc_vddci_delta) * VOLTAGE_SCALE) << VDDCI_SHIFT;
|
||||
|
||||
if (POLARIS10_VOLTAGE_CONTROL_BY_GPIO == data->vddci_control)
|
||||
vddci = (uint32_t)phm_find_closest_vddci(&(data->vddci_voltage_table),
|
||||
mm_table->entries[count].vddc - VDDC_VDDCI_DELTA);
|
||||
else if (POLARIS10_VOLTAGE_CONTROL_BY_SVID2 == data->vddci_control)
|
||||
vddci = mm_table->entries[count].vddc - VDDC_VDDCI_DELTA;
|
||||
else
|
||||
vddci = (data->vbios_boot_state.vddci_bootup_value * VOLTAGE_SCALE) << VDDCI_SHIFT;
|
||||
|
||||
table->UvdLevel[count].MinVoltage |= (vddci * VOLTAGE_SCALE) << VDDCI_SHIFT;
|
||||
table->UvdLevel[count].MinVoltage |= 1 << PHASES_SHIFT;
|
||||
|
||||
/* retrieve divider value for VBIOS */
|
||||
|
@ -1690,8 +1710,8 @@ static int polaris10_populate_smc_uvd_level(struct pp_hwmgr *hwmgr,
|
|||
CONVERT_FROM_HOST_TO_SMC_UL(table->UvdLevel[count].VclkFrequency);
|
||||
CONVERT_FROM_HOST_TO_SMC_UL(table->UvdLevel[count].DclkFrequency);
|
||||
CONVERT_FROM_HOST_TO_SMC_UL(table->UvdLevel[count].MinVoltage);
|
||||
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
@ -1787,24 +1807,32 @@ static int polaris10_populate_clock_stretcher_data_table(struct pp_hwmgr *hwmgr)
|
|||
|
||||
ro = efuse * (max -min)/255 + min;
|
||||
|
||||
/* Populate Sclk_CKS_masterEn0_7 and Sclk_voltageOffset */
|
||||
/* Populate Sclk_CKS_masterEn0_7 and Sclk_voltageOffset
|
||||
* there is a little difference in calculating
|
||||
* volt_with_cks with windows */
|
||||
for (i = 0; i < sclk_table->count; i++) {
|
||||
data->smc_state_table.Sclk_CKS_masterEn0_7 |=
|
||||
sclk_table->entries[i].cks_enable << i;
|
||||
|
||||
volt_without_cks = (uint32_t)(((ro - 40) * 1000 - 2753594 - sclk_table->entries[i].clk/100 * 136418 /1000) / \
|
||||
(sclk_table->entries[i].clk/100 * 1132925 /10000 - 242418)/100);
|
||||
|
||||
volt_with_cks = (uint32_t)((ro * 1000 -2396351 - sclk_table->entries[i].clk/100 * 329021/1000) / \
|
||||
(sclk_table->entries[i].clk/10000 * 649434 /1000 - 18005)/10);
|
||||
if (hwmgr->chip_id == CHIP_POLARIS10) {
|
||||
volt_without_cks = (uint32_t)((2753594000 + (sclk_table->entries[i].clk/100) * 136418 -(ro - 70) * 1000000) / \
|
||||
(2424180 - (sclk_table->entries[i].clk/100) * 1132925/1000));
|
||||
volt_with_cks = (uint32_t)((279720200 + sclk_table->entries[i].clk * 3232 - (ro - 65) * 100000000) / \
|
||||
(252248000 - sclk_table->entries[i].clk/100 * 115764));
|
||||
} else {
|
||||
volt_without_cks = (uint32_t)((2416794800 + (sclk_table->entries[i].clk/100) * 1476925/10 -(ro - 50) * 1000000) / \
|
||||
(2625416 - (sclk_table->entries[i].clk/100) * 12586807/10000));
|
||||
volt_with_cks = (uint32_t)((2999656000 + sclk_table->entries[i].clk * 392803/100 - (ro - 44) * 1000000) / \
|
||||
(3422454 - sclk_table->entries[i].clk/100 * 18886376/10000));
|
||||
}
|
||||
|
||||
if (volt_without_cks >= volt_with_cks)
|
||||
volt_offset = (uint8_t)(((volt_without_cks - volt_with_cks +
|
||||
sclk_table->entries[i].cks_voffset) * 100 / 625) + 1);
|
||||
volt_offset = (uint8_t)CEILING_UCHAR((volt_without_cks - volt_with_cks +
|
||||
sclk_table->entries[i].cks_voffset) * 100 / 625);
|
||||
|
||||
data->smc_state_table.Sclk_voltageOffset[i] = volt_offset;
|
||||
}
|
||||
|
||||
data->smc_state_table.LdoRefSel = (table_info->cac_dtp_table->ucCKS_LDO_REFSEL != 0) ? table_info->cac_dtp_table->ucCKS_LDO_REFSEL : 6;
|
||||
/* Populate CKS Lookup Table */
|
||||
if (stretch_amount == 1 || stretch_amount == 2 || stretch_amount == 5)
|
||||
stretch_amount2 = 0;
|
||||
|
@ -2487,6 +2515,8 @@ int polaris10_enable_dpm_tasks(struct pp_hwmgr *hwmgr)
|
|||
PP_ASSERT_WITH_CODE((0 == tmp_result),
|
||||
"Failed to enable VR hot GPIO interrupt!", result = tmp_result);
|
||||
|
||||
smum_send_msg_to_smc(hwmgr->smumgr, (PPSMC_Msg)PPSMC_HasDisplay);
|
||||
|
||||
tmp_result = polaris10_enable_sclk_control(hwmgr);
|
||||
PP_ASSERT_WITH_CODE((0 == tmp_result),
|
||||
"Failed to enable SCLK control!", result = tmp_result);
|
||||
|
@ -2913,6 +2943,31 @@ static int polaris10_set_private_data_based_on_pptable(struct pp_hwmgr *hwmgr)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int polaris10_patch_voltage_workaround(struct pp_hwmgr *hwmgr)
|
||||
{
|
||||
struct phm_ppt_v1_information *table_info =
|
||||
(struct phm_ppt_v1_information *)(hwmgr->pptable);
|
||||
struct phm_ppt_v1_clock_voltage_dependency_table *dep_mclk_table =
|
||||
table_info->vdd_dep_on_mclk;
|
||||
struct phm_ppt_v1_voltage_lookup_table *lookup_table =
|
||||
table_info->vddc_lookup_table;
|
||||
uint32_t i;
|
||||
|
||||
if (hwmgr->chip_id == CHIP_POLARIS10 && hwmgr->hw_revision == 0xC7) {
|
||||
if (lookup_table->entries[dep_mclk_table->entries[dep_mclk_table->count-1].vddInd].us_vdd >= 1000)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < lookup_table->count; i++) {
|
||||
if (lookup_table->entries[i].us_vdd < 0xff01 && lookup_table->entries[i].us_vdd >= 1000) {
|
||||
dep_mclk_table->entries[dep_mclk_table->count-1].vddInd = (uint8_t) i;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int polaris10_hwmgr_backend_init(struct pp_hwmgr *hwmgr)
|
||||
{
|
||||
struct polaris10_hwmgr *data = (struct polaris10_hwmgr *)(hwmgr->backend);
|
||||
|
@ -2990,6 +3045,7 @@ int polaris10_hwmgr_backend_init(struct pp_hwmgr *hwmgr)
|
|||
|
||||
polaris10_set_features_platform_caps(hwmgr);
|
||||
|
||||
polaris10_patch_voltage_workaround(hwmgr);
|
||||
polaris10_init_dpm_defaults(hwmgr);
|
||||
|
||||
/* Get leakage voltage based on leakage ID. */
|
||||
|
@ -4359,6 +4415,15 @@ static int polaris10_notify_link_speed_change_after_state_change(
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int polaris10_notify_smc_display(struct pp_hwmgr *hwmgr)
|
||||
{
|
||||
struct polaris10_hwmgr *data = (struct polaris10_hwmgr *)(hwmgr->backend);
|
||||
|
||||
smum_send_msg_to_smc_with_parameter(hwmgr->smumgr,
|
||||
(PPSMC_Msg)PPSMC_MSG_SetVBITimeout, data->frame_time_x2);
|
||||
return (smum_send_msg_to_smc(hwmgr->smumgr, (PPSMC_Msg)PPSMC_HasDisplay) == 0) ? 0 : -EINVAL;
|
||||
}
|
||||
|
||||
static int polaris10_set_power_state_tasks(struct pp_hwmgr *hwmgr, const void *input)
|
||||
{
|
||||
int tmp_result, result = 0;
|
||||
|
@ -4407,6 +4472,11 @@ static int polaris10_set_power_state_tasks(struct pp_hwmgr *hwmgr, const void *i
|
|||
"Failed to program memory timing parameters!",
|
||||
result = tmp_result);
|
||||
|
||||
tmp_result = polaris10_notify_smc_display(hwmgr);
|
||||
PP_ASSERT_WITH_CODE((0 == tmp_result),
|
||||
"Failed to notify smc display settings!",
|
||||
result = tmp_result);
|
||||
|
||||
tmp_result = polaris10_unfreeze_sclk_mclk_dpm(hwmgr);
|
||||
PP_ASSERT_WITH_CODE((0 == tmp_result),
|
||||
"Failed to unfreeze SCLK MCLK DPM!",
|
||||
|
@ -4441,6 +4511,7 @@ static int polaris10_set_max_fan_pwm_output(struct pp_hwmgr *hwmgr, uint16_t us_
|
|||
PPSMC_MSG_SetFanPwmMax, us_max_fan_pwm);
|
||||
}
|
||||
|
||||
|
||||
int polaris10_notify_smc_display_change(struct pp_hwmgr *hwmgr, bool has_display)
|
||||
{
|
||||
PPSMC_Msg msg = has_display ? (PPSMC_Msg)PPSMC_HasDisplay : (PPSMC_Msg)PPSMC_NoDisplay;
|
||||
|
@ -4460,8 +4531,6 @@ int polaris10_notify_smc_display_config_after_ps_adjustment(struct pp_hwmgr *hwm
|
|||
|
||||
if (num_active_displays > 1) /* to do && (pHwMgr->pPECI->displayConfiguration.bMultiMonitorInSync != TRUE)) */
|
||||
polaris10_notify_smc_display_change(hwmgr, false);
|
||||
else
|
||||
polaris10_notify_smc_display_change(hwmgr, true);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -4502,6 +4571,8 @@ int polaris10_program_display_gap(struct pp_hwmgr *hwmgr)
|
|||
frame_time_in_us = 1000000 / refresh_rate;
|
||||
|
||||
pre_vbi_time_in_us = frame_time_in_us - 200 - mode_info.vblank_time_us;
|
||||
data->frame_time_x2 = frame_time_in_us * 2 / 100;
|
||||
|
||||
display_gap2 = pre_vbi_time_in_us * (ref_clock / 100);
|
||||
|
||||
cgs_write_ind_register(hwmgr->device, CGS_IND_REG__SMC, ixCG_DISPLAY_GAP_CNTL2, display_gap2);
|
||||
|
@ -4510,8 +4581,6 @@ int polaris10_program_display_gap(struct pp_hwmgr *hwmgr)
|
|||
|
||||
cgs_write_ind_register(hwmgr->device, CGS_IND_REG__SMC, data->soft_regs_start + offsetof(SMU74_SoftRegisters, VBlankTimeout), (frame_time_in_us - pre_vbi_time_in_us));
|
||||
|
||||
polaris10_notify_smc_display_change(hwmgr, num_active_displays != 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -4623,7 +4692,7 @@ int polaris10_upload_mc_firmware(struct pp_hwmgr *hwmgr)
|
|||
return 0;
|
||||
}
|
||||
|
||||
data->need_long_memory_training = true;
|
||||
data->need_long_memory_training = false;
|
||||
|
||||
/*
|
||||
* PPMCME_FirmwareDescriptorEntry *pfd = NULL;
|
||||
|
|
|
@ -315,6 +315,7 @@ struct polaris10_hwmgr {
|
|||
|
||||
uint32_t avfs_vdroop_override_setting;
|
||||
bool apply_avfs_cks_off_voltage;
|
||||
uint32_t frame_time_x2;
|
||||
};
|
||||
|
||||
/* To convert to Q8.8 format for firmware */
|
||||
|
|
|
@ -411,6 +411,8 @@ struct phm_cac_tdp_table {
|
|||
uint8_t ucVr_I2C_Line;
|
||||
uint8_t ucPlx_I2C_address;
|
||||
uint8_t ucPlx_I2C_Line;
|
||||
uint32_t usBoostPowerLimit;
|
||||
uint8_t ucCKS_LDO_REFSEL;
|
||||
};
|
||||
|
||||
struct phm_ppm_table {
|
||||
|
|
|
@ -392,6 +392,8 @@ typedef uint16_t PPSMC_Result;
|
|||
#define PPSMC_MSG_SetGpuPllDfsForSclk ((uint16_t) 0x300)
|
||||
#define PPSMC_MSG_Didt_Block_Function ((uint16_t) 0x301)
|
||||
|
||||
#define PPSMC_MSG_SetVBITimeout ((uint16_t) 0x306)
|
||||
|
||||
#define PPSMC_MSG_SecureSRBMWrite ((uint16_t) 0x600)
|
||||
#define PPSMC_MSG_SecureSRBMRead ((uint16_t) 0x601)
|
||||
#define PPSMC_MSG_SetAddress ((uint16_t) 0x800)
|
||||
|
|
|
@ -270,7 +270,8 @@ struct SMU74_Discrete_DpmTable {
|
|||
uint8_t BootPhases;
|
||||
|
||||
uint8_t VRHotLevel;
|
||||
uint8_t Reserved1[3];
|
||||
uint8_t LdoRefSel;
|
||||
uint8_t Reserved1[2];
|
||||
uint16_t FanStartTemperature;
|
||||
uint16_t FanStopTemperature;
|
||||
uint16_t MaxVoltage;
|
||||
|
|
|
@ -2365,16 +2365,16 @@ static int i915_ppgtt_info(struct seq_file *m, void *data)
|
|||
task = get_pid_task(file->pid, PIDTYPE_PID);
|
||||
if (!task) {
|
||||
ret = -ESRCH;
|
||||
goto out_put;
|
||||
goto out_unlock;
|
||||
}
|
||||
seq_printf(m, "\nproc: %s\n", task->comm);
|
||||
put_task_struct(task);
|
||||
idr_for_each(&file_priv->context_idr, per_file_ctx,
|
||||
(void *)(unsigned long)m);
|
||||
}
|
||||
out_unlock:
|
||||
mutex_unlock(&dev->filelist_mutex);
|
||||
|
||||
out_put:
|
||||
intel_runtime_pm_put(dev_priv);
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
|
|
|
@ -8447,16 +8447,16 @@ static void lpt_reset_fdi_mphy(struct drm_i915_private *dev_priv)
|
|||
tmp |= FDI_MPHY_IOSFSB_RESET_CTL;
|
||||
I915_WRITE(SOUTH_CHICKEN2, tmp);
|
||||
|
||||
if (wait_for_atomic_us(I915_READ(SOUTH_CHICKEN2) &
|
||||
FDI_MPHY_IOSFSB_RESET_STATUS, 100))
|
||||
if (wait_for_us(I915_READ(SOUTH_CHICKEN2) &
|
||||
FDI_MPHY_IOSFSB_RESET_STATUS, 100))
|
||||
DRM_ERROR("FDI mPHY reset assert timeout\n");
|
||||
|
||||
tmp = I915_READ(SOUTH_CHICKEN2);
|
||||
tmp &= ~FDI_MPHY_IOSFSB_RESET_CTL;
|
||||
I915_WRITE(SOUTH_CHICKEN2, tmp);
|
||||
|
||||
if (wait_for_atomic_us((I915_READ(SOUTH_CHICKEN2) &
|
||||
FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100))
|
||||
if (wait_for_us((I915_READ(SOUTH_CHICKEN2) &
|
||||
FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100))
|
||||
DRM_ERROR("FDI mPHY reset de-assert timeout\n");
|
||||
}
|
||||
|
||||
|
@ -9440,8 +9440,8 @@ static void hsw_disable_lcpll(struct drm_i915_private *dev_priv,
|
|||
val |= LCPLL_CD_SOURCE_FCLK;
|
||||
I915_WRITE(LCPLL_CTL, val);
|
||||
|
||||
if (wait_for_atomic_us(I915_READ(LCPLL_CTL) &
|
||||
LCPLL_CD_SOURCE_FCLK_DONE, 1))
|
||||
if (wait_for_us(I915_READ(LCPLL_CTL) &
|
||||
LCPLL_CD_SOURCE_FCLK_DONE, 1))
|
||||
DRM_ERROR("Switching to FCLK failed\n");
|
||||
|
||||
val = I915_READ(LCPLL_CTL);
|
||||
|
@ -9514,8 +9514,8 @@ static void hsw_restore_lcpll(struct drm_i915_private *dev_priv)
|
|||
val &= ~LCPLL_CD_SOURCE_FCLK;
|
||||
I915_WRITE(LCPLL_CTL, val);
|
||||
|
||||
if (wait_for_atomic_us((I915_READ(LCPLL_CTL) &
|
||||
LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1))
|
||||
if (wait_for_us((I915_READ(LCPLL_CTL) &
|
||||
LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1))
|
||||
DRM_ERROR("Switching back to LCPLL failed\n");
|
||||
}
|
||||
|
||||
|
|
|
@ -663,7 +663,7 @@ intel_dp_aux_wait_done(struct intel_dp *intel_dp, bool has_aux_irq)
|
|||
done = wait_event_timeout(dev_priv->gmbus_wait_queue, C,
|
||||
msecs_to_jiffies_timeout(10));
|
||||
else
|
||||
done = wait_for_atomic(C, 10) == 0;
|
||||
done = wait_for(C, 10) == 0;
|
||||
if (!done)
|
||||
DRM_ERROR("dp aux hw did not signal timeout (has irq: %i)!\n",
|
||||
has_aux_irq);
|
||||
|
@ -4899,13 +4899,15 @@ static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp)
|
|||
|
||||
void intel_dp_encoder_reset(struct drm_encoder *encoder)
|
||||
{
|
||||
struct intel_dp *intel_dp;
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->dev);
|
||||
struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
|
||||
|
||||
if (!HAS_DDI(dev_priv))
|
||||
intel_dp->DP = I915_READ(intel_dp->output_reg);
|
||||
|
||||
if (to_intel_encoder(encoder)->type != INTEL_OUTPUT_EDP)
|
||||
return;
|
||||
|
||||
intel_dp = enc_to_intel_dp(encoder);
|
||||
|
||||
pps_lock(intel_dp);
|
||||
|
||||
/*
|
||||
|
|
|
@ -1377,8 +1377,8 @@ static void bxt_ddi_pll_enable(struct drm_i915_private *dev_priv,
|
|||
I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp);
|
||||
POSTING_READ(BXT_PORT_PLL_ENABLE(port));
|
||||
|
||||
if (wait_for_atomic_us((I915_READ(BXT_PORT_PLL_ENABLE(port)) &
|
||||
PORT_PLL_LOCK), 200))
|
||||
if (wait_for_us((I915_READ(BXT_PORT_PLL_ENABLE(port)) & PORT_PLL_LOCK),
|
||||
200))
|
||||
DRM_ERROR("PLL %d not locked\n", port);
|
||||
|
||||
/*
|
||||
|
|
|
@ -61,6 +61,7 @@ MODULE_LICENSE("GPL");
|
|||
#define MT_QUIRK_ALWAYS_VALID (1 << 4)
|
||||
#define MT_QUIRK_VALID_IS_INRANGE (1 << 5)
|
||||
#define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 6)
|
||||
#define MT_QUIRK_CONFIDENCE (1 << 7)
|
||||
#define MT_QUIRK_SLOT_IS_CONTACTID_MINUS_ONE (1 << 8)
|
||||
#define MT_QUIRK_NO_AREA (1 << 9)
|
||||
#define MT_QUIRK_IGNORE_DUPLICATES (1 << 10)
|
||||
|
@ -78,6 +79,7 @@ struct mt_slot {
|
|||
__s32 contactid; /* the device ContactID assigned to this slot */
|
||||
bool touch_state; /* is the touch valid? */
|
||||
bool inrange_state; /* is the finger in proximity of the sensor? */
|
||||
bool confidence_state; /* is the touch made by a finger? */
|
||||
};
|
||||
|
||||
struct mt_class {
|
||||
|
@ -503,10 +505,8 @@ static int mt_touch_input_mapping(struct hid_device *hdev, struct hid_input *hi,
|
|||
return 1;
|
||||
case HID_DG_CONFIDENCE:
|
||||
if (cls->name == MT_CLS_WIN_8 &&
|
||||
field->application == HID_DG_TOUCHPAD) {
|
||||
cls->quirks &= ~MT_QUIRK_ALWAYS_VALID;
|
||||
cls->quirks |= MT_QUIRK_VALID_IS_CONFIDENCE;
|
||||
}
|
||||
field->application == HID_DG_TOUCHPAD)
|
||||
cls->quirks |= MT_QUIRK_CONFIDENCE;
|
||||
mt_store_field(usage, td, hi);
|
||||
return 1;
|
||||
case HID_DG_TIPSWITCH:
|
||||
|
@ -619,6 +619,7 @@ static void mt_complete_slot(struct mt_device *td, struct input_dev *input)
|
|||
return;
|
||||
|
||||
if (td->curvalid || (td->mtclass.quirks & MT_QUIRK_ALWAYS_VALID)) {
|
||||
int active;
|
||||
int slotnum = mt_compute_slot(td, input);
|
||||
struct mt_slot *s = &td->curdata;
|
||||
struct input_mt *mt = input->mt;
|
||||
|
@ -633,10 +634,14 @@ static void mt_complete_slot(struct mt_device *td, struct input_dev *input)
|
|||
return;
|
||||
}
|
||||
|
||||
if (!(td->mtclass.quirks & MT_QUIRK_CONFIDENCE))
|
||||
s->confidence_state = 1;
|
||||
active = (s->touch_state || s->inrange_state) &&
|
||||
s->confidence_state;
|
||||
|
||||
input_mt_slot(input, slotnum);
|
||||
input_mt_report_slot_state(input, MT_TOOL_FINGER,
|
||||
s->touch_state || s->inrange_state);
|
||||
if (s->touch_state || s->inrange_state) {
|
||||
input_mt_report_slot_state(input, MT_TOOL_FINGER, active);
|
||||
if (active) {
|
||||
/* this finger is in proximity of the sensor */
|
||||
int wide = (s->w > s->h);
|
||||
/* divided by two to match visual scale of touch */
|
||||
|
@ -701,6 +706,8 @@ static void mt_process_mt_event(struct hid_device *hid, struct hid_field *field,
|
|||
td->curdata.touch_state = value;
|
||||
break;
|
||||
case HID_DG_CONFIDENCE:
|
||||
if (quirks & MT_QUIRK_CONFIDENCE)
|
||||
td->curdata.confidence_state = value;
|
||||
if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
|
||||
td->curvalid = value;
|
||||
break;
|
||||
|
|
|
@ -81,7 +81,7 @@ static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro)
|
|||
|
||||
mutex_lock(&st->buf_lock);
|
||||
ret = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
|
||||
if (ret)
|
||||
if (ret < 0)
|
||||
goto error_ret;
|
||||
st->tx[0] = KXSD9_WRITE(KXSD9_REG_CTRL_C);
|
||||
st->tx[1] = (ret & ~KXSD9_FS_MASK) | i;
|
||||
|
@ -163,7 +163,7 @@ static int kxsd9_read_raw(struct iio_dev *indio_dev,
|
|||
break;
|
||||
case IIO_CHAN_INFO_SCALE:
|
||||
ret = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
|
||||
if (ret)
|
||||
if (ret < 0)
|
||||
goto error_ret;
|
||||
*val2 = kxsd9_micro_scales[ret & KXSD9_FS_MASK];
|
||||
ret = IIO_VAL_INT_PLUS_MICRO;
|
||||
|
|
|
@ -396,8 +396,8 @@ static int ad7266_probe(struct spi_device *spi)
|
|||
|
||||
st = iio_priv(indio_dev);
|
||||
|
||||
st->reg = devm_regulator_get(&spi->dev, "vref");
|
||||
if (!IS_ERR_OR_NULL(st->reg)) {
|
||||
st->reg = devm_regulator_get_optional(&spi->dev, "vref");
|
||||
if (!IS_ERR(st->reg)) {
|
||||
ret = regulator_enable(st->reg);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
@ -408,6 +408,9 @@ static int ad7266_probe(struct spi_device *spi)
|
|||
|
||||
st->vref_mv = ret / 1000;
|
||||
} else {
|
||||
/* Any other error indicates that the regulator does exist */
|
||||
if (PTR_ERR(st->reg) != -ENODEV)
|
||||
return PTR_ERR(st->reg);
|
||||
/* Use internal reference */
|
||||
st->vref_mv = 2500;
|
||||
}
|
||||
|
|
|
@ -56,6 +56,7 @@ static int asus_acpi_get_sensor_info(struct acpi_device *adev,
|
|||
int i;
|
||||
acpi_status status;
|
||||
union acpi_object *cpm;
|
||||
int ret;
|
||||
|
||||
status = acpi_evaluate_object(adev->handle, "CNF0", NULL, &buffer);
|
||||
if (ACPI_FAILURE(status))
|
||||
|
@ -82,10 +83,10 @@ static int asus_acpi_get_sensor_info(struct acpi_device *adev,
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
ret = cpm->package.count;
|
||||
kfree(buffer.pointer);
|
||||
|
||||
return cpm->package.count;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int acpi_i2c_check_resource(struct acpi_resource *ares, void *data)
|
||||
|
|
|
@ -1031,17 +1031,17 @@ static int xpad_play_effect(struct input_dev *dev, void *data, struct ff_effect
|
|||
|
||||
case XTYPE_XBOXONE:
|
||||
packet->data[0] = 0x09; /* activate rumble */
|
||||
packet->data[1] = 0x08;
|
||||
packet->data[1] = 0x00;
|
||||
packet->data[2] = xpad->odata_serial++;
|
||||
packet->data[3] = 0x08; /* continuous effect */
|
||||
packet->data[4] = 0x00; /* simple rumble mode */
|
||||
packet->data[5] = 0x03; /* L and R actuator only */
|
||||
packet->data[6] = 0x00; /* TODO: LT actuator */
|
||||
packet->data[7] = 0x00; /* TODO: RT actuator */
|
||||
packet->data[3] = 0x09;
|
||||
packet->data[4] = 0x00;
|
||||
packet->data[5] = 0x0F;
|
||||
packet->data[6] = 0x00;
|
||||
packet->data[7] = 0x00;
|
||||
packet->data[8] = strong / 512; /* left actuator */
|
||||
packet->data[9] = weak / 512; /* right actuator */
|
||||
packet->data[10] = 0x80; /* length of pulse */
|
||||
packet->data[11] = 0x00; /* stop period of pulse */
|
||||
packet->data[10] = 0xFF;
|
||||
packet->data[11] = 0x00;
|
||||
packet->data[12] = 0x00;
|
||||
packet->len = 13;
|
||||
packet->pending = true;
|
||||
|
@ -1437,16 +1437,6 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
|
|||
break;
|
||||
}
|
||||
|
||||
if (xpad_device[i].xtype == XTYPE_XBOXONE &&
|
||||
intf->cur_altsetting->desc.bInterfaceNumber != 0) {
|
||||
/*
|
||||
* The Xbox One controller lists three interfaces all with the
|
||||
* same interface class, subclass and protocol. Differentiate by
|
||||
* interface number.
|
||||
*/
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);
|
||||
if (!xpad)
|
||||
return -ENOMEM;
|
||||
|
@ -1478,6 +1468,8 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
|
|||
if (intf->cur_altsetting->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC) {
|
||||
if (intf->cur_altsetting->desc.bInterfaceProtocol == 129)
|
||||
xpad->xtype = XTYPE_XBOX360W;
|
||||
else if (intf->cur_altsetting->desc.bInterfaceProtocol == 208)
|
||||
xpad->xtype = XTYPE_XBOXONE;
|
||||
else
|
||||
xpad->xtype = XTYPE_XBOX360;
|
||||
} else {
|
||||
|
@ -1492,6 +1484,17 @@ static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id
|
|||
xpad->mapping |= MAP_STICKS_TO_NULL;
|
||||
}
|
||||
|
||||
if (xpad->xtype == XTYPE_XBOXONE &&
|
||||
intf->cur_altsetting->desc.bInterfaceNumber != 0) {
|
||||
/*
|
||||
* The Xbox One controller lists three interfaces all with the
|
||||
* same interface class, subclass and protocol. Differentiate by
|
||||
* interface number.
|
||||
*/
|
||||
error = -ENODEV;
|
||||
goto err_free_in_urb;
|
||||
}
|
||||
|
||||
error = xpad_init_output(intf, xpad);
|
||||
if (error)
|
||||
goto err_free_in_urb;
|
||||
|
|
|
@ -1568,13 +1568,7 @@ static int elantech_set_properties(struct elantech_data *etd)
|
|||
case 5:
|
||||
etd->hw_version = 3;
|
||||
break;
|
||||
case 6:
|
||||
case 7:
|
||||
case 8:
|
||||
case 9:
|
||||
case 10:
|
||||
case 13:
|
||||
case 14:
|
||||
case 6 ... 14:
|
||||
etd->hw_version = 4;
|
||||
break;
|
||||
default:
|
||||
|
|
|
@ -355,18 +355,11 @@ int vmmouse_detect(struct psmouse *psmouse, bool set_properties)
|
|||
return -ENXIO;
|
||||
}
|
||||
|
||||
if (!request_region(VMMOUSE_PROTO_PORT, 4, "vmmouse")) {
|
||||
psmouse_dbg(psmouse, "VMMouse port in use.\n");
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
/* Check if the device is present */
|
||||
response = ~VMMOUSE_PROTO_MAGIC;
|
||||
VMMOUSE_CMD(GETVERSION, 0, version, response, dummy1, dummy2);
|
||||
if (response != VMMOUSE_PROTO_MAGIC || version == 0xffffffffU) {
|
||||
release_region(VMMOUSE_PROTO_PORT, 4);
|
||||
if (response != VMMOUSE_PROTO_MAGIC || version == 0xffffffffU)
|
||||
return -ENXIO;
|
||||
}
|
||||
|
||||
if (set_properties) {
|
||||
psmouse->vendor = VMMOUSE_VENDOR;
|
||||
|
@ -374,8 +367,6 @@ int vmmouse_detect(struct psmouse *psmouse, bool set_properties)
|
|||
psmouse->model = version;
|
||||
}
|
||||
|
||||
release_region(VMMOUSE_PROTO_PORT, 4);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -394,7 +385,6 @@ static void vmmouse_disconnect(struct psmouse *psmouse)
|
|||
psmouse_reset(psmouse);
|
||||
input_unregister_device(priv->abs_dev);
|
||||
kfree(priv);
|
||||
release_region(VMMOUSE_PROTO_PORT, 4);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -438,15 +428,10 @@ int vmmouse_init(struct psmouse *psmouse)
|
|||
struct input_dev *rel_dev = psmouse->dev, *abs_dev;
|
||||
int error;
|
||||
|
||||
if (!request_region(VMMOUSE_PROTO_PORT, 4, "vmmouse")) {
|
||||
psmouse_dbg(psmouse, "VMMouse port in use.\n");
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
psmouse_reset(psmouse);
|
||||
error = vmmouse_enable(psmouse);
|
||||
if (error)
|
||||
goto release_region;
|
||||
return error;
|
||||
|
||||
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
||||
abs_dev = input_allocate_device();
|
||||
|
@ -502,8 +487,5 @@ init_fail:
|
|||
kfree(priv);
|
||||
psmouse->private = NULL;
|
||||
|
||||
release_region:
|
||||
release_region(VMMOUSE_PROTO_PORT, 4);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
|
|
@ -27,7 +27,7 @@ MODULE_AUTHOR("Jaya Kumar <jayakumar.lkml@gmail.com>");
|
|||
MODULE_DESCRIPTION(DRIVER_DESC);
|
||||
MODULE_LICENSE("GPL");
|
||||
|
||||
#define W8001_MAX_LENGTH 11
|
||||
#define W8001_MAX_LENGTH 13
|
||||
#define W8001_LEAD_MASK 0x80
|
||||
#define W8001_LEAD_BYTE 0x80
|
||||
#define W8001_TAB_MASK 0x40
|
||||
|
@ -339,6 +339,15 @@ static irqreturn_t w8001_interrupt(struct serio *serio,
|
|||
w8001->idx = 0;
|
||||
parse_multi_touch(w8001);
|
||||
break;
|
||||
|
||||
default:
|
||||
/*
|
||||
* ThinkPad X60 Tablet PC (pen only device) sometimes
|
||||
* sends invalid data packets that are larger than
|
||||
* W8001_PKTLEN_TPCPEN. Let's start over again.
|
||||
*/
|
||||
if (!w8001->touch_dev && w8001->idx > W8001_PKTLEN_TPCPEN - 1)
|
||||
w8001->idx = 0;
|
||||
}
|
||||
|
||||
return IRQ_HANDLED;
|
||||
|
|
|
@ -1107,13 +1107,13 @@ static int __init init_iommu_from_acpi(struct amd_iommu *iommu,
|
|||
break;
|
||||
}
|
||||
|
||||
devid = e->devid;
|
||||
DUMP_printk(" DEV_ACPI_HID(%s[%s])\t\tdevid: %02x:%02x.%x\n",
|
||||
hid, uid,
|
||||
PCI_BUS_NUM(devid),
|
||||
PCI_SLOT(devid),
|
||||
PCI_FUNC(devid));
|
||||
|
||||
devid = e->devid;
|
||||
flags = e->flags;
|
||||
|
||||
ret = add_acpi_hid_device(hid, uid, &devid, false);
|
||||
|
|
|
@ -4607,7 +4607,7 @@ static void free_all_cpu_cached_iovas(unsigned int cpu)
|
|||
if (!iommu)
|
||||
continue;
|
||||
|
||||
for (did = 0; did < 0xffff; did++) {
|
||||
for (did = 0; did < cap_ndoms(iommu->cap); did++) {
|
||||
domain = get_iommu_domain(iommu, did);
|
||||
|
||||
if (!domain)
|
||||
|
|
|
@ -420,8 +420,10 @@ retry:
|
|||
|
||||
/* Try replenishing IOVAs by flushing rcache. */
|
||||
flushed_rcache = true;
|
||||
preempt_disable();
|
||||
for_each_online_cpu(cpu)
|
||||
free_cpu_cached_iovas(cpu, iovad);
|
||||
preempt_enable();
|
||||
goto retry;
|
||||
}
|
||||
|
||||
|
@ -749,7 +751,7 @@ static bool __iova_rcache_insert(struct iova_domain *iovad,
|
|||
bool can_insert = false;
|
||||
unsigned long flags;
|
||||
|
||||
cpu_rcache = this_cpu_ptr(rcache->cpu_rcaches);
|
||||
cpu_rcache = get_cpu_ptr(rcache->cpu_rcaches);
|
||||
spin_lock_irqsave(&cpu_rcache->lock, flags);
|
||||
|
||||
if (!iova_magazine_full(cpu_rcache->loaded)) {
|
||||
|
@ -779,6 +781,7 @@ static bool __iova_rcache_insert(struct iova_domain *iovad,
|
|||
iova_magazine_push(cpu_rcache->loaded, iova_pfn);
|
||||
|
||||
spin_unlock_irqrestore(&cpu_rcache->lock, flags);
|
||||
put_cpu_ptr(rcache->cpu_rcaches);
|
||||
|
||||
if (mag_to_free) {
|
||||
iova_magazine_free_pfns(mag_to_free, iovad);
|
||||
|
@ -812,7 +815,7 @@ static unsigned long __iova_rcache_get(struct iova_rcache *rcache,
|
|||
bool has_pfn = false;
|
||||
unsigned long flags;
|
||||
|
||||
cpu_rcache = this_cpu_ptr(rcache->cpu_rcaches);
|
||||
cpu_rcache = get_cpu_ptr(rcache->cpu_rcaches);
|
||||
spin_lock_irqsave(&cpu_rcache->lock, flags);
|
||||
|
||||
if (!iova_magazine_empty(cpu_rcache->loaded)) {
|
||||
|
@ -834,6 +837,7 @@ static unsigned long __iova_rcache_get(struct iova_rcache *rcache,
|
|||
iova_pfn = iova_magazine_pop(cpu_rcache->loaded, limit_pfn);
|
||||
|
||||
spin_unlock_irqrestore(&cpu_rcache->lock, flags);
|
||||
put_cpu_ptr(rcache->cpu_rcaches);
|
||||
|
||||
return iova_pfn;
|
||||
}
|
||||
|
|
|
@ -203,6 +203,7 @@ static int max77620_get_fps_period_reg_value(struct max77620_chip *chip,
|
|||
break;
|
||||
case MAX77620:
|
||||
fps_min_period = MAX77620_FPS_PERIOD_MIN_US;
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
@ -236,6 +237,7 @@ static int max77620_config_fps(struct max77620_chip *chip,
|
|||
break;
|
||||
case MAX77620:
|
||||
fps_max_period = MAX77620_FPS_PERIOD_MAX_US;
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
|
|
@ -657,6 +657,20 @@ static void __set_agg_ports_ready(struct aggregator *aggregator, int val)
|
|||
}
|
||||
}
|
||||
|
||||
static int __agg_active_ports(struct aggregator *agg)
|
||||
{
|
||||
struct port *port;
|
||||
int active = 0;
|
||||
|
||||
for (port = agg->lag_ports; port;
|
||||
port = port->next_port_in_aggregator) {
|
||||
if (port->is_enabled)
|
||||
active++;
|
||||
}
|
||||
|
||||
return active;
|
||||
}
|
||||
|
||||
/**
|
||||
* __get_agg_bandwidth - get the total bandwidth of an aggregator
|
||||
* @aggregator: the aggregator we're looking at
|
||||
|
@ -664,39 +678,40 @@ static void __set_agg_ports_ready(struct aggregator *aggregator, int val)
|
|||
*/
|
||||
static u32 __get_agg_bandwidth(struct aggregator *aggregator)
|
||||
{
|
||||
int nports = __agg_active_ports(aggregator);
|
||||
u32 bandwidth = 0;
|
||||
|
||||
if (aggregator->num_of_ports) {
|
||||
if (nports) {
|
||||
switch (__get_link_speed(aggregator->lag_ports)) {
|
||||
case AD_LINK_SPEED_1MBPS:
|
||||
bandwidth = aggregator->num_of_ports;
|
||||
bandwidth = nports;
|
||||
break;
|
||||
case AD_LINK_SPEED_10MBPS:
|
||||
bandwidth = aggregator->num_of_ports * 10;
|
||||
bandwidth = nports * 10;
|
||||
break;
|
||||
case AD_LINK_SPEED_100MBPS:
|
||||
bandwidth = aggregator->num_of_ports * 100;
|
||||
bandwidth = nports * 100;
|
||||
break;
|
||||
case AD_LINK_SPEED_1000MBPS:
|
||||
bandwidth = aggregator->num_of_ports * 1000;
|
||||
bandwidth = nports * 1000;
|
||||
break;
|
||||
case AD_LINK_SPEED_2500MBPS:
|
||||
bandwidth = aggregator->num_of_ports * 2500;
|
||||
bandwidth = nports * 2500;
|
||||
break;
|
||||
case AD_LINK_SPEED_10000MBPS:
|
||||
bandwidth = aggregator->num_of_ports * 10000;
|
||||
bandwidth = nports * 10000;
|
||||
break;
|
||||
case AD_LINK_SPEED_20000MBPS:
|
||||
bandwidth = aggregator->num_of_ports * 20000;
|
||||
bandwidth = nports * 20000;
|
||||
break;
|
||||
case AD_LINK_SPEED_40000MBPS:
|
||||
bandwidth = aggregator->num_of_ports * 40000;
|
||||
bandwidth = nports * 40000;
|
||||
break;
|
||||
case AD_LINK_SPEED_56000MBPS:
|
||||
bandwidth = aggregator->num_of_ports * 56000;
|
||||
bandwidth = nports * 56000;
|
||||
break;
|
||||
case AD_LINK_SPEED_100000MBPS:
|
||||
bandwidth = aggregator->num_of_ports * 100000;
|
||||
bandwidth = nports * 100000;
|
||||
break;
|
||||
default:
|
||||
bandwidth = 0; /* to silence the compiler */
|
||||
|
@ -1530,10 +1545,10 @@ static struct aggregator *ad_agg_selection_test(struct aggregator *best,
|
|||
|
||||
switch (__get_agg_selection_mode(curr->lag_ports)) {
|
||||
case BOND_AD_COUNT:
|
||||
if (curr->num_of_ports > best->num_of_ports)
|
||||
if (__agg_active_ports(curr) > __agg_active_ports(best))
|
||||
return curr;
|
||||
|
||||
if (curr->num_of_ports < best->num_of_ports)
|
||||
if (__agg_active_ports(curr) < __agg_active_ports(best))
|
||||
return best;
|
||||
|
||||
/*FALLTHROUGH*/
|
||||
|
@ -1561,8 +1576,14 @@ static int agg_device_up(const struct aggregator *agg)
|
|||
if (!port)
|
||||
return 0;
|
||||
|
||||
return netif_running(port->slave->dev) &&
|
||||
netif_carrier_ok(port->slave->dev);
|
||||
for (port = agg->lag_ports; port;
|
||||
port = port->next_port_in_aggregator) {
|
||||
if (netif_running(port->slave->dev) &&
|
||||
netif_carrier_ok(port->slave->dev))
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -1610,7 +1631,7 @@ static void ad_agg_selection_logic(struct aggregator *agg,
|
|||
|
||||
agg->is_active = 0;
|
||||
|
||||
if (agg->num_of_ports && agg_device_up(agg))
|
||||
if (__agg_active_ports(agg) && agg_device_up(agg))
|
||||
best = ad_agg_selection_test(best, agg);
|
||||
}
|
||||
|
||||
|
@ -1622,7 +1643,7 @@ static void ad_agg_selection_logic(struct aggregator *agg,
|
|||
* answering partner.
|
||||
*/
|
||||
if (active && active->lag_ports &&
|
||||
active->lag_ports->is_enabled &&
|
||||
__agg_active_ports(active) &&
|
||||
(__agg_has_partner(active) ||
|
||||
(!__agg_has_partner(active) &&
|
||||
!__agg_has_partner(best)))) {
|
||||
|
@ -2133,7 +2154,7 @@ void bond_3ad_unbind_slave(struct slave *slave)
|
|||
else
|
||||
temp_aggregator->lag_ports = temp_port->next_port_in_aggregator;
|
||||
temp_aggregator->num_of_ports--;
|
||||
if (temp_aggregator->num_of_ports == 0) {
|
||||
if (__agg_active_ports(temp_aggregator) == 0) {
|
||||
select_new_active_agg = temp_aggregator->is_active;
|
||||
ad_clear_agg(temp_aggregator);
|
||||
if (select_new_active_agg) {
|
||||
|
@ -2432,7 +2453,9 @@ void bond_3ad_adapter_speed_duplex_changed(struct slave *slave)
|
|||
*/
|
||||
void bond_3ad_handle_link_change(struct slave *slave, char link)
|
||||
{
|
||||
struct aggregator *agg;
|
||||
struct port *port;
|
||||
bool dummy;
|
||||
|
||||
port = &(SLAVE_AD_INFO(slave)->port);
|
||||
|
||||
|
@ -2459,6 +2482,9 @@ void bond_3ad_handle_link_change(struct slave *slave, char link)
|
|||
port->is_enabled = false;
|
||||
ad_update_actor_keys(port, true);
|
||||
}
|
||||
agg = __get_first_agg(port);
|
||||
ad_agg_selection_logic(agg, &dummy);
|
||||
|
||||
netdev_dbg(slave->bond->dev, "Port %d changed link status to %s\n",
|
||||
port->actor_port_number,
|
||||
link == BOND_LINK_UP ? "UP" : "DOWN");
|
||||
|
@ -2499,7 +2525,7 @@ int bond_3ad_set_carrier(struct bonding *bond)
|
|||
active = __get_active_agg(&(SLAVE_AD_INFO(first_slave)->aggregator));
|
||||
if (active) {
|
||||
/* are enough slaves available to consider link up? */
|
||||
if (active->num_of_ports < bond->params.min_links) {
|
||||
if (__agg_active_ports(active) < bond->params.min_links) {
|
||||
if (netif_carrier_ok(bond->dev)) {
|
||||
netif_carrier_off(bond->dev);
|
||||
goto out;
|
||||
|
|
|
@ -712,9 +712,10 @@ static int at91_poll_rx(struct net_device *dev, int quota)
|
|||
|
||||
/* upper group completed, look again in lower */
|
||||
if (priv->rx_next > get_mb_rx_low_last(priv) &&
|
||||
quota > 0 && mb > get_mb_rx_last(priv)) {
|
||||
mb > get_mb_rx_last(priv)) {
|
||||
priv->rx_next = get_mb_rx_first(priv);
|
||||
goto again;
|
||||
if (quota > 0)
|
||||
goto again;
|
||||
}
|
||||
|
||||
return received;
|
||||
|
|
|
@ -332,9 +332,23 @@ static void c_can_setup_tx_object(struct net_device *dev, int iface,
|
|||
|
||||
priv->write_reg(priv, C_CAN_IFACE(MSGCTRL_REG, iface), ctrl);
|
||||
|
||||
for (i = 0; i < frame->can_dlc; i += 2) {
|
||||
priv->write_reg(priv, C_CAN_IFACE(DATA1_REG, iface) + i / 2,
|
||||
frame->data[i] | (frame->data[i + 1] << 8));
|
||||
if (priv->type == BOSCH_D_CAN) {
|
||||
u32 data = 0, dreg = C_CAN_IFACE(DATA1_REG, iface);
|
||||
|
||||
for (i = 0; i < frame->can_dlc; i += 4, dreg += 2) {
|
||||
data = (u32)frame->data[i];
|
||||
data |= (u32)frame->data[i + 1] << 8;
|
||||
data |= (u32)frame->data[i + 2] << 16;
|
||||
data |= (u32)frame->data[i + 3] << 24;
|
||||
priv->write_reg32(priv, dreg, data);
|
||||
}
|
||||
} else {
|
||||
for (i = 0; i < frame->can_dlc; i += 2) {
|
||||
priv->write_reg(priv,
|
||||
C_CAN_IFACE(DATA1_REG, iface) + i / 2,
|
||||
frame->data[i] |
|
||||
(frame->data[i + 1] << 8));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -402,10 +416,20 @@ static int c_can_read_msg_object(struct net_device *dev, int iface, u32 ctrl)
|
|||
} else {
|
||||
int i, dreg = C_CAN_IFACE(DATA1_REG, iface);
|
||||
|
||||
for (i = 0; i < frame->can_dlc; i += 2, dreg ++) {
|
||||
data = priv->read_reg(priv, dreg);
|
||||
frame->data[i] = data;
|
||||
frame->data[i + 1] = data >> 8;
|
||||
if (priv->type == BOSCH_D_CAN) {
|
||||
for (i = 0; i < frame->can_dlc; i += 4, dreg += 2) {
|
||||
data = priv->read_reg32(priv, dreg);
|
||||
frame->data[i] = data;
|
||||
frame->data[i + 1] = data >> 8;
|
||||
frame->data[i + 2] = data >> 16;
|
||||
frame->data[i + 3] = data >> 24;
|
||||
}
|
||||
} else {
|
||||
for (i = 0; i < frame->can_dlc; i += 2, dreg++) {
|
||||
data = priv->read_reg(priv, dreg);
|
||||
frame->data[i] = data;
|
||||
frame->data[i + 1] = data >> 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -798,6 +798,9 @@ static int can_validate(struct nlattr *tb[], struct nlattr *data[])
|
|||
* - control mode with CAN_CTRLMODE_FD set
|
||||
*/
|
||||
|
||||
if (!data)
|
||||
return 0;
|
||||
|
||||
if (data[IFLA_CAN_CTRLMODE]) {
|
||||
struct can_ctrlmode *cm = nla_data(data[IFLA_CAN_CTRLMODE]);
|
||||
|
||||
|
@ -1008,6 +1011,11 @@ static int can_newlink(struct net *src_net, struct net_device *dev,
|
|||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
static void can_dellink(struct net_device *dev, struct list_head *head)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
static struct rtnl_link_ops can_link_ops __read_mostly = {
|
||||
.kind = "can",
|
||||
.maxtype = IFLA_CAN_MAX,
|
||||
|
@ -1016,6 +1024,7 @@ static struct rtnl_link_ops can_link_ops __read_mostly = {
|
|||
.validate = can_validate,
|
||||
.newlink = can_newlink,
|
||||
.changelink = can_changelink,
|
||||
.dellink = can_dellink,
|
||||
.get_size = can_get_size,
|
||||
.fill_info = can_fill_info,
|
||||
.get_xstats_size = can_get_xstats_size,
|
||||
|
|
|
@ -16,7 +16,8 @@ config CAN_ESD_USB2
|
|||
config CAN_GS_USB
|
||||
tristate "Geschwister Schneider UG interfaces"
|
||||
---help---
|
||||
This driver supports the Geschwister Schneider USB/CAN devices.
|
||||
This driver supports the Geschwister Schneider and bytewerk.org
|
||||
candleLight USB CAN interfaces USB/CAN devices
|
||||
If unsure choose N,
|
||||
choose Y for built in support,
|
||||
M to compile as module (module will be named: gs_usb).
|
||||
|
@ -46,6 +47,8 @@ config CAN_KVASER_USB
|
|||
- Kvaser USBcan R
|
||||
- Kvaser Leaf Light v2
|
||||
- Kvaser Mini PCI Express HS
|
||||
- Kvaser Mini PCI Express 2xHS
|
||||
- Kvaser USBcan Light 2xHS
|
||||
- Kvaser USBcan II HS/HS
|
||||
- Kvaser USBcan II HS/LS
|
||||
- Kvaser USBcan Rugged ("USBcan Rev B")
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
/* CAN driver for Geschwister Schneider USB/CAN devices.
|
||||
/* CAN driver for Geschwister Schneider USB/CAN devices
|
||||
* and bytewerk.org candleLight USB CAN interfaces.
|
||||
*
|
||||
* Copyright (C) 2013 Geschwister Schneider Technologie-,
|
||||
* Copyright (C) 2013-2016 Geschwister Schneider Technologie-,
|
||||
* Entwicklungs- und Vertriebs UG (Haftungsbeschränkt).
|
||||
* Copyright (C) 2016 Hubert Denkmair
|
||||
*
|
||||
* Many thanks to all socketcan devs!
|
||||
*
|
||||
|
@ -29,6 +31,9 @@
|
|||
#define USB_GSUSB_1_VENDOR_ID 0x1d50
|
||||
#define USB_GSUSB_1_PRODUCT_ID 0x606f
|
||||
|
||||
#define USB_CANDLELIGHT_VENDOR_ID 0x1209
|
||||
#define USB_CANDLELIGHT_PRODUCT_ID 0x2323
|
||||
|
||||
#define GSUSB_ENDPOINT_IN 1
|
||||
#define GSUSB_ENDPOINT_OUT 2
|
||||
|
||||
|
@ -952,6 +957,8 @@ static void gs_usb_disconnect(struct usb_interface *intf)
|
|||
static const struct usb_device_id gs_usb_table[] = {
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(USB_GSUSB_1_VENDOR_ID,
|
||||
USB_GSUSB_1_PRODUCT_ID, 0) },
|
||||
{ USB_DEVICE_INTERFACE_NUMBER(USB_CANDLELIGHT_VENDOR_ID,
|
||||
USB_CANDLELIGHT_PRODUCT_ID, 0) },
|
||||
{} /* Terminating entry */
|
||||
};
|
||||
|
||||
|
@ -969,5 +976,6 @@ module_usb_driver(gs_usb_driver);
|
|||
MODULE_AUTHOR("Maximilian Schneider <mws@schneidersoft.net>");
|
||||
MODULE_DESCRIPTION(
|
||||
"Socket CAN device driver for Geschwister Schneider Technologie-, "
|
||||
"Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces.");
|
||||
"Entwicklungs- und Vertriebs UG. USB2.0 to CAN interfaces\n"
|
||||
"and bytewerk.org candleLight USB CAN interfaces.");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
|
|
@ -59,11 +59,14 @@
|
|||
#define USB_CAN_R_PRODUCT_ID 39
|
||||
#define USB_LEAF_LITE_V2_PRODUCT_ID 288
|
||||
#define USB_MINI_PCIE_HS_PRODUCT_ID 289
|
||||
#define USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID 290
|
||||
#define USB_USBCAN_LIGHT_2HS_PRODUCT_ID 291
|
||||
#define USB_MINI_PCIE_2HS_PRODUCT_ID 292
|
||||
|
||||
static inline bool kvaser_is_leaf(const struct usb_device_id *id)
|
||||
{
|
||||
return id->idProduct >= USB_LEAF_DEVEL_PRODUCT_ID &&
|
||||
id->idProduct <= USB_MINI_PCIE_HS_PRODUCT_ID;
|
||||
id->idProduct <= USB_MINI_PCIE_2HS_PRODUCT_ID;
|
||||
}
|
||||
|
||||
/* Kvaser USBCan-II devices */
|
||||
|
@ -537,6 +540,9 @@ static const struct usb_device_id kvaser_usb_table[] = {
|
|||
.driver_info = KVASER_HAS_TXRX_ERRORS },
|
||||
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LITE_V2_PRODUCT_ID) },
|
||||
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_HS_PRODUCT_ID) },
|
||||
{ USB_DEVICE(KVASER_VENDOR_ID, USB_LEAF_LIGHT_HS_V2_OEM_PRODUCT_ID) },
|
||||
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN_LIGHT_2HS_PRODUCT_ID) },
|
||||
{ USB_DEVICE(KVASER_VENDOR_ID, USB_MINI_PCIE_2HS_PRODUCT_ID) },
|
||||
|
||||
/* USBCANII family IDs */
|
||||
{ USB_DEVICE(KVASER_VENDOR_ID, USB_USBCAN2_PRODUCT_ID),
|
||||
|
|
|
@ -509,8 +509,8 @@ static int au1000_mii_probe(struct net_device *dev)
|
|||
* on the current MAC's MII bus
|
||||
*/
|
||||
for (phy_addr = 0; phy_addr < PHY_MAX_ADDR; phy_addr++)
|
||||
if (mdiobus_get_phy(aup->mii_bus, aup->phy_addr)) {
|
||||
phydev = mdiobus_get_phy(aup->mii_bus, aup->phy_addr);
|
||||
if (mdiobus_get_phy(aup->mii_bus, phy_addr)) {
|
||||
phydev = mdiobus_get_phy(aup->mii_bus, phy_addr);
|
||||
if (!aup->phy_search_highest_addr)
|
||||
/* break out with first one found */
|
||||
break;
|
||||
|
|
|
@ -96,10 +96,6 @@ struct alx_priv {
|
|||
unsigned int rx_ringsz;
|
||||
unsigned int rxbuf_size;
|
||||
|
||||
struct page *rx_page;
|
||||
unsigned int rx_page_offset;
|
||||
unsigned int rx_frag_size;
|
||||
|
||||
struct napi_struct napi;
|
||||
struct alx_tx_queue txq;
|
||||
struct alx_rx_queue rxq;
|
||||
|
|
|
@ -70,35 +70,6 @@ static void alx_free_txbuf(struct alx_priv *alx, int entry)
|
|||
}
|
||||
}
|
||||
|
||||
static struct sk_buff *alx_alloc_skb(struct alx_priv *alx, gfp_t gfp)
|
||||
{
|
||||
struct sk_buff *skb;
|
||||
struct page *page;
|
||||
|
||||
if (alx->rx_frag_size > PAGE_SIZE)
|
||||
return __netdev_alloc_skb(alx->dev, alx->rxbuf_size, gfp);
|
||||
|
||||
page = alx->rx_page;
|
||||
if (!page) {
|
||||
alx->rx_page = page = alloc_page(gfp);
|
||||
if (unlikely(!page))
|
||||
return NULL;
|
||||
alx->rx_page_offset = 0;
|
||||
}
|
||||
|
||||
skb = build_skb(page_address(page) + alx->rx_page_offset,
|
||||
alx->rx_frag_size);
|
||||
if (likely(skb)) {
|
||||
alx->rx_page_offset += alx->rx_frag_size;
|
||||
if (alx->rx_page_offset >= PAGE_SIZE)
|
||||
alx->rx_page = NULL;
|
||||
else
|
||||
get_page(page);
|
||||
}
|
||||
return skb;
|
||||
}
|
||||
|
||||
|
||||
static int alx_refill_rx_ring(struct alx_priv *alx, gfp_t gfp)
|
||||
{
|
||||
struct alx_rx_queue *rxq = &alx->rxq;
|
||||
|
@ -115,9 +86,22 @@ static int alx_refill_rx_ring(struct alx_priv *alx, gfp_t gfp)
|
|||
while (!cur_buf->skb && next != rxq->read_idx) {
|
||||
struct alx_rfd *rfd = &rxq->rfd[cur];
|
||||
|
||||
skb = alx_alloc_skb(alx, gfp);
|
||||
/*
|
||||
* When DMA RX address is set to something like
|
||||
* 0x....fc0, it will be very likely to cause DMA
|
||||
* RFD overflow issue.
|
||||
*
|
||||
* To work around it, we apply rx skb with 64 bytes
|
||||
* longer space, and offset the address whenever
|
||||
* 0x....fc0 is detected.
|
||||
*/
|
||||
skb = __netdev_alloc_skb(alx->dev, alx->rxbuf_size + 64, gfp);
|
||||
if (!skb)
|
||||
break;
|
||||
|
||||
if (((unsigned long)skb->data & 0xfff) == 0xfc0)
|
||||
skb_reserve(skb, 64);
|
||||
|
||||
dma = dma_map_single(&alx->hw.pdev->dev,
|
||||
skb->data, alx->rxbuf_size,
|
||||
DMA_FROM_DEVICE);
|
||||
|
@ -153,7 +137,6 @@ static int alx_refill_rx_ring(struct alx_priv *alx, gfp_t gfp)
|
|||
alx_write_mem16(&alx->hw, ALX_RFD_PIDX, cur);
|
||||
}
|
||||
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
|
@ -622,11 +605,6 @@ static void alx_free_rings(struct alx_priv *alx)
|
|||
kfree(alx->txq.bufs);
|
||||
kfree(alx->rxq.bufs);
|
||||
|
||||
if (alx->rx_page) {
|
||||
put_page(alx->rx_page);
|
||||
alx->rx_page = NULL;
|
||||
}
|
||||
|
||||
dma_free_coherent(&alx->hw.pdev->dev,
|
||||
alx->descmem.size,
|
||||
alx->descmem.virt,
|
||||
|
@ -681,7 +659,6 @@ static int alx_request_irq(struct alx_priv *alx)
|
|||
alx->dev->name, alx);
|
||||
if (!err)
|
||||
goto out;
|
||||
|
||||
/* fall back to legacy interrupt */
|
||||
pci_disable_msi(alx->hw.pdev);
|
||||
}
|
||||
|
@ -725,7 +702,6 @@ static int alx_init_sw(struct alx_priv *alx)
|
|||
struct pci_dev *pdev = alx->hw.pdev;
|
||||
struct alx_hw *hw = &alx->hw;
|
||||
int err;
|
||||
unsigned int head_size;
|
||||
|
||||
err = alx_identify_hw(alx);
|
||||
if (err) {
|
||||
|
@ -741,12 +717,7 @@ static int alx_init_sw(struct alx_priv *alx)
|
|||
|
||||
hw->smb_timer = 400;
|
||||
hw->mtu = alx->dev->mtu;
|
||||
|
||||
alx->rxbuf_size = ALX_MAX_FRAME_LEN(hw->mtu);
|
||||
head_size = SKB_DATA_ALIGN(alx->rxbuf_size + NET_SKB_PAD) +
|
||||
SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
|
||||
alx->rx_frag_size = roundup_pow_of_two(head_size);
|
||||
|
||||
alx->tx_ringsz = 256;
|
||||
alx->rx_ringsz = 512;
|
||||
hw->imt = 200;
|
||||
|
@ -848,7 +819,6 @@ static int alx_change_mtu(struct net_device *netdev, int mtu)
|
|||
{
|
||||
struct alx_priv *alx = netdev_priv(netdev);
|
||||
int max_frame = ALX_MAX_FRAME_LEN(mtu);
|
||||
unsigned int head_size;
|
||||
|
||||
if ((max_frame < ALX_MIN_FRAME_SIZE) ||
|
||||
(max_frame > ALX_MAX_FRAME_SIZE))
|
||||
|
@ -860,9 +830,6 @@ static int alx_change_mtu(struct net_device *netdev, int mtu)
|
|||
netdev->mtu = mtu;
|
||||
alx->hw.mtu = mtu;
|
||||
alx->rxbuf_size = max(max_frame, ALX_DEF_RXBUF_SIZE);
|
||||
head_size = SKB_DATA_ALIGN(alx->rxbuf_size + NET_SKB_PAD) +
|
||||
SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
|
||||
alx->rx_frag_size = roundup_pow_of_two(head_size);
|
||||
netdev_update_features(netdev);
|
||||
if (netif_running(netdev))
|
||||
alx_reinit(alx);
|
||||
|
|
|
@ -267,15 +267,16 @@ static void bgmac_dma_tx_free(struct bgmac *bgmac, struct bgmac_dma_ring *ring)
|
|||
while (ring->start != ring->end) {
|
||||
int slot_idx = ring->start % BGMAC_TX_RING_SLOTS;
|
||||
struct bgmac_slot_info *slot = &ring->slots[slot_idx];
|
||||
u32 ctl1;
|
||||
u32 ctl0, ctl1;
|
||||
int len;
|
||||
|
||||
if (slot_idx == empty_slot)
|
||||
break;
|
||||
|
||||
ctl0 = le32_to_cpu(ring->cpu_base[slot_idx].ctl0);
|
||||
ctl1 = le32_to_cpu(ring->cpu_base[slot_idx].ctl1);
|
||||
len = ctl1 & BGMAC_DESC_CTL1_LEN;
|
||||
if (ctl1 & BGMAC_DESC_CTL0_SOF)
|
||||
if (ctl0 & BGMAC_DESC_CTL0_SOF)
|
||||
/* Unmap no longer used buffer */
|
||||
dma_unmap_single(dma_dev, slot->dma_addr, len,
|
||||
DMA_TO_DEVICE);
|
||||
|
@ -1312,7 +1313,8 @@ static int bgmac_open(struct net_device *net_dev)
|
|||
|
||||
phy_start(bgmac->phy_dev);
|
||||
|
||||
netif_carrier_on(net_dev);
|
||||
netif_start_queue(net_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -499,6 +499,7 @@ static void nic_tx_channel_cfg(struct nicpf *nic, u8 vnic,
|
|||
u32 rr_quantum;
|
||||
u8 sq_idx = sq->sq_num;
|
||||
u8 pqs_vnic;
|
||||
int svf;
|
||||
|
||||
if (sq->sqs_mode)
|
||||
pqs_vnic = nic->pqs_vf[vnic];
|
||||
|
@ -511,10 +512,19 @@ static void nic_tx_channel_cfg(struct nicpf *nic, u8 vnic,
|
|||
/* 24 bytes for FCS, IPG and preamble */
|
||||
rr_quantum = ((NIC_HW_MAX_FRS + 24) / 4);
|
||||
|
||||
tl4 = (lmac * NIC_TL4_PER_LMAC) + (bgx * NIC_TL4_PER_BGX);
|
||||
if (!sq->sqs_mode) {
|
||||
tl4 = (lmac * NIC_TL4_PER_LMAC) + (bgx * NIC_TL4_PER_BGX);
|
||||
} else {
|
||||
for (svf = 0; svf < MAX_SQS_PER_VF; svf++) {
|
||||
if (nic->vf_sqs[pqs_vnic][svf] == vnic)
|
||||
break;
|
||||
}
|
||||
tl4 = (MAX_LMAC_PER_BGX * NIC_TL4_PER_LMAC);
|
||||
tl4 += (lmac * NIC_TL4_PER_LMAC * MAX_SQS_PER_VF);
|
||||
tl4 += (svf * NIC_TL4_PER_LMAC);
|
||||
tl4 += (bgx * NIC_TL4_PER_BGX);
|
||||
}
|
||||
tl4 += sq_idx;
|
||||
if (sq->sqs_mode)
|
||||
tl4 += vnic * 8;
|
||||
|
||||
tl3 = tl4 / (NIC_MAX_TL4 / NIC_MAX_TL3);
|
||||
nic_reg_write(nic, NIC_PF_QSET_0_127_SQ_0_7_CFG2 |
|
||||
|
|
|
@ -551,7 +551,9 @@ static int bgx_xaui_check_link(struct lmac *lmac)
|
|||
}
|
||||
|
||||
/* Clear rcvflt bit (latching high) and read it back */
|
||||
bgx_reg_modify(bgx, lmacid, BGX_SPUX_STATUS2, SPU_STATUS2_RCVFLT);
|
||||
if (bgx_reg_read(bgx, lmacid, BGX_SPUX_STATUS2) & SPU_STATUS2_RCVFLT)
|
||||
bgx_reg_modify(bgx, lmacid,
|
||||
BGX_SPUX_STATUS2, SPU_STATUS2_RCVFLT);
|
||||
if (bgx_reg_read(bgx, lmacid, BGX_SPUX_STATUS2) & SPU_STATUS2_RCVFLT) {
|
||||
dev_err(&bgx->pdev->dev, "Receive fault, retry training\n");
|
||||
if (bgx->use_training) {
|
||||
|
@ -570,13 +572,6 @@ static int bgx_xaui_check_link(struct lmac *lmac)
|
|||
return -1;
|
||||
}
|
||||
|
||||
/* Wait for MAC RX to be ready */
|
||||
if (bgx_poll_reg(bgx, lmacid, BGX_SMUX_RX_CTL,
|
||||
SMU_RX_CTL_STATUS, true)) {
|
||||
dev_err(&bgx->pdev->dev, "SMU RX link not okay\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Wait for BGX RX to be idle */
|
||||
if (bgx_poll_reg(bgx, lmacid, BGX_SMUX_CTL, SMU_CTL_RX_IDLE, false)) {
|
||||
dev_err(&bgx->pdev->dev, "SMU RX not idle\n");
|
||||
|
@ -589,29 +584,30 @@ static int bgx_xaui_check_link(struct lmac *lmac)
|
|||
return -1;
|
||||
}
|
||||
|
||||
if (bgx_reg_read(bgx, lmacid, BGX_SPUX_STATUS2) & SPU_STATUS2_RCVFLT) {
|
||||
dev_err(&bgx->pdev->dev, "Receive fault\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Receive link is latching low. Force it high and verify it */
|
||||
bgx_reg_modify(bgx, lmacid, BGX_SPUX_STATUS1, SPU_STATUS1_RCV_LNK);
|
||||
if (bgx_poll_reg(bgx, lmacid, BGX_SPUX_STATUS1,
|
||||
SPU_STATUS1_RCV_LNK, false)) {
|
||||
dev_err(&bgx->pdev->dev, "SPU receive link down\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Clear receive packet disable */
|
||||
cfg = bgx_reg_read(bgx, lmacid, BGX_SPUX_MISC_CONTROL);
|
||||
cfg &= ~SPU_MISC_CTL_RX_DIS;
|
||||
bgx_reg_write(bgx, lmacid, BGX_SPUX_MISC_CONTROL, cfg);
|
||||
return 0;
|
||||
|
||||
/* Check for MAC RX faults */
|
||||
cfg = bgx_reg_read(bgx, lmacid, BGX_SMUX_RX_CTL);
|
||||
/* 0 - Link is okay, 1 - Local fault, 2 - Remote fault */
|
||||
cfg &= SMU_RX_CTL_STATUS;
|
||||
if (!cfg)
|
||||
return 0;
|
||||
|
||||
/* Rx local/remote fault seen.
|
||||
* Do lmac reinit to see if condition recovers
|
||||
*/
|
||||
bgx_lmac_xaui_init(bgx, lmacid, bgx->lmac_type);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void bgx_poll_for_link(struct work_struct *work)
|
||||
{
|
||||
struct lmac *lmac;
|
||||
u64 link;
|
||||
u64 spu_link, smu_link;
|
||||
|
||||
lmac = container_of(work, struct lmac, dwork.work);
|
||||
|
||||
|
@ -621,8 +617,11 @@ static void bgx_poll_for_link(struct work_struct *work)
|
|||
bgx_poll_reg(lmac->bgx, lmac->lmacid, BGX_SPUX_STATUS1,
|
||||
SPU_STATUS1_RCV_LNK, false);
|
||||
|
||||
link = bgx_reg_read(lmac->bgx, lmac->lmacid, BGX_SPUX_STATUS1);
|
||||
if (link & SPU_STATUS1_RCV_LNK) {
|
||||
spu_link = bgx_reg_read(lmac->bgx, lmac->lmacid, BGX_SPUX_STATUS1);
|
||||
smu_link = bgx_reg_read(lmac->bgx, lmac->lmacid, BGX_SMUX_RX_CTL);
|
||||
|
||||
if ((spu_link & SPU_STATUS1_RCV_LNK) &&
|
||||
!(smu_link & SMU_RX_CTL_STATUS)) {
|
||||
lmac->link_up = 1;
|
||||
if (lmac->bgx->lmac_type == BGX_MODE_XLAUI)
|
||||
lmac->last_speed = 40000;
|
||||
|
@ -636,9 +635,15 @@ static void bgx_poll_for_link(struct work_struct *work)
|
|||
}
|
||||
|
||||
if (lmac->last_link != lmac->link_up) {
|
||||
if (lmac->link_up) {
|
||||
if (bgx_xaui_check_link(lmac)) {
|
||||
/* Errors, clear link_up state */
|
||||
lmac->link_up = 0;
|
||||
lmac->last_speed = SPEED_UNKNOWN;
|
||||
lmac->last_duplex = DUPLEX_UNKNOWN;
|
||||
}
|
||||
}
|
||||
lmac->last_link = lmac->link_up;
|
||||
if (lmac->link_up)
|
||||
bgx_xaui_check_link(lmac);
|
||||
}
|
||||
|
||||
queue_delayed_work(lmac->check_link, &lmac->dwork, HZ * 2);
|
||||
|
@ -710,7 +715,7 @@ static int bgx_lmac_enable(struct bgx *bgx, u8 lmacid)
|
|||
static void bgx_lmac_disable(struct bgx *bgx, u8 lmacid)
|
||||
{
|
||||
struct lmac *lmac;
|
||||
u64 cmrx_cfg;
|
||||
u64 cfg;
|
||||
|
||||
lmac = &bgx->lmac[lmacid];
|
||||
if (lmac->check_link) {
|
||||
|
@ -719,9 +724,33 @@ static void bgx_lmac_disable(struct bgx *bgx, u8 lmacid)
|
|||
destroy_workqueue(lmac->check_link);
|
||||
}
|
||||
|
||||
cmrx_cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);
|
||||
cmrx_cfg &= ~(1 << 15);
|
||||
bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cmrx_cfg);
|
||||
/* Disable packet reception */
|
||||
cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);
|
||||
cfg &= ~CMR_PKT_RX_EN;
|
||||
bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cfg);
|
||||
|
||||
/* Give chance for Rx/Tx FIFO to get drained */
|
||||
bgx_poll_reg(bgx, lmacid, BGX_CMRX_RX_FIFO_LEN, (u64)0x1FFF, true);
|
||||
bgx_poll_reg(bgx, lmacid, BGX_CMRX_TX_FIFO_LEN, (u64)0x3FFF, true);
|
||||
|
||||
/* Disable packet transmission */
|
||||
cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);
|
||||
cfg &= ~CMR_PKT_TX_EN;
|
||||
bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cfg);
|
||||
|
||||
/* Disable serdes lanes */
|
||||
if (!lmac->is_sgmii)
|
||||
bgx_reg_modify(bgx, lmacid,
|
||||
BGX_SPUX_CONTROL1, SPU_CTL_LOW_POWER);
|
||||
else
|
||||
bgx_reg_modify(bgx, lmacid,
|
||||
BGX_GMP_PCS_MRX_CTL, PCS_MRX_CTL_PWR_DN);
|
||||
|
||||
/* Disable LMAC */
|
||||
cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);
|
||||
cfg &= ~CMR_EN;
|
||||
bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cfg);
|
||||
|
||||
bgx_flush_dmac_addrs(bgx, lmacid);
|
||||
|
||||
if ((bgx->lmac_type != BGX_MODE_XFI) &&
|
||||
|
|
|
@ -41,6 +41,7 @@
|
|||
#define BGX_CMRX_RX_STAT10 0xC0
|
||||
#define BGX_CMRX_RX_BP_DROP 0xC8
|
||||
#define BGX_CMRX_RX_DMAC_CTL 0x0E8
|
||||
#define BGX_CMRX_RX_FIFO_LEN 0x108
|
||||
#define BGX_CMR_RX_DMACX_CAM 0x200
|
||||
#define RX_DMACX_CAM_EN BIT_ULL(48)
|
||||
#define RX_DMACX_CAM_LMACID(x) (x << 49)
|
||||
|
@ -50,6 +51,7 @@
|
|||
#define BGX_CMR_CHAN_MSK_AND 0x450
|
||||
#define BGX_CMR_BIST_STATUS 0x460
|
||||
#define BGX_CMR_RX_LMACS 0x468
|
||||
#define BGX_CMRX_TX_FIFO_LEN 0x518
|
||||
#define BGX_CMRX_TX_STAT0 0x600
|
||||
#define BGX_CMRX_TX_STAT1 0x608
|
||||
#define BGX_CMRX_TX_STAT2 0x610
|
||||
|
|
|
@ -2121,7 +2121,7 @@ static void handle_error_info_rsp(union ibmvnic_crq *crq,
|
|||
struct ibmvnic_adapter *adapter)
|
||||
{
|
||||
struct device *dev = &adapter->vdev->dev;
|
||||
struct ibmvnic_error_buff *error_buff;
|
||||
struct ibmvnic_error_buff *error_buff, *tmp;
|
||||
unsigned long flags;
|
||||
bool found = false;
|
||||
int i;
|
||||
|
@ -2133,7 +2133,7 @@ static void handle_error_info_rsp(union ibmvnic_crq *crq,
|
|||
}
|
||||
|
||||
spin_lock_irqsave(&adapter->error_list_lock, flags);
|
||||
list_for_each_entry(error_buff, &adapter->errors, list)
|
||||
list_for_each_entry_safe(error_buff, tmp, &adapter->errors, list)
|
||||
if (error_buff->error_id == crq->request_error_rsp.error_id) {
|
||||
found = true;
|
||||
list_del(&error_buff->list);
|
||||
|
@ -3141,14 +3141,14 @@ static void handle_request_ras_comp_num_rsp(union ibmvnic_crq *crq,
|
|||
|
||||
static void ibmvnic_free_inflight(struct ibmvnic_adapter *adapter)
|
||||
{
|
||||
struct ibmvnic_inflight_cmd *inflight_cmd;
|
||||
struct ibmvnic_inflight_cmd *inflight_cmd, *tmp1;
|
||||
struct device *dev = &adapter->vdev->dev;
|
||||
struct ibmvnic_error_buff *error_buff;
|
||||
struct ibmvnic_error_buff *error_buff, *tmp2;
|
||||
unsigned long flags;
|
||||
unsigned long flags2;
|
||||
|
||||
spin_lock_irqsave(&adapter->inflight_lock, flags);
|
||||
list_for_each_entry(inflight_cmd, &adapter->inflight, list) {
|
||||
list_for_each_entry_safe(inflight_cmd, tmp1, &adapter->inflight, list) {
|
||||
switch (inflight_cmd->crq.generic.cmd) {
|
||||
case LOGIN:
|
||||
dma_unmap_single(dev, adapter->login_buf_token,
|
||||
|
@ -3165,8 +3165,8 @@ static void ibmvnic_free_inflight(struct ibmvnic_adapter *adapter)
|
|||
break;
|
||||
case REQUEST_ERROR_INFO:
|
||||
spin_lock_irqsave(&adapter->error_list_lock, flags2);
|
||||
list_for_each_entry(error_buff, &adapter->errors,
|
||||
list) {
|
||||
list_for_each_entry_safe(error_buff, tmp2,
|
||||
&adapter->errors, list) {
|
||||
dma_unmap_single(dev, error_buff->dma,
|
||||
error_buff->len,
|
||||
DMA_FROM_DEVICE);
|
||||
|
|
|
@ -154,6 +154,16 @@ void __ew32(struct e1000_hw *hw, unsigned long reg, u32 val)
|
|||
writel(val, hw->hw_addr + reg);
|
||||
}
|
||||
|
||||
static bool e1000e_vlan_used(struct e1000_adapter *adapter)
|
||||
{
|
||||
u16 vid;
|
||||
|
||||
for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* e1000_regdump - register printout routine
|
||||
* @hw: pointer to the HW structure
|
||||
|
@ -2789,7 +2799,7 @@ static void e1000e_vlan_filter_enable(struct e1000_adapter *adapter)
|
|||
}
|
||||
|
||||
/**
|
||||
* e1000e_vlan_strip_enable - helper to disable HW VLAN stripping
|
||||
* e1000e_vlan_strip_disable - helper to disable HW VLAN stripping
|
||||
* @adapter: board private structure to initialize
|
||||
**/
|
||||
static void e1000e_vlan_strip_disable(struct e1000_adapter *adapter)
|
||||
|
@ -3443,7 +3453,8 @@ static void e1000e_set_rx_mode(struct net_device *netdev)
|
|||
|
||||
ew32(RCTL, rctl);
|
||||
|
||||
if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX)
|
||||
if (netdev->features & NETIF_F_HW_VLAN_CTAG_RX ||
|
||||
e1000e_vlan_used(adapter))
|
||||
e1000e_vlan_strip_enable(adapter);
|
||||
else
|
||||
e1000e_vlan_strip_disable(adapter);
|
||||
|
|
|
@ -481,20 +481,23 @@ static inline void mtk_rx_get_desc(struct mtk_rx_dma *rxd,
|
|||
/* the qdma core needs scratch memory to be setup */
|
||||
static int mtk_init_fq_dma(struct mtk_eth *eth)
|
||||
{
|
||||
dma_addr_t phy_ring_head, phy_ring_tail;
|
||||
dma_addr_t phy_ring_tail;
|
||||
int cnt = MTK_DMA_SIZE;
|
||||
dma_addr_t dma_addr;
|
||||
int i;
|
||||
|
||||
eth->scratch_ring = dma_alloc_coherent(eth->dev,
|
||||
cnt * sizeof(struct mtk_tx_dma),
|
||||
&phy_ring_head,
|
||||
ð->phy_scratch_ring,
|
||||
GFP_ATOMIC | __GFP_ZERO);
|
||||
if (unlikely(!eth->scratch_ring))
|
||||
return -ENOMEM;
|
||||
|
||||
eth->scratch_head = kcalloc(cnt, MTK_QDMA_PAGE_SIZE,
|
||||
GFP_KERNEL);
|
||||
if (unlikely(!eth->scratch_head))
|
||||
return -ENOMEM;
|
||||
|
||||
dma_addr = dma_map_single(eth->dev,
|
||||
eth->scratch_head, cnt * MTK_QDMA_PAGE_SIZE,
|
||||
DMA_FROM_DEVICE);
|
||||
|
@ -502,19 +505,19 @@ static int mtk_init_fq_dma(struct mtk_eth *eth)
|
|||
return -ENOMEM;
|
||||
|
||||
memset(eth->scratch_ring, 0x0, sizeof(struct mtk_tx_dma) * cnt);
|
||||
phy_ring_tail = phy_ring_head +
|
||||
phy_ring_tail = eth->phy_scratch_ring +
|
||||
(sizeof(struct mtk_tx_dma) * (cnt - 1));
|
||||
|
||||
for (i = 0; i < cnt; i++) {
|
||||
eth->scratch_ring[i].txd1 =
|
||||
(dma_addr + (i * MTK_QDMA_PAGE_SIZE));
|
||||
if (i < cnt - 1)
|
||||
eth->scratch_ring[i].txd2 = (phy_ring_head +
|
||||
eth->scratch_ring[i].txd2 = (eth->phy_scratch_ring +
|
||||
((i + 1) * sizeof(struct mtk_tx_dma)));
|
||||
eth->scratch_ring[i].txd3 = TX_DMA_SDL(MTK_QDMA_PAGE_SIZE);
|
||||
}
|
||||
|
||||
mtk_w32(eth, phy_ring_head, MTK_QDMA_FQ_HEAD);
|
||||
mtk_w32(eth, eth->phy_scratch_ring, MTK_QDMA_FQ_HEAD);
|
||||
mtk_w32(eth, phy_ring_tail, MTK_QDMA_FQ_TAIL);
|
||||
mtk_w32(eth, (cnt << 16) | cnt, MTK_QDMA_FQ_CNT);
|
||||
mtk_w32(eth, MTK_QDMA_PAGE_SIZE << 16, MTK_QDMA_FQ_BLEN);
|
||||
|
@ -671,7 +674,7 @@ static int mtk_tx_map(struct sk_buff *skb, struct net_device *dev,
|
|||
|
||||
err_dma:
|
||||
do {
|
||||
tx_buf = mtk_desc_to_tx_buf(ring, txd);
|
||||
tx_buf = mtk_desc_to_tx_buf(ring, itxd);
|
||||
|
||||
/* unmap dma */
|
||||
mtk_tx_unmap(&dev->dev, tx_buf);
|
||||
|
@ -701,6 +704,20 @@ static inline int mtk_cal_txd_req(struct sk_buff *skb)
|
|||
return nfrags;
|
||||
}
|
||||
|
||||
static int mtk_queue_stopped(struct mtk_eth *eth)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MTK_MAC_COUNT; i++) {
|
||||
if (!eth->netdev[i])
|
||||
continue;
|
||||
if (netif_queue_stopped(eth->netdev[i]))
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mtk_wake_queue(struct mtk_eth *eth)
|
||||
{
|
||||
int i;
|
||||
|
@ -766,12 +783,9 @@ static int mtk_start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|||
if (mtk_tx_map(skb, dev, tx_num, ring, gso) < 0)
|
||||
goto drop;
|
||||
|
||||
if (unlikely(atomic_read(&ring->free_count) <= ring->thresh)) {
|
||||
if (unlikely(atomic_read(&ring->free_count) <= ring->thresh))
|
||||
mtk_stop_queue(eth);
|
||||
if (unlikely(atomic_read(&ring->free_count) >
|
||||
ring->thresh))
|
||||
mtk_wake_queue(eth);
|
||||
}
|
||||
|
||||
spin_unlock_irqrestore(ð->page_lock, flags);
|
||||
|
||||
return NETDEV_TX_OK;
|
||||
|
@ -826,6 +840,7 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
|
|||
DMA_FROM_DEVICE);
|
||||
if (unlikely(dma_mapping_error(&netdev->dev, dma_addr))) {
|
||||
skb_free_frag(new_data);
|
||||
netdev->stats.rx_dropped++;
|
||||
goto release_desc;
|
||||
}
|
||||
|
||||
|
@ -833,6 +848,7 @@ static int mtk_poll_rx(struct napi_struct *napi, int budget,
|
|||
skb = build_skb(data, ring->frag_size);
|
||||
if (unlikely(!skb)) {
|
||||
put_page(virt_to_head_page(new_data));
|
||||
netdev->stats.rx_dropped++;
|
||||
goto release_desc;
|
||||
}
|
||||
skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN);
|
||||
|
@ -921,7 +937,6 @@ static int mtk_poll_tx(struct mtk_eth *eth, int budget, bool *tx_again)
|
|||
}
|
||||
mtk_tx_unmap(eth->dev, tx_buf);
|
||||
|
||||
ring->last_free->txd2 = next_cpu;
|
||||
ring->last_free = desc;
|
||||
atomic_inc(&ring->free_count);
|
||||
|
||||
|
@ -946,7 +961,8 @@ static int mtk_poll_tx(struct mtk_eth *eth, int budget, bool *tx_again)
|
|||
if (!total)
|
||||
return 0;
|
||||
|
||||
if (atomic_read(&ring->free_count) > ring->thresh)
|
||||
if (mtk_queue_stopped(eth) &&
|
||||
(atomic_read(&ring->free_count) > ring->thresh))
|
||||
mtk_wake_queue(eth);
|
||||
|
||||
return total;
|
||||
|
@ -1027,9 +1043,8 @@ static int mtk_tx_alloc(struct mtk_eth *eth)
|
|||
|
||||
atomic_set(&ring->free_count, MTK_DMA_SIZE - 2);
|
||||
ring->next_free = &ring->dma[0];
|
||||
ring->last_free = &ring->dma[MTK_DMA_SIZE - 2];
|
||||
ring->thresh = max((unsigned long)MTK_DMA_SIZE >> 2,
|
||||
MAX_SKB_FRAGS);
|
||||
ring->last_free = &ring->dma[MTK_DMA_SIZE - 1];
|
||||
ring->thresh = MAX_SKB_FRAGS;
|
||||
|
||||
/* make sure that all changes to the dma ring are flushed before we
|
||||
* continue
|
||||
|
@ -1207,6 +1222,14 @@ static void mtk_dma_free(struct mtk_eth *eth)
|
|||
for (i = 0; i < MTK_MAC_COUNT; i++)
|
||||
if (eth->netdev[i])
|
||||
netdev_reset_queue(eth->netdev[i]);
|
||||
if (eth->scratch_ring) {
|
||||
dma_free_coherent(eth->dev,
|
||||
MTK_DMA_SIZE * sizeof(struct mtk_tx_dma),
|
||||
eth->scratch_ring,
|
||||
eth->phy_scratch_ring);
|
||||
eth->scratch_ring = NULL;
|
||||
eth->phy_scratch_ring = 0;
|
||||
}
|
||||
mtk_tx_clean(eth);
|
||||
mtk_rx_clean(eth);
|
||||
kfree(eth->scratch_head);
|
||||
|
@ -1269,7 +1292,7 @@ static int mtk_start_dma(struct mtk_eth *eth)
|
|||
mtk_w32(eth,
|
||||
MTK_TX_WB_DDONE | MTK_RX_DMA_EN | MTK_TX_DMA_EN |
|
||||
MTK_RX_2B_OFFSET | MTK_DMA_SIZE_16DWORDS |
|
||||
MTK_RX_BT_32DWORDS,
|
||||
MTK_RX_BT_32DWORDS | MTK_NDP_CO_PRO,
|
||||
MTK_QDMA_GLO_CFG);
|
||||
|
||||
return 0;
|
||||
|
@ -1383,7 +1406,7 @@ static int __init mtk_hw_init(struct mtk_eth *eth)
|
|||
|
||||
/* disable delay and normal interrupt */
|
||||
mtk_w32(eth, 0, MTK_QDMA_DELAY_INT);
|
||||
mtk_irq_disable(eth, MTK_TX_DONE_INT | MTK_RX_DONE_INT);
|
||||
mtk_irq_disable(eth, ~0);
|
||||
mtk_w32(eth, RST_GL_PSE, MTK_RST_GL);
|
||||
mtk_w32(eth, 0, MTK_RST_GL);
|
||||
|
||||
|
@ -1697,7 +1720,7 @@ static int mtk_add_mac(struct mtk_eth *eth, struct device_node *np)
|
|||
mac->hw_stats->reg_offset = id * MTK_STAT_OFFSET;
|
||||
|
||||
SET_NETDEV_DEV(eth->netdev[id], eth->dev);
|
||||
eth->netdev[id]->watchdog_timeo = HZ;
|
||||
eth->netdev[id]->watchdog_timeo = 5 * HZ;
|
||||
eth->netdev[id]->netdev_ops = &mtk_netdev_ops;
|
||||
eth->netdev[id]->base_addr = (unsigned long)eth->base;
|
||||
eth->netdev[id]->vlan_features = MTK_HW_FEATURES &
|
||||
|
|
|
@ -91,6 +91,7 @@
|
|||
#define MTK_QDMA_GLO_CFG 0x1A04
|
||||
#define MTK_RX_2B_OFFSET BIT(31)
|
||||
#define MTK_RX_BT_32DWORDS (3 << 11)
|
||||
#define MTK_NDP_CO_PRO BIT(10)
|
||||
#define MTK_TX_WB_DDONE BIT(6)
|
||||
#define MTK_DMA_SIZE_16DWORDS (2 << 4)
|
||||
#define MTK_RX_DMA_BUSY BIT(3)
|
||||
|
@ -357,6 +358,7 @@ struct mtk_rx_ring {
|
|||
* @rx_ring: Pointer to the memore holding info about the RX ring
|
||||
* @rx_napi: The NAPI struct
|
||||
* @scratch_ring: Newer SoCs need memory for a second HW managed TX ring
|
||||
* @phy_scratch_ring: physical address of scratch_ring
|
||||
* @scratch_head: The scratch memory that scratch_ring points to.
|
||||
* @clk_ethif: The ethif clock
|
||||
* @clk_esw: The switch clock
|
||||
|
@ -384,6 +386,7 @@ struct mtk_eth {
|
|||
struct mtk_rx_ring rx_ring;
|
||||
struct napi_struct rx_napi;
|
||||
struct mtk_tx_dma *scratch_ring;
|
||||
dma_addr_t phy_scratch_ring;
|
||||
void *scratch_head;
|
||||
struct clk *clk_ethif;
|
||||
struct clk *clk_esw;
|
||||
|
|
|
@ -2597,7 +2597,6 @@ int mlx4_cmd_use_events(struct mlx4_dev *dev)
|
|||
priv->cmd.free_head = 0;
|
||||
|
||||
sema_init(&priv->cmd.event_sem, priv->cmd.max_cmds);
|
||||
spin_lock_init(&priv->cmd.context_lock);
|
||||
|
||||
for (priv->cmd.token_mask = 1;
|
||||
priv->cmd.token_mask < priv->cmd.max_cmds;
|
||||
|
|
|
@ -406,14 +406,18 @@ static int mlx4_en_vlan_rx_add_vid(struct net_device *dev,
|
|||
mutex_lock(&mdev->state_lock);
|
||||
if (mdev->device_up && priv->port_up) {
|
||||
err = mlx4_SET_VLAN_FLTR(mdev->dev, priv);
|
||||
if (err)
|
||||
if (err) {
|
||||
en_err(priv, "Failed configuring VLAN filter\n");
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
if (mlx4_register_vlan(mdev->dev, priv->port, vid, &idx))
|
||||
en_dbg(HW, priv, "failed adding vlan %d\n", vid);
|
||||
mutex_unlock(&mdev->state_lock);
|
||||
err = mlx4_register_vlan(mdev->dev, priv->port, vid, &idx);
|
||||
if (err)
|
||||
en_dbg(HW, priv, "Failed adding vlan %d\n", vid);
|
||||
|
||||
return 0;
|
||||
out:
|
||||
mutex_unlock(&mdev->state_lock);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int mlx4_en_vlan_rx_kill_vid(struct net_device *dev,
|
||||
|
@ -421,7 +425,7 @@ static int mlx4_en_vlan_rx_kill_vid(struct net_device *dev,
|
|||
{
|
||||
struct mlx4_en_priv *priv = netdev_priv(dev);
|
||||
struct mlx4_en_dev *mdev = priv->mdev;
|
||||
int err;
|
||||
int err = 0;
|
||||
|
||||
en_dbg(HW, priv, "Killing VID:%d\n", vid);
|
||||
|
||||
|
@ -438,7 +442,7 @@ static int mlx4_en_vlan_rx_kill_vid(struct net_device *dev,
|
|||
}
|
||||
mutex_unlock(&mdev->state_lock);
|
||||
|
||||
return 0;
|
||||
return err;
|
||||
}
|
||||
|
||||
static void mlx4_en_u64_to_mac(unsigned char dst_mac[ETH_ALEN + 2], u64 src_mac)
|
||||
|
@ -2032,11 +2036,20 @@ err:
|
|||
return -ENOMEM;
|
||||
}
|
||||
|
||||
static void mlx4_en_shutdown(struct net_device *dev)
|
||||
{
|
||||
rtnl_lock();
|
||||
netif_device_detach(dev);
|
||||
mlx4_en_close(dev);
|
||||
rtnl_unlock();
|
||||
}
|
||||
|
||||
void mlx4_en_destroy_netdev(struct net_device *dev)
|
||||
{
|
||||
struct mlx4_en_priv *priv = netdev_priv(dev);
|
||||
struct mlx4_en_dev *mdev = priv->mdev;
|
||||
bool shutdown = mdev->dev->persist->interface_state &
|
||||
MLX4_INTERFACE_STATE_SHUTDOWN;
|
||||
|
||||
en_dbg(DRV, priv, "Destroying netdev on port:%d\n", priv->port);
|
||||
|
||||
|
@ -2044,7 +2057,10 @@ void mlx4_en_destroy_netdev(struct net_device *dev)
|
|||
if (priv->registered) {
|
||||
devlink_port_type_clear(mlx4_get_devlink_port(mdev->dev,
|
||||
priv->port));
|
||||
unregister_netdev(dev);
|
||||
if (shutdown)
|
||||
mlx4_en_shutdown(dev);
|
||||
else
|
||||
unregister_netdev(dev);
|
||||
}
|
||||
|
||||
if (priv->allocated)
|
||||
|
@ -2069,7 +2085,8 @@ void mlx4_en_destroy_netdev(struct net_device *dev)
|
|||
kfree(priv->tx_ring);
|
||||
kfree(priv->tx_cq);
|
||||
|
||||
free_netdev(dev);
|
||||
if (!shutdown)
|
||||
free_netdev(dev);
|
||||
}
|
||||
|
||||
static int mlx4_en_change_mtu(struct net_device *dev, int new_mtu)
|
||||
|
@ -2447,9 +2464,14 @@ static netdev_features_t mlx4_en_features_check(struct sk_buff *skb,
|
|||
* strip that feature if this is an IPv6 encapsulated frame.
|
||||
*/
|
||||
if (skb->encapsulation &&
|
||||
(skb->ip_summed == CHECKSUM_PARTIAL) &&
|
||||
(ip_hdr(skb)->version != 4))
|
||||
features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
|
||||
(skb->ip_summed == CHECKSUM_PARTIAL)) {
|
||||
struct mlx4_en_priv *priv = netdev_priv(dev);
|
||||
|
||||
if (!priv->vxlan_port ||
|
||||
(ip_hdr(skb)->version != 4) ||
|
||||
(udp_hdr(skb)->dest != priv->vxlan_port))
|
||||
features &= ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
|
||||
}
|
||||
|
||||
return features;
|
||||
}
|
||||
|
|
|
@ -3222,6 +3222,7 @@ static int mlx4_load_one(struct pci_dev *pdev, int pci_dev_data,
|
|||
|
||||
INIT_LIST_HEAD(&priv->pgdir_list);
|
||||
mutex_init(&priv->pgdir_mutex);
|
||||
spin_lock_init(&priv->cmd.context_lock);
|
||||
|
||||
INIT_LIST_HEAD(&priv->bf_list);
|
||||
mutex_init(&priv->bf_mutex);
|
||||
|
@ -4134,8 +4135,11 @@ static void mlx4_shutdown(struct pci_dev *pdev)
|
|||
|
||||
mlx4_info(persist->dev, "mlx4_shutdown was called\n");
|
||||
mutex_lock(&persist->interface_state_mutex);
|
||||
if (persist->interface_state & MLX4_INTERFACE_STATE_UP)
|
||||
if (persist->interface_state & MLX4_INTERFACE_STATE_UP) {
|
||||
/* Notify mlx4 clients that the kernel is being shut down */
|
||||
persist->interface_state |= MLX4_INTERFACE_STATE_SHUTDOWN;
|
||||
mlx4_unload_one(pdev);
|
||||
}
|
||||
mutex_unlock(&persist->interface_state_mutex);
|
||||
}
|
||||
|
||||
|
|
|
@ -545,6 +545,7 @@ const char *mlx5_command_str(int command)
|
|||
MLX5_COMMAND_STR_CASE(ALLOC_FLOW_COUNTER);
|
||||
MLX5_COMMAND_STR_CASE(DEALLOC_FLOW_COUNTER);
|
||||
MLX5_COMMAND_STR_CASE(QUERY_FLOW_COUNTER);
|
||||
MLX5_COMMAND_STR_CASE(MODIFY_FLOW_TABLE);
|
||||
default: return "unknown command opcode";
|
||||
}
|
||||
}
|
||||
|
|
|
@ -401,7 +401,7 @@ enum mlx5e_traffic_types {
|
|||
};
|
||||
|
||||
enum {
|
||||
MLX5E_STATE_ASYNC_EVENTS_ENABLE,
|
||||
MLX5E_STATE_ASYNC_EVENTS_ENABLED,
|
||||
MLX5E_STATE_OPENED,
|
||||
MLX5E_STATE_DESTROYING,
|
||||
};
|
||||
|
|
|
@ -184,7 +184,9 @@ static unsigned long mlx5e_query_pfc_combined(struct mlx5e_priv *priv)
|
|||
#define MLX5E_NUM_SQ_STATS(priv) \
|
||||
(NUM_SQ_STATS * priv->params.num_channels * priv->params.num_tc * \
|
||||
test_bit(MLX5E_STATE_OPENED, &priv->state))
|
||||
#define MLX5E_NUM_PFC_COUNTERS(priv) hweight8(mlx5e_query_pfc_combined(priv))
|
||||
#define MLX5E_NUM_PFC_COUNTERS(priv) \
|
||||
(hweight8(mlx5e_query_pfc_combined(priv)) * \
|
||||
NUM_PPORT_PER_PRIO_PFC_COUNTERS)
|
||||
|
||||
static int mlx5e_get_sset_count(struct net_device *dev, int sset)
|
||||
{
|
||||
|
@ -211,42 +213,41 @@ static void mlx5e_fill_stats_strings(struct mlx5e_priv *priv, uint8_t *data)
|
|||
|
||||
/* SW counters */
|
||||
for (i = 0; i < NUM_SW_COUNTERS; i++)
|
||||
strcpy(data + (idx++) * ETH_GSTRING_LEN, sw_stats_desc[i].name);
|
||||
strcpy(data + (idx++) * ETH_GSTRING_LEN, sw_stats_desc[i].format);
|
||||
|
||||
/* Q counters */
|
||||
for (i = 0; i < MLX5E_NUM_Q_CNTRS(priv); i++)
|
||||
strcpy(data + (idx++) * ETH_GSTRING_LEN, q_stats_desc[i].name);
|
||||
strcpy(data + (idx++) * ETH_GSTRING_LEN, q_stats_desc[i].format);
|
||||
|
||||
/* VPORT counters */
|
||||
for (i = 0; i < NUM_VPORT_COUNTERS; i++)
|
||||
strcpy(data + (idx++) * ETH_GSTRING_LEN,
|
||||
vport_stats_desc[i].name);
|
||||
vport_stats_desc[i].format);
|
||||
|
||||
/* PPORT counters */
|
||||
for (i = 0; i < NUM_PPORT_802_3_COUNTERS; i++)
|
||||
strcpy(data + (idx++) * ETH_GSTRING_LEN,
|
||||
pport_802_3_stats_desc[i].name);
|
||||
pport_802_3_stats_desc[i].format);
|
||||
|
||||
for (i = 0; i < NUM_PPORT_2863_COUNTERS; i++)
|
||||
strcpy(data + (idx++) * ETH_GSTRING_LEN,
|
||||
pport_2863_stats_desc[i].name);
|
||||
pport_2863_stats_desc[i].format);
|
||||
|
||||
for (i = 0; i < NUM_PPORT_2819_COUNTERS; i++)
|
||||
strcpy(data + (idx++) * ETH_GSTRING_LEN,
|
||||
pport_2819_stats_desc[i].name);
|
||||
pport_2819_stats_desc[i].format);
|
||||
|
||||
for (prio = 0; prio < NUM_PPORT_PRIO; prio++) {
|
||||
for (i = 0; i < NUM_PPORT_PER_PRIO_TRAFFIC_COUNTERS; i++)
|
||||
sprintf(data + (idx++) * ETH_GSTRING_LEN, "prio%d_%s",
|
||||
prio,
|
||||
pport_per_prio_traffic_stats_desc[i].name);
|
||||
sprintf(data + (idx++) * ETH_GSTRING_LEN,
|
||||
pport_per_prio_traffic_stats_desc[i].format, prio);
|
||||
}
|
||||
|
||||
pfc_combined = mlx5e_query_pfc_combined(priv);
|
||||
for_each_set_bit(prio, &pfc_combined, NUM_PPORT_PRIO) {
|
||||
for (i = 0; i < NUM_PPORT_PER_PRIO_PFC_COUNTERS; i++) {
|
||||
sprintf(data + (idx++) * ETH_GSTRING_LEN, "prio%d_%s",
|
||||
prio, pport_per_prio_pfc_stats_desc[i].name);
|
||||
sprintf(data + (idx++) * ETH_GSTRING_LEN,
|
||||
pport_per_prio_pfc_stats_desc[i].format, prio);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -256,16 +257,15 @@ static void mlx5e_fill_stats_strings(struct mlx5e_priv *priv, uint8_t *data)
|
|||
/* per channel counters */
|
||||
for (i = 0; i < priv->params.num_channels; i++)
|
||||
for (j = 0; j < NUM_RQ_STATS; j++)
|
||||
sprintf(data + (idx++) * ETH_GSTRING_LEN, "rx%d_%s", i,
|
||||
rq_stats_desc[j].name);
|
||||
sprintf(data + (idx++) * ETH_GSTRING_LEN,
|
||||
rq_stats_desc[j].format, i);
|
||||
|
||||
for (tc = 0; tc < priv->params.num_tc; tc++)
|
||||
for (i = 0; i < priv->params.num_channels; i++)
|
||||
for (j = 0; j < NUM_SQ_STATS; j++)
|
||||
sprintf(data + (idx++) * ETH_GSTRING_LEN,
|
||||
"tx%d_%s",
|
||||
priv->channeltc_to_txq_map[i][tc],
|
||||
sq_stats_desc[j].name);
|
||||
sq_stats_desc[j].format,
|
||||
priv->channeltc_to_txq_map[i][tc]);
|
||||
}
|
||||
|
||||
static void mlx5e_get_strings(struct net_device *dev,
|
||||
|
|
|
@ -105,11 +105,11 @@ static void mlx5e_update_sw_counters(struct mlx5e_priv *priv)
|
|||
|
||||
s->rx_packets += rq_stats->packets;
|
||||
s->rx_bytes += rq_stats->bytes;
|
||||
s->lro_packets += rq_stats->lro_packets;
|
||||
s->lro_bytes += rq_stats->lro_bytes;
|
||||
s->rx_lro_packets += rq_stats->lro_packets;
|
||||
s->rx_lro_bytes += rq_stats->lro_bytes;
|
||||
s->rx_csum_none += rq_stats->csum_none;
|
||||
s->rx_csum_sw += rq_stats->csum_sw;
|
||||
s->rx_csum_inner += rq_stats->csum_inner;
|
||||
s->rx_csum_complete += rq_stats->csum_complete;
|
||||
s->rx_csum_unnecessary_inner += rq_stats->csum_unnecessary_inner;
|
||||
s->rx_wqe_err += rq_stats->wqe_err;
|
||||
s->rx_mpwqe_filler += rq_stats->mpwqe_filler;
|
||||
s->rx_mpwqe_frag += rq_stats->mpwqe_frag;
|
||||
|
@ -122,24 +122,23 @@ static void mlx5e_update_sw_counters(struct mlx5e_priv *priv)
|
|||
|
||||
s->tx_packets += sq_stats->packets;
|
||||
s->tx_bytes += sq_stats->bytes;
|
||||
s->tso_packets += sq_stats->tso_packets;
|
||||
s->tso_bytes += sq_stats->tso_bytes;
|
||||
s->tso_inner_packets += sq_stats->tso_inner_packets;
|
||||
s->tso_inner_bytes += sq_stats->tso_inner_bytes;
|
||||
s->tx_tso_packets += sq_stats->tso_packets;
|
||||
s->tx_tso_bytes += sq_stats->tso_bytes;
|
||||
s->tx_tso_inner_packets += sq_stats->tso_inner_packets;
|
||||
s->tx_tso_inner_bytes += sq_stats->tso_inner_bytes;
|
||||
s->tx_queue_stopped += sq_stats->stopped;
|
||||
s->tx_queue_wake += sq_stats->wake;
|
||||
s->tx_queue_dropped += sq_stats->dropped;
|
||||
s->tx_csum_inner += sq_stats->csum_offload_inner;
|
||||
tx_offload_none += sq_stats->csum_offload_none;
|
||||
s->tx_csum_partial_inner += sq_stats->csum_partial_inner;
|
||||
tx_offload_none += sq_stats->csum_none;
|
||||
}
|
||||
}
|
||||
|
||||
/* Update calculated offload counters */
|
||||
s->tx_csum_offload = s->tx_packets - tx_offload_none - s->tx_csum_inner;
|
||||
s->rx_csum_good = s->rx_packets - s->rx_csum_none -
|
||||
s->rx_csum_sw;
|
||||
s->tx_csum_partial = s->tx_packets - tx_offload_none - s->tx_csum_partial_inner;
|
||||
s->rx_csum_unnecessary = s->rx_packets - s->rx_csum_none - s->rx_csum_complete;
|
||||
|
||||
s->link_down_events = MLX5_GET(ppcnt_reg,
|
||||
s->link_down_events_phy = MLX5_GET(ppcnt_reg,
|
||||
priv->stats.pport.phy_counters,
|
||||
counter_set.phys_layer_cntrs.link_down_events);
|
||||
}
|
||||
|
@ -244,7 +243,7 @@ static void mlx5e_async_event(struct mlx5_core_dev *mdev, void *vpriv,
|
|||
{
|
||||
struct mlx5e_priv *priv = vpriv;
|
||||
|
||||
if (!test_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLE, &priv->state))
|
||||
if (!test_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLED, &priv->state))
|
||||
return;
|
||||
|
||||
switch (event) {
|
||||
|
@ -260,12 +259,12 @@ static void mlx5e_async_event(struct mlx5_core_dev *mdev, void *vpriv,
|
|||
|
||||
static void mlx5e_enable_async_events(struct mlx5e_priv *priv)
|
||||
{
|
||||
set_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLE, &priv->state);
|
||||
set_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLED, &priv->state);
|
||||
}
|
||||
|
||||
static void mlx5e_disable_async_events(struct mlx5e_priv *priv)
|
||||
{
|
||||
clear_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLE, &priv->state);
|
||||
clear_bit(MLX5E_STATE_ASYNC_EVENTS_ENABLED, &priv->state);
|
||||
synchronize_irq(mlx5_get_msix_vec(priv->mdev, MLX5_EQ_VEC_ASYNC));
|
||||
}
|
||||
|
||||
|
@ -580,7 +579,7 @@ static int mlx5e_create_sq(struct mlx5e_channel *c,
|
|||
void *sqc_wq = MLX5_ADDR_OF(sqc, sqc, wq);
|
||||
int err;
|
||||
|
||||
err = mlx5_alloc_map_uar(mdev, &sq->uar, true);
|
||||
err = mlx5_alloc_map_uar(mdev, &sq->uar, !!MLX5_CAP_GEN(mdev, bf));
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
|
|
|
@ -689,7 +689,7 @@ static inline void mlx5e_handle_csum(struct net_device *netdev,
|
|||
if (is_first_ethertype_ip(skb)) {
|
||||
skb->ip_summed = CHECKSUM_COMPLETE;
|
||||
skb->csum = csum_unfold((__force __sum16)cqe->check_sum);
|
||||
rq->stats.csum_sw++;
|
||||
rq->stats.csum_complete++;
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -699,7 +699,7 @@ static inline void mlx5e_handle_csum(struct net_device *netdev,
|
|||
if (cqe_is_tunneled(cqe)) {
|
||||
skb->csum_level = 1;
|
||||
skb->encapsulation = 1;
|
||||
rq->stats.csum_inner++;
|
||||
rq->stats.csum_unnecessary_inner++;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -42,9 +42,11 @@
|
|||
be64_to_cpu(*(__be32 *)((char *)ptr + dsc[i].offset))
|
||||
|
||||
#define MLX5E_DECLARE_STAT(type, fld) #fld, offsetof(type, fld)
|
||||
#define MLX5E_DECLARE_RX_STAT(type, fld) "rx%d_"#fld, offsetof(type, fld)
|
||||
#define MLX5E_DECLARE_TX_STAT(type, fld) "tx%d_"#fld, offsetof(type, fld)
|
||||
|
||||
struct counter_desc {
|
||||
char name[ETH_GSTRING_LEN];
|
||||
char format[ETH_GSTRING_LEN];
|
||||
int offset; /* Byte offset */
|
||||
};
|
||||
|
||||
|
@ -53,18 +55,18 @@ struct mlx5e_sw_stats {
|
|||
u64 rx_bytes;
|
||||
u64 tx_packets;
|
||||
u64 tx_bytes;
|
||||
u64 tso_packets;
|
||||
u64 tso_bytes;
|
||||
u64 tso_inner_packets;
|
||||
u64 tso_inner_bytes;
|
||||
u64 lro_packets;
|
||||
u64 lro_bytes;
|
||||
u64 rx_csum_good;
|
||||
u64 tx_tso_packets;
|
||||
u64 tx_tso_bytes;
|
||||
u64 tx_tso_inner_packets;
|
||||
u64 tx_tso_inner_bytes;
|
||||
u64 rx_lro_packets;
|
||||
u64 rx_lro_bytes;
|
||||
u64 rx_csum_unnecessary;
|
||||
u64 rx_csum_none;
|
||||
u64 rx_csum_sw;
|
||||
u64 rx_csum_inner;
|
||||
u64 tx_csum_offload;
|
||||
u64 tx_csum_inner;
|
||||
u64 rx_csum_complete;
|
||||
u64 rx_csum_unnecessary_inner;
|
||||
u64 tx_csum_partial;
|
||||
u64 tx_csum_partial_inner;
|
||||
u64 tx_queue_stopped;
|
||||
u64 tx_queue_wake;
|
||||
u64 tx_queue_dropped;
|
||||
|
@ -76,7 +78,7 @@ struct mlx5e_sw_stats {
|
|||
u64 rx_cqe_compress_pkts;
|
||||
|
||||
/* Special handling counters */
|
||||
u64 link_down_events;
|
||||
u64 link_down_events_phy;
|
||||
};
|
||||
|
||||
static const struct counter_desc sw_stats_desc[] = {
|
||||
|
@ -84,18 +86,18 @@ static const struct counter_desc sw_stats_desc[] = {
|
|||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tso_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tso_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tso_inner_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tso_inner_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, lro_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, lro_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_good) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_tso_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_tso_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_tso_inner_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_tso_inner_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_lro_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_lro_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_unnecessary) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_none) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_sw) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_inner) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_csum_offload) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_csum_inner) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_complete) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_csum_unnecessary_inner) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_csum_partial) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_csum_partial_inner) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_queue_stopped) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_queue_wake) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_queue_dropped) },
|
||||
|
@ -105,7 +107,7 @@ static const struct counter_desc sw_stats_desc[] = {
|
|||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_buff_alloc_err) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_cqe_compress_blks) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_cqe_compress_pkts) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, link_down_events) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, link_down_events_phy) },
|
||||
};
|
||||
|
||||
struct mlx5e_qcounter_stats {
|
||||
|
@ -125,12 +127,6 @@ struct mlx5e_vport_stats {
|
|||
};
|
||||
|
||||
static const struct counter_desc vport_stats_desc[] = {
|
||||
{ "rx_vport_error_packets",
|
||||
VPORT_COUNTER_OFF(received_errors.packets) },
|
||||
{ "rx_vport_error_bytes", VPORT_COUNTER_OFF(received_errors.octets) },
|
||||
{ "tx_vport_error_packets",
|
||||
VPORT_COUNTER_OFF(transmit_errors.packets) },
|
||||
{ "tx_vport_error_bytes", VPORT_COUNTER_OFF(transmit_errors.octets) },
|
||||
{ "rx_vport_unicast_packets",
|
||||
VPORT_COUNTER_OFF(received_eth_unicast.packets) },
|
||||
{ "rx_vport_unicast_bytes",
|
||||
|
@ -192,94 +188,68 @@ struct mlx5e_pport_stats {
|
|||
};
|
||||
|
||||
static const struct counter_desc pport_802_3_stats_desc[] = {
|
||||
{ "frames_tx", PPORT_802_3_OFF(a_frames_transmitted_ok) },
|
||||
{ "frames_rx", PPORT_802_3_OFF(a_frames_received_ok) },
|
||||
{ "check_seq_err", PPORT_802_3_OFF(a_frame_check_sequence_errors) },
|
||||
{ "alignment_err", PPORT_802_3_OFF(a_alignment_errors) },
|
||||
{ "octets_tx", PPORT_802_3_OFF(a_octets_transmitted_ok) },
|
||||
{ "octets_received", PPORT_802_3_OFF(a_octets_received_ok) },
|
||||
{ "multicast_xmitted", PPORT_802_3_OFF(a_multicast_frames_xmitted_ok) },
|
||||
{ "broadcast_xmitted", PPORT_802_3_OFF(a_broadcast_frames_xmitted_ok) },
|
||||
{ "multicast_rx", PPORT_802_3_OFF(a_multicast_frames_received_ok) },
|
||||
{ "broadcast_rx", PPORT_802_3_OFF(a_broadcast_frames_received_ok) },
|
||||
{ "in_range_len_errors", PPORT_802_3_OFF(a_in_range_length_errors) },
|
||||
{ "out_of_range_len", PPORT_802_3_OFF(a_out_of_range_length_field) },
|
||||
{ "too_long_errors", PPORT_802_3_OFF(a_frame_too_long_errors) },
|
||||
{ "symbol_err", PPORT_802_3_OFF(a_symbol_error_during_carrier) },
|
||||
{ "mac_control_tx", PPORT_802_3_OFF(a_mac_control_frames_transmitted) },
|
||||
{ "mac_control_rx", PPORT_802_3_OFF(a_mac_control_frames_received) },
|
||||
{ "unsupported_op_rx",
|
||||
PPORT_802_3_OFF(a_unsupported_opcodes_received) },
|
||||
{ "pause_ctrl_rx", PPORT_802_3_OFF(a_pause_mac_ctrl_frames_received) },
|
||||
{ "pause_ctrl_tx",
|
||||
PPORT_802_3_OFF(a_pause_mac_ctrl_frames_transmitted) },
|
||||
{ "tx_packets_phy", PPORT_802_3_OFF(a_frames_transmitted_ok) },
|
||||
{ "rx_packets_phy", PPORT_802_3_OFF(a_frames_received_ok) },
|
||||
{ "rx_crc_errors_phy", PPORT_802_3_OFF(a_frame_check_sequence_errors) },
|
||||
{ "tx_bytes_phy", PPORT_802_3_OFF(a_octets_transmitted_ok) },
|
||||
{ "rx_bytes_phy", PPORT_802_3_OFF(a_octets_received_ok) },
|
||||
{ "tx_multicast_phy", PPORT_802_3_OFF(a_multicast_frames_xmitted_ok) },
|
||||
{ "tx_broadcast_phy", PPORT_802_3_OFF(a_broadcast_frames_xmitted_ok) },
|
||||
{ "rx_multicast_phy", PPORT_802_3_OFF(a_multicast_frames_received_ok) },
|
||||
{ "rx_broadcast_phy", PPORT_802_3_OFF(a_broadcast_frames_received_ok) },
|
||||
{ "rx_in_range_len_errors_phy", PPORT_802_3_OFF(a_in_range_length_errors) },
|
||||
{ "rx_out_of_range_len_phy", PPORT_802_3_OFF(a_out_of_range_length_field) },
|
||||
{ "rx_oversize_pkts_phy", PPORT_802_3_OFF(a_frame_too_long_errors) },
|
||||
{ "rx_symbol_err_phy", PPORT_802_3_OFF(a_symbol_error_during_carrier) },
|
||||
{ "tx_mac_control_phy", PPORT_802_3_OFF(a_mac_control_frames_transmitted) },
|
||||
{ "rx_mac_control_phy", PPORT_802_3_OFF(a_mac_control_frames_received) },
|
||||
{ "rx_unsupported_op_phy", PPORT_802_3_OFF(a_unsupported_opcodes_received) },
|
||||
{ "rx_pause_ctrl_phy", PPORT_802_3_OFF(a_pause_mac_ctrl_frames_received) },
|
||||
{ "tx_pause_ctrl_phy", PPORT_802_3_OFF(a_pause_mac_ctrl_frames_transmitted) },
|
||||
};
|
||||
|
||||
static const struct counter_desc pport_2863_stats_desc[] = {
|
||||
{ "in_octets", PPORT_2863_OFF(if_in_octets) },
|
||||
{ "in_ucast_pkts", PPORT_2863_OFF(if_in_ucast_pkts) },
|
||||
{ "in_discards", PPORT_2863_OFF(if_in_discards) },
|
||||
{ "in_errors", PPORT_2863_OFF(if_in_errors) },
|
||||
{ "in_unknown_protos", PPORT_2863_OFF(if_in_unknown_protos) },
|
||||
{ "out_octets", PPORT_2863_OFF(if_out_octets) },
|
||||
{ "out_ucast_pkts", PPORT_2863_OFF(if_out_ucast_pkts) },
|
||||
{ "out_discards", PPORT_2863_OFF(if_out_discards) },
|
||||
{ "out_errors", PPORT_2863_OFF(if_out_errors) },
|
||||
{ "in_multicast_pkts", PPORT_2863_OFF(if_in_multicast_pkts) },
|
||||
{ "in_broadcast_pkts", PPORT_2863_OFF(if_in_broadcast_pkts) },
|
||||
{ "out_multicast_pkts", PPORT_2863_OFF(if_out_multicast_pkts) },
|
||||
{ "out_broadcast_pkts", PPORT_2863_OFF(if_out_broadcast_pkts) },
|
||||
{ "rx_discards_phy", PPORT_2863_OFF(if_in_discards) },
|
||||
{ "tx_discards_phy", PPORT_2863_OFF(if_out_discards) },
|
||||
{ "tx_errors_phy", PPORT_2863_OFF(if_out_errors) },
|
||||
};
|
||||
|
||||
static const struct counter_desc pport_2819_stats_desc[] = {
|
||||
{ "drop_events", PPORT_2819_OFF(ether_stats_drop_events) },
|
||||
{ "octets", PPORT_2819_OFF(ether_stats_octets) },
|
||||
{ "pkts", PPORT_2819_OFF(ether_stats_pkts) },
|
||||
{ "broadcast_pkts", PPORT_2819_OFF(ether_stats_broadcast_pkts) },
|
||||
{ "multicast_pkts", PPORT_2819_OFF(ether_stats_multicast_pkts) },
|
||||
{ "crc_align_errors", PPORT_2819_OFF(ether_stats_crc_align_errors) },
|
||||
{ "undersize_pkts", PPORT_2819_OFF(ether_stats_undersize_pkts) },
|
||||
{ "oversize_pkts", PPORT_2819_OFF(ether_stats_oversize_pkts) },
|
||||
{ "fragments", PPORT_2819_OFF(ether_stats_fragments) },
|
||||
{ "jabbers", PPORT_2819_OFF(ether_stats_jabbers) },
|
||||
{ "collisions", PPORT_2819_OFF(ether_stats_collisions) },
|
||||
{ "p64octets", PPORT_2819_OFF(ether_stats_pkts64octets) },
|
||||
{ "p65to127octets", PPORT_2819_OFF(ether_stats_pkts65to127octets) },
|
||||
{ "p128to255octets", PPORT_2819_OFF(ether_stats_pkts128to255octets) },
|
||||
{ "p256to511octets", PPORT_2819_OFF(ether_stats_pkts256to511octets) },
|
||||
{ "p512to1023octets", PPORT_2819_OFF(ether_stats_pkts512to1023octets) },
|
||||
{ "p1024to1518octets",
|
||||
PPORT_2819_OFF(ether_stats_pkts1024to1518octets) },
|
||||
{ "p1519to2047octets",
|
||||
PPORT_2819_OFF(ether_stats_pkts1519to2047octets) },
|
||||
{ "p2048to4095octets",
|
||||
PPORT_2819_OFF(ether_stats_pkts2048to4095octets) },
|
||||
{ "p4096to8191octets",
|
||||
PPORT_2819_OFF(ether_stats_pkts4096to8191octets) },
|
||||
{ "p8192to10239octets",
|
||||
PPORT_2819_OFF(ether_stats_pkts8192to10239octets) },
|
||||
{ "rx_undersize_pkts_phy", PPORT_2819_OFF(ether_stats_undersize_pkts) },
|
||||
{ "rx_fragments_phy", PPORT_2819_OFF(ether_stats_fragments) },
|
||||
{ "rx_jabbers_phy", PPORT_2819_OFF(ether_stats_jabbers) },
|
||||
{ "rx_64_bytes_phy", PPORT_2819_OFF(ether_stats_pkts64octets) },
|
||||
{ "rx_65_to_127_bytes_phy", PPORT_2819_OFF(ether_stats_pkts65to127octets) },
|
||||
{ "rx_128_to_255_bytes_phy", PPORT_2819_OFF(ether_stats_pkts128to255octets) },
|
||||
{ "rx_256_to_511_bytes_phy", PPORT_2819_OFF(ether_stats_pkts256to511octets) },
|
||||
{ "rx_512_to_1023_bytes_phy", PPORT_2819_OFF(ether_stats_pkts512to1023octets) },
|
||||
{ "rx_1024_to_1518_bytes_phy", PPORT_2819_OFF(ether_stats_pkts1024to1518octets) },
|
||||
{ "rx_1519_to_2047_bytes_phy", PPORT_2819_OFF(ether_stats_pkts1519to2047octets) },
|
||||
{ "rx_2048_to_4095_bytes_phy", PPORT_2819_OFF(ether_stats_pkts2048to4095octets) },
|
||||
{ "rx_4096_to_8191_bytes_phy", PPORT_2819_OFF(ether_stats_pkts4096to8191octets) },
|
||||
{ "rx_8192_to_10239_bytes_phy", PPORT_2819_OFF(ether_stats_pkts8192to10239octets) },
|
||||
};
|
||||
|
||||
static const struct counter_desc pport_per_prio_traffic_stats_desc[] = {
|
||||
{ "rx_octets", PPORT_PER_PRIO_OFF(rx_octets) },
|
||||
{ "rx_frames", PPORT_PER_PRIO_OFF(rx_frames) },
|
||||
{ "tx_octets", PPORT_PER_PRIO_OFF(tx_octets) },
|
||||
{ "tx_frames", PPORT_PER_PRIO_OFF(tx_frames) },
|
||||
{ "rx_prio%d_bytes", PPORT_PER_PRIO_OFF(rx_octets) },
|
||||
{ "rx_prio%d_packets", PPORT_PER_PRIO_OFF(rx_frames) },
|
||||
{ "tx_prio%d_bytes", PPORT_PER_PRIO_OFF(tx_octets) },
|
||||
{ "tx_prio%d_packets", PPORT_PER_PRIO_OFF(tx_frames) },
|
||||
};
|
||||
|
||||
static const struct counter_desc pport_per_prio_pfc_stats_desc[] = {
|
||||
{ "rx_pause", PPORT_PER_PRIO_OFF(rx_pause) },
|
||||
{ "rx_pause_duration", PPORT_PER_PRIO_OFF(rx_pause_duration) },
|
||||
{ "tx_pause", PPORT_PER_PRIO_OFF(tx_pause) },
|
||||
{ "tx_pause_duration", PPORT_PER_PRIO_OFF(tx_pause_duration) },
|
||||
{ "rx_pause_transition", PPORT_PER_PRIO_OFF(rx_pause_transition) },
|
||||
{ "rx_prio%d_pause", PPORT_PER_PRIO_OFF(rx_pause) },
|
||||
{ "rx_prio%d_pause_duration", PPORT_PER_PRIO_OFF(rx_pause_duration) },
|
||||
{ "tx_prio%d_pause", PPORT_PER_PRIO_OFF(tx_pause) },
|
||||
{ "tx_prio%d_pause_duration", PPORT_PER_PRIO_OFF(tx_pause_duration) },
|
||||
{ "rx_prio%d_pause_transition", PPORT_PER_PRIO_OFF(rx_pause_transition) },
|
||||
};
|
||||
|
||||
struct mlx5e_rq_stats {
|
||||
u64 packets;
|
||||
u64 bytes;
|
||||
u64 csum_sw;
|
||||
u64 csum_inner;
|
||||
u64 csum_complete;
|
||||
u64 csum_unnecessary_inner;
|
||||
u64 csum_none;
|
||||
u64 lro_packets;
|
||||
u64 lro_bytes;
|
||||
|
@ -292,19 +262,19 @@ struct mlx5e_rq_stats {
|
|||
};
|
||||
|
||||
static const struct counter_desc rq_stats_desc[] = {
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, csum_sw) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, csum_inner) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, csum_none) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, lro_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, lro_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, wqe_err) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, mpwqe_filler) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, mpwqe_frag) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, buff_alloc_err) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, cqe_compress_blks) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_rq_stats, cqe_compress_pkts) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, packets) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, bytes) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_complete) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_unnecessary_inner) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, csum_none) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, lro_packets) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, lro_bytes) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, wqe_err) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, mpwqe_filler) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, mpwqe_frag) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, buff_alloc_err) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, cqe_compress_blks) },
|
||||
{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, cqe_compress_pkts) },
|
||||
};
|
||||
|
||||
struct mlx5e_sq_stats {
|
||||
|
@ -315,28 +285,28 @@ struct mlx5e_sq_stats {
|
|||
u64 tso_bytes;
|
||||
u64 tso_inner_packets;
|
||||
u64 tso_inner_bytes;
|
||||
u64 csum_offload_inner;
|
||||
u64 csum_partial_inner;
|
||||
u64 nop;
|
||||
/* less likely accessed in data path */
|
||||
u64 csum_offload_none;
|
||||
u64 csum_none;
|
||||
u64 stopped;
|
||||
u64 wake;
|
||||
u64 dropped;
|
||||
};
|
||||
|
||||
static const struct counter_desc sq_stats_desc[] = {
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, tso_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, tso_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, tso_inner_packets) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, tso_inner_bytes) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, csum_offload_inner) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, nop) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, csum_offload_none) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, stopped) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, wake) },
|
||||
{ MLX5E_DECLARE_STAT(struct mlx5e_sq_stats, dropped) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, packets) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, bytes) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, tso_packets) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, tso_bytes) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, tso_inner_packets) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, tso_inner_bytes) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, csum_partial_inner) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, nop) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, csum_none) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, stopped) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, wake) },
|
||||
{ MLX5E_DECLARE_TX_STAT(struct mlx5e_sq_stats, dropped) },
|
||||
};
|
||||
|
||||
#define NUM_SW_COUNTERS ARRAY_SIZE(sw_stats_desc)
|
||||
|
|
|
@ -192,12 +192,12 @@ static netdev_tx_t mlx5e_sq_xmit(struct mlx5e_sq *sq, struct sk_buff *skb)
|
|||
if (skb->encapsulation) {
|
||||
eseg->cs_flags |= MLX5_ETH_WQE_L3_INNER_CSUM |
|
||||
MLX5_ETH_WQE_L4_INNER_CSUM;
|
||||
sq->stats.csum_offload_inner++;
|
||||
sq->stats.csum_partial_inner++;
|
||||
} else {
|
||||
eseg->cs_flags |= MLX5_ETH_WQE_L4_CSUM;
|
||||
}
|
||||
} else
|
||||
sq->stats.csum_offload_none++;
|
||||
sq->stats.csum_none++;
|
||||
|
||||
if (sq->cc != sq->prev_cc) {
|
||||
sq->prev_cc = sq->cc;
|
||||
|
|
|
@ -1508,8 +1508,9 @@ static const struct pci_device_id mlx5_core_pci_table[] = {
|
|||
{ PCI_VDEVICE(MELLANOX, 0x1014), MLX5_PCI_DEV_IS_VF}, /* ConnectX-4 VF */
|
||||
{ PCI_VDEVICE(MELLANOX, 0x1015) }, /* ConnectX-4LX */
|
||||
{ PCI_VDEVICE(MELLANOX, 0x1016), MLX5_PCI_DEV_IS_VF}, /* ConnectX-4LX VF */
|
||||
{ PCI_VDEVICE(MELLANOX, 0x1017) }, /* ConnectX-5 */
|
||||
{ PCI_VDEVICE(MELLANOX, 0x1017) }, /* ConnectX-5, PCIe 3.0 */
|
||||
{ PCI_VDEVICE(MELLANOX, 0x1018), MLX5_PCI_DEV_IS_VF}, /* ConnectX-5 VF */
|
||||
{ PCI_VDEVICE(MELLANOX, 0x1019) }, /* ConnectX-5, PCIe 4.0 */
|
||||
{ 0, }
|
||||
};
|
||||
|
||||
|
|
|
@ -105,6 +105,9 @@ static void mlx5e_vxlan_add_port(struct work_struct *work)
|
|||
struct mlx5e_vxlan *vxlan;
|
||||
int err;
|
||||
|
||||
if (mlx5e_vxlan_lookup_port(priv, port))
|
||||
goto free_work;
|
||||
|
||||
if (mlx5e_vxlan_core_add_port_cmd(priv->mdev, port))
|
||||
goto free_work;
|
||||
|
||||
|
|
|
@ -75,14 +75,14 @@ int mlx5_wq_cyc_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
|
|||
|
||||
err = mlx5_db_alloc_node(mdev, &wq_ctrl->db, param->db_numa_node);
|
||||
if (err) {
|
||||
mlx5_core_warn(mdev, "mlx5_db_alloc() failed, %d\n", err);
|
||||
mlx5_core_warn(mdev, "mlx5_db_alloc_node() failed, %d\n", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
err = mlx5_buf_alloc_node(mdev, mlx5_wq_cyc_get_byte_size(wq),
|
||||
&wq_ctrl->buf, param->buf_numa_node);
|
||||
if (err) {
|
||||
mlx5_core_warn(mdev, "mlx5_buf_alloc() failed, %d\n", err);
|
||||
mlx5_core_warn(mdev, "mlx5_buf_alloc_node() failed, %d\n", err);
|
||||
goto err_db_free;
|
||||
}
|
||||
|
||||
|
@ -111,14 +111,14 @@ int mlx5_cqwq_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
|
|||
|
||||
err = mlx5_db_alloc_node(mdev, &wq_ctrl->db, param->db_numa_node);
|
||||
if (err) {
|
||||
mlx5_core_warn(mdev, "mlx5_db_alloc() failed, %d\n", err);
|
||||
mlx5_core_warn(mdev, "mlx5_db_alloc_node() failed, %d\n", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
err = mlx5_buf_alloc_node(mdev, mlx5_cqwq_get_byte_size(wq),
|
||||
&wq_ctrl->buf, param->buf_numa_node);
|
||||
if (err) {
|
||||
mlx5_core_warn(mdev, "mlx5_buf_alloc() failed, %d\n", err);
|
||||
mlx5_core_warn(mdev, "mlx5_buf_alloc_node() failed, %d\n", err);
|
||||
goto err_db_free;
|
||||
}
|
||||
|
||||
|
@ -148,13 +148,14 @@ int mlx5_wq_ll_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
|
|||
|
||||
err = mlx5_db_alloc_node(mdev, &wq_ctrl->db, param->db_numa_node);
|
||||
if (err) {
|
||||
mlx5_core_warn(mdev, "mlx5_db_alloc() failed, %d\n", err);
|
||||
mlx5_core_warn(mdev, "mlx5_db_alloc_node() failed, %d\n", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
err = mlx5_buf_alloc(mdev, mlx5_wq_ll_get_byte_size(wq), &wq_ctrl->buf);
|
||||
err = mlx5_buf_alloc_node(mdev, mlx5_wq_ll_get_byte_size(wq),
|
||||
&wq_ctrl->buf, param->buf_numa_node);
|
||||
if (err) {
|
||||
mlx5_core_warn(mdev, "mlx5_buf_alloc() failed, %d\n", err);
|
||||
mlx5_core_warn(mdev, "mlx5_buf_alloc_node() failed, %d\n", err);
|
||||
goto err_db_free;
|
||||
}
|
||||
|
||||
|
|
|
@ -408,7 +408,11 @@ static netdev_tx_t mlxsw_sp_port_xmit(struct sk_buff *skb,
|
|||
}
|
||||
|
||||
mlxsw_sp_txhdr_construct(skb, &tx_info);
|
||||
len = skb->len;
|
||||
/* TX header is consumed by HW on the way so we shouldn't count its
|
||||
* bytes as being sent.
|
||||
*/
|
||||
len = skb->len - MLXSW_TXHDR_LEN;
|
||||
|
||||
/* Due to a race we might fail here because of a full queue. In that
|
||||
* unlikely case we simply drop the packet.
|
||||
*/
|
||||
|
|
|
@ -316,7 +316,10 @@ static netdev_tx_t mlxsw_sx_port_xmit(struct sk_buff *skb,
|
|||
}
|
||||
}
|
||||
mlxsw_sx_txhdr_construct(skb, &tx_info);
|
||||
len = skb->len;
|
||||
/* TX header is consumed by HW on the way so we shouldn't count its
|
||||
* bytes as being sent.
|
||||
*/
|
||||
len = skb->len - MLXSW_TXHDR_LEN;
|
||||
/* Due to a race we might fail here because of a full queue. In that
|
||||
* unlikely case we simply drop the packet.
|
||||
*/
|
||||
|
|
|
@ -2015,7 +2015,7 @@ static void nfp_net_open_stack(struct nfp_net *nn)
|
|||
|
||||
netif_tx_wake_all_queues(nn->netdev);
|
||||
|
||||
enable_irq(nn->irq_entries[NFP_NET_CFG_LSC].vector);
|
||||
enable_irq(nn->irq_entries[NFP_NET_IRQ_LSC_IDX].vector);
|
||||
nfp_net_read_link_status(nn);
|
||||
}
|
||||
|
||||
|
@ -2044,7 +2044,7 @@ static int nfp_net_netdev_open(struct net_device *netdev)
|
|||
NFP_NET_IRQ_LSC_IDX, nn->lsc_handler);
|
||||
if (err)
|
||||
goto err_free_exn;
|
||||
disable_irq(nn->irq_entries[NFP_NET_CFG_LSC].vector);
|
||||
disable_irq(nn->irq_entries[NFP_NET_IRQ_LSC_IDX].vector);
|
||||
|
||||
nn->rx_rings = kcalloc(nn->num_rx_rings, sizeof(*nn->rx_rings),
|
||||
GFP_KERNEL);
|
||||
|
@ -2133,7 +2133,7 @@ static void nfp_net_close_stack(struct nfp_net *nn)
|
|||
{
|
||||
unsigned int r;
|
||||
|
||||
disable_irq(nn->irq_entries[NFP_NET_CFG_LSC].vector);
|
||||
disable_irq(nn->irq_entries[NFP_NET_IRQ_LSC_IDX].vector);
|
||||
netif_carrier_off(nn->netdev);
|
||||
nn->link_up = false;
|
||||
|
||||
|
|
|
@ -3700,6 +3700,7 @@ struct public_port {
|
|||
#define MEDIA_DA_TWINAX 0x3
|
||||
#define MEDIA_BASE_T 0x4
|
||||
#define MEDIA_SFP_1G_FIBER 0x5
|
||||
#define MEDIA_MODULE_FIBER 0x6
|
||||
#define MEDIA_KR 0xf0
|
||||
#define MEDIA_NOT_PRESENT 0xff
|
||||
|
||||
|
|
|
@ -72,6 +72,7 @@ int qed_sp_eth_vport_start(struct qed_hwfn *p_hwfn,
|
|||
p_ramrod->mtu = cpu_to_le16(p_params->mtu);
|
||||
p_ramrod->inner_vlan_removal_en = p_params->remove_inner_vlan;
|
||||
p_ramrod->drop_ttl0_en = p_params->drop_ttl0;
|
||||
p_ramrod->untagged = p_params->only_untagged;
|
||||
|
||||
SET_FIELD(rx_mode, ETH_VPORT_RX_MODE_UCAST_DROP_ALL, 1);
|
||||
SET_FIELD(rx_mode, ETH_VPORT_RX_MODE_MCAST_DROP_ALL, 1);
|
||||
|
@ -247,10 +248,6 @@ qed_sp_update_accept_mode(struct qed_hwfn *p_hwfn,
|
|||
SET_FIELD(state, ETH_VPORT_TX_MODE_UCAST_DROP_ALL,
|
||||
!!(accept_filter & QED_ACCEPT_NONE));
|
||||
|
||||
SET_FIELD(state, ETH_VPORT_TX_MODE_UCAST_ACCEPT_ALL,
|
||||
(!!(accept_filter & QED_ACCEPT_UCAST_MATCHED) &&
|
||||
!!(accept_filter & QED_ACCEPT_UCAST_UNMATCHED)));
|
||||
|
||||
SET_FIELD(state, ETH_VPORT_TX_MODE_MCAST_DROP_ALL,
|
||||
!!(accept_filter & QED_ACCEPT_NONE));
|
||||
|
||||
|
@ -1748,7 +1745,8 @@ static int qed_start_vport(struct qed_dev *cdev,
|
|||
start.vport_id, start.mtu);
|
||||
}
|
||||
|
||||
qed_reset_vport_stats(cdev);
|
||||
if (params->clear_stats)
|
||||
qed_reset_vport_stats(cdev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше
Загрузка…
Ссылка в новой задаче