|
|
Line 4,748: |
Line 4,748: |
| |- | | |- |
| | <code>TLoggingOutputEx = procedure(AFacility,ASeverity:LongWord; const ATag,AContent:String);</code> | | | <code>TLoggingOutputEx = procedure(AFacility,ASeverity:LongWord; const ATag,AContent:String);</code> |
| + | | style="width: 40%;"| |
| + | |- |
| + | |} |
| + | |
| + | '''Environment get''' |
| + | |
| + | {| class="wikitable" style="font-size: 14px; text-align: left; width: 100%; height: 50px;" |
| + | |- |
| + | | <code>TEnvironmentGet = function(const AName:String):String;</code> |
| + | | style="width: 40%;"| |
| + | |- |
| + | |} |
| + | |
| + | '''Environment set''' |
| + | |
| + | {| class="wikitable" style="font-size: 14px; text-align: left; width: 100%; height: 50px;" |
| + | |- |
| + | | <code>TEnvironmentSet = function(const AName,AValue:String):LongWord;</code> |
| + | | style="width: 40%;"| |
| + | |- |
| + | |} |
| + | '''Environment count''' |
| + | |
| + | {| class="wikitable" style="font-size: 14px; text-align: left; width: 100%; height: 50px;" |
| + | |- |
| + | | <code>TEnvironmentCount = function(AReset:Boolean):LongWord;</code> |
| + | | style="width: 40%;"| |
| + | |- |
| + | |} |
| + | '''Environment index''' |
| + | |
| + | {| class="wikitable" style="font-size: 14px; text-align: left; width: 100%; height: 50px;" |
| + | |- |
| + | | <code>TEnvironmentIndex = function(const AName:String):LongWord;</code> |
| + | | style="width: 40%;"| |
| + | |- |
| + | |} |
| + | '''Environment string''' |
| + | |
| + | {| class="wikitable" style="font-size: 14px; text-align: left; width: 100%; height: 50px;" |
| + | |- |
| + | | <code>TEnvironmentString = function(AIndex:LongWord):String;</code> |
| | style="width: 40%;"| | | | style="width: 40%;"| |
| |- | | |- |
Revision as of 06:23, 6 September 2024
Return to Unit Reference
Description
Ultibo Platform Interface unit
Constants
Handle flag HANDLE_FLAG_*
HANDLE_FLAG_NONE = $00000000;
|
|
HANDLE_FLAG_NAMED = $00000001;
|
Set if the handle has a name
|
HANDLE_FLAG_DUPLICATE = $00000002;
|
Set if the handle can be duplicated
|
|
HANDLE_FLAG_INTERNAL = HANDLE_FLAG_NONE + $80000000;
|
Note: Temporary value to avoid warning
|
Handle constants HANDLE_*
HANDLE_SIGNATURE = $CD15E20A;
|
|
|
HANDLE_TABLE_MIN = $100;
|
Minimum handle number (Skip first 256)
|
HANDLE_TABLE_MAX = $7FFFFFFF;
|
Maximum handle number (Avoid MSB as THandle is a signed value)
|
|
HANDLE_TABLE_MASK = $7FF;
|
2048 buckets for handle lookups
|
|
HANDLE_NAME_LENGTH = 256;
|
Maximum length of handle name
|
DMA data flag DMA_DATA_FLAG_*
DMA_DATA_FLAG_NONE = $00000000;
|
|
DMA_DATA_FLAG_STRIDE = $00000001;
|
Transfer from the source to the destination using 2D stride (If supported)
|
DMA_DATA_FLAG_SOURCE_NOINCREMENT = $00000002;
|
Don't increment the source address during the DMA request (If supported)
|
DMA_DATA_FLAG_DEST_NOINCREMENT = $00000004;
|
Don't increment the dest address during the DMA request (If supported)
|
DMA_DATA_FLAG_SOURCE_DREQ = $00000008;
|
Use DREQ gating on the source address during the DMA request (If supported)
|
DMA_DATA_FLAG_DEST_DREQ = $00000010;
|
Use DREQ gating on the dest address during the DMA request (If supported)
|
DMA_DATA_FLAG_SOURCE_WIDE = $00000020;
|
Use wide reads on the source address during the DMA request (If supported)
|
DMA_DATA_FLAG_DEST_WIDE = $00000040;
|
Use wide writes on the dest address during the DMA request (If supported)
|
DMA_DATA_FLAG_NOREAD = $00000080;
|
Ignore the source address and zero fill the destination (If supported)
|
DMA_DATA_FLAG_NOWRITE = $00000100;
|
Ignore the dest address and cache fill from the source (If supported)
|
DMA_DATA_FLAG_NOCLEAN = $00000200;
|
Do not perform cache clean on the source address (If applicable)
|
DMA_DATA_FLAG_NOINVALIDATE = $00000400;
|
Do not perform cache invalidate on the dest address (If applicable)
|
DMA_DATA_FLAG_BULK = $00000800;
|
Perform a bulk transfer (Higher transfer throughput) (If applicable)
|
DMA_DATA_FLAG_LITE = $00001000;
|
Perform a "lite" transfer (Lower transfer throughput but less waiting for free channel) (If applicable)
|
DMA_DATA_FLAG_40BIT = $00002000;
|
Perform a 40-bit address transfer (Address to memory above 1GB or 4GB depending on SoC) (If applicable)
|
Page table flag PAGE_TABLE_FLAG_*
PAGE_TABLE_FLAG_NONE = $00000000;
|
|
Reserved 0x00000001 (Previously used incorrectly for PAGE_TABLE_FLAG_NONE)
|
PAGE_TABLE_FLAG_NORMAL = $00000002;
|
Page Table Entry represents Normal memory
|
PAGE_TABLE_FLAG_DEVICE = $00000004;
|
Page Table Entry represents Device memory
|
PAGE_TABLE_FLAG_ORDERED = $00000008;
|
Page Table Entry represents Ordered memory
|
PAGE_TABLE_FLAG_SHARED = $00000010;
|
Page Table Entry represents Shared memory
|
PAGE_TABLE_FLAG_CACHEABLE = $00000020;
|
Page Table Entry represents Cacheable memory
|
PAGE_TABLE_FLAG_READONLY = $00000040;
|
Page Table Entry represents Read Only memory
|
PAGE_TABLE_FLAG_READWRITE = $00000080;
|
Page Table Entry represents Read Write memory
|
PAGE_TABLE_FLAG_EXECUTABLE = $00000100;
|
Page Table Entry represents Executable memory
|
PAGE_TABLE_FLAG_WRITEBACK = $00000200;
|
Page Table Entry is Writeback Cacheable memory
|
PAGE_TABLE_FLAG_WRITETHROUGH = $00000400;
|
Page Table Entry is Writethrough Cacheable memory
|
PAGE_TABLE_FLAG_WRITEALLOCATE = $00000800;
|
Page Table Entry is Writeallocate Cacheable memory
|
Interrupt entry flag INTERRUPT_FLAG_*
INTERRUPT_FLAG_NONE = $00000000;
|
|
INTERRUPT_FLAG_SHARED = $00000001;
|
A shared interrupt, multiple devices can register for the same interrupt and each will be called until one returns INTERRUPT_RETURN_HANDLED
|
INTERRUPT_FLAG_LOCAL = $00000002;
|
A local interrupt, generated only on the CPU it is associated with
|
INTERRUPT_FLAG_IPI = $00000004;
|
A software interrupt or inter processor interrupt, generated by a software request instead of hardware
|
INTERRUPT_FLAG_FIQ = $00000008;
|
A fast interrupt, takes precedence over all other interrupts (where applicable)
|
INTERRUPT_FLAG_CHAINED = $00000010;
|
A chained interrupt, multiple devices can register for the same interrupt and all will be called when it occurs
|
Interrupt priority value INTERRUPT_PRIORITY_*
INTERRUPT_PRIORITY_MAXIMUM = $00;
|
|
INTERRUPT_PRIORITY_FIQ = $40;
|
|
INTERRUPT_PRIORITY_DEFAULT = $A0;
|
|
INTERRUPT_PRIORITY_MINIMUM = $F0;
|
|
Interrupt return value INTERRUPT_RETURN_*
INTERRUPT_RETURN_NONE = 0;
|
Shared interrupt not handled or not for this device
|
INTERRUPT_RETURN_HANDLED = 1;
|
Shared interrupt handled, no further processing
|
Vector table entry VECTOR_TABLE_ENTRY_*
ARM
|
VECTOR_TABLE_ENTRY_ARM_RESET = 0;
|
ARM Reset Vector
|
VECTOR_TABLE_ENTRY_ARM_UNDEFINED = 1;
|
ARM Undefined Vector
|
VECTOR_TABLE_ENTRY_ARM_SWI = 2;
|
ARM Software Interrupt (SWI) Vector
|
VECTOR_TABLE_ENTRY_ARM_PREFETCH = 3;
|
ARM Prefetch Abort Vector
|
VECTOR_TABLE_ENTRY_ARM_ABORT = 4;
|
ARM Data Abort Vector
|
VECTOR_TABLE_ENTRY_ARM_RESERVED = 5;
|
ARM Reserved Vector
|
VECTOR_TABLE_ENTRY_ARM_IRQ = 6;
|
ARM IRQ Vector
|
VECTOR_TABLE_ENTRY_ARM_FIQ = 7;
|
ARM FIQ Vector
|
Shutdown flag SHUTDOWN_FLAG_*
SHUTDOWN_FLAG_NONE = $00000000;
|
|
SHUTDOWN_FLAG_RESTART = $00000001;
|
The system is shutting down and restarting
|
SHUTDOWN_FLAG_FORCE = $00000002;
|
Forced shutdown or restart requested, registered callbacks will be bypassed
|
Shutdown constant SHUTDOWN_*
SHUTDOWN_SIGNATURE = $A73D8B0C;
|
|
|
SHUTDOWN_DEFAULT_DELAY = 1000;
|
Default delay before starting a shutdown or restart (Milliseconds)
|
SHUTDOWN_MINIMUM_DELAY = 10;
|
Minimum delay before starting a shutdown or restart (Milliseconds)
|
|
SHUTDOWN_DEFAULT_TIMEOUT = 5000;
|
Default time to wait for a shutdown callback to complete before continuing (Milliseconds)
|
Exception type EXCEPTION_TYPE_*
EXCEPTION_TYPE_DATA_ABORT = 1;
|
|
EXCEPTION_TYPE_PREFETCH_ABORT = 2;
|
|
EXCEPTION_TYPE_UNDEFINED_INSTRUCTION = 3;
|
|
Firmware throttling flag FIRMWARE_THROTTLE_*
FIRMWARE_THROTTLE_NONE = (0 shl 0);
|
|
FIRMWARE_THROTTLE_UNDER_VOLTAGE = (1 shl 0);
|
Under voltage is occurring
|
FIRMWARE_THROTTLE_FREQUENCY_LIMIT = (1 shl 1);
|
Frequency limiting is occurring
|
FIRMWARE_THROTTLE_THROTTLED = (1 shl 2);
|
Throttling is occurring
|
FIRMWARE_THROTTLE_SOFT_TEMP_LIMIT = (1 shl 3);
|
Soft temperature limit is active
|
FIRMWARE_THROTTLE_WAS_UNDER_VOLTAGE = (1 shl 16);
|
Under voltage has occurred
|
FIRMWARE_THROTTLE_WAS_FREQUENCY_LIMIT = (1 shl 17);
|
Frequency limiting has occurred
|
FIRMWARE_THROTTLE_WAS_THROTTLED = (1 shl 18);
|
Throttling has occurred
|
FIRMWARE_THROTTLE_WAS_SOFT_TEMP_LIMIT = (1 shl 19);
|
Soft temperature limit has occurred
|
Platform logging PLATFORM_LOG_LEVEL_*
PLATFORM_LOG_LEVEL_DEBUG = LOG_LEVEL_DEBUG;
|
Platform debugging messages
|
PLATFORM_LOG_LEVEL_INFO = LOG_LEVEL_INFO;
|
Platform informational messages
|
PLATFORM_LOG_LEVEL_WARN = LOG_LEVEL_WARN;
|
Platform warning messages
|
PLATFORM_LOG_LEVEL_ERROR = LOG_LEVEL_ERROR;
|
Platform error messages
|
PLATFORM_LOG_LEVEL_NONE = LOG_LEVEL_NONE;
|
No Platform messages
|
IRQ logging IRQ_LOG_LEVEL_*
IRQ_LOG_LEVEL_DEBUG = LOG_LEVEL_DEBUG;
|
IRQ debugging messages
|
IRQ_LOG_LEVEL_INFO = LOG_LEVEL_INFO;
|
IRQ informational messages
|
IRQ_LOG_LEVEL_WARN = LOG_LEVEL_WARN;
|
IRQ warning messages
|
IRQ_LOG_LEVEL_ERROR = LOG_LEVEL_ERROR;
|
IRQ error messages
|
IRQ_LOG_LEVEL_NONE = LOG_LEVEL_NONE;
|
No IRQ messages
|
FIQ logging FIQ_LOG_LEVEL_*
FIQ_LOG_LEVEL_DEBUG = LOG_LEVEL_DEBUG;
|
FIQ debugging messages
|
FIQ_LOG_LEVEL_INFO = LOG_LEVEL_INFO;
|
FIQ informational messages
|
FIQ_LOG_LEVEL_WARN = LOG_LEVEL_WARN;
|
FIQ warning messages
|
FIQ_LOG_LEVEL_ERROR = LOG_LEVEL_ERROR;
|
FIQ error messages
|
FIQ_LOG_LEVEL_NONE = LOG_LEVEL_NONE;
|
No FIQ messages
|
SWI logging SWI_LOG_LEVEL_*
DEBUG = LOG_LEVEL_DEBUG;
|
SWI debugging messages
|
SWI_LOG_LEVEL_INFO = LOG_LEVEL_INFO;
|
SWI informational messages
|
SWI_LOG_LEVEL_WARN = LOG_LEVEL_WARN;
|
SWI warning messages
|
SWI_LOG_LEVEL_ERROR = LOG_LEVEL_ERROR;
|
SWI error messages
|
SWI_LOG_LEVEL_NONE = LOG_LEVEL_NONE;
|
No SWI messages
|
Type definitions
IRQ mask
FIQ mask
IRQ/FIQ mask
Abort mask
DMA data
PDMAData = ^TDMAData;
TDMAData = record
Data Properties
|
Source:Pointer;
|
Source address for DMA (May need to be allocated in accordance with DMA host configuration)
|
Dest:Pointer;
|
Dest address for DMA (May need to be allocated in accordance with DMA host configuration)
|
Size:LongWord;
|
Size for DMA transfer (For 2D stride the length of a row multiplied by the count of rows)
|
Flags:LongWord;
|
Flags for DMA transfer (See DMA_DATA_FLAG_* above)
|
Stride Properties
|
StrideLength:LongWord;
|
Length of each row during 2D stride (If supported)
|
SourceStride:LongInt;
|
Increment between rows for source address during 2D stride (If supported)
|
DestStride:LongInt;
|
Increment between rows for destination address during 2D stride (If supported)
|
Next Block
|
Next:PDMAData;
|
Link to next DMA data block (or nil for the last block)
|
System call request (SWI)
PSystemCallRequest = ^TSystemCallRequest;
TSystemCallRequest = record
Number:LongWord;
|
|
Param1:PtrUInt;
|
|
Param2:PtrUInt;
|
|
Param3:PtrUInt;
|
|
Handle close
THandleClose = procedure(Data:THandle);
|
|
Handle close extended
THandleCloseEx = function(Data:THandle):LongWord;
|
|
Handle duplicate
THandleDuplicate = function(Data:THandle):THandle;
|
|
Handle enumeration callback
THandleEnumerate = function(Handle:PHandleEntry; Data:Pointer):LongWord;
|
|
Handle entry
PHandleEntry = ^THandleEntry;
THandleEntry = record
Handle Properties
|
Signature:LongWord;
|
Signature for entry validation
|
Handle:THandle;
|
Handle (Number) of this Handle
|
HandleType:LongWord;
|
Type of this Handle (eg HANDLE_TYPE_FILE)
|
Count:LongWord;
|
Reference Count of the Handle
|
Flags:LongWord;
|
Flags for the Handle (eg HANDLE_FLAG_NAMED)
|
Name:PChar;
|
The name of the Handle (Optional)
|
Hash:LongWord;
|
Hash of the Handle name (Only if named)
|
Data:THandle;
|
Purpose specific data for the Handle (eg a file handle or a socket handle)
|
Close:THandleClose;
|
Procedure to call on final close (Optional)
|
CloseEx:THandleCloseEx;
|
Function to call on final close (Optional)
|
Duplicate:THandleDuplicate;
|
Function to call when duplicating handle (Optional)
|
Internal Properties
|
Prev:PHandleEntry;
|
Previous entry in Handle table
|
Next:PHandleEntry;
|
Next entry in Handle table
|
Statistics Properties
|
|
Handle entries
PHandleEntries = ^THandleEntries;
THandleEntries = array[0..HANDLE_TABLE_MASK + 1] of PHandleEntry;
Handle table
PHandleTable = ^THandleTable;
THandleTable = record
Next:LongWord;
|
The next handle number
|
Count:LongWord;
|
The current handle count
|
Handles:PHandleEntries;
|
Array of handle entries hash buckets
|
Shutdown callback
TShutdownCallback = function(Flags:LongWord; Parameter:Pointer):LongWord;
|
|
Shutdown entry
PShutdownEntry = ^TShutdownEntry;
TShutdownEntry = record
Shutdown Properties
|
Signature:LongWord;
|
Signature for entry validation
|
Callback:TShutdownCallback;
|
The procedure to call on Shutdown or Restart
|
Parameter:Pointer;
|
The parameter to pass to the Shutdown procedure (or nil)
|
Timeout:LongWord;
|
The time to wait for the Callback to complete (or 0 to use the default timeout) (Milliseconds)
|
Internal Properties
|
Prev:PShutdownEntry;
|
Previous entry in Shutdown table
|
Next:PShutdownEntry;
|
Next entry in Shutdown table
|
Shutdown data
PShutdownData = ^TShutdownData;
TShutdownData = record
Used internally by Shutdown or Restart
|
Delay:LongWord;
|
Delay value requested for Shutdown or Restart (Milliseconds)
|
Flags:LongWord;
|
Flags for requested Shutdown or Restart (eg SHUTDOWN_FLAG_RESTART)
|
Entry:PShutdownEntry;
|
The current shutdown entry being processed
|
Interrupt entry (IRQ/FIQ)
PInterruptEntry = ^TInterruptEntry;
TInterruptEntry = record
Interrupt Properties
|
FNumber:LongWord;
|
|
FFlags:LongWord;
|
|
FCPUMask:LongWord;
|
|
FPriority:LongWord;
|
|
FHandler:TInterruptHandler;
|
|
FHandlerEx:TInterruptExHandler;
|
|
FSharedHandler:TSharedInterruptHandler;
|
|
FParameter:Pointer;
|
|
Internal Properties
|
FPrev:PInterruptEntry;
|
|
FNext:PInterruptEntry;
|
|
|
function GetCPUID:LongWord;
|
|
procedure SetCPUID(ACPUID:LongWord);
|
|
|
procedure SetPriority(APriority:LongWord);
|
|
|
function GetIsShared:Boolean;
|
|
procedure SetIsShared(AValue:Boolean);
|
|
function GetIsLocal:Boolean;
|
|
procedure SetIsLocal(AValue:Boolean);
|
|
function GetIsIPI:Boolean;
|
|
procedure SetIsIPI(AValue:Boolean);
|
|
function GetIsFIQ:Boolean;
|
|
procedure SetIsFIQ(AValue:Boolean);
|
|
function GetIsChained:Boolean;
|
|
procedure SetIsChained(AValue:Boolean);
|
|
|
function GetPriorityDefault:Boolean;
|
|
procedure SetPriorityDefault(AValue:Boolean);
|
|
function GetPriorityMinimum:Boolean;
|
|
procedure SetPriorityMinimum(AValue:Boolean);
|
|
function GetPriorityMaximum:Boolean;
|
|
procedure SetPriorityMaximum(AValue:Boolean);
|
|
function GetPriorityFIQ:Boolean;
|
|
procedure SetPriorityFIQ(AValue:Boolean);
|
|
public
|
Interrupt Properties
|
property Number:LongWord read FNumber write FNumber;
|
|
property Flags:LongWord read FFlags write FFlags;
|
|
property CPUMask:LongWord read FCPUMask write FCPUMask;
|
|
property Handler:TInterruptHandler read FHandler write FHandler;
|
|
property HandlerEx:TInterruptExHandler read FHandlerEx write FHandlerEx;
|
|
property SharedHandler:TSharedInterruptHandler read FSharedHandler write FSharedHandler;
|
|
property Parameter:Pointer read FParameter write FParameter;
|
|
Internal Properties
|
property Prev:PInterruptEntry read FPrev write FPrev;
|
|
property Next:PInterruptEntry read FNext write FNext;
|
|
Additional Properties
|
property CPUID:LongWord read GetCPUID write SetCPUID;
|
|
property Priority:LongWord read FPriority write SetPriority;
|
|
|
property IsShared:Boolean read GetIsShared write SetIsShared;
|
|
property IsLocal:Boolean read GetIsLocal write SetIsLocal;
|
|
property IsIPI:Boolean read GetIsIPI write SetIsIPI;
|
|
property IsFIQ:Boolean read GetIsFIQ write SetIsFIQ;
|
|
property IsChained:Boolean read GetIsChained write SetIsChained;
|
|
|
property PriorityDefault:Boolean read GetPriorityDefault write SetPriorityDefault;
|
|
property PriorityMinimum:Boolean read GetPriorityMinimum write SetPriorityMinimum;
|
|
property PriorityMaximum:Boolean read GetPriorityMaximum write SetPriorityMaximum;
|
|
property PriorityFIQ:Boolean read GetPriorityFIQ write SetPriorityFIQ;
|
|
System call entry (SWI)
PSystemCallEntry = ^TSystemCallEntry;
TSystemCallEntry = record
Number:LongWord;
|
|
CPUID:LongWord;
|
|
Handler:procedure(Request:PSystemCallRequest);
|
|
HandlerEx:function(CPUID:LongWord; Thread:TThreadHandle; Request:PSystemCallRequest):TThreadHandle;
|
|
Page table entry
PPageTableEntry = ^TPageTableEntry;
TPageTableEntry = record
private
|
Page Table Properties
|
VirtualAddress:PtrUInt;
|
|
PhysicalAddress:PtrUInt;
|
|
Size:LongWord;
|
|
Flags:LongWord;
|
|
Platform lock
PPlatformLock = ^TPlatformLock;
TPlatformLock = record
Lock:THandle;
|
|
AcquireLock:function(Handle:THandle):LongWord;
|
|
ReleaseLock:function(Handle:THandle):LongWord;
|
|
Platform semaphore
PPlatformSemaphore = ^TPlatformSemaphore;
TPlatformSemaphore = record
Semaphore:THandle;
|
|
WaitSemaphore:function(Handle:THandle; Timeout:LongWord):LongWord;
|
|
SignalSemaphore:function(Handle:THandle):LongWord;
|
|
CPU initialization
FPU initialization
GPU initialization
MMU initialization
SMP initialization
Cache initialization
Board initialization
Memory initialization
Clock initialization
Power initialization
Mailbox initialization
TMailboxInit = procedure;
|
|
Interrupt initialization
TInterruptInit = procedure;
|
|
Peripheral initialization
TPeripheralInit = procedure;
|
|
Framebuffer initialization
TFramebufferInit = procedure;
|
|
Parse boot tags
TParseBootTags = procedure;
|
|
Parse command line
TParseCommandLine = procedure;
|
|
Parse environment
TParseEnvironment = procedure;
|
|
Options initialization
TOptionsInit = procedure;
|
|
Device tree valid
TDeviceTreeValid = function:Boolean;
|
|
Device tree get base
TDeviceTreeGetBase = function:PtrUInt;
|
|
Device tree get size
TDeviceTreeGetSize = function:LongWord;
|
|
Device tree read
TDeviceTreeRead = function(const Path,Name:String; Buffer:Pointer; var Size:LongWord):LongWord;
|
|
Device tree read 32
TDeviceTreeRead32 = function(const Path,Name:String; var Value:LongWord):LongWord;
|
|
Device tree read 64
TDeviceTreeRead64 = function(const Path,Name:String; var Value:UInt64):LongWord;
|
|
Device tree read string
TDeviceTreeReadString = function(const Path,Name:String; var Value:String):LongWord;
|
|
Inter Processor Interrupt (IPI) handler
TIPIHandler = TSharedInterruptHandler;
|
Note: When used for IPI the CPUID parameter will be the sending CPU
|
System call (SWI) handler
TSystemCallHandler = procedure(Request:PSystemCallRequest);
|
|
System call (SWI) ex handler
TSystemCallExHandler = function(CPUID:LongWord; Thread:TThreadHandle; Request:PSystemCallRequest):TThreadHandle;
|
|
Thread yield
TThreadYield = function:LongWord;
|
|
Thread wait
TThreadWait = function(List:TListHandle; Lock:TSpinHandle; Flags:LongWord):LongWord;
|
|
Thread wait ex
TThreadWaitEx = function(List:TListHandle; Lock:TSpinHandle; Flags,Timeout:LongWord):LongWord;
|
|
Thread release
TThreadRelease = function(List:TListHandle):LongWord;
|
|
Thread abandon
TThreadAbandon = function(List:TListHandle):LongWord;
|
|
Thread wake
TThreadWake = function(Thread:TThreadHandle):LongWord;
|
|
Thread ready
TThreadReady = function(Thread:TThreadHandle; Reschedule:Boolean):LongWord;
|
|
Thread timeout
TThreadTimeout = function(Thread:TThreadHandle):LongWord;
|
|
Timer event
TTimerEvent = procedure(Data:Pointer);
|
|
Worker task
TWorkerTask = procedure(Data:Pointer);
|
|
Worker callback
TWorkerCallback = procedure(Data:Pointer);
|
|
Counter callback
TCounterCallback = procedure(Data:Pointer);
|
|
GPIO callback
TGPIOCallback = procedure(Data:Pointer; Pin,Trigger:LongWord);
|
|
Boot blink
Boot output
TBootOutput = procedure(Value:LongWord);
|
|
Boot console start
TBootConsoleStart = procedure;
|
|
Boot console write
TBootConsoleWrite = procedure(const Value:String);
|
|
Boot console write ex
TBootConsoleWriteEx = procedure(const Value:String; X,Y:LongWord);
|
|
Boot console get x
TBootConsoleGetX = function:LongWord;
|
|
Boot console get y
TBootConsoleGetY = function:LongWord;
|
|
Power LED enable
TPowerLEDEnable = procedure;
|
|
Power LED on
Power LED off
TPowerLEDOff = procedure;
|
|
Activity LED enable
TActivityLEDEnable = procedure;
|
|
Activity LED on
TActivityLEDOn = procedure;
|
|
Activity LED off
TActivityLEDOff = procedure;
|
|
Counter available
TCounterAvailable = function:Boolean;
|
|
Counter read
TCounterRead = function:LongWord;
|
|
Counter read64
TCounterRead64 = function:Int64;
|
|
Counter wait
TCounterWait = function:LongWord;
|
|
Counter event
TCounterEvent = function(Callback:TCounterCallback; Data:Pointer):LongWord;
|
|
Counter cancel
TCounterCancel = function:LongWord;
|
|
Counter get rate
TCounterGetRate = function:LongWord;
|
|
Counter set rate
TCounterSetRate = function(Rate:LongWord):LongWord;
|
|
Counter get interval
TCounterGetInterval = function:LongWord;
|
|
Counter set interval
TCounterSetInterval = function(Interval:LongWord):LongWord;
|
|
Mailbox receive
TMailboxReceive = function(Mailbox,Channel:LongWord):LongWord;
|
|
Mailbox send
TMailboxSend = procedure(Mailbox,Channel,Data:LongWord);
|
|
Mailbox call
TMailboxCall = function(Mailbox,Channel,Data:LongWord; var Response:LongWord):LongWord;
|
|
Mailbox call ex
TMailboxCallEx = function(Mailbox,Channel,Data:LongWord; var Response:LongWord; Timeout:LongWord):LongWord;
|
|
Mailbox property call
TMailboxPropertyCall = function(Mailbox,Channel:LongWord; Data:Pointer; var Response:LongWord):LongWord;
|
|
Mailbox property call ex
TMailboxPropertyCallEx = function(Mailbox,Channel:LongWord; Data:Pointer; var Response:LongWord; Timeout:LongWord):LongWord;
|
|
Mailbox property tag
TMailboxPropertyTag = function(Tag:LongWord; Data:Pointer; Size:LongWord):LongWord;
|
|
Random available
TRandomAvailable = function:Boolean;
|
|
Random seed
TRandomSeed = procedure(Seed:LongWord);
|
|
Random read long int
TRandomReadLongInt = function(Limit:LongInt):LongInt;
|
|
Random read int64
TRandomReadInt64 = function(Limit:Int64):Int64;
|
|
Random read double
TRandomReadDouble = function:Double;
|
|
Watchdog available
TWatchdogAvailable = function:Boolean;
|
|
Watchdog start
TWatchdogStart = function(Milliseconds:LongWord):LongWord;
|
|
Watchdog stop
TWatchdogStop = function:LongWord;
|
|
Watchdog refresh
TWatchdogRefresh = function(Milliseconds:LongWord):LongWord;
|
|
Request IRQ
TRequestIRQ = function(CPUID,Number:LongWord; Handler:TInterruptHandler; Parameter:Pointer):LongWord;
|
|
Release IRQ
TReleaseIRQ = function(CPUID,Number:LongWord; Handler:TInterruptHandler; Parameter:Pointer):LongWord;
|
|
Request ex IRQ
TRequestExIRQ = function(CPUID,Number:LongWord; Handler:TInterruptHandler; HandlerEx:TInterruptExHandler; Parameter:Pointer):LongWord;
|
|
Release ex IRQ
TReleaseExIRQ = function(CPUID,Number:LongWord; Handler:TInterruptHandler; HandlerEx:TInterruptExHandler; Parameter:Pointer):LongWord;
|
|
Request FIQ
TRequestFIQ = function(CPUID,Number:LongWord; Handler:TInterruptHandler; Parameter:Pointer):LongWord;
|
|
Release FIQ
TReleaseFIQ = function(CPUID,Number:LongWord; Handler:TInterruptHandler; arameter:Pointer):LongWord;
|
|
Request ex FIQ
TRequestExFIQ = function(CPUID,Number:LongWord; Handler:TInterruptHandler; HandlerEx:TInterruptExHandler; Parameter:Pointer):LongWord;
|
|
Request IPI
TRequestIPI = function(CPUID,Number:LongWord; Handler:TIPIHandler; Parameter:Pointer):LongWord;
|
|
Release IPI
TReleaseIPI = function(CPUID,Number:LongWord; Handler:TIPIHandler; Parameter:Pointer):LongWord;
|
|
Register interrupt handler
TRegisterInterrupt = function(Number,Mask,Priority,Flags:LongWord; Handler:TSharedInterruptHandler; Parameter:Pointer):LongWord;
|
|
Deregister interrupt handler
TDeregisterInterrupt = function(Number,Mask,Priority,Flags:LongWord; Handler:TSharedInterruptHandler; Parameter:Pointer):LongWord;
|
|
System call
TSystemCall = procedure(Number:LongWord; Param1,Param2,Param3:PtrUInt);
|
|
Register system call
TRegisterSystemCall = function(Number:LongWord; Handler:TSystemCallHandler):LongWord;
|
|
Deregister system call
TDeregisterSystemCall = function(Number:LongWord; Handler:TSystemCallHandler):LongWord;
|
|
Register system call ex
TRegisterSystemCallEx = function(CPUID,Number:LongWord; Handler:TSystemCallHandler; HandlerEx:TSystemCallExHandler):LongWord;
|
|
Deregister system call ex
TDeregisterSystemCallEx = function(CPUID,Number:LongWord; Handler:TSystemCallHandler; HandlerEx:TSystemCallExHandler):LongWord;
|
|
Get interrupt count
TGetInterruptCount = function:LongWord;
|
|
Get interrupt start
TGetInterruptStart = function:LongWord;
|
|
Get interrupt entry
TGetInterruptEntry = function(Number,Instance:LongWord; var Interrupt:TInterruptEntry):LongWord;
|
|
Get local interrupt count
TGetLocalInterruptCount = function:LongWord;
|
|
Get local interrupt start
TGetLocalInterruptStart = function:LongWord;
|
|
Get local interrupt entry
TGetLocalInterruptEntry = function(CPUID,Number,Instance:LongWord; var Interrupt:TInterruptEntry):LongWord;
|
|
Get software interrupt count
TGetSoftwareInterruptCount = function:LongWord;
|
|
Get software interrupt start
TGetSoftwareInterruptStart = function:LongWord;
|
|
Get software interrupt entry
TGetSoftwareInterruptEntry = function(CPUID,Number,Instance:LongWord; var Interrupt:TInterruptEntry):LongWord;
|
|
Get system call count
TGetSystemCallCount = function:LongWord;
|
|
Get system call entry
TGetSystemCallEntry = function(Number:LongWord):TSystemCallEntry;
|
|
System restart
TSystemRestart = function(Delay:LongWord):LongWord;
|
|
System shutdown
TSystemShutdown = function(Delay:LongWord):LongWord;
|
|
System get uptime
TSystemGetUptime = function:Int64;
|
|
System get command line
TSystemGetCommandLine = function:String;
|
|
System get environment
TSystemGetEnvironment = function:Pointer;
|
|
CPU get arch
TCPUGetArch = function:LongWord;
|
|
CPU get type
TCPUGetType = function:LongWord;
|
|
CPU get boot
TCPUGetBoot = function:LongWord;
|
|
CPU get mask
TCPUGetMask = function:LongWord;
|
|
CPU get count
TCPUGetCount = function:LongWord;
|
|
CPU get mode
TCPUGetMode = function:LongWord;
|
|
CPU get state
TCPUGetState = function:LongWord;
|
|
CPU get group
TCPUGetGroup = function:LongWord;
|
|
CPU get current
TCPUGetCurrent = function:LongWord;
|
|
CPU get memory
TCPUGetMemory = function(var Address:PtrUInt; var Length:UInt64):LongWord;
|
|
CPU get percentage
TCPUGetPercentage = function(CPUID:LongWord):Double;
|
|
CPU get utilization
TCPUGetUtilization = function(CPUID:LongWord):LongWord;
|
|
CPU get model
TCPUGetModel = function:LongWord;
|
|
CPU get revision
TCPUGetRevision = function:LongWord;
|
|
CPU get description
TCPUGetDescription = function:String;
|
|
FPU get type
TFPUGetType = function:LongWord;
|
|
FPU get state
TFPUGetState = function:LongWord;
|
|
GPU get type
TGPUGetType = function:LongWord;
|
|
GPU get state
TGPUGetState = function:LongWord;
|
|
GPU get memory
TGPUGetMemory = function(var Address:PtrUInt; var Length:UInt64):LongWord;
|
|
L1 cache get type
TL1CacheGetType = function:LongWord;
|
|
L1 data cache get size
TL1DataCacheGetSize = function:LongWord;
|
|
L1 data cache get line size
TL1DataCacheGetLineSize = function:LongWord;
|
|
L1 instruction cache get size
TL1InstructionCacheGetSize = function:LongWord;
|
|
L1 instruction cache get line size
TL1InstructionCacheGetLineSize = function:LongWord;
|
|
L2 cache get type
TL2CacheGetType = function:LongWord;
|
|
L2 cache get size
TL2CacheGetSize = function:LongWord;
|
|
L2 cache get line size
TL2CacheGetLineSize = function:LongWord;
|
|
Board get type
TBoardGetType = function:LongWord;
|
|
Board get model
TBoardGetModel = function:LongWord;
|
|
Board get serial
TBoardGetSerial = function:Int64;
|
|
Board get revision
TBoardGetRevision = function:LongWord;
|
|
Board get MAC address
TBoardGetMACAddress = function:String;
|
|
Chip get revision
TChipGetRevision = function:LongWord;
|
|
Firmware get revision
TFirmwareGetRevision = function:LongWord;
|
|
Firmware get throttled
TFirmwareGetThrottled = function:LongWord;
|
|
Machine get type
TMachineGetType = function:LongWord;
|
|
Memory get base
TMemoryGetBase = function:PtrUInt;
|
|
Memory get size
TMemoryGetSize = function:UInt64;
|
|
Memory get page size
TMemoryGetPageSize = function:LongWord;
|
|
Memory get large page size
TMemoryGetLargePageSize = function:LongWord;
|
|
Memory get section size
TMemoryGetSectionSize = function:LongWord;
|
|
Memory get large section size
TMemoryGetLargeSectionSize = function:LongWord;
|
|
Power get wait
TPowerGetWait = function(PowerId:LongWord):LongWord;
|
|
Power get state
TPowerGetState = function(PowerId:LongWord):LongWord;
|
|
Power set state
TPowerSetState = function(PowerId,State:LongWord; Wait:Boolean):LongWord;
|
|
Clock get count
TClockGetCount = function:LongWord;
|
|
Clock get total
TClockGetTotal = function:Int64;
|
|
Clock update offset
TClockUpdateOffset = function:LongWord;
|
|
Clock get rate
TClockGetRate = function(ClockId:LongWord):LongWord;
|
|
Clock set rate
TClockSetRate = function(ClockId,Rate:LongWord; Turbo:Boolean):LongWord;
|
|
Clock get state
TClockGetState = function(ClockId:LongWord):LongWord;
|
|
Clock set state
TClockSetState = function(ClockId,State:LongWord):LongWord;
|
|
Clock get min rate
TClockGetMinRate = function(ClockId:LongWord):LongWord;
|
|
Clock get max rate
TClockGetMaxRate = function(ClockId:LongWord):LongWord;
|
|
Turbo get state
TTurboGetState = function(TurboId:LongWord):LongWord;
|
|
Turbo set state
TTurboSetState = function(TurboId,State:LongWord):LongWord;
|
|
Voltage get value
TVoltageGetValue = function (VoltageId:LongWord):LongWord;
|
|
Voltage set value
TVoltageSetValue = function (VoltageId,Value:LongWord):LongWord;
|
|
Voltage get min value
TVoltageGetMinValue = function(VoltageId:LongWord):LongWord;
|
|
Voltage get max value
TVoltageGetMaxValue = function(VoltageId:LongWord):LongWord;
|
|
Temperature get current
TTemperatureGetCurrent = function(TemperatureId:LongWord):LongWord;
|
|
Temperature get maximum
TTemperatureGetMaximum = function(TemperatureId:LongWord):LongWord;
|
|
GPU memory allocate
TGPUMemoryAllocate = function(Length,Alignment,Flags:LongWord):THandle;
|
|
GPU memory release
TGPUMemoryRelease = function(Handle:THandle):LongWord;
|
|
GPU memory lock
TGPUMemoryLock = function(Handle:THandle):LongWord;
|
|
GPU memory unlock
TGPUMemoryUnlock = function(Handle:THandle):LongWord;
|
|
GPU execute code
TGPUExecuteCode = function(Address:Pointer; R0,R1,R2,R3,R4,R5:LongWord):LongWord;
|
|
Dispmanx handle get
TDispmanxHandleGet = function(Resource:THandle):THandle;
|
|
EDID block get
TEDIDBlockGet = function(Block:LongWord; Buffer:Pointer; Length:LongWord):LongWord;
|
|
Framebuffer available
TFramebufferAvailable = function:Boolean;
|
|
Framebuffer allocate
TFramebufferAllocate = function(Alignment:LongWord; var Address,Length:LongWord):LongWord;
|
|
Framebuffer release
TFramebufferRelease = function:LongWord;
|
|
Framebuffer set state
TFramebufferSetState = function(State:LongWord):LongWord;
|
|
Framebuffer get dimensions
TFramebufferGetDimensions = function(var Width,Height,Top,Bottom,Left,Right:LongWord):LongWord;
|
|
Framebuffer get physical
TFramebufferGetPhysical = function(var Width,Height:LongWord):LongWord;
|
|
Framebuffer set physical
TFramebufferSetPhysical = function(var Width,Height:LongWord):LongWord;
|
|
Framebuffer test physical
TFramebufferTestPhysical = function(var Width,Height:LongWord):LongWord;
|
|
Framebuffer get virtual
TFramebufferGetVirtual = function(var Width,Height:LongWord):LongWord;
|
|
Framebuffer set virtual
TFramebufferSetVirtual = function(var Width,Height:LongWord):LongWord;
|
|
Framebuffer test virtual
TFramebufferTestVirtual = function(var Width,Height:LongWord):LongWord;
|
|
Framebuffer get depth
TFramebufferGetDepth = function(var Depth:LongWord):LongWord;
|
|
Framebuffer set depth
TFramebufferSetDepth = function(var Depth:LongWord):LongWord;
|
|
Framebuffer test depth
TFramebufferTestDepth = function(var Depth:LongWord):LongWord;
|
|
Framebuffer get pixel order
TFramebufferGetPixelOrder = function(var Order:LongWord):LongWord;
|
|
Framebuffer set pixel order
TFramebufferSetPixelOrder = function(var Order:LongWord):LongWord;
|
|
Framebuffer test pixel order
TFramebufferTestPixelOrder = function(var Order:LongWord):LongWord;
|
|
Framebuffer get alpha mode
TFramebufferGetAlphaMode = function(var Mode:LongWord):LongWord;
|
|
Framebuffer set alpha mode
TFramebufferSetAlphaMode = function(var Mode:LongWord):LongWord;
|
|
Framebuffer test alpha mode
TFramebufferTestAlphaMode = function(var Mode:LongWord):LongWord;
|
|
Framebuffer get pitch
TFramebufferGetPitch = function:LongWord;
|
|
Framebuffer get offset
TFramebufferGetOffset = function(var X,Y:LongWord):LongWord;
|
|
Framebuffer set offset
TFramebufferSetOffset = function(var X,Y:LongWord):LongWord;
|
|
Framebuffer test offset
TFramebufferTestOffset = function(var X,Y:LongWord):LongWord;
|
|
Framebuffer get overscan
TFramebufferGetOverscan = function(var Top,Bottom,Left,Right:LongWord):LongWord;
|
|
Framebuffer set overscan
TFramebufferSetOverscan = function(var Top,Bottom,Left,Right:LongWord):LongWord;
|
|
Framebuffer test overscan
TFramebufferTestOverscan = function(var Top,Bottom,Left,Right:LongWord):LongWord;
|
|
Framebuffer get palette
TFramebufferGetPalette = function(Buffer:Pointer; Length:LongWord):LongWord;
|
|
Framebuffer set palette
TFramebufferSetPalette = function(Start,Count:LongWord; Buffer:Pointer; Length:LongWord):LongWord;
|
|
Framebuffer test palette
TFramebufferTestPalette = function(Start,Count:LongWord; Buffer:Pointer; Length:LongWord):LongWord;
|
|
Framebuffer get layer
TFramebufferGetLayer = function(var Layer:LongInt):LongWord;
|
|
Framebuffer set layer
TFramebufferSetLayer = function(var Layer:LongInt):LongWord;
|
|
Framebuffer test layer
TFramebufferTestLayer = function(var Layer:LongInt):LongWord;
|
|
Framebuffer test vsync
TFramebufferTestVsync = function:LongWord;
|
|
Framebuffer set vsync
TFramebufferSetVsync = function:LongWord;
|
|
Framebuffer set backlight
TFramebufferSetBacklight = function(Brightness:LongWord):LongWord;
|
|
Framebuffer get num displays
TFramebufferGetNumDisplays = function(var NumDisplays:LongWord):LongWord;
|
|
Framebuffer get display id
TFramebufferGetDisplayId = function(DisplayNum:LongWord):LongWord;
|
|
Framebuffer set display num
TFramebufferSetDisplayNum = function(DisplayNum:LongWord):LongWord;
|
|
Framebuffer get display settings
TFramebufferGetDisplaySettings = function(DisplayNum:LongWord; var DisplaySettings:TDisplaySettings):LongWord;
|
|
Framebuffer display id to name
TFramebufferDisplayIdToName = function(DisplayId:LongWord):String;
|
|
Touch get buffer
TTouchGetBuffer = function(var Address:PtrUInt):LongWord;
|
|
Touch set buffer
TTouchSetBuffer = function(Address:PtrUInt):LongWord;
|
|
Cursor set default
TCursorSetDefault = function:LongWord;
|
|
Cursor set info
TCursorSetInfo = function(Width,Height,HotspotX,HotspotY:LongWord; Pixels:Pointer; Length:LongWord):LongWord;
|
|
Cursor set state
TCursorSetState = function(Enabled:Boolean; X,Y:LongWord; Relative:Boolean):LongWord;
|
|
DMA available
TDMAAvailable = function:Boolean;
|
|
DMA transfer
TDMATransfer = function(Data:PDMAData; Direction,Peripheral:LongWord):LongWord;
|
|
DMA fill memory
TDMAFillMemory = function(Dest:Pointer; Size:LongWord; Value:Byte):LongWord;
|
|
DMA copy memory
TDMACopyMemory = function(Source,Dest:Pointer; Size:LongWord):LongWord;
|
|
DMA read peripheral
TDMAReadPeripheral = function(Address,Dest:Pointer; Size,Peripheral:LongWord):LongWord;
|
|
DMA write peripheral
TDMAWritePeripheral = function(Source,Address:Pointer; Size,Peripheral:LongWord):LongWord;
|
|
DMA allocate buffer
TDMAAllocateBuffer = function(Size:LongWord):Pointer;
|
|
DMA allocate buffer ex
TDMAAllocateBufferEx = function(var Size:LongWord):Pointer;
|
|
DMA release buffer
TDMAReleaseBuffer = function(Buffer:Pointer):LongWord;
|
|
DMA get channels
TDMAGetChannels = function:LongWord;
|
|
GPIO available
TGPIOAvailable = function:Boolean;
|
|
GPIO read
TGPIORead = function(Reg:LongWord):LongWord;
|
|
GPIO write
TGPIOWrite = procedure(Reg,Value:LongWord);
|
|
GPIO input get
TGPIOInputGet = function(Pin:LongWord):LongWord;
|
|
GPIO input wait
TGPIOInputWait = function(Pin,Trigger,Timeout:LongWord):LongWord;
|
|
GPIO input event
TGPIOInputEvent = function(Pin,Trigger,Timeout:LongWord; Callback:TGPIOCallback; Data:Pointer):LongWord;
|
|
GPIO output set
TGPIOOutputSet = function(Pin,Level:LongWord):LongWord;
|
|
GPIO pull get
TGPIOPullGet = function(Pin:LongWord):LongWord;
|
|
GPIO pull select
TGPIOPullSelect = function(Pin,Mode:LongWord):LongWord;
|
|
GPIO function get
TGPIOFunctionGet = function(Pin:LongWord):LongWord;
|
|
GPIO function select
TGPIOFunctionSelect = function(Pin,Mode:LongWord):LongWord;
|
|
Virtual GPIO input get
TVirtualGPIOInputGet = function(Pin:LongWord):LongWord;
|
|
Virtual GPIO output set
TVirtualGPIOOutputSet = function(Pin,Level:LongWord):LongWord;
|
|
Virtual GPIO function get
TVirtualGPIOFunctionGet = function(Pin:LongWord):LongWord;
|
|
Virtual GPIO function select
TVirtualGPIOFunctionSelect = function(Pin,Mode:LongWord):LongWord;
|
|
SPI available
TSPIAvailable = function:Boolean;
|
|
SPI start
TSPIStart = function(Mode,ClockRate,ClockPhase,ClockPolarity:LongWord):LongWord;
|
|
SPI stop
TSPIStop = function:LongWord;
|
|
SPI read
TSPIRead = function(ChipSelect:Word; Dest:Pointer; Size:LongWord; var Count:LongWord):LongWord;
|
|
SPI write
TSPIWrite = function(ChipSelect:Word; Source:Pointer; Size:LongWord; var Count:LongWord):LongWord;
|
|
SPI write read
TSPIWriteRead = function(ChipSelect:Word; Source,Dest:Pointer; Size:LongWord; var Count:LongWord):LongWord;
|
|
SPI get mode
TSPIGetMode = function:LongWord;
|
|
SPI set mode
TSPISetMode = function(Mode:LongWord):LongWord;
|
|
SPI get clock rate
TSPIGetClockRate = function(ChipSelect:Word):LongWord;
|
|
SPI set clock rate
TSPISetClockRate = function(ChipSelect:Word; ClockRate:LongWord):LongWord;
|
|
SPI get clock phase
TSPIGetClockPhase = function:LongWord;
|
|
SPI set clock phase
TSPISetClockPhase = function(ClockPhase:LongWord):LongWord;
|
|
SPI get clock polarity
TSPIGetClockPolarity = function:LongWord;
|
|
SPI set clock polarity
TSPISetClockPolarity = function(ClockPolarity:LongWord):LongWord;
|
|
SPI get select polarity
TSPIGetSelectPolarity = function(ChipSelect:Word):LongWord;
|
|
SPI set select polarity
TSPISetSelectPolarity = function(ChipSelect:Word; SelectPolarity:LongWord):LongWord;
|
|
SPI get description
TSPIGetDescription = function(Id:LongWord):String;
|
|
I2C available
TI2CAvailable = function:Boolean;
|
|
I2C start
TI2CStart = function(Rate:LongWord):LongWord;
|
|
I2C stop
TI2CStop = function:LongWord;
|
|
I2C read
TI2CRead = function(Address:Word; Buffer:Pointer; Size:LongWord; var Count:LongWord):LongWord;
|
|
I2C write
TI2CWrite = function(Address:Word; Buffer:Pointer; Size:LongWord; var Count:LongWord):LongWord;
|
|
I2C write read
TI2CWriteRead = function(Address:Word; Initial:Pointer; Len:LongWord; Data:Pointer; Size:LongWord; var Count:LongWord):LongWord;
|
|
I2C write write
TI2CWriteWrite = function(Address:Word; Initial:Pointer; Len:LongWord; Data:Pointer; Size:LongWord; var Count:LongWord):LongWord;
|
|
I2C get rate
TI2CGetRate = function:LongWord;
|
|
I2C set rate
TI2CSetRate = function(Rate:LongWord):LongWord;
|
|
I2C get address
TI2CGetAddress = function:Word;
|
|
I2C set address
TI2CSetAddress = function(Address:Word):LongWord;
|
|
I2C get description
TI2CGetDescription = function(Id:LongWord):String;
|
|
I2C slave get description
TI2CSlaveGetDescription = function(Id:LongWord):String;
|
|
PWM available
TPWMAvailable = function:Boolean;
|
|
PWM start
TPWMStart = function:LongWord;
|
|
PWM stop
TPWMStop = function:LongWord;
|
|
PWM write
TPWMWrite = function(Value:LongWord):LongWord;
|
|
PWM set mode
TPWMSetMode = function(Mode:LongWord):LongWord;
|
|
PWM set range
TPWMSetRange = function(Range:LongWord):LongWord;
|
|
PWM set frequency
TPWMSetFrequency = function(Frequency:LongWord):LongWord;
|
|
PWM configure
TPWMConfigure = function(DutyNS,PeriodNS:LongWord):LongWord;
|
|
PWM get description
TPWMGetDescription = function(Id,Channel:LongWord):String;
|
|
RTC available
TRTCAvailable = function:Boolean;
|
|
RTC get time
TRTCGetTime = function:Int64;
|
|
RTC set time
TRTCSetTime = function(const Time:Int64):Int64;
|
|
UART get description
TUARTGetDescription = function(Id:LongWord):String;
|
|
Serial available
TSerialAvailable = function:Boolean;
|
|
Serial open
TSerialOpen = function(BaudRate,DataBits,StopBits,Parity,FlowControl,ReceiveDepth,TransmitDepth:LongWord):LongWord;
|
|
Serial close
TSerialClose = function:LongWord;
|
|
Serial read
TSerialRead = function(Buffer:Pointer; Size:LongWord; var Count:LongWord):LongWord;
|
|
Serial write
TSerialWrite = function(Buffer:Pointer; Size:LongWord; var Count:LongWord):LongWord;
|
|
Peripheral get base
TPeripheralGetBase = function:PtrUInt;
|
|
Peripheral get size
TPeripheralGetSize = function:LongWord;
|
|
Peripheral read
TPeripheralRead = function(Base,Reg:LongWord):LongWord;
|
|
Peripheral write
TPeripheralWrite = procedure(Base,Reg,Value:LongWord);
|
|
Local Peripheral get base
TLocalPeripheralGetBase = function:PtrUInt;
|
|
Local peripheral get size
TLocalPeripheralGetSize = function:LongWord;
|
|
Get SP
TGetSP = function:PtrUInt;
|
|
Get PC
TGetPC = function:PtrUInt;
|
|
Get IRQ
TGetIRQ = function:Boolean;
|
|
Enable IRQ
Disable IRQ
Save IRQ
TSaveIRQ = function:TIRQMask;
|
|
Restore IRQ
TRestoreIRQ = function(IRQMask:TIRQMask):TIRQMask;
|
|
Get FIQ
TGetFIQ = function:Boolean;
|
|
Enable FIQ
Disable FIQ
Save FIQ
TSaveFIQ = function:TFIQMask;
|
|
Restore FIQ
TRestoreFIQ = function(FIQMask:TFIQMask):TFIQMask;
|
|
Enable IRQ/FIQ
TEnableIRQFIQ = procedure;
|
|
Disable IRQ/FIQ
TDisableIRQFIQ = procedure;
|
|
Save IRQ/FIQ
TSaveIRQFIQ = function:TIRQFIQMask;
|
|
Restore IRQ/FIQ
TRestoreIRQFIQ = function(IRQFIQMask:TIRQFIQMask):TIRQFIQMask;
|
|
Get abort
TGetAbort = function:Boolean;
|
|
Enable abort
TEnableAbort = procedure;
|
|
Disable abort
TDisableAbort = procedure;
|
|
Save abort
TSaveAbort = function:TAbortMask;
|
|
Restore abort
TRestoreAbort = function(AbortMask:TAbortMask):TAbortMask;
|
|
Halt
Pause
Halt thread
THaltThread = function(ExitCode:LongWord):LongWord;
|
|
Send event
Wait for event
TWaitForEvent = procedure;
|
|
Wait for interrupt
TWaitForInterrupt = procedure;
|
|
Read memory barrier
TReadMemoryBarrier = procedure;
|
|
Write memory barrier
TWriteMemoryBarrier = procedure;
|
|
Data memory barrier
TDataMemoryBarrier = procedure;
|
|
Data synchronization barrier
TDataSynchronizationBarrier = procedure;
|
|
Instruction memory barrier
TInstructionMemoryBarrier = procedure;
|
|
Invalidate TLB
TInvalidateTLB = procedure;
|
|
Invalidate data TLB
TInvalidateDataTLB = procedure;
|
|
Invalidate instruction TLB
TInvalidateInstructionTLB = procedure;
|
|
Invalidate cache
TInvalidateCache = procedure;
|
|
Clean data cache
TCleanDataCache = procedure;
|
|
Invalidate data cache
TInvalidateDataCache = procedure;
|
|
Clean and invalidate data cache
TCleanAndInvalidateDataCache = procedure;
|
|
Invalidate instruction cache
TInvalidateInstructionCache = procedure;
|
|
Clean data cache range
TCleanDataCacheRange = procedure(Address:PtrUInt; Size:LongWord);
|
|
Invaliate data cache range
TInvalidateDataCacheRange = procedure(Address:PtrUInt; Size:LongWord);
|
|
Clean and invalidate data cache range
TCleanAndInvalidateDataCacheRange = procedure(Address:PtrUInt; Size:LongWord);
|
|
Invalidate instruction cache range
TInvalidateInstructionCacheRange = procedure(Address:PtrUInt; Size:LongWord);
|
|
Flush prefetch buffer
TFlushPrefetchBuffer = procedure;
|
|
Flush branch target cache
TFlushBranchTargetCache = procedure;
|
|
Context switch
TContextSwitch = procedure(OldStack,NewStack:Pointer; NewThread:TThreadHandle);
|
|
Context switch IRQ
TContextSwitchIRQ = procedure(OldStack,NewStack:Pointer; NewThread:TThreadHandle);
|
|
Context switch FIQ
TContextSwitchFIQ = procedure(OldStack,NewStack:Pointer; NewThread:TThreadHandle);
|
|
Context switch SWI
TContextSwitchSWI = procedure(OldStack,NewStack:Pointer; NewThread:TThreadHandle);
|
|
Interlocked or
TInterlockedOr = function(var Target:LongInt; Value:LongInt):LongInt;
|
|
Interlocked x or
TInterlockedXor = function(var Target:LongInt; Value:LongInt):LongInt;
|
|
Interlocked and
TInterlockedAnd = function(var Target:LongInt; Value:LongInt):LongInt;
|
|
Interlocked decrement
TInterlockedDecrement = function(var Target:LongInt):LongInt;
|
|
Interlocked increment
TInterlockedIncrement = function(var Target:LongInt):LongInt;
|
|
Interlocked exchange
TInterlockedExchange = function(var Target:LongInt; Source:LongInt):LongInt;
|
|
Interlocked add exchange
TInterlockedAddExchange = function(var Target:LongInt; Source:LongInt):LongInt;
|
|
Interlocked compare exchange
TInterlockedCompareExchange = function(var Target:LongInt; Source,Compare:LongInt):LongInt;
|
|
Page table get levels
TPageTableGetLevels = function:LongWord;
|
|
Page directory get base
TPageDirectoryGetBase = function:PtrUInt;
|
|
Page directory get size
TPageDirectoryGetSize = function:LongWord;
|
|
Page table get base
TPageTableGetBase = function:PtrUInt;
|
|
Page table get size
TPageTableGetSize = function:LongWord;
|
|
Page table get entry
TPageTableGetEntry = procedure(Address:PtrUInt; var Entry:TPageTableEntry);
|
|
Page table set entry
TPageTableSetEntry = function(const Entry:TPageTableEntry):LongWord;
|
|
Page table get page size
TPageTableGetPageSize = function(Address:PtrUInt):LongWord;
|
|
Page table get page flags
TPageTableGetPageFlags = function(Address:PtrUInt):LongWord;
|
|
Page table get page physical
TPageTableGetPagePhysical = function(Address:PtrUInt):PtrUInt;
|
|
Page tables get address
TPageTablesGetAddress = function:PtrUInt;
|
|
Page tables get length
TPageTablesGetLength = function:LongWord;
|
|
Page tables get count
TPageTablesGetCount = function:LongWord;
|
|
Page tables get shift
TPageTablesGetShift = function:LongWord;
|
|
Page tables get next
TPageTablesGetNext = function:PtrUInt;
|
|
Page tables get used
TPageTablesGetUsed = function:LongWord;
|
|
Page tables get free
TPageTablesGetFree = function:LongWord;
|
|
Vector table get base
TVectorTableGetBase = function:PtrUInt;
|
|
Vector table get size
TVectorTableGetSize = function:LongWord;
|
|
Vector table get count
TVectorTableGetCount = function:LongWord;
|
|
Vector table get entry
TVectorTableGetEntry = function(Number:LongWord):PtrUInt;
|
|
Vector table set entry
TVectorTableSetEntry = function(Number:LongWord; Address:PtrUInt):LongWord;
|
|
First bit set
TFirstBitSet = function(Value:LongWord):LongWord;
|
|
Count leading zeros
TCountLeadingZeros = function(Value:LongWord):LongWord;
|
|
Text IO write char
TTextIOWriteChar = function(ACh:Char; AUserData:Pointer):Boolean;
|
|
Text IO read char
TTextIOReadChar = function(var ACh:Char; AUserData:Pointer):Boolean;
|
|
Text IO write buffer
TTextIOWriteBuffer = function(ABuffer:PChar; ACount:LongInt; AUserData:Pointer):LongInt;
|
|
Console get key
TConsoleGetKey = function(var ACh:Char; AUserData:Pointer):Boolean;
|
|
Console peek key
TConsolePeekKey = function(var ACh:Char; AUserData:Pointer):Boolean;
|
|
Console write char
TConsoleWriteChar = function(ACh:Char; AUserData:Pointer):Boolean;
|
|
Console read char
TConsoleReadChar = function(var ACh:Char; AUserData:Pointer):Boolean;
|
|
Console read wide char
TConsoleReadWideChar = function(var ACh:WideChar; AUserData:Pointer):Boolean;
|
|
Console hide mouse
TConsoleHideMouse = function(AUserData:Pointer):Boolean;
|
|
Console show mouse
TConsoleShowMouse = function(X,Y:LongWord; AUserData:Pointer):Boolean;
|
|
Console read mouse
TConsoleReadMouse = function(var X,Y,Buttons:LongWord; AUserData:Pointer):Boolean;
|
|
Code page to wide char
TCodePageToWideChar = function(Ch:Char):WideChar;
|
|
Wide char to code page
TWideCharToCodePage = function(Ch:WideChar):Char;
|
|
Host get name
THostGetName = function:String;
|
|
Host set name
THostSetName = function(const AName:String):Boolean;
|
|
Host get domain
THostGetDomain = function:String;
|
|
Host set domain
THostSetDomain = function(const ADomain:String):Boolean;
|
|
Module load
TModuleLoad = function(const AName:String):THandle;
|
|
Module unload
TModuleUnload = function(AHandle:THandle):Boolean;
|
|
Module get name
TModuleGetName = function(AHandle:THandle):String;
|
|
Symbol add
TSymbolAdd = function(AHandle:THandle; const AName:String; AAddress:PtrUInt):Boolean;
|
|
Symbol remove
TSymbolRemove = function(AHandle:THandle; const AName:String):Boolean;
|
|
Symbol get address
TSymbolGetAddress = function(AHandle:THandle; const AName:String):PtrUInt;
|
|
Logging output
TLoggingOutput = procedure(const AText:String);
|
|
Logging output ex
TLoggingOutputEx = procedure(AFacility,ASeverity:LongWord; const ATag,AContent:String);
|
|
Environment get
TEnvironmentGet = function(const AName:String):String;
|
|
Environment set
TEnvironmentSet = function(const AName,AValue:String):LongWord;
|
|
Environment count
TEnvironmentCount = function(AReset:Boolean):LongWord;
|
|
Environment index
TEnvironmentIndex = function(const AName:String):LongWord;
|
|
Environment string
TEnvironmentString = function(AIndex:LongWord):String;
|
|
Text IO data
PTextIOData = ^TTextIOData;
TTextIOData = record
WriteChar:TTextIOWriteChar;
|
|
ReadChar:TTextIOReadChar;
|
|
UserData:Pointer;
|
|
Platform timer
PPlatformTimer = ^TPlatformTimer;
TPlatformTimer = record
Data:Pointer;
|
|
CreateTimer:function(Interval:LongWord; Enabled,Reschedule:Boolean; Event:TTimerEvent; Data:Pointer):TTimerHandle;
|
|
Platform worker
PPlatformWorker = ^TPlatformWorker;
TPlatformWorker = record
Data:Pointer;
|
|
ScheduleWorker:function(Interval:LongWord; Task:TWorkerTask; Data:Pointer; Callback:TWorkerCallback):LongWord;
|
|
Class definitions
Platform specific classes
Public variables
Platform logging
PLATFORM_DEFAULT_LOG_LEVEL:LongWord = PLATFORM_LOG_LEVEL_DEBUG;
|
Minimum level for Platform messages. Only messages with level greater than or equal to this will be printed.
|
PLATFORM_LOG_ENABLED:Boolean;
|
|
IRQ logging
IRQ_DEFAULT_LOG_LEVEL:LongWord = IRQ_LOG_LEVEL_INFO;
|
Minimum level for IRQ messages. Only messages with level greater than or equal to this will be printed.
|
FIQ logging
FIQ_DEFAULT_LOG_LEVEL:LongWord = FIQ_LOG_LEVEL_INFO;
|
Minimum level for FIQ messages. Only messages with level greater than or equal to this will be printed.
|
SWI logging
SWI_DEFAULT_LOG_LEVEL:LongWord = SWI_LOG_LEVEL_INFO;
|
Minimum level for SWI messages. Only messages with level greater than or equal to this will be printed.
|
Platform specific variables
PlatformInitialized:Boolean;
|
|
CacheInitialized:Boolean;
|
|
BoardInitialized:Boolean;
|
|
MemoryInitialized:Boolean;
|
|
ClockInitialized:Boolean;
|
|
PowerInitialized:Boolean;
|
|
MailboxInitialized:Boolean;
|
|
InterruptsInitialized:Boolean;
|
|
PeripheralsInitialized:Boolean;
|
|
ParseBootTagsCompleted:Boolean;
|
|
ParseCommandLineCompleted:Boolean;
|
|
ParseEnvironmentCompleted:Boolean;
|
|
OptionsInitCompleted:Boolean;
|
|
Lock variables
MailboxLock:TPlatformLock;
|
|
ShutdownLock:TPlatformLock;
|
|
InterruptLock:TPlatformLock;
|
|
PageTableLock:TPlatformLock;
|
|
VectorTableLock:TPlatformLock;
|
|
HandleNameLock:TPlatformLock;
|
|
HandleTableLock:TPlatformLock;
|
|
ShutdownTableLock:TPlatformLock;
|
|
UtilityLock:TPlatformLock;
|
|
EnvironmentLock:TPlatformLock;
|
|
Semaphore variables
ShutdownSemaphore:TPlatformSemaphore;
|
|
Worker variables
ShutdownWorker:TPlatformWorker;
|
|
Clock variables
ClockBase:Int64 = TIME_TICKS_TO_1899;
|
The system time as of the last setting of the clock
|
ClockLast:LongWord;
|
The timer value of the last clock tick
|
ClockTicks:LongWord;
|
Current number of clock ticks (When this reaches CLOCK_TICKS_PER_SECOND then ClockSeconds is incremented and this is reset to zero)
|
ClockSeconds:LongWord;
|
Current number of clock seconds (This forms the system clock)
|
ClockRTCInvalid:LongBool;
|
True if available time from RTC is invalid
|
Utilization variables
UtilizationLast:array of LongWord;
|
The per CPU utilization for the last second (Allocated by scheduler initialization)
|
UtilizationCurrent:array of LongWord;
|
The per CPU utilization for the current second (Updated by Idle thread and reset by Scheduler interrupt) (Allocated by scheduler initialization)
|
Initialization handlers
CacheInitHandler:TCacheInit;
|
|
BoardInitHandler:TBoardInit;
|
|
MemoryInitHandler:TMemoryInit;
|
|
ClockInitHandler:TClockInit;
|
|
PowerInitHandler:TPowerInit;
|
|
MailboxInitHandler:TMailboxInit;
|
|
InterruptInitHandler:TInterruptInit;
|
|
PeripheralInitHandler:TPeripheralInit;
|
|
ParseBootTagsHandler:TParseBootTags;
|
|
ParseCommandLineHandler:TParseCommandLine;
|
|
ParseEnvironmentHandler:TParseEnvironment;
|
|
OptionsInitHandler:TOptionsInit;
|
|
Device tree handlers
DeviceTreeValidHandler:TDeviceTreeValid;
|
|
DeviceTreeGetBaseHandler:TDeviceTreeGetBase;
|
|
DeviceTreeGetSizeHandler:TDeviceTreeGetSize;
|
|
DeviceTreeReadHandler:TDeviceTreeRead;
|
|
DeviceTreeRead32Handler:TDeviceTreeRead32;
|
|
DeviceTreeRead64Handler:TDeviceTreeRead64;
|
|
DeviceTreeReadStringHandler:TDeviceTreeReadString;
|
|
Blink/Output handlers
BootBlinkHandler:TBootBlink;
|
|
BootOutputHandler:TBootOutput;
|
|
BootConsoleStartHandler:TBootConsoleStart;
|
|
BootConsoleWriteHandler:TBootConsoleWrite;
|
|
BootConsoleWriteExHandler:TBootConsoleWriteEx;
|
|
BootConsoleGetXHandler:TBootConsoleGetX;
|
|
BootConsoleGetYHandler:TBootConsoleGetY;
|
|
LED handlers
PowerLEDEnableHandler:TPowerLEDEnable;
|
|
PowerLEDOnHandler:TPowerLEDOn;
|
|
PowerLEDOffHandler:TPowerLEDOff;
|
|
ActivityLEDEnableHandler:TActivityLEDEnable;
|
|
ActivityLEDOnHandler:TActivityLEDOn;
|
|
ActivityLEDOffHandler:TActivityLEDOff;
|
|
Counter handlers
CounterAvailableHandler:TCounterAvailable;
|
|
CounterReadHandler:TCounterRead;
|
|
CounterRead64Handler:TCounterRead64;
|
|
CounterWaitHandler:TCounterWait;
|
|
CounterEventHandler:TCounterEvent;
|
|
CounterCancelHandler:TCounterCancel;
|
|
CounterGetRateHandler:TCounterGetRate;
|
|
CounterSetRateHandler:TCounterSetRate;
|
|
CounterGetIntervalHandler:TCounterGetInterval;
|
|
CounterSetIntervalHandler:TCounterSetInterval;
|
|
Mailbox handlers
MailboxReceiveHandler:TMailboxReceive;
|
|
MailboxSendHandler:TMailboxSend;
|
|
MailboxCallHandler:TMailboxCall;
|
|
MailboxCallExHandler:TMailboxCallEx;
|
|
MailboxPropertyCallHandler:TMailboxPropertyCall;
|
|
MailboxPropertyCallExHandler:TMailboxPropertyCallEx;
|
|
MailboxPropertyTagHandler:TMailboxPropertyTag;
|
|
Random handlers
RandomAvailableHandler:TRandomAvailable;
|
|
RandomSeedHandler:TRandomSeed;
|
|
RandomReadLongIntHandler:TRandomReadLongInt;
|
|
RandomReadInt64Handler:TRandomReadInt64;
|
|
RandomReadExtendedHandler:TRandomReadExtended;
|
|
Watchdog handlers
WatchdogAvailableHandler:TWatchdogAvailable;
|
|
WatchdogStartHandler:TWatchdogStart;
|
|
WatchdogStopHandler:TWatchdogStop;
|
|
WatchdogRefreshHandler:TWatchdogRefresh;
|
|
Interrupt request (IRQ) handlers
RequestIRQHandler:TRequestIRQ;
|
|
ReleaseIRQHandler:TReleaseIRQ;
|
|
RequestExIRQHandler:TRequestExIRQ;
|
|
ReleaseExIRQHandler:TReleaseExIRQ;
|
|
Fast interrupt request (FIQ) handlers
RequestFIQHandler:TRequestFIQ;
|
|
ReleaseFIQHandler:TReleaseFIQ;
|
|
RequestExFIQHandler:TRequestExFIQ;
|
|
ReleaseExFIQHandler:TReleaseExFIQ;
|
|
Inter processor interrupt (IPI) handlers
RequestIPIHandler:TRequestIPI;
|
|
ReleaseIPIHandler:TReleaseIPI;
|
|
Interrupt register/deregister handlers
RegisterInterruptHandler:TRegisterInterrupt;
|
|
DeregisterInterruptHandler:TDeregisterInterrupt;
|
|
System call (SWI) handlers
SystemCallHandler:TSystemCall;
|
|
RegisterSystemCallHandler:TRegisterSystemCall;
|
|
DeregisterSystemCallHandler:TDeregisterSystemCall;
|
|
RegisterSystemCallExHandler:TRegisterSystemCallEx;
|
|
DeregisterSystemCallExHandler:TDeregisterSystemCallEx;
|
|
Interrupt entry handlers
GetInterruptCountHandler:TGetInterruptCount;
|
|
GetInterruptStartHandler:TGetInterruptStart;
|
|
GetInterruptEntryHandler:TGetInterruptEntry;
|
|
Local interrupt entry handlers
GetLocalInterruptCountHandler:TGetLocalInterruptCount;
|
|
GetLocalInterruptStartHandler:TGetLocalInterruptStart;
|
|
GetLocalInterruptEntryHandler:TGetLocalInterruptEntry;
|
|
Software interrupt entry (IPI) handlers
GetSoftwareInterruptCountHandler:TGetSoftwareInterruptCount;
|
|
GetSoftwareInterruptStartHandler:TGetSoftwareInterruptStart;
|
|
GetSoftwareInterruptEntryHandler:TGetSoftwareInterruptEntry;
|
|
System call entry (SWI) handlers
GetSystemCallCountHandler:TGetSystemCallCount;
|
|
GetSystemCallEntryHandler:TGetSystemCallEntry;
|
|
System handlers
SystemRestartHandler:TSystemRestart;
|
|
SystemShutdownHandler:TSystemShutdown;
|
|
SystemGetUptimeHandler:TSystemGetUptime;
|
|
SystemGetCommandLineHandler:TSystemGetCommandLine;
|
|
SystemGetEnvironmentHandler:TSystemGetEnvironment;
|
|
CPU handlers
CPUGetArchHandler:TCPUGetArch;
|
|
CPUGetTypeHandler:TCPUGetType;
|
|
CPUGetBootHandler:TCPUGetBoot;
|
|
CPUGetMaskHandler:TCPUGetMask;
|
|
CPUGetCountHandler:TCPUGetCount;
|
|
CPUGetModeHandler:TCPUGetMode;
|
|
CPUGetStateHandler:TCPUGetState;
|
|
CPUGetGroupHandler:TCPUGetGroup;
|
|
CPUGetCurrentHandler:TCPUGetCurrent;
|
|
CPUGetMemoryHandler:TCPUGetMemory;
|
|
CPUGetPercentageHandler:TCPUGetPercentage;
|
|
CPUGetUtilizationHandler:TCPUGetUtilization;
|
|
CPUGetModelHandler:TCPUGetModel;
|
|
CPUGetRevisionHandler:TCPUGetRevision;
|
|
CPUGetDescriptionHandler:TCPUGetDescription;
|
|
FPU handlers
FPUGetTypeHandler:TFPUGetType;
|
|
FPUGetStateHandler:TFPUGetState;
|
|
GPU handlers
GPUGetTypeHandler:TGPUGetType;
|
|
GPUGetStateHandler:TGPUGetState;
|
|
GPUGetMemoryHandler:TGPUGetMemory;
|
|
Cache handlers
L1CacheGetTypeHandler:TL1CacheGetType;
|
|
L1DataCacheGetSizeHandler:TL1DataCacheGetSize;
|
|
L1DataCacheGetLineSizeHandler:TL1DataCacheGetLineSize;
|
|
L1InstructionCacheGetSizeHandler:TL1InstructionCacheGetSize;
|
|
L1InstructionCacheGetLineSizeHandler:TL1InstructionCacheGetLineSize;
|
|
L2CacheGetTypeHandler:TL2CacheGetType;
|
|
L2CacheGetSizeHandler:TL2CacheGetSize;
|
|
L2CacheGetLineSizeHandler:TL2CacheGetLineSize;
|
|
Board handlers
BoardGetTypeHandler:TBoardGetType;
|
|
BoardGetModelHandler:TBoardGetModel;
|
|
BoardGetSerialHandler:TBoardGetSerial;
|
|
BoardGetRevisionHandler:TBoardGetRevision;
|
|
BoardGetMACAddressHandler:TBoardGetMACAddress;
|
|
Chip handlers
ChipGetRevisionHandler:TChipGetRevision;
|
|
Firmware handlers
FirmwareGetRevisionHandler:TFirmwareGetRevision;
|
|
FirmwareGetThrottledHandler:TFirmwareGetThrottled;
|
|
Machine handlers
MachineGetTypeHandler:TMachineGetType;
|
|
Memory handlers
MemoryGetBaseHandler:TMemoryGetBase;
|
|
MemoryGetSizeHandler:TMemoryGetSize;
|
|
MemoryGetPageSizeHandler:TMemoryGetPageSize;
|
|
MemoryGetLargePageSizeHandler:TMemoryGetLargePageSize;
|
|
MemoryGetSectionSizeHandler:TMemoryGetSectionSize;
|
|
MemoryGetLargeSectionSizeHandler:TMemoryGetLargeSectionSize;
|
|
Power handlers
PowerGetWaitHandler:TPowerGetWait;
|
|
PowerGetStateHandler:TPowerGetState;
|
|
PowerSetStateHandler:TPowerSetState;
|
|
Clock handlers
ClockGetCountHandler:TClockGetCount;
|
|
ClockGetTotalHandler:TClockGetTotal;
|
|
ClockUpdateOffsetHandler:TClockUpdateOffset;
|
|
ClockGetRateHandler:TClockGetRate;
|
|
ClockSetRateHandler:TClockSetRate;
|
|
ClockGetStateHandler:TClockGetState;
|
|
ClockSetStateHandler:TClockSetState;
|
|
ClockGetMinRateHandler:TClockGetMinRate;
|
|
ClockGetMaxRateHandler:TClockGetMaxRate;
|
|
Turbo handlers
TurboGetStateHandler:TTurboGetState;
|
|
TurboSetStateHandler:TTurboSetState;
|
|
Voltage handlers
VoltageGetValueHandler:TVoltageGetValue;
|
|
VoltageSetValueHandler:TVoltageSetValue;
|
|
VoltageGetMinValueHandler:TVoltageGetMinValue;
|
|
VoltageGetMaxValueHandler:TVoltageGetMaxValue;
|
|
Temperature handlers
TemperatureGetCurrentHandler:TTemperatureGetCurrent;
|
|
TemperatureGetMaximumHandler:TTemperatureGetMaximum;
|
|
GPU memory handlers
GPUMemoryAllocateHandler:TGPUMemoryAllocate;
|
|
GPUMemoryReleaseHandler:TGPUMemoryRelease;
|
|
GPUMemoryLockHandler:TGPUMemoryLock;
|
|
GPUMemoryUnlockHandler:TGPUMemoryUnlock;
|
|
GPU miscellaneous handlers
GPUExecuteCodeHandler:TGPUExecuteCode;
|
|
DispmanxHandleGetHandler:TDispmanxHandleGet;
|
|
EDIDBlockGetHandler:TEDIDBlockGet;
|
|
Framebuffer handlers
FramebufferAvailableHandler:TFramebufferAvailable;
|
|
FramebufferAllocateHandler:TFramebufferAllocate;
|
|
FramebufferReleaseHandler:TFramebufferRelease;
|
|
FramebufferSetStateHandler:TFramebufferSetState;
|
|
FramebufferGetDimensionsHandler:TFramebufferGetDimensions;
|
|
FramebufferGetPhysicalHandler:TFramebufferGetPhysical;
|
|
FramebufferSetPhysicalHandler:TFramebufferSetPhysical;
|
|
FramebufferTestPhysicalHandler:TFramebufferTestPhysical;
|
|
FramebufferGetVirtualHandler:TFramebufferGetVirtual;
|
|
FramebufferSetVirtualHandler:TFramebufferSetVirtual;
|
|
FramebufferTestVirtualHandler:TFramebufferTestVirtual;
|
|
FramebufferGetDepthHandler:TFramebufferGetDepth;
|
|
FramebufferSetDepthHandler:TFramebufferSetDepth;
|
|
FramebufferTestDepthHandler:TFramebufferTestDepth;
|
|
FramebufferGetPixelOrderHandler:TFramebufferGetPixelOrder;
|
|
FramebufferSetPixelOrderHandler:TFramebufferSetPixelOrder;
|
|
FramebufferTestPixelOrderHandler:TFramebufferTestPixelOrder;
|
|
FramebufferGetAlphaModeHandler:TFramebufferGetAlphaMode;
|
|
FramebufferSetAlphaModeHandler:TFramebufferSetAlphaMode;
|
|
FramebufferTestAlphaModeHandler:TFramebufferTestAlphaMode;
|
|
FramebufferGetPitchHandler:TFramebufferGetPitch;
|
|
FramebufferGetOffsetHandler:TFramebufferGetOffset;
|
|
FramebufferSetOffsetHandler:TFramebufferSetOffset;
|
|
FramebufferTestOffsetHandler:TFramebufferTestOffset;
|
|
FramebufferGetOverscanHandler:TFramebufferGetOverscan;
|
|
FramebufferSetOverscanHandler:TFramebufferSetOverscan;
|
|
FramebufferTestOverscanHandler:TFramebufferTestOverscan;
|
|
FramebufferGetPaletteHandler:TFramebufferGetPalette;
|
|
FramebufferSetPaletteHandler:TFramebufferSetPalette;
|
|
FramebufferTestPaletteHandler:TFramebufferTestPalette;
|
|
FramebufferGetLayerHandler:TFramebufferGetLayer;
|
|
FramebufferSetLayerHandler:TFramebufferSetLayer;
|
|
FramebufferTestLayerHandler:TFramebufferTestLayer;
|
|
FramebufferTestVsyncHandler:TFramebufferTestVsync;
|
|
FramebufferSetVsyncHandler:TFramebufferSetVsync;
|
|
FramebufferSetBacklightHandler:TFramebufferSetBacklight;
|
|
FramebufferGetNumDisplaysHandler:TFramebufferGetNumDisplays;
|
|
FramebufferGetDisplayIdHandler:TFramebufferGetDisplayId;
|
|
FramebufferSetDisplayNumHandler:TFramebufferSetDisplayNum;
|
|
FramebufferGetDisplaySettingsHandler:TFramebufferGetDisplaySettings;
|
|
FramebufferDisplayIdToNameHandler:TFramebufferDisplayIdToName;
|
|
Cursor handlers
CursorSetDefaultHandler:TCursorSetDefault;
|
|
CursorSetInfoHandler:TCursorSetInfo;
|
|
CursorSetStateHandler:TCursorSetState;
|
|
Touch handlers
TouchGetBufferHandler:TTouchGetBuffer;
|
|
TouchSetBufferHandler:TTouchSetBuffer;
|
|
DMA handlers
DMAAvailableHandler:TDMAAvailable;
|
|
DMATransferHandler:TDMATransfer;
|
|
DMAFillMemoryHandler:TDMAFillMemory;
|
|
DMACopyMemoryHandler:TDMACopyMemory;
|
|
DMAReadPeripheralHandler:TDMAReadPeripheral;
|
|
DMAWritePeripheralHandler:TDMAWritePeripheral;
|
|
DMAAllocateBufferHandler:TDMAAllocateBuffer;
|
|
DMAAllocateBufferExHandler:TDMAAllocateBufferEx;
|
|
DMAReleaseBufferHandler:TDMAReleaseBuffer;
|
|
DMAGetChannelsHandler:TDMAGetChannels;
|
|
GPIO handlers
GPIOAvailableHandler:TGPIOAvailable;
|
|
GPIOReadHandler:TGPIORead;
|
|
GPIOWriteHandler:TGPIOWrite;
|
|
GPIOInputGetHandler:TGPIOInputGet;
|
|
GPIOInputWaitHandler:TGPIOInputWait;
|
|
GPIOInputEventHandler:TGPIOInputEvent;
|
|
GPIOOutputSetHandler:TGPIOOutputSet;
|
|
GPIOPullGetHandler:TGPIOPullGet;
|
|
GPIOPullSelectHandler:TGPIOPullSelect;
|
|
GPIOFunctionGetHandler:TGPIOFunctionGet;
|
|
GPIOFunctionSelectHandler:TGPIOFunctionSelect;
|
|
Virtual GPIO handlers
VirtualGPIOInputGetHandler:TVirtualGPIOInputGet;
|
|
VirtualGPIOOutputSetHandler:TVirtualGPIOOutputSet;
|
|
VirtualGPIOFunctionGetHandler:TVirtualGPIOFunctionGet;
|
|
VirtualGPIOFunctionSelectHandler:TVirtualGPIOFunctionSelect;
|
|
SPI handlers
SPIAvailableHandler:TSPIAvailable;
|
|
SPIStartHandler:TSPIStart;
|
|
SPIWriteHandler:TSPIWrite;
|
|
SPIWriteReadHandler:TSPIWriteRead;
|
|
SPIGetModeHandler:TSPIGetMode;
|
|
SPISetModeHandler:TSPISetMode;
|
|
SPIGetClockRateHandler:TSPIGetClockRate;
|
|
SPISetClockRateHandler:TSPISetClockRate;
|
|
SPIGetClockPhaseHandler:TSPIGetClockPhase;
|
|
SPISetClockPhaseHandler:TSPISetClockPhase;
|
|
SPIGetClockPolarityHandler:TSPIGetClockPolarity;
|
|
SPISetClockPolarityHandler:TSPISetClockPolarity;
|
|
SPIGetSelectPolarityHandler:TSPIGetSelectPolarity;
|
|
SPISetSelectPolarityHandler:TSPISetSelectPolarity;
|
|
SPIGetDescriptionHandler:TSPIGetDescription;
|
|
I2C handlers
I2CAvailableHandler:TI2CAvailable;
|
|
I2CStartHandler:TI2CStart;
|
|
I2CWriteHandler:TI2CWrite;
|
|
I2CWriteReadHandler:TI2CWriteRead;
|
|
I2CWriteWriteHandler:TI2CWriteWrite;
|
|
I2CGetRateHandler:TI2CGetRate;
|
|
I2CSetRateHandler:TI2CSetRate;
|
|
I2CGetAddressHandler:TI2CGetAddress;
|
|
I2CSetAddressHandler:TI2CSetAddress;
|
|
I2CGetDescriptionHandler:TI2CGetDescription;
|
|
I2CSlaveGetDescriptionHandler:TI2CSlaveGetDescription;
|
|
PWM handlers
PWMAvailableHandler:TPWMAvailable;
|
|
PWMStartHandler:TPWMStart;
|
|
PWMWriteHandler:TPWMWrite;
|
|
PWMSetModeHandler:TPWMSetMode;
|
|
PWMSetRangeHandler:TPWMSetRange;
|
|
PWMSetFrequencyHandler:TPWMSetFrequency;
|
|
PWMConfigureHandler:TPWMConfigure;
|
|
PWMGetDescriptionHandler:TPWMGetDescription;
|
|
RTC handlers
RTCAvailableHandler:TRTCAvailable;
|
|
RTCGetTimeHandler:TRTCGetTime;
|
|
RTCSetTimeHandler:TRTCSetTime;
|
|
UART handlers
UARTGetDescriptionHandler:TUARTGetDescription;
|
|
Serial handlers
SerialAvailableHandler:TSerialAvailable;
|
|
SerialOpenHandler:TSerialOpen;
|
|
SerialCloseHandler:TSerialClose;
|
|
SerialReadHandler:TSerialRead;
|
|
SerialWriteHandler:TSerialWrite;
|
|
Peripheral handlers
PeripheralGetBaseHandler:TPeripheralGetBase;
|
|
PeripheralGetSizeHandler:TPeripheralGetSize;
|
|
PeripheralReadHandler:TPeripheralRead;
|
|
PeripheralWriteHandler:TPeripheralWrite;
|
|
LocalPeripheralGetBaseHandler:TLocalPeripheralGetBase;
|
|
LocalPeripheralGetSizeHandler:TLocalPeripheralGetSize;
|
|
Get SP/PC handlers
Enable/Disable/Save/Restore IRQ/FIQ handlers
EnableIRQHandler:TEnableIRQ;
|
|
DisableIRQHandler:TDisableIRQ;
|
|
RestoreIRQHandler:TRestoreIRQ;
|
|
EnableFIQHandler:TEnableFIQ;
|
|
DisableFIQHandler:TDisableFIQ;
|
|
RestoreFIQHandler:TRestoreFIQ;
|
|
EnableIRQFIQHandler:TEnableIRQFIQ;
|
|
DisableIRQFIQHandler:TDisableIRQFIQ;
|
|
SaveIRQFIQHandler:TSaveIRQFIQ;
|
|
RestoreIRQFIQHandler:TRestoreIRQFIQ;
|
|
GetAbortHandler:TGetAbort;
|
|
EnableAbortHandler:TEnableAbort;
|
|
DisableAbortHandler:TDisableAbort;
|
|
SaveAbortHandler:TSaveAbort;
|
|
RestoreAbortHandler:TRestoreAbort;
|
|
Halt/Pause handlers
Halt thread handlers
HaltThreadHandler:THaltThread;
|
|
SendEvent/WaitForEvent/Interrupt handlers
SendEventHandler:TSendEvent;
|
|
WaitForEventHandler:TWaitForEvent;
|
|
WaitForInterruptHandler:TWaitForInterrupt;
|
|
Barrier handlers
ReadMemoryBarrierHandler:TReadMemoryBarrier;
|
|
WriteMemoryBarrierHandler:TWriteMemoryBarrier;
|
|
DataMemoryBarrierHandler:TDataMemoryBarrier;
|
|
DataSynchronizationBarrierHandler:TDataSynchronizationBarrier;
|
|
InstructionMemoryBarrierHandler:TInstructionMemoryBarrier;
|
|
TLB handlers
InvalidateTLBHandler:TInvalidateTLB;
|
|
InvalidateDataTLBHandler:TInvalidateDataTLB;
|
|
InvalidateInstructionTLBHandler:TInvalidateInstructionTLB;
|
|
Cache handlers
InvalidateCacheHandler:TInvalidateCache;
|
|
CleanDataCacheHandler:TCleanDataCache;
|
|
InvalidateDataCacheHandler:TInvalidateDataCache;
|
|
CleanAndInvalidateDataCacheHandler:TCleanAndInvalidateDataCache;
|
|
InvalidateInstructionCacheHandler:TInvalidateInstructionCache;
|
|
CleanDataCacheRangeHandler:TCleanDataCacheRange;
|
|
InvalidateDataCacheRangeHandler:TInvalidateDataCacheRange;
|
|
CleanAndInvalidateDataCacheRangeHandler:TCleanAndInvalidateDataCacheRange;
|
|
InvalidateInstructionCacheRangeHandler:TInvalidateInstructionCacheRange;
|
|
Prefetch buffer handlers
FlushPrefetchBufferHandler:TFlushPrefetchBuffer;
|
|
Branch target cache handlers
FlushBranchTargetCacheHandler:TFlushBranchTargetCache;
|
|
Context switch handlers
ContextSwitchHandler:TContextSwitch;
|
|
ContextSwitchIRQHandler:TContextSwitchIRQ;
|
|
ContextSwitchFIQHandler:TContextSwitchFIQ;
|
|
ContextSwitchSWIHandler:TContextSwitchSWI;
|
|
And/Xor/Or/Increment/Decrement/Exchange handlers
InterlockedOrHandler:TInterlockedOr;
|
|
InterlockedXorHandler:TInterlockedXor;
|
|
InterlockedAndHandler:TInterlockedAnd;
|
|
InterlockedDecrementHandler:TInterlockedDecrement;
|
|
InterlockedIncrementHandler:TInterlockedIncrement;
|
|
InterlockedExchangeHandler:TInterlockedExchange;
|
|
InterlockedAddExchangeHandler:TInterlockedAddExchange;
|
|
InterlockedCompareExchangeHandler:TInterlockedCompareExchange;
|
|
Page table handlers
PageTableGetLevelsHandler:TPageTableGetLevels;
|
|
PageDirectoryGetBaseHandler:TPageDirectoryGetBase;
|
|
PageDirectoryGetSizeHandler:TPageDirectoryGetSize;
|
|
PageTableGetBaseHandler:TPageTableGetBase;
|
|
PageTableGetSizeHandler:TPageTableGetSize;
|
|
PageTableGetEntryHandler:TPageTableGetEntry;
|
|
PageTableSetEntryHandler:TPageTableSetEntry;
|
|
PageTableGetPageSizeHandler:TPageTableGetPageSize;
|
|
PageTableGetPageFlagsHandler:TPageTableGetPageFlags;
|
|
PageTableGetPagePhysicalHandler:TPageTableGetPagePhysical;
|
|
Page tables handlers
PageTablesGetAddressHandler:TPageTablesGetAddress;
|
|
PageTablesGetLengthHandler:TPageTablesGetLength;
|
|
PageTablesGetCountHandler:TPageTablesGetCount;
|
|
PageTablesGetShiftHandler:TPageTablesGetShift;
|
|
PageTablesGetNextHandler:TPageTablesGetNext;
|
|
PageTablesGetUsedHandler:TPageTablesGetUsed;
|
|
PageTablesGetFreeHandler:TPageTablesGetFree;
|
|
Vector table handlers
VectorTableGetBaseHandler:TVectorTableGetBase;
|
|
VectorTableGetSizeHandler:TVectorTableGetSize;
|
|
VectorTableGetCountHandler:TVectorTableGetCount;
|
|
VectorTableGetEntryHandler:TVectorTableGetEntry;
|
|
VectorTableSetEntryHandler:TVectorTableSetEntry;
|
|
First bit set handlers
FirstBitSetHandler:TFirstBitSet;
|
|
Count leading zeros handlers
CountLeadingZerosHandler:TCountLeadingZeros;
|
|
Text IO handlers
TextIOWriteCharHandler:TTextIOWriteChar;
|
|
TextIOReadCharHandler:TTextIOReadChar;
|
|
TextIOWriteBufferHandler:TTextIOWriteBuffer;
|
|
Console handlers
ConsoleGetKeyHandler:TConsoleGetKey;
|
|
ConsolePeekKeyHandler:TConsolePeekKey;
|
|
ConsoleWriteCharHandler:TConsoleWriteChar;
|
|
ConsoleReadCharHandler:TConsoleReadChar;
|
|
ConsoleReadWideCharHandler:TConsoleReadWideChar;
|
|
ConsoleHideMouseHandler:TConsoleHideMouse;
|
|
ConsoleShowMouseHandler:TConsoleShowMouse;
|
|
ConsoleReadMouseHandler:TConsoleReadMouse;
|
|
Code page handlers
CodePageToWideCharHandler:TCodePageToWideChar;
|
|
WideCharToCodePageHandler:TWideCharToCodePage;
|
|
Name handlers
HostGetNameHandler:THostGetName;
|
|
HostSetNameHandler:THostSetName;
|
|
HostGetDomainHandler:THostGetDomain;
|
|
HostSetDomainHandler:THostSetDomain;
|
|
Module handlers
ModuleLoadHandler:TModuleLoad;
|
|
ModuleUnloadHandler:TModuleUnload;
|
|
ModuleGetNameHandler:TModuleGetName;
|
|
Symbol handlers
SymbolAddHandler:TSymbolAdd;
|
|
SymbolRemoveHandler:TSymbolRemove;
|
|
SymbolGetAddressHandler:TSymbolGetAddress;
|
|
Logging handlers
LoggingOutputHandler:TLoggingOutput;
|
|
LoggingOutputExHandler:TLoggingOutputEx;
|
|
Function declarations
Initialization functions
procedure PlatformInit;
Description: Initialize platform specific information for the current hardware
procedure CPUInit;
Description: Initialize the CPU including performance features etc (Where Applicable)
procedure FPUInit;
Description: Initialize the Floating Point Processor Unit (Where Applicable)
procedure GPUInit;
Description: Initialize the Graphics Processor Unit (Where Applicable)
procedure MMUInit;
Description: Initialize the Memory Management Unit (Where Applicable)
procedure SMPInit;
Description: Initialize the Symetric Multi Processor support (Where Applicable)
Note
|
Secondary CPU boot is performed by SecondaryInit in Threads
|
procedure CacheInit;
Description: Initialize CPU Data and Instruction Caching (Where Applicable)
procedure BoardInit;
Description: Initialize Board specific information (Where Applicable)
procedure MemoryInit;
Description: Initialize Memory specific information (Where Applicable)
procedure ClockInit;
Description: Initialize the Clock handling
procedure PowerInit;
Description: Initialize Power management (Where Applicable)
procedure MailboxInit;
Description: Initialize Mailbox access (Where Applicable)
procedure InterruptInit;
Description: Initialize Interrupt handling
procedure PeripheralInit;
Description: Initialize Peripheral devices (Where Applicable)
procedure ParseBootTags;
Description: Parse any boot tag information passed by the bootloader (Where Applicable)
procedure ParseCommandLine;
Description: Setup argc, argv and cmdline and process known command line options (Where Applicable)
procedure ParseEnvironment;
Description: Setup envp and process known environment options (Where Applicable)
procedure OptionsInit;
Description: Process known command line and environment options (Where Applicable)
Device tree functions
function DeviceTreeValid:Boolean; inline;
Description: Check if valid Device Tree information was provided by the firmware/bootloader
function DeviceTreeGetBase:PtrUInt; inline;
Description: Get the base address of the Device Tree Blob (Where Applicable)
function DeviceTreeGetSize:LongWord; inline;
Description: Get the total size of the Device Tree Blob (Where Applicable)
function DeviceTreeRead(const Path,Name:String; Buffer:Pointer; var Size:LongWord):LongWord; inline;
Description: Read the raw value of a Device Tree property (Where Applicable)
Path
|
The path of the requested property
|
Name
|
The name of the requested property
|
Buffer
|
A pointer to a buffer to receive the raw value
|
Size
|
The size in byte of the buffer, updated on return with the actual size of the value.
|
Return
|
ERROR_SUCCESS if the property value was read or another error code on failure
|
function DeviceTreeRead32(const Path,Name:String; var Value:LongWord):LongWord; inline;
Description: Read a 32-bit value from a Device Tree property (Where Applicable)
Path
|
The path of the requested property
|
Name
|
The name of the requested property
|
Value
|
The returned value of the property
|
Return
|
ERROR_SUCCESS if the property value was read or another error code on failure
|
function DeviceTreeRead64(const Path,Name:String; var Value:UInt64):LongWord; inline;
Description: Read a 64-bit value from a Device Tree property (Where Applicable)
Path
|
The path of the requested property
|
Name
|
The name of the requested property
|
Value
|
The returned value of the property
|
Return
|
ERROR_SUCCESS if the property value was read or another error code on failure
|
function DeviceTreeReadString(const Path,Name:String; var Value:String):LongWord; inline;
Description: Read a string value from a Device Tree property (Where Applicable)
Path
|
The path of the requested property
|
Name
|
The name of the requested property
|
Value
|
The returned value of the property
|
Return
|
ERROR_SUCCESS if the property value was read or another error code on failure
|
Boot functions
procedure BootBlink; inline;
Description: Blink the Activity LED (Where Applicable)
Note
|
Intended for startup diagnostics when bootstrapping a new board
|
procedure BootOutput(Value:LongWord); inline;
Description: Output boot time information (Where Applicable)
Note
|
Intended for startup diagnostics when bootstrapping a new board
|
procedure BootConsoleStart; inline;
Description: Start the boot time console display (Where Applicable)
Note
|
Intended for startup diagnostics when bootstrapping a new board
|
procedure BootConsoleWrite(const Value:String); inline;
Description: Output text to the boot time console display (Where Applicable)
Note
|
Intended for startup diagnostics when bootstrapping a new board
|
procedure BootConsoleWriteEx(const Value:String; X,Y:LongWord); inline;
Description: Output text to the boot time console display at the specified X and Y position (Where Applicable)
Note
|
Intended for startup diagnostics when bootstrapping a new board
|
function BootConsoleGetX:LongWord; inline;
Description: Get the current X position of the boot time console display (Where Applicable)
Note
|
Intended for startup diagnostics when bootstrapping a new board
|
function BootConsoleGetY:LongWord; inline;
Description: Get the current Y position of the boot time console display (Where Applicable)
Note
|
Intended for startup diagnostics when bootstrapping a new board
|
LED functions
procedure PowerLEDEnable; inline;
Description: Enable the Power LED (Where Applicable)
procedure PowerLEDOn; inline;
Description: Turn On the Power LED (Where Applicable)
procedure PowerLEDOff; inline;
Description: Turn Off the Power LED (Where Applicable)
procedure ActivityLEDEnable; inline;
Description: Enable the Activity LED (Where Applicable)
procedure ActivityLEDOn; inline;
Description: Turn On the Activity LED (Where Applicable)
procedure ActivityLEDOff; inline;
Description: Turn Off the Activity LED (Where Applicable)
Counter functions (Timer device)
function CounterAvailable:Boolean; inline;
Description: Check if a counter is currently available
function CounterRead:LongWord; inline;
Description: Read the current value of the default counter
Return
|
The 32 bit current value of the counter or 0 on failure
|
function CounterRead64:Int64; inline;
Description: Read the current value of the default counter
Return
|
The 64 bit current value of the counter or 0 on failure
|
function CounterWait:LongWord; inline;
Description: Wait for the current interval to expire on the default counter
Return
|
ERROR_SUCCESS if the interval expired or another error code on failure
|
function CounterEvent(Callback:TCounterCallback; Data:Pointer):LongWord; inline;
Description: Schedule a function to be called when the current interval expires on the default counter
Callback
|
The function to be called when the interval expires
|
Data
|
A pointer to be pass to the function when the interval expires (Optional)
|
Return
|
ERROR_SUCCESS if the callback was scheduled successfully or another error code on failure
|
function CounterCancel:LongWord; inline;
Description: Cancel a previously scheduled event callback function on the default counter
Return
|
ERROR_SUCCESS if the callback was cancelled successfully or another error code on failure
|
function CounterGetRate:LongWord; inline;
Description: Get the current clock rate in Hz of the default counter
Return
|
The current clock rate in Hz or 0 on failure
|
function CounterSetRate(Rate:LongWord):LongWord; inline;
Description: Set the current clock rate in Hz of the default counter
Rate
|
The clock rate in Hz to set
|
Return
|
ERROR_SUCCESS if the clock rate was set or another error code on failure
|
function CounterGetInterval:LongWord; inline;
Description: Get the current interval in ticks of the default counter
Return
|
The current interval in ticks or 0 on failure (or not set)
|
Note
|
The tick rate is determined by the clock rate
|
function CounterSetInterval(Interval:LongWord):LongWord; inline;
Description: Set the current interval in ticks of the default counter
Interval
|
The interval in ticks to set
|
Return
|
ERROR_SUCCESS if the interval was set or another error code on failure
|
Note
|
The tick rate is determined by the clock rate
|
Mailbox functions
function MailboxReceive(Mailbox,Channel:LongWord):LongWord; inline;
Description: Receive from specified mailbox on specified channel
procedure MailboxSend(Mailbox,Channel,Data:LongWord); inline;
Description: Send to specified mailbox on specified channel
function MailboxCall(Mailbox,Channel,Data:LongWord; var Response:LongWord):LongWord; inline;
Description: Perform a transaction (Send/Receive) to specified mailbox on specified channel
function MailboxCallEx(Mailbox,Channel,Data:LongWord; var Response:LongWord; Timeout:LongWord):LongWord; inline;
Description: Perform a transaction (Send/Receive) to specified mailbox on specified channel
function MailboxPropertyCall(Mailbox,Channel:LongWord; Data:Pointer; var Response:LongWord):LongWord; inline;
Description: Perform a property tag transaction (Send/Receive) to specified mailbox on specified channel
function MailboxPropertyCallEx(Mailbox,Channel:LongWord; Data:Pointer; var Response:LongWord; Timeout:LongWord):LongWord; inline;
Description: Perform a property tag transaction (Send/Receive) to specified mailbox on specified channel
function MailboxPropertyTag(Tag:LongWord; Data:Pointer; Size:LongWord):LongWord; inline;
Description: Request a property tag (Get/Set) from the mailbox property channel
Random number functions
function RandomAvailable:Boolean; inline;
Description: Check if a hardware random number generator is currently available
Note
|
The software random number generator from the RTL is always available
|
procedure RandomSeed(Seed:LongWord); inline;
Description: To be documented
function RandomReadLongInt(Limit:LongInt):LongInt; inline;
Description: To be documented
function RandomReadInt64(Limit:Int64):Int64; inline;
Description: To be documented
function RandomReadDouble:Double; inline;
Description: To be documented
function RandomReadExtended:Extended; inline;
Description: To be documented
Note
|
Replaced by RandomReadDouble
|
Watchdog timer functions
function WatchdogAvailable:Boolean; inline;
Description: Check if a watchdog timer is currently available
function WatchdogStart(Milliseconds:LongWord):LongWord; inline;
Description: To be documented
function WatchdogStop:LongWord; inline;
Description: To be documented
function WatchdogRefresh(Milliseconds:LongWord):LongWord; inline;
Description: To be documented
Interrupt request (IRQ) functions
function RequestIRQ(CPUID,Number:LongWord; Handler:TInterruptHandler; Parameter:Pointer):LongWord; inline;
Description: Request registration of the supplied handler to the specified IRQ number
CPUID
|
CPU to route IRQ to
|
Number
|
IRQ number to register
|
Handler
|
Interrupt handler function to register
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
If the IRQ number is already registered then the request will fail
|
function ReleaseIRQ(CPUID,Number:LongWord; Handler:TInterruptHandler; Parameter:Pointer):LongWord; inline;
Description: Request deregistration of the supplied handler from the specified IRQ number
CPUID
|
CPU to unroute IRQ from
|
Number
|
IRQ number to deregister
|
Handler
|
Interrupt handler function to deregister
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
If the IRQ number is not currently registered then the request will fail
|
function RequestExIRQ(CPUID,Number:LongWord; Handler:TInterruptHandler; HandlerEx:TInterruptExHandler; Parameter:Pointer):LongWord; inline;
Description: Request registration of the supplied extended handler to the specified IRQ number
CPUID
|
CPU to route IRQ to
|
Number
|
IRQ number to register
|
Handler
|
Interrupt handler function to register
|
HandlerEx
|
Extended Interrupt handler function to register
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
Only one of Handler or HandlerEx can be specified. If the IRQ number is already registered then the request will fail
|
function ReleaseExIRQ(CPUID,Number:LongWord; Handler:TInterruptHandler; HandlerEx:TInterruptExHandler; Parameter:Pointer):LongWord; inline;
Description: Request deregistration of the supplied extended handler from the specified IRQ number
CPUID
|
CPU to unroute IRQ from
|
Number
|
IRQ number to deregister
|
Handler
|
Interrupt handler function to deregister
|
HandlerEx
|
Extended Interrupt handler function to deregister
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
Only one of Handler or HandlerEx can be specified. If the IRQ number is not currently registered then the request will fail
|
function RequestFIQ(CPUID,Number:LongWord; Handler:TInterruptHandler; Parameter:Pointer):LongWord; inline;
Description: Request registration of the supplied handler to the specified FIQ number (Where Applicable)
CPUID
|
CPU to route FIQ to
|
Number
|
FIQ number to register
|
Handler
|
Interrupt handler function to register
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
If the FIQ number is already registered then the request will fail
|
function ReleaseFIQ(CPUID,Number:LongWord; Handler:TInterruptHandler; Parameter:Pointer):LongWord; inline;
Description: Request deregistration of the supplied handler from the specified FIQ number (Where Applicable)
CPUID
|
CPU to unroute FIQ from
|
Number
|
FIQ number to deregister
|
Handler
|
Interrupt handler function to deregister
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
If the FIQ number is not currently registered then the request will fail
|
function RequestExFIQ(CPUID,Number:LongWord; Handler:TInterruptHandler; HandlerEx:TInterruptExHandler; Parameter:Pointer):LongWord; inline;
Description: Request registration of the supplied extended handler to the specified FIQ number (Where Applicable)
CPUID
|
CPU to route FIQ to
|
Number
|
FIQ number to register
|
Handler
|
Interrupt handler function to register
|
HandlerEx
|
Extended Interrupt handler function to register
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
Only one of Handler or HandlerEx can be specified. If the FIQ number is already registered then the request will fail
|
function ReleaseExFIQ(CPUID,Number:LongWord; Handler:TInterruptHandler; HandlerEx:TInterruptExHandler; Parameter:Pointer):LongWord; inline;
Description: Request deregistration of the supplied extended handler from the specified FIQ number (Where Applicable)
CPUID
|
CPU to unroute FIQ from
|
Number
|
FIQ number to deregister
|
Handler
|
Interrupt handler function to deregister
|
HandlerEx
|
Extended Interrupt handler function to deregister
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
Only one of Handler or HandlerEx can be specified. If the FIQ number is not currently registered then the request will fail
|
Inter processor interrupt (IPI) functions
function RequestIPI(CPUID,Number:LongWord; Handler:TIPIHandler; Parameter:Pointer):LongWord; inline;
Description: Request registration of the supplied handler to the specified IPI (Inter-processor interrupt) number (Where Applicable)
CPUID
|
CPU to route IPI to
|
Number
|
IPI number to register
|
Handler
|
Interrupt handler function to register
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
If the IPI number is already registered then the request will fail
|
function ReleaseIPI(CPUID,Number:LongWord; Handler:TIPIHandler; Parameter:Pointer):LongWord; inline;
Description: Request deregistration of the supplied handler from the specified IPI (Inter-processor interrupt) number (Where Applicable)
CPUID
|
CPU to unroute IPI from
|
Number
|
IPI number to deregister
|
Handler
|
Interrupt handler function to deregister
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Note
|
If the IPI number is not currently registered then the request will fail
|
Interrupt register/deregister functions
function RegisterInterrupt(Number,Mask,Priority,Flags:LongWord; Handler:TSharedInterruptHandler; Parameter:Pointer):LongWord; inline;
Description: Request registration of the supplied handler to the specified interrupt number (Where Applicable)
Number
|
The interrupt number to register the handler for
|
Mask
|
The mask of CPUs to register the handler for (eg CPU_MASK_0, CPU_MASK_1) (Where Applicable)
|
Priority
|
The priority level of the interrupt to be registered (eg INTERRUPT_PRIORITY_MAXIMUM) (Where Applicable)
|
Flags
|
The flags to control the registration of the interrupt (eg INTERRUPT_FLAG_SHARED) (Where Applicable)
|
Handler
|
The shared interrupt handler to be called when the interrupt occurs
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Return
|
ERROR_SUCCESS if the callback was scheduled successfully or another error code on failure
|
Note
|
None documented
|
function DeregisterInterrupt(Number,Mask,Priority,Flags:LongWord; Handler:TSharedInterruptHandler; Parameter:Pointer):LongWord; inline;
Description: Request deregistration of the supplied handler from the specified interrupt number (Where Applicable)
Number
|
The interrupt number to deregister the handler for
|
Mask
|
The mask of CPUs to deregister the handler for (eg CPU_MASK_0, CPU_MASK_1) (Where Applicable)
|
Priority
|
The priority level of the interrupt to be deregistered (eg INTERRUPT_PRIORITY_MAXIMUM) (Where Applicable)
|
Flags
|
The flags to control the deregistration of the interrupt (eg INTERRUPT_FLAG_SHARED, INTERRUPT_FLAG_LOCAL, INTERRUPT_FLAG_FIQ) (Where Applicable)
|
Handler
|
The shared interrupt handler to be called when the interrupt occurs
|
Parameter
|
A pointer to be passed to the handler when the interrupt occurs (Optional)
|
Return
|
ERROR_SUCCESS if the callback was scheduled successfully or another error code on failure
|
Note
|
None documented
|
System call (SWI) functions
procedure SystemCall(Number:LongWord; Param1,Param2,Param3:PtrUInt); inline;
Description: Perform a System Call function with the supplied parameters (Where Applicable)
Number
|
The System Call number to be called
|
Param1
|
The first parameter to pass to the function (Optional/Function defined)
|
Param2
|
The second parameter to pass to the function (Optional/Function defined)
|
Param3
|
The third parameter to pass to the function (Optional/Function defined)
|
function RegisterSystemCall(Number:LongWord; Handler:TSystemCallHandler):LongWord; inline;
Description: Request registration of the supplied handler to the specified System Call number (Where Applicable)
Number
|
The System Call number to be registered
|
Handler
|
The handler function to be registered
|
Note
|
If the System Call number is already registered then the request will fail
|
function DeregisterSystemCall(Number:LongWord; Handler:TSystemCallHandler):LongWord; inline;
Description: Request deregistration of the supplied handler from the specified System Call number (Where Applicable)
Number
|
The System Call number to be deregistered
|
Handler
|
The handler function to be deregistered
|
Note
|
If the System Call number is not currently registered then the request will fail
|
function RegisterSystemCallEx(CPUID,Number:LongWord; Handler:TSystemCallHandler; HandlerEx:TSystemCallExHandler):LongWord; inline;
Description: Request registration of the supplied extended handler to the specified System Call number (Where Applicable)
CPUID
|
The CPU Id to register the System Call against (or CPU_ID_ALL)
|
Number
|
The System Call number to be registered
|
Handler
|
The handler function to be registered (Optional) (Handler or HandlerEx must be specified, not both)
|
HandlerEx
|
The extended handler function to be registered (Optional) (Handler or HandlerEx must be specified, not both)
|
Note
|
If the System Call number is already registered then the request will fail
|
function DeregisterSystemCallEx(CPUID,Number:LongWord; Handler:TSystemCallHandler; HandlerEx:TSystemCallExHandler):LongWord; inline;
Description: Request deregistration of the supplied extended handler from the specified System Call number (Where Applicable)
CPUID
|
The CPU Id to deregister the System Call from (or CPU_ID_ALL)
|
Number
|
The System Call number to be deregistered
|
Handler
|
The handler function to be deregistered (Optional) (Handler or HandlerEx must be specified, not both)
|
HandlerEx
|
The extended handler function to be deregistered (Optional) (Handler or HandlerEx must be specified, not both)
|
Note
|
If the System Call number is not currently registered then the request will fail
|
Interrupt entry functions
function GetInterruptCount:LongWord; inline;
Description: Get the number of interrupt entries for the current platform
function GetInterruptStart:LongWord; inline;
Description: Get the starting number of interrupt entries for the current platform
function GetInterruptEntry(Number:LongWord):TInterruptEntry; overload;
Description: Get the interrupt entry for the specified interrupt number
function GetInterruptEntry(Number,Instance:LongWord;var Interrupt:TInterruptEntry):LongWord; inline; overload;
Description: Get the interrupt entry for the specified interrupt number and instance
Local interrupt entry functions
function GetLocalInterruptCount:LongWord; inline;
Description: Get the number of local interrupt entries for the current platform (Where Applicable)
function GetLocalInterruptStart:LongWord; inline;
Description: Get the starting number of local interrupt entries for the current platform (Where Applicable)
function GetLocalInterruptEntry(CPUID,Number:LongWord):TInterruptEntry;
Description: Get the local interrupt entry for the specified interrupt number (Where Applicable)
function GetLocalInterruptEntry(CPUID,Number,Instance:LongWord; var Interrupt:TInterruptEntry):LongWord; inline;
Description: Get the local interrupt entry for the specified interrupt number and instance (Where Applicable)
Software interrupt entry (IPI) functions
function GetSoftwareInterruptCount:LongWord; inline;
Description: Get the number of software interrupt entries for the current platform (Where Applicable)
function GetSoftwareInterruptStart:LongWord; inline;
Description: Get the starting number of software interrupt entries for the current platform (Where Applicable)
function GetSoftwareInterruptEntry(CPUID,Number:LongWord):TInterruptEntry; overload;
Description: Get the software interrupt entry for the specified interrupt number and instance (Where Applicable)
function GetSoftwareInterruptEntry(CPUID,Number,Instance:LongWord; var Interrupt:TInterruptEntry):LongWord; inline; overload;
Description: Get the software interrupt entry for the specified interrupt number and instance (Where Applicable)
System call entry (SWI) functions
function GetSystemCallCount:LongWord; inline;
Description: Get the number of system call entries for the current platform (Where Applicable)
function GetSystemCallEntry(Number:LongWord):TSystemCallEntry; inline;
Description: Get the system call entry for the specified system call number (Where Applicable)
System functions
function SystemRestart(Delay:LongWord):LongWord;
Description: Restart the system
Delay
|
How long to delay before commencing the restart (Milliseconds)
|
Return
|
ERROR_SUCCESS if the restart was successfully initiated or another error code on failure
|
function SystemShutdown(Delay:LongWord):LongWord;
Description: Shutdown the system
Delay
|
How long to delay before commencing the shutdown (Milliseconds)
|
Return
|
ERROR_SUCCESS if the shutdown was successfully initiated or another error code on failure
|
function SystemRegisterShutdown(Callback:TShutdownCallback; Parameter:Pointer; Timeout:LongWord):LongWord;
Description: Register a procedure to be called during system shutdown or restart
Callback
|
The procedure to be called on shutdown or restart
|
Parameter
|
A pointer to be passed to the callback procedure
|
Timeout
|
Time the shutdown process should wait for this callback to complete (0 for the default timeout) (Milliseconds)
|
Return
|
ERROR_SUCCESS if the callback was successfully registered or another error code on failure
|
function SystemDeregisterShutdown(Callback:TShutdownCallback; Parameter:Pointer):LongWord;
Description: Deregister a procedure from being called during system shutdown or restart
Callback
|
The procedure previously registered for shutdown or restart
|
Parameter
|
The pointer previously registered for the callback procedure
|
Return
|
ERROR_SUCCESS if the callback was successfully deregistered or another error code on failure
|
function SystemGetUptime:Int64; inline;
Description: Get the current system up time in 100 nanosecond ticks since 1/1/1601
Return
|
The current system up time
|
Note
|
This is the same time format as Windows FILE_TIME and is intended to allow compatibility with file system functions etc
|
function SystemGetCommandLine:String; inline;
Description: Get the current command line
function SystemGetEnvironment:Pointer; inline;
Description: Get the current environment
function SystemDateToString(Date:TDateTime):String; inline;
Description: Return the supplied date value as a string in the system defined format
Date
|
The date in Pascal TDateTime format
|
Return
|
The date formatted according to the system date format
|
Note
|
Applications should use FormatDateTime or DateTimeToString directly. This function is intended to provide a uniform and generic date and time output from system functions such as logging and debug output.
|
function SystemTimeToString(Time:TDateTime):String; inline;
Description: Return the supplied time value as a string in the system defined format
Time
|
The time in Pascal TDateTime format
|
Return
|
The time formatted according to the system time format
|
Note
|
Applications should use FormatDateTime or DateTimeToString directly. This function is intended to provide a uniform and generic date and time output from system functions such as logging and debug output.
|
function SystemDateTimeToString(DateTime:TDateTime):String; inline;
Description: Return the supplied date and time value as a string in the system defined format
DateTime
|
The date and time in Pascal TDateTime format
|
Return
|
The date and time formatted according to the system date and time format
|
Note
|
Applications should use FormatDateTime or DateTimeToString directly. This function is intended to provide a uniform and generic date and time output from system functions such as logging and debug output.
|
function SystemIntervalToString(Interval:TDateTime):String; inline;
Description: Return the supplied time interval as a string in the system defined format
Interval
|
The time interval in Pascal TDateTime format
|
Return
|
The time interval formatted according to the system time format
|
CPU functions
function CPUGetArch:LongWord; inline;
Description: Get the CPU architecture for this board
function CPUGetType:LongWord; inline;
Description: Get the CPU type for this board
function CPUGetBoot:LongWord; inline;
Description: Get the boot CPU for this board
function CPUGetMask:LongWord; inline;
Description: Get the CPU mask for this board
function CPUGetCount:LongWord; inline;
Description: Get the CPU count for this board
function CPUGetMode:LongWord; inline;
Description: Get the current CPU moded
Note
|
The return value is specific to the CPU type
|
function CPUGetState:LongWord; inline;
Description: Get the current CPU state
function CPUGetGroup:LongWord; inline;
Description: Get the current CPU group
function CPUGetCurrent:LongWord; inline;
Description: Get the current CPU Id
function CPUGetMemory(var Address:PtrUInt; var Length:UInt64):LongWord; inline;
Description: Get the memory start and size available to the CPU
function CPUGetPercentage(CPUID:LongWord):Double; inline;
Description: Get the last second utilization of the specified CPU in percentage
CPUID
|
The CPU to get utilization from or CPU_ID_ALL for average of all CPUs
|
function CPUGetUtilization(CPUID:LongWord):LongWord; inline;
Description: Get the last second utilization of the specified CPU
CPUID
|
The CPU to get utilization from or CPU_ID_ALL for average of all CPUs
|
function CPUGetModel:LongWord; inline;
Description: Get the CPU model of the current CPU
function CPUGetRevision:LongWord; inline;
Description: Get the CPU revision of the current CPU
Note
|
The return value is specific to the CPU type and model
|
function CPUGetDescription:String; inline;
Description: Get the CPU description of the current CPU
FPU functions
function FPUGetType:LongWord; inline;
Description: Get the FPU type for this board
function FPUGetState:LongWord; inline;
Description: Get the current FPU state
GPU functions
function GPUGetType:LongWord; inline;
Description: Get the GPU type for this board
function GPUGetState:LongWord; inline;
Description: Get the current GPU state
function GPUGetMemory(var Address:PtrUInt; var Length:UInt64):LongWord; inline;
Description: Get the memory start and size available to the GPU
Cache functions
function L1CacheGetType:LongWord; inline;
Description: Get the L1 cache type for this board
function L1DataCacheGetSize:LongWord; inline;
Description: Get the L1 data cache size for this board
Note
|
If data cache is not supported, the size returned is zero. If separate data and instruction caches are not supported, the size returned is the unified size.
|
function L1DataCacheGetLineSize:LongWord; inline;
Description: Get the L1 data cache line size for this board
Note
|
If data cache is not supported, the size returned is zero. If separate data and instruction caches are not supported, the size returned is the unified size.
|
function L1InstructionCacheGetSize:LongWord; inline;
Description: Get the L1 instruction cache size for this board
Note
|
If instruction cache is not supported, the size returned is zero. If separate data and instruction caches are not supported, the size returned is the unified size.
|
function L1InstructionCacheGetLineSize:LongWord; inline;
Description: Get the L1 instruction cache line size for this board
Note
|
If instruction cache is not supported, the size returned is zero. If separate data and instruction caches are not supported, the size returned is the unified size.
|
function L2CacheGetType:LongWord; inline;
Description: Get the L2 cache type for this board
function L2CacheGetSize:LongWord; inline;
Description: Get the L2 cache size for this board
Note
|
If L2 cache is not supported, the size returned is zero
|
function L2CacheGetLineSize:LongWord; inline;
Description: Get the L2 cache line size for this board
Note
|
If L2 cache is not supported, the size returned is zero
|
Version functions
procedure VersionGetInfo(var Major,Minor,Revision:LongWord);
Description: Get the version information of the currently running system
function VersionGetDate:String;
Description: Get the version release date of the currently running system
function VersionGetName:String;
Description: Get the version release name of the currently running system
function VersionGetVersion:String;
Description: Get the version string of the currently running system
Board functions
function BoardGetType:LongWord; inline;
Description: Get the current Board type
function BoardGetModel:LongWord; inline;
Description: Get the current Board model
function BoardGetSerial:Int64; inline;
Description: Get the current Board serial number
function BoardGetRevision:LongWord; inline;
Description: Get the current Board revision number
function BoardGetMACAddress:String; inline;
Description: Get the current Board MAC address (Where Applicable)
Chip functions
function ChipGetRevision:LongWord; inline;
Description: Get the current Chip revision number
Firmware functions
function FirmwareGetRevision:LongWord; inline;
Description: Get the current board Firmware Revision
function FirmwareGetThrottled:LongWord; inline;
Description: Get the current throttling state from the firmware
Return
|
A bit mask of FIRMWARE_THROTTLE_* values for the throttling state
|
Machine functions
function MachineGetType:LongWord; inline;
Description: Get the current Machine type
Memory functions
function MemoryGetBase:PtrUInt; inline;
Description: Get the base address of system memory
function MemoryGetSize:UInt64; inline;
Description: Get the total size of system memory
function MemoryGetPageSize:LongWord; inline;
Description: Get the page size of system memory
function MemoryGetLargePageSize:LongWord; inline;
Description: Get the large page size of system memory (Where Applicable)
function MemoryGetSectionSize:LongWord; inline;
Description: Get the section size of system memory (Where Applicable)
function MemoryGetLargeSectionSize:LongWord; inline;
Description: Get the large section size of system memory (Where Applicable)
Power functions
function PowerOn(PowerId:LongWord):LongWord;
Description: Power On the specified device
function PowerOff(PowerId:LongWord):LongWord;
Description: Power Off the specified device
function PowerGetWait(PowerId:LongWord):LongWord; inline;
Description: Get the enable wait time in Microseconds of the specified device
function PowerGetState(PowerId:LongWord):LongWord; inline;
Description: Get the power state of the specified device
function PowerSetState(PowerId,State:LongWord; Wait:Boolean):LongWord; inline;
Description: Set the power state of the specified device (Optionally waiting for ready)
Clock functions
function ClockTicks:LongWord;
Description: Get the current number of clock ticks
Return
|
The current number of clock ticks
|
Note
|
When this reaches CLOCK_TICKS_PER_SECOND then ClockSeconds is incremented and this is reset to zero
|
function ClockSeconds:LongWord;
Description: Get the number of clock seconds since the system was started
Return
|
The current number of clock seconds
|
Note
|
This forms the system clock
|
function ClockMilliseconds:Int64;
Description: Get the number of clock milliseconds since the system was started
Return
|
The current number of clock milliseconds
|
function ClockMicroseconds:Int64;
Description: Get the number of clock microseconds since the system was started
Return
|
The current number of clock microseconds
|
function ClockNanoseconds:Int64;
Description: Get the number of clock nanoseconds since the system was started
Return
|
The current number of clock nanoseconds
|
function ClockGetTime:Int64;
Description: Get the current system time in 100 nanosecond ticks since 1/1/1601
Return
|
The current system time
|
Note
|
This is the same time format as Windows FILE_TIME and is intended to allow compatibility with file system functions etc. By default the time returned by this function is considered to be UTC but the actual conversion between UTC and local time is handled at a higher level.
|
function ClockSetTime(const Time:Int64; RTC:Boolean):Int64;
Description: Set the current system time in 100 nanosecond ticks since 1/1/1601
Time
|
The time to be set
|
RTC
|
Set the default RTC (real time clock) if available
|
Return
|
The system time after setting
|
Note
|
This is the same time format as Windows FILE_TIME and is intended to allow compatibility with file system functions etc. By default the time passed to this function is considered to be UTC but the actual conversion between UTC and local time is handled at a higher level.
|
function ClockGetCount:LongWord; inline;
Description: Gets the current system clock count (32 least significant bits of total)
Note
|
This will normally come from the free running system timer in the board and is useful as a form of tick count but not for time keeping because the actual rate at which this increments is dependent on the system timer clock frequency of the specific board and may not be a measure of time in its raw form.
|
function ClockGetTotal:Int64; inline;
Description: Gets the total system clock count
Note
|
This will normally come from the free running system timer in the board and is useful as a form of tick count but not for time keeping because the actual rate at which this increments is dependent on the system timer clock frequency of the specific board and may not be a measure of time in its raw form.
|
function ClockUpdateOffset:LongWord; inline;
Description: Update the system time offset between UTC and Local
function ClockGetRate(ClockId:LongWord):LongWord; inline;
Description: Get the clock rate in Hz of the specified Clock
function ClockSetRate(ClockId,Rate:LongWord; Turbo:Boolean):LongWord; inline;
Description: Set the clock rate in Hz of the specified Clock
function ClockGetState(ClockId:LongWord):LongWord; inline;
Description: Get the state of the specified Clock
function ClockSetState(ClockId,State:LongWord):LongWord; inline;
Description: Set the state of the specified Clock
function ClockGetMinRate(ClockId:LongWord):LongWord; inline;
Description: Get the minimum clock rate in Hz of the specified Clock
function ClockGetMaxRate(ClockId:LongWord):LongWord; inline;
Description: Get the maximum clock rate in Hz of the specified Clock
Turbo functions
function TurboGetState(TurboId:LongWord):LongWord; inline;
Description: Get the Turbo state (0 equals Off/1 equals On) of the specified device
function TurboSetState(TurboId,State:LongWord):LongWord; inline;
Description: Set the Turbo state (0 equals Off/1 equals On) of the specified device
Voltage functions
function VoltageGetValue(VoltageId:LongWord):LongWord; inline;
Description: Get the current voltage level of the specified device
function VoltageSetValue(VoltageId,Value:LongWord):LongWord; inline;
Description: Set the current voltage level of the specified device
function VoltageGetMinValue(VoltageId:LongWord):LongWord; inline;
Description: Get the minimum voltage level of the specified device
function VoltageGetMaxValue(VoltageId:LongWord):LongWord; inline;
Description: Get the maximum voltage level of the specified device
Temperature functions
function TemperatureGetCurrent(TemperatureId:LongWord):LongWord; inline;
Description: Get the current temperature in thousandths of a degree C of the specified device
function TemperatureGetMaximum(TemperatureId:LongWord):LongWord; inline;
Description: Get the maximum temperature in thousandths of a degree C of the specified device
GPU memory functions
function GPUMemoryAllocate(Length,Alignment,Flags:LongWord):THandle; inline;
Description: Allocate memory from the GPU
function GPUMemoryRelease(Handle:THandle):LongWord; inline;
Description: Release memory allocated from the GPU
function GPUMemoryLock(Handle:THandle):LongWord; inline;
Description: Lock memory allocated from the GPU and return an address
function GPUMemoryUnlock(Handle:THandle):LongWord; inline;
Description: Unlock memory allocated from the GPU
GPU miscellaneous functions
function GPUExecuteCode(Address:Pointer; R0,R1,R2,R3,R4,R5:LongWord):LongWord; inline;
Description: Execute a block of code on the GPU
function DispmanxHandleGet(Resource:THandle):THandle; inline;
Description: Convert a Dispmanx Resource handle to a Memory handle (Which can be passed to Lock/Unlock above)
function EDIDBlockGet(Block:LongWord; Buffer:Pointer; Length:LongWord):LongWord; inline;
Description: Get an EDID block from HDMI
Framebuffer functions
function FramebufferAvailable:Boolean; inline;
Description: Check if a framebuffer device is currently available
function FramebufferAllocate(Alignment:LongWord; var Address,Length:LongWord):LongWord; inline;
Description: Allocate a new Framebuffer
function FramebufferRelease:LongWord; inline;
Description: Release the current Framebuffer
function FramebufferSetState(State:LongWord):LongWord; inline;
Description: Set the current Framebuffer (Display) state (0 for Off/1 for On)
function FramebufferGetDimensions(var Width,Height,Top,Bottom,Left,Right:LongWord):LongWord; inline;
Description: Get the default Dimensions of the Framebuffer (Physical Width, Height and Overscan Top, Bottom, Left, Right in Pixels)
function FramebufferGetPhysical(var Width,Height:LongWord):LongWord; inline;
Description: Get the Physical Framebuffer Width and Height in Pixels
Note
|
The "physical" size is the size of the allocated buffer in memory, not the resolution of the video signal sent to the display device
|
function FramebufferSetPhysical(var Width,Height:LongWord):LongWord; inline;
Description: Set the Physical Framebuffer Width and Height in Pixels
function FramebufferTestPhysical(var Width,Height:LongWord):LongWord; inline;
Description: Test the Physical Framebuffer Width and Height in Pixels
function FramebufferGetVirtual(var Width,Height:LongWord):LongWord; inline;
Description: Get the Virtual Framebuffer Width and Height in Pixels
Note
|
The "virtual" size is the portion of buffer that is sent to the display device, not the resolution the buffer itself. This may be smaller than the allocated buffer size in order to implement panning
|
function FramebufferSetVirtual(var Width,Height:LongWord):LongWord; inline;
Description: Set the Virtual Framebuffer Width and Height in Pixels
function FramebufferTestVirtual(var Width,Height:LongWord):LongWord; inline;
Description: Test the Virtual Framebuffer Width and Height in Pixels
function FramebufferGetDepth(var Depth:LongWord):LongWord; inline;
Description: Get the Framebuffer Depth in Bits per Pixel
function FramebufferSetDepth(var Depth:LongWord):LongWord; inline;
Description: Set the Framebuffer Depth in Bits per Pixel
function FramebufferTestDepth(var Depth:LongWord):LongWord; inline;
Description: Test the Framebuffer Depth in Bits per Pixel
function FramebufferGetPixelOrder(var Order:LongWord):LongWord; inline;
Description: Get the Framebuffer Pixel Order (0 = BGR/1 = RGB)
function FramebufferSetPixelOrder(var Order:LongWord):LongWord; inline;
Description: Set the Framebuffer Pixel Order (0 = BGR/1 = RGB)
function FramebufferTestPixelOrder(var Order:LongWord):LongWord; inline;
Description: Test the Framebuffer Pixel Order (0 = BGR/1 = RGB)
function FramebufferGetAlphaMode(var Mode:LongWord):LongWord; inline;
Description: Get the Framebuffer Alpha Mode
function FramebufferSetAlphaMode(var Mode:LongWord):LongWord; inline;
Description: Set the Framebuffer Alpha Mode
function FramebufferTestAlphaMode(var Mode:LongWord):LongWord; inline;
Description: Test the Framebuffer Alpha Mode
function FramebufferGetPitch:LongWord; inline;
Description: Get the Framebuffer Pitch in Bytes per Line
function FramebufferGetOffset(var X,Y:LongWord):LongWord; inline;
Description: Get the Framebuffer Virtual Offset in Pixels
function FramebufferSetOffset(var X,Y:LongWord):LongWord; inline;
Description: Set the Framebuffer Virtual Offset in Pixels
function FramebufferTestOffset(var X,Y:LongWord):LongWord; inline;
Description: Test the Framebuffer Virtual Offset in Pixels
function FramebufferGetOverscan(var Top,Bottom,Left,Right:LongWord):LongWord; inline;
Description: Get the Framebuffer Top, Bottom, Left and Right Overscan in Pixels
function FramebufferSetOverscan(var Top,Bottom,Left,Right:LongWord):LongWord; inline;
Description: Set the Framebuffer Top, Bottom, Left and Right Overscan in Pixels
function FramebufferTestOverscan(var Top,Bottom,Left,Right:LongWord):LongWord; inline;
Description: Test the Framebuffer Top, Bottom, Left and Right Overscan in Pixels
function FramebufferGetPalette(Buffer:Pointer; Length:LongWord):LongWord; inline;
Description: Get the Framebuffer Palette in RGBA values
function FramebufferSetPalette(Start,Count:LongWord; Buffer:Pointer; Length:LongWord):LongWord; inline;
Description: Set the Framebuffer Palette in RGBA values
function FramebufferTestPalette(Start,Count:LongWord; Buffer:Pointer; Length:LongWord):LongWord; inline;
Description: Test the Framebuffer Palette in RGBA values
function FramebufferGetLayer(var Layer:LongInt):LongWord; inline;
Description: Get the Framebuffer Layer
function FramebufferSetLayer(var Layer:LongInt):LongWord; inline;
Description: Set the Framebuffer Layer
function FramebufferTestLayer(var Layer:LongInt):LongWord; inline;
Description: Test the Framebuffer Layer
function FramebufferTestVsync:LongWord; inline;
Description: Test the Framebuffer Vertical Sync (Where Applicable)
function FramebufferSetVsync:LongWord; inline;
Description: Set (Wait For) the Framebuffer Vertical Sync (Where Applicable)
function FramebufferSetBacklight(Brightness:LongWord):LongWord; inline;
Description: Set the Framebuffer Backlight brightness (Where Applicable)
function FramebufferGetNumDisplays(var NumDisplays:LongWord):LongWord; inline;
Description: Get the number of framebuffer displays (Where Applicable)
function FramebufferGetDisplayId(DisplayNum:LongWord):LongWord; inline;
Description: Get the display id for the specified display number (Where Applicable)
function FramebufferSetDisplayNum(DisplayNum:LongWord):LongWord; inline;
Description: Set the current framebuffer display number (Where Applicable)
function FramebufferGetDisplaySettings(DisplayNum:LongWord; var DisplaySettings:TDisplaySettings):LongWord; inline;
Description: Get the display settings for the specified display number (Where Applicable)
function FramebufferDisplayIdToName(DisplayId:LongWord):String; inline;
Description: Get the name for the specified display id (Where Applicable)
Touch functions
function TouchGetBuffer(var Address:PtrUInt):LongWord; inline;
Description: Get the Touchscreen memory buffer (Where Applicable)
function TouchSetBuffer(Address:PtrUInt):LongWord; inline;
Description: Set the Touchscreen memory buffer (Where Applicable)
Cursor functions
function CursorSetDefault:LongWord; inline;
Description: Set the default Cursor Info (Where Applicable)
function CursorSetInfo(Width,Height,HotspotX,HotspotY:LongWord; Pixels:Pointer; Length:LongWord):LongWord; inline;
Description: Set the Cursor Info (Width and Height, Hotspot and Pixel image)
function CursorSetState(Enabled:Boolean; X,Y:LongWord; Relative:Boolean):LongWord; inline;
Description: Set the Cursor State (Enabled, X and Y)
Relative
|
X, Y is relative to Display (Virtual) not Framebuffer (Physical)
|
DMA functions
function DMAAvailable:Boolean; inline;
Description: Check if DMA is currently available
function DMATransfer(Data:PDMAData; Direction,Peripheral:LongWord):LongWord; inline;
Description: Perform a DMA transfer using the list of DMA data blocks provided
Data
|
A linked list of DMA data blocks for the transfer
|
Direction
|
The direction of the DMA request (eg DMA_DIR_MEM_TO_MEM)
|
Peripheral
|
The peripheral Id for data request gating (eg DMA_DREQ_ID_NONE)
|
function DMAFillMemory(Dest:Pointer; Size:LongWord; Value:Byte):LongWord; inline;
Description: Fill memory at the destination address using DMA
Dest
|
The address to start the memory fill
|
Size
|
The size of memory to fill in bytes
|
Value
|
The value to fill the memory with
|
function DMACopyMemory(Source,Dest:Pointer; Size:LongWord):LongWord; inline;
Description: Copy memory from the source to the destination address using DMA
Source
|
The source address to start the memory copy
|
Dest
|
The destination address to start the memory copy
|
Size
|
The size of memory to copy in bytes
|
function DMAReadPeripheral(Address,Dest:Pointer; Size,Peripheral:LongWord):LongWord; inline;
Description: Read from a peripheral address to the destination address using DMA
Address
|
The address of the peripheral register to read from
|
Source
|
The destination address to start writing to
|
Size
|
The size of the read in bytes
|
Peripheral
|
The peripheral Id for data request gating (eg DMA_DREQ_ID_UART_RX)
|
function DMAWritePeripheral(Source,Address:Pointer; Size,Peripheral:LongWord):LongWord; inline;
Description: Write to a peripheral address from the source address using DMA
Source
|
The source address to start reading from
|
Address
|
The address of the peripheral register to write to
|
Size
|
The size of the write in bytes
|
Peripheral
|
The peripheral Id for data request gating (eg DMA_DREQ_ID_UART_TX)
|
function DMAAllocateBuffer(Size:LongWord):Pointer; inline;
Description: Allocate a buffer compatible with DMA memory reads or writes
Size
|
The size of the buffer to allocate
|
function DMAAllocateBufferEx(var Size:LongWord):Pointer; inline;
Description: Allocate a buffer compatible with DMA memory reads or writes
Size
|
The size of the buffer to allocate (Updated on return to actual size)
|
function DMAReleaseBuffer(Buffer:Pointer):LongWord; inline;
Description: Release a buffer allocated with DMAAllocateBuffer
Buffer
|
The buffer to be released
|
function DMAGetChannels:LongWord; inline;
Description: Get the currently enabled DMA channel bitmap (If supported)
Handle functions
function HandleCreate(Data:THandle; AType:LongWord):THandle; inline;
Description: Create and Open a new unnamed handle of the supplied type
Data
|
Purpose specific data to be referenced by the new handle (Optional)
|
AType
|
The type of the new handle (eg HANDLE_TYPE_FILE)
|
Return
|
The newly created handle or INVALID_HANDLE_VALUE on failure
|
function HandleCreateEx(const Name:String; Flags:LongWord; Data:THandle; AType:LongWord):PHandleEntry;
Description: Create and Open a new named or unnamed handle of the supplied type
Name
|
The name of the new handle (Optional)
|
Flags
|
The flags for the new handle (eg HANDLE_FLAG_DUPLICATE)
|
Data
|
Purpose specific data to be referenced by the new handle (Optional)
|
AType
|
The type of the new handle (eg HANDLE_TYPE_FILE)
|
Return
|
The newly created handle entry or nil on failure
|
function HandleDestroy(Handle:THandle):LongWord;
Description: Close and Destroy a named or unnamed handle
Handle
|
The handle to be closed and destroyed
|
Return
|
ERROR_SUCCESS if completed successfully or another error code on failure
|
Note
|
For handles which have been opened multiple times, the handle is not destroyed until the last reference is closed. If there are still open references to the handle the return value will be ERROR_IN_USE instead of ERROR_SUCCESS
|
function HandleGet(Handle:THandle):PHandleEntry;
Description: Get the handle entry for the supplied handle
Handle
|
The handle to get the entry for
|
Return
|
The handle entry on success or nil on failure
|
function HandleFind(const Name:String):PHandleEntry;
Description: Find an existing named handle of the supplied type
Name
|
The name of the handle to find
|
Return
|
The handle entry on success or nil on failure
|
function HandleEnumerate(Callback:THandleEnumerate; Data:Pointer):LongWord;
Description: Enumerate all handles in the handle table
Callback
|
The callback function to call for each handle in the table
|
Data
|
A private data pointer to pass to callback for each device in the table
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function HandleOpen(const Name:String):THandle;
Description: Open an existing named handle
Name
|
The name of the handle to open
|
Return
|
The handle matching the name or INVALID_HANDLE_VALUE on failure
|
function HandleClose(Handle:THandle):LongWord; inline;
Description: Close a named or unnamed handle
Handle
|
The handle to be closed
|
Return
|
ERROR_SUCCESS if completed successfully or another error code on failure
|
Note
|
For handles which have been opened multiple times, the handle is destroyed when the last reference is closed
|
function HandleDuplicate(Handle:THandle):THandle;
Description: Duplicate an existing named or unnamed handle
Handle
|
The handle to be duplicated
|
Return
|
The newly duplicated handle or INVALID_HANDLE_VALUE on failure
|
Note
|
Handles must be marked as HANDLE_FLAG_DUPLICATE to support duplication
|
GPIO functions
function GPIOAvailable:Boolean; inline;
Description: Check if a GPIO device is available
Reg
|
The memory register to read from
|
Value
|
The value of the memory register
|
function GPIORead(Reg:LongWord):LongWord; inline;
Description: Perform a direct read from a GPIO register
Reg
|
The memory register to read from
|
Value
|
The value of the memory register
|
procedure GPIOWrite(Reg,Value:LongWord); inline;
Description: Perform a direct write to a GPIO register
Reg
|
The memory register to write to
|
Value
|
The value to write to the register
|
function GPIOInputGet(Pin:LongWord):LongWord; inline;
Description: Get the current state of a GPIO input pin
Pin
|
The pin to get the state for (eg GPIO_PIN_1)
|
Return
|
The current state (eg GPIO_LEVEL_HIGH) or GPIO_LEVEL_UNKNOWN on failure
|
function GPIOInputWait(Pin,Trigger,Timeout:LongWord):LongWord; inline;
Description: Wait for the state of a GPIO input pin to change
Pin
|
The pin to wait for the state to change (eg GPIO_PIN_1)
|
Trigger
|
The trigger event to wait for (eg GPIO_TRIGGER_HIGH)
|
Timeout
|
Number of milliseconds to wait for the change (INFINITE to wait forever)
|
Return
|
The state after the change (eg GPIO_LEVEL_HIGH) or GPIO_LEVEL_UNKNOWN on failure or timeout
|
function GPIOInputEvent(Pin,Trigger,Timeout:LongWord; Callback:TGPIOCallback; Data:Pointer):LongWord; inline;
Description: Schedule a function to be called when the state of a GPIO input pin changes
Pin
|
The pin to schedule the state change for (eg GPIO_PIN_1)
|
Trigger
|
The trigger event which will cause the function to be called (eg GPIO_TRIGGER_HIGH)
|
Timeout
|
The number of milliseconds before the scheduled trigger expires (INFINITE to never expire)
|
Callback
|
The function to be called when the trigger occurs
|
Data
|
A pointer to be pass to the function when the trigger occurs (Optional)
|
Return
|
ERROR_SUCCESS if the trigger was scheduled successfully or another error code on failure
|
Note
|
The pin and trigger that caused the event will be passed to the callback function
|
function GPIOOutputSet(Pin,Level:LongWord):LongWord; inline;
Description: Change the state of a GPIO output pin
Pin
|
The pin to change the state for (eg GPIO_PIN_1)
|
Level
|
The state to change the pin to (eg GPIO_LEVEL_HIGH)
|
Return
|
ERROR_SUCCESS if completed successfully or another error code on failure
|
function GPIOLevelGet(Pin:LongWord):LongWord; inline;
Description: Get the current level (state) of a GPIO pin
Pin
|
The pin to get the level for (eg GPIO_PIN_1)
|
Return
|
The current level (eg GPIO_LEVEL_HIGH) or GPIO_LEVEL_UNKNOWN on failure
|
Note
|
This function is a synonym for GPIOInputGet as in many cases the level can be read from a pin regardless of input or output mode. This may help to make code clearer or easier to understand in some cases.
|
function GPIOLevelSet(Pin,Level:LongWord):LongWord; inline;
Description: Set the level (state) of a GPIO pin
Pin
|
The pin to set the level for (eg GPIO_PIN_1)
|
Level
|
The level to set the pin to (eg GPIO_LEVEL_HIGH)
|
Return
|
ERROR_SUCCESS if completed successfully or another error code on failure
|
Note
|
This function is a synonym for GPIOOutputSet as in many cases the level can be set for a pin regardless of input or output mode. This may help to make code clearer or easier to understand in some cases.
|
function GPIOPullGet(Pin:LongWord):LongWord; inline;
Description: Get the current pull state of a GPIO pin
Pin
|
The pin to get the pull state for (eg GPIO_PIN_1)
|
Return
|
The current pull state of the pin (eg GPIO_PULL_UP) or GPIO_PULL_UNKNOWN on failure
|
function GPIOPullSelect(Pin,Mode:LongWord):LongWord; inline;
Description: Change the pull state of a GPIO pin
Pin
|
The pin to change the pull state for (eg GPIO_PIN_1)
|
Mode
|
The pull state to set for the pin (eg GPIO_PULL_UP)
|
Return
|
ERROR_SUCCESS if completed successfully or another error code on failure
|
function GPIOFunctionGet(Pin:LongWord):LongWord; inline;
Description: Get the current function of a GPIO pin
Pin
|
The pin to get the function for (eg GPIO_PIN_1)
|
Return
|
The current function of the pin (eg GPIO_FUNCTION_IN) or GPIO_FUNCTION_UNKNOWN on failure
|
function GPIOFunctionSelect(Pin,Mode:LongWord):LongWord; inline;
Description: Change the function of a GPIO pin
Pin
|
The pin to change the function for (eg GPIO_PIN_1)
|
Mode
|
The function to set for the pin (eg GPIO_FUNCTION_OUT)
|
Return
|
ERROR_SUCCESS if completed successfully or another error code on failure
|
Virtual GPIO functions
function VirtualGPIOInputGet(Pin:LongWord):LongWord; inline;
Description: Get the current state of a virtual GPIO input pin
Pin
|
The pin to get the state for (eg VIRTUAL_GPIO_PIN_1)
|
Return
|
The current state (eg GPIO_LEVEL_HIGH) or GPIO_LEVEL_UNKNOWN on failure
|
function VirtualGPIOOutputSet(Pin,Level:LongWord):LongWord; inline;
Description: Set the state of a virtual GPIO output pin
Pin
|
The pin to set the state for (eg GPIO_PIN_1)
|
Level
|
The state to set the pin to (eg GPIO_LEVEL_HIGH)
|
Return
|
ERROR_SUCCESS if completed successfully or another error code on failure
|
function VirtualGPIOLevelGet(Pin:LongWord):LongWord; inline;
Description: Get the current level (state) of a virtual GPIO pin
Pin
|
The pin to get the level for (eg GPIO_PIN_1)
|
Return
|
The current level (eg GPIO_LEVEL_HIGH) or GPIO_LEVEL_UNKNOWN on failure
|
Note
|
This function is a synonym for VirtualGPIOInputGet as in many cases the level can be read from a pin regardless of input or output mode. This may help to make code clearer or easier to understand in some cases.
|
function VirtualGPIOLevelSet(Pin,Level:LongWord):LongWord; inline;
Description: Set the level (state) of a virtual GPIO pin
Pin
|
The pin to set the level for (eg GPIO_PIN_1)
|
Level
|
The level to set the pin to (eg GPIO_LEVEL_HIGH)
|
Return
|
ERROR_SUCCESS if completed successfully or another error code on failure
|
Note
|
This function is a synonym for VirtualGPIOOutputSet as in many cases the level can be set for a pin regardless of input or output mode. This may help to make code clearer or easier to understand in some cases.
|
function VirtualGPIOFunctionGet(Pin:LongWord):LongWord; inline;
Description: Get the current function of a virtual GPIO pin
Pin
|
The pin to get the function for (eg GPIO_PIN_1)
|
Return
|
The current function of the pin (eg GPIO_FUNCTION_IN) or GPIO_FUNCTION_UNKNOWN on failure
|
function VirtualGPIOFunctionSelect(Pin,Mode:LongWord):LongWord; inline;
Description: Change the function of a virtual GPIO pin
Pin
|
The pin to change the function for (eg GPIO_PIN_1)
|
Mode
|
The function to set for the pin (eg GPIO_FUNCTION_OUT)
|
Return
|
ERROR_SUCCESS if completed successfully or another error code on failure
|
SPI functions
function SPIAvailable:Boolean; inline;
Description: Check if an SPI device is available
function SPIStart(Mode,ClockRate,ClockPhase,ClockPolarity:LongWord):LongWord; inline;
Description: Start the default SPI device ready for writing and reading
Mode
|
The device mode to set (eg SPI_MODE_4WIRE)
|
ClockRate
|
The clock rate to set for the device
|
ClockPhase
|
The clock phase to set (eg SPI_CLOCK_PHASE_LOW)
|
ClockPolarity
|
The clock polarity to set (eg SPI_CLOCK_POLARITY_LOW)
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIStop:LongWord; inline;
Description: Stop the default SPI device and terminate writing and reading
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIRead(ChipSelect:Word; Dest:Pointer; Size:LongWord; var Count:LongWord):LongWord; inline;
Description: Read data from the default SPI device. Because SPI writes and then reads for each byte, dummy data will be written for each byte to be read.
ChipSelect
|
The chip select for the slave to read from (eg SPI_CS_0)
|
Dest
|
Pointer to a buffer to receive the data
|
Size
|
The size of the buffer
|
Count
|
The number of bytes read on return
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIWrite(ChipSelect:Word; Source:Pointer; Size:LongWord; var Count:LongWord):LongWord; inline;
Description: Write data to the default SPI device. Because SPI writes and then reads for each byte, received data will be discarded for each byte written.
ChipSelect
|
The chip select for the slave to write to (eg SPI_CS_0)
|
Source
|
Pointer to a buffer of data to transmit
|
Size
|
The size of the buffer
|
Count
|
The number of bytes written on return
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIWriteRead(ChipSelect:Word; Source,Dest:Pointer; Size:LongWord; var Count:LongWord):LongWord; inline;
Description: Write data to and Read data from the default SPI device in one operation. Because SPI writes and then reads for each byte, both the source and dest buffers must be the same size.
ChipSelect
|
The chip select for the slave to write to and read from (eg SPI_CS_0)
|
Source
|
Pointer to a buffer of data to transmit
|
Dest
|
Pointer to a buffer to receive the data
|
Size
|
The size of the buffer
|
Count
|
The number of bytes written and read on return
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIGetMode:LongWord; inline;
Description: Get the device mode of the default SPI device
Return
|
The device mode or SPI_MODE_UNKNOWN on failure
|
function SPISetMode(Mode:LongWord):LongWord; inline;
Description: Set the device mode for the default SPI device
Mode
|
The device mode to set (eg SPI_MODE_4WIRE)
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIGetClockRate(ChipSelect:Word):LongWord; inline;
Description: Get the clock rate of the default SPI device
ChipSelect
|
The chip select number to get clock rate from (SPI_CS_NONE for default)
|
Return
|
The clock rate in Hz or 0 on failure
|
function SPISetClockRate(ChipSelect:Word;ClockRate:LongWord):LongWord; inline;
Description: Set the clock rate for the default SPI device
ClockRate
|
The clock rate to set in Hz
|
ChipSelect
|
The chip select number to set clock rate for (SPI_CS_NONE for default)
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIGetClockPhase:LongWord; inline;
Description: Get the clock phase of the default SPI device
Return
|
The clock phase or SPI_CLOCK_PHASE_UNKNOWN on failure
|
function SPISetClockPhase(ClockPhase:LongWord):LongWord; inline;
Description: Set the clock phase for the default SPI device
ClockPhase
|
The clock phase to set (eg SPI_CLOCK_PHASE_LOW)
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIGetClockPolarity:LongWord; inline;
Description: Get the clock polarity of the default SPI device
Return
|
The clock polarity or SPI_CLOCK_POLARITY_UNKNOWN on failure
|
function SPISetClockPolarity(ClockPolarity:LongWord):LongWord; inline;
Description: Set the clock polarity for the default SPI device
ClockPolarity
|
The clock polarity to set (eg SPI_CLOCK_POLARITY_LOW)
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIGetSelectPolarity(ChipSelect:Word):LongWord; inline;
Description: Get the chip select polarity of the default SPI device
ChipSelect
|
The chip select number to get polarity from (SPI_CS_NONE for default)
|
Return
|
The chip select polarity or SPI_CS_POLARITY_UNKNOWN on failure
|
function SPISetSelectPolarity(ChipSelect:Word; SelectPolarity:LongWord):LongWord; inline;
Description: Set the chip select polarity for the default SPI device
ChipSelect
|
The chip select number to set polarity for (SPI_CS_NONE for default)
|
SelectPolarity
|
The chip select polarity to set (eg SPI_CS_POLARITY_LOW)
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function SPIGetDescription(Id:LongWord):String; inline;
Description: Return the device description of an SPI device
Id
|
The Id number of the SPI device as shown in the official documentation
|
Return
|
The correct device description suitable for passing to SPIDeviceFindByDescription
|
Note
|
The Id number supplied to this function may differ from the Ultibo device id value
|
I2C functions
function I2CAvailable:Boolean; inline;
Description: Check if an I2C device is available
function I2CStart(Rate:LongWord):LongWord; inline;
Description: Start the default I2C device ready for reading and writing
Rate
|
The clock rate to set for the device (0 to use the default rate)
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function I2CStop:LongWord; inline;
Description: Stop the default I2C device and terminate reading and writing
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function I2CRead(Address:Word; Buffer:Pointer; Size:LongWord; var Count:LongWord):LongWord; inline;
Description: Read data from the default I2C device
Address
|
The slave address to read from (I2C_ADDRESS_INVALID to use the current address)
|
Buffer
|
Pointer to a buffer to receive the data
|
Size
|
The size of the buffer
|
Count
|
The number of bytes read on return
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function I2CWrite(Address:Word; Buffer:Pointer; Size:LongWord; var Count:LongWord):LongWord; inline;
Description: Write data to the default I2C device
Address
|
The slave address to write to (I2C_ADDRESS_INVALID to use the current address)
|
Buffer
|
Pointer to a buffer of data to transmit
|
Size
|
The size of the buffer
|
Count
|
The number of bytes written on return
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function I2CWriteRead(Address:Word; Initial:Pointer; Len:LongWord; Data:Pointer; Size:LongWord; var Count:LongWord):LongWord; inline;
Description: Write data to and Read data from the default I2C device in one operation. Useful for devices that require a register address specified before a read (eg EEPROM devices)
Address
|
The slave address to write to (I2C_ADDRESS_INVALID to use the current address)
|
Initial
|
Pointer to the initial buffer to transmit
|
Len
|
The size of the initial buffer
|
Data
|
Pointer to a buffer to receive the data
|
Size
|
The size of the data buffer
|
Count
|
The number of bytes read on return
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function I2CWriteWrite(Address:Word; Initial:Pointer; Len:LongWord; Data:Pointer; Size:LongWord; var Count:LongWord):LongWord; inline;
Description: Write 2 data blocks to the default I2C device in one operation. Useful for devices that require a register address specified before a write (eg EEPROM devices)
Address
|
The slave address to write to (I2C_ADDRESS_INVALID to use the current address)
|
Initial
|
Pointer to the initial buffer to transmit
|
Len
|
The size of the initial buffer
|
Data
|
Pointer to a buffer of data to transmit
|
Size
|
The size of the data buffer
|
Count
|
The number of bytes of data written on return
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function I2CGetRate:LongWord; inline;
Description: Get the clock rate of the default I2C device
Return
|
The clock rate in Hz or 0 on failure
|
function I2CSetRate(Rate:LongWord):LongWord; inline;
Description: Set the clock rate for the default I2C device
Rate
|
The clock rate to set in Hz
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function I2CGetAddress:Word; inline;
Description: Get the slave address for the default I2C device
Return
|
The slave address or I2C_ADDRESS_INVALID on failure
|
function I2CSetAddress(Address:Word):LongWord; inline;
Description: Set the slave address for the default I2C device
Address
|
The slave address to set
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function I2CGetDescription(Id:LongWord):String; inline;
Description: Get the device description of an I2C device
Id
|
The Id number of the I2C device as shown in the official documentation
|
Return
|
The correct device description suitable for passing to I2CDeviceFindByDescription
|
Note
|
The Id number supplied to this function may differ from the Ultibo device id value
|
function I2CSlaveGetDescription(Id:LongWord):String; inline;
Description: Get the device description of an I2C slave device
Id
|
The Id number of the I2C slave device as shown in the official documentation
|
Return
|
The correct device description suitable for passing to I2CSlaveFindByDescription
|
Note
|
The Id number supplied to this function may differ from the Ultibo device id value
|
PWM functions
function PWMAvailable:Boolean; inline;
Description: Check if a PWM device is available
function PWMStart:LongWord; inline;
Description: Start the default PWM device
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function PWMStop:LongWord; inline;
Description: Stop the default PWM device
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function PWMWrite(Value:LongWord):LongWord; inline;
Description: Write a value to the default PWM device
Value
|
The value to write
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
Note
|
The exact meaning of value may depend on the device and other configured options, in many cases the value will represent the "on" time of each pulse with regard to the duty cycle of the waveform output by the device
|
function PWMSetMode(Mode:LongWord):LongWord; inline;
Description: Set the mode for the default PWM device
Mode
|
The mode value to set (eg PWM_MODE_MARKSPACE)
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function PWMSetRange(Range:LongWord):LongWord; inline;
Description: Set the range for the default PWM device
Range
|
The range value to set
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
Note
|
The exact meaning of range may depend on the device and other configured options, in many cases the range will represent the period of one full cycle of the waveform output by the device
|
function PWMSetFrequency(Frequency:LongWord):LongWord; inline;
Description: Set the clock frequency for the default PWM device
Frequency
|
The frequency to set in Hz
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function PWMConfigure(DutyNS,PeriodNS:LongWord):LongWord; inline;
Description: Set the configuration of the default PWM device
DutyNS
|
The "on" time part of the cycle (Nanoseconds)
|
PeriodNS
|
The duration of one full cycle (Nanoseconds)
|
Return
|
ERROR_SUCCESS if completed or another error code on failure
|
function PWMGetDescription(Id,Channel:LongWord):String; inline;
Description: Get the device description of an PWM device
Id
|
The Id number of the PWM device as shown in the official documentation
|
Channel
|
The channel number of the PWM device as shown in the official documentation
|
Return
|
The correct device description suitable for passing to PWMDeviceFindByDescription
|
Note
|
The Id number supplied to this function may differ from the Ultibo device id value
|
RTC functions
function RTCAvailable:Boolean; inline;
Description: Check if a Real Time Clock (RTC) device is available
function RTCGetTime:Int64; inline;
Description: Get the current time from a Real Time Clock device
Note
|
Returned time is 100 nanosecond ticks since 1 January 1601. The same format as the ClockGetTime function.
|
function RTCSetTime(const Time:Int64):Int64; inline;
Description: Set the current time for a Real Time Clock device
Time
|
The time to be set
|
Return
|
The device time after setting (or 0 on failure)
|
Note
|
Time and returned time is 100 nanosecond ticks since 1 January 1601. The same format as the ClockSetTime function.
|
UART functions
function UARTGetDescription(Id:LongWord):String; inline;
Description: Get the device description of a UART device
Id
|
The Id number of the UART device as shown in the official documentation
|
Return
|
The correct device description suitable for passing to UARTDeviceFindByDescription
|
Note
|
The Id number supplied to this function may differ from the Ultibo device id value
|
Serial functions
function SerialAvailable:Boolean; inline;
Description: Check if a Serial device is available
function SerialOpen(BaudRate,DataBits,StopBits,Parity,FlowControl,ReceiveDepth,TransmitDepth:LongWord):LongWord; inline;
Description: Open the default Serial device ready for sending and receiving
BaudRate
|
Baud rate for the connection (eg 9600, 57600, 115200 etc
|
DataBits
|
Size of the data (eg SERIAL_DATA_8BIT)
|
StopBits
|
Number of stop bits (eg SERIAL_STOP_1BIT)
|
Parity
|
Parity type for the data (eg SERIAL_PARITY_NONE)
|
FlowControl
|
Flow control for the connection (eg SERIAL_FLOW_NONE)
|
ReceiveDepth
|
Size of the receive buffer (0 = Default size)
|
TransmitDepth
|
Size of the transmit buffer (0 = Default size)
|
function SerialClose:LongWord; inline;
Description: Close the default Serial device and terminate sending and receiving
function SerialRead(Buffer:Pointer; Size:LongWord; var Count:LongWord):LongWord; inline;
Description: Read data from the default Serial device
Buffer
|
Pointer to a buffer to receive the data
|
Size
|
The size of the buffer
|
Count
|
The number of bytes read on return
|
function SerialWrite(Buffer:Pointer; Size:LongWord; var Count:LongWord):LongWord; inline;
Description: Write data to the default Serial device
Buffer
|
Pointer to a buffer of data to transmit
|
Size
|
The size of the buffer
|
Count
|
The number of bytes written on return
|
Peripheral functions
function PeripheralGetBase:PtrUInt; inline;
Description: Get the base address of the peripherals
function PeripheralGetSize:LongWord; inline;
Description: Get the total size of the peripherals
function PeripheralRead(Base,Reg:LongWord):LongWord; inline;
Description: Read from a Peripheral register
procedure PeripheralWrite(Base,Reg,Value:LongWord); inline;
Description: Write to a Peripheral register
function LocalPeripheralGetBase:PtrUInt; inline;
Description: Get the base address of the local peripherals (Peripherals local to each CPU)
function LocalPeripheralGetSize:LongWord; inline;
Description: Get the total size of the local peripherals (Peripherals local to each CPU)
System functions
function GetSP:PtrUInt; inline;
Description: Get the current stack pointer (SP)
function GetPC:PtrUInt; inline;
Description: Get the current program counter (PC)
function GetIRQ:Boolean; inline;
Description: Get Interrupts (IRQ) state
Return
|
True is enabled, False if disabled
|
procedure EnableIRQ; inline;
Description: Enable Interrupts (IRQ) unconditionally
procedure DisableIRQ; inline;
Description: Disable Interrupts (IRQ) unconditionally
function SaveIRQ:TIRQMask; inline;
Description: Disable Interrupts (IRQ) and return the previous state
Return
|
IRQ state when called
|
function RestoreIRQ(IRQMask:TIRQMask):TIRQMask; inline;
Description: Restore Interrupts (IRQ) to a previous state
IRQMask
|
IRQ state to restore
|
Return
|
IRQ state when called
|
function GetFIQ:Boolean; inline;
Description: Get Fast Interrupts (FIQ) state
Return
|
True is enabled, False if disabled
|
procedure EnableFIQ; inline;
Description: Enable Fast Interrupts (FIQ) unconditionally
procedure DisableFIQ; inline;
Description: Disable Fast Interrupts (FIQ) unconditionally
function SaveFIQ:TFIQMask; inline;
Description: Disable Fast Interrupts (FIQ) and return the previous state
Return
|
FIQ state when called
|
function RestoreFIQ(FIQMask:TFIQMask):TFIQMask; inline;
Description: Restore Fast Interrupts (FIQ) to a previous state
FIQMask
|
FIQ state to restore
|
Return
|
FIQ state when called
|
procedure EnableIRQFIQ; inline;
Description: Enable Interrupts and Fast Interrupts (IRQ/FIQ) unconditionally
procedure DisableIRQFIQ; inline;
Description: Disable Interrupts and Fast Interrupts (IRQ/FIQ) unconditionally
function SaveIRQFIQ:TIRQFIQMask; inline;
Description: Disable Interrupts and Fast Interrupts (IRQ/FIQ) and return the previous state
Return
|
IRQ/FIQ state when called
|
function RestoreIRQFIQ(IRQFIQMask:TIRQFIQMask):TIRQFIQMask; inline;
Description: Restore Interrupts and Fast Interrupts (IRQ/FIQ) to a previous state
IRQFIQMask
|
IRQ/FIQ state to restore
|
Return
|
IRQ/FIQ state when called
|
function GetAbort:Boolean; inline;
Description: Get Abort state
Return
|
True is enabled, False if disabled
|
procedure EnableAbort; inline;
Description: Enable Abort unconditionally
procedure DisableAbort; inline;
Description: Disable Abort unconditionally
function SaveAbort:TAbortMask; inline;
Description: Disable Abort and return the previous state
Return
|
Abort state when called
|
function RestoreAbort(AbortMask:TAbortMask):TAbortMask; inline;
Description: Restore Abort to a previous state
AbortMask
|
Abort state to restore
|
Return
|
Abort state when called
|
procedure Halt; inline;
Description: Halt the current processor
procedure Pause; inline;
Description: Pause the current processor and wait for an Event or Interrupt (Where Applicable)
function HaltThread(ExitCode:LongWord):LongWord; inline;
Description: Halt the current thread
procedure SendEvent; inline;
Description: Send a signal that an Event has occurred (Where Applicable)
procedure WaitForEvent; inline;
Description: Wait for an Event to occur (Where Applicable)
procedure WaitForInterrupt; inline;
Description: Wait for an Interrupt to occur (Where Applicable)
procedure ReadMemoryBarrier; inline;
Description: Perform a Read Memory Barrier operation (Where Applicable)
procedure WriteMemoryBarrier; inline;
Description: Perform a Write Memory Barrier operation (Where Applicable)
procedure DataMemoryBarrier; inline;
Description: Perform a Data Memory Barrier operation (Where Applicable)
procedure DataSynchronizationBarrier; inline;
Description: Perform a Data Synchronization Barrier operation (Where Applicable)
procedure InstructionMemoryBarrier; inline;
Description: Perform an Instruction Memory Barrier operation (Where Applicable)
procedure InvalidateTLB; inline;
Description: Perform an Invalidate Entire TLB operation (Where Applicable)
procedure InvalidateDataTLB; inline;
Description: Perform an Invalidate Data TLB operation (Where Applicable)
procedure InvalidateInstructionTLB; inline;
Description: Perform an Invalidate Instruction TLB operation (Where Applicable)
procedure InvalidateCache; inline;
Description: Perform an Invalidate Entire Cache operation (Where Applicable)
procedure CleanDataCache; inline;
Description: Perform a Clean Data Cache operation (Where Applicable)
procedure InvalidateDataCache; inline;
Description: Perform an Invalidate Data Cache operation (Where Applicable)
procedure CleanAndInvalidateDataCache; inline;
Description: Perform a Clean and Invalidate Data Cache operation (Where Applicable)
procedure InvalidateInstructionCache; inline;
Description: Perform an Invalidate Instruction Cache operation (Where Applicable)
procedure CleanDataCacheRange(Address:PtrUInt; Size:LongWord); inline;
Description: Perform a Clean Data Cache Range operation (Where Applicable)
procedure InvalidateDataCacheRange(Address:PtrUInt; Size:LongWord); inline;
Description: Perform an Invalidate Data Cache Range operation (Where Applicable)
procedure CleanAndInvalidateDataCacheRange(Address:PtrUInt; Size:LongWord); inline;
Description: Perform a Clean and Invalidate Data Cache Range operation (Where Applicable)
procedure InvalidateInstructionCacheRange(Address:PtrUInt; Size:LongWord); inline;
Description: Perform an Invalidate Instruction Cache Range operation (Where Applicable)
procedure FlushPrefetchBuffer; inline;
Description: Perform a Flush Prefetch Buffer operation (Where Applicable)
procedure FlushBranchTargetCache; inline;
Description: Perform a Flush Entire Branch Target Cache operation (Where Applicable)
procedure ContextSwitch(OldStack,NewStack:Pointer; NewThread:TThreadHandle); inline;
Description: Perform a Context Switch from one thread to another
procedure ContextSwitchIRQ(OldStack,NewStack:Pointer; NewThread:TThreadHandle); inline;
Description: Perform a Context Switch from one thread to another from an IRQ handler
procedure ContextSwitchFIQ(OldStack,NewStack:Pointer; NewThread:TThreadHandle); inline;
Description: Perform a Context Switch from one thread to another from an FIQ handler
procedure ContextSwitchSWI(OldStack,NewStack:Pointer; NewThread:TThreadHandle); inline;
Description: Perform a Context Switch from one thread to another from a software interrupt handler
function InterlockedOr(var Target:LongInt;Value:LongInt):LongInt; inline;
Description: Perform an atomic OR operation
function InterlockedXor(var Target:LongInt; Value:LongInt):LongInt; inline;
Description: Perform an atomic XOR operation
function InterlockedAnd(var Target:LongInt; Value:LongInt):LongInt; inline;
Description: Perform an atomic AND operation
function InterlockedDecrement(var Target:LongInt):LongInt; inline;
Description: Perform an atomic decrement operation
function InterlockedIncrement(var Target:LongInt):LongInt; inline;
Description: Perform an atomic increment operation
function InterlockedExchange(var Target:LongInt; Source:LongInt):LongInt; inline;
Description: Perform an atomic exchange operation
function InterlockedAddExchange(var Target:LongInt; Source:LongInt):LongInt; inline;
Description: Perform an atomic add and exchange operation
function InterlockedCompareExchange(var Target:LongInt; Source,Compare:LongInt):LongInt; inline;
Description: Perform an atomic compare and exchange operation
function PageTableGetLevels:LongWord; inline;
Description: Get the number of page table levels for the current platform
function PageDirectoryGetBase:PtrUInt; inline;
Description: Get the base address of the first level page directory (Where applicable)
function PageDirectoryGetSize:LongWord; inline;
Description: Get the size of the first level page directory (Where applicable)
function PageTableGetBase:PtrUInt; inline;
Description: Get the base address of the first or second level page table
function PageTableGetSize:LongWord; inline;
Description: Get the size of the first or second level page table
function PageTableGetEntry(Address:PtrUInt):TPageTableEntry; overload;
Description: Get the Page Table entry that corresponds to the supplied virtual address
procedure PageTableGetEntry(Address:PtrUInt; var Entry:TPageTableEntry); inline; overload;
Description: Get the Page Table entry that corresponds to the supplied virtual address
function PageTableSetEntry(const Entry:TPageTableEntry):LongWord; inline;
Description: Set the Page Table entry that corresponds to the supplied virtual address
function PageTableGetPageSize(Address:PtrUInt):LongWord; inline;
Description: Get the Size from the Page Table page that corresponds to the supplied virtual address
function PageTableGetPageFlags(Address:PtrUInt):LongWord; inline;
Description: Get the Flags from the Page Table page that corresponds to the supplied virtual address
function PageTableGetPageRange(Address:PtrUInt):LongWord; inline;
Description: Get the Physical Range from the Page Table page that corresponds to the supplied virtual address
function PageTableGetPagePhysical(Address:PtrUInt):PtrUInt; inline;
Description: Get the Physical Address from the Page Table page that corresponds to the supplied virtual address
function PageTablesGetAddress:PtrUInt; inline;
Description: Get the address of the second or third level page tables
function PageTablesGetLength:LongWord; inline;
Description: Get the size of the second or third level page tables
function PageTablesGetCount:LongWord; inline;
Description: Get the number of second or third level page tables
function PageTablesGetShift:LongWord; inline;
Description: Get the multiplier to convert count to actual size of the second or third level page tables
function PageTablesGetNext:PtrUInt; inline;
Description: Get the address of the next available second or third level page table
function PageTablesGetUsed:LongWord; inline;
Description: Get the number of used second or third level page tables
function PageTablesGetFree:LongWord; inline;
Description: Get the number of available second or third level page tables
function VectorTableGetBase:PtrUInt; inline;
Description: Get the base address of the interrupt vector table
function VectorTableGetSize:LongWord; inline;
Description: Get the size in bytes of the interrupt vector table
function VectorTableGetCount:LongWord; inline;
Description: Get the number of entries in the interrupt vector table
function VectorTableGetEntry(Number:LongWord):PtrUInt; inline;
Description: Get the interrupt vector table entry that corresponds to the supplied number
function VectorTableSetEntry(Number:LongWord; Address:PtrUInt):LongWord; inline;
Description: Set the interrupt vector table entry that corresponds to the supplied number
Exception functions
procedure HardwareException(AType:LongWord; Address,Frame:Pointer);
Description: To be documented
procedure UnhandledException(Obj:TObject; Addr:CodePointer; FrameCount:LongInt; Frames:PCodePointer);
Description: To be documented
Text IO functions
procedure TextIOOpen(var F:Text; AWrite:TTextIOWriteChar; ARead:TTextIOReadChar; AMode:LongInt; AUserData:Pointer);
Description: Open a text file with the input or output directed to the default text IO device
procedure TextIOClose(var T:TextRec);
Description: Close a text file that was opened by TextIOOpen (Dummy only)
procedure TextIORead(var T:TextRec);
Description: Internal read function for text files using the text IO device
Note
|
Not intended to be called directly by applications, use Read or ReadLn instead
|
procedure TextIOWrite(var T:TextRec);
Description: Internal write function for text files using the text IO device
Note
|
Not intended to be called directly by applications, use Write or WriteLn instead
|
function TextIOReadData(ARead:TTextIOReadChar; AUserData:Pointer; ABuffer:PChar; ACount:LongInt):LongInt;
Description: Internal read function for text files using the text IO device
Note
|
Not intended to be called directly by applications, use Read or ReadLn instead
|
function TextIOWriteChar(ACh:Char; AUserData:Pointer):Boolean; inline;
Description: Output a character to the default text IO device
Note
|
Not intended to be called directly by applications, use Write or WriteLn instead
|
function TextIOReadChar(var ACh:Char; AUserData:Pointer):Boolean; inline;
Description: Input a character from the default text IO device
Note
|
Not intended to be called directly by applications, use Read or ReadLn instead
|
function TextIOWriteBuffer(ABuffer:PChar; ACount:LongInt; AUserData:Pointer):LongInt;
Description: Output one or more characters to the default text IO device
Note
|
Not intended to be called directly by applications, use Write or WriteLn instead
|
Console functions
function ConsoleGetKey(var ACh:Char; AUserData:Pointer):Boolean; inline;
Description: To be documented
function ConsolePeekKey(var ACh:Char; AUserData:Pointer):Boolean; inline;
Description: To be documented
function ConsoleWriteChar(ACh:Char; AUserData:Pointer):Boolean; inline;
Description: To be documented
function ConsoleReadChar(var ACh:Char; AUserData:Pointer):Boolean; inline;
Description: To be documented
function ConsoleReadWideChar(var ACh:WideChar; AUserData:Pointer):Boolean; inline;
Description: To be documented
function ConsoleHideMouse(AUserData:Pointer):Boolean; inline;
Description: To be documented
function ConsoleShowMouse(X,Y:LongWord; AUserData:Pointer):Boolean; inline;
Description: To be documented
function ConsoleReadMouse(var X,Y,Buttons:LongWord; AUserData:Pointer):Boolean; inline;
Description: To be documented
CodePage functions
function CodePageToWideChar(Ch:Char):WideChar; inline;
Description: To be documented
function WideCharToCodePage(Ch:WideChar):Char; inline;
Description: To be documented
Name functions
function HostGetName:String; inline;
Description: To be documented
function HostSetName(const AName:String):Boolean; inline;
Description: To be documented
function HostGetDomain:String; inline;
Description: To be documented
function HostSetDomain(const ADomain:String):Boolean; inline;
Description: To be documented
Module functions
function ModuleLoad(const AName:String):THandle; inline;
Description: To be documented
function ModuleUnload(AHandle:THandle):Boolean; inline;
Description: To be documented
function ModuleGetName(AHandle:THandle):String; inline;
Description: To be documented
Symbol functions
function SymbolAdd(AHandle:THandle; const AName:String; AAddress:PtrUInt):Boolean; inline;
Description: To be documented
function SymbolRemove(AHandle:THandle; const AName:String):Boolean; inline;
Description: To be documented
function SymbolGetAddress(AHandle:THandle; const AName:String):PtrUInt; inline;
Description: To be documented
Logging functions
procedure LoggingOutput(const AText:String); inline;
Description: To be documented
procedure LoggingOutputEx(AFacility,ASeverity:LongWord; const ATag,AContent:String); inline;
Description: To be documented
Environment functions
function EnvironmentGet(const AName:String):String; inline;
Description: Locate an environment variable and return the current value
Name
|
The name of the variable to locate (eg TZ)
|
Return
|
The value of the variable or an empty string if not found
|
function EnvironmentSet(const AName,AValue:String):LongWord; inline;
Description: Add an environment variable or update an existing variable
Name
|
The name of the variable to add or update (eg TZ)
|
Value
|
The new value of the variable (eg EST+5)
|
Return
|
ERROR_SUCCESS if the value was set or another error code on failure
|
function EnvironmentCount(AReset:Boolean):LongWord; inline;
Description: Get the current number of environment variables
Reset
|
If True then force a recount
|
Return
|
The number of environment variables
|
function EnvironmentIndex(const AName:String):LongWord; inline;
Description: Locate an environment variable and return the index
Name
|
The name of the variable to locate (eg TZ)
|
Return
|
The index of the environment variable or 0 if not found
|
function EnvironmentString(AIndex:LongWord):String; inline;
Description: Get an environment variable by index
Index
|
The index of the variable to get (1 to EnvironmentCount)
|
Return
|
The environment variable or an empty string of index is not valid
|
function EnvironmentSetDefault(const AName,AValue:String):LongWord;
Description: Default version of EnvironmentSet function used if no handler is registered
Note
|
Not intended to be called directly by applications, use EnvironmentSet instead
|
Utility functions
function FirstBitSet(Value:LongWord):LongWord; inline;
Description: Find the first set bit in a nonzero 32 bit value
Note
|
Returns 31 for MSB and 0 for LSB (0xFFFFFFFF/-1 if no bits are set)
|
function CountLeadingZeros(Value:LongWord):LongWord; inline;
Description: Count the number of leading 0 bits in a nonzero 32 bit value
Note
|
Returns 32 if no bits are set
|
function PhysicalToIOAddress(Address:Pointer):PtrUInt; inline;
Description: Convert Physical address to an IO addresses (Where Applicable)
function IOAddressToPhysical(Address:Pointer):PtrUInt; inline;
Description: Convert an IO address to a Physical address (Where Applicable)
function PhysicalToBusAddress(Address:Pointer):PtrUInt; inline;
Description: Convert a Physical address to a Bus address (Where Applicable)
function BusAddressToPhysical(Address:Pointer):PtrUInt; inline;
Description: Convert a Bus address to a Physical address (Where Applicable)
procedure NanosecondDelay(Nanoseconds:LongWord);
Description: Non sleep wait for a number of nanoseconds
Nanseconds
|
Number of nanoseconds to wait
|
procedure MicrosecondDelay(Microseconds:LongWord);
Description: Non sleep wait for a number of microseconds
Milliseconds
|
Number of microseconds to wait
|
procedure MillisecondDelay(Milliseconds:LongWord);
Description: Non sleep wait for a number of milliseconds
Milliseconds
|
Number of milliseconds to wait
|
procedure NanosecondDelayEx(Nanoseconds:LongWord; Wait:Boolean);
Description: Non sleep wait for a number of nanoseconds
Nanoseconds
|
Number of nanoseconds to wait
|
Wait
|
Use WaitForEvent on each loop to reduce power consumption
|
Note
|
Not suitable for use by interrupt handlers if wait is true
|
procedure MicrosecondDelayEx(Microseconds:LongWord; Wait:Boolean);
Description: Non sleep wait for a number of microseconds
Milliseconds
|
Number of milliseconds to wait
|
Wait
|
Use WaitForEvent on each loop to reduce power consumption
|
Note
|
Not suitable for use by interrupt handlers if wait is true
|
procedure MillisecondDelayEx(Milliseconds:LongWord; Wait:Boolean);
Description: Non sleep wait for a number of milliseconds
Milliseconds
|
Number of milliseconds to wait
|
Wait
|
Use WaitForEvent on each loop to reduce power consumption
|
Note
|
Not suitable for use by interrupt handlers if wait is true
|
System random functions
procedure SystemRandomize;
Description: To be documented
Dos conversion functions
function DosGetMsCount:Int64;
Description: To be documented
Dos info/date/time functions
function DosDosVersion:Word;
Description: To be documented
procedure DosGetDate(var Year,Month,MDay,WDay:Word);
Description: To be documented
procedure DosSetDate(Year,Month,Day:Word);
Description: To be documented
procedure DosGetTime(var Hour,Minute,Second,Sec100:Word);
Description: To be documented
procedure DosSetTime(Hour,Minute,Second,Sec100:Word);
Description: To be documented
Dos environment functions
function DosEnvCount:Longint;
Description: To be documented
function DosEnvStr(Index:LongInt):ShortString;
Description: To be documented
function DosGetEnv(EnvVar:ShortString):ShortString;
Description: To be documented
SysUtils tick functions
function SysUtilsGetTickCount:LongWord;
Description: To be documented
function SysUtilsGetTickCount64:QWord;
Description: To be documented
SysUtils locale functions
procedure SysUtilsGetLocalTime(var SystemTime:TSystemTime);
Description: Get the current local time as a SystemTime value
Note
|
Includes timezone offset if configured
|
procedure SysUtilsSetLocalTime(const SystemTime:TSystemTime);
Description: Set the current local time from a SystemTime value
Note
|
Includes timezone offset if configured
|
function SysUtilsGetUniversalTime(var SystemTime:TSystemTime):Boolean;
Description: Get the current UTC time as a SystemTime value
function SysUtilsGetLocalTimeOffset:Integer;
Description: Get the current local time offset value
function SysUtilsGetLocalTimeOffsetEx(const DateTime:TDateTime; const InputIsUTC:Boolean; out Offset:Integer):Boolean;
Description: Get the current local time offset value at the given date and time
Platform helper functions
function HandleTypeToString(HandleType:LongWord):String;
Description: To be documented
procedure PlatformLog(Level:LongWord; const AText:String);
Description: To be documented
procedure PlatformLogInfo(const AText:String); inline;
Description: To be documented
procedure PlatformLogWarn(const AText:String); inline;
Description: To be documented
procedure PlatformLogError(const AText:String); inline;
Description: To be documented
procedure PlatformLogDebug(const AText:String); inline;
Description: To be documented
Return to Unit Reference