一、总体框架图

二、字符设备相关函数

静态申请设备号 register_chrdev_region

函数原型：
	register_chrdev_region(dev_t from, unsigned count, const char *name)
函数作用：
	静态申请设备号，可以一次性申请多个连续的号，count指定申请的个数，from指定起始的设备号
参数含义：
    from: 自定义的 dev_t 类型设备号
    count: 申请设备的数量
    name: 申请的设备名称
函数返回值：
	申请成功返回 0，申请失败返回负数

动态申请设备号 alloc_chrdev_region

函数原型：
	alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name)
函数作用：
	动态申请设备号，可以一次性申请多个连续的号，count指定申请的个数，baseminor指定起始的次设备号，
    相较于静态申请设备号，动态申请会避免注册设备号相同引发冲突的问题。
参数含义：
    dev: 分配得到的第一个设备号
    baseminor: 次设备号可申请的最小值,我一般写0
    count: 申请设备的数量
    name: 申请的设备名称
函数返回值：
	申请成功返回 0，申请失败返回负数
ps: 
	dev2.dev_num = dev1.dev_num + 1        

字符设备初始化 cdev_init

cdev 结构体

struct cdev {
    struct kobject kobj; 		//内嵌的内核对象. 
    struct module *owner; 		//该字符设备所在的内核模块的对象指针. 
    const struct file_operations *ops; //该结构描述了字符设备所能实现的方法，是极为关键的一个结构体.
    struct list_head list; 		//用来将已经向内核注册的所有字符设备形成链表. 
    dev_t dev; 					//字符设备的设备号，由主设备号和次设备号构成. 
    unsigned int count; 		//隶属于同一主设备号的次设备号的个数. 
};

cdev_init在“内核源码/include/fs/char_dev.c文件中定义

void cdev_init(struct cdev *cdev, const struct file_operations *fops)
{
    memset(cdev, 0, sizeof *cdev);		//将整个结构体清零；
    INIT_LIST_HEAD(&cdev->list);		//初始化 list 成员使其指向自身；
    kobject_init(&cdev->kobj, &ktype_cdev_default);		//初始化 kobj 成员；
    cdev->ops = fops;					//初始化 ops 成员，建立 cdev 和 file_operations 之间的连接
}

void cdev_init(struct cdev *, const struct file_operations *);
函数作用：
    初始化传入的 cdev 类型的结构体，并与自定义的 file_operations * 类型的结构体进行链接。
参数含义：
    cdev: 要传入的 cdev 类型结构体，为要初始化的字符设备。
    fops：要传入的 file_operations * 类型结构体，关于 file_operations 结构体的相关的知识会在下一章节进行讲解。
函数返回值：
    无返回值。

字符设备的注册 cdev_add

函数原型：
	int cdev_add(struct cdev *p, dev_t dev, unsigned count)
函数作用：
	该函数向内核注册一个 struct cdev 结构体
参数含义：
    (1)第一个参数为要添加的 struct cdev 类型的结构体
    (2)第二个参数为申请的字符设备号
    (3)第三个参数为和该设备关联的设备编号的数量。
函数返回值：
    添加成功返回 0，添加失败返回负数。

字符设备的注销 cdev_del

函数原型：
	void cdev_del(struct cdev *p);
函数作用：
	该函数会向内核删除一个 struct cdev 类型结构体
参数含义：
	该函数只有一个参数，为要删除的 struct cdev 类型的结构体
函数返回值：无返回值

手动创建设备节点

原型:
	mknod NAME TYPE MAJOR MINOR
参数含义：
    NAME: 要创建的节点名称
    TYPE: b 表示块设备，c 表示字符设备，p 表示管道
    MAJOR：要链接设备的主设备号
    MINOR: 要链接设备的从设备号

例如，使用以下命令创建一个名为 device_test 的字符设备节点，链接设备的主设备号和从设备号分别为 236 和 0：

 mknod /dev/device_test c 236 0

class_create(…)函数

函数原型：
    #define class_create(owner, name) 
    ({ 
        static struct lock_class_key __key; 
        __class_create(owner, name, &__key); 
    })

函数作用：
    用于动态创建设备的逻辑类，并完成部分字段的初始化，然后将其添加进 Linux 内核系统。
参数含义：
	owner：struct module 结构体类型的指针，指向函数即将创建的这个 struct class 的模块。一般赋值为 THIS_MODULE。
name：
    char 类型的指针，代表即将创建的 struct class 变量的名字。
返回值：
    struct class * 类型的结构体。

class_destroy(…)函数

函数原型：
	extern void class_destroy(struct class *cls);
函数作用：
	用于删除设备的逻辑类，即从 Linux 内核系统中删除设备的逻辑类。
参数含义：
	cls：代表即将要删除的 struct class 变量的名字。
返回值：无

device_create(…)函数

函数原型：
struct device *device_create(
    struct class *cls, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...);

函数作用：
	用来在 class 类中下创建一个设备属性文件，udev 会自动识别从而进行设备节点的创建。
参数含义：
    cls：指定所要创建的设备所从属的类。
    parent:指定该设备的父设备，如果没有就指定为 NULL。
    devt:指定创建设备的设备号。
    drvdata:被添加到该设备回调的数据，没有则指定为 NULL。
    fmt：添加到系统的设备节点名称。
返回值：
    struct device * 类型结构体

device_destroy(…)函数

函数原型：
	extern void device_destroy(struct class *cls, dev_t devt);
函数作用：
	用来删除 class 类中的设备属性文件，udev 会自动识别从而进行设备节点的删除。
参数含义：
    cls：指定所要创建的设备所从属的类。
    devt:指定创建设备的设备号。
返回值：无

container_of 函数

函数原型：
	container_of(ptr,type,member);
函数作用：
	通过结构体变量中某个成员的首地址获取到整个结构体变量的首地址。
参数含义：
    ptr 是结构体变量中某个成员的地址。
    type 是结构体的类型
    member 是该结构体变量的具体名字
container_of 宏的作用是通过结构体内某个成员变量的地址和该变量名，以及结构体类型。找到该结构体变量的地址。

三、实例代码

file.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/moduleparam.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/uaccess.h>

struct device_test{
    int major;                  // 主设备号
    int minor;                  // 次设备号
    dev_t dev_num;              // 用来一个32位无符号整形的设备号
    struct cdev cdev_test;      // 定义一个字符设备的cdev结构体
    struct class *class;        // 类
    struct device *device;      // 设备文件
    char kbuf[32];
};

struct device_test dev1;        // 定义一个设备文件结构体


static int cdev_test_open(struct inode * inode, struct file * file){
    file->private_data = &dev1;     // 设置私有数据
    printk("This is cdev_test_open!\n");
    return 0;
}


static ssize_t cdev_test_read(struct file * file, char __user *buf, size_t size, loff_t *off){

    struct device_test *temp_dev = (struct device_test *)file->private_data;

    // strcpy(temp_dev->kbuf, "This is cdev_test_read!")   //模拟内核空间数据

    // copy_to_user 成功返回0，失败返回没有拷贝成功的数据字节数
    if(copy_to_user(buf, temp_dev->kbuf, strlen(temp_dev->kbuf)) != 0){
        printk("copy_to_user error\r\n"); //打印 copy_to_user 函数执行失败
        return -1;
    }

    printk("This is cdev_test_read!\n");
    return 0;
}


static ssize_t cdev_test_write(struct file * file, const char __user * buf, size_t size, loff_t *off){
    struct device_test *temp_dev = (struct device_test *)file->private_data;
    

    if(copy_from_user(temp_dev->kbuf, buf, size) != 0){   // copy_from_user:用户空间向内核空间传数据
        printk("copy_from_user error\r\n");//打印 copy_from_user 函数执行失败
        return -1;
    }
    printk("This is cdev_test_write!\n");
    printk("kbuf is %s! \n", temp_dev->kbuf);
    return 0;
}


static int cdev_test_release(struct inode * inode, struct file * file){
    printk("This is cdev_test_release!\n");
    return 0;
}


struct file_operations cdev_test_ops={
    .owner = THIS_MODULE,    // 文件操作结构体
    .open = cdev_test_open,
    .read = cdev_test_read,
    .write = cdev_test_write,
    .release = cdev_test_release,
};


static int chardev_init(void){
    int ret;     //返回值判断
   
    // 动态注册一个设备号，成功返回0，失败返回复数
    ret = alloc_chrdev_region(&dev1.dev_num, 0, 1, "char_devname");
    if(ret < 0){
        printk("动态注册设备号失败!\n");
        goto err_alloc;
    }
    printk("动态注册设备号成功!\n");
    dev1.major = MAJOR(dev1.dev_num);     //通过 MAJOR()函数进行主设备号获取
    dev1.minor = MINOR(dev1.dev_num);     //通过 MINOR()函数进行次设备号获取
    printk("major = %d!\n",dev1.major);
    printk("minor = %d!\n",dev1.minor);

    cdev_init(&dev1.cdev_test, &cdev_test_ops);  //初始化字符设备结构体cdev_test，并连接到文件操作结构体cdev_test_ops
    dev1.cdev_test.owner = THIS_MODULE;
    ret = cdev_add(&dev1.cdev_test, dev1.dev_num, 1); //使用cdev_add()函数进行字符设备的添加。
    if(ret < 0){
        printk("字符设备注册失败!\n");
        goto err_cdev_add;
    }
    printk("字符设备注册成功!\n");

    dev1.class = class_create(THIS_MODULE, "class");   // 初始化class_create
    if(IS_ERR(dev1.class)){
        ret = PTR_ERR(dev1.class);
        goto err_class_create;
    }
    dev1.device = device_create(dev1.class, NULL, dev1.dev_num, NULL, "device"); //
    if(IS_ERR(dev1.device)){
        ret = PTR_ERR(dev1.device);
        goto err_device_create;
    }


err_device_create:
    class_destroy(dev1.class);      //设备节点建立失败，删除类

err_class_create:
    cdev_del(&dev1.cdev_test);      //类创建失败，删除设备cdev

err_cdev_add:
    unregister_chrdev_region(dev1.dev_num, 1);  //注册设备失败，释放设备号

err_alloc:
    return ret;     //申请设备号失败，返回

    return 0;
}


static void chardev_exit(void){
    //先删除字符设备
    cdev_del(&dev1.cdev_test);
    //再释放字符驱动设备号
    unregister_chrdev_region(dev1.dev_num, 1);

    //删除创建的设备
    device_destroy(dev1.class, dev1.dev_num);
    //删除创建的类
    class_destroy(dev1.class);

    printk("chardev_exit!\n");
}


module_init(chardev_init);
module_exit(chardev_exit);


MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("ZSY");
MODULE_VERSION("V1.0");

Makefile

# 只对当前终端有效
export ARCH=arm64
export CROSS_COMPILE=/home/topeet/source/linux/rk356x_linux/prebuilts/gcc/linux-x86/aarch64/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-

obj-m += file.o
KDIR := /home/topeet/source/linux/rk356x_linux/kernel
PWD ?= $(shell pwd)
all:
	make -C $(KDIR) M=$(PWD) modules
clean:
	make -C $(KDIR) M=$(PWD) clean #make clean 操作 

app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[]){
    int fd;

    char buf1[32] = {0};        // 定义读写缓存区buf1
    char buf2[32] = "nihao!";   // 定义读写缓存区buf2

    fd = open("/dev/device",O_RDWR);   // 打开字符设备驱动文件"device_test"
    if(fd < 0){
        perror("open error \n");
        return fd;
    }

    // read(fd, buf1, sizeof(buf1));
    // printf("buf1 is %s! \n", buf1);

    write(fd, buf2,sizeof(buf2));

    close(fd);
    return 0;
}