字符设备驱动简介

          字符设备是 Linux 最基本的设备驱动

          字符设备就是一个一个字节，按字节流进行读写操作，读写数据分 先后顺序

          字符设备驱动包括 点灯、按键、 IIC、 SPI，LCD 等

    Linux 应用程序对驱动程序的调用

             Linux 中一切皆为文件

             驱动加载成功后，会在“/dev”目录下生成一个相应的文件

             此文件就是驱动文件

            open 打开 该驱动函数

            close 关闭 该驱动函数

            write 函数 向此驱动 写入数据

            read 函数从驱动中读取相应的状态

             应用程序 运行在 用户空间

             驱动 运行在 内核空间

      open 函数调用流程

// linux-5.5.4/include/linux/fs.h
/* Linux 内核驱动操作函数集合 */

struct file_operations
{ 
    struct module *owner;                              // 该结构体的模块的指针
    loff_t (* llseek) (struct file *, loft_t, int);    // 修改文件当前的读写位置
    /* 读取设备文件 */
    ssize_t (* read) (struct file *, char __user *, size_t, loff_t *);
    /* 向设备文件写入数据 */
    ssize_t (* weite) (struct file *, const char __user *, size_t, loff_t *); 
    ssize_t (* read_iter) (struct kiocb *, struct iov_iter *);                   
    ssize_t (* write_iter) (struct kiocb *, stuct iov_iter *);
    int (* iterate) (struct file *, struct dir_context *);
    /* 查询设备是否可以非阻塞的读写 */
    unsigned int (* poll) (struct file *, struct poll_table_struct *);

    /* 提供对设备的控制功能，32位系统，32位的应用程序调用 */
    long (* unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    /* 提供对设备的控制功能，64位系统，32位的应用程序调用 */
    long (* compat_ioctl) (struct file *, unsigned int, unsigned long); 
    /* 将设备的内存映射到进程空间(用户空间), 不用在用户空间和内核空间之间来回复制 */
    int (* mmap) (struct file *, struct vm_area_struct *);  

    int (* mremap) (struct file *, struct vm_area_struct *);
    int (* open) (struct inode *, struct file *);    // 打开设备文件
    int (* flush) (struct file *, fl_owner_t id);    
    int (* release)(struct inode *, struct file *);    // 释放(关闭)设备文件
    int (* fasync)(int, struct file*, int);    //刷新待处理的数据, 将缓冲区的数据刷新到磁盘
    // ...
}__randomize_layout;

字符设备驱动开发步骤

       驱动模块的加载与卸载

          Linux 驱动运行方式：

                驱动编译进 Linux 内核，当 Linux 内核启动时，会运行驱动程序

                驱动编译成模块( .ko )，Linux 内核启动后。

                “ insmod ” 命令 加载驱动模块
                “ rmmod ” 命令卸载具体驱动

         调试驱动时一般将编译为模块，驱动编译为模块最大的好处就是方便开发

// linux-5.5.4/include/linux/module.h

#ifndef MODULE
/**
 * module_init() - driver initialization entry point
 *                  驱动程序初始化函数
 * @x: function to be run at kernel boot time or module insertion
 *      在内核启动或模块插入时运行的函数
 * module_init() will either be called during do_initcalls() (if
 * builtin) or at module insertion time (if a module).  
 * There can only be one per module.
 * 每个模块只能有一个
 */
#define module_init(x)	__initcall(x);

/**
 * module_exit() - driver exit entry point
 *                 驱动程序退出函数
 * @x: function to be run when driver is removed
 *     删除驱动程序时要运行的函数
 * module_exit() will wrap the driver clean-up code
 * with cleanup_module() when used with rmmod when
 * the driver is a module.  
 * If the driver is statically compiled into the kernel, 
 * module_exit() has no effect.
 * 如果驱动程序被静态编译到内核中，module_exit()无效
 * There can only be one per module.
 */
#define module_exit(x)	__exitcall(x);

#else /* MODULE */

/*
 * In most cases loadable modules do not need custom
 * initcall levels. There are still some valid cases where
 * a driver may be needed early if built in, and does not
 * matter when built as a loadable module. Like bus
 * snooping debug drivers.
 */

/* Each module must use one module_init(). */
/* 每个模块必须使用一个module_init() */
#define module_init(initfn)					\
	static inline initcall_t __maybe_unused __inittest(void)		\
	{ return initfn; }					\
	int init_module(void) __copy(initfn) __attribute__((alias(#initfn)));

/* This is only required if you want to be unloadable. */
/* 仅当您要卸载时才需要 */
#define module_exit(exitfn)					\
	static inline exitcall_t __maybe_unused __exittest(void)		\
	{ return exitfn; }					\
	void cleanup_module(void) __copy(exitfn) __attribute__((alias(#exitfn)));

#endif

字符设备驱动模块加载和卸载模板
 

// linux-5.5.4/arch/arm/common/locomo.c

/* 驱动入口函数 */
static int __init locomo_init(void)
{
    /* 入口函数具体内容 */
	int ret = bus_register(&locomo_bus_type);
	if (ret == 0)
		platform_driver_register(&locomo_device_driver);
	return ret;
}
/* 驱动出口函数 */
static void __exit locomo_exit(void)
{
    /* 出口函数具体内容 */
	platform_driver_unregister(&locomo_device_driver);
	bus_unregister(&locomo_bus_type);
}

/* 将上面两个函数指定为驱动的入口和出口函数 */
module_init(locomo_init);
module_exit(locomo_exit);

      驱动编译完成后，扩展名为.ko

           insmod 用于加载指定的 .ko 模块，不能解决模块的依赖关系
           modprobe 会 分析模块的依赖关系，将所有的依赖模块加载到内核
             默认会去 /lib/modules/<kernel-version> 目录中查找模块， Linux kernel 为 版本号

         modprobe -r 可卸载掉驱动模块所依赖的其他模块 

   字符设备注册与注销

            驱动模块加载成功后，需要注册字符设备

            卸载驱动模块时，需要注销掉字符设备

//linux-5.5.4/include/linux/fs.h

/* 注册字符设备
 * major : 主设备号
 * name ：设备名字
 * fops : 指向设备的操作函数集合变量
 */
static inline int register_chrdev(unsigned int major,     
                                  const char *name,
                                  const struct file_operations *fops)
{
    return __register_chardev(major, 0, 256, name, fops);
}

/* 注销字符设备
 * major : 主设备号
 * name ：设备名字
 */
static inline void unregister_chrdev(unsigned int major, 
                                     const char *name)
{
	__unregister_chrdev(major, 0, 256, name);
}

// linux-5.5.4/fs/char_dev.c
/**
 * __register_chrdev() - create and register a cdev occupying a range of minors
 * @major: major device number or 0 for dynamic allocation
 * @baseminor: first of the requested range of minor numbers
 * @count: the number of minor numbers required
 * @name: name of this range of devices
 * @fops: file operations associated with this devices
 *
 * If @major == 0 this functions will dynamically allocate a major and return
 * its number.
 *
 * If @major > 0 this function will attempt to reserve a device with the given
 * major number and will return zero on success.
 *
 * Returns a -ve errno on failure.
 *
 * The name of this device has nothing to do with the name of the device in
 * /dev. It only helps to keep track of the different owners of devices. If
 * your module name has only one type of devices it's ok to use e.g. the name
 * of the module here.
 */
int __register_chrdev(unsigned int major, unsigned int baseminor,
		      unsigned int count, const char *name,
		      const struct file_operations *fops)
{
	struct char_device_struct *cd;
	struct cdev *cdev;
	int err = -ENOMEM;

	cd = __register_chrdev_region(major, baseminor, count, name);
	if (IS_ERR(cd))
		return PTR_ERR(cd);

	cdev = cdev_alloc();
	if (!cdev)
		goto out2;

	cdev->owner = fops->owner;
	cdev->ops = fops;
	kobject_set_name(&cdev->kobj, "%s", name);

	err = cdev_add(cdev, MKDEV(cd->major, baseminor), count);
	if (err)
		goto out;

	cd->cdev = cdev;

	return major ? 0 : cd->major;
out:
	kobject_put(&cdev->kobj);
out2:
	kfree(__unregister_chrdev_region(cd->major, baseminor, count));
	return err;
}

/**
 * __unregister_chrdev - unregister and destroy a cdev
 *                       注销并销毁 cdev
 * @major: major device number
 *         主设备号
 * @baseminor: first of the range of minor numbers            
 * @count: the number of minor numbers this cdev is occupying
 * @name: name of this range of devices
 *
 * Unregister and destroy the cdev occupying the region described by
 * @major, @baseminor and @count.  This function undoes what
 * __register_chrdev() did.
 */
void __unregister_chrdev(unsigned int major, unsigned int baseminor,
			 unsigned int count, const char *name)
{
	struct char_device_struct *cd;

	cd = __unregister_chrdev_region(major, baseminor, count);
	if (cd && cd->cdev)
		cdev_del(cd->cdev);
	kfree(cd);
}

       输入命令“ cat /proc/devices ”可查看 当前已经被使用掉的设备号
 

// linux-5.5.4/arch/mips/sibyte/common/sb_tbprof.c

/* 主设备号为 240 */
#define SBPROF_TB_MAJOR 240
/* 设备名字为“sb_tbprof” */
#define DEVNAME "sb_tbprof"

/* 设备的操作函数集合 */
static const struct file_operations sbprof_tb_fops = 
{
	.owner		= THIS_MODULE,
	.open		= sbprof_tb_open,
	.release	= sbprof_tb_release,
	.read		= sbprof_tb_read,
	.unlocked_ioctl = sbprof_tb_ioctl,
	.compat_ioctl	= sbprof_tb_ioctl,
	.mmap		= NULL,
	.llseek		= default_llseek,
};

/* 驱动入口函数 */
static int __init sbprof_tb_init(void)
{
	struct device *dev;
	struct class *tbc;
	int err;

    /* 主设备号为 SBPROF_TB_MAJOR
     * 设备名字为“DEVNAME”
     */
    if (register_chrdev(SBPROF_TB_MAJOR, DEVNAME, &sbprof_tb_fops)) 
    {
        /* 字符设备注册失败,自行处理 */
	    printk(KERN_WARNING DEVNAME ": initialization failed (dev %d)\n",
		    SBPROF_TB_MAJOR);
	    return -EIO;
    }

    tbc = class_create(THIS_MODULE, "sb_tracebuffer");
    if (IS_ERR(tbc)) 
    {
	    err = PTR_ERR(tbc);
	    goto out_chrdev;
    }
    // ...
out_chrdev:
	unregister_chrdev(SBPROF_TB_MAJOR, DEVNAME);

	return err;
}

static void __exit sbprof_tb_cleanup(void)
{
    device_destroy(tb_class, MKDEV(SBPROF_TB_MAJOR, 0));
    /* 注销字符设备驱动 */
    unregister_chrdev(SBPROF_TB_MAJOR, DEVNAME);
    class_destroy(tb_class);
}
 /* 将上面两个函数指定为驱动的入口和出口函数 */
module_init(sbprof_tb_init);
module_exit(sbprof_tb_cleanup);

   设备的具体操作函数

            设备 进行读写操作框架

/* 打开设备 */
static int xxx_open(struct inode *inode, struct file *filp)
{
    return 0;
}
/* 从设备读取 */
static ssize_t xxx_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    return 0;
}
/* 向设备写数据 */
static ssize_t xxx_write(struct file *file, const char __user *buf, size_t cnt, loff_t *offt)
{
    /* 用户实现具体功能 */
    return 0;
}
 /* 关闭/释放设备 */
static int xxx_release(struct inode *inode, struct file *filp)
{
    /* 用户实现具体功能 */
    return 0;
}

static struct file_oprations xxx_fops = 
{
    .owner = THIS_MODULE,
    .open = xxx_open,
    .read = xxx_read,
    .write = xxx_write,
    .release = xxx.release,
};
/* 驱动入口函数 */
static int __init xxx_init(void)
{
    /* 入口函数具体内容 */
    int retvalue = 0;
    /* 注册字符设备驱动 */
    retvalue = register_chrdev(99, "xxx", &xxx_fops);
    if(retvalue > 0)
    {
        /* 字符设备注册失败,自行处理 */
    }
    return 0;
}
/* 驱动出口函数 */
static void __exit xxx_exit(void)
{
    /* 注销字符设备驱动 */
    unregister_chrdev(99,"xxx");
}
 /* 将上面两个函数指定为驱动的入口和出口函数 */
module_init(xxx_init);
module_exit(xxx_exit);

/* LICENSE 采用 GPL 协议 */
MODULE_LICENSE("GPL");
/* 作者名字 */
MODULE_AUTHOR("CpuCode");

Linux 设备号

       Linux 中每个设备都有一个设备号
       设备号由主设备号和次设备号

        主设备号：一个驱动，高 12 位为主设备号（0 ~ 4095）

        次设备号：使用该驱动的各个设备，低 20 位为次设备号
 

// linux-5.5.4/inlcude/linux/types.h

typedef u32 __kernel_dev_t;
typedef __kernel_dev_t		dev_t;

// linux-5.5.4/include/uapi/asm-generic/int-ll64.h
typedef __u32 u32;
typedef unsigned int __u32;

// linux-5.5.4/include/linux/kdev_t.h

#define MINORBITS	20        //次设备号位数
#define MINORMASK	((1U << MINORBITS) - 1)    //次设备号掩码

#define MAJOR(dev)	((unsigned int) ((dev) >> MINORBITS))    // dev_t 中获取主设备号
#define MINOR(dev)	((unsigned int) ((dev) & MINORMASK))    // dev_t 中获取次设备号

/* 给定的主设备号和次设备号的值组合成 dev_t 类型的设备号 */
#define MKDEV(ma,mi)	(((ma) << MINORBITS) | (mi))    

     设备号的分配

            静态分配设备号

cat /proc/devices    // 查看系统使用的所有设备号

           动态分配设备号

// linux-5.5.4/fs/char_dev.c

/**
 * alloc_chrdev_region() - register a range of char device numbers
 *                         注册一系列字符设备号
 * @dev: output parameter for first assigned number
 *       第一个分配编号的输出参数
 * @baseminor: first of the requested range of minor numbers
 *             第一个请求的次设备数字
 * @count: the number of minor numbers required
 *         次设备的数量
 * @name: the name of the associated device or driver
 *        相关设备或驱动程序的名称
 *
 * Allocates a range of char device numbers.  
 *  分配一系列字符设备号
 * The major number will be chosen dynamically, and returned 
 * (along with the first minor number)in @dev.
 * Returns zero or a negative error code.
 *   返回零或负错误代码
 */
int alloc_chrdev_region(det_t *dev, unsigned baseminor, unsigned count, const char *name)
{
    struct char_device_struct *cd;
    cd = __register_chrdev_region(0, baseminor, count, name);

    if(IS_ERR(cd))
    {
        return PTR_ERR(cd);
    }
    *dev = MKDEV(cd -> major, cd -> baseminor);
    return 0;
}

/**
 * unregister_chrdev_region() - unregister a range of device numbers
 * @from: the first in the range of numbers to unregister
 *        注销的数字范围中的第一个
 * @count: the number of device numbers to unregister
 *         注销的设备号的数量
 *
 * This function will unregister a range of @count device numbers,starting with @from.
 * 取消注册一系列@count设备数量，从@from开始
 * The caller should normally be the one who allocated those numbers in the first place..
 * 
 */
void unregister_chrdev_region(dev_t from, unsigned count)
{
    dev_t to = from + count;
    dev_t n, next;

    for (n = from; n < to; n = next) 
    {
	next = MKDEV(MAJOR(n)+1, 0);

	if (next > to)
        {
            next = to;
        }  
	kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
    }
}

 添加头文件路径

      按下“ Crtl+Shift+P ”打开 VSCode 的控制台，然后输入“C/C++: Edit configurations(JSON) ”，打开 C/C++编辑配置文件，

      .vscode 目录下生成一个名为 c_cpp_properties.json 的文件

         includePath 表示 头文件路径 ( 绝对路径 )

{
    "configurations": 
    [
        {
            "name": "Linux",
            "includePath": 
            [
                "${workspaceFolder}/**",
                "/home/.../linux-5.5.4/include",
                "/home/.../linux-5.5.4/arch/arm/include",
                "/home/.../linux-5.5.4/arch/arm/include/generated/"
            ],
            "defines": [],
            // ...
        }
    ],
    "version": 4
}

  编写程序:

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>

// 主设备号
#define    CHRDEVBASE_MAJOR    99
// 设备名
#define    CHRDEVBASE_NAME    "chrdevbase"

// 读缓冲区
static char readbuf[100];
// 写缓冲区
static char writebuf[100];
static char kerneldata[] = {"kernel data"};

/*
 * 打开设备
 * inode：传递驱动inode
 * filp：设备文件
 * return: 0:成功 其他：失败
 */
static int chrdevbase_open(struct inode*inode, struct file *filp)
{
    // printf：用户态 printk：内核态 1.1
    printk("chrdevbase_open \r\n");
    return 0;
}

/*
 * 读数据
 * filp: 设备文件（文件描述符）
 * buf: 返回给用户空间的数据缓冲区
 * cnt: 数据长度
 * offt：相当于文件首地址的偏移
 * return: 成功：字节数 失败：负值
 */
static ssize_t chrdevbase_read(struct file *filp, 
                               char __user *buf, 
                               ssize_t cnt, 
                               loff_t *offt)
{
    int retvalue = 0;

    printk("chrdevbase read!\r\n");
    //  kerneldata 数组中的数据拷贝到读缓冲区 readbuf 
    memcpy(readbuf, kerneldata, sizeof(kerneldata)):
    /* readbuf 中的数据复制到参数 buf
     * 内核空间不能直接操作用户空间的内存
     */
    retvalue = copy_to_user(buf, readbuf, cnt);

    if(retvalue == 0)
    {
        printk("kernel senddata ok \r\n");
    }
    else
    {
        printk("kernel senddata failed \r\n");

    }

    return 0;
}

/*
 * 写数据
 * filp：设备文件
 * buf：写入数据
 * cnt：数据长度
 * offt：对于文件首地址的偏移量
 * return：成功：字节数 失败：负数
 */
static ssize_t chrdevbase_write(struct file *filp,
                                const char __user *buf, 
                                size_t cnt, 
                                loff_t *offt)
{
    int retvalue = 0;

    printk("chrdevbase write \r\n");
    /* buf 中的数据复制到写缓冲区 writebuf
     * 用户空间内存不能直接访问内核空间的内存
     */
    retvalue = copy_from_user(writebuf, buf, cnt);
    
    if(retvalue == 0)
    {
        printk("kernel recevdata:%s \r\n", writebuf);
    }
    else
    {
        printk("kernel recevdata failed \r\n");
    }

    return 0;
}

/*
 * 关闭设备
 * filp：关闭设备文件
 * return: 成功：0 失败：其他
 */
static int chrdevbase_release(struct inode *inode, struct file *filp)
{
    printk("chrdevbase release \r\n");
    return 0;
}

// 设备操作函数结构体
static struct file_operations chrdevbase_fops =
{
    .owner = THIS_MODULE,
    .open = chrdevbase_open,
    .read = chrdevbase_read,
    .write = chrdevbase_write,
    .release = chrdevbase_release,
};

/*
 * 驱动入口
 * return：成功：0 失败: 其他
 */
static int __init chrdevbase_init(void)
{
    int retvalue =0;
    printk("chrdevbase_init \r\n");

    // 注册字符设备驱动
    retvalue = register_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME, &chrdevbase_fops);
    
    if(retvalue < 0)
    {
        printk("chrdevbase driver register failed \r\n");
    }

    return 0;
}

// 驱动出口
static void __exit chrdevbase_exit(void)
{
    // 注销字符设备驱动
    unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME);
    printk("chrdevbase_exit() \r\n");
}

// 驱动入口 出口
module_init(chrdevbase_init);
module_exit(chrdevbase_exit);

// LICENSE 作者
MODULE_LICENSE("GPL");
MODULE_AUTHOR("CpuCode");

/* linux-5.5.4/linux/kern_levels.h */
/* 1.1
 *  0 的优先级最高 7 的优先级最低
 *
 */
#define KERN_SOH	"\001"		/* ASCII Start Of Header */
#define KERN_SOH_ASCII	'\001'

#define KERN_EMERG	KERN_SOH "0"	/* system is unusable */
#define KERN_ALERT	KERN_SOH "1"	/* action must be taken immediately */
#define KERN_CRIT	KERN_SOH "2"	/* critical conditions */
#define KERN_ERR	KERN_SOH "3"	/* error conditions */
#define KERN_WARNING	KERN_SOH "4"	/* warning conditions */
#define KERN_NOTICE	KERN_SOH "5"	/* normal but significant condition */
#define KERN_INFO	KERN_SOH "6"	/* informational */
#define KERN_DEBUG	KERN_SOH "7"	/* debug-level messages */

// linux-5.5.4/include/linux/printk.h
/* printk's without a loglevel use this.. */
#define MESSAGE_LOGLEVEL_DEFAULT CONFIG_MESSAGE_LOGLEVEL_DEFAULT
/*
 * Default used to be hard-coded at 7, quiet used to be hardcoded at 4,
 * we're now allowing both to be set from kernel config.
 */
#define CONSOLE_LOGLEVEL_DEFAULT CONFIG_CONSOLE_LOGLEVEL_DEFAULT

//linux-5.5.7/include/generated/autoconf.h
#define CONFIG_MESSAGE_LOGLEVEL_DEFAULT 4
#define CONFIG_CONSOLE_LOGLEVEL_DEFAULT 7

//linux-5.5.7/tools/virtio/linux/uaccess.h

static inline int copy_from_user(void *to, const void __user volatile *from,
				 unsigned long n)
{
	__chk_user_ptr(from, n);
	volatile_memcpy(to, from, n);
	return 0;
}

static inline int copy_to_user(void __user volatile *to, const void *from,
			       unsigned long n)
{
	__chk_user_ptr(to, n);
	volatile_memcpy(to, from, n);
	return 0;
}

   编写应用程序

      C 库文件操作基本函数

                open 函数

/*
 * pathname:打开的设备或 文件名
 * return: 成功：文件描述符
 */
int open(const char *pathname, int flags)

             flags： 文件打开模式

          O_RDONLY    只读模式

          O_WRONLY   只写模式

          O_RDWR        读写模式

           O_APPEND       每次写操作都写入文件的末尾

           O_CREAT           如文件不存在，就创建该文件

           O_EXCL            如文件存在，返回-1 并修改errno的值

           O_TRUNC         如文件存在，并以只写/读写打开，清空文件全部内容

           O_NOCTTY       如路径名指终端设备，不作控制终端

           O_NONBLOCK  

           DSYNC            

           O_RSYNC        

           O_SYNC         

            read 函数

/*
 * fd:文件描述符
 * buf：数据读取到buf
 * count：数据长度
 * return：成功：字节数，文件名末尾返回0  失败：负值
 */
ssize_t read(int fd, void *buf, size_t count)

          write 函数

/*
 * fd: 文件描述符
 * buf：写入的数据
 * count：数据长度
 * return：成功：字节数 没有数据返回0 失败：负值
 */
ssize_t write(int fd, const void *buf, size_t count)

           close 函数

/*
 * fd：文件描述符
 * return：成功:0 失败：负值
 */
int close(int fd)

应用程序：

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

// 测试数据
static char usrdata[] = {"usr data"};

/*
 * argc: argv数组个数
 * argv:命令行参数
 * return：成功:0 失败：负值
 */
int main(int argc, char *argv[])
{
    int fd;
    int retalue;
    char *filename;
    char readbuf[100],writebuf[100];
    
    // 判断参数是否为 3
    if(argc != 3)
    {
        printf("Error Usage \r\n");
        return -1;
    }

    // 设备名
    filename = argv[1];
    
    // 打开驱动文件
    fd = open(filename, O_RDWR);

    if(fd < 0)
    {
        printf("Can't open file %s \r\n", filename);
        return -1;
    }

    // 读取数据，atoi 字符数转换为数字
    if(atoi(argv[2]) == 1)
    {
        //驱动文件中读取数据
        retvalue = read(fd, readbuf, 50);

        if(retvalue < 0)
        {
            printf("read file %s failed \r\n", filename);
        }
        else
        {
            // 读取成功，打印数据
            printf("read data %s \r\n", readbuf);
        }
    }

    // 写数据
    if(atoi(argv[2]) == 2)
    {
        // 写数据
        memcpy(writebuf, usrdata, sizeof(usrdata));
        retvalue = write(fd, writebuf, 50);
        if(retvalue < 0)
        {
            printf("write file %s failed \r\n", filename);
        }
    }

    // 关闭设备
    retvalue = close(fd);
    
    if(retvalue < 0)
    {
        printf("can't close file %s \r\n", filename);
        return -1;
    }

    return 0;
}

Makefile：

# linux内核的绝对路径
KERNELDIR := /home/cpucode/linux-5.5.7
# 当前路径
CPRRENT_PATH := $(shell pwd)
#将文件编译为ko模块
obj-m := chrdevbase.o

build:kernel_modules

# modules ：编译模块
# -C：当前目录切换到KERNELDIR
# M:模块源码目录
kernel_modules:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

编译驱动程序：

make

编译应用程序：

arm-linux-gnueabihf-gcc chrdevbaseApp.c -o chrdevbaseApp

#查看程序信息
file chrdevbaseApp

加载驱动文件

modprobe chrdevbase.ko

# 查看模块
lsmod

# 查看所有设备
cat /proc/devices

# mknod：创建节点
# chrdevbase：创建节点目录
# c:字符设备
# 99: 主设备
# 9：次数
mknod /dev/chrdevbase c 99 9

#卸载模块
rmmod chrdevbase.ko