RCS file: header.h,v
Working file: header.h
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Implementing
—————————-
revision 1.1 locked by: root;
date: 2014/11/25 06:17:53; author: root; state: Exp;
Initial revision
=============================================================================
RCS file: declaration.h,v
Working file: declaration.h
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
—————————-
revision 1.1 locked by: root;
date: 2014/11/25 06:18:56; author: root; state: Exp;
Initial revision
============================================================================
RCS file: dev_open.c,v
Working file: dev_open.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
open the device
—————————-
revision 1.1 locked by: root;
date: 2014/11/25 06:20:22; author: root; state: Exp;
Initial revision
=============================================================================
RCS file: dev_release.c,v
Working file: dev_release.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Release the device.
—————————-
revision 1.1 locked by: root;
date: 2014/11/25 06:22:30; author: root; state: Exp;
Initial revision
=============================================================================
RCS file: initilization.c,v
Working file: initilization.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Implemented check_region(), release_region() and request_region().
—————————-
revision 1.1 locked by: root;
date: 2014/11/25 06:28:58; author: root; state: Exp;
Initial revision
=============================================================================
RCS file: cleanup.c,v
Working file: cleanup.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Implemented release_region().
—————————-
revision 1.1 locked by: root;
date: 2014/11/25 06:30:56; author: root; state: Exp;
Initial revision
=============================================================================
RCS file: dev_write.c,v
Working file: dev_write.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Written 100k byte data serially implementing RS 232 protocol.
Data written through circular Buffer. Data Transfered by following proper handshaking Mechanism by Using LSR, and MCR and MSR registers.

It took 1.53 min to read the data
—————————-
revision 1.1 locked by: root;
date: 2014/11/25 06:27:06; author: root; state: Exp;
Initial revision
=============================================================================
RCS file: dev_read.c,v
Working file: dev_read.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Read 100k byte data serially.

Data Recieved by following proper handshaking Mechanism by Using LSR, and MCR and MSR registers.

—————————-
revision 1.1 locked by: root;
date: 2014/11/25 06:33:55; author: root; state: Exp;
Initial revision
=============================================================================
RCS file: file_op.h,v
Working file: file_op.h
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
—————————-
revision 1.1 locked by: root;
date: 2014/11/25 06:35:37; author: root; state: Exp;
Initial revision
=============================================================================

log files :——————————–
>> read :
2 RCS file: dev_read.c,v
3 Working file: dev_read.c
4 head: 1.3
5 branch:
6 locks: strict
7 root: 1.3
8 access list:
9 symbolic names:
10 keyword substitution: kv
11 total revisions: 3; selected revisions: 3
12 description:
13 read module for transfering 7 mb of data over the serial channel using RS-232 protocol.
14 —————————-
15 revision 1.3 locked by: root;
16 date: 2014/11/21 19:28:25; author: root; state: Exp; lines: +0 -2
17 removed debugging symbols.
18 driver in release mode
19 successful implementation of the read module.
20 7 MB of data successfully received.
21
22
23 The reader has no way of knowing when the writer will stop sending data, thus to overcome this the application on the
24 DCE end is to know(explicitly) how musch data is to be send by the DTE.
25 —————————-
26 revision 1.2
27 date: 2014/11/21 19:26:21; author: root; state: Exp; lines: +2 -18
28 successfully implemented the reader module for the DCE.
29 able to receive 7MB of data.
30 time taken to transfer 7MB is 13 minutes.

——————————————————–
>> write :

2 RCS file: dev_write.c,v
3 Working file: dev_write.c
4 head: 1.3
5 branch:
6 locks: strict
7 access list:
8 symbolic names:
9 keyword substitution: kv
10 total revisions: 3; selected revisions: 3
11 description:
12 Sending a file of 7 mb on a serial channel, using the RS 232 protocol.
13 —————————-
14 revision 1.3
15 date: 2014/11/21 19:21:46; author: root; state: Exp; lines: +1 -7
16 Removed the comments.
17 write module ready for release.
18 —————————-
19 revision 1.2
20 date: 2014/11/21 19:15:27; author: root; state: Exp; lines: +3 -5
21 Implemented hand shaking between the DTE and DCE.
22 DTE has a circular buffer (max size of buffer = 4k bytes).
23 —————————-

for(i=0;i<noq;i++)
{

if(idata[i],ubuff(lv*QUANTUM_SIZE),QUANTUM_SIZE);
for(j=0;j<8;j++)
{
printk(KERN_INFO "data[%d] = %c\n",i,ch1);
while((inb(0x3f8+5)&0×60)!=0×60);
outb(ch1,0x3f8);
}
lv++;
}

printk(KERN_INFO "noq = %d\n",noq);
printk(KERN_INFO "QUANTUM_SIZE =%d, i = %d\n",QUANTUM_SIZE,i);
if(i<QUANTUM_SIZE-1)
{
printk(KERN_INFO "Inside if for next quantum\n");
noq = noq- QUANTUM_SIZE;
i = 0;
goto label;
}
}

RS-232 is a standard for serial communication transmission of data. It formally defines the signals connecting between a DTE (Data terminal equipment) such as a computer, and a DCE (Data communication equipment), such as a modem.

A straight-through cable is used to connect a DTE (e.g. computer) to a DCE (e.g. modem), all signals in one side connected to the corresponding signals in the other side in a one-to-one basis. A crossover (null-modem) cable is used to connect two DTE directly, without a modem in between.

using coomand ==lspci on the terminal will give ou list of all chipset for audio card , usb ,serial, parallel ,vga …….etc

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.

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.

How Transmitter Transmits and Reciever  recieves start , stop and parity bit if 8 bit data is sent from transmitter to reciever , as THR containes 8 bits and that should be data .

How parity error bit of LSR of Reciever machine will check the parity of data , sent by Transmitter device ,

#include”header.h”

static int my_proc (char * buf, char ** start,off_t off, int count)
{
int intr_id,lsr,msr,len=0;
int baudrate,div_lacth,lcr;
#ifdef PRINT
printk(KERN_INFO “Begin : ‘%s’\n”,__func__);
#endif

intr_id = inb(SERIAL_IIR);
lsr = inb(SERIAL_LSR);
msr = inb(SERIAL_MSR);

lcr = inb(SERIAL_LCR);
outb(lcr | 0×80 , SERIAL_LCR);
div_lacth = inw(SERIAL_DLL);
outb(lcr,SERIAL_LCR);

baudrate = CLOCKRATE / div_lacth;

len = len + sprintf(buf+len, “Baudrate = %d\n”,baudrate);
len = len + sprintf(buf+len, “Data Format = %d\n”, 5+(lcr & 3));
len = len + sprintf(buf+len, “MSR = %02x\n”,msr);
len = len + sprintf(buf+len, “LSR = %02x\n”,lsr);
len = len + sprintf(buf+len, “Interrupt ID = %02x\n”,intr_id);
len = len + sprintf(buf+len, “\n”);

#ifdef PRINT
printk(KERN_INFO “Exit : ‘%s’\n”,__func__);
#endif

return len;
}

static int my_open(struct inode *inode, struct file *filp)
{

#ifdef PRINT
printk(KERN_INFO “Begin :’%s’\n”,__func__);
printk(KERN_INFO “Device_Open = %d\n”,Device_Open);
#endif

if(Device_Open)
{
#ifdef PRINT
printk(KERN_INFO “The driver is busy\n”);
#endif
return -EBUSY;
}
Device_Open ++;

//MOD_INC_USE_COUNT(THIS_MODULE);
try_module_get(THIS_MODULE);
#ifdef PRINT
printk(KERN_INFO “Exit :’%s’\n”,__func__);
#endif
return 0;
}

static int my_release(struct inode *inode, struct file *filp)
{
#ifdef PRINT
printk(KERN_INFO “Begin :’%s’\n”,__func__);
#endif

Device_Open –;
#ifdef PRINT
printk(KERN_INFO “Decrementing the value of Device_Open, new value is %d\n”,Device_Open);
#endif

//MOD_INC_COUNT(THIS_MODULE);
module_put(THIS_MODULE);
#ifdef PRINT
printk(KERN_INFO “Decrementing the count in the kernel\n”);
#endif

#ifdef PRINT
printk(KERN_INFO “Exit :’%s’\n”,__func__);
#endif
return 0;
}

int my_ioctl(struct inode *inode, struct file *filp, unsigned int request, unsigned long address)
{
int lcr,div_lacth,baudrate = 0 ;
int *there = (int *) address;
#ifdef PRINT
printk(KERN_INFO “Begin :’%s’\n”,__func__);
#endif

switch(request)
{
case IOCTL_GET_BAUDRATE:
lcr = inb(SERIAL_LCR);
outb(inb(SERIAL_LCR) | 0×80, SERIAL_LCR);
div_lacth = inw(SERIAL_DLL);
outb(lcr,SERIAL_LCR);

if(div_lacth > 0)
{
baudrate = CLOCKRATE / div_lacth;
#ifdef PRINT
printk(KERN_INFO “div_lacth = %d\n”,div_lacth);
printk(KERN_INFO “baudrate = %d\n”,baudrate);
printk(KERN_INFO “Clockrate = %d”,CLOCKRATE);
#endif
}

if(copy_to_user(there, &baudrate, 4))
{
#ifdef PRINT
#endif
return -EFAULT;
}
return 0;
break;

case IOCTL_SET_BAUDRATE:
if(copy_from_user(&baudrate, there, 4))
{
#ifdef PRINT
#endif
return -EFAULT;
}

if((baudrate CLOCKRATE))
{
#ifdef PRINT
#endif
return -EFAULT;
}

div_lacth = CLOCKRATE / baudrate;
lcr = inb(SERIAL_LCR);
outb(inb(SERIAL_LCR)| 0×80, SERIAL_LCR);
outw(div_lacth,SERIAL_DLL);
outb(lcr,SERIAL_LCR);
return 0;
break;
}

#ifdef PRINT
printk(KERN_INFO “Exit :’%s’\n”,__func__);
#endif
return -EINVAL;
}

ssize_t my_read(struct file *filp, char *buf, size_t len, loff_t *pos)
{
unsigned char data;
int count,i,lsr;
#ifdef PRINT
printk(KERN_INFO “Begin :’%s’\n”,__func__);
#endif

lsr = inb(SERIAL_LSR);
#ifdef PRINT
printk(KERN_INFO “The LSR status is %04x\n”,lsr);
printk(KERN_INFO “The LSR status is %04x\n”,inb(SERIAL_LSR));
#endif

if((lsr & 0×01) == 0)
{
if(filp->f_flags & O_NONBLOCK)
{
#ifdef PRINT
printk(KERN_INFO “A NONBLOCK flag is on, exiting now\n”);
#endif
return 0;
}
}

count = 0;

for (i=0;if_flags & O_NONBLOCK)
#ifdef PRINT
printk(KERN_INFO “A NONBLOCK flag is on, exiting now\n”);
#endif
return 0;
}
count = 0;

for(i=0;i<len;i++)
{
if(copy_from_user(&data,buf+i,1))
{
#ifdef PRINT
printk(KERN_INFO "Unable to read macro failed\n");
#endif
return -EFAULT;
}

while((inb(SERIAL_LSR) & 0×20) == 0×00);
outb(data,SERIAL_TX_REG);
++count;

if((inb(SERIAL_MASK) & 0×01) != 0×01)
{
#ifdef PRINT
printk(KERN_INFO "the writer is not sending data to reciver\n");
#endif
break;
}
}
#ifdef PRINT
printk(KERN_INFO "Exit :'%s'\n",__func__);
#endif
return count;
}

static dev_t serial_setup_cdev (struct serial_dev *ldev , int i)
{
dev_t ldevno;
int result;
#ifdef PRINT
printk(KERN_INFO "Begin :'%s'\n",__func__);
#endif
ldevno = MKDEV(serial_major,serial_minor);
cdev_init(&ldev[i].cdev,&fops);
ldev[i].cdev.owner = THIS_MODULE;
ldev[i].cdev.ops = &fops;
result = cdev_add(&ldev[i].cdev,ldevno,ndevice);
#ifdef PRINT
printk(KERN_INFO "result = %d\n",result);
printk(KERN_INFO "device no : %d\t,minor number = %d\n",i,serial_minor);
#endif

serial_minor++;

#ifdef PRINT
printk(KERN_INFO "Exit :'%s'\n",__func__);
#endif
return 0;
}

static int __init my_init(void)
{
int ret,i;
#ifdef PRINT
printk(KERN_INFO "Begin :'%s'\n",__func__);
#endif

#ifdef PRINT
//printk(KERN_INFO "Current value of jiffies is %ld\n",j1);
printk(KERN_INFO "Major = %d\tMinor = %d\n",serial_major,serial_minor);
#endif

if(serial_major)
{
devno = MKDEV(serial_major,serial_minor);
ret = register_chrdev_region(devno, ndevice, device_name);
}
else
{
ret = alloc_chrdev_region(&devno, serial_minor, ndevice, device_name);
serial_major = MAJOR(devno);
#ifdef PRINT
printk(KERN_INFO "Major number allocated is %d\n",serial_major);
#endif
}

if(ret comm,current->pid);
#endif

if(serial_major)
{
serial_dev = (struct serial_dev *) kmalloc (sizeof(struct serial_dev),GFP_KERNEL);
if(!serial_dev)
{
#ifdef PRINT
printk(KERN_WARNING “Unable to allocate the memory for the device\n”);
#endif
return -ENOMEM;
}
#ifdef PRINT
printk(KERN_WARNING “allocate the memory for the device\n”);
#endif
memset(serial_dev, 0, sizeof(struct serial_dev));

for(i=0;icomm,current->pid);
#endif

//changing the register
#ifdef PRINT
printk(KERN_INFO “Setting the default values to the register…now\n”);
#endif

outb(0×00,SERIAL_IER); //disable the IER
outb(0×00,SERIAL_FIFO); //disable the FIFO
outb(0×00,SERIAL_MCR); //MCR = 0

#ifdef PRINT
printk(KERN_INFO “Setting the default values to the register done successfully\n”);
#endif

#ifdef PRINT
printk(KERN_INFO “Exit :’%s’\n”,__func__);
#endif
}

module_init(my_init);
module_exit(my_exit);