MTK keypad调试，扩张键盘IC AW9523

其他 2018-10-07 03:26:02 阅读次数: 0

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

[java]  view plain  copy
  1.  public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags, boolean isScreenOn) {  
  2.      if (!mSystemBooted) {  
  3.          // If we have not yet booted, don't let key events do anything.  
  4.          return 0;  
  5.      }  
  6.   
  7.  // Handle special keys.  
  8.      switch (keyCode) {  
  9.          //add by //SCAN_123  ---  
  10. case KeyEvent.KEYCODE_FN:  
  11.     if (down){  
  12.         fnflag = (!fnflag);  
  13.         Log.i(TAG, "fn status is " + fnflag);  
  14.         result &= ~ACTION_PASS_TO_USER;  
  15.         //add fn icon   trs 2012-07-20  
  16.         Intent intent = new Intent(Intent.ACTION_FN_STATUS);  
  17.         intent.putExtra("fn_status", fnflag);  
  18.         mContext.sendBroadcast(intent);  
  19.     }  
  20.     break;  
  21. case KeyEvent.KEYCODE_F1:  
  22. case KeyEvent.KEYCODE_F2:  
  23. case KeyEvent.KEYCODE_F3:  
  24. case KeyEvent.KEYCODE_F4:  
  25.     if (!down){  
  26.         handleFKeys(keyCode);  
  27.     }  
  28.     result &= ~ACTION_PASS_TO_USER;  
  29.     break;  
  30. //add end//SCAN_123 ---       


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

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

[java]  view plain  copy
  1. public class KeyEvent extends InputEvent implements Parcelable {  
  2.     /** Key code constant: Unknown key code. */  
  3.     public static final int KEYCODE_UNKNOWN         = 0;  
  4.     /** Key code constant: Soft Left key. 
  5.      * Usually situated below the display on phones and used as a multi-function 
  6.      * feature key for selecting a software defined function shown on the bottom left 
  7.      * of the display. */  
  8.     public static final int KEYCODE_SOFT_LEFT       = 1;  
  9.     /** Key code constant: Soft Right key. 
  10.      * Usually situated below the display on phones and used as a multi-function 
  11.      * feature key for selecting a software defined function shown on the bottom right 
  12.      * of the display. */  
  13.     public static final int KEYCODE_SOFT_RIGHT      = 2;  
  14.     /** Key code constant: Home key. 
  15.      * This key is handled by the framework and is never delivered to applications. */  
  16.     public static final int KEYCODE_HOME            = 3;  
  17.     /** Key code constant: Back key. */  
  18.     public static final int KEYCODE_BACK            = 4;  
  19.     /** Key code constant: Call key. */  
  20.     public static final int KEYCODE_CALL            = 5;  
[java]  view plain  copy
  1.     public static final int KEYCODE_KANA            = 218;  
  2.     /** Key code constant: Assist key. 
  3.      * Launches the global assist activity.  Not delivered to applications. */  
  4.     public static final int KEYCODE_ASSIST          = 219;  
  5.     public static final int KEYCODE_SCAN          = 220;//sam add   
  6.     public static final int KEYCODE_SCAN_LEFT          = 221;  
  7.     public static final int KEYCODE_SCAN_RIGHT          = 222;  
  8.     public static final int KEYCODE_FN             = 223;  
  9.     private static final int LAST_KEYCODE           = KEYCODE_FN;//KEYCODE_ASSIST;////  
  10.   
  11.      private static void populateKeycodeSymbolicNames() {  
  12.         SparseArray<String> names = KEYCODE_SYMBOLIC_NAMES;  
  13.         names.append(KEYCODE_UNKNOWN, "KEYCODE_UNKNOWN");  
  14.         names.append(KEYCODE_SOFT_LEFT, "KEYCODE_SOFT_LEFT");  
  15.         names.append(KEYCODE_SOFT_RIGHT, "KEYCODE_SOFT_RIGHT");  
  16.         names.append(KEYCODE_HOME, "KEYCODE_HOME");  
  17.         names.append(KEYCODE_BACK, "KEYCODE_BACK");  
  18.         names.append(KEYCODE_CALL, "KEYCODE_CALL");  
  19.         names.append(KEYCODE_ENDCALL, "KEYCODE_ENDCALL");  
  20.         names.append(KEYCODE_0, "KEYCODE_0");  

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

[java]  view plain  copy
  1. field public static final int KEYCODE_HOME = 3; // 0x3  //与上面的数字值要一样。  
  2. ...  
  3. field public static final int META_SHIFT_RIGHT_ON = 128; // 0x80  
  4. field public static final int META_SYM_ON = 4; // 0x4  
  5. field public static final int KEYCODE_SCAN = 220; // 0xdc  
  6. field public static final int KEYCODE_SCAN_LEFT = 221; // 0xdd  
  7. field public static final int KEYCODE_SCAN_RIGHT = 221; // 0xde  


---

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

[cpp]  view plain  copy
  1.     AKEYCODE_KANA            = 218,  
  2.     AKEYCODE_ASSIST          = 219,  
  3.     AKEYCODE_SCAN            = 220,//sam add  
  4.     AKEYCODE_SCAN_LEFT       = 221,  
  5.     AKEYCODE_SCAN_RIGHT      = 222,  
  6.     AKEYCODE_FN              = 223,  
  7.     // NOTE: If you add a new keycode here you must also add it to several other files.  
  8.     //       Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.  
  9. };  

---

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

[cpp]  view plain  copy
  1. bool KeyEvent::isSystemKey(int32_t keyCode) {  
  2.     switch (keyCode) {  
  3.         case AKEYCODE_MENU:  
  4.         case AKEYCODE_SOFT_RIGHT:  
  5.         case AKEYCODE_HOME:  
  6.         case AKEYCODE_BACK:  
  7.         case AKEYCODE_CALL:  
  8.         ....  
  9.         case AKEYCODE_SEARCH:  
  10.         case AKEYCODE_SCAN://sam add --below...  
  11.         case AKEYCODE_SCAN_LEFT:  
  12.         case AKEYCODE_SCAN_RIGHT:  
  13.         case AKEYCODE_FN:  
  14.         case AKEYCODE_F1:  
  15.         case AKEYCODE_F2:  
  16.         case AKEYCODE_F3:  
  17.         case AKEYCODE_F4:  
  18.             return true;  
  19.     }  


----

alps\frameworks\native\include\input\KeycodeLabels.h
...
static const KeycodeLabel KEYCODES[] = {//下层与上层的对照,能过字符串把两个数字来找的。
 
[cpp]  view plain  copy
  1.   { "SOFT_LEFT", 1 },  
  2.    { "SOFT_RIGHT", 2 },  
  3.    { "HOME", 3 },  
  4.    { "BACK", 4 },  
  5. ...  
  6.     { "KANA", 218 },  
  7.     { "ASSIST", 219 },  
  8.     { "SCAN", 220 },//sam add  
  9.     { "SCAN_LEFT", 221 },  
  10.     { "SCAN_RIGHT", 222 },  
  11.     { "FN", 223 },  
  12.     // NOTE: If you add a new keycode here you must also add it to several other files.  
  13.     //       Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.  
  14.   
  15.   
  16.     { NULL, 0 }  
  17. };  



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

[objc]  view plain  copy
  1. key 102   HOME  
  2. ...  
  3. key 59   F1  
  4. key 60   F2  
  5. key 61   F3  
  6. key 62   F4  
  7. key 464  FN  
  8.   
  9. key 220   SCAN  
  10. key 125   SCAN_LEFT  
  11. 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.
[cpp]  view plain  copy
  1. </pre><pre code_snippet_id="378654" snippet_file_name="blog_20140605_4_3325559" name="code" class="cpp">alps\mediatek\platform\mt6572\kernel\drivers\keypad\kpd.c  
[cpp]  view plain  copy
  1. /* 
  2.  * Copyright (C) 2010 MediaTek, Inc. 
  3.  * 
  4.  * Author: Terry Chang <[email protected]> 
  5.  * 
  6.  * This software is licensed under the terms of the GNU General Public 
  7.  * License version 2, as published by the Free Software Foundation, and 
  8.  * may be copied, distributed, and modified under those terms. 
  9.  * 
  10.  * This program is distributed in the hope that it will be useful, 
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of 
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
  13.  * GNU General Public License for more details. 
  14.  * 
  15.  */  
  16.   
  17. #include <linux/init.h>  
  18. #include <linux/module.h>  
  19. #include <linux/kernel.h>  
  20. #include <linux/input.h>  
  21. #include <linux/workqueue.h>  
  22. #include <linux/timer.h>  
  23. #include <linux/interrupt.h>  
  24. #include <linux/fs.h>  
  25. #include <linux/miscdevice.h>  
  26. #include <linux/platform_device.h>  
  27. #include <linux/earlysuspend.h>  
  28. #include <linux/spinlock.h>  
  29.   
  30. #include <asm/atomic.h>  
  31. #include <asm/uaccess.h>  
  32.   
  33.   
  34. #include <mach/mt_reg_base.h>  
  35. #include <mach/mt_boot.h>  
  36. #include <mtk_kpd.h>      /* custom file */  
  37. #include <mach/irqs.h>  
  38. #include <mach/eint.h>  
  39. #include <mach/mt_gpio.h>  
  40. #include <mach/mt_pmic_wrap.h>  
  41. #include <mach/mt_sleep.h>  
  42. #include <mach/kpd.h>  
  43. #include <mach/sync_write.h>  
  44.   
  45. #include <linux/aee.h>  
  46.   
  47. #if 1   //ATA_TEST  
  48. #define KPD_AUTOTEST_BY_KP    
  49. #endif  
  50.   
  51. #define KPD_NAME    "mtk-kpd"  
  52.   
  53. /* Keypad registers */  
  54. #define KP_STA          (KP_BASE + 0x0000)  
  55. #define KP_MEM1         (KP_BASE + 0x0004)  
  56. #define KP_MEM2         (KP_BASE + 0x0008)  
  57. #define KP_MEM3         (KP_BASE + 0x000c)  
  58. #define KP_MEM4         (KP_BASE + 0x0010)  
  59. #define KP_MEM5         (KP_BASE + 0x0014)  
  60. #define KP_DEBOUNCE     (KP_BASE + 0x0018)  
  61. #define KP_SCAN_TIMING      (KP_BASE + 0x001C)  
  62. #define KP_SEL          (KP_BASE + 0x0020)  
  63. #define KP_EN           (KP_BASE + 0x0024)  
  64.   
  65. #define KPD_NUM_MEMS    5  
  66. #define KPD_MEM5_BITS   8  
  67.   
  68. #define KPD_NUM_KEYS    72  /* 4 * 16 + KPD_MEM5_BITS */  
  69.   
  70. #define KPD_DEBOUNCE_MASK   ((1U << 14) - 1)  
  71.   
  72. #define KPD_SAY     "kpd: "  
  73. #if KPD_DEBUG  
  74. #define kpd_print(fmt, arg...)  printk(KPD_SAY fmt, ##arg)  
  75. #else  
  76. #define kpd_print(fmt, arg...)  do {} while (0)  
  77. #endif  
  78.   
  79.   
  80. static struct input_dev *kpd_input_dev;  
  81. static bool kpd_suspend = false;  
  82. static int kpd_show_hw_keycode = 1;  
  83. static int kpd_show_register = 1;  
  84. static int kpd_enable_lprst = 1;  
  85.   
  86. /* for AEE manual dump */  
  87. #if 0  
  88. static bool kpd_volumn_down_flag = false;  
  89. static bool kpd_volumn_up_flag = false;  
  90. static inline void check_aee_dump()  
  91. {  
  92.     if( (kpd_volumn_down_flag == true) && (kpd_volumn_up_flag == true))  
  93.     {  
  94.         printk(KPD_SAY "kpd_volumn_up+ volumn_down,will trige DB\n");  
  95.         aee_kernel_reminding("manual dump ", "Triggered by press KEY_VOLUMEUP+KEY_VOLUMEDOWN");  
  96.     }  
  97. }  
  98. #endif  
  99.   
  100. /* for backlight control */  
  101. #if KPD_DRV_CTRL_BACKLIGHT  
  102. static void kpd_switch_backlight(struct work_struct *work);  
  103. static void kpd_backlight_timeout(unsigned long data);  
  104. static DECLARE_WORK(kpd_backlight_work, kpd_switch_backlight);  
  105. static DEFINE_TIMER(kpd_backlight_timer, kpd_backlight_timeout, 0, 0);  
  106.   
  107. static unsigned long kpd_wake_keybit[BITS_TO_LONGS(KEY_CNT)];  
  108. static u16 kpd_wake_key[] __initdata = KPD_BACKLIGHT_WAKE_KEY;  
  109.   
  110. static volatile bool kpd_backlight_on;  
  111. static atomic_t kpd_key_pressed = ATOMIC_INIT(0);  
  112. #endif  
  113.   
  114. /* for slide QWERTY */  
  115. #if KPD_HAS_SLIDE_QWERTY  
  116. static void kpd_slide_handler(unsigned long data);  
  117. static DECLARE_TASKLET(kpd_slide_tasklet, kpd_slide_handler, 0);  
  118.   
  119. static u8 kpd_slide_state = !KPD_SLIDE_POLARITY;  
  120. #endif  
  121.   
  122. /* for Power key using EINT */  
  123. #if KPD_PWRKEY_USE_EINT  
  124. static void kpd_pwrkey_handler(unsigned long data);  
  125. static DECLARE_TASKLET(kpd_pwrkey_tasklet, kpd_pwrkey_handler, 0);  
  126. static u8 kpd_pwrkey_state = !KPD_PWRKEY_POLARITY;  
  127. #endif  
  128.   
  129. /* for Power key using PMIC */  
  130. /*********************************************************************/  
  131. #if 0//KPD_PWRKEY_USE_PMIC //for 77 chip and earlier version   power key bug, has fixed on 89 chip  
  132.   
  133. static void kpd_pwrkey_handler(struct work_struct *work);  
  134. static DECLARE_WORK(pwrkey_pmic_work, kpd_pwrkey_handler);  
  135. #endif  
  136. /*********************************************************************/  
  137.   
  138. /* for keymap handling */  
  139. static DEFINE_SPINLOCK(keymap_handler_spinlock);  
  140. static void kpd_keymap_handler(unsigned long data);  
  141. static DECLARE_TASKLET(kpd_keymap_tasklet, kpd_keymap_handler, 0);  
  142.   
  143.   
  144. #define KPD_INIT_KEYMAP_FULL()  \  
  145. {   \  
  146.     [0] = KEY_1,        \  
  147.     [1] = KEY_2,        \  
  148.     [2] = KEY_3,        \  
  149.     [3] = KEY_4,        \  
  150.     [4] = KEY_5,        \  
  151.     [5] = KEY_6,        \  
  152.     [6] = KEY_7,        \  
  153.     [7] = KEY_8,        \  
  154.     [8] = KEY_9,        \  
  155.     [9] = KEY_VOLUMEDOWN,       \  
  156.     [10] = KEY_VOLUMEUP,        \  
  157.     [11] = KEY_0,       \  
  158.     [12] = KEY_ENTER,       \  
  159.     [13] = KEY_TAB,     \  
  160.     [14] = KEY_BACKSPACE,       \  
  161.     [15] = KEY_STAR,        \  
  162.     [16] = KEY_POUND,       \  
  163.     [17] = KEY_SYM,     \  
  164.     [18] = KEY_DOT,     \  
  165.     [19] = KEY_FN,      \  
  166.     [20] = KEY_F1,      \  
  167.     [21] = KEY_F2,      \  
  168.     [22] = KEY_F3,      \  
  169.     [23] = KEY_F4,      \  
  170.     [24] = KEY_DEL,     \  
  171.     [25] = KEY_S,       \     
  172.     [25] = KEY_OK,      \         
  173. }      
  174.   
  175.   
  176. //static u16 kpd_keymap[KPD_NUM_KEYS] = KPD_INIT_KEYMAP_FULL(); //KPD_INIT_KEYMAP();  
  177. static u16 kpd_keymap[KPD_NUM_KEYS] = KPD_INIT_KEYMAP();  
  178. static u16 kpd_keymap_state[KPD_NUM_MEMS] = {  
  179.     0xffff, 0xffff, 0xffff, 0xffff, 0x00ff  
  180. };  
  181. /*********************************************************************/  
  182. /*************************kpd function decleare***************************/  
  183. /*********************************************************************/  
  184. static int kpd_pdrv_probe(struct platform_device *pdev);  
  185. static int kpd_pdrv_remove(struct platform_device *pdev);  
  186. #ifndef CONFIG_HAS_EARLYSUSPEND   
  187. static int kpd_pdrv_suspend(struct platform_device *pdev, pm_message_t state);  
  188. static int kpd_pdrv_resume(struct platform_device *pdev);  
  189. #endif  
  190.   
  191. void mtk_kpd_get_gpio_col(unsigned int COL_REG[], unsigned int GPIO_MODE[]);  
  192. void kpd_auto_test_for_factorymode(void);  
  193.   
  194. static struct platform_driver kpd_pdrv = {  
  195.     .probe      = kpd_pdrv_probe,  
  196.     .remove     = kpd_pdrv_remove,  
  197. #ifndef CONFIG_HAS_EARLYSUSPEND   
  198.     .suspend    = kpd_pdrv_suspend,  
  199.     .resume     = kpd_pdrv_resume,  
  200. #endif    
  201.     .driver     = {  
  202.         .name   = KPD_NAME,  
  203.         .owner  = THIS_MODULE,  
  204.     },  
  205. };  
  206. /********************************************************************/  
  207. void mtk_kpd_get_gpio_col(unsigned int COL_REG[], unsigned int GPIO_MODE[])  
  208. {  
  209.     int i;  
  210.     for(i = 0; i< 8; i++)  
  211.     {  
  212.         COL_REG[i] = 0;  
  213.         GPIO_MODE[i] = 0;  
  214.     }  
  215.     kpd_print("Enter mtk_kpd_get_gpio_col! \n");  
  216.       
  217.     #ifdef GPIO_KPD_KCOL0_PIN  
  218.         kpd_print("checking GPIO_KPD_KCOL0_PIN! \n");  
  219.         COL_REG[0] = GPIO_KPD_KCOL0_PIN;  
  220.         GPIO_MODE[0] |= (GPIO_KPD_KCOL0_PIN_M_KCOL << 4);  
  221.     #endif  
  222.   
  223.     #ifdef GPIO_KPD_KCOL1_PIN  
  224.         kpd_print("checking GPIO_KPD_KCOL1_PIN! \n");  
  225.         COL_REG[1] = GPIO_KPD_KCOL1_PIN;  
  226.         GPIO_MODE[1] |= (GPIO_KPD_KCOL1_PIN_M_KCOL << 4);  
  227.     #endif  
  228.   
  229.     #ifdef GPIO_KPD_KCOL2_PIN  
  230.         kpd_print("checking GPIO_KPD_KCOL2_PIN! \n");  
  231.         COL_REG[2] = GPIO_KPD_KCOL2_PIN;  
  232.         GPIO_MODE[2] |= (GPIO_KPD_KCOL2_PIN_M_KCOL << 4);  
  233.     #endif  
  234.   
  235.     #ifdef GPIO_KPD_KCOL3_PIN  
  236.         kpd_print("checking GPIO_KPD_KCOL3_PIN! \n");  
  237.         COL_REG[3] = GPIO_KPD_KCOL3_PIN;  
  238.         GPIO_MODE[3] |= (GPIO_KPD_KCOL3_PIN_M_KCOL << 4);  
  239.     #endif  
  240.   
  241.     #ifdef GPIO_KPD_KCOL4_PIN  
  242.         kpd_print("checking GPIO_KPD_KCOL4_PIN! \n");  
  243.         COL_REG[4] = GPIO_KPD_KCOL4_PIN;  
  244.         GPIO_MODE[4] |= (GPIO_KPD_KCOL4_PIN_M_KCOL << 4);  
  245.     #endif  
  246.   
  247.     #ifdef GPIO_KPD_KCOL5_PIN  
  248.         kpd_print("checking GPIO_KPD_KCOL5_PIN! \n");  
  249.         COL_REG[5] = GPIO_KPD_KCOL5_PIN;  
  250.         GPIO_MODE[5] |= (GPIO_KPD_KCOL5_PIN_M_KCOL << 4);  
  251.     #endif  
  252.   
  253.     #ifdef GPIO_KPD_KCOL6_PIN  
  254.         kpd_print("checking GPIO_KPD_KCOL6_PIN! \n");  
  255.         COL_REG[6] = GPIO_KPD_KCOL6_PIN;  
  256.         GPIO_MODE[6] |= (GPIO_KPD_KCOL6_PIN_M_KCOL << 4);  
  257.     #endif  
  258.   
  259.     #ifdef GPIO_KPD_KCOL7_PIN  
  260.         kpd_print("checking GPIO_KPD_KCOL7_PIN! \n");  
  261.         COL_REG[7] = GPIO_KPD_KCOL7_PIN;  
  262.         GPIO_MODE[7] |= (GPIO_KPD_KCOL7_PIN_M_KCOL << 4);  
  263.     #endif  
  264. }  
  265.   
  266. #ifdef KPD_AUTOTEST_BY_KP  
  267. void kpd_reset_keymap_state(u16 state[])  
  268. {  
  269.     int i;  
  270.     for(i = 0; i < (KPD_NUM_MEMS - 1); i++)  
  271.         state[i] = 0xffff;  
  272.       
  273.     state[(KPD_NUM_MEMS - 1)] = 0x00ff;  
  274.     return;  
  275. }  
  276.   
  277. void kpd_kcol_scan_for_factorymode(void)  
  278. {  
  279.     unsigned int COL_REG[8], COL_LAST = 0;  
  280.     unsigned int GPIO_MODE[8];  
  281.     int i, col_num;  
  282.       
  283. #if !KPD_USE_EXTEND_TYPE  
  284.     kpd_print("Enter kpd_kcol_scan_for_factorymode on single keypad! \n");  
  285.     col_num =   8;  
  286. #else                 
  287.     kpd_print("Enter kpd_kcol_scan_for_factorymode on double keypad! \n");    
  288.     col_num =   3;  
  289. #endif    
  290.       
  291.     disable_irq_nosync(MT_KP_IRQ_ID);  
  292.     *(volatile u16 *)KP_EN = 0;  
  293.     kpd_keymap_handler(1);  
  294.     msleep(100);      
  295.       
  296.     mtk_kpd_get_gpio_col(COL_REG, GPIO_MODE);  
  297.       
  298.     for(i = 0; i < col_num; i++)  
  299.     {  
  300.         if (COL_REG[i] != 0)  
  301.             mt_set_gpio_mode(COL_REG[i], GPIO_MODE_GPIO);  
  302.     }  
  303.   
  304.     for(i = 0; i < col_num; i++)  
  305.     {  
  306.         if (COL_REG[i] != 0)  
  307.         {  
  308.             mt_set_gpio_mode(COL_REG[i], ((GPIO_MODE[i] >> 4) & 0x0f));  
  309.             kpd_reset_keymap_state(kpd_keymap_state);  
  310.             COL_LAST = COL_REG[i];  
  311.             *(volatile u16 *)KP_EN = 0x1;  
  312.             kpd_print("kpd_kcol_scan_for_factorymode:  KP enable KCOL=%d \n", i);  
  313.         }  
  314.                                 
  315.         msleep(100);  
  316.         if(*(volatile u16 *)KP_STA & 0x01)                        
  317.                 kpd_keymap_handler(2);  
  318.   
  319.         if(0 != COL_LAST)  
  320.         {     
  321.             msleep(100);  
  322.             kpd_keymap_handler(1);  
  323.             *(volatile u16 *)KP_EN = 0;  
  324.             mt_set_gpio_mode(COL_LAST, GPIO_MODE_GPIO);  
  325.             kpd_print("kpd_kcol_scan_for_factorymode:  KP disable KCOL=%d \n", i);  
  326.             COL_LAST = 0;  
  327.         }  
  328.     }  
  329.   
  330.     for(i = 0; i < col_num; i++)  
  331.     {  
  332.         if (COL_REG[i] != 0)  
  333.             mt_set_gpio_mode(COL_REG[i], ((GPIO_MODE[i] >> 4) & 0x0f));  
  334.     }  
  335.       
  336.     kpd_reset_keymap_state(kpd_keymap_state);  
  337.     *(volatile u16 *)KP_EN = 0x1;     
  338.       
  339.     if(upmu_get_pwrkey_deb()!=1)  
  340.     {  
  341.             kpd_pwrkey_pmic_handler(0);  
  342.             msleep(100);  
  343.             kpd_pwrkey_pmic_handler(1);  
  344.     }     
  345.       
  346.     enable_irq(MT_KP_IRQ_ID);  
  347.     return;  
  348. }  
  349. #else       //KPD_AUTOTEST_BY_KP  
  350. void kpd_auto_test_for_factorymode(void)  
  351. {  
  352.     unsigned int COL_REG[8];  
  353.     unsigned int GPIO_MODE[8];  
  354.     int i;  
  355.       
  356.     kpd_pwrkey_pmic_handler(1);  
  357.     msleep(100);  
  358.     kpd_pwrkey_pmic_handler(0);  
  359.       
  360. #ifdef KPD_PMIC_RSTKEY_MAP  
  361.     kpd_pmic_rstkey_handler(1);  
  362.     msleep(100);  
  363.     kpd_pmic_rstkey_handler(0);  
  364. #endif  
  365.   
  366.     kpd_print("Enter kpd_auto_test_for_factorymode! \n");  
  367.     mtk_kpd_get_gpio_col(COL_REG, GPIO_MODE);  
  368.       
  369.     for(i = 0; i < 8; i++)  
  370.     {  
  371.         if (COL_REG[i] != 0)  
  372.         {  
  373.             msleep(100);  
  374.             kpd_print("kpd kcolumn %d pull down!\n", COL_REG[i]);  
  375.             mt_set_gpio_pull_select(COL_REG[i], 0);  
  376.             msleep(100);  
  377.             kpd_print("kpd kcolumn %d pull up!\n", COL_REG[i]);  
  378.             mt_set_gpio_pull_select(COL_REG[i], 1);  
  379.         }  
  380.     }  
  381.   
  382.     return;  
  383. }  
  384. #endif      //KPD_AUTOTEST_BY_KP  
  385.   
  386. /********************************************************************/  
  387.   
  388.   
  389. /********************************************************************/  
  390. /*****************for kpd auto set wake up source*************************/  
  391. /********************************************************************/  
  392. static volatile int call_status = 0;  
  393. static ssize_t kpd_store_call_state(struct device_driver *ddri, const char *buf, size_t count)  
  394. {  
  395.     if (sscanf(buf, "%u", &call_status) != 1) {  
  396.             kpd_print("kpd call state: Invalid values\n");  
  397.             return -EINVAL;  
  398.         }  
  399.   
  400.     switch(call_status)  
  401.         {  
  402.         case 1 :  
  403.             kpd_print("kpd call state: Idle state!\n");  
  404.         break;  
  405.         case 2 :  
  406.             kpd_print("kpd call state: ringing state!\n");  
  407.         break;  
  408.         case 3 :  
  409.             kpd_print("kpd call state: active or hold state!\n");     
  410.         break;  
  411.               
  412.         default:  
  413.             kpd_print("kpd call state: Invalid values\n");  
  414.         break;  
  415.     }  
  416.     return count;  
  417. }  
  418.   
  419. static ssize_t kpd_show_call_state(struct device_driver *ddri, char *buf)  
  420. {  
  421.     ssize_t res;  
  422.     res = snprintf(buf, PAGE_SIZE, "%d\n", call_status);       
  423.     return res;     
  424. }  
  425. static DRIVER_ATTR(kpd_call_state,  S_IWUSR | S_IRUGO,  kpd_show_call_state,    kpd_store_call_state);  
  426.   
  427. static struct driver_attribute *kpd_attr_list[] = {  
  428.     &driver_attr_kpd_call_state,  
  429. };  
  430.   
  431. /*----------------------------------------------------------------------------*/  
  432. static int kpd_create_attr(struct device_driver *driver)   
  433. {  
  434.     int idx, err = 0;  
  435.     int num = (int)(sizeof(kpd_attr_list)/sizeof(kpd_attr_list[0]));  
  436.     if (driver == NULL)  
  437.     {  
  438.         return -EINVAL;  
  439.     }  
  440.   
  441.     for(idx = 0; idx < num; idx++)  
  442.     {  
  443.         if((err = driver_create_file(driver, kpd_attr_list[idx])))  
  444.         {              
  445.             kpd_print("driver_create_file (%s) = %d\n", kpd_attr_list[idx]->attr.name, err);  
  446.             break;  
  447.         }  
  448.     }      
  449.     return err;  
  450. }  
  451. /*----------------------------------------------------------------------------*/  
  452. static int kpd_delete_attr(struct device_driver *driver)  
  453.     {  
  454.     int idx ,err = 0;  
  455.     int num = (int)(sizeof(kpd_attr_list)/sizeof(kpd_attr_list[0]));  
  456.   
  457.     if (!driver)  
  458.     return -EINVAL;  
  459.   
  460.     for (idx = 0; idx < num; idx++)   
  461.     {  
  462.         driver_remove_file(driver, kpd_attr_list[idx]);  
  463.     }  
  464.       
  465.     return err;  
  466. }  
  467. /*----------------------------------------------------------------------------*/  
  468. /********************************************************************/  
  469. /********************************************************************/  
  470. /********************************************************************/  
  471.   
  472. /* for autotest */  
  473. #if KPD_AUTOTEST  
  474. static const u16 kpd_auto_keymap[] = {  
  475.     KEY_OK, KEY_MENU,  
  476.     KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT,  
  477.     KEY_HOME, KEY_BACK,  
  478.     KEY_CALL, KEY_ENDCALL,  
  479.     KEY_VOLUMEUP, KEY_VOLUMEDOWN,  
  480.     KEY_FOCUS, KEY_CAMERA,  
  481. };  
  482. #endif  
  483.   
  484. /* for AEE manual dump */  
  485. #define AEE_VOLUMEUP_BIT    0  
  486. #define AEE_VOLUMEDOWN_BIT  1  
  487. #define AEE_DELAY_TIME      15  
  488. /* enable volup + voldown was pressed 5~15 s Trigger aee manual dump */  
  489. #define AEE_ENABLE_5_15     1  
  490. static struct hrtimer aee_timer;  
  491. static unsigned long  aee_pressed_keys;  
  492. static bool aee_timer_started;  
  493.   
  494. #if AEE_ENABLE_5_15  
  495. #define AEE_DELAY_TIME_5S   5  
  496. static struct hrtimer aee_timer_5s;  
  497. static bool aee_timer_5s_started;  
  498. static bool flags_5s;  
  499. #endif  
  500.   
  501. static inline void kpd_update_aee_state(void) {  
  502.     if(aee_pressed_keys == ((1<<AEE_VOLUMEUP_BIT) | (1<<AEE_VOLUMEDOWN_BIT))) {  
  503.         /* if volumeup and volumedown was pressed the same time then start the time of ten seconds */  
  504.         aee_timer_started = true;  
  505.           
  506. #if AEE_ENABLE_5_15  
  507.         aee_timer_5s_started = true;  
  508.         hrtimer_start(&aee_timer_5s,   
  509.                 ktime_set(AEE_DELAY_TIME_5S, 0),  
  510.                 HRTIMER_MODE_REL);  
  511. #endif  
  512.         hrtimer_start(&aee_timer,   
  513.                 ktime_set(AEE_DELAY_TIME, 0),  
  514.                 HRTIMER_MODE_REL);  
  515.         kpd_print("aee_timer started\n");  
  516.     } else {  
  517.         if(aee_timer_started) {  
  518. /* 
  519.   * hrtimer_cancel - cancel a timer and wait for the handler to finish. 
  520.   * Returns: 
  521.   * 0 when the timer was not active.  
  522.   * 1 when the timer was active. 
  523.  */  
  524.             if(hrtimer_cancel(&aee_timer))  
  525.             {  
  526.                 kpd_print("try to cancel hrtimer \n");  
  527. #if AEE_ENABLE_5_15  
  528.                 if(flags_5s)  
  529.                 {  
  530.                     printk("Pressed Volup + Voldown5s~15s then trigger aee manual dump.\n");  
  531.                     aee_kernel_reminding("manual dump", "Trigger Vol Up +Vol Down 5s");  
  532.                 }  
  533. #endif  
  534.                       
  535.             }  
  536. #if AEE_ENABLE_5_15  
  537.             flags_5s = false;  
  538. #endif  
  539.             aee_timer_started = false;  
  540.             kpd_print("aee_timer canceled\n");  
  541.         }  
  542.   
  543. #if AEE_ENABLE_5_15  
  544.         if(aee_timer_5s_started) {  
  545. /* 
  546.   * hrtimer_cancel - cancel a timer and wait for the handler to finish. 
  547.   * Returns: 
  548.   * 0 when the timer was not active.  
  549.   * 1 when the timer was active. 
  550.  */  
  551.             if(hrtimer_cancel(&aee_timer_5s))  
  552.             {  
  553.                 kpd_print("try to cancel hrtimer (5s) \n");  
  554.             }  
  555.             aee_timer_5s_started = false;  
  556.             kpd_print("aee_timer canceled (5s)\n");  
  557.         }  
  558.   
  559. #endif  
  560.     }  
  561. }  
  562.   
  563. static void kpd_aee_handler(u32 keycode, u16 pressed) {  
  564.     if(pressed) {  
  565.         if(keycode == KEY_VOLUMEUP) {  
  566.             __set_bit(AEE_VOLUMEUP_BIT, &aee_pressed_keys);  
  567.         } else if(keycode == KEY_VOLUMEDOWN) {  
  568.             __set_bit(AEE_VOLUMEDOWN_BIT, &aee_pressed_keys);  
  569.         } else {  
  570.             return;  
  571.         }  
  572.         kpd_update_aee_state();  
  573.     } else {  
  574.         if(keycode == KEY_VOLUMEUP) {  
  575.             __clear_bit(AEE_VOLUMEUP_BIT, &aee_pressed_keys);  
  576.         } else if(keycode == KEY_VOLUMEDOWN) {  
  577.             __clear_bit(AEE_VOLUMEDOWN_BIT, &aee_pressed_keys);  
  578.         } else {  
  579.             return;  
  580.         }  
  581.         kpd_update_aee_state();  
  582.     }  
  583. }  
  584.   
  585. static enum hrtimer_restart aee_timer_func(struct hrtimer *timer) {  
  586.     //printk("kpd: vol up+vol down AEE manual dump!\n");  
  587.     //aee_kernel_reminding("manual dump ", "Triggered by press KEY_VOLUMEUP+KEY_VOLUMEDOWN");  
  588.     aee_trigger_kdb();  
  589.     return HRTIMER_NORESTART;  
  590. }  
  591.   
  592. #if AEE_ENABLE_5_15  
  593. static enum hrtimer_restart aee_timer_5s_func(struct hrtimer *timer) {  
  594.       
  595.     //printk("kpd: vol up+vol down AEE manual dump timer 5s !\n");  
  596.     flags_5s = true;  
  597.     return HRTIMER_NORESTART;  
  598. }  
  599. #endif  
  600.   
  601. static inline void kpd_get_keymap_state(u16 state[])  
  602. {  
  603.     state[0] = *(volatile u16 *)KP_MEM1;  
  604.     state[1] = *(volatile u16 *)KP_MEM2;  
  605.     state[2] = *(volatile u16 *)KP_MEM3;  
  606.     state[3] = *(volatile u16 *)KP_MEM4;  
  607.     state[4] = *(volatile u16 *)KP_MEM5;  
  608.     if (kpd_show_register) {  
  609.         printk(KPD_SAY "register = %x %x %x %x %x\n",  
  610.                state[0], state[1], state[2], state[3], state[4]);  
  611.     }  
  612. }  
  613.   
  614. static inline void kpd_set_debounce(u16 val)  
  615. {  
  616.     mt65xx_reg_sync_writew((u16)(val & KPD_DEBOUNCE_MASK), KP_DEBOUNCE);  
  617. }  
  618.   
  619. #if KPD_DRV_CTRL_BACKLIGHT  
  620. static void kpd_switch_backlight(struct work_struct *work)  
  621. {  
  622.     if (kpd_backlight_on) {  
  623.         kpd_enable_backlight();  
  624.         kpd_print("backlight is on\n");  
  625.     } else {  
  626.         kpd_disable_backlight();  
  627.         kpd_print("backlight is off\n");  
  628.     }  
  629. }  
  630.   
  631. static void kpd_backlight_timeout(unsigned long data)  
  632. {  
  633.     if (!atomic_read(&kpd_key_pressed)) {  
  634.         kpd_backlight_on = !!atomic_read(&kpd_key_pressed);  
  635.         schedule_work(&kpd_backlight_work);  
  636.         data = 1;  
  637.     }  
  638.     kpd_print("backlight timeout%s\n",   
  639.               data ? ": schedule backlight work" : "");  
  640. }  
  641.   
  642. void kpd_backlight_handler(bool pressed, u16 linux_keycode)  
  643. {  
  644.     if (kpd_suspend && !test_bit(linux_keycode, kpd_wake_keybit)) {  
  645.         kpd_print("Linux keycode %u is not WAKE key\n", linux_keycode);  
  646.         return;  
  647.     }  
  648.   
  649.     /* not in suspend or the key pressed is WAKE key */  
  650.     if (pressed) {  
  651.         atomic_inc(&kpd_key_pressed);  
  652.         kpd_backlight_on = !!atomic_read(&kpd_key_pressed);  
  653.         schedule_work(&kpd_backlight_work);  
  654.         kpd_print("switch backlight on\n");  
  655.     } else {  
  656.         atomic_dec(&kpd_key_pressed);  
  657.         mod_timer(&kpd_backlight_timer,  
  658.                   jiffies + KPD_BACKLIGHT_TIME * HZ);  
  659.         kpd_print("activate backlight timer\n");  
  660.     }  
  661. }  
  662. #endif  
  663.   
  664. #if KPD_HAS_SLIDE_QWERTY  
  665. static void kpd_slide_handler(unsigned long data)  
  666. {  
  667.     bool slid;  
  668.     u8 old_state = kpd_slide_state;  
  669.   
  670.     kpd_slide_state = !kpd_slide_state;  
  671.     slid = (kpd_slide_state == !!KPD_SLIDE_POLARITY);  
  672.     /* for SW_LID, 1: lid open => slid, 0: lid shut => closed */  
  673.     input_report_switch(kpd_input_dev, SW_LID, slid);  
  674.     input_sync(kpd_input_dev);  
  675.     kpd_print("report QWERTY = %s\n", slid ? "slid" : "closed");  
  676.   
  677.     if(old_state) {  
  678.         mt_set_gpio_pull_select(GPIO_QWERTYSLIDE_EINT_PIN, 0);  
  679.     } else {  
  680.         mt_set_gpio_pull_select(GPIO_QWERTYSLIDE_EINT_PIN, 1);  
  681.     }  
  682.     /* for detecting the return to old_state */  
  683.     mt65xx_eint_set_polarity(KPD_SLIDE_EINT, old_state);  
  684.     mt65xx_eint_unmask(KPD_SLIDE_EINT);  
  685. }  
  686.   
  687. static void kpd_slide_eint_handler(void)  
  688. {  
  689.     tasklet_schedule(&kpd_slide_tasklet);  
  690. }  
  691. #endif  
  692.   
  693. #if KPD_PWRKEY_USE_EINT  
  694. static void kpd_pwrkey_handler(unsigned long data)  
  695. {  
  696.     bool pressed;  
  697.     u8 old_state = kpd_pwrkey_state;  
  698.   
  699.     kpd_pwrkey_state = !kpd_pwrkey_state;  
  700.     pressed = (kpd_pwrkey_state == !!KPD_PWRKEY_POLARITY);  
  701.     if (kpd_show_hw_keycode) {  
  702.         printk(KPD_SAY "(%s) HW keycode = using EINT\n",  
  703.                pressed ? "pressed" : "released");  
  704.     }  
  705.     kpd_backlight_handler(pressed, KPD_PWRKEY_MAP);  
  706.     input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);  
  707.     input_sync(kpd_input_dev);  
  708.     kpd_print("report Linux keycode = %u\n", KPD_PWRKEY_MAP);  
  709.   
  710.     /* for detecting the return to old_state */  
  711.     mt65xx_eint_set_polarity(KPD_PWRKEY_EINT, old_state);  
  712.     mt65xx_eint_unmask(KPD_PWRKEY_EINT);  
  713. }  
  714.   
  715. static void kpd_pwrkey_eint_handler(void)  
  716. {  
  717.     tasklet_schedule(&kpd_pwrkey_tasklet);  
  718. }  
  719. #endif  
  720. /*********************************************************************/  
  721. #if 0//KPD_PWRKEY_USE_PMIC //for 77 chip and earlier version   power key bug, has fixed on 89 chip  
  722. static void kpd_pwrkey_handler(struct work_struct *work)  
  723. {  
  724.     int pressed = 1;  
  725.     /* report  Press*/  
  726.     input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);  
  727.     input_sync(kpd_input_dev);  
  728.     if (kpd_show_hw_keycode) {  
  729.         printk(KPD_SAY "(%s) HW keycode = using PMIC\n",  
  730.                pressed ? "pressed" : "released");  
  731.     }  
  732.     while(1)  
  733.     {  
  734.         if(upmu_get_pwrkey_deb() == 1)  
  735.         {  
  736.             pressed = 0;  
  737.             /* Report Release */  
  738.             input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);  
  739.             input_sync(kpd_input_dev);  
  740.         if (kpd_show_hw_keycode) {  
  741.                printk(KPD_SAY "(%s) HW keycode = using PMIC\n",  
  742.                  pressed ? "pressed" : "released");  
  743.         }             
  744.             break;  
  745.         }  
  746.         msleep(10);  
  747.     }         
  748. }  
  749.   
  750. void kpd_pwrkey_pmic_handler(unsigned long pressed)  
  751. {  
  752.     printk(KPD_SAY "Power Key generate, pressed=%ld\n", pressed);  
  753.     if(!kpd_input_dev) {  
  754.         printk("KPD input device not ready\n");  
  755.         return;  
  756.     }  
  757.     if(get_chip_eco_ver() == CHIP_E2) {  
  758.         input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);  
  759.         input_sync(kpd_input_dev);  
  760.         if (kpd_show_hw_keycode) {  
  761.             printk(KPD_SAY "(%s) HW keycode =%d using PMIC\n",  
  762.                    pressed ? "pressed" : "released", KPD_PWRKEY_MAP);  
  763.         }  
  764.     } else {  
  765.         schedule_work(&pwrkey_pmic_work);  
  766.     }  
  767. }  
  768. #endif  
  769. /*********************************************************************/  
  770. #if KPD_PWRKEY_USE_PMIC  
  771.   
  772. void kpd_pwrkey_pmic_handler(unsigned long pressed)  
  773. {  
  774.     printk(KPD_SAY "Power Key generate, pressed=%ld\n", pressed);  
  775.     if(!kpd_input_dev) {  
  776.         printk("KPD input device not ready\n");  
  777.         return;  
  778.     }  
  779.       
  780.         input_report_key(kpd_input_dev, KPD_PWRKEY_MAP, pressed);  
  781.         input_sync(kpd_input_dev);  
  782.         if (kpd_show_hw_keycode) {  
  783.             printk(KPD_SAY "(%s) HW keycode =%d using PMIC\n",  
  784.                    pressed ? "pressed" : "released", KPD_PWRKEY_MAP);  
  785.         }  
  786. }  
  787. #endif  
  788.   
  789. /*********************************************************************/  
  790. void kpd_pmic_rstkey_handler(unsigned long pressed)  
  791. {  
  792.     printk(KPD_SAY "PMIC reset Key generate, pressed=%ld\n", pressed);  
  793.     if(!kpd_input_dev) {  
  794.         printk("KPD input device not ready\n");  
  795.         return;  
  796.     }  
  797. #ifdef KPD_PMIC_RSTKEY_MAP  
  798.         input_report_key(kpd_input_dev, KPD_PMIC_RSTKEY_MAP, pressed);  
  799.         input_sync(kpd_input_dev);  
  800.         if (kpd_show_hw_keycode) {  
  801.             printk(KPD_SAY "(%s) HW keycode =%d using PMIC\n",  
  802.                    pressed ? "pressed" : "released", KPD_PMIC_RSTKEY_MAP);  
  803.         }  
  804.         kpd_aee_handler(KPD_PMIC_RSTKEY_MAP, pressed);  
  805. #endif  
  806. }  
  807.   
  808. static void kpd_keymap_handler(unsigned long data)  
  809. {  
  810.     int i, j;  
  811.     bool pressed;  
  812.     u16 new_state[KPD_NUM_MEMS], change, mask;  
  813.     u16 hw_keycode, linux_keycode;  
  814.   
  815.     spin_lock(&keymap_handler_spinlock);  
  816.     kpd_get_keymap_state(new_state);  
  817.   
  818. #ifdef KPD_AUTOTEST_BY_KP  
  819.     if(data == 1)  
  820.         kpd_reset_keymap_state(new_state);  
  821.         kpd_print("kpd_keymap_handler:  data=%d, new_state = %x %x %x %x %x \n",  
  822.                      data, new_state[0], new_state[1], new_state[2], new_state[3], new_state[4]);         
  823. #endif  
  824.   
  825.     for (i = 0; i < KPD_NUM_MEMS; i++) {  
  826.         change = new_state[i] ^ kpd_keymap_state[i];  
  827.         if (!change)  
  828.             continue;  
  829.   
  830.         for (j = 0; j < 16; j++) {  
  831.             mask = 1U << j;  
  832.             if (!(change & mask))  
  833.                 continue;  
  834.   
  835.             hw_keycode = (i << 4) + j;  
  836.             /* bit is 1: not pressed, 0: pressed */  
  837.             pressed = !(new_state[i] & mask);  
  838.             if (kpd_show_hw_keycode) {  
  839.                 printk(KPD_SAY "(%s) HW keycode = %u\n",  
  840.                        pressed ? "pressed" : "released",  
  841.                        hw_keycode);  
  842.             }  
  843.             BUG_ON(hw_keycode >= KPD_NUM_KEYS);  
  844.             linux_keycode = kpd_keymap[hw_keycode];           
  845.             if (unlikely(linux_keycode == 0)) {  
  846.                 kpd_print("Linux keycode = 0\n");  
  847.                 continue;  
  848.             }         
  849.               
  850. #ifdef KPD_AUTOTEST_BY_KP  
  851.             if((get_boot_mode() != FACTORY_BOOT) && (get_boot_mode() != ATE_FACTORY_BOOT))  
  852. #endif            
  853.             kpd_aee_handler(linux_keycode, pressed);  
  854.             kpd_backlight_handler(pressed, linux_keycode);  
  855.             input_report_key(kpd_input_dev, linux_keycode, pressed);  
  856.             input_sync(kpd_input_dev);  
  857.             kpd_print("report Linux keycode = %u\n", linux_keycode);  
  858.         }  
  859.     }  
  860.       
  861.     memcpy(kpd_keymap_state, new_state, sizeof(new_state));  
  862.     //kpd_print("save new keymap state\n");  
  863. #ifdef KPD_AUTOTEST_BY_KP  
  864.     if(data == 0)  
  865. #endif  
  866.     enable_irq(MT_KP_IRQ_ID);  
  867.     spin_unlock(&keymap_handler_spinlock);  
  868. }  
  869.   
  870. static irqreturn_t kpd_irq_handler(int irq, void *dev_id)  
  871. {  
  872.     /* use _nosync to avoid deadlock */  
  873.     disable_irq_nosync(MT_KP_IRQ_ID);  
  874.   
  875.     tasklet_schedule(&kpd_keymap_tasklet);  
  876.     return IRQ_HANDLED;  
  877. }  
  878.   
  879. static long kpd_dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)  
  880. {  
  881.     void __user *uarg = (void __user *)arg;  
  882.     struct kpd_ledctl ledctl;  
  883.   
  884.     switch (cmd) {  
  885. #if KPD_AUTOTEST  
  886.     case PRESS_OK_KEY://KPD_AUTOTEST disable auto test setting to resolve CR ALPS00464496  
  887.         if(test_bit(KEY_OK, kpd_input_dev->keybit)){  
  888.         printk("[AUTOTEST] PRESS OK KEY!!\n");  
  889.         input_report_key(kpd_input_dev, KEY_OK, 1);  
  890.         input_sync(kpd_input_dev);  
  891.         }else{  
  892.             printk("[AUTOTEST] Not Support OK KEY!!\n");  
  893.         }  
  894.         break;  
  895.     case RELEASE_OK_KEY:  
  896.         if(test_bit(KEY_OK, kpd_input_dev->keybit)){  
  897.         printk("[AUTOTEST] RELEASE OK KEY!!\n");  
  898.         input_report_key(kpd_input_dev, KEY_OK, 0);  
  899.         input_sync(kpd_input_dev);  
  900.         }else{  
  901.             printk("[AUTOTEST] Not Support OK KEY!!\n");  
  902.         }  
  903.         break;  
  904.     case PRESS_MENU_KEY:  
  905.         if(test_bit(KEY_MENU, kpd_input_dev->keybit)){  
  906.         printk("[AUTOTEST] PRESS MENU KEY!!\n");  
  907.         input_report_key(kpd_input_dev, KEY_MENU, 1);  
  908.         input_sync(kpd_input_dev);  
  909.         }else{  
  910.             printk("[AUTOTEST] Not Support MENU KEY!!\n");  
  911.         }  
  912.         break;  
  913.     case RELEASE_MENU_KEY:  
  914.         if(test_bit(KEY_MENU, kpd_input_dev->keybit)){  
  915.         printk("[AUTOTEST] RELEASE MENU KEY!!\n");  
  916.         input_report_key(kpd_input_dev, KEY_MENU, 0);  
  917.         input_sync(kpd_input_dev);  
  918.         }else{  
  919.             printk("[AUTOTEST] Not Support MENU KEY!!\n");  
  920.         }  
  921.   
  922.         break;  
  923.     case PRESS_UP_KEY:  
  924.         if(test_bit(KEY_UP, kpd_input_dev->keybit)){  
  925.         printk("[AUTOTEST] PRESS UP KEY!!\n");  
  926.         input_report_key(kpd_input_dev, KEY_UP, 1);  
  927.         input_sync(kpd_input_dev);  
  928.         }else{  
  929.             printk("[AUTOTEST] Not Support UP KEY!!\n");  
  930.         }  
  931.         break;  
  932.     case RELEASE_UP_KEY:  
  933.         if(test_bit(KEY_UP, kpd_input_dev->keybit)){  
  934.         printk("[AUTOTEST] RELEASE UP KEY!!\n");  
  935.         input_report_key(kpd_input_dev, KEY_UP, 0);  
  936.         input_sync(kpd_input_dev);  
  937.         }else{  
  938.             printk("[AUTOTEST] Not Support UP KEY!!\n");  
  939.         }  
  940.         break;  
  941.     case PRESS_DOWN_KEY:  
  942.         if(test_bit(KEY_DOWN, kpd_input_dev->keybit)){  
  943.         printk("[AUTOTEST] PRESS DOWN KEY!!\n");  
  944.         input_report_key(kpd_input_dev, KEY_DOWN, 1);  
  945.         input_sync(kpd_input_dev);  
  946.         }else{  
  947.             printk("[AUTOTEST] Not Support DOWN KEY!!\n");  
  948.         }  
  949.         break;  
  950.     case RELEASE_DOWN_KEY:  
  951.         if(test_bit(KEY_DOWN, kpd_input_dev->keybit)){  
  952.         printk("[AUTOTEST] RELEASE DOWN KEY!!\n");  
  953.         input_report_key(kpd_input_dev, KEY_DOWN, 0);  
  954.         input_sync(kpd_input_dev);  
  955.         }else{  
  956.             printk("[AUTOTEST] Not Support DOWN KEY!!\n");  
  957.         }  
  958.         break;  
  959.     case PRESS_LEFT_KEY:  
  960.         if(test_bit(KEY_LEFT, kpd_input_dev->keybit)){  
  961.         printk("[AUTOTEST] PRESS LEFT KEY!!\n");  
  962.         input_report_key(kpd_input_dev, KEY_LEFT, 1);  
  963.         input_sync(kpd_input_dev);  
  964.         }else{  
  965.             printk("[AUTOTEST] Not Support LEFT KEY!!\n");  
  966.         }  
  967.         break;  
  968.     case RELEASE_LEFT_KEY:  
  969.         if(test_bit(KEY_LEFT, kpd_input_dev->keybit)){  
  970.         printk("[AUTOTEST] RELEASE LEFT KEY!!\n");  
  971.         input_report_key(kpd_input_dev, KEY_LEFT, 0);  
  972.         input_sync(kpd_input_dev);  
  973.         }else{  
  974.             printk("[AUTOTEST] Not Support LEFT KEY!!\n");  
  975.         }  
  976.         break;  
  977.     case PRESS_RIGHT_KEY:  
  978.         if(test_bit(KEY_RIGHT, kpd_input_dev->keybit)){  
  979.         printk("[AUTOTEST] PRESS RIGHT KEY!!\n");  
  980.         input_report_key(kpd_input_dev, KEY_RIGHT, 1);  
  981.         input_sync(kpd_input_dev);  
  982.         }else{  
  983.             printk("[AUTOTEST] Not Support RIGHT KEY!!\n");  
  984.         }  
  985.         break;  
  986.     case RELEASE_RIGHT_KEY:  
  987.         if(test_bit(KEY_RIGHT, kpd_input_dev->keybit)){  
  988.         printk("[AUTOTEST] RELEASE RIGHT KEY!!\n");  
  989.         input_report_key(kpd_input_dev, KEY_RIGHT, 0);  
  990.         input_sync(kpd_input_dev);  
  991.         }else{  
  992.             printk("[AUTOTEST] Not Support RIGHT KEY!!\n");  
  993.         }  
  994.         break;  
  995.     case PRESS_HOME_KEY:  
  996.         if(test_bit(KEY_HOME, kpd_input_dev->keybit)){  
  997.         printk("[AUTOTEST] PRESS HOME KEY!!\n");  
  998.         input_report_key(kpd_input_dev, KEY_HOME, 1);  
  999.         input_sync(kpd_input_dev);  
  1000.         }else{  
  1001.             printk("[AUTOTEST] Not Support HOME KEY!!\n");  
  1002.         }  
  1003.         break;  
  1004.     case RELEASE_HOME_KEY:  
  1005.         if(test_bit(KEY_HOME, kpd_input_dev->keybit)){  
  1006.         printk("[AUTOTEST] RELEASE HOME KEY!!\n");  
  1007.         input_report_key(kpd_input_dev, KEY_HOME, 0);  
  1008.         input_sync(kpd_input_dev);  
  1009.         }else{  
  1010.             printk("[AUTOTEST] Not Support HOME KEY!!\n");  
  1011.         }  
  1012.         break;  
  1013.     case PRESS_BACK_KEY:  
  1014.         if(test_bit(KEY_BACK, kpd_input_dev->keybit)){  
  1015.         printk("[AUTOTEST] PRESS BACK KEY!!\n");  
  1016.         input_report_key(kpd_input_dev, KEY_BACK, 1);  
  1017.         input_sync(kpd_input_dev);  
  1018.         }else{  
  1019.             printk("[AUTOTEST] Not Support BACK KEY!!\n");  
  1020.         }  
  1021.         break;  
  1022.     case RELEASE_BACK_KEY:  
  1023.         if(test_bit(KEY_BACK, kpd_input_dev->keybit)){  
  1024.         printk("[AUTOTEST] RELEASE BACK KEY!!\n");  
  1025.         input_report_key(kpd_input_dev, KEY_BACK, 0);  
  1026.         input_sync(kpd_input_dev);  
  1027.         }else{  
  1028.             printk("[AUTOTEST] Not Support BACK KEY!!\n");  
  1029.         }  
  1030.         break;  
  1031.     case PRESS_CALL_KEY:  
  1032.         if(test_bit(KEY_CALL, kpd_input_dev->keybit)){  
  1033.         printk("[AUTOTEST] PRESS CALL KEY!!\n");  
  1034.         input_report_key(kpd_input_dev, KEY_CALL, 1);  
  1035.         input_sync(kpd_input_dev);  
  1036.         }else{  
  1037.             printk("[AUTOTEST] Not Support CALL KEY!!\n");  
  1038.         }  
  1039.         break;  
  1040.     case RELEASE_CALL_KEY:  
  1041.         if(test_bit(KEY_CALL, kpd_input_dev->keybit)){  
  1042.         printk("[AUTOTEST] RELEASE CALL KEY!!\n");  
  1043.         input_report_key(kpd_input_dev, KEY_CALL, 0);  
  1044.         input_sync(kpd_input_dev);  
  1045.         }else{  
  1046.             printk("[AUTOTEST] Not Support CALL KEY!!\n");  
  1047.         }  
  1048.         break;  
  1049.     case PRESS_ENDCALL_KEY:  
  1050.         if(test_bit(KEY_ENDCALL, kpd_input_dev->keybit)){  
  1051.         printk("[AUTOTEST] PRESS ENDCALL KEY!!\n");  
  1052.         input_report_key(kpd_input_dev, KEY_ENDCALL, 1);  
  1053.         input_sync(kpd_input_dev);  
  1054.         }else{  
  1055.             printk("[AUTOTEST] Not Support ENDCALL KEY!!\n");  
  1056.         }  
  1057.         break;  
  1058.     case RELEASE_ENDCALL_KEY:  
  1059.         if(test_bit(KEY_ENDCALL, kpd_input_dev->keybit)){  
  1060.         printk("[AUTOTEST] RELEASE ENDCALL KEY!!\n");  
  1061.         input_report_key(kpd_input_dev, KEY_ENDCALL, 0);  
  1062.         input_sync(kpd_input_dev);  
  1063.         }else{  
  1064.             printk("[AUTOTEST] Not Support ENDCALL KEY!!\n");  
  1065.         }  
  1066.         break;  
  1067.     case PRESS_VLUP_KEY:  
  1068.         if(test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)){  
  1069.         printk("[AUTOTEST] PRESS VOLUMEUP KEY!!\n");  
  1070.         input_report_key(kpd_input_dev, KEY_VOLUMEUP, 1);  
  1071.         input_sync(kpd_input_dev);  
  1072.         }else{  
  1073.             printk("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");  
  1074.         }  
  1075.         break;  
  1076.     case RELEASE_VLUP_KEY:  
  1077.         if(test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)){  
  1078.         printk("[AUTOTEST] RELEASE VOLUMEUP KEY!!\n");  
  1079.         input_report_key(kpd_input_dev, KEY_VOLUMEUP, 0);  
  1080.         input_sync(kpd_input_dev);  
  1081.         }else{  
  1082.             printk("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");  
  1083.         }  
  1084.         break;  
  1085.     case PRESS_VLDOWN_KEY:  
  1086.         if(test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)){  
  1087.         printk("[AUTOTEST] PRESS VOLUMEDOWN KEY!!\n");  
  1088.         input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 1);  
  1089.         input_sync(kpd_input_dev);  
  1090.         }else{  
  1091.             printk("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");  
  1092.         }  
  1093.         break;  
  1094.     case RELEASE_VLDOWN_KEY:  
  1095.         if(test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)){  
  1096.         printk("[AUTOTEST] RELEASE VOLUMEDOWN KEY!!\n");  
  1097.         input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 0);  
  1098.         input_sync(kpd_input_dev);  
  1099.         }else{  
  1100.             printk("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");  
  1101.         }  
  1102.         break;  
  1103.     case PRESS_FOCUS_KEY:  
  1104.         if(test_bit(KEY_FOCUS, kpd_input_dev->keybit)){  
  1105.         printk("[AUTOTEST] PRESS FOCUS KEY!!\n");  
  1106.         input_report_key(kpd_input_dev, KEY_FOCUS, 1);  
  1107.         input_sync(kpd_input_dev);  
  1108.         }else{  
  1109.             printk("[AUTOTEST] Not Support FOCUS KEY!!\n");  
  1110.         }  
  1111.         break;  
  1112.     case RELEASE_FOCUS_KEY:  
  1113.         if(test_bit(KEY_FOCUS, kpd_input_dev->keybit)){  
  1114.         printk("[AUTOTEST] RELEASE FOCUS KEY!!\n");  
  1115.         input_report_key(kpd_input_dev, KEY_FOCUS, 0);  
  1116.         input_sync(kpd_input_dev);  
  1117.         }else{  
  1118.             printk("[AUTOTEST] Not Support RELEASE KEY!!\n");  
  1119.         }  
  1120.         break;  
  1121.     case PRESS_CAMERA_KEY:  
  1122.         if(test_bit(KEY_CAMERA, kpd_input_dev->keybit)){  
  1123.         printk("[AUTOTEST] PRESS CAMERA KEY!!\n");  
  1124.         input_report_key(kpd_input_dev, KEY_CAMERA, 1);  
  1125.         input_sync(kpd_input_dev);  
  1126.         }else{  
  1127.             printk("[AUTOTEST] Not Support CAMERA KEY!!\n");  
  1128.         }  
  1129.         break;  
  1130.     case RELEASE_CAMERA_KEY:  
  1131.         if(test_bit(KEY_CAMERA, kpd_input_dev->keybit)){  
  1132.         printk("[AUTOTEST] RELEASE CAMERA KEY!!\n");  
  1133.         input_report_key(kpd_input_dev, KEY_CAMERA, 0);  
  1134.         input_sync(kpd_input_dev);  
  1135.         }else{  
  1136.             printk("[AUTOTEST] Not Support CAMERA KEY!!\n");  
  1137.         }  
  1138.         break;  
  1139. #endif  
  1140.   
  1141.     case SET_KPD_BACKLIGHT:  
  1142.         if (copy_from_user(&ledctl, uarg, sizeof(struct kpd_ledctl)))  
  1143.             return -EFAULT;  
  1144.   
  1145.         //kpd_set_backlight(ledctl.onoff, &ledctl.div, &ledctl.duty);  
  1146.         break;  
  1147.   
  1148.     case SET_KPD_KCOL:  
  1149. #ifndef KPD_AUTOTEST_BY_KP  
  1150.         kpd_auto_test_for_factorymode();  
  1151. #else  
  1152.         kpd_kcol_scan_for_factorymode();  
  1153. #endif        
  1154.         printk("[kpd_auto_test_for_factorymode] test performed!!\n");  
  1155.         break;  
  1156.     default:  
  1157.         return -EINVAL;  
  1158.     }  
  1159.   
  1160.     return 0;  
  1161. }  
  1162.   
  1163. static int kpd_dev_open(struct inode *inode, struct file *file)  
  1164. {  
  1165.     return 0;  
  1166. }  
  1167.   
  1168. static struct file_operations kpd_dev_fops = {  
  1169.     .owner      = THIS_MODULE,  
  1170.     .unlocked_ioctl = kpd_dev_ioctl,  
  1171.     .open       = kpd_dev_open,  
  1172. };  
  1173.   
  1174. static struct miscdevice kpd_dev = {  
  1175.     .minor  = MISC_DYNAMIC_MINOR,  
  1176.     .name   = KPD_NAME,  
  1177.     .fops   = &kpd_dev_fops,  
  1178. };  
  1179.   
  1180. static int kpd_open(struct input_dev *dev)  
  1181. {  
  1182. #if KPD_HAS_SLIDE_QWERTY  
  1183.     bool evdev_flag=false;  
  1184.     bool power_op=false;  
  1185.     struct input_handler *handler;  
  1186.     struct input_handle *handle;  
  1187.     handle = rcu_dereference(dev->grab);  
  1188.     if (handle)  
  1189.     {  
  1190.         handler = handle->handler;  
  1191.         if(strcmp(handler->name, "evdev")==0)   
  1192.         {  
  1193.             return -1;  
  1194.         }     
  1195.     }  
  1196.     else   
  1197.     {  
  1198.         list_for_each_entry_rcu(handle, &dev->h_list, d_node) {  
  1199.             handler = handle->handler;  
  1200.             if(strcmp(handler->name, "evdev")==0)   
  1201.             {  
  1202.                 evdev_flag=true;  
  1203.                 break;  
  1204.             }  
  1205.         }  
  1206.         if(evdev_flag==false)  
  1207.         {  
  1208.             return -1;    
  1209.         }     
  1210.     }  
  1211.   
  1212.     power_op = powerOn_slidePin_interface();  
  1213.     if(!power_op) {  
  1214.         printk(KPD_SAY "Qwerty slide pin interface power on fail\n");  
  1215.     } else {  
  1216.         kpd_print("Qwerty slide pin interface power on success\n");  
  1217.     }  
  1218.           
  1219.     mt65xx_eint_set_sens(KPD_SLIDE_EINT, KPD_SLIDE_SENSITIVE);  
  1220.     mt65xx_eint_set_hw_debounce(KPD_SLIDE_EINT, KPD_SLIDE_DEBOUNCE);  
  1221.     mt65xx_eint_registration(KPD_SLIDE_EINT, true, KPD_SLIDE_POLARITY,  
  1222.                              kpd_slide_eint_handler, false);  
  1223.                                
  1224.     power_op = powerOff_slidePin_interface();  
  1225.     if(!power_op) {  
  1226.         printk(KPD_SAY "Qwerty slide pin interface power off fail\n");  
  1227.     } else {  
  1228.         kpd_print("Qwerty slide pin interface power off success\n");  
  1229.     }  
  1230.   
  1231. #if 0  
  1232.     /*qwerty slide: GPIO 214. input, mode=EINT, pull enbale, pull select high*/  
  1233.     mt_set_gpio_mode(214, 2);  
  1234.     mt_set_gpio_dir(214, 0);  
  1235.     mt_set_gpio_pull_enable(214, 1);  
  1236.     mt_set_gpio_pull_select(214, 0);  
  1237. #endif  
  1238. #endif    
  1239.     return 0;  
  1240. }  
  1241.   
  1242.   
  1243.   
  1244.   
  1245.   
  1246. #if 1 // AW9523  扩展键盘IC:  
  1247.   
  1248. #define GPIO_SIMULATE_I2C  
  1249.   
  1250. #define AW9523_EINT_GPIO               GPIO144  
  1251. #define AW9523_EINT_NO                 5  //CUST_EINT_MHALL_NUM   
  1252.   
  1253. #define AW9523_RESET_PIN GPIO128  
  1254.   
  1255. #define KPD_AW9523_SWITCH_DEBOUNCE       10   //50  // 30  
  1256. #define KPD_AW9523_SWITCH_POLARITY          CUST_EINT_MHALL_POLARITY  
  1257. #define KPD_AW9523_SWITCH_SENSITIVE      CUST_EINT_EDGE_SENSITIVE  // CUST_EINT_MHALL_SENSITIVE  
  1258.   
  1259. static void kpd_aw9523_handler(unsigned long data);  
  1260. static DECLARE_TASKLET(kpd_aw9523_tasklet, kpd_aw9523_handler, 0);  
  1261. static u8 kpd_aw9523_state = !CUST_EINT_POLARITY_LOW;   
  1262.   
  1263. #define LED_SLAVE_ADDR        0xb0//0xB6  
  1264. //#if defined(GPIO_SIMULATE_I2C)  
  1265. #define I2C_SDA_GPIO         GPIO114    //GPIO111      // ROW1  
  1266. #define I2C_SCL_GPIO         GPIO113    //GPIO108      // COL1  
  1267.   
  1268. typedef enum {  
  1269. P0_0=0,  
  1270. P0_1,  
  1271. P0_2,  
  1272. P0_3,  
  1273. P0_4,  
  1274. P0_5,  
  1275. P0_6,  
  1276. P0_7  
  1277. } P0_Enum;  
  1278.   
  1279. typedef enum {  
  1280. P1_0=0,  
  1281. P1_1,  
  1282. P1_2,   
  1283. P1_3,  
  1284. P1_4,   
  1285. P1_5,  
  1286. P1_6,  
  1287. P1_7  
  1288. } P1_Enum;  
  1289.   
  1290. #define AW9523_I2C_MAX_LOOP 50  
  1291.   
  1292. #define Y_NUM  6    
  1293. #define X_NUM  6                // has pullup resistor   
  1294.   
  1295. //  P0 ---> X_NUM ---> col         input  
  1296. //  P1 ---> Y_NUM ---> line(row)   output  
  1297. const P0_Enum COL[X_NUM] =  {P0_0, P0_1, P0_2, P0_3, P0_4, P0_5};  
  1298. //const P1_Enum Line[Y_NUM] = {P1_2, P1_3, P1_4, P1_5, P1_6, P1_7};    
  1299. const P1_Enum Line[Y_NUM] = {P1_0, P1_1, P1_2, P1_3, P1_4, P1_5};    
  1300.   
  1301. const u8  aw9523_key[Y_NUM][X_NUM]={  
  1302. //     1          2          3          4              5              6  
  1303. /* 
  1304.     {KEY_7,     KEY_8,    KEY_9, KEY_POUND,         KEY_OK,         KEY_BACK}, 
  1305.     {KEY_4,     KEY_5,      KEY_6,  KEY_STAR        ,KEY_1,     KEY_2}, 
  1306.     {KEY_LEFT,  KEY_UP,      KEY_MENU,     KEY_RIGHT,         KEY_DOWN,         KEY_HOME}, 
  1307.     {KEY_A, KEY_0,   KEY_B, KEY_C,         KEY_D,         KEY_S},       //SCAN here 
  1308.     {KEY_E,     KEY_F,      KEY_G,     KEY_H,   KEY_I,         KEY_J}, 
  1309.     {KEY_K,     KEY_L,      KEY_M,     KEY_N,         KEY_O,         KEY_P}, 
  1310. */  
  1311.   
  1312.     {KEY_F1,     KEY_F2,    KEY_F3, KEY_F4,         KEY_DEL,         KEY_3},  
  1313.     {KEY_FN,     KEY_0,      KEY_DOT,  KEY_SYM      ,KEY_OK,     KEY_ENTER},  
  1314.     {KEY_7,  KEY_8,      KEY_9,     KEY_POUND,         KEY_TAB,         KEY_BACK},  
  1315.     {KEY_4, KEY_5,   KEY_6, KEY_STAR,         KEY_1,         KEY_2},  
  1316.     {KEY_LEFT,     KEY_UP,      KEY_MENU,     KEY_RIGHT,   KEY_DOWN,         KEY_HOME},  
  1317.     {KEY_K,     KEY_L,      KEY_M,     KEY_N,         KEY_O,         KEY_S},  
  1318.   
  1319. };  
  1320.   
  1321. u8 P0_kbd_used[8]={1, 1, 1, 1, 1, 1, 0, 0};  
  1322.   
  1323. u8 P1_kbd_used[8]={0, 0, 1, 1, 1, 1, 1, 1};   
  1324.   
  1325. typedef  enum {  
  1326.     KEY_STATE_PRESSED=0,  
  1327.     KEY_STATE_RELEASED,  
  1328.     KEY_STATE_LONGPRESS,  
  1329.     KEY_STATE_REPEATED,   
  1330.     KEY_STATE_NULL   
  1331. }TOUCHKEY_STATE;  
  1332.   
  1333.   
  1334. u8  P0_INT_STATE=0x0;  
  1335. u8  P1_INT_STATE=0x0;  
  1336. u8  P0_IN_OUT_STATE=0x0;  
  1337. u8  P1_IN_OUT_STATE=0x0;  
  1338. u8  P0_kbd_used_temp=0x0;  
  1339. u8  pre_x=0x00;  
  1340. u8  pre_y=0x00;  
  1341. u8  P0_X[X_NUM];  
  1342. u8  P1_Y[Y_NUM];  
  1343. u8  P1_VALUE=0;  
  1344. u8 KeyBoard_Key=0xFF;  
  1345. u8 KeyBoard_Key_Previous=0xFF;  
  1346. TOUCHKEY_STATE KeyBoardKey_State=KEY_STATE_NULL;  
  1347.   
  1348.   
  1349. u8 DELAY_TIMES=2;  
  1350.   
  1351. //extern void kpled_ctrl_open(u8 enable);  
  1352. #define AW9523_delay_1us(ms)     udelay(ms*DELAY_TIMES)  
  1353.   
  1354.   
  1355. #define GPIO_ModeSetup(x, y)      mt_set_gpio_mode(x, y);  
  1356. #define GPIO_InitIO(x, y)                mt_set_gpio_dir(y, x)  
  1357. #define GPIO_WriteIO(x, y)            mt_set_gpio_out(y, x)  
  1358. #define GPIO_ReadIO(x)                  mt_get_gpio_in(x)  
  1359.   
  1360.   
  1361. #define I2C_SDA_MODE           mt_set_gpio_mode(I2C_SDA_GPIO, GPIO_MODE_GPIO)  
  1362. #define I2C_SCL_MODE           mt_set_gpio_mode(I2C_SCL_GPIO, GPIO_MODE_GPIO)  
  1363. #define I2C_SDA_OUTPUT      mt_set_gpio_dir(I2C_SDA_GPIO, GPIO_DIR_OUT)  
  1364. #define I2C_SDA_INPUT          mt_set_gpio_dir(I2C_SDA_GPIO, GPIO_DIR_IN)  
  1365. #define I2C_SCL_OUTPUT       mt_set_gpio_dir(I2C_SCL_GPIO, GPIO_DIR_OUT)  
  1366. #define I2C_SDA_HIGH            mt_set_gpio_out(I2C_SDA_GPIO, GPIO_OUT_ONE)  
  1367. #define I2C_SDA_LOW             mt_set_gpio_out(I2C_SDA_GPIO, GPIO_OUT_ZERO)  
  1368. #define I2C_SCL_HIGH            mt_set_gpio_out(I2C_SCL_GPIO, GPIO_OUT_ONE)  
  1369. #define I2C_SCL_LOW             mt_set_gpio_out(I2C_SCL_GPIO, GPIO_OUT_ZERO)  
  1370. #define I2C_SDA_READ           mt_get_gpio_in(I2C_SDA_GPIO)  
  1371.   
  1372. #define NEW_I2C_TIMING              1  
  1373.   
  1374.   
  1375. void AW9523_i2c_initial(void)  
  1376. {  
  1377. #if NEW_I2C_TIMING  
  1378.         I2C_SDA_MODE;  
  1379.     I2C_SCL_MODE;  
  1380.     I2C_SDA_OUTPUT;  
  1381.     I2C_SCL_OUTPUT;  
  1382.   
  1383.    mt_set_gpio_pull_enable(I2C_SDA_GPIO, GPIO_PULL_ENABLE);   
  1384.    mt_set_gpio_pull_enable(I2C_SCL_GPIO, GPIO_PULL_ENABLE);   
  1385.   
  1386.     I2C_SDA_HIGH;  
  1387.     I2C_SCL_HIGH;  
  1388. #else  
  1389.     GPIO_ModeSetup(I2C_SCL_GPIO, 0);  
  1390.     GPIO_InitIO(1, I2C_SCL_GPIO);  
  1391.     mt_set_gpio_pull_enable(I2C_SCL_GPIO, GPIO_PULL_ENABLE);  
  1392.     GPIO_WriteIO(1, I2C_SCL_GPIO);  
  1393.       
  1394.     GPIO_ModeSetup(I2C_SDA_GPIO, 0);  
  1395.     GPIO_InitIO(1,I2C_SDA_GPIO);  
  1396.     mt_set_gpio_pull_enable(I2C_SDA_GPIO, GPIO_PULL_ENABLE);  
  1397.     GPIO_WriteIO(0, I2C_SDA_GPIO);  
  1398.     AW9523_delay_1us(5);  
  1399.     GPIO_WriteIO(1, I2C_SDA_GPIO);//脦陋卤脺脙芒i2c initial 脢卤虏煤脡煤\u017d铆脦贸碌脛脳\u017d脤卢拢卢脧脠路垄脪禄\u017e枚脥拢脰鹿脤玫\u0152镁  
  1400. #endif  
  1401. }  
  1402.   
  1403. void AW9523_Hw_reset(void)  
  1404. {     
  1405.   
  1406.     GPIO_ModeSetup(GPIO74, 0);  
  1407.     GPIO_InitIO(0, AW9523_RESET_PIN);  
  1408.     AW9523_delay_1us(50);  
  1409.   
  1410.   
  1411.     GPIO_ModeSetup(AW9523_RESET_PIN, 0);  
  1412.     GPIO_InitIO(1, AW9523_RESET_PIN);  
  1413.     GPIO_WriteIO(0, AW9523_RESET_PIN);  
  1414.     //kpled_ctrl_open(1);           // Kpled on , then reset be pulled down  
  1415.   
  1416.     AW9523_delay_1us(200); //\u017e\u017d脦禄脨脜潞脜脦陋碌脥碌莽脝\u0153碌脛鲁脰脨酶脢卤\u0152盲卤脴脨毛脰脕脡脵20us虏脜脛脺脮媒鲁拢\u017e\u017d脦禄    
  1417.     GPIO_WriteIO(1, AW9523_RESET_PIN);   
  1418.     //kpled_ctrl_open(0);            // Kpled off, then reset be pulled up by VIO18  
  1419.     //AW9523_delay_1us(30);   
  1420.     mdelay(30);  
  1421. }  
  1422.   
  1423. static void AW9523_i2c_start(void)  
  1424. {  
  1425. #if NEW_I2C_TIMING  
  1426.         I2C_SDA_MODE;  
  1427.     I2C_SCL_MODE;  
  1428.     I2C_SDA_OUTPUT;  
  1429.     I2C_SCL_OUTPUT;  
  1430.         //spin_lock_irqsave(&gpio_i2c_spinLock, flags_spin);  
  1431.     I2C_SDA_HIGH;  
  1432.     AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1433.     I2C_SCL_HIGH;  
  1434.     AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1435.     I2C_SDA_LOW;  
  1436.     AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1437. #else  
  1438.     GPIO_InitIO(1,I2C_SDA_GPIO);  
  1439.     GPIO_InitIO(1,I2C_SCL_GPIO);  
  1440.       
  1441.     GPIO_WriteIO(1, I2C_SDA_GPIO);  
  1442.     GPIO_WriteIO(1, I2C_SCL_GPIO);  
  1443.     AW9523_delay_1us(2);  
  1444.     GPIO_WriteIO(0, I2C_SDA_GPIO);  
  1445.     AW9523_delay_1us(2);      
  1446.     GPIO_WriteIO(0, I2C_SCL_GPIO);  
  1447.     AW9523_delay_1us(2);      
  1448. #endif   
  1449. }  
  1450.   
  1451. static void AW9523_i2c_stop(void)  
  1452. {  
  1453. #if NEW_I2C_TIMING  
  1454.     I2C_SDA_OUTPUT;  
  1455.     I2C_SCL_OUTPUT;  
  1456.     //spin_lock_irqsave(&gpio_i2c_spinLock, flags_spin);  
  1457.     I2C_SCL_LOW;   // test @20131009  
  1458.     AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);     // 20131010  
  1459.     I2C_SDA_LOW;  
  1460.     AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1461.     I2C_SCL_HIGH;  
  1462.     AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1463.     I2C_SDA_HIGH;  
  1464.         AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1465. #else  
  1466.     GPIO_InitIO(1,I2C_SDA_GPIO);  
  1467.     GPIO_InitIO(1,I2C_SCL_GPIO);      
  1468.     GPIO_WriteIO(0, I2C_SCL_GPIO);  
  1469.     AW9523_delay_1us(2);  
  1470.     GPIO_WriteIO(0, I2C_SDA_GPIO);  
  1471.     GPIO_WriteIO(1, I2C_SCL_GPIO);  
  1472.     AW9523_delay_1us(2);  
  1473.     GPIO_WriteIO(1, I2C_SDA_GPIO);  
  1474. #endif  
  1475. }  
  1476.   
  1477. static char AW9523_i2c_write_byte(unsigned char data)  
  1478. {  
  1479. #if NEW_I2C_TIMING  
  1480.   
  1481.         char  i = 0;  
  1482.         char times = 0;  
  1483.     //unsigned long flags_spin;  
  1484.   
  1485.         //spin_lock_irqsave(&gpio_i2c_spinLock, flags_spin);  
  1486.         I2C_SCL_LOW;  
  1487.     AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1488.     I2C_SDA_OUTPUT;  
  1489.   
  1490.         for(i=0;i<8;i++)  
  1491.         {  
  1492.             if((data<<i)&0x80)  
  1493.                      I2C_SDA_HIGH;  
  1494.             else  
  1495.                      I2C_SDA_LOW;                 
  1496.             AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1497.             I2C_SCL_HIGH;             
  1498.             AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1499.             I2C_SCL_LOW;  
  1500.         AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1501.         }          
  1502.   
  1503.         I2C_SDA_INPUT;  
  1504.         AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);  
  1505.     I2C_SCL_HIGH;  
  1506.     AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1507.     //spin_unlock_irqrestore(&gpio_i2c_spinLock, flags_spin);  
  1508.     while  (I2C_SDA_READ==1)  
  1509.     {  
  1510.          AW9523_delay_1us(5);  //udelay(10);//return 1;  
  1511.         times++;  
  1512.         if (times==10)  
  1513.           break;  
  1514.     }  
  1515.       
  1516.     I2C_SCL_LOW;  
  1517.     AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);   
  1518.       
  1519.         return 1;  
  1520.   
  1521. #else  
  1522.   
  1523.     u8 i;  
  1524.     char ack;  
  1525.       
  1526.     GPIO_InitIO(1,I2C_SDA_GPIO);  
  1527.     for (i=0; i<8; i++)  
  1528.     {  
  1529.         if (data & 0x80)  
  1530.             GPIO_WriteIO(1,I2C_SDA_GPIO);  
  1531.         else  
  1532.             GPIO_WriteIO(0,I2C_SDA_GPIO);  
  1533.         data <<= 1;  
  1534.         AW9523_delay_1us(1);  
  1535.         GPIO_WriteIO(1,I2C_SCL_GPIO);  
  1536.         AW9523_delay_1us(1);  
  1537.         GPIO_WriteIO(0,I2C_SCL_GPIO);  
  1538.         AW9523_delay_1us(1);  
  1539.     }  
  1540.     GPIO_InitIO(0,I2C_SDA_GPIO);  
  1541.     AW9523_delay_1us(6);  
  1542.     GPIO_WriteIO(1,I2C_SCL_GPIO);  
  1543.     ack = GPIO_ReadIO(I2C_SDA_GPIO); /// ack     
  1544.     AW9523_delay_1us(1);  
  1545.     GPIO_WriteIO(0,I2C_SCL_GPIO);  
  1546.     return ack;   
  1547. #endif  
  1548. }  
  1549.   
  1550. static u8 AW9523_i2c_read_byte(void)  
  1551. {  
  1552. #if NEW_I2C_TIMING  
  1553.         u8 rec_byte = 0x00;  
  1554.     u8 i = 0;  
  1555.   
  1556.     //I2C_SCL_LOW;  
  1557.     //mdelay(1);   
  1558.       
  1559.     for (i=0; i<8; i++)  
  1560.     {  
  1561.           rec_byte <<=1;  
  1562.          //I2C_SCL_LOW;  
  1563.              //mdelay(1);  
  1564.          I2C_SCL_HIGH;  
  1565.          AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);  
  1566.   
  1567.          rec_byte |= I2C_SDA_READ;  
  1568.          I2C_SCL_LOW;  
  1569.              AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);  
  1570.     }  
  1571.   
  1572.          I2C_SDA_OUTPUT;  
  1573.      I2C_SDA_HIGH;  
  1574.      AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);  
  1575.   
  1576.      I2C_SCL_HIGH;    
  1577.          AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);  
  1578.      I2C_SCL_LOW;    
  1579.          AW9523_delay_1us(5);  //udelay(10); //udelay(100); //mdelay(1);      
  1580.            
  1581.      return rec_byte;  
  1582. #else  
  1583.     u8 i;  
  1584.     u8 bData;  
  1585.     GPIO_InitIO(0, I2C_SDA_GPIO);  
  1586.     //脢媒\u0178脻露脕鲁枚  
  1587.       bData = 0x00;  
  1588.       for (i=0;i<8;i++) {  
  1589.           bData <<= 1;  
  1590.           AW9523_delay_1us(4);  
  1591.           GPIO_WriteIO(1, I2C_SCL_GPIO);  
  1592.           if (GPIO_ReadIO(I2C_SDA_GPIO)) {  
  1593.               bData |= 0x01;  
  1594.           } else {  
  1595.               bData &= 0xfe;  
  1596.           }  
  1597.           AW9523_delay_1us(1);  
  1598.            GPIO_WriteIO(0, I2C_SCL_GPIO);  
  1599.       }  
  1600.       AW9523_delay_1us(1);  
  1601.       GPIO_WriteIO(1, I2C_SCL_GPIO);      
  1602.       AW9523_delay_1us(1);  
  1603.       GPIO_WriteIO(0, I2C_SCL_GPIO);  
  1604.       return bData;  
  1605. #endif  
  1606. }  
  1607.   
  1608. static char AW9523_i2c_write_reg_org(unsigned char reg,unsigned char data)  
  1609. {  
  1610. #if NEW_I2C_TIMING  
  1611.         AW9523_i2c_start();  
  1612.     AW9523_i2c_write_byte(LED_SLAVE_ADDR);  
  1613.     AW9523_i2c_write_byte(reg);  
  1614.     AW9523_i2c_write_byte(data);  
  1615.     AW9523_i2c_stop();  
  1616.     return 1;  
  1617. #else  
  1618.   
  1619.     char ack=0;  
  1620.     AW9523_i2c_start();   
  1621.     ack|=AW9523_i2c_write_byte(LED_SLAVE_ADDR);     //write device address  
  1622.     ack|=AW9523_i2c_write_byte(reg);    // reg address  
  1623.     ack|= AW9523_i2c_write_byte(data);  // data  
  1624.     AW9523_i2c_stop();  
  1625.     return ack;  
  1626. #endif  
  1627.   
  1628. }  
  1629.   
  1630. static char AW9523_i2c_write_reg(unsigned char reg,unsigned char data)  
  1631. {  
  1632. #if NEW_I2C_TIMING  
  1633.         AW9523_i2c_start();  
  1634.     AW9523_i2c_write_byte(LED_SLAVE_ADDR);  
  1635.     AW9523_i2c_write_byte(reg);  
  1636.     AW9523_i2c_write_byte(data);  
  1637.     AW9523_i2c_stop();  
  1638.     return 1;  
  1639. #else  
  1640.     char ack=0;  
  1641.     char i;  
  1642.     for (i=0;i<AW9523_I2C_MAX_LOOP;i++)  
  1643.         {  
  1644.             ack=AW9523_i2c_write_reg_org(reg,data);  
  1645.             if(ack==0) // ack success  
  1646.                 break;  
  1647.         }  
  1648.     return ack;  
  1649. #endif  
  1650. }  
  1651.   
  1652. u8 AW9523_i2c_read_reg(u8 regaddr)   
  1653. {  
  1654. #if NEW_I2C_TIMING  
  1655.         u8 read_byte = 0;  
  1656.   
  1657.         AW9523_i2c_start();  
  1658.         AW9523_i2c_write_byte(LED_SLAVE_ADDR);  
  1659.     AW9523_i2c_write_byte(regaddr);  
  1660.     AW9523_i2c_stop();             /////////////////////  
  1661.     AW9523_i2c_start();            //restart signal  
  1662.     AW9523_i2c_write_byte(LED_SLAVE_ADDR|0x01);  
  1663.     read_byte = AW9523_i2c_read_byte();  
  1664.     AW9523_i2c_stop();  
  1665.     return read_byte;  
  1666. #else  
  1667.     u8 mask,i, bData;  
  1668.     char ack1,ack2,ack3;  
  1669.     u8 i2caddr;  
  1670.     for (i=0;i<AW9523_I2C_MAX_LOOP;i++)  
  1671.         {  
  1672.             AW9523_i2c_start();   
  1673.             ack1=AW9523_i2c_write_byte(LED_SLAVE_ADDR);     //write device address  
  1674.             ack2=AW9523_i2c_write_byte(regaddr);    // reg address  
  1675.             AW9523_i2c_stop();  
  1676.             AW9523_i2c_start();   
  1677.             ack3=AW9523_i2c_write_byte((LED_SLAVE_ADDR|0x01));  //write device address  
  1678.             if((ack1 || ack2 || ack3)==0) // ack success  
  1679.                 break;  
  1680.         }  
  1681.     bData=AW9523_i2c_read_byte();  
  1682.     AW9523_i2c_stop();  
  1683.         return bData;  
  1684. #endif  
  1685.   
  1686. }  
  1687.   
  1688. static void AW9523_SDA_Change(void)   
  1689. {  
  1690.     u8 SDA_index = 0;  
  1691.     GPIO_WriteIO(0,I2C_SDA_GPIO);  
  1692.     AW9523_delay_1us(80);  
  1693.     for (SDA_index=0;SDA_index<50;SDA_index++)  
  1694.         {             
  1695.             GPIO_InitIO(0, I2C_SDA_GPIO);  
  1696.             AW9523_delay_1us(420);  //SDA碌脛脰脺脝脷拢卢\u017e脽碌莽脝\u0153420us拢卢 脭脷\u017e梅脝\u0153脤\u0161脧脗脟毛\u017e霉\u0178脻脰梅脝碌脌\u017d碌梅脮没拢卢卤拢鲁脰脪禄脰脗  
  1697.             GPIO_InitIO(1, I2C_SDA_GPIO);//SDA碌脛脰脺脝脷拢卢碌脥碌莽脝\u015380us拢卢 脭脷\u017e梅脝\u0153脤\u0161脧脗脟毛\u017e霉\u0178脻脰梅脝碌脌\u017d碌梅脮没拢卢卤拢鲁脰脪禄脰脗  
  1698.             AW9523_delay_1us(80); //SDA碌脥碌莽脝\u015380us  
  1699.         }  
  1700.     GPIO_InitIO(1, I2C_SDA_GPIO);  
  1701.     GPIO_WriteIO(1,I2C_SDA_GPIO);  
  1702.     AW9523_delay_1us(420);    
  1703. }  
  1704.   
  1705. char AW9523_POWER_ON(void)  
  1706. {    // AW9523 POWER-ON拢卢 脟毛驴脥禄搂虏禄脪陋\u017e脛露炉\u017d脣潞炉脢媒  
  1707.      // 脭脷aw9523_init()脰脨拢卢脧脠\u0153酶脨脨POWER-ON拢卢脭脵\u0153酶脨脨驴脥禄搂脳脭脡铆碌脛脧脿鹿脴虏脵脳梅  
  1708.     char ack=0;  
  1709.     u8 count=0;  
  1710.     AW9523_i2c_initial();  
  1711.     AW9523_Hw_reset();  
  1712.       while(count++ < 120)       //  
  1713.               {  
  1714.                   if(AW9523_i2c_write_reg_org(0x55,0x55))   //脜脨露脧脫\u0160\u017d冒脛拢脢\u0153隆拢0x55脦陋驴脮\u0152脛\u017d忙脝梅拢卢虏禄禄谩露脭驴脥禄搂脫\u0160脫脙虏煤脡煤脫掳脧矛  
  1715.                       {  
  1716.                       AW9523_SDA_Change();  
  1717.                       continue;  
  1718.                       }  
  1719.                   if(AW9523_i2c_write_reg_org(0xaa,0xaa))  
  1720.                       {  
  1721.                       AW9523_SDA_Change();  
  1722.                       continue;  
  1723.                       }     
  1724.                   if(AW9523_i2c_write_reg_org(0x55,0xaa))  
  1725.                       {  
  1726.                       AW9523_SDA_Change();  
  1727.                       continue;  
  1728.                       }                 
  1729.                   if(AW9523_i2c_write_reg_org(0xaa,0x55))   
  1730.                       {  
  1731.                       AW9523_SDA_Change();  
  1732.                       continue;  
  1733.                       }                                 
  1734.   
  1735.                   break;                    
  1736.               }  
  1737.     ack |= AW9523_i2c_write_reg_org(0x55,0x55);   
  1738.     ack |= AW9523_i2c_write_reg_org(0xaa,0xaa);   
  1739.     //SCI_TRACE_LOW("----AW9523 POWER ON -----end =%d\r\n", count);  
  1740.     return ack;  
  1741. }  
  1742.   
  1743. /*=======================================i2c driver end =================================*/  
  1744.   
  1745. /*===========================aw9523\u0152脛\u017d忙脝梅碌脛虏脵脳梅\u0153脫驴脷 begin ================================*/  
  1746. void aw9523_p0_p1_in_out_setting(void)  /* 脡猫脰脙 p0 p1 脢盲脠毛脢盲鲁枚脳\u017d脤卢*/  
  1747. {  
  1748.     P0_IN_OUT_STATE=0xFF;  
  1749.     AW9523_i2c_write_reg(0x04,P0_IN_OUT_STATE);//脡猫脰脙脣霉脫脨P0_\u0153脜脦陋脢盲脠毛脳\u017d脤卢  
  1750.     P1_IN_OUT_STATE=0x0;  
  1751.     AW9523_i2c_write_reg(0x05,P1_IN_OUT_STATE);//脡猫脰脙脣霉脫脨P1_\u0153脜脦陋脢盲鲁枚脳\u017d脤卢  
  1752. }  
  1753.   
  1754. void aw9523_p0_p1_interrupt_setting(void)   /* 脡猫脰脙 p0 p1 脭脢脨铆脰脨露脧脳\u017d脤卢*/  
  1755. {  
  1756.     u8 i=0;  
  1757.     P0_INT_STATE=0x0;   
  1758.     for (i=0;i<X_NUM;i++) {  
  1759.         P0_INT_STATE=P0_INT_STATE|(1<<COL[i]);//\u017e霉\u0178脻掳\u017d\u0152眉脜脜虏\u0152脌\u017d脡猫脰脙脰脨露脧  
  1760.     }  
  1761.     P0_INT_STATE=~P0_INT_STATE;  
  1762.     AW9523_i2c_write_reg(0x06,P0_INT_STATE);//潞脥掳\u017d\u0152眉脕脨露脭脫\u0160碌脛P0_\u0153脜脭脢脨铆脰脨露脧  
  1763.   
  1764.     P1_INT_STATE=0xFF;  
  1765.     AW9523_i2c_write_reg(0x07,P1_INT_STATE);//p1\u0153脜露\u0152虏禄脛脺脰脨露脧  
  1766.   
  1767. }  
  1768.   
  1769. void aw9523_p0_int_restore(void)  
  1770. {  
  1771.     AW9523_i2c_write_reg(0x06,P0_INT_STATE);  
  1772.   
  1773. }  
  1774.   
  1775. void aw9523_P1_int_restore()  
  1776. {  
  1777.     AW9523_i2c_write_reg(0x07,P1_INT_STATE);  
  1778. }  
  1779.   
  1780. void aw9523_p0_int_disable()  
  1781. {  
  1782.     AW9523_i2c_write_reg(0x06, 0xff);  
  1783. }  
  1784.   
  1785. void aw9523_p1_int_disable()  
  1786. {  
  1787.     AW9523_i2c_write_reg(0x07, 0xff);  
  1788. }  
  1789.   
  1790. u8 aw9523_get_p0(void)    
  1791. {  
  1792.     //AW9523_i2c_read_reg(0x01);       //just for test 20131129  
  1793.     return AW9523_i2c_read_reg(0x00);  
  1794. }  
  1795.   
  1796. u8 aw9523_get_p1(void)  
  1797. {  
  1798.     return AW9523_i2c_read_reg(0x01);  
  1799. }  
  1800.   
  1801. void aw9523_set_p0(u8 data)  
  1802. {  
  1803.     AW9523_i2c_write_reg(0x02,data);  
  1804. }  
  1805.   
  1806. void aw9523_set_p1(u8 data)  
  1807. {  
  1808.     AW9523_i2c_write_reg(0x03,data);  
  1809. }  
  1810.   
  1811. void RE_P0_WRITE(u8 P0,u8 data)   
  1812. {  
  1813.     u8 tmp_value;  
  1814.     tmp_value = AW9523_i2c_read_reg(0x02);  
  1815.     if(data==1)  
  1816.     {  
  1817.         AW9523_i2c_write_reg(0x02,(tmp_value|(1<<P0)));  
  1818.     }  
  1819.     else  
  1820.     {  
  1821.         AW9523_i2c_write_reg(0x02,(tmp_value&(~(1<<P0))));  
  1822.     }     
  1823. }  
  1824.   
  1825. void RE_P1_WRITE(u8 P1,u8 data)  
  1826. {  
  1827.     u8 tmp_value;  
  1828.     tmp_value = AW9523_i2c_read_reg(0x03);  
  1829.     if(data==1)  
  1830.     {  
  1831.         AW9523_i2c_write_reg(0x03,(tmp_value|(1<<P1)));  
  1832.     }  
  1833.     else  
  1834.     {  
  1835.         AW9523_i2c_write_reg(0x03,(tmp_value&(~(1<<P1))));  
  1836.     }     
  1837. }  
  1838.   
  1839. void aw9523_keylight_open(u8 enable)  
  1840. {  
  1841.         if (enable)  
  1842.         {  
  1843.               AW9523_i2c_write_reg(0x20, 0x40);       // led current P1_0  
  1844.               AW9523_i2c_write_reg(0x21, 0x40);       // led current P1_1  
  1845.                 
  1846.               AW9523_i2c_write_reg(0x13, 0xFf);       // P1_0, P1_1 working mode  
  1847.         }  
  1848.     else  
  1849.     {  
  1850.               AW9523_i2c_write_reg(0x20, 0x00);       // led current P1_0  
  1851.               AW9523_i2c_write_reg(0x21, 0x00);       // led current P1_1  
  1852.   
  1853.               AW9523_i2c_write_reg(0x13, 0xFf);       // P1_0, P1_1 working mode                
  1854.     }  
  1855. }  
  1856.   
  1857. #include <mach/mt_pm_ldo.h>  
  1858.   
  1859. #define SCAN_GPIO    GPIO30             
  1860. #define SCAN_POWER_GPIO    GPIO134             
  1861. #define SCAN_POWER2_GPIO    GPIO110  
  1862.   
  1863. void SCAN_init(void)  
  1864. {  
  1865. /* 
  1866.     GPIO_ModeSetup(SCAN_POWER_GPIO, 0); 
  1867.     GPIO_InitIO(1, SCAN_POWER_GPIO); 
  1868.     GPIO_WriteIO(1, SCAN_POWER_GPIO); 
  1869.      
  1870.     GPIO_ModeSetup(SCAN_POWER2_GPIO, 0); 
  1871.     GPIO_InitIO(1, SCAN_POWER2_GPIO); 
  1872.     GPIO_WriteIO(1, SCAN_POWER2_GPIO); 
  1873.  
  1874.     hwPowerDown(MT6323_POWER_LDO_VGP2, "TP"); 
  1875.     hwPowerOn(MT6323_POWER_LDO_VGP2, VOL_1800, "TP"); 
  1876.      
  1877.     hwPowerDown(MT6323_POWER_LDO_VGP1, "TP"); 
  1878.     hwPowerOn(MT6323_POWER_LDO_VGP1, VOL_3300, "TP"); 
  1879.  
  1880.  
  1881.     GPIO_ModeSetup(SCAN_GPIO, 0); 
  1882.     GPIO_InitIO(1, SCAN_GPIO); 
  1883.     GPIO_WriteIO(1, SCAN_GPIO); 
  1884. */    
  1885. }  
  1886.   
  1887. void SCAN_test(void)  
  1888. {  
  1889.    printk("\===== SCAN_test\r\n");  
  1890.   
  1891.     GPIO_ModeSetup(SCAN_GPIO, 0);  
  1892.     GPIO_InitIO(1, SCAN_GPIO);  
  1893.     GPIO_WriteIO(1, SCAN_GPIO);  
  1894.     mdelay(20);  
  1895.   
  1896.     GPIO_ModeSetup(SCAN_POWER_GPIO, 0);  
  1897.     GPIO_InitIO(1, SCAN_POWER_GPIO);  
  1898.     GPIO_WriteIO(1, SCAN_POWER_GPIO);  
  1899.       
  1900.     GPIO_ModeSetup(SCAN_POWER2_GPIO, 0);  
  1901.     GPIO_InitIO(1, SCAN_POWER2_GPIO);  
  1902.     GPIO_WriteIO(1, SCAN_POWER2_GPIO);  
  1903.   
  1904.     hwPowerDown(MT6323_POWER_LDO_VGP2, "TP");  
  1905.     hwPowerOn(MT6323_POWER_LDO_VGP2, VOL_1800, "TP");  
  1906.       
  1907.     hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1908.     hwPowerOn(MT6323_POWER_LDO_VGP1, VOL_3300, "TP");  
  1909.   
  1910.   
  1911.     mdelay(100);  
  1912.      
  1913.       
  1914.     GPIO_WriteIO(0, SCAN_GPIO);  
  1915.     mdelay(1500);  
  1916.   
  1917.     GPIO_WriteIO(1, SCAN_GPIO);  
  1918.     mdelay(100);  
  1919.       
  1920.     hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1921.     hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1922.     hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1923.     hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1924.   
  1925.     //GPIO_WriteIO(1, SCAN_GPIO);  
  1926.   
  1927. }  
  1928.   
  1929.   
  1930. EXPORT_SYMBOL(SCAN_init);  
  1931. EXPORT_SYMBOL(SCAN_test);  
  1932.   
  1933. void trig_scan_evel(int level)  
  1934. {  
  1935. #if 0  
  1936.     SCAN_test();  
  1937.   
  1938. #else  
  1939.     printk("\===== SCAN_test\r\n");  
  1940.   
  1941.     GPIO_ModeSetup(SCAN_GPIO, 0);  
  1942.     GPIO_InitIO(1, SCAN_GPIO);  
  1943.     GPIO_WriteIO(1, SCAN_GPIO);  
  1944.     mdelay(20);  
  1945.   
  1946.     GPIO_ModeSetup(SCAN_POWER_GPIO, 0);  
  1947.     GPIO_InitIO(1, SCAN_POWER_GPIO);  
  1948.     GPIO_WriteIO(1, SCAN_POWER_GPIO);  
  1949.   
  1950.     GPIO_ModeSetup(SCAN_POWER2_GPIO, 0);  
  1951.     GPIO_InitIO(1, SCAN_POWER2_GPIO);  
  1952.     GPIO_WriteIO(1, SCAN_POWER2_GPIO);  
  1953.   
  1954.     if(level > 0)  
  1955.     {         
  1956.         hwPowerDown(MT6323_POWER_LDO_VGP2, "TP");  
  1957.         hwPowerOn(MT6323_POWER_LDO_VGP2, VOL_1800, "TP");  
  1958.           
  1959.         hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1960.         hwPowerOn(MT6323_POWER_LDO_VGP1, VOL_3300, "TP");  
  1961.   
  1962.         mdelay(200);  
  1963.           
  1964.         GPIO_WriteIO(0, SCAN_GPIO);  
  1965.         mdelay(100);  
  1966.     }  
  1967.     else  
  1968.     {         
  1969.         GPIO_WriteIO(1, SCAN_GPIO);  
  1970.         mdelay(100);  
  1971.           
  1972.         hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1973.         hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1974.         hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1975.         hwPowerDown(MT6323_POWER_LDO_VGP1, "TP");  
  1976.     }  
  1977. #endif    
  1978. }  
  1979.   
  1980.   
  1981.   
  1982. void aw9523_test(void)  
  1983. {  
  1984. // i2c_initial();    
  1985. //   AW9523_Hw_reset();  
  1986. //   AW9523_i2c_initial();  
  1987.    printk("\===== naw9523_test_entry=\r\n");  
  1988.    printk("\===== naw9523_i2c_read_reg_0x00=0x%x\r\n",AW9523_i2c_read_reg(0x00));  
  1989.    printk("\===== naw9523_i2c_read_reg_0x01=0x%x\r\n",AW9523_i2c_read_reg(0x01));   
  1990.    printk("\===== naw9523_i2c_read_reg_0x02=0x%x\r\n",AW9523_i2c_read_reg(0x02));  
  1991.    printk("\===== naw9523_i2c_read_reg_0x03=0x%x\r\n",AW9523_i2c_read_reg(0x03));   
  1992.    printk("\===== naw9523_i2c_read_reg_0x04=0x%x\r\n",AW9523_i2c_read_reg(0x04));  
  1993.    printk("\===== naw9523_i2c_read_reg_0x05=0x%x\r\n",AW9523_i2c_read_reg(0x05));   
  1994.    printk("\===== naw9523_i2c_read_reg_0x06=0x%x\r\n",AW9523_i2c_read_reg(0x06));  
  1995.    printk("\===== naw9523_i2c_read_reg_0x07=0x%x\r\n",AW9523_i2c_read_reg(0x07));      
  1996.    printk("\===== naw9523_i2c_read_reg_0x10=0x%x\r\n",AW9523_i2c_read_reg(0x10));      
  1997.    printk("\===== naw9523_i2c_read_reg_0x11=0x%x\r\n",AW9523_i2c_read_reg(0x11));      
  1998.    printk("\===== naw9523_i2c_read_reg_0x12=0x%x\r\n",AW9523_i2c_read_reg(0x12));  
  1999.    printk("\===== naw9523_i2c_read_reg_0x13=0x%x\r\n",AW9523_i2c_read_reg(0x13));     
  2000. }  
  2001.   
  2002.  void aw9523_set_p1_gpio_mode(void)  
  2003.  {  
  2004.      AW9523_i2c_write_reg(0x13,0xff);  
  2005.  }  
  2006.   
  2007. void aw9523_init()  
  2008. {  
  2009.     //AW9523_POWER_ON();          // test new i2c timing , delete this code   
  2010.     //GPIO_ModeSetup(GPIO73, 0);  
  2011.     //GPIO_InitIO(1, GPIO73);  
  2012.     //GPIO_WriteIO(0, GPIO73);  
  2013.     printk("======= aw9523_init\n");  
  2014.   
  2015.         AW9523_i2c_initial();  
  2016.         AW9523_Hw_reset();    
  2017.           
  2018. #if 1  
  2019.         AW9523_i2c_write_reg(0x7F, 0x00);   // sw reset  
  2020.         mdelay(10);  
  2021.   
  2022.         aw9523_keylight_open(0);        // close P1_0, P1_1 mos fet  
  2023.           
  2024.         aw9523_p0_int_disable();   
  2025.   
  2026.         aw9523_set_p1_gpio_mode();  
  2027.   
  2028.         //liubiao  
  2029.         aw9523_p0_p1_in_out_setting();  
  2030.         aw9523_p0_p1_interrupt_setting();  
  2031.         aw9523_set_p1(P1_VALUE);  
  2032.         AW9523_i2c_read_reg(0x00);   
  2033.         AW9523_i2c_read_reg(0x01);      
  2034. #endif  
  2035. }  
  2036.   
  2037. void Set_P0_X_AND_P1_Y(void)   
  2038. {  
  2039.     u8 i=0;  
  2040.     u8 temp=0;  
  2041.     for (i=0;i<X_NUM;i++) {  
  2042.         temp=temp|(1<<COL[i]);  
  2043.   }  
  2044.     //SCI_TRACE_LOW("temp=%x\r\n",temp);  
  2045.   
  2046.     for (i=0;i<X_NUM;i++) {  
  2047.         P0_X[i]=temp&(~(1<<COL[i]));  
  2048.         //SCI_TRACE_LOW("P0_X[%d]=%x\r\n",i,P0_X[i]);  
  2049.     }  
  2050.   
  2051.     temp=0;  
  2052.     for (i=0;i<Y_NUM;i++) {  
  2053.         temp=temp|(1<<Line[i]);  
  2054.     }  
  2055.     //SCI_TRACE_LOW("temp=%x\r\n",temp);  
  2056.     for (i=0;i<Y_NUM;i++) {  
  2057.         P1_Y[i]=temp&(~(1<<Line[i]));  
  2058.         //SCI_TRACE_LOW("P1_Y[%d]=%x\r\n",i,P1_Y[i]);  
  2059.     }  
  2060.      
  2061.     for(i=0;i<8;i++)  
  2062.     {  
  2063.         if(P0_kbd_used[i]==1)  
  2064.         {  
  2065.             P0_kbd_used_temp|=1<<i;  
  2066.         }  
  2067.     }  
  2068.     //SCI_TRACE_LOW("P0_kbd_used_temp=%x\r\n",P0_kbd_used_temp);  
  2069. }  
  2070.   
  2071. u8 keyboard_get_press_key(void)  
  2072. {  
  2073.     u8 x=0xFF,y=0XFF;  
  2074.     u8 i=0,j=0,k=0;  
  2075.     u8 get_p0=0xff;   
  2076.       
  2077.     get_p0=aw9523_get_p0();  
  2078.     i=(get_p0)|(~(P0_kbd_used_temp));  //脦\u017d脫脙脳枚\u0152眉脜脤脡\u0161脙猫碌脛P0驴脷,脝盲露脕鲁枚碌脛脰碌卤禄脝脕卤脦  
  2079.     //i=get_p0 & P0_kbd_used_temp;  //脦\u017d脫脙脳枚\u0152眉脜脤脡\u0161脙猫碌脛P0驴脷,脝盲露脕鲁枚碌脛脰碌卤禄脝脕卤脦  
  2080.     //SCI_TRACE_LOW("===aw9523_get_p0()===%x\r\n",get_p0);  
  2081.     if (i==0xff)   
  2082.     {  
  2083.         //  SCI_TRACE_LOW("------get_key=0xff----\r\n");      
  2084.         return 0xFF;  
  2085.     }  
  2086.     else   
  2087.     {  
  2088.     //SCI_TRACE_LOW("===aw9523_get_p0()===%x\r\n",i);      
  2089.        if(KeyBoardKey_State==KEY_STATE_PRESSED || KeyBoardKey_State==KEY_STATE_LONGPRESS)  
  2090.     {  
  2091.             //脠莽鹿没脰庐脟掳脢脟\u017d\u0160脫脷脫脨掳\u017d\u0152眉碌脛脳\u017d脤卢,脭貌脰卤\u0153脫脠楼\u0152矛虏芒脮芒\u017e枚掳\u017d\u0152眉脢脟路帽脢脥路脜  
  2092.          //SCI_TRACE_LOW("------press or longpress entry ,pre_x=%d,pre_y=%d ----\r\n",pre_x,pre_y);   
  2093.             AW9523_i2c_write_reg(0x05,P1_Y[pre_y]);  
  2094.             get_p0=aw9523_get_p0();   
  2095.           //i=get_p0 & P0_kbd_used_temp;  
  2096.               if  ((get_p0&(1<<COL[pre_x])) == 0)  
  2097.         {  
  2098.                AW9523_i2c_write_reg(0x05,P1_VALUE);   
  2099.                return aw9523_key[pre_y][pre_x];  
  2100.         }  
  2101.               else   
  2102.             {  
  2103.                AW9523_i2c_write_reg(0x05,P1_VALUE);  
  2104.                return 0xFF;  
  2105.             }  
  2106.         }   
  2107.         else   
  2108.      {  
  2109.     //\u0152矛虏芒掳\u017d\u0152眉碌脛鲁脤脨貌脠毛驴脷  
  2110.            for (j=0;j<X_NUM;j++)   
  2111.         {  
  2112.                 if((i&(1<<COL[j]))==0)  
  2113.          {  
  2114.         //if (i==P0_X[j]) {  
  2115.             //卤\u0178脌媒脰脨P0_X[0:7]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f},  
  2116.             //脠么露脕鲁枚碌脛P0_脰碌脛鲁脪禄脦禄脦陋0拢卢脭貌脜脨露脧鲁枚掳\u017d脧脗碌脛脢脟脮芒脪禄脕脨  
  2117.                   x=j;  
  2118.                   break;  
  2119.                }  
  2120.            }  
  2121.              
  2122.            if (x==0xFF)   
  2123.         {  
  2124.        // SCI_TRACE_LOW("------get_key=0xff----\r\n");    
  2125.               return 0xFF;  
  2126.            }  
  2127.              
  2128.         for (j=0;j<Y_NUM;j++)   
  2129.         {  
  2130.            // aw9523_set_p1(P1_Y[j]);   
  2131.              AW9523_i2c_write_reg(0x05,P1_Y[j]);  
  2132.             /*脗脰脩炉脡\u0161脙猫隆拢脪脌\u017d脦\u0153芦脛鲁脪禄脨脨P1脰碌脰脙0拢卢脝盲脣没脨脨脰脙1禄貌\u017e脽脳猫拢卢脙驴脡\u0161脙猫脪禄脨脨脢卤拢卢露\u0152露脕脪禄\u017d脦P0脰碌 
  2133.             碌卤脡\u0161脙猫碌\u0153脛鲁脪禄脨脨脢卤拢卢脠么露脕鲁枚碌脛P0脰碌脫毛脰庐脟掳脜脨露脧碌\u0153碌脛P0脰碌脧脿碌脠拢卢脭貌脜脨露脧鲁枚掳\u017d脧脗碌脛脢脟脮芒脪禄脨脨 */  
  2134.              get_p0=aw9523_get_p0();   
  2135.              k=(get_p0)|(~(P0_kbd_used_temp));             
  2136.           // if (k==P0_X[x]) {   
  2137.              if ((k&(1<<COL[x]))==0)  
  2138.           {   
  2139.                 y=j;  
  2140.                 break;  
  2141.              }  
  2142.            }  
  2143.         //aw9523_set_p1(P1_VALUE);  
  2144.            AW9523_i2c_write_reg(0x05,P1_VALUE);  
  2145.           // get_p0=aw9523_get_p0();   
  2146.           // k=get_p0 & P0_kbd_used_temp;   
  2147.         //SCI_TRACE_LOW("------get_key: x=%d,y=%d----\r\n",x,y);  
  2148.            if (x!=0xFF && y!=0xFF )   
  2149.         {  
  2150.               pre_x=x;  
  2151.               pre_y=y;  
  2152.                 return aw9523_key[y][x];  
  2153.            }  
  2154.         else   
  2155.         {  
  2156.                 return 0xFF;  
  2157.            }  
  2158.      }}  
  2159. }   
  2160.   
  2161. static void kpd_aw9523_handler(unsigned long data)  
  2162. {  
  2163.     //bool pressed;  
  2164.     u8 old_state = kpd_aw9523_state;  
  2165.         //static u8 flag = 1;  
  2166.   
  2167.         //mt65xx_eint_set_polarity(AW9523_EINT_NO, old_state);  
  2168.         aw9523_p0_int_disable();  
  2169.         disable_irq(MT_KP_IRQ_ID);  
  2170.         mt_eint_mask(AW9523_EINT_NO);  // mt65xx_eint_mask(AW9523_EINT_NO);  
  2171.     //aw9523_p0_int_disable();  
  2172.     printk("====== kpd_aw9523_handler state=%d\n", kpd_aw9523_state);  
  2173.       
  2174.         //printk("\n<<<<  xxx==kpd_aw9523_handler state=%d\n", kpd_aw9523_state);  
  2175.         //mt65xx_eint_unmask(AW9523_EINT_NO);  
  2176.     kpd_aw9523_state = !kpd_aw9523_state;  
  2177.   
  2178.         #if 0  
  2179.          if (kpd_aw9523_state!=KPD_AW9523_SWITCH_POLARITY)  
  2180.          {  
  2181.   
  2182.         mt65xx_eint_set_polarity(AW9523_EINT_NO, old_state);  
  2183.         enable_irq(MT_KP_IRQ_ID);     
  2184.         mt65xx_eint_unmask(AW9523_EINT_NO);  
  2185.   
  2186.             aw9523_p0_int_restore();     
  2187.   
  2188.         return;  
  2189.          }  
  2190.          #endif  
  2191.           
  2192.         printk("\n<<<<  ==== key =%d  pressed=======\r\n",keyboard_get_press_key());  
  2193.         KeyBoard_Key=keyboard_get_press_key();  //KEY_HOME;  
  2194.         printk("\n<<<<  === aw9523_handler==key =%d  pressed,old_state=%d==\r\n",KeyBoard_Key, old_state);  
  2195. /* 
  2196.         if(KeyBoard_Key==158) 
  2197.             KeyBoard_Key=KEY_3; 
  2198. */            
  2199.         //if(KeyBoard_Key==232)  
  2200.         //  KeyBoard_Key=KEY_DEL;  
  2201.   
  2202.         //if(((KeyBoard_Key>1)&&(KeyBoard_Key<12))||(KeyBoard_Key==103)||(KeyBoard_Key==105)||(KeyBoard_Key==106)||(KeyBoard_Key==108))  
  2203.         //if((KeyBoard_Key>1)&&(KeyBoard_Key<12))  
  2204.         //if(KeyBoard_Key==KEY_S)  
  2205.         //  SCAN_test();  
  2206.   
  2207.   
  2208.         //if(KeyBoard_Key==KEY_STAR)  
  2209.         //  trig_scan_evel(1);  
  2210.         //if(KeyBoard_Key==KEY_POUND)  
  2211.         //  trig_scan_evel(0);  
  2212.           
  2213.   
  2214.         if (KeyBoardKey_State==KEY_STATE_NULL||KeyBoardKey_State==KEY_STATE_RELEASED)   
  2215.         {  
  2216.             if (KeyBoard_Key!=0xFF)   
  2217.         {  
  2218.                KeyBoardKey_State=KEY_STATE_PRESSED;  
  2219.   
  2220.                KeyBoard_Key_Previous=KeyBoard_Key;  
  2221.            input_report_key(kpd_input_dev, KeyBoard_Key, 1);  
  2222.            input_sync(kpd_input_dev);  
  2223.   
  2224.             }  
  2225.        }   
  2226.        else if (KeyBoardKey_State==KEY_STATE_PRESSED)   
  2227.        {  
  2228.             if (KeyBoard_Key != KeyBoard_Key_Previous)   
  2229.         {  
  2230.                 KeyBoardKey_State=KEY_STATE_RELEASED;  
  2231.         //---  
  2232.         input_report_key(kpd_input_dev, KeyBoard_Key_Previous, 0); //发送键值  
  2233.             input_sync(kpd_input_dev); //同步  
  2234.             //-----  
  2235.              }  
  2236.         }   
  2237.   //      */  
  2238.   
  2239.         AW9523_i2c_write_reg(0x05,P1_VALUE);  
  2240.   
  2241.     enable_irq(MT_KP_IRQ_ID);     
  2242.     mt_eint_unmask(AW9523_EINT_NO);  // mt65xx_eint_unmask(AW9523_EINT_NO);  
  2243.   
  2244.         aw9523_p0_int_restore();    
  2245.           
  2246.         AW9523_i2c_read_reg(0x00);  
  2247.         AW9523_i2c_read_reg(0x01);  
  2248.   
  2249.   
  2250. #if 0  
  2251.         aw9523_test();  
  2252. #endif  
  2253.   
  2254.         //mt65xx_eint_set_polarity(AW9523_EINT_NO, old_state);  
  2255. }  
  2256.   
  2257. static void kpd_aw9523_eint_handler(void)  
  2258. {  
  2259.     printk("===== kpd_aw9523_eint_handler\n");  
  2260.   
  2261.         //printk("\nxxx==kpd_halldet_eint_handler===\n");  
  2262.     tasklet_schedule(&kpd_aw9523_tasklet);  
  2263. }  
  2264.   
  2265. #endif  
  2266.   
  2267. static int kpd_pdrv_probe(struct platform_device *pdev)  
  2268. {  
  2269.       
  2270.     int i, r;  
  2271.     int err = 0;  
  2272.   
  2273.         printk("===== kpd_pdrv_probe\n");  
  2274.   
  2275.       
  2276. //#ifdef CONFIG_MTK_LDVT      
  2277. //unsigned int a, c, j;  
  2278. //unsigned int addr[]= {0x0502, 0xc0d8, 0xc0e0, 0xc0e8, 0xc0f0, 0xc048};  
  2279. //unsigned int data[]= {0x4000, 0x1249, 0x1249, 0x1249, 0x0009, 0x00ff};  
  2280. //    
  2281. //for(j = 0; j < 6; j++) {  
  2282. // a = pwrap_read(addr[j],&c);  
  2283. // if(a != 0)  
  2284. //  printk("kpd read fail, addr: 0x%x\n", addr[j]);  
  2285. //  printk("kpd read addr: 0x%x: data:0x%x\n",addr[j], c);  
  2286. // a = pwrap_write(addr[j],data[j]);  
  2287. // if(a != 0)  
  2288. //  printk("kpd write fail, addr: 0x%x\n", addr[j]);      
  2289. // a = pwrap_read(addr[j],&c);  
  2290. // if(a != 0)  
  2291. //  printk("kpd read fail, addr: 0x%x\n", addr[j]);  
  2292. // printk("kpd read addr: 0x%x: data:0x%x\n",addr[j], c);  
  2293. //}  
  2294. //  
  2295. ////    *(volatile u16 *)(KP_PMIC) = 0x1;  
  2296. ////    printk("kpd register for pmic set!\n");  
  2297. //#endif  
  2298.   
  2299.     /* initialize and register input device (/dev/input/eventX) */  
  2300.     kpd_input_dev = input_allocate_device();  
  2301.     if (!kpd_input_dev)  
  2302.         return -ENOMEM;  
  2303.   
  2304.     kpd_input_dev->name = KPD_NAME;  
  2305.     kpd_input_dev->id.bustype = BUS_HOST;  
  2306.     kpd_input_dev->id.vendor = 0x2454;  
  2307.     kpd_input_dev->id.product = 0x6572;  
  2308.     kpd_input_dev->id.version = 0x0010;  
  2309.     kpd_input_dev->open = kpd_open;  
  2310.   
  2311.     __set_bit(EV_KEY, kpd_input_dev->evbit);  
  2312.   
  2313. #if (KPD_PWRKEY_USE_EINT||KPD_PWRKEY_USE_PMIC)  
  2314.     __set_bit(KPD_PWRKEY_MAP, kpd_input_dev->keybit);  
  2315.     kpd_keymap[8] = 0;  
  2316. #endif  
  2317.     for (i = 17; i < KPD_NUM_KEYS; i += 9)   /* only [8] works for Power key */  
  2318.         kpd_keymap[i] = 0;  
  2319.   
  2320.     for (i = 0; i < KPD_NUM_KEYS; i++) {  
  2321.         if (kpd_keymap[i] != 0)  
  2322.             __set_bit(kpd_keymap[i], kpd_input_dev->keybit);  
  2323.     }  
  2324.   
  2325. #if KPD_AUTOTEST  
  2326.     for (i = 0; i < ARRAY_SIZE(kpd_auto_keymap); i++)  
  2327.         __set_bit(kpd_auto_keymap[i], kpd_input_dev->keybit);  
  2328. #endif  
  2329.   
  2330. #if KPD_HAS_SLIDE_QWERTY  
  2331.     __set_bit(EV_SW, kpd_input_dev->evbit);  
  2332.     __set_bit(SW_LID, kpd_input_dev->swbit);  
  2333. #endif  
  2334.   
  2335. #ifdef KPD_PMIC_RSTKEY_MAP  
  2336.     __set_bit(KPD_PMIC_RSTKEY_MAP, kpd_input_dev->keybit);  
  2337. #endif  
  2338.   
  2339.     kpd_input_dev->dev.parent = &pdev->dev;  
  2340.     r = input_register_device(kpd_input_dev);  
  2341.     if (r) {  
  2342.         printk(KPD_SAY "register input device failed (%d)\n", r);  
  2343.         input_free_device(kpd_input_dev);  
  2344.         return r;  
  2345.     }  
  2346.   
  2347.     /* register misc device (/dev/mtk-kpd) */  
  2348.     kpd_dev.parent = &pdev->dev;  
  2349.     r = misc_register(&kpd_dev);  
  2350.     if (r) {  
  2351.         printk(KPD_SAY "register device failed (%d)\n", r);  
  2352.         input_unregister_device(kpd_input_dev);  
  2353.         return r;  
  2354.     }  
  2355.   
  2356.     /* register IRQ and EINT */  
  2357.     kpd_set_debounce(KPD_KEY_DEBOUNCE);  
  2358.     r = request_irq(MT_KP_IRQ_ID, kpd_irq_handler, IRQF_TRIGGER_FALLING, KPD_NAME, NULL);  
  2359.     if (r) {  
  2360.         printk(KPD_SAY "register IRQ failed (%d)\n", r);  
  2361.         misc_deregister(&kpd_dev);  
  2362.         input_unregister_device(kpd_input_dev);  
  2363.         return r;  
  2364.     }  
  2365.   
  2366.   
  2367. #if 0   //KPD_PWRKEY_USE_EINT  
  2368.     mt65xx_eint_set_sens(KPD_PWRKEY_EINT, KPD_PWRKEY_SENSITIVE);  
  2369.     mt65xx_eint_set_hw_debounce(KPD_PWRKEY_EINT, KPD_PWRKEY_DEBOUNCE);  
  2370.     mt65xx_eint_registration(KPD_PWRKEY_EINT, true, KPD_PWRKEY_POLARITY,  
  2371.                              kpd_pwrkey_eint_handler, false);  
  2372. #endif  
  2373.   
  2374.   
  2375.   
  2376.   
  2377.   
  2378. #if 1  
  2379.     printk("===== AW9523 probe\n");  
  2380.   
  2381.     GPIO_ModeSetup(SCAN_GPIO, 0);  
  2382.     GPIO_InitIO(1, SCAN_GPIO);  
  2383.     GPIO_WriteIO(1, SCAN_GPIO);  
  2384.   
  2385.     mt_set_gpio_mode(AW9523_EINT_GPIO, GPIO_MODE_03);  
  2386.     mt_set_gpio_dir(AW9523_EINT_GPIO, GPIO_DIR_IN);  
  2387.     mt_set_gpio_pull_enable(AW9523_EINT_GPIO, GPIO_PULL_ENABLE); //To disable GPIO PULL.  
  2388.   
  2389.     Set_P0_X_AND_P1_Y();  
  2390.     aw9523_init();  
  2391.   
  2392.     mt_eint_set_sens(AW9523_EINT_NO, KPD_AW9523_SWITCH_SENSITIVE);  
  2393.     mt_eint_set_hw_debounce(AW9523_EINT_NO, KPD_AW9523_SWITCH_DEBOUNCE);  
  2394.     mt_eint_registration(AW9523_EINT_NO, EINTF_TRIGGER_FALLING, kpd_aw9523_eint_handler, false);  
  2395.     mt_eint_unmask(AW9523_EINT_NO);  
  2396. #endif  
  2397.   
  2398.   
  2399.   
  2400.   
  2401. #ifndef KPD_EARLY_PORTING /*add for avoid early porting build err the macro is defined in custom file*/  
  2402. /*long press reboot function realize*/  
  2403.     if(kpd_enable_lprst && get_boot_mode() == NORMAL_BOOT) {  
  2404.         kpd_print("Normal Boot long press reboot selection\n");  
  2405.         upmu_set_rg_pwrkey_rst_en(0x00);//pmic package function for long press reboot function setting  
  2406.         upmu_set_rg_homekey_rst_en(0x00);         
  2407.           
  2408.     #ifdef CONFIG_ONEKEY_REBOOT_NORMAL_MODE  
  2409.         kpd_print("Enable ONE KEY normal mode LPRST\n");  
  2410.         upmu_set_rg_pwrkey_rst_en(0x01);//pmic_config_interface(TOP_RST_MISC, 0x01, PMIC_RG_PWRKEY_RST_EN_MASK, PMIC_RG_PWRKEY_RST_EN_SHIFT);  
  2411.         upmu_set_rg_pwrkey_rst_td(CONFIG_KPD_PMIC_LPRST_TD);  
  2412.     #endif  
  2413.     #ifdef CONFIG_TWOKEY_REBOOT_NORMAL_MODE  
  2414.         kpd_print("Enable TWO KEY normal mode LPRST\n");  
  2415.         upmu_set_rg_pwrkey_rst_en(0x01);//pmic package function for long press reboot function setting//pmic_config_interface(TOP_RST_MISC, 0x01, PMIC_RG_PWRKEY_RST_EN_MASK, PMIC_RG_PWRKEY_RST_EN_SHIFT);  
  2416.         upmu_set_rg_homekey_rst_en(0x01);//pmic_config_interface(TOP_RST_MISC, 0x01, PMIC_RG_HOMEKEY_RST_EN_MASK, PMIC_RG_HOMEKEY_RST_EN_SHIFT);  
  2417.         //upmu_set_rg_homekey_puen(0x01);//pmic_config_interface(GPIO_SMT_CON3,0x01, PMIC_RG_HOMEKEY_PUEN_MASK, PMIC_RG_HOMEKEY_PUEN_SHIFT);//pull up homekey pin of PMIC for 89 project  
  2418.         upmu_set_rg_pwrkey_rst_td(CONFIG_KPD_PMIC_LPRST_TD);  
  2419.     #endif  
  2420.     }   
  2421.     else {  
  2422.         kpd_print("Other Boot Mode long press reboot selection\n");  
  2423.         upmu_set_rg_pwrkey_rst_en(0x00);//pmic package function for long press reboot function setting  
  2424.         upmu_set_rg_homekey_rst_en(0x00);         
  2425.       
  2426.     #ifdef CONFIG_ONEKEY_REBOOT_OTHER_MODE  
  2427.         kpd_print("Enable ONE KEY other mode LPRST\n");  
  2428.         upmu_set_rg_pwrkey_rst_en(0x01);//pmic_config_interface(TOP_RST_MISC, 0x01, PMIC_RG_PWRKEY_RST_EN_MASK, PMIC_RG_PWRKEY_RST_EN_SHIFT);  
  2429.         upmu_set_rg_pwrkey_rst_td(CONFIG_KPD_PMIC_LPRST_TD);  
  2430.     #endif    
  2431.     #ifdef CONFIG_TWOKEY_REBOOT_OTHER_MODE  
  2432.         kpd_print("Enable TWO KEY other mode LPRST\n");  
  2433.         upmu_set_rg_pwrkey_rst_en(0x01);//pmic package function for long press reboot function setting//pmic_config_interface(TOP_RST_MISC, 0x01, PMIC_RG_PWRKEY_RST_EN_MASK, PMIC_RG_PWRKEY_RST_EN_SHIFT);  
  2434.         upmu_set_rg_homekey_rst_en(0x01);//pmic_config_interface(TOP_RST_MISC, 0x01, PMIC_RG_HOMEKEY_RST_EN_MASK, PMIC_RG_HOMEKEY_RST_EN_SHIFT);  
  2435.         //upmu_set_rg_homekey_puen(0x01);//pmic_config_interface(GPIO_SMT_CON3,0x01, PMIC_RG_HOMEKEY_PUEN_MASK, PMIC_RG_HOMEKEY_PUEN_SHIFT);//pull up homekey pin of PMIC for 89 project  
  2436.         upmu_set_rg_pwrkey_rst_td(CONFIG_KPD_PMIC_LPRST_TD);  
  2437.     #endif  
  2438.     }  
  2439.     /* 
  2440.     int reg; 
  2441.     pmic_read_interface(TOP_RST_MISC, &reg, PMIC_RG_PWRKEY_RST_TD_MASK, PMIC_RG_PWRKEY_RST_TD_SHIFT); 
  2442.     kpd_print("long press reboot time value reg = %d\n", reg); 
  2443.     */  
  2444. #endif    
  2445.     hrtimer_init(&aee_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);  
  2446.     aee_timer.function = aee_timer_func;  
  2447.   
  2448. #if AEE_ENABLE_5_15  
  2449.     hrtimer_init(&aee_timer_5s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);  
  2450.     aee_timer_5s.function = aee_timer_5s_func;  
  2451.   
  2452.   
  2453. #endif  
  2454.   
  2455.     if((err = kpd_create_attr(&kpd_pdrv.driver)))  
  2456.     {  
  2457.         kpd_print("create attr file fail\n");  
  2458.         kpd_delete_attr(&kpd_pdrv.driver);  
  2459.         return err;  
  2460.     }  
  2461.   
  2462. /**********************disable kpd as wake up source operation********************************/  
  2463.     #ifndef EVB_PLATFORM  
  2464.     kpd_print("disable kpd as wake up source operation!\n");  
  2465.     upmu_set_rg_smps_autoff_dis(0x00);  
  2466.     #endif  
  2467. /****************************************************************************************/  
  2468.   
  2469.   
  2470. #if 0  
  2471.     /* KCOL0: GPIO103: KCOL1: GPIO108, KCOL2: GPIO105 input + pull enable + pull up */  
  2472.     mt_set_gpio_mode(103, 1);  
  2473.     mt_set_gpio_dir(103, 0);  
  2474.     mt_set_gpio_pull_enable(103, 1);  
  2475.     mt_set_gpio_pull_select(103, 1);  
  2476.       
  2477.       
  2478.     mt_set_gpio_mode(108, 1);  
  2479.     mt_set_gpio_dir(108, 0);  
  2480.     mt_set_gpio_pull_enable(108, 1);  
  2481.     mt_set_gpio_pull_select(108, 1);  
  2482.       
  2483.     mt_set_gpio_mode(105, 1);  
  2484.     mt_set_gpio_dir(105, 0);  
  2485.     mt_set_gpio_pull_enable(105, 1);  
  2486.     mt_set_gpio_pull_select(105, 1);  
  2487.     /* KROW0: GPIO98, KROW1: GPIO97: KROW2: GPIO95 output + pull disable + pull down */  
  2488.     mt_set_gpio_mode(98, 1);  
  2489.     mt_set_gpio_dir(98, 1);  
  2490.     mt_set_gpio_pull_enable(98, 0);   
  2491.     mt_set_gpio_pull_select(98, 0);  
  2492.       
  2493.     mt_set_gpio_mode(97, 1);  
  2494.     mt_set_gpio_dir(97, 1);  
  2495.     mt_set_gpio_pull_enable(97, 0);   
  2496.     mt_set_gpio_pull_select(97, 0);  
  2497.       
  2498.     mt_set_gpio_mode(95, 1);  
  2499.     mt_set_gpio_dir(95, 1);  
  2500.     mt_set_gpio_pull_enable(95, 0);       
  2501.     mt_set_gpio_pull_select(95, 0);  
  2502. #endif  
  2503.     return 0;  
  2504. }  
  2505.   
  2506. /* should never be called */  
  2507. static int kpd_pdrv_remove(struct platform_device *pdev)  
  2508. {  
  2509.     return 0;  
  2510. }  
  2511.   
  2512. #define MTK_KP_WAKESOURCE//this is for auto set wake up source  
  2513. static int incall = 0;//this is for whether phone in call state judgement when resume  
  2514.   
  2515. #ifndef CONFIG_HAS_EARLYSUSPEND  
  2516. static int kpd_pdrv_suspend(struct platform_device *pdev, pm_message_t state)  
  2517. {  
  2518.     kpd_suspend = true;  
  2519. #ifdef MTK_KP_WAKESOURCE  
  2520.     #if 0 // TODO: check whether need to enable in 6572  
  2521.     if(call_status == 2){  
  2522.         if(incall == 0){  
  2523.             kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);  
  2524.             upmu_set_rg_smps_autoff_dis(0x01);  
  2525.             incall = 1;  
  2526.             }  
  2527.         //if(incall == 1){}  
  2528.     }else{  
  2529.         //if(incall == 0){}  
  2530.         if(incall == 1){  
  2531.             kpd_print("kpd_early_resume wake up source disable!! (%d)\n", kpd_suspend);  
  2532.             upmu_set_rg_smps_autoff_dis(0x00);  
  2533.             incall = 0;  
  2534.             }  
  2535.     }  
  2536.     #endif  
  2537. #endif        
  2538.     kpd_disable_backlight();  
  2539.     kpd_print("suspend!! (%d)\n", kpd_suspend);  
  2540.     return 0;  
  2541. }  
  2542.   
  2543. static int kpd_pdrv_resume(struct platform_device *pdev)  
  2544. {  
  2545.     kpd_suspend = false;  
  2546.     //kpd_enable_backlight();  
  2547.     kpd_print("resume!! (%d)\n", kpd_suspend);  
  2548.     return 0;  
  2549. }  
  2550. #else  
  2551. #define kpd_pdrv_suspend    NULL  
  2552. #define kpd_pdrv_resume     NULL  
  2553. #endif  
  2554.   
  2555. #ifdef CONFIG_HAS_EARLYSUSPEND  
  2556. static void kpd_early_suspend(struct early_suspend *h)  
  2557. {  
  2558.     kpd_suspend = true;  
  2559. #ifdef MTK_KP_WAKESOURCE  
  2560.     #if 0 // FIXME: check whether need to enable in 6572  
  2561.     if(call_status == 2){  
  2562.         if(incall == 0){  
  2563.             kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);  
  2564.             upmu_set_rg_smps_autoff_dis(0x01);  
  2565.             incall = 1;  
  2566.             }  
  2567.         //if(incall == 1){}  
  2568.     }else{  
  2569.         //if(incall == 0){}  
  2570.         if(incall == 1){  
  2571.             kpd_print("kpd_early_resume wake up source disable!! (%d)\n", kpd_suspend);  
  2572.             upmu_set_rg_smps_autoff_dis(0x00);  
  2573.             incall = 0;  
  2574.             }  
  2575.     }  
  2576.     #endif  
  2577. #endif    
  2578.     kpd_disable_backlight();  
  2579.     kpd_print("early suspend!! (%d)\n", kpd_suspend);  
  2580. }  
  2581.   
  2582. static void kpd_early_resume(struct early_suspend *h)  
  2583. {  
  2584.     kpd_suspend = false;  
  2585.     //kpd_enable_backlight();  
  2586.     kpd_print("early resume!! (%d)\n", kpd_suspend);  
  2587. }  
  2588.   
  2589. static struct early_suspend kpd_early_suspend_desc = {  
  2590.     .level      = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1,  
  2591.     .suspend    = kpd_early_suspend,  
  2592.     .resume     = kpd_early_resume,  
  2593. };  
  2594. #endif  
  2595.   
  2596. static int __init kpd_mod_init(void)  
  2597. {  
  2598.     int r;  
  2599.   
  2600. #if KPD_DRV_CTRL_BACKLIGHT  
  2601.     for (r = 0; r < ARRAY_SIZE(kpd_wake_key); r++)  
  2602.         __set_bit(kpd_wake_key[r], kpd_wake_keybit);  
  2603. #endif  
  2604.   
  2605.     r = platform_driver_register(&kpd_pdrv);  
  2606.     if (r) {  
  2607.         printk(KPD_SAY "register driver failed (%d)\n", r);  
  2608.         return r;  
  2609.     }  
  2610.   
  2611. #ifdef CONFIG_HAS_EARLYSUSPEND  
  2612.     register_early_suspend(&kpd_early_suspend_desc);  
  2613. #endif  
  2614.     return 0;  
  2615. }  
  2616.   
  2617. /* should never be called */  
  2618. static void __exit kpd_mod_exit(void)  
  2619. {  
  2620. }  
  2621.   
  2622. module_init(kpd_mod_init);  
  2623. module_exit(kpd_mod_exit);  
  2624.   
  2625. module_param(kpd_show_hw_keycode, int, 0644);  
  2626. module_param(kpd_show_register, int, 0644);  
  2627. module_param(kpd_enable_lprst, int, 0644);  
  2628.   
  2629. MODULE_AUTHOR("Terry Chang <[email protected]>");  
  2630. MODULE_DESCRIPTION("MTK Keypad (KPD) Driver v0.3");  
  2631. MODULE_LICENSE("GPL");  

猜你喜欢

转载自blog.csdn.net/chenzhen1080/article/details/79145435
MTK
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022