Linux Device Drivers: Written by Industry Experts

Executive Summary: Bridging Physical Silicon & The Kernel

Operating system kernels cannot directly understand every physical component or expansion card attached to a computer system. Hardware device drivers serve as the critical translation layer, mapping custom silicon registers, interrupt lines, and memory buffers into uniform kernel data structures.

Linux Device Drivers is the authoritative 600-page engineering guide for hardware developers, embedded systems architects, and Linux driver authors. Spanning 8 technical modules, this handbook covers the entire spectrum of driver development: from low-level I/O port accessing and MMIO region mapping to PCI device probing, coherent DMA buffer management, USB endpoint handling, block queue handling, and NAPI network driver architecture.

Deep Dive: Advanced Driver Subsystems

The handbook provides operational C source code blueprints across five primary driver domains:

1. PCI/PCIe Bus Subsystem & BAR Mapping

Probing expansion cards and accessing Base Address Registers (BARs):

• PCI Driver Registration: Probing vendor/device ID tables via pci_register_driver() and enabling bus mastering with pci_set_master().
• MMIO Memory Mapping: Mapping physical BAR regions into kernel virtual address space using pci_iomap() and ioread32() / iowrite32() primitives.

2. Direct Memory Access (DMA) & Coherence

High-speed hardware-driven memory transfers bypassing CPU execution:

• Coherent DMA Buffers: Allocating un-cached, cache-coherent physical memory blocks using dma_alloc_coherent().
• Streaming DMA & Scatter-Gather: Mapping existing kernel buffers dynamically with dma_map_single() and handling multi-segment scatter-gather lists.

3. Network Card Drivers (`net_device`) & NAPI

Building high-speed network interfaces for 10GbE / 100GbE controllers:

• NAPI Polling: Preventing hardware interrupt storms under heavy traffic by switching from IRQ triggers to adaptive NAPI polling (`napi_schedule`).

Field Engineering: Complete PCI Driver C Module

Chapter 6 of the handbook provides practical C source code for a complete PCI bus device driver:

#include 
#include 
#include 

#define MMN_VENDOR_ID 0x8086 // Example Vendor ID
#define MMN_DEVICE_ID 0x100e // Example Device ID

MODULE_LICENSE("GPL");

static struct pci_device_id mmn_pci_tbl[] = {
    { PCI_DEVICE(MMN_VENDOR_ID, MMN_DEVICE_ID) },
    { 0, }
};
MODULE_DEVICE_TABLE(pci, mmn_pci_tbl);

static int mmn_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) {
    void __iomap *mmio_ptr;
    u32 reg_val;

    pr_info("mmn_pci: Probing PCI Device [%04x:%04x]\n", pdev->vendor, pdev->device);

    // Enable PCI Device & Bus Mastering
    if (pci_enable_device(pdev) < 0) return -ENODEV;
    pci_set_master(pdev);

    // Request & Map Memory BAR 0
    pci_request_region(pdev, 0, "mmn_pci_bar0");
    mmio_ptr = pci_iomap(pdev, 0, 0);

    // Read Control Register via MMIO
    reg_val = ioread32(mmio_ptr);
    pr_info("mmn_pci: MMIO BAR0 Register Value: 0x%08x\n", reg_val);

    pci_set_drvdata(pdev, mmio_ptr);
    return 0;
}

static void mmn_pci_remove(struct pci_dev *pdev) {
    void __iomap *mmio_ptr = pci_get_drvdata(pdev);
    pci_iounmap(pdev, mmio_ptr);
    pci_release_region(pdev, 0);
    pci_disable_device(pdev);
    pr_info("mmn_pci: Device Removed\n");
}

static struct pci_driver mmn_driver = {
    .name = "mmn_pci_driver",
    .id_table = mmn_pci_tbl,
    .probe = mmn_pci_probe,
    .remove = mmn_pci_remove,
};

module_pci_driver(mmn_driver);

#include 

void* alloc_dma_buffer(struct device *dev, size_t size, dma_addr_t *dma_handle) {
    void *virt_addr;

    // Allocate un-cached, cache-coherent physical memory buffer
    virt_addr = dma_alloc_coherent(dev, size, dma_handle, GFP_KERNEL);
    if (!virt_addr) {
        pr_err("[-] DMA Allocation Failed!\n");
        return NULL;
    }

    pr_info("[+] DMA Buffer Allocated. Virt: %p, Phys Handle: %pad\n", virt_addr, dma_handle);
    return virt_addr;
}

Complete Table of Contents & Module Syllabus

• Module 01 Driver Architecture & Major/Minor Device Registration

  Pages 1–75
  Dynamic allocation of major/minor device numbers (`alloc_chrdev_region`), cdev struct initialization, and class creation.
• Module 02 Advanced Character Drivers & User-Space Memory Copies

  Pages 76–150
  Implementing `file_operations` vectors (`read`/`write`/`mmap`), user memory safety (`copy_to_user`), and `ioctl` control.
• Module 03 Hardware Access: I/O Ports & Memory-Mapped I/O (MMIO)

  Pages 151–225
  Accessing hardware registers, port I/O (`inb`/`outb`), mapping MMIO space (`ioremap`), and atomic register reads (`ioread32`).
• Module 04 Interrupt Handling, IRQ Sharing & Hardware Service Routines

  Pages 226–300
  Registering hardware interrupts (`request_irq`), interrupt sharing (`IRQF_SHARED`), top/bottom halves, and SoftIRQs.
• Module 05 Direct Memory Access (DMA) & Coherent Allocations

  Pages 301–375
  Bus physical addresses vs virtual addresses, coherent DMA (`dma_alloc_coherent`), streaming DMA mappings, and scatter-gather.
• Module 06 PCI/PCIe Bus Subsystem & BAR Mapping

  Pages 376–450
  PCI device probing, reading Vendor/Device ID tables, enabling bus mastering (`pci_set_master`), and mapping BARs (`pci_iomap`).
• Module 07 USB Device Drivers & USB Request Block (URB) Processing

  Pages 451–525
  Interfacing with USB endpoints, allocating URBs (`usb_alloc_urb`), submitting USB transfers (`usb_submit_urb`), and completion callbacks.
• Module 08 Block Storage Drivers & Network Interfaces (`net_device`)

  Pages 526–600
  Block disk queues (`gendisk`), network interface registration (`alloc_etherdev`), socket buffer manipulation (`sk_buff`), and NAPI polling.

Who Should Read This Handbook?

This handbook is designed for hardware developers and Linux kernel engineers:

Verified Hardware Engineer Reviews

Frequently Asked Questions