字符设备驱动模型【转】

本文转载自：http://blog.csdn.net/coding__madman/article/details/51347290

字符驱动编程模型：

1. 设备描述结构cdev

1.1 结构定义

1.2 设备号

1.3 设备操作集

在Linux系统中,设备的类型非常繁多，如：字符设备，块设备，网络接口设备，USB设备，PCI设备，平台设备，混杂设备……，而设备类型不同，也意味着其对应的驱动程序模型不同，这样就导致了我们需要去掌握众多的驱动程序模型。那么能不能从这些众多的驱动模型中提炼出一些具有共性的规则，则是我们能不能学好Linux驱动的关键。

查看设备号可以通过查看/dev目录下设备号看到

次设备号

设备号的操作：

设备号的分配：

设备号的注销：

不论使用何种方法分配设备号，都应该在驱动退出时，使用unregister_chrdev_region函数释放这些设备号。

操作函数集：

2. 字符设备驱动模型

描述结构的分配：

cdev变量的定义可以采用静态和动态两种方法

静态分配： struct cdev mdev;

动态分配： struct cdev *pdev = cdev_alloc();

描述结构的初始化：

描述结构的注册：

字符设备的注册使用cdev_add函数来完成，函数原型：

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

参数：

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

dev: 设备号

count: 该类设备的设备个数

剩下的就是根据相应的芯片手册，完成初始化。

实现设备操作：

设备操作原型：

打开设备，响应open系统调用

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

关闭设备，响应close系统调用

int (*release)(struct inode *, struct file *)

重定位读写指针，响应lseek系统调用

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

从设备读取数据，响应read系统调用

ssize_t(*read)(struct file*, char __user *, size_t, lofft *)

向设备写入数据，响应write系统调用

ssize_t(*write)(struct file*, char __user *, size_t, lofft *)

Struct file：在linux系统中，每一个打开的文件，在内核中都会关联一个struct file,它由在内核打开时创建，在文件关闭后释放。

重要成员：

loff_t f_pos /* 文件读写指针 */

struct file_operations *f_op /* 读文件所对应的操作 */

struct inode

每一个存在于文件系统里面的文件都会关联一个inode结构，该结构主要用来记录文件物理上的信息。因此，它和代表打开文件的file结构是不同的。一个文件没有被打开时不会关联file结构，但是会关联一个inode结构。

重要成员： dev_t i_rdev /* 设备号 */

设备操作---open

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

1> 标明次设备号

2.> 启动设备

设备操作---release

release方法的作用正好与open相反。这个设备方法有时也称为close, 它的作用是关闭设备

设备操作---read

设备操作---write

最后就是驱动的注销了：当我们从内核中卸载驱动程序的时候，需要使cdev_del函数来完成字符设备的注销。

3. 范例驱动分析

这里给一个编写好的字符驱动示例代码：

memdev.c文件

[cpp] view plain copy

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
int dev1_registers[5];
int dev2_registers[5];
struct cdev cdev;
dev_t devno;
/*文件打开函数*/
int mem_open(struct inode *inode, struct file *filp)
{
/*获取次设备号*/
int num = MINOR(inode->i_rdev);
if (num==0)
filp->private_data = dev1_registers;
else if(num == 1)
filp->private_data = dev2_registers;
else
return -ENODEV; //无效的次设备号
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;
int *register_addr = filp->private_data; /*获取设备的寄存器基地址*/
/*判断读位置是否有效*/
if (p >= 5*sizeof(int))
return 0;
if (count > 5*sizeof(int) - p)
count = 5*sizeof(int) - p;
/*读数据到用户空间*/
if (copy_to_user(buf, register_addr+p, count))
{
ret = -EFAULT;
}
else
{
*ppos += count;
ret = count;
}
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;
int *register_addr = filp->private_data; /*获取设备的寄存器地址*/
/*分析和获取有效的写长度*/
if (p >= 5*sizeof(int))
return 0;
if (count > 5*sizeof(int) - p)
count = 5*sizeof(int) - p;
/*从用户空间写入数据*/
if (copy_from_user(register_addr + p, buf, count))
ret = -EFAULT;
else
{
*ppos += count;
ret = count;
}
return ret;
}
/* seek文件定位函数 */
static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
{
loff_t newpos;
switch(whence) {
case SEEK_SET:
newpos = offset;
break;
case SEEK_CUR:
newpos = filp->f_pos + offset;
break;
case SEEK_END:
newpos = 5*sizeof(int)-1 + offset;
break;
default:
return -EINVAL;
}
if ((newpos<0) || (newpos>5*sizeof(int)))
return -EINVAL;
filp->f_pos = newpos;
return newpos;
}
/*文件操作结构体*/
static const struct file_operations mem_fops =
{
.llseek = mem_llseek,
.read = mem_read,
.write = mem_write,
.open = mem_open,
.release = mem_release,
};
/*设备驱动模块加载函数*/
static int memdev_init(void)
{
/*初始化cdev结构*/
cdev_init(&cdev, &mem_fops);
/* 注册字符设备 */
alloc_chrdev_region(&devno, 0, 2, "memdev");
cdev_add(&cdev, devno, 2);
}
/*模块卸载函数*/
static void memdev_exit(void)
{
cdev_del(&cdev); /*注销设备*/
unregister_chrdev_region(devno, 2); /*释放设备号*/
}
MODULE_LICENSE("GPL");
module_init(memdev_init);
module_exit(memdev_exit);