MTK keypad调试，扩张键盘IC AW9523

FROM：http://blog.csdn.net/aree/article/details/28683741

按键没有hal层

设备中断-------驱动------>内核按键码（SCANCODE）-------*.kl--------> android keycode（char*）--------- KeycodeLabels.h ------>android keyevent（int, KeyEvent.java）

B：android keycode（char*）--------------- *.kcm/*.kcm.bin ------------>显示字符（char）

---

\alps\frameworks\base\policy\src\com\android\internal\policy\impl\PhoneWindowManager.java

  public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn) {
      if (!mSystemBooted) {
          // If we have not yet booted, don't let key events do anything.
          return 0;
      }

  // Handle special keys.
      switch (keyCode) {
          //add by //SCAN_123  ---
 case KeyEvent.KEYCODE_FN:
     if (down){
         fnflag = (!fnflag);
         Log.i(TAG, "fn status is " + fnflag);
         result &= ~ACTION_PASS_TO_USER;
         //add fn icon   trs 2012-07-20
         Intent intent = new Intent(Intent.ACTION_FN_STATUS);
         intent.putExtra("fn_status", fnflag);
         mContext.sendBroadcast(intent);
     }
     break;
 case KeyEvent.KEYCODE_F1:
 case KeyEvent.KEYCODE_F2:
 case KeyEvent.KEYCODE_F3:
 case KeyEvent.KEYCODE_F4:
     if (!down){
         handleFKeys(keyCode);
     }
     result &= ~ACTION_PASS_TO_USER;
     break;
 //add end//SCAN_123 ---

event hub  alps\frameworks\base\services\input\
event read

------------- alps\frameworks\base\core\java\android\view\KeyEvent.java 上层

 public class KeyEvent extends InputEvent implements Parcelable {
     /** Key code constant: Unknown key code. */
     public static final int KEYCODE_UNKNOWN         = 0;
     /** Key code constant: Soft Left key.
      * Usually situated below the display on phones and used as a multi-function
      * feature key for selecting a software defined function shown on the bottom left
      * of the display. */
     public static final int KEYCODE_SOFT_LEFT       = 1;
     /** Key code constant: Soft Right key.
      * Usually situated below the display on phones and used as a multi-function
      * feature key for selecting a software defined function shown on the bottom right
      * of the display. */
     public static final int KEYCODE_SOFT_RIGHT      = 2;
     /** Key code constant: Home key.
      * This key is handled by the framework and is never delivered to applications. */
     public static final int KEYCODE_HOME            = 3;
     /** Key code constant: Back key. */
     public static final int KEYCODE_BACK            = 4;
     /** Key code constant: Call key. */
     public static final int KEYCODE_CALL            = 5;

     public static final int KEYCODE_KANA            = 218;
     /** Key code constant: Assist key.
      * Launches the global assist activity.  Not delivered to applications. */
     public static final int KEYCODE_ASSIST          = 219;
     public static final int KEYCODE_SCAN          = 220;//sam add
     public static final int KEYCODE_SCAN_LEFT          = 221;
     public static final int KEYCODE_SCAN_RIGHT          = 222;
     public static final int KEYCODE_FN             = 223;
     private static final int LAST_KEYCODE           = KEYCODE_FN;//KEYCODE_ASSIST;

      private static void populateKeycodeSymbolicNames() {
         SparseArray names = KEYCODE_SYMBOLIC_NAMES;
         names.append(KEYCODE_UNKNOWN, "KEYCODE_UNKNOWN");
         names.append(KEYCODE_SOFT_LEFT, "KEYCODE_SOFT_LEFT");
         names.append(KEYCODE_SOFT_RIGHT, "KEYCODE_SOFT_RIGHT");
         names.append(KEYCODE_HOME, "KEYCODE_HOME");
         names.append(KEYCODE_BACK, "KEYCODE_BACK");
         names.append(KEYCODE_CALL, "KEYCODE_CALL");
         names.append(KEYCODE_ENDCALL, "KEYCODE_ENDCALL");
         names.append(KEYCODE_0, "KEYCODE_0");

alps\frameworks\base\api\17.txt   // android API 17 = android4.2 //找到 17.txt文件改  //可能需要使用命令:./make update-api

 field public static final int KEYCODE_HOME = 3; // 0x3  //与上面的数字值要一样。
 ...
 field public static final int META_SHIFT_RIGHT_ON = 128; // 0x80
 field public static final int META_SYM_ON = 4; // 0x4
 field public static final int KEYCODE_SCAN = 220; // 0xdc
 field public static final int KEYCODE_SCAN_LEFT = 221; // 0xdd
 field public static final int KEYCODE_SCAN_RIGHT = 221; // 0xde

---

alpsAteam\frameworks\native\include\android\keycodes.h

     AKEYCODE_KANA            = 218,
     AKEYCODE_ASSIST          = 219,
     AKEYCODE_SCAN            = 220,//sam add
     AKEYCODE_SCAN_LEFT       = 221,
     AKEYCODE_SCAN_RIGHT      = 222,
     AKEYCODE_FN              = 223,
     // NOTE: If you add a new keycode here you must also add it to several other files.
     //       Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.
 };

---

\alps\frameworks\base\libs\androidfw\Input.cpp

 bool KeyEvent::isSystemKey(int32_t keyCode) {
     switch (keyCode) {
         case AKEYCODE_MENU:
         case AKEYCODE_SOFT_RIGHT:
         case AKEYCODE_HOME:
         case AKEYCODE_BACK:
         case AKEYCODE_CALL:
         ....
         case AKEYCODE_SEARCH:
         case AKEYCODE_SCAN://sam add --below...
         case AKEYCODE_SCAN_LEFT:
         case AKEYCODE_SCAN_RIGHT:
         case AKEYCODE_FN:
         case AKEYCODE_F1:
         case AKEYCODE_F2:
         case AKEYCODE_F3:
         case AKEYCODE_F4:
             return true;
     }

----

alps\frameworks\native\include\input\KeycodeLabels.h
...
static const KeycodeLabel KEYCODES[] = {//下层与上层的对照,能过字符串把两个数字来找的。
 

   { "SOFT_LEFT", 1 },
    { "SOFT_RIGHT", 2 },
    { "HOME", 3 },
    { "BACK", 4 },
 ...
     { "KANA", 218 },
     { "ASSIST", 219 },
     { "SCAN", 220 },//sam add
     { "SCAN_LEFT", 221 },
     { "SCAN_RIGHT", 222 },
     { "FN", 223 },
     // NOTE: If you add a new keycode here you must also add it to several other files.
     //       Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.


     { NULL, 0 }
 };

mtk-kpd.kl //底层
....

 key 102   HOME
 ...
 key 59   F1
 key 60   F2
 key 61   F3
 key 62   F4
 key 464  FN

 key 220   SCAN
 key 125   SCAN_LEFT
 key 128   SCAN_RIGHT

...
----
//mt6571/72可以做18个的扩展键盘(3个row pin和3个col pin)，但做不了更多，
3*3*2 =power , volume ,   

更多keypad需要做8*8 (8 row pin 和8 col pin)

也可以外挂一个键盘ic来做。
-----
//mtk默认pmic有两个key ，一个是 power key,另一个是 vlume down key/home key/ 

在codegen.dws中
[KEYPAD Setting]页面，有一个PowerKey use EINT ，选中，则会打开了这个开关  KPD_PWRKEY_USE_EINT在mediatek\kernel\drivers\keypad\kpd.c中使用到.一般我们不用EINT做power key,而是默认使用pmic做power key.

 "378654" snippet_file_name="blog_20140605_4_3325559" name="code" class="cpp">alps\mediatek\platform\mt6572\kernel\drivers\keypad\kpd.c

 /*
  * Copyright (C) 2010 MediaTek, Inc.
  *
  * Author: Terry Chang
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  */

 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include

 #include
 #include


 #include
 #include
 #include       /* custom file */
 #include
 #include
 #include
 #include
 #include
 #include
 #include

 #include

 #if 1   //ATA_TEST
 #define KPD_AUTOTEST_BY_KP
 #endif

 #define KPD_NAME    "mtk-kpd"

 /* Keypad registers */
 #define KP_STA          (KP_BASE + 0x0000)
 #define KP_MEM1         (KP_BASE + 0x0004)
 #define KP_MEM2         (KP_BASE + 0x0008)
 #define KP_MEM3         (KP_BASE + 0x000c)
 #define KP_MEM4         (KP_BASE + 0x0010)
 #define KP_MEM5         (KP_BASE + 0x0014)
 #define KP_DEBOUNCE     (KP_BASE + 0x0018)
 #define KP_SCAN_TIMING      (KP_BASE + 0x001C)
 #define KP_SEL          (KP_BASE + 0x0020)
 #define KP_EN           (KP_BASE + 0x0024)

 #define KPD_NUM_MEMS    5
 #define KPD_MEM5_BITS   8

 #define KPD_NUM_KEYS    72  /* 4 * 16 + KPD_MEM5_BITS */

 #define KPD_DEBOUNCE_MASK   ((1U << 14) - 1)

 #define KPD_SAY     "kpd: "
 #if KPD_DEBUG
 #define kpd_print(fmt, arg...)  printk(KPD_SAY fmt, ##arg)
 #else
 #define kpd_print(fmt, arg...)  do {} while (0)
 #endif


 static struct input_dev *kpd_input_dev;
 static bool kpd_suspend = false;
 static int kpd_show_hw_keycode = 1;
 static int kpd_show_register = 1;
 static int kpd_enable_lprst = 1;

 /* for AEE manual dump */
 #if 0
 static bool kpd_volumn_down_flag = false;
 static bool kpd_volumn_up_flag = false;
 static inline void check_aee_dump()
 {
     if( (kpd_volumn_down_flag == true) && (kpd_volumn_up_flag == true))
     {
         printk(KPD_SAY "kpd_volumn_up+ volumn_down,will trige DB\n");
         aee_kernel_reminding("manual dump ", "Triggered by press KEY_VOLUMEUP+KEY_VOLUMEDOWN");
     }
 }
 #endif

 /* for backlight control */
 #if KPD_DRV_CTRL_BACKLIGHT
 static void kpd_switch_backlight(struct work_struct *work);
 static void kpd_backlight_timeout(unsigned long data);
 static DECLARE_WORK(kpd_backlight_work, kpd_switch_backlight);
 static DEFINE_TIMER(kpd_backlight_timer, kpd_backlight_timeout, 0, 0);

 static unsigned long kpd_wake_keybit[BITS_TO_LONGS(KEY_CNT)];
 static u16 kpd_wake_key[] __initdata = KPD_BACKLIGHT_WAKE_KEY;

 static volatile bool kpd_backlight_on;
 static atomic_t kpd_key_pressed = ATOMIC_INIT(0);
 #endif

 /* for slide QWERTY */
 #if KPD_HAS_SLIDE_QWERTY
 static void kpd_slide_handler(unsigned long data);
 static DECLARE_TASKLET(kpd_slide_tasklet, kpd_slide_handler, 0);

 static u8 kpd_slide_state = !KPD_SLIDE_POLARITY;
 #endif

 /* for Power key using EINT */
 #if KPD_PWRKEY_USE_EINT
 static void kpd_pwrkey_handler(unsigned long data);
 static DECLARE_TASKLET(kpd_pwrkey_tasklet, kpd_pwrkey_handler, 0);
 static u8 kpd_pwrkey_state = !KPD_PWRKEY_POLARITY;
 #endif

 /* for Power key using PMIC */
 /*********************************************************************/
 #if 0//KPD_PWRKEY_USE_PMIC //for 77 chip and earlier version   power key bug, has fixed on 89 chip

 static void kpd_pwrkey_handler(struct work_struct *work);
 static DECLARE_WORK(pwrkey_pmic_work, kpd_pwrkey_handler);
 #endif
 /*********************************************************************/

 /* for keymap handling */
 static DEFINE_SPINLOCK(keymap_handler_spinlock);
 static void kpd_keymap_handler(unsigned long data);
 static DECLARE_TASKLET(kpd_keymap_tasklet, kpd_keymap_handler, 0);


 #define KPD_INIT_KEYMAP_FULL()  \
 {   \
     [0] = KEY_1,        \
     [1] = KEY_2,        \
     [2] = KEY_3,        \
     [3] = KEY_4,        \
     [4] = KEY_5,        \
     [5] = KEY_6,        \
     [6] = KEY_7,        \
     [7] = KEY_8,        \
     [8] = KEY_9,        \
     [9] = KEY_VOLUMEDOWN,       \
     [10] = KEY_VOLUMEUP,        \
     [11] = KEY_0,       \
     [12] = KEY_ENTER,       \
     [13] = KEY_TAB,     \
     [14] = KEY_BACKSPACE,       \
     [15] = KEY_STAR,        \
     [16] = KEY_POUND,       \
     [17] = KEY_SYM,     \
     [18] = KEY_DOT,     \
     [19] = KEY_FN,      \
     [20] = KEY_F1,      \
     [21] = KEY_F2,      \
     [22] = KEY_F3,      \
     [23] = KEY_F4,      \
     [24] = KEY_DEL,     \
     [25] = KEY_S,       \
     [25] = KEY_OK,      \
 }


 //static u16 kpd_keymap[KPD_NUM_KEYS] = KPD_INIT_KEYMAP_FULL(); //KPD_INIT_KEYMAP();
 static u16 kpd_keymap[KPD_NUM_KEYS] = KPD_INIT_KEYMAP();
 static u16 kpd_keymap_state[KPD_NUM_MEMS] = {
     0xffff, 0xffff, 0xffff, 0xffff, 0x00ff
 };
 /*********************************************************************/
 /*************************kpd function decleare***************************/
 /*********************************************************************/
 static int kpd_pdrv_probe(struct platform_device *pdev);
 static int kpd_pdrv_remove(struct platform_device *pdev);
 #ifndef CONFIG_HAS_EARLYSUSPEND
 static int kpd_pdrv_suspend(struct platform_device *pdev, pm_message_t state);
 static int kpd_pdrv_resume(struct platform_device *pdev);
 #endif

 void mtk_kpd_get_gpio_col(unsigned int COL_REG[], unsigned int GPIO_MODE[]);
 void kpd_auto_test_for_factorymode(void);

 static struct platform_driver kpd_pdrv = {
     .probe      = kpd_pdrv_probe,
     .remove     = kpd_pdrv_remove,
 #ifndef CONFIG_HAS_EARLYSUSPEND
     .suspend    = kpd_pdrv_suspend,
     .resume     = kpd_pdrv_resume,
 #endif
     .driver     = {
         .name   = KPD_NAME,
         .owner  = THIS_MODULE,
     },
 };
 /********************************************************************/
 void mtk_kpd_get_gpio_col(unsigned int COL_REG[], unsigned int GPIO_MODE[])
 {
     int i;
     for(i = 0; i< 8; i++)
     {
         COL_REG[i] = 0;
         GPIO_MODE[i] = 0;
     }
     kpd_print("Enter mtk_kpd_get_gpio_col! \n");

     #ifdef GPIO_KPD_KCOL0_PIN
         kpd_print("checking GPIO_KPD_KCOL0_PIN! \n");
         COL_REG[0] = GPIO_KPD_KCOL0_PIN;
         GPIO_MODE[0] |= (GPIO_KPD_KCOL0_PIN_M_KCOL << 4);
     #endif

     #ifdef GPIO_KPD_KCOL1_PIN
         kpd_print("checking GPIO_KPD_KCOL1_PIN! \n");
         COL_REG[1] = GPIO_KPD_KCOL1_PIN;
         GPIO_MODE[1] |= (GPIO_KPD_KCOL1_PIN_M_KCOL << 4);
     #endif

     #ifdef GPIO_KPD_KCOL2_PIN
         kpd_print("checking GPIO_KPD_KCOL2_PIN! \n");
         COL_REG[2] = GPIO_KPD_KCOL2_PIN;
         GPIO_MODE[2] |= (GPIO_KPD_KCOL2_PIN_M_KCOL << 4);
     #endif

     #ifdef GPIO_KPD_KCOL3_PIN
         kpd_print("checking GPIO_KPD_KCOL3_PIN! \n");
         COL_REG[3] = GPIO_KPD_KCOL3_PIN;
         GPIO_MODE[3] |= (GPIO_KPD_KCOL3_PIN_M_KCOL << 4);
     #endif

     #ifdef GPIO_KPD_KCOL4_PIN
         kpd_print("checking GPIO_KPD_KCOL4_PIN! \n");
         COL_REG[4] = GPIO_KPD_KCOL4_PIN;
         GPIO_MODE[4] |= (GPIO_KPD_KCOL4_PIN_M_KCOL << 4);
     #endif

     #ifdef GPIO_KPD_KCOL5_PIN
         kpd_print("checking GPIO_KPD_KCOL5_PIN! \n");
         COL_REG[5] = GPIO_KPD_KCOL5_PIN;
         GPIO_MODE[5] |= (GPIO_KPD_KCOL5_PIN_M_KCOL << 4);
     #endif

     #ifdef GPIO_KPD_KCOL6_PIN
         kpd_print("checking GPIO_KPD_KCOL6_PIN! \n");
         COL_REG[6] = GPIO_KPD_KCOL6_PIN;
         GPIO_MODE[6] |= (GPIO_KPD_KCOL6_PIN_M_KCOL << 4);
     #endif

     #ifdef GPIO_KPD_KCOL7_PIN
         kpd_print("checking GPIO_KPD_KCOL7_PIN! \n");
         COL_REG[7] = GPIO_KPD_KCOL7_PIN;
         GPIO_MODE[7] |= (GPIO_KPD_KCOL7_PIN_M_KCOL << 4);
     #endif
 }

 #ifdef KPD_AUTOTEST_BY_KP
 void kpd_reset_keymap_state(u16 state[])
 {
     int i;
     for(i = 0; i < (KPD_NUM_MEMS - 1); i++)
         state[i] = 0xffff;

     state[(KPD_NUM_MEMS - 1)] = 0x00ff;
     return;
 }

 void kpd_kcol_scan_for_factorymode(void)
 {
     unsigned int COL_REG[8], COL_LAST = 0;
     unsigned int GPIO_MODE[8];
     int i, col_num;

 #if !KPD_USE_EXTEND_TYPE
     kpd_print("Enter kpd_kcol_scan_for_factorymode on single keypad! \n");
     col_num =   8;
 #else
     kpd_print("Enter kpd_kcol_scan_for_factorymode on double keypad! \n");
     col_num =   3;
 #endif

     disable_irq_nosync(MT_KP_IRQ_ID);
     *(volatile u16 *)KP_EN = 0;
     kpd_keymap_handler(1);
     msleep(100);

     mtk_kpd_get_gpio_col(COL_REG, GPIO_MODE);

     for(i = 0; i < col_num; i++)
     {
         if (COL_REG[i] != 0)
             mt_set_gpio_mode(COL_REG[i], GPIO_MODE_GPIO);
     }

     for(i = 0; i < col_num; i++)
     {
         if (COL_REG[i] != 0)
         {
             mt_set_gpio_mode(COL_REG[i], ((GPIO_MODE[i] >> 4) & 0x0f));
             kpd_reset_keymap_state(kpd_keymap_state);
             COL_LAST = COL_REG[i];
             *(volatile u16 *)KP_EN = 0x1;
             kpd_print("kpd_kcol_scan_for_factorymode:  KP enable KCOL=%d \n", i);
         }

         msleep(100);
         if(*(volatile u16 *)KP_STA & 0x01)
                 kpd_keymap_handler(2);

         if(0 != COL_LAST)
         {
             msleep(100);
             kpd_keymap_handler(1);
             *(volatile u16 *)KP_EN = 0;
             mt_set_gpio_mode(COL_LAST, GPIO_MODE_GPIO);
             kpd_print("kpd_kcol_scan_for_factorymode:  KP disable KCOL=%d \n", i);
             COL_LAST = 0;
         }
     }

     for(i = 0; i < col_num; i++)
     {
         if (COL_REG[i] != 0)
             mt_set_gpio_mode(COL_REG[i], ((GPIO_MODE[i] >> 4) & 0x0f));
     }

     kpd_reset_keymap_state(kpd_keymap_state);
     *(volatile u16 *)KP_EN = 0x1;

     if(upmu_get_pwrkey_deb()!=1)
     {
             kpd_pwrkey_pmic_handler(0);
             msleep(100);
             kpd_pwrkey_pmic_handler(1);
     }

     enable_irq(MT_KP_IRQ_ID);
     return;
 }
 #else       //KPD_AUTOTEST_BY_KP
 void kpd_auto_test_for_factorymode(void)
 {
     unsigned int COL_REG[8];
     unsigned int GPIO_MODE[8];
     int i;

     kpd_pwrkey_pmic_handler(1);
     msleep(100);
     kpd_pwrkey_pmic_handler(0);

 #ifdef KPD_PMIC_RSTKEY_MAP
     kpd_pmic_rstkey_handler(1);
     msleep(100);
     kpd_pmic_rstkey_handler(0);
 #endif

     kpd_print("Enter kpd_auto_test_for_factorymode! \n");
     mtk_kpd_get_gpio_col(COL_REG, GPIO_MODE);

     for(i = 0; i < 8; i++)
     {
         if (COL_REG[i] != 0)
         {
             msleep(100);
             kpd_print("kpd kcolumn %d pull down!\n", COL_REG[i]);
             mt_set_gpio_pull_select(COL_REG[i], 0);
             msleep(100);
             kpd_print("kpd kcolumn %d pull up!\n", COL_REG[i]);
             mt_set_gpio_pull_select(COL_REG[i], 1);
         }
     }

     return;
 }
 #endif      //KPD_AUTOTEST_BY_KP

 /********************************************************************/


 /********************************************************************/
 /*****************for kpd auto set wake up source*************************/
 /********************************************************************/
 static volatile int call_status = 0;
 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 ssize_t kpd_show_call_state(struct device_driver *ddri, char *buf)
 {
     ssize_t res;
     res = snprintf(buf, PAGE_SIZE, "%d\n", call_status);
     return res;
 }
 static DRIVER_ATTR(kpd_call_state,  S_IWUSR | S_IRUGO,  kpd_show_call_state,    kpd_store_call_state);

 static struct driver_attribute *kpd_attr_list[] = {
     &driver_attr_kpd_call_state,
 };

 /*----------------------------------------------------------------------------*/
 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 int kpd_delete_attr(struct device_driver *driver)
     {
     int idx ,err = 0;
     int num = (int)(sizeof(kpd_attr_list)/sizeof(kpd_attr_list[0]));

     if (!driver)
     return -EINVAL;

     for (idx = 0; idx < num; idx++)
     {
         driver_remove_file(driver, kpd_attr_list[idx]);
     }

     return err;
 }
 /*----------------------------------------------------------------------------*/
 /********************************************************************/
 /********************************************************************/
 /********************************************************************/

 /* for autotest */
 #if KPD_AUTOTEST
 static const u16 kpd_auto_keymap[] = {
     KEY_OK, KEY_MENU,
     KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT,
     KEY_HOME, KEY_BACK,
     KEY_CALL, KEY_ENDCALL,
     KEY_VOLUMEUP, KEY_VOLUMEDOWN,
     KEY_FOCUS, KEY_CAMERA,
 };
 #endif

 /* for AEE manual dump */
 #define AEE_VOLUMEUP_BIT    0
 #define AEE_VOLUMEDOWN_BIT  1
 #define AEE_DELAY_TIME      15
 /* enable volup + voldown was pressed 5~15 s Trigger aee manual dump */
 #define AEE_ENABLE_5_15     1
 static struct hrtimer aee_timer;
 static unsigned long  aee_pressed_keys;
 static bool aee_timer_started;

 #if AEE_ENABLE_5_15
 #define AEE_DELAY_TIME_5S   5
 static struct hrtimer aee_timer_5s;
 static bool aee_timer_5s_started;
 static bool flags_5s;
 #endif

 static inline void kpd_update_aee_state(void) {
     if(aee_pressed_keys == ((1<
         /* 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
     }
 }

 static void kpd_aee_handler(u32 keycode, u16 pressed) {
     if(pressed) {
         if(keycode == KEY_VOLUMEUP) {
             __set_bit(AEE_VOLUMEUP_BIT, &aee_pressed_keys);
         } else if(keycode == KEY_VOLUMEDOWN) {
             __set_bit(AEE_VOLUMEDOWN_BIT, &aee_pressed_keys);
         } else {
             return;
         }
         kpd_update_aee_state();
     } else {
         if(keycode == KEY_VOLUMEUP) {
             __clear_bit(AEE_VOLUMEUP_BIT, &aee_pressed_keys);
         } else if(keycode == KEY_VOLUMEDOWN) {
             __clear_bit(AEE_VOLUMEDOWN_BIT, &aee_pressed_keys);
         } else {
             return;
         }
         kpd_update_aee_state();
     }
 }

 static enum hrtimer_restart aee_timer_func(struct hrtimer *timer) {
     //printk("kpd: vol up+vol down AEE manual dump!\n");
     //aee_kernel_reminding("manual dump ", "Triggered by press KEY_VOLUMEUP+KEY_VOLUMEDOWN");
     aee_trigger_kdb();
     return HRTIMER_NORESTART;
 }

 #if AEE_ENABLE_5_15
 static enum hrtimer_restart aee_timer_5s_func(struct hrtimer *timer) {

     //printk("kpd: vol up+vol down AEE manual dump timer 5s !\n");
     flags_5s = true;
     return HRTIMER_NORESTART;
 }
 #endif

 static inline void kpd_get_keymap_state(u16 state[])
 {
     state[0] = *(volatile u16 *)KP_MEM1;
     state[1] = *(volatile u16 *)KP_MEM2;
     state[2] = *(volatile u16 *)KP_MEM3;
     state[3] = *(volatile u16 *)KP_MEM4;
     state[4] = *(volatile u16 *)KP_MEM5;
     if (kpd_show_register) {
         printk(KPD_SAY "register = %x %x %x %x %x\n",
                state[0], state[1], state[2], state[3], state[4]);
     }
 }

 static inline void kpd_set_debounce(u16 val)
 {
     mt65xx_reg_sync_writew((u16)(val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);
 }

 #if KPD_DRV_CTRL_BACKLIGHT
 static void kpd_switch_backlight(struct work_struct *work)
 {
     if (kpd_backlight_on) {
         kpd_enable_backlight();
         kpd_print("backlight is on\n");
     } else {
         kpd_disable_backlight();
         kpd_print("backlight is off\n");
     }
 }

 static void kpd_backlight_timeout(unsigned long data)
 {
     if (!atomic_read(&kpd_key_pressed)) {
         kpd_backlight_on = !!atomic_read(&kpd_key_pressed);
         schedule_work(&kpd_backlight_work);
         data = 1;
     }
     kpd_print("backlight timeout%s\n",
               data ? ": schedule backlight work" : "");
 }

 void kpd_backlight_handler(bool pressed, u16 linux_keycode)
 {
     if (kpd_suspend && !test_bit(linux_keycode, kpd_wake_keybit)) {
         kpd_print("Linux keycode %u is not WAKE key\n", linux_keycode);
         return;
     }

     /* not in suspend or the key pressed is WAKE key */
     if (pressed) {
         atomic_inc(&kpd_key_pressed);
         kpd_backlight_on = !!atomic_read(&kpd_key_pressed);
         schedule_work(&kpd_backlight_work);
         kpd_print("switch backlight on\n");
     } else {
         atomic_dec(&kpd_key_pressed);
         mod_timer(&kpd_backlight_timer,
                   jiffies + KPD_BACKLIGHT_TIME * HZ);
         kpd_print("activate backlight timer\n");
     }
 }
 #endif

 #if KPD_HAS_SLIDE_QWERTY
 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 kpd_slide_eint_handler(void)
 {
     tasklet_schedule(&kpd_slide_tasklet);
 }
 #endif

 #if KPD_PWRKEY_USE_EINT
 static void kpd_pwrkey_handler(unsigned long data)
 {
     bool pressed;
     u8 old_state = kpd_pwrkey_state;

     kpd_pwrkey_state = !kpd_pwrkey_state;
     pressed = (kpd_pwrkey_state == !!KPD_PWRKEY_POLARITY);
     if (kpd_show_hw_keycode) {
         printk(KPD_SAY "(%s) HW keycode = using EINT\n",
                pressed ? "pressed" : "released");
     }
     kpd_backlight_handler(pressed, KPD_PWRKEY_MAP);
     input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);
     input_sync(kpd_input_dev);
     kpd_print("report Linux keycode = %u\n", KPD_PWRKEY_MAP);

     /* for detecting the return to old_state */
     mt65xx_eint_set_polarity(KPD_PWRKEY_EINT, old_state);
     mt65xx_eint_unmask(KPD_PWRKEY_EINT);
 }

 static void kpd_pwrkey_eint_handler(void)
 {
     tasklet_schedule(&kpd_pwrkey_tasklet);
 }
 #endif
 /*********************************************************************/
 #if 0//KPD_PWRKEY_USE_PMIC //for 77 chip and earlier version   power key bug, has fixed on 89 chip
 static void kpd_pwrkey_handler(struct work_struct *work)
 {
     int pressed = 1;
     /* report  Press*/
     input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);
     input_sync(kpd_input_dev);
     if (kpd_show_hw_keycode) {
         printk(KPD_SAY "(%s) HW keycode = using PMIC\n",
                pressed ? "pressed" : "released");
     }
     while(1)
     {
         if(upmu_get_pwrkey_deb() == 1)
         {
             pressed = 0;
             /* Report Release */
             input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);
             input_sync(kpd_input_dev);
         if (kpd_show_hw_keycode) {
                printk(KPD_SAY "(%s) HW keycode = using PMIC\n",
                  pressed ? "pressed" : "released");
         }
             break;
         }
         msleep(10);
     }
 }

 void kpd_pwrkey_pmic_handler(unsigned long pressed)
 {
     printk(KPD_SAY "Power Key generate, pressed=%ld\n", pressed);
     if(!kpd_input_dev) {
         printk("KPD input device not ready\n");
         return;
     }
     if(get_chip_eco_ver() == CHIP_E2) {
         input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);
         input_sync(kpd_input_dev);
         if (kpd_show_hw_keycode) {
             printk(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
                    pressed ? "pressed" : "released", KPD_PWRKEY_MAP);
         }
     } else {
         schedule_work(&pwrkey_pmic_work);
     }
 }
 #endif
 /*********************************************************************/
 #if KPD_PWRKEY_USE_PMIC

 void kpd_pwrkey_pmic_handler(unsigned long pressed)
 {
     printk(KPD_SAY "Power Key generate, pressed=%ld\n", pressed);
     if(!kpd_input_dev) {
         printk("KPD input device not ready\n");
         return;
     }

         input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);
         input_sync(kpd_input_dev);
         if (kpd_show_hw_keycode) {
             printk(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
                    pressed ? "pressed" : "released", KPD_PWRKEY_MAP);
         }
 }
 #endif

 /*********************************************************************/
 void kpd_pmic_rstkey_handler(unsigned long pressed)
 {
     printk(KPD_SAY "PMIC reset Key generate, pressed=%ld\n", pressed);
     if(!kpd_input_dev) {
         printk("KPD input device not ready\n");
         return;
     }
 #ifdef KPD_PMIC_RSTKEY_MAP
         input_report_key(kpd_input_dev, KPD_PMIC_RSTKEY_MAP, pressed);
         input_sync(kpd_input_dev);
         if (kpd_show_hw_keycode) {
             printk(KPD_SAY "(%s) HW keycode =%d using PMIC\n",
                    pressed ? "pressed" : "released", 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;

     spin_lock(&keymap_handler_spinlock);
     kpd_get_keymap_state(new_state);

 #ifdef KPD_AUTOTEST_BY_KP
     if(data == 1)
         kpd_reset_keymap_state(new_state);
         kpd_print("kpd_keymap_handler:  data=%d, new_state = %x %x %x %x %x \n",
                      data, new_state[0], new_state[1], new_state[2], new_state[3], new_state[4]);
 #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;
             }

 #ifdef KPD_AUTOTEST_BY_KP
             if((get_boot_mode() != FACTORY_BOOT) && (get_boot_mode() != ATE_FACTORY_BOOT))
 #endif
             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 KPD_AUTOTEST_BY_KP
     if(data == 0)
 #endif
     enable_irq(MT_KP_IRQ_ID);
     spin_unlock(&keymap_handler_spinlock);
 }

 static irqreturn_t kpd_irq_handler(int irq, void *dev_id)
 {
     /* use _nosync to avoid deadlock */
     disable_irq_nosync(MT_KP_IRQ_ID);

     tasklet_schedule(&kpd_keymap_tasklet);
     return IRQ_HANDLED;
 }

 static long kpd_dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
     void __user *uarg = (void __user *)arg;
     struct kpd_ledctl ledctl;

     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)){
         printk("[AUTOTEST] PRESS OK KEY!!\n");
         input_report_key(kpd_input_dev, KEY_OK, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support OK KEY!!\n");
         }
         break;
     case RELEASE_OK_KEY:
         if(test_bit(KEY_OK, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE OK KEY!!\n");
         input_report_key(kpd_input_dev, KEY_OK, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support OK KEY!!\n");
         }
         break;
     case PRESS_MENU_KEY:
         if(test_bit(KEY_MENU, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS MENU KEY!!\n");
         input_report_key(kpd_input_dev, KEY_MENU, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support MENU KEY!!\n");
         }
         break;
     case RELEASE_MENU_KEY:
         if(test_bit(KEY_MENU, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE MENU KEY!!\n");
         input_report_key(kpd_input_dev, KEY_MENU, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support MENU KEY!!\n");
         }

         break;
     case PRESS_UP_KEY:
         if(test_bit(KEY_UP, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS UP KEY!!\n");
         input_report_key(kpd_input_dev, KEY_UP, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support UP KEY!!\n");
         }
         break;
     case RELEASE_UP_KEY:
         if(test_bit(KEY_UP, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE UP KEY!!\n");
         input_report_key(kpd_input_dev, KEY_UP, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support UP KEY!!\n");
         }
         break;
     case PRESS_DOWN_KEY:
         if(test_bit(KEY_DOWN, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS DOWN KEY!!\n");
         input_report_key(kpd_input_dev, KEY_DOWN, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support DOWN KEY!!\n");
         }
         break;
     case RELEASE_DOWN_KEY:
         if(test_bit(KEY_DOWN, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE DOWN KEY!!\n");
         input_report_key(kpd_input_dev, KEY_DOWN, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support DOWN KEY!!\n");
         }
         break;
     case PRESS_LEFT_KEY:
         if(test_bit(KEY_LEFT, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS LEFT KEY!!\n");
         input_report_key(kpd_input_dev, KEY_LEFT, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support LEFT KEY!!\n");
         }
         break;
     case RELEASE_LEFT_KEY:
         if(test_bit(KEY_LEFT, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE LEFT KEY!!\n");
         input_report_key(kpd_input_dev, KEY_LEFT, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support LEFT KEY!!\n");
         }
         break;
     case PRESS_RIGHT_KEY:
         if(test_bit(KEY_RIGHT, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS RIGHT KEY!!\n");
         input_report_key(kpd_input_dev, KEY_RIGHT, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support RIGHT KEY!!\n");
         }
         break;
     case RELEASE_RIGHT_KEY:
         if(test_bit(KEY_RIGHT, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE RIGHT KEY!!\n");
         input_report_key(kpd_input_dev, KEY_RIGHT, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support RIGHT KEY!!\n");
         }
         break;
     case PRESS_HOME_KEY:
         if(test_bit(KEY_HOME, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS HOME KEY!!\n");
         input_report_key(kpd_input_dev, KEY_HOME, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support HOME KEY!!\n");
         }
         break;
     case RELEASE_HOME_KEY:
         if(test_bit(KEY_HOME, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE HOME KEY!!\n");
         input_report_key(kpd_input_dev, KEY_HOME, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support HOME KEY!!\n");
         }
         break;
     case PRESS_BACK_KEY:
         if(test_bit(KEY_BACK, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS BACK KEY!!\n");
         input_report_key(kpd_input_dev, KEY_BACK, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support BACK KEY!!\n");
         }
         break;
     case RELEASE_BACK_KEY:
         if(test_bit(KEY_BACK, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE BACK KEY!!\n");
         input_report_key(kpd_input_dev, KEY_BACK, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support BACK KEY!!\n");
         }
         break;
     case PRESS_CALL_KEY:
         if(test_bit(KEY_CALL, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS CALL KEY!!\n");
         input_report_key(kpd_input_dev, KEY_CALL, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support CALL KEY!!\n");
         }
         break;
     case RELEASE_CALL_KEY:
         if(test_bit(KEY_CALL, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE CALL KEY!!\n");
         input_report_key(kpd_input_dev, KEY_CALL, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support CALL KEY!!\n");
         }
         break;
     case PRESS_ENDCALL_KEY:
         if(test_bit(KEY_ENDCALL, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS ENDCALL KEY!!\n");
         input_report_key(kpd_input_dev, KEY_ENDCALL, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support ENDCALL KEY!!\n");
         }
         break;
     case RELEASE_ENDCALL_KEY:
         if(test_bit(KEY_ENDCALL, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE ENDCALL KEY!!\n");
         input_report_key(kpd_input_dev, KEY_ENDCALL, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support ENDCALL KEY!!\n");
         }
         break;
     case PRESS_VLUP_KEY:
         if(test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS VOLUMEUP KEY!!\n");
         input_report_key(kpd_input_dev, KEY_VOLUMEUP, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");
         }
         break;
     case RELEASE_VLUP_KEY:
         if(test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE VOLUMEUP KEY!!\n");
         input_report_key(kpd_input_dev, KEY_VOLUMEUP, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");
         }
         break;
     case PRESS_VLDOWN_KEY:
         if(test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS VOLUMEDOWN KEY!!\n");
         input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");
         }
         break;
     case RELEASE_VLDOWN_KEY:
         if(test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE VOLUMEDOWN KEY!!\n");
         input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");
         }
         break;
     case PRESS_FOCUS_KEY:
         if(test_bit(KEY_FOCUS, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS FOCUS KEY!!\n");
         input_report_key(kpd_input_dev, KEY_FOCUS, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support FOCUS KEY!!\n");
         }
         break;
     case RELEASE_FOCUS_KEY:
         if(test_bit(KEY_FOCUS, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE FOCUS KEY!!\n");
         input_report_key(kpd_input_dev, KEY_FOCUS, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support RELEASE KEY!!\n");
         }
         break;
     case PRESS_CAMERA_KEY:
         if(test_bit(KEY_CAMERA, kpd_input_dev->keybit)){
         printk("[AUTOTEST] PRESS CAMERA KEY!!\n");
         input_report_key(kpd_input_dev, KEY_CAMERA, 1);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support CAMERA KEY!!\n");
         }
         break;
     case RELEASE_CAMERA_KEY:
         if(test_bit(KEY_CAMERA, kpd_input_dev->keybit)){
         printk("[AUTOTEST] RELEASE CAMERA KEY!!\n");
         input_report_key(kpd_input_dev, KEY_CAMERA, 0);
         input_sync(kpd_input_dev);
         }else{
             printk("[AUTOTEST] Not Support CAMERA KEY!!\n");
         }
         break;
 #endif

     case SET_KPD_BACKLIGHT:
         if (copy_from_user(&ledctl, uarg, sizeof(struct kpd_ledctl)))
             return -EFAULT;

         //kpd_set_backlight(ledctl.onoff, &ledctl.div, &ledctl.duty);
         break;

     case SET_KPD_KCOL:
 #ifndef KPD_AUTOTEST_BY_KP
         kpd_auto_test_for_factorymode();
 #else
         kpd_kcol_scan_for_factorymode();
 #endif
         printk("[kpd_auto_test_for_factorymode] test performed!!\n");
         break;
     default:
         return -EINVAL;
     }

     return 0;
 }

 static int kpd_dev_open(struct inode *inode, struct file *file)
 {
     return 0;
 }

 static struct file_operations kpd_dev_fops = {
     .owner      = THIS_MODULE,
     .unlocked_ioctl = kpd_dev_ioctl,
     .open       = kpd_dev_open,
 };

 static struct miscdevice kpd_dev = {
     .minor  = MISC_DYNAMIC_MINOR,
     .name   = KPD_NAME,
     .fops   = &kpd_dev_fops,
 };

 static int kpd_open(struct input_dev *dev)
 {
 #if KPD_HAS_SLIDE_QWERTY
     bool evdev_flag=false;
     bool power_op=false;
     struct input_handler *handler;
     struct input_handle *handle;
     handle = rcu_dereference(dev->grab);
     if (handle)
     {
         handler = handle->handler;
         if(strcmp(handler->name, "evdev")==0)
         {
             return -1;
         }
     }
     else
     {
         list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
             handler = handle->handler;
             if(strcmp(handler->name, "evdev")==0)
             {
                 evdev_flag=true;
                 break;
             }
         }
         if(evdev_flag==false)
         {
             return -1;
         }
     }

     power_op = powerOn_slidePin_interface();
     if(!power_op) {
         printk(KPD_SAY "Qwerty slide pin interface power on fail\n");
     } else {
         kpd_print("Qwerty slide pin interface power on success\n");
     }

     mt65xx_eint_set_sens(KPD_SLIDE_EINT, KPD_SLIDE_SENSITIVE);
     mt65xx_eint_set_hw_debounce(KPD_SLIDE_EINT, KPD_SLIDE_DEBOUNCE);
     mt65xx_eint_registration(KPD_SLIDE_EINT, true, KPD_SLIDE_POLARITY,
                              kpd_slide_eint_handler, false);

     power_op = powerOff_slidePin_interface();
     if(!power_op) {
         printk(KPD_SAY "Qwerty slide pin interface power off fail\n");
     } else {
         kpd_print("Qwerty slide pin interface power off success\n");
     }

 #if 0
     /*qwerty slide: GPIO 214. input, mode=EINT, pull enbale, pull select high*/
     mt_set_gpio_mode(214, 2);
     mt_set_gpio_dir(214, 0);
     mt_set_gpio_pull_enable(214, 1);
     mt_set_gpio_pull_select(214, 0);
 #endif
 #endif
     return 0;
 }





 #if 1 // AW9523  扩展键盘IC:

 #define GPIO_SIMULATE_I2C

 #define AW9523_EINT_GPIO               GPIO144
 #define AW9523_EINT_NO                 5  //CUST_EINT_MHALL_NUM

 #define AW9523_RESET_PIN GPIO128

 #define KPD_AW9523_SWITCH_DEBOUNCE       10   //50  // 30
 #define KPD_AW9523_SWITCH_POLARITY          CUST_EINT_MHALL_POLARITY
 #define KPD_AW9523_SWITCH_SENSITIVE      CUST_EINT_EDGE_SENSITIVE  // CUST_EINT_MHALL_SENSITIVE

 static void kpd_aw9523_handler(unsigned long data);
 static DECLARE_TASKLET(kpd_aw9523_tasklet, kpd_aw9523_handler, 0);
 static u8 kpd_aw9523_state = !CUST_EINT_POLARITY_LOW;

 #define LED_SLAVE_ADDR        0xb0//0xB6
 //#if defined(GPIO_SIMULATE_I2C)
 #define I2C_SDA_GPIO         GPIO114    //GPIO111      // ROW1
 #define I2C_SCL_GPIO         GPIO113    //GPIO108      // COL1

 typedef enum {
 P0_0=0,
 P0_1,
 P0_2,
 P0_3,
 P0_4,
 P0_5,
 P0_6,
 P0_7
 } P0_Enum;

 typedef enum {
 P1_0=0,
 P1_1,
 P1_2,
 P1_3,
 P1_4,
 P1_5,
 P1_6,
 P1_7
 } P1_Enum;

 #define AW9523_I2C_MAX_LOOP 50

 #define Y_NUM  6
 #define X_NUM  6                // has pullup resistor

 //  P0 ---> X_NUM ---> col         input
 //  P1 ---> Y_NUM ---> line(row)   output
 const P0_Enum COL[X_NUM] =  {P0_0, P0_1, P0_2, P0_3, P0_4, P0_5};
 //const P1_Enum Line[Y_NUM] = {P1_2, P1_3, P1_4, P1_5, P1_6, P1_7};
 const P1_Enum Line[Y_NUM] = {P1_0, P1_1, P1_2, P1_3, P1_4, P1_5};

 const u8  aw9523_key[Y_NUM][X_NUM]={
 //     1          2          3          4              5              6
 /*
     {KEY_7,     KEY_8,    KEY_9, KEY_POUND,         KEY_OK,         KEY_BACK},
     {KEY_4,     KEY_5,      KEY_6,  KEY_STAR        ,KEY_1,     KEY_2},
     {KEY_LEFT,  KEY_UP,      KEY_MENU,     KEY_RIGHT,         KEY_DOWN,         KEY_HOME},
     {KEY_A, KEY_0,   KEY_B, KEY_C,         KEY_D,         KEY_S},       //SCAN here
     {KEY_E,     KEY_F,      KEY_G,     KEY_H,   KEY_I,         KEY_J},
     {KEY_K,     KEY_L,      KEY_M,     KEY_N,         KEY_O,         KEY_P},
 */

     {KEY_F1,     KEY_F2,    KEY_F3, KEY_F4,         KEY_DEL,         KEY_3},
     {KEY_FN,     KEY_0,      KEY_DOT,  KEY_SYM      ,KEY_OK,     KEY_ENTER},