linux驱动程序中的poll机制编程

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/irq.h>
#include <linux/interrupt.h>
#include <asm/uaccess.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>
/* 加载模式后,执行”cat /proc/devices”命令看到的设备名称 */
#define DEVICE_NAME     "key_poll"  
/*自动创建设备节点类*/
struct class *key_poll_dev_class = NULL;
struct class_device *key_poll_dev_class_dev = NULL;
/* 用来指定按键所用的外部中断引脚及中断触发方式, 名字 */
struct button_irq_desc {
    int 		irq;
    unsigned long 	flags;
    char 		*name;
};
static struct button_irq_desc button_irqs [] = {
    {IRQ_EINT19, IRQF_TRIGGER_FALLING, "key_poll1"}, /* K1 */
    {IRQ_EINT11, IRQF_TRIGGER_FALLING, "key_poll2"}, /* K2 */
    {IRQ_EINT2,  IRQF_TRIGGER_FALLING, "key_poll3"}, /* K3 */
    {IRQ_EINT0,  IRQF_TRIGGER_FALLING, "key_poll4"}, /* K4 */
};
/* 按键被按下的次数(准确地说,是发生中断的次数) */
static volatile int press_cnt [] = {0, 0, 0, 0};
/* 等待队列: 
 * 当没有按键被按下时,如果有进程调用key_poll_dev_read函数,
 * 它将休眠
 */
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
/* 中断事件标志, 中断服务程序将它置1,key_poll_dev_read将它清0 */
static volatile int ev_press = 0;
static irqreturn_t buttons_interrupt(int irq, void *dev_id)
{
    volatile int *press_cnt = (volatile int *)dev_id;
    
    *press_cnt = *press_cnt + 1; /* 按键计数加1 */
    ev_press = 1;                /* 表示中断发生了 */
    wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
    
    return IRQ_RETVAL(IRQ_HANDLED);
}
static int key_poll_dev_open(struct inode *inode, struct file *file)
{
    int i;
    int err;
    
    for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++) 
    {
        // 注册中断处理函数
        err = request_irq(button_irqs[i].irq, buttons_interrupt, button_irqs[i].flags, button_irqs[i].name, (void *)&press_cnt[i]);
        if (err)
            break;
    }
    if (err) 
    {
        // 释放已经注册的中断
        i--;
        for (; i >= 0; i--)
            free_irq(button_irqs[i].irq, (void *)&press_cnt[i]);
        return -EBUSY;
    }
    return 0;
}
static int key_poll_dev_close(struct inode *inode, struct file *file)
{
    int i;
    
    for (i = 0; i < sizeof(button_irqs)/sizeof(button_irqs[0]); i++) {
        // 释放已经注册的中断
        free_irq(button_irqs[i].irq, (void *)&press_cnt[i]);
    }
    return 0;
}
/* 应用程序对设备文件/dev/buttons执行read(...)时,
 * 就会调用key_poll_dev_read函数
 */
static int key_poll_dev_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
{
    unsigned long err = 0;
    
    /* 如果ev_press等于0,休眠 */
    wait_event_interruptible(button_waitq, ev_press);
    /* 执行到这里时,ev_press等于1,将它清0 */
    ev_press = 0;
    /* 将按键状态复制给用户*/
    err = copy_to_user(buff, (const void *)press_cnt, min(sizeof(press_cnt), count));
    //memset((void *)press_cnt, 0, sizeof(press_cnt));
    
    return err ? -EFAULT : 0;
}
static int key_poll_dev_poll(struct file *file, poll_table *wait)
{
	unsigned int mask = 0;

	/*
	void poll_wait(struct file *filp, wait_queue_head_t *queue, poll_table *wait);
	typedef struct poll_table_struct { 
		poll_queue_proc qproc; 
		unsigned long key; 
	} poll_table;
	poll_wait的作用就是把当前进程添加到指定等待列表wait(poll_table)中。
	需要注意的是这个函数是不会引起阻塞的,呵呵,谁给它取得个名字带wait的,给咱们添这么多麻烦。
	*/
	poll_wait(file, &button_waitq, wait);

	if (ev_press)
		mask |= POLLIN | POLLRDNORM;
	/*
	POLLIN		普通或优先级带数据可读
	POLLRDNORM	普通数据可读
	POLLRDBAND	优先级带数据可读
	POLLPRI		高优先级数据可读
	POLLOUT		普通数据可写
	POLLWRNORM	普通数据可写
	POLLWRBAND	优先级带数据可写
	POLLERR		发生错误
	POLLHUP		发生挂起
	POLLNVAL	描述字不是一个打开的文件
	*/	

	return mask;
}

/* 这个结构是字符设备驱动程序的核心
 * 当应用程序操作设备文件时所调用的open、read、write等函数,
 * 最终会调用这个结构中的对应函数
 */
static struct file_operations key_poll_dev_fops = {
    .owner   =   THIS_MODULE,    /* 这是一个宏,指向编译模块时自动创建的__this_module变量 */
    .open    =   key_poll_dev_open,
    .release =   key_poll_dev_close, 
    .read    =   key_poll_dev_read,
	.poll    =   key_poll_dev_poll,
};

/*
 * 执行“insmod key_poll_driver.ko”命令时就会调用这个函数
 */
int key_poll_major = 0;
int key_poll_minor = 0;
static int __init initialization_key_poll_dev(void)
{
    /* 注册字符设备驱动程序
     * 参数为主设备号、设备名字、file_operations结构;
     * 这样,主设备号就和具体的file_operations结构联系起来了,
     * 操作主设备为key_poll_major的设备文件时,就会调用key_poll_dev_fops中的相关成员函数
     * key_poll_MAJOR可以设为0,表示由内核自动分配主设备号
     */
	printk("Before register Major = %d\n", key_poll_major);
	if (key_poll_major)
		register_chrdev(key_poll_major, DEVICE_NAME, &key_poll_dev_fops);
    	else 
		key_poll_major = register_chrdev(0, DEVICE_NAME, &key_poll_dev_fops);
    	printk("After register Major = %d\n", key_poll_major);

	/* 自动生成设备节点 */
	key_poll_dev_class = class_create(THIS_MODULE, "key_poll_drv");
	key_poll_dev_class_dev = class_device_create(key_poll_dev_class, NULL, MKDEV(key_poll_major, key_poll_minor), NULL, "key_poll%d", key_poll_minor);

    	printk(DEVICE_NAME " initialized OK.\n");
    	return 0;
}

/*执行”rmmod key_poll_dev.ko”命令时就会调用这个函数*/
static void __exit cleanup_key_poll_dev(void)
{
    	/* 卸载驱动程序 */
    	unregister_chrdev(key_poll_major, DEVICE_NAME);
	class_device_unregister(key_poll_dev_class_dev);
	class_destroy(key_poll_dev_class);
	printk(DEVICE_NAME " cleanup OK.\n");
}

/* 这两行指定驱动程序的初始化函数和卸载函数 */
module_init(initialization_key_poll_dev);
module_exit(cleanup_key_poll_dev);

/*insmod传参*/
module_param(key_poll_major, int, S_IRUGO);
module_param(key_poll_minor, int, S_IRUGO);

/* 描述驱动程序的一些信息,不是必须的 */
MODULE_AUTHOR("lhbo");             		// 驱动程序的作者
MODULE_DESCRIPTION("JZ2440 key_poll Driver");   // 一些描述信息
MODULE_LICENSE("GPL");                          // 遵循的协议

/*===========================异步通知驱动测试=========================*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <poll.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char **argv)
{
    int i;
    int ret;
    int fd;
    int press_cnt[4];
    struct pollfd fds[1];

    fd = open("/dev/key_poll", 0);  // 打开设备
    if (fd < 0) 
    {
        printf("Can‘t open /dev/key\n");
        return -1;
    }

	fds[0].fd = fd;
	fds[0].events = POLLIN;

    	/* 
	这是个无限循环,进程可能在read函数中休眠,当有按键被按下时,它才返回
    	*/
	while (1) 
	{
		int ret = poll(fds, 1, 5000);	//5000ms 1个文件
		/*
		执行上面这条语句后,如果在5s内没有按键,则进程在这5s内被阻塞在poll处,5s之后返回0,否则poll立即返回非0值。
		*/
		if (ret == 0)
		{
			printf("Time out!\n");
		} 
		else 
		{
			/* 读出按键被按下的次数*/
			ret = read(fd, press_cnt, sizeof(press_cnt));
			if (ret < 0) 
			{
				printf("read err!\n");
				continue;
			} 
			/*读取成功打印按键次数*/
			for (i = 0; i < 4; i++) 
				printf("K%d has been pressed %d times!\n", i+1, press_cnt[i]);
		}
    	}
    	close(fd);

    	return 0;    
}

linux驱动程序中的poll机制编程,布布扣,bubuko.com

时间: 2024-09-29 03:11:38

linux驱动程序中的poll机制编程的相关文章

Linux内核中的信号机制--一个简单的例子【转】

本文转载自:http://blog.csdn.net/ce123_zhouwei/article/details/8562958 Linux内核中的信号机制--一个简单的例子 Author:ce123(http://blog.csdn.NET/ce123) 信号机制是类UNIX系统中的一种重要的进程间通信手段之一.我们经常使用信号来向一个进程发送一个简短的消息.例如:假设我们启动一个进程通过socket读取远程主机发送过来的网络数据包,此时由于网络因素当前主机还没有收到相应的数据,当前进程被设置

linux驱动程序中的异步编程

A 前面介绍的等待队列和轮询编程提供了较好的解决设备访问的机制,但是这些机制都 是由应用程序发起的,都需要应用程序主动访问设备.更完美的方式是由驱动程序主 动通知应用程序,也就是说,当驱动程序满足某些条件后,会主动通知应用程序处理 ,这些处理方式有些像面向对象编程的事件,而在linux内核使用的事件是接下来要介 绍的信号. #include<sys/types.h> #include<sys/stat.h> #include<stdio.h> #include<f

linux驱动程序中的并发控制

   现代操作系统有三大特性:中断处理.多任务处理和多处理器.这些特性导致当多个进程.线程或者CPU同时访问一个资源时,可能发生错误,这些错误是操作系统运行所不允许的.在操作系统中,内核需要提供并发控制机制,对共享资源进行保护.   在操作系统中,并发是指一个时间段中有几个程序都处于已启动运行到运行完毕之间,且这几个程序都是在同一个处理机上运行,但任一个时刻点上只有一个程序在处理机上运行.并发容易导致竞争的问题.竞争就是两个或两个以上的进程同时访问一个资源,同时引起资源的错误.并发控制机制有以下

linux驱动编写之poll机制

一.概念 1.poll情景描述 以按键驱动为例进行说明,用阻塞的方式打开按键驱动文件/dev/buttons,应用程序使用read()函数来读取按键的键值.这样做的效果是:如果有按键按下了,调用该read()函数的进程,就成功读取到数据,应用程序得到继续执行:倘若没有按键按下,则要一直处于休眠状态,等待这有按键按下这样的事件发生. 这种功能在一些场合是适用的,但是并不能满足我们所有的需要,有时我们需要一个时间节点.倘若没有按键按下,那么超过多少时间之后,也要返回超时错误信息,进程能够继续得到执行

【转】linux驱动程序中的并发控制

原文网址:http://www.cnblogs.com/geneil/archive/2011/12/03/2274684.html 现代操作系统有三大特性:中断处理.多任务处理和多处理器.这些特性导致当多个进程.线程或者CPU同时访问一个资源时,可能发生错误,这些错误是操作系统运行所不允许的.在操作系统中,内核需要提供并发控制机制,对共享资源进行保护. 在操作系统中,并发是指一个时间段中有几个程序都处于已启动运行到运行完毕之间,且这几个程序都是在同一个处理机上运行,但任一个时刻点上只有一个程序

再谈Linux内核中的RCU机制

转自:http://blog.chinaunix.net/uid-23769728-id-3080134.html RCU的设计思想比较明确,通过新老指针替换的方式来实现免锁方式的共享保护.但是具体到代码的层面,理解起来多少还是会有些困难.在<深入Linux设备驱动程序内核机制>第4章中,已经非常明确地叙述了RCU背后所遵循的规则,这些规则是从一个比较高的视角来看,因为我觉得过多的代码分析反而容易让读者在细节上迷失方向.最近拿到书后,我又重头仔细看了RCU部分的文字,觉得还应该补充一点点内容,

Linux 驱动程序中相关函数注释汇总(跟新中)

1.ARRAY_SIZE 宏,是求设备结构体中设备的个数 定义在linux/kernel.h中 #define ARRAY_SIZE(arr)(sizeof(arr)/sizeof((arr)[0]) + __must_be_array(arr)) sizeof(arr)/sizeof((arr)[0])是求出设备的个数,__must_be_array(arr)是防止被吴用,比如用指针而不是数组上. 2.INT_WORK 以前内核里对这个函数是这样定义的 #define INIT_WORK(_w

linux设备驱动程序中的阻塞、IO多路复用与异步通知机制

一.阻塞与非阻塞 阻塞与非阻塞是设备访问的两种方式.在写阻塞与非阻塞的驱动程序时,经常用到等待队列. 阻塞调用是指调用结果返回之前,当前线程会被挂起,函数只有在得到结果之后才会返回. 非阻塞指不能立刻得到结果之前,该函数不会阻塞当前进程,而会立刻返回. 函数是否处于阻塞模式和驱动对应函数中的实现机制是直接相关的,但并不是一一对应的,例如我们在应用层设置为阻塞模式,如果驱动中没有实现阻塞,函数仍然没有阻塞功能. 二.等待队列 在linux设备驱动程序中,阻塞进程可以使用等待队列来实现. 在内核中,

Linux内核中的机制学习总结

一.驱动中的poll机制 1.简介:select()和poll()系统调用的本质一样,前者在 BSD UNIX 中引入的,后者在 System V 中引入的. 应用程序使用 select() 或 poll() 调用设备驱动程序的 file_operations 的 poll() 函数. 2.实现(1).初始化一个等待队列头init_waitqueue_head(&dev->rx_wait/&dev->tx_wait); (2).实现驱动中的poll()方法 static uns