2013-01-18 09:42:19 +00:00
|
|
|
/*
|
2015-06-04 10:05:53 +00:00
|
|
|
* ARC Cache Management
|
2013-01-18 09:42:19 +00:00
|
|
|
*
|
2015-06-04 10:05:53 +00:00
|
|
|
* Copyright (C) 2014-15 Synopsys, Inc. (www.synopsys.com)
|
2013-01-18 09:42:19 +00:00
|
|
|
* Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/cache.h>
|
|
|
|
#include <linux/mmu_context.h>
|
|
|
|
#include <linux/syscalls.h>
|
|
|
|
#include <linux/uaccess.h>
|
2013-05-09 16:24:51 +00:00
|
|
|
#include <linux/pagemap.h>
|
2013-01-18 09:42:19 +00:00
|
|
|
#include <asm/cacheflush.h>
|
|
|
|
#include <asm/cachectl.h>
|
|
|
|
#include <asm/setup.h>
|
|
|
|
|
2014-08-29 05:25:15 +00:00
|
|
|
#ifdef CONFIG_ISA_ARCV2
|
|
|
|
#define USE_RGN_FLSH 1
|
|
|
|
#endif
|
|
|
|
|
2015-04-03 09:37:07 +00:00
|
|
|
static int l2_line_sz;
|
2016-10-13 22:58:59 +00:00
|
|
|
static int ioc_exists;
|
2017-01-17 19:09:18 +00:00
|
|
|
int slc_enable = 1, ioc_enable = 1;
|
2015-10-24 14:01:16 +00:00
|
|
|
unsigned long perip_base = ARC_UNCACHED_ADDR_SPACE; /* legacy value for boot */
|
2016-08-26 22:41:29 +00:00
|
|
|
unsigned long perip_end = 0xFFFFFFFF; /* legacy value */
|
2015-04-03 09:37:07 +00:00
|
|
|
|
2015-09-15 01:43:42 +00:00
|
|
|
void (*_cache_line_loop_ic_fn)(phys_addr_t paddr, unsigned long vaddr,
|
2017-01-24 03:32:23 +00:00
|
|
|
unsigned long sz, const int op, const int full_page);
|
2015-06-04 09:09:15 +00:00
|
|
|
|
2016-03-16 09:34:39 +00:00
|
|
|
void (*__dma_cache_wback_inv)(phys_addr_t start, unsigned long sz);
|
|
|
|
void (*__dma_cache_inv)(phys_addr_t start, unsigned long sz);
|
|
|
|
void (*__dma_cache_wback)(phys_addr_t start, unsigned long sz);
|
2015-05-25 16:54:28 +00:00
|
|
|
|
2014-02-24 03:42:50 +00:00
|
|
|
char *arc_cache_mumbojumbo(int c, char *buf, int len)
|
2013-01-18 09:42:24 +00:00
|
|
|
{
|
|
|
|
int n = 0;
|
2015-04-06 11:53:57 +00:00
|
|
|
struct cpuinfo_arc_cache *p;
|
2013-01-18 09:42:24 +00:00
|
|
|
|
2014-06-27 10:19:47 +00:00
|
|
|
#define PR_CACHE(p, cfg, str) \
|
2016-12-19 19:24:08 +00:00
|
|
|
if (!(p)->line_len) \
|
2013-01-18 09:42:24 +00:00
|
|
|
n += scnprintf(buf + n, len - n, str"\t\t: N/A\n"); \
|
|
|
|
else \
|
|
|
|
n += scnprintf(buf + n, len - n, \
|
2014-06-27 10:19:47 +00:00
|
|
|
str"\t\t: %uK, %dway/set, %uB Line, %s%s%s\n", \
|
|
|
|
(p)->sz_k, (p)->assoc, (p)->line_len, \
|
|
|
|
(p)->vipt ? "VIPT" : "PIPT", \
|
|
|
|
(p)->alias ? " aliasing" : "", \
|
2015-10-02 13:50:27 +00:00
|
|
|
IS_USED_CFG(cfg));
|
2013-01-18 09:42:24 +00:00
|
|
|
|
2014-06-27 10:19:47 +00:00
|
|
|
PR_CACHE(&cpuinfo_arc700[c].icache, CONFIG_ARC_HAS_ICACHE, "I-Cache");
|
|
|
|
PR_CACHE(&cpuinfo_arc700[c].dcache, CONFIG_ARC_HAS_DCACHE, "D-Cache");
|
2013-01-18 09:42:24 +00:00
|
|
|
|
2015-04-06 11:53:57 +00:00
|
|
|
p = &cpuinfo_arc700[c].slc;
|
2016-12-19 19:24:08 +00:00
|
|
|
if (p->line_len)
|
2015-04-06 11:53:57 +00:00
|
|
|
n += scnprintf(buf + n, len - n,
|
2015-06-04 13:00:23 +00:00
|
|
|
"SLC\t\t: %uK, %uB Line%s\n",
|
|
|
|
p->sz_k, p->line_len, IS_USED_RUN(slc_enable));
|
2015-04-06 11:53:57 +00:00
|
|
|
|
2016-10-13 22:53:02 +00:00
|
|
|
n += scnprintf(buf + n, len - n, "Peripherals\t: %#lx%s%s\n",
|
|
|
|
perip_base,
|
|
|
|
IS_AVAIL3(ioc_exists, ioc_enable, ", IO-Coherency "));
|
2015-05-25 16:54:28 +00:00
|
|
|
|
2013-01-18 09:42:24 +00:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
/*
|
|
|
|
* Read the Cache Build Confuration Registers, Decode them and save into
|
|
|
|
* the cpuinfo structure for later use.
|
|
|
|
* No Validation done here, simply read/convert the BCRs
|
|
|
|
*/
|
2015-08-21 09:36:43 +00:00
|
|
|
static void read_decode_cache_bcr_arcv2(int cpu)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
2015-08-21 09:36:43 +00:00
|
|
|
struct cpuinfo_arc_cache *p_slc = &cpuinfo_arc700[cpu].slc;
|
2015-04-06 11:53:57 +00:00
|
|
|
struct bcr_generic sbcr;
|
|
|
|
|
|
|
|
struct bcr_slc_cfg {
|
|
|
|
#ifdef CONFIG_CPU_BIG_ENDIAN
|
|
|
|
unsigned int pad:24, way:2, lsz:2, sz:4;
|
|
|
|
#else
|
|
|
|
unsigned int sz:4, lsz:2, way:2, pad:24;
|
|
|
|
#endif
|
|
|
|
} slc_cfg;
|
|
|
|
|
2015-05-25 16:54:28 +00:00
|
|
|
struct bcr_clust_cfg {
|
|
|
|
#ifdef CONFIG_CPU_BIG_ENDIAN
|
|
|
|
unsigned int pad:7, c:1, num_entries:8, num_cores:8, ver:8;
|
|
|
|
#else
|
|
|
|
unsigned int ver:8, num_cores:8, num_entries:8, c:1, pad:7;
|
|
|
|
#endif
|
|
|
|
} cbcr;
|
|
|
|
|
2016-08-26 22:41:29 +00:00
|
|
|
struct bcr_volatile {
|
|
|
|
#ifdef CONFIG_CPU_BIG_ENDIAN
|
|
|
|
unsigned int start:4, limit:4, pad:22, order:1, disable:1;
|
|
|
|
#else
|
|
|
|
unsigned int disable:1, order:1, pad:22, limit:4, start:4;
|
|
|
|
#endif
|
|
|
|
} vol;
|
|
|
|
|
|
|
|
|
2015-08-21 09:36:43 +00:00
|
|
|
READ_BCR(ARC_REG_SLC_BCR, sbcr);
|
|
|
|
if (sbcr.ver) {
|
|
|
|
READ_BCR(ARC_REG_SLC_CFG, slc_cfg);
|
|
|
|
p_slc->sz_k = 128 << slc_cfg.sz;
|
|
|
|
l2_line_sz = p_slc->line_len = (slc_cfg.lsz == 0) ? 128 : 64;
|
|
|
|
}
|
|
|
|
|
|
|
|
READ_BCR(ARC_REG_CLUSTER_BCR, cbcr);
|
2016-10-13 22:58:59 +00:00
|
|
|
if (cbcr.c)
|
2015-08-21 09:36:43 +00:00
|
|
|
ioc_exists = 1;
|
2016-10-13 22:58:59 +00:00
|
|
|
else
|
|
|
|
ioc_enable = 0;
|
2015-10-24 14:01:16 +00:00
|
|
|
|
2016-08-26 22:41:29 +00:00
|
|
|
/* HS 2.0 didn't have AUX_VOL */
|
|
|
|
if (cpuinfo_arc700[cpu].core.family > 0x51) {
|
|
|
|
READ_BCR(AUX_VOL, vol);
|
|
|
|
perip_base = vol.start << 28;
|
|
|
|
/* HS 3.0 has limit and strict-ordering fields */
|
|
|
|
if (cpuinfo_arc700[cpu].core.family > 0x52)
|
|
|
|
perip_end = (vol.limit << 28) - 1;
|
|
|
|
}
|
2015-08-21 09:36:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void read_decode_cache_bcr(void)
|
|
|
|
{
|
|
|
|
struct cpuinfo_arc_cache *p_ic, *p_dc;
|
|
|
|
unsigned int cpu = smp_processor_id();
|
|
|
|
struct bcr_cache {
|
|
|
|
#ifdef CONFIG_CPU_BIG_ENDIAN
|
|
|
|
unsigned int pad:12, line_len:4, sz:4, config:4, ver:8;
|
|
|
|
#else
|
|
|
|
unsigned int ver:8, config:4, sz:4, line_len:4, pad:12;
|
|
|
|
#endif
|
|
|
|
} ibcr, dbcr;
|
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
p_ic = &cpuinfo_arc700[cpu].icache;
|
|
|
|
READ_BCR(ARC_REG_IC_BCR, ibcr);
|
|
|
|
|
2014-06-27 10:19:47 +00:00
|
|
|
if (!ibcr.ver)
|
|
|
|
goto dc_chk;
|
|
|
|
|
2015-04-06 11:53:57 +00:00
|
|
|
if (ibcr.ver <= 3) {
|
|
|
|
BUG_ON(ibcr.config != 3);
|
|
|
|
p_ic->assoc = 2; /* Fixed to 2w set assoc */
|
|
|
|
} else if (ibcr.ver >= 4) {
|
|
|
|
p_ic->assoc = 1 << ibcr.config; /* 1,2,4,8 */
|
|
|
|
}
|
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
p_ic->line_len = 8 << ibcr.line_len;
|
2014-06-27 10:19:47 +00:00
|
|
|
p_ic->sz_k = 1 << (ibcr.sz - 1);
|
|
|
|
p_ic->vipt = 1;
|
|
|
|
p_ic->alias = p_ic->sz_k/p_ic->assoc/TO_KB(PAGE_SIZE) > 1;
|
2013-01-18 09:42:19 +00:00
|
|
|
|
2014-06-27 10:19:47 +00:00
|
|
|
dc_chk:
|
2013-01-18 09:42:19 +00:00
|
|
|
p_dc = &cpuinfo_arc700[cpu].dcache;
|
|
|
|
READ_BCR(ARC_REG_DC_BCR, dbcr);
|
|
|
|
|
2014-06-27 10:19:47 +00:00
|
|
|
if (!dbcr.ver)
|
2015-04-06 11:53:57 +00:00
|
|
|
goto slc_chk;
|
|
|
|
|
|
|
|
if (dbcr.ver <= 3) {
|
|
|
|
BUG_ON(dbcr.config != 2);
|
|
|
|
p_dc->assoc = 4; /* Fixed to 4w set assoc */
|
|
|
|
p_dc->vipt = 1;
|
|
|
|
p_dc->alias = p_dc->sz_k/p_dc->assoc/TO_KB(PAGE_SIZE) > 1;
|
|
|
|
} else if (dbcr.ver >= 4) {
|
|
|
|
p_dc->assoc = 1 << dbcr.config; /* 1,2,4,8 */
|
|
|
|
p_dc->vipt = 0;
|
|
|
|
p_dc->alias = 0; /* PIPT so can't VIPT alias */
|
|
|
|
}
|
2014-06-27 10:19:47 +00:00
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
p_dc->line_len = 16 << dbcr.line_len;
|
2014-06-27 10:19:47 +00:00
|
|
|
p_dc->sz_k = 1 << (dbcr.sz - 1);
|
2015-04-06 11:53:57 +00:00
|
|
|
|
|
|
|
slc_chk:
|
2015-08-21 09:36:43 +00:00
|
|
|
if (is_isa_arcv2())
|
|
|
|
read_decode_cache_bcr_arcv2(cpu);
|
2013-01-18 09:42:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-06-04 10:05:53 +00:00
|
|
|
* Line Operation on {I,D}-Cache
|
2013-01-18 09:42:19 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#define OP_INV 0x1
|
|
|
|
#define OP_FLUSH 0x2
|
|
|
|
#define OP_FLUSH_N_INV 0x3
|
2013-09-05 08:13:03 +00:00
|
|
|
#define OP_INV_IC 0x4
|
|
|
|
|
|
|
|
/*
|
2015-06-04 10:05:53 +00:00
|
|
|
* I-Cache Aliasing in ARC700 VIPT caches (MMU v1-v3)
|
|
|
|
*
|
|
|
|
* ARC VIPT I-cache uses vaddr to index into cache and paddr to match the tag.
|
|
|
|
* The orig Cache Management Module "CDU" only required paddr to invalidate a
|
|
|
|
* certain line since it sufficed as index in Non-Aliasing VIPT cache-geometry.
|
|
|
|
* Infact for distinct V1,V2,P: all of {V1-P},{V2-P},{P-P} would end up fetching
|
|
|
|
* the exact same line.
|
|
|
|
*
|
|
|
|
* However for larger Caches (way-size > page-size) - i.e. in Aliasing config,
|
|
|
|
* paddr alone could not be used to correctly index the cache.
|
|
|
|
*
|
|
|
|
* ------------------
|
|
|
|
* MMU v1/v2 (Fixed Page Size 8k)
|
|
|
|
* ------------------
|
|
|
|
* The solution was to provide CDU with these additonal vaddr bits. These
|
|
|
|
* would be bits [x:13], x would depend on cache-geometry, 13 comes from
|
|
|
|
* standard page size of 8k.
|
|
|
|
* H/w folks chose [17:13] to be a future safe range, and moreso these 5 bits
|
|
|
|
* of vaddr could easily be "stuffed" in the paddr as bits [4:0] since the
|
|
|
|
* orig 5 bits of paddr were anyways ignored by CDU line ops, as they
|
|
|
|
* represent the offset within cache-line. The adv of using this "clumsy"
|
|
|
|
* interface for additional info was no new reg was needed in CDU programming
|
|
|
|
* model.
|
|
|
|
*
|
|
|
|
* 17:13 represented the max num of bits passable, actual bits needed were
|
|
|
|
* fewer, based on the num-of-aliases possible.
|
|
|
|
* -for 2 alias possibility, only bit 13 needed (32K cache)
|
|
|
|
* -for 4 alias possibility, bits 14:13 needed (64K cache)
|
|
|
|
*
|
|
|
|
* ------------------
|
|
|
|
* MMU v3
|
|
|
|
* ------------------
|
|
|
|
* This ver of MMU supports variable page sizes (1k-16k): although Linux will
|
|
|
|
* only support 8k (default), 16k and 4k.
|
2016-05-21 11:45:35 +00:00
|
|
|
* However from hardware perspective, smaller page sizes aggravate aliasing
|
2015-06-04 10:05:53 +00:00
|
|
|
* meaning more vaddr bits needed to disambiguate the cache-line-op ;
|
|
|
|
* the existing scheme of piggybacking won't work for certain configurations.
|
|
|
|
* Two new registers IC_PTAG and DC_PTAG inttoduced.
|
|
|
|
* "tag" bits are provided in PTAG, index bits in existing IVIL/IVDL/FLDL regs
|
2013-09-05 08:13:03 +00:00
|
|
|
*/
|
2015-06-04 10:05:53 +00:00
|
|
|
|
2014-08-04 15:32:31 +00:00
|
|
|
static inline
|
2015-09-15 01:43:42 +00:00
|
|
|
void __cache_line_loop_v2(phys_addr_t paddr, unsigned long vaddr,
|
2017-01-24 03:32:23 +00:00
|
|
|
unsigned long sz, const int op, const int full_page)
|
2013-09-05 08:13:03 +00:00
|
|
|
{
|
2014-08-04 15:32:31 +00:00
|
|
|
unsigned int aux_cmd;
|
2013-09-05 08:13:03 +00:00
|
|
|
int num_lines;
|
|
|
|
|
2015-06-04 10:05:53 +00:00
|
|
|
if (op == OP_INV_IC) {
|
2013-09-05 08:13:03 +00:00
|
|
|
aux_cmd = ARC_REG_IC_IVIL;
|
2014-08-04 15:32:31 +00:00
|
|
|
} else {
|
2013-09-05 08:13:03 +00:00
|
|
|
/* d$ cmd: INV (discard or wback-n-discard) OR FLUSH (wback) */
|
2015-06-04 10:05:53 +00:00
|
|
|
aux_cmd = op & OP_INV ? ARC_REG_DC_IVDL : ARC_REG_DC_FLDL;
|
2013-09-05 08:13:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Ensure we properly floor/ceil the non-line aligned/sized requests
|
|
|
|
* and have @paddr - aligned to cache line and integral @num_lines.
|
|
|
|
* This however can be avoided for page sized since:
|
|
|
|
* -@paddr will be cache-line aligned already (being page aligned)
|
|
|
|
* -@sz will be integral multiple of line size (being page sized).
|
|
|
|
*/
|
2014-08-04 15:32:31 +00:00
|
|
|
if (!full_page) {
|
2013-09-05 08:13:03 +00:00
|
|
|
sz += paddr & ~CACHE_LINE_MASK;
|
|
|
|
paddr &= CACHE_LINE_MASK;
|
|
|
|
vaddr &= CACHE_LINE_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
num_lines = DIV_ROUND_UP(sz, L1_CACHE_BYTES);
|
|
|
|
|
|
|
|
/* MMUv2 and before: paddr contains stuffed vaddrs bits */
|
|
|
|
paddr |= (vaddr >> PAGE_SHIFT) & 0x1F;
|
2014-08-04 15:32:31 +00:00
|
|
|
|
|
|
|
while (num_lines-- > 0) {
|
|
|
|
write_aux_reg(aux_cmd, paddr);
|
|
|
|
paddr += L1_CACHE_BYTES;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-06 15:44:57 +00:00
|
|
|
/*
|
|
|
|
* For ARC700 MMUv3 I-cache and D-cache flushes
|
2017-01-04 20:02:44 +00:00
|
|
|
* - ARC700 programming model requires paddr and vaddr be passed in seperate
|
|
|
|
* AUX registers (*_IV*L and *_PTAG respectively) irrespective of whether the
|
|
|
|
* caches actually alias or not.
|
|
|
|
* - For HS38, only the aliasing I-cache configuration uses the PTAG reg
|
|
|
|
* (non aliasing I-cache version doesn't; while D-cache can't possibly alias)
|
2015-02-06 15:44:57 +00:00
|
|
|
*/
|
2014-08-04 15:32:31 +00:00
|
|
|
static inline
|
2015-09-15 01:43:42 +00:00
|
|
|
void __cache_line_loop_v3(phys_addr_t paddr, unsigned long vaddr,
|
2017-01-24 03:32:23 +00:00
|
|
|
unsigned long sz, const int op, const int full_page)
|
2014-08-04 15:32:31 +00:00
|
|
|
{
|
|
|
|
unsigned int aux_cmd, aux_tag;
|
|
|
|
int num_lines;
|
|
|
|
|
|
|
|
if (op == OP_INV_IC) {
|
|
|
|
aux_cmd = ARC_REG_IC_IVIL;
|
|
|
|
aux_tag = ARC_REG_IC_PTAG;
|
|
|
|
} else {
|
|
|
|
aux_cmd = op & OP_INV ? ARC_REG_DC_IVDL : ARC_REG_DC_FLDL;
|
|
|
|
aux_tag = ARC_REG_DC_PTAG;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ensure we properly floor/ceil the non-line aligned/sized requests
|
|
|
|
* and have @paddr - aligned to cache line and integral @num_lines.
|
|
|
|
* This however can be avoided for page sized since:
|
|
|
|
* -@paddr will be cache-line aligned already (being page aligned)
|
|
|
|
* -@sz will be integral multiple of line size (being page sized).
|
|
|
|
*/
|
|
|
|
if (!full_page) {
|
|
|
|
sz += paddr & ~CACHE_LINE_MASK;
|
|
|
|
paddr &= CACHE_LINE_MASK;
|
|
|
|
vaddr &= CACHE_LINE_MASK;
|
|
|
|
}
|
|
|
|
num_lines = DIV_ROUND_UP(sz, L1_CACHE_BYTES);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MMUv3, cache ops require paddr in PTAG reg
|
|
|
|
* if V-P const for loop, PTAG can be written once outside loop
|
|
|
|
*/
|
|
|
|
if (full_page)
|
2014-03-07 07:52:22 +00:00
|
|
|
write_aux_reg(aux_tag, paddr);
|
2013-09-05 08:13:03 +00:00
|
|
|
|
2015-02-06 15:44:57 +00:00
|
|
|
/*
|
|
|
|
* This is technically for MMU v4, using the MMU v3 programming model
|
2016-05-21 11:45:35 +00:00
|
|
|
* Special work for HS38 aliasing I-cache configuration with PAE40
|
2015-02-06 15:44:57 +00:00
|
|
|
* - upper 8 bits of paddr need to be written into PTAG_HI
|
|
|
|
* - (and needs to be written before the lower 32 bits)
|
|
|
|
* Note that PTAG_HI is hoisted outside the line loop
|
|
|
|
*/
|
|
|
|
if (is_pae40_enabled() && op == OP_INV_IC)
|
|
|
|
write_aux_reg(ARC_REG_IC_PTAG_HI, (u64)paddr >> 32);
|
|
|
|
|
2013-09-05 08:13:03 +00:00
|
|
|
while (num_lines-- > 0) {
|
2014-08-04 15:32:31 +00:00
|
|
|
if (!full_page) {
|
2013-09-05 09:15:51 +00:00
|
|
|
write_aux_reg(aux_tag, paddr);
|
|
|
|
paddr += L1_CACHE_BYTES;
|
|
|
|
}
|
2013-09-05 08:13:03 +00:00
|
|
|
|
|
|
|
write_aux_reg(aux_cmd, vaddr);
|
|
|
|
vaddr += L1_CACHE_BYTES;
|
|
|
|
}
|
|
|
|
}
|
2013-01-18 09:42:19 +00:00
|
|
|
|
2014-08-29 05:25:15 +00:00
|
|
|
#ifndef USE_RGN_FLSH
|
|
|
|
|
2015-04-06 11:53:57 +00:00
|
|
|
/*
|
2015-02-06 15:44:57 +00:00
|
|
|
* In HS38x (MMU v4), I-cache is VIPT (can alias), D-cache is PIPT
|
|
|
|
* Here's how cache ops are implemented
|
2015-04-06 11:53:57 +00:00
|
|
|
*
|
2015-02-06 15:44:57 +00:00
|
|
|
* - D-cache: only paddr needed (in DC_IVDL/DC_FLDL)
|
|
|
|
* - I-cache Non Aliasing: Despite VIPT, only paddr needed (in IC_IVIL)
|
|
|
|
* - I-cache Aliasing: Both vaddr and paddr needed (in IC_IVIL, IC_PTAG
|
|
|
|
* respectively, similar to MMU v3 programming model, hence
|
|
|
|
* __cache_line_loop_v3() is used)
|
|
|
|
*
|
|
|
|
* If PAE40 is enabled, independent of aliasing considerations, the higher bits
|
|
|
|
* needs to be written into PTAG_HI
|
2015-04-06 11:53:57 +00:00
|
|
|
*/
|
|
|
|
static inline
|
2015-09-15 01:43:42 +00:00
|
|
|
void __cache_line_loop_v4(phys_addr_t paddr, unsigned long vaddr,
|
2017-01-24 03:32:23 +00:00
|
|
|
unsigned long sz, const int op, const int full_page)
|
2015-04-06 11:53:57 +00:00
|
|
|
{
|
|
|
|
unsigned int aux_cmd;
|
|
|
|
int num_lines;
|
|
|
|
|
2017-01-24 03:32:23 +00:00
|
|
|
if (op == OP_INV_IC) {
|
2015-04-06 11:53:57 +00:00
|
|
|
aux_cmd = ARC_REG_IC_IVIL;
|
|
|
|
} else {
|
|
|
|
/* d$ cmd: INV (discard or wback-n-discard) OR FLUSH (wback) */
|
2017-01-24 03:32:23 +00:00
|
|
|
aux_cmd = op & OP_INV ? ARC_REG_DC_IVDL : ARC_REG_DC_FLDL;
|
2015-04-06 11:53:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Ensure we properly floor/ceil the non-line aligned/sized requests
|
|
|
|
* and have @paddr - aligned to cache line and integral @num_lines.
|
|
|
|
* This however can be avoided for page sized since:
|
|
|
|
* -@paddr will be cache-line aligned already (being page aligned)
|
|
|
|
* -@sz will be integral multiple of line size (being page sized).
|
|
|
|
*/
|
2017-01-24 03:32:23 +00:00
|
|
|
if (!full_page) {
|
2015-04-06 11:53:57 +00:00
|
|
|
sz += paddr & ~CACHE_LINE_MASK;
|
|
|
|
paddr &= CACHE_LINE_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
num_lines = DIV_ROUND_UP(sz, L1_CACHE_BYTES);
|
|
|
|
|
2015-02-06 15:44:57 +00:00
|
|
|
/*
|
|
|
|
* For HS38 PAE40 configuration
|
|
|
|
* - upper 8 bits of paddr need to be written into PTAG_HI
|
|
|
|
* - (and needs to be written before the lower 32 bits)
|
|
|
|
*/
|
|
|
|
if (is_pae40_enabled()) {
|
2017-01-24 03:32:23 +00:00
|
|
|
if (op == OP_INV_IC)
|
2015-02-06 15:44:57 +00:00
|
|
|
/*
|
|
|
|
* Non aliasing I-cache in HS38,
|
|
|
|
* aliasing I-cache handled in __cache_line_loop_v3()
|
|
|
|
*/
|
|
|
|
write_aux_reg(ARC_REG_IC_PTAG_HI, (u64)paddr >> 32);
|
|
|
|
else
|
|
|
|
write_aux_reg(ARC_REG_DC_PTAG_HI, (u64)paddr >> 32);
|
|
|
|
}
|
|
|
|
|
2015-04-06 11:53:57 +00:00
|
|
|
while (num_lines-- > 0) {
|
|
|
|
write_aux_reg(aux_cmd, paddr);
|
|
|
|
paddr += L1_CACHE_BYTES;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-29 05:25:15 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
/*
|
|
|
|
* optimized flush operation which takes a region as opposed to iterating per line
|
|
|
|
*/
|
|
|
|
static inline
|
|
|
|
void __cache_line_loop_v4(phys_addr_t paddr, unsigned long vaddr,
|
|
|
|
unsigned long sz, const int op, const int full_page)
|
|
|
|
{
|
ARCv2: mm: Merge 2 updates to DC_CTRL for region flush
Region Flush has a weird programming model.
1. Flush or Invalidate is selected by DC_CTRL.RGN_OP
2 Flush-n-Invalidate is done by DC_CTRL.IM
Given the code structuring before, case #2 above was generating two
seperate updates to DC_CTRL which was pointless.
| 80a342b0 <__dma_cache_wback_inv_l1>:
| 80a342b0: clri r4
| 80a342b4: lr r2,[dc_ctrl]
| 80a342b8: bset_s r2,r2,0x6
| 80a342ba: sr r2,[dc_ctrl] <-- FIRST
|
| 80a342be: bmskn r3,r0,0x5
|
| 80a342c2: lr r2,[dc_ctrl]
| 80a342c6: and r2,r2,0xfffff1ff
| 80a342ce: bset_s r2,r2,0x9
| 80a342d0: sr r2,[dc_ctrl] <-- SECOND
|
| 80a342d4: add_s r1,r1,0x3f
| 80a342d6: bmsk_s r0,r0,0x5
| 80a342d8: add_s r0,r0,r1
| 80a342da: add_s r0,r0,r3
| 80a342dc: sr r0,[78]
| 80a342e0: sr r3,[77]
|...
|...
So move setting of DC_CTRL.RGN_OP into __before_dc_op() and combine with
any other update.
| 80b63324 <__dma_cache_wback_inv_l1>:
| 80b63324: clri r3
| 80b63328: lr r2,[dc_ctrl]
| 80b6332c: and r2,r2,0xfffff1ff
| 80b63334: or r2,r2,576
| 80b63338: sr r2,[dc_ctrl]
|
| 80b6333c: add_s r1,r1,0x3f
| 80b6333e: bmskn r2,r0,0x5
| 80b63342: add_s r0,r0,r1
| 80b63344: sr r0,[78]
| 80b63348: sr r2,[77]
Signed-off-by: Vineet Gupta <vgupta@synopsys.com>
2017-05-02 22:28:12 +00:00
|
|
|
unsigned int s, e;
|
2014-08-29 05:25:15 +00:00
|
|
|
|
|
|
|
/* Only for Non aliasing I-cache in HS38 */
|
|
|
|
if (op == OP_INV_IC) {
|
|
|
|
s = ARC_REG_IC_IVIR;
|
|
|
|
e = ARC_REG_IC_ENDR;
|
|
|
|
} else {
|
|
|
|
s = ARC_REG_DC_STARTR;
|
|
|
|
e = ARC_REG_DC_ENDR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!full_page) {
|
|
|
|
/* for any leading gap between @paddr and start of cache line */
|
|
|
|
sz += paddr & ~CACHE_LINE_MASK;
|
|
|
|
paddr &= CACHE_LINE_MASK;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* account for any trailing gap to end of cache line
|
|
|
|
* this is equivalent to DIV_ROUND_UP() in line ops above
|
|
|
|
*/
|
|
|
|
sz += L1_CACHE_BYTES - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_pae40_enabled()) {
|
|
|
|
/* TBD: check if crossing 4TB boundary */
|
|
|
|
if (op == OP_INV_IC)
|
|
|
|
write_aux_reg(ARC_REG_IC_PTAG_HI, (u64)paddr >> 32);
|
|
|
|
else
|
|
|
|
write_aux_reg(ARC_REG_DC_PTAG_HI, (u64)paddr >> 32);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ENDR needs to be set ahead of START */
|
|
|
|
write_aux_reg(e, paddr + sz); /* ENDR is exclusive */
|
|
|
|
write_aux_reg(s, paddr);
|
|
|
|
|
|
|
|
/* caller waits on DC_CTRL.FS */
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2014-08-04 15:32:31 +00:00
|
|
|
#if (CONFIG_ARC_MMU_VER < 3)
|
|
|
|
#define __cache_line_loop __cache_line_loop_v2
|
|
|
|
#elif (CONFIG_ARC_MMU_VER == 3)
|
|
|
|
#define __cache_line_loop __cache_line_loop_v3
|
2015-04-06 11:53:57 +00:00
|
|
|
#elif (CONFIG_ARC_MMU_VER > 3)
|
|
|
|
#define __cache_line_loop __cache_line_loop_v4
|
2014-08-04 15:32:31 +00:00
|
|
|
#endif
|
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
#ifdef CONFIG_ARC_HAS_DCACHE
|
|
|
|
|
|
|
|
/***************************************************************
|
|
|
|
* Machine specific helpers for Entire D-Cache or Per Line ops
|
|
|
|
*/
|
|
|
|
|
ARCv2: mm: Merge 2 updates to DC_CTRL for region flush
Region Flush has a weird programming model.
1. Flush or Invalidate is selected by DC_CTRL.RGN_OP
2 Flush-n-Invalidate is done by DC_CTRL.IM
Given the code structuring before, case #2 above was generating two
seperate updates to DC_CTRL which was pointless.
| 80a342b0 <__dma_cache_wback_inv_l1>:
| 80a342b0: clri r4
| 80a342b4: lr r2,[dc_ctrl]
| 80a342b8: bset_s r2,r2,0x6
| 80a342ba: sr r2,[dc_ctrl] <-- FIRST
|
| 80a342be: bmskn r3,r0,0x5
|
| 80a342c2: lr r2,[dc_ctrl]
| 80a342c6: and r2,r2,0xfffff1ff
| 80a342ce: bset_s r2,r2,0x9
| 80a342d0: sr r2,[dc_ctrl] <-- SECOND
|
| 80a342d4: add_s r1,r1,0x3f
| 80a342d6: bmsk_s r0,r0,0x5
| 80a342d8: add_s r0,r0,r1
| 80a342da: add_s r0,r0,r3
| 80a342dc: sr r0,[78]
| 80a342e0: sr r3,[77]
|...
|...
So move setting of DC_CTRL.RGN_OP into __before_dc_op() and combine with
any other update.
| 80b63324 <__dma_cache_wback_inv_l1>:
| 80b63324: clri r3
| 80b63328: lr r2,[dc_ctrl]
| 80b6332c: and r2,r2,0xfffff1ff
| 80b63334: or r2,r2,576
| 80b63338: sr r2,[dc_ctrl]
|
| 80b6333c: add_s r1,r1,0x3f
| 80b6333e: bmskn r2,r0,0x5
| 80b63342: add_s r0,r0,r1
| 80b63344: sr r0,[78]
| 80b63348: sr r2,[77]
Signed-off-by: Vineet Gupta <vgupta@synopsys.com>
2017-05-02 22:28:12 +00:00
|
|
|
#ifndef USE_RGN_FLSH
|
|
|
|
/*
|
|
|
|
* this version avoids extra read/write of DC_CTRL for flush or invalid ops
|
|
|
|
* in the non region flush regime (such as for ARCompact)
|
|
|
|
*/
|
2015-06-04 03:23:47 +00:00
|
|
|
static inline void __before_dc_op(const int op)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
2014-06-29 13:33:58 +00:00
|
|
|
if (op == OP_FLUSH_N_INV) {
|
|
|
|
/* Dcache provides 2 cmd: FLUSH or INV
|
|
|
|
* INV inturn has sub-modes: DISCARD or FLUSH-BEFORE
|
|
|
|
* flush-n-inv is achieved by INV cmd but with IM=1
|
|
|
|
* So toggle INV sub-mode depending on op request and default
|
|
|
|
*/
|
2015-06-04 03:23:47 +00:00
|
|
|
const unsigned int ctl = ARC_REG_DC_CTRL;
|
|
|
|
write_aux_reg(ctl, read_aux_reg(ctl) | DC_CTRL_INV_MODE_FLUSH);
|
2014-06-29 13:33:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
ARCv2: mm: Merge 2 updates to DC_CTRL for region flush
Region Flush has a weird programming model.
1. Flush or Invalidate is selected by DC_CTRL.RGN_OP
2 Flush-n-Invalidate is done by DC_CTRL.IM
Given the code structuring before, case #2 above was generating two
seperate updates to DC_CTRL which was pointless.
| 80a342b0 <__dma_cache_wback_inv_l1>:
| 80a342b0: clri r4
| 80a342b4: lr r2,[dc_ctrl]
| 80a342b8: bset_s r2,r2,0x6
| 80a342ba: sr r2,[dc_ctrl] <-- FIRST
|
| 80a342be: bmskn r3,r0,0x5
|
| 80a342c2: lr r2,[dc_ctrl]
| 80a342c6: and r2,r2,0xfffff1ff
| 80a342ce: bset_s r2,r2,0x9
| 80a342d0: sr r2,[dc_ctrl] <-- SECOND
|
| 80a342d4: add_s r1,r1,0x3f
| 80a342d6: bmsk_s r0,r0,0x5
| 80a342d8: add_s r0,r0,r1
| 80a342da: add_s r0,r0,r3
| 80a342dc: sr r0,[78]
| 80a342e0: sr r3,[77]
|...
|...
So move setting of DC_CTRL.RGN_OP into __before_dc_op() and combine with
any other update.
| 80b63324 <__dma_cache_wback_inv_l1>:
| 80b63324: clri r3
| 80b63328: lr r2,[dc_ctrl]
| 80b6332c: and r2,r2,0xfffff1ff
| 80b63334: or r2,r2,576
| 80b63338: sr r2,[dc_ctrl]
|
| 80b6333c: add_s r1,r1,0x3f
| 80b6333e: bmskn r2,r0,0x5
| 80b63342: add_s r0,r0,r1
| 80b63344: sr r0,[78]
| 80b63348: sr r2,[77]
Signed-off-by: Vineet Gupta <vgupta@synopsys.com>
2017-05-02 22:28:12 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
static inline void __before_dc_op(const int op)
|
|
|
|
{
|
|
|
|
const unsigned int ctl = ARC_REG_DC_CTRL;
|
|
|
|
unsigned int val = read_aux_reg(ctl);
|
|
|
|
|
|
|
|
if (op == OP_FLUSH_N_INV) {
|
|
|
|
val |= DC_CTRL_INV_MODE_FLUSH;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (op != OP_INV_IC) {
|
|
|
|
/*
|
|
|
|
* Flush / Invalidate is provided by DC_CTRL.RNG_OP 0 or 1
|
|
|
|
* combined Flush-n-invalidate uses DC_CTRL.IM = 1 set above
|
|
|
|
*/
|
|
|
|
val &= ~DC_CTRL_RGN_OP_MSK;
|
|
|
|
if (op & OP_INV)
|
|
|
|
val |= DC_CTRL_RGN_OP_INV;
|
|
|
|
}
|
|
|
|
write_aux_reg(ctl, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2015-06-04 03:23:47 +00:00
|
|
|
static inline void __after_dc_op(const int op)
|
2014-06-29 13:33:58 +00:00
|
|
|
{
|
2015-06-04 03:23:47 +00:00
|
|
|
if (op & OP_FLUSH) {
|
|
|
|
const unsigned int ctl = ARC_REG_DC_CTRL;
|
|
|
|
unsigned int reg;
|
2014-06-29 13:33:58 +00:00
|
|
|
|
2015-06-04 03:23:47 +00:00
|
|
|
/* flush / flush-n-inv both wait */
|
|
|
|
while ((reg = read_aux_reg(ctl)) & DC_CTRL_FLUSH_STATUS)
|
|
|
|
;
|
|
|
|
|
|
|
|
/* Switch back to default Invalidate mode */
|
|
|
|
if (op == OP_FLUSH_N_INV)
|
|
|
|
write_aux_reg(ctl, reg & ~DC_CTRL_INV_MODE_FLUSH);
|
|
|
|
}
|
2013-01-18 09:42:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Operation on Entire D-Cache
|
2015-06-04 10:05:53 +00:00
|
|
|
* @op = {OP_INV, OP_FLUSH, OP_FLUSH_N_INV}
|
2013-01-18 09:42:19 +00:00
|
|
|
* Note that constant propagation ensures all the checks are gone
|
|
|
|
* in generated code
|
|
|
|
*/
|
2015-06-04 10:05:53 +00:00
|
|
|
static inline void __dc_entire_op(const int op)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
|
|
|
int aux;
|
|
|
|
|
2015-06-04 03:23:47 +00:00
|
|
|
__before_dc_op(op);
|
2013-01-18 09:42:19 +00:00
|
|
|
|
2015-06-04 10:05:53 +00:00
|
|
|
if (op & OP_INV) /* Inv or flush-n-inv use same cmd reg */
|
2013-01-18 09:42:19 +00:00
|
|
|
aux = ARC_REG_DC_IVDC;
|
|
|
|
else
|
|
|
|
aux = ARC_REG_DC_FLSH;
|
|
|
|
|
|
|
|
write_aux_reg(aux, 0x1);
|
|
|
|
|
2015-06-04 03:23:47 +00:00
|
|
|
__after_dc_op(op);
|
2013-01-18 09:42:19 +00:00
|
|
|
}
|
|
|
|
|
2016-06-22 10:31:19 +00:00
|
|
|
static inline void __dc_disable(void)
|
|
|
|
{
|
|
|
|
const int r = ARC_REG_DC_CTRL;
|
|
|
|
|
|
|
|
__dc_entire_op(OP_FLUSH_N_INV);
|
|
|
|
write_aux_reg(r, read_aux_reg(r) | DC_CTRL_DIS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __dc_enable(void)
|
|
|
|
{
|
|
|
|
const int r = ARC_REG_DC_CTRL;
|
|
|
|
|
|
|
|
write_aux_reg(r, read_aux_reg(r) & ~DC_CTRL_DIS);
|
|
|
|
}
|
|
|
|
|
2013-05-09 16:24:51 +00:00
|
|
|
/* For kernel mappings cache operation: index is same as paddr */
|
2013-05-09 09:40:18 +00:00
|
|
|
#define __dc_line_op_k(p, sz, op) __dc_line_op(p, p, sz, op)
|
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
/*
|
2015-06-04 10:05:53 +00:00
|
|
|
* D-Cache Line ops: Per Line INV (discard or wback+discard) or FLUSH (wback)
|
2013-01-18 09:42:19 +00:00
|
|
|
*/
|
2015-09-15 01:43:42 +00:00
|
|
|
static inline void __dc_line_op(phys_addr_t paddr, unsigned long vaddr,
|
2015-06-04 10:05:53 +00:00
|
|
|
unsigned long sz, const int op)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
2017-01-24 03:32:23 +00:00
|
|
|
const int full_page = __builtin_constant_p(sz) && sz == PAGE_SIZE;
|
2014-06-29 13:33:58 +00:00
|
|
|
unsigned long flags;
|
2013-01-18 09:42:19 +00:00
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
2015-06-04 03:23:47 +00:00
|
|
|
__before_dc_op(op);
|
2013-01-18 09:42:19 +00:00
|
|
|
|
2017-01-24 03:32:23 +00:00
|
|
|
__cache_line_loop(paddr, vaddr, sz, op, full_page);
|
2013-01-18 09:42:19 +00:00
|
|
|
|
2015-06-04 03:23:47 +00:00
|
|
|
__after_dc_op(op);
|
2013-01-18 09:42:19 +00:00
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2015-06-04 10:05:53 +00:00
|
|
|
#define __dc_entire_op(op)
|
2016-06-22 10:31:19 +00:00
|
|
|
#define __dc_disable()
|
|
|
|
#define __dc_enable()
|
2015-06-04 10:05:53 +00:00
|
|
|
#define __dc_line_op(paddr, vaddr, sz, op)
|
|
|
|
#define __dc_line_op_k(paddr, sz, op)
|
2013-01-18 09:42:19 +00:00
|
|
|
|
|
|
|
#endif /* CONFIG_ARC_HAS_DCACHE */
|
|
|
|
|
|
|
|
#ifdef CONFIG_ARC_HAS_ICACHE
|
|
|
|
|
2014-07-09 09:29:47 +00:00
|
|
|
static inline void __ic_entire_inv(void)
|
|
|
|
{
|
|
|
|
write_aux_reg(ARC_REG_IC_IVIC, 1);
|
|
|
|
read_aux_reg(ARC_REG_IC_CTRL); /* blocks */
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2015-09-15 01:43:42 +00:00
|
|
|
__ic_line_inv_vaddr_local(phys_addr_t paddr, unsigned long vaddr,
|
2014-07-09 09:29:47 +00:00
|
|
|
unsigned long sz)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
2017-01-24 03:32:23 +00:00
|
|
|
const int full_page = __builtin_constant_p(sz) && sz == PAGE_SIZE;
|
2013-01-18 09:42:19 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
2017-01-24 03:32:23 +00:00
|
|
|
(*_cache_line_loop_ic_fn)(paddr, vaddr, sz, OP_INV_IC, full_page);
|
2013-01-18 09:42:19 +00:00
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
|
2014-07-09 09:29:47 +00:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
|
|
|
|
#define __ic_line_inv_vaddr(p, v, s) __ic_line_inv_vaddr_local(p, v, s)
|
|
|
|
|
|
|
|
#else
|
2013-06-22 13:52:42 +00:00
|
|
|
|
2014-07-09 09:29:47 +00:00
|
|
|
struct ic_inv_args {
|
2015-09-15 01:43:42 +00:00
|
|
|
phys_addr_t paddr, vaddr;
|
2013-02-17 10:51:42 +00:00
|
|
|
int sz;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void __ic_line_inv_vaddr_helper(void *info)
|
|
|
|
{
|
2014-09-03 11:41:11 +00:00
|
|
|
struct ic_inv_args *ic_inv = info;
|
2014-07-09 09:29:47 +00:00
|
|
|
|
2013-02-17 10:51:42 +00:00
|
|
|
__ic_line_inv_vaddr_local(ic_inv->paddr, ic_inv->vaddr, ic_inv->sz);
|
|
|
|
}
|
|
|
|
|
2015-09-15 01:43:42 +00:00
|
|
|
static void __ic_line_inv_vaddr(phys_addr_t paddr, unsigned long vaddr,
|
2013-02-17 10:51:42 +00:00
|
|
|
unsigned long sz)
|
|
|
|
{
|
2014-07-09 09:29:47 +00:00
|
|
|
struct ic_inv_args ic_inv = {
|
|
|
|
.paddr = paddr,
|
|
|
|
.vaddr = vaddr,
|
|
|
|
.sz = sz
|
|
|
|
};
|
|
|
|
|
2013-02-17 10:51:42 +00:00
|
|
|
on_each_cpu(__ic_line_inv_vaddr_helper, &ic_inv, 1);
|
|
|
|
}
|
2014-07-09 09:29:47 +00:00
|
|
|
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
|
|
|
#else /* !CONFIG_ARC_HAS_ICACHE */
|
2013-01-18 09:42:19 +00:00
|
|
|
|
2013-06-22 13:52:42 +00:00
|
|
|
#define __ic_entire_inv()
|
2013-01-18 09:42:19 +00:00
|
|
|
#define __ic_line_inv_vaddr(pstart, vstart, sz)
|
|
|
|
|
|
|
|
#endif /* CONFIG_ARC_HAS_ICACHE */
|
|
|
|
|
2017-08-01 04:53:27 +00:00
|
|
|
noinline void slc_op_rgn(phys_addr_t paddr, unsigned long sz, const int op)
|
2015-04-03 09:37:07 +00:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_ISA_ARCV2
|
2015-06-29 12:24:37 +00:00
|
|
|
/*
|
|
|
|
* SLC is shared between all cores and concurrent aux operations from
|
|
|
|
* multiple cores need to be serialized using a spinlock
|
|
|
|
* A concurrent operation can be silently ignored and/or the old/new
|
|
|
|
* operation can remain incomplete forever (lockup in SLC_CTRL_BUSY loop
|
|
|
|
* below)
|
|
|
|
*/
|
|
|
|
static DEFINE_SPINLOCK(lock);
|
2015-04-03 09:37:07 +00:00
|
|
|
unsigned long flags;
|
|
|
|
unsigned int ctrl;
|
2017-08-01 09:58:47 +00:00
|
|
|
phys_addr_t end;
|
2015-04-03 09:37:07 +00:00
|
|
|
|
2015-06-29 12:24:37 +00:00
|
|
|
spin_lock_irqsave(&lock, flags);
|
2015-04-03 09:37:07 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The Region Flush operation is specified by CTRL.RGN_OP[11..9]
|
|
|
|
* - b'000 (default) is Flush,
|
|
|
|
* - b'001 is Invalidate if CTRL.IM == 0
|
|
|
|
* - b'001 is Flush-n-Invalidate if CTRL.IM == 1
|
|
|
|
*/
|
|
|
|
ctrl = read_aux_reg(ARC_REG_SLC_CTRL);
|
|
|
|
|
|
|
|
/* Don't rely on default value of IM bit */
|
|
|
|
if (!(op & OP_FLUSH)) /* i.e. OP_INV */
|
|
|
|
ctrl &= ~SLC_CTRL_IM; /* clear IM: Disable flush before Inv */
|
|
|
|
else
|
|
|
|
ctrl |= SLC_CTRL_IM;
|
|
|
|
|
|
|
|
if (op & OP_INV)
|
|
|
|
ctrl |= SLC_CTRL_RGN_OP_INV; /* Inv or flush-n-inv */
|
|
|
|
else
|
|
|
|
ctrl &= ~SLC_CTRL_RGN_OP_INV;
|
|
|
|
|
|
|
|
write_aux_reg(ARC_REG_SLC_CTRL, ctrl);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lower bits are ignored, no need to clip
|
|
|
|
* END needs to be setup before START (latter triggers the operation)
|
|
|
|
* END can't be same as START, so add (l2_line_sz - 1) to sz
|
|
|
|
*/
|
2017-08-01 09:58:47 +00:00
|
|
|
end = paddr + sz + l2_line_sz - 1;
|
|
|
|
if (is_pae40_enabled())
|
|
|
|
write_aux_reg(ARC_REG_SLC_RGN_END1, upper_32_bits(end));
|
|
|
|
|
|
|
|
write_aux_reg(ARC_REG_SLC_RGN_END, lower_32_bits(end));
|
|
|
|
|
|
|
|
if (is_pae40_enabled())
|
|
|
|
write_aux_reg(ARC_REG_SLC_RGN_START1, upper_32_bits(paddr));
|
|
|
|
|
|
|
|
write_aux_reg(ARC_REG_SLC_RGN_START, lower_32_bits(paddr));
|
2015-04-03 09:37:07 +00:00
|
|
|
|
2017-07-07 09:25:14 +00:00
|
|
|
/* Make sure "busy" bit reports correct stataus, see STAR 9001165532 */
|
|
|
|
read_aux_reg(ARC_REG_SLC_CTRL);
|
|
|
|
|
2015-04-03 09:37:07 +00:00
|
|
|
while (read_aux_reg(ARC_REG_SLC_CTRL) & SLC_CTRL_BUSY);
|
|
|
|
|
2015-06-29 12:24:37 +00:00
|
|
|
spin_unlock_irqrestore(&lock, flags);
|
2015-04-03 09:37:07 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-08-01 04:53:27 +00:00
|
|
|
noinline void slc_op_line(phys_addr_t paddr, unsigned long sz, const int op)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_ISA_ARCV2
|
|
|
|
/*
|
|
|
|
* SLC is shared between all cores and concurrent aux operations from
|
|
|
|
* multiple cores need to be serialized using a spinlock
|
|
|
|
* A concurrent operation can be silently ignored and/or the old/new
|
|
|
|
* operation can remain incomplete forever (lockup in SLC_CTRL_BUSY loop
|
|
|
|
* below)
|
|
|
|
*/
|
|
|
|
static DEFINE_SPINLOCK(lock);
|
|
|
|
|
|
|
|
const unsigned long SLC_LINE_MASK = ~(l2_line_sz - 1);
|
|
|
|
unsigned int ctrl, cmd;
|
|
|
|
unsigned long flags;
|
|
|
|
int num_lines;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&lock, flags);
|
|
|
|
|
|
|
|
ctrl = read_aux_reg(ARC_REG_SLC_CTRL);
|
|
|
|
|
|
|
|
/* Don't rely on default value of IM bit */
|
|
|
|
if (!(op & OP_FLUSH)) /* i.e. OP_INV */
|
|
|
|
ctrl &= ~SLC_CTRL_IM; /* clear IM: Disable flush before Inv */
|
|
|
|
else
|
|
|
|
ctrl |= SLC_CTRL_IM;
|
|
|
|
|
|
|
|
write_aux_reg(ARC_REG_SLC_CTRL, ctrl);
|
|
|
|
|
|
|
|
cmd = op & OP_INV ? ARC_AUX_SLC_IVDL : ARC_AUX_SLC_FLDL;
|
|
|
|
|
|
|
|
sz += paddr & ~SLC_LINE_MASK;
|
|
|
|
paddr &= SLC_LINE_MASK;
|
|
|
|
|
|
|
|
num_lines = DIV_ROUND_UP(sz, l2_line_sz);
|
|
|
|
|
|
|
|
while (num_lines-- > 0) {
|
|
|
|
write_aux_reg(cmd, paddr);
|
|
|
|
paddr += l2_line_sz;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Make sure "busy" bit reports correct stataus, see STAR 9001165532 */
|
|
|
|
read_aux_reg(ARC_REG_SLC_CTRL);
|
|
|
|
|
|
|
|
while (read_aux_reg(ARC_REG_SLC_CTRL) & SLC_CTRL_BUSY);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&lock, flags);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
#define slc_op(paddr, sz, op) slc_op_rgn(paddr, sz, op)
|
|
|
|
|
2016-06-22 10:13:22 +00:00
|
|
|
noinline static void slc_entire_op(const int op)
|
|
|
|
{
|
|
|
|
unsigned int ctrl, r = ARC_REG_SLC_CTRL;
|
|
|
|
|
|
|
|
ctrl = read_aux_reg(r);
|
|
|
|
|
|
|
|
if (!(op & OP_FLUSH)) /* i.e. OP_INV */
|
|
|
|
ctrl &= ~SLC_CTRL_IM; /* clear IM: Disable flush before Inv */
|
|
|
|
else
|
|
|
|
ctrl |= SLC_CTRL_IM;
|
|
|
|
|
|
|
|
write_aux_reg(r, ctrl);
|
|
|
|
|
|
|
|
write_aux_reg(ARC_REG_SLC_INVALIDATE, 1);
|
|
|
|
|
2017-03-29 14:15:11 +00:00
|
|
|
/* Make sure "busy" bit reports correct stataus, see STAR 9001165532 */
|
|
|
|
read_aux_reg(r);
|
|
|
|
|
2016-06-22 10:13:22 +00:00
|
|
|
/* Important to wait for flush to complete */
|
|
|
|
while (read_aux_reg(r) & SLC_CTRL_BUSY);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void arc_slc_disable(void)
|
|
|
|
{
|
|
|
|
const int r = ARC_REG_SLC_CTRL;
|
|
|
|
|
|
|
|
slc_entire_op(OP_FLUSH_N_INV);
|
|
|
|
write_aux_reg(r, read_aux_reg(r) | SLC_CTRL_DIS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void arc_slc_enable(void)
|
|
|
|
{
|
|
|
|
const int r = ARC_REG_SLC_CTRL;
|
|
|
|
|
|
|
|
write_aux_reg(r, read_aux_reg(r) & ~SLC_CTRL_DIS);
|
|
|
|
}
|
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
/***********************************************************
|
|
|
|
* Exported APIs
|
|
|
|
*/
|
|
|
|
|
2013-05-09 16:24:51 +00:00
|
|
|
/*
|
|
|
|
* Handle cache congruency of kernel and userspace mappings of page when kernel
|
|
|
|
* writes-to/reads-from
|
|
|
|
*
|
|
|
|
* The idea is to defer flushing of kernel mapping after a WRITE, possible if:
|
|
|
|
* -dcache is NOT aliasing, hence any U/K-mappings of page are congruent
|
|
|
|
* -U-mapping doesn't exist yet for page (finalised in update_mmu_cache)
|
|
|
|
* -In SMP, if hardware caches are coherent
|
|
|
|
*
|
|
|
|
* There's a corollary case, where kernel READs from a userspace mapped page.
|
|
|
|
* If the U-mapping is not congruent to to K-mapping, former needs flushing.
|
|
|
|
*/
|
2013-01-18 09:42:19 +00:00
|
|
|
void flush_dcache_page(struct page *page)
|
|
|
|
{
|
2013-05-09 16:24:51 +00:00
|
|
|
struct address_space *mapping;
|
|
|
|
|
|
|
|
if (!cache_is_vipt_aliasing()) {
|
2013-05-13 11:53:58 +00:00
|
|
|
clear_bit(PG_dc_clean, &page->flags);
|
2013-05-09 16:24:51 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* don't handle anon pages here */
|
|
|
|
mapping = page_mapping(page);
|
|
|
|
if (!mapping)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pagecache page, file not yet mapped to userspace
|
|
|
|
* Make a note that K-mapping is dirty
|
|
|
|
*/
|
|
|
|
if (!mapping_mapped(mapping)) {
|
2013-05-13 11:53:58 +00:00
|
|
|
clear_bit(PG_dc_clean, &page->flags);
|
2016-01-16 00:53:46 +00:00
|
|
|
} else if (page_mapcount(page)) {
|
2013-05-09 16:24:51 +00:00
|
|
|
|
|
|
|
/* kernel reading from page with U-mapping */
|
2015-09-15 01:43:42 +00:00
|
|
|
phys_addr_t paddr = (unsigned long)page_address(page);
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
unsigned long vaddr = page->index << PAGE_SHIFT;
|
2013-05-09 16:24:51 +00:00
|
|
|
|
|
|
|
if (addr_not_cache_congruent(paddr, vaddr))
|
|
|
|
__flush_dcache_page(paddr, vaddr);
|
|
|
|
}
|
2013-01-18 09:42:19 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(flush_dcache_page);
|
|
|
|
|
2015-05-25 16:54:28 +00:00
|
|
|
/*
|
|
|
|
* DMA ops for systems with L1 cache only
|
|
|
|
* Make memory coherent with L1 cache by flushing/invalidating L1 lines
|
|
|
|
*/
|
2016-03-16 09:34:39 +00:00
|
|
|
static void __dma_cache_wback_inv_l1(phys_addr_t start, unsigned long sz)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
2013-05-09 09:40:18 +00:00
|
|
|
__dc_line_op_k(start, sz, OP_FLUSH_N_INV);
|
2015-05-25 16:54:28 +00:00
|
|
|
}
|
2015-04-03 09:37:07 +00:00
|
|
|
|
2016-03-16 09:34:39 +00:00
|
|
|
static void __dma_cache_inv_l1(phys_addr_t start, unsigned long sz)
|
2015-05-25 16:54:28 +00:00
|
|
|
{
|
|
|
|
__dc_line_op_k(start, sz, OP_INV);
|
2013-01-18 09:42:19 +00:00
|
|
|
}
|
|
|
|
|
2016-03-16 09:34:39 +00:00
|
|
|
static void __dma_cache_wback_l1(phys_addr_t start, unsigned long sz)
|
2015-05-25 16:54:28 +00:00
|
|
|
{
|
|
|
|
__dc_line_op_k(start, sz, OP_FLUSH);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DMA ops for systems with both L1 and L2 caches, but without IOC
|
2016-02-23 23:24:55 +00:00
|
|
|
* Both L1 and L2 lines need to be explicitly flushed/invalidated
|
2015-05-25 16:54:28 +00:00
|
|
|
*/
|
2016-03-16 09:34:39 +00:00
|
|
|
static void __dma_cache_wback_inv_slc(phys_addr_t start, unsigned long sz)
|
2015-05-25 16:54:28 +00:00
|
|
|
{
|
|
|
|
__dc_line_op_k(start, sz, OP_FLUSH_N_INV);
|
|
|
|
slc_op(start, sz, OP_FLUSH_N_INV);
|
|
|
|
}
|
|
|
|
|
2016-03-16 09:34:39 +00:00
|
|
|
static void __dma_cache_inv_slc(phys_addr_t start, unsigned long sz)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
2013-05-09 09:40:18 +00:00
|
|
|
__dc_line_op_k(start, sz, OP_INV);
|
2015-05-25 16:54:28 +00:00
|
|
|
slc_op(start, sz, OP_INV);
|
|
|
|
}
|
2015-04-03 09:37:07 +00:00
|
|
|
|
2016-03-16 09:34:39 +00:00
|
|
|
static void __dma_cache_wback_slc(phys_addr_t start, unsigned long sz)
|
2015-05-25 16:54:28 +00:00
|
|
|
{
|
|
|
|
__dc_line_op_k(start, sz, OP_FLUSH);
|
|
|
|
slc_op(start, sz, OP_FLUSH);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DMA ops for systems with IOC
|
|
|
|
* IOC hardware snoops all DMA traffic keeping the caches consistent with
|
|
|
|
* memory - eliding need for any explicit cache maintenance of DMA buffers
|
|
|
|
*/
|
2016-03-16 09:34:39 +00:00
|
|
|
static void __dma_cache_wback_inv_ioc(phys_addr_t start, unsigned long sz) {}
|
|
|
|
static void __dma_cache_inv_ioc(phys_addr_t start, unsigned long sz) {}
|
|
|
|
static void __dma_cache_wback_ioc(phys_addr_t start, unsigned long sz) {}
|
2015-05-25 16:54:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Exported DMA API
|
|
|
|
*/
|
2016-03-16 09:34:39 +00:00
|
|
|
void dma_cache_wback_inv(phys_addr_t start, unsigned long sz)
|
2015-05-25 16:54:28 +00:00
|
|
|
{
|
|
|
|
__dma_cache_wback_inv(start, sz);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dma_cache_wback_inv);
|
|
|
|
|
2016-03-16 09:34:39 +00:00
|
|
|
void dma_cache_inv(phys_addr_t start, unsigned long sz)
|
2015-05-25 16:54:28 +00:00
|
|
|
{
|
|
|
|
__dma_cache_inv(start, sz);
|
2013-01-18 09:42:19 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dma_cache_inv);
|
|
|
|
|
2016-03-16 09:34:39 +00:00
|
|
|
void dma_cache_wback(phys_addr_t start, unsigned long sz)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
2015-05-25 16:54:28 +00:00
|
|
|
__dma_cache_wback(start, sz);
|
2013-01-18 09:42:19 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(dma_cache_wback);
|
|
|
|
|
|
|
|
/*
|
2013-04-12 06:48:25 +00:00
|
|
|
* This is API for making I/D Caches consistent when modifying
|
|
|
|
* kernel code (loadable modules, kprobes, kgdb...)
|
2013-01-18 09:42:19 +00:00
|
|
|
* This is called on insmod, with kernel virtual address for CODE of
|
|
|
|
* the module. ARC cache maintenance ops require PHY address thus we
|
|
|
|
* need to convert vmalloc addr to PHY addr
|
|
|
|
*/
|
|
|
|
void flush_icache_range(unsigned long kstart, unsigned long kend)
|
|
|
|
{
|
2014-09-24 06:06:20 +00:00
|
|
|
unsigned int tot_sz;
|
2013-01-18 09:42:19 +00:00
|
|
|
|
2014-09-24 06:06:20 +00:00
|
|
|
WARN(kstart < TASK_SIZE, "%s() can't handle user vaddr", __func__);
|
2013-01-18 09:42:19 +00:00
|
|
|
|
|
|
|
/* Shortcut for bigger flush ranges.
|
|
|
|
* Here we don't care if this was kernel virtual or phy addr
|
|
|
|
*/
|
|
|
|
tot_sz = kend - kstart;
|
|
|
|
if (tot_sz > PAGE_SIZE) {
|
|
|
|
flush_cache_all();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Case: Kernel Phy addr (0x8000_0000 onwards) */
|
|
|
|
if (likely(kstart > PAGE_OFFSET)) {
|
2013-04-12 06:48:25 +00:00
|
|
|
/*
|
|
|
|
* The 2nd arg despite being paddr will be used to index icache
|
|
|
|
* This is OK since no alternate virtual mappings will exist
|
|
|
|
* given the callers for this case: kprobe/kgdb in built-in
|
|
|
|
* kernel code only.
|
|
|
|
*/
|
2013-04-12 06:50:23 +00:00
|
|
|
__sync_icache_dcache(kstart, kstart, kend - kstart);
|
2013-01-18 09:42:19 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Case: Kernel Vaddr (0x7000_0000 to 0x7fff_ffff)
|
|
|
|
* (1) ARC Cache Maintenance ops only take Phy addr, hence special
|
|
|
|
* handling of kernel vaddr.
|
|
|
|
*
|
|
|
|
* (2) Despite @tot_sz being < PAGE_SIZE (bigger cases handled already),
|
|
|
|
* it still needs to handle a 2 page scenario, where the range
|
|
|
|
* straddles across 2 virtual pages and hence need for loop
|
|
|
|
*/
|
|
|
|
while (tot_sz > 0) {
|
2014-09-24 06:06:20 +00:00
|
|
|
unsigned int off, sz;
|
|
|
|
unsigned long phy, pfn;
|
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
off = kstart % PAGE_SIZE;
|
|
|
|
pfn = vmalloc_to_pfn((void *)kstart);
|
|
|
|
phy = (pfn << PAGE_SHIFT) + off;
|
|
|
|
sz = min_t(unsigned int, tot_sz, PAGE_SIZE - off);
|
2013-04-12 06:50:23 +00:00
|
|
|
__sync_icache_dcache(phy, kstart, sz);
|
2013-01-18 09:42:19 +00:00
|
|
|
kstart += sz;
|
|
|
|
tot_sz -= sz;
|
|
|
|
}
|
|
|
|
}
|
2014-08-29 22:19:09 +00:00
|
|
|
EXPORT_SYMBOL(flush_icache_range);
|
2013-01-18 09:42:19 +00:00
|
|
|
|
|
|
|
/*
|
2013-04-12 06:50:23 +00:00
|
|
|
* General purpose helper to make I and D cache lines consistent.
|
|
|
|
* @paddr is phy addr of region
|
2013-07-10 06:10:27 +00:00
|
|
|
* @vaddr is typically user vaddr (breakpoint) or kernel vaddr (vmalloc)
|
|
|
|
* However in one instance, when called by kprobe (for a breakpt in
|
2013-04-12 06:50:23 +00:00
|
|
|
* builtin kernel code) @vaddr will be paddr only, meaning CDU operation will
|
|
|
|
* use a paddr to index the cache (despite VIPT). This is fine since since a
|
2013-07-10 06:10:27 +00:00
|
|
|
* builtin kernel page will not have any virtual mappings.
|
|
|
|
* kprobe on loadable module will be kernel vaddr.
|
2013-01-18 09:42:19 +00:00
|
|
|
*/
|
2015-09-15 01:43:42 +00:00
|
|
|
void __sync_icache_dcache(phys_addr_t paddr, unsigned long vaddr, int len)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
2013-05-16 06:49:29 +00:00
|
|
|
__dc_line_op(paddr, vaddr, len, OP_FLUSH_N_INV);
|
2013-02-17 10:51:42 +00:00
|
|
|
__ic_line_inv_vaddr(paddr, vaddr, len);
|
2013-01-18 09:42:19 +00:00
|
|
|
}
|
|
|
|
|
2013-04-11 13:06:35 +00:00
|
|
|
/* wrapper to compile time eliminate alignment checks in flush loop */
|
2015-09-15 01:43:42 +00:00
|
|
|
void __inv_icache_page(phys_addr_t paddr, unsigned long vaddr)
|
2013-01-18 09:42:19 +00:00
|
|
|
{
|
2013-04-11 13:06:35 +00:00
|
|
|
__ic_line_inv_vaddr(paddr, vaddr, PAGE_SIZE);
|
2013-01-18 09:42:19 +00:00
|
|
|
}
|
|
|
|
|
2013-05-09 09:40:18 +00:00
|
|
|
/*
|
|
|
|
* wrapper to clearout kernel or userspace mappings of a page
|
|
|
|
* For kernel mappings @vaddr == @paddr
|
|
|
|
*/
|
2015-09-15 01:43:42 +00:00
|
|
|
void __flush_dcache_page(phys_addr_t paddr, unsigned long vaddr)
|
2013-04-16 08:40:48 +00:00
|
|
|
{
|
2013-05-09 09:40:18 +00:00
|
|
|
__dc_line_op(paddr, vaddr & PAGE_MASK, PAGE_SIZE, OP_FLUSH_N_INV);
|
2013-04-16 08:40:48 +00:00
|
|
|
}
|
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
noinline void flush_cache_all(void)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
2013-06-22 13:52:42 +00:00
|
|
|
__ic_entire_inv();
|
2013-01-18 09:42:19 +00:00
|
|
|
__dc_entire_op(OP_FLUSH_N_INV);
|
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-05-09 16:24:51 +00:00
|
|
|
#ifdef CONFIG_ARC_CACHE_VIPT_ALIASING
|
|
|
|
|
|
|
|
void flush_cache_mm(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
flush_cache_all();
|
|
|
|
}
|
|
|
|
|
|
|
|
void flush_cache_page(struct vm_area_struct *vma, unsigned long u_vaddr,
|
|
|
|
unsigned long pfn)
|
|
|
|
{
|
|
|
|
unsigned int paddr = pfn << PAGE_SHIFT;
|
|
|
|
|
2013-05-16 06:53:31 +00:00
|
|
|
u_vaddr &= PAGE_MASK;
|
|
|
|
|
2015-05-18 07:16:37 +00:00
|
|
|
__flush_dcache_page(paddr, u_vaddr);
|
2013-05-16 06:53:31 +00:00
|
|
|
|
|
|
|
if (vma->vm_flags & VM_EXEC)
|
|
|
|
__inv_icache_page(paddr, u_vaddr);
|
2013-05-09 16:24:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void flush_cache_range(struct vm_area_struct *vma, unsigned long start,
|
|
|
|
unsigned long end)
|
|
|
|
{
|
|
|
|
flush_cache_all();
|
|
|
|
}
|
|
|
|
|
2013-05-25 08:34:25 +00:00
|
|
|
void flush_anon_page(struct vm_area_struct *vma, struct page *page,
|
|
|
|
unsigned long u_vaddr)
|
|
|
|
{
|
|
|
|
/* TBD: do we really need to clear the kernel mapping */
|
|
|
|
__flush_dcache_page(page_address(page), u_vaddr);
|
|
|
|
__flush_dcache_page(page_address(page), page_address(page));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2013-05-09 16:24:51 +00:00
|
|
|
void copy_user_highpage(struct page *to, struct page *from,
|
|
|
|
unsigned long u_vaddr, struct vm_area_struct *vma)
|
|
|
|
{
|
2015-03-05 11:36:31 +00:00
|
|
|
void *kfrom = kmap_atomic(from);
|
|
|
|
void *kto = kmap_atomic(to);
|
2013-05-09 16:24:51 +00:00
|
|
|
int clean_src_k_mappings = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If SRC page was already mapped in userspace AND it's U-mapping is
|
|
|
|
* not congruent with K-mapping, sync former to physical page so that
|
|
|
|
* K-mapping in memcpy below, sees the right data
|
|
|
|
*
|
|
|
|
* Note that while @u_vaddr refers to DST page's userspace vaddr, it is
|
|
|
|
* equally valid for SRC page as well
|
2015-03-05 11:36:31 +00:00
|
|
|
*
|
|
|
|
* For !VIPT cache, all of this gets compiled out as
|
|
|
|
* addr_not_cache_congruent() is 0
|
2013-05-09 16:24:51 +00:00
|
|
|
*/
|
2016-01-16 00:53:46 +00:00
|
|
|
if (page_mapcount(from) && addr_not_cache_congruent(kfrom, u_vaddr)) {
|
2015-03-05 11:36:31 +00:00
|
|
|
__flush_dcache_page((unsigned long)kfrom, u_vaddr);
|
2013-05-09 16:24:51 +00:00
|
|
|
clean_src_k_mappings = 1;
|
|
|
|
}
|
|
|
|
|
2015-03-05 11:36:31 +00:00
|
|
|
copy_page(kto, kfrom);
|
2013-05-09 16:24:51 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Mark DST page K-mapping as dirty for a later finalization by
|
|
|
|
* update_mmu_cache(). Although the finalization could have been done
|
|
|
|
* here as well (given that both vaddr/paddr are available).
|
|
|
|
* But update_mmu_cache() already has code to do that for other
|
|
|
|
* non copied user pages (e.g. read faults which wire in pagecache page
|
|
|
|
* directly).
|
|
|
|
*/
|
2013-05-13 11:53:58 +00:00
|
|
|
clear_bit(PG_dc_clean, &to->flags);
|
2013-05-09 16:24:51 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* if SRC was already usermapped and non-congruent to kernel mapping
|
|
|
|
* sync the kernel mapping back to physical page
|
|
|
|
*/
|
|
|
|
if (clean_src_k_mappings) {
|
2015-03-05 11:36:31 +00:00
|
|
|
__flush_dcache_page((unsigned long)kfrom, (unsigned long)kfrom);
|
2013-05-13 11:53:58 +00:00
|
|
|
set_bit(PG_dc_clean, &from->flags);
|
2013-05-09 16:24:51 +00:00
|
|
|
} else {
|
2013-05-13 11:53:58 +00:00
|
|
|
clear_bit(PG_dc_clean, &from->flags);
|
2013-05-09 16:24:51 +00:00
|
|
|
}
|
2015-03-05 11:36:31 +00:00
|
|
|
|
|
|
|
kunmap_atomic(kto);
|
|
|
|
kunmap_atomic(kfrom);
|
2013-05-09 16:24:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void clear_user_page(void *to, unsigned long u_vaddr, struct page *page)
|
|
|
|
{
|
|
|
|
clear_page(to);
|
2013-05-13 11:53:58 +00:00
|
|
|
clear_bit(PG_dc_clean, &page->flags);
|
2013-05-09 16:24:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-01-18 09:42:19 +00:00
|
|
|
/**********************************************************************
|
|
|
|
* Explicit Cache flush request from user space via syscall
|
|
|
|
* Needed for JITs which generate code on the fly
|
|
|
|
*/
|
|
|
|
SYSCALL_DEFINE3(cacheflush, uint32_t, start, uint32_t, sz, uint32_t, flags)
|
|
|
|
{
|
|
|
|
/* TBD: optimize this */
|
|
|
|
flush_cache_all();
|
|
|
|
return 0;
|
|
|
|
}
|
2015-06-04 10:05:53 +00:00
|
|
|
|
2016-06-22 10:31:19 +00:00
|
|
|
/*
|
|
|
|
* IO-Coherency (IOC) setup rules:
|
|
|
|
*
|
|
|
|
* 1. Needs to be at system level, so only once by Master core
|
|
|
|
* Non-Masters need not be accessing caches at that time
|
|
|
|
* - They are either HALT_ON_RESET and kick started much later or
|
|
|
|
* - if run on reset, need to ensure that arc_platform_smp_wait_to_boot()
|
|
|
|
* doesn't perturb caches or coherency unit
|
|
|
|
*
|
|
|
|
* 2. caches (L1 and SLC) need to be purged (flush+inv) before setting up IOC,
|
|
|
|
* otherwise any straggler data might behave strangely post IOC enabling
|
|
|
|
*
|
|
|
|
* 3. All Caches need to be disabled when setting up IOC to elide any in-flight
|
|
|
|
* Coherency transactions
|
|
|
|
*/
|
2017-01-18 23:10:52 +00:00
|
|
|
noinline void __init arc_ioc_setup(void)
|
2016-06-22 10:13:22 +00:00
|
|
|
{
|
2017-08-15 18:13:53 +00:00
|
|
|
unsigned int ioc_base, mem_sz;
|
2017-01-18 20:59:21 +00:00
|
|
|
|
2016-06-22 10:31:19 +00:00
|
|
|
/* Flush + invalidate + disable L1 dcache */
|
|
|
|
__dc_disable();
|
|
|
|
|
|
|
|
/* Flush + invalidate SLC */
|
|
|
|
if (read_aux_reg(ARC_REG_SLC_BCR))
|
|
|
|
slc_entire_op(OP_FLUSH_N_INV);
|
|
|
|
|
2017-01-18 20:59:21 +00:00
|
|
|
/*
|
2017-08-15 18:13:53 +00:00
|
|
|
* currently IOC Aperture covers entire DDR
|
2017-01-18 20:59:21 +00:00
|
|
|
* TBD: fix for PGU + 1GB of low mem
|
|
|
|
* TBD: fix for PAE
|
|
|
|
*/
|
2017-08-15 18:13:53 +00:00
|
|
|
mem_sz = arc_get_mem_sz();
|
|
|
|
|
|
|
|
if (!is_power_of_2(mem_sz) || mem_sz < 4096)
|
|
|
|
panic("IOC Aperture size must be power of 2 larger than 4KB");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IOC Aperture size decoded as 2 ^ (SIZE + 2) KB,
|
|
|
|
* so setting 0x11 implies 512MB, 0x12 implies 1GB...
|
|
|
|
*/
|
|
|
|
write_aux_reg(ARC_REG_IO_COH_AP0_SIZE, order_base_2(mem_sz >> 10) - 2);
|
|
|
|
|
|
|
|
/* for now assume kernel base is start of IOC aperture */
|
2017-08-15 18:13:54 +00:00
|
|
|
ioc_base = CONFIG_LINUX_RAM_BASE;
|
2017-08-15 18:13:53 +00:00
|
|
|
|
|
|
|
if (ioc_base % mem_sz != 0)
|
|
|
|
panic("IOC Aperture start must be aligned to the size of the aperture");
|
2016-06-22 10:31:19 +00:00
|
|
|
|
2017-08-15 18:13:53 +00:00
|
|
|
write_aux_reg(ARC_REG_IO_COH_AP0_BASE, ioc_base >> 12);
|
2016-06-22 10:13:22 +00:00
|
|
|
write_aux_reg(ARC_REG_IO_COH_PARTIAL, 1);
|
|
|
|
write_aux_reg(ARC_REG_IO_COH_ENABLE, 1);
|
2016-06-22 10:31:19 +00:00
|
|
|
|
|
|
|
/* Re-enable L1 dcache */
|
|
|
|
__dc_enable();
|
2016-06-22 10:13:22 +00:00
|
|
|
}
|
|
|
|
|
2017-08-03 12:15:44 +00:00
|
|
|
/*
|
|
|
|
* Cache related boot time checks/setups only needed on master CPU:
|
|
|
|
* - Geometry checks (kernel build and hardware agree: e.g. L1_CACHE_BYTES)
|
|
|
|
* Assume SMP only, so all cores will have same cache config. A check on
|
|
|
|
* one core suffices for all
|
|
|
|
* - IOC setup / dma callbacks only need to be done once
|
|
|
|
*/
|
2017-01-18 23:10:52 +00:00
|
|
|
void __init arc_cache_init_master(void)
|
2015-06-04 10:05:53 +00:00
|
|
|
{
|
|
|
|
unsigned int __maybe_unused cpu = smp_processor_id();
|
2016-06-13 14:38:27 +00:00
|
|
|
|
2015-06-04 10:05:53 +00:00
|
|
|
if (IS_ENABLED(CONFIG_ARC_HAS_ICACHE)) {
|
|
|
|
struct cpuinfo_arc_cache *ic = &cpuinfo_arc700[cpu].icache;
|
|
|
|
|
2016-12-19 19:24:08 +00:00
|
|
|
if (!ic->line_len)
|
2015-06-04 10:05:53 +00:00
|
|
|
panic("cache support enabled but non-existent cache\n");
|
|
|
|
|
|
|
|
if (ic->line_len != L1_CACHE_BYTES)
|
|
|
|
panic("ICache line [%d] != kernel Config [%d]",
|
|
|
|
ic->line_len, L1_CACHE_BYTES);
|
|
|
|
|
2015-06-04 09:09:15 +00:00
|
|
|
/*
|
2016-05-21 11:45:35 +00:00
|
|
|
* In MMU v4 (HS38x) the aliasing icache config uses IVIL/PTAG
|
2015-06-04 09:09:15 +00:00
|
|
|
* pair to provide vaddr/paddr respectively, just as in MMU v3
|
|
|
|
*/
|
|
|
|
if (is_isa_arcv2() && ic->alias)
|
|
|
|
_cache_line_loop_ic_fn = __cache_line_loop_v3;
|
|
|
|
else
|
|
|
|
_cache_line_loop_ic_fn = __cache_line_loop;
|
2015-06-04 10:05:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_ARC_HAS_DCACHE)) {
|
|
|
|
struct cpuinfo_arc_cache *dc = &cpuinfo_arc700[cpu].dcache;
|
|
|
|
|
2016-12-19 19:24:08 +00:00
|
|
|
if (!dc->line_len)
|
2015-06-04 10:05:53 +00:00
|
|
|
panic("cache support enabled but non-existent cache\n");
|
|
|
|
|
|
|
|
if (dc->line_len != L1_CACHE_BYTES)
|
|
|
|
panic("DCache line [%d] != kernel Config [%d]",
|
|
|
|
dc->line_len, L1_CACHE_BYTES);
|
|
|
|
|
2015-04-06 11:53:57 +00:00
|
|
|
/* check for D-Cache aliasing on ARCompact: ARCv2 has PIPT */
|
|
|
|
if (is_isa_arcompact()) {
|
|
|
|
int handled = IS_ENABLED(CONFIG_ARC_CACHE_VIPT_ALIASING);
|
2016-12-19 19:38:38 +00:00
|
|
|
int num_colors = dc->sz_k/dc->assoc/TO_KB(PAGE_SIZE);
|
|
|
|
|
|
|
|
if (dc->alias) {
|
|
|
|
if (!handled)
|
|
|
|
panic("Enable CONFIG_ARC_CACHE_VIPT_ALIASING\n");
|
|
|
|
if (CACHE_COLORS_NUM != num_colors)
|
|
|
|
panic("CACHE_COLORS_NUM not optimized for config\n");
|
|
|
|
} else if (!dc->alias && handled) {
|
2015-04-06 11:53:57 +00:00
|
|
|
panic("Disable CONFIG_ARC_CACHE_VIPT_ALIASING\n");
|
2016-12-19 19:38:38 +00:00
|
|
|
}
|
2015-04-06 11:53:57 +00:00
|
|
|
}
|
2015-06-04 10:05:53 +00:00
|
|
|
}
|
2015-05-25 16:54:28 +00:00
|
|
|
|
2016-06-22 10:13:22 +00:00
|
|
|
/* Note that SLC disable not formally supported till HS 3.0 */
|
|
|
|
if (is_isa_arcv2() && l2_line_sz && !slc_enable)
|
|
|
|
arc_slc_disable();
|
2015-06-04 13:00:23 +00:00
|
|
|
|
2016-06-22 10:13:22 +00:00
|
|
|
if (is_isa_arcv2() && ioc_enable)
|
|
|
|
arc_ioc_setup();
|
2015-06-04 13:00:23 +00:00
|
|
|
|
2016-10-13 22:58:59 +00:00
|
|
|
if (is_isa_arcv2() && ioc_enable) {
|
2015-05-25 16:54:28 +00:00
|
|
|
__dma_cache_wback_inv = __dma_cache_wback_inv_ioc;
|
|
|
|
__dma_cache_inv = __dma_cache_inv_ioc;
|
|
|
|
__dma_cache_wback = __dma_cache_wback_ioc;
|
2015-06-04 13:00:23 +00:00
|
|
|
} else if (is_isa_arcv2() && l2_line_sz && slc_enable) {
|
2015-05-25 16:54:28 +00:00
|
|
|
__dma_cache_wback_inv = __dma_cache_wback_inv_slc;
|
|
|
|
__dma_cache_inv = __dma_cache_inv_slc;
|
|
|
|
__dma_cache_wback = __dma_cache_wback_slc;
|
|
|
|
} else {
|
|
|
|
__dma_cache_wback_inv = __dma_cache_wback_inv_l1;
|
|
|
|
__dma_cache_inv = __dma_cache_inv_l1;
|
|
|
|
__dma_cache_wback = __dma_cache_wback_l1;
|
|
|
|
}
|
2015-06-04 10:05:53 +00:00
|
|
|
}
|
2017-01-18 23:10:52 +00:00
|
|
|
|
|
|
|
void __ref arc_cache_init(void)
|
|
|
|
{
|
|
|
|
unsigned int __maybe_unused cpu = smp_processor_id();
|
|
|
|
char str[256];
|
|
|
|
|
2017-06-15 08:43:51 +00:00
|
|
|
pr_info("%s", arc_cache_mumbojumbo(0, str, sizeof(str)));
|
2017-01-18 23:10:52 +00:00
|
|
|
|
|
|
|
if (!cpu)
|
|
|
|
arc_cache_init_master();
|
2017-08-03 12:15:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* In PAE regime, TLB and cache maintenance ops take wider addresses
|
|
|
|
* And even if PAE is not enabled in kernel, the upper 32-bits still need
|
|
|
|
* to be zeroed to keep the ops sane.
|
|
|
|
* As an optimization for more common !PAE enabled case, zero them out
|
|
|
|
* once at init, rather than checking/setting to 0 for every runtime op
|
|
|
|
*/
|
|
|
|
if (is_isa_arcv2() && pae40_exist_but_not_enab()) {
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_ARC_HAS_ICACHE))
|
|
|
|
write_aux_reg(ARC_REG_IC_PTAG_HI, 0);
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_ARC_HAS_DCACHE))
|
|
|
|
write_aux_reg(ARC_REG_DC_PTAG_HI, 0);
|
|
|
|
|
|
|
|
if (l2_line_sz) {
|
|
|
|
write_aux_reg(ARC_REG_SLC_RGN_END1, 0);
|
|
|
|
write_aux_reg(ARC_REG_SLC_RGN_START1, 0);
|
|
|
|
}
|
|
|
|
}
|
2017-01-18 23:10:52 +00:00
|
|
|
}
|