前言

本文将通过轮询、中断、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

exec 5

cat /proc/interrupts 查看开启的中断

ps 命令查看进程

kill -9 PID 杀死进程

./program & 后台运行程序

top 查看进程占据cpu多少的资源

lsmod 查看已经装载的驱动

kill -USR1 PID 向进程发送一个信号