radkernel.h

Go to the documentation of this file.

#ifndef RADKERNEL_H
#define RADKERNEL_H
 
#include <stddef.h>
#include <stdint.h>
#include <stdarg.h>
 
#if defined(__cplusplus) && !defined(RADLIB_EMBEDDED_NO_CPP_WRAPPERS)
#include <string>
#include <vector>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define RADEK_VERSION_MAJOR 0 
#define RADEK_VERSION_MINOR 1 
#define RADEK_VERSION_PATCH 2 
 
#define RAD_IOCTL_NONE 0u 
#define RAD_IOCTL_WRITE 1u 
#define RAD_IOCTL_READ 2u 
#define RAD_IOCTL_READWRITE 3u 
#define RAD_IOCTL(dir, type, nr, size) ((((uint32_t)(dir) & 3u) << 30) | (((uint32_t)(size) & 0x3fffu) << 16) | (((uint32_t)(type) & 0xffu) << 8) | ((uint32_t)(nr) & 0xffu)) 
#define RAD_IO(type, nr) RAD_IOCTL(RAD_IOCTL_NONE, type, nr, 0u) 
#define RAD_IOR(type, nr, type_name) RAD_IOCTL(RAD_IOCTL_READ, type, nr, sizeof(type_name)) 
#define RAD_IOW(type, nr, type_name) RAD_IOCTL(RAD_IOCTL_WRITE, type, nr, sizeof(type_name)) 
#define RAD_IOWR(type, nr, type_name) RAD_IOCTL(RAD_IOCTL_READWRITE, type, nr, sizeof(type_name)) 
#define RAD_IOCTL_DIR(request) (((uint32_t)(request) >> 30) & 3u) 
#define RAD_IOCTL_SIZE(request) (((uint32_t)(request) >> 16) & 0x3fffu) 
#define RAD_IOCTL_TYPE(request) (((uint32_t)(request) >> 8) & 0xffu) 
#define RAD_IOCTL_NR(request) ((uint32_t)(request) & 0xffu) 
 
#define RAD_IOCTL_TYPE_I2C 'I' 
#define RAD_IOCTL_TYPE_SPI 'S' 
#define RAD_IOCTL_TYPE_AUDIO 'A' 
#define RAD_IOCTL_TYPE_SERIAL 'T' 
#define RAD_IOCTL_TYPE_FRAMEBUFFER 'F' 
#define RAD_IOCTL_TYPE_INPUT 'K' 
#define RAD_IOCTL_TYPE_BLOCK 'B' 
#define RAD_IOCTL_TYPE_NET 'N' 
#define RAD_IOCTL_TYPE_COMPOSITOR 'C' 
#define RAD_IOCTL_TYPE_USB 'U' 
#define RAD_IOCTL_TYPE_TTY 'Y' 
 
#define RAD_DEVICE_IOCTL_I2C_TRANSFER RAD_IOWR(RAD_IOCTL_TYPE_I2C, 1u, struct rad_i2c_transfer) 
#define RAD_DEVICE_IOCTL_SPI_TRANSFER RAD_IOWR(RAD_IOCTL_TYPE_SPI, 1u, struct rad_spi_transfer) 
#define RAD_DEVICE_IOCTL_AUDIO_CONFIGURE RAD_IOW(RAD_IOCTL_TYPE_AUDIO, 1u, struct rad_audio_format) 
#define RAD_DEVICE_IOCTL_SERIAL_CONFIGURE RAD_IOW(RAD_IOCTL_TYPE_SERIAL, 1u, struct rad_serial_config) 
#define RAD_DEVICE_IOCTL_FRAMEBUFFER_INFO RAD_IOR(RAD_IOCTL_TYPE_FRAMEBUFFER, 1u, struct rad_framebuffer_info) 
#define RAD_DEVICE_IOCTL_FRAMEBUFFER_FLUSH RAD_IOW(RAD_IOCTL_TYPE_FRAMEBUFFER, 2u, struct rad_framebuffer_rect) 
#define RAD_DEVICE_IOCTL_BLOCK_INFO RAD_IOR(RAD_IOCTL_TYPE_BLOCK, 1u, struct rad_block_info) 
#define RAD_DEVICE_IOCTL_BLOCK_READ RAD_IOWR(RAD_IOCTL_TYPE_BLOCK, 2u, struct rad_block_request) 
#define RAD_DEVICE_IOCTL_BLOCK_WRITE RAD_IOWR(RAD_IOCTL_TYPE_BLOCK, 3u, struct rad_block_request) 
#define RAD_DEVICE_IOCTL_BLOCK_FLUSH RAD_IO(RAD_IOCTL_TYPE_BLOCK, 4u) 
#define RAD_DEVICE_IOCTL_NET_LINK_INFO RAD_IOR(RAD_IOCTL_TYPE_NET, 1u, struct rad_net_link_info) 
#define RAD_DEVICE_IOCTL_NET_SEND RAD_IOW(RAD_IOCTL_TYPE_NET, 2u, struct rad_net_packet) 
#define RAD_DEVICE_IOCTL_NET_POLL RAD_IO(RAD_IOCTL_TYPE_NET, 3u) 
#define RAD_DEVICE_IOCTL_NET_RECV RAD_IOWR(RAD_IOCTL_TYPE_NET, 4u, struct rad_net_packet) 
#define RAD_DEVICE_IOCTL_NET_STACK_INFO RAD_IOR(RAD_IOCTL_TYPE_NET, 5u, struct rad_net_stack_info) 
#define RAD_DEVICE_IOCTL_NET_NTP_QUERY RAD_IOWR(RAD_IOCTL_TYPE_NET, 6u, struct rad_ntp_query) 
#define RAD_DEVICE_IOCTL_NET_CONFIGURE RAD_IOW(RAD_IOCTL_TYPE_NET, 7u, struct rad_net_stack_config) 
#define RAD_DEVICE_IOCTL_COMPOSITOR_CREATE_SURFACE RAD_IOWR(RAD_IOCTL_TYPE_COMPOSITOR, 1u, struct rad_compositor_ipc_surface) 
#define RAD_DEVICE_IOCTL_COMPOSITOR_QUEUE_DAMAGE RAD_IOW(RAD_IOCTL_TYPE_COMPOSITOR, 2u, struct rad_compositor_ipc_damage) 
#define RAD_DEVICE_IOCTL_FRAMEBUFFER_PRESENT RAD_IOW(RAD_IOCTL_TYPE_FRAMEBUFFER, 3u, struct rad_framebuffer_present) 
#define RAD_DEVICE_IOCTL_USB_HOST_INFO RAD_IOR(RAD_IOCTL_TYPE_USB, 1u, struct rad_usb_host_info) 
#define RAD_DEVICE_IOCTL_TTY_GET_WINSIZE RAD_IOR(RAD_IOCTL_TYPE_TTY, 1u, struct rad_tty_window_size) 
#define RAD_DEVICE_IOCTL_TTY_SET_WINSIZE RAD_IOW(RAD_IOCTL_TYPE_TTY, 2u, struct rad_tty_window_size) 
#define RAD_DEVICE_IOCTL_TTY_GET_MODE RAD_IOR(RAD_IOCTL_TYPE_TTY, 3u, uint32_t) 
#define RAD_DEVICE_IOCTL_TTY_SET_MODE RAD_IOW(RAD_IOCTL_TYPE_TTY, 4u, uint32_t) 
#define RAD_DEVICE_IOCTL_TTY_GET_TERMIOS RAD_IOR(RAD_IOCTL_TYPE_TTY, 5u, struct rad_tty_termios) 
#define RAD_DEVICE_IOCTL_TTY_SET_TERMIOS RAD_IOW(RAD_IOCTL_TYPE_TTY, 6u, struct rad_tty_termios) 
#define RAD_DEVICE_IOCTL_TTY_FLUSH RAD_IOW(RAD_IOCTL_TYPE_TTY, 7u, uint32_t) 
 
#define RAD_BOOT_MAX_ARGS 16u 
#define RAD_BOOT_MAX_MEMORY_REGIONS 8u 
#define RAD_BOOT_MAX_STRING 64u 
#define RAD_BOOT_HANDOFF_MAGIC 0x52414448u 
#define RAD_BOOT_HANDOFF_VERSION 1u 
#define RAD_BOOT_HANDOFF_FLAG_SECONDARIES_PARKED 0x00000001u 
#define RAD_BOOT_HANDOFF_FLAG_MMU_DISABLED 0x00000002u 
#define RAD_BOOT_HANDOFF_FLAG_DCACHE_DISABLED 0x00000004u 
#define RAD_BOOT_HANDOFF_FLAG_ICACHE_INVALIDATED 0x00000008u 
#define RAD_BOOT_HANDOFF_FLAG_TLB_INVALIDATED 0x00000010u 
#define RAD_BOOT_HANDOFF_FLAG_INTERRUPTS_MASKED 0x00000020u 
 
#define RAD_OVERLAY_MAGIC 0x4f444152u 
#define RAD_OVERLAY_VERSION 1u 
#define RAD_TREE_MAX_PROPERTY_NAME 64u 
#define RAD_TREE_MAX_PATH 96u 
#define RAD_TREE_MAX_VALUE 96u 
#define RAD_I2C_BUS_NAME_MAX 32u 
#define RAD_SPI_BUS_NAME_MAX 32u 
#define RAD_DRIVER_NAME_MAX 32u 
#define RAD_COMPATIBLE_MAX 64u 
#define RAD_MODULE_NAME_MAX 32u 
#define RAD_MODULE_MAX_INFO 32u 
#define RAD_SERVICE_NAME_MAX 32u 
#define RAD_SERVICE_COMPATIBLE_MAX 64u 
#define RAD_SERVICE_CAPABILITY_MAX 32u 
#define RAD_IRQ_NAME_MAX 32u 
#define RAD_IRQ_DOMAIN_NAME_MAX 32u 
#define RAD_IRQ_MAX_RESOURCES 4u 
#define RAD_FRAMEBUFFER_NAME_MAX 64u 
#define RAD_DISPLAY_CONNECTOR_MAX 32u 
#define RAD_FRAMEBUFFER_MAX_MODES 8u 
#define RAD_SHM_NAME_MAX 64u 
#define RAD_SHM_MAX_PAGES 16u 
#define RAD_MMAP_PROT_READ 1u 
#define RAD_MMAP_PROT_WRITE 2u 
#define RAD_MMAP_SHARED 1u 
#define RAD_MMAP_PRIVATE 2u 
#define RAD_COMPOSITOR_DAMAGE_EXPOSED 1u 
#define RAD_AF_INET 2u 
#define RAD_SOCK_DGRAM 2u 
#define RAD_SOCK_STREAM 1u 
#define RAD_IPPROTO_UDP 17u 
#define RAD_IPPROTO_TCP 6u 
#define RAD_PERF_NAME_MAX 32u 
#define RAD_TIMER_NAME_MAX 32u 
#define RAD_INPUT_QUEUE_NAME_MAX 64u 
#define RAD_WAIT_FOREVER 0xffffffffu 
#define RAD_LOG_CATEGORY_MAX 32u 
#define RAD_LOG_MESSAGE_MAX 192u 
 
#define RAD_BOOT_MEMORY_USABLE 1u 
#define RAD_BOOT_MEMORY_RESERVED 2u 
#define RAD_BOOT_MEMORY_PSRAM 3u 
#define RAD_BOOT_MEMORY_MMIO 4u 
 
typedef enum rad_status {
    RAD_STATUS_OK = 0, 
    RAD_STATUS_ERROR = -1, 
    RAD_STATUS_INVALID_ARGUMENT = -2, 
    RAD_STATUS_NOT_FOUND = -3, 
    RAD_STATUS_NO_MEMORY = -4, 
    RAD_STATUS_TIMEOUT = -5, 
    RAD_STATUS_NOT_SUPPORTED = -6, 
    RAD_STATUS_ALREADY_EXISTS = -7, 
    RAD_STATUS_NOT_INITIALIZED = -8 
} rad_status_t; 
 
typedef enum rad_log_level {
    RAD_LOG_TRACE = 0, 
    RAD_LOG_DEBUG = 1, 
    RAD_LOG_INFO = 2, 
    RAD_LOG_WARNING = 3, 
    RAD_LOG_ERROR = 4, 
    RAD_LOG_CRITICAL = 5 
} rad_log_level_t; 
 
typedef enum rad_kernel_print_level {
    RKERN_DBG = 0, 
    RKERN_STAT = 1, 
    RKERN_WARN = 2, 
    RKERN_ERR = 3 
} rad_kernel_print_level_t; 
 
typedef enum rad_posix_syscall {
    RAD_SYSCALL_READ = 0, 
    RAD_SYSCALL_WRITE = 1, 
    RAD_SYSCALL_OPEN = 2, 
    RAD_SYSCALL_CLOSE = 3, 
    RAD_SYSCALL_IOCTL = 4, 
    RAD_SYSCALL_LSEEK = 5, 
    RAD_SYSCALL_STAT = 6, 
    RAD_SYSCALL_FSTAT = 7, 
    RAD_SYSCALL_GETTIMEOFDAY = 8, 
    RAD_SYSCALL_NANOSLEEP = 9, 
    RAD_SYSCALL_EXIT = 10, 
    RAD_SYSCALL_FORK = 11, 
    RAD_SYSCALL_EXECVE = 12, 
    RAD_SYSCALL_WAITPID = 13, 
    RAD_SYSCALL_GETPID = 14, 
    RAD_SYSCALL_GETPPID = 15, 
    RAD_SYSCALL_DUP = 16, 
    RAD_SYSCALL_DUP2 = 17, 
    RAD_SYSCALL_CHDIR = 18, 
    RAD_SYSCALL_GETCWD = 19, 
    RAD_SYSCALL_BRK = 20, 
    RAD_SYSCALL_PIPE = 21, 
    RAD_SYSCALL_FCNTL = 22, 
    RAD_SYSCALL_ACCESS = 23, 
    RAD_SYSCALL_ISATTY = 24, 
    RAD_SYSCALL_SOCKET = 25, 
    RAD_SYSCALL_BIND = 26, 
    RAD_SYSCALL_CONNECT = 27, 
    RAD_SYSCALL_LISTEN = 28, 
    RAD_SYSCALL_ACCEPT = 29, 
    RAD_SYSCALL_SENDTO = 30, 
    RAD_SYSCALL_RECVFROM = 31, 
    RAD_SYSCALL_SHUTDOWN = 32, 
    RAD_SYSCALL_SETSOCKOPT = 33, 
    RAD_SYSCALL_GETSOCKOPT = 34, 
    RAD_SYSCALL_MMAP = 35, 
    RAD_SYSCALL_MUNMAP = 36, 
    RAD_SYSCALL_SHM_OPEN = 37, 
    RAD_SYSCALL_SHM_UNLINK = 38, 
    RAD_SYSCALL_POLL = 39, 
    RAD_SYSCALL_SETTIMEOFDAY = 40, 
    RAD_SYSCALL_GETDENTS = 1000, 
    RAD_SYSCALL_REMOVE = 1001, 
    RAD_SYSCALL_MKDIR = 1002, 
    RAD_SYSCALL_RMDIR = 1003, 
    RAD_SYSCALL_RENAME = 1004, 
    RAD_SYSCALL_TRUNCATE = 1005, 
    RAD_SYSCALL_LOG_READ = 1006, 
    RAD_SYSCALL_LOG_FLUSH = 1007, 
    RAD_SYSCALL_GETUID = 1008, 
    RAD_SYSCALL_GETEUID = 1009, 
    RAD_SYSCALL_GETGID = 1010, 
    RAD_SYSCALL_GETEGID = 1011, 
    RAD_SYSCALL_SETUID = 1012, 
    RAD_SYSCALL_SETGID = 1013, 
    RAD_SYSCALL_CHMOD = 1014, 
    RAD_SYSCALL_LINK = 1015, 
    RAD_SYSCALL_SYMLINK = 1016, 
    RAD_SYSCALL_READLINK = 1017, 
    RAD_SYSCALL_FSYNC = 1018, 
    RAD_SYSCALL_KILL = 1019, 
    RAD_SYSCALL_FCHDIR = 1020, 
    RAD_SYSCALL_FTRUNCATE = 1021, 
    RAD_SYSCALL_UTIME = 1022, 
    RAD_SYSCALL_GETPGID = 1023, 
    RAD_SYSCALL_SETPGID = 1024, 
    RAD_SYSCALL_GETSID = 1025, 
    RAD_SYSCALL_SETSID = 1026, 
    RAD_SYSCALL_TCGETPGRP = 1027, 
    RAD_SYSCALL_TCSETPGRP = 1028, 
    RAD_SYSCALL_PIPE2 = 1029 
} rad_posix_syscall_t; 
 
typedef enum rad_process_state {
    RAD_PROCESS_RUNNING = 1, 
    RAD_PROCESS_WAITING = 2, 
    RAD_PROCESS_ZOMBIE = 3 
} rad_process_state_t; 
 
#define RAD_WAIT_NOHANG 1u 
#define RAD_FD_CLOEXEC 1u 
#define RAD_FD_NONBLOCK 256u 
#define RAD_FCNTL_GETFD 1u 
#define RAD_FCNTL_SETFD 2u 
#define RAD_FCNTL_GETFL 3u 
#define RAD_FCNTL_SETFL 4u 
 
#define RAD_POLLIN 0x0001 
#define RAD_POLLOUT 0x0004 
#define RAD_POLLERR 0x0008 
#define RAD_POLLHUP 0x0010 
#define RAD_POLLNVAL 0x0020 
 
typedef enum rad_vfs_open_flags {
    RAD_VFS_READ = 1u << 0, 
    RAD_VFS_WRITE = 1u << 1, 
    RAD_VFS_CREATE = 1u << 2, 
    RAD_VFS_TRUNCATE = 1u << 3, 
    RAD_VFS_APPEND = 1u << 4, 
    RAD_VFS_DIRECTORY = 1u << 5 
} rad_vfs_open_flags_t; 
 
typedef enum rad_seek_origin {
    RAD_SEEK_SET = 0, 
    RAD_SEEK_CUR = 1, 
    RAD_SEEK_END = 2 
} rad_seek_origin_t; 
 
typedef uint32_t rad_uid_t; 
typedef uint32_t rad_gid_t; 
 
typedef struct rad_credentials {
    rad_uid_t uid; 
    rad_uid_t euid; 
    rad_gid_t gid; 
    rad_gid_t egid; 
} rad_credentials_t; 
 
typedef enum rad_device_type {
    RAD_DEVICE_GENERIC = 0, 
    RAD_DEVICE_I2C = 1, 
    RAD_DEVICE_SPI = 2, 
    RAD_DEVICE_AUDIO = 3, 
    RAD_DEVICE_SERIAL = 4, 
    RAD_DEVICE_FRAMEBUFFER = 5, 
    RAD_DEVICE_TTY = 6, 
    RAD_DEVICE_PTY = 7, 
    RAD_DEVICE_INPUT = 8, 
    RAD_DEVICE_BLOCK = 9, 
    RAD_DEVICE_NETWORK = 10, 
    RAD_DEVICE_COMPOSITOR = 11, 
    RAD_DEVICE_USB = 12 
} rad_device_type_t; 
 
typedef enum rad_usb_controller_type {
    RAD_USB_CONTROLLER_UNKNOWN = 0, 
    RAD_USB_CONTROLLER_DWC_OTG = 1 
} rad_usb_controller_type_t; 
 
typedef enum rad_usb_device_class {
    RAD_USB_CLASS_UNKNOWN = 0, 
    RAD_USB_CLASS_HID_KEYBOARD = 1, 
    RAD_USB_CLASS_HID_MOUSE = 2, 
    RAD_USB_CLASS_MASS_STORAGE = 3 
} rad_usb_device_class_t; 
 
typedef enum rad_input_event_type {
    RAD_INPUT_EVENT_NONE = 0, 
    RAD_INPUT_EVENT_KEY = 1, 
    RAD_INPUT_EVENT_POINTER_MOTION = 2, 
    RAD_INPUT_EVENT_POINTER_BUTTON = 3, 
    RAD_INPUT_EVENT_POINTER_SCROLL = 4 
} rad_input_event_type_t; 
 
typedef enum rad_input_key {
    RAD_INPUT_KEY_UNKNOWN = 0, 
    RAD_INPUT_KEY_ESCAPE = 1, 
    RAD_INPUT_KEY_ENTER = 2, 
    RAD_INPUT_KEY_BACKSPACE = 3, 
    RAD_INPUT_KEY_TAB = 4, 
    RAD_INPUT_KEY_UP = 5, 
    RAD_INPUT_KEY_DOWN = 6, 
    RAD_INPUT_KEY_LEFT = 7, 
    RAD_INPUT_KEY_RIGHT = 8, 
    RAD_INPUT_KEY_HOME = 9, 
    RAD_INPUT_KEY_END = 10, 
    RAD_INPUT_KEY_PAGE_UP = 11, 
    RAD_INPUT_KEY_PAGE_DOWN = 12, 
    RAD_INPUT_KEY_INSERT = 13, 
    RAD_INPUT_KEY_DELETE = 14, 
    RAD_INPUT_KEY_LEFT_SHIFT = 15, 
    RAD_INPUT_KEY_RIGHT_SHIFT = 16, 
    RAD_INPUT_KEY_LEFT_CTRL = 17, 
    RAD_INPUT_KEY_RIGHT_CTRL = 18, 
    RAD_INPUT_KEY_LEFT_ALT = 19, 
    RAD_INPUT_KEY_RIGHT_ALT = 20, 
    RAD_INPUT_KEY_CAPS_LOCK = 21 
} rad_input_key_t; 
 
typedef enum rad_input_modifier_flags {
    RAD_INPUT_MOD_SHIFT = 1u << 0, 
    RAD_INPUT_MOD_CTRL = 1u << 1, 
    RAD_INPUT_MOD_ALT = 1u << 2, 
    RAD_INPUT_MOD_META = 1u << 3, 
    RAD_INPUT_MOD_CAPS_LOCK = 1u << 4 
} rad_input_modifier_flags_t; 
 
typedef enum rad_input_pointer_button_flags {
    RAD_INPUT_POINTER_BUTTON_LEFT = 1u << 0, 
    RAD_INPUT_POINTER_BUTTON_RIGHT = 1u << 1, 
    RAD_INPUT_POINTER_BUTTON_MIDDLE = 1u << 2 
} rad_input_pointer_button_flags_t; 
 
typedef enum rad_pixel_format {
    RAD_PIXEL_FORMAT_RGB565 = 1, 
    RAD_PIXEL_FORMAT_XRGB8888 = 2 
} rad_pixel_format_t; 
 
typedef enum rad_sd_mode {
    RAD_SD_MODE_AUTO = 0, 
    RAD_SD_MODE_SPI = 1, 
    RAD_SD_MODE_PIO_SDIO = 2 
} rad_sd_mode_t; 
 
typedef enum rad_spi_transfer_mode {
    RAD_SPI_TRANSFER_MODE_AUTO = 0, 
    RAD_SPI_TRANSFER_MODE_PIO = 1, 
    RAD_SPI_TRANSFER_MODE_DMA = 2 
} rad_spi_transfer_mode_t; 
 
typedef enum rad_dma_transfer_type {
    RAD_DMA_MEMORY_TO_MEMORY = 0, 
    RAD_DMA_MEMORY_TO_DEVICE = 1, 
    RAD_DMA_DEVICE_TO_MEMORY = 2 
} rad_dma_transfer_type_t; 
 
typedef enum rad_dma_request_id {
    RAD_DMA_DREQ_NONE = 0, 
    RAD_DMA_DREQ_SPI0_TX = 1, 
    RAD_DMA_DREQ_SPI0_RX = 2, 
    RAD_DMA_DREQ_SPI1_TX = 3, 
    RAD_DMA_DREQ_SPI1_RX = 4, 
    RAD_DMA_DREQ_RP2350_HSTX_TX = 5 
} rad_dma_request_id_t; 
 
typedef enum rad_display_output_type {
    RAD_DISPLAY_OUTPUT_MEMORY = 0, 
    RAD_DISPLAY_OUTPUT_CIRCLE = 1, 
    RAD_DISPLAY_OUTPUT_GRUB = 2, 
    RAD_DISPLAY_OUTPUT_RP2350_HSTX = 3, 
    RAD_DISPLAY_OUTPUT_SPI_PANEL = 4, 
    RAD_DISPLAY_OUTPUT_BCM283X_MAILBOX = 5 
} rad_display_output_type_t; 
 
typedef enum rad_tty_mode_flags {
    RAD_TTY_MODE_CANONICAL = 1u << 0, 
    RAD_TTY_MODE_ECHO = 1u << 1, 
    RAD_TTY_MODE_CRLF = 1u << 2 
} rad_tty_mode_flags_t; 
 
typedef enum rad_irq_trigger {
    RAD_IRQ_TRIGGER_NONE = 0, 
    RAD_IRQ_TRIGGER_EDGE_RISING = 1u << 0, 
    RAD_IRQ_TRIGGER_EDGE_FALLING = 1u << 1, 
    RAD_IRQ_TRIGGER_LEVEL_HIGH = 1u << 2, 
    RAD_IRQ_TRIGGER_LEVEL_LOW = 1u << 3 
} rad_irq_trigger_t; 
 
#define RAD_TASK_CORE_ANY (-1) 
#define RAD_TASK_CORE_SERVICE 0 
 
typedef enum rad_task_state {
    RAD_TASK_NEW = 0, 
    RAD_TASK_READY = 1, 
    RAD_TASK_RUNNING = 2, 
    RAD_TASK_SLEEPING = 3, 
    RAD_TASK_BLOCKED = 4, 
    RAD_TASK_FINISHED = 5, 
    RAD_TASK_DETACHED = 6 
} rad_task_state_t; 
 
typedef struct rad_kernel_config {
    const char *backend_name; 
    const void *boot_info; 
} rad_kernel_config_t; 
 
typedef struct rad_boot_arg {
    char key[RAD_BOOT_MAX_STRING]; 
    char value[RAD_BOOT_MAX_STRING]; 
} rad_boot_arg_t; 
 
typedef struct rad_boot_memory_region {
    uint64_t base; 
    uint64_t size; 
    uint32_t type; 
    uint32_t flags; 
    char name[RAD_BOOT_MAX_STRING]; 
} rad_boot_memory_region_t; 
 
typedef struct rad_boot_info {
    uint32_t size; 
    uint32_t version; 
    char backend[RAD_BOOT_MAX_STRING]; 
    char board[RAD_BOOT_MAX_STRING]; 
    char console_device[RAD_BOOT_MAX_STRING]; 
    char sd_mode[RAD_BOOT_MAX_STRING]; 
    uintptr_t fdt_pointer; 
    uintptr_t initrd_pointer; 
    uint32_t boot_flags; 
    uint32_t memory_region_count; 
    rad_boot_memory_region_t memory_regions[RAD_BOOT_MAX_MEMORY_REGIONS]; 
    uint32_t arg_count; 
    rad_boot_arg_t args[RAD_BOOT_MAX_ARGS]; 
} rad_boot_info_t; 
 
typedef struct rad_boot_handoff {
    uint32_t magic; 
    uint32_t version; 
    uint32_t size; 
    uint32_t flags; 
    rad_boot_info_t boot; 
    uintptr_t kernel_image_base; 
    uintptr_t kernel_image_size; 
    uintptr_t kernel_entry; 
    uintptr_t stack_base; 
    uintptr_t stack_size; 
    uintptr_t fdt_pointer; 
    uintptr_t initrd_pointer; 
    uintptr_t peripheral_base; 
    uintptr_t mailbox_base; 
    uintptr_t local_interrupt_base; 
    uintptr_t arm_memory_base; 
    uintptr_t arm_memory_size; 
    uint32_t board_id; 
    uint32_t entry_el; 
    uint32_t core_count; 
    uint32_t parked_core_mask; 
    char payload_name[RAD_BOOT_MAX_STRING]; 
} rad_boot_handoff_t; 
 
typedef struct rad_memory_stats {
    uint64_t allocations; 
    uint64_t frees; 
    uint64_t bytes_allocated; 
    uint64_t bytes_freed; 
    uint64_t bytes_live; 
    uint64_t peak_bytes_live; 
} rad_memory_stats_t; 
 
typedef struct rad_perf_counter_info {
    char name[RAD_PERF_NAME_MAX]; 
    uint64_t value; 
} rad_perf_counter_info_t; 
 
typedef struct rad_timer_source_config {
    uint32_t size; 
    const char *name; 
    uint32_t frequency_hz; 
    int supports_oneshot; 
} rad_timer_source_config_t; 
 
typedef struct rad_timer_source_ops {
    void *context; 
    rad_status_t (*start_periodic)(void *context, uint32_t frequency_hz);
    rad_status_t (*schedule_oneshot)(void *context, uint64_t delay_micros);
    rad_status_t (*cancel_oneshot)(void *context);
} rad_timer_source_ops_t; 
 
typedef struct rad_timer_source_info {
    char name[RAD_TIMER_NAME_MAX]; 
    uint32_t frequency_hz; 
    int supports_oneshot; 
    int active; 
    uint64_t ticks; 
} rad_timer_source_info_t; 
 
typedef struct rad_task_info {
    uint64_t id; 
    char name[64]; 
    int running; 
    int finished; 
    rad_task_state_t state; 
    int target_core; 
    int current_core; 
    int priority; 
    size_t stack_size; 
    int detached; 
} rad_task_info_t; 
 
typedef struct rad_task_config {
    uint32_t size; 
    const char *name; 
    size_t stack_size; 
    int target_core; 
    int priority; 
    void *user_context; 
} rad_task_config_t; 
 
typedef struct rad_core_info {
    uint32_t detected_cores; 
    uint32_t worker_cores; 
    uint32_t service_core; 
    uint32_t worker_running_mask; 
} rad_core_info_t; 
 
typedef enum rad_scheduler_mode {
    RAD_SCHEDULER_COOPERATIVE = 0, 
    RAD_SCHEDULER_PREEMPTIVE = 1 
} rad_scheduler_mode_t; 
 
typedef struct rad_scheduler_info {
    uint32_t detected_cores; 
    uint32_t worker_running_mask; 
    uint32_t running_threads; 
    uint32_t ready_threads; 
    uint32_t blocked_threads; 
    uint32_t sleeping_threads; 
    uint32_t exited_threads; 
    uint32_t process_count; 
    int preemption_supported; 
    rad_scheduler_mode_t mode; 
    char arch[32]; 
    uint32_t online_core_mask; 
    uint32_t current_core; 
    int preemption_enabled; 
    uint64_t context_switches; 
    uint64_t scheduler_ticks; 
} rad_scheduler_info_t; 
 
typedef enum rad_tree_property_type {
    RAD_TREE_PROP_BOOL = 1, 
    RAD_TREE_PROP_U32 = 2, 
    RAD_TREE_PROP_STRING = 3, 
    RAD_TREE_PROP_U32_ARRAY = 4, 
    RAD_TREE_PROP_STRING_ARRAY = 5 
} rad_tree_property_type_t; 
 
typedef struct rad_tree_node_handle *rad_tree_node_t;
 
typedef struct rad_tree_node_info {
    char path[RAD_TREE_MAX_PATH]; 
    char name[RAD_TREE_MAX_PROPERTY_NAME]; 
    char parent[RAD_TREE_MAX_PATH]; 
    char module[RAD_TREE_MAX_PROPERTY_NAME]; 
    int bound; 
} rad_tree_node_info_t; 
 
typedef struct rad_overlay_info {
    char name[RAD_TREE_MAX_PROPERTY_NAME]; 
    char source[RAD_TREE_MAX_PATH]; 
    uint32_t node_count; 
    uint32_t property_count; 
} rad_overlay_info_t; 
 
typedef struct rad_vfs_stat {
    uint64_t size; 
    int is_directory; 
    uint32_t mode; 
    rad_uid_t uid; 
    rad_gid_t gid; 
    uint64_t mtime_millis; 
} rad_vfs_stat_t; 
 
typedef struct rad_block_info {
    uint32_t size; 
    uint32_t sector_size; 
    uint64_t sector_count; 
    uint32_t flags; 
    uint32_t reserved; 
} rad_block_info_t; 
 
typedef struct rad_block_request {
    uint32_t size; 
    uint64_t sector; 
    uint32_t sector_count; 
    void *buffer; 
} rad_block_request_t; 
 
typedef struct rad_usb_host_info {
    uint32_t size; 
    rad_usb_controller_type_t controller; 
    uint32_t device_count; 
    uint32_t hid_keyboard_count; 
    uint32_t hid_mouse_count; 
    uint32_t flags; 
} rad_usb_host_info_t; 
 
typedef struct rad_mac_address {
    uint8_t bytes[6]; 
} rad_mac_address_t; 
 
typedef struct rad_ipv4_address {
    uint8_t bytes[4]; 
} rad_ipv4_address_t; 
 
typedef struct rad_net_packet {
    uint32_t size; 
    void *data; 
    size_t length; 
} rad_net_packet_t; 
 
typedef struct rad_net_link_info {
    uint32_t size; 
    rad_mac_address_t mac; 
    uint32_t mtu; 
    int link_up; 
    uint64_t tx_packets; 
    uint64_t rx_packets; 
} rad_net_link_info_t; 
 
typedef struct rad_net_stack_info {
    uint32_t size; 
    rad_ipv4_address_t ipv4; 
    rad_ipv4_address_t netmask; 
    rad_ipv4_address_t gateway; 
    rad_ipv4_address_t ntp_server; 
    uint16_t ntp_port; 
    uint16_t arp_entries; 
    uint64_t ethernet_rx; 
    uint64_t ethernet_tx; 
    uint64_t arp_rx; 
    uint64_t arp_tx; 
    uint64_t ipv4_rx; 
    uint64_t ipv4_tx; 
    uint64_t udp_rx; 
    uint64_t udp_tx; 
    uint64_t icmp_rx; 
    uint64_t icmp_tx; 
} rad_net_stack_info_t; 
 
typedef struct rad_net_stack_config {
    uint32_t size; 
    rad_ipv4_address_t ipv4; 
    rad_ipv4_address_t netmask; 
    rad_ipv4_address_t gateway; 
    rad_ipv4_address_t ntp_server; 
    uint16_t ntp_port; 
    uint16_t flags; 
} rad_net_stack_config_t; 
 
typedef struct rad_ntp_status {
    uint32_t size; 
    rad_ipv4_address_t server; 
    uint16_t port; 
    uint16_t valid; 
    uint64_t last_unix_seconds; 
    int64_t offset_millis; 
    uint64_t queries; 
    uint64_t responses; 
} rad_ntp_status_t; 
 
typedef struct rad_ntp_query {
    uint32_t size; 
    rad_ipv4_address_t server; 
    uint16_t port; 
    uint16_t timeout_ms; 
    rad_ntp_status_t status; 
} rad_ntp_query_t; 
 
typedef struct rad_sockaddr_in {
    uint16_t family; 
    uint16_t port; 
    rad_ipv4_address_t address; 
    uint8_t zero[8]; 
} rad_sockaddr_in_t; 
 
typedef enum rad_tcp_state {
    RAD_TCP_CLOSED = 0, 
    RAD_TCP_LISTEN = 1, 
    RAD_TCP_SYN_SENT = 2, 
    RAD_TCP_SYN_RECEIVED = 3, 
    RAD_TCP_ESTABLISHED = 4, 
    RAD_TCP_FIN_WAIT = 5, 
    RAD_TCP_CLOSE_WAIT = 6, 
    RAD_TCP_LAST_ACK = 7, 
    RAD_TCP_TIME_WAIT = 8 
} rad_tcp_state_t; 
 
typedef struct rad_socket_info {
    uint32_t size; 
    int domain; 
    int type; 
    int protocol; 
    rad_tcp_state_t tcp_state; 
    uint16_t local_port; 
    uint16_t remote_port; 
    rad_ipv4_address_t local_address; 
    rad_ipv4_address_t remote_address; 
} rad_socket_info_t; 
 
typedef struct rad_posix_timeval {
    int64_t tv_sec; 
    int64_t tv_usec; 
} rad_posix_timeval_t; 
 
typedef struct rad_pollfd {
    int32_t fd; 
    int16_t events; 
    int16_t revents; 
} rad_pollfd_t; 
 
typedef struct rad_process_info {
    int32_t pid; 
    int32_t parent_pid; 
    int32_t process_group_id; 
    int32_t session_id; 
    int32_t exited; 
    int32_t exit_code; 
    rad_process_state_t state; 
    rad_credentials_t credentials; 
    char path[128]; 
} rad_process_info_t; 
 
typedef struct rad_process_arch_ops {
    uint32_t size; 
    void *context; 
    int32_t (*fork_from_frame)(void *context, void *trap_frame);
    void (*process_reaped)(void *context, int32_t pid, int32_t status);
} rad_process_arch_ops_t; 
 
typedef struct rad_vfs_dirent {
    char name[96]; 
    rad_vfs_stat_t stat; 
} rad_vfs_dirent_t; 
 
typedef struct rad_dirent_user {
    uint8_t type; 
    char name[256]; 
} rad_dirent_user_t; 
 
typedef int (*rad_vfs_list_callback_t)(const char *name, const rad_vfs_stat_t *stat, void *context);
 
typedef struct rad_vfs_backend_ops {
    void *context; 
    rad_status_t (*open)(void *context, const char *path, uint32_t flags, void **file);
    rad_status_t (*read)(void *file, void *buffer, size_t size, size_t *bytes_read);
    rad_status_t (*write)(void *file, const void *buffer, size_t size, size_t *bytes_written);
    rad_status_t (*seek)(void *file, int64_t offset, rad_seek_origin_t origin);
    uint64_t (*tell)(void *file);
    void (*close)(void *file);
    rad_status_t (*stat)(void *context, const char *path, rad_vfs_stat_t *stat);
    rad_status_t (*list)(void *context, const char *path, rad_vfs_list_callback_t callback, void *callback_context);
    rad_status_t (*mkdir)(void *context, const char *path);
    rad_status_t (*remove)(void *context, const char *path);
    rad_status_t (*rename)(void *context, const char *old_path, const char *new_path);
    rad_status_t (*rmdir)(void *context, const char *path);
    rad_status_t (*fsync)(void *file);
    rad_status_t (*truncate)(void *context, const char *path, uint64_t size);
    rad_status_t (*readlink)(void *context, const char *path, char *buffer, size_t size);
    rad_status_t (*symlink)(void *context, const char *target, const char *link_path);
    rad_status_t (*link)(void *context, const char *old_path, const char *new_path);
    rad_status_t (*chmod)(void *context, const char *path, uint32_t mode);
} rad_vfs_backend_ops_t; 
 
typedef enum rad_program_state {
    RAD_PROGRAM_LOADED = 0, 
    RAD_PROGRAM_RUNNING = 1, 
    RAD_PROGRAM_FINISHED = 2, 
    RAD_PROGRAM_FAILED = 3 
} rad_program_state_t; 
 
typedef struct rad_program_info {
    uint64_t id; 
    char path[128]; 
    char name[64]; 
    rad_program_state_t state; 
    uint64_t task_id; 
    int exit_code; 
} rad_program_info_t; 
 
typedef struct rad_device_ops {
    void *context; 
    rad_status_t (*read)(void *context, void *buffer, size_t size, size_t *bytes_read);
    rad_status_t (*write)(void *context, const void *buffer, size_t size, size_t *bytes_written);
    rad_status_t (*ioctl)(void *context, uint32_t request, void *argument);
} rad_device_ops_t; 
 
typedef struct rad_input_event {
    uint32_t size; 
    rad_input_event_type_t type; 
    uint32_t code; 
    uint32_t codepoint; 
    uint32_t modifiers; 
    uint8_t pressed; 
    uint8_t repeat; 
    uint16_t reserved; 
    int32_t x; 
    int32_t y; 
    int32_t dx; 
    int32_t dy; 
    int32_t scroll_x; 
    int32_t scroll_y; 
    uint32_t buttons; 
} rad_input_event_t; 
 
typedef struct rad_framebuffer_rect {
    uint32_t x; 
    uint32_t y; 
    uint32_t width; 
    uint32_t height; 
} rad_framebuffer_rect_t; 
 
typedef struct rad_framebuffer_info {
    uint32_t size; 
    uint32_t width; 
    uint32_t height; 
    uint32_t stride_bytes; 
    rad_pixel_format_t pixel_format; 
    void *pixels; 
} rad_framebuffer_info_t; 
 
typedef struct rad_framebuffer_present {
    uint32_t size; 
    void *pixels; 
    uint32_t stride_bytes; 
    rad_framebuffer_rect_t rect; 
} rad_framebuffer_present_t; 
 
typedef struct rad_display_mode {
    uint32_t width; 
    uint32_t height; 
    uint32_t refresh_hz; 
    uint32_t stride_bytes; 
    rad_pixel_format_t pixel_format; 
} rad_display_mode_t; 
 
typedef struct rad_framebuffer_ops {
    void *context; 
    rad_status_t (*flush)(void *context, const rad_framebuffer_rect_t *rect);
    rad_status_t (*present)(void *context, const rad_framebuffer_present_t *present);
    rad_status_t (*set_mode)(void *context, const rad_display_mode_t *mode);
    rad_status_t (*blank)(void *context, int blanked);
    uint64_t (*get_vsync_counter)(void *context);
} rad_framebuffer_ops_t; 
 
typedef struct rad_framebuffer_handle *rad_framebuffer_t;
 
typedef struct rad_framebuffer_config {
    uint32_t size; 
    const char *name; 
    rad_framebuffer_info_t info; 
    rad_display_output_type_t output_type; 
    const char *connector; 
    uint32_t mode_count; 
    uint32_t preferred_mode; 
    rad_display_mode_t modes[RAD_FRAMEBUFFER_MAX_MODES]; 
    int primary; 
} rad_framebuffer_config_t; 
 
typedef struct rad_framebuffer_display_info {
    uint32_t size; 
    char name[RAD_FRAMEBUFFER_NAME_MAX]; 
    rad_framebuffer_info_t framebuffer; 
    rad_display_output_type_t output_type; 
    char connector[RAD_DISPLAY_CONNECTOR_MAX]; 
    uint32_t mode_count; 
    uint32_t preferred_mode; 
    uint32_t current_mode; 
    rad_display_mode_t modes[RAD_FRAMEBUFFER_MAX_MODES]; 
    int primary; 
} rad_framebuffer_display_info_t; 
 
typedef struct rad_shm_info {
    uint32_t size; 
    char name[RAD_SHM_NAME_MAX]; 
    size_t byte_size; 
    size_t page_count; 
} rad_shm_info_t; 
 
typedef struct rad_compositor_ipc_surface {
    uint32_t size; 
    int32_t shm_fd; 
    uint32_t width; 
    uint32_t height; 
    uint32_t stride_pixels; 
    int32_t x; 
    int32_t y; 
    int32_t z; 
    uint32_t flags; 
    uint32_t surface_id; 
} rad_compositor_ipc_surface_t; 
 
typedef struct rad_compositor_ipc_damage {
    uint32_t size; 
    uint32_t surface_id; 
    int32_t x; 
    int32_t y; 
    int32_t width; 
    int32_t height; 
    uint32_t flags; 
} rad_compositor_ipc_damage_t; 
 
typedef struct rad_i2c_transfer {
    uint8_t address; 
    const uint8_t *write_data; 
    size_t write_size; 
    uint8_t *read_data; 
    size_t read_size; 
} rad_i2c_transfer_t; 
 
typedef struct rad_i2c_bus_handle *rad_i2c_bus_t;
typedef struct rad_i2c_device rad_i2c_device_t;
 
typedef struct rad_i2c_controller_ops {
    void *context; 
    rad_status_t (*transfer)(void *context, const rad_i2c_transfer_t *transfer);
} rad_i2c_controller_ops_t; 
 
typedef struct rad_i2c_controller_config {
    uint32_t size; 
    uint32_t bus_id; 
    const char *name; 
    const char *tree_path; 
    uint32_t clock_hz; 
    uint8_t sda_gpio; 
    uint8_t scl_gpio; 
} rad_i2c_controller_config_t; 
 
typedef struct rad_i2c_driver {
    uint32_t size; 
    const char *name; 
    const char *compatible; 
    void *context; 
    rad_status_t (*probe)(void *context, rad_i2c_device_t *device);
    void (*remove)(void *context, rad_i2c_device_t *device);
} rad_i2c_driver_t; 
 
typedef struct rad_spi_transfer {
    const uint8_t *tx_data; 
    uint8_t *rx_data; 
    size_t size; 
    uint32_t speed_hz; 
    uint8_t mode; 
    uint8_t bits_per_word; 
    uint8_t cs; 
    uint8_t transfer_mode; 
} rad_spi_transfer_t; 
 
typedef struct rad_spi_bus_handle *rad_spi_bus_t;
typedef struct rad_spi_device rad_spi_device_t;
 
typedef struct rad_dma_channel_handle *rad_dma_channel_t;
 
typedef struct rad_dma_transfer {
    uint32_t size; 
    rad_dma_transfer_type_t type; 
    rad_dma_request_id_t request_id; 
    const void *source; 
    void *destination; 
    uintptr_t peripheral_address; 
    uint32_t flags; 
} rad_dma_transfer_t; 
 
typedef struct rad_dma_backend_ops {
    void *context; 
    rad_status_t (*request)(void *context, rad_dma_request_id_t request_id, void **backend_channel);
    void (*release)(void *context, void *backend_channel);
    rad_status_t (*submit)(void *context, void *backend_channel, const rad_dma_transfer_t *transfer);
    rad_status_t (*wait)(void *context, void *backend_channel, uint32_t timeout_ms);
    rad_status_t (*cancel)(void *context, void *backend_channel);
} rad_dma_backend_ops_t; 
 
typedef struct rad_dma_controller_config {
    uint32_t size; 
    const char *name; 
    uint32_t channel_count; 
} rad_dma_controller_config_t; 
 
typedef struct rad_spi_controller_ops {
    void *context; 
    rad_status_t (*transfer)(void *context, const rad_spi_device_t *device, const rad_spi_transfer_t *transfer);
    rad_status_t (*transfer_dma)(void *context, const rad_spi_device_t *device, const rad_spi_transfer_t *transfer, rad_dma_channel_t tx_channel, rad_dma_channel_t rx_channel);
} rad_spi_controller_ops_t; 
 
typedef struct rad_spi_controller_config {
    uint32_t size; 
    uint32_t bus_id; 
    const char *name; 
    const char *tree_path; 
    uint32_t clock_hz; 
    uint8_t sck_gpio; 
    uint8_t tx_gpio; 
    uint8_t rx_gpio; 
    uint8_t cs_gpio; 
} rad_spi_controller_config_t; 
 
typedef struct rad_spi_driver {
    uint32_t size; 
    const char *name; 
    const char *compatible; 
    void *context; 
    rad_status_t (*probe)(void *context, rad_spi_device_t *device);
    void (*remove)(void *context, rad_spi_device_t *device);
} rad_spi_driver_t; 
 
typedef struct rad_module_descriptor {
    uint32_t size; 
    const char *name; 
    const char *bus; 
    const char *compatible; 
    rad_status_t (*init)(void *context);
    void (*exit)(void *context);
    void *context; 
} rad_module_descriptor_t; 
 
typedef enum rad_module_state {
    RAD_MODULE_REGISTERED = 1, 
    RAD_MODULE_INITIALIZED = 2, 
    RAD_MODULE_FAILED = 3, 
    RAD_MODULE_EXITED = 4 
} rad_module_state_t; 
 
typedef enum rad_service_state {
    RAD_SERVICE_REGISTERED = 1, 
    RAD_SERVICE_CONFIGURED = 2, 
    RAD_SERVICE_RUNNING = 3, 
    RAD_SERVICE_FAILED = 4, 
    RAD_SERVICE_STOPPED = 5 
} rad_service_state_t; 
 
typedef struct rad_module_info {
    char name[RAD_MODULE_NAME_MAX]; 
    char bus[RAD_DRIVER_NAME_MAX]; 
    char compatible[RAD_COMPATIBLE_MAX]; 
    rad_module_state_t state; 
    int32_t last_status; 
} rad_module_info_t; 
 
typedef struct rad_service_config {
    uint32_t size; 
    const char *tree_path; 
    const char *backend; 
    const char *display; 
    const char *keyboard; 
    const char *pointer; 
    const char *terminal; 
    int autostart; 
    int order; 
} rad_service_config_t; 
 
typedef struct rad_service_descriptor {
    uint32_t size; 
    const char *name; 
    const char *compatible; 
    const char *capability; 
    int default_order; 
    rad_status_t (*start)(void *context, const rad_service_config_t *config);
    void (*stop)(void *context);
    rad_status_t (*poll)(void *context);
    void *context; 
} rad_service_descriptor_t; 
 
typedef struct rad_service_info {
    char name[RAD_SERVICE_NAME_MAX]; 
    char compatible[RAD_SERVICE_COMPATIBLE_MAX]; 
    char capability[RAD_SERVICE_CAPABILITY_MAX]; 
    char tree_path[RAD_TREE_MAX_PATH]; 
    char backend[RAD_TREE_MAX_VALUE]; 
    char display[RAD_TREE_MAX_VALUE]; 
    char keyboard[RAD_TREE_MAX_VALUE]; 
    char pointer[RAD_TREE_MAX_VALUE]; 
    char terminal[RAD_TREE_MAX_VALUE]; 
    rad_service_state_t state; 
    int autostart; 
    int order; 
    int32_t last_status; 
} rad_service_info_t; 
 
typedef struct rad_driver_info {
    char name[RAD_DRIVER_NAME_MAX]; 
    char bus[RAD_DRIVER_NAME_MAX]; 
    char compatible[RAD_COMPATIBLE_MAX]; 
    char role[RAD_DRIVER_NAME_MAX]; 
} rad_driver_info_t; 
 
typedef struct rad_irq_domain_handle *rad_irq_domain_t;
 
typedef struct rad_irq_domain_config {
    uint32_t size; 
    const char *name; 
    const char *tree_path; 
    uint32_t interrupt_base; 
    uint32_t line_count; 
    uint32_t interrupt_cells; 
} rad_irq_domain_config_t; 
 
typedef struct rad_irq_resource {
    uint32_t irq; 
    uint32_t line; 
    uint32_t flags; 
    rad_irq_trigger_t trigger; 
    char domain[RAD_IRQ_DOMAIN_NAME_MAX]; 
    char controller_path[RAD_TREE_MAX_PATH]; 
} rad_irq_resource_t; 
 
typedef struct rad_i2c_device_info {
    uint32_t bus_id; 
    uint8_t address; 
    uint32_t irq_count; 
    rad_irq_resource_t irqs[RAD_IRQ_MAX_RESOURCES]; 
    char path[RAD_TREE_MAX_PATH]; 
    char compatible[RAD_COMPATIBLE_MAX]; 
    char driver[RAD_DRIVER_NAME_MAX]; 
    int bound; 
} rad_i2c_device_info_t; 
 
typedef struct rad_spi_device_info {
    uint32_t bus_id; 
    uint8_t cs; 
    uint32_t clock_hz; 
    uint8_t mode; 
    uint8_t bits_per_word; 
    uint8_t transfer_mode; 
    uint32_t irq_count; 
    rad_irq_resource_t irqs[RAD_IRQ_MAX_RESOURCES]; 
    char path[RAD_TREE_MAX_PATH]; 
    char compatible[RAD_COMPATIBLE_MAX]; 
    char driver[RAD_DRIVER_NAME_MAX]; 
    int bound; 
} rad_spi_device_info_t; 
 
typedef struct rad_dma_channel_info {
    char controller[RAD_DRIVER_NAME_MAX]; 
    uint32_t index; 
    uint32_t request_id; 
    int allocated; 
    int active; 
} rad_dma_channel_info_t; 
 
typedef struct rad_irq_info {
    uint32_t irq; 
    char name[RAD_IRQ_NAME_MAX]; 
    int registered; 
    int enabled; 
    uint64_t count; 
    uint64_t unhandled_count; 
} rad_irq_info_t; 
 
typedef struct rad_audio_format {
    uint32_t sample_rate; 
    uint16_t channels; 
    uint16_t bits_per_sample; 
} rad_audio_format_t; 
 
typedef struct rad_serial_config {
    uint32_t baud_rate; 
    uint8_t data_bits; 
    uint8_t stop_bits; 
    uint8_t parity; 
    uint8_t flow_control; 
} rad_serial_config_t; 
 
typedef struct rad_sd_config {
    rad_sd_mode_t mode; 
    const char *device_name; 
    const char *mount_point; 
    uint8_t spi_instance; 
    uint8_t sck_gpio; 
    uint8_t tx_gpio; 
    uint8_t rx_gpio; 
    uint8_t cs_gpio; 
    uint8_t pio_instance; 
    uint8_t sdio_clk_gpio; 
    uint8_t sdio_cmd_gpio; 
    uint8_t sdio_dat0_gpio; 
    uint8_t card_detect_gpio; 
} rad_sd_config_t; 
 
typedef void (*rad_task_entry_t)(void *context);
typedef void (*rad_terminal_write_t)(const char *text, void *context);
typedef rad_status_t (*rad_terminal_handler_t)(int argc, const char **argv, rad_terminal_write_t write, void *write_context, void *command_context);
typedef void (*rad_tty_output_t)(const void *data, size_t size, void *context);
typedef void (*rad_irq_handler_t)(uint32_t irq, void *context);
typedef void (*rad_work_handler_t)(void *context);
 
typedef struct rad_task_handle *rad_task_t;
typedef struct rad_mutex_handle *rad_mutex_t;
typedef struct rad_event_handle *rad_event_t;
typedef struct rad_wait_queue_handle *rad_wait_queue_t;
typedef struct rad_input_queue_handle *rad_input_queue_t;
typedef struct rad_file_handle *rad_file_t;
typedef struct rad_dir_handle *rad_dir_t;
typedef struct rad_device_handle *rad_device_t;
typedef struct rad_program_handle *rad_program_t;
typedef struct rad_tty_handle *rad_tty_t;
typedef struct rad_pty_handle *rad_pty_t;
 
typedef struct rad_tty_window_size {
    uint16_t rows; 
    uint16_t columns; 
    uint16_t x_pixels; 
    uint16_t y_pixels; 
} rad_tty_window_size_t; 
 
#define RAD_TTY_NCCS 32u
#define RAD_TTY_FLUSH_INPUT 1u
#define RAD_TTY_FLUSH_OUTPUT 2u
 
typedef struct rad_tty_termios {
    uint32_t input_flags; 
    uint32_t output_flags; 
    uint32_t control_flags; 
    uint32_t local_flags; 
    uint32_t input_speed; 
    uint32_t output_speed; 
    uint8_t control_chars[RAD_TTY_NCCS]; 
} rad_tty_termios_t; 
 
typedef struct rad_log_entry {
    uint64_t sequence; 
    uint64_t time_millis; 
    rad_log_level_t level; 
    char category[RAD_LOG_CATEGORY_MAX]; 
    char message[RAD_LOG_MESSAGE_MAX]; 
} rad_log_entry_t; 
 
rad_status_t rad_kernel_init(const rad_kernel_config_t *config); 
void rad_kernel_shutdown(void); 
int rad_kernel_is_initialized(void); 
const char *rad_kernel_backend_name(void); 
const char *rad_kernel_version_string(void); 
rad_status_t rad_kernel_poll(void); 
rad_status_t rad_kernel_run(void); 
void rad_kernel_request_shutdown(void); 
int rad_kernel_is_shutdown_requested(void); 
int rad_vprintk(const char *format, va_list args); 
int rad_printk(const char *format, ...); 
int rad_vkprintk(rad_kernel_print_level_t level, const char *format, va_list args); 
int rad_kprintk(rad_kernel_print_level_t level, const char *format, ...); 
int rad_early_vprintk(const char *format, va_list args); 
int rad_early_printk(const char *format, ...); 
void rad_debug_marker(const char *marker); 
rad_status_t rad_log_write(rad_log_level_t level, const char *category, const char *message); 
size_t rad_log_read(rad_log_entry_t *entries, size_t capacity, uint64_t after_sequence); 
rad_status_t rad_log_flush_to_path(const char *path); 
rad_status_t rad_cpu_interrupts_enable(void); 
rad_status_t rad_cpu_interrupts_disable(void); 
int rad_cpu_interrupts_enabled(void); 
void rad_cpu_idle(void); 
void rad_cpu_halt_forever(void); 
rad_status_t rad_boot_info_set(const rad_boot_info_t *boot_info); 
rad_status_t rad_boot_info_get(rad_boot_info_t *boot_info); 
const char *rad_boot_arg_get(const char *key); 
 
uint64_t rad_time_micros(void); 
uint64_t rad_time_millis(void); 
uint64_t rad_realtime_micros(void); 
rad_status_t rad_realtime_set_micros(uint64_t unix_micros); 
void rad_sleep_ms(uint32_t milliseconds); 
void rad_sleep_us(uint32_t microseconds); 
uint64_t rad_perf_now_cycles(void); 
void rad_perf_counter_add(const char *name, uint64_t delta); 
size_t rad_perf_counter_list(rad_perf_counter_info_t *counters, size_t capacity); 
rad_status_t rad_work_submit(const char *name, rad_work_handler_t handler, void *context); 
rad_status_t rad_work_poll(size_t budget, size_t *ran); 
rad_status_t rad_wait_queue_create(rad_wait_queue_t *queue); 
void rad_wait_queue_destroy(rad_wait_queue_t queue); 
rad_status_t rad_wait_queue_wait(rad_wait_queue_t queue, uint32_t timeout_ms); 
rad_status_t rad_wait_queue_wake_one(rad_wait_queue_t queue); 
rad_status_t rad_wait_queue_wake_all(rad_wait_queue_t queue); 
rad_status_t rad_timer_source_register(const rad_timer_source_config_t *config, const rad_timer_source_ops_t *ops); 
rad_status_t rad_timer_source_unregister(const char *name); 
void rad_timer_tick(uint64_t elapsed_micros); 
rad_status_t rad_timer_schedule_oneshot(uint64_t delay_micros); 
rad_status_t rad_timer_cancel_oneshot(void); 
size_t rad_timer_list(rad_timer_source_info_t *timers, size_t capacity); 
 
rad_status_t rad_task_create(rad_task_t *task, const char *name, rad_task_entry_t entry, void *context, size_t stack_size); 
rad_status_t rad_task_create_config(rad_task_t *task, const rad_task_config_t *config, rad_task_entry_t entry, void *context); 
rad_status_t rad_task_join(rad_task_t task); 
void rad_task_detach(rad_task_t task); 
uint64_t rad_task_current_id(void); 
int rad_task_current_core(void); 
void rad_task_yield(void); 
void rad_task_sleep_ms(uint32_t milliseconds); 
void rad_task_sleep_us(uint32_t microseconds); 
size_t rad_task_list(rad_task_info_t *tasks, size_t capacity); 
rad_status_t rad_core_info_get(rad_core_info_t *info); 
rad_status_t rad_scheduler_info_get(rad_scheduler_info_t *info); 
void rad_scheduler_yield_from_irq(void); 
void rad_scheduler_set_preemption_enabled(int enabled); 
uint32_t rad_scheduler_current_core(void); 
uint32_t rad_scheduler_online_core_mask(void); 
 
rad_status_t rad_mutex_create(rad_mutex_t *mutex); 
void rad_mutex_destroy(rad_mutex_t mutex); 
rad_status_t rad_mutex_lock(rad_mutex_t mutex); 
rad_status_t rad_mutex_unlock(rad_mutex_t mutex); 
 
rad_status_t rad_event_create(rad_event_t *event, int initially_signaled); 
void rad_event_destroy(rad_event_t event); 
rad_status_t rad_event_wait(rad_event_t event, uint32_t timeout_ms); 
rad_status_t rad_event_signal(rad_event_t event); 
rad_status_t rad_event_reset(rad_event_t event); 
 
void *rad_memory_alloc(size_t size); 
void rad_memory_free(void *pointer); 
void rad_memory_get_stats(rad_memory_stats_t *stats); 
 
rad_status_t rad_vfs_mount_host(const char *mount_point, const char *host_path); 
rad_status_t rad_vfs_mount_sd(const rad_sd_config_t *config); 
rad_status_t rad_vfs_mount_provider(const char *mount_point, const rad_vfs_backend_ops_t *ops); 
rad_status_t rad_vfs_unmount(const char *mount_point); 
rad_status_t rad_vfs_open(const char *path, uint32_t flags, rad_file_t *file); 
rad_status_t rad_vfs_read(rad_file_t file, void *buffer, size_t size, size_t *bytes_read); 
rad_status_t rad_vfs_write(rad_file_t file, const void *buffer, size_t size, size_t *bytes_written); 
rad_status_t rad_vfs_seek(rad_file_t file, int64_t offset, rad_seek_origin_t origin); 
uint64_t rad_vfs_tell(rad_file_t file); 
void rad_vfs_close(rad_file_t file); 
rad_status_t rad_vfs_stat(const char *path, rad_vfs_stat_t *stat); 
rad_status_t rad_vfs_list(const char *path, rad_vfs_list_callback_t callback, void *context); 
rad_status_t rad_vfs_mkdir(const char *path); 
rad_status_t rad_vfs_remove(const char *path); 
rad_status_t rad_vfs_rename(const char *old_path, const char *new_path); 
rad_status_t rad_vfs_rmdir(const char *path); 
rad_status_t rad_vfs_fsync(rad_file_t file); 
rad_status_t rad_vfs_truncate(const char *path, uint64_t size); 
rad_status_t rad_vfs_readlink(const char *path, char *buffer, size_t size); 
rad_status_t rad_vfs_symlink(const char *target, const char *link_path); 
rad_status_t rad_vfs_link(const char *old_path, const char *new_path); 
rad_status_t rad_vfs_chmod(const char *path, uint32_t mode); 
rad_status_t rad_vfs_chdir(const char *path); 
rad_status_t rad_vfs_getcwd(char *buffer, size_t size); 
rad_status_t rad_vfs_opendir(const char *path, rad_dir_t *dir); 
rad_status_t rad_vfs_readdir(rad_dir_t dir, rad_vfs_dirent_t *entry); 
void rad_vfs_closedir(rad_dir_t dir); 
 
int32_t rad_process_current_pid(void); 
int32_t rad_process_parent_pid(void); 
int32_t rad_process_fork(void); 
int32_t rad_process_execve(const char *path, const char *const argv[]); 
int32_t rad_process_waitpid(int32_t pid, int32_t *status, uint32_t options); 
void rad_process_exit(int32_t status); 
int32_t rad_process_kill(int32_t pid, int32_t signal_number); 
size_t rad_process_list(rad_process_info_t *processes, size_t capacity); 
int32_t rad_process_create(const char *path, int32_t parent_pid); 
rad_status_t rad_process_attach_task(int32_t pid, rad_task_t task); 
void rad_process_set_current_pid(int32_t pid); 
rad_status_t rad_process_mark_exec(int32_t pid, const char *path); 
rad_status_t rad_process_clone_fds(int32_t parent_pid, int32_t child_pid); 
rad_status_t rad_process_arch_register(const rad_process_arch_ops_t *ops); 
int32_t rad_process_fork_from_arch_frame(void *trap_frame); 
int32_t rad_process_reap(int32_t pid, int32_t *status); 
rad_status_t rad_process_get_credentials(int32_t pid, rad_credentials_t *credentials); 
rad_status_t rad_process_set_credentials(int32_t pid, const rad_credentials_t *credentials); 
rad_uid_t rad_process_getuid(void); 
rad_uid_t rad_process_geteuid(void); 
rad_gid_t rad_process_getgid(void); 
rad_gid_t rad_process_getegid(void); 
rad_status_t rad_process_setuid(rad_uid_t uid); 
rad_status_t rad_process_setgid(rad_gid_t gid); 
int32_t rad_process_getpgid(int32_t pid); 
int32_t rad_process_setpgid(int32_t pid, int32_t pgid); 
int32_t rad_process_getsid(int32_t pid); 
int32_t rad_process_setsid(void); 
int32_t rad_process_tcgetpgrp(int32_t fd); 
int32_t rad_process_tcsetpgrp(int32_t fd, int32_t pgid); 
 
rad_status_t rad_module_register(const rad_module_descriptor_t *descriptor); 
rad_status_t rad_module_unregister(const char *name); 
size_t rad_module_list(rad_module_info_t *modules, size_t capacity); 
rad_status_t rad_service_register(const rad_service_descriptor_t *descriptor); 
rad_status_t rad_service_unregister(const char *name); 
rad_status_t rad_service_configure(const char *name, const rad_service_config_t *config); 
rad_status_t rad_service_configure_tree(rad_tree_node_t node); 
rad_status_t rad_service_start(const char *name); 
rad_status_t rad_service_stop(const char *name); 
rad_status_t rad_service_poll_all(void); 
size_t rad_service_list(rad_service_info_t *services, size_t capacity); 
 
rad_status_t rad_irq_register(uint32_t irq, const char *name, rad_irq_handler_t handler, void *context); 
rad_status_t rad_irq_unregister(uint32_t irq); 
rad_status_t rad_irq_enable(uint32_t irq); 
rad_status_t rad_irq_disable(uint32_t irq); 
rad_status_t rad_irq_dispatch(uint32_t irq); 
size_t rad_irq_list(rad_irq_info_t *irqs, size_t capacity); 
rad_status_t rad_irq_domain_register(const rad_irq_domain_config_t *config, rad_irq_domain_t *domain); 
rad_status_t rad_irq_domain_unregister(const char *tree_path); 
rad_status_t rad_irq_domain_find(const char *tree_path, rad_irq_domain_t *domain); 
size_t rad_irq_resolve_tree(rad_tree_node_t node, rad_irq_resource_t *resources, size_t capacity); 
rad_status_t rad_irq_resource_enable(const rad_irq_resource_t *resource); 
rad_status_t rad_irq_resource_disable(const rad_irq_resource_t *resource); 
rad_status_t rad_irq_resource_register_handler(const rad_irq_resource_t *resource, const char *name, rad_irq_handler_t handler, void *context); 
 
int32_t rad_fd_open(const char *path, uint32_t flags); 
int32_t rad_fd_close(int32_t fd); 
intptr_t rad_fd_read(int32_t fd, void *buffer, size_t size); 
intptr_t rad_fd_write(int32_t fd, const void *buffer, size_t size); 
int64_t rad_fd_lseek(int32_t fd, int64_t offset, rad_seek_origin_t origin); 
int32_t rad_fd_ioctl(int32_t fd, uint32_t request, void *argument); 
intptr_t rad_fd_getdents(int32_t fd, rad_dirent_user_t *entries, size_t capacity); 
int32_t rad_fd_stat(const char *path, rad_vfs_stat_t *stat); 
int32_t rad_fd_fstat(int32_t fd, rad_vfs_stat_t *stat); 
int32_t rad_fd_fchdir(int32_t fd); 
int32_t rad_fd_ftruncate(int32_t fd, uint64_t size); 
int32_t rad_fd_dup(int32_t fd); 
int32_t rad_fd_dup2(int32_t old_fd, int32_t new_fd); 
int32_t rad_fd_fcntl(int32_t fd, uint32_t command, uintptr_t argument); 
int32_t rad_fd_poll(rad_pollfd_t *fds, size_t count, int32_t timeout_ms); 
int32_t rad_pipe_create(int32_t pipefd[2]); 
int32_t rad_shm_open(const char *name, size_t byte_size, uint32_t flags); 
int32_t rad_shm_unlink(const char *name); 
int32_t rad_shm_get_info(int32_t fd, rad_shm_info_t *info); 
int32_t rad_shm_set_page(int32_t fd, size_t page_index, uintptr_t page_token); 
int32_t rad_shm_get_page(int32_t fd, size_t page_index, uintptr_t *page_token); 
void *rad_shm_kernel_pointer(int32_t fd); 
 
intptr_t rad_syscall_dispatch(uintptr_t number, uintptr_t arg0, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t arg4, uintptr_t arg5); 
 
rad_status_t rad_program_load(const char *path, rad_program_t *program); 
rad_status_t rad_program_spawn(rad_program_t program, int argc, const char **argv, rad_task_t *task); 
void rad_program_unload(rad_program_t program); 
size_t rad_program_list(rad_program_info_t *programs, size_t capacity); 
 
rad_status_t rad_overlay_load_memory(const void *data, size_t size); 
rad_status_t rad_overlay_load_file(const char *path); 
rad_status_t rad_overlay_apply_boot(void); 
size_t rad_overlay_list(rad_overlay_info_t *overlays, size_t capacity); 
size_t rad_tree_list(rad_tree_node_info_t *nodes, size_t capacity); 
rad_tree_node_t rad_tree_find(const char *path); 
rad_status_t rad_tree_get_property_u32(rad_tree_node_t node, const char *name, uint32_t *value); 
size_t rad_tree_get_property_u32_array(rad_tree_node_t node, const char *name, uint32_t *values, size_t capacity); 
rad_status_t rad_tree_get_property_bool(rad_tree_node_t node, const char *name, int *value); 
rad_status_t rad_tree_get_property_string(rad_tree_node_t node, const char *name, char *buffer, size_t size); 
 
rad_status_t rad_device_register(const char *name, rad_device_type_t type, const rad_device_ops_t *ops); 
rad_status_t rad_device_unregister(const char *name); 
rad_status_t rad_device_open(const char *name, rad_device_t *device); 
void rad_device_close(rad_device_t device); 
rad_status_t rad_device_read(rad_device_t device, void *buffer, size_t size, size_t *bytes_read); 
rad_status_t rad_device_write(rad_device_t device, const void *buffer, size_t size, size_t *bytes_written); 
rad_status_t rad_device_ioctl(rad_device_t device, uint32_t request, void *argument); 
size_t rad_device_list(char names[][64], rad_device_type_t *types, size_t capacity); 
 
rad_status_t rad_input_device_register(const char *name, const rad_device_ops_t *ops); 
rad_status_t rad_input_device_unregister(const char *name); 
rad_status_t rad_input_open(const char *name, rad_device_t *device); 
rad_status_t rad_input_read_event(rad_device_t device, rad_input_event_t *event); 
rad_status_t rad_input_queue_create(const char *name, size_t capacity, rad_input_queue_t *queue); 
void rad_input_queue_destroy(rad_input_queue_t queue); 
rad_status_t rad_input_queue_push(rad_input_queue_t queue, const rad_input_event_t *event); 
rad_status_t rad_input_queue_read(rad_input_queue_t queue, rad_input_event_t *events, size_t capacity, uint32_t timeout_ms, size_t *count); 
rad_status_t rad_input_device_register_queue(const char *name, rad_input_queue_t queue); 
 
rad_status_t rad_block_device_register(const char *name, const rad_device_ops_t *ops); 
rad_status_t rad_block_open(const char *name, rad_device_t *device); 
rad_status_t rad_block_info(rad_device_t device, rad_block_info_t *info); 
rad_status_t rad_block_read(rad_device_t device, uint64_t sector, uint32_t sector_count, void *buffer); 
rad_status_t rad_block_write(rad_device_t device, uint64_t sector, uint32_t sector_count, const void *buffer); 
rad_status_t rad_block_flush(rad_device_t device); 
rad_status_t rad_net_device_register(const char *name, const rad_device_ops_t *ops); 
rad_status_t rad_net_open(const char *name, rad_device_t *device); 
rad_status_t rad_net_link_info(rad_device_t device, rad_net_link_info_t *info); 
rad_status_t rad_net_send(rad_device_t device, const void *data, size_t length); 
intptr_t rad_net_receive(rad_device_t device, void *data, size_t length); 
rad_status_t rad_net_poll(rad_device_t device); 
rad_status_t rad_net_stack_info(rad_net_stack_info_t *info); 
rad_status_t rad_net_configure(const rad_net_stack_config_t *config); 
rad_status_t rad_net_ntp_status(rad_ntp_status_t *status); 
rad_status_t rad_net_ntp_query(rad_ntp_query_t *query); 
int32_t rad_socket_create(int domain, int type, int protocol); 
int32_t rad_socket_bind(int32_t fd, const rad_sockaddr_in_t *address, size_t address_length); 
int32_t rad_socket_listen(int32_t fd, int backlog); 
int32_t rad_socket_accept(int32_t fd, rad_sockaddr_in_t *address, size_t *address_length); 
int32_t rad_socket_connect(int32_t fd, const rad_sockaddr_in_t *address, size_t address_length); 
intptr_t rad_socket_sendto(int32_t fd, const void *buffer, size_t size, uint32_t flags, const rad_sockaddr_in_t *address, size_t address_length); 
intptr_t rad_socket_recvfrom(int32_t fd, void *buffer, size_t size, uint32_t flags, rad_sockaddr_in_t *address, size_t *address_length); 
intptr_t rad_socket_send(int32_t fd, const void *buffer, size_t size, uint32_t flags); 
intptr_t rad_socket_recv(int32_t fd, void *buffer, size_t size, uint32_t flags); 
int32_t rad_socket_shutdown(int32_t fd, int how); 
int32_t rad_socket_get_info(int32_t fd, rad_socket_info_t *info); 
int32_t rad_socket_setsockopt(int32_t fd, int level, int option, const void *value, size_t value_length); 
int32_t rad_socket_getsockopt(int32_t fd, int level, int option, void *value, size_t *value_length); 
 
rad_status_t rad_framebuffer_register(const char *name, const rad_framebuffer_info_t *info, const rad_framebuffer_ops_t *ops); 
rad_status_t rad_framebuffer_register_ex(const rad_framebuffer_config_t *config, const rad_framebuffer_ops_t *ops); 
rad_status_t rad_framebuffer_unregister(const char *name); 
rad_status_t rad_framebuffer_open(const char *name, rad_framebuffer_t *framebuffer); 
rad_status_t rad_framebuffer_open_primary(rad_framebuffer_t *framebuffer); 
void rad_framebuffer_close(rad_framebuffer_t framebuffer); 
rad_status_t rad_framebuffer_get_info(rad_framebuffer_t framebuffer, rad_framebuffer_info_t *info); 
rad_status_t rad_framebuffer_get_display_info(rad_framebuffer_t framebuffer, rad_framebuffer_display_info_t *info); 
rad_status_t rad_framebuffer_set_primary(const char *name); 
rad_status_t rad_framebuffer_set_mode(rad_framebuffer_t framebuffer, uint32_t mode_index); 
rad_status_t rad_framebuffer_blank(rad_framebuffer_t framebuffer, int blanked); 
rad_status_t rad_framebuffer_get_vsync_counter(rad_framebuffer_t framebuffer, uint64_t *counter); 
rad_status_t rad_framebuffer_clear(rad_framebuffer_t framebuffer, uint32_t color); 
rad_status_t rad_framebuffer_draw_text(rad_framebuffer_t framebuffer, uint32_t cell_x, uint32_t cell_y, const char *text, uint32_t foreground, uint32_t background); 
rad_status_t rad_framebuffer_flush(rad_framebuffer_t framebuffer, const rad_framebuffer_rect_t *rect); 
rad_status_t rad_framebuffer_present(rad_framebuffer_t framebuffer, const rad_framebuffer_present_t *present); 
size_t rad_framebuffer_list(rad_framebuffer_info_t *framebuffers, char names[][64], size_t capacity); 
size_t rad_framebuffer_list_ex(rad_framebuffer_display_info_t *framebuffers, size_t capacity); 
 
rad_status_t rad_i2c_controller_register(const rad_i2c_controller_config_t *config, const rad_i2c_controller_ops_t *ops); 
rad_status_t rad_i2c_controller_unregister(uint32_t bus_id); 
rad_status_t rad_i2c_bus_open(uint32_t bus_id, rad_i2c_bus_t *bus); 
void rad_i2c_bus_close(rad_i2c_bus_t bus); 
rad_status_t rad_i2c_transfer(rad_i2c_bus_t bus, const rad_i2c_transfer_t *transfer); 
rad_status_t rad_i2c_bind_tree(void); 
rad_status_t rad_i2c_driver_register(const rad_i2c_driver_t *driver); 
rad_status_t rad_i2c_driver_unregister(const char *name); 
rad_status_t rad_i2c_device_open(uint32_t bus_id, uint8_t address, rad_i2c_device_t **device); 
void rad_i2c_device_close(rad_i2c_device_t *device); 
rad_status_t rad_i2c_device_transfer(rad_i2c_device_t *device, const rad_i2c_transfer_t *transfer); 
size_t rad_i2c_device_irq_count(const rad_i2c_device_t *device); 
rad_status_t rad_i2c_device_get_irq(const rad_i2c_device_t *device, size_t index, rad_irq_resource_t *resource); 
size_t rad_i2c_list_devices(rad_i2c_device_info_t *devices, size_t capacity); 
rad_status_t rad_i2c_transfer_device(rad_device_t device, const rad_i2c_transfer_t *transfer); 
 
rad_status_t rad_spi_controller_register(const rad_spi_controller_config_t *config, const rad_spi_controller_ops_t *ops); 
rad_status_t rad_spi_controller_unregister(uint32_t bus_id); 
rad_status_t rad_spi_bus_open(uint32_t bus_id, rad_spi_bus_t *bus); 
void rad_spi_bus_close(rad_spi_bus_t bus); 
rad_status_t rad_spi_transfer(rad_spi_bus_t bus, const rad_spi_transfer_t *transfer); 
rad_status_t rad_spi_driver_register(const rad_spi_driver_t *driver); 
rad_status_t rad_spi_driver_unregister(const char *name); 
rad_status_t rad_spi_device_open(uint32_t bus_id, uint8_t cs, rad_spi_device_t **device); 
void rad_spi_device_close(rad_spi_device_t *device); 
rad_status_t rad_spi_device_transfer(rad_spi_device_t *device, const rad_spi_transfer_t *transfer); 
size_t rad_spi_device_irq_count(const rad_spi_device_t *device); 
rad_status_t rad_spi_device_get_irq(const rad_spi_device_t *device, size_t index, rad_irq_resource_t *resource); 
size_t rad_spi_list_devices(rad_spi_device_info_t *devices, size_t capacity); 
rad_status_t rad_spi_transfer_device(rad_device_t device, const rad_spi_transfer_t *transfer); 
 
rad_status_t rad_dma_controller_register(const rad_dma_controller_config_t *config, const rad_dma_backend_ops_t *ops); 
rad_status_t rad_dma_controller_unregister(const char *name); 
rad_status_t rad_dma_channel_request(rad_dma_request_id_t request_id, rad_dma_channel_t *channel); 
void rad_dma_channel_release(rad_dma_channel_t channel); 
rad_status_t rad_dma_submit(rad_dma_channel_t channel, const rad_dma_transfer_t *transfer); 
rad_status_t rad_dma_wait(rad_dma_channel_t channel, uint32_t timeout_ms); 
rad_status_t rad_dma_cancel(rad_dma_channel_t channel); 
size_t rad_dma_list_channels(rad_dma_channel_info_t *channels, size_t capacity); 
 
size_t rad_driver_list(rad_driver_info_t *drivers, size_t capacity); 
rad_status_t rad_audio_configure(rad_device_t device, const rad_audio_format_t *format); 
rad_status_t rad_serial_configure(rad_device_t device, const rad_serial_config_t *config); 
 
rad_status_t rad_tty_open(const char *name, rad_tty_t *tty); 
void rad_tty_close(rad_tty_t tty); 
rad_status_t rad_tty_read(rad_tty_t tty, void *buffer, size_t size, size_t *bytes_read); 
rad_status_t rad_tty_write(rad_tty_t tty, const void *buffer, size_t size, size_t *bytes_written); 
rad_status_t rad_tty_push_input(rad_tty_t tty, const void *buffer, size_t size, size_t *bytes_consumed); 
rad_status_t rad_tty_set_output_callback(rad_tty_t tty, rad_tty_output_t output, void *context); 
rad_status_t rad_tty_set_window_size(rad_tty_t tty, const rad_tty_window_size_t *size); 
rad_status_t rad_tty_get_window_size(rad_tty_t tty, rad_tty_window_size_t *size); 
rad_status_t rad_tty_set_mode(rad_tty_t tty, uint32_t mode); 
rad_status_t rad_tty_get_mode(rad_tty_t tty, uint32_t *mode); 
rad_status_t rad_tty_set_termios(rad_tty_t tty, const rad_tty_termios_t *termios); 
rad_status_t rad_tty_get_termios(rad_tty_t tty, rad_tty_termios_t *termios); 
rad_status_t rad_tty_flush(rad_tty_t tty, uint32_t queues); 
 
rad_status_t rad_pty_open_pair(const char *name, rad_pty_t *pty); 
void rad_pty_close(rad_pty_t pty); 
rad_status_t rad_pty_read_master(rad_pty_t pty, void *buffer, size_t size, size_t *bytes_read); 
rad_status_t rad_pty_write_master(rad_pty_t pty, const void *buffer, size_t size, size_t *bytes_written); 
rad_status_t rad_pty_read_slave(rad_pty_t pty, void *buffer, size_t size, size_t *bytes_read); 
rad_status_t rad_pty_write_slave(rad_pty_t pty, const void *buffer, size_t size, size_t *bytes_written); 
rad_status_t rad_pty_resize(rad_pty_t pty, const rad_tty_window_size_t *size); 
rad_status_t rad_pty_slave_name(rad_pty_t pty, char *buffer, size_t size); 
 
rad_status_t rad_terminal_register_command(const char *name, const char *description, rad_terminal_handler_t handler, void *context); 
rad_status_t rad_terminal_execute(const char *line, rad_terminal_write_t write, void *write_context); 
rad_status_t rad_terminal_poll_tty(rad_tty_t tty); 
rad_status_t rad_terminal_attach_device(const char *device_name); 
rad_status_t rad_terminal_attach_tty(const char *serial_device_name, const char *tty_name); 
rad_status_t rad_terminal_poll_attached(void); 
void rad_terminal_repl_set(int enabled); 
size_t rad_terminal_command_count(void); 
 
#if defined(__cplusplus)
}
 
#ifndef RADLIB_EMBEDDED_NO_CPP_WRAPPERS
namespace RADEmbedded {
 
class Kernel {
public:
    static rad_status_t init(const char *backend = "linux_sim") {
        rad_kernel_config_t config{};
        config.backend_name = backend;
        return rad_kernel_init(&config); //< Public RADPx-OS kernel API entry point.
    }
    static void shutdown() { rad_kernel_shutdown(); }
    static bool initialized() { return rad_kernel_is_initialized() != 0; }
    static std::string backendName() { return rad_kernel_backend_name(); }
    static std::string version() { return rad_kernel_version_string(); }
};
 
class Mutex {
public:
    Mutex() { rad_mutex_create(&handle_); }
    ~Mutex() { rad_mutex_destroy(handle_); }
    Mutex(const Mutex&) = delete;
    Mutex& operator=(const Mutex&) = delete;
    rad_status_t lock() { return rad_mutex_lock(handle_); }
    rad_status_t unlock() { return rad_mutex_unlock(handle_); }
    rad_mutex_t native() const { return handle_; }
private:
    rad_mutex_t handle_ = nullptr;
};
 
class Event {
public:
    explicit Event(bool signaled = false) { rad_event_create(&handle_, signaled ? 1 : 0); }
    ~Event() { rad_event_destroy(handle_); }
    Event(const Event&) = delete;
    Event& operator=(const Event&) = delete;
    rad_status_t wait(uint32_t timeoutMs) { return rad_event_wait(handle_, timeoutMs); }
    rad_status_t signal() { return rad_event_signal(handle_); }
    rad_status_t reset() { return rad_event_reset(handle_); }
private:
    rad_event_t handle_ = nullptr;
};
 
class File {
public:
    File() = default;
    ~File() { close(); }
    File(const File&) = delete;
    File& operator=(const File&) = delete;
    bool open(const char *path, uint32_t flags) { close(); return rad_vfs_open(path, flags, &handle_) == RAD_STATUS_OK; }
    size_t read(void *buffer, size_t size) { size_t done = 0; rad_vfs_read(handle_, buffer, size, &done); return done; }
    size_t write(const void *buffer, size_t size) { size_t done = 0; rad_vfs_write(handle_, buffer, size, &done); return done; }
    void close() { if (handle_) { rad_vfs_close(handle_); handle_ = nullptr; } }
private:
    rad_file_t handle_ = nullptr;
};
 
} // namespace RADEmbedded
#endif
#endif
 
#endif