1.3
date    2014.01.07.05.55.57;    author root;    state Exp;
branches;
next    1.2;

1.2
date    2014.01.07.04.44.27;    author root;    state Exp;
branches;
next    1.1;

1.1
date    2014.01.07.03.22.24;    author root;    state Exp;
branches;
next    ;

desc
@device driver registerd using alloc_chrdev_region
@

1.3
log
@device structure cdev initialized and cdev is added to device table
@

head    1.2;
access;
symbols;
locks
root:1.2; strict;
comment @ * @;

1.2
date    2014.01.07.04.44.27;    author root;    state Exp;
branches;
next    1.1;

1.1
date    2014.01.07.03.22.24;    author root;    state Exp;
branches;
next    ;

desc
@device driver registerd using alloc_chrdev_region
@

1.2
log
@device driver structure(Sculldev) represented & memory allocated using kmalloc
@
_______________________________________________________________________________________________________

module clean_up log_file

head    1.2;
access;
symbols;
locks; strict;
comment @ * @;

1.2
date    2014.01.07.04.46.28;    author root;    state Exp;
branches;
next    1.1;

1.1
date    2014.01.07.03.26.40;    author root;    state Exp;
branches;
next    ;

desc
@device driver unregisterd using unregister_chrdev_region
@

1.2
log
@device driver structure(Sculldev) deallocated using kfree & device driver unregistered
@

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment @ * @;

1.1
date    2014.01.07.03.22.24;    author root;    state Exp;
branches;
next    ;

desc
@device driver registerd using alloc_chrdev_region
@

1.1
log
@Initial revision
@

______________________________________________________________________________________________________________________________________________________________________

module clean_up log_file

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment @ * @;

1.1
date    2014.01.07.03.26.40;    author root;    state Exp;
branches;
next    ;

desc
@device driver unregisterd using unregister_chrdev_region
@

1.1
log
@Initial revision
@

So device drivers are that loadable kernel modules which insert in kernel ,work as part of kernel and removes as the need is ended.
Now there are Basically three types of drivers:
1.Character Driver
2.Block Driver
3.Network Driver
Character Driver:- First of all in driver we have to know that we are legally hack the kernel so we cant user level commands here for example we can’t use printf ,we use printk instead of that.
In kernel level there are two main functions which are module_init (arg) and Module_exit (arg).Here arguments is our start and exit functions. This is the two main micros of a driver. That mean a driver perform Module_init at starting and Module_exit on exit.
module_init (fn name):In module _init we register our driver by using
alloc_chrdev_region(&dev, minorno, nod, DRIVER_NAME);

in this dev id dev_t type and minor no is device no and nod Is number of devices .
now we get a a combination of major and minor no in dev which is of 32 byte in which 20 byte is of minor no and 12 byte is for major no. we can get our major no. by using micros major(dev) and minor(dev) this will give major and minor no.
We make our user defined function sculldev which have all the information about the device and allocate memory for it using Kmalloc. Which return a pointer which points to it starting address.
Now initialize our C_dev which is points to struct cdev and fops.
cdev_init (&sculldev->c_dev, &fop);
we can inform the kernel about this c dev structure using the cdev_add call.
int cdev_add(struct sculldev ->c_dev, dev_t dev, unsigned int count);
this is our start function. Now we proceeed to exit one.
In exit function we do nothing but to unregister device and free the memory allocatd to sculldev.
Now we go to our header file and define our sculldev structure and assign its members that are our quantum_size ,qset size,device size.and struct cdev type c_dev and struct scullaset *scullqs.et which points to our structure ScullQset which contains two things which are first our next pointer which points to out next scullqset structure and second is data pointer which contains qset which actually an array of pointer.It contains starting address of quantums.Ultimately our data is going to store in the quantums.
The whole structure of ScullQset is known as Item.We can relate it as our linked list which has next pointer and an info part.
This is our scullqset structure.

struct ScullQset
{
struct ScullQset *next;
void **data;
};
.
Now as we know that every device has its own set of open,close etc fn. So we have to map it using a structure names file_operations.
const struct file_operations fop=
{
open:scull_open,
write:scull_write,
read:scull_read,
release:scull_release
};

Here we map open call by scull_open means whenever a open call is make the command goes to scull open and perform scull_open.Simiarly we can map any no. of user level command.
Now we are defining prototypes of mapped command which are given in fs.h libraray which can accessible in kernel file.
int scull_open(struct inode *, struct file * );
int scull_release(struct inode *, struct file * );
ssize_t scull_read (struct file *, char __user *, size_t, loff_t *);
ssize_t scull_write(struct file *, const char __user *, size_t, loff_t *);

Now after that I write our open function in which I use Container_of which is used to map scull memory on device.
I preserve starting point pointer i.e sculldev in filep->private data.
Now In read fn . I get data from application and perform some calculation which give me idea on how many no. of quantum’s I needed to write this data .After that I write the data in Quantums by using the micro copy_from_user(destination,source,len)
Now I mapped the read function also so I read this data and show it in application by micro copy_to_user (destination, source, len)
Now I make a simple application and test it .I pass the data by using file descriptors.
I make a node which connect device driver to application.
I connect the application with device driver code by writing a command in script as
./ appl node.
Loadable Moduler kernel can be inserted and removed from the running kernel(using kernel utilities insmod and rmmod respectively);
Successfully worked till this. Working on lseek now.

What is device driver and need of driver?
From my knowledge device driver is nothing but piece of code that runs the device . Every device need that code to run ,without driver device is dead, to make device alive we have to provide that code.
This code is nothing but the driver.
When the driver sit in the hardware permanently that that driver is called firmware , when this driver set the rule how the system boot up then this driver know as BIOS.
So i can conclude that every device need a piece of software to run the device. Driver not also run the device but it also decide that what will do i the device is on ,running and shutdown. From booting of the device to shutdown device need the support of the driver.

Types of device driver:
1. Character driver
2. block driver
3. Network driver/pipe driver

In this article i will talk about character driver. Character-driven drivers are device drivers that operate on characters (bytes) as the basic unit of input and
output. They are accessed in a sequential, nonrandom manner.
We can access the device as the file and operation of file like read, write ,open close and lseek.

Linux kernel have feature that we can add functionality when the system is being running and similarly we can remove some functionality. We can add or remove functionality by mean of piece of code and that piece of code is nothing but the module. When the module is inserted then it works as the part of the Linux kernel.

In short we can add or remove the module. For adding the module i used insmod command and for removing it i used rmmod command.
By doing insmode we can see our module is inserted in the kernel to cross check i used lsmod command and i saw that my module was i the list. As soon as i do rmmod i saw that my module was not there.

Now question comes what is moudle?
As i already told that module in nothing but the piece of code. Every module as at-least two function initialization function and cleanup function.
When the module is inserted by insmode the initialization function does it work and this function is initialized by a macro module_init().
And when we do rmmode the cleanup function does its job and this function is invoked by the module_exit() function .
And one thing we should keep in mind that what we have did in the initialization function we have do remove that in revere order int the cleanup function.
After inserted the module in the kernel i register the my module first by older way register_chrdev(), this function takes three argument major no, driver_name, and a pointer to struct file operations . By giving major number as 0 we do let the kernel to choose the lowest available major number and for unregistering the module i used unregister_chrdev(). It takes two argumnet major number and same device_name.
This method is now obsolete. Now a days developer used new method for registration and unregistration. But if we dig out the code of the old driver we still found that this method is being used.

The newer function to registering the device is alloc_chrdev_region and register_chrdev_region.
The alloc_chardev_region register the module by taking three argument first one is a pointer of dev_t and first minor no which is always 0 third argument is integer number and fourth is the deive name. By using this function we let the kernel to choice available major number.
Same thing is done by register_chrdev_region function but in this we have to provide the major number. It is always advisable that not to choose the major number statically because that major may also be used by the some other driver so a good developer pick the major number dynamically by using alloc_chrdev_region() for very first time . I also used alloc_chredv_region() for the first time and when i get the major number i used that major number in the second function and the number of node (ie how many i want to register the device for that particular driver/module ). The second one also prevent the registration of the same module in the kernel .

Then i declared a user defined structure struct ScullDev{}; this structure has initially it has two member first is pointer to struct scullqset and a varible of type struct cdec.

And the struct ScullQset has the the various member like a void pointer , a pointer itself and lot more like device size,qset size ,quantum size. The void pointer has the that address where our data actually reside.

Next i used cdev_init() and cdev_add() functionn. By using cdev_intit function i initialized the chracter device and by using cdev_add() i inform the kernel.
Before going on this step i understand the some structure like file structure , inode structure, file_operations structure and relation between them.

Then i made a simple application for testing the driver. In which i simply used open ,write,read and close command.

In my driver i mapped the open command to my own open routine same i did for read,write ,close and lseek . And made nod by using mknod of type c and provide this mode major and minor number which i got for the alloc_chrdev_region. By doing this when i run my application using this node and when my application try to open the device it open the device according to my routine.

I made my open routine , close routine and read and write . In this routine i used my own algorithm to read and write and trim .
In write function and also used kmallc function to allocate the memory from kernel space which is physical memory and cop_from_user macro.

And in read routine i track the quantum which is created and used copy_to_user macro.

In open routine i used container_of macro .

Until now i successfully implemented open ,write,read,release ,lseek
and application open the device in write only mode it first to trim. And open the driver after writing some data it will trim all the data and also implemented the driver for other version of read in which it free that quantum that is read.

I started writing my first character driver by writing the simplest module – hello world module.

Character devices have to register themselves with the kernel and provide it with the information that enables the kernel to invoke the correct functions when applications wish to interact with the device. I registered my driver using alloc_chrdev_region() and register_chrdev_region(). When we register our driver for the first time , we use the former method and to prevent its re-registeration when a new device is connected , we use the latter… The older method of registering a driver i the kernel is : register_chrdev().

The syntax of these are as follows:

int alloc_chrdev_region(dev_t * , unsigned , unsigned , const char *);

int register_chrdev_region(dev_t , unsigned , const char *);

We also need to include the required libraries in our header file.These are <linux/init.h> , <linux/module.h> , <linux/fs.h> , and others will be mentioned as per requirement. In our module we require two functions : module_init and module_exit.

module_init is used for calling the initialization function while module_exit is needed for the cleanup function. I also used a special macro MODULE_LICENSE() to tell the kernel that my module bears a free license.

To unregister the driver we use unregister_chrdev_region() in our cleanup function. The syntax of unregister_chrdev_region is:

unregister_chrdev_region(dev_t , unsigned);

Loading and unloading the driver

To load and unload our driver we need special utilities / commands. These are insmod and rmmod.

To insert my driver into the kernel I used insmod and to unload it I used rmmod. Also we can pass parameters while doing insmode. For that we use macro: module_param and include the header file moduleparam.h.

module_param uses three parameters : name of the variable to be passed , its type and permissions. For eg: I used it as:

module_param(nod , int , S_IRUGO). Here nod stands for number of devices which is of integer type.

After inserting our driver , we can perform various tasks like open , read , write and close. Rmmod simply tells the kernel that the driver is not there and it cannot perform these tasks.

Getting memory for Scull Device

The very next thing we need to do is to create the scull.

This is done using kmalloc in the following manner:

kmalloc(size_t , gfp_t flags);

The flag that we used is GFP_KERNEL.

The header file for kmalloc is <linux/slab.h>. This is done in the initialization function.

In our cleanup function we need to undo everything we do in initialization function in the reverse order. So to free this allocated memory we use kfree().

Also its better to memset this allocated memory using memset.

Major and Minor numbers

We know that in linux everything is a file. Even the device is a file. The character devices are accessed through names in file system. We call them nodes.

The major number identifies the driver for the device while the minor number is used by the kernel to determine exactly which device is being referred to.

The device is internally referred by device numbers.dev_t is used to hold these device numbers. To get the major and minor numbers we use special macros:

MAJOR(dev_t);

MINOR(dev_t);

To convert the major and minor numbers into device numbers , we use MKNOD.

MKNOD(majorno , minorno);

So the device number is a 32 bit combination of major and minor numbers.

12 bits are for major number and 20 bits for minor number.

The alloc_chrdev_region() and register_chrdev_region() are used by the kernel to allocate device numbers for our driver.

Initializing the cdev structure

The cdev structure is used to represent our char device internally.

I used cdev_init () to initialize the struct cdev. In this function , I initialized all the members of this structure:

set cdev.owner to THIS_MODULE

set cdev.dev to dev

set fileoperations to fops.

After these initializations we need to tell the kernel about the cdev structure . To do so , I used cdev_add(). In my cleanup function I used cdev_del() .

The syntax of these functios are as follows:

void cdev_init(struct cdev *, const struct file_operations *);

int cdev_add(struct cdev *, dev_t, unsigned);

void cdev_del(struct cdev *);

Initializing the struct ScullDev

The struct ScullDev is a user defined structure to represent the device.

We need to initialize the members of struct ScullDev also.

The members are : qset size , quantum size , device size and data size.

I used my own function init_scull() to make these initializations.

After doing upto this , our device is ready to be opened and we can perform read write operations on it. These operations are performed through an application that uses system calls: open , write , read and close.

We then map these system calls to our own routines and use struct file_operations to do the mapping.

I made an application and made it to interact with my driver to perform the read write and open close operations through a script.

Apart from this we need to trim our device when we open it in write only mode. For this i made a scull_trim() function.

I am able to perform writing and reading and also lseek.

Checked the access mode and called the function scull_trim to trim the device.
—————————-
revision 1.5
date: 2013/07/03 09:27:15; author: taruna; state: Exp; lines: +54 -2
Wrote the functions : init_scull , scull_open and scull_release.
—————————-
revision 1.4
date: 2013/07/03 07:43:05; author: taruna; state: Exp; lines: +35 -27
Used loop to add nod no. of devices in scull_setup() function.
Stored the major and minor number from alloc_chrdev_region in variable tmp using MKDEV and passed this tmp in unregister_chrdev_region in the cleanup function.
—————————-
revision 1.3
date: 2013/07/03 06:56:13; author: taruna; state: Exp; lines: +51 -0
Initialized the struct cdev through function scull_setup.
Initializeed the owner , operations and dev of struct cdev.

used cdev_init and cdev_add in scull_setup function and cdev_del in the cleanup function.
—————————-
revision 1.2
date: 2013/07/03 05:59:03; author: taruna; state: Exp; lines: +18 -2
Allocated memory for struct Sculldev using kmalloc and freed that memory using kfree in cleanup function.
—————————-
revision 1.1
date: 2013/07/03 05:35:59; author: taruna; state: Exp;
Initial revision
102,1 98%
=============================================================================
103,1 Bot

RCS File

head 1.8;
access;
symbols;
locks; strict;
comment @ * @;
1.8
date 2013.07.14.10.18.16; author Ashish; state Exp;
branches;
next 1.7;

1.7
date 2013.07.13.07.47.07; author Ashish; state Exp;
branches;
next 1.6;

1.6
date 2013.07.11.08.29.33; author Ashish; state Exp;
branches;
next 1.5;

1.5
date 2013.07.11.05.31.28; author Ashish; state Exp;
branches;
next 1.4;

1.4
date 2013.07.09.10.25.39; author Ashish; state Exp;
branches;
next 1.3;

1.3
date 2013.07.09.10.15.33; author Ashish; state Exp;
branches;
next 1.2;

1.2
date 2013.07.09.08.29.36; author Ashish; state Exp;
branches;
next 1.1;

1.1
date 2013.07.08.09.52.37; author Ashish; state Exp;
branches;
next ;
desc
@Done with tri
trim.
@
1.8
log
@Some modification with refrence to maximum no. of bytes written in a particular scull
Write fn is already done.
moving to read fn.
@
text
@#include”header.h”

MODULE_LICENSE(“GPL”);
//—————————trim Fn————————————————//
int scull_trim(struct Sculldev *fsculldev)
{
if(!fsculldev)
{
printk(KERN_ERR”Error:No Sculldev\n”);
}
printk(“No error “);
return 0;
}

//————————————-SCULL OPEN———————————
int scull_open(struct inode *inodep,struct file *filep)
{
struct Sculldev *pdev;

printk(“\nScull open function start\n”);
pdev=container_of(inodep->i_cdev,struct Sculldev,c_dev); //mapping RAM memory on Device:Sculldev
filep->private_data=pdev; //preserving it on file as lsculldev is lost
if((filep->f_flags & O_ACCMODE)==O_WRONLY)
{
printk(KERN_ALERT “FILE OPEN “);
scull_trim(pdev);
}
printk(“Scull open function complete\n”);
return 0;
}

//—————————Scull realease———————————————
int scull_release(struct inode *node,struct file *filep)
{

printk(“Scull release function start\n”);
printk(“Scull release function complete\n”);
return 0;
}
//——————————Scull Write———————————————–
ssize_t scull_write(struct file *filep,const char __user *ubuff,size_t size,loff_t *loff )
{
struct Sculldev *lsculldev;
struct ScullQset *lscullqset;
int lv,mnobps,nobpq,noq; //nobps=no.of bytes per scull //noq is no. of quantums required.
int ret=noq=0;
int ls=nobpq=mnobps=0; //no. of bytes per quantum
int nobns=0; //no. if byte in next scull
int nobtw=size; //no. of bytes to write
int nobsw=0;int sno=1; //sno is scull no
int nosqs=0; // no. of scull
mnobps=quantum_size * qset_size; //maximum no. of byteis scull
printk(“\nStarting %s”,__func__);
lsculldev=filep->private_data;
if(!lsculldev)
{
printk(KERN_ALERT “ERROR lsculldev Not declared \n “);
}
noq=size/quantum_size; //no of quantum
if(size % quantum_size)
{
noq++;
}
printk(“no of Quantums are %d”,noq);

nosqs=size/(quantum_size * qset_size); //////this is no. of item required
if(size%(quantum_size * qset_size))
{
nosqs++;
}
printk(“No of SQSET require is %d “,nosqs); //finding how much Qset requires
lsculldev->scullqset=create_sqset(nosqs); //creating ScullQset in lsculldc which point to ScullQset
lscullqset=lsculldev->scullqset; //passing whole ScullQset structure
create_qset(lscullqset,nosqs); //passing whole Scullqset structure and no scull qset require
create_quantum(lscullqset,noq);
nobtw=size;
printk(“\n NO of bytes per quantum is %d “,nobpq);

// ret=copy_from_user(lscullqset->data[lv],ubuff,size);
//printk(“\n quantum no is and data : %s”,(char *)lscullqset->data[lv]);
printk(“\n NO of bytes to write is %d “,nobtw);

while(nosqs!=0)
{

if(nobtw>mnobps)
{
nobns=nobtw-mnobps; //no. of byte to write in next shell
nobtw=mnobps;
ls=noq-quantum_size; //in ls we store no. of quantums want in next shell
noq=quantum_size;
}
for(lv=0;lv<noq;lv++)

{
if(nobtw>quantum_size)
{
nobpq=quantum_size;
}
else
{
nobpq=nobtw;
}
ret=copy_from_user(lscullqset->data[lv],ubuff+nobsw,nobpq);//writing 8 bytes in a quantum
printk(“\nScull is %d quantum no is %d and data : %s”,sno,lv,(char *)lscullqset->data[lv]);
nobsw=nobsw+(nobpq-ret); //no of Bytes Sucessfull Written
nobtw=nobtw+(nobpq-ret);
}
noq=ls;
nobtw=nobns;
nosqs–;
sno++;

}
return size-ret ;

printk(“\nLO JI HOGAYA End %s”,__func__);

}
//==========================Creating ScullQset==========================================================
struct ScullQset *create_sqset(int fnosqs) //we use pointer here becaz it returns a an address …pointer
{
struct ScullQset *lscullqset;
struct ScullQset *start;
int flag=0;
int lv;
int count=0;
printk(“\n WE ARE In CREATE SCullQSET “);

for(lv=0;lv<fnosqs;lv++)
{
if(flag==0)
{
lscullqset=start=(struct ScullQset *)kmalloc(sizeof(struct ScullQset),GFP_KERNEL);//as in linklist we preserve first nodee and allocating memory to first node
flag++;
}
else
{
lscullqset->next=(struct ScullQset *)kmalloc(sizeof(struct ScullQset ),GFP_KERNEL);
lscullqset=lscullqset->next;
}
count++;
}
printk(“\nNo. of ScullQset created is %d”,count);
return start;
}

//===================================Creating Qset======================================>>>>>>.>
int create_qset(struct ScullQset *fscullqset,int fnosqs)
{
int lv;
printk(“\n We are in %s\n”,__func__);
for(lv=0;lv<fnosqs;lv++) //it make qset in more than one scull
{
fscullqset->data=kmalloc(sizeof(int *)*qset_size,GFP_KERNEL); //allocating memory to the data pointer of qset data
fscullqset=fscullqset->next; //pointing to next scullqset …
}
printk(“Success fully Ended %s”,__func__);
return 0;
}

//++++++++++++++++++++++++++++++Creating Quantum+++++++++++++++++++++++++++++++++++++++++++

int create_quantum(struct ScullQset *fscullqset,int fnoq)
{
int lv;int lnoq;int count=0;
printk(“Enter in %s”,__func__);
while(fscullqset!=NULL)
{ if(fnoq>quantum_size)
lnoq=quantum_size;
else
lnoq=fnoq;
for(lv=0;lv<lnoq;lv++)
{
fscullqset->data[lv]=kmalloc(quantum_size,GFP_KERNEL); //we are allocating memory in qset ke data me of quantum_size
count++; // no of quantum created
// printk(KERN_ALERT”quantum number=%u”,&fscullqset->data[lv]);
}
fnoq=fnoq-quantum_size;
fscullqset=fscullqset->next;;
}
printk(“\n no of quantum created %d”,count);

printk(“\n Exiting from %s”,__func__);
return 0;

}

//—————————Read Function——————————————————————
ssize_t scull_read(struct file *filep,char __user *ubuff,size_t size,loff_t *loff )
{
//int ret;
printk(“\n Starting %s “,__func__);
//ret=copy_from_user(lscullqset->data[],ubuff,size);
printk(“\nEnd %s”,__func__);
return 0;
}

//=====================================Scull init========================================================
void scull_init(void)
{
printk(“starting__func_\n”);
sculldev->quantum_size=QUANTUM_SIZE;
sculldev->qset_size=QSET_SIZE;
sculldev->data_size=DATA_SIZE;
sculldev->device_size=DEVICE_SIZE;
printk(“Quantum Size is %d “,sculldev->quantum_size);
printk(“\n %s”,__func__);
}

//======================================start=======================================================
static int start(void)
{
printk(KERN_ALERT “WELCOME TO DEVICE DRIVER\n”);
if(!majorno)
{
ret = alloc_chrdev_region(&dev, minorno, nod, DRIVER_NAME);
if(ret==0)
printk(KERN_ALERT “Registration done\n”);
else
printk(“Registration failure\n”);
majorno = MAJOR(dev); //MAJOR Is A Micro to fetch Major no. stored in dev //DEV has major +minor no. =20 bit (major no 12 + minor no 20 )
minorno = MINOR(dev);
}
printk(“Major number assigned is___ %d\n”,majorno);
printk(“Minor number assigned is___ %d\n”,minorno);
sculldev= kmalloc(sizeof(struct Sculldev) * nod, GFP_KERNEL);
memset(sculldev, ”,sizeof(sculldev)*nod);
dev=MKDEV(majorno,minorno);
cdev_init(&sculldev->c_dev, &fop);
sculldev->c_dev.owner=THIS_MODULE; //we goto c_dev owner through sculldec
sculldev->c_dev.ops=&fop;
sculldev->c_dev.count=nod;
cdev_add(&sculldev->c_dev, dev, nod); //c_dev main dev ka add
minorno = MAJOR(sculldev->c_dev.dev);
majorno = MINOR(sculldev->c_dev.dev);
printk(“SEC MINOR value____ %d\n”,minorno);
printk(“SEC MAJOR value____ %d\n”,majorno);
scull_init();
printk(KERN_ALERT “Ho gaya Ji”);
return 0;
}
//=====================================Exit===================================================
static void end(void)
{
printk(KERN_ALERT “bye\n”);
unregister_chrdev_region(dev, nod);
printk(“Unregistration done\n”);
}

module_init(start);
module_exit(end);
@
1.7
log
@Completed Writing in diffrent Quantums as well as in diffrent Scullqset
@
text
@d47 8
a54 9
int noq=0;int nobw=0; //nobw =no. of bytes wrriten
int ret=0;
int lv,ls; //noq is no. of quantums required.
int nobpq=0;
int nobns=0; //no. if byte in next scull
int nobtw=size;
int nobsw=0;int sno=1; //sno is scull no

int nosqs=0; // no. of scull
d88 1
a88 1
if(nobtw>64)
d90 3
a92 5
nobns=nobtw-64; //no. of byte to write in next shell
nobtw=64;
// printk(“\n no. of byte to write in first shell : %d”,nobtw);
// printk(“\n no. of byte to write in first shell : %d”,nobtw);
ls=noq-quantum_size;
d96 1
a96 1
// ret=copy_from_user(scullqset->data[lv],ubuff+nobsw,nobpq); //for writing everytjing in a single quantum
d99 2
a100 1
{ nobpq=quantum_size;
d107 2
a108 2
printk(“\nScull is %d quantum no is %d and data : %s”,sno,lv,(char *)lscullqset->data[lv]);
nobsw=nobsw+(nobpq-ret);
d111 3
a113 5

// printk(“\n no. of byte to write in next shell : %d”,nobns);
noq=ls;
nobtw=nobns;
nosqs–;
@
1.6
log
@maked Qset
@
text
@d47 9
a55 3
int noq=0;
// int ret; //noq is no. of quantums required.
int nosqs=0; // no. of scull
d77 47
a123 1
create_qset(lscullqset,nosqs); //passing whole Scullqset structure and no scull qset require
d125 1
a125 3
printk(“\nLO JI HOGAYA End %s”,__func__);
return 0;
}
d129 1
a129 1
struct ScullQset *lsculldev;
d132 2
d135 4
a138 1
if(flag==0)
d140 1
a140 1
lsculldev=start=(struct ScullQset *)kmalloc(sizeof(struct ScullQset *),GFP_KERNEL);//as in linklist we preserve first nodee and allocating memory to first node
d144 3
a146 3
{
lsculldev->next=(struct ScullQset *)kmalloc(sizeof(struct ScullQset *),GFP_KERNEL);
lsculldev=lsculldev->next;
d148 3
d159 1
a159 1
for(lv=0;lv<fnosqs;lv++)
d162 1
a162 1
fscullqset=fscullqset->next;
d168 29
d203 1
a203 10

 
printk(“\nEnd %s”,__func__);
@
1.5
log
@done with finding quantum size
\.
@
text
@d4 1
a4 1

d15 1
a15 1

d32 1
d42 1
a42 1

d46 3
a48 1
int noq=0; //noq is no. of quantums required.
d68 4
a71 3

lsculldev->scullqset=create_sqset(nosqs);

d73 1
a73 1
printk(“\nLO JI HOGAYA End %s”,__func__);
d76 19
d96 2
a97 1
struct ScullQset *create_sqset(int fnosqs) //we use pointer here becaz it returns a an address …pointer
d99 19
a117 2
struct ScullQset *lsculldev;
struct ScullQset *start;
a118 1
int flag=0;
a119 1
printk(“\n WE ARE In CREATE SQSET “);
a121 10
if(flag==0)
{
lsculldev=start=(struct ScullQset *)kmalloc(sizeof(struct ScullQset *),GFP_KERNEL);
return start;
}
else
{
lsculldev=(struct ScullQset *)kmalloc(sizeof(struct ScullQset *),GFP_KERNEL);
return lsculldev;
}
a123 1
}
a124 3
ssize_t scull_read(struct file *filep,char __user *ubuff,size_t size,loff_t *loff )
{
printk(“\n Starting %s “,__func__);
d129 1
d140 2
d173 1
a173 1

@
1.4
log
@in write define lsculldev
@
text
@d45 2
d53 17
a69 1
printk(“\nEnd %s”,__func__);
d72 24
@
1.3
log
@finally witth trim
@
text
@d44 8
a51 2
printk(“\nStarting %s”,__func__);
printk(“\nEnd %s”,__func__);
@
1.2
log
@./
/
@
text
@d7 3
a9 3
if(!fsculldev)
{
printk(KERN_ERR”Error:No Sculldev\n”);
d11 1
d18 10
a27 13
// struct Sculldev *lsculldev;

printk(“\nScull open function start\n”);
// container_of(inodep->i_cdev,struct Sculldev,c_dev); //mapping RAM memory on Device:Sculldev
// filep->private_data=lsculldev; //preserving it on file as lsculldev is lost
// if((filep->f_flags && O_ACCMODE)==O_WRONLY)
// {
// printk(KERN_ALERT “FILE OPEN “);
// scull_trim(lsculldev);
// }

d45 1
d52 1
d68 5
a72 6
printk(KERN_ALERT “WELCOME TO DEVICE DRIVER\n”);

if(!majorno)
{
ret = alloc_chrdev_region(&dev, minorno, nod, DRIVER_NAME);
if(ret==0)
d79 2
a80 9
// else if(majorno==0)
// {
// dev=MKDEV(majorno,minorno+1);
// ret=register_chrdev_region(dev,nod,DRIVER_NAME);
// }

printk(“Major number assigned is___ %d\n”,majorno);
printk(“Minor number assigned is___ %d\n”,minorno);

a82 1

d85 1
a85 1
sculldev->c_dev.owner=”Ashish”; //we goto c_dev owner through sculldec
a92 1

a94 17

//scull_open();

/* dev= MKDEV(majorno,i);
cdev_init(&sculldev->c_dev, &fop);
sculldev->c_dev.owner=”Ashish”; //we goto c_dev owner through sculldec
sculldev->c_dev.ops=&fop;
sculldev->c_dev.count=nod;
cdev_add(&sculldev->c_dev, dev, nod); //c_dev main dev ka add
majorno = MAJOR(sculldev->c_dev.dev);
minorno = MINOR(sculldev->c_dev.dev);

printk(” MAJOR value____ %d\n”,majorno);
printk(” MINOR value____ %d\n”,minorno);
*/
a97 1

a100 2

a101 1

@
1.1
log
@Initial revision
@
text
@d17 1
a17 1
struct Sculldev *lsculldev;
d20 7
a26 7
container_of(inodep->i_cdev,struct Sculldev,c_dev); //mapping RAM memory on Device:Sculldev
filep->private_data=lsculldev; //preserving it on file as lsculldev is lost
if((filep->f_flags && O_ACCMODE)==O_WRONLY)
{
printk(KERN_ALERT “FILE OPEN “);
scull_trim(lsculldev);
}
@