Units
Class Hierarchy
Classes, Interfaces and Objects
Types
Enumerations
Variables
Constants
Functions and Procedures
Identifiers

All Classes, Interfaces and Objects

NameUnitDescription
TAutomateCardFormkdautocardClass TkdAutomateCardForm represents a friendly wizard called CardBuilder. Being a descendant of the Kylix design window class, any object of it, when constructed, helps you to produce the definition of device model and the diagnostics of corresponding hardware at design time in Kylix IDE, in the most comfortable form. It is needless to document a great number of members of this class, because this class implements a pure design-time instrument. Refer to the outside documentation for additional information and usage.
TInterruptHandlerParserkdinthandlerClass TInterruptHandlerParser parses and validates the set of instructions of kernel-mode interrupt handler hosted at InterruptHandler property of TkdInterrupt class.
TkdCustomCardkdclxcoreClass TkdCustomCard models hardware device. Whereas descendants of TkdResource class model different hardware resources separately (such as: memory and port ranges, registers, interrupts and other), TkdCustomCard models hardware device (or card) on the whole. This class includes members for making up the device abstraction (henceforth, model) by attaching and detaching essential resources mentioned above, loading and unloading the GDD, registering and unregistering the device model (the prototype of user-mode device driver) in the system. An original and very powerful feature is that this component and its CardItems property are equipped with a specific editor - tool whose name is CardBuilder. Right at design time CardBuilder, like a wizard, helps you to produce the definition of device model and the diagnostics of corresponding hardware. TkdCustomCard is the ultimate class for hardware devices, it does not support inheritance. Although TkdCustomCard class has dozens of methods and properties, relevant members are documented only. Refer to the outside documentation about how to use CardBuilder.
TkdDirectMemoryRangekdrangesResource class TkdDirectMemoryRange is the ancestor for all components modelling memory ranges which are directly accessible from the user space. Beside other behaviour the class introduces UserDirectAddr property to provide user programs with direct access to device memory. This class is actual to accelerate access to hardware devices which lend themselves to the Linux mmap abstraction. Most PCI periferals, for example, map their control registers to a memory address, and demanding applications might prefer to have direct access to the registers instead of having to use indirect transfers provided by TkdMemoryRange class. Depending on the nature of memory required to be accessed there have been established two descendant classes: TkdDirectRPIOMRange and TkdDirectRRAMRange whose implementations vary mainly on the GDD level.
TkdDirectRPIOMRangekdrangesFinal resource class TkdDirectRPIOMRange models direct memory ranges, i.e. memory regions directly accessible from the user space and represented by: 1. reserved pages whose physical addresses are between 640KB and 1 MB and 2. I/O memory regions whose physical addresses are above the top of physical memory. This is the only and sufficient class that allows to get an access to a real hardware device in the direct manner from the user space via a pointer provided. The targeted range of physical addresses accessible through objects of this class may spread from 0x9FC00 up to 0xFFFFFFFF.
TkdDirectRRAMRangekdrangesFinal resource class TkdDirectRRAMRange models direct memory ranges, i.e. memory regions directly accessible from the user space those physical addresses belong to the real RAM (known as Conventional Memory). The targeted range of physical addresses accessible through objects of this class may spread from 0 up to 0x9FBFF.
TkdDMABufferkddmabufferFinal resource class TkdDMABuffer models multi-purpose DMA buffer related to broad range of hardware that needs this buffer for data tranfer with no CPU activity. It includes properties for specifying parameters of the DMA buffer as well as methods for locking and unlocking it. The remaining members of the class are necessary accessors for obtaining data required by user-space programs and peripherals for the purpose of proper functioning with the DMA buffer established.
TkdFrameworkAssistantkdframeworkassistantComplementary class TkdFrameworkAssistant brings the KylixDriver Application Library to a more pragmatic interface functionality especially for run-time purposes.
TkdHWRangekdrangesResource class TkdHWRange is the ancestor for all components modelling address ranges composed of either ports or memory areas belonging to a particular hardware device. Those areas are locations where different resources of the hardware device are mapped. This class introduces Transfer method that initiates data reading and writing operations on hardware and it introduces properties which specify rules for the transfer. By making up multifarious combination over values of the properties, required transfer operations can be easily composed. The class also introduces a number of virtual methods intended to be overridden by its port-oriented and memory-oriented descendants, including those checking the self-consistency and the inter-consistency of all instances of this class, and those maintaining instances of the dependent class TkdHWRangeRegister.
TkdHWRangeRegisterkdregisterFinal resource class TkdHWRangeRegister models hardware register related to some address range of hardware, either memory or port concerned, i.e. a descendant of TkdHWRange class. It includes properties for specifying the targeted address range for the register, the offset of the register within the range, the size of the register and the access mode to it. Use Value property to actually read from or write to the register.
TkdInterruptkdinterruptFinal resource class TkdInterrupt models hardware interrupts. This basic interrupt managing class includes members for specifying a particular interrupt and all information for that interrupt acknowledgement, binding to that interrupt the common interrupt service routine (ISR) located inside the GDD and running in the privileged mode and a user-defined interrupt event handler established through the inter-spatial interrupt-bearing pipe between kernel and user spaces. There are proper reversing methods for unbinding the ISR from that interrupt and destroying the pipe instance. The class also includes several statistical members such as properties for obtaining system times at whose two recent interrupts are generated and properties for calculating the whole number of interrupts generated and directed to a user-defined interrupt event handler, if established. Each instance of this class contains singular instance of TkdInterruptPipe class, the former is being completely responsible for creation, activation, synchronization and destruction of the pipe encapsulated. Each instance of this class can also hold the whole set of interrupt acknowledgement actions, each of which is modelled by TkdInterruptAcknowledgement class. Although TkdInterrupt class has dozens of methods and properties, including those intended merely for design-time work, relevant members are documented only.
TkdInterruptAcknowledgementkdinterruptComplementary resource class TkdInterruptAcknowledgement models a single hardware interrupt acknowledgement action belonging to the whole hardware interrupt acknowledgement session. Each instance of this class is hosted at InterruptAcknowledgement list-oriented property and can be attached to and detached from it by AddInterruptAcknowledgement and DeleteInterruptAcknowledgement methods of the paternal instance of TkdInterrupt class. Concerning hardware interrupt acknowledgement, this class involves only a classic solution in the form of accessing a required hardware register related to some address range of hardware. It includes properties for specifying: a particular operation to undertake as a part of the whole acknowledgement session, a particular hardware register that has to be accessed , a particular value that has to be written to the register if the writing operation is specified. The whole acknowledgement session often consists of one or more serial acknowledgement actions. If your card's interrupt acknowledgement scheme can not be established by using the abilities of this class only, InterruptHandler property of the paternal instance of TkdInterrupt class with the outside documentation is at your disposal. Hardware interrupt acknowledgement with this class is only allowable and actual if the interrupt type specified is level-sensitive (PCI interrupt).
TkdInterruptPipekdinterruptComplementary class TkdInterruptPipe models the inter-spatial interrupt-bearing pipe between the GDD and the user-defined interrupt event handler. The class is constructively a CLX-based system thread initially fallen asleep and awakened by the GDD whenever a new hardware interrupt or a small group of frequent interrupts is generated. This is the time at that OnHwInterrupt event of the paternal instance of TkdInterrupt class is fired and the user-defined interrupt event handler established is run. Various interrupt-related data is also moves up to the user space to become accessible straight in a Kylix application via several statistical members of the paternal instance of TkdInterrupt class, such: as InterruptsGenerated, InterruptsDirected, InterruptLastTime, InterruptPreviousTime properties. The functional core of this class is accommodated in its Execute method overridden.
TkdMemoryRangekdrangesFinal resource class TkdMemoryRange models address ranges of hardware memory and is used to access I/O memory regions both directly-mapped to physical addresses and software-mapped, regardless of if these regions are low memory or high PCI buffers. In order to access the memory this class arranges for the specified range of physical addresses to be visible from the GDD - I/O remap operation. By excluding the ability to provide user programs with the direct access to device memory this class allows to advert to absolutely all memory-mapped devices from the whole 32-bit address space, even those not lending themselves to Linux mmap abstraction. The class redefines necessary methods of its parental class TkdHWRange to deal with the specificity of hardware memory and makes published all concerned properties it inherits.
TkdPCIConfigkdpcihdrResource class TkdPCIConfig is the ancestor for all components modelling different configuration spaces of PCI devices. All PCI devices (and, consequently, their configuration spaces) are subdivided into 3 classes: normal PCI devices (PCI non-bridges), PCI bridges, and PCI cardbus bridges. Device driving is a process of reading from and writing to three address spaces: memory, port and configuration. Thus, in particular, accessing the configuration space is vital to the driver because it is the only way it can find out where the device is mapped in memory and in port space. Configuration space is a specifically structured memory area that consists of registers and those overall layout looks like TPciCfg record. This record is 256 bytes long; the first 64 bytes is device general info depending on PCI device class; remaining 192 bytes is device specific info. This class introduces 12 properties for specifying and accessing the corresponding registers of configuration space common to all PCI devices. Also, this class introduces 3 additional properties for specifying PCI logical vector that represents: bus number, slot number and function number of PCI device. This vector resolves the situation that more than one PCI device with the same device identifier and vendor identifier is in the system.
TkdPCINonBridgekdpcihdrFinal resource class TkdPCINonBridge models configuration space of normal PCI device (PCI non-bridge). To the series of properties already inherited, this class adds a new one to access the corresponding registers of configuration space specific to non-bridge PCI devices. To observe the overall layout of that part of configuration space see TNonBridge subrecord of TPciCfg record. All concerned properties inherited are made published to accomplish the whole configuration space of normal PCI device.
TkdPortRangekdrangesFinal resource class TkdPortRange models address ranges of hardware ports and is used to access I/O port regions regardless of if a device is mapping its registers to a separate address space for I/O ports the periferal bus has or into a memory address region. Whatever the case, all address regions lent into the Linux concept of I/O ports on your PC are completely accessible. The class redefines necessary methods of its parental class TkdHWRange to deal with the specificity of hardware ports and makes published all concerned properties it inherits.
TkdRangekdrangesResource class TkdRange is the ancestor for all components modelling different address ranges which are either directly accessible through a virtual address assigned to a user process (descendants of TkdDirectMemoryRange class) or circumstantially accessible - by means of a proper remapping (TkdMemoryRange descendant of TkdHWRange class) or even port ranges. Whatever the case, the class encapsulates the fundamental behavior common to all ranges and introduces methods that can be overridden to examine the validity of bounds of the address range and reimplement the viewable representation of some published information concerned to the address range comprehension.
TkdResourcekdclxcoreResource class TkdResource is the ultimate ancestor for all components modelling hardware resources in KylixDriver Application Library. The class provides no specific members for actual hardware access, rather it represents a detailed framework that allows its descendants to equally establish their working sessions with the GDD and to have the opportunities to be plainly registered in the system. Although TkdResource class has dozens of methods and properties, relevant members are documented only.