When Unix was written 25 years ago, its design was eclectic. One unusual design feature was that every physical device connected to the computer was represented as a file. This was a bold decision, because many devices are very different from one another, especially at first glance. Why use the same interface to talk to a printer as to talk to a disk drive?

The short answer is that while the devices are very much different, they can be thought of as having most of the same characteristics as files. The entire system is then kept smaller and simpler by only using one interface with a few extensions.

This is fine, except that it hides important differences between devices. For example, it is possible to read any byte on a disk at any time, but it is only possible to read the next byte from a terminal.

There are other differences, but this is the most fundamental one: Some devices (like disks) are random-access, and others (like terminals) are sequential-access. Of course, it is possible to pretend that a random-access device is a sequential-access device, but it doesn’t work the other way around.

A practical effect of the difference is that file systems can only be mounted on block devices, not on character ones. For example, most tapes are character devices. It is possible to copy the contents of a raw, quiescent (unmounted and not being modified) file system to a tape, but you will not be able to mount the tape, even though it contains the same information as the disk.

Most textbooks and tutorials start by explaining character devices, the sequential-access ones, because a minimal character device driver is easier to write than a minimal block device driver. My own Linux Kernel Hackers’ Guide (the KHG) is written the same way.

My reason for starting this column with block devices, the random-access devices, is that the KHG explains simple character devices better than it does block devices, and I think that there is a greater need for information on block devices right now. Furthermore, real character device drivers can be quite complex, just as complex as block device drivers, and fewer people know how to write block device drivers.

I am not going to give a complete example of a device driver here. I am going to explain the important parts, and let you discover the rest by examining the Linux source code. Reading this article and the ramdisk driver (drivers/block/ramdisk.c), and possibly some parts of the KHG, should make it possible for you to write a simple, non-interrupt-driven block device driver, good enough to mount a filesystem on. To write an interrupt-driven driver, read drivers/block/hd.c, the AT hard disk driver, and follow along. I’ve included a few hints in this article, as well.

The Heart of the Driver

Whereas character device drivers provide procedures for directly reading and writing data from and to the device they drive, block devices do not. Instead, they provide a single request() procedure which is used for both reading and writing. There are generic block_read() and block_write() procedures which know how to call the request() procedure, but all you need to know about those functions is to place a reference to them in the right place, and that will be covered later.

The request() procedure (perhaps surprisingly for a function designed to do I/O) takes no arguments and returns void. Instead of explicit input and return values, it looks at a queue of requests for I/O, and processes the requests one at a time, in order. (The requests have already been sorted by the time the request() function reads the queue.) When it is called, if it is not interrupt-driven, it processes requests for blocks to be read from the device, until it has exhausted all pending requests. (Normally, there will be only one request in the queue, but the request() procedure should check until it is empty. Note that other requests may be added to the queue by other processes while the current request is being processed.)

On the other hand, if the device is interrupt-driven, the request() procedure will usually schedule an interrupt to take place, and then let the interrupt handling procedure call end_request() (more on end_request() later) and then call the request() procedure again to schedule the next request (if any) to be processed.

C is the most powerful programming language in the software development world. You can do whatever you want to do regarding development then go through the C language. You can’t even imagine the depth of C language. And the most powerful tool of the C is Pointer. If you are master in the Pointer you can be the master of C language.

So, now your curiosity is some questions arising in your mind, like:

1. Why Pointer are that much powerful tool?, When we can use the Pointers in our program?

2. How Pointer works?

3. How Pointers can increase the efficiency and decrease the length of our program?

 Here are the answers of these question.

Definition of Pointers-: The simple definition of Pointer is the variable which holds the address in memory of some other variable. You can understand this like a arrow pointing towards your home and on the arrow your address is print means the arrow holding the address of your home, and your home is the variable. This Lehman definition will help you to understand what is pointer.

 The declaration of Pointer is as follows:

                   int *pointer;

Here’s the pointer is a variable which is integer type, and * sign is actually an operator to DE-reference a pointer. The only time it means “hey I’m a pointer” is during variable declaration.

And how it holds the address:

                int *pointer;

                int a;

             pointer = &a;

Here, & ampersand sign specify the address of the variable.

In the above expression, variable a is the integer type and pointer is holding the address of a with the help of & sign. The data type int shows, 4 bytes of data the variable stored in.

Pointers in Array-:

Arrays are continuous block of memory holds multiple objects and the type of objects are specified. An array variable is constant. You can’t assign a pointer to an array variable, even if the pointer variable actually points to the same or a different array. You also cannot assign one array variable to another. You can assign an array variable to a pointer though and that is where things get confusing. When assigning the array to the pointer we are actually assigning the address of the first element in the array to the pointer.

 int a[4] = {1,2,3};

int *pointer = a;

printf(“*pointer=%d\n”, *pointer);

 Firstly we initialize the array of integer type. After this we initialize the integer pointer and assign the array variable to it. Since the array variable actually is the memory address of the first element in the array, we have assigned the memory address of the first element in the array to the pointer. This is the same as doing int *pointer = &a[0], explicitly stating the address-of the first element in the array.

 Notice the pointer has to be the same type as the elements of the array, unless the pointer is a void pointer.

Pointers to structure-:

A pointer to a structure holds the memory address of the first memory of structures. And the pointers to structure must be declared to point to the structure type or be void type.

struct person {

int age;

   char *name;

};

struct person first;

struct person *ptr;

 first.age = 21;

char *fullname = “full name”;

first.name = fullname;

ptr = &first;

 printf(“age=%d, name=%s\n”, first.age, ptr->name);

 On the first 6 lines we declare the struct person, a variable to hold a person struct, and a pointer to a person struct. Line 8 we assign a literal int to the age member. Line 9-10 we declare a char pointer to a literal char array and then assign that to the struct name member. Line 11 we assign a reference to the first person struct to our struct pointer variable.

Line 13 we print out the age and name of our struct instance. Notice the two different notations, the . and the ->. With the age field we are accessing the struct instance directly and so we use the . notation. With the name field we are using our pointer to the struct instance and so we use the -> notation. This would be the same as doing (*ptr).name where we first derefence the pointer and then access the name field.

As we have seen always, there is a Driver which drives every machine automatically or manually. In the same way Driver plays most important role in LINUX. Before we move on to Character Driver lets talk a bit about Device Driver. Device driver is a computer program that simply controls the external devices like Mouse, Keyboard, Pen-drive, USB, Hard-disk, Printer, Scanner, Web-cam etc, Drivers basically depends on hardware and also the operating what you are using.

There are three types of Device Drivers in LINUX.
1.Character Driver.
2.Block Driver.
3.Network Driver.

Character Driver: Character Driver simply means it Read or Write Character by Character only.
There are some set of rules to write a Character Driver. Follow the rules and you can write a best Character Driver.

Initialization: Firstly we have to initialize the kernel module, for which we have to use macro init_module(), this macro is use to initialize our kernel module. This function is called when the module is inserted into the kernel with help of command insmod. Now we have to end our module if we start it and for this we use at the end cleanup_module(). This function has called when module is remove from the kernel and the command is rmmod. These two are the most important part of kernel module. We are using some modules here which means we have to use header file #includethis header file needed by all kernel module. One more header file we use for the initialization of kernel loadable module is #includeand also we need to define two macros at the end of initialization and cleanup function are module_init(init_function); & module_exit(cleanup_function); these are the macros that designates a module is initialization and clean up functions.

After written your first code now is the time to compile it, here in kernel module we need a Makefile for the compilation of our kernel module. After this write make and if you are lucky then you will see a successfully compiled module. After the compilation you can check the ko(Kernel object) file with the help of ls on the command line. Now enter into the modules with the help of command, cd modules.
In the modules insert your kernel object file, write insmod filename.ko. To Check whether the file is insert successfully or not, give command dmesg by which you can see your inserted module. Once the module insert, now is the time to remove it with the help of command rmmod, and again enter dmesg to check whether the module removed successfully or not.

Make sure that there are no errors in your program, because when you work on the character driver is just like you are going to hack the kernel and one single mistake in your program may lead to reboot but reboot means you are lucky, because sometimes due to errors your system may crash. So its better to make your self good in system C.

The above process may have one alternate. Rather than go for that long you can do it by scripting as well. All you need to do just write a script and than change the mode of your scripting file into the executable file by giving command chmod called change mode.

Here the registration of your loadable kernel module is complete. We are making this module for a device, but now we are not using any physical hardware. In the place of this we will assign some memory inside our system which will act as device for our character driver and further testing we will do with the help of that created memory which will create with the help of scull(Simple Character Utility for Loading Localities). We are using scull because it isn’t hardware dependent. Scull using the space which is allocated by the kernel. And also the portability of scull is so easy across the computer architecture on which the linux runs. We allocate memory to to scull with the help of kmalloc.

Now once you allocate memory for scull you should check the major and minor number of your device. Major and Minor number are the most important part for any device access, to check the major and minor write ls -l. Here you can see the major & minor number. Actually why these major and minor number concept we use, because the major number shows that which driver we have to use to acces particular hardware, because system already assign a unique major number for every device, all device files with same major number are controlled by same driver. Now the driver use minor number to distinguish between the various driver it controls. Driver may have same major number but have different minor number.

The command to check the major and minor number is-:
printk(KERN_ALERT “Major no.:%d\n”, MAJOR(dev));
printk(KERN_ALERT “Minor no.:%d\n”, MINOR(dev));