0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看威廉希尔官方网站 视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

i.MX6ULL驱动开发1—字符设备开发模板

码农爱学习 来源:码农爱学习 作者:码农爱学习 2022-03-17 09:13 次阅读

之前的几篇文章(从i.MX6ULL嵌入式Linux开发1-uboot移植初探起),介绍了嵌入式了Linux的系统移植(uboot、内核与根文件系统)以及使用MfgTool工具将系统烧写到板子的EMMC中。

本篇开始介绍嵌入式Linux驱动开发。

1 Linux驱动分类

Linux中的外设驱动可以分为三大类:字符设备驱动、块设备驱动和网络设备驱动。

字符设备驱动:字符设备是能够按照字节流(比如文件)进行读写操作的设备。字符设备最常见,从最简单的点灯到I2C、SPI、音频等都属于字符设备驱动

块设备驱动:以存储块为基础的设备驱动,如EMMC、NAND、SD卡等。对用户而言,字符设备与块设备的访问方式没有差别。

网络设备驱动:即网络驱动,它同时具有字符设备和块设备的特点,因为它是输入输出是有结构块的(报文,包,帧),但它的块的大小又不是固定的。

poYBAGIx_3KAJV1gAAB19ZrvOjc355.png

2 Linux驱动基本原理

Linux中一切皆文件,驱动加载成功以后会在“/dev”目录下生成一个相应的文件,应用程序通过对这个名为“/dev/xxx”的文件进行相应的操作即可实现对硬件的操作。

比如最简单的点灯功能,会有/dev/led这样的驱动文件,应用程序使用open函数来打开文件/dev/led,如果要点亮或关闭led,那么就使用write函数写入开关值,如果要获取led的状态,就用read函数从驱动中读取相应的状态,使用完成以后使用close函数关闭/dev/led这个文件。

2.1 Linux软件分层结构

Linux软件从上到下可以分层4层结构,以控制LED为例:

应用层:应用程序使用库提供的open函数打开LED设备

:库根据open函数传入的参数执行“swi”指令,进而引起CPU异常,进入内核

内核:内核的异常处理函数根据传入的参数找到对应的驱动程序,返回文件句柄给库,进而返回给应用层

应用层得到文件句柄后,使用库提供的write或ioctl发出控制指令

库根据write或ioctl函数传入的参数执行“swi”指令,进入内核

内核的异常处理函数根据传入的参数找到对应的驱动程序

驱动:驱动程序控制硬件,点亮LED

应用程序运行在用户空间,而Linux驱动属于内核的一部分,因此驱动运行于内核空间。当应用层通过open函数打开/dev/led 这个驱动时,因用户空间不能直接操作内核,因此会使用“系统调用”的方法来从用户空间“陷入”到内核空间,实现对底层驱动的操作。

pYYBAGIx_3yAY25pAAA6Q-W_Aa8447.png

比如应用程序调用了open这个函数,则在驱动程序中也应有一个对应的open的函数。

2.2 Linux内核驱动操作函数

每一个系统调用,在驱动中都有与之对应的一个驱动函数,在Linux内核文件include/linux/fs.h中有个file_operations结构体,就是Linux内核驱动操作函数集合:

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 (*iterate) (struct file *, struct dir_context *);
	unsigned int (*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 *);
	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 (*fsync) (struct file *, loff_t, loff_t, int datasync);
	int (*aio_fsync) (struct kiocb *, int datasync);
	int (*fasync) (int, struct file *, int);
	/*省略若干行...*/
};

其中有关字符设备驱动开发中常用的函数有:

owner:拥有该结构体的模块的指针,一般设置为THIS_MODULE。

llseek函数:用于修改文件当前的读写位置。

read函数:用于读取设备文件。

write函数:用于向设备文件写入(发送)数据。

poll函数:是个轮询函数,用于查询设备是否可以进行非阻塞的读写。

unlocked_ioctl函数:提供对于设备的控制功能, 与应用程序中的 ioctl 函数对应。

compat_ioctl函数:与 unlocked_ioctl功能一样,区别在于在 64 位系统上,32 位的应用程序调用将会使用此函数。在 32 位的系统上运行 32 位的应用程序调用的是unlocked_ioctl。

mmap函数:用于将将设备的内存映射到进程空间中(也就是用户空间),一般帧缓冲设备会使用此函数, 比如 LCD 驱动的显存,将帧缓冲(LCD 显存)映射到用户空间中以后应用程序就可以直接操作显存了,这样就不用在用户空间和内核空间之间来回复制。

open函数:用于打开设备文件。

release函数:用于释放(关闭)设备文件,与应用程序中的 close 函数对应。

fasync函数:用于刷新待处理的数据,用于将缓冲区中的数据刷新到磁盘中。

aio_fsync函数:与fasync功能类似,只是 aio_fsync 是异步刷新待处理的

2.3 Linux驱动运行方式

Linux 驱动有两种运行方式:

将驱动编译进Linux内核中, 这样当Linux内核启动的时候就会自动运行驱动程序。

将驱动编译成模块(扩展名为 .ko), 在Linux内核启动以后使用“insmod”命令加载驱动模块。

在驱动开发阶段一般都将其编译为模块,不需要编译整个Linux代码,方便调试驱动程序。当驱动开发完成后,根据实际需要,可以选择是否将驱动编译进Linux内核中。

2.4 Linux设备号

2.4.1 设备号的组成

Linux中每个设备都有一个设备号,设备号由主设备号和次设备号两部分组成。

主设备号:表示某一个具体的驱动

次设备号:表示使用这个驱动的各个设备

Linux 提供了名为dev_t的数据类型表示设备号,其本质是32位的unsigned int数据类型,其中高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))

MINORBITS:表示次设备号位数,一共20位

MINORMASK:表示次设备号掩码

MAJOR:用于从dev_t中获取主设备号,将dev_t右移20位即可

MINOR:用于从dev_t中获取次设备号,取dev_t的低20位的值即可

MKDEV:用于将给定的主设备号和次设备号的值组合成dev_t类型的设备号

2.4.2 主设备号的分配

主设备号的分配包括静态分配和动态分配

静态分配需要手动指定设备号,并且要注意不能与已有的重复,一些常用的设备号已经被Linux内核开发者给分配掉了,使用“cat /proc/devices”命令可查看当前系统中所有已经使用了的设备号。

动态分配是在注册字符设备之前先申请一个设备号,系统会自动分配一个没有被使用的设备号, 这样就避免了冲突。在卸载驱动的时候释放掉这个设备号即可。

设备号的申请函数:

/*
* dev:保存申请到的设备号
* baseminor:次设备号起始地址,一般baseminor为0 (次设备号以baseminor为起始地址地址开始递)
* count:要申请的设备号数量
* name:设备名字
*/
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name) 

设备号的释放函数:

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

3 字符设备驱动开发模板

3.1 加载与卸载

在编写驱动的时候需要注册模块加载和卸载这两种函数:

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); 

驱动编译完成以后扩展名为.ko, 有两种命令可以加载驱动模块:

insmod:最简单的模块加载命令,用于加载指定的.ko模块,此命令不能解决模块的依赖关系

modprobe:该命令会分析模块的依赖关系,将所有的依赖模块都加载到内核中,因此更智能

modprobe 命令默认会去/lib/modules/目录中查找模块(自制的根文件系统没有这个目录,需要手动创建)

卸载驱动也有两种命令:

rmmod:例如使用rmmod drv.ko来卸载 drv.ko这一个模块

modprobe -r:该命令除了卸载指定的驱动,还卸载其所依赖的其他模块,若这些依赖模块还在被其它模块使用,就不能使用 modprobe来卸载驱动模块!!!

3.2 注册与注销

对于字符设备驱动而言,当驱动模块加载成功以后需要注册字符设备,同样,卸载驱动模块的时候也需要注销掉字符设备

字符设备的注册函数原型如下所示:

/* func: register_chrdev 注册字符设备
* major:主设备号
* name:设备名字,指向一串字符串
* fops:结构体 file_operations 类型指针,指向设备的操作函数集合变量
*/
static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops) 

字符设备的注销函数原型如下所示:

/* func: unregister_chrdev 注销字符设备
* majo:要注销的设备对应的主设备号 
* name:要注销的设备对应的设备名
*/
static inline void unregister_chrdev(unsigned int major, const char *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); 

注:选择没有被使用的主设备号,可输入命令“cat /proc/devices”来查看当前已经被使用掉的设备号

3.3 实现设备的具体操作函数

file_operations 结构体就是设备的具体操作函数。

假设对chrtest这个设备有如下两个要求:

能够实现打开和关闭操作:需要实现 file_operations 中的openrelease这两个函数

能够实现进行读写操作:需要实现 file_operations 中的readwrite这两个函数

首先是 打开(open)、读取(read)、写入(write)、释放(release) 4个基本操作

/*打开设备*/ 
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; 
} 

然后是 驱动的入口(init)和出口(exit) 函数:

/*文件操作结构体*/
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); 

3.4 添加LICENSE和作者信息

LICENSE是必须添加的,否则编译时会报错,作者信息可加可不加。

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

总结一下:

poYBAGIx_5GAAfbZAAEAxs0IOYU711.png

4 字符设备驱动开发实验

下面以正点原子提供的教程中的chrdevbase这个虚拟设备为例,完整的编写一个字符设备驱动模块。chrdevbase不是实际存在的一个设备,只是为了学习字符设备的开发的流程。

4.1 程序编写

需要分别编写驱动程序应用程序

注:为了区分两个程序的打印信息,在驱动程序的打印前都添加“[BSP]”标识,在应用程序的打印前都添加”[APP]“标识

4.1.1 编写驱动程序

一些定义

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

static char readbuf[100];		/*读缓冲区*/
static char writebuf[100];		/*写缓冲区*/
static char kerneldata[] = {"kernel data!"}; /*内核驱动中的数据,用来测试应用程序读取该数据*/

打开、关闭、读取、写入

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件,file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int chrdevbase_open(struct inode *inode, struct file *filp)
{
	printk("[BSP] chrdevbase open!\n");
	return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数,如果为负值,表示读取失败
 */
static ssize_t chrdevbase_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue = 0;
	
	/* 向用户空间发送数据 */
	memcpy(readbuf, kerneldata, sizeof(kerneldata));
    
	retvalue = copy_to_user(buf, readbuf, cnt);
	if(retvalue == 0)
    {
		printk("[BSP] kernel senddata ok!\n");
	}
    else
    {
		printk("[BSP] kernel senddata failed!\n");
	}
	
	printk("[BSP] chrdevbase read!\n");
	return 0;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件,表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数,如果为负值,表示写入失败
 */
static ssize_t chrdevbase_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
	int retvalue = 0;
    
	/* 接收用户空间传递给内核的数据并且打印出来 */
	retvalue = copy_from_user(writebuf, buf, cnt);
	if(retvalue == 0)
    {
		printk("[BSP] kernel recevdata:%s\n", writebuf);
	}
    else
    {
		printk("[BSP] kernel recevdata failed!\n");
	}
	
	printk("[BSP] chrdevbase write!\n");
	return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int chrdevbase_release(struct inode *inode, struct file *filp)
{
	printk("[BSP] chrdevbase release!\n");
	return 0;
}

驱动加载与注销

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

/*
 * @description	: 驱动入口函数 
 * @param 		: 无
 * @return 		: 0 成功;其他 失败
 */
static int __init chrdevbase_init(void)
{
	int retvalue = 0;

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

/*
 * @description	: 驱动出口函数
 * @param 		: 无
 * @return 		: 无
 */
static void __exit chrdevbase_exit(void)
{
	/* 注销字符设备驱动 */
	unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME);
	printk("[BSP] chrdevbase exit!\n");
}

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

最后的LIENSE与作者

/*LICENSE和作者信息*/
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zuozhongkai & xxpcb"); //本篇的程序代码在“正点原子”左大神提供的代码上进行修改

4.1.2 编写应用程序

这里把程序截取为3段分析,首先看开头

#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!"}; /*应用程序中的数据,用于测试通过驱动访问写入内核*/

int main(int argc, char *argv[])
{
	int fd, retvalue;
	char *filename;
	char readbuf[100], writebuf[100];

	if(argc != 3)
    {
		printf("[APP] Error Usage!\n");
		return -1;
	}

    //参数1是驱动的文件名,用来指定驱动的位置
	filename = argv[1];

	//【1】打开驱动文件
	fd  = open(filename, O_RDWR);
	if(fd < 0)
    {
		printf("[APP] Can't open file %s\n", filename);
		return -1;
	}
    printf("[APP] open file: '%s' success\n", filename);

主要是一些头文件和main函数入口,调用main函数时需要传入2个参数(实际是3个参数,函数名本身是默认的第0个参数,不需要手动指定),具体作用为:

参数0:argv[0],函数名本身,这里不作用途

参数1:argv[1],filename,这里不作用途

参数2:argv[2],自定义的操作参数,下面函数会讲到,1为从驱动文件中读取,2为向驱动文件中写入数据

再来看具体操作:

    //【2】从驱动文件读取数据
	if(atoi(argv[2]) == 1)//参数1表示【读取】内核中的数据
    { 
		retvalue = read(fd, readbuf, 50);
		if(retvalue < 0)
        {
			printf("[APP] read file '%s' failed!\n", filename);
		}
        else
        {
			/* 读取成功,打印出读取成功的数据 */
			printf("[APP] read data:%s\n",readbuf);
		}
	}
    //【3】向设备驱动写数据
	if(atoi(argv[2]) == 2)//参数2表示向内核中【写入】数据
    {
		memcpy(writebuf, usrdata, sizeof(usrdata));
		retvalue = write(fd, writebuf, 50);
		if(retvalue < 0)
        {
			printf("[APP] write file %s failed!\n", filename);
		}
        else
        {
            printf("[APP] write data:'%s' to file ok\n", writebuf);
        }
	}

最后是关闭设备

	//【4】关闭设备
	retvalue = close(fd);
	if(retvalue < 0)
    {
		printf("[APP] Can't close file %s\n", filename);
		return -1;
	}
	printf("[APP] close file ok\r\n");

	return 0;
}

关闭即表示不再使用该设备了(若要再使用则重新打开即可),通过关闭驱动文件来实现字符设备驱动的关闭。

4.2 程序编译

4.2.1 编译驱动程序

编译驱动,即编译chrdevbase.c这个文件为.ko 模块,使用Makefile来编译,先创建Makefile:

KERNELDIR := /home/xxpcb/myTest/imx6ull/kernel/nxp_kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga
CURRENT_PATH := $(shell pwd)
obj-m := chrdevbase.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

各行含义:

KERNELDIR:开发板所使用的Linux内核源码目录

CURRENT_PATH:当前路径,通过运行“pwd”命令获取

obj-m:将 chrdevbase.c 这个文件编译为chrdevbase.ko模块

具体的编译命令:后面的modules表示编译模块,-C 表示切换工作目录到KERNERLDIR目录,M表示模块源码目录

输入“make”命令即可编译,编译后会出现许多编译文件

pYYBAGIx_6SALhsxAAFV2abmvkw000.png

注:若直接make编译报如下错误,是因为kernel中没有指定编译器和架构,使用了默认的x86平台编译报错。

pYYBAGIx_6uAB8ssAAFRkPfoi04933.png

修改Kernel工程的顶层Makefile,直接定义ARCH和CROSS_COMPILE 这两个的变量值为 arm 和 arm-linux-gnueabihf-

(内核篇的介绍见:i.MX6ULL嵌入式Linux开发3-Kernel移植)

poYBAGIx_7OAFZGEAAHM8Vq9p9g685.png

4.2.2 编译应用程序

编译应用程序不需要内核文件参与,只有一个文件就能编译,因此直接输入指令进行编译:

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

编译会生chrdevbaseApp,它是32位LSB格式的ARM版本可执行文件

pYYBAGIx_7qAYyOQAADRLEqdxKc780.png

4.3 测试

上一篇文章(i.MX6ULL嵌入式Linux开发6-系统烧写到eMM)已经实现了系统移植的打包烧录工作,系统已经烧录的EMMC中了。这次我们就直接在这个基础上进行实验。

4.3.1 创建驱动模块目录

加载驱动模块,使用的modprobe命令,会从特定的目录下寻找文件。比如开发板使用的是4.1.15版的Linux内核 ,则是“/lib/modules/4.1.15”这个目录,这个目录一般是没有的,需要根据Linux内核的版本自己创建。

注意这是开发板的文件系统中的路径,可以通过串口连接进入开发板,通过linux指令创建该目录。

4.3.2 发送文件到开发板(TFTP传输)

此次测试首先需要将ubuntu中编译的文件传输到板子中运行,怎么传输呢?可以使用TFTP传输服务。

poYBAGIx__mAJAMxAAFqlflsgR8688.png

之前的文章(i.MX6ULL嵌入式Linux开发2-uboot移植实践)中已经介绍了如何在ubuntu中搭建TFTP服务器

搭建好TFTP服务后,开始传输文件到开发板具体的传输步骤为:

开发板连接网线,与ubuntu虚拟机处于同一局域网内

确保ubuntu已安装的TFTP服务,并设置了TFTP服务文件夹

将ubuntu中编译好的文件复制到ubuntu的TFTP服务文件夹中!!!

mv chrdevbaseApp ~/myTest/tftpboot/
mv chrdevbase.ko ~/myTest/tftpboot/

注:编译完程序,在传输到板子之前,一定要记得把文件先复制到TFTP文件夹中,否则板子获取到的可能是TFTP文件夹中的旧文件。

开发板的串口中通过如下指令来将ubuntu中的文件传输到开发板中

cd /lib/modules/4.1.15   /*确保在要下载文件的目录中,若已在,则忽略*/
tftp -g -r chrdevbaseApp 192.168.5.101 /*获取chrdevbaseApp文件*/
tftp -g -r chrdevbase.ko 192.168.5.101 /*获取chrdevbase.ko文件*/

这里的-g代表get,即下载文件,-r代表remote file,即远程主机的文件名,然后是要下载的文件名,最后的远程主机ubuntu的IP地址

输入该指令后,可以看到文件传输进度,如下图:

poYBAGIyAAGAOFfdAAAnPNVU2dE378.png

4.3.3 开始测试

驱动文件chrdevbase.ko和应用文件chrdevbaseApp传输到板子中的/lib/modules/4.1.15目录后,就可以测试了。

首先使用insmod命令来加载驱动,然后使用lsmod查看当前的驱动(只有一个我们刚加载的字符驱动),再使用使用cat指令查看devices 信息,确认系统中是否已经列举了该设备,3条指令如下:

insmod chrdevbase.ko 
lsmod
cat /proc/devices 

具体是输出信息:

pYYBAGIyAAmAFyp0AAB4iFrzgsc420.png

可以看出,系统中存在chrdevbase设备,主设备号为程序中设定的200。

驱动加载后,还要在/dev目录下创建一个对应的设备节点文件(应用程序就是通过该节点文件实现对设备的操作)。

输入如下2条命令创建/dev/chrdevbase这个设备节点文件,并查看结果:

mknod /dev/chrdevbase c 200 0 
ls /dev/chrdevbase -l
pYYBAGIyAA-AX6J5AAAy_IcL8LE995.png

至此,字符设备驱动已经加载完成,可以测试我们的应用程序了,也就是

按照上面程序的设定,1是读,2是写:

./chrdevbaseApp /dev/chrdevbase 1  
./chrdevbaseApp /dev/chrdevbase 2

先来看“读测试”,注意要给chrdevbaseApp可执行的权限,否则无法运行。

poYBAGIyABWAU-ruAADTDlIHaAc973.png

图中下部是程序输出信息,但似乎只有BSP驱动程序的的输出,没有APP应用程序的输出,应该是内核打印printk与应用的打印printf冲突了,导致APP的打印被挤掉了。

再来看“写测试'',同样也是只有BSP的打印

pYYBAGIyABuAGx8pAAAVuxovM8w140.png

4.3.4 打印冲突问题规避

对于打印冲突问题,我们可以先在每个printf前后加个sleep(1)的1秒延时,这样可以先避免打印冲突。

增加延时后再次测试,打印正常:

poYBAGIyACKACZljAAB8A9RNG8I614.png

测试完,最后是rmmod命令卸载模块:

pYYBAGIyACaAAjSlAAAKmjegX_U693.png

5 总结

本篇介绍了嵌入式Linux驱动开发中的基础驱动——字符驱动开发的基本模式,使用了一个虚拟的字符设备驱动进行测试,了解驱动程序与应用程序之间的调用关系。
审核编辑:汤梓红

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 设备
    +关注

    关注

    2

    文章

    4503

    浏览量

    70611
  • 模板
    +关注

    关注

    0

    文章

    108

    浏览量

    20561
收藏 人收藏

    评论

    相关推荐

    i.MX6ULL 驱动开发7—按键输入捕获与GPIO输入配置与高低电平读取

    本篇主要介绍了i.MX6ULL的按键检测的使用,主要的知识点是设备树的修改,以及GPIO的输入配置与高低电平的读取。
    的头像 发表于 05-24 09:11 6222次阅读
    <b class='flag-5'>i.MX6ULL</b> <b class='flag-5'>驱动</b><b class='flag-5'>开发</b>7—按键输入捕获与GPIO输入配置与高低电平读取

    i.MX6ULL嵌入式Linux开发1-uboot移植初探

    本系列教程以i.MX6ULL处理器的ARM开发板为实验基础,学习记录嵌入式Linux开发的各种知识与经验,主要内容包括嵌入式Linux移植,嵌入式Linux驱动
    的头像 发表于 03-07 08:57 3880次阅读
    <b class='flag-5'>i.MX6ULL</b>嵌入式Linux<b class='flag-5'>开发</b><b class='flag-5'>1</b>-uboot移植初探

    i.MX6ULL驱动开发2—新字符设备开发模板

    上篇文章介绍了字符设备开发模板,但那是一种旧版本的驱动开发模式,
    的头像 发表于 03-17 09:11 3174次阅读
    <b class='flag-5'>i.MX6ULL</b><b class='flag-5'>驱动</b><b class='flag-5'>开发</b>2—新<b class='flag-5'>字符</b><b class='flag-5'>设备</b><b class='flag-5'>开发</b><b class='flag-5'>模板</b>

    使用i.MX6ULL开发板进行Linux根文件系统的完善

    上一篇推文讲了怎么移植根文件系统,并在i.MX6ULL开发板中运行起来,但是会出现一些提示,现在来进行根文件的完善。
    发表于 10-17 11:13 791次阅读

    移植NXP官方linux 5.4内核到i.MX6ULL开发

    本文描述移植NXP官方 linux 5.4 内核到i.MX6ULL开发板。
    发表于 12-19 11:10 2034次阅读

    I.MX6ULL终结者开发板裸机仿真jlink调试

    I.MX6ULL‘终结者’开发板预留了JTAG仿真接口,并给出了开发文档,可以实现在JLINK仿真器条件下的单步跟踪、断点调试等功能,使得开发研究i
    发表于 07-07 10:56

    i.MX6ULL开发板硬件资源

    迅为i.MX6ULL 终结者开发板硬件资源非常丰富,几乎将 i.MX6ULL 芯片的所有资源都扩展引出到底板上了,底板提供了丰富的外设接口,开发板的尺寸是 190mm*125mm,充分
    发表于 12-29 06:18

    初识 i.MX6ULL 寄存器

    裸机开发_L1_汇编LED实验0. 本节目标1. 硬件层电路2. 初识 i.MX6ULL 寄存器2.1 i.MX6ULL 时钟控制寄存器2.
    发表于 12-20 07:13

    飞凌i.MX6ULL开发板的评测,再次进阶拥有更高的性价比

    处理器MCIMX6Y2开发设计,采用先进的ARMCortex-A7内核,运行速度高达800MHz。i.MX6ULL应用处理器包括一个集成的电源管理模块,降低了外接电源的复杂性,并简化了上电时序。
    发表于 10-27 11:55 1485次阅读
    飞凌<b class='flag-5'>i.MX6ULL</b><b class='flag-5'>开发</b>板的评测,再次进阶拥有更高的性价比

    基于NXP i.MX6ULL处理器的FETMX6ULL-C核心板

    合作伙伴,飞凌不负美誉,基于i.MX6ULL匠心打造的FETMX6ULL-S核心板一经问世便好评不断,且已有数百家来自工业、医疗、电力、物联网等行业的用户采用此款核心板快速完成了整机产品的开发上市。
    发表于 04-11 15:05 1155次阅读
    基于NXP <b class='flag-5'>i.MX6ULL</b>处理器的FETMX<b class='flag-5'>6ULL</b>-C核心板

    i.MX6ULL驱动开发4——点亮LED(寄存器版)

    本篇主要介绍了如何通过操作寄存器来点亮i.MX6ULL开发板上的led,通过编写LED对应的驱动程序和应用程序,实现程序设计的分层。
    的头像 发表于 05-21 21:26 2976次阅读
    【<b class='flag-5'>i.MX6ULL</b>】<b class='flag-5'>驱动</b><b class='flag-5'>开发</b>4——点亮LED(寄存器版)

    i.MX6ULL|字符设备驱动开发实践

    字符设备驱动开发的基本步骤可以看上一篇,本节就以 chrdevbase 这个虚拟设备为例,完整的编写一个
    的头像 发表于 10-31 11:27 665次阅读

    【北京迅为】i.MX6ULL开发板移植 Debian 文件系统

    【北京迅为】i.MX6ULL开发板移植 Debian 文件系统
    的头像 发表于 02-10 15:34 1143次阅读
    【北京迅为】<b class='flag-5'>i.MX6ULL</b><b class='flag-5'>开发</b>板移植 Debian 文件系统

    基于i.MX6ULL的掉电检测设计与软件测试

    基于i.MX6ULL的掉电检测设计与软件测试基于i.MX6ULL平台设计实现掉电检测功能,首先选择一路IO,利用IO电平变化触发中断,在编写驱动时捕获该路GPIO的中断,然后在中断响应函数中发
    的头像 发表于 11-09 10:40 841次阅读
    基于<b class='flag-5'>i.MX6ULL</b>的掉电检测设计与软件测试

    【迅为电子】i.MX6UL和i.MX6ULL芯片区别与开发板对比

    【迅为电子】i.MX6UL和i.MX6ULL芯片区别与开发板对比
    的头像 发表于 11-28 14:31 336次阅读
    【迅为电子】<b class='flag-5'>i.MX6</b>UL和<b class='flag-5'>i.MX6ULL</b>芯片区别与<b class='flag-5'>开发</b>板对比