字符设备驱动内部实现原理解析

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

用户层：

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

内核层：

1. 内核层的VFS虚拟文件系统层，根据open传递的文件路径找到文件的inode 结构体
   • inode号是存在文件系统的唯一标识，同时也是索引当前文件的inode的索引号
2. 根据inode结构体找到文件对应的驱动对象指针（struct cdev）
3. 根据驱动对象指针找到驱动对象的操作方法结构体指针（struct file_operations *ops）
4. 回调操作方法结构体指针中的open

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

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

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

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

2. 字符设备驱动对象的初始化

   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，失败返回错误码

   4. 注销流程

      1. 字符设备驱动对象的注销

      void cdev_del(struct cdev *);
      功能：字符设备驱动对象的注销
      参数：字符设备驱动对象指针
      返回值：无

      2. 释放申请的设备号

      unregister_chrdev_region(MKDEV(major,minor),3);

      3. 释放对象空间

         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");