Commit a84d2d29 authored by Linus Torvalds's avatar Linus Torvalds

Merge tag 'csky-for-linus-5.3-rc1' of git://github.com/c-sky/csky-linux

Pull arch/csky pupdates from Guo Ren:
 "This round of csky subsystem gives two features (ASID algorithm
  update, Perf pmu record support) and some fixups.

  ASID updates:
   - Revert mmu ASID mechanism
   - Add new asid lib code from arm
   - Use generic asid algorithm to implement switch_mm
   - Improve tlb operation with help of asid

  Perf pmu record support:
   - Init pmu as a device
   - Add count-width property for csky pmu
   - Add pmu interrupt support
   - Fix perf record in kernel/user space
   - dt-bindings: Add csky PMU bindings

  Fixes:
   - Fixup no panic in kernel for some traps
   - Fixup some error count in 810 & 860.
   - Fixup abiv1 memset error"

* tag 'csky-for-linus-5.3-rc1' of git://github.com/c-sky/csky-linux:
  csky: Fixup abiv1 memset error
  csky: Improve tlb operation with help of asid
  csky: Use generic asid algorithm to implement switch_mm
  csky: Add new asid lib code from arm
  csky: Revert mmu ASID mechanism
  dt-bindings: csky: Add csky PMU bindings
  dt-bindings: interrupt-controller: Update csky mpintc
  csky: Fixup some error count in 810 & 860.
  csky: Fix perf record in kernel/user space
  csky: Add pmu interrupt support
  csky: Add count-width property for csky pmu
  csky: Init pmu as a device
  csky: Fixup no panic in kernel for some traps
  csky: Select intc & timer drivers
parents b5d72dda bdfeb0cc
===============================
C-SKY Performance Monitor Units
===============================
C-SKY Performance Monitor is designed for ck807/ck810/ck860 SMP soc and
it could count cpu's events for helping analysis performance issues.
============================
PMU node bindings definition
============================
Description: Describes PMU
PROPERTIES
- compatible
Usage: required
Value type: <string>
Definition: must be "csky,csky-pmu"
- interrupts
Usage: required
Value type: <u32 IRQ_TYPE_XXX>
Definition: must be pmu irq num defined by soc
- count-width
Usage: optional
Value type: <u32>
Definition: the width of pmu counter
Examples:
---------
#include <dt-bindings/interrupt-controller/irq.h>
pmu: performace-monitor {
compatible = "csky,csky-pmu";
interrupts = <23 IRQ_TYPE_EDGE_RISING>;
interrupt-parent = <&intc>;
count-width = <48>;
};
...@@ -10,6 +10,9 @@ config CSKY ...@@ -10,6 +10,9 @@ config CSKY
select COMMON_CLK select COMMON_CLK
select CLKSRC_MMIO select CLKSRC_MMIO
select CLKSRC_OF select CLKSRC_OF
select CSKY_MPINTC if CPU_CK860
select CSKY_MP_TIMER if CPU_CK860
select CSKY_APB_INTC
select DMA_DIRECT_REMAP select DMA_DIRECT_REMAP
select IRQ_DOMAIN select IRQ_DOMAIN
select HANDLE_DOMAIN_IRQ select HANDLE_DOMAIN_IRQ
...@@ -30,6 +33,7 @@ config CSKY ...@@ -30,6 +33,7 @@ config CSKY
select GENERIC_IRQ_MULTI_HANDLER select GENERIC_IRQ_MULTI_HANDLER
select GENERIC_SCHED_CLOCK select GENERIC_SCHED_CLOCK
select GENERIC_SMP_IDLE_THREAD select GENERIC_SMP_IDLE_THREAD
select GX6605S_TIMER if CPU_CK610
select HAVE_ARCH_TRACEHOOK select HAVE_ARCH_TRACEHOOK
select HAVE_ARCH_AUDITSYSCALL select HAVE_ARCH_AUDITSYSCALL
select HAVE_DYNAMIC_FTRACE select HAVE_DYNAMIC_FTRACE
......
...@@ -5,5 +5,4 @@ obj-y += bswapsi.o ...@@ -5,5 +5,4 @@ obj-y += bswapsi.o
obj-y += cacheflush.o obj-y += cacheflush.o
obj-y += mmap.o obj-y += mmap.o
obj-y += memcpy.o obj-y += memcpy.o
obj-y += memset.o
obj-y += strksyms.o obj-y += strksyms.o
...@@ -78,6 +78,12 @@ static inline void tlb_invalid_all(void) ...@@ -78,6 +78,12 @@ static inline void tlb_invalid_all(void)
cpwcr("cpcr8", 0x04000000); cpwcr("cpcr8", 0x04000000);
} }
static inline void local_tlb_invalid_all(void)
{
tlb_invalid_all();
}
static inline void tlb_invalid_indexed(void) static inline void tlb_invalid_indexed(void)
{ {
cpwcr("cpcr8", 0x02000000); cpwcr("cpcr8", 0x02000000);
......
...@@ -7,7 +7,4 @@ ...@@ -7,7 +7,4 @@
#define __HAVE_ARCH_MEMCPY #define __HAVE_ARCH_MEMCPY
extern void *memcpy(void *, const void *, __kernel_size_t); extern void *memcpy(void *, const void *, __kernel_size_t);
#define __HAVE_ARCH_MEMSET
extern void *memset(void *, int, __kernel_size_t);
#endif /* __ABI_CSKY_STRING_H */ #endif /* __ABI_CSKY_STRING_H */
// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.
#include <linux/types.h>
void *memset(void *dest, int c, size_t l)
{
char *d = dest;
int ch = c & 0xff;
int tmp = (ch | ch << 8 | ch << 16 | ch << 24);
while (((uintptr_t)d & 0x3) && l--)
*d++ = ch;
while (l >= 16) {
*(((u32 *)d)) = tmp;
*(((u32 *)d)+1) = tmp;
*(((u32 *)d)+2) = tmp;
*(((u32 *)d)+3) = tmp;
l -= 16;
d += 16;
}
while (l > 3) {
*(((u32 *)d)) = tmp;
l -= 4;
d += 4;
}
while (l) {
*d = ch;
l--;
d++;
}
return dest;
}
...@@ -4,4 +4,3 @@ ...@@ -4,4 +4,3 @@
#include <linux/module.h> #include <linux/module.h>
EXPORT_SYMBOL(memcpy); EXPORT_SYMBOL(memcpy);
EXPORT_SYMBOL(memset);
...@@ -85,6 +85,16 @@ static inline void tlb_invalid_all(void) ...@@ -85,6 +85,16 @@ static inline void tlb_invalid_all(void)
#endif #endif
} }
static inline void local_tlb_invalid_all(void)
{
#ifdef CONFIG_CPU_HAS_TLBI
asm volatile("tlbi.all\n":::"memory");
sync_is();
#else
tlb_invalid_all();
#endif
}
static inline void tlb_invalid_indexed(void) static inline void tlb_invalid_indexed(void)
{ {
mtcr("cr<8, 15>", 0x02000000); mtcr("cr<8, 15>", 0x02000000);
......
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __ASM_ASM_ASID_H
#define __ASM_ASM_ASID_H
#include <linux/atomic.h>
#include <linux/compiler.h>
#include <linux/cpumask.h>
#include <linux/percpu.h>
#include <linux/spinlock.h>
struct asid_info
{
atomic64_t generation;
unsigned long *map;
atomic64_t __percpu *active;
u64 __percpu *reserved;
u32 bits;
/* Lock protecting the structure */
raw_spinlock_t lock;
/* Which CPU requires context flush on next call */
cpumask_t flush_pending;
/* Number of ASID allocated by context (shift value) */
unsigned int ctxt_shift;
/* Callback to locally flush the context. */
void (*flush_cpu_ctxt_cb)(void);
};
#define NUM_ASIDS(info) (1UL << ((info)->bits))
#define NUM_CTXT_ASIDS(info) (NUM_ASIDS(info) >> (info)->ctxt_shift)
#define active_asid(info, cpu) *per_cpu_ptr((info)->active, cpu)
void asid_new_context(struct asid_info *info, atomic64_t *pasid,
unsigned int cpu, struct mm_struct *mm);
/*
* Check the ASID is still valid for the context. If not generate a new ASID.
*
* @pasid: Pointer to the current ASID batch
* @cpu: current CPU ID. Must have been acquired throught get_cpu()
*/
static inline void asid_check_context(struct asid_info *info,
atomic64_t *pasid, unsigned int cpu,
struct mm_struct *mm)
{
u64 asid, old_active_asid;
asid = atomic64_read(pasid);
/*
* The memory ordering here is subtle.
* If our active_asid is non-zero and the ASID matches the current
* generation, then we update the active_asid entry with a relaxed
* cmpxchg. Racing with a concurrent rollover means that either:
*
* - We get a zero back from the cmpxchg and end up waiting on the
* lock. Taking the lock synchronises with the rollover and so
* we are forced to see the updated generation.
*
* - We get a valid ASID back from the cmpxchg, which means the
* relaxed xchg in flush_context will treat us as reserved
* because atomic RmWs are totally ordered for a given location.
*/
old_active_asid = atomic64_read(&active_asid(info, cpu));
if (old_active_asid &&
!((asid ^ atomic64_read(&info->generation)) >> info->bits) &&
atomic64_cmpxchg_relaxed(&active_asid(info, cpu),
old_active_asid, asid))
return;
asid_new_context(info, pasid, cpu, mm);
}
int asid_allocator_init(struct asid_info *info,
u32 bits, unsigned int asid_per_ctxt,
void (*flush_cpu_ctxt_cb)(void));
#endif
...@@ -5,7 +5,7 @@ ...@@ -5,7 +5,7 @@
#define __ASM_CSKY_MMU_H #define __ASM_CSKY_MMU_H
typedef struct { typedef struct {
unsigned long asid[NR_CPUS]; atomic64_t asid;
void *vdso; void *vdso;
} mm_context_t; } mm_context_t;
......
...@@ -16,122 +16,32 @@ ...@@ -16,122 +16,32 @@
#define TLBMISS_HANDLER_SETUP_PGD(pgd) \ #define TLBMISS_HANDLER_SETUP_PGD(pgd) \
setup_pgd(__pa(pgd), false) setup_pgd(__pa(pgd), false)
#define TLBMISS_HANDLER_SETUP_PGD_KERNEL(pgd) \ #define TLBMISS_HANDLER_SETUP_PGD_KERNEL(pgd) \
setup_pgd(__pa(pgd), true) setup_pgd(__pa(pgd), true)
#define cpu_context(cpu, mm) ((mm)->context.asid[cpu]) #define ASID_MASK ((1 << CONFIG_CPU_ASID_BITS) - 1)
#define cpu_asid(cpu, mm) (cpu_context((cpu), (mm)) & ASID_MASK) #define cpu_asid(mm) (atomic64_read(&mm->context.asid) & ASID_MASK)
#define asid_cache(cpu) (cpu_data[cpu].asid_cache)
#define ASID_FIRST_VERSION (1 << CONFIG_CPU_ASID_BITS) #define init_new_context(tsk,mm) ({ atomic64_set(&(mm)->context.asid, 0); 0; })
#define ASID_INC 0x1 #define activate_mm(prev,next) switch_mm(prev, next, current)
#define ASID_MASK (ASID_FIRST_VERSION - 1)
#define ASID_VERSION_MASK ~ASID_MASK
#define destroy_context(mm) do {} while (0) #define destroy_context(mm) do {} while (0)
#define enter_lazy_tlb(mm, tsk) do {} while (0) #define enter_lazy_tlb(mm, tsk) do {} while (0)
#define deactivate_mm(tsk, mm) do {} while (0) #define deactivate_mm(tsk, mm) do {} while (0)
/* void check_and_switch_context(struct mm_struct *mm, unsigned int cpu);
* All unused by hardware upper bits will be considered
* as a software asid extension.
*/
static inline void
get_new_mmu_context(struct mm_struct *mm, unsigned long cpu)
{
unsigned long asid = asid_cache(cpu);
asid += ASID_INC;
if (!(asid & ASID_MASK)) {
flush_tlb_all(); /* start new asid cycle */
if (!asid) /* fix version if needed */
asid = ASID_FIRST_VERSION;
}
cpu_context(cpu, mm) = asid_cache(cpu) = asid;
}
/*
* Initialize the context related info for a new mm_struct
* instance.
*/
static inline int
init_new_context(struct task_struct *tsk, struct mm_struct *mm)
{
int i;
for_each_online_cpu(i) static inline void
cpu_context(i, mm) = 0; switch_mm(struct mm_struct *prev, struct mm_struct *next,
return 0;
}
static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
struct task_struct *tsk) struct task_struct *tsk)
{ {
unsigned int cpu = smp_processor_id(); unsigned int cpu = smp_processor_id();
unsigned long flags;
local_irq_save(flags);
/* Check if our ASID is of an older version and thus invalid */
if ((cpu_context(cpu, next) ^ asid_cache(cpu)) & ASID_VERSION_MASK)
get_new_mmu_context(next, cpu);
write_mmu_entryhi(cpu_asid(cpu, next));
TLBMISS_HANDLER_SETUP_PGD(next->pgd);
/* if (prev != next)
* Mark current->active_mm as not "active" anymore. check_and_switch_context(next, cpu);
* We don't want to mislead possible IPI tlb flush routines.
*/
cpumask_clear_cpu(cpu, mm_cpumask(prev));
cpumask_set_cpu(cpu, mm_cpumask(next));
local_irq_restore(flags);
}
/*
* After we have set current->mm to a new value, this activates
* the context for the new mm so we see the new mappings.
*/
static inline void
activate_mm(struct mm_struct *prev, struct mm_struct *next)
{
unsigned long flags;
int cpu = smp_processor_id();
local_irq_save(flags);
/* Unconditionally get a new ASID. */
get_new_mmu_context(next, cpu);
write_mmu_entryhi(cpu_asid(cpu, next));
TLBMISS_HANDLER_SETUP_PGD(next->pgd); TLBMISS_HANDLER_SETUP_PGD(next->pgd);
write_mmu_entryhi(next->context.asid.counter);
/* mark mmu ownership change */
cpumask_clear_cpu(cpu, mm_cpumask(prev));
cpumask_set_cpu(cpu, mm_cpumask(next));
local_irq_restore(flags);
}
/*
* If mm is currently active_mm, we can't really drop it. Instead,
* we will get a new one for it.
*/
static inline void
drop_mmu_context(struct mm_struct *mm, unsigned int cpu)
{
unsigned long flags;
local_irq_save(flags);
if (cpumask_test_cpu(cpu, mm_cpumask(mm))) {
get_new_mmu_context(mm, cpu);
write_mmu_entryhi(cpu_asid(cpu, mm));
} else {
/* will get a new context next time */
cpu_context(cpu, mm) = 0;
}
local_irq_restore(flags);
} }
#endif /* __ASM_CSKY_MMU_CONTEXT_H */ #endif /* __ASM_CSKY_MMU_CONTEXT_H */
...@@ -290,8 +290,6 @@ static inline pte_t *pte_offset(pmd_t *dir, unsigned long address) ...@@ -290,8 +290,6 @@ static inline pte_t *pte_offset(pmd_t *dir, unsigned long address)
extern pgd_t swapper_pg_dir[PTRS_PER_PGD]; extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
extern void paging_init(void); extern void paging_init(void);
extern void show_jtlb_table(void);
void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, void update_mmu_cache(struct vm_area_struct *vma, unsigned long address,
pte_t *pte); pte_t *pte);
......
This diff is collapsed.
...@@ -212,8 +212,6 @@ void csky_start_secondary(void) ...@@ -212,8 +212,6 @@ void csky_start_secondary(void)
TLBMISS_HANDLER_SETUP_PGD(swapper_pg_dir); TLBMISS_HANDLER_SETUP_PGD(swapper_pg_dir);
TLBMISS_HANDLER_SETUP_PGD_KERNEL(swapper_pg_dir); TLBMISS_HANDLER_SETUP_PGD_KERNEL(swapper_pg_dir);
asid_cache(smp_processor_id()) = ASID_FIRST_VERSION;
#ifdef CONFIG_CPU_HAS_FPU #ifdef CONFIG_CPU_HAS_FPU
init_fpu(); init_fpu();
#endif #endif
......
...@@ -120,6 +120,7 @@ asmlinkage void trap_c(struct pt_regs *regs) ...@@ -120,6 +120,7 @@ asmlinkage void trap_c(struct pt_regs *regs)
switch (vector) { switch (vector) {
case VEC_ZERODIV: case VEC_ZERODIV:
die_if_kernel("Kernel mode ZERO DIV", regs, vector);
sig = SIGFPE; sig = SIGFPE;
break; break;
/* ptrace */ /* ptrace */
...@@ -128,6 +129,7 @@ asmlinkage void trap_c(struct pt_regs *regs) ...@@ -128,6 +129,7 @@ asmlinkage void trap_c(struct pt_regs *regs)
sig = SIGTRAP; sig = SIGTRAP;
break; break;
case VEC_ILLEGAL: case VEC_ILLEGAL:
die_if_kernel("Kernel mode ILLEGAL", regs, vector);
#ifndef CONFIG_CPU_NO_USER_BKPT #ifndef CONFIG_CPU_NO_USER_BKPT
if (*(uint16_t *)instruction_pointer(regs) != USR_BKPT) if (*(uint16_t *)instruction_pointer(regs) != USR_BKPT)
#endif #endif
...@@ -139,6 +141,7 @@ asmlinkage void trap_c(struct pt_regs *regs) ...@@ -139,6 +141,7 @@ asmlinkage void trap_c(struct pt_regs *regs)
case VEC_TRAP1: case VEC_TRAP1:
/* jtagserver breakpoint */ /* jtagserver breakpoint */
case VEC_BREAKPOINT: case VEC_BREAKPOINT:
die_if_kernel("Kernel mode BKPT", regs, vector);
info.si_code = TRAP_BRKPT; info.si_code = TRAP_BRKPT;
sig = SIGTRAP; sig = SIGTRAP;
break; break;
...@@ -150,8 +153,10 @@ asmlinkage void trap_c(struct pt_regs *regs) ...@@ -150,8 +153,10 @@ asmlinkage void trap_c(struct pt_regs *regs)
#endif #endif
#ifdef CONFIG_CPU_HAS_FPU #ifdef CONFIG_CPU_HAS_FPU
case VEC_FPE: case VEC_FPE:
die_if_kernel("Kernel mode FPE", regs, vector);
return fpu_fpe(regs); return fpu_fpe(regs);
case VEC_PRIV: case VEC_PRIV:
die_if_kernel("Kernel mode PRIV", regs, vector);
if (fpu_libc_helper(regs)) if (fpu_libc_helper(regs))
return; return;
#endif #endif
......
...@@ -12,3 +12,5 @@ obj-y += init.o ...@@ -12,3 +12,5 @@ obj-y += init.o
obj-y += ioremap.o obj-y += ioremap.o
obj-y += syscache.o obj-y += syscache.o
obj-y += tlb.o obj-y += tlb.o
obj-y += asid.o
obj-y += context.o
// SPDX-License-Identifier: GPL-2.0
/*
* Generic ASID allocator.
*
* Based on arch/arm/mm/context.c
*
* Copyright (C) 2002-2003 Deep Blue Solutions Ltd, all rights reserved.
* Copyright (C) 2012 ARM Ltd.
*/
#include <linux/slab.h>
#include <linux/mm_types.h>
#include <asm/asid.h>
#define reserved_asid(info, cpu) *per_cpu_ptr((info)->reserved, cpu)
#define ASID_MASK(info) (~GENMASK((info)->bits - 1, 0))
#define ASID_FIRST_VERSION(info) (1UL << ((info)->bits))
#define asid2idx(info, asid) (((asid) & ~ASID_MASK(info)) >> (info)->ctxt_shift)
#define idx2asid(info, idx) (((idx) << (info)->ctxt_shift) & ~ASID_MASK(info))
static void flush_context(struct asid_info *info)
{
int i;
u64 asid;
/* Update the list of reserved ASIDs and the ASID bitmap. */
bitmap_clear(info->map, 0, NUM_CTXT_ASIDS(info));
for_each_possible_cpu(i) {
asid = atomic64_xchg_relaxed(&active_asid(info, i), 0);
/*
* If this CPU has already been through a
* rollover, but hasn't run another task in
* the meantime, we must preserve its reserved
* ASID, as this is the only trace we have of
* the process it is still running.
*/
if (asid == 0)
asid = reserved_asid(info, i);
__set_bit(asid2idx(info, asid), info->map);
reserved_asid(info, i) = asid;
}
/*
* Queue a TLB invalidation for each CPU to perform on next
* context-switch
*/
cpumask_setall(&info->flush_pending);
}
static bool check_update_reserved_asid(struct asid_info *info, u64 asid,
u64 newasid)
{
int cpu;
bool hit = false;
/*
* Iterate over the set of reserved ASIDs looking for a match.
* If we find one, then we can update our mm to use newasid
* (i.e. the same ASID in the current generation) but we can't
* exit the loop early, since we need to ensure that all copies
* of the old ASID are updated to reflect the mm. Failure to do
* so could result in us missing the reserved ASID in a future
* generation.
*/
for_each_possible_cpu(cpu) {
if (reserved_asid(info, cpu) == asid) {
hit = true;
reserved_asid(info, cpu) = newasid;
}
}
return hit;
}
static u64 new_context(struct asid_info *info, atomic64_t *pasid,
struct mm_struct *mm)
{
static u32 cur_idx = 1;
u64 asid = atomic64_read(pasid);
u64 generation = atomic64_read(&info->generation);
if (asid != 0) {
u64 newasid = generation | (asid & ~ASID_MASK(info));
/*
* If our current ASID was active during a rollover, we
* can continue to use it and this was just a false alarm.
*/
if (check_update_reserved_asid(info, asid, newasid))
return newasid;
/*
* We had a valid ASID in a previous life, so try to re-use
* it if possible.
*/
if (!__test_and_set_bit(asid2idx(info, asid), info->map))
return newasid;
}
/*
* Allocate a free ASID. If we can't find one, take a note of the
* currently active ASIDs and mark the TLBs as requiring flushes. We
* always count from ASID #2 (index 1), as we use ASID #0 when setting
* a reserved TTBR0 for the init_mm and we allocate ASIDs in even/odd
* pairs.
*/
asid = find_next_zero_bit(info->map, NUM_CTXT_ASIDS(info), cur_idx);
if (asid != NUM_CTXT_ASIDS(info))
goto set_asid;
/* We're out of ASIDs, so increment the global generation count */
generation = atomic64_add_return_relaxed(ASID_FIRST_VERSION(info),
&info->generation);
flush_context(info);
/* We have more ASIDs than CPUs, so this will always succeed */
asid = find_next_zero_bit(info->map, NUM_CTXT_ASIDS(info), 1);
set_asid:
__set_bit(asid, info->map);
cur_idx = asid;
cpumask_clear(mm_cpumask(mm));
return idx2asid(info, asid) | generation;
}
/*
* Generate a new ASID for the context.
*
* @pasid: Pointer to the current ASID batch allocated. It will be updated
* with the new ASID batch.
* @cpu: current CPU ID. Must have been acquired through get_cpu()
*/
void asid_new_context(struct asid_info *info, atomic64_t *pasid,
unsigned int cpu, struct mm_struct *mm)
{
unsigned long flags;
u64 asid;
raw_spin_lock_irqsave(&info->lock, flags);
/* Check that our ASID belongs to the current generation. */
asid = atomic64_read(pasid);
if ((asid ^ atomic64_read(&info->generation)) >> info->bits) {
asid = new_context(info, pasid, mm);
atomic64_set(pasid, asid);
}
if (cpumask_test_and_clear_cpu(cpu, &info->flush_pending))
info->flush_cpu_ctxt_cb();
atomic64_set(&active_asid(info, cpu), asid);
cpumask_set_cpu(cpu, mm_cpumask(mm));
raw_spin_unlock_irqrestore(&info->lock, flags);
}
/*
* Initialize the ASID allocator
*
* @info: Pointer to the asid allocator structure
* @bits: Number of ASIDs available
* @asid_per_ctxt: Number of ASIDs to allocate per-context. ASIDs are
* allocated contiguously for a given context. This value should be a power of
* 2.
*/
int asid_allocator_init(struct asid_info *info,
u32 bits, unsigned int asid_per_ctxt,
void (*flush_cpu_ctxt_cb)(void))
{
info->bits = bits;
info->ctxt_shift = ilog2(asid_per_ctxt);
info->flush_cpu_ctxt_cb = flush_cpu_ctxt_cb;
/*
* Expect allocation after rollover to fail if we don't have at least
* one more ASID than CPUs. ASID #0 is always reserved.
*/
WARN_ON(NUM_CTXT_ASIDS(info) - 1 <= num_possible_cpus());
atomic64_set(&info->generation, ASID_FIRST_VERSION(info));
info->map = kcalloc(BITS_TO_LONGS(NUM_CTXT_ASIDS(info)),
sizeof(*info->map), GFP_KERNEL);
if (!info->map)
return -ENOMEM;
raw_spin_lock_init(&info->lock);
return 0;
}
// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2018 Hangzhou C-SKY Microsystems co.,ltd.
#include <linux/bitops.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <asm/asid.h>
#include <asm/mmu_context.h>
#include <asm/smp.h>
#include <asm/tlbflush.h>
static DEFINE_PER_CPU(atomic64_t, active_asids);
static DEFINE_PER_CPU(u64, reserved_asids);
struct asid_info asid_info;
void check_and_switch_context(struct mm_struct *mm, unsigned int cpu)
{
asid_check_context(&asid_info, &mm->context.asid, cpu, mm);
}
static void asid_flush_cpu_ctxt(void)
{
local_tlb_invalid_all();
}
static int asids_init(void)
{
BUG_ON(((1 << CONFIG_CPU_ASID_BITS) - 1) <= num_possible_cpus());
if (asid_allocator_init(&asid_info, CONFIG_CPU_ASID_BITS, 1,
asid_flush_cpu_ctxt))
panic("Unable to initialize ASID allocator for %lu ASIDs\n",
NUM_ASIDS(&asid_info));
asid_info.active = &active_asids;
asid_info.reserved = &reserved_asids;
pr_info("ASID allocator initialised with %lu entries\n",
NUM_CTXT_ASIDS(&asid_info));
return 0;
}
early_initcall(asids_init);
...@@ -114,8 +114,6 @@ void __init pre_mmu_init(void) ...@@ -114,8 +114,6 @@ void __init pre_mmu_init(void)
TLBMISS_HANDLER_SETUP_PGD(swapper_pg_dir); TLBMISS_HANDLER_SETUP_PGD(swapper_pg_dir);
TLBMISS_HANDLER_SETUP_PGD_KERNEL(swapper_pg_dir); TLBMISS_HANDLER_SETUP_PGD_KERNEL(swapper_pg_dir);
asid_cache(smp_processor_id()) = ASID_FIRST_VERSION;
/* Setup page mask to 4k */ /* Setup page mask to 4k */
write_mmu_pagemask(0); write_mmu_pagemask(0);
} }
...@@ -10,7 +10,12 @@ ...@@ -10,7 +10,12 @@
#include <asm/pgtable.h> #include <asm/pgtable.h>
#include <asm/setup.h> #include <asm/setup.h>
#define CSKY_TLB_SIZE CONFIG_CPU_TLB_SIZE /*
* One C-SKY MMU TLB entry contain two PFN/page entry, ie:
* 1VPN -> 2PFN
*/
#define TLB_ENTRY_SIZE (PAGE_SIZE * 2)
#define TLB_ENTRY_SIZE_MASK (PAGE_MASK << 1)
void flush_tlb_all(void) void flush_tlb_all(void)
{ {
...@@ -19,119 +24,105 @@ void flush_tlb_all(void) ...@@ -19,119 +24,105 @@ void flush_tlb_all(void)
void flush_tlb_mm(struct mm_struct *mm) void flush_tlb_mm(struct mm_struct *mm)
{ {
int cpu = smp_processor_id(); #ifdef CONFIG_CPU_HAS_TLBI
asm volatile("tlbi.asids %0"::"r"(cpu_asid(mm)));
if (cpu_context(cpu, mm) != 0) #else
drop_mmu_context(mm, cpu);
tlb_invalid_all(); tlb_invalid_all();
#endif
} }
/*
* MMU operation regs only could invalid tlb entry in jtlb and we
* need change asid field to invalid I-utlb & D-utlb.
*/
#ifndef CONFIG_CPU_HAS_TLBI
#define restore_asid_inv_utlb(oldpid, newpid) \ #define restore_asid_inv_utlb(oldpid, newpid) \
do { \ do { \
if ((oldpid & ASID_MASK) == newpid) \ if (oldpid == newpid) \
write_mmu_entryhi(oldpid + 1); \ write_mmu_entryhi(oldpid + 1); \
write_mmu_entryhi(oldpid); \ write_mmu_entryhi(oldpid); \
} while (0) } while (0)
#endif
void flush_tlb_range(struct vm_area_struct *vma, unsigned long start, void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
unsigned long end) unsigned long end)
{ {
struct mm_struct *mm = vma->vm_mm; unsigned long newpid = cpu_asid(vma->vm_mm);
int cpu = smp_processor_id();
if (cpu_context(cpu, mm) != 0) { start &= TLB_ENTRY_SIZE_MASK;
unsigned long size, flags; end += TLB_ENTRY_SIZE - 1;
int newpid = cpu_asid(cpu, mm); end &= TLB_ENTRY_SIZE_MASK;
local_irq_save(flags);
size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
size = (size + 1) >> 1;
if (size <= CSKY_TLB_SIZE/2) {
start &= (PAGE_MASK << 1);
end += ((PAGE_SIZE << 1) - 1);
end &= (PAGE_MASK << 1);
#ifdef CONFIG_CPU_HAS_TLBI #ifdef CONFIG_CPU_HAS_TLBI
while (start < end) { while (start < end) {
asm volatile("tlbi.vaas %0" asm volatile("tlbi.vas %0"::"r"(start | newpid));
::"r"(start | newpid)); start += 2*PAGE_SIZE;
start += (PAGE_SIZE << 1);
} }
sync_is(); sync_is();
#else #else
{ {
int oldpid = read_mmu_entryhi(); unsigned long flags, oldpid;
local_irq_save(flags);
oldpid = read_mmu_entryhi() & ASID_MASK;
while (start < end) { while (start < end) {
int idx; int idx;
write_mmu_entryhi(start | newpid); write_mmu_entryhi(start | newpid);
start += (PAGE_SIZE << 1); start += 2*PAGE_SIZE;
tlb_probe(); tlb_probe();
idx = read_mmu_index(); idx = read_mmu_index();
if (idx >= 0) if (idx >= 0)
tlb_invalid_indexed(); tlb_invalid_indexed();
} }
restore_asid_inv_utlb(oldpid, newpid); restore_asid_inv_utlb(oldpid, newpid);
}
#endif
} else {
drop_mmu_context(mm, cpu);
}
local_irq_restore(flags); local_irq_restore(flags);
} }
#endif
} }
void flush_tlb_kernel_range(unsigned long start, unsigned long end) void flush_tlb_kernel_range(unsigned long start, unsigned long end)
{ {
unsigned long size, flags; start &= TLB_ENTRY_SIZE_MASK;
end += TLB_ENTRY_SIZE - 1;
end &= TLB_ENTRY_SIZE_MASK;
local_irq_save(flags);
size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
if (size <= CSKY_TLB_SIZE) {
start &= (PAGE_MASK << 1);
end += ((PAGE_SIZE << 1) - 1);
end &= (PAGE_MASK << 1);
#ifdef CONFIG_CPU_HAS_TLBI #ifdef CONFIG_CPU_HAS_TLBI
while (start < end) { while (start < end) {
asm volatile("tlbi.vaas %0"::"r"(start)); asm volatile("tlbi.vaas %0"::"r"(start));
start += (PAGE_SIZE << 1); start += 2*PAGE_SIZE;
} }
sync_is(); sync_is();
#else #else
{ {
int oldpid = read_mmu_entryhi(); unsigned long flags, oldpid;
local_irq_save(flags);
oldpid = read_mmu_entryhi() & ASID_MASK;
while (start < end) { while (start < end) {
int idx; int idx;
write_mmu_entryhi(start); write_mmu_entryhi(start | oldpid);
start += (PAGE_SIZE << 1); start += 2*PAGE_SIZE;
tlb_probe(); tlb_probe();
idx = read_mmu_index(); idx = read_mmu_index();
if (idx >= 0) if (idx >= 0)
tlb_invalid_indexed(); tlb_invalid_indexed();
} }
restore_asid_inv_utlb(oldpid, 0); restore_asid_inv_utlb(oldpid, oldpid);
local_irq_restore(flags);
} }
#endif #endif
} else {
flush_tlb_all();
}
local_irq_restore(flags);
} }
void flush_tlb_page(struct vm_area_struct *vma, unsigned long page) void flush_tlb_page(struct vm_area_struct *vma, unsigned long addr)
{ {
int cpu = smp_processor_id(); int newpid = cpu_asid(vma->vm_mm);
int newpid = cpu_asid(cpu, vma->vm_mm);
if (!vma || cpu_context(cpu, vma->vm_mm) != 0) { addr &= TLB_ENTRY_SIZE_MASK;
page &= (PAGE_MASK << 1);
#ifdef CONFIG_CPU_HAS_TLBI #ifdef CONFIG_CPU_HAS_TLBI
asm volatile("tlbi.vaas %0"::"r"(page | newpid)); asm volatile("tlbi.vas %0"::"r"(addr | newpid));
sync_is(); sync_is();
#else #else
{ {
...@@ -139,8 +130,8 @@ void flush_tlb_page(struct vm_area_struct *vma, unsigned long page) ...@@ -139,8 +130,8 @@ void flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
unsigned long flags; unsigned long flags;
local_irq_save(flags); local_irq_save(flags);
oldpid = read_mmu_entryhi(); oldpid = read_mmu_entryhi() & ASID_MASK;
write_mmu_entryhi(page | newpid); write_mmu_entryhi(addr | newpid);
tlb_probe(); tlb_probe();
idx = read_mmu_index(); idx = read_mmu_index();
if (idx >= 0) if (idx >= 0)
...@@ -150,70 +141,31 @@ void flush_tlb_page(struct vm_area_struct *vma, unsigned long page) ...@@ -150,70 +141,31 @@ void flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
local_irq_restore(flags); local_irq_restore(flags);
} }
#endif #endif
}
} }
/* void flush_tlb_one(unsigned long addr)
* Remove one kernel space TLB entry. This entry is assumed to be marked
* global so we don't do the ASID thing.
*/
void flush_tlb_one(unsigned long page)
{ {
int oldpid; addr &= TLB_ENTRY_SIZE_MASK;
oldpid = read_mmu_entryhi();
page &= (PAGE_MASK << 1);
#ifdef CONFIG_CPU_HAS_TLBI #ifdef CONFIG_CPU_HAS_TLBI
page = page | (oldpid & 0xfff); asm volatile("tlbi.vaas %0"::"r"(addr));
asm volatile("tlbi.vaas %0"::"r"(page));
sync_is(); sync_is();
#else #else
{ {
int idx; int oldpid, idx;
unsigned long flags; unsigned long flags;
page = page | (oldpid & 0xff);
local_irq_save(flags); local_irq_save(flags);
write_mmu_entryhi(page); oldpid = read_mmu_entryhi() & ASID_MASK;
write_mmu_entryhi(addr | oldpid);
tlb_probe(); tlb_probe();
idx = read_mmu_index(); idx = read_mmu_index();
if (idx >= 0) if (idx >= 0)
tlb_invalid_indexed(); tlb_invalid_indexed();
restore_asid_inv_utlb(oldpid, oldpid); restore_asid_inv_utlb(oldpid, oldpid);
local_irq_restore(flags); local_irq_restore(flags);
} }
#endif #endif
} }
EXPORT_SYMBOL(flush_tlb_one); EXPORT_SYMBOL(flush_tlb_one);
/* show current 32 jtlbs */
void show_jtlb_table(void)
{
unsigned long flags;
int entryhi, entrylo0, entrylo1;
int entry;
int oldpid;
local_irq_save(flags);
entry = 0;
pr_info("\n\n\n");
oldpid = read_mmu_entryhi();
while (entry < CSKY_TLB_SIZE) {
write_mmu_index(entry);
tlb_read();
entryhi = read_mmu_entryhi();
entrylo0 = read_mmu_entrylo0();
entrylo0 = entrylo0;
entrylo1 = read_mmu_entrylo1();
entrylo1 = entrylo1;
pr_info("jtlb[%d]: entryhi - 0x%x; entrylo0 - 0x%x;"
" entrylo1 - 0x%x\n",
entry, entryhi, entrylo0, entrylo1);
entry++;
}
write_mmu_entryhi(oldpid);
local_irq_restore(flags);
}
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment