Linux Device Drivers (3rd Edition) [Electronic resources] نسخه متنی

Chapter 10. Interrupt Handling

Although some devices can be controlled using nothing but their I/O
regions, most real devices are a bit more complicated than that.
Devices have to deal with the external world, which often includes
things such as spinning disks, moving tape, wires to distant places,
and so on. Much has to be done in a time frame that is different
from, and far slower than, that of the processor. Since it is almost
always undesirable to have the processor wait on external events,
there must be a way for a device to let the processor know when
something has happened.

That way, of course, is interrupts. An interrupt
is simply a signal that the hardware can send when it wants the
processor's attention. Linux handles interrupts in
much the same way that it handles signals in user space. For the most
part, a driver need only register a handler for its
device's interrupts, and handle them properly when
they arrive. Of course, underneath that simple picture there is some
complexity; in particular, interrupt handlers are somewhat limited in
the actions they can perform as a result of how they are run.

It is difficult to demonstrate the use of interrupts without a real
hardware device to generate them. Thus, the sample code used in this
chapter works with the parallel port. Such ports are starting to
become scarce on modern hardware, but, with luck, most people are
still able to get their hands on a system with an available port.
We'll be working with the short
module from the previous chapter; with some small additions it can
generate and handle interrupts from the parallel port. The
module's name, short, actually
means short int (it is C, isn't
it?), to remind us that it handles interrupts.

Before we get into the topic, however, it is time for one cautionary
note. Interrupt handlers, by their nature, run concurrently with
other code. Thus, they inevitably raise issues of concurrency and
contention for data structures and hardware. If you succumbed to the
temptation to pass over the discussion in Chapter 5, we understand. But we also
recommend that you turn back and have another look now. A solid
understanding of concurrency control techniques is vital when working
with interrupts.