Linux驱动——应用程序和驱动程序的交互机制[查询，休眠唤醒(中断、线程)，poll、异步通知]

已于 2022-06-12 19:41:27 修改
阅读量2.6k 收藏 18
点赞数 2
分类专栏： boot、Linux驱动、ARM 文章标签： linux 交互
于 2021-12-07 17:17:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cha1290878789/article/details/121701254
版权

在Linux系统中应用层和驱动层之间的交互方式有多种：查询、休眠、poll、和异步通知。
查询方式（非阻塞方式）：
查询方式就是通过简单的应用层和驱动层之间交互的一种方式，应用层以非阻塞的方式打开设备文件；
在应用程序中如果使用open打开一个设备文件，就会在当前进程里分配一个file结构体；
应用层使用open函数以非阻塞的方式打开一个文件方式如下：在这里插入图片描述
底层驱动fileoperation结构体中的read和write函数中第一个参数就是应用层在打开该设备文件时在进程中分配的file结构体，在这个file结构体中会将应用层open中flag相关参数设置进去，在驱动的read和write函数中可以根据file结构体中的相关信息进行完善驱动代码。
在这里插入图片描述
在这里插入图片描述
以查询的方式进行应用层和底层进行交互，如果应用层不断调用read函数此时CPU占用较高是一种耗费资源的方式。
以总线设备驱动模型的驱动按键代码为例，设备信息在设备树中进行定义：
设备树中添加的代码

Key{
		conpatible = "board_Key_control";
		gpios = <&gpio4 1 GPIO_ACTIVE_HIGH>;
}

Key_drv.c

#include <linux/module.h>
#include <linux/poll.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <asm/current.h>
//主设备号
static int major = 0;
//创建设备类的结构体
static struct class Key_Class;
//用于从设备树中记录设备信息的结构体
static struct gpio_desc Key_device;

static ssize_t Key_read(struct file *file, char __user *buf, size_t size, loff_t *offset)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		int val = gpiod_get_value(&Key_device);   //获取gpio发送过来的数据

		int len;

		if(size < 4){
			len = size;
		}else{
			len = 4;
		}

		copy_to_user(buf, &val, size);         //将获取的数据传送至应用层
		
		return len;
}

static struct file_operations Key_control_fops = {
		.owner = THIS_MODULE,
		.read = Key_read,
};



static int Key_probe(struct platform_device *pdev)    //驱动程序和设备树中含有conpatible的设备匹配成功后调用此函数
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		
		Key_device = gpiod_get(pdev->dev, NULL, 0);        //记录设备信息放置在全局结构体Key_device中   
		gpiod_direction_input(Key_device);                 //设置方向
		
		device_create(Key_Class, NULL, MKDEV(major,0), NULL, "/dev/key_control");    //创建设备节点，在此是可以让驱动和设备匹配成功后创建设备节点，不用再入口函数中进行初始化。

}

static int Key_remove(struct platform_device *pdev)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		device_destroy(Key_Class, MKDEV(major,0));                       //销毁在probe中创建的设备
}

static const struct of_device_id board_control[] = {             //用于匹配所有总线设备中与该驱动相匹配的设备
    { .compatible = "board_Key_control" },                       //对应到设备树中的设备节点设置的conpatible属性
    { },
};

static struct platform_driver  Key_platform_drv = {             //总线驱动结构体
	.probe      = Key_probe,
    .remove     = Key_remove,
    .driver     = {
        .name   = "key_control",
        .of_match_table = board_control,                        //对需要匹配的设备进行定义
    },
};

static int __init Key_drv_init(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		major = register_chrdev(0,"key_control",&Key_control_fops);         //注册字符设备驱动

		Key_Class = class_create(THIS_MODULE, "key_class");                  //创建对应设备的类

		if (IS_ERR(Key_Class)) {
			printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
			unregister_chrdev(major, "key_control");
			return PTR_ERR(Key_Class);
		}

		int err = platform_driver_register(&Key_platform_drv);                //注册总线驱动

		return err;
}

static void __exit Key_drv_exit(void)                                  //出口函数
{
		platform_driver_unregister(&Key_platform_drv);               //卸载总线驱动
		class_destroy(&Key_Class);                                   //销毁类，device_destroy是在总线驱动结构体的remove中调用
		unregister_chrdev(major, "key_control");					 //卸载字符设备驱动
}


module_init(Key_drv_init);
module_exit(Key_drv_exit);

MODULE_LICENSE("GPL");

在jz2440中进行验证：
应用程序：

#include <fcntl.h>
#include <stdio.h>
#include <unsitd.h>
int main(int argc,char **argv)
{

	int fd;
	int val = 0;
	int time = 0;
	fd = open("/dev/led",O_RDWR);

	if(fd<0){
		printf("open faile\n");
	}else{
		printf("open success\n");
	}
	while(1){
		read(fd,&val,4);
		printf("val = %d\n",val);
		time++;
		if(time == 20){
			break;
		}
	}
	return 0;
}

驱动程序：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>

static int major = 0;
static struct class *led_class;
static struct class_device	*firstdrv_class_dev;


volatile unsigned long *gpfcon =NULL;
volatile unsigned long *gpfdat =NULL;

volatile unsigned long *gpgcon =NULL;
volatile unsigned long *gpgdat =NULL;


static int led_driver_open(struct inode * inode,struct file *file)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	*gpfcon &= ~(  (0x3) | (0x3<<(2*2))|(0x3<<(4*2)) |(0x3<<(5*2))|(0x3<<(6*2)));   //GPIOF对应LED位清零
	*gpfcon |=  ( (0x1<<(4*2)) |(0x1<<(5*2))|(0x1<<(6*2)));    //对应位配置为输出

	*gpgcon &= ~((0x3<<(2*3)) | (0x3<<(11*2)));  
	
	*gpfdat |= (1<<4) | (1<<5) |(1<<6);
	//*gpfdat &= ~((1<<4) | (1<<5) |(1<<6)) ;

	return 0;
}



static 	ssize_t led_driver_read(struct file *file,const char __user *buf,size_t size,loff_t *ppos)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		int val = 1;
		int regfval = *gpfdat;
		int reggval = *gpgdat;
		
		if(!(regfval & (1<<0))){   //判断那个按键被按下
			*gpfdat &= ~(1<<4);
			val = 1;
		}else if(!(regfval & (1<<2))){
			*gpfdat &= ~(1<<5);
			val = 2;
		}else if(!(reggval  & (1<<11))){
			*gpfdat &= ~(1<<6);
			val = 3;
		}else if(!(reggval  & (1<<3))){
			*gpfdat |= (1<<4) | (1<<5) |(1<<6);
			val = 0;
		}

	
		copy_to_user(buf,&val,4);
		return 0;
}

static struct file_operations led_drv_fops = {
	.owner = THIS_MODULE,
	.open = led_driver_open,
	.read = led_driver_read,
};


static int __init led_drv_init(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		major = register_chrdev(0, "led_driver", &led_drv_fops);

		led_class = class_create(THIS_MODULE,"led_class");
		firstdrv_class_dev = class_device_create(led_class, NULL, MKDEV(major,0), NULL, "led");
		gpfcon = (volatile unsigned long *)ioremap(0x56000050,16);
		gpfdat = gpfcon+1;

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

		return 0;
}

static void __exit led_drv_exit(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		iounmap(gpfcon);
		iounmap(gpfdat);
		iounmap(gpgdat);
		iounmap(gpgdat);

		class_device_unregister(firstdrv_class_dev);
		class_destroy(led_class);
		unregister_chrdev(major, "led_driver");
}


module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");

使用top命令查看cpu使用情况
在这里插入图片描述

休眠唤醒方式：
使用休眠和唤醒方式，应用层在打开设备文件时可以不添加阻塞的flag，此时默认为阻塞方式打开，阻塞标记位被保存在file结构体中。
在对应的read中使用wait_event_interruptible函数可以使用户态当前任务进入到休眠状态，等待被唤醒，其他任务按照顺序运行，休眠的任务不占用CPU资源。唤醒休眠任务需要使用到wake_up_interruptible函数进行唤醒，唤醒的时候
wait_event_interruptible函数中第一个参数是用来将当前任务放置在队列中，第二个参数是用来判断条件是否成立。
在这里插入图片描述
在这里插入图片描述
如果需要唤醒使用wake_up_interruptible函数对休眠进行唤醒，从队列中将任务唤醒，这样驱动程序就可以继续执行wait_event_interrputible函数之后的内容：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
使用休眠唤醒方式进行应用层和驱动层之间的交互，驱动程序以阻塞的方式打开，当调用wait_event_interruptible函数时就会将用户态进程上下文对应的任务进行休眠，并将任务放入等待队列中。当有驱动程序使用wake_up函数时内核态就会继续从之前调用wait_event_interruptible函数之后继续运行。用户态之前被休眠的任务也会开始运行，但是该任务并不一定是立即执行，有可能是等其他任务运行之后再运行。相比于查询方式，使用休眠唤醒方式进行应用层和驱动层进行交互可以程序在阻塞时长时间占用CPU资源的情况。
key_drv.c

#include <linux/module.h>
#include <linux/poll.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <asm/current.h>

static int major = 0;

static int has_data = 0;    //等待时间条件

static int irq;             //中断号

static struct class *key_class;

static struct gpio_desc *key_dev;

static wait_queue_head_t key_wq;      //等待队列

static ssize_t key_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		int val;
		int len;
		
		wait_event_interruptible(key_wq, has_data);      //休眠，等待唤醒
		val = gpiod_get_value(key_dev);                  //读取GPIO信息
		
		copy_to_user(buf, &val, size);
		has_data= 0;                                    //将唤醒条件复位

		if(size>=4){
			len = 4;
		}else{
			len = size;
		}
		
		return len;
}

static irqreturn_t key_isr(int irq, void *dev_id)                        //中断服务函数
{
		
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		has_data = 1;                                                    //置位中断条件

		wake_up(&key_wq);                                                //唤醒队列

		return IRQ_HANDLED;
}

static struct file_operations  drv_fops= {
	.owner = THIS_MODULE,
	.read = key_drv_read,
};

static int key_driver_probe(struct platform_device *pdev)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		key_dev = gpiod_get(pdev->dev,NULL, 0);   
		gpiod_direction_input(key_dev);

		irq = gpiod_to_irq(key_dev);                                //获取中断号

		

		request_irq(irq, key_isr, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "key_inter", NULL);         //注册中断
		device_create(key_class, NULL, MKDEV(major,0), 0, "/dev/key");                                    

		return 0;
}

static int key_driver_remove(struct platform_device *pdev)
{
		
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		device_destroy(key_class, MKDEV(major,0));

		free_irq(irq, NULL);

		gpiod_put(key_dev);
		
}


static const struct of_device_id key_drv_dev[] = {
	{ .compatible = "key_drv", },
	{}
};

static struct platform_driver key_plat_drv = {
	.probe      = key_driver_probe,
    .remove     = key_driver_remove,
    .driver     = {
        .name   = "board_key_driver",
        .of_match_table = key_drv_dev,
    },
};

static int __init key_drv_init(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		major = register_chrdev(0, "key_driver", &drv_fops);

		key_class = class_create(THIS_MODULE, "key_drv_class");

		init_waitqueue_head(&key_wq);                             //初始化等待队列

		platform_driver_register(&key_plat_drv);

		return 0；
}

static void __exit gpio_key_exit(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		platform_driver_unregister(&key_plat_drv);

		class_destroy(key_class);
		unregister_chrdev(major, "key_driver");
}


module_init(key_drv_init);
module_exit(key_drv_exit);
MODULE_LICENSE("GPL");

使用jz2440验证中断功能
应用程序

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
int main(int argc,char **argv)
{

	int fd;
	int val = 0;
	int time = 0;
	fd = open("/dev/led",O_RDWR);

	if(fd<0){
		printf("open faile\n");
	}else{
		printf("open success\n");
	}
	while(1){
		read(fd,&val,4);
		printf("val = %d\n",val);
		time++;
		if(time == 20){
			break;
		}
	}
	return 0;
}

驱动程序

#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 <asm/arch/regs-gpio.h>
#include <asm/hardware.h>

static int major = 0;
static struct class *led_class;
static struct class_device	*firstdrv_class_dev;
static int has_data = 0;

volatile unsigned long *gpfcon =NULL;
volatile unsigned long *gpfdat =NULL;

volatile unsigned long *gpgcon =NULL;
volatile unsigned long *gpgdat =NULL;

static DECLARE_WAIT_QUEUE_HEAD(key_pin_que);


static struct pin_des{
	unsigned int pin;
	unsigned int val;
};

static struct pin_des key_pin[4] = {
		{S3C2410_GPF0,0x01},
		{S3C2410_GPF2,0x02},
		{S3C2410_GPG3,0x03},
		{S3C2410_GPG11,0x04},
};

static irqreturn_t irq_ser(int irq,void *dev_id)
{
	 
	if(!s3c2410_gpio_getpin(S3C2410_GPF0)){   //低电平表示被按下
			has_data = 1;
			
	}else if(!s3c2410_gpio_getpin(S3C2410_GPF2)){   //低电平表示被按下
			has_data = 2;
	}else if(!s3c2410_gpio_getpin(S3C2410_GPG3)){   //低电平表示被按下
			has_data = 3;
	}else if(!s3c2410_gpio_getpin(S3C2410_GPG11)){   //低电平表示被按下
			has_data = 4;
	}else{
			has_data = 0;
	}

	wake_up(&key_pin_que);
	return IRQ_RETVAL(IRQ_HANDLED);
}

static int led_driver_open(struct inode * inode,struct file *file)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
/*	*gpfcon &= ~(  (0x3) | (0x3<<(2*2))|(0x3<<(4*2)) |(0x3<<(5*2))|(0x3<<(6*2)));   //GPIOF对应LED位清零
	*gpfcon |=  ( (0x1<<(4*2)) |(0x1<<(5*2))|(0x1<<(6*2)));    //对应位配置为输出

	*gpgcon &= ~((0x3<<(2*3)) | (0x3<<(11*2)));  
	
	*gpfdat |= (1<<4) | (1<<5) |(1<<6);
	//*gpfdat &= ~((1<<4) | (1<<5) |(1<<6)) ;
*/
	request_irq(IRQ_EINT0, irq_ser,IRQT_BOTHEDGE , "key_pin0", &key_pin[0]);
	request_irq(IRQ_EINT2, irq_ser,IRQT_BOTHEDGE , "key_pin2", &key_pin[1]);
	request_irq(IRQ_EINT11, irq_ser,IRQT_BOTHEDGE , "key_pin11", &key_pin[2]);
	request_irq(IRQ_EINT19, irq_ser,IRQT_BOTHEDGE , "key_pin19", &key_pin[3]);
	
	return 0;
}



static 	ssize_t led_driver_read(struct file *file,const char __user *buf,size_t size,loff_t *ppos)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		int val = 1;
		int regfval = *gpfdat;
		int reggval = *gpgdat;


		wait_event_interruptible(key_pin_que, has_data);
		switch(has_data){
			case 1:
				s3c2410_gpio_setpin(S3C2410_GPF4, 0);
				break;
			case 2:
				s3c2410_gpio_setpin(S3C2410_GPF5, 0);
				break;

			case 3:
				s3c2410_gpio_setpin(S3C2410_GPF6, 0);
				break;
			case 4:
				s3c2410_gpio_setpin(S3C2410_GPF4, 1);
				s3c2410_gpio_setpin(S3C2410_GPF5, 1);
				s3c2410_gpio_setpin(S3C2410_GPF6, 1);
				break;
		}
		
/*		
		if(!(regfval & (1<<0))){
			*gpfdat &= ~(1<<4);
			val = 1;
		}else if(!(regfval & (1<<2))){
			*gpfdat &= ~(1<<5);
			val = 2;
		}else if(!(reggval  & (1<<11))){
			*gpfdat &= ~(1<<6);
			val = 3;
		}else if(!(reggval  & (1<<3))){
			*gpfdat |= (1<<4) | (1<<5) |(1<<6);
			val = 0;
		}
*/
	
		copy_to_user(buf,&has_data,4);

		has_data = 0;
		return 0;
}

static int led_driver_close(struct inode *inode, struct file *file)
{
		free_irq(IRQ_EINT0,&key_pin[0]);
		free_irq(IRQ_EINT2,&key_pin[1]);
		free_irq(IRQ_EINT11,&key_pin[2]);
		free_irq(IRQ_EINT19,&key_pin[3]);
		return 0;
}


static struct file_operations led_drv_fops = {
	.owner = THIS_MODULE,
	.open = led_driver_open,
	.read = led_driver_read,
	.release = led_driver_close,
};


static int __init led_drv_init(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		major = register_chrdev(0, "led_driver", &led_drv_fops);

		led_class = class_create(THIS_MODULE,"led_class");
		firstdrv_class_dev = class_device_create(led_class, NULL, MKDEV(major,0), NULL, "led");
	
		gpfcon = (volatile unsigned long *)ioremap(0x56000050,16);
		gpfdat = gpfcon+1;
		gpgcon = (volatile unsigned long *)ioremap(0x56000060,16);
		gpgdat = gpgcon+1;

		return 0;
}

static void __exit led_drv_exit(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		iounmap(gpfcon);
		iounmap(gpfdat);
		iounmap(gpgdat);
		iounmap(gpgdat);

		class_device_unregister(firstdrv_class_dev);
		class_destroy(led_class);
		unregister_chrdev(major, "led_driver");
}


module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");

使用cat/proc/interrupt查看中断信息：
在这里插入图片描述
使用ps指令查看程序运情况：
在这里插入图片描述
使用top指令查看cpu使用情况：
在这里插入图片描述

如果单板不支持中断时，可以使用内核线程来对休眠线程进行唤醒，在内核线程中不断查询设置相关装态，满足条件后使用wake_up函数对休眠的线程进行唤醒：

#include <linux/module.h>
#include <linux/poll.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <asm/current.h>
#include <linux/kthread.h>

static int major = 0;

static struct class *Remote_Control_Class;

static struct gpio_desc *Key_device;

static int has_data = 0;

static wait_queue_head_t Key_wq;

static struct task_struct *remote_thread;    //创建线程函数返回的结构体

static ssize_t remote_control_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
		wait_event_interruptible(Key_wq, has_data);

		int val = gpiod_get_value(Key_device);
		copy_to_user(buf, &val, 4);

		has_data = 0;

		if(size<4){
			return size;
		}

		return 4;
}


static struct file_operations remote_control_fops = {
			.owner = THIS_MODULE,
			.read = remote_control_read,
}

static int remote_control_probe(struct platform_device *pdev)
{
		*Key_device = gpiod_get(pdev->dev, NULL, 0);

		device_create(Remote_Control_Class, NULL, MKDEV(major,0), NULL, "/dev/remote_control");
		
		return 0;
}

static int remote_control_remove(struct platform_device *pdev)
{
		gpiod_put(Key_device);

		device_destroy(Remote_Control_Class, MKDEV(major,0));
}


static const struct of_device_id board_device[] = {
    { .compatible = "remote_control_device" },
    { },
};


static struct platform_driver plat_drv = {
		.probe		= remote_control_probe,
		.remove     = remote_control_remove,
	    .driver     = {
	        .name   = "board_control",
	        .of_match_table = board_device,
	    },
}

static int kthread_func(void *data)
{
	int data = 0;
	while(!kthread_should_stop(void)){                        //为了让线程可以stop必须加kthread_should_stop(void)
		data = gpiod_get_value(Key_device);
		if(data != 0){
			has_data = 0x08 | data;
			wake_up(&Key_wq);
		}
		set_current_state(TASK_INTERRUPTIBLE);                //schedule_timeout可以运行的前提是设置了当前线程状态
		schedule_timeout(HZ/50);                               //延时
	}

	return 0;
}


static int __init Remote_drv_init(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		major = register_chrdev(0, "remote_control", const struct file_operations * fops);

		Remote_Control_Class = class_create(THIS_MODULE, "remote_control_class");
		
		init_waitqueue_head(&Key_wq);

		remote_thread = kthread_run(kthread_func,NULL,"remote_control_d");          //创建线程

		platform_driver_register(&plat_drv);

		return 0;
}

static void __exit Remote_drv_exit(void)
{
	platform_driver_unregister(&plat_drv);

	kthread_stop(remote_thread);                   //线程停止

	class_destroy(Remote_Control_Class);

	unregister_chrdev major, "remote_control");
}


module_init(Remote_drv_init);
module_exit(Remote_drv_exit);

MODULE_LICENSE("GPL");

poll方式
在poll方式中，驱动程序中需要对fileoperation结构体中的poll函数指针进行初始化。使用poll方式进行交互，任务也会休眠，但是该任务的休眠并不是发生驱动层而是发生内核文件系统中的sys_poll中。在sys_poll中首先会进入到一个循环中，调用到驱动程序中file_operation中定义的poll函数，获取该函数返回的设备状态，然后判断设备状态以及是否超时，当设备状态满足条件或者超时就会返回用户态，否则就会进入休眠，将线程挂到队列中。sys_poll如果进入到休眠期有两种唤醒方式，一种是因超时被内核自动唤醒，另一种是中断服务程序中有使用wake_up_interruptible函数对挂起的线程进行唤醒，进入到下一次循环，调用驱动程序中的poll函数获取设备状态，此时设备状态满足条件立即返回值用户态。
在驱动程序的poll函数中会做两件事情，一个是将线程挂入队列，但是不会进行休眠操作，另一个是返回设备状态由内核文件系统sys_poll取读取设备状态进行判断。

驱动程序中的poll函数：
在这里插入图片描述
在这里插入图片描述
应用程序：
首先设置相关参数：
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
系统调用poll和select都对应底层驱动程序中的poll函数。休眠和唤醒方式在等待时间发生时可能会等待很久，并且在这段时间并不知道底层的运行情况，但是使用poll机制时就会给等待某一事件的时间加上一个期限，这样在等待事件发生时就有两种方式进行唤醒，一种是等待超时由内核自动唤醒，另一种是事件发生使用wake_up_interruptible函数对任务进行唤醒。
在应用程序中调用poll其中对应的事件如下：
在这里插入图片描述

在jz2440中进行验证：
驱动程序：

#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 <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>


static int major = 0;
static struct class *led_class;
static struct class_device	*firstdrv_class_dev;


volatile unsigned long *gpfcon =NULL;
volatile unsigned long *gpfdat =NULL;

volatile unsigned long *gpgcon =NULL;
volatile unsigned long *gpgdat =NULL;

static int has_data = 0;

static DECLARE_WAIT_QUEUE_HEAD(key_pin_que);


static struct pin_des{
	unsigned int pin;
	unsigned int val;
};

static struct pin_des key_pin[4] = {
		{S3C2410_GPF0,0x01},
		{S3C2410_GPF2,0x02},
		{S3C2410_GPG3,0x03},
		{S3C2410_GPG11,0x04},
};

static irqreturn_t irq_ser(int irq,void *dev_id)
{
	 
	if(!s3c2410_gpio_getpin(S3C2410_GPF0)){   //低电平表示被按下
			has_data = 1;
	}else if(!s3c2410_gpio_getpin(S3C2410_GPF2)){   //低电平表示被按下
			has_data = 2;
	}else if(!s3c2410_gpio_getpin(S3C2410_GPG3)){   //低电平表示被按下
			has_data = 3;
	}else if(!s3c2410_gpio_getpin(S3C2410_GPG11)){   //低电平表示被按下
			has_data = 4;
	}else{
			has_data = 0;
	}

	wake_up(&key_pin_que);
	return IRQ_RETVAL(IRQ_HANDLED);
}

static int led_driver_open(struct inode * inode,struct file *file)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
/*	*gpfcon &= ~(  (0x3) | (0x3<<(2*2))|(0x3<<(4*2)) |(0x3<<(5*2))|(0x3<<(6*2)));   //GPIOF对应LED位清零
	*gpfcon |=  ( (0x1<<(4*2)) |(0x1<<(5*2))|(0x1<<(6*2)));    //对应位配置为输出

	*gpgcon &= ~((0x3<<(2*3)) | (0x3<<(11*2)));  
	
	*gpfdat |= (1<<4) | (1<<5) |(1<<6);
	//*gpfdat &= ~((1<<4) | (1<<5) |(1<<6)) ;
*/
	request_irq(IRQ_EINT0, irq_ser,IRQT_BOTHEDGE , "key_pin0", &key_pin[0]);
	request_irq(IRQ_EINT2, irq_ser,IRQT_BOTHEDGE , "key_pin2", &key_pin[1]);
	request_irq(IRQ_EINT11, irq_ser,IRQT_BOTHEDGE , "key_pin11", &key_pin[2]);
	request_irq(IRQ_EINT19, irq_ser,IRQT_BOTHEDGE , "key_pin19", &key_pin[3]);
	
	return 0;
}



static 	ssize_t led_driver_read(struct file *file,const char __user *buf,size_t size,loff_t *ppos)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		int val = 1;
		int regfval = *gpfdat;
		int reggval = *gpgdat;


		wait_event_interruptible(key_pin_que, has_data);
		switch(has_data){
			case 1:
				s3c2410_gpio_setpin(S3C2410_GPF4, 0);
				break;
			case 2:
				s3c2410_gpio_setpin(S3C2410_GPF5, 0);
				break;

			case 3:
				s3c2410_gpio_setpin(S3C2410_GPF6, 0);
				break;
			case 4:
				s3c2410_gpio_setpin(S3C2410_GPF4, 1);
				s3c2410_gpio_setpin(S3C2410_GPF5, 1);
				s3c2410_gpio_setpin(S3C2410_GPF6, 1);
				break;
		}
		
/*		
		if(!(regfval & (1<<0))){
			*gpfdat &= ~(1<<4);
			val = 1;
		}else if(!(regfval & (1<<2))){
			*gpfdat &= ~(1<<5);
			val = 2;
		}else if(!(reggval  & (1<<11))){
			*gpfdat &= ~(1<<6);
			val = 3;
		}else if(!(reggval  & (1<<3))){
			*gpfdat |= (1<<4) | (1<<5) |(1<<6);
			val = 0;
		}
*/
	
		copy_to_user(buf,&has_data,4);

		has_data = 0;
		return 0;
}

static int led_driver_close(struct inode *inode, struct file *file)
{
		free_irq(IRQ_EINT0,&key_pin[0]);
		free_irq(IRQ_EINT2,&key_pin[1]);
		free_irq(IRQ_EINT11,&key_pin[2]);
		free_irq(IRQ_EINT19,&key_pin[3]);
		return 0;
}

static int led_driver_poll(struct file *file,poll_table *wait)
{
	unsigned int mask = 0;

	poll_wait(file,&key_pin_que, wait);    //将应用线程挂起到队列，但不是立即挂起
	if(has_data){                          
		mask = POLLIN |POLLRDNORM;         //当有按键按下是立即返回POLLIN
	}

	return mask;
}


static struct file_operations led_drv_fops = {
	.owner = THIS_MODULE,
	.open = led_driver_open,
	.read = led_driver_read,
	.release = led_driver_close,
	.poll = led_driver_poll,
};


static int __init led_drv_init(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		major = register_chrdev(0, "led_driver", &led_drv_fops);

		led_class = class_create(THIS_MODULE,"led_class");
		firstdrv_class_dev = class_device_create(led_class, NULL, MKDEV(major,0), NULL, "led");

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

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

static void __exit led_drv_exit(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		iounmap(gpfcon);
		iounmap(gpfdat);
		iounmap(gpgdat);
		iounmap(gpgdat);
		
		class_device_unregister(firstdrv_class_dev);
		class_destroy(led_class);
		unregister_chrdev(major, "led_driver");
}


module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");

应用程序：

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <poll.h>

struct pollfd fds[1];     //设置poll中等待的fd集合

int main(int argc,char **argv)
{

	int fd;
	int val = 0;
	int time = 0;
	int poll_ret;
	fd = open("/dev/led",O_RDWR);

	if(fd<0){
		printf("open faile\n");
		return -1;
	}else{
		printf("open success\n");
	}

	fds[0].fd = fd;            //设置文件描述符
	fds[0].events = POLLIN;    //设置为有数据可读的事件
	
	while(1){
		poll_ret = poll(fds,1,5000);    
		if(poll_ret == 0){      //当poll返回为0时表示等待超时
			printf("time_out\n");
		}else{                  //返回值不为零表示有对应的event事件发生
			read(fd,&val,4);    //对应event来read或者write
			printf("val = %d\n",val);
		}
	}
	return 0;
}

程序运行情况：
在这里插入图片描述
cpu占用情况：
在这里插入图片描述

异步通知方式
应用层使用异步通知方式步骤：
1.注册信号处理函数signal
2.打开驱动程序
3.将进程PID传给底层驱动程序

fcntl(fd,F_SETOWN,getpid());

4.设置flag为FASYNC，启动异步通知功能

Oflags = fcntl(fd,F_GETFL);
fcntl(fd,F_SETFL,fkags|FASYNC);

注册信号处理函数：
在这里插入图片描述
在这里插入图片描述

将pid和flag传给底层驱动程序，并设置异步通知功能
在这里插入图片描述
这样应用层就可以执行其他的任务等待底层发送信号执行异步通知。当接收到信号的时候就会执行信号处理函数。
步骤3和4都会在内核文件系统中的sys_fcntl中对pid以及flag进行赋值，然后调用驱动程序中的fcntl函数将值传入到底层驱动中。

驱动层需要对fileoperation中的fasync函数指针进行初始化，在函数中调用fasync_helper函数来获取应用层传过来的pid和flag，根据flag是否是FASYNC判断是否为异步通知。底层如果想向上层发送信号，可以使用kill_fasync函数。当上层收到底层发送的信号后就可以执行应用层注册的信号处理函数，在信号处理函数中可以去read底层信息。
在这里插入图片描述
在这里插入图片描述
其中fasync_helper函数中的button_fasync结构体如下：
在这里插入图片描述
在这里插入图片描述
底层驱动向上层应用层发送信号，如果button_fasync结构体中的file结构体不为空则取出pid发送信号
在这里插入图片描述
在这里插入图片描述
以jz2440作为验证：
驱动程序：

#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 <asm/arch/regs-gpio.h>
#include <asm/hardware.h>

static int major = 0;
static struct class *led_class;
static struct class_device	*firstdrv_class_dev;


volatile unsigned long *gpfcon =NULL;
volatile unsigned long *gpfdat =NULL;

volatile unsigned long *gpgcon =NULL;
volatile unsigned long *gpgdat =NULL;

static int has_data = 0;

static DECLARE_WAIT_QUEUE_HEAD(key_pin_que);

static struct fasync_struct *led_driver_fasync_queue;

static struct pin_des{
	unsigned int pin;
	unsigned int val;
};

static struct pin_des key_pin[4] = {
		{S3C2410_GPF0,0x01},
		{S3C2410_GPF2,0x02},
		{S3C2410_GPG3,0x03},
		{S3C2410_GPG11,0x04},
};

static irqreturn_t irq_ser(int irq,void *dev_id)
{
	 
	if(!s3c2410_gpio_getpin(S3C2410_GPF0)){   //低电平表示被按下
			has_data = 1;
			
	}else if(!s3c2410_gpio_getpin(S3C2410_GPF2)){   //低电平表示被按下
			has_data = 2;
	}else if(!s3c2410_gpio_getpin(S3C2410_GPG3)){   //低电平表示被按下
			has_data = 3;
	}else if(!s3c2410_gpio_getpin(S3C2410_GPG11)){   //低电平表示被按下
			has_data = 4;
	}else{
			has_data = 0;
	}

	kill_fasync(&led_driver_fasync_queue, SIGIO, POLL_IN);     //向应用程序发送信号
	
	wake_up(&key_pin_que);
	return IRQ_RETVAL(IRQ_HANDLED);
}

static int led_driver_open(struct inode * inode,struct file *file)
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
/*	*gpfcon &= ~(  (0x3) | (0x3<<(2*2))|(0x3<<(4*2)) |(0x3<<(5*2))|(0x3<<(6*2)));   //GPIOF对应LED位清零
	*gpfcon |=  ( (0x1<<(4*2)) |(0x1<<(5*2))|(0x1<<(6*2)));    //对应位配置为输出

	*gpgcon &= ~((0x3<<(2*3)) | (0x3<<(11*2)));  
	
	*gpfdat |= (1<<4) | (1<<5) |(1<<6);
	//*gpfdat &= ~((1<<4) | (1<<5) |(1<<6)) ;
*/
	request_irq(IRQ_EINT0, irq_ser,IRQT_BOTHEDGE , "key_pin0", &key_pin[0]);
	request_irq(IRQ_EINT2, irq_ser,IRQT_BOTHEDGE , "key_pin2", &key_pin[1]);
	request_irq(IRQ_EINT11, irq_ser,IRQT_BOTHEDGE , "key_pin11", &key_pin[2]);
	request_irq(IRQ_EINT19, irq_ser,IRQT_BOTHEDGE , "key_pin19", &key_pin[3]);
	
	return 0;
}



static 	ssize_t led_driver_read(struct file *file,const char __user *buf,size_t size,loff_t *ppos)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		int val = 1;
		int regfval = *gpfdat;
		int reggval = *gpgdat;


		wait_event_interruptible(key_pin_que, has_data);
		switch(has_data){
			case 1:
				s3c2410_gpio_setpin(S3C2410_GPF4, 0);
				break;
			case 2:
				s3c2410_gpio_setpin(S3C2410_GPF5, 0);
				break;

			case 3:
				s3c2410_gpio_setpin(S3C2410_GPF6, 0);
				break;
			case 4:
				s3c2410_gpio_setpin(S3C2410_GPF4, 1);
				s3c2410_gpio_setpin(S3C2410_GPF5, 1);
				s3c2410_gpio_setpin(S3C2410_GPF6, 1);
				break;
		}
		

		copy_to_user(buf,&has_data,4);

		has_data = 0;
		return 0;
}

static int led_driver_close(struct inode *inode, struct file *file)
{
		free_irq(IRQ_EINT0,&key_pin[0]);
		free_irq(IRQ_EINT2,&key_pin[1]);
		free_irq(IRQ_EINT11,&key_pin[2]);
		free_irq(IRQ_EINT19,&key_pin[3]);
		return 0;
}


static int led_driver_fasync(int fd, struct file *file, int on)    //对led_driver_fasync_queue结构体进行初始化
{
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	return fasync_helper(fd, file, on, &led_driver_fasync_queue);       //获取应用层传来的pid和falg并初始化led_driver_fasync_queue中
}


static struct file_operations led_drv_fops = {
	.owner = THIS_MODULE,
	.open = led_driver_open,
	.read = led_driver_read,
	.release = led_driver_close,
	.fasync = led_driver_fasync,
};


static int __init led_drv_init(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);

		major = register_chrdev(0, "led_driver", &led_drv_fops);

		led_class = class_create(THIS_MODULE,"led_class");
		firstdrv_class_dev = class_device_create(led_class, NULL, MKDEV(major,0), NULL, "led");
		gpfcon = (volatile unsigned long *)ioremap(0x56000050,16);
		gpfdat = gpfcon+1;

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

		return 0;
}

static void __exit led_drv_exit(void)
{
		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
		iounmap(gpfcon);
		iounmap(gpfdat);
		iounmap(gpgdat);
		iounmap(gpgdat);

		class_device_unregister(firstdrv_class_dev);
		class_destroy(led_class);
		unregister_chrdev(major, "led_driver");
}


module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");

应用程序：

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <signal.h>

int fd;

void sig_function(int signum)     //信号处理函数，驱动层有信号发送过来的时候就执行该函数
{
		int val;
		read(fd,&val,4);
		printf("val = %d\n",val);

		
}

int main(int argc,char **argv)
{


	int val = 0;
	int time = 0;
	int Oflag;
	
	fd = open("/dev/led",O_RDWR);

	signal(SIGIO,sig_function);     //注册信号

	fcntl(fd,F_SETOWN,getpid());   //将进程id号给到驱动程序

	Oflag = fcntl(fd,F_GETFL);     //获取当前的flag

	fcntl(fd,F_SETFL,Oflag | FASYNC);  //设置为异步通知的flag

	if(fd<0){
		printf("open faile\n");
	}else{
		printf("open success\n");
	}
	while(1){
		
	}
	return 0;
}

Linux单板的中断方式：
中断处理流程：
1.设置中断控制器
2.注册中断处理函数
3.保存现场
4.调用中断处理函数
5.恢复现场

异常虽然与中断处理流程一致，但是中断可以被屏蔽，而异常不能被屏蔽；

中断发生后的过程：发生中断后CPU会指向中断向量表，保存现场，执行中断处理函数，恢复现场。其中保存和恢复现场都是内核实现的，但是执行中断处理函数是由开发人员提供的对应函数。
在驱动中编写中断函数时需要使用到request_irq函数取注册驱动；
第一个参数为中断号，第二个参数为中断处理函数，第三个参数为标志位，第四个为名字，第五个为设备。其中最为重要的就是中断号和中断处理函数。
在这里插入图片描述

值得一提的是现在的底层中断驱动程序通常采用GIC协议，在内核代码中的设备树可以看到中断是会分级的，下面以树莓派使用的bcm2835和imx6ull作为例子。
在树莓派设备树中：在gpio作为中断源时其上层节点为soc节点，soc节点的父中断为intc，intc会向cpu发送一条中断信息。
在这里插入图片描述
在imx6ull的设备树中可以看到：gpio作为中断源其上层节点是soc节点，soc的父中断是gpc，gpc的父中断是intc，然后intc会向cpu发送一个中断信息。
在这里插入图片描述
在设备树中可以设置中断信息，可以不了解整个中断的层级过程，但是必须要指明中断的父节点。

learned_from：韦东山

基尔霍夫原来是码农
关注
  • 2
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hook与IoCallDriver与IofCallDriver
fengkuangfj的专栏
03-08 3380
用途之一：从内核层保护文件不被删除 IoCallDriver：一个内核例程，过滤所有的系统请求 NTSTATUS IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp ); IofCallDriver：在IoCallDriver中调用的一个例程，几乎所有的内核驱动都调用了IofCallDr
s3c2440驱动设计和应用程序综合设计
02-25
1.基于s3c2440的led驱动设计、驱动...4.基于s3c2440的中断poll驱动设计、驱动调用应用程序设计； 5.基于s3c2440的异步中断驱动设计、驱动调用应用程序设计； 6.基于s3c2440的中断阻塞驱动设计、驱动调用应用程序设计；
驱动和应用数据交互四种方式
nihaoma95278的博客
01-02 564
如果条件不满足，poll机制会使应用程序休眠指定时间，休眠时间内条件满足则唤醒进程。如果条件一直不满足，达到指定超时时间后，进程自动唤醒再次判断条件是否满足。：这是一种非阻塞的方式，应用程序通过查询方式与底层驱动交互。如果应用层不断调用read函数，CPU占用较高，是一种耗费资源的方式。：应用程序注册信号处理函数，驱动程序在特定事件发生时发送信号给应用程序。：当条件不满足时，应用程序会休眠，等待条件满足时被唤醒。这种方式可能会导致应用程序一直休眠下去，如果条件一直不满足。
阐述嵌入式系统的基本组成：硬件层、驱动层、操作系统层和应用层
最新发布
D_ovis的博客
04-14 1447
硬件抽象层将操作系统内核、上层应用程序与硬件进行隔离，提供统一的软件接口，使得上层应用开发无需关心具体的硬件组成。应用层软件根据具体的应用需求进行开发，如数字相框的应用层需要支持图像的加载和显示、文件管理、用户交互等功能。总的来说，嵌入式系统的这四个层次各自扮演着重要的角色，它们共同构成了一个完整、高效的嵌入式系统。从硬件到应用，每一层都为系统的稳定运行和高效执行提供了必要的支持和保障。操作系统的选择对于嵌入式系统的性能和稳定性至关重要，常见的嵌入式操作系统包括Linux、RTOS等。
【Linux驱动】休眠与唤醒 | POLL机制 | 异步通知 | 阻塞与非阻塞 | 软件定时器
weixin_63726869的博客
01-22 1798
讲解了休眠与唤醒，POLL机制，异步通知，阻塞与非阻塞的使用，大概原理和注意事项。还介绍了软件定时器在按键消抖中的使用。
LINUX应用和驱动交互的四种方式
站在技术的肩膀上看世界
01-28 960
驱动和应用的同步模式简介
【IMX6ULL驱动开发学习】04.应用程序和驱动程序数据传输和交互的4种方式：非阻塞、阻塞、POLL、异步通知
阿龙的博客
08-09 1971
应用程序和驱动程序数据传输和交互的4种方式：非阻塞、阻塞、POLL、异步通知
uClinux设备驱动程序的设计与编写
08-03
每个步骤都需要精确无误，以确保驱动程序能够正确地与硬件交互，并为上层应用程序提供稳定的服务。通过以上介绍，读者应该对uClinux设备驱动的编写有了更清晰的认识，但这只是基础，实际的驱动开发还需要结合具体的...
i.MX6ULL实现非阻塞IO访问【Linux驱动】.zip
02-21
在Linux环境下，驱动程序是连接硬件和操作系统的关键组件，它允许操作系统控制和管理硬件资源。非阻塞I/O（Non-blocking I/O）是一种优化I/O操作的方法，特别适用于处理大量并发连接的情况，如网络服务器或实时数据...
树莓派按键驱动和用户侧程序
07-26
- `mybutton_irq_fasync_user.c`、`mybutton_irq_poll_user.c`和`mybutton_irq_read_user.c`：用户侧程序，分别对应于中断+异步通知、中断+轮询和中断+read的触发方式。 编写这样的驱动程序通常包括以下步骤： 1. ...
STM32MP135实现非阻塞IO访问【支持STM32MP1系列单片机_Linux驱动】.zip
04-28
通过以上知识点的掌握和实践，开发者可以编写出高效的STM32MP135 Linux驱动程序，充分利用其硬件资源，为各种应用提供流畅的非阻塞I/O访问。提供的代码项目应包含驱动程序的源码、编译脚本以及相关文档，方便开发者...
linux内核线程睡眠与唤醒
热门推荐
luckywang1103的专栏
08-22 1万+
这里以内核usb gadget driver中f_mass_storage驱动为例子进行说明。static int sleep_thread(struct fsg_common *common) { int rc = 0;/* Wait until a signal arrives or we are woken up */ for (;;) { try_to_freeze(); s
Linux系统调用怎么和内核或底层驱动交互的 inode struct file
u014426028的博客
04-22 1010
学习Linux系统下驱动程序开发已有大半年时间，心中一直有个疑惑：那就是诸如open、write、read等系统调用是怎么和 内核或底层驱动建立起联系的呢？今天将自己的一些粗略的理解总结如下。 学过Linux系统下驱动程序开发的都知道，大部分的基础性的驱动操作都包括3个重要的内核数据结构，称为file_operations，file，和inode。我们需要对这些结构有个基...
linux驱动之阻塞与休眠
qq_40684669的博客
11-09 506
在休眠与唤醒的基础上, 获取应用程序意图(阻塞读取/非阻塞读取), 来决定是否休眠
【Linux】内核中休眠与唤醒的使用（wait_event、wake_up）
ZHONGCAI0901的博客
09-19 1万+
文章目录1. 前言2. 休眠和唤醒内核函数介绍3. 使用休眠与唤醒的驱动框架4. 编写测试程序 1. 前言 在wait_event_interruptible()函数中会将当前进程的状态设置成TASK_INTERRUPTIBLE，然后调用schedule()，它会将位于TASK_INTERRUPTIBLE状态的进程从run queue队列中删除。从run queue队列中删除的结果是，当前这个进程将不再参与调度，除非通过其他将这个进程重新放入run queue队列中，wake_up()函数就是这个作用。 由
线程的休眠、状态和安全问题
qq_52463861的博客
10-31 507
线程的休眠、状态和安全问题
嵌入式linux驱动学习之应用层数据如何和驱动层数据进行交互
m0_57730390的博客
07-14 1212
linux驱动学习之应用层数据和内核层数据的互通
linux应用与驱动之间的通讯--驱动篇
weixin_46537240的博客
07-18 923
对于非阻塞，驱动程序在应用程序调用read时，提供驱动程序的drv_read,所以主要判断传入的参数，在drv_read函数中，判断file->flag是否为O_NONBLOCK即可。首先我们要明白，应用程序是不能直接操作内核的，由于写应用程序的人水平参差不齐，又或是动机不良，直接允许应用程序操作内核是件危险的事。对于阻塞，只要传入的flag不为O_NONBLOCK即可，当无数据时，程序会进入休眠，直到被唤醒。④当有数据时，比如当按下按键时，驱动程序的中断服务程序被调用，它会记录数据、唤醒APP；...
Linux系统调用怎么和内核或底层驱动交互的
02-28 978
学习Linux系统下驱动程序开发已有大半年时间，心中一直有个疑惑：那就是诸如open、write、read等系统调用是怎么和内核或底层驱动建立起联系的呢？今天将自己的一些粗略的理解总结如下。 学过Linux系统下驱动程序开发的都知道，大部分的基础性的驱动操作都包括3个重要的内核数据结构，称为file_operations，file，和inode。我们需要对这些结构有...
临时文件_录完整章再合并进全集文档__第19章_驱动程序基石1
08-03
第 19 章 驱动程序基石19.1 休眠与唤醒19.1.1 适用场景在前面引入中断时，我们曾经举过一个例子：妈妈怎么知道卧室里小孩醒了？① 时不时进房间看一下：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值