book

Linux Device Driver Development - Second Edition

Name: Linux Device Driver Development - Second Edition
Author: John Madieu
ISBN: 9781803240060

by John Madieu

April 2022

Beginner to intermediate

708 pages

14h 54m

English

Packt Publishing

Read now

Unlock full access

Linux Device Driver Development Second Edition
ContributorsAbout the authorAbout the reviewer
Preface
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
Section 1 -Linux Kernel Development Basics
Chapter 1: Introduction to Kernel Development
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
Chapter 2: Understanding Linux Kernel Module Basic Concepts
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
Chapter 3: Dealing with Kernel Core Helpers
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
Chapter 4: Writing Character Device Drivers
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
Section 2 - Linux Kernel Platform Abstraction and Device Drivers
Chapter 5: Understanding and Leveraging the Device Tree
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
Chapter 6: Introduction to Devices, Drivers, and Platform Abstraction
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

Chapter 7: Understanding the Concept of Platform Devices and Drivers
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
Chapter 8: Writing I2C Device Drivers
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
Chapter 9: Writing SPI Device Drivers
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
Section 3 - Making the Most out of Your Hardware
Chapter 10: Understanding the Linux Kernel Memory Allocation
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
Chapter 11: Implementing Direct Memory Access (DMA) Support
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
Chapter 12: Abstracting Memory Access – Introduction to the Regmap API: a Register Map Abstraction
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
Chapter 13: Demystifying the Kernel IRQ Framework
Brief presentation of interruptsUnderstanding interrupt controllers and interrupt multiplexingDiving into advanced peripheral IRQ managementUnderstanding IRQ and propagationChaining IRQsDemystifying per-CPU interruptsSGIs and IPIsSummary
Chapter 14: Introduction to the Linux Device Model
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
Section 4 - Misc Kernel Subsystems for the Embedded World
Chapter 15: Digging into the IIO Framework
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
Chapter 16: Getting the Most Out of the Pin Controller and GPIO Subsystems
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
Chapter 17: Leveraging the Linux Kernel Input Subsystem
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
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Content preview from Linux Device Driver Development - Second Edition

Chapter 14: Introduction to the Linux Device Model

Until version 2.5, the Linux kernel had no way to describe and manage objects, and its code reusability was not as enhanced as it is now. In other words, there was no device topology, nor organization as we know it is in sysfs nowadays. There was no information on subsystem relationships, nor on how the system is put together. Then came the Linux Device Model (LDM), which introduced the following features:

The concept of classes. They are used to group devices of the same type or that expose the same functionalities (for example, mice and keyboards are both input devices).
Communication with the user space through a virtual filesystem, allowing you to manage and enumerate devices and the properties ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781803240060

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Linux Device Driver Development - Second Edition

by John Madieu

Chapter 14: Introduction to the Linux Device Model

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.