Linux设备驱动开发——字符设备驱动架构
字符设备驱动架构
驱动层设计
驱动运行在Linux的内核态，对于字符设备而言，应用层调用open、read、write来对表示对设备的操作，虚拟文件系统要将应用层的open、read、write链接到系统的open、read、write函数，最终调用设备驱动程序的open、read、write函数来完成对设备的操作。
在应用程序调用之前，需要先找到设备的接口，通常是/dev/xxx 设备，/dev/xxx 也称为设备节点。因此驱动程序首先需要完成暴露接口给应用程序。另外，通过系统函数调用后，一个操作的最终完成是由驱动程序中的open、read和write函数完成，因此驱动要提供一个接口让应用层递归调用到自己的open、read和write函数。此外，Linux系统中存在不止一个设备的驱动，驱动或设备应当具有唯一的ID来让内核告诉应用层哪个驱动是自己需要调用的。在Linux内核中使用设备号来完成对设备和对应驱动的唯一标识：设备号共32位，其中主设备号12位，次设备号20位。内核通过设备号找到对应的设备，另外还提供了一套file_ops结构体来完成应用层像驱动的调用，最终在file_ops中的函数完成硬件相关操作。
Linux字符设备驱动结构
1.cdev结构体
在Linux内核中使用cdev结构体描述一个字符设备
struct cdev {
struct kobject kobj;
struct module *owner;
const struct file_operations *ops;
struct list_head list;
dev_t dev;
unsigned int count;
};
cdev的dev_t定义了设备的设备号，12位主设备号和20位次设备号。
MAJIOR（dev_t dev）；获取主设备号
MINOR（dev_t dev）；获取次设备号
cdev的另一个重要的结构体是file_operations操作结构体，其中填充了硬件相关的操作函数，也是系统调用完成最终操作的函数。Linux内核提供了一系列函数用来操作cdev结构体：
void cdev_init(struct cdev *cdev, const struct file_operations *fops) 该函数用于初始化cdev成员，将file_operations和cdev建立连接。
cdev_alloc用于动态申请一个cdev结构体
cdev_add和cdev_del分别用于向内核注册和删除一个cdev结构体
2.分配和释放设备号
在调用cdev_add向内核注册cdev结构体之前，应该首先调用register_chrdev_region()或者alloc_chrdev_region（）向系统申请设备号。register_chrdev_region()用于设备号已知的情况，alloc_chrdev_region（）会自动避开已注册的设备号。
相应的，在调用cdev_del删除设备后，unregister_chrdev_region（）用于释放申请的设备号。
3.file_operations结构体
file_operations结构体中的函数是字符设备驱动中的主要设计内用，这些函数会被应用程序逐层调用，完成硬件相关的操作。file_operations结构体已经相当庞大，好在常用的结构并不多。
llseek（）函数用来修改文件的当前读写位置，并将新位置返回，出错时返回负值。
read（）函数从设备中读取的数据，成功时返回字节数，失败时返回负值
write（）函数向设备中写数据，成功时返回写入字节数，
unlock（）提供控制命令的操作，
mmap（）将内核数据映射到进程中去，这个函数广泛应用于帧缓冲设备
poll（）函数用于询问设备是否可以非阻塞的立即读写
4设备驱动程序的入口和出口
设备驱动程序模块加载函数作为驱动模块的入口，必须完成设备号的申请和cdev的注册，而在卸载也就是出口函数中则完成相反的操作。现代操作系统大都采用面向对象的思维，Linux也推荐将设备封装为一个结构体，该结构体一般会包含cdev，私有数据，锁等。
在驱动中会有以下参数的使用：
filp是文件结构的指针，buf是用户空间的内存地址，改地址不可再内核中直接读写。count是传入内核或从内核读出的数据字节长度。f_ops是写的位置相对于文件开头的偏移。由于内核空间和用户空间不能直接互相访问，因此借助copy_to_user和copy_from_user完成数据的传输。
字符驱动设备实例
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#define SIZE 0x1000
#define MEM_CLEAR 0x1
#define MAJOR 230
static int major = MAJOR;
module_param(major, int, S_IRUGO);
struct mem_dev {
struct cdev cdev;
unsigned char mem[GLOBALMEM_SIZE];
struct mutex mutex;
}; / /将设备封装
struct mem_dev *mem_devp;
static int mem_open(struct inode *inode, struct file *filp)
{
filp->private_data = mem_devp;
return 0;
}
int mem_release(struct inode *inode, struct file *filp)
{
return 0;
}
static long mem_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
struct mem_dev *dev = filp->private_data;
switch (cmd) {
case MEM_CLEAR:
mutex_lock(&dev->mutex);
memset(dev->mem, 0, GLOBALMEM_SIZE);
mutex_unlock(&dev->mutex);
printk(KERN_INFO "mem is set to zero\n");
break;
default:
return -EINVAL;
}
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 >= MEM_SIZE)
return 0;
if (count >MEM_SIZE - p)
count = MEM_SIZE - p;
if (copy_to_user(buf, dev->mem + p, count)) {
ret = -EFAULT;
} else {
*ppos += count;
ret = count;
printk(KERN_INFO "read %u bytes(s) from %lu\n", count, p);
}
mutex_unlock(&dev->mutex);
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 >= MEM_SIZE)
return 0;
if (count > MEM_SIZE - p)
count = MEM_SIZE - p;
mutex_lock(&dev->mutex);
if (copy_from_user(dev->mem + p, buf, count))
ret = -EFAULT;
else {
*ppos += count;
ret = count;
printk(KERN_INFO "written %u bytes(s) from %lu\n", count, p);
}
mutex_unlock(&dev->mutex);
return ret;
}
static loff_t mem_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 > MEM_SIZE) {
ret = -EINVAL;
break;
}
filp->f_pos = (unsigned int)offset;
ret = filp->f_pos;
break;
case 1:
if ((filp->f_pos + offset) > MEM_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 =lmem_llseek,
.read = mem_read,
.write = mem_write,
.unlocked_ioctl = mem_ioctl,
.open = mem_open,
.release = mem_release,
};
static int __init mem_init(void)
{
int ret;
dev_t devno = MKDEV(mem_major, 0);
if （mem_major)
ret = register_chrdev_region(devno, 1, "mem");
else {
ret = alloc_chrdev_region(&devno, 0, 1, "mem");
mem_major = MAJOR(devno);
}
if (ret < 0)
return ret;
mem_devp = kzalloc(sizeof(struct mem_dev), GFP_KERNEL);
if (!mem_devp) {
ret = -ENOMEM;
goto fail_malloc;
}
cdev_init(&dev->cdev, &mem_fops);
dev->cdev.owner = THIS_MODULE;
err = cdev_add(&dev->cdev, devno, 1);
if (err)
printk(KERN_NOTICE "Error %d adding globalmem%d", err, index);
mutex_init(&mem_devp->mutex);
return 0;
fail_malloc:
unregister_chrdev_region(devno, 1);
return ret;
}
module_init(mem_init);
static void __exit mem_exit(void)
{
cdev_del(&gmem_devp->cdev);
kfree(mem_devp);
unregister_chrdev_region(MKDEV(mem_major, 0), 1);
}
module_exit(mem_exit);
MODULE_AUTHOR("YJFei ");
MODULE_LICENSE("GPL v2");
代码解析
-
module_init(mem_init);和module_exit(mem_exit);用于修饰驱动的入口和出口函数。
-
mem_init(void)函数中首先创建了设备号dev_t devno = MKDEV(mem_major, 0)，用于向内核注册设备。向内核注册设备时，使用判断语句进行了两种注册
if （mem_major)
ret = register_chrdev_region(devno, 1, “mem”);
else {
ret = alloc_chrdev_region(&devno, 0, 1, “mem”);
mem_major = MAJOR(devno);
}
if (ret < 0)
return ret;
并且根据返回值进行判断，这将会大大增强驱动的健壮性 -
向内核中申请内存，用来表示一个设备对象，并初始化cdev
mem_devp = kzalloc(sizeof(struct mem_dev), GFP_KERNEL);
然后初始化cdev，所谓初始化cdev，就是讲对应的file_ops添加到cdev中，这样在应用逐层向下调用时，最后可以调用到硬件相关的操作函数。
驱动完成cdev的初始化操作后，需要将其添加到内核中，使用cdev_add完成添加，注意cdev_add函数的参数
err = cdev_add(&dev->cdev, devno, 1); 包含cdev结构体和设备号，同时，设备号、cdev结构体和file_ops就相关联了。 -
对于file_ops结构体的填充函数，这是设备最终调用的函数其中
static ssize_t mem_read(struct file *filp, char __user * buf, size_t size,
loff_t * ppos)用于完成将ppos指针指向的数据作为起始，长度为count字节的数据发送到buf缓冲区*应用面读写static ssize_t mem_write(struct file *filp, const char __user * buf,
size_t size, loff_t * ppos)
而write函数用于完成将buf中的数据写入从ppos指向的地址作为起始，长度为size字节长度的内核数据区域中 -
使用私有数据，在open函数中，filp->private_data = mem_devp;将dev的数据传给了文件指针的私有数据，同样，在后面的read、write函数中，也是用私有数据进行传递。
编译和验证
编写makefile，生成mem_dev.ko文件
使用insmod命令加载mem_dev.ko模块
使用shell命令cat /proc/devices查看，发现主设备号230的字符设备mem
首先为设备创建设备节点
mknod /dev/mem c 230 0
使用shell命令读写设备，验证
设备节点和应用调用接口
未完待续
至此，一个字符设备驱动的基本框架就完成了
参考：
韦东山：字符设备驱动程序的另一种写法
宋宝华：Linux设备驱动程序开发