linux驱动开发之路（四）结合按键驱动看通信方式

一、目的：

1. 本文是韦东山教程，uboot按键驱动的学习笔记。
2. 主要是记录Linux驱动的查询方式。

二、方式：

方式	内容
查询	采用while循环，不断read按键状态。
中断	当按键产生中断时，自动返回
poll方式	Poll机制，如果获取到了就继续执行，没有获取到就休眠
异步通知机制	在某个时机发送异步信号到某一个进程
互斥锁	同一时刻只有一个进程可以使用
阻塞	对于设备文件，我们可以用阻塞和非阻塞的方式读写。在阻塞方式下，若设备不可读写，则该进程休眠，释放CPU资源；若设备文件可读写，则对设备文件进行读写。在非阻塞方式下，若设备不可读写，进程放弃读写，继续向下执行；若设备文件可读写，则对设备文件进行读写

三、button驱动基础架构：

3.1、read以及open函数

static int second_drv_open(struct inode *inode,struct file *file)
{
	/* 配置 gpf 0,2 为输入引脚*/
	*gpfcon &= ~((0x3<<(0*2))| (0x3<<(2*2)));
	/* 配置gpg 3,11为输入引脚*/

	*gpgcon &= ~((0x3<<(3*2))| (0x3<<(11*2)));
	return 0;
}

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

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

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

		/* 读 gpg 3,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);
}

3.2、init以及exit函数：

//入口函数
int second_drv_init(void)
{
	//注册驱动设备，将结构告诉内核
	//major: 主设备号，0表示自动分配
	major = register_chrdev(0,"second_drv",&second_drv_fops);

	seconddrv_class = class_create(THIS_MODULE,"second_drv");

	seconddrv_class_dev = class_device_create(seconddrv_class,NULL,MKDEV(major,0),NULL,"buttons");

	gpfcon = (volatile unsigned long *)ioremap(0x56000050,16);
	gpfdat = gpfcon +1;

	
	gpgcon = (volatile unsigned long *)ioremap(0x56000060,16);
	gpgdat = gpgcon +1;


	return 0;
}

//出口函数
int second_drv_exit(void)
{
	//注册驱动设备，将结构告诉内核
	//major: 主设备号，0表示自动分配
	unregister_chrdev(major,"second_drv");

	class_device_unregister(seconddrv_class_dev);
	class_destroy(seconddrv_class);

	iounmap(gpfcon);
	iounmap(gpgcon);

	
	return 0;
}

3.3、基础测试函数：

• 直接打开，然后while死循环读取：

/* seconddrvtest on
  * seconddrvtest off
  */
int main(int argc, char **argv)
{
	int fd;
	int cnt = 0;
	unsigned char key_vals[4];
	
	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("key pressed: %d %d %d %d\n,",cnt++,key_vals[0],key_vals[1],key_vals[2],key_vals[3]);
		}
	}
	//write(fd, &val, 4);
	return 0;
}

四、中断查询：

在采用while方式的时候，我们可以通过ps命令发现cpu几乎都被这一个进程所占用。这当然不是我们所希望的。那么，采用中断方式，无疑可以减少cpu的工作量。
写一个中断程序的例子为：
1.在open函数里面申请中断。
2.编写中断函数。
3.编写中断退出函数：close
4.在read函数中休眠进程。

• 定义一些变量：

#include <linux/irq.h>
//这是仿照的一个结构体，包含管脚和数值
struct pin_desc
{
	unsigned int pin;
	unsigned int key_val;
};

static struct file_operations third_drv_fops = {
    .owner   =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =   third_drv_open,     
	.read 	 = 	third_drv_read,
	.release =	third_drv_close,
};

/*中断事件标志，中断服务程序将它置为一，forth_drv_read将它值置为零*/
static volatile int ev_press = 0;

4.1、open函数申请中断：

采用request_irq函数申请中断：

int request_irq(
	unsigned int irq,
	irq_handler_t handler,
	unsigned long flags,
	const char *devname,
	void *dev_id)

open函数里面申请中断

static int third_drv_open(struct inode *inode,struct file *file)
{
//申请，按键中断，上升沿和下降沿触发，设备id为pin_desc
	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;
}

4.2、编写中断函数：

/*
 * 确定按键值
*/
static irqreturn_t buttons_irq(int irq,void *dev_id)
{
	//获取设备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);
}

4.3、编写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;
}

4.4、编写read函数，当没有得到按键值得时候休眠进程：

ssize_t third_drv_read(struct file *file,const 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;
}

4.5、测试程序：

• 注意这个时候虽然也是while不断查询，但是由于只有产生按键中断时，才会导致进程被唤醒。从而减少了cpu占用。

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

	while(1)
	{
		read(fd,&key_val,1); 
		printf("key_val = 0x %x\n",key_val);
	}
	return 0;
}

五、poll机制

应用程序的调用函数如下：
int poll(struct pollfd *fds,nfds_t nfds, int timeout);
Poll机制会判断fds中的文件是否可读，如果可读则会立即返回，返回的值就是可读fd的数量，如果不可读，那么就进程就会休眠timeout这么长的时间，然后再来判断是否有文件可读，如果有，返回fd的数量，如果没有，则返回0.

做个总结，大概意思就是。用户可以采用poll函数，poll函数如果可读，那么就返回值。如果不可读，那么就会休眠一段时间，这段时间里面可以被驱动唤醒，当然到了时间还没有被唤醒的话，就会返回超时。

• 准备工作，添加头文件，和.poll:

#include <linux/poll.h>
//添加poll
static struct file_operations forth_drv_fops = {
    .owner   =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =   forth_drv_open,     
	.read 	 = 	forth_drv_read,
	.release =	forth_drv_close,
	.poll 	 =	forth_drv_poll, 
};

5.0、了解linux如何实现poll：

这篇文章很详细啊点击这里进去观看

5.1、编写驱动poll函数：

static unsigned forth_drv_poll(struct file *file,poll_table *wait)
{
	unsigned char mask =0 ;
	poll_wait(file,&button_waitq,wait);//不会立刻进入休眠，这个函数是为了对应的等待队列头添加到poll_table。

	if(ev_press)
	 mask |= POLLIN | POLLRDNORM;

	 return mask;
}

5.1、编写测试函数：

#include <poll.h>

/* forth
  */
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("Timeout\n");
		}
		else
		{
			read(fd,&key_val,1); 
			printf("key_val = 0x %x\n",key_val);
		}
	}
	return 0;
}

六、异步通讯和信号：

6.1、编写异步函数：

static struct file_operations fifth_drv_fops = {
    .owner   =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open    =   fifth_drv_open,     
	.read 	 = 	fifth_drv_read,
	.release =	fifth_drv_close,
	.poll 	 =	fifth_drv_poll, 
	.fasync	 = 	fifth_drv_fasync,
};

static int fifth_drv_fasync(int fd,struct file *filp,int on)
{
	printk("friver: fifth fasync\n");
	return fasync_helper(fd,filp,on,&button_async);
}

6.2、编写测试函数：

#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
int fd;
void my_signal_fun(int signum)
{
	unsigned char key_val;
	read(fd,&key_val,1);
	printf("keyval :0x %x times\n",key_val);
}

/* forth */
int main(int argc, char **argv)
{
	unsigned char key_val;
	int ret;
	int oflags;
//参数1：我们要进行处理的信号。系统的信号我们可以再终端键入 kill -l查看(共64个)。其实这些信号时系统定义的宏。
//参数2：我们处理的方式（是系统默认还是忽略还是捕获）。
	signal(SIGIO,my_signal_fun);
	fd = open("/dev/buttons", O_RDWR);
	if (fd < 0)
	{
		printf("can't open!\n");
	}
	
	fcntl(fd,F_SETOWN,getpid());
	oflags = fcntl(fd,F_GETFL);
	fcntl(fd,F_SETFL,oflags |FASYNC);
	
	while(1)
	{
		sleep(1000);
	}
	return 0;
}

六、互斥锁和信号量

互斥锁，保证了只有一个进程能够使用这个驱动：

6.1、定义互斥锁

//定义互斥锁：
static	DECLARE_MUTEX(button_lock);

6.2、获得信号量：

open函数里面:
/*获取信号量*/ down(&button_lock);

6.3、释放信号量：

close函数里面：
//释放信号量 up(&button_lock);

七、阻塞和非阻塞方式：

1、阻塞
　　阻塞操作是指在执行设备操作时，托不能获得资源，则挂起进程直到满足操作所需的条件后再进行操作。被挂起的进程进入休眠状态（不占用cpu资源），从调度器的运行队列转移到等待队列，直到条件满足。
2、非阻塞
非阻塞操作是指在进行设备操作是，若操作条件不满足并不会挂起，而是直接返回或重新查询（一直占用CPU资源）直到操作条件满足为止。

• 总的来说，我们可以让多个进程来调用这个驱动，但是，我们也可以采用阻塞方式来设置
• 

7.1、open函数里面判断阻塞

	if(file->f_flags & O_NONBLOCK)
	{
		if(down_trylock(&button_lock))//无法获取信号量，返回busy
			return -EBUSY;
	}
	else
	{
		/*获取信号量*/
		down(&button_lock);
	}

7.2、read函数里面判断阻塞

	if(file->f_flags & O_NONBLOCK)
	{
		//非阻塞立即重新执行
		if(!ev_press)
			return -EAGAIN;
	}
	else	//如果是阻塞
	{
		/* 如果没有按键动作，休眠*/
		wait_event_interruptible(button_waitq,ev_press);
	}

7.3、测试函数：

int main(int argc, char **argv)
{
	unsigned char key_val;
	int ret;
	int oflags;
	//fd = open("/dev/buttons", O_RDWR );这个是阻塞方式
	fd = open("/dev/buttons", O_RDWR | O_NONBLOCK);//非阻塞方式
	if (fd < 0)
	{
		printf("can't open!\n");
		return -1;
	}
	while(1)
	{
		ret = read(fd,&key_val,1);
		printf("keyval :0x %x,ret :%d\n",key_val,ret);
		sleep(5);
	}
	return 0;
}