网站做网站,做网站找顺的,网站开发90天,在线定制头像免费目录异步通知异步通知简介驱动中的信号处理应用程序对异步通知的处理硬件原理图分析实验程序编写修改设备树文件程序编写编写测试APP运行测试编译驱动程序和测试APP运行测试在前面使用阻塞或者非阻塞的方式来读取驱动中按键值都是应用程序主动读取的#xff0c;对于非阻塞方式…
目录异步通知异步通知简介驱动中的信号处理应用程序对异步通知的处理硬件原理图分析实验程序编写修改设备树文件程序编写编写测试APP运行测试编译驱动程序和测试APP运行测试在前面使用阻塞或者非阻塞的方式来读取驱动中按键值都是应用程序主动读取的对于非阻塞方式来说还需要应用程序通过poll 函数不断的轮询。最好的方式就是驱动程序能主动向应用程序发出通知报告自己可以访问然后应用程序在从驱动程序中读取或写入数据类似于我们在裸机例程中讲解的中断。Linux 提供了异步通知这个机制来完成此功能本章我们就来学习一下异步通知以及如何在驱动中添加异步通知相关处理代码。
异步通知
异步通知简介
我们首先来回顾一下“中断”中断是处理器提供的一种异步机制我们配置好中断以后就可以让处理器去处理其他的事情了当中断发生以后会触发我们事先设置好的中断服务函数在中断服务函数中做具体的处理。比如我们在裸机篇里面编写的GPIO 按键中断实验我们通过按键去开关蜂鸣器采用中断以后处理器就不需要时刻的去查看按键有没有被按下因为按键按下以后会自动触发中断。
Linux 应用程序可以通过阻塞或者非阻塞这两种方式来访问驱动设备
通过阻塞方式访问的话应用程序会处于休眠态(挂起)等待驱动设备可以使用非阻塞方式的话会通过poll 函数来不断的轮询查看驱动设备文件是否可以使用。 这两种方式都需要应用程序主动的去查询设备的使用情况如果能提供一种类似中断的机制当驱动程序可以访问的时候主动告诉应用程序那就最好了“信号”为此应运而生。 信号(异步通知)类似于我们硬件上使用的“中断”只不过信号是软件层次上的。算是在软件层次上对中断的一种模拟驱动可以通过主动向应用程序发送信号的方式来报告自己可以访问了应用程序获取到信号以后就可以从驱动设备中读取或者写入数据了。整个过程就相当于应用程序收到了驱动发送过来了的一个中断然后应用程序去响应这个中断在整个处理过程中应用程序并没有去查询驱动设备是否可以访问一切都是由驱动设备自己告诉给应用程序的。
阻塞、非阻塞、异步通知这三种是针对不同的场合提出来的不同的解决方法没有优劣之分在实际的工作和学习中根据自己的实际需求选择合适的处理方法即可。
异步通知的核心就是信号在arch/xtensa/include/uapi/asm/signal.h 文件中定义了Linux 所支持的所有信号这些信号如下所示
34 #define SIGHUP 1 /* 终端挂起或控制进程终止*/
35 #define SIGINT 2 /* 终端中断(CtrlC组合键) */
36 #define SIGQUIT 3 /* 终端退出(Ctrl\组合键) */
37 #define SIGILL 4 /* 非法指令*/
38 #define SIGTRAP 5 /* debug使用有断点指令产生*/
39 #define SIGABRT 6 /* 由abort(3)发出的退出指令*/
40 #define SIGIOT 6 /* IOT指令*/
41 #define SIGBUS 7 /* 总线错误*/
42 #define SIGFPE 8 /* 浮点运算错误*/
43 #define SIGKILL 9 /* 杀死、终止进程*/
44 #define SIGUSR1 10 /* 用户自定义信号1 */
45 #define SIGSEGV 11 /* 段违例(无效的内存段) */
46 #define SIGUSR2 12 /* 用户自定义信号2 */
47 #define SIGPIPE 13 /* 向非读管道写入数据*/
48 #define SIGALRM 14 /* 闹钟*/
49 #define SIGTERM 15 /* 软件终止*/
50 #define SIGSTKFLT 16 /* 栈异常*/
51 #define SIGCHLD 17 /* 子进程结束*/
52 #define SIGCONT 18 /* 进程继续*/
53 #define SIGSTOP 19 /* 停止进程的执行只是暂停*/
在示例代码53.1.1.1 中的这些信号中除了SIGKILL(9)和SIGSTOP(19)这两个信号不能被忽略外其他的信号都可以忽略。这些信号就相当于中断号不同的中断号代表了不同的中断不同的中断所做的处理不同因此驱动程序可以通过向应用程序发送不同的信号来实现不同的功能。
我们使用中断的时候需要设置中断处理函数同样的如果要在应用程序中使用信号那么就必须设置信号所使用的信号处理函数在应用程序中使用signal 函数来设置指定信号的处理函数signal 函数原型如下所示
sighandler_t signal(int signum, sighandler_t handler)函数参数和返回值含义如下 signum要设置处理函数的信号。 handler信号的处理函数。 返回值设置成功的话返回信号的前一个处理函数设置失败的话返回SIG_ERR。 信号处理函数原型如下所示
typedef void (*sighandler_t)(int)我们前面讲解的使用“kill -9 PID”杀死指定进程的方法就是向指定的进程(PID)发送SIGKILL 这个信号。当按下键盘上的CTRLC 组合键以后会向当前正在占用终端的应用程序发出SIGINT 信号SIGINT 信号默认的动作是关闭当前应用程序。这里我们修改一下SIGINT 信号的默认处理函数当按下CTRLC 组合键以后先在终端上打印出“SIGINT signal”这行字符串然后再关闭当前应用程序。新建signaltest.c 文件然后输入如下所示内容
1 #include stdlib.h
2 #include stdio.h
3 #include signal.h
4
5 void sigint_handler(int num)
6 {
7 printf(\r\nSIGINT signal!\r\n);
8 exit(0);
在示例代码53.1.1.2 中我们设置SIGINT 信号的处理函数为sigint_handler当按下CTRLC向signaltest 发送SIGINT 信号以后sigint_handler 函数就会执行此函数先输出一行“SIGINT signal!”字符串然后调用exit 函数关闭signaltest 应用程序。 使用如下命令编译signaltest.c
gcc signaltest.c -o signaltest然后输入“./signaltest”命令打开signaltest 这个应用程序然后按下键盘上的CTRLC 组合键结果如图53.1.1.1 所示
从图53.1.1.1 可以看出当按下CTRLC 组合键以后sigint_handler 这个SIGINT 信号处理函数执行了并且输出了“SIGINT signal”这行字符串。
驱动中的信号处理
1、fasync_struct 结构体
首先我们需要在驱动程序中定义一个fasync_struct 结构体指针变量fasync_struct 结构体内容如下
struct fasync_struct {
spinlock_t fa_lock;
int magic;
int fa_fd;
struct fasync_struct *fa_next;
struct file *fa_file;
struct rcu_head fa_rcu;
};一般将fasync_struct 结构体指针变量定义到设备结构体中比如在上一章节的imx6uirq_dev结构体中添加一个fasync_struct 结构体指针变量结果如下所示
1 struct imx6uirq_dev {
2 struct device *dev;
3 struct class *cls;
4 struct cdev cdev;
......
14 struct fasync_struct *async_queue; /* 异步相关结构体*/
15 };
第14 行就是在imx6uirq_dev 中添加了一个fasync_struct 结构体指针变量。
2、fasync 函数 如果要使用异步通知需要在设备驱动中实现file_operations 操作集中的fasync 函数此函数格式如下所示
int (*fasync) (int fd, struct file *filp, int on)fasync 函数里面一般通过调用fasync_helper 函数来初始化前面定义的fasync_struct 结构体指针fasync_helper 函数原型如下
int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)fasync_helper 函数的前三个参数就是fasync 函数的那三个参数第四个参数就是要初始化的fasync_struct 结构体指针变量。当应用程序通过“fcntl(fd, F_SETFL, flags | FASYNC)”改变fasync 标记的时候驱动程序file_operations 操作集中的fasync 函数就会执行。
驱动程序中的fasync 函数参考示例如下
1 struct xxx_dev {
2 ......
3 struct fasync_struct *async_queue; /* 异步相关结构体*/
4 };
5
6 static int xxx_fasync(int fd, struct file *filp, int on)
7 {
8 struct xxx_dev *dev (xxx_dev)filp-private_data;
9
10 if (fasync_helper(fd, filp, on, dev-async_queue) 0)
11 return -EIO;
12 return 0;
13 }
14
15 static struct file_operations xxx_ops {
16 ......
17 .fasync xxx_fasync,
18 ......
19 };
在关闭驱动文件的时候需要在file_operations 操作集中的release 函数中释放fasync_structfasync_struct 的释放函数同样为fasync_helperrelease 函数参数参考实例如下
1 static int xxx_release(struct inode *inode, struct file *filp)
2 {
3 return xxx_fasync(-1, filp, 0); /* 删除异步通知*/
4 }
5
6 static struct file_operations xxx_ops {
7 ......
8 .release xxx_release,
9 };
第3 行通过调用示例代码53.1.2.3 中的xxx_fasync 函数来完成fasync_struct 的释放工作但是其最终还是通过fasync_helper 函数完成释放工作。
1、kill_fasync 函数 当设备可以访问的时候驱动程序需要向应用程序发出信号相当于产生“中断”。kill_fasync函数负责发送指定的信号kill_fasync 函数原型如下所示
void kill_fasync(struct fasync_struct **fp, int sig, int band)函数参数和返回值含义如下 fp要操作的fasync_struct。 sig要发送的信号。 band可读时设置为POLL_IN可写时设置为POLL_OUT。 返回值无。
应用程序对异步通知的处理
应用程序对异步通知的处理包括以下三步 1、注册信号处理函数 应用程序根据驱动程序所使用的信号来设置信号的处理函数应用程序使用signal 函数来设置信号的处理函数。前面已经详细的讲过了这里就不细讲了。 2、将本应用程序的进程号告诉给内核 使用fcntl(fd, F_SETOWN, getpid())将本应用程序的进程号告诉给内核。 3、开启异步通知 使用如下两行程序开启异步通知
flags fcntl(fd, F_GETFL); /* 获取当前的进程状态*/
fcntl(fd, F_SETFL, flags | FASYNC); /* 开启当前进程异步通知功能*/重点就是通过fcntl 函数设置进程状态为FASYNC经过这一步驱动程序中的fasync 函数就会执行。
硬件原理图分析
本章实验硬件原理图参考15.2 小节即可。
实验程序编写
本实验对应的例程路径为开发板光盘- 2、Linux 驱动例程- 16_asyncnoti。 本章实验我们在上一章实验“15_noblockio”的基础上完成在其中加入异步通知相关内容即可当按键按下以后驱动程序向应用程序发送SIGIO 信号应用程序获取到SIGIO 信号以后读取并且打印出按键值。
修改设备树文件
因为是在实验“15_noblockio”的基础上完成的因此不需要修改设备树。
程序编写
新建名为“16_asyncnoti”的文件夹然后在16_asyncnoti 文件夹里面创建vscode 工程工作区命名为“asyncnoti”。将“15_noblockio”实验中的noblockio.c 复制到16_asyncnoti 文件夹中并重命名为asyncnoti.c。接下来我们就修改asyncnoti.c 这个文件在其中添加异步通知关的代码完成以后的asyncnoti.c 内容如下所示(因为是在上一章实验的noblockio.c 文件的基础 上修改的因为了减少篇幅下面的代码有省略)
#include linux/types.h
#include linux/kernel.h
#include linux/delay.h
#include linux/ide.h
#include linux/init.h
#include linux/module.h
#include linux/errno.h
#include linux/gpio.h
#include linux/cdev.h
#include linux/device.h
#include linux/of.h
#include linux/of_address.h
#include linux/of_gpio.h
#include linux/semaphore.h
#include linux/timer.h
#include linux/of_irq.h
#include linux/irq.h
#include linux/fcntl.h
#include linux/wait.h
#include linux/poll.h
#include asm/mach/map.h
#include asm/uaccess.h
#include asm/io.h
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名 : asyncnoti.c
作者 : 左忠凯
版本 : V1.0
描述 : 非阻塞IO访问
其他 : 无
论坛 : www.openedv.com
日志 : 初版V1.0 2019/8/13 左忠凯创建
***************************************************************/
#define IMX6UIRQ_CNT 1 /* 设备号个数 */
#define IMX6UIRQ_NAME asyncnoti /* 名字 */
#define KEY0VALUE 0X01 /* KEY0按键值 */
#define INVAKEY 0XFF /* 无效的按键值 */
#define KEY_NUM 1 /* 按键数量 *//* 中断IO描述结构体 */
struct irq_keydesc {int gpio; /* gpio */int irqnum; /* 中断号 */unsigned char value; /* 按键对应的键值 */char name[10]; /* 名字 */irqreturn_t (*handler)(int, void *); /* 中断服务函数 */
};/* imx6uirq设备结构体 */
struct imx6uirq_dev{dev_t devid; /* 设备号 */ struct cdev cdev; /* cdev */ struct class *class; /* 类 */struct device *device; /* 设备 */int major; /* 主设备号 */int minor; /* 次设备号 */struct device_node *nd; /* 设备节点 */ atomic_t keyvalue; /* 有效的按键键值 */atomic_t releasekey; /* 标记是否完成一次完成的按键包括按下和释放 */struct timer_list timer;/* 定义一个定时器*/struct irq_keydesc irqkeydesc[KEY_NUM]; /* 按键init述数组 */unsigned char curkeynum; /* 当前init按键号 */wait_queue_head_t r_wait; /* 读等待队列头 */struct fasync_struct *async_queue; /* 异步相关结构体 */
};struct imx6uirq_dev imx6uirq; /* irq设备 *//* description : 中断服务函数开启定时器 * 定时器用于按键消抖。* param - irq : 中断号 * param - dev_id : 设备结构。* return : 中断执行结果*/
static irqreturn_t key0_handler(int irq, void *dev_id)
{struct imx6uirq_dev *dev (struct imx6uirq_dev*)dev_id;dev-curkeynum 0;dev-timer.data (volatile long)dev_id;mod_timer(dev-timer, jiffies msecs_to_jiffies(10)); /* 10ms定时 */return IRQ_RETVAL(IRQ_HANDLED);
}/* description : 定时器服务函数用于按键消抖定时器到了以后* 再次读取按键值如果按键还是处于按下状态就表示按键有效。* param - arg : 设备结构变量* return : 无*/
void timer_function(unsigned long arg)
{unsigned char value;unsigned char num;struct irq_keydesc *keydesc;struct imx6uirq_dev *dev (struct imx6uirq_dev *)arg;num dev-curkeynum;keydesc dev-irqkeydesc[num];value gpio_get_value(keydesc-gpio); /* 读取IO值 */if(value 0){ /* 按下按键 */atomic_set(dev-keyvalue, keydesc-value);}else{ /* 按键松开 */atomic_set(dev-keyvalue, 0x80 | keydesc-value);atomic_set(dev-releasekey, 1); /* 标记松开按键即完成一次完整的按键过程 */} if(atomic_read(dev-releasekey)) { /* 一次完整的按键过程 */if(dev-async_queue)kill_fasync(dev-async_queue, SIGIO, POLL_IN); /* 释放SIGIO信号 */}#if 0/* 唤醒进程 */if(atomic_read(dev-releasekey)) { /* 完成一次按键过程 *//* wake_up(dev-r_wait); */wake_up_interruptible(dev-r_wait);}
#endif
}/** description : 按键IO初始化* param : 无* return : 无*/
static int keyio_init(void)
{unsigned char i 0;char name[10];int ret 0;imx6uirq.nd of_find_node_by_path(/key);if (imx6uirq.nd NULL){printk(key node not find!\r\n);return -EINVAL;} /* 提取GPIO */for (i 0; i KEY_NUM; i) {imx6uirq.irqkeydesc[i].gpio of_get_named_gpio(imx6uirq.nd ,key-gpio, i);if (imx6uirq.irqkeydesc[i].gpio 0) {printk(cant get key%d\r\n, i);}}/* 初始化key所使用的IO并且设置成中断模式 */for (i 0; i KEY_NUM; i) {memset(imx6uirq.irqkeydesc[i].name, 0, sizeof(name)); /* 缓冲区清零 */sprintf(imx6uirq.irqkeydesc[i].name, KEY%d, i); /* 组合名字 */gpio_request(imx6uirq.irqkeydesc[i].gpio, name);gpio_direction_input(imx6uirq.irqkeydesc[i].gpio); imx6uirq.irqkeydesc[i].irqnum irq_of_parse_and_map(imx6uirq.nd, i);
#if 0imx6uirq.irqkeydesc[i].irqnum gpio_to_irq(imx6uirq.irqkeydesc[i].gpio);
#endif}/* 申请中断 */imx6uirq.irqkeydesc[0].handler key0_handler;imx6uirq.irqkeydesc[0].value KEY0VALUE;for (i 0; i KEY_NUM; i) {ret request_irq(imx6uirq.irqkeydesc[i].irqnum, imx6uirq.irqkeydesc[i].handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, imx6uirq.irqkeydesc[i].name, imx6uirq);if(ret 0){printk(irq %d request failed!\r\n, imx6uirq.irqkeydesc[i].irqnum);return -EFAULT;}}/* 创建定时器 */init_timer(imx6uirq.timer);imx6uirq.timer.function timer_function;/* 初始化等待队列头 */init_waitqueue_head(imx6uirq.r_wait);return 0;
}/** description : 打开设备* param - inode : 传递给驱动的inode* param - filp : 设备文件file结构体有个叫做private_data的成员变量* 一般在open的时候将private_data指向设备结构体。* return : 0 成功;其他 失败*/
static int imx6uirq_open(struct inode *inode, struct file *filp)
{filp-private_data imx6uirq; /* 设置私有数据 */return 0;
}/** description : 从设备读取数据 * param - filp : 要打开的设备文件(文件描述符)* param - buf : 返回给用户空间的数据缓冲区* param - cnt : 要读取的数据长度* param - offt : 相对于文件首地址的偏移* return : 读取的字节数如果为负值表示读取失败*/
static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{int ret 0;unsigned char keyvalue 0;unsigned char releasekey 0;struct imx6uirq_dev *dev (struct imx6uirq_dev *)filp-private_data;if (filp-f_flags O_NONBLOCK) { /* 非阻塞访问 */if(atomic_read(dev-releasekey) 0) /* 没有按键按下返回-EAGAIN */return -EAGAIN;} else { /* 阻塞访问 *//* 加入等待队列等待被唤醒,也就是有按键按下 */ret wait_event_interruptible(dev-r_wait, atomic_read(dev-releasekey)); if (ret) {goto wait_error;}}keyvalue atomic_read(dev-keyvalue);releasekey atomic_read(dev-releasekey);if (releasekey) { /* 有按键按下 */ if (keyvalue 0x80) {keyvalue ~0x80;ret copy_to_user(buf, keyvalue, sizeof(keyvalue));} else {goto data_error;}atomic_set(dev-releasekey, 0);/* 按下标志清零 */} else {goto data_error;}return 0;wait_error:return ret;
data_error:return -EINVAL;
}/** description : poll函数用于处理非阻塞访问* param - filp : 要打开的设备文件(文件描述符)* param - wait : 等待列表(poll_table)* return : 设备或者资源状态*/
unsigned int imx6uirq_poll(struct file *filp, struct poll_table_struct *wait)
{unsigned int mask 0;struct imx6uirq_dev *dev (struct imx6uirq_dev *)filp-private_data;poll_wait(filp, dev-r_wait, wait); /* 将等待队列头添加到poll_table中 */if(atomic_read(dev-releasekey)) { /* 按键按下 */mask POLLIN | POLLRDNORM; /* 返回PLLIN */}return mask;
}/** description : fasync函数用于处理异步通知* param - fd : 文件描述符* param - filp : 要打开的设备文件(文件描述符)* param - on : 模式* return : 负数表示函数执行失败*/
static int imx6uirq_fasync(int fd, struct file *filp, int on)
{struct imx6uirq_dev *dev (struct imx6uirq_dev *)filp-private_data;return fasync_helper(fd, filp, on, dev-async_queue);
}/** description : release函数应用程序调用close关闭驱动文件的时候会执行* param - inode : inode节点* param - filp : 要打开的设备文件(文件描述符)* return : 负数表示函数执行失败*/
static int imx6uirq_release(struct inode *inode, struct file *filp)
{return imx6uirq_fasync(-1, filp, 0);
}/* 设备操作函数 */
static struct file_operations imx6uirq_fops {.owner THIS_MODULE,.open imx6uirq_open,.read imx6uirq_read,.poll imx6uirq_poll,.fasync imx6uirq_fasync,.release imx6uirq_release,
};/** description : 驱动入口函数* param : 无* return : 无*/
static int __init imx6uirq_init(void)
{/* 1、构建设备号 */if (imx6uirq.major) {imx6uirq.devid MKDEV(imx6uirq.major, 0);register_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME);} else {alloc_chrdev_region(imx6uirq.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME);imx6uirq.major MAJOR(imx6uirq.devid);imx6uirq.minor MINOR(imx6uirq.devid);}/* 2、注册字符设备 */cdev_init(imx6uirq.cdev, imx6uirq_fops);cdev_add(imx6uirq.cdev, imx6uirq.devid, IMX6UIRQ_CNT);/* 3、创建类 */imx6uirq.class class_create(THIS_MODULE, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.class)) { return PTR_ERR(imx6uirq.class);}/* 4、创建设备 */imx6uirq.device device_create(imx6uirq.class, NULL, imx6uirq.devid, NULL, IMX6UIRQ_NAME);if (IS_ERR(imx6uirq.device)) {return PTR_ERR(imx6uirq.device);}/* 5、始化按键 */atomic_set(imx6uirq.keyvalue, INVAKEY);atomic_set(imx6uirq.releasekey, 0);keyio_init();return 0;
}/** description : 驱动出口函数* param : 无* return : 无*/
static void __exit imx6uirq_exit(void)
{unsigned i 0;/* 删除定时器 */del_timer_sync(imx6uirq.timer); /* 删除定时器 *//* 释放中断 */ for (i 0; i KEY_NUM; i) {free_irq(imx6uirq.irqkeydesc[i].irqnum, imx6uirq);}cdev_del(imx6uirq.cdev);unregister_chrdev_region(imx6uirq.devid, IMX6UIRQ_CNT);device_destroy(imx6uirq.class, imx6uirq.devid);class_destroy(imx6uirq.class);
} module_init(imx6uirq_init);
module_exit(imx6uirq_exit);
MODULE_LICENSE(GPL);
第20 行添加fcntl.h 头文件因为要用到相关的API 函数。 第64 行在设备结构体imx6uirq_dev 中添加fasync_struct 指针变量。 第109~112 行如果是一次完整的按键过程那么就通过kill_fasync 函数发送SIGIO 信号。 第114~120 行屏蔽掉以前的唤醒进程相关程序。 第269~273 行imx6uirq_fasync 函数为file_operations 操作集中的fasync 函数此函数内容很简单就是调用一下fasync_helper。 第281~284 行release 函数应用程序调用close 函数关闭驱动设备文件的时候此函数就会执行在此函数中释放掉fasync_struct 指针变量。 第292~293 行设置file_operations 操作集中的fasync 和release 这两个成员变量。
编写测试APP
测试APP 要实现的内容很简单设置SIGIO 信号的处理函数为sigio_signal_func当驱动程序向应用程序发送SIGIO 信号以后sigio_signal_func 函数就会执行。sigio_signal_func 函数内容很简单就是通过read 函数读取按键值。新建名为asyncnotiApp.c 的文件然后输入如下所示内容
#include stdio.h
#include unistd.h
#include sys/types.h
#include sys/stat.h
#include fcntl.h
#include stdlib.h
#include string.h
#include poll.h
#include sys/select.h
#include sys/time.h
#include linux/ioctl.h
#include signal.h
/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名 : asyncnotiApp.c
作者 : 左忠凯
版本 : V1.0
描述 : 异步通知测试APP
其他 : 无
使用方法 ./asyncnotiApp /dev/asyncnoti 打开测试App
论坛 : www.openedv.com
日志 : 初版V1.0 2019/8/13 左忠凯创建
***************************************************************/static int fd 0; /* 文件描述符 *//** SIGIO信号处理函数* param - signum : 信号值* return : 无*/
static void sigio_signal_func(int signum)
{int err 0;unsigned int keyvalue 0;err read(fd, keyvalue, sizeof(keyvalue));if(err 0) {/* 读取错误 */} else {printf(sigio signal! key value%d\r\n, keyvalue);}
}/** description : main主程序* param - argc : argv数组元素个数* param - argv : 具体参数* return : 0 成功;其他 失败*/
int main(int argc, char *argv[])
{int flags 0;char *filename;if (argc ! 2) {printf(Error Usage!\r\n);return -1;}filename argv[1];fd open(filename, O_RDWR);if (fd 0) {printf(Cant open file %s\r\n, filename);return -1;}/* 设置信号SIGIO的处理函数 */signal(SIGIO, sigio_signal_func);fcntl(fd, F_SETOWN, getpid()); /* 设置当前进程接收SIGIO信号 */flags fcntl(fd, F_GETFL); /* 获取当前的进程状态 */fcntl(fd, F_SETFL, flags | FASYNC); /* 设置进程启用异步通知功能 */ while(1) {sleep(2);}close(fd);return 0;
}
第32~43 行sigio_signal_func 函数SIGIO 信号的处理函数当驱动程序有效按键按下以后就会发送SIGIO 信号此函数就会执行。此函数通过read 函数读取按键值然后通过printf 函数打印在终端上。 第69 行通过signal 函数设置SIGIO 信号的处理函数为sigio_signal_func。 第71~73 行设置当前进程的状态开启异步通知的功能。 第75~77 行while 循环等待信号产生。
运行测试
编译驱动程序和测试APP
1、编译驱动程序 编写Makefile 文件本章实验的Makefile 文件和第四十章实验基本一样只是将obj-m 变量的值改为asyncnoti.oMakefile 内容如下所示
KERNELDIR : /home/zuozhongkai/linux/IMX6ULL/linux/temp/linux-imx-rel_imx_4.1.15_2.1.0_ga_alientek
CURRENT_PATH : $(shell pwd)obj-m : asyncnoti.obuild: kernel_moduleskernel_modules:$(MAKE) -C $(KERNELDIR) M$(CURRENT_PATH) modulesclean:$(MAKE) -C $(KERNELDIR) M$(CURRENT_PATH) clean第4 行设置obj-m 变量的值为asyncnoti.o。 输入如下命令编译出驱动模块文件
make -j32编译成功以后就会生成一个名为“asyncnoti.ko”的驱动模块文件。
2、编译测试APP 输入如下命令编译测试asyncnotiApp.c 这个测试程序
arm-linux-gnueabihf-gcc asyncnotiApp.c -o asyncnotiApp编译成功以后就会生成asyncnotiApp 这个应用程序。
运行测试
将上一小节编译出来asyncnoti.ko 和asyncnotiApp 这两个文件拷贝到 rootfs/lib/modules/4.1.15 目录中重启开发板进入到目录lib/modules/4.1.15 中输入如下命令加载asyncnoti.ko 驱动模块
depmod //第一次加载驱动的时候需要运行此命令
modprobe asyncnoti.ko //加载驱动驱动加载成功以后使用如下命令来测试中断
./asyncnotiApp /dev/asyncnoti按下开发板上的KEY0 键终端就会输出按键值如图53.4.2.1 所示 从图53.4.2.1 可以看出捕获到SIGIO 信号并且按键值获取成功大家可以自行以后台模式运行asyncnotiApp查看一下这个应用程序的CPU 使用率。如果要卸载驱动的话输入如下命令即可
rmmod asyncnoti.ko
