Serial communication is the process of sending data one bit at a time, sequentially, over a communication channel or computer bus where as in case of parallel communication, where several bits are sent as a whole, on a link with several parallel channels. Serial communication is used for all long distance communication and most computer networks, where the difficulties like cost and synchronization make parallel communication difficult. Serial communication mostly refers to the RS-232 communication protocol where 9 pin connectors used for communication between 2 devices.

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.

The following is commonly used RS-232 signals and pin:

• Pin 1 = CT (Carrier Detect)

• Pin 2 = RxD (Received Data)

• Pin 3 = TxD (Transmitted Data)

• Pin 4 = DTR (Data Terminal Ready)

• Pin 5 = Ground

• Pin 6 = DSR (Data Set Ready)

• Pin 7 = RTS (Request To Send)

• Pin 8 = CTS (Clear To Send)

• Pin 9 = RI (Ring Indicator)

Serial Port base Address and IRQ Number:

Serial Port has following base addresses and IRQ number associated with it:

1. 3F8 4

2. 2F8 3

3. 3E8 4

4. 2E8 3

The most commonly used UART IC in personal computers is pc16550D. It has 8 registers which are used for controlling the data transmission. They are:

Register 0: Receiver Buffer Register(Read Only) & Transmitter Register(Write Only).

These buffer are used for receiving and transmitting data between two devices.

Register 1: Interrupt Enable register

This register is used to enabling the interrupts. Setting bit 0-3 will enable Receive Data Available, Transmitter empty, Line Status Interrupt and Modem Status Interrupt.

Register 2 : Interrupts Identification Register(R/O) & FIFO Control Register (W/O)

IIR : If any interrupt has occurred, reading out this register will give the corresponding interrupt value.

FCR : This will enable the FIFO mode for UART i.e. it will store up-to 14 bytes of data before transmission.

Register 3 : Line Control Register :

This register controls the transmission pattern of data. It is also used to set the baud rate of the UART by setting bit 7 and writing value in Divisor latch buffers.

Register 4 : Modem Control Register:

Used to start the handshaking mechanism between host and peripheral.

Register 5: Line status Register :

This register is used to get the line status and if data is available. It is a read only register.

Register 6: Modem Status Register:

This register shows the current state of data line when read.

Register 7: Scratch Register

Divisor Latch (LS) & (MS) :

These register together forms a 16bit register when the bit7 of LCR register is set. They hold the multiplier value, to set the baud rate of the UART at desired rate.

Data Transmission:

First the transmitter will indicate the receiver by setting is MCR bit0 which will notify the receiver at MSR bit5 as pin 4 of transmitter is connected to pin 6 of receiver. After receiving the signal DSR, receiver will set its MCR bit1 which is connected to transmitter’s RTS pin and will notify the transmitter that he is ready to receive data. Then transmitter will put the data in Transmitter buffer and receiver will receive the data in receiver buffer.

Parallel port is the mostly used for interfacing line printers. It was introduced by IBM in early 1980′s. Earlier there was no standard defined for parallel port interfacing. Every company has their own standards for interfacing parallel port. Then came the IEEE 1284 standard (Standard Signaling Method for bi-directional parallel peripheral interface for personal computers).

There are three base addresses defined for parallel port which can be used for interfacing parallel port. Those addresses are

0×378-0x37A

0×278-0x27A

0x3BC-0x3BF

A parallel port is a 25 pin connector having 8 data pins, 5 status pins and 4 control pins and rest of the pins are connected to ground.

2 – 9 = 8 Data Pins

10,11,12,13,15 = Status Pins

1, 14, 16,17 = Control Pins

18 – 25 = Ground Pins

This port will allow the input of up to 9 bits or the output of 12 bits at any one given time.

There are 5 data transfer mode in parallel communication:

1. Compatibility Mode: Data can be transferred only in one direction using data register.

2. Nibble mode: Data can be transferred in both direction in half-duplex manner (only four bit at a time).

3. Byte Mode: 8bit data can be transferred in both direction in half-duplex manner.

4. EPP Mode.

5. ECP Mode.

Compatibility, Nibble & Byte modes use just the standard hardware available on the original Parallel Port cards while EPP & ECP modes require additional hardware which can run at faster speeds, while still being compatible with the Standard Parallel Port.

Compatibility Mode:

This mode defines the protocol used by most PCs to transfer data to a printer. It is commonly called the Centronics mode and is the method utilized with the standard parallel port. In this mode, data is placed on the port’s data lines, the printer status is checked for that it is not Busy, and then a data Strobe is generated by the software to send the data to the printer

Compatibility Mode steps:

1. Write the data to the data register

2. Program reads the status register to check that the printer is not BUSY

3. If not BUSY, then Write to the Control Register to assert the STROBE line

4. Write to the Control register to de-assert the STROBE line

To transfer one byte of data it requires four operation and at least as many additional instructions. The data transfer rate in this protocol is 150K bytes per second. This mode is for the forward channel only. This mode was included as a way to provide backward compatibility with the huge base of installed printers and peripherals. The other modes are used to provide the reverse channel and high performance communication links. Many of the integrated 1284 I/O controllers have implemented a mode that uses a FIFO buffer to transfer data with the Compatibility mode protocol. This mode is referred to as Fast Centronics or Parallel Port FIFO Mode. When this mode is enabled, data written to the FIFO port will be transferred to the printer using hardware generated strobes for the handshaking.

Threads, like processes are a mechanism to allow a program to do more than one thing at a time. In Linux when a process is created, it already contains a thread, used to execute the main() function. Threads are implemented as lightweight process. A process can have multiple threads of execution and they all share the same process address space and system state information. When a thread is created in a process, the new thread of execution gets its own stack but shares global variables, file descriptors, signal states. When a program creates another thread, nothing is copied. The creating and the created thread share the same memory space, file descriptors, and other system resources as the original. If one thread changes the value of a variable, for instance, the other thread will see the modified value. Similarly, if one thread closes a file descriptor, other threads may not read from or write to that file descriptor. Because a process and all its threads can be executing only one program at a time, if any thread inside a process calls one of the exec functions, all the other threads are ended.

Linux implements the POSIX thread api. All thread functions and data types are declared in the header file <pthread.h>. to use these library calls link the program with the threads library using -lpthread, as they are not included in standard C library.

Thread Creation:

Each process is identified by a thread id of type pthread_t. Upon creation each thread executes a thread function. When this function returns, thread ends. Function to create a thread is

pthread_create(pthread_t* thread, pthread_attr_t * attr, void *(*routine), (void *), void *arg);

thread is a pointer to a pthread_t structure that will be initialized by the function. Later, this structure can be used to reference the thread.

Attr is a pointer to an optional structure pthread_attr_t. This structure can be manipulated using pthread_attr_*() functions. It can be used to set various attributes of the threads (detach policy, scheduling policy, etc.)

start_routine is the function that will be executed by the thread

arg is the private data passed as argument to the start_routine function

Thread Exit :

A thread can exit by calling pthread_exit .This function may be called from within the thread function or from some other function called directly or indirectly by the thread function. The argument to pthread_exit is the thread’s return value. Syntax of pthread_exit is

void pthread_exit(void *retval).

Thread Joining :

When the main() function exits, all threads of the application are destroyed. The pthread_join() function call can be used to suspend the execution of a thread until another thread terminates. This function must be called in order to release the resources used by the thread, otherwise it remains as zombie. Syntax of pthread_join is

int pthread_join(pthread_t thread, void **thread_return);

where thread the thread for which to wait, that was filled by the pthread_create function call. Second argument point to the return value of the thread.

Advantages of using threads:

• Improves program performance.

• Reduce system overheads.

• Enables the better utilization of hardware in multi-core cpu’s.

• Less demanding on resources as compared to multiple processes.

Disadvantages :

• Program complexity and requires very careful design.

• Debugging a multi-threaded application is a difficult task.

• Deadlocks.

Device drivers are building blocks of a OS. In Linux there are three types of device driver i.e.

• Character Driver

• Block Driver

• Pipes Driver

Device driver are used to make hardware do a specific job with some defined set of rules and they hide the working procedure of hardware from the outside world. Device drivers as implemented as loadable kernel module means you can add a drive at any instance of time.

Character drivers are used to access streams of byte at one by one. Some example of char driver are text console, serial port, USB keyboard etc. Before working with driver, driver must be registered with kernel so that driver can be inserted as lkm module. Driver communicate using node in file-system.

For using the char device, there should be one entry point which will start the driver and there should be one exit point which will be used to remove the driver from the list of installed modules. For this there are two macro’s defined in kernel for char driver. They are module_init() and module_exit(). They take the __init and __exit functions as there arguments. After this the lkm is inserted using the insmod command and lkm is removed using the rmmod command.

To access the device using node,system provides the Major and Minor numbers. To get the Major and Minor numbers, the driver for lkm is registered with kernel using alloc_chrdev_region(if no major number is allocated) and register_chrdev_region(if major number for the device driver is already obtained). It takes the dev_t type variable, no of device, module name and starting minor number as argument and fills the dev_t type variable with the major number allocated to the device. dev_t is a 32 bit variable who’s upper 12 bit represents the major number and lower 20 bits represents the minor number. To get major and minor number separately kernel symbol table provides the two macro’s i.e. MAJOR() and MINOR() which takes the dev_t as argument. The major number is number provided to the device driver and the minor number is used to specify the specific device using the the driver. Device can be freed using the unregistered_chrdev_region which take the dev_t type as argument.

Char device memory is accessed using the scull. Scull stands for simply character utility for loading localities. Scull is implemented as a link list. Scull is represents as

struct scullqset

{

void **;

struct scullqset *next

};

struct sculldev

{

struct scullqset *qset;

//data

};

Sculldev contains the attribute of the devices like quantum size, qset size, device size, date size and some flag etc where as scullqset contains the data present in device. It has a void ** which is used to save data.

Scull device is added to the modules using the cdev_init and cdev_add. cdev_init initialize the file operation that are gonna work on the device and cdev_add adds them into the module. cdev_add creates the node in file-system for the device. Every device, who uses driver is registered and added to kernel modules before any other operations. Modules are removed using cdev_del.

Every device provides some basic operations like open, close, read, write etc… these function are mapped to the standard functions in file_operation structure and are already added at the time cdev_add.

When a device is opened, a special micro is used called CONTAINER_OF which creates a mapping for the outside memory device in form of scull. The obtained scull pointer is stored into private_data variable of the file_operation structure. After that the mode of open is checked, if opened in write-only mode, then previous mapping of the device is removed and cleaned.

In write operation, sculldev is loaded from the file stream’s private_data. memory is allocated for the amount of data to be written. The write function uses the micro provided by the kernel to copy data from the user application using copy_from_user function. This function copies the data from user space to kernel space and put it into the device memory using scull. copy_from_user return the numbers of bytes not copied. After successful copy, the device attributes is updated.

Read operation is also similar like write operation with difference is it uses copy_to_user function for reading the data from scull memory to user application.

llseek operation is used to set the offset from where read or write operation is to be performed by updating the f_pos value.