1660d5f0dSAlexey Brodkin /* 2660d5f0dSAlexey Brodkin * Copyright (C) 2013-2014 Synopsys, Inc. All rights reserved. 3660d5f0dSAlexey Brodkin * 4660d5f0dSAlexey Brodkin * SPDX-License-Identifier: GPL-2.0+ 5660d5f0dSAlexey Brodkin */ 6660d5f0dSAlexey Brodkin 7660d5f0dSAlexey Brodkin #include <config.h> 8379b3280SAlexey Brodkin #include <common.h> 9ef639e6fSAlexey Brodkin #include <linux/compiler.h> 10ef639e6fSAlexey Brodkin #include <linux/kernel.h> 1197a63144SAlexey Brodkin #include <linux/log2.h> 12660d5f0dSAlexey Brodkin #include <asm/arcregs.h> 13*88ae27edSEugeniy Paltsev #include <asm/arc-bcr.h> 14205e7a7bSAlexey Brodkin #include <asm/cache.h> 15660d5f0dSAlexey Brodkin 16c27814beSEugeniy Paltsev /* 17c27814beSEugeniy Paltsev * [ NOTE 1 ]: 18c27814beSEugeniy Paltsev * Data cache (L1 D$ or SL$) entire invalidate operation or data cache disable 19c27814beSEugeniy Paltsev * operation may result in unexpected behavior and data loss even if we flush 20c27814beSEugeniy Paltsev * data cache right before invalidation. That may happens if we store any context 21c27814beSEugeniy Paltsev * on stack (like we store BLINK register on stack before function call). 22c27814beSEugeniy Paltsev * BLINK register is the register where return address is automatically saved 23c27814beSEugeniy Paltsev * when we do function call with instructions like 'bl'. 24c27814beSEugeniy Paltsev * 25c27814beSEugeniy Paltsev * There is the real example: 26c27814beSEugeniy Paltsev * We may hang in the next code as we store any BLINK register on stack in 27c27814beSEugeniy Paltsev * invalidate_dcache_all() function. 28c27814beSEugeniy Paltsev * 29c27814beSEugeniy Paltsev * void flush_dcache_all() { 30c27814beSEugeniy Paltsev * __dc_entire_op(OP_FLUSH); 31c27814beSEugeniy Paltsev * // Other code // 32c27814beSEugeniy Paltsev * } 33c27814beSEugeniy Paltsev * 34c27814beSEugeniy Paltsev * void invalidate_dcache_all() { 35c27814beSEugeniy Paltsev * __dc_entire_op(OP_INV); 36c27814beSEugeniy Paltsev * // Other code // 37c27814beSEugeniy Paltsev * } 38c27814beSEugeniy Paltsev * 39c27814beSEugeniy Paltsev * void foo(void) { 40c27814beSEugeniy Paltsev * flush_dcache_all(); 41c27814beSEugeniy Paltsev * invalidate_dcache_all(); 42c27814beSEugeniy Paltsev * } 43c27814beSEugeniy Paltsev * 44c27814beSEugeniy Paltsev * Now let's see what really happens during that code execution: 45c27814beSEugeniy Paltsev * 46c27814beSEugeniy Paltsev * foo() 47c27814beSEugeniy Paltsev * |->> call flush_dcache_all 48c27814beSEugeniy Paltsev * [return address is saved to BLINK register] 49c27814beSEugeniy Paltsev * [push BLINK] (save to stack) ![point 1] 50c27814beSEugeniy Paltsev * |->> call __dc_entire_op(OP_FLUSH) 51c27814beSEugeniy Paltsev * [return address is saved to BLINK register] 52c27814beSEugeniy Paltsev * [flush L1 D$] 53c27814beSEugeniy Paltsev * return [jump to BLINK] 54c27814beSEugeniy Paltsev * <<------ 55c27814beSEugeniy Paltsev * [other flush_dcache_all code] 56c27814beSEugeniy Paltsev * [pop BLINK] (get from stack) 57c27814beSEugeniy Paltsev * return [jump to BLINK] 58c27814beSEugeniy Paltsev * <<------ 59c27814beSEugeniy Paltsev * |->> call invalidate_dcache_all 60c27814beSEugeniy Paltsev * [return address is saved to BLINK register] 61c27814beSEugeniy Paltsev * [push BLINK] (save to stack) ![point 2] 62c27814beSEugeniy Paltsev * |->> call __dc_entire_op(OP_FLUSH) 63c27814beSEugeniy Paltsev * [return address is saved to BLINK register] 64c27814beSEugeniy Paltsev * [invalidate L1 D$] ![point 3] 65c27814beSEugeniy Paltsev * // Oops!!! 66c27814beSEugeniy Paltsev * // We lose return address from invalidate_dcache_all function: 67c27814beSEugeniy Paltsev * // we save it to stack and invalidate L1 D$ after that! 68c27814beSEugeniy Paltsev * return [jump to BLINK] 69c27814beSEugeniy Paltsev * <<------ 70c27814beSEugeniy Paltsev * [other invalidate_dcache_all code] 71c27814beSEugeniy Paltsev * [pop BLINK] (get from stack) 72c27814beSEugeniy Paltsev * // we don't have this data in L1 dcache as we invalidated it in [point 3] 73c27814beSEugeniy Paltsev * // so we get it from next memory level (for example DDR memory) 74c27814beSEugeniy Paltsev * // but in the memory we have value which we save in [point 1], which 75c27814beSEugeniy Paltsev * // is return address from flush_dcache_all function (instead of 76c27814beSEugeniy Paltsev * // address from current invalidate_dcache_all function which we 77c27814beSEugeniy Paltsev * // saved in [point 2] !) 78c27814beSEugeniy Paltsev * return [jump to BLINK] 79c27814beSEugeniy Paltsev * <<------ 80c27814beSEugeniy Paltsev * // As BLINK points to invalidate_dcache_all, we call it again and 81c27814beSEugeniy Paltsev * // loop forever. 82c27814beSEugeniy Paltsev * 83c27814beSEugeniy Paltsev * Fortunately we may fix that by using flush & invalidation of D$ with a single 84c27814beSEugeniy Paltsev * one instruction (instead of flush and invalidation instructions pair) and 85c27814beSEugeniy Paltsev * enabling force function inline with '__attribute__((always_inline))' gcc 86c27814beSEugeniy Paltsev * attribute to avoid any function call (and BLINK store) between cache flush 87c27814beSEugeniy Paltsev * and disable. 88c27814beSEugeniy Paltsev */ 89c27814beSEugeniy Paltsev 90660d5f0dSAlexey Brodkin /* Bit values in IC_CTRL */ 9119b10a42SEugeniy Paltsev #define IC_CTRL_CACHE_DISABLE BIT(0) 92660d5f0dSAlexey Brodkin 93660d5f0dSAlexey Brodkin /* Bit values in DC_CTRL */ 9419b10a42SEugeniy Paltsev #define DC_CTRL_CACHE_DISABLE BIT(0) 9519b10a42SEugeniy Paltsev #define DC_CTRL_INV_MODE_FLUSH BIT(6) 9619b10a42SEugeniy Paltsev #define DC_CTRL_FLUSH_STATUS BIT(8) 97660d5f0dSAlexey Brodkin #define CACHE_VER_NUM_MASK 0xF 98660d5f0dSAlexey Brodkin 995d7a24d6SEugeniy Paltsev #define OP_INV BIT(0) 1005d7a24d6SEugeniy Paltsev #define OP_FLUSH BIT(1) 1015d7a24d6SEugeniy Paltsev #define OP_FLUSH_N_INV (OP_FLUSH | OP_INV) 102ef639e6fSAlexey Brodkin 10341cada4dSEugeniy Paltsev /* Bit val in SLC_CONTROL */ 10441cada4dSEugeniy Paltsev #define SLC_CTRL_DIS 0x001 10541cada4dSEugeniy Paltsev #define SLC_CTRL_IM 0x040 10641cada4dSEugeniy Paltsev #define SLC_CTRL_BUSY 0x100 10741cada4dSEugeniy Paltsev #define SLC_CTRL_RGN_OP_INV 0x200 10841cada4dSEugeniy Paltsev 109ef639e6fSAlexey Brodkin /* 110ef639e6fSAlexey Brodkin * By default that variable will fall into .bss section. 111ef639e6fSAlexey Brodkin * But .bss section is not relocated and so it will be initilized before 112ef639e6fSAlexey Brodkin * relocation but will be used after being zeroed. 113ef639e6fSAlexey Brodkin */ 114379b3280SAlexey Brodkin int l1_line_sz __section(".data"); 1153cf23939SEugeniy Paltsev bool dcache_exists __section(".data") = false; 1163cf23939SEugeniy Paltsev bool icache_exists __section(".data") = false; 117379b3280SAlexey Brodkin 118379b3280SAlexey Brodkin #define CACHE_LINE_MASK (~(l1_line_sz - 1)) 119379b3280SAlexey Brodkin 120379b3280SAlexey Brodkin #ifdef CONFIG_ISA_ARCV2 121ef639e6fSAlexey Brodkin int slc_line_sz __section(".data"); 1223cf23939SEugeniy Paltsev bool slc_exists __section(".data") = false; 1233cf23939SEugeniy Paltsev bool ioc_exists __section(".data") = false; 12441cada4dSEugeniy Paltsev bool pae_exists __section(".data") = false; 125ef639e6fSAlexey Brodkin 126b0146f9eSEugeniy Paltsev /* To force enable IOC set ioc_enable to 'true' */ 127b0146f9eSEugeniy Paltsev bool ioc_enable __section(".data") = false; 128b0146f9eSEugeniy Paltsev 12941cada4dSEugeniy Paltsev void read_decode_mmu_bcr(void) 130ef639e6fSAlexey Brodkin { 13141cada4dSEugeniy Paltsev /* TODO: should we compare mmu version from BCR and from CONFIG? */ 13241cada4dSEugeniy Paltsev #if (CONFIG_ARC_MMU_VER >= 4) 133*88ae27edSEugeniy Paltsev union bcr_mmu_4 mmu4; 134ef639e6fSAlexey Brodkin 135*88ae27edSEugeniy Paltsev mmu4.word = read_aux_reg(ARC_AUX_MMU_BCR); 136ef639e6fSAlexey Brodkin 137*88ae27edSEugeniy Paltsev pae_exists = !!mmu4.fields.pae; 13841cada4dSEugeniy Paltsev #endif /* (CONFIG_ARC_MMU_VER >= 4) */ 13941cada4dSEugeniy Paltsev } 14041cada4dSEugeniy Paltsev 14141cada4dSEugeniy Paltsev static void __slc_entire_op(const int op) 14241cada4dSEugeniy Paltsev { 14341cada4dSEugeniy Paltsev unsigned int ctrl; 14441cada4dSEugeniy Paltsev 14541cada4dSEugeniy Paltsev ctrl = read_aux_reg(ARC_AUX_SLC_CTRL); 14641cada4dSEugeniy Paltsev 14741cada4dSEugeniy Paltsev if (!(op & OP_FLUSH)) /* i.e. OP_INV */ 14841cada4dSEugeniy Paltsev ctrl &= ~SLC_CTRL_IM; /* clear IM: Disable flush before Inv */ 14941cada4dSEugeniy Paltsev else 15041cada4dSEugeniy Paltsev ctrl |= SLC_CTRL_IM; 15141cada4dSEugeniy Paltsev 15241cada4dSEugeniy Paltsev write_aux_reg(ARC_AUX_SLC_CTRL, ctrl); 15341cada4dSEugeniy Paltsev 15441cada4dSEugeniy Paltsev if (op & OP_INV) /* Inv or flush-n-inv use same cmd reg */ 15541cada4dSEugeniy Paltsev write_aux_reg(ARC_AUX_SLC_INVALIDATE, 0x1); 15641cada4dSEugeniy Paltsev else 15741cada4dSEugeniy Paltsev write_aux_reg(ARC_AUX_SLC_FLUSH, 0x1); 15841cada4dSEugeniy Paltsev 15941cada4dSEugeniy Paltsev /* Make sure "busy" bit reports correct stataus, see STAR 9001165532 */ 16041cada4dSEugeniy Paltsev read_aux_reg(ARC_AUX_SLC_CTRL); 16141cada4dSEugeniy Paltsev 16241cada4dSEugeniy Paltsev /* Important to wait for flush to complete */ 16341cada4dSEugeniy Paltsev while (read_aux_reg(ARC_AUX_SLC_CTRL) & SLC_CTRL_BUSY); 16441cada4dSEugeniy Paltsev } 16541cada4dSEugeniy Paltsev 16641cada4dSEugeniy Paltsev static void slc_upper_region_init(void) 16741cada4dSEugeniy Paltsev { 16841cada4dSEugeniy Paltsev /* 16941cada4dSEugeniy Paltsev * ARC_AUX_SLC_RGN_END1 and ARC_AUX_SLC_RGN_START1 are always == 0 17041cada4dSEugeniy Paltsev * as we don't use PAE40. 17141cada4dSEugeniy Paltsev */ 17241cada4dSEugeniy Paltsev write_aux_reg(ARC_AUX_SLC_RGN_END1, 0); 17341cada4dSEugeniy Paltsev write_aux_reg(ARC_AUX_SLC_RGN_START1, 0); 17441cada4dSEugeniy Paltsev } 17541cada4dSEugeniy Paltsev 17641cada4dSEugeniy Paltsev static void __slc_rgn_op(unsigned long paddr, unsigned long sz, const int op) 17741cada4dSEugeniy Paltsev { 17841cada4dSEugeniy Paltsev unsigned int ctrl; 17941cada4dSEugeniy Paltsev unsigned long end; 18041cada4dSEugeniy Paltsev 18141cada4dSEugeniy Paltsev /* 18241cada4dSEugeniy Paltsev * The Region Flush operation is specified by CTRL.RGN_OP[11..9] 18341cada4dSEugeniy Paltsev * - b'000 (default) is Flush, 18441cada4dSEugeniy Paltsev * - b'001 is Invalidate if CTRL.IM == 0 18541cada4dSEugeniy Paltsev * - b'001 is Flush-n-Invalidate if CTRL.IM == 1 18641cada4dSEugeniy Paltsev */ 18741cada4dSEugeniy Paltsev ctrl = read_aux_reg(ARC_AUX_SLC_CTRL); 18841cada4dSEugeniy Paltsev 18941cada4dSEugeniy Paltsev /* Don't rely on default value of IM bit */ 19041cada4dSEugeniy Paltsev if (!(op & OP_FLUSH)) /* i.e. OP_INV */ 19141cada4dSEugeniy Paltsev ctrl &= ~SLC_CTRL_IM; /* clear IM: Disable flush before Inv */ 19241cada4dSEugeniy Paltsev else 19341cada4dSEugeniy Paltsev ctrl |= SLC_CTRL_IM; 19441cada4dSEugeniy Paltsev 19541cada4dSEugeniy Paltsev if (op & OP_INV) 19641cada4dSEugeniy Paltsev ctrl |= SLC_CTRL_RGN_OP_INV; /* Inv or flush-n-inv */ 19741cada4dSEugeniy Paltsev else 19841cada4dSEugeniy Paltsev ctrl &= ~SLC_CTRL_RGN_OP_INV; 19941cada4dSEugeniy Paltsev 20041cada4dSEugeniy Paltsev write_aux_reg(ARC_AUX_SLC_CTRL, ctrl); 20141cada4dSEugeniy Paltsev 20241cada4dSEugeniy Paltsev /* 20341cada4dSEugeniy Paltsev * Lower bits are ignored, no need to clip 20441cada4dSEugeniy Paltsev * END needs to be setup before START (latter triggers the operation) 20541cada4dSEugeniy Paltsev * END can't be same as START, so add (l2_line_sz - 1) to sz 20641cada4dSEugeniy Paltsev */ 20741cada4dSEugeniy Paltsev end = paddr + sz + slc_line_sz - 1; 20841cada4dSEugeniy Paltsev 20941cada4dSEugeniy Paltsev /* 21041cada4dSEugeniy Paltsev * Upper addresses (ARC_AUX_SLC_RGN_END1 and ARC_AUX_SLC_RGN_START1) 21141cada4dSEugeniy Paltsev * are always == 0 as we don't use PAE40, so we only setup lower ones 21241cada4dSEugeniy Paltsev * (ARC_AUX_SLC_RGN_END and ARC_AUX_SLC_RGN_START) 21341cada4dSEugeniy Paltsev */ 21441cada4dSEugeniy Paltsev write_aux_reg(ARC_AUX_SLC_RGN_END, end); 21541cada4dSEugeniy Paltsev write_aux_reg(ARC_AUX_SLC_RGN_START, paddr); 21641cada4dSEugeniy Paltsev 21741cada4dSEugeniy Paltsev /* Make sure "busy" bit reports correct stataus, see STAR 9001165532 */ 21841cada4dSEugeniy Paltsev read_aux_reg(ARC_AUX_SLC_CTRL); 21941cada4dSEugeniy Paltsev 22041cada4dSEugeniy Paltsev while (read_aux_reg(ARC_AUX_SLC_CTRL) & SLC_CTRL_BUSY); 22141cada4dSEugeniy Paltsev } 222a6f557c4SEugeniy Paltsev 223a6f557c4SEugeniy Paltsev static void arc_ioc_setup(void) 224a6f557c4SEugeniy Paltsev { 225a6f557c4SEugeniy Paltsev /* IOC Aperture start is equal to DDR start */ 226a6f557c4SEugeniy Paltsev unsigned int ap_base = CONFIG_SYS_SDRAM_BASE; 227a6f557c4SEugeniy Paltsev /* IOC Aperture size is equal to DDR size */ 228a6f557c4SEugeniy Paltsev long ap_size = CONFIG_SYS_SDRAM_SIZE; 229a6f557c4SEugeniy Paltsev 230a6f557c4SEugeniy Paltsev flush_n_invalidate_dcache_all(); 231a6f557c4SEugeniy Paltsev 232a6f557c4SEugeniy Paltsev if (!is_power_of_2(ap_size) || ap_size < 4096) 233a6f557c4SEugeniy Paltsev panic("IOC Aperture size must be power of 2 and bigger 4Kib"); 234a6f557c4SEugeniy Paltsev 235a6f557c4SEugeniy Paltsev /* 236a6f557c4SEugeniy Paltsev * IOC Aperture size decoded as 2 ^ (SIZE + 2) KB, 237a6f557c4SEugeniy Paltsev * so setting 0x11 implies 512M, 0x12 implies 1G... 238a6f557c4SEugeniy Paltsev */ 239a6f557c4SEugeniy Paltsev write_aux_reg(ARC_AUX_IO_COH_AP0_SIZE, 240a6f557c4SEugeniy Paltsev order_base_2(ap_size / 1024) - 2); 241a6f557c4SEugeniy Paltsev 242a6f557c4SEugeniy Paltsev /* IOC Aperture start must be aligned to the size of the aperture */ 243a6f557c4SEugeniy Paltsev if (ap_base % ap_size != 0) 244a6f557c4SEugeniy Paltsev panic("IOC Aperture start must be aligned to the size of the aperture"); 245a6f557c4SEugeniy Paltsev 246a6f557c4SEugeniy Paltsev write_aux_reg(ARC_AUX_IO_COH_AP0_BASE, ap_base >> 12); 247a6f557c4SEugeniy Paltsev write_aux_reg(ARC_AUX_IO_COH_PARTIAL, 1); 248a6f557c4SEugeniy Paltsev write_aux_reg(ARC_AUX_IO_COH_ENABLE, 1); 249a6f557c4SEugeniy Paltsev } 25041cada4dSEugeniy Paltsev #endif /* CONFIG_ISA_ARCV2 */ 251ef639e6fSAlexey Brodkin 252379b3280SAlexey Brodkin #ifdef CONFIG_ISA_ARCV2 253379b3280SAlexey Brodkin static void read_decode_cache_bcr_arcv2(void) 254ef639e6fSAlexey Brodkin { 255*88ae27edSEugeniy Paltsev union bcr_slc_cfg slc_cfg; 256*88ae27edSEugeniy Paltsev union bcr_clust_cfg cbcr; 257*88ae27edSEugeniy Paltsev union bcr_generic sbcr; 258379b3280SAlexey Brodkin 259379b3280SAlexey Brodkin sbcr.word = read_aux_reg(ARC_BCR_SLC); 260379b3280SAlexey Brodkin if (sbcr.fields.ver) { 261379b3280SAlexey Brodkin slc_cfg.word = read_aux_reg(ARC_AUX_SLC_CONFIG); 2623cf23939SEugeniy Paltsev slc_exists = true; 263379b3280SAlexey Brodkin slc_line_sz = (slc_cfg.fields.lsz == 0) ? 128 : 64; 264379b3280SAlexey Brodkin } 265db6ce231SAlexey Brodkin 266db6ce231SAlexey Brodkin cbcr.word = read_aux_reg(ARC_BCR_CLUSTER); 267b0146f9eSEugeniy Paltsev if (cbcr.fields.c && ioc_enable) 2683cf23939SEugeniy Paltsev ioc_exists = true; 269379b3280SAlexey Brodkin } 270379b3280SAlexey Brodkin #endif 271379b3280SAlexey Brodkin 272379b3280SAlexey Brodkin void read_decode_cache_bcr(void) 273379b3280SAlexey Brodkin { 274379b3280SAlexey Brodkin int dc_line_sz = 0, ic_line_sz = 0; 275*88ae27edSEugeniy Paltsev union bcr_di_cache ibcr, dbcr; 276379b3280SAlexey Brodkin 277379b3280SAlexey Brodkin ibcr.word = read_aux_reg(ARC_BCR_IC_BUILD); 278379b3280SAlexey Brodkin if (ibcr.fields.ver) { 2793cf23939SEugeniy Paltsev icache_exists = true; 280379b3280SAlexey Brodkin l1_line_sz = ic_line_sz = 8 << ibcr.fields.line_len; 281379b3280SAlexey Brodkin if (!ic_line_sz) 282379b3280SAlexey Brodkin panic("Instruction exists but line length is 0\n"); 283ef639e6fSAlexey Brodkin } 284ef639e6fSAlexey Brodkin 285379b3280SAlexey Brodkin dbcr.word = read_aux_reg(ARC_BCR_DC_BUILD); 286379b3280SAlexey Brodkin if (dbcr.fields.ver) { 2873cf23939SEugeniy Paltsev dcache_exists = true; 288379b3280SAlexey Brodkin l1_line_sz = dc_line_sz = 16 << dbcr.fields.line_len; 289379b3280SAlexey Brodkin if (!dc_line_sz) 290379b3280SAlexey Brodkin panic("Data cache exists but line length is 0\n"); 291379b3280SAlexey Brodkin } 292379b3280SAlexey Brodkin 293379b3280SAlexey Brodkin if (ic_line_sz && dc_line_sz && (ic_line_sz != dc_line_sz)) 294379b3280SAlexey Brodkin panic("Instruction and data cache line lengths differ\n"); 295ef639e6fSAlexey Brodkin } 296ef639e6fSAlexey Brodkin 297ef639e6fSAlexey Brodkin void cache_init(void) 298ef639e6fSAlexey Brodkin { 299379b3280SAlexey Brodkin read_decode_cache_bcr(); 300379b3280SAlexey Brodkin 301ef639e6fSAlexey Brodkin #ifdef CONFIG_ISA_ARCV2 302379b3280SAlexey Brodkin read_decode_cache_bcr_arcv2(); 303db6ce231SAlexey Brodkin 304a6f557c4SEugeniy Paltsev if (ioc_exists) 305a6f557c4SEugeniy Paltsev arc_ioc_setup(); 30641cada4dSEugeniy Paltsev 30741cada4dSEugeniy Paltsev read_decode_mmu_bcr(); 30841cada4dSEugeniy Paltsev 30941cada4dSEugeniy Paltsev /* 31041cada4dSEugeniy Paltsev * ARC_AUX_SLC_RGN_START1 and ARC_AUX_SLC_RGN_END1 register exist 31141cada4dSEugeniy Paltsev * only if PAE exists in current HW. So we had to check pae_exist 31241cada4dSEugeniy Paltsev * before using them. 31341cada4dSEugeniy Paltsev */ 31441cada4dSEugeniy Paltsev if (slc_exists && pae_exists) 31541cada4dSEugeniy Paltsev slc_upper_region_init(); 31641cada4dSEugeniy Paltsev #endif /* CONFIG_ISA_ARCV2 */ 317ef639e6fSAlexey Brodkin } 318ef639e6fSAlexey Brodkin 319660d5f0dSAlexey Brodkin int icache_status(void) 320660d5f0dSAlexey Brodkin { 321379b3280SAlexey Brodkin if (!icache_exists) 322660d5f0dSAlexey Brodkin return 0; 323660d5f0dSAlexey Brodkin 324ef639e6fSAlexey Brodkin if (read_aux_reg(ARC_AUX_IC_CTRL) & IC_CTRL_CACHE_DISABLE) 325ef639e6fSAlexey Brodkin return 0; 326ef639e6fSAlexey Brodkin else 327ef639e6fSAlexey Brodkin return 1; 328660d5f0dSAlexey Brodkin } 329660d5f0dSAlexey Brodkin 330660d5f0dSAlexey Brodkin void icache_enable(void) 331660d5f0dSAlexey Brodkin { 332379b3280SAlexey Brodkin if (icache_exists) 333660d5f0dSAlexey Brodkin write_aux_reg(ARC_AUX_IC_CTRL, read_aux_reg(ARC_AUX_IC_CTRL) & 334660d5f0dSAlexey Brodkin ~IC_CTRL_CACHE_DISABLE); 335660d5f0dSAlexey Brodkin } 336660d5f0dSAlexey Brodkin 337660d5f0dSAlexey Brodkin void icache_disable(void) 338660d5f0dSAlexey Brodkin { 339379b3280SAlexey Brodkin if (icache_exists) 340660d5f0dSAlexey Brodkin write_aux_reg(ARC_AUX_IC_CTRL, read_aux_reg(ARC_AUX_IC_CTRL) | 341660d5f0dSAlexey Brodkin IC_CTRL_CACHE_DISABLE); 342660d5f0dSAlexey Brodkin } 343660d5f0dSAlexey Brodkin 34416aeee81SEugeniy Paltsev /* IC supports only invalidation */ 34516aeee81SEugeniy Paltsev static inline void __ic_entire_invalidate(void) 346660d5f0dSAlexey Brodkin { 34716aeee81SEugeniy Paltsev if (!icache_status()) 34816aeee81SEugeniy Paltsev return; 34916aeee81SEugeniy Paltsev 350660d5f0dSAlexey Brodkin /* Any write to IC_IVIC register triggers invalidation of entire I$ */ 351660d5f0dSAlexey Brodkin write_aux_reg(ARC_AUX_IC_IVIC, 1); 352f2a22678SAlexey Brodkin /* 353f2a22678SAlexey Brodkin * As per ARC HS databook (see chapter 5.3.3.2) 354f2a22678SAlexey Brodkin * it is required to add 3 NOPs after each write to IC_IVIC. 355f2a22678SAlexey Brodkin */ 356f2a22678SAlexey Brodkin __builtin_arc_nop(); 357f2a22678SAlexey Brodkin __builtin_arc_nop(); 358f2a22678SAlexey Brodkin __builtin_arc_nop(); 359ef639e6fSAlexey Brodkin read_aux_reg(ARC_AUX_IC_CTRL); /* blocks */ 360660d5f0dSAlexey Brodkin } 36141cada4dSEugeniy Paltsev 36216aeee81SEugeniy Paltsev void invalidate_icache_all(void) 36316aeee81SEugeniy Paltsev { 36416aeee81SEugeniy Paltsev __ic_entire_invalidate(); 36516aeee81SEugeniy Paltsev 36641cada4dSEugeniy Paltsev #ifdef CONFIG_ISA_ARCV2 36741cada4dSEugeniy Paltsev if (slc_exists) 36841cada4dSEugeniy Paltsev __slc_entire_op(OP_INV); 369ef639e6fSAlexey Brodkin #endif 37041cada4dSEugeniy Paltsev } 371660d5f0dSAlexey Brodkin 372660d5f0dSAlexey Brodkin int dcache_status(void) 373660d5f0dSAlexey Brodkin { 374379b3280SAlexey Brodkin if (!dcache_exists) 375660d5f0dSAlexey Brodkin return 0; 376660d5f0dSAlexey Brodkin 377ef639e6fSAlexey Brodkin if (read_aux_reg(ARC_AUX_DC_CTRL) & DC_CTRL_CACHE_DISABLE) 378ef639e6fSAlexey Brodkin return 0; 379ef639e6fSAlexey Brodkin else 380ef639e6fSAlexey Brodkin return 1; 381660d5f0dSAlexey Brodkin } 382660d5f0dSAlexey Brodkin 383660d5f0dSAlexey Brodkin void dcache_enable(void) 384660d5f0dSAlexey Brodkin { 385379b3280SAlexey Brodkin if (!dcache_exists) 386660d5f0dSAlexey Brodkin return; 387660d5f0dSAlexey Brodkin 388660d5f0dSAlexey Brodkin write_aux_reg(ARC_AUX_DC_CTRL, read_aux_reg(ARC_AUX_DC_CTRL) & 389660d5f0dSAlexey Brodkin ~(DC_CTRL_INV_MODE_FLUSH | DC_CTRL_CACHE_DISABLE)); 390660d5f0dSAlexey Brodkin } 391660d5f0dSAlexey Brodkin 392660d5f0dSAlexey Brodkin void dcache_disable(void) 393660d5f0dSAlexey Brodkin { 394379b3280SAlexey Brodkin if (!dcache_exists) 395660d5f0dSAlexey Brodkin return; 396660d5f0dSAlexey Brodkin 397660d5f0dSAlexey Brodkin write_aux_reg(ARC_AUX_DC_CTRL, read_aux_reg(ARC_AUX_DC_CTRL) | 398660d5f0dSAlexey Brodkin DC_CTRL_CACHE_DISABLE); 399660d5f0dSAlexey Brodkin } 400660d5f0dSAlexey Brodkin 401660d5f0dSAlexey Brodkin #ifndef CONFIG_SYS_DCACHE_OFF 402c4ef14d2SEugeniy Paltsev /* Common Helper for Line Operations on D-cache */ 403c4ef14d2SEugeniy Paltsev static inline void __dcache_line_loop(unsigned long paddr, unsigned long sz, 404ef639e6fSAlexey Brodkin const int cacheop) 405660d5f0dSAlexey Brodkin { 406ef639e6fSAlexey Brodkin unsigned int aux_cmd; 407ef639e6fSAlexey Brodkin int num_lines; 408660d5f0dSAlexey Brodkin 409ef639e6fSAlexey Brodkin /* d$ cmd: INV (discard or wback-n-discard) OR FLUSH (wback) */ 410ef639e6fSAlexey Brodkin aux_cmd = cacheop & OP_INV ? ARC_AUX_DC_IVDL : ARC_AUX_DC_FLDL; 411660d5f0dSAlexey Brodkin 412ef639e6fSAlexey Brodkin sz += paddr & ~CACHE_LINE_MASK; 413ef639e6fSAlexey Brodkin paddr &= CACHE_LINE_MASK; 414ef639e6fSAlexey Brodkin 415379b3280SAlexey Brodkin num_lines = DIV_ROUND_UP(sz, l1_line_sz); 416ef639e6fSAlexey Brodkin 417ef639e6fSAlexey Brodkin while (num_lines-- > 0) { 418ef639e6fSAlexey Brodkin #if (CONFIG_ARC_MMU_VER == 3) 419c4ef14d2SEugeniy Paltsev write_aux_reg(ARC_AUX_DC_PTAG, paddr); 420ef639e6fSAlexey Brodkin #endif 421ef639e6fSAlexey Brodkin write_aux_reg(aux_cmd, paddr); 422379b3280SAlexey Brodkin paddr += l1_line_sz; 423ef639e6fSAlexey Brodkin } 424ef639e6fSAlexey Brodkin } 425ef639e6fSAlexey Brodkin 4265d7a24d6SEugeniy Paltsev static void __before_dc_op(const int op) 427ef639e6fSAlexey Brodkin { 4285d7a24d6SEugeniy Paltsev unsigned int ctrl; 429ef639e6fSAlexey Brodkin 4305d7a24d6SEugeniy Paltsev ctrl = read_aux_reg(ARC_AUX_DC_CTRL); 4315d7a24d6SEugeniy Paltsev 4325d7a24d6SEugeniy Paltsev /* IM bit implies flush-n-inv, instead of vanilla inv */ 4335d7a24d6SEugeniy Paltsev if (op == OP_INV) 4345d7a24d6SEugeniy Paltsev ctrl &= ~DC_CTRL_INV_MODE_FLUSH; 4355d7a24d6SEugeniy Paltsev else 4365d7a24d6SEugeniy Paltsev ctrl |= DC_CTRL_INV_MODE_FLUSH; 4375d7a24d6SEugeniy Paltsev 4385d7a24d6SEugeniy Paltsev write_aux_reg(ARC_AUX_DC_CTRL, ctrl); 439ef639e6fSAlexey Brodkin } 440ef639e6fSAlexey Brodkin 4415d7a24d6SEugeniy Paltsev static void __after_dc_op(const int op) 442ef639e6fSAlexey Brodkin { 443ef639e6fSAlexey Brodkin if (op & OP_FLUSH) /* flush / flush-n-inv both wait */ 44419b10a42SEugeniy Paltsev while (read_aux_reg(ARC_AUX_DC_CTRL) & DC_CTRL_FLUSH_STATUS); 445ef639e6fSAlexey Brodkin } 446ef639e6fSAlexey Brodkin 447ef639e6fSAlexey Brodkin static inline void __dc_entire_op(const int cacheop) 448ef639e6fSAlexey Brodkin { 449ef639e6fSAlexey Brodkin int aux; 4505d7a24d6SEugeniy Paltsev 4515d7a24d6SEugeniy Paltsev __before_dc_op(cacheop); 452ef639e6fSAlexey Brodkin 453ef639e6fSAlexey Brodkin if (cacheop & OP_INV) /* Inv or flush-n-inv use same cmd reg */ 454ef639e6fSAlexey Brodkin aux = ARC_AUX_DC_IVDC; 455ef639e6fSAlexey Brodkin else 456ef639e6fSAlexey Brodkin aux = ARC_AUX_DC_FLSH; 457ef639e6fSAlexey Brodkin 458ef639e6fSAlexey Brodkin write_aux_reg(aux, 0x1); 459ef639e6fSAlexey Brodkin 4605d7a24d6SEugeniy Paltsev __after_dc_op(cacheop); 461ef639e6fSAlexey Brodkin } 462ef639e6fSAlexey Brodkin 463ef639e6fSAlexey Brodkin static inline void __dc_line_op(unsigned long paddr, unsigned long sz, 464ef639e6fSAlexey Brodkin const int cacheop) 465ef639e6fSAlexey Brodkin { 4665d7a24d6SEugeniy Paltsev __before_dc_op(cacheop); 467c4ef14d2SEugeniy Paltsev __dcache_line_loop(paddr, sz, cacheop); 4685d7a24d6SEugeniy Paltsev __after_dc_op(cacheop); 469ef639e6fSAlexey Brodkin } 470ef639e6fSAlexey Brodkin #else 471ef639e6fSAlexey Brodkin #define __dc_entire_op(cacheop) 472ef639e6fSAlexey Brodkin #define __dc_line_op(paddr, sz, cacheop) 473ef639e6fSAlexey Brodkin #endif /* !CONFIG_SYS_DCACHE_OFF */ 474ef639e6fSAlexey Brodkin 475660d5f0dSAlexey Brodkin void invalidate_dcache_range(unsigned long start, unsigned long end) 476660d5f0dSAlexey Brodkin { 47741cada4dSEugeniy Paltsev if (start >= end) 47841cada4dSEugeniy Paltsev return; 47941cada4dSEugeniy Paltsev 480ef639e6fSAlexey Brodkin #ifdef CONFIG_ISA_ARCV2 481db6ce231SAlexey Brodkin if (!ioc_exists) 482db6ce231SAlexey Brodkin #endif 483db6ce231SAlexey Brodkin __dc_line_op(start, end - start, OP_INV); 484db6ce231SAlexey Brodkin 485db6ce231SAlexey Brodkin #ifdef CONFIG_ISA_ARCV2 486db6ce231SAlexey Brodkin if (slc_exists && !ioc_exists) 48741cada4dSEugeniy Paltsev __slc_rgn_op(start, end - start, OP_INV); 488660d5f0dSAlexey Brodkin #endif 489660d5f0dSAlexey Brodkin } 490660d5f0dSAlexey Brodkin 491ef639e6fSAlexey Brodkin void flush_dcache_range(unsigned long start, unsigned long end) 492660d5f0dSAlexey Brodkin { 49341cada4dSEugeniy Paltsev if (start >= end) 49441cada4dSEugeniy Paltsev return; 49541cada4dSEugeniy Paltsev 496ef639e6fSAlexey Brodkin #ifdef CONFIG_ISA_ARCV2 497db6ce231SAlexey Brodkin if (!ioc_exists) 498db6ce231SAlexey Brodkin #endif 499db6ce231SAlexey Brodkin __dc_line_op(start, end - start, OP_FLUSH); 500db6ce231SAlexey Brodkin 501db6ce231SAlexey Brodkin #ifdef CONFIG_ISA_ARCV2 502db6ce231SAlexey Brodkin if (slc_exists && !ioc_exists) 50341cada4dSEugeniy Paltsev __slc_rgn_op(start, end - start, OP_FLUSH); 504ef639e6fSAlexey Brodkin #endif 505660d5f0dSAlexey Brodkin } 506660d5f0dSAlexey Brodkin 507660d5f0dSAlexey Brodkin void flush_cache(unsigned long start, unsigned long size) 508660d5f0dSAlexey Brodkin { 509660d5f0dSAlexey Brodkin flush_dcache_range(start, start + size); 510660d5f0dSAlexey Brodkin } 5116eb15e50SAlexey Brodkin 512c27814beSEugeniy Paltsev /* 513c27814beSEugeniy Paltsev * As invalidate_dcache_all() is not used in generic U-Boot code and as we 514c27814beSEugeniy Paltsev * don't need it in arch/arc code alone (invalidate without flush) we implement 515c27814beSEugeniy Paltsev * flush_n_invalidate_dcache_all (flush and invalidate in 1 operation) because 516c27814beSEugeniy Paltsev * it's much safer. See [ NOTE 1 ] for more details. 517c27814beSEugeniy Paltsev */ 518c27814beSEugeniy Paltsev void flush_n_invalidate_dcache_all(void) 519ef639e6fSAlexey Brodkin { 520c27814beSEugeniy Paltsev __dc_entire_op(OP_FLUSH_N_INV); 521db6ce231SAlexey Brodkin 522db6ce231SAlexey Brodkin #ifdef CONFIG_ISA_ARCV2 523bd91508bSAlexey Brodkin if (slc_exists) 524c27814beSEugeniy Paltsev __slc_entire_op(OP_FLUSH_N_INV); 525ef639e6fSAlexey Brodkin #endif 5266eb15e50SAlexey Brodkin } 5276eb15e50SAlexey Brodkin 528ef639e6fSAlexey Brodkin void flush_dcache_all(void) 5296eb15e50SAlexey Brodkin { 530db6ce231SAlexey Brodkin __dc_entire_op(OP_FLUSH); 531db6ce231SAlexey Brodkin 532db6ce231SAlexey Brodkin #ifdef CONFIG_ISA_ARCV2 5332a8382c6SAlexey Brodkin if (slc_exists) 534ef639e6fSAlexey Brodkin __slc_entire_op(OP_FLUSH); 535ef639e6fSAlexey Brodkin #endif 5366eb15e50SAlexey Brodkin } 537