static ssize_t kpd_store_call_state(struct device_driver *ddri, const char *buf, size_t count)
{
if (sscanf(buf, "%u", &call_status) != 1) {
kpd_print("kpd call state: Invalid values\n");
return -EINVAL;
}
switch(call_status)
{
case 1 :
kpd_print("kpd call state: Idle state!\n");
break;
case 2 :
kpd_print("kpd call state: ringing state!\n");
break;
case 3 :
kpd_print("kpd call state: active or hold state!\n");
break;
default:
kpd_print("kpd call state: Invalid values\n");
break;
}
return count;
}
static void hall_out_handler(unsigned long data)
{
/**/
#if 0
int state;
state = __gpio_get_value(CEI_HALL_OUT);
kpd_print("[Keypad] state = %d , old_INT_stat = %d \n", (int)state, old_INT_stat);
if(old_INT_stat != state)
{
if(state == 1)
{
kpd_print("[Keypad] hall_out (0 -> 1) OPEN\n");
}
else
{
kpd_print("[Keypad] hall_out (1 -> 0) CLOSE\n");
}
old_INT_stat = state;
switch_set_state((struct switch_dev *)&sdev, state);
}
#endif
kpd_print("[Keypad] %s() Enter\n", __FUNCTION__);
schedule_delayed_work(&hall_work, 0);
/**/
enable_irq(hall_irqnr);
}
static inline void kpd_update_aee_state(void)
{
if (aee_pressed_keys == ((1 << AEE_VOLUMEUP_BIT) | (1 << AEE_VOLUMEDOWN_BIT))) {
/* if volumeup and volumedown was pressed the same time then start the time of ten seconds */
aee_timer_started = true;
#if AEE_ENABLE_5_15
aee_timer_5s_started = true;
hrtimer_start(&aee_timer_5s, ktime_set(AEE_DELAY_TIME_5S, 0), HRTIMER_MODE_REL);
#endif
hrtimer_start(&aee_timer, ktime_set(AEE_DELAY_TIME, 0), HRTIMER_MODE_REL);
kpd_print("aee_timer started\n");
} else {
if (aee_timer_started) {
/*
* hrtimer_cancel - cancel a timer and wait for the handler to finish.
* Returns:
* 0 when the timer was not active.
* 1 when the timer was active.
*/
if (hrtimer_cancel(&aee_timer)) {
kpd_print("try to cancel hrtimer\n");
#if AEE_ENABLE_5_15
if (flags_5s) {
printk
("Pressed Volup + Voldown5s~15s then trigger aee manual dump.\n");
aee_kernel_reminding("manual dump",
"Trigger Vol Up +Vol Down 5s");
}
#endif
}
#if AEE_ENABLE_5_15
flags_5s = false;
#endif
aee_timer_started = false;
kpd_print("aee_timer canceled\n");
}
#if AEE_ENABLE_5_15
if (aee_timer_5s_started) {
/*
* hrtimer_cancel - cancel a timer and wait for the handler to finish.
* Returns:
* 0 when the timer was not active.
* 1 when the timer was active.
*/
if (hrtimer_cancel(&aee_timer_5s)) {
kpd_print("try to cancel hrtimer (5s)\n");
}
aee_timer_5s_started = false;
kpd_print("aee_timer canceled (5s)\n");
}
#endif
}
}
void kpd_pmic_rstkey_handler(unsigned long pressed)
{
kpd_print("PMIC reset Key generate, pressed=%ld\n", pressed);
if (!kpd_input_dev) {
kpd_print("KPD input device not ready\n");
return;
}
kpd_pmic_rstkey_hal(pressed);
#ifdef KPD_PMIC_RSTKEY_MAP
kpd_aee_handler(KPD_PMIC_RSTKEY_MAP, pressed);
#endif
}
static void kpd_keymap_handler(unsigned long data)
{
int i, j;
bool pressed;
u16 new_state[KPD_NUM_MEMS], change, mask;
u16 hw_keycode, linux_keycode;
kpd_get_keymap_state(new_state);
#ifdef CONFIG_MTK_TC1_FM_AT_SUSPEND
wake_lock_timeout(&kpd_suspend_lock, HZ / 2);
#endif
for (i = 0; i < KPD_NUM_MEMS; i++) {
change = new_state[i] ^ kpd_keymap_state[i];
if (!change)
continue;
for (j = 0; j < 16; j++) {
mask = 1U << j;
if (!(change & mask))
continue;
hw_keycode = (i << 4) + j;
/* bit is 1: not pressed, 0: pressed */
pressed = !(new_state[i] & mask);
if (kpd_show_hw_keycode) {
printk(KPD_SAY "(%s) HW keycode = %u\n",
pressed ? "pressed" : "released", hw_keycode);
}
BUG_ON(hw_keycode >= KPD_NUM_KEYS);
linux_keycode = kpd_keymap[hw_keycode];
if (unlikely(linux_keycode == 0)) {
kpd_print("Linux keycode = 0\n");
continue;
}
kpd_aee_handler(linux_keycode, pressed);
kpd_backlight_handler(pressed, linux_keycode);
input_report_key(kpd_input_dev, linux_keycode, pressed);
input_sync(kpd_input_dev);
kpd_print("report Linux keycode = %u\n", linux_keycode);
}
}
memcpy(kpd_keymap_state, new_state, sizeof(new_state));
kpd_print("save new keymap state\n");
#ifdef CONFIG_OF
enable_irq(kp_irqnr);
#else
enable_irq(MT_KP_IRQ_ID);
#endif
}
static void kpd_early_suspend(struct early_suspend *h)
{
kpd_suspend = true;
#ifdef MTK_KP_WAKESOURCE
if (call_status == 2) {
kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);
} else {
/* kpd_wakeup_src_setting(0); */
kpd_print("kpd_early_suspend wake up source disable!! (%d)\n", kpd_suspend);
}
#endif
kpd_print("early suspend!! (%d)\n", kpd_suspend);
}
static void kpd_early_resume(struct early_suspend *h)
{
kpd_suspend = false;
#ifdef MTK_KP_WAKESOURCE
if (call_status == 2) {
kpd_print("kpd_early_resume wake up source resume!! (%d)\n", kpd_suspend);
} else {
kpd_print("kpd_early_resume wake up source enable!! (%d)\n", kpd_suspend);
/* kpd_wakeup_src_setting(1); */
}
#endif
kpd_print("early resume!! (%d)\n", kpd_suspend);
}
static int kpd_pdrv_suspend(struct platform_device *pdev, pm_message_t state)
{
kpd_suspend = true;
#ifdef MTK_KP_WAKESOURCE
if (call_status == 2) {
kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);
} else {
kpd_wakeup_src_setting(0);
kpd_print("kpd_early_suspend wake up source disable!! (%d)\n", kpd_suspend);
}
#endif
kpd_print("suspend!! (%d)\n", kpd_suspend);
return 0;
}
static int kpd_pdrv_resume(struct platform_device *pdev)
{
kpd_suspend = false;
#ifdef MTK_KP_WAKESOURCE
if (call_status == 2) {
kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);
} else {
kpd_print("kpd_early_suspend wake up source resume!! (%d)\n", kpd_suspend);
kpd_wakeup_src_setting(1);
}
#endif
kpd_print("resume!! (%d)\n", kpd_suspend);
return 0;
}
void kpd_pwrkey_pmic_handler(unsigned long pressed)
{
kpd_print("Power Key generate, pressed=%ld\n", pressed);
if (!kpd_input_dev) {
kpd_print("KPD input device not ready\n");
return;
}
kpd_pmic_pwrkey_hal(pressed);
#ifdef CONFIG_ARCH_MT8173
if (pressed) /* keep the lock while the button in held pushed */
wake_lock(&pwrkey_lock);
else /* keep the lock for extra 500ms after the button is released */
wake_lock_timeout(&pwrkey_lock, HZ/2);
#endif
}
static int kpd_pdrv_resume(struct platform_device *pdev)
{
kpd_suspend = false;
//kpd_enable_backlight();
kpd_print("resume!! (%d)\n", kpd_suspend);
return 0;
}
static irqreturn_t hall_interrupt_handler(int irq, void *dev)
{
/* use _nosync to avoid deadlock */
disable_irq_nosync(hall_irqnr);
kpd_print("[Keypad] %s() Enter\n", __FUNCTION__);
tasklet_schedule(&hall_out_tasklet);
return IRQ_HANDLED;
}
static void kpd_early_suspend(struct early_suspend *h)
{
kpd_suspend = true;
#ifdef MTK_KP_WAKESOURCE
if(call_status == 2){
if(incall == 0){
kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);
kpd_wakeup_src_setting(1);
incall = 1;
}
//if(incall == 1){}
}else{
//if(incall == 0){}
if(incall == 1){
kpd_print("kpd_early_resume wake up source disable!! (%d)\n", kpd_suspend);
kpd_wakeup_src_setting(0);
incall = 0;
}
}
#endif
kpd_disable_backlight();
kpd_print("early suspend!! (%d)\n", kpd_suspend);
}
static int get_kpd_mem(void)
{
int i;
for(i = 0; i < sizeof(kpd_mem_default)/sizeof(short); i++)
{
if((*(volatile u16 *)(KP_MEM1+4*i)&kpd_mem_default[i]) != kpd_mem_default[i])
{
kpd_print("KP_MEM%d: expect: 0x%x, fact:0x%x", kpd_mem_default[i], *(volatile u16 *)(KP_MEM1+4*i));
return -1;
}
}
return 0;
}
static void hall_work_func(struct work_struct *work)
{
int state;
state = __gpio_get_value(CEI_HALL_OUT);
kpd_print("[Keypad] state = %d , old_INT_stat = %d \n", (int)state, old_INT_stat);
mutex_lock(&hall_state_mutex);
if(old_INT_stat != state)
{
if(state == 1)
{
kpd_print("[Keypad] hall_out (0 -> 1) OPEN\n");
}
else
{
kpd_print("[Keypad] hall_out (1 -> 0) CLOSE\n");
}
old_INT_stat = state;
switch_set_state((struct switch_dev *)&sdev, state);
}
mutex_unlock(&hall_state_mutex);
}
static int kpd_camerakey_setup_eint(void)
{
int err = 0;
struct device_node *node;
u32 ints[2] = { 0, 0 };
u32 ints1[2] = { 0, 0 };
//int irq_flags;
//irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
//Focus key Setting.
node = of_find_compatible_node(NULL, NULL, "mediatek,CEI_CAMERA_FOCUS-eint");
if (node) {
of_property_read_u32_array(node, "debounce", ints, ARRAY_SIZE(ints));
of_property_read_u32_array(node, "interrupts", ints1, ARRAY_SIZE(ints1));
gpiopin = ints[0];
camerakeydebounce = ints[1];
focuskey_eint_type = ints1[1];
//gpio_request(gpiopin, "foucskey");
//gpio_set_debounce(gpiopin, 1024);
//gpio_free(gpiopin);
focuskey_irq = irq_of_parse_and_map(node, 0);
err = request_irq(focuskey_irq, kpd_camera_focus_eint_handler, IRQF_TRIGGER_NONE, "focuskey-eint", NULL);
//err = request_irq(focuskey_irq, kpd_camera_focus_eint_handler, irq_flags, "focuskey-eint", NULL);
if (err > 0) {
kpd_print("[Keypad] FOUCS KEY EINT IRQ LINE NOT AVAILABLE\n");
} else {
kpd_print("[keypad] FOUCS KEY set EINT finished, focuskey_irq=%d, headsetdebounce=%d\n",
focuskey_irq, camerakeydebounce);
}
} else {
kpd_print("[Keypad]%s can't find compatible node\n", __func__);
}
//Capture key Setting.
node = of_find_compatible_node(NULL, NULL, "mediatek,CEI_CAMERA_CAPTURE-eint");
if (node) {
of_property_read_u32_array(node, "debounce", ints, ARRAY_SIZE(ints));
of_property_read_u32_array(node, "interrupts", ints1, ARRAY_SIZE(ints1));
gpiopin = ints[0];
camerakeydebounce = ints[1];
capturekey_eint_type = ints1[1];
//gpio_request(gpiopin, "capturekey");
//gpio_set_debounce(gpiopin, 1024);
//gpio_free(gpiopin);
capturekey_irq = irq_of_parse_and_map(node, 0);
err = request_irq(capturekey_irq, kpd_camera_capture_eint_handler, IRQF_TRIGGER_NONE, "capturekey-eint", NULL);
//err = request_irq(capturekey_irq, kpd_camera_capture_eint_handler, irq_flags, "capturekey-eint", NULL);
if (err > 0) {
kpd_print("[Keypad] CAPTURE KEY EINT IRQ LINE NOT AVAILABLE\n");
} else {
kpd_print("[keypad] CAPTURE KEY set EINT finished, capturekey_irq=%d, headsetdebounce=%d\n",
capturekey_irq, camerakeydebounce);
}
} else {
kpd_print("[Keypad]%s can't find compatible node\n", __func__);
}
return 0;
}
static int kpd_pdrv_suspend(struct platform_device *pdev, pm_message_t state)
{
kpd_suspend = true;
#ifdef MTK_KP_WAKESOURCE
if(call_status == 2){
if(incall == 0){
kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);
kpd_wakeup_src_setting(1);
incall = 1;
}
//if(incall == 1){}
}else{
//if(incall == 0){}
if(incall == 1){
kpd_print("kpd_early_resume wake up source disable!! (%d)\n", kpd_suspend);
kpd_wakeup_src_setting(0);
incall = 0;
}
}
#endif
kpd_disable_backlight();
kpd_print("suspend!! (%d)\n", kpd_suspend);
return 0;
}
/*----------------------------------------------------------------------------*/
static int kpd_create_attr(struct device_driver *driver)
{
int idx, err = 0;
int num = (int)(sizeof(kpd_attr_list) / sizeof(kpd_attr_list[0]));
if (driver == NULL) {
return -EINVAL;
}
for (idx = 0; idx < num; idx++) {
if ((err = driver_create_file(driver, kpd_attr_list[idx]))) {
kpd_print("driver_create_file (%s) = %d\n", kpd_attr_list[idx]->attr.name,
err);
break;
}
}
return err;
}
static void kpd_slide_handler(unsigned long data)
{
bool slid;
u8 old_state = kpd_slide_state;
kpd_slide_state = !kpd_slide_state;
slid = (kpd_slide_state == !!KPD_SLIDE_POLARITY);
/* for SW_LID, 1: lid open => slid, 0: lid shut => closed */
input_report_switch(kpd_input_dev, SW_LID, slid);
input_sync(kpd_input_dev);
kpd_print("report QWERTY = %s\n", slid ? "slid" : "closed");
if (old_state)
mt_set_gpio_pull_select(GPIO_QWERTYSLIDE_EINT_PIN, 0);
else
mt_set_gpio_pull_select(GPIO_QWERTYSLIDE_EINT_PIN, 1);
/* for detecting the return to old_state */
mt65xx_eint_set_polarity(KPD_SLIDE_EINT, old_state);
mt65xx_eint_unmask(KPD_SLIDE_EINT);
}
static void camera_capture_eint_func(unsigned long data)
{
bool pressed = false;
u8 old_state;
wake_lock_timeout(&kpd_suspend_lock, HZ / 2);
#if 1
if(capturekey_eint_type == IRQ_TYPE_LEVEL_LOW)
{
old_state = (1);
}
else
{
old_state = (0);
}
kpd_print("[Keypad]old_state = %d\n",(int)old_state);
if(capturekey_eint_type == IRQ_TYPE_LEVEL_LOW)
{
pressed=true;
irq_set_irq_type(capturekey_irq, IRQ_TYPE_LEVEL_HIGH);
capturekey_eint_type = IRQ_TYPE_LEVEL_HIGH;
}
else
{
pressed=false;
irq_set_irq_type(capturekey_irq, IRQ_TYPE_LEVEL_LOW);
capturekey_eint_type = IRQ_TYPE_LEVEL_LOW;
}
//kpd_info("[Keypad]revert camera_capture_state = %d \n",(int)camera_capture_state);
printk(KPD_SAY "(%s) [Keypad] HW keycode = %u\n",
pressed ? "pressed" : "released", KPD_CAM_CAPTURE_MAP);
//kpd_print("[Keypad]pressed = %d\n",(int)pressed);
input_report_key(kpd_input_dev, KPD_CAM_CAPTURE_MAP, pressed);
input_sync(kpd_input_dev);
enable_irq(capturekey_irq);
#endif
}
void kpd_get_dts_info(struct device_node *node)
{
of_property_read_u32(node, "mediatek,kpd-key-debounce", &kpd_dts_data.kpd_key_debounce);
of_property_read_u32(node, "mediatek,kpd-sw-pwrkey", &kpd_dts_data.kpd_sw_pwrkey);
of_property_read_u32(node, "mediatek,kpd-hw-pwrkey", &kpd_dts_data.kpd_hw_pwrkey);
of_property_read_u32(node, "mediatek,kpd-sw-rstkey", &kpd_dts_data.kpd_sw_rstkey);
of_property_read_u32(node, "mediatek,kpd-hw-rstkey", &kpd_dts_data.kpd_hw_rstkey);
of_property_read_u32(node, "mediatek,kpd-use-extend-type", &kpd_dts_data.kpd_use_extend_type);
of_property_read_u32(node, "mediatek,kpd-pwrkey-eint-gpio", &kpd_dts_data.kpd_pwrkey_eint_gpio);
of_property_read_u32(node, "mediatek,kpd-pwrkey-gpio-din", &kpd_dts_data.kpd_pwrkey_gpio_din);
of_property_read_u32(node, "mediatek,kpd-hw-dl-key1", &kpd_dts_data.kpd_hw_dl_key1);
of_property_read_u32(node, "mediatek,kpd-hw-dl-key2", &kpd_dts_data.kpd_hw_dl_key2);
of_property_read_u32(node, "mediatek,kpd-hw-dl-key3", &kpd_dts_data.kpd_hw_dl_key3);
of_property_read_u32(node, "mediatek,kpd-hw-recovery-key", &kpd_dts_data.kpd_hw_recovery_key);
of_property_read_u32(node, "mediatek,kpd-hw-factory-key", &kpd_dts_data.kpd_hw_factory_key);
of_property_read_u32(node, "mediatek,kpd-hw-map-num", &kpd_dts_data.kpd_hw_map_num);
of_property_read_u32_array(node, "mediatek,kpd-hw-init-map", kpd_dts_data.kpd_hw_init_map,
kpd_dts_data.kpd_hw_map_num);
kpd_print("key-debounce = %d, sw-pwrkey = %d, hw-pwrkey = %d, hw-rstkey = %d, sw-rstkey = %d\n",
kpd_dts_data.kpd_key_debounce, kpd_dts_data.kpd_sw_pwrkey, kpd_dts_data.kpd_hw_pwrkey,
kpd_dts_data.kpd_hw_rstkey, kpd_dts_data.kpd_sw_rstkey);
}
static int kpd_pdrv_probe(struct platform_device *pdev)
{
int i, r;
int err = 0;
struct clk *kpd_clk = NULL;
kpd_info("Keypad probe start!!!\n");
/*kpd-clk should be control by kpd driver, not depend on default clock state*/
kpd_clk = devm_clk_get(&pdev->dev, "kpd-clk");
if (!IS_ERR(kpd_clk)) {
clk_prepare(kpd_clk);
clk_enable(kpd_clk);
} else {
kpd_print("get kpd-clk fail, but not return, maybe kpd-clk is set by ccf.\n");
}
kp_base = of_iomap(pdev->dev.of_node, 0);
if (!kp_base) {
kpd_info("KP iomap failed\n");
return -ENODEV;
};
kp_irqnr = irq_of_parse_and_map(pdev->dev.of_node, 0);
if (!kp_irqnr) {
kpd_info("KP get irqnr failed\n");
return -ENODEV;
}
kpd_info("kp base: 0x%p, addr:0x%p, kp irq: %d\n", kp_base, &kp_base, kp_irqnr);
/* initialize and register input device (/dev/input/eventX) */
kpd_input_dev = input_allocate_device();
if (!kpd_input_dev) {
kpd_print("input allocate device fail.\n");
return -ENOMEM;
}
kpd_input_dev->name = KPD_NAME;
kpd_input_dev->id.bustype = BUS_HOST;
kpd_input_dev->id.vendor = 0x2454;
kpd_input_dev->id.product = 0x6500;
kpd_input_dev->id.version = 0x0010;
kpd_input_dev->open = kpd_open;
kpd_get_dts_info(pdev->dev.of_node);
#ifdef CONFIG_ARCH_MT8173
wake_lock_init(&pwrkey_lock, WAKE_LOCK_SUSPEND, "PWRKEY");
#endif
/* fulfill custom settings */
kpd_memory_setting();
__set_bit(EV_KEY, kpd_input_dev->evbit);
#if defined(CONFIG_KPD_PWRKEY_USE_EINT) || defined(CONFIG_KPD_PWRKEY_USE_PMIC)
__set_bit(kpd_dts_data.kpd_sw_pwrkey, kpd_input_dev->keybit);
kpd_keymap[8] = 0;
#endif
if (!kpd_dts_data.kpd_use_extend_type) {
for (i = 17; i < KPD_NUM_KEYS; i += 9) /* only [8] works for Power key */
kpd_keymap[i] = 0;
}
for (i = 0; i < KPD_NUM_KEYS; i++) {
if (kpd_keymap[i] != 0)
__set_bit(kpd_keymap[i], kpd_input_dev->keybit);
}
#if KPD_AUTOTEST
for (i = 0; i < ARRAY_SIZE(kpd_auto_keymap); i++)
__set_bit(kpd_auto_keymap[i], kpd_input_dev->keybit);
#endif
#if KPD_HAS_SLIDE_QWERTY
__set_bit(EV_SW, kpd_input_dev->evbit);
__set_bit(SW_LID, kpd_input_dev->swbit);
#endif
if (kpd_dts_data.kpd_sw_rstkey)
__set_bit(kpd_dts_data.kpd_sw_rstkey, kpd_input_dev->keybit);
#ifdef KPD_KEY_MAP
__set_bit(KPD_KEY_MAP, kpd_input_dev->keybit);
#endif
#ifdef CONFIG_MTK_MRDUMP_KEY
__set_bit(KEY_RESTART, kpd_input_dev->keybit);
#endif
kpd_input_dev->dev.parent = &pdev->dev;
r = input_register_device(kpd_input_dev);
if (r) {
kpd_info("register input device failed (%d)\n", r);
input_free_device(kpd_input_dev);
return r;
}
/* register device (/dev/mt6575-kpd) */
kpd_dev.parent = &pdev->dev;
r = misc_register(&kpd_dev);
if (r) {
kpd_info("register device failed (%d)\n", r);
input_unregister_device(kpd_input_dev);
return r;
}
wake_lock_init(&kpd_suspend_lock, WAKE_LOCK_SUSPEND, "kpd wakelock");
/* register IRQ and EINT */
kpd_set_debounce(kpd_dts_data.kpd_key_debounce);
r = request_irq(kp_irqnr, kpd_irq_handler, IRQF_TRIGGER_NONE, KPD_NAME, NULL);
if (r) {
kpd_info("register IRQ failed (%d)\n", r);
misc_deregister(&kpd_dev);
input_unregister_device(kpd_input_dev);
return r;
}
mt_eint_register();
#ifndef KPD_EARLY_PORTING /*add for avoid early porting build err the macro is defined in custom file */
long_press_reboot_function_setting(); /* /API 4 for kpd long press reboot function setting */
#endif
hrtimer_init(&aee_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer.function = aee_timer_func;
#if AEE_ENABLE_5_15
hrtimer_init(&aee_timer_5s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer_5s.function = aee_timer_5s_func;
#endif
err = kpd_create_attr(&kpd_pdrv.driver);
if (err) {
kpd_info("create attr file fail\n");
kpd_delete_attr(&kpd_pdrv.driver);
return err;
}
kpd_info("%s Done\n", __func__);
return 0;
}
int hall_gpio_eint_setup(struct platform_device *pdev)
{
int err;
int irq_flags;
kpd_print("[Keypad] %s , enter\n", __FUNCTION__ );
/* get pinctrl */
pinctrl_hall = devm_pinctrl_get(&pdev->dev);
if (IS_ERR_OR_NULL(pinctrl_hall)) {
kpd_print("[Keypad] %s , Failed to get pinctrl\n", __FUNCTION__ );
goto hall_gpio_pinctrl_err;
}
pins_hall_default = pinctrl_lookup_state(pinctrl_hall, "cei_hall_out");
if (IS_ERR_OR_NULL(pins_hall_default)) {
kpd_print("[Keypad] %s , Failed to look up cei_hall_out state\n", __FUNCTION__ );
goto hall_gpio_pinctrl_err;
}
/* request gpio */
err = gpio_request_one(CEI_HALL_OUT, GPIOF_DIR_IN, "hall_sensor_irq");
if (err) {
kpd_print("[Keypad] %s , unable to request gpio %d\n", __FUNCTION__ , CEI_HALL_OUT);
goto hall_gpio_pinctrl_err;
}
/* select pinctrl */
err = pinctrl_select_state(pinctrl_hall, pins_hall_default);
if (err) {
kpd_print("[Keypad] %s , Can't select pinctrl default state\n", __FUNCTION__ );
return err;
}
/* request irq */
hall_irq_node = of_find_compatible_node(NULL, NULL, "mediatek, cei_hall_out-eint");
if (hall_irq_node) {
hall_irqnr = irq_of_parse_and_map(hall_irq_node, 0);
kpd_print("[Keypad] %s , hall_irqnr = %d\n", __FUNCTION__ , hall_irqnr );
if (!hall_irqnr) {
kpd_print("[Keypad] %s , irq_of_parse_and_map fail!!\n", __FUNCTION__ );
goto free_gpio;
}
irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
//if ( request_irq(hall_irqnr, hall_interrupt_handler, IRQF_TRIGGER_NONE, "cei_hall_out-eint", NULL) ) {
if ( request_irq(hall_irqnr, hall_interrupt_handler, irq_flags, "cei_hall_out-eint", NULL) ) {
kpd_print("[Keypad] %s , IRQ LINE NOT AVAILABLE!!\n", __FUNCTION__ );
goto free_gpio;
}
enable_irq(hall_irqnr);
}
else {
kpd_print("[Keypad] %s , cannot find cei_hall_out-eint node\n", __FUNCTION__ );
goto free_gpio;
}
kpd_print("[Keypad] %s , exit - Success\n", __FUNCTION__ );
return 0;
free_gpio:
gpio_free(CEI_HALL_OUT);
hall_gpio_pinctrl_err:
kpd_print("[Keypad] %s , exit - Fail\n", __FUNCTION__ );
return -EINVAL;
}
long kpd_dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
/* void __user *uarg = (void __user *)arg; */
switch (cmd) {
#if KPD_AUTOTEST
case PRESS_OK_KEY: /* KPD_AUTOTEST disable auto test setting to resolve CR ALPS00464496 */
if (test_bit(KEY_OK, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS OK KEY!!\n");
input_report_key(kpd_input_dev, KEY_OK, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support OK KEY!!\n");
}
break;
case RELEASE_OK_KEY:
if (test_bit(KEY_OK, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE OK KEY!!\n");
input_report_key(kpd_input_dev, KEY_OK, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support OK KEY!!\n");
}
break;
case PRESS_MENU_KEY:
if (test_bit(KEY_MENU, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS MENU KEY!!\n");
input_report_key(kpd_input_dev, KEY_MENU, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support MENU KEY!!\n");
}
break;
case RELEASE_MENU_KEY:
if (test_bit(KEY_MENU, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE MENU KEY!!\n");
input_report_key(kpd_input_dev, KEY_MENU, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support MENU KEY!!\n");
}
break;
case PRESS_UP_KEY:
if (test_bit(KEY_UP, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS UP KEY!!\n");
input_report_key(kpd_input_dev, KEY_UP, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support UP KEY!!\n");
}
break;
case RELEASE_UP_KEY:
if (test_bit(KEY_UP, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE UP KEY!!\n");
input_report_key(kpd_input_dev, KEY_UP, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support UP KEY!!\n");
}
break;
case PRESS_DOWN_KEY:
if (test_bit(KEY_DOWN, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS DOWN KEY!!\n");
input_report_key(kpd_input_dev, KEY_DOWN, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support DOWN KEY!!\n");
}
break;
case RELEASE_DOWN_KEY:
if (test_bit(KEY_DOWN, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE DOWN KEY!!\n");
input_report_key(kpd_input_dev, KEY_DOWN, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support DOWN KEY!!\n");
}
break;
case PRESS_LEFT_KEY:
if (test_bit(KEY_LEFT, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS LEFT KEY!!\n");
input_report_key(kpd_input_dev, KEY_LEFT, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support LEFT KEY!!\n");
}
break;
case RELEASE_LEFT_KEY:
if (test_bit(KEY_LEFT, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE LEFT KEY!!\n");
input_report_key(kpd_input_dev, KEY_LEFT, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support LEFT KEY!!\n");
}
break;
case PRESS_RIGHT_KEY:
if (test_bit(KEY_RIGHT, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS RIGHT KEY!!\n");
input_report_key(kpd_input_dev, KEY_RIGHT, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support RIGHT KEY!!\n");
}
break;
case RELEASE_RIGHT_KEY:
if (test_bit(KEY_RIGHT, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE RIGHT KEY!!\n");
input_report_key(kpd_input_dev, KEY_RIGHT, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support RIGHT KEY!!\n");
}
break;
case PRESS_HOME_KEY:
if (test_bit(KEY_HOME, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS HOME KEY!!\n");
input_report_key(kpd_input_dev, KEY_HOME, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support HOME KEY!!\n");
}
break;
case RELEASE_HOME_KEY:
if (test_bit(KEY_HOME, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE HOME KEY!!\n");
input_report_key(kpd_input_dev, KEY_HOME, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support HOME KEY!!\n");
}
break;
case PRESS_BACK_KEY:
if (test_bit(KEY_BACK, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS BACK KEY!!\n");
input_report_key(kpd_input_dev, KEY_BACK, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support BACK KEY!!\n");
}
break;
case RELEASE_BACK_KEY:
if (test_bit(KEY_BACK, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE BACK KEY!!\n");
input_report_key(kpd_input_dev, KEY_BACK, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support BACK KEY!!\n");
}
break;
case PRESS_CALL_KEY:
if (test_bit(KEY_CALL, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS CALL KEY!!\n");
input_report_key(kpd_input_dev, KEY_CALL, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support CALL KEY!!\n");
}
break;
case RELEASE_CALL_KEY:
if (test_bit(KEY_CALL, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE CALL KEY!!\n");
input_report_key(kpd_input_dev, KEY_CALL, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support CALL KEY!!\n");
}
break;
case PRESS_ENDCALL_KEY:
if (test_bit(KEY_ENDCALL, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS ENDCALL KEY!!\n");
input_report_key(kpd_input_dev, KEY_ENDCALL, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support ENDCALL KEY!!\n");
}
break;
case RELEASE_ENDCALL_KEY:
if (test_bit(KEY_ENDCALL, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE ENDCALL KEY!!\n");
input_report_key(kpd_input_dev, KEY_ENDCALL, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support ENDCALL KEY!!\n");
}
break;
case PRESS_VLUP_KEY:
if (test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS VOLUMEUP KEY!!\n");
input_report_key(kpd_input_dev, KEY_VOLUMEUP, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");
}
break;
case RELEASE_VLUP_KEY:
if (test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE VOLUMEUP KEY!!\n");
input_report_key(kpd_input_dev, KEY_VOLUMEUP, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");
}
break;
case PRESS_VLDOWN_KEY:
if (test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS VOLUMEDOWN KEY!!\n");
input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");
}
break;
case RELEASE_VLDOWN_KEY:
if (test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE VOLUMEDOWN KEY!!\n");
input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");
}
break;
case PRESS_FOCUS_KEY:
if (test_bit(KEY_FOCUS, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS FOCUS KEY!!\n");
input_report_key(kpd_input_dev, KEY_FOCUS, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support FOCUS KEY!!\n");
}
break;
case RELEASE_FOCUS_KEY:
if (test_bit(KEY_FOCUS, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE FOCUS KEY!!\n");
input_report_key(kpd_input_dev, KEY_FOCUS, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support RELEASE KEY!!\n");
}
break;
case PRESS_CAMERA_KEY:
if (test_bit(KEY_CAMERA, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS CAMERA KEY!!\n");
input_report_key(kpd_input_dev, KEY_CAMERA, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support CAMERA KEY!!\n");
}
break;
case RELEASE_CAMERA_KEY:
if (test_bit(KEY_CAMERA, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE CAMERA KEY!!\n");
input_report_key(kpd_input_dev, KEY_CAMERA, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support CAMERA KEY!!\n");
}
break;
case PRESS_POWER_KEY:
if (test_bit(KEY_POWER, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] PRESS POWER KEY!!\n");
input_report_key(kpd_input_dev, KEY_POWER, 1);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support POWER KEY!!\n");
}
break;
case RELEASE_POWER_KEY:
if (test_bit(KEY_POWER, kpd_input_dev->keybit)) {
kpd_print("[AUTOTEST] RELEASE POWER KEY!!\n");
input_report_key(kpd_input_dev, KEY_POWER, 0);
input_sync(kpd_input_dev);
} else {
kpd_print("[AUTOTEST] Not Support POWER KEY!!\n");
}
break;
#endif
case SET_KPD_KCOL:
kpd_auto_test_for_factorymode(); /* API 3 for kpd factory mode auto-test */
kpd_print("[kpd_auto_test_for_factorymode] test performed!!\n");
break;
default:
return -EINVAL;
}
return 0;
}
static int kpd_pdrv_probe(struct platform_device *pdev)
{
int i, r;
int err = 0;
kpd_ldvt_test_init();//API 2 for kpd LFVT test enviroment settings
/* initialize and register input device (/dev/input/eventX) */
kpd_input_dev = input_allocate_device();
if (!kpd_input_dev)
return -ENOMEM;
kpd_input_dev->name = KPD_NAME;
kpd_input_dev->id.bustype = BUS_HOST;
kpd_input_dev->id.vendor = 0x2454;
kpd_input_dev->id.product = 0x6500;
kpd_input_dev->id.version = 0x0010;
kpd_input_dev->open = kpd_open;
//fulfill custom settings
kpd_memory_setting();
__set_bit(EV_KEY, kpd_input_dev->evbit);
#if (KPD_PWRKEY_USE_EINT||KPD_PWRKEY_USE_PMIC)
__set_bit(KPD_PWRKEY_MAP, kpd_input_dev->keybit);
kpd_keymap[8] = 0;
#endif
for (i = 17; i < KPD_NUM_KEYS; i += 9) /* only [8] works for Power key */
kpd_keymap[i] = 0;
for (i = 0; i < KPD_NUM_KEYS; i++) {
if (kpd_keymap[i] != 0)
__set_bit(kpd_keymap[i], kpd_input_dev->keybit);
}
#if KPD_AUTOTEST
for (i = 0; i < ARRAY_SIZE(kpd_auto_keymap); i++)
__set_bit(kpd_auto_keymap[i], kpd_input_dev->keybit);
#endif
#if KPD_HAS_SLIDE_QWERTY
__set_bit(EV_SW, kpd_input_dev->evbit);
__set_bit(SW_LID, kpd_input_dev->swbit);
#endif
#ifdef KPD_PMIC_RSTKEY_MAP
__set_bit(KPD_PMIC_RSTKEY_MAP, kpd_input_dev->keybit);
#endif
#ifdef AEON_FCOVER_SUPPORT
__set_bit(KEY_FCOVER_1, kpd_input_dev->keybit);
__set_bit(KEY_FCOVER_2, kpd_input_dev->keybit);
#endif
kpd_input_dev->dev.parent = &pdev->dev;
r = input_register_device(kpd_input_dev);
if (r) {
printk(KPD_SAY "register input device failed (%d)\n", r);
input_free_device(kpd_input_dev);
return r;
}
/* register device (/dev/mt6575-kpd) */
kpd_dev.parent = &pdev->dev;
r = misc_register(&kpd_dev);
if (r) {
printk(KPD_SAY "register device failed (%d)\n", r);
input_unregister_device(kpd_input_dev);
return r;
}
/* register IRQ and EINT */
kpd_set_debounce(KPD_KEY_DEBOUNCE);
r = request_irq(MT_KP_IRQ_ID, kpd_irq_handler, IRQF_TRIGGER_FALLING, KPD_NAME, NULL);
if (r) {
printk(KPD_SAY "register IRQ failed (%d)\n", r);
misc_deregister(&kpd_dev);
input_unregister_device(kpd_input_dev);
return r;
}
#if KPD_PWRKEY_USE_EINT
mt_eint_register();
#endif
#ifdef AEON_FCOVER_SUPPORT
printk("leanda AEON_FCOVER_SUPPORT \r\n");
mt_set_gpio_mode(GPIO_FCOVER_EINT_PIN, GPIO_MODE_01);
mt_set_gpio_dir(GPIO_FCOVER_EINT_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_FCOVER_EINT_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_FCOVER_EINT_PIN, GPIO_PULL_UP);
mt_eint_set_sens(FCOVER_KEY_EINT, FCOVER_KEY_SENSITIVE);
mt_eint_set_hw_debounce(FCOVER_KEY_EINT, FCOVER_KEY_DEBOUNCE);
mt_eint_registration(FCOVER_KEY_EINT, FCOVER_KEY_TYPE,
kpd_fcover_eint_handler, 0);
mt_eint_unmask(FCOVER_KEY_EINT);
#endif
//mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_TYPE, tpd_eint_interrupt_handler, 1);
#ifndef KPD_EARLY_PORTING /*add for avoid early porting build err the macro is defined in custom file*/
long_press_reboot_function_setting();///API 4 for kpd long press reboot function setting
#endif
hrtimer_init(&aee_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer.function = aee_timer_func;
#if AEE_ENABLE_5_15
hrtimer_init(&aee_timer_5s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer_5s.function = aee_timer_5s_func;
#endif
if((err = kpd_create_attr(&kpd_pdrv.driver)))
{
kpd_print("create attr file fail\n");
kpd_delete_attr(&kpd_pdrv.driver);
return err;
}
return 0;
}
static void kpd_early_resume(struct early_suspend *h)
{
kpd_suspend = false;
//kpd_enable_backlight();
kpd_print("early resume!! (%d)\n", kpd_suspend);
}
static int kpd_pdrv_probe(struct platform_device *pdev)
{
int i, r;
int err = 0;
kpd_ldvt_test_init();//API 2 for kpd LFVT test enviroment settings
/* initialize and register input device (/dev/input/eventX) */
kpd_input_dev = input_allocate_device();
if (!kpd_input_dev)
return -ENOMEM;
kpd_input_dev->name = KPD_NAME;
kpd_input_dev->id.bustype = BUS_HOST;
kpd_input_dev->id.vendor = 0x2454;
kpd_input_dev->id.product = 0x6500;
kpd_input_dev->id.version = 0x0010;
kpd_input_dev->open = kpd_open;
//fulfill custom settings
kpd_memory_setting();
__set_bit(EV_KEY, kpd_input_dev->evbit);
#if (KPD_PWRKEY_USE_EINT||KPD_PWRKEY_USE_PMIC)
__set_bit(KPD_PWRKEY_MAP, kpd_input_dev->keybit);
kpd_keymap[8] = 0;
#endif
for (i = 17; i < KPD_NUM_KEYS; i += 9) /* only [8] works for Power key */
kpd_keymap[i] = 0;
for (i = 0; i < KPD_NUM_KEYS; i++) {
if (kpd_keymap[i] != 0)
__set_bit(kpd_keymap[i], kpd_input_dev->keybit);
}
#if KPD_AUTOTEST
for (i = 0; i < ARRAY_SIZE(kpd_auto_keymap); i++)
__set_bit(kpd_auto_keymap[i], kpd_input_dev->keybit);
#endif
#if KPD_HAS_SLIDE_QWERTY
__set_bit(EV_SW, kpd_input_dev->evbit);
__set_bit(SW_LID, kpd_input_dev->swbit);
#endif
#ifdef KPD_PMIC_RSTKEY_MAP
__set_bit(KPD_PMIC_RSTKEY_MAP, kpd_input_dev->keybit);
#endif
/* LENOVO.SW BEGIN.chenyb1,2012.9.4, add for new standard */
#ifdef LENOVO_STD_LINECTL_EARPHONE
__set_bit(KEY_INFO, kpd_input_dev->keybit);
#endif //LENOVO_STD_LINECTL_EARPHONE
/* LENOVO.SW END.chenyb1,2012.9.4, add for new standard */
kpd_input_dev->dev.parent = &pdev->dev;
r = input_register_device(kpd_input_dev);
if (r) {
printk(KPD_SAY "register input device failed (%d)\n", r);
input_free_device(kpd_input_dev);
return r;
}
/* register device (/dev/mt6575-kpd) */
kpd_dev.parent = &pdev->dev;
r = misc_register(&kpd_dev);
if (r) {
printk(KPD_SAY "register device failed (%d)\n", r);
input_unregister_device(kpd_input_dev);
return r;
}
/* register IRQ and EINT */
kpd_set_debounce(KPD_KEY_DEBOUNCE);
r = request_irq(MT_KP_IRQ_ID, kpd_irq_handler, IRQF_TRIGGER_FALLING, KPD_NAME, NULL);
if (r) {
printk(KPD_SAY "register IRQ failed (%d)\n", r);
misc_deregister(&kpd_dev);
input_unregister_device(kpd_input_dev);
return r;
}
#if KPD_PWRKEY_USE_EINT
mt_eint_register();
#endif
#ifndef KPD_EARLY_PORTING /*add for avoid early porting build err the macro is defined in custom file*/
long_press_reboot_function_setting();///API 4 for kpd long press reboot function setting
#endif
hrtimer_init(&aee_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer.function = aee_timer_func;
#if AEE_ENABLE_5_15
hrtimer_init(&aee_timer_5s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer_5s.function = aee_timer_5s_func;
#endif
if((err = kpd_create_attr(&kpd_pdrv.driver)))
{
kpd_print("create attr file fail\n");
kpd_delete_attr(&kpd_pdrv.driver);
return err;
}
return 0;
}
//Camera key bring up -E
static int kpd_pdrv_probe(struct platform_device *pdev)
{
int i, r;
int err = 0;
struct clk *kpd_clk = NULL;
//Keypad porting - S
#if 1
struct pinctrl *pinctrl1;
struct pinctrl_state *pins_default, *pins_eint_int;
#endif
//Keypad porting - E
kpd_info("Keypad probe start!!!\n");
/*kpd-clk should be control by kpd driver, not depend on default clock state*/
kpd_clk = devm_clk_get(&pdev->dev, "kpd-clk");
if (!IS_ERR(kpd_clk)) {
clk_prepare(kpd_clk);
clk_enable(kpd_clk);
} else {
kpd_print("get kpd-clk fail, but not return, maybe kpd-clk is set by ccf.\n");
}
kp_base = of_iomap(pdev->dev.of_node, 0);
if (!kp_base) {
kpd_info("KP iomap failed\n");
return -ENODEV;
};
kp_irqnr = irq_of_parse_and_map(pdev->dev.of_node, 0);
if (!kp_irqnr) {
kpd_info("KP get irqnr failed\n");
return -ENODEV;
}
kpd_info("kp base: 0x%p, addr:0x%p, kp irq: %d\n", kp_base, &kp_base, kp_irqnr);
/* initialize and register input device (/dev/input/eventX) */
kpd_input_dev = input_allocate_device();
if (!kpd_input_dev) {
kpd_print("input allocate device fail.\n");
return -ENOMEM;
}
kpd_input_dev->name = KPD_NAME;
kpd_input_dev->id.bustype = BUS_HOST;
kpd_input_dev->id.vendor = 0x2454;
kpd_input_dev->id.product = 0x6500;
kpd_input_dev->id.version = 0x0010;
kpd_input_dev->open = kpd_open;
kpd_get_dts_info(pdev->dev.of_node);
#ifdef CONFIG_ARCH_MT8173
wake_lock_init(&pwrkey_lock, WAKE_LOCK_SUSPEND, "PWRKEY");
#endif
/* fulfill custom settings */
kpd_memory_setting();
__set_bit(EV_KEY, kpd_input_dev->evbit);
//keypad bring up - S
#if 1 //for volume down key
pinctrl1 = devm_pinctrl_get(&pdev->dev);
if (IS_ERR(pinctrl1)) {
err = PTR_ERR(pinctrl1);
dev_err(&pdev->dev, "fwq Cannot find voldown pinctrl1!\n");
return err;
}
pins_default = pinctrl_lookup_state(pinctrl1, "default");
if (IS_ERR(pins_default)) {
err = PTR_ERR(pins_default);
dev_err(&pdev->dev, "fwq Cannot find voldown pinctrl default!\n");
}
pins_eint_int = pinctrl_lookup_state(pinctrl1, "kpd_pins_eint");
if (IS_ERR(pins_eint_int)) {
err = PTR_ERR(pins_eint_int);
dev_err(&pdev->dev, "fwq Cannot find voldown pinctrl state_eint_int!\n");
return err;
}
#endif
#if 0
gpio_request(KPD_VOLUP , "KPD_KCOL1");
gpio_direction_input(KPD_VOLUP);
gpio_free(KPD_VOLUP);
#endif
pinctrl_select_state(pinctrl1, pins_eint_int);
//keypad bring up - E
/**/
err = hall_gpio_eint_setup(pdev);
if (err!=0) {
kpd_print("[Keypad] %s , hall_gpio_eint_setup failed (%d)\n", __FUNCTION__ , err );
}
proc_create_data("hall_out_status", 0444, NULL, &hall_out_status_fops, NULL);
sdev.name = "hall_gpio";
sdev.index = 0;
sdev.state = 1;
r = switch_dev_register(&sdev);
if (r) {
kpd_info("[Keypad] %s , register switch device failed (%d)\n", __FUNCTION__ , r);
switch_dev_unregister(&sdev);
return r;
}
/**/
switch_set_state((struct switch_dev *)&sdev, 1); // state initialization
/**/
/**/
mutex_init(&hall_state_mutex);
INIT_DELAYED_WORK(&hall_work, hall_work_func);
/**/
/**/
#if defined(CONFIG_KPD_PWRKEY_USE_EINT) || defined(CONFIG_KPD_PWRKEY_USE_PMIC)
__set_bit(kpd_dts_data.kpd_sw_pwrkey, kpd_input_dev->keybit);
kpd_keymap[8] = 0;
#endif
if (!kpd_dts_data.kpd_use_extend_type) {
for (i = 17; i < KPD_NUM_KEYS; i += 9) /* only [8] works for Power key */
kpd_keymap[i] = 0;
}
for (i = 0; i < KPD_NUM_KEYS; i++) {
if (kpd_keymap[i] != 0)
__set_bit(kpd_keymap[i], kpd_input_dev->keybit);
}
#if KPD_AUTOTEST
for (i = 0; i < ARRAY_SIZE(kpd_auto_keymap); i++)
__set_bit(kpd_auto_keymap[i], kpd_input_dev->keybit);
#endif
#if KPD_HAS_SLIDE_QWERTY
__set_bit(EV_SW, kpd_input_dev->evbit);
__set_bit(SW_LID, kpd_input_dev->swbit);
#endif
if (kpd_dts_data.kpd_sw_rstkey)
__set_bit(kpd_dts_data.kpd_sw_rstkey, kpd_input_dev->keybit);
#ifdef KPD_KEY_MAP
__set_bit(KPD_KEY_MAP, kpd_input_dev->keybit);
#endif
#ifdef CONFIG_MTK_MRDUMP_KEY
__set_bit(KEY_RESTART, kpd_input_dev->keybit);
#endif
//Caerma key porting
#if 1
for (i = 0; i < KPD_CAMERA_NUM; i++) {
if (kpd_camerakeymap[i] != 0)
__set_bit(kpd_camerakeymap[i], kpd_input_dev->keybit);
kpd_info("[Keypad] set kpd_camerakeymap[%d]" , i);
}
#endif
kpd_input_dev->dev.parent = &pdev->dev;
r = input_register_device(kpd_input_dev);
if (r) {
kpd_info("register input device failed (%d)\n", r);
input_free_device(kpd_input_dev);
return r;
}
/* register device (/dev/mt6575-kpd) */
kpd_dev.parent = &pdev->dev;
r = misc_register(&kpd_dev);
if (r) {
kpd_info("register device failed (%d)\n", r);
input_unregister_device(kpd_input_dev);
return r;
}
wake_lock_init(&kpd_suspend_lock, WAKE_LOCK_SUSPEND, "kpd wakelock");
/* register IRQ and EINT */
kpd_set_debounce(kpd_dts_data.kpd_key_debounce);
r = request_irq(kp_irqnr, kpd_irq_handler, IRQF_TRIGGER_NONE, KPD_NAME, NULL);
if (r) {
kpd_info("register IRQ failed (%d)\n", r);
misc_deregister(&kpd_dev);
input_unregister_device(kpd_input_dev);
return r;
}
mt_eint_register();
//Camera key bring up -S
printk("camera_key_setup_eint() START!!\n");
kpd_camerakey_setup_eint();
printk("camera_key_setup_eint() Done!!\n");
//Camera key bring up -E
#ifndef KPD_EARLY_PORTING /*add for avoid early porting build err the macro is defined in custom file */
long_press_reboot_function_setting(); /* /API 4 for kpd long press reboot function setting */
#endif
hrtimer_init(&aee_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer.function = aee_timer_func;
#if AEE_ENABLE_5_15
hrtimer_init(&aee_timer_5s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer_5s.function = aee_timer_5s_func;
#endif
#ifdef PWK_DUMP
hrtimer_init(&aee_timer_powerkey_30s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer_powerkey_30s.function = aee_timer_30s_func;
#endif
err = kpd_create_attr(&kpd_pdrv.driver);
if (err) {
kpd_info("create attr file fail\n");
kpd_delete_attr(&kpd_pdrv.driver);
return err;
}
kpd_info("%s Done\n", __func__);
return 0;
}
static int kpd_pdrv_probe(struct platform_device *pdev)
{
int i, r;
int err = 0;
#ifdef CONFIG_OF
kp_base = of_iomap(pdev->dev.of_node, 0);
if (!kp_base) {
pr_warn(KPD_SAY "KP iomap failed\n");
return -ENODEV;
};
kp_irqnr = irq_of_parse_and_map(pdev->dev.of_node, 0);
if (!kp_irqnr) {
pr_warn(KPD_SAY "KP get irqnr failed\n");
return -ENODEV;
}
pr_warn(KPD_SAY "kp base: 0x%p, addr:0x%p, kp irq: %d\n", kp_base,&kp_base, kp_irqnr);
#endif
kpd_ldvt_test_init(); /* API 2 for kpd LFVT test enviroment settings */
/* initialize and register input device (/dev/input/eventX) */
kpd_input_dev = input_allocate_device();
if (!kpd_input_dev)
return -ENOMEM;
kpd_input_dev->name = KPD_NAME;
kpd_input_dev->id.bustype = BUS_HOST;
kpd_input_dev->id.vendor = 0x2454;
kpd_input_dev->id.product = 0x6500;
kpd_input_dev->id.version = 0x0010;
kpd_input_dev->open = kpd_open;
#ifdef AEON_FCOVER_SUPPORT
spin_lock_init(&fcover_lock);
fcover_close_flag = 1;
#endif
//fulfill custom settings
kpd_memory_setting();
__set_bit(EV_KEY, kpd_input_dev->evbit);
#if (KPD_PWRKEY_USE_EINT || KPD_PWRKEY_USE_PMIC)
__set_bit(KPD_PWRKEY_MAP, kpd_input_dev->keybit);
kpd_keymap[8] = 0;
#endif
#if !KPD_USE_EXTEND_TYPE
for (i = 17; i < KPD_NUM_KEYS; i += 9) /* only [8] works for Power key */
kpd_keymap[i] = 0;
#endif
for (i = 0; i < KPD_NUM_KEYS; i++) {
if (kpd_keymap[i] != 0)
__set_bit(kpd_keymap[i], kpd_input_dev->keybit);
}
#if KPD_AUTOTEST
for (i = 0; i < ARRAY_SIZE(kpd_auto_keymap); i++)
__set_bit(kpd_auto_keymap[i], kpd_input_dev->keybit);
#endif
#if KPD_HAS_SLIDE_QWERTY
__set_bit(EV_SW, kpd_input_dev->evbit);
__set_bit(SW_LID, kpd_input_dev->swbit);
#endif
#ifdef KPD_PMIC_RSTKEY_MAP
__set_bit(KPD_PMIC_RSTKEY_MAP, kpd_input_dev->keybit);
#endif
#ifdef KPD_KEY_MAP
__set_bit(KPD_KEY_MAP, kpd_input_dev->keybit);
#endif
#ifdef AEON_FCOVER_SUPPORT
// __set_bit(KEY_FCOVER_1, kpd_input_dev->keybit);
// __set_bit(KEY_FCOVER_2, kpd_input_dev->keybit);
__set_bit(KEY_F11, kpd_input_dev->keybit);
__set_bit(KEY_F12, kpd_input_dev->keybit);
#endif
kpd_input_dev->dev.parent = &pdev->dev;
r = input_register_device(kpd_input_dev);
if (r) {
printk(KPD_SAY "register input device failed (%d)\n", r);
input_free_device(kpd_input_dev);
return r;
}
/* register device (/dev/mt6575-kpd) */
kpd_dev.parent = &pdev->dev;
r = misc_register(&kpd_dev);
if (r) {
printk(KPD_SAY "register device failed (%d)\n", r);
input_unregister_device(kpd_input_dev);
return r;
}
#ifdef CONFIG_MTK_TC1_FM_AT_SUSPEND
wake_lock_init(&kpd_suspend_lock, WAKE_LOCK_SUSPEND, "kpd wakelock");
#endif
/* register IRQ and EINT */
kpd_set_debounce(KPD_KEY_DEBOUNCE);
#ifdef CONFIG_OF
r = request_irq(kp_irqnr, kpd_irq_handler, IRQF_TRIGGER_NONE, KPD_NAME, NULL);
#else
r = request_irq(MT_KP_IRQ_ID, kpd_irq_handler, IRQF_TRIGGER_FALLING, KPD_NAME, NULL);
#endif
if (r) {
printk(KPD_SAY "register IRQ failed (%d)\n", r);
misc_deregister(&kpd_dev);
input_unregister_device(kpd_input_dev);
return r;
}
mt_eint_register();
#ifndef KPD_EARLY_PORTING /*add for avoid early porting build err the macro is defined in custom file */
long_press_reboot_function_setting(); /* /API 4 for kpd long press reboot function setting */
#endif
hrtimer_init(&aee_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer.function = aee_timer_func;
#if AEE_ENABLE_5_15
hrtimer_init(&aee_timer_5s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer_5s.function = aee_timer_5s_func;
#endif
if ((err = kpd_create_attr(&kpd_pdrv.driver))) {
kpd_print("create attr file fail\n");
kpd_delete_attr(&kpd_pdrv.driver);
return err;
}
pr_warn(KPD_SAY "%s Done\n", __FUNCTION__);
#ifdef AEON_FCOVER_SUPPORT
fcover_workqueue = create_singlethread_workqueue("fcover");
INIT_WORK(&fcover_work, fcover_key_handler);
fcover_data.name = "hall";
fcover_data.index = 0;
fcover_data.state = fcover_close_flag;
err = switch_dev_register(&fcover_data);
if(err)
{
printk("[Accdet]switch_dev_register returned:%d!\n", err);
// return 1;
}
switch_set_state((struct switch_dev *)&fcover_data, fcover_close_flag);
#ifdef AEON_FCOVER_SUPPORT
mt_set_gpio_mode(GPIO_FCOVER_EINT_PIN, GPIO_EINT_HALL_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_FCOVER_EINT_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_FCOVER_EINT_PIN, GPIO_PULL_DISABLE);
// mt_set_gpio_pull_select(GPIO_FCOVER_EINT_PIN, GPIO_PULL_UP);
mdelay(20);
fcover_close_flag = mt_get_gpio_in(GPIO_FCOVER_EINT_PIN);
// tpd_fcover_setting(fcover_close_flag);
mt_set_gpio_mode(GPIO_FCOVER_EINT_PIN, GPIO_EINT_HALL_PIN_M_EINT);
mt_eint_set_sens(FCOVER_KEY_EINT, FCOVER_KEY_SENSITIVE);
mt_eint_set_hw_debounce(FCOVER_KEY_EINT, FCOVER_KEY_DEBOUNCE);
mt_eint_registration(FCOVER_KEY_EINT, EINTF_TRIGGER_LOW,
kpd_fcover_eint_handler, 0);
mt_eint_unmask(FCOVER_KEY_EINT);
printk(KPD_SAY "xuqian kpd_fcover_eint_handler ..\n");
#else
mt_set_gpio_mode(GPIO_FCOVER_EINT_PIN, GPIO_EINT_HALL_PIN_M_GPIO);
mt_set_gpio_dir(GPIO_FCOVER_EINT_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_FCOVER_EINT_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_FCOVER_EINT_PIN, GPIO_PULL_DOWN);
#endif
// err = device_create_file(&(pdev->dev), &dev_attr_kpd_fcover_state);
// if(err)
// {
// printk("create attr file dev_attr_kpd_fcover_state error\n");
//// kpd_delete_attr(&kpd_pdrv.driver);
//// return err;
// }
// else
// {
// printk("create attr file dev_attr_kpd_fcover_state ok\n");
// }
#endif
return 0;
}
static int kpd_pdrv_probe(struct platform_device *pdev)
{
int i, r;
int err = 0;
#ifdef CONFIG_OF
kp_base = of_iomap(pdev->dev.of_node, 0);
if (!kp_base) {
pr_warn(KPD_SAY "KP iomap failed\n");
return -ENODEV;
};
kp_irqnr = irq_of_parse_and_map(pdev->dev.of_node, 0);
if (!kp_irqnr) {
pr_warn(KPD_SAY "KP get irqnr failed\n");
return -ENODEV;
}
pr_warn(KPD_SAY "kp base: 0x%p, addr:0x%p, kp irq: %d\n", kp_base,&kp_base, kp_irqnr);
#endif
kpd_ldvt_test_init(); /* API 2 for kpd LFVT test enviroment settings */
/* initialize and register input device (/dev/input/eventX) */
kpd_input_dev = input_allocate_device();
if (!kpd_input_dev)
return -ENOMEM;
kpd_input_dev->name = KPD_NAME;
kpd_input_dev->id.bustype = BUS_HOST;
kpd_input_dev->id.vendor = 0x2454;
kpd_input_dev->id.product = 0x6500;
kpd_input_dev->id.version = 0x0010;
kpd_input_dev->open = kpd_open;
/* fulfill custom settings */
kpd_memory_setting();
__set_bit(EV_KEY, kpd_input_dev->evbit);
#if (KPD_PWRKEY_USE_EINT || KPD_PWRKEY_USE_PMIC)
__set_bit(KPD_PWRKEY_MAP, kpd_input_dev->keybit);
kpd_keymap[8] = 0;
#endif
#if !KPD_USE_EXTEND_TYPE
for (i = 17; i < KPD_NUM_KEYS; i += 9) /* only [8] works for Power key */
kpd_keymap[i] = 0;
#endif
for (i = 0; i < KPD_NUM_KEYS; i++) {
if (kpd_keymap[i] != 0)
__set_bit(kpd_keymap[i], kpd_input_dev->keybit);
}
#if KPD_AUTOTEST
for (i = 0; i < ARRAY_SIZE(kpd_auto_keymap); i++)
__set_bit(kpd_auto_keymap[i], kpd_input_dev->keybit);
#endif
#if KPD_HAS_SLIDE_QWERTY
__set_bit(EV_SW, kpd_input_dev->evbit);
__set_bit(SW_LID, kpd_input_dev->swbit);
#endif
#ifdef KPD_PMIC_RSTKEY_MAP
__set_bit(KPD_PMIC_RSTKEY_MAP, kpd_input_dev->keybit);
#endif
#ifdef CONFIG_TOUCHSCREEN_PREVENT_SLEEP
#ifdef CONFIG_TOUCHSCREEN_SWEEP2WAKE
sweep2wake_setdev(kpd_input_dev);
#endif
#ifdef CONFIG_TOUCHSCREEN_DOUBLETAP2WAKE
doubletap2wake_setdev(kpd_input_dev);
#endif
#endif
#ifdef KPD_KEY_MAP
__set_bit(KPD_KEY_MAP, kpd_input_dev->keybit);
#endif
kpd_input_dev->dev.parent = &pdev->dev;
r = input_register_device(kpd_input_dev);
if (r) {
printk(KPD_SAY "register input device failed (%d)\n", r);
input_free_device(kpd_input_dev);
return r;
}
/* register device (/dev/mt6575-kpd) */
kpd_dev.parent = &pdev->dev;
r = misc_register(&kpd_dev);
if (r) {
printk(KPD_SAY "register device failed (%d)\n", r);
input_unregister_device(kpd_input_dev);
return r;
}
#ifdef CONFIG_MTK_TC1_FM_AT_SUSPEND
wake_lock_init(&kpd_suspend_lock, WAKE_LOCK_SUSPEND, "kpd wakelock");
#endif
/* register IRQ and EINT */
kpd_set_debounce(KPD_KEY_DEBOUNCE);
#ifdef CONFIG_OF
r = request_irq(kp_irqnr, kpd_irq_handler, IRQF_TRIGGER_NONE, KPD_NAME, NULL);
#else
r = request_irq(MT_KP_IRQ_ID, kpd_irq_handler, IRQF_TRIGGER_FALLING, KPD_NAME, NULL);
#endif
if (r) {
printk(KPD_SAY "register IRQ failed (%d)\n", r);
misc_deregister(&kpd_dev);
input_unregister_device(kpd_input_dev);
return r;
}
mt_eint_register();
#ifndef KPD_EARLY_PORTING /*add for avoid early porting build err the macro is defined in custom file */
long_press_reboot_function_setting(); /* /API 4 for kpd long press reboot function setting */
#endif
hrtimer_init(&aee_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer.function = aee_timer_func;
#if AEE_ENABLE_5_15
hrtimer_init(&aee_timer_5s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
aee_timer_5s.function = aee_timer_5s_func;
#endif
if ((err = kpd_create_attr(&kpd_pdrv.driver))) {
kpd_print("create attr file fail\n");
kpd_delete_attr(&kpd_pdrv.driver);
return err;
}
pr_warn(KPD_SAY "%s Done\n", __FUNCTION__);
return 0;
}
