字符设备驱动内部实现原理解析-Toy模板网

这篇具有很好参考价值的文章主要介绍了字符设备驱动内部实现原理解析。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一. 字符设备驱动对象内部实现原理解析

字符设备驱动内部实现原理解析
用户层：

当用户打开（open）一个文件时,会生成一个文件描述符表

内核层：

内核层的VFS虚拟文件系统层，根据open传递的文件路径找到文件的inode 结构体
inode号是存在文件系统的唯一标识，同时也是索引当前文件的inode的索引号

根据inode结构体找到文件对应的驱动对象指针（struct cdev）

根据驱动对象指针找到驱动对象的操作方法结构体指针（struct file_operations *ops）

回调操作方法结构体指针中的open

二. 字符设备驱动的注册流程

为字符设备驱动对象申请空间

struct cdev cdev;//直接分配一个变量空间

struct cdev *cdev_alloc(void);//手动申请字符设备驱动对象空间
返回值：成功返回申请空间首地址，失败返回NULL

字符设备驱动对象的初始化
1. 实现字符设备驱动对象的部分初始化
  
  void cdev_init(struct cdev *cdev, const struct file_operations *fops);
  功能：实现字符设备驱动对象的部分初始化
  参数：
  cdev:字符设备驱动对象指针
  fops:操作方法结构体指针
  返回值：无
2. 申请设备号
  1. 静态指定设备号
    
    int register_chrdev_region(dev_t from, unsigned count, const char *name)
    参数：
    from:要申请的设备号
    count:要申请的设备资源的数量
    name:驱动名字
    返回值：成功返回0，失败返回错误码
  2. 动态申请一定范围的设备号
    
    int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
    const char *name)
    参数：
    dev：申请的设备号填充在这个变量中
    baseminor:次设备号的起始值
    count:要申请的设备资源的数量
    name:驱动名字
    返回值：成功返回0，失败返回错误码
3. 将字符设备驱动对象注册进内核
int cdev_add(struct cdev *cdev, dev_t dev, unsigned count);
参数：
cdev:字符设备驱动对象指针
dev:申请的设备号的起始值
count：设备数量
返回值：成功返回0，失败返回错误码
1. 注销流程
  1. 字符设备驱动对象的注销
  void cdev_del(struct cdev *);
  功能：字符设备驱动对象的注销
  参数：字符设备驱动对象指针
  返回值：无
  1. 释放申请的设备号
  unregister_chrdev_region(MKDEV(major,minor),3);
  1. 释放对象空间
    
    kfree(cdev);

三. 代码示例

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

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

struct cdev *cdev;
int major, minor; // 设备号，全局为0
dev_t devno;
struct class *cls;
struct device *dev;

int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
struct file_operations ops = {
    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};
static int __init mycdev_init(void)
{
    int ret;
    // 分配对象空间
    cdev = cdev_alloc();
    if (NULL == cdev)
    {
        printk("字符设备驱动对象分配失败\n");
        ret = -EFAULT;
        goto OUT1;
    }
    printk("字符设备驱动对象分配成功\n");
    // 初始化对象
    cdev_init(cdev, &ops);
    // 申请设备号,采用动态申请的方式
    ret = alloc_chrdev_region(&devno, minor, 1, "mycdev");
    if (ret)
    {
        printk("申请设备号失败\n");
        goto OUT2;
    }
    major = MAJOR(devno);
    minor = MINOR(devno);
    printk("设备号申请成功\n");
    // 注册字符设备驱动对象
    ret = cdev_add(cdev, MKDEV(major, minor), 1);
    if (ret)
    {
        printk("注册字符设备驱动对象失败\n");
        goto OUT3;
    }
    printk("注册字符设备驱动对象成功\n");
    // 向上提交目录
    cls = class_create(THIS_MODULE, "mycdev");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret = -PTR_ERR(cls);
        goto OUT4;
    }
    // 向上提交结点信息
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "mycdev");
    if (IS_ERR(dev))
    {
        ret = -PTR_ERR(dev);
        goto OUT5;
    }
OUT5:
    // 释放已经申请的设备节点信息

    device_destroy(cls, MKDEV(major, 0));

    // 释放目录空间
    class_destroy(cls);
OUT4:
    // 注销字符设备驱动对象
    cdev_del(cdev);
OUT3:
    // 释放设备号
    unregister_chrdev_region(MKDEV(major, minor), 1);
OUT2:
    kfree(cdev);
OUT1:
    return ret;
}
static void __exit mycdev_exit(void)
{
    // 销毁设备节点
    device_destroy(cls, MKDEV(major, 0));
    // 释放目录空间
    class_destroy(cls);
    // 1.注销字符设备驱动对象
    cdev_del(cdev);
    // 2.释放设备号
    unregister_chrdev_region(MKDEV(major, minor), 0);
    // 3.释放对象空间
    kfree(cdev);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");