字符设备驱动

一． 知识点

1. 设备号；

2. 创建设备文件；

3. 设备注册；

4. 重要数据结构；

5. 设备操作；

二．主设备号

字符设备通过字符设备文件来存取。字符设备文件由使用ls -l 的输出的第一列的”C”标识；

如果使用ls –l 命令，会看到在设备文件项中有2个数（由一个逗号分隔）这些数字就是设备文件的主次设备编

举例：

crw-rw---- 1 root uucp 4, 66 04-18 21:59 ttyS2

crw-rw---- 1 root uucp 4, 67 04-18 21:59 ttyS3

crw-rw-rw- 1 root root 1, 9 04-18 22:00 urandom

crw-rw---- 1 root root 249, 0 04-18 22:00 usbdev1.1_ep00

crw-rw---- 1 root root 249, 1 04-18 22:00 usbdev1.1_ep81

crw-rw---- 1 root root 249, 2 04-18 22:00 usbdev2.1_ep00

crw-rw---- 1 root root 249, 3 04-18 22:00 usbdev2.1_ep81

crw-rw---- 1 root root 251, 0 04-18 22:00 usbmon0

crw-rw---- 1 root root 251, 1 04-18 22:00 usbmon1

crw-rw---- 1 root root 251, 2 04-18 22:00 usbmon2

crw-rw---- 1 vcsa tty 7, 0 04-18 22:00 vcs

crw-rw---- 1 vcsa tty 7, 1 04-18 22:00 vcs1

crw-rw---- 1 vcsa tty 7, 2 04-18 22:00 vcs2

crw-rw---- 1 vcsa tty 7, 3 04-18 22:00 vcs3

crw-rw---- 1 vcsa tty 7, 4 04-18 22:00 vcs4

设备号

设备号用来做什么？？

设备号的作用

1>.主设备号用来标识与设备文件相连的驱动程序。

次设备号被驱动程序用来辨别操作的是哪个设备。

*****主设备号用来反映设备类型******

***次设备号用来区分同类型的哪一个设备***

三．主次设备号

Q:内核中如何描述设备号？

A:dev_t

*****其实质为unsigned int 32位整数，其中高12位为主设备号，低20位为次设备号。

Q：如何从dev_t中分解出主设备号？

A：MAJOR(dev_t dev)

Q:如何从dev_t只分解出次设备号？

A：MINOR(dev_t dev)

四．分配主设备号

Linux 内核如何给设备分配主设备号？

可以采用静态申请，动态分配两种方法

（动态、静态是针对主设备号来说的）

静态申请

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

功能：申请使用从from开始的count 个设备号（主设备号不变，次设备号增加）

参数：

From :希望申请使用的设备号数目

Count :希望申请使用的设备号数目

Name :设备名（体现在/proc/devices）

动态分配

方法：

使用alloc_chrdev_region分配设备号

优点：简单，易于驱动推广

缺点：无法在安装驱动前创建设备文件（因为安装前还没分配到主设备号。）

解决办法：

安装驱动后，从/proc/devices中查询设备号

动态分配

Int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)

功能：动态申请count个设备号，第1个设备号的次设备号为baseminor.

参数：

Dev:分配到的设备号

Baseminor :起始次设备号

Count :要注册的设备号个数

Name :设备名（体现在/proc/devices）

主设备号是动态产生的，次设备号（的第一个）是要指定的；

五．注销设备号

不论使用何种方法分配设备号，都应该在不再使用它们的时候释放这些设备号。

Void unregister_chrdev_region(dev_t from, unsigned count)

功能：

释放从from 开始的count个设备号

六．创建设备文件

两种方法：1.使用mknod命令手工创建；

2.自动创建

手工创建：

mknod用法：

mknod filename type major minor

filename :设备文件名

type: 设备文件类型

major：主设备号

minor :次设备号

例如：mknod serial0 c 100 0

之后 ls serial0 命令可查

不要0也可以，通过0知道是第几个设备

七．重要结构

在Linux 字符设备驱动程序设计中，有3种非常重要的数据结构：

1. struct file

2. struct inode

3. struct file_operations

Stuct file

代表一个开打的文件。系统中每一个打开的文件在内核空间都有一个关联的struct file . 它由内核在打开文件时创建，在文件关闭后释放。

(一个文件被打开一次对应一个Struct file，这个文件同时被打开10次，则对应10个Struct file)

***重要成员

Loff_t f_pos /*文件读写位置*/

Struct file_operations *f_op

struct inode

用来记录文件的物理上的信息。因此，他和代表打开文件的file结构是不同的。

一个文件可以对应多个file结构，但只有一个inode结构。

***重要成员：

dev_t i_rdev :设备号

struct file_operations

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

例：mem_fops

Struct file_operations mem_fops={

.owner = THIS_MODULE,

.llseek =mem_seek,

.read =mem_read,

.write = mem_ioctl,

.ioctl =mem_open,

.release =mem_release,

};

（左边红色为指针,右边为函数）

应用程序如何访问驱动程序？（read_write.c）

八．设备注册（分配）

在Linux 2.6内核中，字符设备使用struct cdev来描述。

字符设备的注册可分为如下3个步骤：

1. 分配cdev

2. 初始化cdev

3. 注册（添加）cdev

struct cdev的分配可以使用cdev_alloc函数来完成。

Struct cdev *cdev_alloc(void)

（去分配是因为我们想拿到一个cdev的结构，若是静态的直接定义一个变量，则不需要分配。例如：是整型指针需要分配空间，是一个整型变量则不需要分配空间）

struct cdev的初始化可以使用cdev_init函数来完成。

Void cdev_init(struct cdev *cdev, const struct file_operations *fops)

注意：第二个参数：file_operations *fops就把结构file_operations和驱动程序绑定起来了

参数：

Cdev:待初始化的cdev结构

fops :设备对应的操作函数集

struct cdev的注册使用cdev_add函数来完成。

Int cdev_add(struct cdev *p, dev_t dev,unsigned count)

作用把struct cdev注册到内核里面去

参数：

p:待添加到内核的字符设备结构

dev:设备号

count :添加的设备个数

设备操作

§ int (*open)(struct inode*, struct file*)

在设备文件上的第一个操作，并不要求驱动程序一定要实现这个方法。如果该项为NULL,设备的打开操作永远成功。

§void (*release)(struct inode*,struct file*)

当设备文件被关闭时调用这个操作。与open相仿，release也可以没有。

§ssize_t(*read)(struct file*,char_user*,size_t,loff_t*)

从设备中读取数据

§ ssize_t(*write)(struct file*,char_user*,size_t,loff_t*)

向设备中写数据

§unsigned int(*poll)(stuct file*,struct poll_table_struct*)

对应select系统调用

§int (*ioctl)(struct inode*, struct file*,unsigned int,unsigned long)

控制设备

§int (*mmap)(stuct file*,struct vm_area_struct*)

将设备映射到进程虚拟地址空间中

§off_t (*llseek)(struct file*, loff_t,int)

修改文件的当前读写位置，并将新位置作为返回值

Open方法

Open方法是驱动程序用来为以后的操作完成初始化准备工作的。在大部分驱动程序中，open完成如下工作：

1>.初始化设备；

2>.表明次设备号；

Release方法：

Release方法的作用正好与open相反，关闭设备作用；

读和写

读和写方法都完成类似工作：从设备中读取数据到用户空间；将数据给驱动程序。它的原型也相似：

Ssize_t xxx_read(struct file *filp , char_user *buff, size_t count, loff_t *offp);

Ssize_t xxx_write(struct file *filp, char_user *buff, size_t count, loff_t *offp);

对于2个方法，filp是文件指针，count是请求传输的数据量。Buff参数指向数据缓存。最后，offp指向文件当前的访问位置。

读和写

Read和write方法的buff参数是用户空间指针。因此，它不能被内核代码直接引用，理由如下：

用户空间指针在内核空间时可能根本是无效的—没有那个地址映射。

因此：内核提供了专门的函数用于访问用户空间的指针,例如：

**int copy_from_user(void *to, const void_user *from, int n)

***int copy_to_user(void_user *to, const void *from, int n)

应该从应用程序角度看待：

用户要去读这个设备，则数据从设备流向用户：copy_to_user

驱动程序

（目的：把内存的4k空间看出字符设备，编写字符设备驱动去操作这块内存）

#include <linux/module.h>

#include <linux/types.h>

#include <linux/fs.h>

#include <linux/errno.h>

#include <linux/mm.h>

#include <linux/sched.h>

#include <linux/init.h>

#include <linux/cdev.h>

#include <asm/io.h>

#include <asm/system.h>

#include <asm/uaccess.h>

#include "memdev.h"

static mem_major = MEMDEV_MAJOR;

module_param(mem_major, int, S_IRUGO);

struct mem_dev *mem_devp; /*设备结构体指针*/

struct cdev cdev;

/*文件打开函数*/

int mem_open(struct inode *inode, struct file *filp)

{

struct mem_dev *dev;

/*获取次设备号*/

int num = MINOR(inode->i_rdev);//只有在open中能拿到inode提取num

if (num >= MEMDEV_NR_DEVS)

return -ENODEV;

dev = &mem_devp[num];//只有在open中能拿到inode提取num,并将对应dev保存到filp->private_data

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

filp->private_data = dev;

return 0;

}

/*文件释放函数*/

int mem_release(struct inode *inode, struct file *filp)

{

return 0;

}

/*读函数*/

static ssize_t mem_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 mem_dev *dev = filp->private_data; /*获得设备结构体指针*/

/*判断读位置是否有效*/

if (p >= MEMDEV_SIZE)//读的位置大于设备大小--无效

return 0;

if (count > MEMDEV_SIZE - p)//要读的大小>设备剩下的大小

count = MEMDEV_SIZE - p;

/*读数据到用户空间*/

if (copy_to_user(buf, (void*)(dev->data + 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 mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)

{

unsigned long p = *ppos;

unsigned int count = size;

int ret = 0;

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

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

if (p >= MEMDEV_SIZE)

return 0;

if (count > MEMDEV_SIZE - p)

count = MEMDEV_SIZE - p;

/*从用户空间写入数据*/

if (copy_from_user(dev->data + p, buf, count))

ret = - EFAULT;

else

{

*ppos += count;

ret = count;

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

}

return ret;

}

/* seek文件定位函数 */

static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)

{

loff_t newpos;

switch(whence) {

case 0: /* SEEK_SET 文件头*/

newpos = offset;

break;

case 1: /* SEEK_CUR 文件中*/

newpos = filp->f_pos + offset;//filp->f_pos:当前位置

break;

case 2: /* SEEK_END 文件尾*/

newpos = MEMDEV_SIZE -1 + offset;//MEMDEV_SIZE -1 ：从文件尾

break;

default: /* can't happen */

return -EINVAL;

}

if ((newpos<0) || (newpos>MEMDEV_SIZE))//不合法的当前位置

return -EINVAL;

filp->f_pos = newpos;

return newpos;

}

/*文件操作结构体*/

static const struct file_operations mem_fops =

{

.owner = THIS_MODULE,//

.llseek = mem_llseek,

.read = mem_read,

.write = mem_write,

.open = mem_open,//先分析open

.release = mem_release,

};

/*设备驱动模块加载函数*/

static int memdev_init(void)

{

int result;

int i;

/*利用主设备号、此设备号构造--设备号*/

dev_t devno = MKDEV(mem_major, 0);//mem_major在.h头文件中为254

/* 静态申请设备号*/

if (mem_major)//当mem_major>0，则静态申请设备号

result = register_chrdev_region(devno, 2, "memdev");

else /* mem_major<0,则动态分配设备号 */

{

result = alloc_chrdev_region(&devno, 0, 2, "memdev");//动态分配的设备号填到devno

mem_major = MAJOR(devno);//把主设备号提取出来

}

if (result < 0)

return result;

/*初始化cdev结构*/

cdev_init(&cdev, &mem_fops);//因为cdev定义的是一个静态的结构，所以不需分配空间

cdev.owner = THIS_MODULE;

cdev.ops = &mem_fops;

/* 注册字符设备 */

cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);//MEMDEV_NR_DEVS:多少个设备

/* 为设备描述结构分配内存（因为我们用内存模拟设备，操作设备就要操作这段内存）*/

mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);

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

{

result = - ENOMEM;

goto fail_malloc;

}

memset(mem_devp, 0, sizeof(struct mem_dev));

/*为设备分配内存*/

for (i=0; i < MEMDEV_NR_DEVS; i++)

{

mem_devp[i].size = MEMDEV_SIZE;//MEMDEV_SIZE:4096

mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);

memset(mem_devp[i].data, 0, MEMDEV_SIZE);

}

return 0;

fail_malloc:

unregister_chrdev_region(devno, 1);

return result;

}

/*模块卸载函数*/

static void memdev_exit(void)

{

cdev_del(&cdev); /*注销设备*/

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

unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/

}

MODULE_AUTHOR("David Xie");

MODULE_LICENSE("GPL")

module_init(memdev_init);

module_exit(memdev_exit);

测试程序：

#include <stdio.h>

int main()

{

FILE *fp0 = NULL;

char Buf[4096];

/*初始化Buf*/

strcpy(Buf,"Mem is char dev!");

printf("BUF: %s\n",Buf);

/*打开设备文件*/

fp0 = fopen("/dev/memdev0","r+");

if (fp0 == NULL)

{

printf("Open Memdev0 Error!\n");

return -1;

}

/*写入设备*/

fwrite(Buf, sizeof(Buf), 1, fp0);

/*（思考没有该指令，会有何后果)？*/

//答：因为前面假如写了8个字节，指针就会停在8个字节处，如果要读的话，指针就从8个字节以后开始读，

//这样就读不到东西，因为8个字节后没写东西

/*重新定位文件位置*/

fseek(fp0,0,SEEK_SET);

/*清除Buf*/

strcpy(Buf,"Buf is NULL!");

printf("BUF: %s\n",Buf);

/*读出设备*/

fread(Buf, sizeof(Buf), 1, fp0);

/*检测结果*/

printf("BUF: %s\n",Buf);

return 0;

}

(简单字符设备驱动实例分析)

思路：

1. 拿到主设备号；

2. 初始化cdev=结构；

3. 注册cdev结构（实际上是注册驱动程序）

4. 最后有一些额外的工作是分配内存；

分析一个字符设备程序：

（分析一个字符设备的过程实际也就是实现字符设备的过程）

第一步，分析它的初始化函数；

第二步，分析 file_operation ，找到file_operation当中的函数指针；

（而分析file_operation 需要先分析open函数）