A device driver, often called a driver for short, is a computer program that enables another program (typically, an operating system) to interact with a hardware device. Think of a driver as a manual that gives the operating system (e.g., Windows, Linux) instructions on how to use a particular piece of hardware.
Because of the diversity of modern hardware and operating systems, many ways exist in which drivers can be used. Drivers are used for interfacing with:
Implementing an interface for non-driver software (e.g. TWAIN)
Implementing a language, sometimes quite high-level, e.g. PostScript
Writing a device driver is considered a challenge in most cases, as it requires an in-depth understanding of how a given platform functions, both at the hardware and the software level. In contrast to most types of user-level software running under modern operating systems, which can be stopped without greatly affecting the rest of the system, a bug in a device driver means in many cases that the whole system can stop functioning in a way which can severely damage the data or even the hardware of the computer system. Moreover, debugging device drivers is a difficult skill as it often involves monitoring hardware itself - which by definition behaves in a non-deterministic way.
All of this means that the people most likely to write device drivers come from the companies that develop the hardware - since they have more complete access to information about the design of their hardware than most outsiders. Moreover, it was traditionally considered in the hardware manufacturer's interest to guarantee that their clients would be able to use their hardware in an optimum way. However, in recent years non-vendors too have written numerous device drivers, mainly for use under free operating systems. In such cases, co-operation on behalf of the vendor is still important, however, as reverse engineering is much more difficult with hardware than it is with software, meaning it may take a long time to learn to operate hardware that has an unknown interface.
Typically this constitutes an interface for communicating with the device, through the specific computer bus or communications subsystem that the hardware is connected to, providing commands to and/or receiving data from the device, and on the other end, the requisite interfaces to the operating system and software applications.
Writing a devicedriver is considered a challenge in most cases, as it requires an in-depth understanding of how a given platform functions, both at the hardware and the software level.
The KMDF Kernel ModeDriver Framework model continues to allow development of kernel-modedevicedrivers, but attempts to provide standard implementations of functions that are well known to cause problems, including cancellation of I/O operations, power management, and plug and play device support.
These devicedrivers were ported to both IA64 and AMD64 platforms, and the code tree was modified to build the binaries for the different platforms from a single set of source code.
The updated driver also provides an interface to both insert keyboard and mouse data into the input data stream, and to suppress data coming from keyboards and mice attached to the system allowing an external application to control the keyboard and mice data passed on by the driver.
The devicedriver was modified in such a way that it could auto-detect updated and legacy boards and handle both correctly from within a single driver.
Feeds |
Contact