diff options
Diffstat (limited to 'SrcShared/Palm/Platform/Core/System/IncsPrv/MemoryPrv.h')
| -rw-r--r-- | SrcShared/Palm/Platform/Core/System/IncsPrv/MemoryPrv.h | 603 |
1 files changed, 603 insertions, 0 deletions
diff --git a/SrcShared/Palm/Platform/Core/System/IncsPrv/MemoryPrv.h b/SrcShared/Palm/Platform/Core/System/IncsPrv/MemoryPrv.h new file mode 100644 index 0000000..668a707 --- /dev/null +++ b/SrcShared/Palm/Platform/Core/System/IncsPrv/MemoryPrv.h @@ -0,0 +1,603 @@ +/****************************************************************************** + * + * Copyright (c) 1994-1999 Palm Computing, Inc. or its subsidiaries. + * All rights reserved. + * + * File: MemoryPrv.h + * + * Description: + * Private includes for Memory Manager. + * + * History: + * 11/11/96 RM Re-written to allow heaps > 64K in size. + * 10/26/99 kwk Added memRomStoreNum & memRamStoreNum defines. + * + *****************************************************************************/ + +#ifdef NON_PORTABLE + +// SystemPrv.h must be included before this header file. SystemPrv.h will +// then in turn include this header. +#ifndef __SYSTEMPRV_H__ +#include "SystemPrv.h" +#endif + +#ifndef __MEMORYPRV_H__ +#define __MEMORYPRV_H__ + + +//#include <ErrorMgr.h> + +#include "PalmOptErrorCheckLevel.h" + +/************************************************************ + * Private Flags accepted as parameter for MemNewChunk. + *************************************************************/ +#define memNewChunkFlagAllowLarge 0x1000 // allow >64K allocations + + +/************************************************************ + * Store numbers for MemStoreInfo. + *************************************************************/ +#define memRomStoreNum 0 +#define memRamStoreNum 1 + + +/******************************************************************** + * Structure of a version 2 Master Pointer Table chunk. + * The first master pointer chunk is always immediately following the + * heap header. As more movable chunks are created, new master + * pointer chunks are allocated dynamically and linked together through + * the nextTblOffset field and prevTblOffset field. + ********************************************************************/ +typedef struct { + UInt16 numEntries; // number of master pointer entries + UInt32 nextTblOffset; // offset from start of heap to next table + //void * mstrP[numEntries]; // array of pointers to movable chunks + } MemMstrPtrTableType; +typedef MemMstrPtrTableType* MemMstrPtrTablePtr; + + +/******************************************************************** + * Structure of a version 1 Master Pointer Table chunk. + * This is included for use by the Palm Debugger so that it can do + * heap dumps of devices that use the version 1 Memory Manager. + ********************************************************************/ +typedef struct { + UInt16 numEntries; // number of master pointer entries + UInt16 nextTblOffset; // offset from start of heap to next table + //void * mstrP[numEntries]; // array of pointers to movable chunks + } Mem1MstrPtrTableType; +typedef Mem1MstrPtrTableType* Mem1MstrPtrTablePtr; + + + +/******************************************************************** + * Structure of a version 2 Memory Manager Chunk Header. + ********************************************************************/ +#if CPU_ENDIAN == CPU_ENDIAN_BIG + +typedef struct { + UInt32 free :1; // set if free chunk + UInt32 moved :1; // used by MemHeapScramble + UInt32 unused2 :1; // unused + UInt32 unused3 :1; // unused + UInt32 sizeAdj :4; // size adjustment + UInt32 size :24; // actual size of chunk + + UInt32 lockCount :4; // lock count + UInt32 owner :4; // owner ID + Int32 hOffset :24; // signed MemHandle offset/2 + // used in free chunks to point to next free chunk + } MemChunkHeaderType; + +#else + +// Since this is an internal structure, I rearranged the fields. +// There were two reasons: the size and hOffset fields are accessed +// more efficiently (no shifting needed) and the flags macros still +// return the flags as defined by the API (memChunkFlagsXXXX), without +// requiring a lot of bit manipulation. +// But, the size field needs to be in the first DWord because the +// MemHeapTerminatorType is assumed to be in the same position as size. +typedef struct { + UInt32 size :24; // actual size of chunk + UInt32 sizeAdj :4; // size adjustment + UInt32 unused3 :1; // unused + UInt32 unused2 :1; // unused + UInt32 moved :1; // used by MemHeapScramble + UInt32 free :1; // set if free chunk + + Int32 hOffset :24; // signed MemHandle offset/2 + // used in free chunks to point to next free chunk + UInt32 owner :4; // owner ID + UInt32 lockCount :4; // lock count + } MemChunkHeaderType; + +#endif + +typedef MemChunkHeaderType * MemChunkHeaderPtr; + +// The MemHeapTerminatorType is stored at the end of every heap and +// is pointed to by the last real chunk in the heap +typedef UInt32 MemHeapTerminatorType; + +// This macro is a quicker way of clearing a chunk header than +// MemSet... +#define memClearChunkHeader(p) { *((UInt32 *)p) = 0; *(((UInt32 *)p)+1) = 0;} + +// This macro is used to initialize a freeChunk header +#define memInitFreeChunkHeader(p, size, hOffset) \ + { *((UInt32*)p) = (0x80000000 | (size)); *(((UInt32*)p)+1) = (hOffset); } + +// This macro returns the data portion of a chunk given a pointer to the header +#define memChunkData(chunkP) (void *)(((MemChunkHeaderPtr)(chunkP)) + 1) + +// This macro returns the memChunkHeader given a pointer to the start of the data +#define memChunkHeader(dataP) (((MemChunkHeaderPtr)(dataP)) - 1) + +#if CPU_ENDIAN == CPU_ENDIAN_BIG + +// This macro is used to grab all the flags at once and place them into +// a byte +#define memChunkFlags(p) (*((UInt8 *)p) & 0xF0) + +// This macro is used to clear all the flags at once +#define memChunkFlagsClear(p) ((*((UInt8 *)p)) &= 0x0F) + +#else + +// This macro is used to grab all the flags at once and place them into +// a byte +#define memChunkFlags(p) (*(((UInt8 *)p)+3) & 0xF0) + +// This macro is used to clear all the flags at once +#define memChunkFlagsClear(p) (*(((UInt8 *)p)+3) &= 0x0F) + +#endif + +// When flags are returned by the API (by MemPtrFlags, etc.) +#define memChunkFlagFree 0x80 // free bit +#define memChunkFlagUnused1 0x40 // unused +#define memChunkFlagUnused2 0x20 // unused +#define memChunkFlagUnused3 0x10 // unused + +// A lockcount of memPtrLockCount means a permanently unmovable chunk +#define memPtrLockCount 15 + +// A ownerID of 15 is used for master pointer chunks +#define memOwnerMasterPtrTbl 15 + + +// This equate returns the name of the ChunkHeaderType. This was created +// so that we can change the name of the CHunkHeaderType (as we did for V2 of +// the Memory Manager) and souce code won't know the difference +#define memChunkHeaderTypeName MemChunkHeaderType + + +/******************************************************************** + * Structure of a version 1 Memory Manager Chunk Header. + * This is included for use by the Palm Debugger so that it can do + * heap dumps of devices that use the version 1 Memory Manager. + ********************************************************************/ +typedef struct { + UInt16 size; // size of block in bytes, including header + UInt8 lockOwner; // lock count in high nibble, owner in low + UInt8 flags; // flags, size adj in low nibble + Int16 hOffset; // offset/2 to MemHandle for movables + } Mem1ChunkHeaderType; +typedef Mem1ChunkHeaderType* Mem1ChunkHeaderPtr; + +#define mem1ChunkFlagSizeAdj 0x0F // mask for size adjustment + +// A non-movable chunk has 0xF as the lock count +#define mem1ChunkLockMask 0xF0 +#define mem1ChunkOwnerMask 0x0F + + +/******************************************************************** + * Structure of a Heap + * + * A heap starts with a HeapHeader + * Followed by the offset table (numHandles) + * Followed by movable chunks + * Followed by non-movable chunks + ********************************************************************/ + +/******************************************************************** + * Structure of a version 3 Memory Heap Header. + ********************************************************************/ +typedef struct { + UInt16 flags; // heap flags; + UInt32 size; // size of heap + UInt32 firstFreeChunkOffset;// offset/2 to first free chunk + MemMstrPtrTableType mstrPtrTbl; // Master pointer table + } MemHeapHeaderType; +typedef MemHeapHeaderType * MemHeapHeaderPtr; + + +// Flags Field +#define memHeapFlagReadOnly 0x0001 // heap is read-only (ROM based) +#define memHeapFlagVers2 0x8000 // version 2 heap (> 64K) +#define memHeapFlagVers3 0x4000 // version 3 heap (has free list) +#define memHeapFlagVers4 0x2000 // version 4 heap (has free master pointer table entry list) + +#define memMstrPtrTableGrowBy 50 // # of entries to grow master pointer tables by +#define memMstrPtrTableInitSizeD 200 // # of entries to allocate initially for dynamic heap(s) +#define memMstrPtrTableInitSizeS 200 // # of entries to allocate initially for storage heap(s) + + + +/******************************************************************** + * Structure of a version 1 Memory Heap Header. + * This is included for use by the Palm Debugger so that it can do + * heap dumps of devices that use the version 1 Memory Manager. + ********************************************************************/ +typedef struct { + UInt16 flags; // heap flags; + UInt16 size; // size of heap - 0 means 64K; + Mem1MstrPtrTableType mstrPtrTbl; // Master pointer table + } Mem1HeapHeaderType; +typedef Mem1HeapHeaderType * Mem1HeapHeaderPtr; + + +/******************************************************************** + * Structure of a version 2 Memory Heap Header. + * This is included for use by the Palm Debugger so that it can do + * heap dumps of devices that use the version 1 Memory Manager. + ********************************************************************/ +typedef struct { + UInt16 flags; // heap flags; + UInt32 size; // size of heap + MemMstrPtrTableType mstrPtrTbl; // Master pointer table + } Mem2HeapHeaderType; +typedef Mem2HeapHeaderType * Mem2HeapHeaderPtr; + + +/******************************************************************** + * These macros pave the way for the version 2 Memory Manager that + * supports >64K chunks. + * + * They are a general way to get info out of a Chunk header and Heap header + * whether it be a version 1 or version 2 header. They are used almost + * exclusively by the Palm Debugger and Simulator Heap Dump utility + * since it must be able to do heap dumps of both versions of the Palm + * Memory Manager. + * + * The 'ver' parameter to these macros is either 1 for version 1 or + * 2 for version 2 and the 'p' parameter is the chunk header pointer. + ********************************************************************/ +// This structure is big enough to read in a version 1 or version 2 +// Master Pointer Table into +typedef struct { + union { + MemMstrPtrTableType ver2; + Mem1MstrPtrTableType ver1; + } header; + } MemMstrPtrTableUnionType; + +#define memUSizeOfMstrPtrTable(ver) \ + (ver>1 ? sizeof(MemMstrPtrTableType) : sizeof(Mem1MstrPtrTableType)) + +#define memUMstrPtrTableNextTblOffset(p,ver) \ + (ver>1 ? ((MemMstrPtrTablePtr)p)->nextTblOffset : ((Mem1MstrPtrTablePtr)p)->nextTblOffset) + +#define memUMstrPtrTableNumEntries(p,ver) \ + (ver>1 ? ((MemMstrPtrTablePtr)p)->numEntries : ((Mem1MstrPtrTablePtr)p)->numEntries) + + +// This structure is big enough to read in a version 1, version 2, or version 3 +// heap header into +typedef struct { + union { + MemHeapHeaderType ver3; + Mem2HeapHeaderType ver2; + Mem1HeapHeaderType ver1; + } header; + } MemHeapHeaderUnionType; + +#define memUHeapVer(p) \ + (memUHeapFlags((p)) & memHeapFlagVers4 ? 4 : \ + (memUHeapFlags((p)) & memHeapFlagVers3 ? 3 : \ + (memUHeapFlags((p)) & memHeapFlagVers2 ? 2 : 1))) + +#define memUSizeOfHeapHeader(ver) \ + (ver>2 ? sizeof (MemHeapHeaderType) : (ver>1 ? sizeof(Mem2HeapHeaderType) : sizeof(Mem1HeapHeaderType))) + +#define memUHeapSize(p,ver) \ + (ver>2 ? ((MemHeapHeaderPtr)p)->size : (ver>1 ? ((Mem2HeapHeaderPtr)p)->size : ((Mem1HeapHeaderPtr)p)->size)) + +#define memUHeapFlags(p) \ + (((MemHeapHeaderPtr)p)->flags) + +#define memUHeapMstrPtrEntries(p,ver) \ + (ver>2 ? ((MemHeapHeaderPtr)p)->mstrPtrTbl.numEntries : (ver>1 ? ((Mem2HeapHeaderPtr)p)->mstrPtrTbl.numEntries : ((Mem1HeapHeaderPtr)p)->mstrPtrTbl.numEntries)) + +#define memUHeapMstrPtrAddr(p,ver) \ + (ver>2 ? (void *)&((MemHeapHeaderPtr)p)->mstrPtrTbl : (ver>1 ? (void *)&((Mem2HeapHeaderPtr)p)->mstrPtrTbl : (void *)&((Mem1HeapHeaderPtr)p)->mstrPtrTbl)) + + + +// This structure is big enough to read in a version 1 or version 2 +// chunk header into. +typedef struct { + union { + MemChunkHeaderType ver2; + Mem1ChunkHeaderType ver1; + } header; + } MemChunkHeaderUnionType; + +#define memUSizeOfHeapTerminator(ver) \ + (ver>1 ? sizeof(MemHeapTerminatorType) : sizeof(UInt16)) + +#define memUSizeOfChunkHeader(ver) \ + (ver>1 ? sizeof(MemChunkHeaderType) : sizeof(Mem1ChunkHeaderType)) + +#define memUChunkSize(p,ver) \ + (ver>1 ? ((MemChunkHeaderPtr)p)->size : ((Mem1ChunkHeaderPtr)p)->size) + +#define memUChunkFlags(p,ver) \ + (ver>1 ? memChunkFlags(p) : ((Mem1ChunkHeaderPtr)p)->flags & 0xF0) + +#define memUChunkSizeAdj(p,ver) \ + (ver>1 ? ((MemChunkHeaderPtr)p)->sizeAdj : ((Mem1ChunkHeaderPtr)p)->flags & mem1ChunkFlagSizeAdj) + +#define memUChunkLockCount(p,ver) \ + (ver>1 ? ((MemChunkHeaderPtr)p)->lockCount : ((Mem1ChunkHeaderPtr)p)->lockOwner >> 4) + +#define memUChunkOwner(p,ver) \ + (ver>1 ? ((MemChunkHeaderPtr)p)->owner : ((Mem1ChunkHeaderPtr)p)->lockOwner & mem1ChunkOwnerMask) + +#define memUChunkHOffset(p,ver) \ + (ver>1 ? ((MemChunkHeaderPtr)p)->hOffset : ((Mem1ChunkHeaderPtr)p)->hOffset) + + + + +/************************************************************ + * Structure of a Card Header. + * There is 1 card header for in every card that has ROM. The + * card header is stored at sysCardHeaderOffset into the card. + * + * RAM only cards will not have a card header + *************************************************************/ +#define memMaxNameLen 32 // size of name and manuf fields including null +typedef struct CardHeaderType { + UInt32 initStack; // initial stack pointer (v4: offset to code in RomBoot) + UInt32 resetVector; // reset vector + UInt32 signature; // must be sysCardSignature + UInt16 hdrVersion; // header version + UInt16 flags; // card flags; + UInt8 name[memMaxNameLen]; // card name + UInt8 manuf[memMaxNameLen]; // card manufacturer's name + UInt16 version; // card version + UInt32 creationDate; // card creation date + UInt16 numRAMBlocks; // number of RAM blocks on card + UInt32 blockListOffset; // offset to RAM block list + UInt32 readWriteParmsOffset; // v2: offset from CardBase to r/w system data if any (in ROM) + UInt32 readWriteParmsSize; // v2: size of read/write system data if any (in ROM) + UInt32 readOnlyParmsOffset; // v2: offset from CardBase to read-only system data (in ROM) + UInt32 bigROMOffset; // v2: in SmallROM header: where SmallROM expects bigROM to live + // in BigROM header: where BigROM expects itself to live + UInt32 checksumBytes; // v2: size of card image in bytes (for checksum) + UInt16 checksumValue; // v2: checksum of card image (from Crc16CalcBlock) + + UInt32 readWriteWorkingOffset; // v3: offset from CardBase to r/w working area if any (in ROM) + UInt32 readWriteWorkingSize; // v3: size of read/write working area if any (in ROM) + + UInt32 halCodeOffset; // v4: offset from CardHeader to HAL code + + UInt8 reserved[130]; // to bring us to 0x100 alignment + } CardHeaderType; +typedef CardHeaderType* CardHeaderPtr; + +#define memCardHeaderFlagRAMOnly 0x0001 // RAM only card +#define memCardHeaderFlag328 0x0010 // ROM Supports 68328 processor +#define memCardHeaderFlagEZ 0x0020 // ROM SUpports 68EZ328 processor +#define memCardHeaderFlag230K 0x1000 // SmallROM supports 230Kbps + + + +/************************************************************ + * Structure of a Storage Header. + * There is 1 of these for every "store" on a memory card. A + * "store" can be all the RAM on a card or all the ROM on a card. + * + * The RAM storage header is stored at sysRAMHeader offset into the + * card. and the ROM storage header is stored at sysROMHeader offset + * into the card. + *************************************************************/ +typedef struct { + UInt32 signature; // must be sysStoreSignature + UInt16 version; // version of header + UInt16 flags; // flags + UInt8 name[memMaxNameLen]; // name of store + UInt32 creationDate; // creation date + UInt32 backupDate; // last backup date + UInt32 heapListOffset; // offset to heap list for store + UInt32 initCodeOffset1; // init code for store, if any + UInt32 initCodeOffset2; // second init code for store, if any + LocalID databaseDirID; // local ID of database dir. + UInt32 rsvSpace; // where first heap starts. + UInt32 dynHeapSpace; // how big the dynamic heap area is + // (always 0 for ROM stores) + UInt32 firstRAMBlockSize; // Copy of firstRAMBlock size from cardinfo + // Used to determine if we're rebooting + // with a different amount of RAM. + + // The following fields are used to store non-volatile information that + // must be accessed by the system but that is not convenient to store + // in a database due to access time or frequency. It is only valid + // in the RAM STORE ON CARD #0! Though some initialization values for + // the card 0 RAM store come from the ROM store's nvParams field. + SysNVParamsType nvParams; + + // Filler bytes - reserved for future use. Size adjusted to + // keep total size of storage header at 0x100 bytes. + UInt8 reserved[176-sizeof(SysNVParamsType)]; + + // CRC value + UInt32 crc; // crc to check validity + } StorageHeaderType; +typedef StorageHeaderType* StorageHeaderPtr; + +#define memStoreHeaderFlagRAMOnly 0x0001 // RAM store + + +// A Heap list for each store on a card (either RAM or ROM) gives a list of +// heaps' starting offsets for that store +typedef struct { + UInt16 numHeaps; // Number of heaps in store + UInt32 heapOffset[1]; // offset to heap + } HeapListType; + + + +/******************************************************************** + * CardInfo structure + * The Palm globals has a pointer to an array of CardInfo structures. + * + * This array is initialized by the Boot code before the Memory Manager + * starts up. Among other things, it tells the Memory Manager where + * every card is and the size of each card. + ********************************************************************/ +typedef struct CardInfoType { + + // These fields are filled in by the boot code BEFORE + // MemInit() is called. + UInt8 *baseP; // base address of card + UInt32 size; // address range of card + UInt32 firstRAMBlockSize; // size of RAM block at offset 0 + UInt32 targetROMShift; // used only under Emulation mode, must be + // added to emulated ROM pointers when calculating + // a LocalID for use in the device ROM. + + + UInt32 cardHeaderOffset; // offset to card header (usually in ROM) + // = 0 if RAM only card + + UInt32 rsvSpace; // reserve space in RAM before first heap + UInt32 dynHeapSpace; // how much space to reserve for dynamic heap(s) + StorageHeaderPtr ramStoreP; // pointer to RAM store header + // This location depends on how much space + // was reserved on the card for the dynamic + // heap. + + // These fields are copies of information in the card and storage headers + // they are cached here for quicker access by the Memory Manager. They + // are filled in by the Memory Manager during MemInit. + UInt16 numRAMHeaps; // Number of RAM heaps - for quick access + UInt32 *ramHeapOffsetsP; // Table of RAM heap offsets - for quick access + UInt16 numROMHeaps; // Number of RAM heaps - for quick access + UInt32 *romHeapOffsetsP; // Table of RAM heap offsets - for quick access + + // This field was added for Palm OS v3.5. The HAL fills this in so the OS + // no longer has to use a #define'd value which can differ from device to device. + UInt32 cardOffsetMask; // converts a pointer to a card offset + + } CardInfoType; +typedef CardInfoType* CardInfoPtr; + +// The constant hwrNumCardSlots, defined in Hardware.h defines the maximum number +// of cards supported by the hardware. + + + + +/************************************************************ + * Private Memory Manager Constants + *************************************************************/ +// Private constant - # of dynamic heaps +#define memDynamicHeaps 1 + +// Private constant - maximum chunk size allowed (0xFFFFFFFFL = up to available memory) +// We're presently limiting the maximum chunk allocation because the current HotSync cannot +// transfer records/resources larger than (0x0FFFF - 30) bytes. This restriction will +// be removed when HotSync is extended to MemHandle larger transfers. +#define memMaxChunkAllocSize ((UInt32)(0x0FFFFUL - 30UL)) + + + +/************************************************************ + * Private Memory Manager Macros. These macros are not + * guaranteed to be compatible in the future and should + * only be used in system code, not applications. + * + * To use these, define NON_PORTABLE at the top of your + * source code module. + * + * WARNING: This macro must only be used on Locked chunks!!! + * When running with error checking, it will verify + * that the chunk is locked before it dereferences it. + *************************************************************/ + +#if MEMORY_FORCE_LOCK == MEMORY_FORCE_LOCK_ON + #define memHandleProtect(h) \ + ((MemHandle)((UInt32)h | 0x80000000)) + #define memHandleUnProtect(h) \ + ((void **)((UInt32)h & 0x7FFFFFFF)) +#else + #define memHandleProtect(h) (h) + #define memHandleUnProtect(h) (h) +#endif + + +#if MEMORY_TYPE == MEMORY_LOCAL + #if ERROR_CHECK_LEVEL == ERROR_CHECK_FULL + #define MemDeref(h) \ + ((MemHandleLockCount(h)==0 ? (*((void **)0x80000000)) : (*memHandleUnProtect(h)))) + #else + #define MemDeref(h) \ + (*(memHandleUnProtect(h))) + #endif + +#else + #if ERROR_CHECK_LEVEL == ERROR_CHECK_FULL + #define MemDeref(h) \ + ((MemHandleLockCount(h)==0 ? (*((void **)0x80000000)) : ((void *)ShlDWord(h))) ) + #else + #define MemDeref(h) \ + ((void *)ShlDWord(memHandleUnProtect(h))) + #endif +#endif + + + + +// Typecast access to the MemCardInfo MemPtr +#define memCardInfoP(cardNo) \ + ( ((CardInfoPtr) ((LowMemHdrType*)PilotGlobalsP)->globals.memCardInfoP) + cardNo) + + + +/******************************************************************** + * Memory Manager Private Routines + * These are used only by internal System code + ********************************************************************/ +#ifdef REMOVE_FOR_EMULATOR +#ifdef __cplusplus +extern "C" { +#endif + + +void * MemHeapPtr(UInt16 heapID) + SYS_TRAP(sysTrapMemHeapPtr); + +Err MemStoreSearch(void *startP, UInt32 range, StorageHeaderPtr *storePP) + SYS_TRAP(sysTrapMemStoreSearch); + +Err MemStoreInit(UInt32 firstHeapSize, UInt16 firstHeapMstrPtrs, + UInt16 cardNo, UInt16 numBlocks, UInt32 *blockInfoP, + StorageHeaderPtr storeP, UInt16 numMstrPtrs) + SYS_TRAP(sysTrapMemStoreInit); + +Err MemNVParams(Boolean set, SysNVParamsPtr paramsP) + SYS_TRAP(sysTrapMemNVParams); + +#ifdef __cplusplus +} +#endif +#endif + +#endif // __MEMORYPRV_H__ +#endif // NON_PORTABLE |