1.3 字符设备驱动

xy_L

已于 2024-04-13 18:36:00 修改

阅读量196

点赞数 3

分类专栏： Linux驱动学习文章标签： linux驱动

于 2024-04-13 13:08:44 首次发布

本文链接：https://blog.csdn.net/weixin_45523296/article/details/137712766

版权

Linux驱动学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1、字符设备驱动工作原理

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 **);   
};

3、注册字符设备驱动

向内核注册字符设备，也就是在内核中登记，让内核中分配一个设备号，标识该驱动。

（1）在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);
}

（2）在Linux内核2.6版本后注册字符设备驱动的方式：

设备号申请

//静态申请
/*************************************
* from:注册的指定起始设备编号
* count:需要连续注册的次设备编号个数
* name:字符设备名称
*************************************/
int register_chrdev_region(dev_t from, unsigned count, const char *name);

//动态申请
/******************************************************
* dev: 存放起始设备编号的指针
* baseminor:次设备号基地址
* count:需要连续注册的次设备编号个数
* name:字符设备名称
*******************************************************/
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name);


//注销设备号
void unregister_chrdev_region(dev_t from, unsigned count)；

注册设备驱动

//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 *);

4、应用和内核之间的数据交换

/*************************************************
*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);

5、简单的字符设备驱动示例

#include <linux/module.h>    //module_init() module_exit()
#include <linux/init.h>      //__init __exit

static int module_test_open(struct inode *inode, struct file *file)
{
    return 0;
}

static int module_test_release(struct inode *inode, struct file *file)
{
    return 0;
}

//应用层和驱动之间的数据交换，copy_from_user:从用户空间复制到内核空间，copy_to_user:从内核空间复制到用户空间
static ssize_t module_test_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    char kBuf[1024] = "module_test_read";
    int ret = copy_to_user(ubuf, kBuf, count);
    if (ret == 0)
        printk(KERN_DEBUG, "copy_to_user success");
    return count;
}
static ssize_t module_test_write(struct file *file, const char __user *ubuf, size_t count, loff_t *ppos)
{
    char kBuf[1024];
    int ret = copy_from_user(kBuf, ubuf, count);
    if (ret == 0)
        printk(KERN_DEBUG, "copy_from_user success");
    return count;
}

struct file_operations module_test_fops =
{
    .owner = THIS_MODULE,
    .read = module_test_read,
    .write = module_test_write,
    .open = module_test_open,
    .release = module_test_realse,
};

//__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");
    
    //注册字符设备驱动
    register_chrdev(200, "module_test", &module_test_fops);
    
    return 0;
}

static void __exit chrdev_module_exit(void)
{
    printk(KERN_DEBUG "chrdev_module_exit");
    
    //注销字符设备驱动
    unregister_chrdev(200, "module_test");
}

module_init(chrdev_module_init);
module_exit(chrdev_module_exit);

//宏定义
MODULE_LICENSE("GPL")                 //模块的许可证
MODULE_AUTHOR("xy_L")                 //模块的作者
MODULE_DESCIPTION("chrdev module")    //模块的描述
MODULE_ALIAS("module_test")           //模块的别名

6、查看Linux系统已经注册的驱动设备号