book

Linux Device Drivers, Second Edition

by Jonathan Corbet, Alessandro Rubini

June 2001

Intermediate to advanced

592 pages

19h 20m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Alessandro’s Introduction

The Role of the Device Driver
Kernel Modules Versus ApplicationsUser Space and Kernel SpaceConcurrency in the KernelThe Current Process
Version DependencyPlatform Dependency
Error Handling in init_moduleThe Usage CountUnloadingExplicit Initialization and Cleanup Functions
I/O Ports and I/O MemoryPortsMemoryResource Allocation in Linux 2.4
Changes in Resource ManagementCompiling for Multiprocessor SystemsExporting Symbols in Linux 2.0Module Configuration Parameters
The Design of scull
Dynamic Allocation of Major NumbersRemoving a Driver from the Systemdev_t and kdev_t
The open MethodThe release Method
The read MethodThe write Methodreadv and writev
Using devfs in PracticePortability Issues and devfs
Changes in the File Operations StructureThe Module Usage CountChanges in Semaphore SupportChanges in Access to User Space
Debugging by PrintingprintkHow Messages Get LoggedTurning the Messages On and Off
Using the /proc FilesystemThe ioctl Method
Oops MessagesUsing klogdUsing ksymoopsSystem Hangs
Using gdbThe kdb Kernel DebuggerThe Integrated Kernel Debugger PatchThe kgdb PatchKernel Crash Dump AnalyzersThe User-Mode Linux PortThe Linux Trace ToolkitDynamic Probes
ioctlChoosing the ioctl CommandsThe Return ValueThe Predefined CommandsUsing the ioctl ArgumentCapabilities and Restricted OperationsThe Implementation of the ioctl CommandsDevice Control Without ioctl
Going to Sleep and AwakeningA Deeper Look at Wait QueuesWriting Reentrant CodeBlocking and Nonblocking OperationsA Sample Implementation: scullpipe
Interaction with read and writeReading data from the deviceWriting to the deviceFlushing pending outputThe Underlying Data Structure
The Driver’s Point of View
The llseek Implementation
Single-Open DevicesAnother Digression into Race ConditionsRestricting Access to a Single User at a TimeBlocking open as an Alternative to EBUSYCloning the Device on Open
Wait Queues in Linux 2.2 and 2.0Asynchronous NotificationThe fsync MethodAccess to User Space in Linux 2.0Capabilities in 2.0The Linux 2.0 select MethodSeeking in Linux 2.02.0 and SMP
Time Intervals in the KernelProcessor-Specific Registers
Long DelaysShort Delays
The Nature of Task QueuesHow Task Queues Are RunPredefined Task QueuesHow the examples workThe scheduler queueThe timer queueThe immediate queueRunning Your Own Task QueuesTasklets
The Real Story of kmallocThe Flags ArgumentMemory zonesThe Size Argument
A scull Based on the Slab Caches: scullc
A scull Using Whole Pages: scullp
A scull Using Virtual Addresses: scullv
Acquiring a Dedicated Buffer at Boot TimeThe bigphysarea PatchReserving High RAM Addresses
I/O Ports and I/O MemoryI/O Registers and Conventional Memory
String OperationsPausing I/OPlatform Dependencies
An Overview of the Parallel PortA Sample Driver
Directly Mapped MemoryReusing short for I/O MemorySoftware-Mapped I/O MemoryISA Memory Below 1 MBisa_readb and FriendsProbing for ISA Memory
Overall Control of Interrupts
The /proc InterfaceAutodetecting the IRQ NumberKernel-assisted probingDo-it-yourself probingFast and Slow HandlersThe internals of interrupt handling on the x86
Using ArgumentsEnabling and Disabling Interrupts
TaskletsThe BH MechanismWriting a BH Bottom Half
Installing a Shared HandlerRunning the HandlerThe /proc Interface
Using Circular BuffersUsing SpinlocksUsing Lock VariablesBit operationsAtomic integer operationsGoing to Sleep Without Races
Differences in the 2.2 KernelFurther Differences in the 2.0 Kernel
Use of Standard C Types
Time IntervalsPage SizeByte OrderData Alignment
Loading Modules on DemandRequesting Modules in the KernelThe User-Space SideModule Loading and SecurityModule Loading ExampleRunning User-Mode Helper Programs
Using Version Support in ModulesExporting Versioned Symbols
Registering the Driver
The Request QueuePerforming the Actual Data Transfer
The I/O Request QueueThe request structure and the buffer cacheRequest queue manipulationThe I/O request lockHow the blk.h macros and functions workClustered RequestsThe active queue headMultiqueue Block DriversDoing Without the Request Queue
check_media_changeRevalidationExtra Care
The Generic Hard DiskPartition DetectionPartition Detection Using initrdThe Device Methods for spull
Memory Management in LinuxAddress TypesHigh and Low MemoryThe Memory Map and struct pagePage TablesVirtual Memory Areas
Using remap_page_rangeA Simple ImplementationAdding VMA OperationsMapping Memory with nopageRemapping Specific I/O RegionsRemapping RAMRemapping RAM with the nopage methodRemapping Virtual Addresses
The kiobuf StructureMapping User-Space Buffers and Raw I/O
Overview of a DMA Data TransferAllocating the DMA BufferDo-it-yourself allocationBus AddressesDMA on the PCI BusDealing with difficult hardwareDMA mappingsSetting up consistent DMA mappingsSetting up streaming DMA mappingsScatter-gather mappingsHow different architectures support PCI DMAA simple PCI DMA exampleA quick look at SBusDMA for ISA DevicesRegistering DMA usageTalking to the DMA controller
Changes to Memory ManagementChanges to DMA
How snull Is DesignedAssigning IP NumbersThe Physical Transport of Packets
Module LoadingInitializing Each DeviceModule UnloadingModularized and Nonmodularized Drivers
The Visible HeadThe Hidden FieldsInterface informationThe device methodsUtility fields
Controlling Transmission ConcurrencyTransmission Timeouts
The Important FieldsFunctions Acting on Socket Buffers
Using ARP with EthernetOverriding ARPNon-Ethernet Headers
Kernel Support for MulticastingA Typical Implementation
Differences in Linux 2.2Further Differences in Linux 2.0Probing and HAVE_DEVLIST
The PCI InterfacePCI AddressingBoot TimeConfiguration Registers and InitializationAccessing the Configuration SpaceLooking at a configuration snapshotAccessing the I/O and Memory SpacesPCI I/O resources in Linux 2.4Peeking at the base address registersPCI InterruptsHandling Hot-Pluggable DevicesThe pci_driver structureHardware Abstractions
Hardware ResourcesISA ProgrammingThe Plug-and-Play Specification
MCAEISAVLB
USBWriting a USB Driver
Booting the Kernel
drivers/chardrivers/blockdrivers/idedrivers/mddrivers/cdromdrivers/scsidrivers/netdrivers/sounddrivers/videodrivers/inputdrivers/mediaBus-Specific DirectoriesPlatform-Specific DirectoriesOther Subdirectories
Linux Kernel BooksUnix Design and Internals

Content preview from Linux Device Drivers, Second Edition

Other PC Buses

PCI and ISA are the most commonly used peripheral interfaces in the PC world, but they aren’t the only ones. Here’s a summary of the features of other buses found in the PC market.

MCA

Micro Channel Architecture (MCA) is an IBM standard used in PS/2 computers and some laptops. The main problem with Micro Channel is the lack of documentation, which has resulted in a lack of Linux support for MCA up until recently.

At the hardware level, Micro Channel has more features than ISA. It supports multimaster DMA, 32-bit address and data lines, shared interrupt lines, and geographical addressing to access per-board configuration registers. Such registers are called Programmable Option Select, or POS, but they don’t have all the features of the PCI registers. Linux support for Micro Channel includes functions that are exported to modules.

A device driver can read the integer value MCA_bus to see if it is running on a Micro Channel computer, similar to how it uses pci_present if it’s interested in PCI support. If the symbol is a preprocessor macro, the macro MCA_bus__is_a_macro is defined as well. If MCA_bus__is_a_macro is undefined, then MCA_bus is an integer variable exported to modularized code. Both MCA_BUS and MCA_bus__is_a_macro are defined in <asm/processor.h>.

EISA

The Extended ISA (EISA) bus is a 32-bit extension to ISA, with a compatible interface connector; ISA device boards can be plugged into an EISA connector. The additional wires are routed under the ...