中断脉冲触发设备休眠唤醒--输入子系统+中断机制+队列

场景 ： 使用GPIO_A 作为中断脚检测电平，下降沿触发中断。中断中实现休眠唤醒设备；
相关adb 命令：

getevent 查看输入设备

getevent -l /dev/input/event_n 查看输入设备n上报状态

input keyevent 26 :adb休眠命令
input keyevent KEYCODE_POWER ：adb休眠休眠命令

#include <linux/ioctl.h>
#include <linux/mm.h>
#include <asm/uaccess.h>
#include <linux/blkdev.h>
 

#include <linux/fs.h>
#include <linux/kdev_t.h>

#include <linux/string.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/seq_file.h>
#include <linux/kobject.h>
#include <linux/kobj_map.h>
#include <linux/cdev.h>
#include <linux/mutex.h>
#include <linux/backing-dev.h>
#include <linux/tty.h> 
#include <linux/kernel.h>
#include <linux/hrtimer.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/async.h>
#include <linux/irq.h>
#include <linux/workqueue.h>
#include <linux/proc_fs.h>
#include <linux/input/mt.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/moduleparam.h> 
#include <linux/init.h> 
#include <linux/kmod.h> 
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/debugfs.h>
#include <linux/kthread.h>
#include <asm/unaligned.h>
#include <linux/sched.h>//jiffies在此头文件中定义

static int debug = 4;
module_param(debug, int, S_IRUGO|S_IWUSR);

#define dbg_codec(level, fmt, arg...)		\
	do {					\
		if (debug >= level)		\
			printk(fmt , ## arg);	\
	 } while (0)

#define	DBG(fmt, ...)	dbg_codec(0, fmt, ## __VA_ARGS__)
#define CLONE_KERNEL    (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)

struct input_dev *input_dev = NULL;
int key_power_irq_num;
struct work_struct key_power_wq; //工作队列 
/*
0：代表当前在休眠状态
1：代表当前在工作状态
*/
int machine_status = 1;

 /*
	中断处理底半部
  */
void key_power_do_work(struct work_struct *work)
{	
	int val;

	/*当前状态为工作状态，切换为休眠*/
	if(machine_status == 1){
		//按键有效 ；0:休眠
		machine_status = 0;
		printk("000000000000000000000000\n");
		gpio_direction_output(RK30_PIN1_PB3,0);
		
		//KEY_SLEEP KEY_POWER
		input_report_key(input_dev, KEY_POWER, 1);
		input_sync(input_dev);
		input_report_key(input_dev, KEY_POWER, 0);
		input_sync(input_dev);
		
		msleep(1000);
		
	/* d当前状态为休眠状态，切换为工作*/
	}else if(machine_status == 0){
		//按键有效 ； 1:工作
		machine_status = 1;
		printk("11111111111111111111111\n");
		gpio_direction_output(RK30_PIN1_PB3,1);
		input_report_key(input_dev, KEY_WAKEUP, 1);
		input_sync(input_dev);
		input_report_key(input_dev, KEY_WAKEUP, 0);
		input_sync(input_dev);
		msleep(1000);
	}
	enable_irq(key_power_irq_num);
}
 
static irqreturn_t key_power_irq_handler(int irq, void *dev_id)
{
	printk("---------key_power_irq_handler-----------\n");
	
	disable_irq_nosync(key_power_irq_num);
	
	//DBG("%s :enter\n", __func__);

	//系统调度 调用底半部
	schedule_work(&key_power_wq);
	
	return IRQ_HANDLED;
}



static int power_key_init(void)
{
	int error = -1;
	static struct task_struct *task = NULL;
	printk("---------power_key_init-----------\n");
	
	//输出 RK30_PIN3_PD5  1b3  RK30_PIN1_PB3
	if (!gpio_is_valid(RK30_PIN1_PB3)){
        DBG("%s  gpio43 is unvalid \n", __func__);
    } 
	
	//输入 RK30_PIN1_PB2
	if (!gpio_is_valid(RK30_PIN1_PB2)){
        DBG("%s  gpio42 is unvalid \n", __func__);
    } 
	
	if (gpio_request(RK30_PIN1_PB3, NULL)) {
		DBG("%s  failed to request  irq-gpio, gpio_num =%d\n", __func__, 43);
    }
	
	if (gpio_request(RK30_PIN1_PB2, NULL)) {
		DBG("%s  failed to request  irq-gpio, gpio_num =%d\n", __func__, 42);
    }
	
	gpio_direction_input(RK30_PIN1_PB2);
	gpio_direction_output(RK30_PIN1_PB3,1);
	
	/* 中断号 */
	key_power_irq_num = gpio_to_irq(RK30_PIN1_PB2);   
	DBG("%s  key_power_irq_num=%d\n", __func__, key_power_irq_num);
	 
	//分配一个 input_dev 设备结构体，并且在 /sys/class/input/input-n 下创建设备属性文件
    input_dev = input_allocate_device();
	
	input_dev->name = "key-power";
	input_dev->phys = "key-power";

    input_dev->id.bustype = BUS_HOST;
    input_dev->id.vendor  = 1;
    input_dev->id.product = 1;
    input_dev->id.version = 1;
	
	/*
		设置支持的事件类型
	*/
	input_dev->evbit[0] = BIT_MASK(EV_KEY);
	
	/*
		设置支持的事件
	*/
	set_bit(KEY_POWER, input_dev->keybit);
	set_bit(KEY_WAKEUP, input_dev->keybit);
	
	/*
		注册输入设备
	*/
	error = input_register_device(input_dev);
	
	/*
		注册中断 IRQ_TYPE_LEVEL_LOW  IRQ_TYPE_EDGE_FALLING
	*/	 
	error = request_irq(key_power_irq_num, key_power_irq_handler, IRQ_TYPE_EDGE_FALLING, "key_power_irq", NULL);
	if (error) { 
		printk("request_irq error\n");
	}
	
	// 初始化工作队列
	INIT_WORK(&key_power_wq,key_power_do_work);
	
	printk("---------power_key_init over-----------\n");
	
	return 0;
}

static void  power_key_exit(void)
{
	input_unregister_device(input_dev);
	free_irq(key_power_irq_num, key_power_irq_handler);
}

module_init(power_key_init);
module_exit(power_key_exit);
MODULE_LICENSE("GPL");