book

Linux Device Driver Development - Second Edition

by John Madieu

April 2022

Beginner to intermediate

708 pages

14h 54m

English

Packt Publishing

Read now

Unlock full access

ContributorsAbout the authorAbout the reviewer
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchShare Your Thoughts
Setting up the development environmentSetting up the host machineGetting the sourcesConfiguring and building the Linux kernelSpecifying compilation optionsUnderstanding the kernel configuration processBuilding the Linux kernelBuilding and installing modulesSummary
An introduction to the concept of modulesCase study – module skeletonBuilding a Linux kernel moduleUnderstanding the Linux kernel build systemOut-of-tree buildingIn-tree buildingHandling module parametersDealing with symbol exports and module dependenciesAn introduction to the concept of module dependenciesLearning some Linux kernel programming tipsError handlingMessage printing – goodbye printk, long life dev_*, pr_*, and net_* APIsSummary
Linux kernel locking mechanisms and shared resourcesSpinlocksMutexesTrylock methodsDealing with kernel waiting, sleeping, and delay mechanismsWait queueSimple sleeping in the kernelKernel delay or busy waitingUnderstanding Linux kernel time managementThe concepts of clocksource, clockevent, and tick deviceUsing standard kernel low-precision (low-res) timersHigh-resolution timers (hrtimers) Implementing work-deferring mechanismsSoftirqsTaskletsWorkqueuesWorkqueues' new generationKernel interrupt handlingDesigning and registering an interrupt handlerSummary
The concept of major and minorCharacter device data structure introductionAn introduction to device file operationsFile representation in the kernelCreating a device nodeDevice identificationRegistration and deregistration of character device numbersInitializing and registering a character device on the systemImplementing file operationsExchanging data between the kernel space and user spaceImplementing the open file operationImplementing the release file operationImplementing the write file operationImplementing the read file operationImplementing the llseek file operationThe poll methodThe ioctl methodSummary
Understanding the basic concept of the device tree mechanismThe device tree naming conventionAn introduction to the concept of aliases, labels, phandles, and pathsUnderstanding overwriting nodes and properties Device tree sources and compilersRepresenting and addressing devicesHandling SPI and I2C device addressingMemory-mapped devices and device addressingHandling resourcesThe struct resourceExtracting application-specific dataSummary
Linux kernel platform abstraction and data structuresDevice base structureDevice driver base structureDevice/driver matching and module (auto) loadingDevice declaration – populating devicesBus structureDevice and driver matching mechanism explainedCase study – the OF matching mechanismSummary

Understanding the platform core abstraction in the Linux kernelDealing with platform devicesAllocating and registering platform devicesHow not to allocate platform devices to your codeWorking with platform resourcesPlatform driver abstraction and architectureProbing and releasing the platform devicesProvisioning supported devices in the driverDriver initialization and registrationExample of writing a platform driver from scratchSummary
I2C framework abstractions in the Linux kernelA brief introduction to struct i2c_adapterI2C client and driver data structuresI2C communication APIsThe I2C driver abstraction and architectureProbing the I2C deviceImplementing the i2c_driver.remove methodDriver initialization and registrationProvisioning devices in the driverInstantiating I2C devicesHow not to write I2C device driversSummary
Understanding the SPI framework abstractions in the Linux kernelBrief introduction to struct spi_controllerThe struct spi_device structureThe spi_driver structureThe message transfer data structuresAccessing the SPI deviceDealing with the SPI driver abstraction and architectureProbing the deviceProvisioning devices in the driverImplementing the spi_driver.remove methodDriver initialization and registrationInstantiating SPI devicesLearning how not to write SPI device driversSummary
An introduction to Linux kernel memory-related termsKernel address space layout on 32-bit systems – the concept of low and high memoryAn overview of a process address space from the kernelUnderstanding the concept of VMADemystifying address translation and MMUPage lookup and the TLBThe page allocatorThe slab allocatorkmalloc family allocationvmalloc family allocationA short story about process memory allocation under the hoodWorking with I/O memory to talk to hardwarePIO device accessMMIO device accessMemory (re)mappingUnderstanding the use of kmapMapping kernel memory to user spaceSummary
Setting up DMA mappingsThe concept of cache coherency and DMAMemory mappings for DMAIntroduction to the concept of completionWorking with the DMA engine's APIA brief introduction to the DMA controller interfaceHandling device DMA addressing capabilitiesRequesting a DMA channelConfiguring the DMA channelConfiguring the DMA transferSubmitting the DMA transferIssuing pending DMA requests and waiting for callback notificationPutting it all together – Single-buffer DMA mappingA word on cyclic DMAUnderstanding DMA and DT bindingsConsumer bindingSummary
Introduction to the Regmap data structuresUnderstanding the struct regmap_config structureHandling Regmap initializationUsing Regmap register access functionsBulk and multiple registers reading/writing APIsUnderstanding the Regmap caching systemRegmap-based SPI driver example – putting it all togetherA Regmap exampleLeveraging Regmap from the user spaceSummary
Brief presentation of interruptsUnderstanding interrupt controllers and interrupt multiplexingDiving into advanced peripheral IRQ managementUnderstanding IRQ and propagationChaining IRQsDemystifying per-CPU interruptsSGIs and IPIsSummary
Introduction to LDM data structuresThe bus data structureThe driver data structureThe device data structure Getting deeper inside LDMUnderstanding the kobject structureUnderstanding the kobj_type structureUnderstanding the kset structureWorking with non-default attributesOverview of the device model from sysfsCreating device-, driver-, bus- and class-related attributesMaking a sysfs attribute poll- and select-compatibleSummary
Introduction to IIO data structuresUnderstanding the struct iio_dev structureUnderstanding the struct iio_info structureThe concept of IIO channelsDistinguishing channelsPutting it all together – writing a dummy IIO driverIntegrating IIO triggered buffer supportIIO trigger and sysfs (user space)IIO buffersPutting it all togetherAccessing IIO dataSingle-shot captureAccessing the data bufferDealing with the in-kernel IIO consumer interfaceConsumer kernel APIWriting user-space IIO applicationsScanning and creating an IIO contextWalking through and managing IIO devicesWalking through and managing IIO channelsWorking with a triggerCreating a buffer and reading data samplesWalking through user-space IIO toolsSummary
Introduction to some hardware termsIntroduction to the pin control subsystemDealing with the GPIO controller interfaceWriting a GPIO controller driverGPIO controller bindingsGetting the most out of the GPIO consumer interfaceInteger-based GPIO interface – now deprecatedDescriptor-based GPIO interface: the new and recommended wayLearning how not to write GPIO client driversGoodbye to the legacy GPIO sysfs interfaceWelcome to the Libgpiod GPIO libraryThe GPIO aggregatorSummary
Introduction to the Linux kernel input subsystem – its data structures and APIsAllocating and registering an input deviceUsing polled input devicesGenerating and reporting input eventsHandling input devices from the user spaceSummary
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Content preview from Linux Device Driver Development - Second Edition

Section 4 - Misc Kernel Subsystems for the Embedded World

This section will touch upon the IIO framework, pin control and GPIO systems, and other important feature-rich concepts. In this section, you will also gain an in-depth understanding of GPIOs mapped to interrupts and their processing mechanisms, describing every kernel data structure and API involved. Finally, you’ll learn how to deal with input devices drivers. It goes without saying that user-space handlings of the enumerated subsystems will be introduced in this section as well.

The following chapters will be covered in this section: