精华内容
参与话题
问答
  • 从单片机到ARM Linux驱动——Linux驱动入门篇

    万次阅读 多人点赞 2020-10-24 10:58:43
    大一到大二这段时间里学习过单片机的相关知识,对单片机有一定的认识和了解。如果要深究其原理可能还差了一些火候。知道如何编写程序来点量一个LED灯,改一改官方提供的例程来实现一些功能做一些小东西,对IIC、SPI...

           大一到大二这段时间里学习过单片机的相关知识,对单片机有一定的认识和了解。如果要深究其原理可能还差了一些火候。知道如何编写程序来点量一个LED灯,改一改官方提供的例程来实现一些功能做一些小东西,对IIC、SPI底层的通信协议有一定的了解,但是学着学着逐渐觉得单片机我也就只能改改代码了(当然有的代码也不一定能改出来)。对于我这种以后不想从事单片机开发想搬砖的码农来说已经差不多了(仅仅是个人观点)。
           在单片机开发中我们常常用到的是裸机,并没有用到操作系统(或者接触过ucos/rtos这种实时操作系统),但是嵌入式Linux开发就必须得在Linux系统中进行操作。我们需要熟悉Linux操作系统,知道Linux的常用命令、文件系统、Linux网络、多线程/多进程,同时要会用vi编辑器、gcc编译器、shell脚本和一些简单的makefile的编写,在这些的基础之上进行Linux驱动开发的学习就会如步青云。

    往期推荐:
           史上最全的Linux常用命令汇总(超全面!超详细!)收藏这一篇就够了!
           STM32通过PWM产生频率为20HZ占空比为50%方波,并通过单片机测量频率并显示在这里插入图片描述

           嵌入式Linux操作系统具有:开放源码、所需容量小(最小的安装大约需要2MB)、不需著作权费用、成熟与稳定(经历这些年的发展与使用)、良好的支持等特点。因此被广泛应用于移动电话、个人数码等产品中。嵌入式Linux开发主要包括:底层驱动、操作系统内核、应用开发三大类。需要掌握系统移植(Uboot、Linux Kernel的移植和裁剪、根文件系统的构建)、Linux驱动及内核开发(字符设备驱动、块设备驱动、网络设备驱动)应用开发由于博主能力有限所了解的也不多。

    字符设备驱动简介

           字符设备是Linux驱动中最基本的一类设备驱动,字符设备就是一个字节,按照字节进行读写操作设备,读写数据是分先后顺序的。比如我们常见的点灯、按键、IIC、SPI、LCD等都是字符设备,这些设备的驱动就叫做字符设备驱动。
           在Linux中开发一般只能是用户态,也就是用户只能编写应用程序,但是要作用于内核,那么就需要了解Linux中应用程序是如何调用内核中的驱动程序的,Linux 应用程序对驱动程序的调用如下图所示:
    在这里插入图片描述
           在Linux 中一切皆为文件,驱动加载成功以后会在“/dev”目录下生成一个相应的文件,应用程序通过对这个名为“/dev/xxx” (xxx 是具体的驱动文件名字)的文件进行相应的操作即可实现对硬件的操作。比如现在有个叫做/dev/led 的驱动文件,此文件是 led 灯的驱动文件。应用程序使用 open 函数来打开文件/dev/led,使用完成以后使用 close 函数关闭/dev/led 这个文件。 open和 close 就是打开和关闭 led 驱动的函数,如果要点亮或关闭 led,那么就使用 write 函数来操作,也就是向此驱动写入数据,这个数据就是要关闭还是要打开 led 的控制参数。如果要获取led 灯的状态,就用 read 函数从驱动中读取相应的状态。
           应用程序运行在用户空间,而 Linux 驱动属于内核的一部分,因此驱动运行于内核空间。当我们在用户空间想要实现对内核的操作,比如使用 open 函数打开/dev/led 这个驱动,因为用户空间不能直接对内核进行操作,因此必须使用一个叫做“系统调用”的方法来实现从用户空间陷入到内核空间,这样才能实现对底层驱动的操作。 open、 close、 write 和 read 等这些函数是有 C 库提供的,在 Linux 系统中,系统调用作为 C 库的一部分。当我们调用 open 函数的时候流程如图所示:
    在这里插入图片描述
           应用程序使用到的函数在具体的驱动中都有与之对应的函数,比如应用程序中调用了 open 这个函数,那么在驱动程序中也得有一个名为 open 的函数。每一个系统调用,在驱动中都有与之对应的一个驱动函数,在 Linux 内核文件 include/linux/fs.h 中有个叫做 file_operations 的结构体,此结构体就是 Linux 内核驱动操作函数集合

    struct file_operations {
    	struct module *owner;//owner 拥有该结构体的模块的指针,一般设置为 THIS_MODULE
    	loff_t (*llseek) (struct file *, loff_t, int);//llseek 函数用于修改文件当前的读写位置
    	ssize_t (*read) (struct file *, char __user *, size_t, loff_t*);//read 函数用于读取设备文件
    	ssize_t (*write) (struct file *, const char __user *, size_t,loff_t *);//write 函数用于向设备文件写入(发送)数据
    	ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
    	ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
    	int (*iterate) (struct file *, struct dir_context *);
    	unsigned int (*poll) (struct file *, struct poll_table_struct*);//poll 是个轮询函数,用于查询设备是否可以进行非阻塞的读写
    	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);//unlocked_ioctl 函数提供对于设备的控制功能,与应用程序中的 ioctl 函数对应。
    	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);//compat_ioctl 函数与 unlocked_ioctl 函数功能一样,区别在于在 64 位系统上,32 位的应用程序调用将会使用此函数。在 32 位的系统上运行 32 位的应用程序调用的是unlocked_ioctl。
    	int (*mmap) (struct file *, struct vm_area_struct *);//mmap 函数用于将将设备的内存映射到进程空间中(也就是用户空间),一般帧缓冲设备会使用此函数,比如 LCD 驱动的显存,将帧缓冲(LCD 显存)映射到用户空间中以后应用程序就可以直接操作显存了,这样就不用在用户空间和内核空间之间来回复制。
    	int (*mremap)(struct file *, struct vm_area_struct *);
    	int (*open) (struct inode *, struct file *);//open 函数用于打开设备文件。
    	int (*flush) (struct file *, fl_owner_t id);
    	int (*release) (struct inode *, struct file *);//release 函数用于释放(关闭)设备文件,与应用程序中的 close 函数对应。
    	int (*fsync) (struct file *, loff_t, loff_t, int datasync);//fasync 函数用于刷新待处理的数据,用于将缓冲区中的数据刷新到磁盘中。
    	int (*aio_fsync) (struct kiocb *, int datasync);//aio_fsync 函数与 fasync 函数的功能类似,只是 aio_fsync 是异步刷新待处理的数据
    	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 (*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
    };
    

    字符设备驱动开发步骤

           在学习裸机或者 STM32 的时候关于驱动的开发就是初始化相应的外设寄存器,在 Linux 驱动开发中肯定也是要初始化相应的外设寄存器,这是毫无疑问的。只是在 Linux 驱动开发中我们需要按照其规定的框架来编写驱动,所以说学 Linux 驱动开发重点是学习其驱动框架

    驱动模块的加载和卸载

           Linux 驱动有两种运行方式第一种就是将驱动编译进 Linux 内核中,这样当 Linux 内核启动的时候就会自动运行驱动程序第二种就是将驱动编译成模块(Linux 下模块扩展名为.ko),在Linux 内核启动以后使用“insmod”命令加载驱动模块。在调试驱动的时候一般都选择将其编译为模块,这样我们修改驱动以后只需要编译一下驱动代码即可,不需要编译整个 Linux 代码。而且在调试的时候只需要加载或者卸载驱动模块即可,不需要重启整个系统。

           模块有加载和卸载两种操作,我们在编写驱动的时候需要注册这两种操作函数,模块的加载和卸载注册函数如下:

    module_init(xxx_init); //注册模块加载函数
    module_exit(xxx_exit); //注册模块卸载函数
    

           module_init 函数用来向 Linux 内核注册一个模块加载函数,参数 xxx_init 就是需要注册的具体函数,当使用“insmod”命令加载驱动的时候, xxx_init 这个函数就会被调用。 module_exit()函数用来向 Linux 内核注册一个模块卸载函数,参数 xxx_exit 就是需要注册的具体函数,当使用“rmmod”命令卸载具体驱动的时候 xxx_exit 函数就会被调用。字符设备驱动模块加载和卸载模板如下所示:

     /* 驱动入口函数 */
    static int __init xxx_init(void)
    {
    	/* 入口函数具体内容 */
    	return 0;
    }
    /* 驱动出口函数 */
    static void __exit xxx_exit(void)
    {
    	 /* 出口函数具体内容 */
     }
    
    	/* 将上面两个函数指定为驱动的入口和出口函数 */
    	module_init(xxx_init);
    	module_exit(xxx_exit);
    
    • 第 2 行,定义了个名为 xxx_init 的驱动入口函数,并且使用了“__init”来修饰。
    • 第 9 行,定义了个名为 xxx_exit 的驱动出口函数,并且使用了“__exit”来修饰。
    • 第 15 行,调用函数 module_init 来声明 xxx_init 为驱动入口函数,当加载驱动的时候 xxx_init函数就会被调用。
    • 第16行,调用函数module_exit来声明xxx_exit为驱动出口函数,当卸载驱动的时候xxx_exit函数就会被调用。

           驱动编译完成以后扩展名为.ko,有两种命令可以加载驱动模块: insmodmodprobe,insmod是最简单的模块加载命令,此命令用于加载指定的.ko 模块,比如加载 drv.ko 这个驱动模块,命令如下:

    	insmod drv.ko
    

           insmod 命令不能解决模块的依赖关系,比如 drv.ko 依赖 first.ko 这个模块,就必须先使用insmod 命令加载 first.ko 这个模块,然后再加载 drv.ko 这个模块。但是 modprobe 就不会存在这个问题, modprobe 会分析模块的依赖关系,然后会将所有的依赖模块都加载到内核中,因此modprobe 命令相比 insmod 要智能一些。 modprobe 命令主要智能在提供了模块的依赖性分析、错误检查、错误报告等功能,推荐使用 modprobe 命令来加载驱动。 modprobe 命令默认会去/lib/modules/目录中查找模块,比如本书使用的 Linux kernel 的版本号为 4.1.15,因此 modprobe 命令默认到/lib/modules/4.1.15 这个目录中查找相应的驱动模块,一般自己制作的根文件系统中是不会有这个目录的,所以需要自己手动创建。驱动模块的卸载使用命令“rmmod”即可,比如要卸载 drv.ko,使用如下命令即可:

    	rmmod drv.ko
    

           也可以使用“modprobe -r”命令卸载驱动,比如要卸载 drv.ko,命令如下:

    	modprobe -r drv.ko
    

           使用 modprobe 命令可以卸载掉驱动模块所依赖的其他模块,前提是这些依赖模块已经没有被其他模块所使用,否则就不能使用 modprobe 来卸载驱动模块。所以对于模块的卸载,还是推荐使用 rmmod 命令。

    字符设备注册与注销

           对于字符设备驱动而言,当驱动模块加载成功以后需要注册字符设备,同样,卸载驱动模块的时候也需要注销掉字符设备。字符设备的注册和注销函数原型如下所示:

    static inline int register_chrdev(unsigned int major, const char *name,const struct file_operations *fops)
    static inline void unregister_chrdev(unsigned int major, const char *name)
    
    • register_chrdev 函数用于注册字符设备,此函数一共有三个参数,这三个参数的含义如下:
    • major: 主设备号, Linux 下每个设备都有一个设备号,设备号分为主设备号和次设备号两部分,关于设备号后面会详细讲解。
    • name:设备名字,指向一串字符串。
    • fops: 结构体 file_operations 类型指针,指向设备的操作函数集合变量。
    • unregister_chrdev 函数用户注销字符设备,此函数有两个参数,这两个参数含义如下:
    • major: 要注销的设备对应的主设备号。
    • name: 要注销的设备对应的设备名。

    一般字符设备的注册在驱动模块的入口函数 xxx_init 中进行,字符设备的注销在驱动模块的出口函数 xxx_exit 中进行。在下面代码中字符设备的注册和注销,内容如下所示:

    static struct file_operations test_fops;
    
    /* 驱动入口函数 */
    static int __init xxx_init(void)
    {
    	/* 入口函数具体内容 */
    	int retvalue = 0;
    
    	/* 注册字符设备驱动 */
    	retvalue = register_chrdev(200, "chrtest", &test_fops);
    	if(retvalue < 0){
    		/* 字符设备注册失败,自行处理 */
    	}
    	return 0;
    }
    
    /* 驱动出口函数 */
    static void __exit xxx_exit(void)
    {
    	/* 注销字符设备驱动 */
    	unregister_chrdev(200, "chrtest");
    }
    
    /* 将上面两个函数指定为驱动的入口和出口函数 */
    module_init(xxx_init);
    module_exit(xxx_exit);
    
    • 以上代码中,一开始定义了一个 file_operations 结构体变量 test_fops, test_fops 就是设备的操作函数集合,只是此时我们还没有初始化 test_fops 中的 open、 release 等这些成员变量,所以这个操作函数集合还是空的。
    • 第十行,调用函数 register_chrdev 注册字符设备,主设备号为 200,设备名字为“chrtest”,设备操作函数集合就是第 1 行定义的 test_fops。要注意的一点就是,选择没有被使用的主设备号,输入命令cat /proc/devices可以查看当前已经被使用掉的设备号。
    • 第二十一行,调用函数 unregister_chrdev 注销主设备号为 200 的这个设备。

    实现设备的具体操作函数

           file_operations 结构体就是设备的具体操作函数,在示例代码 40.2.2.1 中我们定义了file_operations结构体类型的变量test_fops,但是还没对其进行初始化,也就是初始化其中的open、release、 read 和 write 等具体的设备操作函数。本节小节我们就完成变量 test_fops 的初始化,设置好针对 chrtest 设备的操作函数。在初始化 test_fops 之前我们要分析一下需求,也就是要对chrtest 这个设备进行哪些操作,只有确定了需求以后才知道我们应该实现哪些操作函数。假设对 chrtest 这个设备有如下两个要求:
    1、能够对 chrtest 进行打开和关闭操作
           设备打开和关闭是最基本的要求,几乎所有的设备都得提供打开和关闭的功能。因此我们需要实现 file_operations 中的 open 和 release 这两个函数。
    2、对 chrtest 进行读写操作
           假设 chrtest 这个设备控制着一段缓冲区(内存),应用程序需要通过 read 和 write 这两个函数对 chrtest 的缓冲区进行读写操作。所以需要实现 file_operations 中的 read 和 write 这两个函数。需求很清晰了,修改驱动示例代码在其中加入 test_fops 这个结构体变量的初始化操作,完成以后的内容如下所示:

    /* 打开设备 */
    static int chrtest_open(struct inode *inode, struct file *filp)
    {
    	/* 用户实现具体功能 */
    	return 0;
    }
    /* 从设备读取 */
    static ssize_t chrtest_read(struct file *filp, char __user *buf,
    size_t cnt, loff_t *offt)
    {
    	/* 用户实现具体功能 */
    	return 0;
    }
    
    /* 向设备写数据 */
    static ssize_t chrtest_write(struct file *filp,
    const char __user *buf,
    size_t cnt, loff_t *offt)
    {
    	/* 用户实现具体功能 */
    	return 0;
    }
    /* 关闭/释放设备 */
    static int chrtest_release(struct inode *inode, struct file *filp)
    {
    	/* 用户实现具体功能 */
    	return 0;
    }
    
    static struct file_operations test_fops = {
    	.owner = THIS_MODULE,
    	.open = chrtest_open,
    	.read = chrtest_read,
    	.write = chrtest_write,
    	.release = chrtest_release,
    };
    
    /* 驱动入口函数 */
    static int __init xxx_init(void)
    {
    	/* 入口函数具体内容 */
    	int retvalue = 0;
    	
    	/* 注册字符设备驱动 */
    	retvalue = register_chrdev(200, "chrtest", &test_fops);
    	if(retvalue < 0){
    		/* 字符设备注册失败,自行处理 */
    	}
    	return 0;
    }
    
    /* 驱动出口函数 */
    static void __exit xxx_exit(void)
    {
    	/* 注销字符设备驱动 */
    	unregister_chrdev(200, "chrtest");
    }
    
    /* 将上面两个函数指定为驱动的入口和出口函数 */
    module_init(xxx_init);
    module_exit(xxx_exit);
    
    • 在上面代码中,我们一开始编写了四个函数:chrtest_openchrtest_readchrtest_writechrtest_release。这四个函数就是 chrtest 设备的 open、 read、 write 和 release 操作函数。第 29行~35 行初始化 test_fops 的 open、read、 write 和 release 这四个成员变量。

    添加LICENSE和作者信息

           在驱动编写最后,我们需要在驱动中加入LICENSE信息和作者信息,其中LICENSE是必须添加的,否则的话编译时会报错,作者信息可以添加也可以不添加。 LICENSE 和作者信息的添加使用如下两个函数:

    	MODULE_LICENSE() //添加模块 LICENSE 信息
    	MODULE_AUTHOR() //添加模块作者信息
    

           给示例代码加入 LICENSE 和作者信息,完成以后的内容如下:

    /* 打开设备 */
    static int chrtest_open(struct inode *inode, struct file *filp)
    {
    	/* 用户实现具体功能 */
    	return 0;
    }
    ......
    
    /* 将上面两个函数指定为驱动的入口和出口函数 */
    module_init(xxx_init);
    module_exit(xxx_exit);
    
    MODULE_LICENSE("GPL");//LICENSE 采用 GPL 协议。
    MODULE_AUTHOR("wly");//添加作者名字
    

           当添加完作者和LICENSE和作者信息后,字符设备驱动的完整流程就基本上结束了,并且也提供了一个完整的Linux驱动的模板,以后字符设备驱动开发就可以修改这个模板。

    Linux设备号

           Linux的设备管理是和文件系统紧密结合的,各种设备都以文件的形式存放在/dev目录下,称为设备文件。应用程序可以打开、关闭和读写这些设备文件,完成对设备的操作,就像操作普通的数据文件一样。为了管理这些设备,系统为设备编了号,这个号就被称为Linux设备号!

    设备号的组成

           设备号由主设备号和次设备号两部分组成,主设备号表示某一个具体的驱动,次设备号表示使用这个驱动的各个设备。 Linux 提供了一个名为 dev_t 的数据类型表示设备号, dev_t 定义在文件include/linux/types.h 里面,定义如下:

    typedef __u32 __kernel_dev_t;
    ......
    typedef __kernel_dev_t dev_t;
    

           可以看出 dev_t 是__u32 类型的,而__u32 定义在文件 include/uapi/asm-generic/int-ll64.h 里面,定义如下:

    typedef unsigned int __u32;
    

           dev_t 其实就是 unsigned int 类型,是一个 32 位的数据类型。这 32 位的数据构成了主设备号和次设备号两部分,其中高 12 位为主设备号,第 20 位为次设备号。因此 Linux系统中主设备号范围为0~4095,所以大家在选择主设备号的时候一定不要超过这个范围。在文件 include/linux/kdev_t.h 中提供了几个关于设备号的操作函数(本质是宏),如下所示:

    #define MINORBITS 20
    #define MINORMASK ((1U << MINORBITS) - 1)
    #define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
    #define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
    #define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))
    
    • 第 1 行,宏 MINORBITS 表示次设备号位数,一共是 20 位。
    • 第 2 行,宏 MINORMASK 表示次设备号掩码。
    • 第 3 行,宏 MAJOR 用于从 dev_t 中获取主设备号,将 dev_t 右移 20 位即可。
    • 第 4 行,宏 MINOR 用于从 dev_t 中获取此设备号,取 dev_t 的低 20 位的值即可。
    • 第 5 行,宏 MKDEV 用于将给定的主设备号和次设备号的值组合成 dev_t 类型的设备号。

    设备号的分配

    1、静态分配设备号

    注册字符设备的时候需要给设备指定一个设备号,这个设备号可以是驱动开发者静态的指定一个设备号,比如选择 200 这个主设备号。有一些常用的设备号已经被 Linux 内核开发者给分配掉了,具体分配的内容可以查看文档 Documentation/devices.txt。并不是说内核开发者已经分配掉的主设备号我们就不能用了,具体能不能用还得看我们的硬件平台运行过程中有没有使用这个主设备号,使用cat /proc/devices命令即可查看当前系统中所有已经使用了的设备号。

    2、动态分配设备号

    静态分配设备号需要我们检查当前系统中所有被使用了的设备号,然后挑选一个没有使用的。而且静态分配设备号很容易带来冲突问题, Linux 社区推荐使用动态分配设备号,在注册字符设备之前先申请一个设备号,系统会自动给你一个没有被使用的设备号,这样就避免了冲突。卸载驱动的时候释放掉这个设备号即可,设备号的申请函数如下:

    int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
    
    • dev:保存申请到的设备号。
    • baseminor: 次设备号起始地址, alloc_chrdev_region 可以申请一段连续的多个设备号,这些设备号的主设备号一样,但是次设备号不同,次设备号以 baseminor 为起始地址地址开始递增。一般 baseminor 为 0,也就是说次设备号从 0 开始。
    • count: 要申请的设备号数量。
    • name:设备名字。

    注销字符设备之后要释放掉设备号,设备号释放函数如下:

    void unregister_chrdev_region(dev_t from, unsigned count)
    
    • from:要释放的设备号。
    • count: 表示从 from 开始,要释放的设备号数量。

           不积小流无以成江河,不积跬步无以至千里。而我想要成为万里羊,就必须坚持学习来获取更多知识,用知识来改变命运,用博客见证成长,用行动证明我在努力。
           如果我的博客对你有帮助、如果你喜欢我的博客内容,记得“点赞” “评论” “收藏”一键三连哦!听说点赞的人运气不会太差,每一天都会元气满满呦!如果实在要白嫖的话,那祝你开心每一天,欢迎常来我博客看看。
    在这里插入图片描述

    展开全文
  • 嵌入式Linux驱动开发

    千人学习 2019-05-11 21:05:29
    说到Linux驱动,尤其是嵌入式Linux驱动,大家可能会望而却步,因为入门太难!很多书上或课程基本是这样的:一上来给我们展示一大堆高深莫测的代码,感觉是C语言,又感觉不是C语言。说它是C语言,这里能找到一些C的...
  • 本课程是linux驱动开发的第5个课程,主要内容是linux的设备驱动模型,包括总线、类、设备、驱动等概念,重点通过platform平台总线的工作来演示设备驱动模型的工作方法,实践环节对上个课程的LED驱动进行平台总线式...
  • linux驱动(一):linux驱动框架

    万次阅读 多人点赞 2017-12-23 11:46:28
    编写linux驱动先看一下驱动框架是什么样子的。 驱动编写和应用层编写有什么区别呢? (一)首先 入口函数的问题。应用层编写我们的入口就是main函数,但在驱动编写时不是这样的,有两种情况, 1、缺省情况下 int...

    编写linux驱动先看一下驱动框架是什么样子的。

    驱动编写和应用层编写有什么区别呢?

    (一)首先 入口函数的问题。应用层编写我们的入口就是main函数,但在驱动编写时不是这样的,有两种情况,

    1、缺省情况下

    int __init init_module(void)  加载模块时的初始化函数,也就是驱动模块的入口函数

    void __exit cleanup_module(void) 卸载模块时的函数,也就是卸载某个驱动时要执行的函数

    2、

    static int __init xxxx_init(void)  加载模块时的初始化函数,也就是驱动模块的入口函数

    static void __exit xxxx_exit(void)  卸载模块时的函数,也就是卸载某个驱动时要执行的函数

    上述两种情况相比,我们一般用第二种,因为第一种的名称是固定的,我们不能做更改,第二种我们可以改写xxxx为我们自己模块的名字。可以达到见文知义。

    在用第二种模式时,我们要首先用固定格式声明一下:

    module_init(xxxx_init);
    module_exit(xxxx_exit);

    来表明加载初始化函数和卸载函数。

    (二)c语言的标准函数库不能使用

            驱动属于内核的一部分,我们此时还无法使用类似像printf这样的c库,但是内核会提供自己的c库,在内核中我们用printk代替printf函数。

    (三)添加LICENSE声明

            linux是开源的系统,那就要我们遵守一定的规范,我们一般用GPL规范,所以在驱动编写时都要声明一下

            MODULE_LICENSE(“GPL”);

    基本的区别就是这些,我们来看一个简单的驱动框架

    #include <linux/init.h>
    #include <linux/module.h>
    #include <linux/kernel.h>
    
    
    MODULE_LICENSE("GPL");
    
    static int __init demo_init(void)
    {
    	printk("%s,%d\n", __func__, __LINE__);
    
    	printk("val:%d\n", obj.val);
    	obj.func();
    
    
    	return 0;
    }
    
    static void __exit demo_exit(void)
    {
    	printk("%s,%d\n", __func__, __LINE__);
    }
    
    module_init(demo_init);
    module_exit(demo_exit);
    完成驱动编写后,如何才能加载到内核呢?我们需要通过Makefile生成.ko文件,一个简单的Makefile如下,这是在ubutnu下的Makefile,如果换为ARM平台下的linux需要更换源文件目录。具体解释可以看内核模块编译makefile入门。执行make即可生成模块.ko文件
    $(warning KERNELRELEASE = $(KERNELRELEASE))
    
    ifeq ($(KERNELRELEASE),)
    
    #内核的源码路径, ?= 条件赋值, uname -r  得到内核的版本号
    KERNELDIR ?= /lib/modules/$(shell uname -r)/build  
    
    # := 立即赋值, 得到当前的绝对路径
    PWD := $(shell pwd)
    
    
    # -C 切换工作路径, make -c
    modules:
    	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
    
    clean:
    	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions Module* modules*
    
    .PHONY: modules  clean
    
    else
    	  # 生成模块
           obj-m := used.o 
    	
    endif
    
    


    下面我们来看几个驱动中常用的命令

    1、加载驱动模块insmod

         将生成驱动模块.ko文件加载,

         insmod xxx.ko

         加载后就会执行xxxx_init函数

    2、卸载驱动模块rmmod

         对应的卸载驱动的命令

         rmmod xxxx 注意不用带.ko

    3、查看内核中的模块信息

         lsmod

    4、查看模块的描述信息

         modinfo xxxx.ko

         我们可以在驱动程序添加一些辅助信息,例如作者 ,驱动描述等。

    5、查看模块打印信息

         dmesg   

         printk是内核打印函数,默认模式下在中断下无法显示(当然,可以设置成打印到终端),用dmesg可以查看一下打印到内核的信息。

    上述几个比较常用,有其他的我们可以以后再看。

    我们把上述几个熟悉一下

    insmod /rmmod/dmesg

     

    加载模块后执行初始化函数,打印函数名和行号


    卸载模块后执行卸载函数,打印函数名和行号

    打印模块信息 modinfo


    查看内核中模块信息lsmod


    module为模块名称   size为模块打下  usedby 表明有几个其他文件使用

    实际上lsmod是读取并分析“/proc/modules”文件,我们来看一下这个文件


    内核已经加载的模块的信息也存在于/sys/module目录下,加载demo.ko后,内核中将包含/sys/moudle/demo目录,demo的目录树结构如下


    除了使用insmod加载模块以外,还可以用modprobe命令来加载模块,并且使用modprobe加载模块时,会同时加载模块所依赖的其他模块。insmod必须按顺序一个一个加载模块。同样在卸载时,modprobe -r filename的方式会同时卸载该模块所依赖的模块。

    模块之间的依赖关系放在/lib/modules/<kernel-version>/modules.dep文件中。实际上是在整体编译内核的时候由depmod工具生成的,该文件的格式很简单:有依赖的直接在“:”后面加上。











    展开全文
  • Linux驱动系列目录

    千次阅读 多人点赞 2019-08-26 18:04:43
  • 本课程是linux驱动开发的第一个课程,主要介绍linux驱动的概念、模块化设计理念、分类、安全性要求,后讲解了linux驱动课程的整体学习方法。学习本课程主要是为后续正式学习linux驱动打个基础。
  • 本课程是linux驱动开发的第7个课程,主要内容是linux的framebuffer驱动详解,本课程带大家分析fb驱动的框架、构成以及一些代码细节,目标是让大家彻底掌握fb驱动在内核中的配置和移植方法、掌握显示设备驱动的关键点...
  • linux驱动分类

    千次阅读 2019-07-04 15:35:05
    linux驱动工程师必须理解的驱动分类 众所周知linux驱动分为三个类,分别为: 字符设备驱动 块设备驱动 网络设备驱动 这三种驱动之前有什么联系或者说有什么差异点呢,可能很多人都不了解,我在研究过程中...

    linux驱动工程师必须理解的驱动分类

    众所周知linux驱动分为三个类,分别为:

    1. 字符设备驱动
    2. 块设备驱动
    3. 网络设备驱动

    这三种驱动之前有什么联系或者说有什么差异点呢,可能很多人都不了解,我在研究过程中为了更好的理解,所以做了一个总结。

    首先我们来看看字符设备驱动和块设备驱动是怎么定义的:

    字符设备驱动

    字符设备驱动是以不定长度的字元来传送资料,字符设备是一个顺序的数据流设备,对这种设备的读写是按字符进行的,而且这些字符是连续地形成一个数据流;
    
    字符设备驱动的关键数据结构有cdev(用来描述一个字符设备)和file_operations结构体的操作
       struct cdev {
    
              struct kobject kobj;
    
              struct module *owner;                     //所属的模块
    
              struct file_operation *ops              //文件操作结构体
    
              struct list_head list;
    
              dev_t dev;
    
              unsigned int count;
    

    };

    Linux字符设备驱动的组成

       1、字符设备驱动的模块加载和卸载函数
    
              (1)加载函数中:实现设备号的申请和cdev的注册
    
       2、字符设备驱动的file_operations结构体的成员函数
    

    块设备驱动

    块设备驱动是以固定大小长度来传送和转移资料的,块设备能够随机,不需要按照顺序地访问固定大小的数据片。
    
    我们从他们的定义就可以明白,
    字符设备驱动是按照数据流的方式做数据传输的,并且这个数据流是有一定顺序的,譬如说键盘这种字符设备驱动,输入yes这样的字串的时候,就会按照Y->E->S这样的顺序的数据流传输,块设备驱动是可以随机访问固定大小的数据段(和字符设备驱动的数据流差异点),并且被读的块可以不一定是连续的,这里的连续的是指被映射的虚拟地址,譬如说硬盘就是一个块设备。
    

    网络设备

    网络设备是一个比较特殊的设备,它负责接收和发送帧数据,可能是物理帧,也可能是ip数据包,这些特性都有网络驱动决定。它并不存在于/dev下面,所以与一般的设备不同。网络设备是一个net_device结构,并通过register_netdev注册到系统里,最后通过IFconfig -a的命令就能看到。
    

    比较典型的几类驱动:
    1,字符设备驱动:鼠标,键盘,显示器
    2,块设备驱动:硬盘,U盘
    3,网络设备驱动:蓝牙,wifi,网卡等

    展开全文
  • linux驱动编写(总结篇)

    万次阅读 多人点赞 2018-04-12 14:49:18
    01、linux驱动编写(入门) 02、linux驱动编写(虚拟字符设备编写) 03、linux驱动编写(字符设备编写框架) 04、linux驱动编写(Kconfig文件和Makefile文件) 05、linux驱动编写(块设备驱动代码) 06、linux...
  • 本课程是linux驱动开发的第11个课程,主要内容是linux的网络驱动的介绍,首先讲述了网络设备驱动接口和之前讲的2种的不同,然后以一个虚拟网卡驱动源码学习了网卡驱动的框架,后分析了一个实际网卡DM9000的驱动细节...
  • 字符设备驱动-linux驱动开发第3部分

    千人学习 2016-10-18 11:07:11
    本课程是linux驱动开发的第3个课程,接上部分继续讲解字符设备驱动的开发要点,重点是相关的内核源代码的解析和一些真正驱动惯用的编程手法的引入。本课程的目的是让大家开始逐渐习惯和熟悉真正内核驱动的特征,为...
  • 本课程是linux驱动开发的第10个课程,主要内容是linux的块设备驱动的介绍,首先详细讲了块设备驱动和字符设备驱动的核心差异,然后以一个内存模拟的块设备驱动源码为案例演示了块设备驱动如何使用,后对源码进行了...
  • 于此,将框架(Framework)和设计模式(Design Pattern)应用于Linux驱动开发,说明了如何以面向对象、设计模式和框架概念来看待Linux驱动程序的架构。其直接的益处就是:让我们能基于一致的设计理念来结合Android HAL与...
  • 本课程是linux驱动开发的第2个课程,从零开始带领大家逐渐熟悉内核模块,并且一步步写出一个字符设备驱动程序来控制LED等。本课程对驱动的学习非常重要,是驱动学习的入门阶段。
  • 本课程是linux驱动开发的第4个课程,主要内容是驱动框架的引入。通过led驱动框架和gpiolib的这两个框架的详细解释,让大家学习内核中驱动框架的使用方法,这个对后续学习基于框架的复杂驱动非常有帮助。

空空如也

1 2 3 4 5 ... 20
收藏数 91,725
精华内容 36,690
关键字:

linux驱动

linux 订阅