Chapter 1. An Introduction to Device Drivers
One of the many advantages of free
operating systems, as typified by Linux, is that their internals are
open for all to view. The operating system, once a dark and
mysterious area whose code was restricted to a small number of
programmers, can now be readily examined, understood, and modified by
anybody with the requisite skills. Linux has helped to democratize
operating systems. The Linux kernel remains a large and complex body
of code, however, and would-be kernel hackers need an entry point
where they can approach the code without being overwhelmed by
complexity. Often, device drivers provide that gateway.
Device drivers take on a special role in the Linux kernel. They are
distinct "black boxes" that make a
particular piece of hardware respond to a well-defined internal
programming interface; they hide completely the details of how the
device works. User activities are performed by means of a set of
standardized calls that are independent of the specific driver;
mapping those calls to device-specific operations that act on real
hardware is then the role of the device driver. This programming
interface is such that drivers can be built separately from the rest
of the kernel and "plugged in" at
runtime when needed. This modularity makes Linux drivers easy to
write, to the point that there are now hundreds of them available.
There are a number of reasons to be interested in the writing of
Linux device drivers. The rate at which new hardware becomes
available (and obsolete!) alone guarantees that driver writers will
be busy for the foreseeable future. Individuals may need to know
about drivers in order to gain access to a particular device that is
of interest to them. Hardware vendors, by making a Linux driver
available for their products, can add the large and growing Linux
user base to their potential markets. And the open source nature of
the Linux system means that if the driver writer wishes, the source
to a driver can be quickly disseminated to millions of users.
This book teaches you how to write your own drivers and how to hack
around in related parts of the kernel. We have taken a
device-independent approach; the programming techniques and
interfaces are presented, whenever possible, without being tied to
any specific device. Each driver is different; as a driver writer,
you need to understand your specific device well. But most of the
principles and basic techniques are the same for all drivers. This
book cannot teach you about your device, but it gives you a handle on
the background you need to make your device work.
As you learn to write drivers, you find out a lot about the Linux
kernel in general; this may help you understand how your machine
works and why things aren't always as fast as you
expect or don't do quite what you want. We introduce
new ideas gradually, starting off with very simple drivers and
building on them; every new concept is accompanied by sample code
that doesn't need special hardware to be tested.
This chapter doesn't actually get into writing code.
However, we introduce some background concepts about the Linux kernel
that you'll be glad you know later, when we do
launch into programming.
|