void keypad_report_keycode(struct gpio_key_state *ks)
{
struct gpio_input_state *ds = ks->ds;
int keymap_index;
const struct gpio_event_direct_entry *key_entry;
int pressed;
if (ds == NULL) {
KEY_LOGE("%s, (ds == NULL) failed\n", __func__);
return;
}
keymap_index = ks - ds->key_state;
key_entry = &ds->info->keymap[keymap_index];
if (key_entry == NULL) {
KEY_LOGE("%s, (key_entry == NULL) failed\n", __func__);
return;
}
pressed = gpio_get_value(key_entry->gpio) ^
!(ds->info->flags & GPIOEDF_ACTIVE_HIGH);
if (key_entry->code == KEY_POWER) {
if (pressed)
wake_lock(&ds->key_pressed_wake_lock);
else
wake_unlock(&ds->key_pressed_wake_lock);
}
if (ds->info->flags & GPIOEDF_PRINT_KEYS)
KEY_LOGD("%s: key %d-%d, %d "
"(%d) changed to %d\n", __func__,
ds->info->type, key_entry->code, keymap_index,
key_entry->gpio, pressed);
#ifdef CONFIG_POWER_KEY_LED
handle_power_key_led(key_entry->code, pressed);
#endif
#ifdef CONFIG_POWER_KEY_CLR_RESET
handle_power_key_reset(key_entry->code, pressed);
#endif
input_event(ds->input_devs->dev[key_entry->dev],
ds->info->type, key_entry->code, pressed);
input_sync(ds->input_devs->dev[key_entry->dev]);
}
static void power_key_check_reset_work_func(struct work_struct *dummy)
{
struct gpio_event_input_info *aa = gis;
int pocket_mode = 0;
KEY_LOGI("[PWR] %s\n", __func__);
if ((aa->clear_hw_reset)) {
/* Check P/L sensor status */
pocket_mode = power_key_check_in_pocket();
if (pocket_mode) {
printk(KERN_INFO "[KEY] power_key_check_in_pocket = %d\n", pocket_mode);
aa->clear_hw_reset();
}
}
else {
KEY_LOGI("[PWR] No reset clear function\n");
}
handle_power_key_reset(KEY_POWER, 1);
}
static void power_key_check_reset_work_func(struct work_struct *dummy)
{
struct gpio_event_input_info *aa = gis;
int pocket_mode = 0;
KEY_LOGI("[PWR] %s\n", __func__);
if ((aa->clear_hw_reset)) {
if (aa->info.rrm1_mode) {
printk(KERN_INFO "[KEY] Power key check in Lab Test RRM1 mode.\n");
aa->clear_hw_reset();
}
else {
pocket_mode = power_key_check_in_pocket();
if (pocket_mode) {
printk(KERN_INFO "[KEY] power_key_check_in_pocket = %d\n", pocket_mode);
aa->clear_hw_reset();
}
}
}
else {
KEY_LOGI("[PWR] No reset clear function\n");
}
handle_power_key_reset(KEY_POWER, 1);
}
static enum hrtimer_restart gpio_event_input_timer_func(struct hrtimer *timer)
{
int i;
int pressed;
struct gpio_input_state *ds =
container_of(timer, struct gpio_input_state, timer);
unsigned gpio_flags = ds->info->flags;
unsigned npolarity;
int nkeys = ds->info->keymap_size;
const struct gpio_event_direct_entry *key_entry;
struct gpio_key_state *key_state;
unsigned long irqflags;
uint8_t debounce;
bool sync_needed;
#if 0
key_entry = kp->keys_info->keymap;
key_state = kp->key_state;
for (i = 0; i < nkeys; i++, key_entry++, key_state++)
pr_info("gpio_read_detect_status %d %d\n", key_entry->gpio,
gpio_read_detect_status(key_entry->gpio));
#endif
key_entry = ds->info->keymap;
key_state = ds->key_state;
sync_needed = false;
spin_lock_irqsave(&ds->irq_lock, irqflags);
for (i = 0; i < nkeys; i++, key_entry++, key_state++) {
debounce = key_state->debounce;
if (debounce & DEBOUNCE_WAIT_IRQ)
continue;
if (key_state->debounce & DEBOUNCE_UNSTABLE) {
debounce = key_state->debounce = DEBOUNCE_UNKNOWN;
#if 0
enable_irq(gpio_to_irq(key_entry->gpio));
#endif
if (gpio_flags & GPIOEDF_PRINT_KEY_UNSTABLE)
KEY_LOGI("gpio_keys_scan_keys: key %x-%x, %d "
"(%d) continue debounce\n",
ds->info->type, key_entry->code,
i, key_entry->gpio);
}
npolarity = !(gpio_flags & GPIOEDF_ACTIVE_HIGH);
pressed = gpio_get_value(key_entry->gpio) ^ npolarity;
if (debounce & DEBOUNCE_POLL) {
if (pressed == !(debounce & DEBOUNCE_PRESSED)) {
ds->debounce_count++;
key_state->debounce = DEBOUNCE_UNKNOWN;
if (gpio_flags & GPIOEDF_PRINT_KEY_DEBOUNCE)
KEY_LOGI("gpio_keys_scan_keys: key %x-"
"%x, %d (%d) start debounce\n",
ds->info->type, key_entry->code,
i, key_entry->gpio);
}
continue;
}
if (pressed && (debounce & DEBOUNCE_NOTPRESSED)) {
if (gpio_flags & GPIOEDF_PRINT_KEY_DEBOUNCE)
KEY_LOGI("gpio_keys_scan_keys: key %x-%x, %d "
"(%d) debounce pressed 1\n",
ds->info->type, key_entry->code,
i, key_entry->gpio);
key_state->debounce = DEBOUNCE_PRESSED;
continue;
}
if (!pressed && (debounce & DEBOUNCE_PRESSED)) {
if (gpio_flags & GPIOEDF_PRINT_KEY_DEBOUNCE)
KEY_LOGI("gpio_keys_scan_keys: key %x-%x, %d "
"(%d) debounce pressed 0\n",
ds->info->type, key_entry->code,
i, key_entry->gpio);
key_state->debounce = DEBOUNCE_NOTPRESSED;
continue;
}
ds->debounce_count--;
if (ds->use_irq)
key_state->debounce |= DEBOUNCE_WAIT_IRQ;
else
key_state->debounce |= DEBOUNCE_POLL;
if (gpio_flags & GPIOEDF_PRINT_KEYS)
KEY_LOGI("gpio_keys_scan_keys: key %x-%x, %d (%d) "
"changed to %d\n", ds->info->type,
key_entry->code, i, key_entry->gpio, pressed);
if (ds->disable_reset_flag == 0) {
#ifdef CONFIG_POWER_KEY_LED
handle_power_key_led(key_entry->code, pressed);
#endif
#ifdef CONFIG_POWER_KEY_CLR_RESET
handle_power_key_reset(key_entry->code, pressed);
#endif
#ifdef CONFIG_PWRKEY_STATUS_API
handle_power_key_state(key_entry->code, pressed);
#endif
} else {
handle_only_power_key(key_entry->code, pressed);
}
input_event(ds->input_devs->dev[key_entry->dev], ds->info->type,
key_entry->code, pressed);
sync_needed = true;
}
if (sync_needed) {
for (i = 0; i < ds->input_devs->count; i++)
input_sync(ds->input_devs->dev[i]);
}
#if 0
key_entry = kp->keys_info->keymap;
key_state = kp->key_state;
for (i = 0; i < nkeys; i++, key_entry++, key_state++) {
pr_info("gpio_read_detect_status %d %d\n", key_entry->gpio,
gpio_read_detect_status(key_entry->gpio));
}
#endif
if (ds->debounce_count)
hrtimer_start(timer, ds->info->debounce_time, HRTIMER_MODE_REL);
else if (!ds->use_irq)
hrtimer_start(timer, ds->info->poll_time, HRTIMER_MODE_REL);
else
wake_unlock(&ds->wake_lock);
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
return HRTIMER_NORESTART;
}
static void power_key_check_reset_work_func(struct work_struct *dummy)
{
struct gpio_event_input_info *aa = gis;
#ifdef CONFIG_POWER_VOLUP_RESET
uint8_t val = 0, i = 0;
#else
int pocket_mode = 0;
#endif
KEY_LOGI("[PWR] %s\n", __func__);
#ifdef CONFIG_OF
if ((aa->dt_clear_hw_reset)) {
if (aa->info.rrm1_mode) {
KEY_LOGI(" Power key check in Lab Test RRM1 mode.\n");
aa->dt_clear_hw_reset(aa->clr_gpio);
#else
if ((aa->clear_hw_reset)) {
if (aa->info.rrm1_mode) {
printk(KERN_INFO "[KEY] Power key check in Lab Test RRM1 mode.\n");
aa->clear_hw_reset();
#endif
#ifndef CONFIG_POWER_VOLUP_RESET
} else if (board_mfg_mode() == MFG_MODE_NORMAL) {
pocket_mode = power_key_check_in_pocket();
if (pocket_mode) {
printk(KERN_INFO "[KEY] power_key_check_in_pocket = %d\n", pocket_mode);
#ifdef CONFIG_OF
aa->dt_clear_hw_reset(aa->clr_gpio);
#else
aa->clear_hw_reset();
#endif
}
} else
printk(KERN_INFO "[KEY] Not in normal OS mode, mode=%d\n", board_mfg_mode());
#else
} else {
printk(KERN_INFO "[KEY] OS Mode=%d\n", board_mfg_mode());
for (i = 0; i < aa->keymap_size; i++) {
if (aa->keymap[i].code == KEY_VOLUMEUP) {
val = gpio_get_value(aa->keymap[i].gpio);
break;
}
}
if (!val) {
KEY_LOGI("HW RESET continue");
} else {
#ifdef CONFIG_OF
aa->dt_clear_hw_reset(aa->clr_gpio);
#else
aa->clear_hw_reset();
#endif
}
}
#endif
} else {
KEY_LOGI("[PWR] No reset clear function\n");
}
handle_power_key_reset(KEY_POWER, 1);
}
static DECLARE_DELAYED_WORK(power_key_check_reset_work, power_key_check_reset_work_func);
static void power_key_clr_check_work_func(struct work_struct *dummy)
{
#ifdef CONFIG_POWER_VOLUP_RESET
uint8_t i = 0, val = 0, pwr_idx = 0;
struct gpio_event_input_info *aa = gis;
for (i = 0; i < aa->keymap_size; i++) {
if (aa->keymap[i].code == KEY_VOLUMEUP) {
val = gpio_get_value(aa->keymap[i].gpio);
if (val) {
KEY_LOGI("volUP clear");
#ifdef CONFIG_OF
aa->dt_clear_hw_reset(aa->clr_gpio);
#else
aa->clear_hw_reset();
#endif
}
break;
}
if (aa->keymap[i].code == KEY_POWER)
pwr_idx = i;
}
val = gpio_get_value(aa->keymap[pwr_idx].gpio);
if (val) {
#endif
if (cancel_delayed_work_sync(&power_key_check_reset_work))
KEY_LOGI("[PWR] cancel power key check reset work successfully\n");
else
KEY_LOGI("[PWR] cancel power key check reset work unsuccessfully\n");
#ifdef CONFIG_KPDPWR_S2_DVDD_RESET
clear_kpdpwr_s2_rst_flag = 0;
KEY_LOGD("%s: Disable kpdpwr s2 reset clear up [%d]\n", __func__, clear_kpdpwr_s2_rst_flag);
if (hrtimer_is_queued(&clr_kpd_reset_timer))
hrtimer_cancel(&clr_kpd_reset_timer);
if (hrtimer_is_queued(&enable_kpd_s2_timer))
hrtimer_cancel(&enable_kpd_s2_timer);
#endif
#ifdef CONFIG_POWER_VOLUP_RESET
}
#endif
wake_unlock(&key_reset_clr_wake_lock);
}
