嵌入式Linux按键驱动框架

小鹏不会飞
502 阅读3分钟

前言

本文将通过轮询、中断、poll机制、异步通知和同步互斥阻塞等方式编写按键驱动程序。本节的驱动框架是在《嵌入式Linux驱动框架的搭建》的基础上进行改进的，所以本文只讲解修改的部分。

轮询方式

驱动程序

轮询方式在驱动部分主要就是通过second_drv_read()函数将按键的状态发送给app。函数内容如下：

ssize_t second_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
	/* 返回4个引脚的电平 */
	unsigned char key_vals[4];
	int regval;

	if (size != sizeof(key_vals))
		return -EINVAL;

	/* 读GPF0,2 */
	regval = *gpfdat;
	key_vals[0] = (regval & (1<<0)) ? 1 : 0;
	key_vals[1] = (regval & (1<<2)) ? 1 : 0;
	

	/* 读GPG3,11 */
	regval = *gpgdat;
	key_vals[2] = (regval & (1<<3)) ? 1 : 0;
	key_vals[3] = (regval & (1<<11)) ? 1 : 0;

	copy_to_user(buf, key_vals, sizeof(key_vals));
	
	return sizeof(key_vals);
}
  • 通过copy_to_user()函数将驱动的数据传给app。

测试程序

int main(int argc, char **argv)
{
	int fd;
	unsigned char key_vals[4];
	int cnt = 0;
	
	fd = open("/dev/buttons", O_RDWR);
	if (fd < 0)
	{
		printf("can't open!\n");
	}

	while (1)
	{
		read(fd, key_vals, sizeof(key_vals));
		if (!key_vals[0] || !key_vals[1] || !key_vals[2] || !key_vals[3])
		{
			printf("%04d key pressed: %d %d %d %d\n", cnt++, key_vals[0], key_vals[1], key_vals[2], key_vals[3]);
		}
	}
	
	return 0;
}
  • 测试程序通过不断地通过read()函数去读取内核的数据，然后将数据打印出来。
  • 因为用轮训方式不断读取按键，所以每次按下按键就会执行很多次printf()函数。

中断方式

一些信息的定义

  • static DECLARE_WAIT_QUEUE_HEAD(button_waitq); 创建一个名为button_waitq的等待队列头。
  • static volatile int ev_press = 0;定义一个中断事件标志位
  • 中断信息io的配置和中断信息的存储结构
struct pin_desc{
	unsigned int pin;
	unsigned int key_val;
};

/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;

struct pin_desc pins_desc[4] = {
	{S3C2410_GPF0, 0x01},
	{S3C2410_GPF2, 0x02},
	{S3C2410_GPG3, 0x03},
	{S3C2410_GPG11, 0x04},
};

buttons_irq() 函数

static irqreturn_t buttons_irq(int irq, void *dev_id)
{
	struct pin_desc * pindesc = (struct pin_desc *)dev_id;
	unsigned int pinval;
	
	pinval = s3c2410_gpio_getpin(pindesc->pin);

	if (pinval)
	{
		/* 松开 */
		key_val = 0x80 | pindesc->key_val;
	}
	else
	{
		/* 按下 */
		key_val = pindesc->key_val;
	}

    ev_press = 1;                  /* 表示中断发生了 */
    wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */

	
	return IRQ_RETVAL(IRQ_HANDLED);
}
  • 该函数为中断函数，即中断出发时程序执行的函数。
  • 首先根据传入的参数判断哪一个引脚发生电平变化。
  • 由于是边沿触发中断，所以根据电平判断按键是处于松开还是按下。
  • 然后改变中断标志位和唤醒休眠的进程，也就是在一开始声明的等待队列。

third_drv_open()函数

static int third_drv_open(struct inode *inode, struct file *file)
{
	/* 配置GPF0,2为输入引脚 */
	/* 配置GPG3,11为输入引脚 */
	request_irq(IRQ_EINT0,  buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
	request_irq(IRQ_EINT2,  buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
	request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
	request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);	

	return 0;
}
  • 该函数对中断进行初始化。指定中断对应的中断函数，和中断函数执行时的参数。
  • IRQT_BOTHEDGE表示该中断为边沿触发，即只要中断引脚发生电平变化就触发一次中断。

third_drv_read()函数

ssize_t third_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
	if (size != 1)
		return -EINVAL;

	/* 如果没有按键动作, 休眠 */
	wait_event_interruptible(button_waitq, ev_press);

	/* 如果有按键动作, 返回键值 */
	copy_to_user(buf, &key_val, 1);
	ev_press = 0;
	
	return 1;
}
  • 该函数主要就是休眠进程，使程序一直等待进程的唤醒，唤醒后把数据发送给app，然后把中断标志位至0。表示可以接收下一次中断。

third_drv_close()函数

int third_drv_close(struct inode *inode, struct file *file)
{
	free_irq(IRQ_EINT0, &pins_desc[0]);
	free_irq(IRQ_EINT2, &pins_desc[1]);
	free_irq(IRQ_EINT11, &pins_desc[2]);
	free_irq(IRQ_EINT19, &pins_desc[3]);
	return 0;
}
  • 该函数之前没有用过，主要是执行关闭中断的功能。

POLL机制

与中断方式不同，若条件不满足，程序将一直休眠下去，而POLL机制则会指定休眠时间，若条件不满足且超过了指定时间，则程序会自动唤醒。

驱动程序

static unsigned forth_drv_poll(struct file *file, poll_table *wait)
{
	unsigned int mask = 0;
	poll_wait(file, &button_waitq, wait); // 不会立即休眠

	if (ev_press)
		mask |= POLLIN | POLLRDNORM;

	return mask;
}
  • 驱动程序在中断程序的基础上只加了一个poll函数。
  • wait参数为需要等待的时间。
  • 该函数返回一个mask,当等待时间结束且发生中断后，返回一个非0数。

测试程序

int main(int argc, char **argv)
{
	int fd;
	unsigned char key_val;
	int ret;

	struct pollfd fds[1];
	
	fd = open("/dev/buttons", O_RDWR);
	if (fd < 0)
	{
		printf("can't open!\n");
	}
	fds[0].fd     = fd;
	fds[0].events = POLLIN;
	while (1)
	{
		ret = poll(fds, 1, 5000);
		if (ret == 0)
		{
			printf("time out\n");
		}
		else
		{
			read(fd, &key_val, 1);
			printf("key_val = 0x%x\n", key_val);
		}
	}
	return 0;
}
  • 该测试程序首先用poll函数设置测试时间为5秒，若超过5秒没有检测到中断的发生则屏幕输出 time out，若在5秒内有中断发生则直接执行中断程序。

异步通知

前面几种按键驱动都是应用程序主动去访问驱动程序，看看有没有值，而异步通知则是通过信号，让驱动程序在发生中断的时候主动通知应用程序。

驱动程序

static struct fasync_struct *button_async;              //#1
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
	...
	kill_fasync (&button_async, SIGIO, POLL_IN);       // #2
    ...
}
static int fifth_drv_fasync (int fd, struct file *filp, int on)
{
	printk("driver: fifth_drv_fasync\n");
	return fasync_helper (fd, filp, on, &button_async);  //#3
}
  • #1: 初始化一个结构体，存放异步通知的一些信息
  • #2： 在中断程序中发送SIGIO信号给应用程序，应用程序的信息保存在button_async中
  • #3： 当应用程序调用fcntl()函数后，系统进入内核调用fifth_drv_fasync()函数，该函数主要是对结构体button_async进行初始化。

测试程序

int fd;  

void my_signal_fun(int signum)         //#1
{
	unsigned char key_val;
	read(fd, &key_val, 1);
	printf("key_val: 0x%x\n", key_val);
}

int main(int argc, char **argv)
{
	unsigned char key_val;
	int ret;
	int Oflags;

	signal(SIGIO, my_signal_fun);   //#2
	
	fd = open("/dev/buttons", O_RDWR);
	if (fd < 0)
	{
		printf("can't open!\n");
	}

	fcntl(fd, F_SETOWN, getpid());      //#3
	
	Oflags = fcntl(fd, F_GETFL); 
	
	fcntl(fd, F_SETFL, Oflags | FASYNC); //#4
	while (1)
	{
		sleep(1000);
	}
	return 0;
}
  • #1: 这是信号处理函数的定义，当应用程序接收到信号后，进入该程序执行相关操作
  • #2：初始化一个接收SIHIO的信号，并指定信号处理函数。
  • #3和#4：是将应用程序的信息，比如PID号，通过fcntl()函数传给驱动程序，告诉确定程序要向该应用程序发送信号。

同步互斥阻塞

要想一个驱动程序一个时刻只能有一个应用程序打开，这时候就要用到信号量。阻塞和非阻塞的区别在于，没有获取到信息时，程序是处于休眠状态一直等待还是跳过休眠执行后续程序。

驱动程序

static DECLARE_MUTEX(button_lock);     //#1
static int sixth_drv_open(struct inode *inode, struct file *file)
{
	...
	if (file->f_flags & O_NONBLOCK)          //#2
	{
		if (down_trylock(&button_lock))      //#3
			return -EBUSY;
	}
	else
	{
		/* 获取信号量 */
		down(&button_lock);                   //#4
	}
    ...
}
int sixth_drv_close(struct inode *inode, struct file *file)
{
	...
	up(&button_lock);                        //#5
	...
}
ssize_t sixth_drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
	...
	if (file->f_flags & O_NONBLOCK)              //#6
	{
		if (!ev_press)
			return -EAGAIN;
	}
	else
	{
		wait_event_interruptible(button_waitq, ev_press);     //#7
	}
    ...
}
  • #1: 定义一个名为button_lock的信号量。
  • #2、#3和#4： 执行open()函数时，会根据标志位判断是阻塞还是非阻塞，若是阻塞，则程序获取信号量，若此时获取不到信号量，该应用程序就一直等待该信号量被释放。若是非阻塞，则用down_trylock()函数获取信号量，若获取不到信号量，则返回一个错误值，即打开失败，然后执行后续程序。
  • #5：当应用程序结束后，用up()函数释放信号量，给其他应用程序使用。
  • #6和#7： #2、#3、#4类似。

测试程序

int main(int argc, char **argv)
{
	unsigned char key_val;
	int ret;
	fd = open("/dev/buttons", O_RDWR | O_NONBLOCK);   //#1
	if (fd < 0)
	{
		printf("can't open!\n");
		return -1;
	}
	while (1)
	{
		ret = read(fd, &key_val, 1);
		printf("key_val: 0x%x, ret = %d\n", key_val, ret);
		sleep(5);
	}
	return 0;
}
  • #1: 打开文件时，选择用非阻塞方式。

相关指令

  • exec 5</dev/buttons 打开设备
  • exec 5<&- 关闭设备
  • cat /proc/interrupts 查看开启的中断
  • ps 命令查看进程
  • kill -9 PID 杀死进程
  • ./program & 后台运行程序
  • top 查看进程占据cpu多少的资源
  • lsmod 查看已经装载的驱动
  • kill -USR1 PID 向进程发送一个信号
avatar
文章
阅读
粉丝