嵌入式Linux驱动学习 —— poll机制

1 IO模式

Linux下的五种IO模型：
1）阻塞IO（blocking IO）：读数据，若没有，一直阻塞，直到有数据后返回；
2）非阻塞IO （nonblocking IO）：读数据，不管有没有，直接返回；
3）IO复用(select 和poll) （IO multiplexing）：同时监听多路数据，只要有一路有数据或超时返回；
4）信号驱动IO （signal driven IO (SIGIO)）：很少用；
5）异步IO （asynchronous IO (the POSIX aio_functions)）：有数据时，主动通知。

2 poll机制

  poll可同时监听多路IO，当应用层调用poll，进入内核，调用fs/select.c中的SYSCALL_DEFINE3，SYSCALL_DEFINE3–>do_sys_poll。

void poll_initwait(struct poll_wqueues *pwq)
{
	init_poll_funcptr(&pwq->pt, __pollwait);
	...
}

int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
		struct timespec *end_time)
{
	..
	poll_initwait(&table);
	fdcount = do_poll(nfds, head, &table, end_time);
	..
}

  poll_initwait–>init_poll_funcptr，即设置table->pt->qproc=__pollwait，__pollwait将在驱动里调用。

static int do_poll(unsigned int nfds,  struct poll_list *list,
		   struct poll_wqueues *wait, struct timespec *end_time)
{
	...
	for (;;) {   //死循环
		struct poll_list *walk; 

		for (walk = list; walk != NULL; walk = walk->next) {
			struct pollfd * pfd, * pfd_end;

			pfd = walk->entries;
			pfd_end = pfd + walk->len;
			for (; pfd != pfd_end; pfd++) {
				if (do_pollfd(pfd, pt)) { //将调用驱动中的poll
					count++;
					pt = NULL;
				}
			}
		}
		...
		if (count || timed_out)  //do_pollfd有成功的，或超时，退出
			break;
		...
		if (!poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack)) //休眠
			timed_out = 1;//超时
	}
	...
}

  count记录调用do_pollfd成功的个数，当count大于零或超时会退出，否则，休眠。休眠到指定的时间或是有中断，则被唤醒。

static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
{
	...
	mask = file->f_op->poll(file, pwait);//驱动中的poll
	...
}

  file->f_op->poll，其中f_op就是驱动中的struct file_operations，所以调用驱动中的poll。驱动中的poll，例如将要写的按键驱动。

static unsigned int third_poll(struct file *fp, poll_table * wait)  //fp:文件  wait:
{
         unsigned int mask =0; 
         poll_wait(fp, &button_wait, wait);
         if(even_press)              //中断事件标志, 1:退出休眠状态     0:进入休眠状态 
         	mask |= POLLIN | POLLRDNORM ;
         return mask;     //当超时,就返给应用层为0 ,被唤醒了就返回POLLIN | POLLRDNORM ;
}

  调用poll_wait。

static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
	if (p && wait_address)
		p->qproc(filp, wait_address, p);
}

  p->qproc就是poll_initwait设置的__pollwait

static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
				poll_table *p)
{
	struct poll_wqueues *pwq = container_of(p, struct poll_wqueues, pt);
	struct poll_table_entry *entry = poll_get_entry(pwq);
	if (!entry)
		return;
	get_file(filp);
	entry->filp = filp;
	entry->wait_address = wait_address;
	entry->key = p->key;
	init_waitqueue_func_entry(&entry->wait, pollwake);
	entry->wait.private = pwq;
	add_wait_queue(wait_address, &entry->wait);
}

  将当前进程挂载到队列里。当所需情况就绪，唤醒队列上的进程。

3 按键驱动

（1）按键驱动

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <mach/regs-gpio.h>
#include <mach/hardware.h>
#include <linux/poll.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/gpio.h>
#include <linux/device.h>

static struct class *buttons_class;
static struct class_device	*buttons_class_dev;


static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

/* 中断事件标志, 中断服务程序将它置1，forth_drv_read将它清0 */
static volatile int ev_press = 0;


struct pin_desc{
	unsigned int pin;
	unsigned int key_val;
};


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

/*
 * K1,K2,K3,K4对应GPG0，GPG3，GPG5，GPG6
 */

struct pin_desc pins_desc[4] = {
	{S3C2410_GPG(0), 0x01},
	{S3C2410_GPG(3), 0x02},
	{S3C2410_GPG(5), 0x03},
	{S3C2410_GPG(6), 0x04},
};


/*
  * 确定按键值
  */
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);
}

static int buttons_drv_open(struct inode *inode, struct file *file)
{
	/* GPG0，GPG3，GPG5，GPG6为中断引脚: EINT8,EINT11,EINT13,EINT14 */
	request_irq(IRQ_EINT8,  buttons_irq, IRQF_TRIGGER_FALLING, "K1", &pins_desc[0]);
	request_irq(IRQ_EINT11, buttons_irq, IRQF_TRIGGER_FALLING, "K2", &pins_desc[1]);
	request_irq(IRQ_EINT13, buttons_irq, IRQF_TRIGGER_FALLING, "K3", &pins_desc[2]);
	request_irq(IRQ_EINT14, buttons_irq, IRQF_TRIGGER_FALLING, "K4", &pins_desc[3]);	

	return 0;
}

ssize_t buttons_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;
}


int buttons_drv_close(struct inode *inode, struct file *file)
{
	free_irq(IRQ_EINT8,  &pins_desc[0]);
	free_irq(IRQ_EINT11, &pins_desc[1]);
	free_irq(IRQ_EINT13, &pins_desc[2]);
	free_irq(IRQ_EINT14, &pins_desc[3]);
	return 0;
}

static unsigned buttons_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;
}



static struct file_operations buttons_drv_fops = {
    .owner   =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =  buttons_drv_open,     
	.read	 =	buttons_drv_read,	   
	.release =  buttons_drv_close,
	.poll    =  buttons_drv_poll,
};


int major;
static int buttons_drv_init(void)
{
	major = register_chrdev(0, "forth_drv", &buttons_drv_fops);

	buttons_class = class_create(THIS_MODULE, "buttons_drv");

	buttons_class_dev = device_create(buttons_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */

	return 0;
}

static void buttons_drv_exit(void)
{
	unregister_chrdev(major, "buttons_drv");
	device_unregister(buttons_class_dev);
	class_destroy(buttons_class);
	return 0;
}


module_init(buttons_drv_init);
module_exit(buttons_drv_exit);
MODULE_LICENSE("GPL");

（2）测试程序

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>



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