Understanding Device Drivers

November 16,18,28 by Bina

Project Report

Introduction

A device driver is computer program that allows a system to interface with hardware devices.
Example driver: printer driver, bluetooth driver, IoT driver
Example devices: your USB stick, sensors: accelerometer
It is a translator between the operating system and applications the use the devices and the devices.
A typical operating system has many device drivers built into it. A device driver converts general IO instructions into device specific operations.
Device drivers operate in a privileged mode requires careful design

Motivation for device driver?

1. A typical computing system (lap top, computer, cell phone, PDA, Point of sale system) deals with a variety of devices.
2. Making a hardware device work as expected is a cumbersome task.
3. Instead adding this code every application, operating system provides a single point interface for all devices by hosting the device drivers.
4. Adding it under the operating systems provides the protection and security needed for the device drivers from malicious use.
5. The device drivers are essentially shared dynamically linked libraries.

Device Driver

What do you with a device? {read, write}, {read only}, {write only}
Lets look at some examples: USB device, CD-ROM, LED Display,
What do you do with a file? open, close, read, write, ..
File is an excellent abstraction for devices.

Illustrative dev directory

total 380
lrwxrwxrwx   1 root           30 Mar  7  2004 allkmem -> ../devices/pseudo/mm@0:
allkmem
lrwxrwxrwx   1 root           27 Aug 15  2001 arp -> ../devices/pseudo/arp@0:arp
lrwxrwxrwx   1 root            7 Aug 15  2001 audio -> sound/0
lrwxrwxrwx   1 root           10 Aug 15  2001 audioctl -> sound/0ctl
lrwxrwxrwx   1 root           11 Oct  4 03:06 bd.off -> /dev/term/b
drwxr-xr-x   2 root          512 Aug 17  2001 cfg
lrwxrwxrwx   1 root           31 Aug 15  2001 conslog -> ../devices/pseudo/log@0
:conslog
lrwxrwxrwx   1 root           30 Aug 15  2001 console -> ../devices/pseudo/cn@0:
console
drwxr-xr-x   2 root          512 Aug 15  2001 cua
drwxr-xr-x   2 root         2048 Aug 31  2002 dsk
lrwxrwxrwx   1 root           29 Aug 15  2001 dump -> ../devices/pseudo/dump@0:d
ump
lrwxrwxrwx   1 root           50 Aug 15  2001 ecpp0 -> ../devices/pci@1f,4000/eb
us@1/ecpp@14,3043bc:ecpp0
lrwxrwxrwx   1 root            8 Aug 15  2001 fb0 -> fbs/ffb0
drwxr-xr-x   2 root          512 Aug 15  2001 fbs
dr-xr-xr-x   2 root          528 Nov  9 11:51 fd
lrwxrwxrwx   1 root           30 Apr  7  2002 fssnapctl -> ../devices/pseudo/

Device Space

Typically there are multiple devices of the same type. All the devices controlled by the same device driver is given the same “major number” A “minor number” distinguishes among the devices of the same type. Example: printers have a major number since purpose is same, minor# is denote a specific printer

Device Driver Philosophy

Hide the hardware completely: hardware abstraction
If the device generates any interrupts include interrupt controllers.
Device driver presents a generic interface for applications at higher level to access the devices: device.h
Device drivers in embedded systems are different from general purpose operating systems: See diagram on the sidebar.
Applications in general purpose systems accesses OS (Operating Systems) which in turn accesses device drivers.
Applications in embedded systems can directly access device drivers.

Device Driver Development Steps

1. An interface to the control and status registers.
2. Variables to track the current state of the physical and logical devices
3. Major and minor device number, device name
4. A routine to initialize the hardware to known state
5. An API for users of the device driver -- Read, write, seek
6. Interrupts service routines

Xinu Serial Device Driver

Now lets look at the UARTdriver of the embedded xinu and WRT54GL. Study the tty driver that is a logical device that is layered on top of the UART driver. Discuss how you would develop a device driver for a framebuffer.. This was a lab2 last year.

Take a look at files in the include directory: device.h, tty.h, uart.h
Also in the system directory devtable.c, initialize.c
Bottom line is this, for a device xyz:

1. Include a file in include directory: xyz.h -- define the operations/functions for the device
2. Add a directory xyz -- implement all functions each in its own file
3. Add an entry in the devtable.c for the device (note that this has the “minor” device number along with other things)

Lets Understand UART Driver

Starting point: uart.h in include directory
uart directory functions
system directory devtable.c, initialize.c
Usage of the devices is through device table:
Ex: pdev = &devtab[i]; (pdev->init)(pdev);

General device driver related files: device.h, devtable.c
Uart files: uart.h defining the physical features of the uart
All the files in the uart directory that implement the operations related to the uart.

uartControl.c   uartInit.c uartIntr.c  
uartPutChar.c   uartWrite.c  uartGetChar.c uartRead.c

On board devices are called internal peripherals and one outside are called external peripherals
UART Chip (internal)
TTY (external)
UART-> transceiver ->RS232 ->D-9 connector -> laptop serial socket

See the sidebar for WRT54GL board and modifications.

Embedded processor interacts with a peripheral device through a set of control and status registers. Registers are part of the peripheral device. These devices are located in the memory space of the processor or I/O space of the processor-- two types: memory-mapped or I/O mapped respectively.

The keyword volatile should be used when declaring pointers to device drivers. Bit patterns for testing, setting, clearing, toggling, shifting bits, bitmasks, and bitfields. Struct overlays: In embedded systems featuring memory mapped IO devices, it is common to overlay a C struct on to each peripheral’s control and status registers. This will provide the offsets for the various registers from the base address of the device.

Xinu Code Modification

Here the xinu code with modifications to include a framebuffer as a shell command.