深入浅出：Linux设备驱动之字符设备驱动

本文是转载外加自己的一些理解与知识点的添加，对初学者的引导自学较好

一、linux系统将设备分为3类：字符设备、块设备、网络设备。使用驱动程序：

• 字符设备：是指只能一个字节一个字节读写的设备，不能随机读取设备内存中的某一数据，读取数据需要按照先后数据。字符设备是面向流的设备，常见的字符设备有鼠标、键盘、串口、控制台和LED设备等。
• 块设备：是指可以从设备的任意位置读取一定长度数据的设备。块设备包括硬盘、磁盘、U盘和SD卡等。以“块”为单位；创建的块设备：nand flash、SD卡、u盘、硬盘、inand......

块设备和字符设备的区别
1、字符设备是以数据流的形式实现数据在应用程序和驱动程序之间交互；数据传输的时候，是以字节为单位
   块设备是数据块（1block = 1kB）的形式实现驱动程序的访问；数据传输的时候，是以块为单位

2、字符设备访问驱动时，访问数据是实时的，是不带有缓存
   块设备访问驱动是，数据不是实时的，首先去缓存中去访问，如果缓存中没有数据或数据已经满了，再去块设备上去访问；所以块设备是有缓存的。

3、字符设备一般应用程序和驱动程序之间交互的数据量比较少。如果字符设备数据量较大（例如：显卡framebuffer、声卡、视频解码、...）采用的方法是：mmap--->将驱动程序中显存的虚拟地址映射到用户空间，这样用户空间就可以直接访问显存，而不需要使用write()函数，提高了效率。
   块设备一般交互的数据量比较大。

4、字符设备上没有文件系统：应用程序--->系统调用--->VFS--->字符设备驱动--->file_operations--->接口函数
   块设备上都要文件系统来管理，nand---yaffs2   SD---vfat：应用程序 ---> 系统调用--->vfs--->块设备缓存--->块设备文件系统---->块设备IO调度器（电梯调度器）--->块数据进行排序或合并--->通过request将数据写到块设备。

每一个字符设备或块设备都在/dev目录下对应一个设备文件。linux用户程序通过设备文件（或称设备节点）来使用驱动程序操作字符设备和块设备。

二、字符设备、字符设备驱动与用户空间访问该设备的程序三者之间的关系。

如图，在Linux内核中使用cdev结构体来描述字符设备，通过其成员dev_t来定义设备号（分为主、次设备号）以确定字符设备的唯一性。通过其成员file_operations来定义字符设备驱动提供给VFS的接口函数，如常见的open()、read()、write()等。

在Linux字符设备驱动中，模块加载函数通过register_chrdev_region( ) 或alloc_chrdev_region( )来静态或者动态获取设备号，通过cdev_init( )建立cdev与file_operations之间的连接，通过cdev_add( )向系统添加一个cdev以完成注册。模块卸载函数通过cdev_del( )来注销cdev，通过unregister_chrdev_region( )来释放设备号。

用户空间访问该设备的程序通过Linux系统调用，如open( )、read( )、write( )，来“调用”file_operations来定义字符设备驱动提供给VFS的接口函数。

三、字符设备驱动模型

1. 驱动初始化

相关知识点：

module_init(init_function);

module_exit(exit_function);

linux驱动是以模块化来进行编程的module_init 说明init_function函数是驱动程序的入口，module_exit说明函数exit_function是驱动函数的出口函数。驱动不像应用程序只有入口，他还有出口，当我们执行 insmod *.ko 函数师就会执行入口函数，rmmod * 时执行退出函数。

linux相关目录

/dev---设备文件，设备节点

/proc--内核相关属性文件

/sys--与/proc目录一样是虚拟文件  驱动的详细信息  cdev  kobject 结构代表的就是里面的每一个目录

/sys/device --设备名称

/usr --应用程序就是安装在这里

/var --运行时需改变的数据

/media --挂在点

/etc --环境变量点

cat /proc/devices   查看设备名称和主设备号

相关变量/结构体

cdev ---字符设备

dev_t --设备号

file_oprations --字符设备集

file --文件对象（工作在内核；FILE 工作在用户空间）

chrdevs --- 字符类散列表  255个，每一个主设备号对应一个，大于就取余

class --设备类

bus --设备总线；驱动与设备都挂载在其上面，通过其成员函数mach进行匹配连接

主设备号：标识与设备文件相连的驱动程序，标识设备的类型

次设备号：辨别是哪一种设备

1.1. 分配cdev

在2.6的内核中使用cdev结构体来描述字符设备，在驱动中分配cdev,主要是分配一个cdev结构体与申请设备号，以按键驱动为例：

申请设备号：动态申请与静态申请

/*************************************************************/

static  int led_major = 0;
static  int led_minor = 0; 

dev_t  led_no;

static int __init  led_init(void) 
{
int ret;
led_no = MKDEV(led_major, led_minor);
if(led_no != 0){
ret = register_chrdev_region(led_no,  1, "led_driver"); //静态申请设备号
if(ret < 0){
printk("failed to  register_chrdev_region\n");
return -EBUSY;
}
}else{
ret = alloc_chrdev_region(&led_no, led_minor, 1, "led_driver"); //动态申请设备号
if(ret < 0){
printk("failed to  alloc_chrdev_region\n");
return -EBUSY;
}
}

return 0；
}




static void __exit led_exit(void)
{
unregister_chrdev_region(led_no, 1);
printk("good bye\n");
}

module_init(led_init); 
module_exit(led_exit);

/*************************************************************/

从上面的代码可以看出，申请设备号有动静之分，其实设备号还有主次之分。

在Linux中以主设备号用来标识与设备文件相连的驱动程序。次编号被驱动程序用来辨别操作的是哪个设备。cdev 结构体的 dev_t 成员定义了设备号，为 32 位，其中高 12 位为主设备号，低20 位为次设备号。

设备号的获得与生成：

获得：主设备号：MAJOR(dev_t dev);

次设备号：MINOR(dev_t dev);

生成：MKDEV(int major,int minor);

设备号申请的动静之分：

静态：

int register_chrdev_region(dev_t first, unsigned int count, char *name);

first是你要分配的起始设备编号.

count是你请求的连续设备编号的总数

name设备的名字; 它会出现在 /proc/devices 和 sysfs 中.

静态申请相对较简单，但是一旦驱动被广泛使用,这个随机选定的主设备号可能会导致设备号冲突，而使驱动程序无法注册。

动态：

1 2	1 int alloc_chrdev_region ( dev_t * dev , unsigned baseminor , unsigned count , const char * name )； 2 /*功能：请求内核动态分配count个设备号，且次设备号从baseminor开始。*/

动态申请简单，易于驱动推广，但是无法在安装驱动前创建设备文件（因为安装前还没有分配到主设备号）。

1.2. 初始化cdev

1 2	1 void cdev_init ( struct cdev * , struct file_operations * ) ; 2 cdev_init ( )函数用于初始化 cdev 的成员，并建立 cdev 和 file _operations 之间的连接。

1.3. 注册cdev

C

1 2	1 int cdev_add ( struct cdev * , dev_t , unsigned ) ; 2 　　　　 cdev_add ( )函数向系统添加一个 cdev，完成字符设备的注册。

/********************************************************************************************/

#include <linux/module.h>  
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/device.h>

static  struct cdev led_dev;
static  int led_major = 0;
static  int led_minor = 0; 
dev_t  led_no;

static  const  struct file_operations led_fops = {
.owner = THIS_MODULE,
.open     = led_open,
.write     = led_write,
.release = led_release,
} ;




static int __init  led_init(void) 
{
int ret;
led_no = MKDEV(led_major, led_minor);
if(led_no != 0){
ret = register_chrdev_region(led_no,  1, "led_driver");
if(ret < 0){
printk("failed to  register_chrdev_region\n");
return -EBUSY;
}
}else{
ret = alloc_chrdev_region(&led_no, led_minor, 1, "led_driver");
if(ret < 0){
printk("failed to  alloc_chrdev_region\n");
return -EBUSY;
}
}

cdev_init(&led_dev,  &led_fops);



ret = cdev_add(&led_dev, led_no, 1);
if(ret < 0){
printk("failed to  cdev add\n");
goto failed_cdev_add;
}

return 0;

failed_request_mem_region:
cdev_del(&led_dev);

failed_cdev_add:
unregister_chrdev_region(led_no, 1);


return ret;


}


static void __exit led_exit(void)
{

cdev_del(&led_dev);
unregister_chrdev_region(led_no, 1);
printk("good bye\n");
}


module_init(led_init); 
module_exit(led_exit);

/********************************************************************************************/

1.4. 硬件初始化

硬件初始化主要是硬件资源的申请与配置，以TQ210的按键驱动为例：

C

1 2 3 4 5

1 /* 1.4 硬件初始化*/ 2 //申请GPIO资源 3 gpio_request ( S5PV210_GPH0 ( 0 ) , "GPH0_0" ) ; 4 //配置输入 5 gpio_direction_input ( S5PV210_GPH0 ( 0 ) ) ; //获取gpio的值 gpio_get_value(gpio) //设置gpio的值 gpio_set_value(gpio); //设置gpio端口的输入或输出 gpio_direction_input(gpio); gpio_direction_output(gpio); //检测gpio是否合法 gpio_is_valid(gpio); //将gpio设置为中断口 gpio_to_irq(gpio)//返回中断号 //irq中断申请 request_irq,free_irq,gpio_export,gpio_free

2.实现设备操作

用户空间的程序以访问文件的形式访问字符设备，通常进行open、read、write、close等系统调用。而这些系统调用的最终落实则是file_operations结构体中成员函数，它们是字符设备驱动与内核的接口。以TQ210的按键驱动为例：

C

1 2 3 4 5 6 7

1 /*设备操作集合*/ 2 static struct file_operations btn_fops = { 3 . owner = THIS_MODULE , 4 . open = button_open , 5 . release = button_close , 6 . read = button _read 7 } ;

上面代码中的button_open、button_close、button_read是要在驱动中自己实现的。file_operations结构体成员函数有很多个，下面就选几个常见的来展示：

2.1. open（）函数

原型：

C

1 2	1 int ( * open ) ( struct inode * , struct file * ) ; 2 /*打开*/

2.2. read( )函数

原型：

C

1 2	ssize_t ( * read ) ( struct file * , char __user * , size_t , loff_t * ) ; /*用来从设备中读取数据，成功时函数返回读取的字节数，出错时返回一个负值*/

2.3. write( )函数

原型：

C

1 2 3

1 ssize_t ( * write ) ( struct file * , const char__user * , size_t , loff_t * ) ; 2 /*向设备发送数据，成功时该函数返回写入的字节数。如果此函数未被实现， 3 当用户进行write()系统调用时，将得到-EINVAL返回值*/

2.4. close( )函数

原型：

C

1 2	1 int ( * release ) ( struct inode * , struct file * ) ; 2 /*关闭*/

2.5. 补充说明

1. 在Linux字符设备驱动程序设计中，有3种非常重要的数据结构：struct file、struct inode、struct file_operations。

struct file 代表一个打开的文件。系统中每个打开的文件在内核空间都有一个关联的struct file。它由内核在打开文件时创建, 在文件关闭后释放。其成员loff_t f_pos 表示文件读写位置。

struct inode 用来记录文件的物理上的信息。因此,它和代表打开文件的file结构是不同的。一个文件可以对应多个file结构,但只有一个inode结构。其成员dev_t i_rdev表示设备号。

struct file_operations 一个函数指针的集合，定义能在设备上进行的操作。结构中的成员指向驱动中的函数,这些函数实现一个特别的操作, 对于不支持的操作保留为NULL。

2. 在read( )和write( )中的buff 参数是用户空间指针。因此,它不能被内核代码直接引用，因为用户空间指针在内核空间时可能根本是无效的——没有那个地址的映射。因此，内核提供了专门的函数用于访问用户空间的指针：

C

1 2	1 unsigned long copy_from_user ( void * to , const void __user * from , unsigned long count ) ; 2 unsigned long copy_to_user ( void __user * to , const void * from , unsigned long count ) ;

3. 驱动注销

3.1. 删除cdev

在字符设备驱动模块卸载函数中通过cdev_del()函数向系统删除一个cdev，完成字符设备的注销。

C

1 2 3 4

/*原型：*/ void cdev_del ( struct cdev * ) ; /*例：*/ cdev_del ( & btn_cdev ) ;

3.2. 释放设备号

在调用cdev_del()函数从系统注销字符设备之后，unregister_chrdev_region()应该被调用以释放原先申请的设备号。

C

1 2 3 4

/*原型：*/ void unregister_chrdev_region ( dev_t from , unsigned count ) ; /*例：*/ unregister_chrdev_region ( MKDEV ( major , 0 ) , 1 ) ;

四、字符设备驱动程序基础:

4.1 cdev结构体

在Linux2.6 内核中，使用cdev结构体来描述一个字符设备，cdev结构体的定义如下：

C

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

1 struct cdev { 2 3 struct kobject kobj ; 4 5 struct module * owner ; /*通常为THIS_MODULE*/ 6 7 struct file_operations * ops ; /*在cdev_init()这个函数里面与cdev结构联系起来*/ 8 9 struct list_head list ; 10 11 dev_t dev ; /*设备号*/ 12 13 unsigned int count ; 14 15 }；

cdev 结构体的dev_t 成员定义了设备号，为32位，其中12位是主设备号，20位是次设备号，我们只需使用二个简单的宏就可以从dev_t 中获取主设备号和次设备号：

MAJOR(dev_t dev)

MINOR(dev_t dev)

相反地，可以通过主次设备号来生成dev_t：

MKDEV(int major,int minor)

4.2 Linux 2.6内核提供一组函数用于操作cdev 结构体

C

1 2 3 4

1： void cdev_init ( struct cdev * , struct file_operations * ) ; 2： struct cdev * cdev_alloc ( void ) ; 3： int cdev_add ( struct cdev * , dev_t , unsigned ) ; 4： void cdev_del ( struct cdev * ) ;

其中（1）用于初始化cdev结构体，并建立cdev与file_operations 之间的连接。（2）用于动态分配一个cdev结构，（3）向内核注册一个cdev结构，（4）向内核注销一个cdev结构

4.3 Linux 2.6内核分配和释放设备号

在调用cdev_add()函数向系统注册字符设备之前，首先应向系统申请设备号，有二种方法申请设备号，一种是静态申请设备号：

5：int register_chrdev_region(dev_t from,unsigned count,const char *name)

另一种是动态申请设备号：

6：int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count,const char *name);

其中，静态申请是已知起始设备号的情况，如先使用cat /proc/devices 命令查得哪个设备号未事先使用（不推荐使用静态申请）；动态申请是由系统自动分配，只需设置major = 0即可。

相反地，在调用cdev_del()函数从系统中注销字符设备之后，应该向系统申请释放原先申请的设备号，使用：

7：void unregister_chrdev_region(dev_t from,unsigned count);

4.4 cdev结构的file_operations结构体

这个结构体是字符设备当中最重要的结构体之一，file_operations 结构体中的成员函数指针是字符设备驱动程序设计的主体内容，这些函数实际上在应用程序进行Linux 的 open()、read()、write()、close()、seek()、ioctl()等系统调用时最终被调用。

C

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52

1 struct file_operations { 2 3 /*拥有该结构的模块计数，一般为THIS_MODULE*/ 4 struct module * owner ; 5 6 /*用于修改文件当前的读写位置*/ 7 loff_t ( * llseek ) ( struct file * , loff_t , int ) ; 8 9 /*从设备中同步读取数据*/ 10 ssize_t ( * read ) ( struct file * , char __user * , size_t , loff_t * ) ; 11 12 /*向设备中写数据*/ 13 ssize_t ( * write ) ( struct file * , const char __user * , size_t , loff_t * ) ; 14 15 16 ssize_t ( * aio_read ) ( struct kiocb * , const struct iovec * , unsigned long , loff_t ) ; 17 ssize_t ( * aio_write ) ( struct kiocb * , const struct iovec * , unsigned long , loff_t ) ; 18 int ( * readdir ) ( struct file * , void * , filldir_t ) ; 19 20 /*轮询函数，判断目前是否可以进行非阻塞的读取或写入*/ 21 unsigned int ( * poll ) ( struct file * , struct poll_table_struct * ) ; 22 23 /*执行设备的I/O命令*/ 24 int ( * ioctl ) ( struct inode * , struct file * , unsigned int , unsigned long ) ; 25 26 27 long ( * unlocked_ioctl ) ( struct file * , unsigned int , unsigned long ) ; 28 long ( * compat_ioctl ) ( struct file * , unsigned int , unsigned long ) ; 29 30 /*用于请求将设备内存映射到进程地址空间*/ 31 int ( * mmap ) ( struct file * , struct vm_area_struct * ) ; 32 33 /*打开设备文件*/ 34 int ( * open ) ( struct inode * , struct file * ) ; 35 int ( * flush ) ( struct file * , fl_owner_t id ) ; 36 37 /*关闭设备文件*/ 38 int ( * release ) ( struct inode * , struct file * ) ; 39 40 41 int ( * fsync ) ( struct file * , struct dentry * , int datasync ) ; 42 int ( * aio_fsync ) ( struct kiocb * , int datasync ) ; 43 int ( * fasync ) ( int , struct file * , int ) ; 44 int ( * lock ) ( struct file * , int , struct file_lock * ) ; 45 ssize_t ( * sendpage ) ( struct file * , struct page * , int , size_t , loff_t * , int ) ; 46 unsigned long ( * get_unmapped_area ) ( struct file * , unsigned long , unsigned long , unsigned long , unsigned long ) ; 47 int ( * check_flags ) ( int ) ; 48 int ( * flock ) ( struct file * , int , struct file_lock * ) ; 49 ssize_t ( * splice_write ) ( struct pipe_inode_info * , struct file * , loff_t * , size_t , unsigned int ) ; 50 ssize_t ( * splice_read ) ( struct file * , loff_t * , struct pipe_inode_info * , size_t , unsigned int ) ; 51 int ( * setlease ) ( struct file * , long , struct file_lock * * ) ; 52 } ;

4.5 file结构

file 结构代表一个打开的文件，它的特点是一个文件可以对应多个file结构。它由内核再open时创建，并传递给在该文件上操作的所有函数，直到最后close函数，在文件的所有实例都被关闭之后，内核才释放这个数据结构。

在内核源代码中，指向 struct file 的指针通常比称为filp，file结构有以下几个重要的成员：

C

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

1 struct file { 2 3 mode_t fmode ; /*文件模式，如FMODE_READ，FMODE_WRITE*/ 4 5 . . . . . . 6 7 loff_t f_pos ; /*loff_t 是一个64位的数，需要时，须强制转换为32位*/ 8 9 unsigned int f_flags ; /*文件标志，如：O_NONBLOCK*/ 10 11 struct file_operations * f_op ; 12 13 void * private_data ; /*非常重要，用于存放转换后的设备描述结构指针*/ 14 15 . . . . . . . 16 17 } ;

4.6 inode 结构

内核用inode 结构在内部表示文件，它是实实在在的表示物理硬件上的某一个文件，且一个文件仅有一个inode与之对应，同样它有二个比较重要的成员：

C

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

1 struct inode { 2 3 dev_t i_rdev ; /*设备编号*/ 4 5 struct cdev * i_cdev ; /*cdev 是表示字符设备的内核的内部结构*/ 6 7 } ; 8 9 可以从 inode中获取主次设备号，使用下面二个宏： 10 11 /*驱动工程师一般不关心这二个宏*/ 12 13 unsigned int imajor ( struct inode * inode ) ; 14 15 unsigned int iminor ( struct inode * inode ) ;

4.7字符设备驱动模块加载与卸载函数

在字符设备驱动模块加载函数中应该实现设备号的申请和cdev 结构的注册，而在卸载函数中应该实现设备号的释放与cdev结构的注销。

我们一般习惯将cdev内嵌到另外一个设备相关的结构体里面，该设备包含所涉及的cdev、私有数据及信号量等等信息。常见的设备结构体、模块加载函数、模块卸载函数形式如下：

C

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

1 /*设备结构体*/ 2 3 struct xxx_dev { 4 5 struct cdev cdev ; 6 7 char * data ; 8 9 struct semaphore sem ; 10 11 . . . . . . 12 13 } ; 16 17 /*模块加载函数*/ 18 19 static int __init xxx_init ( void ) 20 21 { 22 23 . . . . . . . 24 25 初始化 cdev结构 ; 26 27 申请设备号； 28 29 注册设备号； 32 33 申请分配设备结构体的内存； /*非必须*/ 34 35 } 36 37 38 39 /*模块卸载函数*/ 40 41 static void __exit xxx_exit ( void ) 42 43 { 44 45 . . . . . . . 46 47 释放原先申请的设备号； 48 49 释放原先申请的内存； 50 51 注销 cdev设备； 52 53 } 54 55

4.8字符设备驱动的 file_operations 结构体重成员函数

C

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

1 /*读设备*/ 2 3 ssize_t xxx_read ( struct file * filp , char __user * buf , size_t count , loff_t * f_pos ) 4 5 { 6 7 . . . . . . 8 9 使用 filp -> private _data获取设备结构体指针； 10 11 分析和获取有效的长度； 12 13 /*内核空间到用户空间的数据传递*/ 14 15 copy_to_user ( void __user * to , const void * from , unsigned long count ) ; 16 17 . . . . . . 18 19 } 20 21 /*写设备*/ 22 23 ssize_t xxx_write ( struct file * filp , const char __user * buf , size_t count , loff_t * f_pos ) 24 25 { 26 27 . . . . . . 28 29 使用 filp -> private _data获取设备结构体指针； 30 31 分析和获取有效的长度； 32 33 /*用户空间到内核空间的数据传递*/ 34 35 copy_from_user ( void * to , const void __user * from , unsigned long count ) ; 36 37 . . . . . . 38 39 } 40 41 /*ioctl函数*/ 42 43 static int xxx_ioctl ( struct inode * inode , struct file * filp , unsigned int cmd , unsigned long arg ) 44 45 { 46 47 . . . . . . 48 49 switch ( cmd ) { 50 51 case xxx_CMD1 : 52 53 . . . . . . 54 55 break ; 56 57 case xxx_CMD2 : 58 59 . . . . . . . 60 61 break ; 62 63 default : 64 65 return - ENOTTY ; /*不能支持的命令*/ 66 67 } 68 69 return 0 ; 70 71 }

4.9、字符设备驱动文件操作结构体模板

C

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

1 struct file_operations xxx_fops = { 2 3 . owner = THIS_MODULE , 4 5 . open = xxx_open , 6 7 . read = xxx_read , 8 9 . write = xxx_write , 10 11 . close = xxx_release , 12 13 . ioctl = xxx_ioctl , 14 15 . lseek = xxx_llseek , 16 17 } ; 18 19 上面的写法需要注意二点，一：结构体成员之间是以逗号分开的而不是分号，结构体字段结束时最后应加上分号。

五、字符设备驱动小结：

字符设备是3大类设备（字符设备、块设备、网络设备）中较简单的一类设备，其驱动程序中完成的主要工作是初始化、添加和删除cdev结构体，申请和释放设备号，以及填充file_operation结构体中操作函数，并实现file_operations结构体中的read()、write()、ioctl()等重要函数。如图所示为cdev结构体、file_operations和用户空间调用驱动的关系。

/*****************************************************************/

驱动模块的安装

insmod *.ko

建立设备与驱动之间的联系：mknod   设备名称  设备类型  设备号范围最大  设备号范围最小

例子：mknod /dev/my_dev  c  254 0

字符设备驱动设计的一般过程：

1、定义一个字符设备；static struct cdev my_dev

2、申请一个设备号：静态\动态申请，

cdev_t,register_chrdev_region() MKDEV(),MKJOR(),MINOR(),unregister_chrdev_region()

alloc_chrdev_region()，unregister_chrdev_region()；

3、定义并初始化一个字符设备集file_opration；

static struct file_opration my_fops

{

.owner=THIS_MODULE,//设备所在模块，THIS_MODULE表示在本模块内

.open=my_open,//当在应用程序中open设备文件时会调用本函数，可以不写

.write=my_write,

.release=my__release,

......................

};

4、字符设备的初始化

cdev_init(cdev,file_opration)；//将file_opration与cdev结合起来

5、将字符设备注册到内核

cdev_add(cdev,cdev_t);//将cdev与设备号连接起来

6、创建设备文件

法一：  命令行模式

insmod *.ko

mknod 设备名称  设备类型  设备最大可能设备号  设备最小可能设备号

法二:函数代码方式

struct class * class_create(所属模块，"设备名称类")；class_destroy(class *)

device_create(class *,类名,设备号，null,"设备名称"）；device_destroy(class *，设备号)

insmod *.ko

例子：

led_class = class_create(THIS_MODULE,  "led_class");

led_device = device_create(led_class, NULL, led_no, NULL, "led_drv");

入口函数带参数：像main函数一样

module_part(变量名，类型，权限)；module_part(count,int,644);

命令行：insmod  *.ko count=1

你本文件驱动函数需要在其他文件中引用：像应用程序的外部函数一样

在驱动函数中发布出去：export_symbol(函数名)；

在需要引用的文件中：extern  void *function(void);

/***************************************************************/