字符设备驱动开发

M_SET

已于 2023-08-07 00:12:01 修改

阅读量72

点赞数 1

文章标签：驱动开发 linux 笔记

于 2023-08-07 00:03:15 首次发布

本文链接：https://blog.csdn.net/master_one/article/details/132137605

版权

一、字符设备驱动

字符设备是一个一个字节，按照字节流进行读写操作的设备，读写数据有顺序性，并是Linux驱动种中基本设备驱动类型。常见的字符设备,eg:LED、IIC 、LCD、can、485等等。在 Linux 系统中一切皆为二进制文件，在“/dev”目录下编译好驱动文件，运行“/dev/xxx”(xxx 是驱动文件名字)进行相应的操作即可实现对硬件的操作，也是就是驱动运行就是对文件操作。涉及涉及到open、close、write 、 read等等函数。在 Linux 内核文件中 file_operations 的结构体，此结构体就是 Linux 内核驱动操作函数集合。

struct file_operations {
	struct module *owner;
	loff_t (*llseek) (struct file *, loff_t, int);
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	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
};

二、字符设备驱动开发步骤

2.1 驱动模块的加载和卸载

module_init(xxx_init); //注册模块加载函数
module_exit(xxx_exit); //注册模块卸载函数

static int __init xxx_init(void)
{
 /* 入口函数具体内容 */
	return 0;
}
 /* 驱动出口函数 */
static void __exit xxx_exit(void)
{
 /* 出口函数具体内容 */
}
 /* 将上面两个函数指定为驱动的入口和出口函数 */
 module_init(xxx_init);
 module_exit(xxx_exit);

2.2 字符设备注册与注销

static inline int register_chrdev(unsigned int major, const char *name,
const struct file_operations *fops)
static inline void unregister_chrdev(unsigned int major, const char *name)

register_chrdev 函数用于注册字符设备，此函数一共有三个参数，这三个参数的含义如下：
major ：主设备号，Linux 下每个设备都有一个设备号，设备号分为主设备号和次设备号两
部分，关于设备号后面会详细讲解。
name：设备名字，指向一串字符串。
fops ：结构体 file_operations 类型指针，指向设备的操作函数集合变量。
unregister_chrdev 函数用户注销字符设备，此函数有两个参数，这两个参数含义如下：
major ：要注销的设备对应的主设备号。
name ：要注销的设备对应的设备名。

static struct file_operations test_fops;
 /* 驱动入口函数 */
static int __init xxx_init(void)
{
	 /* 入口函数具体内容 */
	 int retvalue = 0;
	 /* 注册字符设备驱动 */
	 retvalue = register_chrdev(200, "chrtest", &test_fops);
	 if(retvalue < 0)
	 {
	 /*  字符设备注册失败, 自行处理 */
	 }
	 return 0;
 }
 /* 驱动出口函数 */
 static void __exit xxx_exit(void)
 {
	/* 注销字符设备驱动 */
 	unregister_chrdev(200, "chrtest");
 }
/* 将上面两个函数指定为驱动的入口和出口函数 */
 module_init(xxx_init);
 module_exit(xxx_exit);

2.3 设备的具体操作函数

file_operations 结构体就是设备的具体操作函数，其中的open、release、read 和 write 等具体的设备操作函数。

三、字符设备驱动示例

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>

#define chardevbase_MAJOR	200				/* 主设备号 */
#define chardevbase_NAME		"chardevbase" 	/* 设备名     */

static char readbuf[100];		/* 读缓冲区 */
static char writebuf[100];		/* 写缓冲区 */
static char kerneldata[] = {"kernel data!"};

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int chardevbase_open(struct inode *inode, struct file *filp)
{
	//printk("chardevbase open!\r\n");
	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t chardevbase_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue = 0;
	
	/* 向用户空间发送数据 */
	memcpy(readbuf, kerneldata, sizeof(kerneldata));
	retvalue = copy_to_user(buf, readbuf, cnt);
	if(retvalue == 0){
		printk("kernel senddata ok!\r\n");
	}else{
		printk("kernel senddata failed!\r\n");
	}
	
	//printk("chardevbase read!\r\n");
	return 0;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t chardevbase_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue = 0;
	/* 接收用户空间传递给内核的数据并且打印出来 */
	retvalue = copy_from_user(writebuf, buf, cnt);
	if(retvalue == 0){
		printk("kernel recevdata:%s\r\n", writebuf);
	}else{
		printk("kernel recevdata failed!\r\n");
	}
	
	//printk("chardevbase write!\r\n");
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int chardevbase_release(struct inode *inode, struct file *filp)
{
	//printk("chardevbase release！\r\n");
	return 0;
}

/*
 * 设备操作函数结构体
 */
static struct file_operations chardevbase_fops = {
	.owner = THIS_MODULE,	
	.open = chardevbase_open,
	.read = chardevbase_read,
	.write = chardevbase_write,
	.release = chardevbase_release,
};

/*
 * @description	: 驱动入口函数 
 * @param 		: 无
 * @return 		: 0 成功;其他 失败
 */
static int __init chardevbase_init(void)
{
	int retvalue = 0;

	/* 注册字符设备驱动 */
	retvalue = register_chrdev(chardevbase_MAJOR, chardevbase_NAME, &chardevbase_fops);
	if(retvalue < 0){
		printk("chardevbase driver register failed\r\n");
	}
	printk("chardevbase init!\r\n");
	return 0;
}

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit chardevbase_exit(void)
{
	/* 注销字符设备驱动 */
	unregister_chrdev(chardevbase_MAJOR, chardevbase_NAME);
	printk("chardevbase exit!\r\n");
}

/* 
 * 将上面两个函数指定为驱动的入口和出口函数 
 */
module_init(chardevbase_init);
module_exit(chardevbase_exit);

/* 
 * LICENSE和作者信息
 */
MODULE_LICENSE("GPL");
MODULE_AUTHOR("M_SET");