module ti.sysbios.hal.Cache

Cache Manager Proxy

This module is a proxy to the generic Cache module functions as defined in ICache.xdc. [ more ... ]
XDCspec summary sourced in ti/sysbios/hal/Cache.xdc
module Cache {  ...
    // inherits xdc.runtime.IModule
C synopsis target-domain
#include <ti/sysbios/hal/Cache.h>
module-wide constants & types
    } Cache_Type;
module-wide functions
    Void Cache_disable// Disables the 'type' cache(s)( Bits16 type );
    Void Cache_enable// Enables all cache(s)( Bits16 type );
    Void Cache_wb// Writes back a range of memory from all cache(s)( Ptr blockPtr, SizeT byteCnt, Bits16 type, Bool wait );
module-wide built-ins
 
XDCscript usage meta-domain
var Cache = xdc.useModule('ti.sysbios.hal.Cache');
module-wide constants & types
        const Cache.Type_L1D// Level 1 Data cache;
        const Cache.Type_L1// Level 1 caches;
        const Cache.Type_L2D// Level 2 Data cache;
        const Cache.Type_L2// Level 2 caches;
        const Cache.Type_ALL// All caches;
 
    var obj = new Cache.ModuleView// ;
        obj.delegateCacheModule = String  ...
module-wide config parameters
 
XDCspec declarations sourced in ti/sysbios/hal/Cache.xdc
package ti.sysbios.hal;
 
module Cache inherits ICache {
module-wide constants & types
        Type_L1// Level 1 caches,
        Type_L2// Level 2 caches,
        Type_ALL// All caches
    };
 
    metaonly struct ModuleView//  {
        String delegateCacheModule;
    };
module-wide config parameters
    metaonly config ViewInfo.Instance rovViewInfo//  = ViewInfo.create;
module-wide functions
    Void disable// Disables the 'type' cache(s)( Bits16 type );
    Void enable// Enables all cache(s)( Bits16 type );
    Void wb// Writes back a range of memory from all cache(s)( Ptr blockPtr, SizeT byteCnt, Bits16 type, Bool wait );
}
DETAILS
This module is a proxy to the generic Cache module functions as defined in ICache.xdc.
The actual implementations of the Cache module functions are provided by the Cache module delegates.
Additional, family specific Cache module APIs may also be provided by the Cache module delegates.
Follow the link below to determine which Cache delegate is used for your Target/Device:

Calling Context

Function Hwi Swi Task Main Startup
disable Y Y Y Y Y
enable Y Y Y Y Y
inv Y Y Y Y Y
wait Y Y Y Y Y
wb Y Y Y Y Y
wbInv Y Y Y Y Y
Definitions:
  • Hwi: API is callable from a Hwi thread.
  • Swi: API is callable from a Swi thread.
  • Task: API is callable from a Task thread.
  • Main: API is callable during any of these phases:
    • In your module startup after this module is started (e.g. Cache_Module_startupDone() returns TRUE).
    • During xdc.runtime.Startup.lastFxns.
    • During main().
    • During BIOS.startupFxns.
  • Startup: API is callable during any of these phases:
    • During xdc.runtime.Startup.firstFxns.
    • In your module startup before this module is started (e.g. Cache_Module_startupDone() returns FALSE).
 
enum Cache.Type

Lists of bitmask cache types

XDCscript usage meta-domain
values of type Cache.Type
    const Cache.Type_L1P;
    // Level 1 Program cache
    const Cache.Type_L1D;
    // Level 1 Data cache
    const Cache.Type_L1;
    // Level 1 caches
    const Cache.Type_L2P;
    // Level 2 Program cache
    const Cache.Type_L2D;
    // Level 2 Data cache
    const Cache.Type_L2;
    // Level 2 caches
    const Cache.Type_ALL;
    // All caches
C synopsis target-domain
typedef enum Cache_Type {
    Cache_Type_L1P,
    // Level 1 Program cache
    Cache_Type_L1D,
    // Level 1 Data cache
    Cache_Type_L1,
    // Level 1 caches
    Cache_Type_L2P,
    // Level 2 Program cache
    Cache_Type_L2D,
    // Level 2 Data cache
    Cache_Type_L2,
    // Level 2 caches
    Cache_Type_ALL
    // All caches
} Cache_Type;
 
 
metaonly struct Cache.ModuleView
XDCscript usage meta-domain
var obj = new Cache.ModuleView;
 
    obj.delegateCacheModule = String  ...
 
 
metaonly config Cache.common$  // module-wide

Common module configuration parameters

XDCscript usage meta-domain
Cache.common$ = Types.Common$ undefined;
 
DETAILS
All modules have this configuration parameter. Its name contains the '$' character to ensure it does not conflict with configuration parameters declared by the module. This allows new configuration parameters to be added in the future without any chance of breaking existing modules.
 
metaonly config Cache.rovViewInfo  // module-wide
XDCscript usage meta-domain
Cache.rovViewInfo = ViewInfo.Instance ViewInfo.create;
 
 
Cache.disable( )  // module-wide

Disables the 'type' cache(s)

C synopsis target-domain
Void Cache_disable( Bits16 type );
 
ARGUMENTS
type — bit mask of Cache type
 
Cache.enable( )  // module-wide

Enables all cache(s)

C synopsis target-domain
Void Cache_enable( Bits16 type );
 
ARGUMENTS
type — bit mask of Cache type
 
Cache.inv( )  // module-wide

Invalidate the range of memory within the specified starting address and byte count. The range of addresses operated on gets quantized to whole cache lines in each cache. All lines in range are invalidated for all the 'type' caches

C synopsis target-domain
Void Cache_inv( Ptr blockPtr, SizeT byteCnt, Bits16 type, Bool wait );
 
ARGUMENTS
blockPtr — start address of range to be invalidated
byteCnt — number of bytes to be invalidated
type — bit mask of Cache type
wait — wait until the operation is completed
 
Cache.wait( )  // module-wide

Wait for a previous cache operation to complete

C synopsis target-domain
Void Cache_wait( );
 
DETAILS
Wait for the cache wb/wbInv/inv operation to complete. A cache operation is not truly complete until it has worked its way through all buffering and all memory writes have landed in the source memory.
 
Cache.wb( )  // module-wide

Writes back a range of memory from all cache(s)

C synopsis target-domain
Void Cache_wb( Ptr blockPtr, SizeT byteCnt, Bits16 type, Bool wait );
 
ARGUMENTS
blockPtr — start address of range to be invalidated
byteCnt — number of bytes to be invalidated
type — bit mask of Cache type
wait — wait until the operation is completed
DETAILS
Writes back the range of memory within the specified starting address and byte count. The range of addresses operated on gets quantized to whole cache lines in each cache. All lines within the range are left valid in the 'type' caches and the data within the range will be written back to the source memory.
 
Cache.wbInv( )  // module-wide

Writes back and invalidates the range of memory within the specified starting address and byte count. The range of addresses operated on gets quantized to whole cache lines in each cache. All lines within the range are written back to the source memory and then invalidated for all 'type' caches

C synopsis target-domain
Void Cache_wbInv( Ptr blockPtr, SizeT byteCnt, Bits16 type, Bool wait );
 
ARGUMENTS
blockPtr — start address of range to be invalidated
byteCnt — number of bytes to be invalidated
type — bit mask of Cache type
wait — wait until the operation is completed
 
module-wide built-ins

C synopsis target-domain
Types_ModuleId Cache_Module_id( );
// Get this module's unique id
 
Bool Cache_Module_startupDone( );
// Test if this module has completed startup
 
IHeap_Handle Cache_Module_heap( );
// The heap from which this module allocates memory
 
Bool Cache_Module_hasMask( );
// Test whether this module has a diagnostics mask
 
Bits16 Cache_Module_getMask( );
// Returns the diagnostics mask for this module
 
Void Cache_Module_setMask( Bits16 mask );
// Set the diagnostics mask for this module
generated on Fri, 16 Oct 2009 20:56:13 GMT