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

用户层：

当用户打开（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");