示例#1
0
// for COOPER
static irqreturn_t gpiokey_irq_handler(int irq_in, void *dev_id)
{
	unsigned int key_status;
	struct gpio_kp *kp = dev_id;
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	unsigned short keyentry = KEY_HW_REV(0); // mi->keymap[0];
	unsigned short dev = keyentry >> MATRIX_CODE_BITS;

	key_status = gpio_get_value(GPIO_POWERKEY);

	if(key_status == 0) // 0 : press
	{
		key_pressed = 1;	
		input_report_key(kp->input_devs->dev[dev], KEY_END, 1);
		printk("key event (keycode:%d, pressed:%d)\n", KEY_END, 1);	//sec: sm.kim
	}
	else if (key_status == 1) // 1 : release
	{
		key_pressed = 0;	
		input_report_key(kp->input_devs->dev[dev], KEY_END, 0);
		printk("key event (keycode:%d, pressed:%d)\n", KEY_END, 0); //sec: sm.kim
#if defined(CONFIG_MACH_COOPER) || defined(CONFIG_MACH_BENI) || defined(CONFIG_MACH_TASS)
#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI4) || defined(CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI)
		TSP_forced_release_forkey();
#endif
#endif
	}

	return IRQ_HANDLED;

}
static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
{
	int ret;
	struct synaptics_ts_data *ts = i2c_get_clientdata(client);
	struct vreg *vreg_touch;
	printk("[TSP] %s+\n", __func__ );
	mutex_lock(&tsp_sleep_lock);
	if( touch_present )
	{

	vreg_touch = vreg_get(NULL, "ldo6");

	if (ts->use_irq)
	{
		disable_irq(client->irq);
	}
#if 0
	gpio_tlmm_config(GPIO_CFG( TSP_SCL, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP,GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	gpio_tlmm_config(GPIO_CFG( TSP_SDA, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP,GPIO_CFG_2MA), GPIO_CFG_ENABLE);
	gpio_tlmm_config(GPIO_CFG( TSP_INT, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP,GPIO_CFG_2MA), GPIO_CFG_ENABLE);
#endif

	gpio_set_value( TSP_SCL , 0 ); 
	gpio_set_value( TSP_SDA , 0 ); 
	gpio_set_value( TSP_INT , 0 ); 

	ret = cancel_work_sync(&ts->work);
	if (ret && ts->use_irq) /* if work was pending disable-count is now 2 */
	{
		enable_irq(client->irq);
	}

	cancel_delayed_work_sync(&ts->work_check_ic);

	ret = vreg_disable(vreg_touch);
	if (ret) {
		printk(KERN_ERR "%s: vreg enable failed (%d)\n",
				__func__, ret);
		return -EIO;
	}
	}
	else
		printk("[TSP] TSP isn't present.\n", __func__ );

	TSP_forced_release_forkey();

	mutex_unlock(&tsp_sleep_lock);
	printk("[TSP] %s-\n", __func__ );
	return 0;
}
static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
{
	int ret;
	struct synaptics_ts_data *ts = i2c_get_clientdata(client);
    
	printk("[TSP] %s+\n", __func__ );

	if(now_tst200_update_luisa == 0)
	{
		if (ts->use_irq)
		{
			disable_irq(client->irq);
		}

		if(touch_present == 1)
			hrtimer_cancel(&ts->timer);
		
		gpio_direction_output( TSP_INT , 0 );
		gpio_direction_output( TSP_SCL , 0 ); 
		gpio_direction_output( TSP_SDA , 0 ); 

		bcm_gpio_pull_up(TSP_INT, false);
		bcm_gpio_pull_up_down_enable(TSP_INT, true);

		#if USE_THREADED_IRQ
		
		#else
		ret = cancel_work_sync(&ts->work);
		
		if (ret && ts->use_irq) /* if work was pending disable-count is now 2 */
		{
			enable_irq(client->irq);
		}
		#endif

		msleep(20);

		touch_ctrl_regulator(TOUCH_OFF);

		if(g_touch_info_press == 1)
		{
			TSP_forced_release_forkey(ts);
		}
	}

	printk("[TSP] %s-\n", __func__ );
	return 0;
}
// for COOPER
static irqreturn_t gpiokey_irq_handler(int irq_in, void *dev_id)
{
	unsigned int key_status;
	struct gpio_kp *kp = dev_id;
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	unsigned short keyentry = mi->keymap[0];
	unsigned short dev = keyentry >> MATRIX_CODE_BITS;

	key_status = gpio_get_value(GPIO_POWERKEY);

	if(!power_off_done) {
		if(key_status == 0) // 0 : press
		{
#if defined(CONFIG_MACH_COOPER_BASE_KOR)
		power_key_pressed = 1;
#endif
			input_report_key(kp->input_devs->dev[dev], KEY_END, 1);
#ifdef CONFIG_KERNEL_DEBUG_SEC
			printk("key event (keycode:%d, pressed:%d)\n", KEY_END, 1);	//sec: sm.kim
#endif
			key_pressed = 1;
		}
		else if (key_status == 1) // 1 : release
		{
#if defined(CONFIG_MACH_COOPER_BASE_KOR)
		power_key_pressed = 0;
#endif
			input_report_key(kp->input_devs->dev[dev], KEY_END, 0);
#ifdef CONFIG_KERNEL_DEBUG_SEC
			printk("key event (keycode:%d, pressed:%d)\n", KEY_END, 0); //sec: sm.kim
#endif
			key_pressed = 0;
#if !defined(CONFIG_MACH_JUNO_SKT) && !defined(CONFIG_MACH_JUNO_KT)
#if defined(CONFIG_MACH_COOPER) || defined(CONFIG_MACH_BENI) || defined(CONFIG_MACH_TASS)
			TSP_forced_release_forkey();
#endif
#endif
		}
	}
	else
		printk("power_off_done : %d\n", power_off_done);

	return IRQ_HANDLED;

}
static void report_key(struct gpio_kp *kp, int key_index, int out, int in)
{
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	int pressed = test_bit(key_index, kp->keys_pressed);
	unsigned short keyentry = mi->keymap[key_index];
	unsigned short keycode = keyentry & MATRIX_KEY_MASK;
	unsigned short dev = keyentry >> MATRIX_CODE_BITS;

	if (pressed != test_bit(keycode, kp->input_devs->dev[dev]->key)) {
		if (keycode == KEY_RESERVED) {
#if defined(CONFIG_MACH_EUROPA)
			if ((mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS) && (board_hw_revision < 4))
#elif defined(CONFIG_MACH_CALLISTO)
			if ((mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS) && (board_hw_revision < 3))
#else
			if (mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS)
#endif			
				pr_info("gpiomatrix: unmapped key, %d-%d "
					"(%d-%d) changed to %d\n",
					out, in, mi->output_gpios[out],
					mi->input_gpios[in], pressed);
		} else {
			if (mi->flags & GPIOKPF_PRINT_MAPPED_KEYS)
				pr_info("gpiomatrix: key %x, %d-%d (%d-%d) "
					"changed to %d\n", keycode,
					out, in, mi->output_gpios[out],
					mi->input_gpios[in], pressed);
#if defined(CONFIG_MACH_EUROPA) || defined(CONFIG_MACH_CALLISTO)  || defined(CONFIG_MACH_COOPER) || defined(CONFIG_MACH_BENI) || defined(CONFIG_MACH_TASS) || defined(CONFIG_MACH_LUCAS)
			if(!power_off_done) {

#if defined(CONFIG_MACH_CALLISTO)
				if ((keycode == KEY_LEFTALT) && pressed)
					alt_key_pressed = 1;
				if ((keycode == KEY_LEFTALT) && !pressed)
					alt_key_pressed = 0;

				if ((alt_key_pressed) && (keycode == KEY_LEFT))
					printk("key (Alt + Down) pressed\n");
				else if ((alt_key_pressed) && (keycode == KEY_RIGHT))
					printk("key (Alt + Up) pressed\n");
				else
				{	
#endif
			input_report_key(kp->input_devs->dev[dev], keycode, pressed);
#if !defined(CONFIG_MACH_JUNO_SKT) && !defined(CONFIG_MACH_JUNO_KT)
#if defined(CONFIG_MACH_COOPER) || defined(CONFIG_MACH_BENI) || defined(CONFIG_MACH_TASS)
				if(keycode == KEY_HOME && pressed == 1)
					TSP_forced_release_forkey();
#endif
#endif
#if defined(CONFIG_MACH_CALLISTO)  || defined(CONFIG_MACH_COOPER)  || defined(CONFIG_MACH_BENI) || defined(CONFIG_MACH_TASS) || defined(CONFIG_MACH_LUCAS)
#ifdef CONFIG_KERNEL_DEBUG_SEC
				printk("key event (keycode:%d, pressed:%d), w=%d\n", 
						keycode, pressed, lcd_on_state_for_debug);	// sec: sm.kim
#endif						
						
#if defined(CONFIG_MACH_COOPER_BASE_KOR)
            if(pressed ==1 && (keycode == KEY_VOLUMEUP || keycode == KEY_VOLUMEDOWN))
             {
                 key_press_count = 0;
        			long_key_state = LONG_KEY_CHECK_ACTIVE;
             }
             else
              {
                 key_press_count = 0;
        			long_key_state = LONG_KEY_CHECK_INACTIVE;              
              }
#endif
		
#ifdef ATH_CLAIM_RELEASE_WAR
				if(!lcd_on_state_for_debug) 
				    ath_debug_sdio_claimer();
#endif
#else
#ifdef CONFIG_KERNEL_DEBUG_SEC
				printk("key event (keycode:%d, pressed:%d), wlan_debug_step=%d\n", 
						keycode, pressed, wlan_debug_step);	// sec: sm.kim
#endif						
#endif
#if defined(CONFIG_MACH_CALLISTO)
				}
#endif
				key_pressed = pressed;
			} else {
				printk("power_off_done : %d\n", power_off_done);
			}
#else
			input_report_key(kp->input_devs->dev[dev], keycode, pressed);
//			printk("key event (keycode:%d, pressed:%d), wlan_debug_step=%d\n", 
//					keycode, pressed, wlan_debug_step);	// sec: sm.kim
#ifdef CONFIG_KERNEL_DEBUG_SEC
			printk("key event (keycode:%d, pressed:%d)\n", keycode, pressed);	//sec: sm.kim
#endif			
#endif
		}
	}
}
static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
{
	int ret;
	struct synaptics_ts_data *ts = i2c_get_clientdata(client);
	struct vreg *vreg_touch;
	printk("[TSP] %s+\n", __func__ );

	vreg_touch = vreg_get(NULL, "maxldo06");

	if (ts->use_irq)
	{
		disable_irq(client->irq);
	}
#if 0
	gpio_configure( TSP_SCL, GPIOF_DRIVE_OUTPUT );
	gpio_configure( TSP_SDA, GPIOF_DRIVE_OUTPUT );
	gpio_configure( TSP_INT, GPIOF_INPUT );

	gpio_tlmm_config(GPIO_CFG( TSP_SCL, 0, GPIO_OUTPUT, GPIO_PULL_UP,GPIO_2MA), GPIO_ENABLE);
	gpio_tlmm_config(GPIO_CFG( TSP_SDA, 0, GPIO_OUTPUT, GPIO_PULL_UP,GPIO_2MA), GPIO_ENABLE);
	gpio_tlmm_config(GPIO_CFG( TSP_INT, 0, GPIO_OUTPUT, GPIO_PULL_UP,GPIO_2MA), GPIO_ENABLE);
#endif

	gpio_set_value( TSP_SCL , 0 ); 
	gpio_set_value( TSP_SDA , 0 ); 
	gpio_set_value( TSP_INT , 0 ); 

	ret = cancel_work_sync(&ts->work);
	if (ret && ts->use_irq) /* if work was pending disable-count is now 2 */
	{
		enable_irq(client->irq);
	}

#ifdef TOUCH_VERIFY_WITH_TIMER
	if(board_hw_revision >= 0x3) {
	cancel_delayed_work_sync(&ts->work_check_ic);
	}
#endif
	ret = vreg_disable(vreg_touch);
	if (ret) {
		printk(KERN_ERR "%s: vreg enable failed (%d)\n",
				__func__, ret);
		return -EIO;
	}

	TSP_forced_release_forkey();

#ifdef KEY_LED_CONTROL
	if(touchkey_led_on_off) {
		ret = key_led_power_control(FALSE);
		if (ret < 0) {
			printk(KERN_ERR "%s: vreg disable failed (%d)\n",__func__, ret);
		return -EIO;
		} else {
      			touchkey_led_on_off = 0;
		}
	}
#endif
	printk("[TSP] %s-\n", __func__ );
	return 0;
}
示例#7
0
static void report_key(struct gpio_kp *kp, int key_index, int out, int in)
{
	struct gpio_event_matrix_info *mi = kp->keypad_info;
	int pressed = test_bit(key_index, kp->keys_pressed);
	unsigned short keyentry = KEY_HW_REV(key_index); //mi->keymap[key_index];
	unsigned short keycode = keyentry & MATRIX_KEY_MASK;
	unsigned short dev = keyentry >> MATRIX_CODE_BITS;

	if (pressed != test_bit(keycode, kp->input_devs->dev[dev]->key)) {
		if (keycode == KEY_RESERVED) {
#if defined(CONFIG_MACH_EUROPA)
			if ((mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS) && (board_hw_revision < 4))
#elif defined(CONFIG_MACH_CALLISTO)
			if ((mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS) && (board_hw_revision < 3))
#else
			if (mi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS)
#endif			
				pr_info("gpiomatrix: unmapped key, %d-%d "
					"(%d-%d) changed to %d\n",
					out, in, mi->output_gpios[out],
					mi->input_gpios[in], pressed);
		} else {

			if(lcd_wake_flag==0) 
			{
				if(keycode==KEY_MENU || keycode==KEY_BACK) 
				{
					printk("lcd is off, so do not send menu or back key\n");
					return ;
				}
			} 
					
			if (mi->flags & GPIOKPF_PRINT_MAPPED_KEYS)
				pr_info("gpiomatrix: key %x, %d-%d (%d-%d) "
					"changed to %d\n", keycode,
					out, in, mi->output_gpios[out],
					mi->input_gpios[in], pressed);
#if defined(CONFIG_MACH_EUROPA) || defined(CONFIG_MACH_CALLISTO)  || defined(CONFIG_MACH_COOPER) || defined(CONFIG_MACH_BENI) || defined(CONFIG_MACH_TASS) || defined(CONFIG_MACH_LUCAS)
			if(!power_off_done) {
#if defined(CONFIG_MACH_LUCAS)
                                if ((keycode == KEY_LEFTALT) && pressed)
                                        alt_key_pressed = 1;
                                if ((keycode == KEY_LEFTALT) && !pressed)
                                        alt_key_pressed = 0;
 
                                if ((alt_key_pressed) && (keycode == KEY_LEFT))
                                        printk("key (Alt + LEFT) pressed\n");
                                else if ((alt_key_pressed) && (keycode == KEY_RIGHT))
                                        printk("key (Alt + RIGHT) pressed\n");
                                else if ((alt_key_pressed) && (keycode == KEY_DOWN))
                                        printk("key (Alt + DOWN) pressed\n");
                                else
                                {

#elif defined(CONFIG_MACH_CALLISTO)
				if ((keycode == KEY_LEFTALT) && pressed)
					alt_key_pressed = 1;
				if ((keycode == KEY_LEFTALT) && !pressed)
					alt_key_pressed = 0;

				if ((alt_key_pressed) && (keycode == KEY_LEFT))
					printk("key (Alt + Down) pressed\n");
				else if ((alt_key_pressed) && (keycode == KEY_RIGHT))
					printk("key (Alt + Up) pressed\n");
				else
				{	
#endif
			input_report_key(kp->input_devs->dev[dev], keycode, pressed);
#ifdef SLEEP_STATE_SKIP_LONGKEY
				if((pressed == 1) && (keycode == KEY_END || keycode == KEY_VOLUMEUP || keycode == KEY_VOLUMEDOWN/* || keycode == KEY_HOME*/))
				{
					key_press_count = 0;
					current_pressed_key = keycode;
					long_key_state = LONG_KEY_CHECK_ACTIVE;
				}
				else
				{
					key_press_count = 0;
					long_key_state = LONG_KEY_CHECK_INACTIVE;              
				}
#endif
#if defined(CONFIG_MACH_COOPER) || defined(CONFIG_MACH_BENI) || defined(CONFIG_MACH_TASS)
#if defined(CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI4) || defined(CONFIG_TOUCHSCREEN_SYNAPTICS_I2C_RMI)
				if(keycode == KEY_HOME && pressed == 1)
					TSP_forced_release_forkey();
#endif
#endif
#if defined(CONFIG_MACH_CALLISTO)  || defined(CONFIG_MACH_COOPER) || defined(CONFIG_MACH_BENI) || defined(CONFIG_MACH_TASS) || defined(CONFIG_MACH_LUCAS)
#if !defined(CONFIG_MACH_TOTORO_CTC) // for google security auth
				printk("key event (keycode:%d, pressed:%d), w=%d\n", 
						keycode, pressed, lcd_on_state_for_debug);	// sec: sm.kim
#endif
				// hsil	
//				if (keycode == 115)
//				{
//					volup_cnt++;
//					if (volup_cnt > 20)
//						enter_suspend = 1;
//				}
//				if (keycode == 114)
//				{
//					volup_cnt = 0;
//					enter_suspend = 0;
//				}
		
#ifdef ATH_CLAIM_RELEASE_WAR
				if(!lcd_on_state_for_debug) 
				    ath_debug_sdio_claimer();
#endif
#else
				printk("key event (keycode:%d, pressed:%d), wlan_debug_step=%d\n", 
						keycode, pressed, wlan_debug_step);	// sec: sm.kim
#endif
#if defined(CONFIG_MACH_LUCAS) || defined(CONFIG_MACH_CALLISTO)
				}
#endif
				key_pressed = pressed;
			} else {
				printk("power_off_done : %d\n", power_off_done);
			}
#else
			input_report_key(kp->input_devs->dev[dev], keycode, pressed);
//			printk("key event (keycode:%d, pressed:%d), wlan_debug_step=%d\n", 
//					keycode, pressed, wlan_debug_step);	// sec: sm.kim
			printk("key event (keycode:%d, pressed:%d)\n", keycode, pressed);	//sec: sm.kim
#endif
		}
	}
}