02、字符设备驱动

02、字符设备驱动

一、cdev结构体

  在Linux内核中，使用cdev结构体描述一个字符设备，cdev结构体的定义在<linux/cdev.h>头文件中声明如下：

struct cdev {
	struct kobject kobj;                 
	struct module *owner;                /* 所属模块 */
	const struct file_operations *ops;   /* 文件操作结构体 */
	struct list_head list;
	dev_t dev;                           /* 设备号 */
	unsigned int count;
};

  同时该头文件中也提供了一组函数用于操作cdev结构体。其中对cdev_add()函数的调用发生在字符设备驱动模块加载函数中，cdev_del()函数的调用通常在字符设备驱动模块卸载函数中。

/**
 * @brief 初始化结构体成员，并将cdev和file_operations建立链接
 * 
 * @param  cdev             --需要初始化的结构体
 * @param  fops             --设备驱动对应的文件操作函数集
 */
void cdev_init(struct cdev *cdev, const struct file_operations *fops);
/**
 * @brief 
 * 
 * @return struct cdev*     --动态申请一个cdev内存
 */
struct cdev *cdev_alloc(void);

/**
 * @brief 向内核中添加一个cdev，完成字符设备的注册
 * 
 * @param  p                --需要注册的字符设备驱动
 * @param  dev              --注册驱动的首个设备号
 * @param  count            --注册驱动的个数
 * @return int              --负值表示注册失败
 */
int cdev_add(struct cdev *p, dev_t dev, unsigned count);

/**
 * @brief 向内核中删除一个cdev，完成字符设备的注销
 * 
 * @param  p                --需要注册的字符设备驱动
 */
void cdev_del(struct cdev *p);

二、分配和释放设备号

  字符设备驱动结构体中已经定义了设备号为32位数，其中12位为主设备号，20位为次设备号。设备号可以通过以下宏函数进行操作。

/*根据输入的设备号返回主设备号*/
#define MAJOR(dev)	((unsigned int) ((dev) >> MINORBITS))
/*根据输入的设备号返回次设备号*/
#define MINOR(dev)	((unsigned int) ((dev) & MINORMASK))
/*根据输入的主设备号和次设备号返回设备号*/
#define MKDEV(ma,mi)	(((ma) << MINORBITS) | (mi))

  在调用cdev_add()函数前需要向内核申请设备号，通过下面两个函数进行操作，函数在<linux/fs.h>文件中进行声明。alloc_chrdev_region相较于register_chrdev_region的优点在于能够避免设备号重复的冲突

/**
 * @brief 用于注册已知起始设备号的情况
 * 
 * @param  from             --起始设备号
 * @param  count            --注册设备号个数
 * @param  name             --设备或设备驱动的名字
 * @return int              --0表示注册成功，负值表示注册失败
 */
int register_chrdev_region(dev_t from, unsigned count, const char *name);

/**
 * @brief 用于动态申请设备号的情况
 * 
 * @param  dev              --申请成功后，得到的设备号存储的未知
 * @param  baseminor        --申请设备号的起始次设备号，一般设置为0
 * @param  count            --申请设备号的个数
 * @param  name             --设备或设备驱动的名字
 * @return int              --0表示申请成功，负值表示注册失败
 */
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
                        const char *name);

  在调用cdev_del()函数后需要向内核释放设备号，通过下面函数进行操作，函数在<linux/fs.h>文件中进行声明。

/**
 * @brief 注销设备号
 * 
 * @param  from             --注销设备号的起始设备号
 * @param  count            --注销设备号的个数
 */
void unregister_chrdev_region(dev_t from, unsigned count)

三、file_operations结构体

  file_operations结构体在<linux/fs.h>文件中声明，结构体中的成员函数是设备驱动设计的主体，这些函数在用户空间调用文件操作函数系统调用时会被内核调用。

struct file_operations {
	struct module *owner;
	/* 修改文件当前的读写位置，并将新位置返回；出错时返回负值 */
	loff_t (*llseek) (struct file *, loff_t, int);
	/* 从设备中读取数据；成功时返回正确读取的字节数， 出错时返回负值，返回0表示EOF */
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	/* 向设备发送数据；成功时返回正确写入的字节数，出错时返回负值，返回0表示EOF */
	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
	ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
	ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
	int (*iterate) (struct file *, struct dir_context *);
	/* 用于询问设备是否支持被非阻塞地立即读写 */
	unsigned int (*poll) (struct file *, struct poll_table_struct *);
	/* 设备相关控制命令的实现（既不是读也不是写）；成功时返回非负值 */
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
	/* 将设备内存映射到进程的虚拟地址空间中 */
	int (*mmap) (struct file *, struct vm_area_struct *);
	int (*mremap)(struct file *, struct vm_area_struct *);
	int (*open) (struct inode *, struct file *);
	int (*flush) (struct file *, fl_owner_t id);
	int (*release) (struct inode *, struct file *);
	int (*fsync) (struct file *, loff_t, loff_t, int datasync);
	int (*aio_fsync) (struct kiocb *, int datasync);
	int (*fasync) (int, struct file *, int);
	int (*lock) (struct file *, int, struct file_lock *);
	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
	int (*check_flags)(int);
	int (*flock) (struct file *, int, struct file_lock *);
	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
	int (*setlease)(struct file *, long, struct file_lock **, void **);
	long (*fallocate)(struct file *file, int mode, loff_t offset,
			  loff_t len);
	void (*show_fdinfo)(struct seq_file *m, struct file *f);
#ifndef CONFIG_MMU
	unsigned (*mmap_capabilities)(struct file *);
#endif
};

1、file结构

  在 <linux/fs.h>中定义struct file结构体，该结构体与用户空间的FILE没有任何关系，该结构体只是一个内核结构，不会出现在用户程序中。
  file结构代表一个打开的文件，由内核在open时创建，并传递给在该文件上进行操作的所有函数，直到最后的close函数。该结构会在所有文件实体关闭后，自动被内核释放。

2、inode结构

  对于单个文件而言，可能有多个表示打开的文件描述符file结构，但是他们都指向同一个inode结构。该结构包含大量有关文件的信息。

3、open方法

  open方法提供驱动程序初始化的能力，从而为之后的操作完成初始化准备。大部分驱动中open应完成如下工作。

• 检查设备特定错误
• 如果是首次打开，则对其进行初始化
• 如果有必要更新f_op指针
• 分配并填写filp->private_data的数据结构

4、release方法

  release方法需要完成如下任务。

• 释放open分配的、保存在filp->private_data中的所有内容
• 在最后一次关闭操作时关闭设备
    并不是每个用户空间的close系统调用都会引起对release方法的调用，只有真正释放设备数据结构的close系统调用才会调用该方法。

5、read和write方法

  两个方法的参数2是指向用户空间的缓冲区，内核代码不能直接引用其中的内容，需要用到<linux/uaccess.h>中的两个函数

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

这两个函数不仅能在用户空间和内核空间进行拷贝数据，还能检查用户空间的指针是否有效。如果用户空间的指针无效就不会进行拷贝，活着拷贝过程中遇到无效地址，则只会拷贝部分数据。

四、字符设备驱动的组成

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/cdev.h>

#define XXX_NAME "XXX"     /* 设备驱动名称 */
#define XXX_COUNT 1    	   /* 申请设备号个数 */
#define XXX_DEV_MAJOR 0    /* 主设备号*/
#define XXX_DEV_MINOR 0    /* 主设备号*/

/* 设备描述结构体 */
struct xxx_dev_t{
	dev_t dev;			/* 设备号 */
	struct cdev cdev;	/* 设备驱动结构体 */
	...
};

static int xxx_open(struct inode *inode, struct file *file);
static ssize_t xxx_read(struct file *filp, char __user *buf,
			size_t len, loff_t *pos);
static ssize_t xxx_write(struct file *filp, const char __user *buf,
			size_t len, loff_t *pos);
/* 设备描述结构体实体 */
static struct xxx_dev_t xxx_desc;
/* 设备驱动文件操作函数集实体 */
static struct file_operations xxx_fops={
	.owner = THIS_MODULE,
	.read = xxx_read,
	.write = xxx_write,
};



/**
 * @brief 
 * 
 * @param  inode            --
 * @param  filp             --
 * @return int              --
 */
static int xxx_open(struct inode *inode, struct file *filp)
{
	struct xxx_dev_t *desc;
	
	desc = containerof(inode->i_cdev, struct xxx_dev_t, cdev);
	filp->private_data = desc;
	...
}
/**
 * @brief 设备驱动读函数
 * 
 * @param  file             --文件结构体指针
 * @param  buf              --用户空间内存地址，内核空间不能直接读写
 * @param  len              --需要读取的字节数
 * @param  pos              --读取位置相对于文件开头的偏移
 * @return ssize_t          --正确读取的字节数，负数表示失败
 */
static ssize_t xxx_read(struct file *filp, char __user *buf,
			size_t len, loff_t *pos)
{
	...
	/* 内核空间数据发送到用户空间 */
	copy_to_user(buf,...,...);
	...
}


/**
 * @brief 设备驱动写函数
 * 
 * @param  file             --文件结构体指针
 * @param  buf              --用户空间内存地址，内核空间不能直接读写
 * @param  len              --需要写的字节数
 * @param  pos              --写的位置相对于文件开头的偏移
 * @return ssize_t          --正确写入的字节数，负数表示失败
 */
static ssize_t xxx_write(struct file *file, const char __user *buf,
			size_t len, loff_t *pos)
{
	...
	/* 用户空间数据发送到内核空间 */
	copy_from_user(..., buf, ...);
	...
}


/* 模块加载函数入口 */
static int __init xxx_init(void)
{
	int ret;
	
	/*第一步、申请设备号*/
	if (XXX_DEV_MAJOR)
	{
		/* 设备号已知 */
		xxx_desc.dev = MKDEV(XXX_DEV_MAJOR, XXX_DEV_MINOR);
		ret = register_chrdev_region(xxx_desc.dev, XXX_COUNT, XXX_NAME);
	}
	else
	{
		/* 需要动态分配设备号 */
		ret = alloc_chrdev_region(&xxx_desc.dev, 0, XXX_COUNT, XXX_NAME);
	}
	/* 异常处理 */
	if (ret < 0)
	{
		pr_err("register or alloc chrdev region error\r\n");
		goto fail_reg_alc_chr;
	}
	
	/* 第二部、注册设备*/
	/* 初始化设备驱动结构体 */
	cdev_init(&xxx_desc.cdev, &xxx_fops);
	xxx_desc.cdev.owner = THIS_MODULE;
	/* 注册设备 */
	ret = cdev_add(&xxx_desc.cdev, xxx_desc.dev, XXX_COIUNT);
	/* 异常处理 */
	if (ret)
	{
		pr_err("cdev add error\r\n");
		goto fail_cdev_add;
	}
	
	...
	
	return 0;
/* 异常处理统一入口 */
fail_cdev_add:
	unregister_chrdev_region(xxx_desc.dev, XXX_COUNT);
fail_reg_alc_chr:
return ret;
}

static void __exit xxx_exit(void)
{
	/* 注销设备 */
	cdev_del(&xxx_desv.cdev);
	/* 释放设备号 */
	unregister_chrdev_region(xxx_desc.dev, XXX_COUNT);
}

module_init(xxx_init);
module_exit(xxx_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andrew");