LINUX—字符设备驱动之-globalmem

下面将以linux设备驱动开发详解上的globalmem设备驱动为例来详细分析字符设备驱动的过程。

#include
<linux/module.h>//模块所需的大量符号和函数定义
#include
<linux/types.h>
#include
<linux/fs.h>//文件系统相关的函数和头文件
#include
<linux/errno.h>
#include
<linux/mm.h>
#include
<linux/sched.h>//包含驱动程序使用的大部分内核API的定义，包括睡眠函数以及各种变量声明
#include
<linux/init.h>//指定初始化和清除函数
#include
<linux/cdev.h>//cdev结构的头文件 包含<linux/kdev_t.h>
#include
<asm/io.h>
#include
<asm/system.h>
#include
<asm/uaccess.h>//在内核和用户空间中移动数据的函数

#define GLOBALMEM_SIZE 0x1000
/*全局内存最大4K字节*/
#define MEM_CLEAR 0x1 /*清0全局内存*/
#define GLOBALMEM_MAJOR 254 /*预设的globalmem的主设备号*/

static int globalmem_major =
GLOBALMEM_MAJOR;
/*globalmem设备结构体*/
struct globalmem_dev

{

struct cdev cdev; /*cdev结构体*/

unsigned char mem[GLOBALMEM_SIZE]; /*全局内存*/
};

struct globalmem_dev *globalmem_devp;
/*设备结构体指针*/
/*文件打开函数*/
int globalmem_open(struct inode *inode,
struct file *filp)
{

/*将设备结构体指针赋值给文件私有数据指针.

系统在调用驱动程序的open方法前将这个指针置为NULL。

驱动程序可以将这个字段用于任意目的，也可以忽略这个字段。

驱动程序可以用这个字段指向已分配的数据，

但是一定要在内核释放file结构前的release方法中清除它*/

filp->private_data = globalmem_devp;

//将文件私有数据private_data指向设备结构体，read，write，ioctl，llseek等函数

//通过private_data访问设备结构体

return 0;
}
/*文件释放函数*/
int globalmem_release(struct inode
*inode, struct file *filp)
{

return 0;
}
/*
备方法应当进行下面的任务:
1、释放
open 分配在
filp->private_data 中的任何东西
2、在最后的
close 关闭设备globalmem_release的基本形式没有硬件去关闭,
因此需要的代码是最少的.不是每个
close 系统调用引起调用
release 方法.
只有真正释放设备数据结构的调用会调用这个方法
*/
/* ioctl设备控制函数
*/
static int globalmem_ioctl(struct inode
*inodep, struct file *filp, unsigned

int cmd, unsigned long arg)
{

struct globalmem_dev *dev = filp->private_data;/*获得设备结构体指针*/

switch (cmd)

{

case MEM_CLEAR://清除全局内存

memset(dev->mem, 0, GLOBALMEM_SIZE);

printk(KERN_INFO "globalmem is set to
zero/n");

break;

default://其他不支持的命令

return -
EINVAL;

}

return 0;
}

/*读函数*/
static ssize_t globalmem_read(struct
file *filp, char __user *buf, size_t size,

loff_t *ppos)
{

unsigned long p =
*ppos;

unsigned int count = size;

int ret = 0;

struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/

/*分析和获取有效的写长度*/

if (p >= GLOBALMEM_SIZE)//0x1000 要读的偏移位置越界

return count ? - ENXIO:
0;

if (count > GLOBALMEM_SIZE - p)//要读的字节数太大

count = GLOBALMEM_SIZE - p;

/*内核空间->用户空间*/

//将内核空间的内容复制到用户空间，所复制的内容是从from来，到to去，复制n个字节。

if (copy_to_user(buf, (void*)(dev->mem + p),
count))

{

ret = -
EFAULT;

}

else

{

*ppos += count;

ret =
count;

printk(KERN_INFO "read %d bytes(s) from %d/n", count,
p);

}

return ret;
}

/*写函数*/
static ssize_t globalmem_write(struct
file *filp, const char __user *buf,

size_t size, loff_t *ppos)
/*
filp
是文件指针，count 是请求的传输数据长度，buff 参数是指向用户空间的缓冲区，这个缓冲区或者保存要写入的数据，或者是一个存放新读入数据的空缓冲区，该地址在内核空间不能直接读写，offp 是一个指针指向一个"long offset type"对象,
它指出用户正在存取的文件位置.
返回值是一个"signed size type。写的位置相对于文件开头的偏移。
*/
{

unsigned long p =
*ppos;

unsigned int count = size;

int ret = 0;

struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/

/*分析和获取有效的写长度*/

if (p >= GLOBALMEM_SIZE)//0x1000 要写的偏移位置越界

return count ? - ENXIO: 0; //？？？

if (count > GLOBALMEM_SIZE - p)//将数据写入该缓存区，直到结尾。这个是判断要写的字节数太多

count = GLOBALMEM_SIZE - p;

/*用户空间->内核空间*/

if (copy_from_user(dev->mem + p, buf,
count))
//目的是从用户空间拷贝数据到内核空间，失败返回没有被拷贝的字节数，成功返回0

ret = -
EFAULT;

else

{

*ppos += count;

ret = count;

printk(KERN_INFO "written %d bytes(s) from %d/n", count,
p);

}

return ret;//如果ret=count，则完成了所请求数目的字节传送。
}

/* seek文件定位函数
*/
/*
seek()函数对文件定位的起始地址可以是文件开头（SEEK_SET，0）、当前位置（SEEK_CUR，1）和文件尾（SEEK_END，2），globalmem支持从文件开头和当前位置相对偏移。在定位的时候，应该检查用户请求的合法性，若不合法，函数返回-
EINVAL，合法时返回文件的当前位置*/
static loff_t globalmem_llseek(struct
file *filp, loff_t offset, int orig)
{

loff_t ret = 0;

switch (orig)

{

case 0: /*相对文件开始位置偏移*/

if (offset < 0)

{

ret = -
EINVAL;

break;

}

if ((unsigned int)offset > GLOBALMEM_SIZE)//偏移越界

{

ret = -
EINVAL;

break;

}

filp->f_pos = (unsigned int)offset;//struct
file

ret = filp->f_pos;

break;

case 1: /*相对文件当前位置偏移*/

if ((filp->f_pos + offset) > GLOBALMEM_SIZE)//偏移越界

{

ret = -
EINVAL;

break;

}

if ((filp->f_pos + offset)
< 0)

{

ret = -
EINVAL;

break;

}

filp->f_pos += offset;

ret = filp->f_pos;

break;

default:

ret = -
EINVAL;

break;

}

return ret;//合法时返回文件的当前位置
}

/*文件操作结构体*/
static const struct file_operations
globalmem_fops =
{

.owner = THIS_MODULE,

.llseek = globalmem_llseek,

.read = globalmem_read,

.write = globalmem_write,

.ioctl = globalmem_ioctl,

.open = globalmem_open,

.release = globalmem_release,
};

/*初始化并注册cdev
globalmem_setup_cdev(globalmem_devp,
0);*/
static void globalmem_setup_cdev(struct
globalmem_dev *dev, int index)
{

int err, devno = MKDEV(globalmem_major,
index);

cdev_init(&dev->cdev,
&globalmem_fops);

/*将 cdev
结构嵌入一个你自己的设备特定的结构,你应当初始化你已经分配的结构使用以上函数，有一个其他的 struct cdev
成员你需要初始化.
象 file_operations
结构,struct cdev
有一个拥有者成员,应当设置为
THIS_MODULE，一旦 cdev
结构建立,
最后的步骤是把它告诉内核,
调用:

cdev_add(&dev->cdev, devno, 1);*/

/*void cdev_init(struct cdev *cdev, const struct file_operations
*fops)
{

memset(cdev, 0, sizeof *cdev);

INIT_LIST_HEAD(&cdev->list);

cdev->kobj.ktype =
&ktype_cdev_default;

kobject_init(&cdev->kobj);

cdev->ops = fops;
}
*/
/*
struct cdev
{

struct kobject kobj;

struct module *owner;

const struct file_operations *ops;

struct list_head list;

dev_t dev;

unsigned int count;
};
/*globalmem设备结构体*/
struct globalmem_dev

{

struct cdev cdev; /*cdev结构体*/

unsigned char mem[GLOBALMEM_SIZE]; /*全局内存*/
};
*/

dev->cdev.owner = THIS_MODULE;

dev->cdev.ops = &globalmem_fops;

err = cdev_add(&dev->cdev, devno, 1);
/*
cdev
是
cdev 结构, devno
是这个设备响应的第一个设备号, count
是应当关联到设备的设备号的数目.
常常 count
是 1,
但是有多个设备号对应于一个特定的设备的情形.
例如,
设想 SCSI
磁带驱动,
它允许用户空间来选择操作模式(例如密度),
通过安排多个次编号给每一个物理设备.在使用 cdev_add
是有几个重要事情要记住.
第一个是这个调用可能失败.
如果它返回一个负的错误码,

你的设备没有增加到系统中.
它几乎会一直成功,
但是,
并且带起了其他的点: cdev_add
一返回,
你的设备就是"活的"并且内核可以调用它的操作.
除非你的驱动完全准备好处理设备上的操作,
你不应当调用 cdev_add */

if (err)

printk(KERN_NOTICE "Error %d adding LED%d", err,
index);
}

/*设备驱动模块加载函数*/
/*_init()：__init是一个宏，编译时会用到。对于静态编译在内核的 模块有意义.
内核使用了大量不同的宏来标记具有不同作用的函数和数据结构。如宏__init、__devinit等。
这些宏在include/linux/init.h头文件中定义。编译器通过这些宏可以把代码优化放到合适的内存位置，
以减少内存占用和提高内核效率。
init()：标记内核启动时使用的初始化代码，内核启动完成后不再需要。以此标记的代码位于.init.text内存区域。
#define _ _init _ _attribute_ _ ((_ _section_ _
(".text.init")))
初始化代码的特点是：在系统启动运行，且一旦运行后马上退出内存，不再占用内存。
*/
int
globalmem_init(void)
{

int result;

dev_t devno = MKDEV(globalmem_major, 0);

/*通过主次设备号生成dev_t.
主次设备号的数据类型是dev_t，在/linux/types.h中定义。
在2.6内核中，dev_t是一个32位的数，其中12位用来表示主设备号，
其余20位用来表示次设备号。要获得设备的主次设备号可以使用内核提供的宏：
MAJOR(dev_t dev);
#获得主设备号
MINOR(dev_t dev);
#获得次设备号
这些宏定义位于linux/kdev_t.h中。如果要把主次设备号转换成dev_t类型，
则可使用：
MKDEV(int major, int
minor);*/

/* 申请设备号*/

if (globalmem_major)/*静态申请设备号*/

result = register_chrdev_region(devno, 1,
"globalmem");

/*在linux/fs.h中，

devno：是你要分配的起始设备编号.
devno的次编号部分常常是 0,
但是没有要求是那个效果；

1：是所请求的连续设备号的个数;
globalmem：是和该设备号范围关联的设备名称，它将出现在/proc/devices或/sysfs中。
如果分配成功则返回0，分配失败则返回一个负的错误码，所请求的设备号无效。

*/

else /* 动态申请设备号*/

{

result = alloc_chrdev_region(&devno, 0, 1,
"globalmem");

/*dev_t *dev

dev：是一个只输出的参数,
它在函数成功完成时持有你的分配范围的第一个数;

firstminor：应当是请求的第一个要用的次编号;
它常常是
0；

1： 是所请求的连续设备号的个数;

Globalmem：是和该设备号范围关联的设备名称，它将出现在/proc/devices或/sysfs中。*/

globalmem_major = MAJOR(devno);/*获得主设备号,从dev_t结构中分解出主设备号*/

}
/*
如果globalmem_major=0，利用udev工具自动向系统动态申请未被占用的设备号相关函数定义在include/linux/kdev_t.h中
#define
MINORBITS
20
#define
MINORMASK ((1U << MINORBITS) -
1)
//(1<<20
-1) 此操作后，MINORMASK宏的低20位为1，高12位为0

#define
MAJOR(dev) ((unsigned int) ((dev)
>> MINORBITS))
#define
MINOR(dev) ((unsigned int) ((dev)
& MINORMASK))
#define
MKDEV(ma,mi) (((ma) << MINORBITS) |
(mi))
*/

if (result < 0)

return result;

/* 动态申请设备结构体的内存*/

globalmem_devp = kmalloc(sizeof(struct globalmem_dev),
GFP_KERNEL);

/*

在设备驱动程序中动态开辟内存，不是用malloc，而是kmalloc，或者用get_free_pages直接申请页。释放内存用的是kfree，或free_pages. 请注意，kmalloc等函数返回的是物理地址！而malloc等返回的是线性地址！要注意kmalloc最大只能开辟128k-16，16个字节是被页描述符结构占用了。内存映射的I/O口，寄存器或者是硬件设备的RAM(如显存)一般占用F0000000以上的地址空间。在驱动程序中不能直接访问，要通过kernel函数vremap获得重新映射以后的地址*/

if (!globalmem_devp)
/*申请失败*/

{

result = -
ENOMEM;

goto fail_malloc;

}

memset(globalmem_devp, 0, sizeof(struct
globalmem_dev));

/*memset会将参数globalmem_devp所指的内存区域中前sizeof(struct globalmem_dev)个字节以参数0填入，然后返回指向globalmem_devp的指针*/

globalmem_setup_cdev(globalmem_devp, 0);

/*初始化并注册cdev*/

return 0;

fail_malloc: unregister_chrdev_region(devno,
1);

/*释放原先申请的设备号

如果我们不再使用设备号，则要使用unregister_chrdev_region()函数释放它。

devno：是要分配的主设备号范围的起始值，次设备号一般设置为0；

1：是所请求的连续设备号的个数;*/

return result;
}

/*模块卸载函数*/
/*
__exit，标记退出代码，对于非模块无效。
*/
void
globalmem_exit(void)
{

cdev_del(&globalmem_devp->cdev);
/*注销cdev,为从系统去除一个字符设备*/

kfree(globalmem_devp);
/*释放设备结构体内存*/

unregister_chrdev_region(MKDEV(globalmem_major, 0), 1);

/*释放设备号

我们一般在模块的清除函数中调用设备号释放函数。*/
}

MODULE_AUTHOR("Song
Baohua");
MODULE_LICENSE("Dual
BSD/GPL");//指定代码使用的许可证

module_param(globalmem_major, int,
S_IRUGO);
/*module_param宏的第一个参数是选项名，可在/sys虚拟文件系统中该模块的parameter目录中中查看到。第二个参数是选项类型，第三个参数是选项的值*/

module_init(globalmem_init);
module_exit(globalmem_exit);
/*向操作系统注册自己定义的这两个函数，该项目在Kconfig中配置项目为布尔型的话为Y和N两种选项，Y为编译进内核，N不编译，如果为三态型（tristate），为Y，N，M三种选项M为编译为模块，模块也可以在内核编译后根据需要进行手动加载，也可以写个脚本自动加载*/

总结：
字符设备是3大类设备（字符设备、块设备和网络设备）中较简单的一类设备，其驱动程序中完成的主要工作是初始化、添加和删除cdev结构体，申请和释放设备号，以及填充file_opersation结构体中的操作函数，实现file_opersation结构体中的read()、write()和ioctl()等函数是驱动设计的主体工作。
http://blogold.chinaunix.net/u3/104334/showart_2061894.html