CLASSES

Base library

* C2DGraphics: Software graphics library with VSync and hardware-accelerated double buffering.
* CActLED: Switch the Act LED on and off, checks the Raspberry Pi model to use the right LED pin.
* CBcm54213Device: Driver for BCM54213PE Gigabit Ethernet Transceiver of Raspberry Pi 4.
* CBcmFrameBuffer: Frame buffer initialization, setting color palette for 8 bit depth.
* CBcmMailBox: Simple GPU mailbox interface, currently used for the property interface.
* CBcmPCIeHostBridge: Driver for PCIe Host Bridge(s) of Raspberry Pi 4 and 5.
* CBcmPropertyTags: Get several information from the GPU side or control something on this side.
* CBcmRandomNumberGenerator: Driver for the built-in hardware random number generator.
* CBcmWatchdog: Driver for the BCM2835 watchdog device.
* CCharGenerator: Gives pixel information for console font
* CClassAllocator: Support class for the class-specific allocation of objects
* CCPUThrottle: Manages CPU clock rate depending on user requirements and SoC temperature.
* CDevice: Base class for all devices
* CDeviceNameService: Devices can be registered by name and retrieved later by this name
* CDeviceTreeBlob: Simple Devicetree blob parser
* CDisplay: Base class for dot-matrix display drivers.
* CDMA4Channel: Platform DMA4 "large address" controller support (helper class).
* CDMAChannel: Platform DMA controller support (I/O read/write, memory copy).
* CDMAChannelRP1: RP1 platform DMA controller support (for Raspberry Pi 5).
* CExceptionHandler: Generates a stack-trace and a panic message if an abort exception occurs.
* CGPIOClock: Using GPIO clocks, initialize, start and stop it.
* CGPIOManager: Interrupt multiplexer for CGPIOPin (only required if GPIO interrupt is used).
* CGPIOPin: Encapsulates a GPIO pin, can be read, write or inverted. Supports interrupts. Simple initialization.
* CGPIOPinFIQ: GPIO fast interrupt pin (only one allowed in the system).
* CGenericLock: Locks a resource with or without scheduler.
* CHeapAllocator: Allocates blocks from a flat memory region.
* CI2CMaster: Driver for I2C master devices.
* CI2CMasterIRQ: Driver for I2C master devices - async using IRQ.
* CI2CSlave: Driver for I2C slave device.
* CInterruptSystem: Connecting to interrupts, an interrupt handler will be called on interrupt.
* CKernelOptions: Providing kernel options from file cmdline.txt (see doc/cmdline.txt).
* CLatencyTester: Measures the IRQ latency of the running code.
* CLogger: Writing logging messages to a target device
* CMACAddress: Encapsulates an Ethernet MAC address.
* CMACBDevice: Driver for MACB/GEM Ethernet NIC of Raspberry Pi 5.
* CMachineInfo: Helper class to get different information about the running computer.
* CMemorySystem: Enabling MMU if requested, switching page tables (not used here).
* CMPHIDevice: A driver, which uses the MPHI device to generate an IRQ.
* CMultiCoreSupport: Implements multi-core support on the Raspberry Pi 2.
* CNetDevice: Base class (interface) of net devices.
* CNullDevice: Character device which ignores sent data and returns 0 bytes on read.
* CNumberPool: Allocation pool for (device) numbers.
* CPageAllocator: Allocates aligned pages from a flat memory region.
* CPageTable: Encapsulates a page table to be used by MMU (AArch32).
* CPtrArray: Container class. Dynamic array of pointers.
* CPtrList: Container class. List of pointers.
* CPtrListFIQ: Container class. List of pointers, usable from FIQ_LEVEL.
* CPWMOutput: Pulse Width Modulator output (2 channels).
* CSouthbridge: Driver for the RP1 multi-function device of the Raspberry Pi 5.
* CScreenDevice: Writing characters to screen, some escape sequences (some are not yet implemented)
* CSerialDevice: Driver for PL011 UART, interrupt or polling mode
* CSMIMaster: Driver for the Second Memory Interface.
* CSpinLock: Encapsulates a spin lock for synchronizing the concurrent access to a resource from multiple cores.
* CSPIMaster: Driver for (non-AUX) SPI master device. Synchronous polling operation.
* CSPIMasterAUX: Driver for the auxiliary SPI master (SPI1).
* CSPIMasterDMA: Driver for SPI0 master device. Asynchronous DMA operation.
* CString: Simple string manipulation class, Format() method works like printf() (but has less formating options)
* CTerminalDevice: Terminal support for dot-matrix displays.
* CTime: Holds, makes and breaks the time.
* CTimer: Manages the system clock, supports kernel timers and a calibrated delay loop.
* CTracer: Collects tracing events in a ring buffer for debugging and dumps them to the logger later.
* CTranslationTable: Encapsulates a translation table to be used by MMU (AArch64).
* CUserTimer: Fine grained user programmable interrupt timer (based on ARM_IRQ_TIMER1)
* CVirtualGPIOPin: Encapsulates a "virtual" GPIO pin controlled by the VideoCore (Output only).
* CWindowDisplay: Non-overlapping window on a display.
* CWriteBufferDevice: Filter for buffered write to (e.g. screen) device.

USB library

* CDWHCICompletionQueue: Queues USB requests ready for completion (with USE_USB_FIQ enabled).
* CDWHCIDevice: USB host controller interface (HCI) driver for Raspberry Pi 1-3.
* CDWHCIFrameScheduler: Base class for a simple micro frame scheduler
* CDWHCIFrameSchedulerIsochronous: Schedules the transmission of isochronous split frames to non-high-speed devices
* CDWHCIFrameSchedulerNonPeriodic: Schedules the transmission of non-interrupt split frames to non-high-speed devices
* CDWHCIFrameSchedulerNoSplit: Schedules the transmission of frames to direct attached non-high-speed devices
* CDWHCIFrameSchedulerPeriodic: Schedules the transmission of interrupt split frames to non-high-speed devices
* CDWHCIRegister: Supporting class for CDWHCIDevice, encapsulates a register of the HCI.
* CDWHCIRootPort: Supporting class for CDWHCIDevice, initializes the root port.
* CDWHCITransactionQueue: Queues coming USB transactions (with USE_USB_SOF_INTR enabled).
* CDWHCITransferStageData: Holds all the data needed for a transfer stage on one HCI channel.
* CLAN7800Device: Driver for the on-board USB Gigabit Ethernet device of the Raspberry Pi 3 B+.
* CSMSC951xDevice: Driver for the on-board USB Ethernet device.
* CUSBAudioControlDevice: Driver for USB audio control devices.
* CUSBAudioStreamingDevice: Low-level driver for USB audio streaming devices.
* CUSBAudioFunctionTopology: Topology parser for USB audio class devices.
* CUSBBluetoothDevice: Bluetooth HCI transport driver for USB Bluetooth BR/EDR dongles.
* CUSBBulkOnlyMassStorageDevice: Driver for USB mass storage devices (bulk only)
* CUSBCDCEthernetDevice: Driver for the USB CDC Ethernet device implemented in QEMU.
* CUSBConfigurationParser: Parses and validates an USB configuration descriptor.
* CUSBController: Generic USB (host or gadget) controller
* CUSBDevice: Encapsulates a general USB device (detects the functions of this device).
* CUSBDeviceFactory: Creates the function objects of the different supported USB functions.
* CUSBEndpoint: Encapsulates an endpoint of an USB device (supports control, bulk and interrupt EPs).
* CUSBFloppyDiskDevice: Driver for USB floppy disk devices (CBI transport).
* CUSBFunction: Encapsulates a function (represented by an interface descriptor) of an USB device.
* CUSBGamePadDevice: Base class for USB gamepad drivers
* CUSBGamePadPS3Device: Driver for PS3 gamepad
* CUSBGamePadPS4Device: Driver for PS4 gamepad
* CUSBGamePadStandardDevice: Driver for USB gamepads with USB HID class report interface (3-0-0)
* CUSBGamePadSwitchProDevice: Driver for Nintendo Switch Pro gamepad
* CUSBGamePadXbox360Device: Driver for Xbox 360 Wired gamepad
* CUSBGamePadXboxOneDevice: Driver for Xbox One gamepad
* CUSBHCIDevice: Alias for CDWHCIDevice, CXHCIDevice or CUSBSubSystem, depending on Raspberry Pi model.
* CUSBHCIRootPort: Base class, which represents an USB HCI root port.
* CUSBHIDDevice: General USB HID device (e.g. keyboard, mouse, gamepad)
* CUSBHostController: Base class of USB host controllers.
* CUSBKeyboardDevice: Driver for USB keyboards
* CUSBMIDIDevice: Interface device for USB Audio Class MIDI 1.0 devices
* CUSBMIDIHostDevice: Host driver for USB Audio Class MIDI 1.0 devices
* CUSBMouseDevice: Driver for USB mice
* CUSBPrinterDevice: Simple communications driver for USB printers (back-channel is not used).
* CUSBRequest: A request to an USB device (URB).
* CUSBSerialDevice: Interface device for USB serial devices.
* CUSBSerialCDCDevice: Driver for USB CDC serial devices (e.g. micro:bit)
* CUSBSerialCH341Device: Driver for CH341 based USB serial devices
* CUSBSerialCP210xDevice: Driver for CP210x based USB serial devices
* CUSBSerialDevice: Base class and interface for USB serial device drivers
* CUSBSerialFT231XDevice: Driver for FTDI based USB serial devices
* CUSBSerialHostDevice: Generic host driver for USB serial devices
* CUSBSerialPL2303Device: Driver for PL2303 based USB serial devices
* CUSBStandardHub: USB hub driver for LAN9512/9514 and external hubs (max. 8 ports)
* CUSBString: Encapsulates a string descriptor, available on an USB device.
* CUSBSubSystem: USB sub-system of the Raspberry Pi 5.
* CUSBTouchScreenDevice: Driver for USB HID-class touchscreens.
* CXHCICommandManager: Synchronous xHC command execution for the xHCI driver.
* CXHCIDevice: USB host controller interface (xHCI) driver for Raspberry Pi 4.
* CXHCIEndpoint: Encapsulates a single endpoint of an USB device for the xHCI driver.
* CXHCIEventManager: xHC event handling for the xHCI driver.
* CXHCIMMIOSpace: Provides access to the memory-mapped I/O registers of the xHCI controller.
* CXHCIRing: Encapsulates a transfer, command or event ring for communication with the xHCI controller.
* CXHCIRootHub: Initializes the available USB root ports of the xHCI controller.
* CXHCIRootPort: Encapsulates an USB root port of the xHCI controller.
* CXHCISharedMemAllocator: Shared memory allocation for the xHCI driver.
* CXHCISlotManager: Manages the USB device slots of the xHCI controller.
* CXHCIUSBDevice: Encapsulates a single USB device, attached to the xHCI controller.

USB gadget library

* CUSBCDCGadget: USB serial CDC gadget
* CUSBCDCGadgetEndpoint: Endpoint of the USB serial CDC gadget
* CDWUSBGadget: DW USB gadget on Raspberry Pi (3)A(+), Zero (2) (W), 4B
* CDWUSBGadgetEndpoint: Endpoint of a DW USB gadget
* CDWUSBGadgetEndpoint0: Endpoint 0 of a DW USB gadget
* CUSBMIDIGadget: USB MIDI (v1.0) gadget
* CUSBMIDIGadgetEndpoint: Endpoint of the USB MIDI gadget
* CUSBMSDGadget: USB mass storage device gadget
* CUSBMSDGadgetEndpoint: Endpoint of the USB mass storage gadget

Input library

* CConsole: Console device using screen/USB keyboard or alternate device (e.g. CSerialDevice)
* CKeyboardBehaviour: Generic keyboard function
* CKeyboardBuffer: Buffers characters entered on the USB keyboard
* CKeyMap: Keyboard translation map (six selectable default maps at the moment)
* CLineDiscipline: Implements line editor function
* CMouseBehaviour: Generic mouse function, handles the mouse cursor
* CMouseDevice: Generic mouse interface device
* CRPiTouchScreen: Driver for the official Raspberry Pi touch screen
* CTouchScreenDevice: Generic touch screen interface device
* CXPT2046TouchScreen: Driver for XPT2046-based touch screens

FS library

* CPartition: Derived from CDevice, restricts access to a storage partition inside its boundaries.
* CPartitionManager: Creates a CPartition object for each primary (non-EFI) partition.

FAT FS library

* CFAT: Encapsulates the File Allocation Table structure of a FAT storage partition.
* CFATInfo: Encapsulates the configuration information describing a FAT storage partition (from BPB and FS Info).
* CFATDirectory: Encapsulates a directory on a FAT partition (currently 8.3-names in the root directory only).
* CFATFileSystem: File system driver for FAT16 and FAT32 storage partitions.
* CFATCache: Sector cache for FAT storage partitions.

Scheduler library

* CMutex: Provides a method to provide mutual exclusion (critical sections) across tasks.
* CPipe: Unidirectional interprocess communication channel using a FIFO.
* CPipeFile: Read or Write endpoint of a CPipe channel.
* CTask: Overload this class, define the Run() method to implement your own task and call new on it to start it.
* CScheduler: Cooperative non-preemptive scheduler which controls which task runs at a time.
* CSemaphore: Implements a semaphore synchronization class.
* CSynchronizationEvent: Provides a method to synchronize the execution of a task with an event.

Net library

* CARPHandler: Resolves IP addresses to Ethernet MAC addresses and responds to ARP requests.
* CChecksumCalculator: Calculates checksums in several TCP/IP packets.
* CDHCPClient: DHCP client task. Gets and maintains an IP address lease for the network device.
* CDNSClient: Resolves hostnames to IP addresses.
* CHTTPClient: Requests documents from HTTP webservers.
* CHTTPDaemon: Simple HTTP server class.
* CICMPHandler: ICMP error message handler and echo (ping) responder.
* CIGMPHandler: IGMP version 2 protocol handler.
* CIPAddress: Encapsulates an IP address.
* CLinkLayer: Encapsulates the Ethernet MAC layer.
* CmDNSDaemon: mDNS responder task.
* CmDNSPublisher: mDNS / Bonjour client task.
* CMQTTClient: Client for the MQTT IoT protocol.
* CMQTTReceivePacket: MQTT helper class.
* CMQTTSendPacket: MQTT helper class.
* CNetBuffer: Generic frame/packet buffer for network protocol handling.
* CNetBufferQueue: FIFO queue for CNetBuffer objects.
* CNetConfig: Encapsulates the network configuration.
* CNetConnection: Virtual transport layer connection (UDP or TCP (not yet available)).
* CNetDeviceLayer: Encapsulates the network device support layer. Queues TX/RX frames before/after transmission.
* CNetQueue: Encapsulates a network packet queue.
* CNetSocket: Base class of networking sockets.
* CNetSubSystem: The main network subsystem class. Create an instance of it in the CKernel class.
* CNetTask: The main networking task running in the background. Processes the different network layers.
* CNetworkLayer: Encapsulates the IP network layer. Does not support packet fragmentation so far.
* CNTPClient: A NTP client which gets the current time from an Internet time server.
* CNTPDaemon: Background task which uses CNTPClient to update the system time every 15 minutes.
* CPHYTask: Background task which continuously updates the PHY of the used net device.
* CReassemblyQueue: Reassembly queue for the TCP receiver.
* CRetransmissionTimeoutCalculator: Calculates the TCP retransmission timeout according to RFC 6298.
* CRouteCache: Caches special routes, received via ICMP redirect requests.
* CSocket: Network application interface (socket) class.
* CSysLogDaemon: Syslog sender task according to RFC5424 and RFC5426 (UDP transport only).
* CTCPConnection: Encapsulates a TCP connection. Derived from CNetConnection.
* CTCPRejector: Rejects TCP segments which do not address an open connection. Derived from CNetConnection.
* CTFTPDaemon: TFTP server task.
* CTransportLayer: Encapsulates the TCP/UDP transport layer.
* CUDPConnection: Encapsulates a (virtual) UDP connection. Derived from CNetConnection.

Sound library

* CDMASoundBuffers: Concatenated DMA buffers to be used by sound device drivers.
* CHDMISoundBaseDevice: Low level access to the HDMI sound device (without VCHIQ).
* CI2SSoundBaseDevice: Low level access to the I2S sound device.
* CPCM512xSoundController: Sound controller for PCM512x.
* CPWMSoundDevice: Using the PWM device to playback sound samples in different formats.
* CPWMSoundBaseDevice: Low level access to the PWM device to generate sounds on the 3.5mm headphone jack.
* CSoundBaseDevice: Base class of sound devices, converts several sound formats.
* CSoundController: Optional controller of a sound device.
* CUSBSoundBaseDevice: High-level driver for USB audio streaming devices.
* CUSBSoundController: Sound controller for USB sound devices.
* CWM8960SoundController: Sound controller for WM8960.