特殊按键--休眠键驱动

最新推荐文章于 2023-10-10 20:18:45 发布
最新推荐文章于 2023-10-10 20:18:45 发布
阅读量1.9k 收藏 1
点赞数 1
分类专栏： linux 设备驱动 文章标签： 内核文件操作 内核线程 等待队列 异步通知
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/williamwang2013/article/details/8664486
版权
这是一个关于休眠和关机的按键驱动。板子：pxa31X系列  内核：2.6.25
这个驱动用到了内核文件操作，内核线程，等待队列，异步通知，并介绍了一种调试驱动的方法。 
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/syscalls.h>
#include <linux/unistd.h>
#include <linux/miscdevice.h>
#include <linux/platform_device.h>
#include <linux/uaccess.h>
#include <linux/string.h>
#include <asm/arch/pxa-regs.h>
#include <asm/arch/pxa3xx-regs.h>
#include <asm/arch/mfp-pxa300.h>
#include <asm/arch/gpio.h>
#include <asm/uaccess.h>    //用于内核线程
#include <linux/irq.h> 
#include <linux/interrupt.h>
#include <linux/ioctl.h>
#include <linux/sched.h>
#include <linux/kthread.h>
#include <linux/errno.h>
#include <linux/spinlock.h>
#include <linux/mutex.h>
#include <linux/wait.h>
#include <asm/semaphore.h>

#include "pmb.h"

#define PB_DEVICE_NAME "william_pmb"            

//#define DEBUG
#ifdef DEBUG
	#define pr_debug(fmt, arg...) printk(KERN_DEBUG fmt, ##arg)
#else
	#define pr_debug(fmt, arg...) printk(KERN_INFO fmt, ##arg)
#endif
/*
用于调试驱动的一种方法。
其中printk函数中的参数，定义于<linux/kernel.h>。
#define	KERN_EMERG	"<0>"	/* system is unusable紧急事件消息，系统崩溃前提示，表示系统不可用*/
#define	KERN_ALERT	"<1>"	/* action must be taken immediately	报告消息，表示必须马上采取措施*/
#define	KERN_CRIT	"<2>"	/* critical conditions临界情况，通常用于涉及严重的硬件或软件操作失败*/
#define	KERN_ERR	"<3>"	/* error conditions错误情况，驱动程序常用来报告硬件错误*/
#define	KERN_WARNING	"<4>"	/* warning conditions警告，对可能出现问题的情况进行警告*/
#define	KERN_NOTICE	"<5>"	/* normal but significant condition正常但又重要的情况，常用于提醒与安全相关的消息*/
#define	KERN_INFO	"<6>"	/* informational提示信息*/
#define	KERN_DEBUG	"<7>"	/* debug-level messages调试级别消息*/
*/

/*硬件上的一些定义*/
#define PECR_E0IS	(1 << 29)	// EXT_WAKEUP<0> Interrupt Status
#define PECR_E0IE	(1 << 28)	// EXT_WAKEUP<0> Pin Interrupt Enable
#define PECR_DIR0(1 << 4)	//Direction for EXT_WAKEUP<0>: 0/1= input/output
#define PECR_IVE0	(1 << 0)	//Input Value for EXT_WAKEUP<0>

//Currently we have
#define IRQ_WAKEUP0	PXA_IRQ(49)	/* EXT_WAKEUP0 */
#define IRQ_WAKEUP1	PXA_IRQ(50)	/* EXT_WAKEUP1 */

//一个重要的全局结构体
static struct powerkey_t pwk;
/*
struct powerkey_t 
{	
	int ifopen;	    //check if device is opened
	unsigned int pressed;	    //current key state		[0/1=release/press]
	int event;	//event:	    [0/1/2/3=narmal/sleep/deepsleep/wakeup]
	wait_queue_head_t keywaitq;	    //powerkey queue
	struct tast_struct *p_thread;
	int checkforsleep;	    //check if which event for sleep
	int ifhandshake;	    //check if need to handshake with app[]
	int handshake;
	struct fasync_struct *pwrkey_async_queue;
	int ifreleasehandshakecnt;	    //0: you can release handshake. >0: can't release handshake	
};
*/

static int pb_handshake(int sig,int mode);

static int wakeup_init(void)
{	
	PECR |= PECR_E0IE;	//enable wakeup0 interrupt
	PECR &= ~PECR_DIR0;	//as input
	return 0;
}

static int disable_wakeup(void)
{	
	PECR &= ~PECR_E0IE;	//disable wakeup0 interrupt
	return 0;
}

static int wakeup_ack_irq(void)
{	
	PECR |= PECR_E0IS;	//interrupt state, write 1 to clear
	return 0;
}


static int pb_sleep_exe(int sleep)
{
	int ret;
	struct file *fd;
	mm_segment_t old_fs;
	//printk("%s\n",__FUNCTION__);
	
	fd = filp_open("sys/power/state",O_RDWR,0);
	if(IS_ERR(fd))
	{
		printk("Open sys/power/state fail,ret = %ld \n",IS_ERR(fd));
		return -1;
	}
	old_fs = get_fs();
	set_fs(KERNEL_DS);
	switch(sleep)
	{
		case SLEEP_EVENT:
			printk("sleep!\n");
			ret = fd->f_op->write(fd,"mem",3,&fd->f_pos);
			if(ret != 3)
			{
				printk("Write to sleep fail!\n");
			}
			//printk("sleep write ok!\n");
			break;
		case DEEPSLEEP_EVENT:
			ret = fd->f_op->write(fd,"deepsleep",9,&fd->f_pos);
			if(ret != 9)
			{
				printk("Write to deepsleep fail!\n");
			}
			break;
		default:
			break;
	}
	set_fs(old_fs);
	filp_close(fd ,NULL);
	
	return 0;
}
/*
内核文件操作
strcut file* filp_open(const char* filename, int open_mode, int mode);
该函数返回strcut file*结构指针，供后继函数操作使用，该返回值用IS_ERR()来检验其有效性。

操作之前先要定位
void set_fs(mm_segment_t fs);
该函数的作用是改变kernel对内存地址检查的处理方式，其实该函数的参数fs只有两个取值：USER_DS，KERNEL_DS，分别代表用户空间和内核空间
get_fs();    取得当前的设置
off_t sys_lseek(unsigned int fd, off_t offset, unsigned int origin)
offset是偏移量。
若origin是SEEK_SET(0)，则将该文件的位移量设置为距文件开始处offset 个字节。
若origin是SEEK_CUR(1)，则将该文件的位移量设置为其当前值加offset, offset可为正或负。
若origin是SEEK_END(2)，则将该文件的位移量设置为文件长度加offset, offset可为正或负。

ret = fd->f_op->write(fd,"mem",3,&fd->f_pos);    文件读写函数

最后关闭文件 int filp_close(struct file*filp, fl_owner_t id);
*/

static int wait_wakeup_handshake(void)
{
	int ret;
	struct powerkey_t *ppwk = &pwk;

	//printk("%s\n",__FUNCTION__);
	ppwk->event = WAKEUP_EVENT;
	if(ppwk->ifopen > NOOPENED)	
	{
		if(ppwk->ifhandshake == REQUESTHANDSHAKE)	
		{
			if(pb_handshake(SIGIO,POLL_IN))
			{
				printk("Posting Handshake fail\n");
				return -1;
			}
			else
			{
				ppwk->handshake = NONEEDHANDSHAKE;
				ret = wait_event_interruptible_timeout(ppwk->keywaitq, ppwk->handshake == HANDSHAKE_EVENT_OK, (20*HZ));
				if( ret == 0)
				{
					printk("Wake up handshake timeout\n");
				}
			}
		}
		else	
		{
			ppwk->handshake = NONEEDHANDSHAKE;
			ret = wait_event_interruptible_timeout(ppwk->keywaitq, ppwk->handshake == HANDSHAKE_EVENT_OK, (20*HZ));
			if( ret == 0)
			{
				printk("Wake up handshake timeout\n");
			}
		}
	}
	ppwk->handshake = NONEEDHANDSHAKE;
	
	return 0;
}


static irqreturn_t extwakeup_handle(int irq, void *dev_id)
{
	int readreg;
	struct powerkey_t *ppwk = &pwk;
	//printk("%s\n",__FUNCTION__);
	
	wakeup_ack_irq();
	
	readreg = PECR;		
	if(readreg & PECR_IVE0)
	{
		//printk("key is pressed !\n");
		ppwk->checkforsleep = NEEDCHECKSLEEP;
		ppwk->pressed = KEYPRESSED;	
	}
	else
	{
		//printk("key released!\n");
		ppwk->pressed = KEYRELEASE;
	}
	wake_up_interruptible(&ppwk->keywaitq);
	wakeup_ack_irq();
	return IRQ_HANDLED;
}


static int pb_irq_init(void)
{
	int err;
	//printk("%s\n",__FUNCTION__);

	err = request_irq(IRQ_WAKEUP0, &extwakeup_handle,NULL,
				  "ext_wakeup0_detect", NULL);
	
	return err;
}

static int preevent_sleep(const int sleepevent)
{
	int ret;
	struct powerkey_t *p = &pwk;
	
	if(sleepevent == DEEPSLEEP_EVENT)
	{
		if(p->ifopen > NOOPENED)	
			ret = wait_event_interruptible_timeout(p->keywaitq, p->pressed == KEYRELEASE, (3*HZ));
		disable_wakeup();
		wakeup_ack_irq();		
	}


	if(p->ifopen > NOOPENED)
	{
		p->handshake = NONEEDHANDSHAKE;
		ret = wait_event_interruptible_timeout(p->keywaitq, p->handshake == HANDSHAKE_EVENT_OK, (20*HZ));
		if( ret == 0)
		{
			printk("Handshake timeout\n");
		}
		p->handshake = NONEEDHANDSHAKE;
	}

	if(sleepevent == DEEPSLEEP_EVENT)
        {
		wakeup_init();
        wakeup_ack_irq();	
	}

	pb_sleep_exe(sleepevent);
	wait_wakeup_handshake();


	return 0;
}


static int wait_handshake_sleep(int sleepevent)
{
	int ret;
	struct powerkey_t *p = &pwk;
	
	p->event = sleepevent;
	if(p->ifhandshake == REQUESTHANDSHAKE)
	{	//for signal mode
		if(pb_handshake(SIGIO,POLL_IN))
		{
			printk("Posting Handshake fail\n");
			return -1;	
		}
		ret = preevent_sleep(sleepevent);
	}
	else	//for polling mode
	{
		ret = preevent_sleep(sleepevent);
	}
	
	return 0;
}
/*
wait_event_interruptible_timeout(queue, condition, timeout)
使用例如：
(1)初始化等待队列
int flags = 0;
wait_queue_head_t    select_wait;
init_waitqueue_head(&select_wait);
(2)等待事件的发生（条件满足）
{
...
    wait_event_interruptible_timeout(select_wait, flags != 0, HZ/10);
...
}
(3)唤醒等待队列
{
...
   if(waitqueue_active(&select_wait))
   {
       flags = 1;
       wake_up_interruptible( &nd->select_in_wait );
   }
...
}    
*/

static int driver_data_init(void)
{
	struct powerkey_t *ppwk = &pwk;
	
	if(PECR & PECR_IVE0)
	{
		ppwk->pressed = KEYPRESSED;
	}
	else
	{
		ppwk->pressed = KEYRELEASE;
	}
	ppwk->ifopen = NOOPENED;
	ppwk->event = NORMAL_EVENT;
	ppwk->handshake = NONEEDHANDSHAKE;
	ppwk->checkforsleep = NONEEDCHECKSLEEP;
	ppwk->ifhandshake = FREEHANDSHAKE;
	ppwk->ifreleasehandshakecnt = 0;
	init_waitqueue_head(&ppwk->keywaitq);
	return 0; 
}

static int powerkey_thread(void *data)
{
	struct powerkey_t *ppwk = &pwk;
	long ret;
//	unsigned long flags;

	//printk("%s\n",__FUNCTION__);
	
	while(!kthread_should_stop())
	{
		set_current_state(TASK_INTERRUPTIBLE);
		//if(kthread_should_stop()) break;
		while(ppwk->checkforsleep == NEEDCHECKSLEEP)
		{
			ret = wait_event_interruptible_timeout(ppwk->keywaitq, ppwk->pressed == KEYRELEASE, (2*HZ));
			if(ret == 0)
			{	//time out
				//disable_wakeup0_int();
				//wakeup0_ack_irq();
				ret = wait_handshake_sleep(DEEPSLEEP_EVENT);
				ppwk->checkforsleep = NONEEDCHECKSLEEP;
				//wakeup0_init();
				//wakeup0_ack_irq();
			}
			else
			{
				disable_wakeup();
				wakeup_ack_irq();
				ret = wait_handshake_sleep(SLEEP_EVENT);
				ppwk->checkforsleep = NONEEDCHECKSLEEP;
				wakeup_init();
				wakeup_ack_irq();
			}
		}
		
		//schedule_timeout();
		ret = wait_event_interruptible_timeout(ppwk->keywaitq, ppwk->checkforsleep == NEEDCHECKSLEEP, (2*HZ));
	}
	printk("%s exit!\n",__FUNCTION__);
	return 0;
}


static int create_powerkey_thread(void)
{
	struct powerkey_t *ppwk = &pwk;
	//printk("%s\n",__FUNCTION__);
	ppwk->p_thread = kthread_run(&powerkey_thread,NULL,"powerkey_thread");
	if(ppwk->p_thread == NULL)
	{
		printk("%s failed\n",__FUNCTION__);
		return -1;
	}
	return 0;
}

static void delete_powerkey_thread(void)
{
	struct powerkey_t *ppwk = &pwk;
	//printk("%s\n",__FUNCTION__);
	if(ppwk->p_thread)
	{
		kthread_stop(ppwk->p_thread);
	}
	ppwk->p_thread = NULL;
}
/*
struct task_struct *kthread_create(int (*threadfn)(void *data),void *data,const char *namefmt, ...);
线程创建后，不会马上运行，而是需要将kthread_create() 返回的task_struct指针传给wake_up_process()，然后通过此函数运行线程。
struct task_struct *kthread_run(int (*threadfn)(void *data),void *data,const char *namefmt, ...);    创建并启动线程
int kthread_stop(struct task_struct *thread);
线程一旦启动起来后，会一直运行，除非该线程主动调用do_exit函数，或者其他的进程调用kthread_stop函数，结束线程的运行
kthread_should_stop()函数，我们需要在开启的线程中嵌入该函数并检查此函数的返回值，否则kthread_stop是不起作用的
类似，我们也可以创建其他几条线程。
*/

static int pb_fasync(int fd,struct file* filp,int mode)
{
	struct powerkey_t *ppwk = &pwk;
	//printk("%s\n",__FUNCTION__);
	ppwk->ifhandshake = REQUESTHANDSHAKE;
	ppwk->ifreleasehandshakecnt++;
	return fasync_helper(fd,filp,mode,&ppwk->pwrkey_async_queue);
}


static int pb_handshake(int sig,int mode)
{
	struct powerkey_t *ppwk = &pwk;
	//printk("%s\n",__FUNCTION__);
	if(ppwk->pwrkey_async_queue)
	{
		kill_fasync(&ppwk->pwrkey_async_queue,sig,mode);
		return 0;
	}
	//printk("%s failed.no async_queue\n",__FUNCTION__);
	return -1;
}


static void release_fasync(struct file *file)
{
	int ret;
	struct powerkey_t *p = &pwk;
	//printk("%s\n",__FUNCTION__);
	
	if(p->ifreleasehandshakecnt != 0)
		p->ifreleasehandshakecnt--;

	if(p->ifhandshake == REQUESTHANDSHAKE)	//have
	{
		if(p->ifreleasehandshakecnt == 0)
		{
			ret = fasync_helper(-1,file,0,&p->pwrkey_async_queue);
			printk("%s fasync_helper ret=%d\n",__FUNCTION__,ret);
			if(p->pwrkey_async_queue)
			{
				p->pwrkey_async_queue = NULL;
			}
			p->ifhandshake = FREEHANDSHAKE;
		}
	}
}
/*
异步通知：一旦设备就绪，则主动通知应用程序，不需要查询。
设备驱动中异步通知比较简单，主要用到fasync_struct结构体，还有下面两个函数。
int fasync_helper(int fd, struct file *filp, int mode, struct fasync_struct **fa);   处理FASYNC标志变更的函数。记得要释放
void kill_fasync(struct fasync_struct **fa, int sig, int band);    释放信号用的函数
sig信号用的最多的是SIGIO，可读时band设置为POLL_IN，可写时band设置为POLL_OUT。
*/

int pb_open(struct inode *inode,struct file *filp)
{
	struct powerkey_t *p = &pwk;
	p->ifopen++;
	return 0;
}

int pb_release(struct inode *inode,struct file *filp)
{
	struct powerkey_t *p = &pwk;
	
	if(p->ifopen > NOOPENED)
		p->ifopen--;
	release_fasync(filp);    //处理FASYNC标志
	return 0;
}
/*
static ssize_t pb_read(struct file *filp,char *buf,size_t size,loff_t *ppos)    
{	
	return 0;
}

static ssize_t pb_write(struct file *filp,const char *buf,size_t size,loff_t *ppos)
{
	return 0;
}
*/
static int pb_ioctl(struct inode *inodep,struct file *filp,unsigned int cmd,unsigned long arg)
{
	int ret = 0;
	struct powerkey_t *ppwk = &pwk;

	switch(cmd)
		{
			case HANDSHAKE_EVENT_OK:
				ppwk->handshake = HANDSHAKE_EVENT_OK;
				wake_up_interruptible(&ppwk->keywaitq);
				break;
			case GET_EVENT_STATE:
				if(copy_to_user((int *)arg,&ppwk->event,sizeof(ppwk->event)))
					{
						ret = -1;
					}
				else
					{
						ppwk->event = NORMAL_EVENT;
					}
				break;
			case FREE_HANDSHAKE_EVENT:
				release_fasync(filp);
				break;
			//case SUSPEND_EVENT:
				//break;
			default:
				break;
		}

	return 0;
}

static struct file_operations pb_fops = {
	.owner = THIS_MODULE,
	//.read = pb_read,
	//.write = pb_write,
	.ioctl = pb_ioctl,
	.open = pb_open,        
	.release = pb_release,
	.fasync	= pb_fasync,
};

static struct miscdevice pb_miscdev = {
	.minor = 100,    
	.name = PB_DEVICE_NAME,
	.fops = &pb_fops,
};    

static int pb_probe(struct platform_device *pdev)
{
	int ret;
	
	ret = misc_register(&pb_miscdev);

	wakeup_init();
	wakeup_ack_irq();
	ret = pb_irq_init();    //中断初始化
	if(ret)
		{
			misc_deregister(&pb_miscdev);
		}
	driver_data_init();
	ret = create_powerkey_thread();    //创建内核线程
	if(ret)
		{
			free_irq(IRQ_WAKEUP0,NULL);
			misc_deregister(&pb_miscdev);
		}
	
	return 0;
}

static int pb_remove(struct platform_device *pdev)
{
	int ret;
	struct powerkey_t *ppwk = &pwk;
	ret = wakeup_ack_irq();
	wake_up_interruptible(&ppwk->keywaitq);    //唤醒等待队列
	delete_powerkey_thread();    //干掉内核线程
	free_irq(IRQ_WAKEUP0, NULL);    //干掉中断
	
	misc_deregister(&pb_miscdev);
	return 0;
}

#ifdef CONFIG_PM       
static int pb_suspend(struct platform_device *pdev, pm_message_t state)
{	
	wakeup_ack_irq();
	disable_wakeup();
	free_irq(IRQ_WAKEUP0, NULL);
	return 0;
}

static int pb_resume(struct platform_device *pdev)
{
	pb_irq_init();
	return 0;
}
#else
#define pb_suspend NULL
#define pb_resume NULL
#endif

static struct platform_driver pb_driver = {
	.driver = {
		.name = "william_pmb",	    	
		},
	.probe = pb_probe,
	.remove = pb_remove,
	.suspend = pb_suspend,
	.resume = pb_resume,
};

static int __init pb_init(void)
{
	printk("hello pb !\n");
	return platform_driver_register(&pb_driver);
}

static void __exit pb_exit(void)
{
	platform_driver_unregister(&pb_driver);
	printk("bye pb !\n");
}

module_init(pb_init);  
module_exit(pb_exit); 

MODULE_AUTHOR("William Wang");  
MODULE_LICENSE("GPL");


williamwang2013
关注
专栏目录
从零开始之驱动发开、linux驱动（十四、字符驱动之按键中断方式实现和等待队列分析）
To_run_away的博客
09-15 1453
  第8节的轮询方式查询按键，非常的浪费CPU资源，这一节主要就是来解决这个问题的。 第12节的中断程序框架也给了出来，这一节我们来完成中断方式的代码实现和分析。   这节是通过使用等待队列的方式来解决CPU资源来等待信号浪费问题。 其主要原理是应用层读按键值，在驱动这边先先检查有没有按键事件发生，如果有则直接返回键值给应用程序。 如果没有，则把该内核进程加入到一个等待队列中（队列是一...
按键映射
coldsnow33的专栏
11-19 4554
1 键扫描码Scancode是由Linux的Input驱动框架定义的整数类型。 include/uapi/linux/input.h中有定义： ...... #define KEY_VOLUMEDOWN 114 #define KEY_VOLUMEUP 115 #define KEY_POWER 116 /* SC System Power Down */#define KEY_MENU
Linux驱动：休眠与唤醒
Yy
05-22 1723
当应用程序必须等待某个事件发生，比如必须等待按键被按下时，可以使用“休眠-唤醒”机制。 1. 休眠-唤醒流程 APP调用read等函数； APP进入内核态read函数，等待按键按下，开始休眠； 当按下按键时，驱动程序的中断服务程序被调用，它会读取按键值并唤醒APP； 驱动中read被唤醒，将按键值返回给应用层。 应用层read函数返回 2. 相关函数 参考内核源码：include\linux\wait.h 2.1 休眠函数 函数 说明 wait_event_interruptible(
LInux 从系统日志中找出系统关闭的原因
热门推荐
ArchitecTang的博客
09-13 1万+
排查Linux服务器故障时，通过排查系统日志查找系统宕机的原因，因为断电或因为过热导致的系统故障
【gpio_key按键驱动】
Sugar_wolf的博客
07-01 2525
【gpio_key按键驱动】
[Linux Device Driver] 组合按键
编程菜汝狗
10-16 1822
0. 背景 本文我已分享过同事，现在也分享给大家。 平台： SM6350、android 10、kernel version：msm-4.19 1. 代码 开机组合键需实现3个功能： 1. Power + Volume Up进入recovery模式 2. Power + Volume Down进入Fastboot模式 3. Power + Volume Up + Volume Down进入edl模式 2. 为啥这样改 这个是根据打印的log，然后改的，可能有的平台代码默认是好的。 代码路径： boo
使用gpio子系统实现按键驱动（二）
最新发布
滴水藏海
10-10 881
Linux内核下的drivers/input/keyboard/gpio_keys.c实现了一个体系无关的GPIO按键驱动，使用此按键驱动，只需要在设备树gpio-key节点添加需要的按键子节点即可，适合于实现独立式按键驱动。gpio-keys是基于input架构实现的一个通用gpio按键驱动，该驱动基于platform_driver架构，实现了驱动和设备分离，符合linux设备驱动模型的思想。
android 按键,Android 7.0 Power 按键处理流程
weixin_29980355的博客
05-27 1077
Android 7.0 Power 按键处理流程Power按键的处理逻辑由PhoneWindowManager来完成，本文只关注PhoneWindowManager中与Power键相关的内容，其他系统按键的处理类似也是在PhoneWindowManager中处理的。理解了power按键的处理再看其他系统按键的逻辑会容易的多也简单的多。一、Power按键的上报Power按键的上报流程与其余的按键处...
ThinkVantageSystemUpdate507-2020-03-09.zip
04-02
"Thinkpad Hotkey 驱动"是ThinkPad特色功能之一，指的是那些通过键盘上的特殊按键实现特定功能的驱动程序。这些热键可以用于调整屏幕亮度、控制音量、开启无线网络等功能，极大地方便了用户。"ThinkVantage System ...
BF7615AMXX-MCU规格书V1.6-19-10-21.pdf
04-10
- 每个按键都能通过特殊的寄存器调节灵敏度。 - 提供JTAG调试仿真接口，方便开发和调试。 - 定时器2作为时钟源，支持多种外部晶振输入。 这些知识点详细描述了BF7615AMXX系列MCU的特性、功能、性能参数及系统...
Ubuntu 设置合上笔记本盖子不休眠的方法
qq_32201015的博客
10-15 6055
参考链接： https://blog.csdn.net/xiaoxiao133/article/details/82847936 编辑下列文件：sudo gedit /etc/systemd/logind.conf #HandlePowerKey按下电源键后的行为，默认power off #HandleSleepKey 按下挂起键后的行为，默认suspend #HandleHibernateKey按下休眠键后的行为，默认hibernate #HandleLidSwitch合上笔记本盖后的行为，一般为默认su
POWER KEY 的两种检测方法
kinbo88的专栏
05-19 2751
芯片平台：mdm9x07 第一种方法当然是用 input 事件 event。 /dev/input/event0 测试代码如下： #include "stdio.h" #include #include #include #include int main() { int keys_fd; //按键句柄 struct input_
长按power key的流程分析
lz99770337的博客
05-03 1152
本文是对长按power key的源码进行分析。 power key 事件的注册 <—-PhoneWindowManager.java—> 在该函数中对power key长按事件进行注册： private class PolicyHandler extends Handler{ ……… case MSG_POWER_LONG_PRESS: p
linux sleep 内核,linux内核是如何支持深度睡眠(deep sleep)方式的?
weixin_28851191的博客
04-30 220
1. 硬件架构arm642. 内核版本4.193. 分析相关函数get_set_conduit_method()->of_property_read_string(np, "method", &method))->set_conduit(PSCI_CONDUIT_HVC) 或set_conduit(PSCI_CONDUIT_SMC),根据设备树中的method属性来设定，设...
linux 休眠定时唤醒_物联网项目开发快速入门(十)：esp32 低功耗模式之深度休眠模式（deep sleep）...
weixin_39867559的博客
12-15 2527
概述对于一款芯片来说低功耗模式可以说是必须有的模式，而对于esp32这种wifi芯片来说低功耗可以说是重重之中，只有低功耗存在esp32才能被称的上是物联网芯片。ESP32 采用了高效、灵活的功耗管理技术，可以在功耗控制、唤醒延迟和不同唤醒源之间实现最佳平衡。ESP32支持5 种功耗模式，可以满足用户的不同场景需求。此外，ESP32 还支持超低功耗协处理器(ULP Coprocessor)控制，允...
对Linux系统休眠的理解
嵌入式驱动_凌阳教育
01-16 1577
出处 ： tekkamanninja.blog.chinaunix.net     今天看了一个关于中断例程为什么不能休眠的文章，引发了我的思考。其实这个问题在学习驱动的时候早就应该解决了，但是由于5年前学驱动的时候属于Linux初学者，能力有限，所以对这个问题就知其然，没有能力知其所以然。现在回头看这个问题的时候，感觉应该可以有一个较为清晰的认识了。 首先必须意识到：休眠是一种进程的特殊状
linux待机与休眠的命令和区别
zr_1877的博客
11-26 2204
区别：待机是挂起到内存，休眠是挂起到硬盘。 #待机的命令: sudo pm-hibernate #休眠的命令: sudo pm-suspend ￥重启的命令: sudo reboot 注:pm(power manager)。
【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()函数就是这个作用。 由
深入解析Android按键驱动开发
这些常量不仅包括常见的字母、数字键，还有功能键、特殊键如日语输入键、音量控制键等。每个按键都有一个唯一的整数标识，当用户按下或释放按键时，对应的值会被发送到输入子系统，进而传递给上层的Android系统。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值