1、 简单的字符驱动源码分析
1.1 printk打印级别
#define KERN_EMERG "<0>" /* systemis unusable */
#define KERN_ALERT "<1>" /* actionmust be taken immediately */
#define KERN_CRIT "<2>" /*critical conditions */
#define KERN_ERR "<3>" /* errorconditions */
#define KERN_WARNING "<4>" /* warning conditions */
#define KERN_NOTICE "<5>" /* normalbut significant */
#define KERN_INFO "<6>" /*informational */
#define KERN_DEBUG "<7>" /*debug-level messages */1.2 module_test.c
#include <linux/module.h> //module_init() module_exit()
#include <linux/init.h> //__init __exit
//__init是一个宏定义，#define __init xxx，作用是编译时，将__init修饰的
//函数放入.init.text中，内核启动时会统一加载.init.text段，加载后释放
static int __init chrdev_module_init(void)
{
//printk是内核源码中用来打印信息的函数，KERN_DEBUG是打印级别
printk(KERN_DEBUG "chrdev_module_init");
return 0;
}
static void __exit chrdev_module_exit(void)
{
printk(KERN_DEBUG "chrdev_module_exit");
}
module_init(chrdev_module_init);
module_exit(chrdev_module_exit);
//宏定义
MODULE_LICENSE("GPL"); //模块的许可证
MODULE_AUTHOR("xy_L"); //模块的作者
MODULE_DESCRIPTION("chrdev module"); //模块的描述
MODULE_ALIAS("module_test"); //模块的别名1.3 Makefile
# 开发板的linux内核的源码树目录
KERN_DIR = /root/driver/kernel
obj-m += module_test.o
all:
make -C $(KERN_DIR) M=`pwd` modules
.PHONY: clean
clean:
make -C $(KERN_DIR) M=`pwd` modules clean2、 字符设备驱动
2.1 字符设备驱动工作原理图
2.2 file_operations结构体
struct file_operations {
struct module *owner; //拥有该结构的模块的指针，一般为THIS_MODULES
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 (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t); //初始化一个异步的读取操作
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t); //初始化一个异步的写入操作
int (*readdir) (struct file *, void *, filldir_t); //仅用于读取目录，对于设备文件，该字段为NULL
unsigned int (*poll) (struct file *, struct poll_table_struct *); //轮询函数，判断目前是否可以进行非阻塞的读写或写入
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); //执行设备I/O控制命令
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long); //不使用BLK文件系统，将使用此种函数指针代替ioctl
long (*compat_ioctl) (struct file *, unsigned int, unsigned long); //在64位系统上，32位的ioctl调用将使用此函数指针代替
int (*mmap) (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 *, struct dentry *, int datasync); //刷新待处理的数据
int (*aio_fsync) (struct kiocb *, int datasync); //异步刷新待处理的数据
int (*fasync) (int, struct file *, int); //通知设备FASYNC标志发生变化
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 **);
}; 2.3 应用和linux内核之间的数据交换
/*************************************************
*to：目标地址（用户空间）
*from：源地址（内核空间）
*n：将要拷贝数据的字节数
*返回：成功返回0，失败返回没有拷贝成功的数据字节数
**************************************************/
unsigned long copy_to_user(void *to, const void *from, unsigned long n);
/*************************************************
*to：目标地址（内核空间）
*from：源地址（用户空间）
*n：将要拷贝数据的字节数
*返回：成功返回0，失败返回没有拷贝成功的数据字节数
**************************************************/
unsigned long copy_from_user(void *to, const void *from, unsigned long n);2.4 linux内核2.4版本前注册字符设备驱动的方式
// 申请注册设备号以第一个参数来辨别动态与静态。
//1、如果第一个参数是0，表示动态的分配给此驱动程序一个主设备号，
//2、非零时候，表示备驱动程序向系统申请主设备号，
static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops)
{
return __register_chrdev(major, 0, 256, name, fops);
}
//主设备号必须和注册时候的主设备号一致，如果注册时候是动态的分配的主设备号，就需要保存起来
static inline void unregister_chrdev(unsigned int major, const char *name)
{
__unregister_chrdev(major, 0, 256, name);
}案例：
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#define DYNAMIC_DEVICE_MAJOR 1
#define MODULE_TEST_MAJOR 200
#define MODULE_TEST_NAME "module_test"
int s_module_test_major;
static int module_test_read(struct file* file, char __user* buf, size_t count, loff_t* ppos)
{
char kbuf[256];
unsigned long lcount;
/*
* 从内核空间拷贝数据到用户空间
* unsigned long copy_to_user(void* to, const void* from, unsigned long n);
*/
lcount = copy_to_user(buf, kbuf, count);
return 0;
}
static int module_test_write(struct file* file, const char __user* ubuf, size_t count, loff_t* ppos)
{
char kbuf[256];
unsigned long lcount;
/*
* 从用户空间拷贝数据到内核空间
* unsigned long copy_from_user(void* to, const void* from, unsigned long n);
*/
lcount = copy_from_user(kbuf, ubuf, count);
return 0;
}
static int module_test_open(struct inode* inode, struct file* file)
{
printk(KERN_INFO "module_test_open\n");
return 0;
}
static int module_test_release(struct inode* inode, struct file* file)
{
printk(KERN_INFO "module_test_release\n");
return 0;
}
// 定义module_test的file_operations结构体变量
static const struct file_operations module_test_fops =
{
.owner = THIS_MODULE,
.read = module_test_read,
.write = module_test_write,
.open = module_test_open,
.release = module_test_release,
};
//__init是一个宏定义，作用是编译时将__init修饰的函数放到init.text中
static int __init module_chrdev_init(void)
{
#if (DYNAMIC_DEVICE_MAJOR == 0)
int ret = -1;
#endif
printk(KERN_INFO "module_chrdev_init\n");
// 注册字符设备驱动
// register_chrdev是用来向内核注册驱动的函数
#if (DYNAMIC_DEVICE_MAJOR == 0)
// 静态申请设备号
ret = register_chrdev(MODULE_TEST_MAJOR, MODULE_TEST_NAME, &module_test_fops);
if (ret)
{
printk(KERN_ERR "module_test register_chrdev failed\n");
return -EINVAL;
}
#else
// 动态申请设备号
s_module_test_major = register_chrdev(0, MODULE_TEST_NAME, &module_test_fops);
if (s_module_test_major < 0)
{
printk(KERN_ERR "module_test register_chrdev failed\n");
return -EINVAL;
}
#endif
return 0;
}
static void __exit module_chrdev_exit(void)
{
printk(KERN_INFO "module_chrdev_exit\n");
// 卸载字符设备驱动
#if (DYNAMIC_DEVICE_MAJOR == 0)
unregister_chrdev(MODULE_TEST_MAJOR, MODULE_TEST_NAME);
#else
unregister_chrdev(s_module_test_major, MODULE_TEST_NAME);
#endif
}
module_init(module_chrdev_init);
module_exit(module_chrdev_exit);
//宏定义
MODULE_LICENSE("GPL"); //模块的许可证
MODULE_AUTHOR("xy_L"); //模块的作者
MODULE_DESCRIPTION("chrdev module"); //模块的描述
MODULE_ALIAS("module_test"); //模块的别名2.5 linux内核2.6之后的版本注册驱动的方式：
通过cdev结构体申请设备号
//MKDEV:将主设备号和次设备号转换成dev_t类型
struct cdev
{
struct kobject kobj;
struct module *owner; //所属模块
const struct file_operations *ops;
struct list_head list; //与 cdev 对应的字符设备文件的 inode->i_devices 的链表头
dev_t dev; //起始设备编号,可以通过MAJOR(),MINOR()来提取主次设备号
unsigned int count; //连续注册次设备号的个数
}
//通过宏定义来获取主、次设备号
MAJOR(dev_t dev)
MINOR(dev_t dev)
//通过主、次设备号生成dev_t
MKDEV(int major,int minor)
//初始化，建立cdev和file_operation 之间的连接
void cdev_init(struct cdev *, const struct file_operations *);
//动态申请一个cdev内存
struct cdev *cdev_alloc(void);
//释放
void cdev_put(struct cdev *p);
//注册设备
int cdev_add(struct cdev *, dev_t, unsigned);
//注销设备
void cdev_del(struct cdev *);案例：
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/cdev.h>
#include <linux/device.h>
#define DYNAMIC_DEVICE_MAJOR 1
#define INTERFACE_MODULE_NAME "register_driver_interface"
struct cdev s_cdev; /* 字符设备 */
dev_t s_devNo; /* 设备号 */
static struct class* s_pmodule_class;
// linux内核2.6之后的版本注册字符设备驱动的方式
static int register_driver_interface_read(struct file* file, char __user* buf, size_t count, loff_t* ppos)
{
return 0;
}
static int register_driver_interface_write(struct file* file, const char __user* ubuf, size_t count, loff_t* ppos)
{
return 0;
}
static int register_driver_interface_open(struct inode* inode, struct file* file)
{
return 0;
}
static int register_driver_interface_release(struct inode* inode, struct file* file)
{
return 0;
}
static const struct file_operations register_driver_interface_fops =
{
.owner = THIS_MODULE,
.read = register_driver_interface_read,
.write = register_driver_interface_write,
.open = register_driver_interface_open,
.release = register_driver_interface_release,
};
static int __init register_driver_interface_init(void)
{
int ret;
// 使用cdev接口的方式注册字符设备驱动
#if (DYNAMIC_DEVICE_MAJOR == 0)
// 先向内核申请一个字符设备号（主设备号+次设备号）
s_devNo = MKDEV(200, 0);
ret = register_chrdev_region(s_devNo, 1, INTERFACE_MODULE_NAME);
if (ret)
{
printk(KERN_ERR "register_chrdev_region failed\n");
return -EINVAL;
}
#else
ret = alloc_chrdev_region(&s_devNo, 0, 1, INTERFACE_MODULE_NAME);
if (ret)
{
printk(KERN_ERR "alloc_chrdev_region failed\n");
return -EINVAL;
}
#endif
// 字符设备号和file_opertations绑定
cdev_init(&s_cdev, ®ister_driver_interface_fops);
// 注册字符设备驱动
ret = cdev_add(&s_cdev, s_devNo, 1);
if (ret)
{
printk(KERN_ERR "cdev_add failed\n");
return -EINVAL;
}
// 创建设备类文件
s_pmodule_class = class_create(THIS_MODULE, "rdi_module_test");
if (IS_ERR(s_pmodule_class))
return -EINVAL;
device_create(s_pmodule_class, NULL, s_devNo, NULL, "rdi_module");
return 0;
}
static void __exit register_driver_interface_exit(void)
{
// 销毁设备文件
device_destroy(s_pmodule_class, s_devNo);
// 销毁设备类
class_destroy(s_pmodule_class);
// 注销字符设备驱动
cdev_del(&s_cdev);
// 注销字符设备号
unregister_chrdev_region(s_devNo, 1);
}
module_init(register_driver_interface_init);
module_exit(register_driver_interface_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("xy_L");
MODULE_DESCRIPTION("register_driver_interface");
MODULE_ALIAS("register_driver_interface_test");