精华内容
下载资源
问答
  • linux驱动
    千次阅读
    2021-05-08 23:40:04

    一 ?编写Linux驱动程序

    1.建立Linux驱动骨架

    ? Linux内核在使用驱动时需要装载与卸载驱动

    ?装载驱动:建立设备文件、分配内存地址空间等;module_init 函数处理驱动初始化

    ?卸载驱动:删除设备文件、释放内存地址空间等;module_exit函数处理退出

    包含这两个函数的两个宏的C程序文件也可看做是Linux驱动的骨架

    2.注册和注销设备文件

    任何一个Linux驱动都需要有一个设备文件,否则应用程序将无法与驱动程序交互。

    建立设备文件:在第一步编写的处理Linux初始化工作的函数中完成。misc_register函数

    删除设备文件:在第一步编写的处理Linux退出工作的函数中完成。misc_deregister函数

    3.指定与驱动相关的信息

    驱动程序是自描述的,驱动程序的作者姓名、使用的开源协议、别名、驱动描述等信息。这些信息都需要在驱动源代码中指定。

    MODULE_AUTHOR、MODULE_LICENSE、MODULE_ALLS、MODULE_DESCRIPION等宏可以指定与驱动相关的信息

    4.指定回调函数

    一个驱动程序并不一定要指定所有的回调函数,回调函数会通过相关机制进行注册

    5.编写业务逻辑

    具体的业务逻辑与驱动的功能有关,业务逻辑可能由多个函数、多个文件甚至是多个Linux驱动模块组成

    6.编写Makefile文件

    Linux内核源代码的编译规则是通过Makefile文件定义的。因此编写一个新的Linux驱动程序必须有一个Makefile文件

    7.编译Linux驱动程序

    可以直接编译进内核,也可以作为模块单独编译

    8.安装和卸载Linux驱动

    若将Linux驱动编译进内核,只要Linux使用该内核,驱动程序就会自动转载

    若Linux驱动程序以模块单独存在,需使用insmod或modprode命令装载Linux驱动模块,rmmod命令卸载Linux驱动模块

    二 ?第一个Linux驱动,以word_count为例

    (一)基础编写代码

    #mkdir -p ?/root/drivers/ch06/word_count ? ?建立目录存放Linux驱动程序

    #cd /root/drivers/ch06/word_count

    #echo '' > word_count.c ?建立驱动源代码文件

    #echo 'obj-m := word_count.o' > Makefile ?编写一个Makefile文件 make命令会吧Linux驱动源代码目录中的word_count.c或 word_count.s文件编译成word_count.o文件

    obj-m 表示将Linux驱动作为模块(.ko文件)编译,word_count.o会被连接进word_count.ko文件,然后使用insmod或modprode命令装载word_count.ko

    obj-y ?表示将Linux驱动编译进Linux内核,word_count.o会被连接进built-in.o 文件,最终会被连接进内核

    Linux系统将内存分为了用户空间和内核空间,两者空间的程序不能直接访问,printk函数运行在内核空间,printf函数运行在用户空间,因此属于内核程序的Linux驱动是不能直接访问printf函数的。

    #make -C /usr/src/linux-headers-3.0.0-15-generic ?M=/root/driver/ch06/word_count ? ?编译Linux驱动源代码

    # insmod word_count.ko ?装载驱动

    # lsmod | grep word_count ? 查看word_count是否安装成功

    # rmmod word_count ? 卸载Linux驱动

    #dmesg | grep word_count | tail -n 2 ? ?查看有Linux驱动输出的日志信息

    (二)加入有关指定的信息的代码

    模块作者:MODULE_AUTHOR("lining");

    模块描述:MODULE_DESCRPTION("statistics of word count .");

    模块别名:MODULE_ALIAS("word count module.");

    开源协议: MODULE_LICENSE("GPL");

    ?

    #define DEVICE_NAME "wordcount" ? ?//定义设备文件名

    //描述与设备文件触发的事件对应的回调函数指针

    //owner:设备事件回调幻术应用于哪些驱动模块,THIS_MODULE表示应用于当前驱动模块

    static struct file_operations dev_fops={.owner = THIS_MODULE};

    //描述设备文件的信息

    //minor:次设备号 MISC_DYNAMIC_MINOR,:动态生成次设备号 ?name : ?设备文件名称

    //fops : file_operations 结构体变量指针

    static struct miscdevice misc={.minor = MISC_DYNAMIC_MINOR, .name=DEVICE_NAME,.fops = &dev_fops};

    //初始化Linux驱动

    static ?int word_count_init(void)

    { int ret;

    ? ?ret = misc_register(&misc);

    ? printk("word_count_init_success

    ");

    ?return ret;

    }

    // 卸载Linux驱动

    static void word_count_exit(void)

    ?{ ?misc_deregister(&misc);

    ? ? printk("word_inti_exit_success

    ");

    }

    ?

    由于内核空间的程序不能直接访问用户空间中的数据,因此,需要在word_count_read(从设备文件读数据)和word_count_write(向设备文件写数据) 函数中分别使用copy_to_user和copy_from_user函数将数据从内核空间复制到用户空间或从用户空间复制到内核空间

    (三)装载与卸载驱动

    检查word_count驱动工作是否完全正常

    #dmesg | tail -n 1

    #modinfo word_count.ko

    检测Linux驱动模块的依赖关系

    #depmod /root/drivers/ch06/word_count/word_count.ko

    调用命令装载Linux驱动

    #modprode word_count

    注:insmod 和 modprode 命令都是加载驱动,后者可以检查驱动模块的依赖性

    三 多种方法测试Linux驱动

    (一)使用Ubuntu Linux 测试Linux驱动

    需要编写专门用于测试的程序,例如test_word_count.c

    #gcc test_word_count.c -o test_word_count

    #test_word_count

    #test_word_count "I love you."

    输出结果: String:I love you.

    ? ? ? ? ? ? ? ?word byte display:0,0,0,3

    ? ? ? ? ? ? ? ?word count:3

    ?(二)在android模拟器上通过原生C程序测试Linux驱动

    #cd ~/kernel/goldfish

    #make menuconfig

    aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvOTM2MTgwLzIwMTYwNS85MzYxODAtMjAxNjA1MjYxNjA5NTg2NjMtNDc5MjYyNTE3LmpwZw? ? ?

    aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvOTM2MTgwLzIwMTYwNS85MzYxODAtMjAxNjA1MjYxNjEwMjI1MDYtMTI0OTAwNTQwNC5qcGc

    ?

    按照如图所示进行设置,之后重新编译Linux内核,成功编译内核后,android模拟器可以使用性生成的zImage内核文件动态装载Linux驱动模块。

    两个条件满足可以直接运行普通的Linux程序:android模拟器、开发板或手机需要有root权限;可执行文件需要使用交叉编译器来编译test_word_count.c文件,建立Android.mk设置编译参数,并使用make命令进行编译

    #mm ? 编译.c文件,在相应目录下

    #adb push ?./emulator/test_word_count ?/data/local ? ?上传到Android模拟器

    执行下面命令测试驱动

    #chmod 777 /data/local/test_word_count ? 设置可执行权限

    #/data/local/test_word_count

    #/data/local/test_word_count ?'a bb ccc ddd eee'

    输出结果:5,表示测试成功

    (三)使用Android NDK测试

    (四)使用开发板测试

    (五)将驱动编译进Linux内核进行测试

    ?

    四 在eclipse中开发Linux驱动程序

    第一步:建立C工程

    第二步:建立C源代码文件链接 ? ? New>Source Folder ? Folder name 输入 src,导入word_count.c文件

    第三步:设置include路径 ? 单击菜单项properties,C/C++General > Paths and Symbols ,选中Include的GNU C项,Add添加两个路径:/root/kernel/goldfish/include和/root/kernel/goldfish/arch/arm/include

    第四步:编译Linux驱动

    ?

    测试Linux驱动

    第一步:导入test_word_count.c文件

    第二步:设置include路径

    第三步:建立Target ? ? ?Make Target > Create ,在Target name 文本框中输入word_count_eclipse_test,点击OK

    第四步:Build工程 ? ?Make Target > Build,选中第三步中建立的文件,然后点击Build

    第五步:运行测试程序 ? Run As > Local C/C++ ?Application

    更多相关内容
  • Qualcomm-Atheros-QCA9377-Wifi-Linux驱动,联想E42-80等等型号电脑适用,此外modprobe设置不要加载idea_thinkpad模块(该模块默认禁用wifi硬件,需自行将其加入黑名单)
  • 360随身wifi3 linux驱动

    2016-11-24 21:31:57
    360随身WiFi” linux驱动,ubuntu能用 MT7603U 从网上找的, 由于没有网卡,还没有试。
  • 从单片机到ARM Linux驱动——Linux驱动入门篇

    万次阅读 多人点赞 2020-10-24 10:58:43
    我们需要熟悉Linux操作系统,知道Linux的常用命令、文件系统、Linux网络、多线程/多进程,同时要会用vi编辑器、gcc编译器、shell脚本和一些简单的makefile的编写,在这些的基础之上进行Linux驱动开发的学习就会如步...

           大一到大二这段时间里学习过单片机的相关知识,对单片机有一定的认识和了解。如果要深究其原理可能还差了一些火候。知道如何编写程序来点量一个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 开始,要释放的设备号数量。

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

    展开全文
  • 包括32位和64位的Linux无线网卡驱动,适用于Broadcom多种网卡
  • Linux驱动基础知识(一)

    千次阅读 2022-03-12 21:16:13
    从现在开始,就对Linux驱动进行学习。在进行学习前,肯定是要给自己定下目标,做好准备。怎么学?怎么学好? 相信学习一样东西的目的,是为了解决问题,而不是为了学所学!所以,在学习前我们是抱着为了解决问题的...


    前言

    参考资料:Linux设备驱动开发详解 宋宝华版

    从现在开始,就对Linux驱动进行学习。在进行学习前,肯定是要给自己定下目标,做好准备。怎么学?怎么学好?

    相信学习一样东西的目的,是为了解决问题,而不是为了学所学!所以,在学习前我们是抱着为了解决问题的思想去学习,这样我们的心理将会得到升华。

    那么学习驱动的目的是什么呢?
    因为驱动开发工程师工资高呀,没错确实很大原因和这个有关。(哈哈哈)
    当然,还有一个原因!
    就是设想一下,在我们身边学应用层开发的同学有去关心过printf函数的实现吗?我们学单片机开发的同学有用过printf函数吗?(有些同学用的是被重构的printf,并不是真的printf)。
    而我们的驱动就是解决这样一个问题的存在,即应用软件工程师不关心硬件,而硬件工程师也不用顾及软件的实现

    设备驱动的作用

    任何计算机系统的运转都是系统中软硬件共同努力的结果,没有硬件的软件就是空中楼阁,没有软件的硬件就是一堆废铁。硬件是基础,代码最终会落实为硬件上的组合逻辑和时序逻辑;软件则实现了具体的应用,照顾不同的业务需求,完成了用户的最终诉求。

    而为了提高开发的效率,软件和硬件不应该相互渗透入对方的领域,即软件工程师不担心硬件,硬件工程师不担心软件。也就是说,驱动的作用就是为了给软件工程师打造一个没有硬件的纯粹的软件世界,让硬件透明化。

    通俗的讲,驱动也叫“驱使硬件设备行动”。驱动与底层硬件直接打交道,按照硬件设备具体的工作方式,读写设备的寄存器,完成设备的轮询,中断处理,DMA通信,进行物理内存向虚拟内存地址映射等,最终让通信设备能收发数据,让显示设备能显示文字和画面,让存储设备能记录文件和数据。

    由此可见,设备驱动充当了硬件和软件之间的纽带,应用软件时只需要调用系统的应用编程接口(API)就可以让硬件去完成要求的工作。在系统没有操作系统的情况下,工程师可以根据硬件设备自己定义接口。而在有操作系统的情况下,驱动的框架由相应的操作系统定义,驱动工程师必须按照相应的架构设计驱动这样驱动才能更好的融合在操作系统中。

    无操作系统时的设备驱动

    并不是任何一个计算机系统都需要操作系统,比如针对工作任务比较单一的公交车刷卡器,冰箱等。实现的功能单一,不需要操作系统的任务调度。所以往往我们对此的设计思路就是一个死循环
    相信大家在对单片机进行开发的时候,就有很深刻的印象。我们的程序逻辑都是包含在一个while(1)循环当中的

    int main(int argc,char *argv[]){
    	while(1){
    	//your's code begin
    	gpio_init();
    	key_init();
    	....
    }
    //your's code end
    }
    

    在这样的系统中,虽然不存在操作系统,但是设备驱动则无论如何都必须存在。一般情况下,每种设备驱动都会定义为一个软件模块,包含.h头文件和.c源文件,前者定义设备驱动的数据结构并声明外部函数,后者进行驱动的具体实现。
    其他模块想要使用这个设备的时候,只需要包含设备的头文件然后调用即可。

    正确的设计框架:实现软件和硬件的分离。
    在这里插入图片描述

    有操作系统时的设备驱动

    从上面的无操作系统时设备驱动我们可以看出,设备驱动的硬件操作是必不可少的。没有这一部分驱动不可能和硬件打交道。
    其次,我们还需要将驱动融入到内核。为了实现这种融合,必须在所有设备的驱动中设计面向操作系统内核的接口,这样的接口由操作系统规定,对一类设备而言结构一致,独立于具体的设备。

    由此可见,当系统中存在操作系统的时候,驱动就变成了连接硬件和内核的桥梁。如下:
    在这里插入图片描述

    操作系统的存在势必要求设备驱动附加更多的代码和功能,把单一的“驱使硬件设备行动”变成了操作系统内核与硬件交互的模块,它对外呈现操作系统API,不再给应用软件工程师直接提供接口。

    操作系统通过给驱动制造麻烦来达到给上层应用提供遍历的目的。当驱动都按照操作系统给出的独立于设备的接口而设计时,那么应用程序可使用统一的系统调用接口来访问各种设备。对于类UNIX的Vxworks、Linux等操作系统而言,当应用程序通过read(),write()等函数读写文件就可以访问各种字符设备和块设备,而不论设备的具体类型和工作方式,那将是多么遍历。

    Linux设备驱动

    设备的分类及其特点

    计算机系统的硬件主要由CPU、存储器和外设组成。随着IC制作工艺的发展,目前芯片的集成度越来越高,往往在CPU内部就集成了存储器和外设适配器。像ARM、PowerPC、MIPS等处理器都集成了UART、IIC控制器,SPI控制器、USB控制器,SDRAM控制器等。有的还集成了GPU(图形处理器)、视频编解码器等。

    驱动针对的对象是存储器和外设(包括CPU内部集成的存储器和外设),而不是针对CPU内核。Linux将存储器和外设分为3个基础大类。

    • 字符设备
    • 块设备
    • 网络设备
      字符设备指那些必须以串行顺序依次访问的设备,如触摸屏,磁带驱动器、鼠标等。块设备可以按任意顺序进行访问,以块为单位进行操作,如硬盘,eMMC等。字符设备和块设备的驱动设计有很大的差异,但是对于用户而言,它们都是通过使用文件系统的操作接口open(),close(),read(),write()等进行访问。

    在Linux系统中,网络设备面向数据包的接收和发送而设计,它并不倾向于对应于文件系统的节点。内核与网络设备的通信与内核和字符设备、网络设备的通信方式完全不同,网络设备主要还是使用套接字接口

    Linux设备驱动与整个软硬件系统的关系

    在这里插入图片描述

    除网络设备外,字符设备与块设备都被映射到Linux文件系统的文件和目录,通过文件系统的系统调用接口open()、write()、read() 、close()等即可访问字符设备和块设备。所有的字符设备和块设备都统一呈现给用户。Linux的块设备有两种访问方法:一种是类似于dd命令对应的原始块设备,如“dev/sdb1”等;另一种方法是在块设备上建立FAT,EXT4,BTRFS等文件系统,然后通过文件路径的方式进行访问。
    在Linux中,针对NOR、NAND等提供了独立的内存技术设备子系统,其上运行YAFFS2,JFFS2,UBIFS等具备擦除和负载均衡能力的文件系统。针对磁盘或者Flash设备的FAT,EXT4,YAFFS2,UBIFS等文件系统定义了文件和目录在存储介质上的组织。而Linux虚拟文件系统则统一对他们进行了抽象

    应用程序可以使用Linux的系统调用接口编程,但也可以使用C库函数,出于代码可移植性的目的,后者更值得推荐。C库函数本身也通过系统调用接口而实现,如C库函数fopen()、fwrite()、 fread()、 fclose()分别会调用操作系统的API open(),write(),read(),close()。

    展开全文
  • Linux驱动开发|WiFi驱动

    千次阅读 2022-01-14 17:30:04
    WiFi驱动

    WiFi驱动

    一、WiFi驱动添加与编译

    I.MX6U-ALPHA 开发板目前支持两种接口的 WIFI:USB 和 SDIO,其中 USB WIFI 使用的芯片为 RTL8188EUS 或 RTL8188CUS, SDIO 接口的 WIFI 使用的芯片为 RTL8189FS。这两个都是 realtek 公司出品的 WIFI 芯片。 realtek 公司已经提供了 WIFI 驱动源码,因此只需要将 WIFI 驱动源码添加 到 Linux 内核中,然后通过图形化界面配置,将其编译成模块即可

    1.1 向内核添加 WIFI 驱动
    • rtl81xx 驱动文件: realtek 公司提供驱动文件 realtek 目录下存放着 RTL8188EUS 和 RTL8189FS 两个芯片的驱动源码
      在这里插入图片描述

    Kconfig 是 WIFI 驱动的配置界面文档,这样可以通过 Linux 内核图形化配置界面来选择是否编译 WIFI 驱动, 文件内容如下所示

    menuconfig REALTEK_WIFI
    	tristate "Realtek wifi"
    
    if REALTEK_WIFI
    
    choice
    	prompt "select wifi type"
    	default RTL8189FS
    
    config RTL8189FS
    	depends on REALTEK_WIFI
    	tristate "rtl8189fs/ftv sdio wifi"
    
    config RTL8188EUS
    	depends on REALTEK_WIFI
    	tristate "rtl8188eus usb wifi"
    
    config RTL8192CU
    	depends on REALTEK_WIFI
    	tristate "Realtek 8192C USB WiFi"
    
    endchoice
    endif
    

    Makefile 文件内容如下所示

    obj-$(CONFIG_RTL8188EUS) += rtl8188EUS/
    obj-$(CONFIG_RTL8189FS) += rtl8189FS/
    obj-$(CONFIG_RTL8192CU) += rtl8192CU/
    
    • 删除内核自带的 RTL8192CU 驱动:内核自带了 RTL8192CU/8188CUS 驱动,但是测试后发现自带的驱动不稳定,因此将其屏蔽

    打开 drivers/net/wireless/rtlwifi/Kconfig,找到下面所示内容然后删除掉:

    config RTL8192CU
    tristate "Realtek RTL8192CU/RTL8188CU USB Wireless Network Adapter"
    depends on USB
    select RTLWIFI
    select RTLWIFI_USB
    select RTL8192C_COMMON
    ---help---
    This is the driver for Realtek RTL8192CU/RTL8188CU 802.11n USB
    wireless network adapters.
    
    If you choose to build it as a module, it will be called rtl8192cu
    

    打开 drivers/net/wireless/rtlwifi/Makefile,找到下面所示内容然后删除掉:

    obj-$(CONFIG_RTL8192CU) += rtl8192cu/
    
    • 将 rtl81xx 驱动添加到 Linux 内核中:将 realtek 整个目录拷贝至内核源码中的 drivers/net/wireless 目录下
    • 修改 drivers/net/wireless/Kconfig:打开 Kconfig 文件,在末尾加入下面内容
    source "drivers/net/wireless/realtek/Kconfig
    
    • 修改 drivers/net/wireless/Makefile:打开 Makefile 文件,在末尾加入下面内容
    obj-y += realtek/
    
    1.2 配置内核

    在编译 RTL8188 和 RTL8189 驱动之前需要先配置 Linux 内核

    • 配置 USB 支持设备
    -> Device Drivers
    	-> <*> USB support
    		-> <*> Support for Host-side USB
    			-> <*> EHCI HCD (USB 2.0) support
    			-> <*> OHCI HCD (USB 1.1) support
    			-> <*> ChipIdea Highspeed Dual Role Controller
    				-> [*] ChipIdea device controller
    				-> [*] ChipIdea host controller
    
    • 配置支持 WIFI 设备
    -> Device Drivers
    	-> [*] Network device support
    		-> [*] Wireless LAN
    			-> <*> IEEE 802.11 for Host AP (Prism2/2.5/3 and WEP/TKIP/CCMP)
    				-> [*] Support downloading firmware images with Host AP driver
    				-> [*] Support for non-volatile firmware download
    
    • 配置支持 IEEE 802.11
    -> Networking support
    	-> -*- Wireless
    		-> [*] cfg80211 wireless extensions compatibility
    		-> <*> Generic IEEE 802.11 Networking Stack (mac80211)
    

    配置好以后重新编译 Linux 内核,之后使用新的 zImage 启动系统

    1.3 编译WiFi驱动
    • 执行make menuconfig命令,打开 Linux 内核配置界面,然后按照如下路径选择将 rtl81xx 驱动编译为模块:
    -> Device Drivers
    	-> Network device support (NETDEVICES [=y])
    		-> Wireless LAN (WLAN [=y])
    			-> Realtek wifi (REALTEK_WIFI [=m])
    				-> rtl8189ftv sdio wifi
    				-> rtl8188eus usb wifi
    				-> Realtek 8192C USB WiFi
    

    在这里插入图片描述

    • 执行make modules -j12命令,将上面选中的选项编译为模块
    • 编译完成后,rtl8188EUS、 rtl8189FS 和 rtl8192CU 文件夹下分别生成 8188eu.ko、8189fs.ko 和 8192cu.ko 三个.ko 文件,将这三个文件拷贝至开发板/lib/modules/4.1.15 目录下
    1.4 驱动加载测试

    将 RTL8188 WIFI 模块插到开发板的 USB HOST 接口上。进入到目录 lib/modules/4.1.15 中,输入如下命令加载驱动模块

    depmod 				//第一次加载驱动的时候需要运行此命令
    modprobe 8188eu.ko 	//RTL8188EUS 模块加载 8188eu.ko 模块
    modprobe 8192cu.ko 	//RTL8188CUS 模块加载 8192cu.ko 模块
    

    驱动加载成功,如下图所示:
    在这里插入图片描述
    输入“ifconfig -a”命令,查看 wlanX(X=0….n)网卡是否存在
    在这里插入图片描述

    二、wireless tools工具

    驱动测试正常,但是 WiFi 要想联网,需要移植一些其他第三方组件,否则无法连接路由器,接下来我们就移植这些第三方组件

    wireless tools 是操作 WIFI 的工具集合,包括以下工具:
    ①、 iwconfig:设置无线网络相关参数
    ②、 iwlist:扫描当前无线网络信息,获取 WIFI 热点
    ③、 iwspy:获取每个节点链接的质量
    ④、 iwpriv:操作 WirelessExtensions 特定驱动
    ⑤、 ifrename:基于各种静态标准命名接口

    • 将 iwlist_for_visteon-master.tar.bz2 源码拷贝到 Ubuntu 中创建的 tool 目录下
    • 解压后,进入该文件夹
    tar -vxjf iwlist_for_visteon-master.tar.bz2
    cd iwlist_for_visteon-master
    
    • 修改 Makefile 中的 CC、 AR 和 RANLIB 这三个变量

    在这里插入图片描述

    • 修改完成以后使用如下命令编译
    make clean 	//先清理一下工程
    make 		//编译
    
    • 编译完成后会在当前目录下生成 iwlist、 iwconfig、 iwspy、 iwpriv、 ifrename 这 5 个工
      具,以及 libiw.so.29 库文件。将这 5 个工具拷贝到开发板根文件系统下的 /usr/bin 目录中,将 libiw.so.29 库文件拷贝到开发板根文件系统下的 /usr/lib 目录中,命令如下:
    sudo cp iwlist iwconfig iwspy iwpriv ifrename /home/andyxi/linux/nfs/rootfs/usr/bin/ -f
    sudo cp libiw.so.29 /home/andyxi/linux/nfs/rootfs/usr/lib/ -f
    
    • wireless tools 工具测试

    输入 iwlist 命令,如果输出下图所示信息就表明 iwlist 工作正常

    在这里插入图片描述

    加载 RTL8188 驱动模块 8188eu.ko,驱动加载成功以后在打开 wlan0 网卡

    modprobe 8188eu.ko 	//加载 RTL8188 驱动模块
    ifconfig wlan0 up 	//打开 wlan0 网卡
    

    wlan0 网卡打开后就可以使用 iwlist 命令查找当前环境下的 WIFI 热点信息,即无线路由器

    iwlist wlan0 scan
    

    要想连接到指定的 WIFI 热点上就需要用到 wpa_supplicant 工具,下面介绍如何移植此工具

    三、wpa_supplicant工具

    3.1 openssl 移植

    wpa_supplicant 依赖于 openssl,因此需要先移植 openssl

    在 tool 目录下新建 “openssl” 文件夹,用于存放 openssl 的编译结果

    mkdir /home/andyxi/linux/tool/openssl
    

    将 openssl 源码拷贝到 Ubuntu 中创建的 tool 目录下,然后将其解压

    tar -vxzf openssl-1.1.1d.tar.gz
    

    进入到解压出来的 openssl-1.1.1d 目录中,进行配置、编译和安装

    ./Configure linux-armv4 shared no-asm 
    --prefix=/home/andyxi/linux/tool/openssl
    CROSS_COMPILE=arm-linux-gnueabihf-	//配置成功后,会生成Makefile
    make			//编译
    make install	//安装
    

    安装完成后,openssl 目录下会生成 lib 等5个文件夹,将 lib 目录下的 libcrypto 和 libssl 库拷贝到开发板根文件系统中的 /usr/lib 目录下

    sudo cp libcrypto.so* /home/andyxi/linux/nfs/rootfs/lib/ -af
    sudo cp libssl.so* /home/andyxi/linux/nfs/rootfs/lib/ -af
    
    3.2 libnl 库移植

    wpa_supplicant 也依赖于 libnl,因此还需要移植一下 libnl 库

    编译 libnl 之前先安装 biosn 和 flex,命令如下:

    sudo apt-get install bison
    sudo apt-get install flex
    

    在 tool 目录下新建 “libnl” 文件夹,用于存放 libnl 的编译结果

    mkdir /home/andyxi/linux/tool/libnl
    

    将 libnl 源码拷贝到 Ubuntu 中创建的 tool 目录下,然后将其解压

    tar -vxzf libnl-3.2.23.tar.gz
    

    进入到解压出来的 libnl-3.2.23 目录中,进行配置、编译和安装

    ./configure --host=arm-linux-gnueabihf 
    --prefix=/home/andyxi/linux/tool/libnl/		//配置
    make -j12		//编译
    make install	//安装
    

    安装完成后,libnl 目录下会生成 lib 等5个文件夹,将 lib 目录下的所有文件拷贝到开发板根文件系统中的 /usr/lib 目录下

    sudo cp lib/* /home/andyxi/linux/nfs/rootfs/usr/lib/ -rf
    
    3.3 wpa_supplicant 移植

    将 wpa_supplicant 源码拷贝到 Ubuntu 中创建的 tool 目录下,然后将其解压

    tar -vxzf wpa_supplicant-2.7.tar.gz
    

    进入到解压出来的 wpa_supplicant-2.7 目录中,再进入wpa_supplicant 目录下,然后进行配置: 将 defconfig 文件拷贝一份并重命名为.config

    cd wpa_supplicant/
    cp defconfig .config
    

    打开.config 文件,在里面指定交叉编译器、 openssl、 libnl 库和头文件路径,添加如下内容:

    CC = arm-linux-gnueabihf-gcc
    
    #openssl 库和头文件路径
    CFLAGS += -I/home/andyxi/linux/tool/openssl/include
    LIBS += -L/home/andyxi/linux/tool/openssl/lib -lssl -lcrypto
    
    #libnl 库和头文件路径
    CFLAGS += -I/home/andyxi/linux/tool/libnl/include/libnl3
    LIBS += -L/home/andyxi/linux/tool/libnl/lib
    

    在这里插入图片描述

    .config 文件配置好以后就可以编译 wpa_supplicant 了

    export PKG_CONFIG_PATH=/home/andyxi/linux/tool/libnl/lib/pkgconfig:$PKG_CONFIG_PATH 
    //指定 libnl 库 pkgconfig 包位置
    make -j12 //编译
    

    编译完成以后就会在本目录下生成 wpa_supplicant 和 wpa_cli 这两个软件,将这两个软件拷贝至开发板根文件系统的 /usr/bin 目录中

    sudo cp wpa_cli wpa_supplicant /home/andyxi/linux/nfs/rootfs/usr/bin/ -f
    

    重启开发板,输入“wpa_supplicant -v” 命令查看版本号,正常的话就会打印出版本号

    四、WiFi联网测试

    联网步骤如下:

    – 插上 WiFi 模块,如板子已经集成就忽略该步
    – 加载 RTL8188 驱动模块
    – 使用 ifconfig 命令打开对应的无线网卡,比如 wlan0 或 wlan1……
    – 无线网卡打开以后使用 iwlist 命令扫描一下当前环境下的 WiFi 热点
    – 使用 wpa_supplicant 将 WIFI 连接到指定的热点上,实现联网功能

    • 扫描到 WIFI 热点后就可以连接了,在开发板根文件系统的/etc 目录下创建一个名为“wpa_supplicant.conf”的配置文件,此文件用于配置要连接的 WiFi 热点以及秘密
    ctrl_interface=/var/run/wpa_supplicant
    ap_scan=1
    network={
     ssid="xxxx"		//要连接的WIFI热点名字
     psk="xxxxxxxx"	//要连接的WIFI热点密码
    }
    //注意:wpa_supplicant.conf 文件对于格式要求比较严格
    //“=”前后一定不能有空格,不可以用TAB键来缩进
    //ssid和psk行的缩进要采用空格,而不是TAB建
    
    • 在开发板根文件系统下创建一个 “/var/run/wpa_supplicant” 目录
    mkdir /var/run/wpa_supplicant -p
    
    • 输入以下命令,让 RTL8188 USB WIFI 连接到热点上
    wpa_supplicant -D wext -c /etc/wpa_supplicant.conf -i wlan0 &
    
    • 连接上 WIFI 热点后会输出如下图所示的信息
      在这里插入图片描述
    • 设置 wlan0 的 IP 地址,使用 udhcpc 命令从路由器申请 IP 地址,IP 地址获取成功以后会输出如下图所示的信息
    udhcpc -i wlan0 	//从路由器获取 IP 地址
    

    在这里插入图片描述

    • 可以使用 ifconfig wlan0 命令查看一下 wlan0 网卡的详细信息
    • 最后通过 ping 命令来测试USB WIFI 是否工作正常
    ping -I 192.168.1.126 www.baidu.com
    //-I 是指定执行ping操作的网卡IP地址
    
    展开全文
  • 驱动程序在 Linux 内核里扮演着特殊的角色. 它们是截然不同的"黑盒子", 使硬件的特殊的一部分响 应定义好的内部编程接口. 它们完全隐藏了设备工作的细节. 用户的活动通过一套标准化的调用来进行, 这些调用与特别的...
  • 大家注意了,这个压缩包的名字叫“【Linux典藏大系】Linux驱动开发入门与实战 郑强.z01”,还要下载一个“【Linux典藏大系】Linux驱动开发入门与实战 郑强.zip”压缩文件,我是用“好压”这个软件进行压缩分卷的,我...
  • 前面Linux专题中关于Linux下系统编程总结了17篇博文,主要是为了提高Linux下的C编程应用能力,熟悉Linux编程应用环境,从此篇博文起开始Linux驱动的总结,后面计划加一些综合实践项目练习。 1 什么是Linux驱动? ...
  • Linux驱动有两种运行方式,第一种就是将驱动编译进Linux内核中,这样当Linux内核启动的时候就会自动运行驱动程序。第二种就是将驱动编译成模块(Linux下模块扩展名为.ko),在Linux内核启动以后使用“insmod”命令...
  • Linux驱动开发入门与实战 高清PDF版 因为高清版的文件太大,所以分成两个包上传,请下载Linux驱动开发入门与实战.part1.rar 和 Linux驱动开发入门与实战.part2.rar 后再解压即可
  • WIFI驱动不需要我们编写,因为 realtek 公司提供了 WIFI 驱动源码,因此我们只需要将 WIFI 驱动源码添加到 Linux内核中,然后通过图形化界面配置,选择将其编译成模块即可。 **3、配置==WIFI 驱动添加与编译 ** ...
  • Linux驱动——设备树

    千次阅读 2021-11-26 14:32:52
    在对总线设备驱动进行详细说明时可以看出,虽然总线设备驱动可以实现驱动和设备分离,但是总线设备驱动引发另外的一个问题就是在相同的芯片不同的开发板上,当外设资源不同时需要在不同的设备文件中去定义引脚,这样...
  • Linux 是一个开放、灵活、跨平台的操作系统,上至庞大的数据中心,下至可放于掌心中的嵌入式设备,无处没有 Linux 的身影。更为重要的是, Linux 是一个与 Unix 既一脉相承又与时俱进的系统。可以说,上世纪70年代...
  • 嵌入式Linux驱动难?到底难在哪?

    千次阅读 2020-09-02 13:24:52
    作为嵌入式linux驱动学习的新人,可能心里都有自己的想法,期望有一个自己心中完美的资料来帮助自己入门。 然而,每个人基础不同,悟性不同,对待 问题的态度不同,所以根本难以一个教程满足所有人。 但是总结来说...
  • 一文带你深入了解linux驱动

    千次阅读 2021-04-20 16:37:36
    很多程序员在学习技能时,盲目追求技术实现,而忽略了整个生态环境的观察和基础理论铺垫,导致学完后似是而非,不能举一反三,遇到...那今天我们就先带大家来深入了解下嵌入式开发中至关重要的一环:linux驱动。 在学
  • 具体内容包括Linux驱动开发入门基础知识,Linux操作系统下驱动开发核心技术,并对ARM系统的各类接口的原理、驱动开发与应用层开发进行逐一分析,其中包括GPIO、CAN、I2C、LCD、USB、触摸屏、网络、块设备、红外、SD...
  • Linux设备驱动开发详解-基于最新的Linux4.0内核(第三版),包括很多Linux系统驱动的程序代码,应该大多数直接可以调试成功。
  • 单片机驱动与Linux驱动的区别1. MCU与MPU的区别2. 单片机驱动与Linux驱动的区别 1. MCU与MPU的区别 首先我们先聊一下MCU与MPU之间的区别然后在去关心两者的驱动的不同。MCU(微控制器)就是我们经常所见到的单片机,...
  • 树莓派基于rust编写linux驱动模块

    千次阅读 2022-03-25 20:59:53
    ​ 最近一直在折腾rust编写linux驱动,这个是官方仓库。官方仓库提供了基本入门文档,也可以参考我之前的文章。网上也有一些,但是基本都是基于X86的。我这里提供一份基于嵌入式Linux的rust驱动编译模块模板:...
  • 水星MW150US安装Linux驱动

    千次阅读 2021-05-11 16:44:12
    水星MW150US安装Linux驱动2013-4-29 王健宇 Linux假期前一天,和同事同买的无线网卡到货了,查了一下没有linux驱动,直接崩溃掉;当天晚上查到了这款无线网卡芯片是realtek 8188eu或者8192us,但是不能确定。把无线...
  • 1.Linux驱动的加载方法:在驱动路径下 insmod testdiver.ko 2.卸载方法:任何路径下 rmmmod testdiver 3.怎么判断驱动是否加载: 3.1进入到根目录 : find | grep testdiver ,可查看/dev/testdiver 3.2 进入ls ...
  • Intel(R) HD Graphics在Linux下的驱动,适用于Debian/Ubuntu。
  • linux驱动编程——ch340x驱动移植

    千次阅读 2021-09-14 07:42:51
    Linux驱动编程——ch340x驱动移植 主要概念: ​ ch340x驱动移植 ​ 作为通用器件,厂商都有提供适配各种平台的驱动。linux一般会提供驱动源码。 ​ 一般所谓驱动移植,就是将厂商的驱动源码拿来改一改,编译成...
  • linux驱动最新面试题(面试题整理,含答案)

    万次阅读 多人点赞 2018-09-06 08:09:46
    linux驱动面试题2018(面试题整理,含答案) 版权声明:本文为博主原创文章,未经博主允许不得转载。 转载请标明原址:https://blog.csdn.net/kai_zone/article/details/82021233 前言: 这篇文章主要是对linux...
  • 今天记录一下简单的Linux驱动程序怎么写以及如何加载/卸载驱动以hello.c为例:hello.c#ifndef __KERNEL__# define __KERNEL__#endif#ifndef MODULE# define MODULE#endif#include #include #include MODULE_LICENSE...
  • 使用IDE(vs code)进行嵌入式linux驱动开发

    千次阅读 多人点赞 2020-08-13 19:13:03
    早期的ubuntu版本上没有好的可用的IDE,那个时候嵌入式linux驱动开发人员多使用vim进行编码;对于没有图像界面的linux服务器,开发人员更是只能选择vim这一编辑工具。但是,接触过IDE的人会意识到vim的不方便:需要...
  • Linux驱动简介及分类

    千次阅读 2019-12-16 16:01:35
    1. Linux驱动简介 在介绍Linux驱动之前,我们首先来看Linux系统分层关系: 图1-1Linux系统分层关系 Linux驱动主要具有如下几点作用: 系统调用是应用程序和内核之间的接口,驱动程序是内核和硬件之间的接口; ...
  • 设备驱动->硬件 (2)API:open、read、write、close等 (3)驱动源码中提供真正的open、read、write、close等函数实体 2、file_operations结构体(用来挂接实体函数地址) (1)元素主要是函数指针,用来挂接...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 578,918
精华内容 231,567
关键字:

linux驱动

友情链接: Rtfactorindunion.rar