struct cdev {

	struct kobject kobj;  // 这是用于设备驱动模型管理的结构

	struct module *owner; // 字符设备驱动的内核模块对象指针，包含了模块的详细信息

	const struct file_operations *ops; // 字符设备驱动的函数操作集

	struct list_head list;  // 一个 List_head 的链表结构，将所有设备驱动串起来

	dev_t dev;   // 字符设备的设备号

	unsigned int count; // 同属一个主设备号的次设备号个数

} __randomize_layout;

#include <linux/module.h>

#include <linux/init.h>

#include <linux/fs.h>

#include <linux/cdev.h>

#include <linux/uaccess.h>

#define DEMO_NAME "demodriver"

static unsigned int count =1 ; // 在一个主设备号下，次设备数量统计

struct demoDriver_cdev

{

    dev_t dev ;    // 字符设备的设备号

    struct cdev *pdev;  // 字符设备的数据结构

    /* data 可以自定义数据 */

} demo_ctx = {

	.dev = 0,

	.pdev = NULL,

};

static int demo_open(struct inode * inode,struct file * file)

{

    // 我们将驱动做成一个设备节点，所以可以用 inode 结构来访问，驱动信息

    int major = MAJOR(inode->i_rdev);

    int minor = MINOR(inode->i_rdev);

    printk(KERN_EMERG"%s: Major Num: %d , Minor Num: %d",__func__,major,minor);

    return 0;

}

static int demo_release(struct inode * inode,struct file * file)

{

    return 0;

}

static ssize_t demo_read(struct file * file, char __user *buf, size_t lbuf,\

                            loff_t *ppos)

{

    printk(KERN_EMERG"%s enter",__func__);

    return 0;

}

static ssize_t demo_write(struct file * file, const char __user *buf, size_t count,\

                            loff_t *f_pos)

{

    printk(KERN_EMERG"%s enter",__func__);

    return 0;

}

static const struct file_operations demo_fops =

{

    .owner = THIS_MODULE,

    .open  = demo_open,

    .release = demo_release,

    .read = demo_read,

    .write = demo_write

};

static int __init demo_init(void)

{

    int ret;

    // 系统自动分配一个主设备号，使用这个接口避免冲突，这里需要 4 个参数 cdev，baseminor ，count ，name

    ret = alloc_chrdev_region(&demo_ctx.dev, 0 ,count,DEMO_NAME);

    if(ret) 

    {

        printk(KERN_EMERG"Faild in alloc char device region");

        return ret;

    }

    demo_ctx.pdev = cdev_alloc(); // 申请设备数据结构

    if (!demo_ctx.pdev)

    {

        printk(KERN_EMERG"cdev_alloc faild");

        goto unregister_chrdev;

    }

    cdev_init(demo_ctx.pdev,&demo_fops); // 结构体和操作函数的指针建立联系

    ret =  cdev_add(demo_ctx.pdev,demo_ctx.dev,count); // 将设备添加到系统中，传入主设备号和次设备数目

    if(ret)

    {

        printk(KERN_EMERG"cdev_add faild");

        goto cdev_fail;

    }

    printk(KERN_EMERG"success register char device: %s\n",DEMO_NAME);

    printk(KERN_EMERG"Major Num: %d , Minor Num: %d",MAJOR(demo_ctx.dev),MINOR(demo_ctx.dev));

    return 0;

// 如果在注册驱动过程失败，则使用进行注销

    cdev_fail:

        cdev_del(demo_ctx.pdev);

    unregister_chrdev:

        unregister_chrdev_region(demo_ctx.dev,count); // 卸载掉，释放回系统

    return ret;

}

static void  __exit demo_exit(void)

{

    printk("remove Device\n");

    if(demo_ctx.pdev)

        cdev_del(demo_ctx.pdev);

    unregister_chrdev_region(demo_ctx.dev,count);

}

module_init(demo_init);

module_exit(demo_exit);

// 模块可选信息

MODULE_LICENSE("GPL");// 许可证声明

MODULE_AUTHOR("junwide");// 作者声明

MODULE_DESCRIPTION("This module is a char device");// 模块描述

MODULE_VERSION("V1.0");// 模块别名

MODULE_ALIAS("Char Modules");// 模块别名

#include <stdio.h>

#include <fcntl.h>

#include <unistd.h>

#define DEMO_DEV_NAME "/dev/demodriver"

int main()

{

	char buffer[64];

	int fd;

	fd = open(DEMO_DEV_NAME, O_RDONLY);

	if (fd < 0) {

		printf("open device %s failded\n", DEMO_DEV_NAME);

		return -1;

	}

	read(fd, buffer, 64);

	close(fd);

	return 0;

}

struct file_operations {

	struct module *owner;

	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 (*read_iter) (struct kiocb *, struct iov_iter *);

	ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);

	int (*iopoll)(struct kiocb *kiocb, bool spin);

	int (*iterate) (struct file *, struct dir_context *);

	int (*iterate_shared) (struct file *, struct dir_context *);

	__poll_t (*poll) (struct file *, struct poll_table_struct *);

	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);

	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);

	int (*mmap) (struct file *, struct vm_area_struct *);

	unsigned long mmap_supported_flags;

	int (*open) (struct inode *, struct file *);

	int (*flush) (struct file *, fl_owner_t id);

	int (*release) (struct inode *, struct file *);

	int (*fsync) (struct file *, loff_t, loff_t, int datasync);

	int (*fasync) (int, struct file *, int);

	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 (*setfl)(struct file *, unsigned long);

	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 **, void **);

	long (*fallocate)(struct file *file, int mode, loff_t offset,

			  loff_t len);

	void (*show_fdinfo)(struct seq_file *m, struct file *f);

#ifndef CONFIG_MMU

	unsigned (*mmap_capabilities)(struct file *);

#endif

	ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,

			loff_t, size_t, unsigned int);

	loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,

				   struct file *file_out, loff_t pos_out,

				   loff_t len, unsigned int remap_flags);

	int (*fadvise)(struct file *, loff_t, loff_t, int);

} __randomize_layout;