Difference between revisions of "Unit Devices"

Latest revision as of 04:55, 21 June 2023

`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

`DEVICE_NAME_LENGTH = SIZE_64;`	Length of device name
`DEVICE_DESC_LENGTH = SIZE_128;`	Length of device description

Difference between revisions of "Unit Devices"

Latest revision as of 04:55, 21 June 2023

Contents

Description

Constants

Type definitions

Public variables

Function declarations

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Navigation

Tools

@@ Line 29: / Line 29: @@
 | <code>DEVICE_SIGNATURE = $AD03FE3C;</code>
 | style="width: 50%;"|&nbsp;
+|-
+|}
+</div></div>
+<br />
+<div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 20px; padding-bottom: 15px;">
+<div style="font-size: 14px; padding-left: 12px;">'''Device name''' <code> DEVICE_*_LENGTH </code></div>
+<div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
+{| class="wikitable" style="font-size: 14px; background: white;"
+|-
+| <code>DEVICE_NAME_LENGTH = SIZE_64;</code>
+| Length of device name
+|-
+| <code>DEVICE_DESC_LENGTH = SIZE_128;</code>
+| Length of device description
 |-
 |}
@@ Line 329: / Line 343: @@
 | <code>DEVICE_CLASS_GENERIC = 56;</code>
 | A Generic Device
+|-
+| <code>DEVICE_CLASS_VIRTIO = 57;</code>
+| A VIRTIO Device (eg Block/Network/Memory/Console/Input etc) (Implementing a standard VIRTIO device interface)
+|-
+| <code>DEVICE_CLASS_BLUETOOTHHOST = 58;</code>
+| A Bluetooth Host Controller (Implementing a standard Bluetooth host interface)
+|-
+| <code>DEVICE_CLASS_JOYSTICK = 59;</code>
+| A Joystick or Gamepad Device
+|-
+| <code>DEVICE_CLASS_HID = 60;</code>
+| A Human Interface Device (HID)
 |-
 |colspan="2"|&nbsp;
 |-
-| <code>DEVICE_CLASS_MAX = 56;</code>
+| <code>DEVICE_CLASS_MAX = 60;</code>
 | &nbsp;
 |-
@@ Line 339: / Line 365: @@
 | <code>DEVICE_CLASS_ANY = $FFFFFFFF;</code>
 | Any Device (Pass to DeviceFind or DeviceEnumerate to match all devices)
+|-
+|colspan="2"|&nbsp;
+|-
+|colspan="2"|''Device Class Names''
+|-
+|colspan="2"|<code>DEVICE_CLASS_NAMES:array[DEVICE_CLASS_NONE..DEVICE_CLASS_MAX] of String = (</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_NONE',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_USBHOST',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_PCIHOST',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_USB',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_PCI',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_NETWORK',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_STORAGE',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_FILESYSTEM',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_PROTOCOL',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_KEYBOARD',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_MOUSE',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_BLUETOOTH',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_SERIAL',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_AUDIO',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_VIDEO',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_SCSI',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_ATA',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_IMAGE',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_PRINTER',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_COMMUNICATIONS',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_SMART_CARD',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_MONITOR',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_DISPLAY',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_AUDIOVIDEO',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_IRDA',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_SPI',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_I2C',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_UART',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_MMC',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_SD',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_SDHCI',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_DFU',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_GPIO',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_MAILBOX',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_OPENGL',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_DVB',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_DAB',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_DMA',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_SCSIHOST',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_ATAHOST',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_TIMER',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_RANDOM',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_FRAMEBUFFER',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_WATCHDOG',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_CLOCK',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_CONSOLE',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_RTC',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_USBHUB',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_LOGGING',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_PCM',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_PWM',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_1WIRE',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_CLOCK_MANAGER',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_CODEC',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_TOUCH',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_MEMORY',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_GENERIC',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_VIRTIO',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_BLUETOOTHHOST',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_JOYSTICK',</code>
+|-
+|colspan="2"|<code>'DEVICE_CLASS_HID');</code>
 |-
 |}
@@ Line 420: / Line 574: @@
 </div></div>
 <br />
+<div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 20px; padding-bottom: 15px;">
+<div style="font-size: 14px; padding-left: 12px;">'''Firmware name''' <code> FIRMWARE_NAME_* </code></div>
+<div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
+{| class="wikitable" style="font-size: 14px; background: white;"
+|-
+| <code>FIRMWARE_NAME_LENGTH = SIZE_256;</code>
+| Length of firmware name
+|-
+|}
+</div></div>
+<br />
+<div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 20px; padding-bottom: 15px;">
+<div style="font-size: 14px; padding-left: 12px;">'''Firmware actions''' <code> FIRMWARE_ACTION_* </code></div>
+<div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
+{| class="wikitable" style="font-size: 14px; background: white;"
+|-
+| <code>FIRMWARE_ACTION_NONE = 0;</code>
+| &nbsp;
+|-
+| <code>FIRMWARE_ACTION_SIZE = 1;</code>
+| Return the size in bytes of the firmware item
+|-
+| <code>FIRMWARE_ACTION_OPEN = 2;</code>
+| Open the firmware item and return a handle
+|-
+| <code>FIRMWARE_ACTION_READ = 3;</code>
+| Read from the firmware item specified by a given handle
+|-
+| <code>FIRMWARE_ACTION_SEEK = 4;</code>
+| Seek to a location in the firmware item specified by a given handle
+|-
+| <code>FIRMWARE_ACTION_CLOSE = 5;</code>
+| Close a handle to the firmware item
+|-
+| <code>FIRMWARE_ACTION_ACQUIRE = 6;</code>
+| Acquire a memory block containing the firmware item
+|-
+| <code>FIRMWARE_ACTION_RELEASE = 7;</code>
+| Release a memory block containing the firmware item
+|-
+|}
+</div></div>
+<br />
+<div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 20px; padding-bottom: 15px;">
+<div style="font-size: 14px; padding-left: 12px;">'''Firmware constants''' <code> FIRMWARE_* </code></div>
+<div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
+{| class="wikitable" style="font-size: 14px; background: white;"
+|-
+| <code>FIRMWARE_WAIT_DELAY = 100;</code>
+| Delay between retries for firmware while waiting for timeout (Milliseconds)
+|-
+| <code>FIRMWARE_MAX_BUFFER = SIZE_4M;</code>
+| Maximum size buffer able to be allocated for firmware by acquire
+|-
+|}
+</div></div>
+<br />
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 20px; padding-bottom: 15px;">
 <div style="font-size: 14px; padding-left: 12px;">'''Notifier signature''' <code> NOTIFIER_SIGNATURE_* </code></div>
@@ Line 503: / Line 714: @@
 | <code>DRIVER_SIGNATURE = $1EB4980A;</code>
 | style="width: 50%;"|&nbsp;
+|-
+|}
+</div></div>
+<br />
+<div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 20px; padding-bottom: 15px;">
+<div style="font-size: 14px; padding-left: 12px;">'''Driver name''' <code> DRIVER_NAME_* </code></div>
+<div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
+{| class="wikitable" style="font-size: 14px; background: white;"
+|-
+| <code>DRIVER_NAME_LENGTH = SIZE_64;</code>
+| Length of driver name
 |-
 |}
@@ Line 556: / Line 778: @@
 | <code>DRIVER_CLASS_BLUETOOTH = 4;</code>
 | A Bluetooth Driver (Implementing a standard Bluetooth driver interface)
+|-
+| <code>DRIVER_CLASS_VIRTIO = 5;</code>
+| A VIRTIO Driver (Implementing a standard VIRTIO driver interface)
+|-
+| <code>DRIVER_CLASS_HID = 6;</code>
+| A Human Interface Device (HID) Driver (Implementing a standard HID driver interface)
 |-
 |colspan="2"|&nbsp;
 |-
-| <code>DRIVER_CLASS_MAX = 4;</code>
+| <code>DRIVER_CLASS_MAX = 6;</code>
 | &nbsp;
 |-
@@ Line 566: / Line 794: @@
 | <code>DRIVER_CLASS_ANY = $FFFFFFFF;</code>
 | Any Driver (Pass to DriverFind or DriverEnumerate to match all drivers)
+|-
+|colspan="2"|&nbsp;
+|-
+|colspan="2"|''Driver Class Names''
+|-
+|colspan="2"|<code>DRIVER_CLASS_NAMES:array[DRIVER_CLASS_NONE..DRIVER_CLASS_MAX] of String = (</code>
+|-
+|colspan="2"|<code>'DRIVER_CLASS_NONE',</code>
+|-
+|colspan="2"|<code>'DRIVER_CLASS_USB',</code>
+|-
+|colspan="2"|<code>'DRIVER_CLASS_PCI',</code>
+|-
+|colspan="2"|<code>'DRIVER_CLASS_SDIO',</code>
+|-
+|colspan="2"|<code>'DRIVER_CLASS_BLUETOOTH',</code>
+|-
+|colspan="2"|<code>'DRIVER_CLASS_VIRTIO',</code>
+|-
+|colspan="2"|<code>'DRIVER_CLASS_HID');</code>
 |-
 |}
@@ Line 588: / Line 836: @@
 | <code>HOST_SIGNATURE = $F45D30FE;</code>
 | style="width: 50%;"|&nbsp;
+|-
+|}
+</div></div>
+<br />
+<div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 20px; padding-bottom: 15px;">
+<div style="font-size: 14px; padding-left: 12px;">'''Host name''' <code> HOST_NAME_* </code></div>
+<div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
+{| class="wikitable" style="font-size: 14px; background: white;"
+|-
+| <code>HOST_NAME_LENGTH = SIZE_64;</code>
+| Length of host name
 |-
 |}
@@ Line 1,036: / Line 1,295: @@
 | Device state (eg Registered/Unregistered)
 |-
-| <code>DeviceName:String;</code>
+| <code>DeviceName:array[0..DEVICE_NAME_LENGTH - 1] of Char;</code>
 | The name of the Device (eg Keyboard0, Storage0 or Network0 etc)
 |-
@@ Line 1,054: / Line 1,313: @@
 | A pointer to a class specific Device interface (eg PUSBDevice, PNetworkDevice or PStorageDevice etc) (Used by Drivers)
 |-
-| <code>DeviceDescription:String;</code>
+| <code>DeviceDescription:array[0..DEVICE_DESC_LENGTH - 1] of Char;</code>
 | A description of the Device (eg BCM2835 PL011 UART)
 |-
@@ Line 1,067: / Line 1,326: @@
 |}
 </div></div>
+'''Device firmware'''
+<div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial;">
+<code>PDeviceFirmware = ^TDeviceFirmware;</code>
+<code>TDeviceFirmware = record</code>
+<div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
+{| class="wikitable" style="font-size: 14px; background: white;"
+|-
+| <code>DeviceClass:LongWord;</code>
+| The Device class supported by this firmware (or DEVICE_CLASS_ANY for all devices)
+|-
+| <code>Name:array[0..FIRMWARE_NAME_LENGTH - 1] of Char;</code>
+| The device specific name of the firmware which may be a filename, a device model, id or type
+|-
+| <code>Size:LongWord;</code>
+| For block (memory) based firmware, the size passed to Create or 0 for other firmware types
+|-
+| <code>Buffer:Pointer;</code>
+| For block (memory) based firmware, the buffer passed to Create or nil for other firmware types
+|-
+| <code>Handles:PFirmwareHandle;</code>
+| List of currently open handles for this firmware
+|-
+| <code>Handler:TDeviceFirmwareHandler;</code>
+| The device specific callback for the handler which provides this firmware
+|-
+|colspan="2"|''Internal Properties''
+|-
+| <code>Prev:PDeviceFirmware;</code>
+| Previous entry in Device firmware table}
+|-
+| <code>Next:PDeviceFirmware;</code>
+| Next entry in Device firmware table
+|-
+|}
+</div></div>
+'''Device firmware handler'''
+{| class="wikitable" style="font-size: 14px; text-align: left; width: 100%; height: 50px;"
+|-
+| <code>TDeviceFirmwareHandler = function(Firmware:PDeviceFirmware; Action:LongWord; var Handle:THandle; var Buffer:Pointer; var Value:LongWord):LongWord;</code>
+| style="width: 40%;"|
+|-
+|}
+'''Firmware handle'''
+<div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial;">
+<code>PFirmwareHandle = ^TFirmwareHandle;</code>
+<code>TFirmwareHandle = record</code>
+<div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
+{| class="wikitable" style="font-size: 14px; background: white;"
+|-
+| <code>Handle:THandle;</code>
+| style="width: 50%;"|&nbsp;
+|-
+| <code>Next:PFirmwareHandle;</code>
+| &nbsp;
+|-
+|}
+</div></div>
 '''Notifier entry'''
@@ Line 1,188: / Line 1,512: @@
 | Driver state (eg Registered/Unregistered)
 |-
-| <code>DriverName:String;</code>
+| <code>DriverName:array[0..DRIVER_NAME_LENGTH - 1] of Char;</code>
 | Descriptive name for the Driver (eg USB Mouse Driver)
 |-
@@ Line 1,234: / Line 1,558: @@
 | Host state (eg Registered/Unregistered)
 |-
-| <code>HostName:String;</code>
+| <code>HostName:array[0..HOST_NAME_LENGTH - 1] of Char;</code>
 | Descriptive name for the Host (eg DWC OTG Host)
 |-
@@ Line 4,677: / Line 5,001: @@
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function DeviceGetCount:LongWord; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function DeviceGetCount:LongWord;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current device count</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 4,701: / Line 5,025: @@
 <br />
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function NotifierGetCount:LongWord; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function NotifierGetCount:LongWord;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current notifier count</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 4,836: / Line 5,160: @@
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function DriverGetCount:LongWord; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function DriverGetCount:LongWord;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current driver count</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 4,887: / Line 5,211: @@
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function ClockDeviceGetCount:LongWord; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function ClockDeviceGetCount:LongWord;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current clock device count</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 4,899: / Line 5,223: @@
 <br />
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function ClockDeviceGetDefault:PClockDevice; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function ClockDeviceGetDefault:PClockDevice;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current default clock device</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 4,962: / Line 5,286: @@
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function TimerDeviceGetCount:LongWord; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function TimerDeviceGetCount:LongWord;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current timer device count</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 4,974: / Line 5,298: @@
 <br />
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function TimerDeviceGetDefault:PTimerDevice; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function TimerDeviceGetDefault:PTimerDevice;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current default timer device</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 4,986: / Line 5,310: @@
 <br />
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function TimerDeviceSetDefault(Timer:PTimerDevice):LongWord; </pre>
+<pre style="border: 0; padding-bottom:0px;">function TimerDeviceSetDefault(Timer:PTimerDevice):LongWord;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Set the current default timer device</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 5,089: / Line 5,413: @@
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function RandomDeviceGetCount:LongWord; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function RandomDeviceGetCount:LongWord;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current random device count</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 5,101: / Line 5,425: @@
 <br />
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function RandomDeviceGetDefault:PRandomDevice; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function RandomDeviceGetDefault:PRandomDevice;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current default random device</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 5,164: / Line 5,488: @@
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function MailboxDeviceGetCount:LongWord; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function MailboxDeviceGetCount:LongWord;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current mailbox device count</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 5,176: / Line 5,500: @@
 <br />
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function MailboxDeviceGetDefault:PMailboxDevice; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function MailboxDeviceGetDefault:PMailboxDevice;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current default mailbox device</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 5,239: / Line 5,563: @@
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function WatchdogDeviceGetCount:LongWord; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function WatchdogDeviceGetCount:LongWord;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current watchdog device count</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">
@@ Line 5,251: / Line 5,575: @@
 <br />
 <div class="toccolours mw-collapsible mw-collapsed" style="border: 1; font-family: arial; padding-top: 0px; padding-bottom: 15px;">
-<pre style="border: 0; padding-bottom:0px;">function WatchdogDeviceGetDefault:PWatchdogDevice; inline;</pre>
+<pre style="border: 0; padding-bottom:0px;">function WatchdogDeviceGetDefault:PWatchdogDevice;</pre>
 <div style="font-size: 14px; padding-left: 12px;">'''Description:''' Get the current default watchdog device</div>
 <div class="mw-collapsible-content" style="text-align: left; padding-left: 5px;">