static enum hrtimer_restart pmic8058_volume_up_debounce(struct hrtimer *timer) { int code = 0; struct pmic8xxx_kp *kp = container_of(timer, struct pmic8xxx_kp, volup_hrtimer); volup_level[1] = gpio_get_value_cansleep(PM8058_GPIO_PM_TO_SYS( PMIC_GPIO_VOLUME_UPKEY)); if (volup_level[0] == volup_level[1] && volup_pre_state != volup_level[1]){ volup_pre_state = volup_level[1]; code = MATRIX_SCAN_CODE((volup_matrix>>8), (volup_matrix&0xFF), PM8058_ROW_SHIFT); #ifndef CONFIG_PRODUCT_SHIP printk(KERN_ERR "%s : keycode [%d] %s\n", __func__, kp->keycodes[code], !volup_level[1] ? "pressed" : "released"); #endif input_event(kp->input, EV_MSC, MSC_SCAN, code); input_report_key(kp->input, kp->keycodes[code], !volup_level[1]); input_sync(kp->input); #if CONFIG_SEC_DEBUG sec_debug_check_crash_key(KEY_VOLUMEUP, !volup_level[1]); #endif } else {
static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id) { struct gpio_button_data *bdata = dev_id; #ifdef CONFIG_SEC_DEBUG int state = (gpio_get_value(bdata->button->gpio) ? 1 : 0) ^ bdata->button->active_low; sec_debug_check_crash_key(bdata->button->code, state); #endif BUG_ON(irq != bdata->irq); if (suspend_state) { irq_in_suspend = true; wakeup_reason = bdata->button->code; pr_info("%s before resume by %d\n", __func__, wakeup_reason); } if (bdata->button->wakeup) pm_stay_awake(bdata->input->dev.parent); if (bdata->timer_debounce) mod_timer(&bdata->timer, jiffies + msecs_to_jiffies(bdata->timer_debounce)); else schedule_work(&bdata->work); return IRQ_HANDLED; }
static void __pmic8xxx_kp_scan_matrix(struct pmic8xxx_kp *kp, u16 *new_state, u16 *old_state) { int row, col, code; for (row = 0; row < kp->pdata->num_rows; row++) { int bits_changed = new_state[row] ^ old_state[row]; if (!bits_changed) continue; for (col = 0; col < kp->pdata->num_cols; col++) { if (!(bits_changed & (1 << col))) continue; #ifndef CONFIG_PRODUCT_SHIP dev_warn(kp->dev, "key [%d:%d] %s\n", row, col, !(new_state[row] & (1 << col)) ? "pressed" : "released"); #endif code = MATRIX_SCAN_CODE(row, col, PM8XXX_ROW_SHIFT); input_event(kp->input, EV_MSC, MSC_SCAN, code); input_report_key(kp->input, kp->keycodes[code], !(new_state[row] & (1 << col))); input_sync(kp->input); #if CONFIG_SEC_DEBUG sec_debug_check_crash_key(kp->keycodes[code], !(new_state[row] & (1 << col))); #endif } } }
static int qpnp_pon_input_dispatch(struct qpnp_pon *pon, u32 pon_type) { int rc; struct qpnp_pon_config *cfg = NULL; u8 pon_rt_sts = 0, pon_rt_bit = 0; cfg = qpnp_get_cfg(pon, pon_type); if (!cfg) return -EINVAL; /* Check if key reporting is supported */ if (!cfg->key_code) return 0; /* check the RT status to get the current status of the line */ rc = spmi_ext_register_readl(pon->spmi->ctrl, pon->spmi->sid, QPNP_PON_RT_STS(pon->base), &pon_rt_sts, 1); if (rc) { dev_err(&pon->spmi->dev, "Unable to read PON RT status\n"); return rc; } switch (cfg->pon_type) { case PON_KPDPWR: pon_rt_bit = QPNP_PON_KPDPWR_N_SET; break; case PON_RESIN: pon_rt_bit = QPNP_PON_RESIN_N_SET; break; case PON_CBLPWR: pon_rt_bit = QPNP_PON_CBLPWR_N_SET; break; default: return -EINVAL; } input_report_key(pon->pon_input, cfg->key_code, (pon_rt_sts & pon_rt_bit)); input_sync(pon->pon_input); if((cfg->key_code == 116) && (pon_rt_sts & pon_rt_bit)){ pon->powerkey_state = 1; }else if((cfg->key_code == 116) && !(pon_rt_sts & pon_rt_bit)){ pon->powerkey_state = 0; } #if CONFIG_SEC_DEBUG sec_debug_check_crash_key(cfg->key_code, pon->powerkey_state); #endif #if defined(CONFIG_MACH_MONTBLANC) check_pkey_press=pon->powerkey_state; #endif return 0; }
static irqreturn_t pwrkey_release_irq(int irq, void *_pwrkey) { struct pmic8xxx_pwrkey *pwrkey = _pwrkey; pwrkey->powerkey_state = 0; input_report_key(pwrkey->pwr, KEY_POWER, 0); input_sync(pwrkey->pwr); #if CONFIG_SEC_DEBUG sec_debug_check_crash_key(KEY_POWER, 0); #endif return IRQ_HANDLED; }
static int __pmic8058_kp_scan_matrix(struct pmic8058_kp *kp, u16 *new_state, u16 *old_state) { int row, col, code; for (row = 0; row < kp->pdata->num_rows; row++) { int bits_changed = new_state[row] ^ old_state[row]; if (!bits_changed) continue; for (col = 0; col < kp->pdata->num_cols; col++) { if (!(bits_changed & (1 << col))) continue; dev_dbg(kp->dev, "key [%d:%d] %s\n", row, col, !(new_state[row] & (1 << col)) ? "pressed" : "released"); code = MATRIX_SCAN_CODE(row, col, PM8058_ROW_SHIFT); input_event(kp->input, EV_MSC, MSC_SCAN, code); input_report_key(kp->input, kp->keycodes[code], !(new_state[row] & (1 << col))); input_sync(kp->input); #if defined (CONFIG_TARGET_LOCALE_USA) pr_info("key [%d:%d] %s\n", row, col, !(new_state[row] & (1 << col)) ? "pressed" : "released"); #else pr_info("key [%d:%d] %s keycode [%d]\n", row, col, !(new_state[row] & (1 << col)) ? "pressed" : "released", kp->keycodes[code]); #endif #if defined (CONFIG_TOUCHSCREEN_MELFAS) #if defined (CONFIG_KOR_MODEL_SHV_E120L) || defined (CONFIG_KOR_MODEL_SHV_E120S) || defined (CONFIG_KOR_MODEL_SHV_E120K) || defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) if(!(new_state[row] & (1 << col)) && (kp->keycodes[code] == KEY_HOME)){ TSP_force_released(); } #endif #endif #if defined(CONFIG_SEC_DEBUG) sec_debug_check_crash_key(kp->keycodes[code], !(new_state[row] & (1 << col))); #endif } } return 0; }
static irqreturn_t pwrkey_press_irq(int irq, void *_pwrkey) { struct pmic8xxx_pwrkey *pwrkey = _pwrkey; pwrkey->powerkey_state = 1; pwrkey_status = true; input_report_key(pwrkey->pwr, KEY_POWER, 1); input_sync(pwrkey->pwr); #if defined(CONFIG_SEC_DEBUG) sec_debug_check_crash_key(KEY_POWER, 1); #endif return IRQ_HANDLED; }
static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata) { const struct gpio_keys_button *button = bdata->button; struct input_dev *input = bdata->input; unsigned int type = button->type ?: EV_KEY; int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low; #ifdef CONFIG_SEC_DEBUG sec_debug_check_crash_key(button->code, state); #endif if (type == EV_ABS) { if (state) input_event(input, type, button->code, button->value); } else { input_event(input, type, button->code, !!state); } input_sync(input); }
static void gpio_keys_report_event(struct gpio_button_data *bdata) { struct gpio_keys_button *button = bdata->button; struct input_dev *input = bdata->input; unsigned int type = button->type ?: EV_KEY; int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low; static int count; #if CONFIG_SEC_DEBUG sec_debug_check_crash_key(button->code, state); #endif if (type == EV_ABS) { if (state) input_event(input, type, button->code, button->value); } else { if (button->code == KEY_HOMEPAGE && count == 1) { if (!!state) { input_event(input, type, button->code, !!state); button_pressed = 1; } else { if (button_pressed == 0) { button_pressed = 1; /*send home key press event to input subsytem if release event detected before press event */ input_event(input, type, button->code, 1); } /*send home key release event to input subsystem */ input_event(input, type, button->code, 0); } } else { input_event(input, type, button->code, !!state); if (button->code == KEY_HOMEPAGE) count = 1; } } input_sync(input); }
static irqreturn_t pmic8058_volume_down_irq(int irq, void *data) { struct pmic8xxx_kp *kp = data; static int pre_down_key_state = -1; int key_state = 1; int code; if (!gpio_get_value_cansleep(PM8058_GPIO_PM_TO_SYS( PMIC_GPIO_VOLUME_DOWNKEY))) key_state = 0; code = MATRIX_SCAN_CODE((voldown_matrix>>8), (voldown_matrix&0xFF), PM8058_ROW_SHIFT); if (pre_down_key_state == key_state && pre_down_key_state != -1 && key_state == 0) { key_state = 1; #ifndef CONFIG_PRODUCT_SHIP printk(KERN_INFO "%s : Fix key state\n", __func__); #endif } pre_down_key_state = key_state; #ifndef CONFIG_PRODUCT_SHIP printk(KERN_ERR "%s : keycode [%d] %s\n", __func__, kp->keycodes[code], !key_state ? "pressed" : "released"); #endif input_event(kp->input, EV_MSC, MSC_SCAN, code); input_report_key(kp->input, kp->keycodes[code], !key_state); input_sync(kp->input); #if CONFIG_SEC_DEBUG sec_debug_check_crash_key(KEY_VOLUMEDOWN, !key_state); #endif return IRQ_HANDLED; }
static irqreturn_t pwrkey_press_irq(int irq, void *_pwrkey) { struct pmic8xxx_pwrkey *pwrkey = _pwrkey; if (pwrkey->press == true) { pwrkey->press = false; return IRQ_HANDLED; } else { pwrkey->press = true; } pwrkey->powerkey_state = 1; if (poweroff_charging) wake_lock(&pwrkey->wake_lock); input_report_key(pwrkey->pwr, KEY_POWER, 1); input_sync(pwrkey->pwr); #if defined(CONFIG_SEC_DEBUG) sec_debug_check_crash_key(KEY_POWER, 1); #endif return IRQ_HANDLED; }
static irqreturn_t gpio_keys_gpio_isr(int irq, void *dev_id) { struct gpio_button_data *bdata = dev_id; #ifdef CONFIG_SEC_DEBUG_ISR_CRASH int state = (gpio_get_value(bdata->button->gpio) ? 1 : 0) ^ bdata->button->active_low; #endif BUG_ON(irq != bdata->irq); if (bdata->button->wakeup) pm_stay_awake(bdata->input->dev.parent); if (bdata->timer_debounce) mod_timer(&bdata->timer, jiffies + msecs_to_jiffies(bdata->timer_debounce)); else schedule_work(&bdata->work); #ifdef CONFIG_SEC_DEBUG_ISR_CRASH sec_debug_check_crash_key(bdata->button->code, state); #endif return IRQ_HANDLED; }
static void gpio_keys_gpio_report_event(struct gpio_button_data *bdata) { const struct gpio_keys_button *button = bdata->button; struct input_dev *input = bdata->input; unsigned int type = button->type ?: EV_KEY; int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low; /* Workaround - QC code drivers/platform/msm/qpnp-power-on.c simulate press event in case release event occured * without a press event */ static int home_old_state; if (button->code == KEY_HOMEPAGE) { if (!home_old_state && !state && key_irq_state ) { pr_info("[KEY] Force press home old state(%d), state(%d)\n", home_old_state, state); input_event(input, type, KEY_HOMEPAGE , 1); input_sync(input); } home_old_state = state; } key_irq_state = 0; pr_info("[KEY] code(0x%02X), value(%d)\n", button->code, state); #ifdef CONFIG_SEC_DEBUG sec_debug_check_crash_key(button->code, state); #endif if (type == EV_ABS) { if (state) input_event(input, type, button->code, button->value); } else { input_event(input, type, button->code, !!state); } input_sync(input); }