DEVICE DRIVER ::A device driver is a software, it’s not a hardware. A driver is a code which is completely specific to a hardware device and brings all the functionality to it. Without a driver in OS environment an application can’t make use of the hardware functionalities. Driver has to be in the kernel space in the case of monolithic kernel. It has to be in the privileged environment, it is so because in the privileged space/kernel space only the driver code has the ability to perform operations on the hardware. This kind of code can also be written for micro controllers where there is no OS.
Applications reside in a non privileged environment and have to rely on services provided by drivers to access the hw. This is done to reduce complexity and making the use of information hiding that is encapsulating and providing abstraction, so as to make the applications easier and safer to write in less time. In linux the drivers are the kernel services to access the hw functionalities.

OS KERNEL :: The operating system is not what you see on your display device or your monitor. The operating system consists of a kernel(the soul of your system), shell and utility programs or api to
access services and interacting with the hardware. The most important part rather the soul of an operating system is it’s kernel. The kernel’s job is to manage memory, do task scheduling, bring functionality to the device through device drivers and provide services for interprocess communication.
The kernel may be MONOLITHIC or a MICRO KERNEL. A monolithic kernel is a kernel where every part of the it is just build into it as a unit and has a disadvantage that if any thing goes wrong with any part of the kernel code that may be for example a device driver code trying to dereference an invalid address the whole SYSTEM crashes. Micro kernels have an advantage over this, as the device drivers and rest of the kernel services lie out side the kernel space and kernel just supervises each of the operations as a server and whole of the kernel is based on CLIENT AND SERVER computing model. Thus the kernel has less probability to crash.

DEVICE DRIVERS :: We use peripheral devices. These are the mouse, keyboard, printer, Network devices to send and receive network information. These devices are not directly connected to the cpu through a bus, they are first connected to a controller or a bridge device (Device IO controller) through a bus that is referred to as peripheral bus. The device IO controller may be UART controller, USB controller, VGA controller, NETWORK controller etc. This controller is again further connected to the processor through the controller bus (in case of a PC set up).
Example :: USB is a peripheral bus and PCI is a controller bus.

DEVICE DRIVER LOGIC :: We cannot directly perform operations on the device as we have the device controller in between. We need to give commands to the controller. Then on behalf of the our code the controller will do the job. Thus our first issue is to send commands to the controller according to the functionalities offered by the device. We must know what all operations this device can support or simply options on the device.
Thus our driver code is broken up into two parts ::

#1 Low Level Driver (LLD):: Interfacing with the controller.(This code remains the same for a specific controller)

#2 High Level Driver (HLD) :: Code specific to the peripheral device functionality.(Without the knowledge of which device you are talking we can’t write this code.)

Interfacing with the controller is called the low level drive. The low level drivers provide the code to interact with the controllers. The high level drivers are only about what to execute on the device.

We need this kind of division because there are different controllers on different architectures. The usb controller for example may be different on different on different boards. If we mix both HLD and LLD in one code our driver will never be portable, will not be able to reuse our code. But if we divide this logically the HLD can remain same while the LLD can differ. The HLD must remain absolutely controller independent and reusable.

To make HLD independent of hw we hide the details of LLD and call it BUS MANAGER. The bus manager is similar to the virtual file system which is an abstraction hiding all the complexities of othe file systems.

Writing low level driver is writing board bring up driver. We have two domains of device driver community BSP driver community and and PERIPHERAL driver community. Simply BSP driver community write LLD and PERIPHERAL driver community write HLD.

In PC domain we don’t really have to worry about the LLD because it comes along with the kernel sources. But in the embedded domain we may have write a little bit of LLD.

HIGH LEVEL DRIVERS :: The high level drivers or the peripheral device drivers reside in the kernel space. The applications are in the user space which use these drivers. Now we have to provide an interface through which the applications can request like do this operation do that operation. Also we communicate with the hard ware which done through the API of low level driver. Now writing this driver is also broken down into two parts.

#1 Interfacing with the application.(This code is specific to design of kernel)(SYS CALLS in Linux)
#2 Interaction with hardware.(This code is specific to bus manager)

Exploring the interaction with hardware requires the reading and understanding of kernel sources.

Linux provides three different approaches for writing interfacing with the application.
Linux Driver Classes =
#1 CHARACTER DRIVER MODEL
#2 BLOCK DRIVER MODEL
#3 NETWORK DRIVER MODEL

The approach we choose depends upon two factors.
#1 Synchronous communication.
#2 Asynchronous communication.

Asynchronous means :: An application will not directly interact with the driver instead it will submit a request and go back. The driver will then carry out the operations. Application will either poll for the operation to be done or the driver will send a signal to the application that the job is done.

Synchronous means :: An application will make a call to a function and wait for it to return.

Example :: A char driver can be for pci bus, it can be on usb bus and so on.

Ankit

15/02/11

There are three types of buses :-

#1 Data Bus. (Bidirectional)

# 2 Address Bus. (Unidirectional)

#3 Control Bus. (Unidirectional)

The data bus is used for carrying data in and out from the CPU. The data bus determines the performance of the CPU, more the data lines in a data bus better is the CPU. The average size of data bus varies from 8 bit to 64 bit.

The address bus is used to identify the device and memory connected to CPU. If CPU wants to communicate with device or a memory, it just loads its address on the address bus and device or location having that add becomes active.

The control bus is used for sending control signal to the addressed device or memory for performing read and write operations at that location.

-> Iterate through scull_qsets

-> for(*s_q=s_d->data;s_q;s_q=next)

-> In every iteration

-> Free the quantums

-> Finaly free the qset array

-> Make pointer to qset as NULL

-> Free scull_qset

-> Finally initialize the default values

We never initialized struct cdev. Still we were very much able to call all the functions mapped in the file_operatins structure using fop.

Why we have to initialize it in the case of alloc_chardev_region
or register_chardev_region ???? Will these function not work ,if we dont initialize cdev in this case.

Why struct cdev is so nessary.

new_mod-objs := new.o

else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
$(MAKE)  -C $(KERNELDIR) M=$(PWD) modules
@rm -rf ${INSTALL_DIR}
@mkdir ${INSTALL_DIR}
@mv -f *.o *.ko *.mod.c .*.cmd ${INSTALL_DIR}
clean:
rm -rf ${INSTALL_DIR}
endif

char * allocate(unsigned char  );
char * allocate(unsigned char j)
{
if(arr+SIZE-p>j)
{
p=p+j;
return p-j;
}
else
{
printf(“Error in size\n”);
return NULL;
}
}
int main()
{
int *j;
char *l;
j=(int *)allocate(sizeof(int));
if(!j)
printf(“Error\n”);
*j=67;
l=(char *)allocate(sizeof(char));
*l=77;
printf(“%d %d\n”,*j,sizeof(*l));
return 0;
}

Basic Hardware

# Main memory and the processor’s registers build into the cpu memory is what cpu can access directly.
# There are machine instructions that take memory addresses as arguments.?? What are those instructions like.
# Thus any instruction in execution or any data used by these instructions must be in any of these (direct-access)storage devices. If they are not they have to moved before cpu can operate them.
# The registers that are build into the cpu are accessible in one cycle of the cpu clock.
# Most cpu’s can decode the instructions in registers and perform simple operations at the rate of one operation per clock tick. This is not the case for the main memory which is held via memory bus.
# The memory access may take many cycles to complete during which the processor has to stall. In the case of main memory.
# The remedy is install a fast memory b/w cpu and main memory called cache.
# The issues are more than this, like protecting the os from the user process.
# This protection is provided by the hardware.
# We need to make sure each process has a separate memory space.
# This can be done by using base and limit register.
# The base register holds the smallest legal phy add. and the limit register holds size of the range.
# The hw protection is obtained by comparison bw these registers.
# If add beyond or below is issued a fatal error is a result of this.
# These registers can only be loaded by kernel.
# The os is only allowed to do such modifications.Thus allowing it dump the code in case of errors.

Address Binding

# The process that are waiting to be brought for the execution form the input queue.
# As the process executes it accesses the data and the instructions from the memory.
# After this its memory space becomes available.
# Many os allow process to reside any where in the memory.
# Add. in the source program are generally symbolic.
# The compiler binds these symbolic add to relocatable add.

Logical vs physical add.

# The add generated by the cpu is generally called the logical add.
# But the add in the memory is generally referred to as physical add.
# In the execution time the add can be referred to as logical add.
# The set of all logical add generated by the program is called the logical add space.
# The set of all physical add corresponding to these logical add is called physical add space.
# In the run time the logical to physical add is done by a hardware called MMU(memory management unit).
# The very basic example is of ms-dos which uses relocation register .
# In relocation register each add is added with the relocation value to form the phy add.
# The program never sees the real add. It can have a pointer pointing to 346 and can do what ver with it ie. add compare.

What is the current scenario ???