Unit Devices

From Ultibo.org
Revision as of 04:55, 21 June 2023 by Ultibo (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

Return to Unit Reference


Description


Ultibo Device Interface unit

Constants



Device specific constants DEVICE_*
DEVICE_NAME_PREFIX = 'Device'; Name prefix for Devices


Device signature DEVICE_SIGNATURE_*
DEVICE_SIGNATURE = $AD03FE3C;  


Device name DEVICE_*_LENGTH
DEVICE_NAME_LENGTH = SIZE_64; Length of device name
DEVICE_DESC_LENGTH = SIZE_128; Length of device description


Device bus DEVICE_BUS_*
NONE = 0;  
DEVICE_BUS_PCI = 1;  
DEVICE_BUS_USB = 2;  
DEVICE_BUS_ISA = 3;  
DEVICE_BUS_PS2 = 4;  
DEVICE_BUS_FIREWIRE = 5;  
DEVICE_BUS_SD = 6; SD/SDHC/SDXC/SDIO etc
DEVICE_BUS_MMC = 7; MMC/eMMC etc
DEVICE_BUS_ATA = 8;  
DEVICE_BUS_IDE = 9;  
DEVICE_BUS_SCSI = 10;  
DEVICE_BUS_ATAPI = 11;  
DEVICE_BUS_SATA = 12;  
DEVICE_BUS_SERIAL = 13;  
DEVICE_BUS_SPI = 14; Serial Peripheral Interface device
DEVICE_BUS_MMIO = 15; Memory Mapped IO device (No Bus)
DEVICE_BUS_PCIE = 16;  
DEVICE_BUS_I2C = 17; I2C connected device
 
DEVICE_BUS_MAX = 17;  


Device state DEVICE_STATE_*
DEVICE_STATE_UNREGISTERED = 0;  
DEVICE_STATE_REGISTERED = 1;  
 
DEVICE_STATE_MAX = 1;  


Device Id DEVICE_ID_*
DEVICE_ID_ANY = $FFFFFFFF; Any Device (Pass to DeviceFind to match all devices)


Device class DEVICE_CLASS_*
DEVICE_CLASS_NONE = 0; No Device
DEVICE_CLASS_USBHOST = 1; A USB Host Controller (eg XHCI/EHCI/UHCI/OHCI or DWCOTG etc) (Implementing a standard USB host interface)
DEVICE_CLASS_PCIHOST = 2; A PCI Host Controller (eg AHCI etc) (Implementing a standard PCI host interface)
DEVICE_CLASS_USB = 3; A USB Device (eg Hub/Keyboard/Mouse/Mass Storage/Vendor Specific etc) (Implementing a standard USB device interface)
DEVICE_CLASS_PCI = 4; A PCI Device (eg Graphics/Controller etc) (Implementing a standard PCI device interface)
DEVICE_CLASS_NETWORK = 5; A Network Device (Implementing a standard Network device interface). May also be a USB or PCI device
DEVICE_CLASS_STORAGE = 6; A Storage Device (Implementing a standard Storage device interface). May also be a USB, PCI, MMC, SCSI or ATA device
DEVICE_CLASS_BLOCK = DEVICE_CLASS_STORAGE;  
DEVICE_CLASS_FILESYSTEM = 7; A FileSystem Device (eg FAT/NTFS/CDFS/EXTFS etc)(Implementing a standard FileSystem device interface)
DEVICE_CLASS_PROTOCOL = 8; A Protocol Device (eg TCP/UDP/IP/ICMP etc) (Implementing a standard Protocol device interface)
DEVICE_CLASS_TRANSPORT = DEVICE_CLASS_PROTOCOL;  
DEVICE_CLASS_KEYBOARD = 9; A Keyboard Device (Implementing a standard Keyboard device interface)
DEVICE_CLASS_MOUSE = 10; A Mouse Device (Implementing a standard Mouse device interface)
DEVICE_CLASS_BLUETOOTH = 11; A Bluetooth Device (Implementing a standard Bluetooth device interface)
DEVICE_CLASS_SERIAL = 12; A Serial Device (Implementing a standard Serial device interface)
DEVICE_CLASS_AUDIO = 13; An Audio Device (Implementing a standard Audio device interface)
DEVICE_CLASS_VIDEO = 14; A Video Device (Implementing a standard Video device interface)
DEVICE_CLASS_SCSI = 15; A SCSI Device (Implementing a standard SCSI device interface). May also be a PCI device
DEVICE_CLASS_ATA = 16; An ATA/ATAPI Device (Implementing a standard ATA/ATAPI device interface). May also be a PCI device
DEVICE_CLASS_IDE = DEVICE_CLASS_ATA;  
DEVICE_CLASS_ATAPI = DEVICE_CLASS_ATA;  
DEVICE_CLASS_IMAGE = 17; An Image Device (eg Camera) (Implementing a standard Image device interface)
DEVICE_CLASS_PRINTER = 18; A Printer Device (Implementing a standard Printer device interface)
DEVICE_CLASS_COMMUNICATIONS = 19; A Communications Device (Implementing a standard Communications device interface)
DEVICE_CLASS_SMART_CARD = 20; A Smart Card Device (Implementing a standard Smart Card device interface)
DEVICE_CLASS_MONITOR = 21; A Monitor Device (Implementing a standard Monitor device interface)
DEVICE_CLASS_DISPLAY = 22; A Display Device (eg Billboard) (Implementing a standard Display device interface)
DEVICE_CLASS_AUDIOVIDEO = 23; An Audio/Video Device (Implementing a standard Audio/Video device interface)
DEVICE_CLASS_IRDA = 24; An Infrared Device (Implementing a standard Infrared device interface)
DEVICE_CLASS_SPI = 25; An SPI Device (Implementing a standard SPI device interface)
DEVICE_CLASS_I2C = 26; An I2C Device (Implementing a standard I2C device interface)
DEVICE_CLASS_UART = 27; A UART Device (Implementing a standard UART device interface)
DEVICE_CLASS_MMC = 28; An MMC Device (Implementing a standard MMC device interface)
DEVICE_CLASS_SD = 29; An SD Device (Implementing a standard SD device interface)
DEVICE_CLASS_SDHCI = 30; An SD/MMC Host Controller (Implementing a standard SDHCI device interface)
DEVICE_CLASS_SDHOST = DEVICE_CLASS_SDHCI;  
DEVICE_CLASS_MMCHOST = DEVICE_CLASS_SDHCI;  
DEVICE_CLASS_MMCIHOST = DEVICE_CLASS_SDHCI;  
DEVICE_CLASS_DFU = 31; A Device Firmware Update Device (Implementing a standard DFU device interface)
DEVICE_CLASS_GPIO = 32; A GPIO Device (Implementing a standard GPIO device interface)
DEVICE_CLASS_MAILBOX = 33; A Mailbox Device
DEVICE_CLASS_OPENGL = 34; An OpenGL Device
DEVICE_CLASS_DVB = 35; A Digital Video Broadcast (DVB) Device
DEVICE_CLASS_DAB = 36; A Digital Audio Broadcast (DAB) Device
DEVICE_CLASS_DMA = 37; A DMA Controller Device (Implementing a standard DMA controller interface)
DEVICE_CLASS_SCSIHOST = 38; A SCSI Host Device (Implementing a standard SCSI host interface)
DEVICE_CLASS_ATAHOST = 39; An ATA Host Device (Implementing a standard ATA host interface)
DEVICE_CLASS_TIMER = 40; A Timer or Counter Device
DEVICE_CLASS_RANDOM = 41; A Random Number Generator Device
DEVICE_CLASS_FRAMEBUFFER = 42; A Frame Buffer Device
DEVICE_CLASS_WATCHDOG = 43; A Watchdog Timer Device
DEVICE_CLASS_CLOCK = 44; A Clock (Date/Time) Device
DEVICE_CLASS_CONSOLE = 45; A Console Device
DEVICE_CLASS_RTC = 46; A Real Time Clock (Battery Backed) Device
DEVICE_CLASS_USBHUB = 47; A USB Hub (Implementing a standard USB hub interface)
DEVICE_CLASS_LOGGING = 48; A Logging Device (Implementing a standard Logging device interface)
DEVICE_CLASS_PCM = 49; A PCM Sound Device (Implementing a standard PCM device interface)
DEVICE_CLASS_I2S = DEVICE_CLASS_PCM;  
DEVICE_CLASS_PWM = 50; A Pulse Width Modulation (PWM) Device
DEVICE_CLASS_1WIRE = 51; A 1-Wire Device (Implementing a standard W1 device interface)
DEVICE_CLASS_CLOCK_MANAGER = 52; A Clock Manager Device
DEVICE_CLASS_CODEC = 53; A CODEC Device (eg Audio or Video)
DEVICE_CLASS_TOUCH = 54; A Touch Device
DEVICE_CLASS_MEMORY = 55; A Memory Device (eg OTP, NVRAM or Flash)
DEVICE_CLASS_GENERIC = 56; A Generic Device
DEVICE_CLASS_VIRTIO = 57; A VIRTIO Device (eg Block/Network/Memory/Console/Input etc) (Implementing a standard VIRTIO device interface)
DEVICE_CLASS_BLUETOOTHHOST = 58; A Bluetooth Host Controller (Implementing a standard Bluetooth host interface)
DEVICE_CLASS_JOYSTICK = 59; A Joystick or Gamepad Device
DEVICE_CLASS_HID = 60; A Human Interface Device (HID)
 
DEVICE_CLASS_MAX = 60;  
 
DEVICE_CLASS_ANY = $FFFFFFFF; Any Device (Pass to DeviceFind or DeviceEnumerate to match all devices)
 
Device Class Names
DEVICE_CLASS_NAMES:array[DEVICE_CLASS_NONE..DEVICE_CLASS_MAX] of String = (
'DEVICE_CLASS_NONE',
'DEVICE_CLASS_USBHOST',
'DEVICE_CLASS_PCIHOST',
'DEVICE_CLASS_USB',
'DEVICE_CLASS_PCI',
'DEVICE_CLASS_NETWORK',
'DEVICE_CLASS_STORAGE',
'DEVICE_CLASS_FILESYSTEM',
'DEVICE_CLASS_PROTOCOL',
'DEVICE_CLASS_KEYBOARD',
'DEVICE_CLASS_MOUSE',
'DEVICE_CLASS_BLUETOOTH',
'DEVICE_CLASS_SERIAL',
'DEVICE_CLASS_AUDIO',
'DEVICE_CLASS_VIDEO',
'DEVICE_CLASS_SCSI',
'DEVICE_CLASS_ATA',
'DEVICE_CLASS_IMAGE',
'DEVICE_CLASS_PRINTER',
'DEVICE_CLASS_COMMUNICATIONS',
'DEVICE_CLASS_SMART_CARD',
'DEVICE_CLASS_MONITOR',
'DEVICE_CLASS_DISPLAY',
'DEVICE_CLASS_AUDIOVIDEO',
'DEVICE_CLASS_IRDA',
'DEVICE_CLASS_SPI',
'DEVICE_CLASS_I2C',
'DEVICE_CLASS_UART',
'DEVICE_CLASS_MMC',
'DEVICE_CLASS_SD',
'DEVICE_CLASS_SDHCI',
'DEVICE_CLASS_DFU',
'DEVICE_CLASS_GPIO',
'DEVICE_CLASS_MAILBOX',
'DEVICE_CLASS_OPENGL',
'DEVICE_CLASS_DVB',
'DEVICE_CLASS_DAB',
'DEVICE_CLASS_DMA',
'DEVICE_CLASS_SCSIHOST',
'DEVICE_CLASS_ATAHOST',
'DEVICE_CLASS_TIMER',
'DEVICE_CLASS_RANDOM',
'DEVICE_CLASS_FRAMEBUFFER',
'DEVICE_CLASS_WATCHDOG',
'DEVICE_CLASS_CLOCK',
'DEVICE_CLASS_CONSOLE',
'DEVICE_CLASS_RTC',
'DEVICE_CLASS_USBHUB',
'DEVICE_CLASS_LOGGING',
'DEVICE_CLASS_PCM',
'DEVICE_CLASS_PWM',
'DEVICE_CLASS_1WIRE',
'DEVICE_CLASS_CLOCK_MANAGER',
'DEVICE_CLASS_CODEC',
'DEVICE_CLASS_TOUCH',
'DEVICE_CLASS_MEMORY',
'DEVICE_CLASS_GENERIC',
'DEVICE_CLASS_VIRTIO',
'DEVICE_CLASS_BLUETOOTHHOST',
'DEVICE_CLASS_JOYSTICK',
'DEVICE_CLASS_HID');


Device notification flag DEVICE_NOTIFICATION_*
DEVICE_NOTIFICATION_NONE = $00000000; Pass to DeviceNotification to cancel an existing Notification
DEVICE_NOTIFICATION_REGISTER = $00000001;  
DEVICE_NOTIFICATION_DEREGISTER = $00000002;  
DEVICE_NOTIFICATION_OPEN = $00000004;  
DEVICE_NOTIFICATION_CLOSE = $00000008;  
DEVICE_NOTIFICATION_UP = $00000010;  
DEVICE_NOTIFICATION_DOWN = $00000020;  
DEVICE_NOTIFICATION_INSERT = $00000040;  
DEVICE_NOTIFICATION_EJECT = $00000080;  
DEVICE_NOTIFICATION_ATTACH = $00000100;  
DEVICE_NOTIFICATION_DETACH = $00000200;  
DEVICE_NOTIFICATION_ENABLE = $00000400;  
DEVICE_NOTIFICATION_DISABLE = $00000800;  
DEVICE_NOTIFICATION_BIND = $00001000;  
DEVICE_NOTIFICATION_UNBIND = $00002000;  
DEVICE_NOTIFICATION_ATTACHING = $00004000;  
DEVICE_NOTIFICATION_DETACHING = $00008000;  
DEVICE_NOTIFICATION_INSERTING = $00010000;  
DEVICE_NOTIFICATION_EJECTING = $00020000;  
DEVICE_NOTIFICATION_OPENING = $00040000;  
DEVICE_NOTIFICATION_CLOSING = $00080000;  
DEVICE_NOTIFICATION_RESIZE = $00100000;  
DEVICE_NOTIFICATION_RESIZING = $00200000;  


Firmware name FIRMWARE_NAME_*
FIRMWARE_NAME_LENGTH = SIZE_256; Length of firmware name


Firmware actions FIRMWARE_ACTION_*
FIRMWARE_ACTION_NONE = 0;  
FIRMWARE_ACTION_SIZE = 1; Return the size in bytes of the firmware item
FIRMWARE_ACTION_OPEN = 2; Open the firmware item and return a handle
FIRMWARE_ACTION_READ = 3; Read from the firmware item specified by a given handle
FIRMWARE_ACTION_SEEK = 4; Seek to a location in the firmware item specified by a given handle
FIRMWARE_ACTION_CLOSE = 5; Close a handle to the firmware item
FIRMWARE_ACTION_ACQUIRE = 6; Acquire a memory block containing the firmware item
FIRMWARE_ACTION_RELEASE = 7; Release a memory block containing the firmware item


Firmware constants FIRMWARE_*
FIRMWARE_WAIT_DELAY = 100; Delay between retries for firmware while waiting for timeout (Milliseconds)
FIRMWARE_MAX_BUFFER = SIZE_4M; Maximum size buffer able to be allocated for firmware by acquire


Notifier signature NOTIFIER_SIGNATURE_*
NOTIFIER_SIGNATURE = $6FA1BEC9;  


Notifier state NOTIFIER_STATE_*
NOTIFIER_STATE_UNREGISTERED = 0;  
NOTIFIER_STATE_REGISTERED = 1;  


Notifier flag NOTIFIER_FLAG_*
NOTIFIER_FLAG_NONE = $00000000;  
NOTIFIER_FLAG_WORKER = $00000001; If set, notification callback event will be scheduled on a worker thread
NOTIFIER_FLAG_UNLOCK = $00000002; If set, the notifier table lock will be released before calling the notification callback event


Device logging DEVICE_LOG_*
DEVICE_LOG_LEVEL_DEBUG = LOG_LEVEL_DEBUG; Device debugging messages
DEVICE_LOG_LEVEL_INFO = LOG_LEVEL_INFO; Device informational messages, such as a device being attached or detached
DEVICE_LOG_LEVEL_WARN = LOG_LEVEL_WARN; Device warning messages
DEVICE_LOG_LEVEL_ERROR = LOG_LEVEL_ERROR; Device error messages
DEVICE_LOG_LEVEL_NONE = LOG_LEVEL_NONE; No Device messages


Driver specific constants DRIVER_*
DRIVER_NAME_PREFIX = 'Driver'; Name prefix for Drivers


Driver signature DRIVER_SIGNATURE_*
DRIVER_SIGNATURE = $1EB4980A;  


Driver name DRIVER_NAME_*
DRIVER_NAME_LENGTH = SIZE_64; Length of driver name


Driver state DRIVER_STATE_*
DRIVER_STATE_UNREGISTERED = 0;  
DRIVER_STATE_REGISTERED = 1;  
 
DRIVER_STATE_MAX = 1;  


Driver Id DRIVER_ID_*
DRIVER_ID_ANY = $FFFFFFFF; Any Driver (Pass to DriverFind to match all drivers)


Driver class DRIVER_CLASS_*
DRIVER_CLASS_NONE = 0; No Driver
DRIVER_CLASS_USB = 1; A USB Driver (Implementing a standard USB driver interface)
DRIVER_CLASS_PCI = 2; A PCI Driver (Implementing a standard PCI driver interface)
DRIVER_CLASS_SDIO = 3; An SDIO Driver (Implementing a standard SDIO driver interface)
DRIVER_CLASS_BLUETOOTH = 4; A Bluetooth Driver (Implementing a standard Bluetooth driver interface)
DRIVER_CLASS_VIRTIO = 5; A VIRTIO Driver (Implementing a standard VIRTIO driver interface)
DRIVER_CLASS_HID = 6; A Human Interface Device (HID) Driver (Implementing a standard HID driver interface)
 
DRIVER_CLASS_MAX = 6;  
 
DRIVER_CLASS_ANY = $FFFFFFFF; Any Driver (Pass to DriverFind or DriverEnumerate to match all drivers)
 
Driver Class Names
DRIVER_CLASS_NAMES:array[DRIVER_CLASS_NONE..DRIVER_CLASS_MAX] of String = (
'DRIVER_CLASS_NONE',
'DRIVER_CLASS_USB',
'DRIVER_CLASS_PCI',
'DRIVER_CLASS_SDIO',
'DRIVER_CLASS_BLUETOOTH',
'DRIVER_CLASS_VIRTIO',
'DRIVER_CLASS_HID');


Host specific constants HOST_*
HOST_NAME_PREFIX = 'Host'; Name prefix for Hosts


Host signature HOST_SIGNATURE_*
HOST_SIGNATURE = $F45D30FE;  


Host name HOST_NAME_*
HOST_NAME_LENGTH = SIZE_64; Length of host name


Host state HOST_STATE_*
HOST_STATE_UNREGISTERED = 0;  
HOST_STATE_REGISTERED = 1;  
 
HOST_STATE_MAX = 1;  


Host Id HOST_ID_*
HOST_ID_ANY = $FFFFFFFF; Any Host (Pass to HostFind to match all hosts)


Host class HOST_CLASS_*
HOST_CLASS_NONE = 0; No Host}
HOST_CLASS_USB = 1; A USB Host (eg XHCI/EHCI/UHCI/OHCI or DWCOTG etc) (Implementing a standard USB host interface)
HOST_CLASS_PCI = 2; A PCI Host (eg AHCI etc) (Implementing a standard PCI host interface)
HOST_CLASS_SD = 3; An SD Host (eg MMC/SDIO etc) (Implementing a standard SD host interface)
HOST_CLASS_BLUETOOTH = 4; A Bluetooth Host (Implementing a standard Bluetooth host interface)
 
HOST_CLASS_MAX = 4;  
 
HOST_CLASS_ANY = $FFFFFFFF; Any Host (Pass to HostFind or HostEnumerate to match all hosts)


Clock specific constants CLOCK_*
CLOCK_NAME_PREFIX = 'Clock'; Name prefix for Clock Devices


Clock device type CLOCK_TYPE_*
CLOCK_TYPE_NONE = 0;  
CLOCK_TYPE_HARDWARE = 1;  
 
CLOCK_TYPE_MAX = 1;  


Clock device state CLOCK_STATE_*
CLOCK_STATE_DISABLED = 0;  
CLOCK_STATE_ENABLED = 1;  
 
CLOCK_STATE_MAX = 1;  


Clock device flag CLOCK_FLAG_*
CLOCK_FLAG_NONE = $00000000;  
CLOCK_FLAG_WRITABLE = $00000001; Device supports writing the clock value
CLOCK_FLAG_VARIABLE = $00000002; Device supports setting the clock rate


Timer specific constants TIMER_*
TIMER_NAME_PREFIX = 'Timer'; Name prefix for Timer Devices


Timer device type TIMER_TYPE_*
TIMER_TYPE_NONE = 0;  
TIMER_TYPE_HARDWARE = 1;  
 
TIMER_TYPE_MAX = 1;  


Timer device state TIMER_STATE_*
TIMER_STATE_DISABLED = 0;  
TIMER_STATE_ENABLED = 1;  
 
TIMER_STATE_MAX = 1;  


Timer device flag TIMER_FLAG_*
TIMER_FLAG_NONE = $00000000;  
TIMER_FLAG_WRAPPING = $00000001; Device provides a wrapping or self reloading counter
TIMER_FLAG_COUNTER = $00000002; Device will appear as a continuously incrementing counter when read
TIMER_FLAG_DOWN = $00000004; Device counts down from the starting value to zero (And optionally triggers an event)


Timer event flag TIMER_EVENT_FLAG_*
TIMER_EVENT_FLAG_NONE = $00000000;  
TIMER_EVENT_FLAG_REPEAT = $00000001; Event will be repeated until cancelled
TIMER_EVENT_FLAG_INTERRUPT = $00000002; Event will be dispatched by interrupt handler (If applicable). Caution: Events called by the interrupt handler must obey interrupt rules with regard to locks, memory allocation and latency.


Random specific constants RANDOM_*
RANDOM_NAME_PREFIX = 'Random'; Name prefix for Random Devices


Random device type RANDOM_TYPE_*
RANDOM_TYPE_NONE = 0;  
RANDOM_TYPE_HARDWARE = 1;  
RANDOM_TYPE_SOFTWARE = 2;  
 
RANDOM_TYPE_MAX = 2;  


Random device state RANDOM_STATE_*
RANDOM_STATE_DISABLED = 0;  
RANDOM_STATE_ENABLED = 1;  
 
RANDOM_STATE_MAX = 1;  


Random device flag RANDOM_FLAG_*
RANDOM_FLAG_NONE = $00000000;  


Mailbox specific constants MAILBOX_*
MAILBOX_NAME_PREFIX = 'Mailbox'; Name prefix for Mailbox Devices


Mailbox device type MAILBOX_TYPE_*
MAILBOX_TYPE_NONE = 0;  
MAILBOX_TYPE_GPU = 1;  
MAILBOX_TYPE_LOCAL = 2;  
 
MAILBOX_TYPE_MAX = 2;  


Mailbox device state MAILBOX_STATE_*
MAILBOX_STATE_DISABLED = 0;  
MAILBOX_STATE_ENABLED = 1;  
 
MAILBOX_STATE_MAX = 1;  


Mailbox device flag MAILBOX_FLAG_*
MAILBOX_FLAG_NONE = $00000000;  


Watchdog specific constants WATCHDOG_*
WATCHDOG_NAME_PREFIX = 'Watchdog'; Name prefix for Watchdog Devices


Watchdog device type WATCHDOG_TYPE_*
WATCHDOG_TYPE_NONE = 0;  
WATCHDOG_TYPE_HARDWARE = 1;  
 
WATCHDOG_TYPE_MAX = 1;  


Watchdog device state WATCHDOG_STATE_*
WATCHDOG_STATE_DISABLED = 0;  
WATCHDOG_STATE_ENABLED = 1;  
 
WATCHDOG_STATE_MAX = 1;  


Watchdog device flag WATCHDOG_FLAG_*
WATCHDOG_FLAG_NONE = $00000000;  


Type definitions



Device enumeration callback

TDeviceEnumerate = function(Device:PDevice; Data:Pointer):LongWord;

Device notification callback

TDeviceNotification = function(Device:PDevice; Data:Pointer; Notification:LongWord):LongWord;

Device entry

PDevice = ^TDevice;

TDevice = record

Device Properties
Signature:LongWord; Signature for entry validation
DeviceId:LongWord; Unique Id of this Device in the Device table
DeviceState:LongWord; Device state (eg Registered/Unregistered)
DeviceName:array[0..DEVICE_NAME_LENGTH - 1] of Char; The name of the Device (eg Keyboard0, Storage0 or Network0 etc)
DeviceClass:LongWord; The class of this Device (eg DEVICE_CLASS_USB, DEVICE_CLASS_NETWORK, DEVICE_CLASS_STORAGE etc)
DeviceBus:LongWord; The Bus type for the Device (eg DEVICE_BUS_USB)
DeviceType:LongWord; A class specific Device type (eg KEYBOARD_TYPE_USB, MOUSE_TYPE_USB, NETWORK_TYPE_ETHERNET etc)
DeviceFlags:LongWord; The class specific Device flags
DeviceData:Pointer; A pointer to a class specific Device interface (eg PUSBDevice, PNetworkDevice or PStorageDevice etc) (Used by Drivers)
DeviceDescription:array[0..DEVICE_DESC_LENGTH - 1] of Char; A description of the Device (eg BCM2835 PL011 UART)
Internal Properties
Prev:PDevice; Previous entry in Device table
Next:PDevice; Next entry in Device table

Device firmware

PDeviceFirmware = ^TDeviceFirmware;

TDeviceFirmware = record

DeviceClass:LongWord; The Device class supported by this firmware (or DEVICE_CLASS_ANY for all devices)
Name:array[0..FIRMWARE_NAME_LENGTH - 1] of Char; The device specific name of the firmware which may be a filename, a device model, id or type
Size:LongWord; For block (memory) based firmware, the size passed to Create or 0 for other firmware types
Buffer:Pointer; For block (memory) based firmware, the buffer passed to Create or nil for other firmware types
Handles:PFirmwareHandle; List of currently open handles for this firmware
Handler:TDeviceFirmwareHandler; The device specific callback for the handler which provides this firmware
Internal Properties
Prev:PDeviceFirmware; Previous entry in Device firmware table}
Next:PDeviceFirmware; Next entry in Device firmware table

Device firmware handler

TDeviceFirmwareHandler = function(Firmware:PDeviceFirmware; Action:LongWord; var Handle:THandle; var Buffer:Pointer; var Value:LongWord):LongWord;

Firmware handle

PFirmwareHandle = ^TFirmwareHandle;

TFirmwareHandle = record

Handle:THandle;  
Next:PFirmwareHandle;  

Notifier entry

PNotifier = ^TNotifier;

TNotifier = record

Notifier Properties
Signature:LongWord; Signature for entry validation
NotifierState:LongWord; Notifier state (eg Registered/Unregistered)
NotifierFlags:LongWord; Notifier flags (eg NOTIFIER_FLAG_WORKER)
Device:PDevice; The Device to notify on (or nil for all devices)
DeviceClass:LongWord; The Device class to notify on (or DEVICE_CLASS_ANY for all devices)
Callback:TDeviceNotification; The callback for device notifications
Data:Pointer; A pointer to callback specific data to be passed with notifications (Optional)
Notification:LongWord; The mask of events to notify on (eg DEVICE_NOTIFICATION_REGISTER etc)
Internal Properties
Prev:PNotifier; Previous entry in Notifier table
Next:PNotifier; Next entry in Notifier table

Notifier task

PNotifierTask = ^TNotifierTask;

TNotifierTask = record

Device:PDevice;  
Callback:TDeviceNotification;  
Data:Pointer;  
Notification:LongWord;  
Next:PNotifierTask;  

Notifier retry

PNotifierRetry = ^TNotifierRetry;

TNotifierRetry = record

Device:PDevice;  
Notification:LongWord;  

Driver enumeration callback

TDriverEnumerate = function(Driver:PDriver; Data:Pointer):LongWord;

Driver entry

PDriver = ^TDriver;

TDriver = record

Driver Properties
Signature:LongWord; Signature for entry validation
DriverId:LongWord; Unique Id of this Driver in the Driver table
DriverState:LongWord; Driver state (eg Registered/Unregistered)
DriverName:array[0..DRIVER_NAME_LENGTH - 1] of Char; Descriptive name for the Driver (eg USB Mouse Driver)
DriverClass:LongWord; The class of this Driver (eg DRIVER_CLASS_USB etc)
Internal Properties
Prev:PDriver; Previous entry in Driver table
Next:PDriver; Next entry in Driver table

Host enumeration callback

THostEnumerate = function(Host:PHost; Data:Pointer):LongWord;

Host entry

PHost = ^THost;

THost = record

Host Properties
Signature:LongWord; Signature for entry validation
HostId:LongWord; Unique Id of this Host in the Host table
HostState:LongWord; Host state (eg Registered/Unregistered)
HostName:array[0..HOST_NAME_LENGTH - 1] of Char; Descriptive name for the Host (eg DWC OTG Host)
HostClass:LongWord; The class of this Host (eg HOST_CLASS_USB etc)
Internal Properties
Prev:PHost; Previous entry in Host table
Next:PHost; Next entry in Host table

Clock properties

PClockProperties = ^TClockProperties;

TClockProperties = record

Flags:LongWord; Device flags (eg CLOCK_FLAG_WRITABLE)
Rate:LongWord; Device current clock rate (Hz)
MinRate:LongWord; Device minimum clock rate (Hz)
MaxRate:LongWord; Device maximum clock rate (Hz)

Clock enumeration callback

TClockEnumerate = function(Clock:PClockDevice; Data:Pointer):LongWord;

Clock notification callback

TClockNotification = function(Device:PDevice; Data:Pointer; Notification:LongWord):LongWord;

Clock device start

TClockDeviceStart = function(Clock:PClockDevice):LongWord;

Clock device stop

TClockDeviceStop = function(Clock:PClockDevice):LongWord;

Clock device read

TClockDeviceRead = function(Clock:PClockDevice):LongWord;

Clock device read 64

TClockDeviceRead64 = function(Clock:PClockDevice):Int64;

Clock device write 64

TClockDeviceWrite64 = function(Clock:PClockDevice; const Value:Int64):LongWord;

Clock device get rate

TClockDeviceGetRate = function(Clock:PClockDevice):LongWord;

Clock device set rate

TClockDeviceSetRate = function(Clock:PClockDevice; Rate:LongWord):LongWord;

Clock device get properties

TClockDeviceGetProperties = function(Clock:PClockDevice; Properties:PClockProperties):LongWord;

Clock device

PClockDevice = ^TClockDevice;

TClockDevice = record

Device Properties
Device:TDevice; The Device entry for this Clock device
Clock Properties
ClockId:LongWord; Unique Id of this Clock device in the Clock device table
ClockState:LongWord; Clock device state (eg CLOCK_STATE_ENABLED)
DeviceStart:TClockDeviceStart; A device specific DeviceStart method implementing a standard clock device interface (Or nil if the default method is suitable)
DeviceStop:TClockDeviceStop; A device specific DeviceStop method implementing a standard clock device interface (Or nil if the default method is suitable)
DeviceRead:TClockDeviceRead; A device specific DeviceRead method implementing a standard clock device interface (Or nil if the default method is suitable)
DeviceRead64:TClockDeviceRead64; A device specific DeviceRead64 method implementing a standard clock device interface (Mandatory)
DeviceWrite64:TClockDeviceWrite64; A device specific DeviceWrite64 method implementing a standard clock device interface (Optional)
DeviceGetRate:TClockDeviceGetRate; A device specific DeviceGetRate method implementing a standard clock device interface (Or nil if the default method is suitable)
DeviceSetRate:TClockDeviceSetRate; A device specific DeviceSetRate method implementing a standard clock device interface (Optional)
DeviceGetProperties:TClockDeviceGetProperties; A device specific DeviceGetProperties method implementing a standard clock device interface (Or nil if the default method is suitable)
Statistics Properties
ReadCount:LongWord;  
Driver Properties
Lock:TMutexHandle; Device lock
Address:Pointer; Device register base address
Rate:LongWord; Device rate (Hz)
MinRate:LongWord; Device minimum rate (Hz)
MaxRate:LongWord; Device maximum rate (Hz)
Internal Properties
Prev:PClockDevice; Previous entry in Clock device table
Next:PClockDevice; Next entry in Clock device table

Timer callback

TTimerCallback = TCounterCallback; Counter callback from Platform

Timer properties

PTimerProperties = ^TTimerProperties;

TTimerProperties = record

Flags:LongWord; Device flags (eg TIMER_FLAG_WRAPPING)
Bits:LongWord; Number of valid bits in timer read (eg 32 or 64)
MinRate:LongWord; Device minimum clock rate (Hz)
MaxRate:LongWord; Device maximum clock rate (Hz)
MinInterval:LongWord; Device minimum interval (Ticks)
MaxInterval:LongWord; Device maximum interval (Ticks)

Timer waiter

PTimerWaiter = ^TTimerWaiter;

TTimerWaiter = record

Note: TTimerEvent is used already by the Threads unit
Timer:PTimerDevice; Timer device this waiter belongs to
Callback:TTimerCallback; Callback function to call when event occurs
Data:Pointer; Pointer to pass to the callback function when event occurs
Prev:PTimerWaiter; Previous event in the list
Next:PTimerWaiter; Next event in the list

Timer enumeration callback

TTimerEnumerate = function(Timer:PTimerDevice; Data:Pointer):LongWord;

Timer notification callback

TTimerNotification = function(Device:PDevice; Data:Pointer; Notification:LongWord):LongWord;

TImer device start

TTimerDeviceStart = function(Timer:PTimerDevice):LongWord;

Timer device stop

TTimerDeviceStop = function(Timer:PTimerDevice):LongWord;

Timer device read

TTimerDeviceRead = function(Timer:PTimerDevice):LongWord;

Timer device read 64

TTimerDeviceRead64 = function(Timer:PTimerDevice):Int64;

Timer device wait

TTimerDeviceWait = function(Timer:PTimerDevice):LongWord;

Timer device event

TTimerDeviceEvent = function(Timer:PTimerDevice; Flags:LongWord; Callback:TTimerCallback; Data:Pointer):LongWord;

Timer device cancel

TTimerDeviceCancel = function(Timer:PTimerDevice):LongWord;

Timer device get rate

TTimerDeviceGetRate = function(Timer:PTimerDevice):LongWord;

Timer device set rate

TTimerDeviceSetRate = function(Timer:PTimerDevice; Rate:LongWord):LongWord;

Timer device get interval

TTimerDeviceGetInterval = function(Timer:PTimerDevice):LongWord;

Timer device set interval

TTimerDeviceSetInterval = function(Timer:PTimerDevice; Interval:LongWord):LongWord;

Timer device get properties

TTimerDeviceGetProperties = function(Timer:PTimerDevice; Properties:PTimerProperties):LongWord;

Timer device

PTimerDevice = ^TTimerDevice;

TTimerDevice = record

Note: Forward declared for TimerWaiter
Device Properties
Device:TDevice; The Device entry for this Timer device
Timer Properties
TimerId:LongWord; Unique Id of this Timer device in the Timer device table
TimerState:LongWord; Timer device state (eg TIMER_STATE_ENABLED)
DeviceStart:TTimerDeviceStart; A device specific DeviceStart method implementing a standard timer device interface (Mandatory)
DeviceStop:TTimerDeviceStop; A device specific DeviceStop method implementing a standard timer device interface (Mandatory)
DeviceRead:TTimerDeviceRead; A device specific DeviceRead method implementing a standard timer device interface (One of Read or Read64 is Mandatory)
DeviceRead64:TTimerDeviceRead64; A device specific DeviceRead64 method implementing a standard timer device interface (One of Read or Read64 is Mandatory
DeviceWait:TTimerDeviceWait; A device specific DeviceWait method implementing a standard timer device interface (Or nil if the operation is not supported)
DeviceEvent:TTimerDeviceEvent; A device specific DeviceEvent method implementing a standard timer device interface (Or nil if the operation is not supported)
DeviceCancel:TTimerDeviceCancel; A device specific DeviceCancel method implementing a standard timer device interface (Or nil if the operation is not supported)
DeviceGetRate:TTimerDeviceGetRate; A device specific DeviceGetRate method implementing a standard timer device interface (Or nil if the default method is suitable)
DeviceSetRate:TTimerDeviceSetRate; A device specific DeviceSetRate method implementing a standard timer device interface (Or nil if the default method is suitable)
DeviceGetInterval:TTimerDeviceGetInterval; A device specific DeviceGetInterval method implementing a standard timer device interface (Or nil if the default method is suitable)
DeviceSetInterval:TTimerDeviceSetInterval; A device specific DeviceSetInterval method implementing a standard timer device interface (Or nil if the default method is suitable)
DeviceGetProperties:TTimerDeviceGetProperties; A device specific DeviceGetProperties method implementing a standard timer device interface (Or nil if the default method is suitable)
Statistics Properties
ReadCount:LongWord;  
WaitCount:LongWord;  
EventCount:LongWord;  
Driver Properties
Lock:TMutexHandle; Device lock
Address:Pointer; Device register base address
Rate:LongWord; Device rate (Hz)
Interval:LongWord; Device interval (Ticks)
Properties:TTimerProperties; Device properties
Event Properties
Flags:LongWord; Event flags for this timer (eg TIMER_EVENT_FLAG_REPEAT)
Count:Longword; Count of threads and events waiting for this timer
Event:TEventHandle; Event for threads waiting for this timer
Waiters:PTimerWaiter; List of events waiting for this timer
Internal Properties
Prev:PTimerDevice; Previous entry in Timer device table
Next:PTimerDevice; Next entry in Timer device table

Random enumeration callback

TRandomEnumerate = function(Random:PRandomDevice; Data:Pointer):LongWord;

Random notification callback

TRandomNotification = function(Device:PDevice; Data:Pointer; Notification:LongWord):LongWord;

Random device start

TRandomDeviceStart = function(Random:PRandomDevice):LongWord;

Random device stop

TRandomDeviceStop = function(Random:PRandomDevice):LongWord;

Random device seed

TRandomDeviceSeed = function(Random:PRandomDevice; Seed:LongWord):LongWord;

Random device read byte

TRandomDeviceReadByte = function(Random:PRandomDevice):Byte;

Random device read word

TRandomDeviceReadWord = function(Random:PRandomDevice):Word;

Random device read long word

TRandomDeviceReadLongWord = function(Random:PRandomDevice):LongWord;

Random device read quad word

TRandomDeviceReadQuadWord = function(Random:PRandomDevice):Int64;

Random device read double

TRandomDeviceReadDouble = function(Random:PRandomDevice):Double;

Random device

PRandomDevice = ^TRandomDevice;

TRandomDevice = record

Device Properties
Device:TDevice; The Device entry for this Random device
Random Properties
RandomId:LongWord; Unique Id of this Random device in the Random device table
RandomState:LongWord; Random device state (eg RANDOM_STATE_ENABLED)
DeviceStart:TRandomDeviceStart; A device specific DeviceStart method implementing a standard random device interface (Mandatory)
DeviceStop:TRandomDeviceStop; A device specific DeviceStop method implementing a standard random device interface (Or nil if the default method is suitable)
DeviceSeed:TRandomDeviceSeed; A device specific DeviceSeed method implementing a standard random device interface (Or nil if the default method is suitable)
DeviceReadByte:TRandomDeviceReadByte; A device specific DeviceReadByte method implementing a standard random device interface (Or nil if the default method is suitable)
DeviceReadWord:TRandomDeviceReadWord; A device specific DeviceReadWord method implementing a standard random device interface (Or nil if the default method is suitable)
DeviceReadLongWord:TRandomDeviceReadLongWord; A device specific DeviceReadLongWord method implementing a standard random device interface (Mandatory)
DeviceReadQuadWord:TRandomDeviceReadQuadWord; A device specific DeviceReadQuadWord method implementing a standard random device interface (Or nil if the default method is suitable)
DeviceReadDouble:TRandomDeviceReadDouble; A device specific DeviceReadDouble method implementing a standard random device interface (Or nil if the default method is suitable)
Statistics Properties
SeedCount:LongWord;  
ReadCount:LongWord;  
Driver Properties
Lock:TMutexHandle; Device lock
Address:Pointer; Device register base address
Internal Properties
Prev:PRandomDevice; Previous entry in Random device table
Next:PRandomDevice; Next entry in Random device table

Mailbox enumeration callback

TMailboxEnumerate = function(Mailbox:PMailboxDevice; Data:Pointer):LongWord;

Mailbox notification callback

TMailboxNotification = function(Device:PDevice; Data:Pointer; Notification:LongWord):LongWord;

Mailbox device start

TMailboxDeviceStart = function(Mailbox:PMailboxDevice):LongWord;

Mailbox device stop

TMailboxDeviceStop = function(Mailbox:PMailboxDevice):LongWord;

Mailbox device receive

TMailboxDeviceReceive = function(Mailbox:PMailboxDevice; Channel:LongWord):LongWord;

Mailbox device send

TMailboxDeviceSend = function(Mailbox:PMailboxDevice; Channel,Data:LongWord):LongWord;

Mailbox device call

TMailboxDeviceCall = function(Mailbox:PMailboxDevice; Channel,Data:LongWord; var Response:LongWord):LongWord;

Mailbox device get timeout

TMailboxDeviceGetTimeout = function(Mailbox:PMailboxDevice):LongWord;

Mailbox device set timeout

TMailboxDeviceSetTimeout = function(Mailbox:PMailboxDevice; Timeout:LongWord):LongWord;

Mailbox device

PMailboxDevice = ^TMailboxDevice;

TMailboxDevice = record

Device Properties
Device:TDevice; The Device entry for this Mailbox device
Mailbox Properties
MailboxId:LongWord; Unique Id of this Mailbox device in the Mailbox device table
MailboxState:LongWord; Mailbox device state (eg MAILBOX_STATE_ENABLED)
DeviceStart:TMailboxDeviceStart; A device specific DeviceStart method implementing a standard mailbox device interface (Or nil if the default method is suitable)
DeviceStop:TMailboxDeviceStop; A device specific DeviceStop method implementing a standard mailbox device interface (Or nil if the default method is suitable)
DeviceReceive:TMailboxDeviceReceive; A device specific DeviceReceive method implementing a standard mailbox device interface (Mandatory)
DeviceSend:TMailboxDeviceSend; A device specific DeviceSend method implementing a standard mailbox device interface (Mandatory)
DeviceCall:TMailboxDeviceCall; A device specific DeviceCall method implementing a standard mailbox device interface (Mandatory)
DeviceGetTimeout:TMailboxDeviceGetTimeout; A device specific DeviceGetTimeout method implementing a standard mailbox device interface (Or nil if the default method is suitable)
DeviceSetTimeout:TMailboxDeviceSetTimeout; A device specific DeviceSetTimeout method implementing a standard mailbox device interface (Or nil if the default method is suitable)
Statistics Properties
ReceiveCount:LongWord;  
SendCount:LongWord;  
CallCount:LongWord;  
Driver Properties
Lock:TMutexHandle; Device lock
Address:Pointer; Device register base address
Timeout:LongWord; Device timeout (Milliseconds)
Internal Properties
Prev:PMailboxDevice; Previous entry in Mailbox device table
Next:PMailboxDevice; Next entry in Mailbox device table

Watchdog enumeration callback

TWatchdogEnumerate = function(Watchdog:PWatchdogDevice; Data:Pointer):LongWord;

Watchdog notification callback

TWatchdogNotification = function(Device:PDevice; Data:Pointer; Notification:LongWord):LongWord;

Watchdog device start

TWatchdogDeviceStart = function(Watchdog:PWatchdogDevice):LongWord;

Watchdog device stop

TWatchdogDeviceStop = function(Watchdog:PWatchdogDevice):LongWord;

Watchdog device refresh

TWatchdogDeviceRefresh = function(Watchdog:PWatchdogDevice):LongWord;

Watchdog device get remain

TWatchdogDeviceGetRemain = function(Watchdog:PWatchdogDevice):LongWord;

Watchdog device get timeout

TWatchdogDeviceGetTimeout = function(Watchdog:PWatchdogDevice):LongWord;

Watchdog device set timeout

TWatchdogDeviceSetTimeout = function(Watchdog:PWatchdogDevice; Timeout:LongWord):LongWord;

Watchdog device

PWatchdogDevice = ^TWatchdogDevice;

TWatchdogDevice = record

Device Properties
Device:TDevice; The Device entry for this Watchdog device
Watchdog Properties
WatchdogId:LongWord; Unique Id of this Watchdog device in the Watchdog device table
WatchdogState:LongWord; Watchdog device state (eg WATCHDOG_STATE_ENABLED)
DeviceStart:TWatchdogDeviceStart; A device specific DeviceStart method implementing a standard watchdog device interface (Mandatory)
DeviceStop:TWatchdogDeviceStop; A device specific DeviceStop method implementing a standard watchdog device interface (Mandatory)
DeviceRefresh:TWatchdogDeviceRefresh; A device specific DeviceRefresh method implementing a standard watchdog device interface (Mandatory)
DeviceGetRemain:TWatchdogDeviceGetRemain; A device specific DeviceGetRemain method implementing a standard watchdog device interface (Mandatory)
DeviceGetTimeout:TWatchdogDeviceGetTimeout; A device specific DeviceGetTimeout method implementing a standard watchdog device interface (Or nil if the default method is suitable)
DeviceSetTimeout:TWatchdogDeviceSetTimeout; A device specific DeviceSetTimeout method implementing a standard watchdog device interface (Or nil if the default method is suitable)
Statistics Properties
StartCount:LongWord;  
StopCount:LongWord;  
RefreshCount:LongWord;  
Driver Properties
Lock:TMutexHandle; Device lock
Address:Pointer; Device register base address
Timeout:LongWord; Device timeout (Milliseconds)
Internal Properties
Prev:PWatchdogDevice; Previous entry in Watchdog device table
Next:PWatchdogDevice; Next entry in Watchdog device table


Public variables



Device logging

DEVICE_DEFAULT_LOG_LEVEL:LongWord = DEVICE_LOG_LEVEL_DEBUG; Minimum level for Device messages. Only messages with level greater than or equal to this will be printed.
DEVICE_LOG_ENABLED:Boolean;


Function declarations



Initialization functions

procedure DevicesInit;
Description: Initialize the Devices unit and device, notifier and driver tables
Note Called only during system startup


Device functions

function DeviceCreate:PDevice;
Description: Create a new Device entry
Return Pointer to new Device entry or nil if device could not be created


function DeviceCreateEx(Size:LongWord):PDevice;
Description: Create a new Device entry
Size Size in bytes to allocate for new device (Including the device entry)
Return Pointer to new Device entry or nil if device could not be created


function DeviceDestroy(Device:PDevice):LongWord;
Description: Destroy an existing Device entry
Device The device to destroy
Return ERROR_SUCCESS if completed or another error code on failure


function DeviceGetName(Device:PDevice):String;
Description: Get the name of the supplied Device
Device The device to get the name from
Return The name of the device or a blank string on error


function DeviceSetName(Device:PDevice; const Name:String):LongWord;
Description: Set the name of the supplied Device
Device The device to set the name for
Name The device name to set
Return ERROR_SUCCESS if completed or another error code on failure


function DeviceGetDescription(Device:PDevice):String;
Description: Get the description of the supplied Device
Device The device to get the description from
Return The description of the device or a blank string on error


function DeviceSetDescription(Device:PDevice; const Description:String):LongWord;
Description: Set the description of the supplied Device
Device The device to set the description for
Description The device description to set
Return ERROR_SUCCESS if completed or another error code on failure


function DeviceRegister(Device:PDevice):LongWord;
Description: Register a new Device in the Device table
Device The device to register
Return ERROR_SUCCESS if completed or another error code on failure


function DeviceDeregister(Device:PDevice):LongWord;
Description: Deregister a Device from the Device table
Device The device to deregister
Return ERROR_SUCCESS if completed or another error code on failure


function DeviceFind(DeviceClass,DeviceId:LongWord):PDevice;
Description: Find a device by ID in the device table
DeviceClass The class of the device to find (DEVICE_CLASS_ANY for all classes)
DeviceId The ID number of the device to find
Return Pointer to device entry or nil if not found


function DeviceFindByDeviceData(DeviceData:Pointer):PDevice;
Description: Find a device with matching DeviceData property in the device table
DeviceData The value to match against the DeviceData property
Return Pointer to device entry or nil if not found


function DeviceFindByName(const Name:String):PDevice; inline;
Description: Find a device by name in the device table
Name The name of the device to find (eg Timer0)
Return Pointer to device entry or nil if not found


function DeviceFindByNameEx(DeviceClass:LongWord; const Name:String):PDevice;
Description: Find a device by class and name in the device table
DeviceClass The class of the device to find (eg DEVICE_CLASS_USB) (DEVICE_CLASS_ANY for all classes)
Name The name of the device to find (eg USB0)
Return Pointer to device entry or nil if not found


function DeviceFindByDescription(const Description:String):PDevice; inline;
Description: Find a device by description in the device table
Description The description of the device to find (eg BCM2836 ARM Timer)
Return Pointer to device entry or nil if not found


function DeviceFindByDescriptionEx(DeviceClass:LongWord; const Description:String):PDevice;
Description: Find a device by class and description in the device table
DeviceClass The class of the device to find (eg DEVICE_CLASS_USB) (DEVICE_CLASS_ANY for all classes)
Description The description of the device to find (eg BCM2836 ARM Timer)
Return Pointer to device entry or nil if not found


function DeviceEnumerate(DeviceClass:LongWord; Callback:TDeviceEnumerate; Data:Pointer):LongWord;
Description: Enumerate all devices in the device table
DeviceClass The class of device to enumerate (DEVICE_CLASS_ANY for all classes)
Callback The callback function to call for each device 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 DeviceNotification(Device:PDevice; DeviceClass:LongWord; Callback:TDeviceNotification; Data:Pointer; Notification,Flags:LongWord):LongWord;
Description: Register a notification for device changes
Device The device to notify changes for (Optional, pass nil for all devices)
DeviceClass The class of device to notify changes for (DEVICE_CLASS_ANY for all classes)
Callback The function to call when a notification event occurs
Data A private data pointer to pass to callback when a notification event occurs
Notification The events to register for notification of (eg DEVICE_NOTIFICATION_REGISTER)
Flags The flags to control the notification (eg NOTIFIER_FLAG_WORKER)


function DeviceFirmwareCreate(DeviceClass:LongWord; const Name:String; Buffer:Pointer; Size:LongWord):Boolean;
Description: Create a new block (memory) based firmware entry using the standard block firmware handler
DeviceClass The class of device this firmware applies to (eg DEVICE_CLASS_NETWORK)(or DEVICE_CLASS_ANY for all devices)
Buffer A pointer to a block of memory containing the firmware to be provided to requesting devices
Size The size in bytes of the block pointed to by buffer
Return True if the new firmware entry was added or False on failure
Note Can be used by device drivers to register built in firmware as a device firmware provider. The supplied buffer can be statically or dynamically allocated but must not be freed once the device firmware has been created.


function DeviceFirmwareRegister(DeviceClass:LongWord; const Name:String; Handler:TDeviceFirmwareHandler):THandle;
Description: Register a new device firmware handler for acquiring device specific firmware
DeviceClass The class of device this firmware applies to (eg DEVICE_CLASS_NETWORK)(or DEVICE_CLASS_ANY for all devices)
Name The name of the device firmware, device specific may be a filename, a device model, id or type
Handler The handler function which is to be called when a device requests this firmware
Return A handle for the new firmware handler on success or INVALID_HANDLE_VALUE on failure
Note Used by device firmware providers to register firmware for device drivers


function DeviceFirmwareDeregister(Handle:THandle):LongWord;
Description: Deregister an existing device firmware handler
Handle The handle returned by Register
Return ERROR_SUCCESS on completion or another error code on failure
Note Used by device firmware providers to deregister firmware for device drivers


function DeviceFirmwareFind(DeviceClass:LongWord; const Name:String):PDeviceFirmware;
Description: Find an existing device firmware handler for a specified device
DeviceClass The class of device for the firmware (eg DEVICE_CLASS_NETWORK)(or DEVICE_CLASS_ANY for any class)
Name The name of the device firmware which is a device specific value such as a filename, a device model, id or type
Return A pointer to the device firmware entry which contains the details of the handler
Note Used internally to locate compatible firmware for a device firmware open request


function DeviceFirmwareFindByHandle(Handle:THandle):PDeviceFirmware;
Description: Find an existing device firmware handler from a returned handle
Handle A handle to the firmware returned by Open or Acquire
Return A pointer to the device firmware entry which contains the details of the handler
Note Used internally to locate referenced firmware for a device firmware request


function DeviceFirmwareOpen(DeviceClass:LongWord; const Name:String; Timeout:LongWord; var Handle:THandle):LongWord;
Description: Open the firmware for a specified device from a registered handler
DeviceClass The class of device for the firmware (eg DEVICE_CLASS_NETWORK)(or DEVICE_CLASS_ANY for any class)
Name The name of the device firmware which is a device specific value such as a filename, a device model, id or type
Timeout Number of milliseconds to wait for the device firmware to be ready (0 to not wait, INFINITE to wait forever)
Handle A variable to receive a handle to the firmware on return
Return ERROR_SUCCESS on completion, ERROR_NOT_FOUND if no handler can supply firmware or another error code on failure
Note A handler may return ERROR_NOT_READY if the firmware may be accepted but is not available yet


function DeviceFirmwareClose(Handle:THandle):LongWord;
Description: Close a handle to the firmware for a specified device from a registered handler
Handle The handle to the firmware as returned by Open
Return ERROR_SUCCESS on completion, ERROR_NOT_FOUND if no handler accepts this firmware or another error code on failure


function DeviceFirmwareSize(Handle:THandle):LongInt;
Description: Return the size of the firmware for a specified device from a registered handler
Handle The handle to the firmware as returned by Open
Return The size of the firmware on success or -1 on failure


function DeviceFirmwareSeek(Handle:THandle; Position:LongInt):LongInt;
Description: Seek to a position within the firmware for a specified device from a registered handler
Handle The handle to the firmware as returned by Open
Position The byte position within the firmware to seek to
Return The new position within the firmware on success or -1 on failure


function DeviceFirmwareRead(Handle:THandle; Buffer:Pointer; Count:LongInt):LongInt;
Description: Read into a buffer from the firmware for a specified device from a registered handler
Handle The handle to the firmware as returned by Open
Buffer A pointer to a buffer to receive the data
Count The maximum number of bytes to be read
Return The number of bytes read on success or -1 on failure


function DeviceFirmwareAcquire(DeviceClass:LongWord; const Name:String; Timeout:LongWord; var Handle:THandle; var Buffer:Pointer; var Size:LongWord):LongWord;
Description: Acquire a memory block containing the firmware for a specified device from a registered handler
DeviceClass The class of device for the firmware (eg DEVICE_CLASS_NETWORK)(or DEVICE_CLASS_ANY for any class)
Name The name of the device firmware which is a device specific value such as a filename, a device model, id or type
Timeout Number of milliseconds to wait for the device firmware to be ready (0 to not wait, INFINITE to wait forever)
Handle A variable to receive a handle to the firmware on return
Buffer A variable to receive a pointer to the block of memory containing the firmware on return
Size A variable to receive the size of the memory block pointed to by buffer on return
Return ERROR_SUCCESS on completion, ERROR_NOT_FOUND if no handler can supply firmware or another error code on failure
Note A handler may return ERROR_NOT_READY if the firmware may be accepted but is not available yet. A handler may return ERROR_MORE_DATA if the size of the firmware is larger than can be returned in a single buffer.


function DeviceFirmwareRelease(Handle:THandle; Buffer:Pointer; Size:LongWord):LongWord;
Description: Release a memory block containing the firmware for a specified device from a registered handler
Handle The handle to the firmware as returned by Acquire
Buffer The pointer to the block of memory containing the firmware as returned by Acquire
Size The size of the memory block as returned by Acquire
Return ERROR_SUCCESS on completion, ERROR_NOT_FOUND if no handler accepts this firmware or another error code on failure


function NotifierAllocate(Device:PDevice; DeviceClass:LongWord; Callback:TDeviceNotification; Data:Pointer; Notification,Flags:LongWord):PNotifier;
Description: Create and Register a new Notifier entry in the Notifier table
Note None documented


function NotifierRelease(Notifier:PNotifier):LongWord;
Description: Deregister and Destroy a Notifier from the Notifier table
Note None documented


function NotifierFind(Device:PDevice; DeviceClass:LongWord; Callback:TDeviceNotification; Data:Pointer):PNotifier;
Description: To be documented
Note None documented


function NotifierNotify(Device:PDevice; Notification:LongWord):LongWord;
Description: To be documented
Note None documented


procedure NotifierRetry(Retry:PNotifierRetry);
Description: To be documented
Note None documented


procedure NotifierWorker(Task:PNotifierTask);
Description: To be documented
Note None documented


Driver functions

function DriverCreate:PDriver;
Description: Create a new Driver entry
Return Pointer to new Driver entry or nil if driver could not be created


function DriverCreateEx(Size:LongWord):PDriver;
Description: Create a new Driver entry
Size Size in bytes to allocate for new driver (Including the driver entry)
Return Pointer to new Driver entry or nil if driver could not be created


function DriverDestroy(Driver:PDriver):LongWord;
Description: Destroy an existing Driver entry
Driver The driver to destroy
Return ERROR_SUCCESS if completed or another error code on failure


function DriverGetName(Driver:PDriver):String;
Description: Get the name of the supplied Driver
Driver The driver to get the name from
Return The name of the driver or a blank string on error


function DriverSetName(Driver:PDriver; const Name:String):LongWord;
Description: Set the name of the supplied Driver
Driver The driver to set the name for
Name The driver name to set
Return ERROR_SUCCESS if completed or another error code on failure


function DriverRegister(Driver:PDriver):LongWord;
Description: Register a new Driver in the Driver table
Driver The driver to register
Return ERROR_SUCCESS if completed or another error code on failure


function DriverDeregister(Driver:PDriver):LongWord;
Description: Deregister a Driver from the Driver table
Driver The driver to deregister
Return ERROR_SUCCESS if completed or another error code on failure


function DriverFind(DriverClass,DriverId:LongWord):PDriver;
Description: Find a driver by ID in the driver table
DriverClass The class of the driver to find (DRIVER_CLASS_ANY for all classes)
DriverId The ID number of the driver to find
Return Pointer to driver entry or nil if not found


function DriverFindByName(const Name:String):PDriver;
Description: Find a driver by name in the driver table
Name The name of the driver to find (eg USB Hub Driver)
Return Pointer to driver entry or nil if not found


function DriverEnumerate(DriverClass:LongWord; Callback:TDriverEnumerate; Data:Pointer):LongWord;
Description: Enumerate all drivers in the driver table
DriverClass The class of driver to enumerate (DRIVER_CLASS_ANY for all classes)
Callback The callback function to call for each driver in the table
Data A private data pointer to pass to callback for each driver in the table
Return ERROR_SUCCESS if completed or another error code on failure


Clock device functions

function ClockDeviceStart(Clock:PClockDevice):LongWord;
Description: Start the counter of the specified clock device
Clock The Clock device to start
Return ERROR_SUCCESS if completed or another error code on failure


function ClockDeviceStop(Clock:PClockDevice):LongWord;
Description: Stop the counter of the specified clock device
Clock The Clock device to stop
Return ERROR_SUCCESS if completed or another error code on failure


function ClockDeviceRead(Clock:PClockDevice):LongWord;
Description: Read the counter value of the specified clock device
Clock The Clock device to read from
Return The 32 bit counter value of the clock or 0 on failure


function ClockDeviceRead64(Clock:PClockDevice):Int64;
Description: Read the counter value of the specified clock device
Clock The Clock device to read from
Return The 64 bit counter value of the clock or 0 on failure


function ClockDeviceWrite64(Clock:PClockDevice; const Value:Int64):LongWord;
Description: Write the counter value of the specified clock device
Clock The Clock device to write to
Value The counter value to write
Return ERROR_SUCCESS if the counter was set or another error code on failure
Note Not all clock devices support setting the counter value, will return an error if unsupported.


function ClockDeviceGetRate(Clock:PClockDevice):LongWord;
Description: Get the current clock rate in Hz of the specified clock device
Clock The Clock device to get the rate from
Return The current clock rate in Hz or 0 on failure


function ClockDeviceSetRate(Clock:PClockDevice; Rate:LongWord):LongWord;
Description: Set the current clock rate in Hz of the specified clock device
Clock The Clock device to set the rate for
Rate The clock rate in Hz to set
Return ERROR_SUCCESS if the clock rate was set or another error code on failure
Note Not all clock devices support setting the clock rate, will return an error if unsupported.


function ClockDeviceProperties(Clock:PClockDevice; Properties:PClockProperties):LongWord; inline;
Description: Get the properties for the specified clock device
Clock The Clock device to get properties from
Properties Pointer to a TClockProperties structure to fill in
Return ERROR_SUCCESS if completed or another error code on failure
Note Replaced by ClockDeviceGetProperties for consistency


function ClockDeviceGetProperties(Clock:PClockDevice; Properties:PClockProperties):LongWord;
Description: Get the properties for the specified clock device
Clock The Clock device to get properties from
Properties Pointer to a TClockProperties structure to fill in
Return ERROR_SUCCESS if completed or another error code on failure


function ClockDeviceCreate:PClockDevice;
Description: Create a new Clock entry
Return Pointer to new Clock entry or nil if Clock could not be created


function ClockDeviceCreateEx(Size:LongWord):PClockDevice;
Description: Create a new Clock entry
Size Size in bytes to allocate for new Clock (Including the Clock entry)
Return Pointer to new Clock entry or nil if Clock could not be created


function ClockDeviceDestroy(Clock:PClockDevice):LongWord;
Description: Destroy an existing clock entry
Clock The clock device to destroy
Return ERROR_SUCCESS if completed or another error code on failure


function ClockDeviceRegister(Clock:PClockDevice):LongWord;
Description: Register a new clock in the clock table
Clock The clock device to register
Return ERROR_SUCCESS if completed or another error code on failure


function ClockDeviceDeregister(Clock:PClockDevice):LongWord;
Description: Deregister a clock from the clock table
Clock The clock device to deregister
Return ERROR_SUCCESS if completed or another error code on failure


function ClockDeviceFind(ClockId:LongWord):PClockDevice;
Description: Find a clock device by ID in the clock table
ClockId The ID number of the clock to find
Return Pointer to clock device entry or nil if not found


function ClockDeviceFindByName(const Name:String):PClockDevice; inline;
Description: Find a clock device by name in the clock table
Name The name of the clock to find (eg Clock0)
Return Pointer to clock device entry or nil if not found


function ClockDeviceFindByDescription(const Description:String):PClockDevice; inline;
Description: Find a clock device by description in the clock table
Description The description of the clock to find (eg BCM2836 ARM Timer Clock)
Return Pointer to clock device entry or nil if not found


function ClockDeviceEnumerate(Callback:TClockEnumerate; Data:Pointer):LongWord;
Description: Enumerate all clock devices in the clock table
Callback The callback function to call for each clock in the table
Data A private data pointer to pass to callback for each clock in the table
Return ERROR_SUCCESS if completed or another error code on failure


function ClockDeviceNotification(Clock:PClockDevice; Callback:TClockNotification; Data:Pointer; Notification,Flags:LongWord):LongWord;
Description: Register a notification for clock device changes
Clock The clock device to notify changes for (Optional, pass nil for all clocks)
Callback The function to call when a notification event occurs
Data A private data pointer to pass to callback when a notification event occurs
Notification The events to register for notification of (eg DEVICE_NOTIFICATION_REGISTER)
Flags The flags to control the notification (eg NOTIFIER_FLAG_WORKER)


Timer device functions

function TimerDeviceStart(Timer:PTimerDevice):LongWord;
Description: Start the clock and counter of the specified Timer device
Timer The Timer device to start
Return ERROR_SUCCESS if completed or another error code on failure


function TimerDeviceStop(Timer:PTimerDevice):LongWord;
Description: Stop the clock and counter of the specified Timer device
Timer The Timer device to stop
Return ERROR_SUCCESS if completed or another error code on failure


function TimerDeviceRead(Timer:PTimerDevice):LongWord;
Description: Read the current value of the specified Timer device
Timer The Timer device to read from
Return The 32 bit current value of the timer or 0 on failure


function TimerDeviceRead64(Timer:PTimerDevice):Int64;
Description: Read the current value of the specified Timer device
Timer The Timer device to read from
Return The 64 bit current value of the timer or 0 on failure


function TimerDeviceWait(Timer:PTimerDevice):LongWord;
Description: Wait for the current interval to expire on the specified Timer device
Timer The Timer device to wait for
Return ERROR_SUCCESS if the interval expired or another error code on failure


function TimerDeviceEvent(Timer:PTimerDevice; Flags:LongWord; Callback:TTimerCallback; Data:Pointer):LongWord;
Description: Schedule a function to be called when the current interval expires on the specified Timer device
Timer The Timer device to schedule the callback for
Flags The flags to control the event (eg TIMER_EVENT_FLAG_REPEAT)
Callback The function to be called when the interval expires
Data A pointer to be passed to the function when the interval expires (Optional)
Return ERROR_SUCCESS if the callback was scheduled successfully or another error code on failure


function TimerDeviceCancel(Timer:PTimerDevice):LongWord;
Description: Cancel a previously scheduled event callback function on the specified Timer device
Timer The Timer device to cancel the callback for
Return ERROR_SUCCESS if the callback was cancelled successfully or another error code on failure


function TimerDeviceGetRate(Timer:PTimerDevice):LongWord;
Description: Get the current clock rate in Hz of the specified Timer device
Timer The Timer device to get the rate from
Return The current clock rate in Hz or 0 on failure


function TimerDeviceSetRate(Timer:PTimerDevice; Rate:LongWord):LongWord;
Description: Set the current clock rate in Hz of the specified Timer device
Timer The Timer device to set the rate for
Rate The clock rate in Hz to set
Return ERROR_SUCCESS if the clock rate was set or another error code on failure


function TimerDeviceGetInterval(Timer:PTimerDevice):LongWord;
Description: Get the current interval in ticks of the specified Timer device
Timer The Timer device to get the interval from
Return The current interval in ticks or 0 on failure (or not set)
Note The tick rate is determined by the clock rate


function TimerDeviceSetInterval(Timer:PTimerDevice; Interval:LongWord):LongWord;
Description: Set the current interval in ticks of the specified Timer device
Timer The Timer device to set the interval for
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


function TimerDeviceProperties(Timer:PTimerDevice; Properties:PTimerProperties):LongWord; inline;
Description: Get the properties for the specified Timer device
Timer The Timer device to get properties from
Properties Pointer to a TTimerProperties structure to fill in
Return ERROR_SUCCESS if completed or another error code on failure
Note Replaced by TimerDeviceGetProperties for consistency


function TimerDeviceGetProperties(Timer:PTimerDevice; Properties:PTimerProperties):LongWord;
Description: Get the properties for the specified Timer device
Timer The Timer device to get properties from
Properties Pointer to a TTimerProperties structure to fill in
Return ERROR_SUCCESS if completed or another error code on failure


function TimerDeviceCreate:PTimerDevice;
Description: Create a new Timer entry
Return Pointer to new Timer entry or nil if Timer could not be created


function TimerDeviceCreateEx(Size:LongWord):PTimerDevice;
Description: Create a new Timer entry
Size Size in bytes to allocate for new Timer (Including the Timer entry)
Return Pointer to new Timer entry or nil if Timer could not be created


function TimerDeviceDestroy(Timer:PTimerDevice):LongWord;
Description: Destroy an existing Timer entry
Timer The timer device to destroy
Return ERROR_SUCCESS if completed or another error code on failure


function TimerDeviceRegister(Timer:PTimerDevice):LongWord;
Description: Register a new Timer in the Timer table
Timer The timer device to register
Return ERROR_SUCCESS if completed or another error code on failure


function TimerDeviceDeregister(Timer:PTimerDevice):LongWord;
Description: Deregister a Timer from the Timer table
Timer The timer device to deregister
Return ERROR_SUCCESS if completed or another error code on failure


function TimerDeviceFind(TimerId:LongWord):PTimerDevice;
Description: Find a timer device by ID in the timer table
TimerId The ID number of the timer to find
Return Pointer to timer device entry or nil if not found


function TimerDeviceFindByName(const Name:String):PTimerDevice; inline;
Description: Find a timer device by name in the timer table
Name The name of the timer to find (eg Timer0)
Return Pointer to timer device entry or nil if not found


function TimerDeviceFindByDescription(const Description:String):PTimerDevice; inline;
Description: Find a timer device by description in the timer table
Description The description of the timer to find (eg BCM2836 ARM Timer)
Return Pointer to timer device entry or nil if not found


function TimerDeviceEnumerate(Callback:TTimerEnumerate; Data:Pointer):LongWord;
Description: Enumerate all timer devices in the timer table
Callback The callback function to call for each timer in the table
Data A private data pointer to pass to callback for each timer in the table
Return ERROR_SUCCESS if completed or another error code on failure


function TimerDeviceNotification(Timer:PTimerDevice; Callback:TTimerNotification; Data:Pointer; Notification,Flags:LongWord):LongWord;
Description: Register a notification for timer device changes
Timer The timer device to notify changes for (Optional, pass nil for all timers)
Callback The function to call when a notification event occurs
Data A private data pointer to pass to callback when a notification event occurs
Notification The events to register for notification of (eg DEVICE_NOTIFICATION_REGISTER)
Flags The flags to control the notification (eg NOTIFIER_FLAG_WORKER)


Random device functions

function RandomDeviceStart(Random:PRandomDevice):LongWord;
Description: To be documented
Note None documented


function RandomDeviceStop(Random:PRandomDevice):LongWord;
Description: To be documented
Note None documented


function RandomDeviceSeed(Random:PRandomDevice; Seed:LongWord):LongWord;
Description: To be documented
Note None documented


function RandomDeviceReadByte(Random:PRandomDevice):Byte;
Description: To be documented
Note None documented


function RandomDeviceReadWord(Random:PRandomDevice):Word;
Description: To be documented
Note None documented


function RandomDeviceReadLongWord(Random:PRandomDevice):LongWord;
Description: To be documented
Note None documented


function RandomDeviceReadQuadWord(Random:PRandomDevice):Int64;
Description: To be documented
Note None documented


function RandomDeviceReadDouble(Random:PRandomDevice):Double;
Description: To be documented
Note None documented


function RandomDeviceReadExtended(Random:PRandomDevice):Extended; inline;
Description: To be documented
Note Replaced by RandomDeviceReadDouble


function RandomDeviceCreate:PRandomDevice;
Description: Create a new Random entry
Return Pointer to new Random entry or nil if Random could not be created


function RandomDeviceCreateEx(Size:LongWord):PRandomDevice;
Description: Create a new Random entry
Size Size in bytes to allocate for new Random (Including the Random entry)
Return Pointer to new Random entry or nil if Random could not be created


function RandomDeviceDestroy(Random:PRandomDevice):LongWord;
Description: Destroy an existing Random entry
Note None documented


function RandomDeviceRegister(Random:PRandomDevice):LongWord;
Description: Register a new Random in the Random table
Note None documented


function RandomDeviceDeregister(Random:PRandomDevice):LongWord;
Description: Deregister a Random from the Random table
Note None documented


function RandomDeviceFind(RandomId:LongWord):PRandomDevice;
Description: To be documented
Note None documented


function RandomDeviceFindByName(const Name:String):PRandomDevice; inline;
Description: To be documented
Note None documented


function RandomDeviceFindByDescription(const Description:String):PRandomDevice; inline;
Description: To be documented
Note None documented


function RandomDeviceEnumerate(Callback:TRandomEnumerate; Data:Pointer):LongWord;
Description: To be documented
Note None documented


function RandomDeviceNotification(Random:PRandomDevice; Callback:TRandomNotification; Data:Pointer; Notification,Flags:LongWord):LongWord;
Description: To be documented
Note None documented


Mailbox device functions

function MailboxDeviceStart(Mailbox:PMailboxDevice):LongWord;
Description: To be documented
Note None documented


function MailboxDeviceStop(Mailbox:PMailboxDevice):LongWord;
Description: To be documented
Note None documented


function MailboxDeviceReceive(Mailbox:PMailboxDevice; Channel:LongWord):LongWord;
Description: To be documented
Note None documented


function MailboxDeviceSend(Mailbox:PMailboxDevice; Channel,Data:LongWord):LongWord;
Description: To be documented
Note None documented


function MailboxDeviceCall(Mailbox:PMailboxDevice; Channel,Data:LongWord; var Response:LongWord):LongWord;
Description: To be documented
Note None documented


function MailboxDeviceGetTimeout(Mailbox:PMailboxDevice):LongWord;
Description: To be documented
Note None documented


function MailboxDeviceSetTimeout(Mailbox:PMailboxDevice; Timeout:LongWord):LongWord;
Description: To be documented
Note None documented


function MailboxDeviceCreate:PMailboxDevice;
Description: Create a new Mailbox entry
Return Pointer to new Mailbox entry or nil if Mailbox could not be created


function MailboxDeviceCreateEx(Size:LongWord):PMailboxDevice;
Description: Create a new Mailbox entry
Size Size in bytes to allocate for new Mailbox (Including the Mailbox entry)
Return Pointer to new Mailbox entry or nil if Mailbox could not be created


function MailboxDeviceDestroy(Mailbox:PMailboxDevice):LongWord;
Description: Destroy an existing Mailbox entry
Note None documented


function MailboxDeviceRegister(Mailbox:PMailboxDevice):LongWord;
Description: Register a new Mailbox in the Mailbox table
Note None documented


function MailboxDeviceDeregister(Mailbox:PMailboxDevice):LongWord;
Description: Deregister a Mailbox from the Mailbox table
Note None documented


function MailboxDeviceFind(MailboxId:LongWord):PMailboxDevice;
Description: To be documented
Note None documented


function MailboxDeviceFindByName(const Name:String):PMailboxDevice; inline;
Description: To be documented
Note None documented


function MailboxDeviceFindByDescription(const Description:String):PMailboxDevice; inline;
Description: To be documented
Note None documented


function MailboxDeviceEnumerate(Callback:TMailboxEnumerate; Data:Pointer):LongWord;
Description: To be documented
Note None documented


function MailboxDeviceNotification(Mailbox:PMailboxDevice; Callback:TMailboxNotification; Data:Pointer; Notification,Flags:LongWord):LongWord;
Description: To be documented
Note None documented


Watchdog device functions

function WatchdogDeviceStart(Watchdog:PWatchdogDevice):LongWord;
Description: To be documented
Note None documented


function WatchdogDeviceStop(Watchdog:PWatchdogDevice):LongWord;
Description: To be documented
Note None documented


function WatchdogDeviceRefresh(Watchdog:PWatchdogDevice):LongWord;
Description: To be documented
Note None documented


function WatchdogDeviceGetRemain(Watchdog:PWatchdogDevice):LongWord;
Description: To be documented
Note None documented


function WatchdogDeviceGetTimeout(Watchdog:PWatchdogDevice):LongWord;
Description: To be documented
Note None documented


function WatchdogDeviceSetTimeout(Watchdog:PWatchdogDevice; Timeout:LongWord):LongWord;
Description: To be documented
Note None documented


function WatchdogDeviceCreate:PWatchdogDevice;
Description: Create a new Watchdog entry
Return Pointer to new Watchdog entry or nil if Watchdog could not be created


function WatchdogDeviceCreateEx(Size:LongWord):PWatchdogDevice;
Description: Create a new Watchdog entry
Size Size in bytes to allocate for new Watchdog (Including the Watchdog entry)
Return Pointer to new Watchdog entry or nil if Watchdog could not be created


function WatchdogDeviceDestroy(Watchdog:PWatchdogDevice):LongWord;
Description: Destroy an existing Watchdog entry
Note None documented


function WatchdogDeviceRegister(Watchdog:PWatchdogDevice):LongWord;
Description: Register a new Watchdog in the Watchdog table
Note None documented


function WatchdogDeviceDeregister(Watchdog:PWatchdogDevice):LongWord;
Description: Deregister a Watchdog from the Watchdog table
Note None documented


function WatchdogDeviceFind(WatchdogId:LongWord):PWatchdogDevice;
Description: To be documented
Note None documented


function WatchdogDeviceFindByName(const Name:String):PWatchdogDevice; inline;
Description: To be documented
Note None documented


function WatchdogDeviceFindByDescription(const Description:String):PWatchdogDevice; inline;
Description: To be documented
Note None documented


function WatchdogDeviceEnumerate(Callback:TWatchdogEnumerate; Data:Pointer):LongWord;
Description: To be documented
Note None documented


function WatchdogDeviceNotification(Watchdog:PWatchdogDevice; Callback:TWatchdogNotification; Data:Pointer; Notification,Flags:LongWord):LongWord;
Description: To be documented
Note None documented


RTL clock functions

function SysClockRead:LongWord;
Description: To be documented
Note None documented


function SysClockRead64:Int64;
Description: To be documented
Note None documented


RTL timer (counter) functions

function SysTimerAvailable:Boolean;
Description: Check if a timer device is available
Note None documented


function SysTimerRead:LongWord;
Description: Read the current value of the default counter
Return The 32 bit current value of the counter or 0 on failure


function SysTimerRead64:Int64;
Description: Read the current value of the default counter
Return The 64 bit current value of the counter or 0 on failure


function SysTimerWait:LongWord;
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 SysTimerEvent(Callback:TTimerCallback; Data:Pointer):LongWord;
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 SysTimerCancel:LongWord;
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 SysTimerGetRate:LongWord;
Description: Get the current clock rate in Hz of the default counter
Return The current clock rate in Hz or 0 on failure


function SysTimerSetRate(Rate:LongWord):LongWord;
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 SysTimerGetInterval:LongWord;
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 SysTimerSetInterval(Interval:LongWord):LongWord;
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


RTL random functions

function SysRandomAvailable:Boolean;
Description: Check if a random (RNG) device is available
Note None documented


procedure SysRandomize;
Description: To be documented
Note None documented


procedure SysRandomSeed(Seed:LongWord);
Description: To be documented
Note None documented


function SysRandomReadLongInt(Limit:LongInt):LongInt;
Description: To be documented
Note None documented


function SysRandomReadInt64(Limit:Int64):Int64;
Description: To be documented
Note None documented


function SysRandomReadDouble:Double;
Description: To be documented
Note None documented


RTL watchdog functions

function SysWatchdogAvailable:Boolean;
Description: Check if a watchdog timer device is available
Note None documented


function SysWatchdogStart(Milliseconds:LongWord):LongWord; 
Description: To be documented
Note None documented


function SysWatchdogStop:LongWord;
Description: To be documented
Note None documented


function SysWatchdogRefresh(Milliseconds:LongWord):LongWord;
Description: To be documented
Note None documented


Device helper functions

function DeviceGetCount:LongWord;
Description: Get the current device count
Note None documented


function DeviceCheck(Device:PDevice):PDevice;
Description: Check if the supplied Device is in the device table
Note None documented


function NotifierGetCount:LongWord;
Description: Get the current notifier count
Note None documented


function NotifierCheck(Notifier:PNotifier):PNotifier;
Description: Check if the supplied Notifier is in the notifier table
Note None documented


function DeviceBusToString(DeviceBus:LongWord):String;
Description: To be documented
Note None documented


function DeviceStateToString(DeviceState:LongWord):String;
Description: To be documented
Note None documented


function DeviceClassToString(DeviceClass:LongWord):String;
Description: To be documented
Note None documented


function NotificationToString(Notification:LongWord):String;
Description: To be documented
Note None documented


procedure DeviceLog(Level:LongWord; Device:PDevice; const AText:String);
Description: To be documented
Note None documented


procedure DeviceLogInfo(Device:PDevice; const AText:String); inline;
Description: To be documented
Note None documented


procedure DeviceLogWarn(Device:PDevice; const AText:String); inline;
Description: To be documented
Note None documented


procedure DeviceLogError(Device:PDevice; const AText:String); inline;
Description: To be documented
Note None documented


procedure DeviceLogDebug(Device:PDevice; const AText:String); inline;
Description: To be documented
Note None documented


Driver helper functions

function DriverGetCount:LongWord;
Description: Get the current driver count
Note None documented


function DriverCheck(Driver:PDriver):PDriver;
Description: Check if the supplied Driver is in the driver table
Note None documented


function DriverStateToString(DriverState:LongWord):String;
Description: To be documented
Note None documented


function DriverClassToString(DriverClass:LongWord):String;
Description: To be documented
Note None documented


Clock device helper functions

function ClockDeviceGetCount:LongWord;
Description: Get the current clock device count
Note None documented


function ClockDeviceGetDefault:PClockDevice;
Description: Get the current default clock device
Note None documented


function ClockDeviceSetDefault(Clock:PClockDevice):LongWord;
Description: Set the current default clock device
Note None documented


function ClockDeviceCheck(Clock:PClockDevice):PClockDevice;
Description: Check if the supplied Clock is in the Clock table
Note None documented


function ClockTypeToString(ClockType:LongWord):String;
Description: Convert a Clock type value to a string
Note None documented


function ClockStateToString(ClockState:LongWord):String;
Description: Convert a Clock state value to a string
Note None documented


Timer device helper functions

function TimerDeviceGetCount:LongWord;
Description: Get the current timer device count
Note None documented


function TimerDeviceGetDefault:PTimerDevice;
Description: Get the current default timer device
Note None documented


function TimerDeviceSetDefault(Timer:PTimerDevice):LongWord;
Description: Set the current default timer device
Note None documented


function TimerDeviceCheck(Timer:PTimerDevice):PTimerDevice;
Description: Check if the supplied Timer is in the Timer table
Note None documented


function TimerTypeToString(TimerType:LongWord):String;
Description: Convert a Timer type value to a string
Note None documented


function TimerStateToString(TimerState:LongWord):String;
Description: Convert a Timer state value to a string
Note None documented


function TimerDeviceCreateWaiter(Timer:PTimerDevice; Callback:TTimerCallback; Data:Pointer):PTimerWaiter;
Description: Create a new waiter using the supplied parameters
Note Waiter must be registered by calling TimerDeviceRegisterWaiter.

Caller must hold the Timer device lock.


function TimerDeviceDestroyWaiter(Timer:PTimerDevice; Waiter:PTimerWaiter):LongWord;
Description: Destroy an existing waiter
Note Waiter must be deregistered first by calling TimerDeviceDeregisterWaiter.

Caller must hold the Timer device lock.


function TimerDeviceRegisterWaiter(Timer:PTimerDevice; Waiter:PTimerWaiter):LongWord;
Description: Register a waiter in the waiter list of the supplied Timer
Note Waiter must be created by calling TimerDeviceCreateWaiter.

Caller must hold the Timer device lock.


function TimerDeviceDeregisterWaiter(Timer:PTimerDevice; Waiter:PTimerWaiter):LongWord;
Description: Deregister a waiter from the waiter list of the supplied Timer
Note Waiter must be destroyed by calling TimerDeviceDestroyWaiter.

Caller must hold the Timer device lock.


Random device helper functions

function RandomDeviceGetCount:LongWord;
Description: Get the current random device count
Note None documented


function RandomDeviceGetDefault:PRandomDevice;
Description: Get the current default random device
Note None documented


function RandomDeviceSetDefault(Random:PRandomDevice):LongWord;
Description: Set the current default random device
Note None documented


function RandomDeviceCheck(Random:PRandomDevice):PRandomDevice;
Description: Check if the supplied Random is in the Random table
Note None documented


function RandomTypeToString(RandomType:LongWord):String;
Description: Convert a Random type value to a string
Note None documented


function RandomStateToString(RandomState:LongWord):String;
Description: Convert a Random state value to a string
Note None documented


Mailbox device helper functions

function MailboxDeviceGetCount:LongWord;
Description: Get the current mailbox device count
Note None documented


function MailboxDeviceGetDefault:PMailboxDevice;
Description: Get the current default mailbox device
Note None documented


function MailboxDeviceSetDefault(Mailbox:PMailboxDevice):LongWord; 
Description: Set the current default mailbox device
Note None documented


function MailboxDeviceCheck(Mailbox:PMailboxDevice):PMailboxDevice;
Description: Check if the supplied Mailbox is in the Mailbox table
Note None documented


function MailboxTypeToString(MailboxType:LongWord):String;
Description: Convert a Mailbox type value to a string
Note None documented


function MailboxStateToString(MailboxState:LongWord):String;
Description: Convert a Mailbox state value to a string
Note None documented


Watchdog device helper functions

function WatchdogDeviceGetCount:LongWord;
Description: Get the current watchdog device count
Note None documented


function WatchdogDeviceGetDefault:PWatchdogDevice;
Description: Get the current default watchdog device
Note None documented


function WatchdogDeviceSetDefault(Watchdog:PWatchdogDevice):LongWord;
Description: Set the current default watchdog device
Note None documented


function WatchdogDeviceCheck(Watchdog:PWatchdogDevice):PWatchdogDevice;
Description: Check if the supplied Watchdog is in the Watchdog table
Note None documented


function WatchdogTypeToString(WatchdogType:LongWord):String;
Description: Convert a Watchdog type value to a string
Note None documented


function WatchdogStateToString(WatchdogState:LongWord):String;
Description: Convert a Watchdog state value to a string
Note None documented


Return to Unit Reference