Écrire des pilotes de périphériques simples

Imagine your computer's operating system (OS) needs to talk to a printer. How does it know how to send print jobs, check ink levels, or handle paper jams?

This is where device drivers come in! They are special software programs that act as translators, allowing the OS to communicate with hardware devices.

To understand drivers, we need to recall privilege levels. Most applications run in user space (less privileged), but drivers operate in kernel space (highly privileged).

• User Space: Where your everyday apps run. Limited direct hardware access.
• Kernel Space: Where the OS core and drivers run. Full, direct access to hardware. This is crucial for controlling devices.

A device driver's main job is to:

• Translate Requests: Convert high-level requests from the OS (e.g., 'read data from disk') into low-level commands the hardware understands.
• Manage Hardware: Control the device's operations, handle data transfer, and respond to hardware events (like an interrupt when data is ready).
• Resource Allocation: Manage memory, I/O ports, and other resources the device needs.

Most modern device drivers, especially in Linux, are implemented as kernel modules. These modules have a common structure, typically in C, with specific entry and exit points.

Key components:

• An initialization function, called when the driver loads.
• An exit function, called when the driver unloads.
• A set of file operations, defining how user applications interact with the device.

When a driver module is loaded into the kernel, its initialization function is executed. This function is typically registered using the module_init macro.

What happens here?

• Registering the device with the kernel.
• Allocating any necessary memory or resources.
• Performing initial hardware setup.

Here's a conceptual C skeleton:

When a driver module is unloaded (or the system shuts down), its exit function is called. This function is registered with the module_exit macro.

Its purpose is to clean up everything the initialization function set up:

• Unregistering the device.
• Releasing all allocated memory and resources.
• Putting the hardware into a safe state.

Conceptual C skeleton:

From a user-space perspective, interacting with a device driver often feels like interacting with a regular file. For example, you might see a device file like /dev/mydevice.

Applications use standard system calls like open(), read(), write(), and close() on these device files. The driver implements the actual logic for these operations.

A common type of driver is a character device. It handles data as a stream of bytes (like a keyboard or serial port). Drivers define a file_operations structure that points to the actual functions for open, read, write, etc.

Here's a simplified C skeleton for a character device driver, showing how these pieces fit together:

Ultimately, drivers need to talk directly to hardware. There are two primary ways:

• I/O Ports: Special addresses (e.g., 0x3F8 for serial) used to send commands to and receive data from devices. This is common for older or simpler hardware.
• Memory-Mapped I/O (MMIO): Device registers are mapped directly into the CPU's memory address space. The CPU accesses them using regular memory load/store instructions, just like RAM. This is more common in modern systems.

We'll dive deeper into direct hardware interaction in the next lesson!

Which of the following are key roles or characteristics of a device driver?

In this lesson, we explored the fundamentals of device drivers:

• Drivers are essential software that enable the OS to communicate with hardware.
• They operate in privileged kernel space.
• Their core functions include translating requests, managing hardware, and allocating resources.
• We saw the basic structure of a Linux kernel module with module_init, module_exit, and file_operations.
• We touched upon I/O ports and MMIO as methods for hardware interaction.

Next, we'll dive deeper into how drivers directly interface with hardware using these methods!