9.Linux驱动-异步通知基础与实验_深海带鲤鱼的博客

1.前言

开发板：正点原子阿尔法
在Linux驱动中如何主动向应用程序发出通知呢，然后应用程序从驱动中读取数据，类似于中断，Linux中提供异步通知来完成这一功能。

2.异步通知

• 阻塞访问驱动程序：应用程序会处于休眠态，等待驱动设备可以使用

• 非阻塞访问驱动程序：通过 poll 函数来不断的轮询，查看驱动设备文件是否可以使用

• 异步通知：驱动设备告诉应用程序自己可以访问

阻塞、非阻塞、异步通知，这三种是针对不同的场合提出来的不同的解决方法，没有优劣之分，在实际的工作和学习中，根据自己的实际需求选择合适的处理方法即可。

2.信号

异步通知的核心在于信号，在在 arch/xtensa/include/uapi/asm/signal.h 文件中定义了 Linux 所支持的所有信号，这些信号如下所示

#define SIGHUP 	1 /* 终端挂起或控制进程终止 */
#define SIGINT 	2 /* 终端中断(Ctrl+C 组合键) */
#define SIGQUIT 3 /* 终端退出(Ctrl+\组合键) */
#define SIGILL  4 /* 非法指令 */
#define SIGTRAP 5 /* debug 使用，有断点指令产生 */
#define SIGABRT 6 /* 由 abort(3)发出的退出指令 */
#define SIGIOT  6 /* IOT 指令 */
#define SIGBUS  7 /* 总线错误 */
#define SIGFPE  8 /* 浮点运算错误 */
#define SIGKILL 9 /* 杀死、终止进程 */
#define SIGUSR1 10 /* 用户自定义信号 1 */
#define SIGSEGV 11 /* 段违例(无效的内存段) */
#define SIGUSR2 12 /* 用户自定义信号 2 */
#define SIGPIPE 13 /* 向非读管道写入数据 */
#define SIGALRM 14 /* 闹钟 */
#define SIGTERM 15 /* 软件终止 */
#define SIGSTKFLT 16 /* 栈异常 */
#define SIGCHLD 17 /* 子进程结束 */
#define SIGCONT 18 /* 进程继续 */
#define SIGSTOP 19 /* 停止进程的执行，只是暂停 */
#define SIGTSTP 20 /* 停止进程的运行(Ctrl+Z 组合键) */
#define SIGTTIN 21 /* 后台进程需要从终端读取数据 */
#define SIGTTOU 22 /* 后台进程需要向终端写数据 */
#define SIGURG  23 /* 有"紧急"数据 */
#define SIGXCPU 24 /* 超过 CPU 资源限制 */
#define SIGXFSZ 25 /* 文件大小超额 */
#define SIGVTALRM 26 /* 虚拟时钟信号 */
#define SIGPROF   27 /* 时钟信号描述 */
#define SIGWINCH  28 /* 窗口大小改变 */
#define SIGIO     29 /* 可以进行输入/输出操作 */
#define SIGPOLL SIGIO
/* #define SIGLOS 29 */
#define SIGPWR    30 /* 断点重启 */
#define SIGSYS    31 /* 非法的系统调用 */
#define SIGUNUSED 31 /* 未使用信号 */

在上面的信号中除了SIGKILL(9)和 SIGSTOP(19)这两个信号不能被忽略外，其他的信号都可以忽略 ，这些信号相当于中断号，在使用中断的时候，需要注册中断处理函数，同样的在使用信号的时候需要注册信号处理函数，在应用程序中使用 signal 函数来设置指定信号的处理函数， signal 函数原型如下所示：

sighandler_t signal(int signum, sighandler_t handler)

• signum：要设置处理函数的信号

• handler： 信号的处理函数。
  返回值： 设置成功的话返回信号的前一个处理函数，设置失败的话返回 SIG_ERR。

• 信号处理函数原型如下所示：

typedef void (*sighandler_t)(int)  

4.驱动中的信号处理

4.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;
};

4.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)

• fd:对应fasync的第一个参数

• on:对应fasync的第三个参数

• fapp：要初始化的fasync_struct

5.实验程序编写

5.1 驱动程序

1.修改设备树,在根结点下添加

btn-gpio {
		#address-cells = <1>;
		#size-cells = <1>;
		compatible = "imx-btn";
		pinctrl-names = "default";
		pinctrl-0 = <&pinctrl_key>;
		key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>; /* KEY0 */
		interrupt-parent = <&gpio1>;
		interrupts = <18 IRQ_TYPE_EDGE_BOTH>; /* FALLING RISING */
		status = "okay";
	};

2.在pinctrl结点下添加

pinctrl_key: keygrp {
			fsl,pins = <
				MX6UL_PAD_UART1_CTS_B__GPIO1_IO18		0xF080	/* KEY0 */
			>;
		};		

执行make dtbs之后拷贝到tftboot下

驱动代码：

btn.c

#include "btn.h"

static void btn_detect_handler(void)
{
	if (data->async_queue) 
	{
		/* Send signal to app program read the data */
		kill_fasync(&data->async_queue, SIGIO, POLL_IN);
		printk(KERN_DEBUG "%s kill SIGIO\n", __func__);
	} 
	else
	{	
		printk(KERN_ERR "%s kill SIGIO error\n", __func__);
	}
	
	printk(KERN_DEBUG "%s btn_status:%d (0:disable,1:enable)\n",__func__,gpio_get_value(data->gpio_num));
	enable_irq(data->irq);
}

static irqreturn_t btn_interrupt(int irq, void *handle)
{
	//disable_irq_nosync(data->irq);
	//btn_detect_handler();
	//硬件消抖
	mod_timer(&data->timer, jiffies +msecs_to_jiffies(10));	
	return IRQ_HANDLED;
}

static void btn_timer_func(unsigned long handle)
{
	disable_irq_nosync(data->irq);
	btn_detect_handler();
}
//cat
static ssize_t btn_status_show(struct device *dev,struct device_attribute *attr, char *buf)
{
	int ret;
    ret = gpio_get_value(data->gpio_num);
	printk("%s:ret=%d\n",__func__,ret);
	
    return sprintf(buf, "%d\n", ret);		
}

//声明btn_status文件节点
static DEVICE_ATTR(btn_status, S_IRUSR, btn_status_show,NULL);

static struct attribute *atk_imx6ul_btn_sysfs_attrs[] = {
	&dev_attr_btn_status.attr,
	NULL,
};


static const struct attribute_group dev_attr_grp = {
      .attrs = atk_imx6ul_btn_sysfs_attrs,
	  NULL,
};

static int imx6ul_btn_open(struct inode *inode, struct file *file)
{
	file->private_data = data;
	return 0;
}


static ssize_t imx6ul_btn_read(struct file *file, char __user *buf, size_t cnt, loff_t * loff)
{
	int ret;
	int val;
	char *readbuf = kzalloc(sizeof(char), GFP_KERNEL);
	
    val = gpio_get_value(data->gpio_num);
	
	//将val格式化为字符串
	sprintf(readbuf,"%d\n",val);
	
	ret = copy_to_user(buf,readbuf,1);
	if(ret == 0)
    {
        printk("senddata ok!\n");
    }else
    {
        printk("senddata failed\n");
    }
	
	return 0;
}

static ssize_t imx6ul_btn_write(struct file *file, const char __user *buf, size_t cnt, loff_t *loff)
{

	return 0;

}

static int imx6ul_btn_fasync(int fd, struct file *filp, int mode)
{
	printk(KERN_DEBUG "imx6ul_btn_fasync\n");
	//初始化data->async_queue
	if(fasync_helper(fd, filp, mode, &data->async_queue) < 0 )
	{
		return -EIO;
	}
	return 0;
}

static int imx6ul_btn_close(struct inode *inode, struct file *file)
{
	printk(KERN_INFO "imx6ul_btn_close\n");
	//删除异步通知
	return imx6ul_btn_fasync(-1, file, 0);
}

static struct file_operations btn_fops = {
	.owner   = THIS_MODULE,
	.read    = imx6ul_btn_read,
	.write   = imx6ul_btn_write,
	.fasync  = imx6ul_btn_fasync,
	.open    = imx6ul_btn_open,
	.release = imx6ul_btn_close,
};

static int btn_parse_dt(void)
{
	int ret;

    /*1.获取设备树中compatible属性的字符串值imx-btn*/
	data->dev_node = of_find_compatible_node(NULL,NULL,"imx-btn");
	if(data->dev_node == NULL)
	{
		printk("led device node find failed\n");
		return -1;
	}

	/*2.获取gpio编号,将节点中的“key-gpio”属性值转换为对应的gpio编号。*/
	data->gpio_num = of_get_named_gpio(data->dev_node, "key-gpio", 0);
	if(data->gpio_num < 0)
	{
		printk("failed to get gpio\n");
		return -1;
	}
	
	/*3.申请gpio管脚*/
	ret = gpio_request(data->gpio_num, "btn-gpio");
	if(ret != 0)
	{
		printk("gpio request failed\n");
		return -1;
	}

	/*4.设置gpio为输入*/
	ret = gpio_direction_input(data->gpio_num);
	if(ret != 0)
	{
		printk("gpio direction input failed\n");
		return -1;
	}

    /*5.设置gpio为中断gpio,获取gpio的中断号*/
    data->irq = gpio_to_irq(data->gpio_num);
    ret = devm_request_threaded_irq(data->device, data->irq, NULL,
					  btn_interrupt,IRQ_TYPE_EDGE_BOTH| IRQF_ONESHOT,"btn-irq", data);
	if (ret) {
		printk("Failed to register interrupt\n");
		return -1;
	}

    disable_irq(data->irq);

	return 0;
}


static int btn_driver_probe(struct platform_device *pdev)
{
	u32 ret;
	
	data = devm_kzalloc(&pdev->dev,sizeof(struct btn_data), GFP_KERNEL);
    if(data == NULL)
    {
        printk(KERN_ERR"kzalloc data failed\n");
        return -ENOMEM;
    }
	
	/*2.字符设备驱动框架那一套*/
	/*2.1 之前定义了主设备号*/
	if(data->major)
	{
		/*选择次设备号*/
		data->devid = MKDEV(data->major,0);
		/*注册设备号*/
		ret = register_chrdev_region(data->devid, DEVICE_CNT, DEVICE_NAME);
		if(ret < 0)
		{
			printk("register_chrdev_region faibtn\n");
			return ret;
		}
	}else
	{
		/*向内核申请主次设备号,DEVICE_NAME体现在/proc/devices*/
		alloc_chrdev_region(&data->devid, 0, DEVICE_CNT,  DEVICE_NAME); /* 申请设备号 */
		data->major = MAJOR(data->devid); /* 获取分配号的主设备号 */
		data->minor = MINOR(data->devid); /* 获取分配号的次设备号 */
	}

	data->cdev.owner = THIS_MODULE;
	cdev_init(&data->cdev,&btn_fops);
	
	/*自动创建设备结点，在/dev目录下体现*/
	ret = cdev_add(&data->cdev,data->devid,DEVICE_CNT);
	if(ret < 0)
	{
		printk("cdev_add device faibtn\n");
		goto fail_cdev_add;
	}

	data->class = class_create(THIS_MODULE,DEVICE_NAME);
	if(IS_ERR(data->class))
	{
		printk("class creat faibtn\n");
		goto fail_class_create;
	}

	/*生成dev/DEVICE_NAME文件*/
	data->device = device_create(data->class,NULL,data->devid,NULL,DEVICE_NAME);
	if(IS_ERR(data->device))
	{
		printk("device class faibtn\n");
		goto fail_device_create;
	}

    /*创建led_enable结点，直接通过系统调用来操作驱动*/
	ret = sysfs_create_group(&data->device->kobj,&dev_attr_grp);
	if(ret)
	{
		printk("failed to create sys files\n");
		goto fail_sys_create;
	}
	
		
	/*1.设备树解析*/
	ret = btn_parse_dt();
	if (ret < 0) {
		printk("btn parse error");
		return ret;
	}
	
    //struct data *device = dev_get_drvdata(dev);
    /*初始化定时器,工作队列*/
    //INIT_WORK(&data.btn_work,btn_exchange_work);
    setup_timer(&data->timer,btn_timer_func,(unsigned long)data);//最后一个值可以传指针

    enable_irq(data->irq);
	
    /*激活定时器，add_timer不激活定时器*/
    //mod_timer(&data->timer, jiffies +msecs_to_jiffies(0));

	
	printk("%s:probe success\n",__func__);
    
	return 0;
fail_cdev_add:
	unregister_chrdev_region(data->devid,DEVICE_CNT);
	return -1;
fail_class_create:
	cdev_del(&data->cdev);
	unregister_chrdev_region(data->devid,DEVICE_CNT);
	return -1;
fail_device_create:
	cdev_del(&data->cdev);
	unregister_chrdev_region(data->devid,DEVICE_CNT);
	class_destroy(data->class);
    return -1;
fail_sys_create:    
    sysfs_remove_group(&data->device->kobj,&dev_attr_grp);
    cdev_del(&data->cdev);
    unregister_chrdev_region(data->devid,DEVICE_CNT);
    class_destroy(data->class);    
    return -1;
}

static int btn_driver_remove(struct platform_device *pdev)
{

    //依赖device,先删除
	sysfs_remove_group(&data->device->kobj, &dev_attr_grp);
    cdev_del(&data->cdev);
	unregister_chrdev_region(data->devid,DEVICE_CNT);
	/*依赖于class所以先删除*/
	device_destroy(data->class, data->devid);
	class_destroy(data->class);
	
    //删除定时器
    del_timer_sync(&data->timer);
	
	gpio_free(data->gpio_num);
	return 0;
}

/* 匹配列表,btn_of_match中的compatible与设备树中的
 * compatible匹配，匹配成功则跑probe函数
 */
 static const struct of_device_id btn_of_match[] = {
     { .compatible = "imx-btn" },
     { /* Sentinel */ }
 };

 /*
 * platform 平台驱动结构体
 */
 static struct platform_driver btn_driver = {
	.driver = {
	    .name = "imx-btn",
	    .of_match_table = btn_of_match,
     },
	.probe  = btn_driver_probe,
	.remove = btn_driver_remove,
 };

module_platform_driver(btn_driver);

MODULE_AUTHOR("fib");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("btn driver of atk imx6ull");

btn.h

#ifndef _BTN_H
#define _BTN_H

#include <linux/types.h>			/*设备号所在头文件*/
#include <linux/module.h>           /*内核模块声明的相关函数*/
#include <linux/init.h>			    /*module_init和module_exit*/
#include <linux/kernel.h>		    /*内核的各种函数*/
#include <asm/io.h>                 /*readl函数*/
#include <linux/cdev.h>             /*cdev*/
#include <linux/device.h>           /*class & device*/
#include <linux/fs.h>
#include <asm/uaccess.h>           /*copy_from_user*/
#include <linux/gpio.h>            /*gpio fileoperation*/
#include <linux/of.h>             
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/fcntl.h>
#include <linux/signal.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/slab.h>


#define DEVICE_NAME "btn_driver"
#define DEVICE_CNT   1
#define LED_ON		 1
#define LED_OFF      0


struct btn_data
{
	dev_t 	devid;		        /*设备号*/
	struct 	cdev cdev;           /*cdev*/
	struct 	class  *class;	    /*类*/
	struct 	device *device;	    /*设备*/
	int    	major;			    /*主设备号*/
	int    	minor;			    /*次设备号*/
    int    	irq;
    int    	gpio_num;
    struct 	fasync_struct *async_queue;
    struct 	device_node* dev_node;
    struct 	timer_list   timer;    /*定时器*/
};

struct btn_data *data;
#endif

Makefile

KERNELDIR := /home/klz/linux/linux-4.1.15

CURRENT_PATH := $(shell pwd)
obj-m := btn.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
copy:
	sudo cp *.ko /home/klz/linux/nfs/rootfs/lib/modules/4.1.15
	
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean	

简单来说，将按键所在的GPIO申请为中断gpio,在中断处理函数中启动定时器实现硬件消抖，在定时器处理函数中上报信号给应用程序,执行以下代码编译并且拷贝到根文件系统

make && make copy

5.2 应用程序

法1：通过syfs结点访问按键值，注意每次sysfs都要重新打开关闭

#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"


static int fd  = 0; /* 文件描述符 */ 
#define BTN_STATUS_PATH  "/sys/devices/virtual/btn_driver/btn_driver/btn_status"


static void get_btn_status(unsigned char *val)
{
	int fd_btn_status = 0;
	
	fd_btn_status = open(BTN_STATUS_PATH, O_RDWR);
	if (fd_btn_status < 0) 
	{
		printf("Can't open file %s\r\n", BTN_STATUS_PATH);
	}
 
	read(fd_btn_status, val, 1);
	
	*val = atoi((const char*)val);
	close(fd_btn_status);
}

 /*
 * SIGIO 信号处理函数
 * @param - signum : 信号值
 * @return : 无
 */
 static void sigio_signal_func(int signum)
 {
	 int err = 0;
	 unsigned char keyvalue = 0;

	 /*err = read(fd, &keyvalue, sizeof(keyvalue));
	 keyvalue = atoi((const char*)&keyvalue);*/
	 get_btn_status(&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("Can't open file %s\r\n", filename);
	return -1;
 }

 /* 设置信号 SIGIO 的处理函数 */ 
 signal(SIGIO, sigio_signal_func);

 fcntl(fd, F_SETOWN, getpid()); /* 将当前进程的进程号告诉给内核 */
 flags = fcntl(fd, F_GETFD); /* 获取当前的进程状态 */
 fcntl(fd, F_SETFL, flags | FASYNC);/* 设置进程启用异步通知功能 */

 while(1) {
  sleep(2);
 }

 close(fd);
 return 0;
}

法2：使用设备结点通过调用read函数来访问按键值

#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"


static int fd  = 0; /* 文件描述符 */ 
#define BTN_STATUS_PATH  "/sys/devices/virtual/btn_driver/btn_driver/btn_status"


static void get_btn_status(unsigned char *val)
{
	int fd_btn_status = 0;
	
	fd_btn_status = open(BTN_STATUS_PATH, O_RDWR);
	if (fd_btn_status < 0) 
	{
		printf("Can't open file %s\r\n", BTN_STATUS_PATH);
	}
 
	read(fd_btn_status, val, 1);
	
	*val = atoi((const char*)val);
	close(fd_btn_status);
}

 /*
 * SIGIO 信号处理函数
 * @param - signum : 信号值
 * @return : 无
 */
 static void sigio_signal_func(int signum)
 {
	 int err = 0;
	 unsigned char keyvalue = 0;

	 err = read(fd, &keyvalue, sizeof(keyvalue));
	 keyvalue = atoi((const char*)&keyvalue);
	 //get_btn_status(&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("Can't open file %s\r\n", filename);
	return -1;
 }

 /* 设置信号 SIGIO 的处理函数 */ 
 signal(SIGIO, sigio_signal_func);

 fcntl(fd, F_SETOWN, getpid()); /* 将当前进程的进程号告诉给内核 */
 flags = fcntl(fd, F_GETFD); /* 获取当前的进程状态 */
 fcntl(fd, F_SETFL, flags | FASYNC);/* 设置进程启用异步通知功能 */

 while(1) {
  sleep(2);
 }

 close(fd);
 return 0;
}

执行以下程序编译并拷贝应用程序到根文件系统下

arm-linux-gnueabihf-gcc btnApp.c -o btnApp
cp btnApp ../../../nfs/rootfs/lib/modules/4.1.15/

6.测试

加载驱动

修改sysfs属性结点权限，执行应用程序，两个应用程序执行代码一样

按下按键下报0，释放按键时报1