void plog_cache_writeback(unsigned long start, long size) { long linesz, linemsk; unsigned long end; #if defined(CONFIG_BMIPS5000) linesz = cpu_scache_line_size(); #else linesz = cpu_dcache_line_size(); #endif /* * Set up the loop counters so the address is cache line aligned (do * we really need to do that?) and the length is a multiple of the * cache line size. */ linemsk = linesz - 1; start &= ~linemsk; size += linesz; end = start + size; while (start < end) { #if defined(CONFIG_BMIPS5000) cache_op(HitWbSc, start); #else cache_op(Hit_Writeback_D, start); #endif start += linesz; } __sync(); }
static int __init pcibios_set_cache_line_size(void) { unsigned int lsize; /* * Set PCI cacheline size to that of the highest level in the * cache hierarchy. */ lsize = cpu_dcache_line_size(); lsize = cpu_scache_line_size() ? : lsize; lsize = cpu_tcache_line_size() ? : lsize; BUG_ON(!lsize); pci_dfl_cache_line_size = lsize >> 2; pr_debug("PCI: pci_cache_line_size set to %d bytes\n", lsize); return 0; }
static void set_prefetch_parameters(void) { if (cpu_has_64bit_gp_regs || cpu_has_64bit_zero_reg) clear_word_size = 8; else clear_word_size = 4; if (cpu_has_64bit_gp_regs) copy_word_size = 8; else copy_word_size = 4; /* * The pref's used here are using "streaming" hints, which cause the * copied data to be kicked out of the cache sooner. A page copy often * ends up copying a lot more data than is commonly used, so this seems * to make sense in terms of reducing cache pollution, but I've no real * performance data to back this up. */ if (cpu_has_prefetch) { /* * XXX: Most prefetch bias values in here are based on * guesswork. */ cache_line_size = cpu_dcache_line_size(); switch (current_cpu_type()) { case CPU_R5500: case CPU_TX49XX: /* These processors only support the Pref_Load. */ pref_bias_copy_load = 256; break; case CPU_RM9000: /* * As a workaround for erratum G105 which make the * PrepareForStore hint unusable we fall back to * StoreRetained on the RM9000. Once it is known which * versions of the RM9000 we'll be able to condition- * alize this. */ case CPU_R10000: case CPU_R12000: case CPU_R14000: /* * Those values have been experimentally tuned for an * Origin 200. */ pref_bias_clear_store = 512; pref_bias_copy_load = 256; pref_bias_copy_store = 256; pref_src_mode = Pref_LoadStreamed; pref_dst_mode = Pref_StoreStreamed; break; case CPU_SB1: case CPU_SB1A: pref_bias_clear_store = 128; pref_bias_copy_load = 128; pref_bias_copy_store = 128; /* * SB1 pass1 Pref_LoadStreamed/Pref_StoreStreamed * hints are broken. */ if (current_cpu_type() == CPU_SB1 && (current_cpu_data.processor_id & 0xff) < 0x02) { pref_src_mode = Pref_Load; pref_dst_mode = Pref_Store; } else { pref_src_mode = Pref_LoadStreamed; pref_dst_mode = Pref_StoreStreamed; } break; default: pref_bias_clear_store = 128; pref_bias_copy_load = 256; pref_bias_copy_store = 128; pref_src_mode = Pref_LoadStreamed; pref_dst_mode = Pref_PrepareForStore; break; } } else { if (cpu_has_cache_cdex_s) cache_line_size = cpu_scache_line_size(); else if (cpu_has_cache_cdex_p) cache_line_size = cpu_dcache_line_size(); } /* * Too much unrolling will overflow the available space in * clear_space_array / copy_page_array. */ half_clear_loop_size = min(16 * clear_word_size, max(cache_line_size >> 1, 4 * clear_word_size)); half_copy_loop_size = min(16 * copy_word_size, max(cache_line_size >> 1, 4 * copy_word_size)); }