devices.h

Go to the documentation of this file.

/*
 * This file is part of the Ultibo project, https://ultibo.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2026 Garry Wood <garry@softoz.com.au>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#ifndef _ULTIBO_DEVICE_H
#define _ULTIBO_DEVICE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "ultibo/globaltypes.h"
#include "ultibo/globalconst.h"
#include "ultibo/platform.h"

#define DEVICE_NAME_PREFIX  "Device" 

#define DEVICE_SIGNATURE    0xAD03FE3C

#define DEVICE_NAME_LENGTH  SIZE_64 
#define DEVICE_DESC_LENGTH  SIZE_128 

#define DEVICE_BUS_NONE 0
#define DEVICE_BUS_PCI  1
#define DEVICE_BUS_USB  2
#define DEVICE_BUS_ISA  3
#define DEVICE_BUS_PS2  4
#define DEVICE_BUS_FIREWIRE 5
#define DEVICE_BUS_SD   6 
#define DEVICE_BUS_MMC  7 
#define DEVICE_BUS_ATA  8
#define DEVICE_BUS_IDE  9
#define DEVICE_BUS_SCSI 10
#define DEVICE_BUS_ATAPI    11
#define DEVICE_BUS_SATA 12
#define DEVICE_BUS_SERIAL   13
#define DEVICE_BUS_SPI  14 
#define DEVICE_BUS_MMIO 15 
#define DEVICE_BUS_PCIE 16
#define DEVICE_BUS_I2C  17 
#define DEVICE_BUS_VIRTIO   18 
#define DEVICE_BUS_BLUETOOTH    19 
 
#define DEVICE_BUS_MAX  19

#define DEVICE_STATE_UNREGISTERED   0
#define DEVICE_STATE_REGISTERED 1
 
#define DEVICE_STATE_MAX    1

#define DEVICE_ID_ANY   0xFFFFFFFF 

#define DEVICE_CLASS_NONE   0 
#define DEVICE_CLASS_USBHOST    1 
#define DEVICE_CLASS_PCIHOST    2 
#define DEVICE_CLASS_USB    3 
#define DEVICE_CLASS_PCI    4 
#define DEVICE_CLASS_NETWORK    5 
#define DEVICE_CLASS_STORAGE    6 
#define DEVICE_CLASS_BLOCK  DEVICE_CLASS_STORAGE
#define DEVICE_CLASS_FILESYSTEM 7 
#define DEVICE_CLASS_PROTOCOL   8 
#define DEVICE_CLASS_TRANSPORT  DEVICE_CLASS_PROTOCOL
#define DEVICE_CLASS_KEYBOARD   9 
#define DEVICE_CLASS_MOUSE  10 
#define DEVICE_CLASS_BLUETOOTH  11 
#define DEVICE_CLASS_SERIAL 12 
#define DEVICE_CLASS_AUDIO  13 
#define DEVICE_CLASS_VIDEO  14 
#define DEVICE_CLASS_SCSI   15 
#define DEVICE_CLASS_ATA    16 
#define DEVICE_CLASS_IDE    DEVICE_CLASS_ATA
#define DEVICE_CLASS_ATAPI  DEVICE_CLASS_ATA
#define DEVICE_CLASS_IMAGE  17 
#define DEVICE_CLASS_PRINTER    18 
#define DEVICE_CLASS_COMMUNICATIONS 19 
#define DEVICE_CLASS_SMART_CARD 20 
#define DEVICE_CLASS_MONITOR    21 
#define DEVICE_CLASS_DISPLAY    22 
#define DEVICE_CLASS_AUDIOVIDEO 23 
#define DEVICE_CLASS_IRDA   24 
#define DEVICE_CLASS_SPI    25 
#define DEVICE_CLASS_I2C    26 
#define DEVICE_CLASS_UART   27 
#define DEVICE_CLASS_MMC    28 
#define DEVICE_CLASS_SD 29 
#define DEVICE_CLASS_SDHCI  30 
#define DEVICE_CLASS_SDHOST DEVICE_CLASS_SDHCI
#define DEVICE_CLASS_MMCHOST    DEVICE_CLASS_SDHCI
#define DEVICE_CLASS_MMCIHOST   DEVICE_CLASS_SDHCI
#define DEVICE_CLASS_DFU    31 
#define DEVICE_CLASS_GPIO   32 
#define DEVICE_CLASS_MAILBOX    33 
#define DEVICE_CLASS_OPENGL 34 
#define DEVICE_CLASS_DVB    35 
#define DEVICE_CLASS_DAB    36 
#define DEVICE_CLASS_DMA    37 
#define DEVICE_CLASS_SCSIHOST   38 
#define DEVICE_CLASS_ATAHOST    39 
#define DEVICE_CLASS_TIMER  40 
#define DEVICE_CLASS_RANDOM 41 
#define DEVICE_CLASS_FRAMEBUFFER    42 
#define DEVICE_CLASS_WATCHDOG   43 
#define DEVICE_CLASS_CLOCK  44 
#define DEVICE_CLASS_CONSOLE    45 
#define DEVICE_CLASS_RTC    46 
#define DEVICE_CLASS_USBHUB 47 
#define DEVICE_CLASS_LOGGING    48 
#define DEVICE_CLASS_PCM    49 
#define DEVICE_CLASS_I2S    DEVICE_CLASS_PCM
#define DEVICE_CLASS_PWM    50 
#define DEVICE_CLASS_1WIRE  51 
#define DEVICE_CLASS_CLOCK_MANAGER  52 
#define DEVICE_CLASS_CODEC  53 
#define DEVICE_CLASS_TOUCH  54 
#define DEVICE_CLASS_MEMORY 55 
#define DEVICE_CLASS_GENERIC    56 
#define DEVICE_CLASS_VIRTIO 57 
#define DEVICE_CLASS_BLUETOOTHHOST  58 
#define DEVICE_CLASS_JOYSTICK   59 
#define DEVICE_CLASS_HID    60 
 
#define DEVICE_CLASS_MAX    60
 
#define DEVICE_CLASS_ANY    0xFFFFFFFF 

#define DEVICE_NOTIFICATION_NONE    0x00000000 
#define DEVICE_NOTIFICATION_REGISTER    0x00000001
#define DEVICE_NOTIFICATION_DEREGISTER  0x00000002
#define DEVICE_NOTIFICATION_OPEN    0x00000004
#define DEVICE_NOTIFICATION_CLOSE   0x00000008
#define DEVICE_NOTIFICATION_UP  0x00000010
#define DEVICE_NOTIFICATION_DOWN    0x00000020
#define DEVICE_NOTIFICATION_INSERT  0x00000040
#define DEVICE_NOTIFICATION_EJECT   0x00000080
#define DEVICE_NOTIFICATION_ATTACH  0x00000100
#define DEVICE_NOTIFICATION_DETACH  0x00000200
#define DEVICE_NOTIFICATION_ENABLE  0x00000400
#define DEVICE_NOTIFICATION_DISABLE 0x00000800
#define DEVICE_NOTIFICATION_BIND    0x00001000
#define DEVICE_NOTIFICATION_UNBIND  0x00002000
#define DEVICE_NOTIFICATION_ATTACHING   0x00004000
#define DEVICE_NOTIFICATION_DETACHING   0x00008000
#define DEVICE_NOTIFICATION_INSERTING   0x00010000
#define DEVICE_NOTIFICATION_EJECTING    0x00020000
#define DEVICE_NOTIFICATION_OPENING 0x00040000
#define DEVICE_NOTIFICATION_CLOSING 0x00080000
#define DEVICE_NOTIFICATION_RESIZE  0x00100000
#define DEVICE_NOTIFICATION_RESIZING    0x00200000

#define FIRMWARE_NAME_LENGTH    SIZE_256 

#define FIRMWARE_ACTION_NONE    0
#define FIRMWARE_ACTION_SIZE    1 
#define FIRMWARE_ACTION_OPEN    2 
#define FIRMWARE_ACTION_READ    3 
#define FIRMWARE_ACTION_SEEK    4 
#define FIRMWARE_ACTION_CLOSE   5 
#define FIRMWARE_ACTION_ACQUIRE 6 
#define FIRMWARE_ACTION_RELEASE 7 

#define FIRMWARE_WAIT_DELAY 100 
#define FIRMWARE_MAX_BUFFER SIZE_4M 

#define NOTIFIER_SIGNATURE  0x6FA1BEC9

#define NOTIFIER_STATE_UNREGISTERED 0
#define NOTIFIER_STATE_REGISTERED   1

#define NOTIFIER_FLAG_NONE  0x00000000
#define NOTIFIER_FLAG_WORKER    0x00000001 
#define NOTIFIER_FLAG_UNLOCK    0x00000002 

#define DRIVER_NAME_PREFIX  "Driver" 

#define DRIVER_SIGNATURE    0x1EB4980A

#define DRIVER_NAME_LENGTH  SIZE_64 

#define DRIVER_STATE_UNREGISTERED   0
#define DRIVER_STATE_REGISTERED 1
 
#define DRIVER_STATE_MAX    1

#define DRIVER_ID_ANY   0xFFFFFFFF 

#define DRIVER_CLASS_NONE   0 
#define DRIVER_CLASS_USB    1 
#define DRIVER_CLASS_PCI    2 
#define DRIVER_CLASS_SDIO   3 
#define DRIVER_CLASS_BLUETOOTH  4 
#define DRIVER_CLASS_VIRTIO 5 
#define DRIVER_CLASS_HID    6 
 
#define DRIVER_CLASS_MAX    6
 
#define DRIVER_CLASS_ANY    0xFFFFFFFF 

#define HOST_NAME_PREFIX    "Host" 

#define HOST_SIGNATURE  0xF45D30FE

#define HOST_NAME_LENGTH    SIZE_64 

#define HOST_STATE_UNREGISTERED 0
#define HOST_STATE_REGISTERED   1
 
#define HOST_STATE_MAX  1

#define HOST_ID_ANY 0xFFFFFFFF 

#define HOST_CLASS_NONE 0 
#define HOST_CLASS_USB  1 
#define HOST_CLASS_PCI  2 
#define HOST_CLASS_SD   3 
#define HOST_CLASS_BLUETOOTH    4 
 
#define HOST_CLASS_MAX  4
 
#define HOST_CLASS_ANY  0xFFFFFFFF 

#define CLOCK_NAME_PREFIX   "Clock" 

#define CLOCK_TYPE_NONE 0
#define CLOCK_TYPE_HARDWARE 1
 
#define CLOCK_TYPE_MAX  1

#define CLOCK_STATE_DISABLED    0
#define CLOCK_STATE_ENABLED 1
 
#define CLOCK_STATE_MAX 1

#define CLOCK_FLAG_NONE 0x00000000
#define CLOCK_FLAG_WRITABLE 0x00000001 
#define CLOCK_FLAG_VARIABLE 0x00000002 

#define TIMER_NAME_PREFIX   "Timer" 

#define TIMER_TYPE_NONE 0
#define TIMER_TYPE_HARDWARE 1
 
#define TIMER_TYPE_MAX  1

#define TIMER_STATE_DISABLED    0
#define TIMER_STATE_ENABLED 1
 
#define TIMER_STATE_MAX 1

#define TIMER_FLAG_NONE 0x00000000
#define TIMER_FLAG_WRAPPING 0x00000001 
#define TIMER_FLAG_COUNTER  0x00000002 
#define TIMER_FLAG_DOWN 0x00000004 

#define TIMER_EVENT_FLAG_NONE   0x00000000
#define TIMER_EVENT_FLAG_REPEAT 0x00000001 
#define TIMER_EVENT_FLAG_INTERRUPT  0x00000002 

#define RANDOM_NAME_PREFIX  "Random" 

#define RANDOM_TYPE_NONE    0
#define RANDOM_TYPE_HARDWARE    1
#define RANDOM_TYPE_SOFTWARE    2
 
#define RANDOM_TYPE_MAX 2

#define RANDOM_STATE_DISABLED   0
#define RANDOM_STATE_ENABLED    1
 
#define RANDOM_STATE_MAX    1

#define RANDOM_FLAG_NONE    0x00000000

#define MAILBOX_NAME_PREFIX "Mailbox" 

#define MAILBOX_TYPE_NONE   0
#define MAILBOX_TYPE_GPU    1
#define MAILBOX_TYPE_LOCAL  2
 
#define MAILBOX_TYPE_MAX    2

#define MAILBOX_STATE_DISABLED  0
#define MAILBOX_STATE_ENABLED   1
 
#define MAILBOX_STATE_MAX   1

#define MAILBOX_FLAG_NONE   0x00000000

#define WATCHDOG_NAME_PREFIX    "Watchdog" 

#define WATCHDOG_TYPE_NONE  0
#define WATCHDOG_TYPE_HARDWARE  1
 
#define WATCHDOG_TYPE_MAX   1

#define WATCHDOG_STATE_DISABLED 0
#define WATCHDOG_STATE_ENABLED  1
 
#define WATCHDOG_STATE_MAX  1

#define WATCHDOG_FLAG_NONE  0x00000000

typedef struct _DEVICE DEVICE;

typedef uint32_t STDCALL (*device_enumerate_cb)(DEVICE *device, void *data);
typedef uint32_t STDCALL (*device_notification_cb)(DEVICE *device, void *data, uint32_t notification);

struct _DEVICE
{
    // Device Properties
    uint32_t signature; 
    uint32_t deviceid; 
    uint32_t devicestate; 
    char devicename[DEVICE_NAME_LENGTH]; 
    uint32_t deviceclass; 
    uint32_t devicebus; 
    uint32_t devicetype; 
    uint32_t deviceflags; 
    void *devicedata; 
    char devicedescription[DEVICE_DESC_LENGTH]; 
    // Internal Properties
    DEVICE *prev; 
    DEVICE *next; 
};
 
typedef struct _DEVICE_FIRMWARE DEVICE_FIRMWARE;

typedef uint32_t STDCALL (*device_firmware_handler)(DEVICE_FIRMWARE *firmware, uint32_t action, HANDLE *handle, void *buffer, uint32_t *value);
 
typedef struct _FIRMWARE_HANDLE FIRMWARE_HANDLE;

struct _DEVICE_FIRMWARE
{
    uint32_t deviceclass; 
    char name[FIRMWARE_NAME_LENGTH]; 
    uint32_t size; 
    void *buffer; 
    FIRMWARE_HANDLE *handles; 
    device_firmware_handler handler; 
    // Internal Properties
    DEVICE_FIRMWARE *prev; 
    DEVICE_FIRMWARE *next; 
};

struct _FIRMWARE_HANDLE
{
    HANDLE handle;
    FIRMWARE_HANDLE *next;
};

typedef struct _NOTIFIER NOTIFIER;
struct _NOTIFIER
{
    // Notifier Properties
    uint32_t signature; 
    uint32_t notifierstate; 
    uint32_t notifierflags; 
    DEVICE *device; 
    uint32_t deviceclass; 
    device_notification_cb callback; 
    void *data; 
    uint32_t notification; 
    // Internal Properties
    NOTIFIER *prev; 
    NOTIFIER *next; 
};

typedef struct _NOTIFIER_TASK NOTIFIER_TASK;
struct _NOTIFIER_TASK
{
    DEVICE *device;
    device_notification_cb callback;
    void *data;
    uint32_t notification;
    NOTIFIER_TASK *next;
};

typedef struct _NOTIFIER_RETRY NOTIFIER_RETRY;
struct _NOTIFIER_RETRY
{
    DEVICE *device;
    uint32_t notification;
};

typedef struct _DRIVER DRIVER;

typedef uint32_t STDCALL (*driver_enumerate_cb)(DRIVER *driver, void *data);

struct _DRIVER
{
    // Driver Properties
    uint32_t signature; 
    uint32_t driverid; 
    uint32_t driverstate; 
    char drivername[DRIVER_NAME_LENGTH]; 
    uint32_t driverclass; 
    // Internal Properties
    DRIVER *prev; 
    DRIVER *next; 
};

typedef struct _HOST HOST;

typedef uint32_t STDCALL (*host_enumerate_cb)(HOST *host, void *data);

struct _HOST
{
    // Host Properties
    uint32_t signature; 
    uint32_t hostid; 
    uint32_t hoststate; 
    char hostname[HOST_NAME_LENGTH]; 
    uint32_t hostclass; 
    // Internal Properties
    HOST *prev; 
    HOST *next; 
};

typedef struct _CLOCK_PROPERTIES CLOCK_PROPERTIES;
struct _CLOCK_PROPERTIES
{
    uint32_t flags; 
    uint32_t rate; 
    uint32_t minrate; 
    uint32_t maxrate; 
};

typedef struct _CLOCK_DEVICE CLOCK_DEVICE;

typedef uint32_t STDCALL (*clock_enumerate_cb)(CLOCK_DEVICE *clock, void *data);
typedef uint32_t STDCALL (*clock_notification_cb)(DEVICE *device, void *data, uint32_t notification);

typedef uint32_t STDCALL (*clock_device_start_proc)(CLOCK_DEVICE *clock);
typedef uint32_t STDCALL (*clock_device_stop_proc)(CLOCK_DEVICE *clock);
typedef uint32_t STDCALL (*clock_device_read_proc)(CLOCK_DEVICE *clock);
typedef int64_t STDCALL (*clock_device_read64_proc)(CLOCK_DEVICE *clock);
typedef uint32_t STDCALL (*clock_device_write64_proc)(CLOCK_DEVICE *clock, int64_t value);
typedef uint32_t STDCALL (*clock_device_get_rate_proc)(CLOCK_DEVICE *clock);
typedef uint32_t STDCALL (*clock_device_set_rate_proc)(CLOCK_DEVICE *clock, uint32_t rate);
typedef uint32_t STDCALL (*clock_device_get_properties_proc)(CLOCK_DEVICE *clock, CLOCK_PROPERTIES *properties);

struct _CLOCK_DEVICE
{
    // Device Properties
    DEVICE device; 
    // Clock Properties
    uint32_t clockid; 
    uint32_t clockstate; 
    clock_device_start_proc devicestart; 
    clock_device_stop_proc devicestop; 
    clock_device_read_proc deviceread; 
    clock_device_read64_proc deviceread64; 
    clock_device_write64_proc devicewrite64; 
    clock_device_get_rate_proc devicegetrate; 
    clock_device_set_rate_proc devicesetrate; 
    clock_device_get_properties_proc devicegetproperties; 
    // Statistics Properties
    uint32_t readcount;
    // Driver Properties
    MUTEX_HANDLE lock; 
    void *address; 
    uint32_t rate; 
    uint32_t minrate; 
    uint32_t maxrate; 
    // Internal Properties
    CLOCK_DEVICE *prev; 
    CLOCK_DEVICE *next; 
};

typedef counter_event_cb timer_cb; 

typedef struct _TIMER_PROPERTIES TIMER_PROPERTIES;
struct _TIMER_PROPERTIES
{
    uint32_t flags; 
    uint32_t bits; 
    uint32_t minrate; 
    uint32_t maxrate; 
    uint32_t mininterval; 
    uint32_t maxinterval; 
};
 

typedef struct _TIMER_DEVICE TIMER_DEVICE; 

typedef struct _TIMER_WAITER TIMER_WAITER;
struct _TIMER_WAITER
{
    TIMER_DEVICE *timer; 
    timer_cb callback; 
    void *data; 
    TIMER_WAITER *prev; 
    TIMER_WAITER *next; 
};

typedef uint32_t STDCALL (*timer_enumerate_cb)(TIMER_DEVICE *timer, void *data);
typedef uint32_t STDCALL (*timer_notification_cb)(DEVICE *device, void *data, uint32_t notification);

typedef uint32_t STDCALL (*timer_device_start_proc)(TIMER_DEVICE *timer);
typedef uint32_t STDCALL (*timer_device_stop_proc)(TIMER_DEVICE *timer);
typedef uint32_t STDCALL (*timer_device_read_proc)(TIMER_DEVICE *timer);
typedef int64_t STDCALL (*timer_device_read64_proc)(TIMER_DEVICE *timer);
typedef uint32_t STDCALL (*timer_device_wait_proc)(TIMER_DEVICE *timer);
typedef uint32_t STDCALL (*timer_device_event_proc)(TIMER_DEVICE *timer, uint32_t flags, timer_cb callback, void *data);
typedef uint32_t STDCALL (*timer_device_cancel_proc)(TIMER_DEVICE *timer);
typedef uint32_t STDCALL (*timer_device_get_rate_proc)(TIMER_DEVICE *timer);
typedef uint32_t STDCALL (*timer_device_set_rate_proc)(TIMER_DEVICE *timer, uint32_t rate);
typedef uint32_t STDCALL (*timer_device_get_interval_proc)(TIMER_DEVICE *timer);
typedef uint32_t STDCALL (*timer_device_set_interval_proc)(TIMER_DEVICE *timer, uint32_t interval);
typedef uint32_t STDCALL (*timer_device_get_properties_proc)(TIMER_DEVICE *timer, TIMER_PROPERTIES *properties);
 
struct _TIMER_DEVICE
{
    // Device Properties
    DEVICE device; 
    // Timer Properties
    uint32_t timerid; 
    uint32_t timerstate; 
    timer_device_start_proc devicestart; 
    timer_device_stop_proc devicestop; 
    timer_device_read_proc deviceread; 
    timer_device_read64_proc deviceread64; 
    timer_device_wait_proc devicewait; 
    timer_device_event_proc deviceevent; 
    timer_device_cancel_proc devicecancel; 
    timer_device_get_rate_proc devicegetrate; 
    timer_device_set_rate_proc devicesetrate; 
    timer_device_get_interval_proc devicegetinterval; 
    timer_device_set_interval_proc devicesetinterval; 
    timer_device_get_properties_proc devicegetproperties; 
    // Statistics Properties
    uint32_t readcount;
    uint32_t waitcount;
    uint32_t eventcount;
    // Driver Properties
    MUTEX_HANDLE lock; 
    void *address; 
    uint32_t rate; 
    uint32_t interval; 
    TIMER_PROPERTIES properties; 
    // Event Properties
    uint32_t flags; 
    uint32_t count; 
    EVENT_HANDLE event; 
    TIMER_WAITER *waiters; 
    // Internal Properties
    TIMER_DEVICE *prev; 
    TIMER_DEVICE *next; 
};

typedef struct _RANDOM_DEVICE RANDOM_DEVICE;

typedef uint32_t STDCALL (*random_enumerate_cb)(RANDOM_DEVICE *random, void *data);
typedef uint32_t STDCALL (*random_notification_cb)(DEVICE *device, void *data, uint32_t notification);

typedef uint32_t STDCALL (*random_device_start_proc)(RANDOM_DEVICE *random);
typedef uint32_t STDCALL (*random_device_stop_proc)(RANDOM_DEVICE *random);
typedef uint32_t STDCALL (*random_device_seed_proc)(RANDOM_DEVICE *random, uint32_t seed);
typedef uint8_t STDCALL (*random_device_read_byte_proc)(RANDOM_DEVICE *random);
typedef uint16_t STDCALL (*random_device_read_word_proc)(RANDOM_DEVICE *random);
typedef uint32_t STDCALL (*random_device_read_longword_proc)(RANDOM_DEVICE *random);
typedef int64_t STDCALL (*random_device_read_long_long_proc)(RANDOM_DEVICE *random);
typedef double_t STDCALL (*random_device_read_double_proc)(RANDOM_DEVICE *random);

struct _RANDOM_DEVICE
{
    // Device Properties
    DEVICE device; 
    // Random Properties
    uint32_t randomid; 
    uint32_t randomstate; 
    random_device_start_proc devicestart; 
    random_device_stop_proc devicestop; 
    random_device_seed_proc deviceseed; 
    random_device_read_byte_proc devicereadbyte; 
    random_device_read_word_proc devicereadword; 
    random_device_read_longword_proc devicereadlongword; 
    random_device_read_long_long_proc devicereadquadword; 
    random_device_read_double_proc devicereaddouble; 
    // Statistics Properties
    uint32_t seedcount;
    uint32_t readcount;
    // Driver Properties
    MUTEX_HANDLE lock; 
    void *address; 
    // Internal Properties
    RANDOM_DEVICE *prev; 
    RANDOM_DEVICE *next; 
};

typedef struct _MAILBOX_DEVICE MAILBOX_DEVICE;

typedef uint32_t STDCALL (*mailbox_enumerate_cb)(MAILBOX_DEVICE *mailbox, void *data);
typedef uint32_t STDCALL (*mailbox_notification_cb)(DEVICE *device, void *data, uint32_t notification);

typedef uint32_t STDCALL (*mailbox_device_start_proc)(MAILBOX_DEVICE *mailbox);
typedef uint32_t STDCALL (*mailbox_device_stop_proc)(MAILBOX_DEVICE *mailbox);
typedef uint32_t STDCALL (*mailbox_device_receive_proc)(MAILBOX_DEVICE *mailbox, uint32_t channel);
typedef uint32_t STDCALL (*mailbox_device_send_proc)(MAILBOX_DEVICE *mailbox, uint32_t channel, uint32_t data);
typedef uint32_t STDCALL (*mailbox_device_call_proc)(MAILBOX_DEVICE *mailbox, uint32_t channel, uint32_t data, uint32_t *response);
typedef uint32_t STDCALL (*mailbox_device_get_timeout_proc)(MAILBOX_DEVICE *mailbox);
typedef uint32_t STDCALL (*mailbox_device_set_timeout_proc)(MAILBOX_DEVICE *mailbox, uint32_t timeout);

struct _MAILBOX_DEVICE
{
    // Device Properties
    DEVICE device; 
    // Mailbox Properties
    uint32_t mailboxid; 
    uint32_t mailboxstate; 
    mailbox_device_start_proc devicestart; 
    mailbox_device_stop_proc devicestop; 
    mailbox_device_receive_proc devicereceive; 
    mailbox_device_send_proc devicesend; 
    mailbox_device_call_proc devicecall; 
    mailbox_device_get_timeout_proc devicegettimeout; 
    mailbox_device_set_timeout_proc devicesettimeout; 
    // Statistics Properties
    uint32_t receivecount;
    uint32_t sendcount;
    uint32_t callcount;
    // Driver Properties
    MUTEX_HANDLE lock; 
    void *address; 
    uint32_t timeout; 
    // Internal Properties
    MAILBOX_DEVICE *prev; 
    MAILBOX_DEVICE *next; 
};

typedef struct _WATCHDOG_DEVICE WATCHDOG_DEVICE;

typedef uint32_t STDCALL (*watchdog_enumerate_cb)(WATCHDOG_DEVICE *watchdog, void *data);
typedef uint32_t STDCALL (*watchdog_notification_cb)(DEVICE *device, void *data, uint32_t notification);

typedef uint32_t STDCALL (*watchdog_device_start_proc)(WATCHDOG_DEVICE *watchdog);
typedef uint32_t STDCALL (*watchdog_device_stop_proc)(WATCHDOG_DEVICE *watchdog);
typedef uint32_t STDCALL (*watchdog_device_refresh_proc)(WATCHDOG_DEVICE *watchdog);
typedef uint32_t STDCALL (*watchdog_device_get_remain_proc)(WATCHDOG_DEVICE *watchdog);
typedef uint32_t STDCALL (*watchdog_device_get_timeout_proc)(WATCHDOG_DEVICE *watchdog);
typedef uint32_t STDCALL (*watchdog_device_set_timeout_proc)(WATCHDOG_DEVICE *watchdog, uint32_t timeout);

struct _WATCHDOG_DEVICE
{
    // Device Properties
    DEVICE device; 
    // Watchdog Properties
    uint32_t watchdogid; 
    uint32_t watchdogstate; 
    watchdog_device_start_proc devicestart; 
    watchdog_device_stop_proc devicestop; 
    watchdog_device_refresh_proc devicerefresh; 
    watchdog_device_get_remain_proc devicegetremain; 
    watchdog_device_get_timeout_proc devicegettimeout; 
    watchdog_device_set_timeout_proc devicesettimeout; 
    // Statistics Properties
    uint32_t startcount;
    uint32_t stopcount;
    uint32_t refreshcount;
    // Driver Properties
    MUTEX_HANDLE lock; 
    void *address; 
    uint32_t timeout; 
    // Internal Properties
    WATCHDOG_DEVICE *prev; 
    WATCHDOG_DEVICE *next; 
};


DEVICE * STDCALL device_create(void);

DEVICE * STDCALL device_create_ex(uint32_t size);

uint32_t STDCALL device_destroy(DEVICE *device);

uint32_t STDCALL device_get_name(DEVICE *device, char *name, uint32_t len);

uint32_t STDCALL device_set_name(DEVICE *device, const char *name);

uint32_t STDCALL device_get_description(DEVICE *device, char *name, uint32_t len);

uint32_t STDCALL device_set_description(DEVICE *device, const char *description);

uint32_t STDCALL device_register(DEVICE *device);

uint32_t STDCALL device_deregister(DEVICE *device);

DEVICE * STDCALL device_find(uint32_t deviceclass, uint32_t deviceid);

DEVICE * STDCALL device_find_by_device_data(void *devicedata);

DEVICE * STDCALL device_find_by_name(const char *name);

DEVICE * STDCALL device_find_by_name_ex(uint32_t deviceclass, const char *name);

DEVICE * STDCALL device_find_by_description(const char *description);

DEVICE * STDCALL device_find_by_description_ex(uint32_t deviceclass, const char *description);

uint32_t STDCALL device_enumerate(uint32_t deviceclass, device_enumerate_cb callback, void *data);

uint32_t STDCALL device_notification(DEVICE *device, uint32_t deviceclass, device_notification_cb callback, void *data, uint32_t notification, uint32_t flags);

BOOL STDCALL device_firmware_create(uint32_t deviceclass, const char *name, void *buffer, uint32_t size);

HANDLE STDCALL device_firmware_register(uint32_t deviceclass, const char *name, device_firmware_handler handler);

uint32_t STDCALL device_firmware_deregister(HANDLE handle);

DEVICE_FIRMWARE * STDCALL device_firmware_find(uint32_t deviceclass, const char *name);

DEVICE_FIRMWARE * STDCALL device_firmware_find_by_handle(HANDLE handle);

uint32_t STDCALL device_firmware_open(uint32_t deviceclass, const char *name, uint32_t timeout, HANDLE *handle);

uint32_t STDCALL device_firmware_close(HANDLE handle);

int32_t STDCALL device_firmware_size(HANDLE handle);

int32_t STDCALL device_firmware_seek(HANDLE handle, int32_t position);

int32_t STDCALL device_firmware_read(HANDLE handle, void *buffer, int32_t count);

uint32_t STDCALL device_firmware_acquire(uint32_t deviceclass, const char *name, uint32_t timeout, HANDLE *handle, void *buffer, uint32_t *size);

uint32_t STDCALL device_firmware_release(HANDLE handle, void *buffer, uint32_t size);

NOTIFIER * STDCALL notifier_allocate(DEVICE *device, uint32_t deviceclass, device_notification_cb callback, void *data, uint32_t notification, uint32_t flags);

uint32_t STDCALL notifier_release(NOTIFIER *notifier);
 
NOTIFIER * STDCALL notifier_find(DEVICE *device, uint32_t deviceclass, device_notification_cb callback, void *data);
uint32_t STDCALL notifier_notify(DEVICE *device, uint32_t notification);
 
void STDCALL notifier_retry(NOTIFIER_RETRY *retry);
void STDCALL notifier_worker(NOTIFIER_TASK *task);


DRIVER * STDCALL driver_create(void);

DRIVER * STDCALL driver_create_ex(uint32_t size);

uint32_t STDCALL driver_destroy(DRIVER *driver);

uint32_t STDCALL driver_get_name(DRIVER *driver, char *name, uint32_t len);

uint32_t STDCALL driver_set_name(DRIVER *driver, const char *name);

uint32_t STDCALL driver_register(DRIVER *driver);

uint32_t STDCALL driver_deregister(DRIVER *driver);

DRIVER * STDCALL driver_find(uint32_t driverclass, uint32_t driverid);

DRIVER * STDCALL driver_find_by_name(const char *name);

uint32_t STDCALL driver_enumerate(uint32_t driverclass, driver_enumerate_cb callback, void *data);


uint32_t STDCALL clock_device_start(CLOCK_DEVICE *clock);

uint32_t STDCALL clock_device_stop(CLOCK_DEVICE *clock);

uint32_t STDCALL clock_device_read(CLOCK_DEVICE *clock);

int64_t STDCALL clock_device_read64(CLOCK_DEVICE *clock);

uint32_t STDCALL clock_device_write64(CLOCK_DEVICE *clock, int64_t value);

uint32_t STDCALL clock_device_get_rate(CLOCK_DEVICE *clock);

uint32_t STDCALL clock_device_set_rate(CLOCK_DEVICE *clock, uint32_t rate);

uint32_t STDCALL clock_device_properties(CLOCK_DEVICE *clock, CLOCK_PROPERTIES *properties);

uint32_t STDCALL clock_device_get_properties(CLOCK_DEVICE *clock, CLOCK_PROPERTIES *properties);

CLOCK_DEVICE * STDCALL clock_device_create(void);

CLOCK_DEVICE * STDCALL clock_device_create_ex(uint32_t size);

uint32_t STDCALL clock_device_destroy(CLOCK_DEVICE *clock);

uint32_t STDCALL clock_device_register(CLOCK_DEVICE *clock);

uint32_t STDCALL clock_device_deregister(CLOCK_DEVICE *clock);

CLOCK_DEVICE * STDCALL clock_device_find(uint32_t clockid);

CLOCK_DEVICE * STDCALL clock_device_find_by_name(const char *name);

CLOCK_DEVICE * STDCALL clock_device_find_by_description(const char *description);

uint32_t STDCALL clock_device_enumerate(clock_enumerate_cb callback, void *data);

uint32_t STDCALL clock_device_notification(CLOCK_DEVICE *clock, clock_notification_cb callback, void *data, uint32_t notification, uint32_t flags);


uint32_t STDCALL timer_device_start(TIMER_DEVICE *timer);

uint32_t STDCALL timer_device_stop(TIMER_DEVICE *timer);

uint32_t STDCALL timer_device_read(TIMER_DEVICE *timer);

int64_t STDCALL timer_device_read64(TIMER_DEVICE *timer);

uint32_t STDCALL timer_device_wait(TIMER_DEVICE *timer);

uint32_t STDCALL timer_device_event(TIMER_DEVICE *timer, uint32_t flags, timer_cb callback, void *data);

uint32_t STDCALL timer_device_cancel(TIMER_DEVICE *timer);

uint32_t STDCALL timer_device_get_rate(TIMER_DEVICE *timer);

uint32_t STDCALL timer_device_set_rate(TIMER_DEVICE *timer, uint32_t rate);

uint32_t STDCALL timer_device_get_interval(TIMER_DEVICE *timer);

uint32_t STDCALL timer_device_set_interval(TIMER_DEVICE *timer, uint32_t interval);

uint32_t STDCALL timer_device_properties(TIMER_DEVICE *timer, TIMER_PROPERTIES *properties);

uint32_t STDCALL timer_device_get_properties(TIMER_DEVICE *timer, TIMER_PROPERTIES *properties);

TIMER_DEVICE * STDCALL timer_device_create(void);

TIMER_DEVICE * STDCALL timer_device_create_ex(uint32_t size);

uint32_t STDCALL timer_device_destroy(TIMER_DEVICE *timer);

uint32_t STDCALL timer_device_register(TIMER_DEVICE *timer);

uint32_t STDCALL timer_device_deregister(TIMER_DEVICE *timer);

TIMER_DEVICE * STDCALL timer_device_find(uint32_t timerid);

TIMER_DEVICE * STDCALL timer_device_find_by_name(const char *name);

TIMER_DEVICE * STDCALL timer_device_find_by_description(const char *description);

uint32_t STDCALL timer_device_enumerate(timer_enumerate_cb callback, void *data);

uint32_t STDCALL timer_device_notification(TIMER_DEVICE *timer, timer_notification_cb callback, void *data, uint32_t notification, uint32_t flags);

uint32_t STDCALL random_device_start(RANDOM_DEVICE *random);
uint32_t STDCALL random_device_stop(RANDOM_DEVICE *random);
 
uint32_t STDCALL random_device_seed(RANDOM_DEVICE *random, uint32_t seed);
uint8_t STDCALL random_device_read_byte(RANDOM_DEVICE *random);
uint16_t STDCALL random_device_read_word(RANDOM_DEVICE *random);
uint32_t STDCALL random_device_read_long_word(RANDOM_DEVICE *random);
int64_t STDCALL random_device_read_quad_word(RANDOM_DEVICE *random);
double_t STDCALL random_device_read_double(RANDOM_DEVICE *random);

double_t STDCALL random_device_read_extended(RANDOM_DEVICE *random);

RANDOM_DEVICE * STDCALL random_device_create(void);

RANDOM_DEVICE * STDCALL random_device_create_ex(uint32_t size);

uint32_t STDCALL random_device_destroy(RANDOM_DEVICE *random);

uint32_t STDCALL random_device_register(RANDOM_DEVICE *random);

uint32_t STDCALL random_device_deregister(RANDOM_DEVICE *random);
 
RANDOM_DEVICE * STDCALL random_device_find(uint32_t randomid);
RANDOM_DEVICE * STDCALL random_device_find_by_name(const char *name);
RANDOM_DEVICE * STDCALL random_device_find_by_description(const char *description);
uint32_t STDCALL random_device_enumerate(random_enumerate_cb callback, void *data);
 
uint32_t STDCALL random_device_notification(RANDOM_DEVICE *random, random_notification_cb callback, void *data, uint32_t notification, uint32_t flags);

uint32_t STDCALL mailbox_device_start(MAILBOX_DEVICE *mailbox);
uint32_t STDCALL mailbox_device_stop(MAILBOX_DEVICE *mailbox);
uint32_t STDCALL mailbox_device_receive(MAILBOX_DEVICE *mailbox, uint32_t channel);
uint32_t STDCALL mailbox_device_send(MAILBOX_DEVICE *mailbox, uint32_t channel, uint32_t data);
uint32_t STDCALL mailbox_device_call(MAILBOX_DEVICE *mailbox, uint32_t channel, uint32_t data, uint32_t *response);
uint32_t STDCALL mailbox_device_get_timeout(MAILBOX_DEVICE *mailbox);
uint32_t STDCALL mailbox_device_set_timeout(MAILBOX_DEVICE *mailbox, uint32_t timeout);

MAILBOX_DEVICE * STDCALL mailbox_device_create(void);

MAILBOX_DEVICE * STDCALL mailbox_device_create_ex(uint32_t size);

uint32_t STDCALL mailbox_device_destroy(MAILBOX_DEVICE *mailbox);

uint32_t STDCALL mailbox_device_register(MAILBOX_DEVICE *mailbox);

uint32_t STDCALL mailbox_device_deregister(MAILBOX_DEVICE *mailbox);
 
MAILBOX_DEVICE * STDCALL mailbox_device_find(uint32_t mailboxid);
MAILBOX_DEVICE * STDCALL mailbox_device_find_by_name(const char *name);
MAILBOX_DEVICE * STDCALL mailbox_device_find_by_description(const char *description);
uint32_t STDCALL mailbox_device_enumerate(mailbox_enumerate_cb callback, void *data);
 
uint32_t STDCALL mailbox_device_notification(MAILBOX_DEVICE *mailbox, mailbox_notification_cb callback, void *data, uint32_t notification, uint32_t flags);

uint32_t STDCALL watchdog_device_start(WATCHDOG_DEVICE *watchdog);
uint32_t STDCALL watchdog_device_stop(WATCHDOG_DEVICE *watchdog);
uint32_t STDCALL watchdog_device_refresh(WATCHDOG_DEVICE *watchdog);
 
uint32_t STDCALL watchdog_device_get_remain(WATCHDOG_DEVICE *watchdog);
uint32_t STDCALL watchdog_device_get_timeout(WATCHDOG_DEVICE *watchdog);
uint32_t STDCALL watchdog_device_set_timeout(WATCHDOG_DEVICE *watchdog, uint32_t timeout);

WATCHDOG_DEVICE * STDCALL watchdog_device_create(void);

WATCHDOG_DEVICE * STDCALL watchdog_device_create_ex(uint32_t size);

uint32_t STDCALL watchdog_device_destroy(WATCHDOG_DEVICE *watchdog);

uint32_t STDCALL watchdog_device_register(WATCHDOG_DEVICE *watchdog);

uint32_t STDCALL watchdog_device_deregister(WATCHDOG_DEVICE *watchdog);
 
WATCHDOG_DEVICE * STDCALL watchdog_device_find(uint32_t watchdogid);
WATCHDOG_DEVICE * STDCALL watchdog_device_find_by_name(const char *name);
WATCHDOG_DEVICE * STDCALL watchdog_device_find_by_description(const char *description);
uint32_t STDCALL watchdog_device_enumerate(watchdog_enumerate_cb callback, void *data);
 
uint32_t STDCALL watchdog_device_notification(WATCHDOG_DEVICE *watchdog, watchdog_notification_cb callback, void *data, uint32_t notification, uint32_t flags);


uint32_t STDCALL device_get_count(void);

DEVICE * STDCALL device_check(DEVICE *device);

uint32_t STDCALL notifier_get_count(void);

NOTIFIER * STDCALL notifier_check(NOTIFIER *notifier);
 
uint32_t STDCALL device_bus_to_string(uint32_t devicebus, char *string, uint32_t len);
uint32_t STDCALL device_state_to_string(uint32_t devicestate, char *string, uint32_t len);
uint32_t STDCALL device_class_to_string(uint32_t deviceclass, char *string, uint32_t len);
 
uint32_t STDCALL notification_to_string(uint32_t notification, char *string, uint32_t len);


uint32_t STDCALL driver_get_count(void);

DRIVER * STDCALL driver_check(DRIVER *driver);
 
uint32_t STDCALL driver_state_to_string(uint32_t driverstate, char *string, uint32_t len);
uint32_t STDCALL driver_class_to_string(uint32_t driverclass, char *string, uint32_t len);


uint32_t STDCALL clock_device_get_count(void);

CLOCK_DEVICE * STDCALL clock_device_get_default(void);

uint32_t STDCALL clock_device_set_default(CLOCK_DEVICE *clock);

CLOCK_DEVICE * STDCALL clock_device_check(CLOCK_DEVICE *clock);

uint32_t STDCALL clock_type_to_string(uint32_t clocktype, char *string, uint32_t len);

uint32_t STDCALL clock_state_to_string(uint32_t clockstate, char *string, uint32_t len);


uint32_t STDCALL timer_device_get_count(void);

TIMER_DEVICE * STDCALL timer_device_get_default(void);

uint32_t STDCALL timer_device_set_default(TIMER_DEVICE *timer);

TIMER_DEVICE * STDCALL timer_device_check(TIMER_DEVICE *timer);

uint32_t STDCALL timer_type_to_string(uint32_t timertype, char *string, uint32_t len);

uint32_t STDCALL timer_state_to_string(uint32_t timerstate, char *string, uint32_t len);

TIMER_WAITER * STDCALL timer_device_create_waiter(TIMER_DEVICE *timer, timer_cb callback, void *data);

uint32_t STDCALL timer_device_destroy_waiter(TIMER_DEVICE *timer, TIMER_WAITER *waiter);

uint32_t STDCALL timer_device_register_waiter(TIMER_DEVICE *timer, TIMER_WAITER *waiter);

uint32_t STDCALL timer_device_deregister_waiter(TIMER_DEVICE *timer, TIMER_WAITER *waiter);


uint32_t STDCALL random_device_get_count(void);

RANDOM_DEVICE * STDCALL random_device_get_default(void);

uint32_t STDCALL random_device_set_default(RANDOM_DEVICE *random);

RANDOM_DEVICE * STDCALL random_device_check(RANDOM_DEVICE *random);

uint32_t STDCALL random_type_to_string(uint32_t randomtype, char *string, uint32_t len);

uint32_t STDCALL random_state_to_string(uint32_t randomstate, char *string, uint32_t len);


uint32_t STDCALL mailbox_device_get_count(void);

MAILBOX_DEVICE * STDCALL mailbox_device_get_default(void);

uint32_t STDCALL mailbox_device_set_default(MAILBOX_DEVICE *mailbox);

MAILBOX_DEVICE * STDCALL mailbox_device_check(MAILBOX_DEVICE *mailbox);

uint32_t STDCALL mailbox_type_to_string(uint32_t mailboxtype, char *string, uint32_t len);

uint32_t STDCALL mailbox_state_to_string(uint32_t mailboxstate, char *string, uint32_t len);


uint32_t STDCALL watchdog_device_get_count(void);

WATCHDOG_DEVICE * STDCALL watchdog_device_get_default(void);

uint32_t STDCALL watchdog_device_set_default(WATCHDOG_DEVICE *watchdog);

WATCHDOG_DEVICE * STDCALL watchdog_device_check(WATCHDOG_DEVICE *watchdog);

uint32_t STDCALL watchdog_type_to_string(uint32_t watchdogtype, char *string, uint32_t len);

uint32_t STDCALL watchdog_state_to_string(uint32_t watchdogstate, char *string, uint32_t len);
 
#ifdef __cplusplus
}
#endif
 
#endif // _ULTIBO_DEVICE_H