forked from rsta2/circle
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathclasses.txt
219 lines (201 loc) · 14.2 KB
/
classes.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
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 of Raspberry Pi 4.
* 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
* CDMA4Channel: Platform DMA4 "large address" controller support (helper class).
* CDMAChannel: Platform DMA controller support (I/O read/write, memory copy).
* 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.
* 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.
* 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).
* 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)
* 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).
* 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).
* 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 or CXHCIDevice, 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 CDWHCIDevice, some basic functions for 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).
* 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
* 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.
* 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
* 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
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
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.
* CTask: Overload this class, define the Run() method to implement your own task and call new on it to start it.
* CScheduler: Cooperative non-preemtive 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.
* CIPAddress: Encapsulates an IP address.
* CLinkLayer: Encapsulates the Ethernet MAC layer.
* CMQTTClient: Client for the MQTT IoT protocol.
* CMQTTReceivePacket: MQTT helper class.
* CMQTTSendPacket: MQTT helper class.
* 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.
* CRetransmissionQueue: The TCP retransmission queue.
* 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.