709 lines
20 KiB
C
709 lines
20 KiB
C
#ifndef XTENSA_CACHEASM_H
|
|
#define XTENSA_CACHEASM_H
|
|
|
|
/*
|
|
* THIS FILE IS GENERATED -- DO NOT MODIFY BY HAND
|
|
*
|
|
* include/asm-xtensa/xtensa/cacheasm.h -- assembler-specific cache
|
|
* related definitions that depend on CORE configuration.
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
* for more details.
|
|
*
|
|
* Copyright (C) 2002 Tensilica Inc.
|
|
*/
|
|
|
|
|
|
#include <xtensa/coreasm.h>
|
|
|
|
|
|
/*
|
|
* This header file defines assembler macros of the form:
|
|
* <x>cache_<func>
|
|
* where <x> is 'i' or 'd' for instruction and data caches,
|
|
* and <func> indicates the function of the macro.
|
|
*
|
|
* The following functions <func> are defined,
|
|
* and apply only to the specified cache (I or D):
|
|
*
|
|
* reset
|
|
* Resets the cache.
|
|
*
|
|
* sync
|
|
* Makes sure any previous cache instructions have been completed;
|
|
* ie. makes sure any previous cache control operations
|
|
* have had full effect and been synchronized to memory.
|
|
* Eg. any invalidate completed [so as not to generate a hit],
|
|
* any writebacks or other pipelined writes written to memory, etc.
|
|
*
|
|
* invalidate_line (single cache line)
|
|
* invalidate_region (specified memory range)
|
|
* invalidate_all (entire cache)
|
|
* Invalidates all cache entries that cache
|
|
* data from the specified memory range.
|
|
* NOTE: locked entries are not invalidated.
|
|
*
|
|
* writeback_line (single cache line)
|
|
* writeback_region (specified memory range)
|
|
* writeback_all (entire cache)
|
|
* Writes back to memory all dirty cache entries
|
|
* that cache data from the specified memory range,
|
|
* and marks these entries as clean.
|
|
* NOTE: on some future implementations, this might
|
|
* also invalidate.
|
|
* NOTE: locked entries are written back, but never invalidated.
|
|
* NOTE: instruction caches never implement writeback.
|
|
*
|
|
* writeback_inv_line (single cache line)
|
|
* writeback_inv_region (specified memory range)
|
|
* writeback_inv_all (entire cache)
|
|
* Writes back to memory all dirty cache entries
|
|
* that cache data from the specified memory range,
|
|
* and invalidates these entries (including all clean
|
|
* cache entries that cache data from that range).
|
|
* NOTE: locked entries are written back but not invalidated.
|
|
* NOTE: instruction caches never implement writeback.
|
|
*
|
|
* lock_line (single cache line)
|
|
* lock_region (specified memory range)
|
|
* Prefetch and lock the specified memory range into cache.
|
|
* NOTE: if any part of the specified memory range cannot
|
|
* be locked, a ??? exception occurs. These macros don't
|
|
* do anything special (yet anyway) to handle this situation.
|
|
*
|
|
* unlock_line (single cache line)
|
|
* unlock_region (specified memory range)
|
|
* unlock_all (entire cache)
|
|
* Unlock cache entries that cache the specified memory range.
|
|
* Entries not already locked are unaffected.
|
|
*/
|
|
|
|
|
|
|
|
/*************************** GENERIC -- ALL CACHES ***************************/
|
|
|
|
|
|
/*
|
|
* The following macros assume the following cache size/parameter limits
|
|
* in the current Xtensa core implementation:
|
|
* cache size: 1024 bytes minimum
|
|
* line size: 16 - 64 bytes
|
|
* way count: 1 - 4
|
|
*
|
|
* Minimum entries per way (ie. per associativity) = 1024 / 64 / 4 = 4
|
|
* Hence the assumption that each loop can execute four cache instructions.
|
|
*
|
|
* Correspondingly, the offset range of instructions is assumed able to cover
|
|
* four lines, ie. offsets {0,1,2,3} * line_size are assumed valid for
|
|
* both hit and indexed cache instructions. Ie. these offsets are all
|
|
* valid: 0, 16, 32, 48, 64, 96, 128, 192 (for line sizes 16, 32, 64).
|
|
* This is true of all original cache instructions
|
|
* (dhi, ihi, dhwb, dhwbi, dii, iii) which have offsets
|
|
* of 0 to 1020 in multiples of 4 (ie. 8 bits shifted by 2).
|
|
* This is also true of subsequent cache instructions
|
|
* (dhu, ihu, diu, iiu, diwb, diwbi, dpfl, ipfl) which have offsets
|
|
* of 0 to 240 in multiples of 16 (ie. 4 bits shifted by 4).
|
|
*
|
|
* (Maximum cache size, currently 32k, doesn't affect the following macros.
|
|
* Cache ways > MMU min page size cause aliasing but that's another matter.)
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
* Macro to apply an 'indexed' cache instruction to the entire cache.
|
|
*
|
|
* Parameters:
|
|
* cainst instruction/ that takes an address register parameter
|
|
* and an offset parameter (in range 0 .. 3*linesize).
|
|
* size size of cache in bytes
|
|
* linesize size of cache line in bytes
|
|
* assoc_or1 number of associativities (ways/sets) in cache
|
|
* if all sets affected by cainst,
|
|
* or 1 if only one set (or not all sets) of the cache
|
|
* is affected by cainst (eg. DIWB or DIWBI [not yet ISA defined]).
|
|
* aa, ab unique address registers (temporaries)
|
|
*/
|
|
|
|
.macro cache_index_all cainst, size, linesize, assoc_or1, aa, ab
|
|
|
|
// Sanity-check on cache parameters:
|
|
.ifne (\size % (\linesize * \assoc_or1 * 4))
|
|
.err // cache configuration outside expected/supported range!
|
|
.endif
|
|
|
|
// \size byte cache, \linesize byte lines, \assoc_or1 way(s) affected by each \cainst.
|
|
movi \aa, (\size / (\linesize * \assoc_or1 * 4))
|
|
// Possible improvement: need only loop if \aa > 1 ;
|
|
// however that particular condition is highly unlikely.
|
|
movi \ab, 0 // to iterate over cache
|
|
floop \aa, cachex\@
|
|
\cainst \ab, 0*\linesize
|
|
\cainst \ab, 1*\linesize
|
|
\cainst \ab, 2*\linesize
|
|
\cainst \ab, 3*\linesize
|
|
addi \ab, \ab, 4*\linesize // move to next line
|
|
floopend \aa, cachex\@
|
|
|
|
.endm
|
|
|
|
|
|
/*
|
|
* Macro to apply a 'hit' cache instruction to a memory region,
|
|
* ie. to any cache entries that cache a specified portion (region) of memory.
|
|
* Takes care of the unaligned cases, ie. may apply to one
|
|
* more cache line than $asize / lineSize if $aaddr is not aligned.
|
|
*
|
|
*
|
|
* Parameters are:
|
|
* cainst instruction/macro that takes an address register parameter
|
|
* and an offset parameter (currently always zero)
|
|
* and generates a cache instruction (eg. "dhi", "dhwb", "ihi", etc.)
|
|
* linesize_log2 log2(size of cache line in bytes)
|
|
* addr register containing start address of region (clobbered)
|
|
* asize register containing size of the region in bytes (clobbered)
|
|
* askew unique register used as temporary
|
|
*
|
|
* !?!?! 2DO: optimization: iterate max(cache_size and \asize) / linesize
|
|
*/
|
|
|
|
.macro cache_hit_region cainst, linesize_log2, addr, asize, askew
|
|
|
|
// Make \asize the number of iterations:
|
|
extui \askew, \addr, 0, \linesize_log2 // get unalignment amount of \addr
|
|
add \asize, \asize, \askew // ... and add it to \asize
|
|
addi \asize, \asize, (1 << \linesize_log2) - 1 // round up!
|
|
srli \asize, \asize, \linesize_log2
|
|
|
|
// Iterate over region:
|
|
floopnez \asize, cacheh\@
|
|
\cainst \addr, 0
|
|
addi \addr, \addr, (1 << \linesize_log2) // move to next line
|
|
floopend \asize, cacheh\@
|
|
|
|
.endm
|
|
|
|
|
|
|
|
|
|
|
|
/*************************** INSTRUCTION CACHE ***************************/
|
|
|
|
|
|
/*
|
|
* Reset/initialize the instruction cache by simply invalidating it:
|
|
* (need to unlock first also, if cache locking implemented):
|
|
*
|
|
* Parameters:
|
|
* aa, ab unique address registers (temporaries)
|
|
*/
|
|
.macro icache_reset aa, ab
|
|
icache_unlock_all \aa, \ab
|
|
icache_invalidate_all \aa, \ab
|
|
.endm
|
|
|
|
|
|
/*
|
|
* Synchronize after an instruction cache operation,
|
|
* to be sure everything is in sync with memory as to be
|
|
* expected following any previous instruction cache control operations.
|
|
*
|
|
* Parameters are:
|
|
* ar an address register (temporary) (currently unused, but may be used in future)
|
|
*/
|
|
.macro icache_sync ar
|
|
#if XCHAL_ICACHE_SIZE > 0
|
|
isync
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Invalidate a single line of the instruction cache.
|
|
* Parameters are:
|
|
* ar address register that contains (virtual) address to invalidate
|
|
* (may get clobbered in a future implementation, but not currently)
|
|
* offset (optional) offset to add to \ar to compute effective address to invalidate
|
|
* (note: some number of lsbits are ignored)
|
|
*/
|
|
.macro icache_invalidate_line ar, offset
|
|
#if XCHAL_ICACHE_SIZE > 0
|
|
ihi \ar, \offset // invalidate icache line
|
|
/*
|
|
* NOTE: in some version of the silicon [!!!SHOULD HAVE BEEN DOCUMENTED!!!]
|
|
* 'ihi' doesn't work, so it had been replaced with 'iii'
|
|
* (which would just invalidate more than it should,
|
|
* which should be okay other than the performance hit
|
|
* because cache locking did not exist in that version,
|
|
* unless user somehow relies on something being cached).
|
|
* [WHAT VERSION IS IT!!?!?
|
|
* IS THERE ANY WAY TO TEST FOR THAT HERE, TO OUTPUT 'III' ONLY IF NEEDED!?!?].
|
|
*
|
|
* iii \ar, \offset
|
|
*/
|
|
icache_sync \ar
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Invalidate instruction cache entries that cache a specified portion of memory.
|
|
* Parameters are:
|
|
* astart start address (register gets clobbered)
|
|
* asize size of the region in bytes (register gets clobbered)
|
|
* ac unique register used as temporary
|
|
*/
|
|
.macro icache_invalidate_region astart, asize, ac
|
|
#if XCHAL_ICACHE_SIZE > 0
|
|
// Instruction cache region invalidation:
|
|
cache_hit_region ihi, XCHAL_ICACHE_LINEWIDTH, \astart, \asize, \ac
|
|
icache_sync \ac
|
|
// End of instruction cache region invalidation
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Invalidate entire instruction cache.
|
|
*
|
|
* Parameters:
|
|
* aa, ab unique address registers (temporaries)
|
|
*/
|
|
.macro icache_invalidate_all aa, ab
|
|
#if XCHAL_ICACHE_SIZE > 0
|
|
// Instruction cache invalidation:
|
|
cache_index_all iii, XCHAL_ICACHE_SIZE, XCHAL_ICACHE_LINESIZE, XCHAL_ICACHE_WAYS, \aa, \ab
|
|
icache_sync \aa
|
|
// End of instruction cache invalidation
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Lock (prefetch & lock) a single line of the instruction cache.
|
|
*
|
|
* Parameters are:
|
|
* ar address register that contains (virtual) address to lock
|
|
* (may get clobbered in a future implementation, but not currently)
|
|
* offset offset to add to \ar to compute effective address to lock
|
|
* (note: some number of lsbits are ignored)
|
|
*/
|
|
.macro icache_lock_line ar, offset
|
|
#if XCHAL_ICACHE_SIZE > 0 && XCHAL_ICACHE_LINE_LOCKABLE
|
|
ipfl \ar, \offset /* prefetch and lock icache line */
|
|
icache_sync \ar
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Lock (prefetch & lock) a specified portion of memory into the instruction cache.
|
|
* Parameters are:
|
|
* astart start address (register gets clobbered)
|
|
* asize size of the region in bytes (register gets clobbered)
|
|
* ac unique register used as temporary
|
|
*/
|
|
.macro icache_lock_region astart, asize, ac
|
|
#if XCHAL_ICACHE_SIZE > 0 && XCHAL_ICACHE_LINE_LOCKABLE
|
|
// Instruction cache region lock:
|
|
cache_hit_region ipfl, XCHAL_ICACHE_LINEWIDTH, \astart, \asize, \ac
|
|
icache_sync \ac
|
|
// End of instruction cache region lock
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Unlock a single line of the instruction cache.
|
|
*
|
|
* Parameters are:
|
|
* ar address register that contains (virtual) address to unlock
|
|
* (may get clobbered in a future implementation, but not currently)
|
|
* offset offset to add to \ar to compute effective address to unlock
|
|
* (note: some number of lsbits are ignored)
|
|
*/
|
|
.macro icache_unlock_line ar, offset
|
|
#if XCHAL_ICACHE_SIZE > 0 && XCHAL_ICACHE_LINE_LOCKABLE
|
|
ihu \ar, \offset /* unlock icache line */
|
|
icache_sync \ar
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Unlock a specified portion of memory from the instruction cache.
|
|
* Parameters are:
|
|
* astart start address (register gets clobbered)
|
|
* asize size of the region in bytes (register gets clobbered)
|
|
* ac unique register used as temporary
|
|
*/
|
|
.macro icache_unlock_region astart, asize, ac
|
|
#if XCHAL_ICACHE_SIZE > 0 && XCHAL_ICACHE_LINE_LOCKABLE
|
|
// Instruction cache region unlock:
|
|
cache_hit_region ihu, XCHAL_ICACHE_LINEWIDTH, \astart, \asize, \ac
|
|
icache_sync \ac
|
|
// End of instruction cache region unlock
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Unlock entire instruction cache.
|
|
*
|
|
* Parameters:
|
|
* aa, ab unique address registers (temporaries)
|
|
*/
|
|
.macro icache_unlock_all aa, ab
|
|
#if XCHAL_ICACHE_SIZE > 0 && XCHAL_ICACHE_LINE_LOCKABLE
|
|
// Instruction cache unlock:
|
|
cache_index_all iiu, XCHAL_ICACHE_SIZE, XCHAL_ICACHE_LINESIZE, 1, \aa, \ab
|
|
icache_sync \aa
|
|
// End of instruction cache unlock
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
|
|
|
|
/*************************** DATA CACHE ***************************/
|
|
|
|
|
|
|
|
/*
|
|
* Reset/initialize the data cache by simply invalidating it
|
|
* (need to unlock first also, if cache locking implemented):
|
|
*
|
|
* Parameters:
|
|
* aa, ab unique address registers (temporaries)
|
|
*/
|
|
.macro dcache_reset aa, ab
|
|
dcache_unlock_all \aa, \ab
|
|
dcache_invalidate_all \aa, \ab
|
|
.endm
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Synchronize after a data cache operation,
|
|
* to be sure everything is in sync with memory as to be
|
|
* expected following any previous data cache control operations.
|
|
*
|
|
* Parameters are:
|
|
* ar an address register (temporary) (currently unused, but may be used in future)
|
|
*/
|
|
.macro dcache_sync ar
|
|
#if XCHAL_DCACHE_SIZE > 0
|
|
// This previous sequence errs on the conservative side (too much so); a DSYNC should be sufficient:
|
|
//memw // synchronize data cache changes relative to subsequent memory accesses
|
|
//isync // be conservative and ISYNC as well (just to be sure)
|
|
|
|
dsync
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Synchronize after a data store operation,
|
|
* to be sure the stored data is completely off the processor
|
|
* (and assuming there is no buffering outside the processor,
|
|
* that the data is in memory). This may be required to
|
|
* ensure that the processor's write buffers are emptied.
|
|
* A MEMW followed by a read guarantees this, by definition.
|
|
* We also try to make sure the read itself completes.
|
|
*
|
|
* Parameters are:
|
|
* ar an address register (temporary)
|
|
*/
|
|
.macro write_sync ar
|
|
memw // ensure previous memory accesses are complete prior to subsequent memory accesses
|
|
l32i \ar, sp, 0 // completing this read ensures any previous write has completed, because of MEMW
|
|
//slot
|
|
add \ar, \ar, \ar // use the result of the read to help ensure the read completes (in future architectures)
|
|
.endm
|
|
|
|
|
|
/*
|
|
* Invalidate a single line of the data cache.
|
|
* Parameters are:
|
|
* ar address register that contains (virtual) address to invalidate
|
|
* (may get clobbered in a future implementation, but not currently)
|
|
* offset (optional) offset to add to \ar to compute effective address to invalidate
|
|
* (note: some number of lsbits are ignored)
|
|
*/
|
|
.macro dcache_invalidate_line ar, offset
|
|
#if XCHAL_DCACHE_SIZE > 0
|
|
dhi \ar, \offset
|
|
dcache_sync \ar
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Invalidate data cache entries that cache a specified portion of memory.
|
|
* Parameters are:
|
|
* astart start address (register gets clobbered)
|
|
* asize size of the region in bytes (register gets clobbered)
|
|
* ac unique register used as temporary
|
|
*/
|
|
.macro dcache_invalidate_region astart, asize, ac
|
|
#if XCHAL_DCACHE_SIZE > 0
|
|
// Data cache region invalidation:
|
|
cache_hit_region dhi, XCHAL_DCACHE_LINEWIDTH, \astart, \asize, \ac
|
|
dcache_sync \ac
|
|
// End of data cache region invalidation
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
#if 0
|
|
/*
|
|
* This is a work-around for a bug in SiChip1 (???).
|
|
* There should be a proper mechanism for not outputting
|
|
* these instructions when not needed.
|
|
* To enable work-around, uncomment this and replace 'dii'
|
|
* with 'dii_s1' everywhere, eg. in dcache_invalidate_all
|
|
* macro below.
|
|
*/
|
|
.macro dii_s1 ar, offset
|
|
dii \ar, \offset
|
|
or \ar, \ar, \ar
|
|
or \ar, \ar, \ar
|
|
or \ar, \ar, \ar
|
|
or \ar, \ar, \ar
|
|
.endm
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Invalidate entire data cache.
|
|
*
|
|
* Parameters:
|
|
* aa, ab unique address registers (temporaries)
|
|
*/
|
|
.macro dcache_invalidate_all aa, ab
|
|
#if XCHAL_DCACHE_SIZE > 0
|
|
// Data cache invalidation:
|
|
cache_index_all dii, XCHAL_DCACHE_SIZE, XCHAL_DCACHE_LINESIZE, XCHAL_DCACHE_WAYS, \aa, \ab
|
|
dcache_sync \aa
|
|
// End of data cache invalidation
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Writeback a single line of the data cache.
|
|
* Parameters are:
|
|
* ar address register that contains (virtual) address to writeback
|
|
* (may get clobbered in a future implementation, but not currently)
|
|
* offset offset to add to \ar to compute effective address to writeback
|
|
* (note: some number of lsbits are ignored)
|
|
*/
|
|
.macro dcache_writeback_line ar, offset
|
|
#if XCHAL_DCACHE_SIZE > 0 && XCHAL_DCACHE_IS_WRITEBACK
|
|
dhwb \ar, \offset
|
|
dcache_sync \ar
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Writeback dirty data cache entries that cache a specified portion of memory.
|
|
* Parameters are:
|
|
* astart start address (register gets clobbered)
|
|
* asize size of the region in bytes (register gets clobbered)
|
|
* ac unique register used as temporary
|
|
*/
|
|
.macro dcache_writeback_region astart, asize, ac
|
|
#if XCHAL_DCACHE_SIZE > 0 && XCHAL_DCACHE_IS_WRITEBACK
|
|
// Data cache region writeback:
|
|
cache_hit_region dhwb, XCHAL_DCACHE_LINEWIDTH, \astart, \asize, \ac
|
|
dcache_sync \ac
|
|
// End of data cache region writeback
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Writeback entire data cache.
|
|
* Parameters:
|
|
* aa, ab unique address registers (temporaries)
|
|
*/
|
|
.macro dcache_writeback_all aa, ab
|
|
#if XCHAL_DCACHE_SIZE > 0 && XCHAL_DCACHE_IS_WRITEBACK
|
|
// Data cache writeback:
|
|
cache_index_all diwb, XCHAL_DCACHE_SIZE, XCHAL_DCACHE_LINESIZE, 1, \aa, \ab
|
|
dcache_sync \aa
|
|
// End of data cache writeback
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Writeback and invalidate a single line of the data cache.
|
|
* Parameters are:
|
|
* ar address register that contains (virtual) address to writeback and invalidate
|
|
* (may get clobbered in a future implementation, but not currently)
|
|
* offset offset to add to \ar to compute effective address to writeback and invalidate
|
|
* (note: some number of lsbits are ignored)
|
|
*/
|
|
.macro dcache_writeback_inv_line ar, offset
|
|
#if XCHAL_DCACHE_SIZE > 0
|
|
dhwbi \ar, \offset /* writeback and invalidate dcache line */
|
|
dcache_sync \ar
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Writeback and invalidate data cache entries that cache a specified portion of memory.
|
|
* Parameters are:
|
|
* astart start address (register gets clobbered)
|
|
* asize size of the region in bytes (register gets clobbered)
|
|
* ac unique register used as temporary
|
|
*/
|
|
.macro dcache_writeback_inv_region astart, asize, ac
|
|
#if XCHAL_DCACHE_SIZE > 0
|
|
// Data cache region writeback and invalidate:
|
|
cache_hit_region dhwbi, XCHAL_DCACHE_LINEWIDTH, \astart, \asize, \ac
|
|
dcache_sync \ac
|
|
// End of data cache region writeback and invalidate
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Writeback and invalidate entire data cache.
|
|
* Parameters:
|
|
* aa, ab unique address registers (temporaries)
|
|
*/
|
|
.macro dcache_writeback_inv_all aa, ab
|
|
#if XCHAL_DCACHE_SIZE > 0
|
|
// Data cache writeback and invalidate:
|
|
#if XCHAL_DCACHE_IS_WRITEBACK
|
|
cache_index_all diwbi, XCHAL_DCACHE_SIZE, XCHAL_DCACHE_LINESIZE, 1, \aa, \ab
|
|
dcache_sync \aa
|
|
#else /*writeback*/
|
|
// Data cache does not support writeback, so just invalidate: */
|
|
dcache_invalidate_all \aa, \ab
|
|
#endif /*writeback*/
|
|
// End of data cache writeback and invalidate
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Lock (prefetch & lock) a single line of the data cache.
|
|
*
|
|
* Parameters are:
|
|
* ar address register that contains (virtual) address to lock
|
|
* (may get clobbered in a future implementation, but not currently)
|
|
* offset offset to add to \ar to compute effective address to lock
|
|
* (note: some number of lsbits are ignored)
|
|
*/
|
|
.macro dcache_lock_line ar, offset
|
|
#if XCHAL_DCACHE_SIZE > 0 && XCHAL_DCACHE_LINE_LOCKABLE
|
|
dpfl \ar, \offset /* prefetch and lock dcache line */
|
|
dcache_sync \ar
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Lock (prefetch & lock) a specified portion of memory into the data cache.
|
|
* Parameters are:
|
|
* astart start address (register gets clobbered)
|
|
* asize size of the region in bytes (register gets clobbered)
|
|
* ac unique register used as temporary
|
|
*/
|
|
.macro dcache_lock_region astart, asize, ac
|
|
#if XCHAL_DCACHE_SIZE > 0 && XCHAL_DCACHE_LINE_LOCKABLE
|
|
// Data cache region lock:
|
|
cache_hit_region dpfl, XCHAL_DCACHE_LINEWIDTH, \astart, \asize, \ac
|
|
dcache_sync \ac
|
|
// End of data cache region lock
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Unlock a single line of the data cache.
|
|
*
|
|
* Parameters are:
|
|
* ar address register that contains (virtual) address to unlock
|
|
* (may get clobbered in a future implementation, but not currently)
|
|
* offset offset to add to \ar to compute effective address to unlock
|
|
* (note: some number of lsbits are ignored)
|
|
*/
|
|
.macro dcache_unlock_line ar, offset
|
|
#if XCHAL_DCACHE_SIZE > 0 && XCHAL_DCACHE_LINE_LOCKABLE
|
|
dhu \ar, \offset /* unlock dcache line */
|
|
dcache_sync \ar
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Unlock a specified portion of memory from the data cache.
|
|
* Parameters are:
|
|
* astart start address (register gets clobbered)
|
|
* asize size of the region in bytes (register gets clobbered)
|
|
* ac unique register used as temporary
|
|
*/
|
|
.macro dcache_unlock_region astart, asize, ac
|
|
#if XCHAL_DCACHE_SIZE > 0 && XCHAL_DCACHE_LINE_LOCKABLE
|
|
// Data cache region unlock:
|
|
cache_hit_region dhu, XCHAL_DCACHE_LINEWIDTH, \astart, \asize, \ac
|
|
dcache_sync \ac
|
|
// End of data cache region unlock
|
|
#endif
|
|
.endm
|
|
|
|
|
|
|
|
/*
|
|
* Unlock entire data cache.
|
|
*
|
|
* Parameters:
|
|
* aa, ab unique address registers (temporaries)
|
|
*/
|
|
.macro dcache_unlock_all aa, ab
|
|
#if XCHAL_DCACHE_SIZE > 0 && XCHAL_DCACHE_LINE_LOCKABLE
|
|
// Data cache unlock:
|
|
cache_index_all diu, XCHAL_DCACHE_SIZE, XCHAL_DCACHE_LINESIZE, 1, \aa, \ab
|
|
dcache_sync \aa
|
|
// End of data cache unlock
|
|
#endif
|
|
.endm
|
|
|
|
|
|
#endif /*XTENSA_CACHEASM_H*/
|
|
|