The serial port on your PC is a full-duplex device meaning that it can send and receive data at the same time. In order to be able to do this, it uses separate lines for transmitting and receiving data. Some types of serial devices support only one-way communications and therefore use only two wires in the cable – the transmit line and the signal ground.

 Communicating by Bits

Once the start bit has been sent, the transmitter sends the actual data bits. There may either be 5, 6, 7, or 8 data bits, depending on the number you have selected. Both receiver and the transmitter must agree on the number of data bits, as well as the baud rate. Start and stop bit is send before and after the data has send.

The Parity Bit

Besides the synchronization provided by the use of start and stop bits, an additional bit called a parity bit transmitted along with the data. A parity bit provide a small amount of error checking, to help detect data corruption that might occur during transmission. You can choose either even parity, odd parity. When even or odd parity is being used, the number of marks (logical 1 bits) in each data byte are counted, and a single bit is transmitted following the data bits to indicate whether the number of 1 bits just sent is even or odd.

RS-232 Protocol

RS-232 is the name for a standards for serial binary single-ended data and control signals connecting between data terminal equipment and data circuit-terminating equipment. It is commonly used in computer serial ports. The standard defines the electrical characteristics and signals timing, size and pin-out of connectors. This protocol defines the maximum open-circuit voltage of +/- 25 volts. Valid signals are in the range of +3 to +15 volts or the range -3 to -15 volts with respect to the ground. The range between -3 to +3 volts is not a valid RS-232 level. For data transmission lines (TxD, RxD etc.) logic one is defined as a negative voltage and the condition is called mark. Logic zero is +ve and the signal condition is termed space. Control signals have the opposite polarity: the active state is positive voltage and the inactive state is negative voltage.

Character Driver
Block Driver
Pipe Driver

In character driver byte by byte transfer of data takes place from user space to kernel space and vice – verse. The only relevant difference between a char device and a regular file is that you can always move back and forth in the regular file, whereas most char devices are just data channels, which you can only access sequentially.

Initialization of Character driver

Initialization of driver module is the first step in any driver programming so in the character driver programming . Each piece of code that can be added to the kernel at run time is called a module. The module is linked dynamically to the running kernel using the insmod command. The rmmod command is used to remove the module entry .

module_init(function_name);
module_exit(function_name);

The module_init() and module_exit() macro defined in <Linux/module.h> are used for initialization of initialization function in kernel using insmod and the removal of the initialization function using rmmod.

Registration and unregistration of Driver

The registration of module is done using different function defined in <Linux/fs.h> . The various functions used for registration of the driver are

register_chrdev(unsigned int major,const char *name, const struct file_operation *fops);
extern int alloc_chrdev_region(dev_t * , unsigned minor_no , unsigned nod, driver name);
extern int register_chrdev_region(dev_t, unsigned, const char *);

(*I have used alloc_chrdev_region for registration)

At the time of removal the unregistration of device is done in clean_up function or exit_function the
function for unregistration of driver are

extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
unsigned int count, const char *name);
extern void unregister_chrdev_region(dev_t, unsigned);

when registration is done kernel give the minor and major no. called inode no. .Major number are used to represent the driver and minor number represent the number of devices administrate by that particular driver. Kernel identify the driver with their major number . In earlier kernel version total 16 bit are used for major no. and minor no., 8 bit for major no. and 8 bit for minor therefore 255 major no. can be allocated by kernel but in new kernel version 32 bits are used from which 12 bits are used for major no. and rest 20 bits are used for minor no. but we still can use only 255 major no. the reason behind it is the 255 major no are defined in the macro in the header file,dev_t type is used to hold device number both major and minor parts. To obtain the major or minor number of dev_t use :

MAJOR(dev_t dev);
MINOR(dev_t dev);

We use scull as a device memory,just like malloc to get memory in user space Kmalloc is used to get memory in kernel space . The garbage in allocated memory in kernel space is remove by :

memset(void *s ,int c ,size_t n);

The first argument refer to the memory location which is to be replaced by the value in second argument and the third argument indicate how of allocated memory should be cleared.Then the deivce is initalized using :

cdev_init(struct cdev *,struct fileoperations * );

cdev_add(struct cdev *,dev_t , nod);

Open and release:-

The open and release operation is performed by the scull_open and scull_release . Open call prepare the device for the future .We know that every thing is in file format, to set a communication between two file the open function is used it make node for every 32 bit inode number so that particular inode number file can use that node for communication .

Scull_open();
Scull_release();
READ and WRITE operation:-
Once the node is open the read and write operation is performed using scull_write and scull_read.
scull_write is to write on kernel space and scull_read to read data of kernel space for these operation
the call copy_from_user and copy_to_user is used. The mapping of all these function are done through
struct file_operation structure.
scull_write(struct file *,const char __user *,ssize_t,loff_t *);
copy_from_user();
scull_read(struct file *,char __user *,ssize_t,loff_t *);
copy_to_user();
that how the data is read and write from and to kernel memory .