drivers/misc/mediatek/keypad/kpd.c

   1 /*
   2  * Copyright (C) 2010 MediaTek, Inc.
   3  *
   4  * Author: Terry Chang <terry.chang@mediatek.com>
   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
  18 /*kpd.h file path: ALPS/mediatek/kernel/include/linux */
  19 #include <linux/kpd.h>
  20 #ifdef CONFIG_OF
  21 #include <linux/of.h>
  22 #include <linux/of_address.h>
  23 #include <linux/of_irq.h>
  24 #endif
  25
  26 #define KPD_NAME        "mtk-kpd"
  27 #define MTK_KP_WAKESOURCE       /* this is for auto set wake up source */
  28
  29 #ifdef CONFIG_OF
  30 void __iomem *kp_base;
  31 static unsigned int kp_irqnr;
  32 #endif
  33 struct input_dev *kpd_input_dev;
  34 static bool kpd_suspend = false;
  35 static int kpd_show_hw_keycode = 1;
  36 static int kpd_show_register = 1;
  37 static volatile int call_status = 0;
  38
  39 /*for kpd_memory_setting() function*/
  40 static u16 kpd_keymap[KPD_NUM_KEYS];
  41 static u16 kpd_keymap_state[KPD_NUM_MEMS];
  42 /***********************************/
  43
  44 /* for slide QWERTY */
  45 #if KPD_HAS_SLIDE_QWERTY
  46 static void kpd_slide_handler(unsigned long data);
  47 static DECLARE_TASKLET(kpd_slide_tasklet, kpd_slide_handler, 0);
  48 static u8 kpd_slide_state = !KPD_SLIDE_POLARITY;
  49 #endif
  50
  51 /* for Power key using EINT */
  52 #if KPD_PWRKEY_USE_EINT
  53 static void kpd_pwrkey_handler(unsigned long data);
  54 static DECLARE_TASKLET(kpd_pwrkey_tasklet, kpd_pwrkey_handler, 0);
  55 #endif
  56
  57 /* for keymap handling */
  58 static void kpd_keymap_handler(unsigned long data);
  59 static DECLARE_TASKLET(kpd_keymap_tasklet, kpd_keymap_handler, 0);
  60
  61 /*********************************************************************/
  62 static void kpd_memory_setting(void);
  63
  64 /*********************************************************************/
  65 static int kpd_pdrv_probe(struct platform_device *pdev);
  66 static int kpd_pdrv_remove(struct platform_device *pdev);
  67 #ifndef USE_EARLY_SUSPEND
  68 static int kpd_pdrv_suspend(struct platform_device *pdev, pm_message_t state);
  69 static int kpd_pdrv_resume(struct platform_device *pdev);
  70 #endif
  71
  72 #ifdef CONFIG_OF
  73 static const struct of_device_id kpd_of_match[] = {
  74         { .compatible = "mediatek,KP", },
  75         {},
  76 };
  77 #endif
  78
  79 static struct platform_driver kpd_pdrv = {
  80         .probe = kpd_pdrv_probe,
  81         .remove = kpd_pdrv_remove,
  82 #ifndef USE_EARLY_SUSPEND
  83         .suspend = kpd_pdrv_suspend,
  84         .resume = kpd_pdrv_resume,
  85 #endif
  86         .driver = {
  87                 .name = KPD_NAME,
  88                 .owner = THIS_MODULE,
  89 #ifdef CONFIG_OF
  90                 .of_match_table = kpd_of_match,
  91 #endif
  92         },
  93 };
  94
  95 /********************************************************************/
  96 static void kpd_memory_setting(void)
  97 {
  98         kpd_init_keymap(kpd_keymap);
  99         kpd_init_keymap_state(kpd_keymap_state);
 100         return;
 101 }
 102
 103
 104 /*****************for kpd auto set wake up source*************************/
 105
 106 static ssize_t kpd_store_call_state(struct device_driver *ddri, const char *buf, size_t count)
 107 {
 108         if (sscanf(buf, "%u", &call_status) != 1) {
 109                 kpd_print("kpd call state: Invalid values\n");
 110                 return -EINVAL;
 111         }
 112
 113         switch (call_status) {
 114         case 1:
 115                 kpd_print("kpd call state: Idle state!\n");
 116                 break;
 117         case 2:
 118                 kpd_print("kpd call state: ringing state!\n");
 119                 break;
 120         case 3:
 121                 kpd_print("kpd call state: active or hold state!\n");
 122                 break;
 123
 124         default:
 125                 kpd_print("kpd call state: Invalid values\n");
 126                 break;
 127         }
 128         return count;
 129 }
 130
 131 static ssize_t kpd_show_call_state(struct device_driver *ddri, char *buf)
 132 {
 133         ssize_t res;
 134         res = snprintf(buf, PAGE_SIZE, "%d\n", call_status);
 135         return res;
 136 }
 137
 138 static DRIVER_ATTR(kpd_call_state, S_IWUSR | S_IRUGO, kpd_show_call_state, kpd_store_call_state);
 139
 140 static struct driver_attribute *kpd_attr_list[] = {
 141         &driver_attr_kpd_call_state,
 142 };
 143
 144 /*----------------------------------------------------------------------------*/
 145 static int kpd_create_attr(struct device_driver *driver)
 146 {
 147         int idx, err = 0;
 148         int num = (int)(sizeof(kpd_attr_list) / sizeof(kpd_attr_list[0]));
 149         if (driver == NULL) {
 150                 return -EINVAL;
 151         }
 152
 153         for (idx = 0; idx < num; idx++) {
 154                 if ((err = driver_create_file(driver, kpd_attr_list[idx]))) {
 155                         kpd_print("driver_create_file (%s) = %d\n", kpd_attr_list[idx]->attr.name,
 156                                   err);
 157                         break;
 158                 }
 159         }
 160         return err;
 161 }
 162
 163 /*----------------------------------------------------------------------------*/
 164 static int kpd_delete_attr(struct device_driver *driver)
 165 {
 166         int idx, err = 0;
 167         int num = (int)(sizeof(kpd_attr_list) / sizeof(kpd_attr_list[0]));
 168
 169         if (!driver)
 170                 return -EINVAL;
 171
 172         for (idx = 0; idx < num; idx++) {
 173                 driver_remove_file(driver, kpd_attr_list[idx]);
 174         }
 175
 176         return err;
 177 }
 178
 179 /*----------------------------------------------------------------------------*/
 180 /********************************************************************************************/
 181 /************************************************************************************************************************************************/
 182 /* for autotest */
 183 #if KPD_AUTOTEST
 184 static const u16 kpd_auto_keymap[] = {
 185         KEY_MENU,
 186         KEY_HOME, KEY_BACK,
 187         KEY_CALL, KEY_ENDCALL,
 188         KEY_VOLUMEUP, KEY_VOLUMEDOWN,
 189         KEY_FOCUS, KEY_CAMERA,
 190 };
 191 #endif
 192 /* for AEE manual dump */
 193 #define AEE_VOLUMEUP_BIT        0
 194 #define AEE_VOLUMEDOWN_BIT      1
 195 #define AEE_DELAY_TIME          15
 196 /* enable volup + voldown was pressed 5~15 s Trigger aee manual dump */
 197 #define AEE_ENABLE_5_15         1
 198 static struct hrtimer aee_timer;
 199 static unsigned long aee_pressed_keys;
 200 static bool aee_timer_started;
 201
 202 #if AEE_ENABLE_5_15
 203 #define AEE_DELAY_TIME_5S       5
 204 static struct hrtimer aee_timer_5s;
 205 static bool aee_timer_5s_started;
 206 static bool flags_5s;
 207 #endif
 208
 209 static inline void kpd_update_aee_state(void)
 210 {
 211         if (aee_pressed_keys == ((1 << AEE_VOLUMEUP_BIT) | (1 << AEE_VOLUMEDOWN_BIT))) {
 212                 /* if volumeup and volumedown was pressed the same time then start the time of ten seconds */
 213                 aee_timer_started = true;
 214
 215 #if AEE_ENABLE_5_15
 216                 aee_timer_5s_started = true;
 217                 hrtimer_start(&aee_timer_5s, ktime_set(AEE_DELAY_TIME_5S, 0), HRTIMER_MODE_REL);
 218 #endif
 219                 hrtimer_start(&aee_timer, ktime_set(AEE_DELAY_TIME, 0), HRTIMER_MODE_REL);
 220                 kpd_print("aee_timer started\n");
 221         } else {
 222                 if (aee_timer_started) {
 223 /*
 224   * hrtimer_cancel - cancel a timer and wait for the handler to finish.
 225   * Returns:
 226   *     0 when the timer was not active.
 227   *     1 when the timer was active.
 228  */
 229                         if (hrtimer_cancel(&aee_timer)) {
 230                                 kpd_print("try to cancel hrtimer\n");
 231 #if AEE_ENABLE_5_15
 232                                 if (flags_5s) {
 233                                         printk
 234                                             ("Pressed Volup + Voldown5s~15s then trigger aee manual dump.\n");
 235                                         aee_kernel_reminding("manual dump",
 236                                                              "Trigger Vol Up +Vol Down 5s");
 237                                 }
 238 #endif
 239
 240                         }
 241 #if AEE_ENABLE_5_15
 242                         flags_5s = false;
 243 #endif
 244                         aee_timer_started = false;
 245                         kpd_print("aee_timer canceled\n");
 246                 }
 247 #if AEE_ENABLE_5_15
 248                 if (aee_timer_5s_started) {
 249 /*
 250   * hrtimer_cancel - cancel a timer and wait for the handler to finish.
 251   * Returns:
 252   *     0 when the timer was not active.
 253   *     1 when the timer was active.
 254  */
 255                         if (hrtimer_cancel(&aee_timer_5s)) {
 256                                 kpd_print("try to cancel hrtimer (5s)\n");
 257                         }
 258                         aee_timer_5s_started = false;
 259                         kpd_print("aee_timer canceled (5s)\n");
 260                 }
 261 #endif
 262         }
 263 }
 264
 265 static void kpd_aee_handler(u32 keycode, u16 pressed)
 266 {
 267         if (pressed) {
 268                 if (keycode == KEY_VOLUMEUP) {
 269                         __set_bit(AEE_VOLUMEUP_BIT, &aee_pressed_keys);
 270                 } else if (keycode == KEY_VOLUMEDOWN) {
 271                         __set_bit(AEE_VOLUMEDOWN_BIT, &aee_pressed_keys);
 272                 } else {
 273                         return;
 274                 }
 275                 kpd_update_aee_state();
 276         } else {
 277                 if (keycode == KEY_VOLUMEUP) {
 278                         __clear_bit(AEE_VOLUMEUP_BIT, &aee_pressed_keys);
 279                 } else if (keycode == KEY_VOLUMEDOWN) {
 280                         __clear_bit(AEE_VOLUMEDOWN_BIT, &aee_pressed_keys);
 281                 } else {
 282                         return;
 283                 }
 284                 kpd_update_aee_state();
 285         }
 286 }
 287
 288 static enum hrtimer_restart aee_timer_func(struct hrtimer *timer)
 289 {
 290         /* printk("kpd: vol up+vol down AEE manual dump!\n"); */
 291         /* aee_kernel_reminding("manual dump ", "Triggered by press KEY_VOLUMEUP+KEY_VOLUMEDOWN"); */
 292         aee_trigger_kdb();
 293         return HRTIMER_NORESTART;
 294 }
 295
 296 #if AEE_ENABLE_5_15
 297 static enum hrtimer_restart aee_timer_5s_func(struct hrtimer *timer)
 298 {
 299
 300         /* printk("kpd: vol up+vol down AEE manual dump timer 5s !\n"); */
 301         flags_5s = true;
 302         return HRTIMER_NORESTART;
 303 }
 304 #endif
 305
 306 /************************************************************************************************************************************************/
 307
 308 #if KPD_HAS_SLIDE_QWERTY
 309 static void kpd_slide_handler(unsigned long data)
 310 {
 311         bool slid;
 312         u8 old_state = kpd_slide_state;
 313
 314         kpd_slide_state = !kpd_slide_state;
 315         slid = (kpd_slide_state == !!KPD_SLIDE_POLARITY);
 316         /* for SW_LID, 1: lid open => slid, 0: lid shut => closed */
 317         input_report_switch(kpd_input_dev, SW_LID, slid);
 318         input_sync(kpd_input_dev);
 319         kpd_print("report QWERTY = %s\n", slid ? "slid" : "closed");
 320
 321         if (old_state) {
 322                 mt_set_gpio_pull_select(GPIO_QWERTYSLIDE_EINT_PIN, 0);
 323         } else {
 324                 mt_set_gpio_pull_select(GPIO_QWERTYSLIDE_EINT_PIN, 1);
 325         }
 326         /* for detecting the return to old_state */
 327         mt65xx_eint_set_polarity(KPD_SLIDE_EINT, old_state);
 328         mt65xx_eint_unmask(KPD_SLIDE_EINT);
 329 }
 330
 331 static void kpd_slide_eint_handler(void)
 332 {
 333         tasklet_schedule(&kpd_slide_tasklet);
 334 }
 335 #endif
 336
 337 #if KPD_PWRKEY_USE_EINT
 338 static void kpd_pwrkey_handler(unsigned long data)
 339 {
 340         kpd_pwrkey_handler_hal(data);
 341 }
 342
 343 static void kpd_pwrkey_eint_handler(void)
 344 {
 345         tasklet_schedule(&kpd_pwrkey_tasklet);
 346 }
 347 #endif
 348 /*********************************************************************/
 349
 350 /*********************************************************************/
 351 #if KPD_PWRKEY_USE_PMIC
 352 void kpd_pwrkey_pmic_handler(unsigned long pressed)
 353 {
 354         printk(KPD_SAY "Power Key generate, pressed=%ld\n", pressed);
 355         if (!kpd_input_dev) {
 356                 printk("KPD input device not ready\n");
 357                 return;
 358         }
 359         kpd_pmic_pwrkey_hal(pressed);
 360 }
 361 #endif
 362
 363
 364 void kpd_pmic_rstkey_handler(unsigned long pressed)
 365 {
 366         printk(KPD_SAY "PMIC reset Key generate, pressed=%ld\n", pressed);
 367         if (!kpd_input_dev) {
 368                 printk("KPD input device not ready\n");
 369                 return;
 370         }
 371         kpd_pmic_rstkey_hal(pressed);
 372 #ifdef KPD_PMIC_RSTKEY_MAP
 373         kpd_aee_handler(KPD_PMIC_RSTKEY_MAP, pressed);
 374 #endif
 375 }
 376
 377 /*********************************************************************/
 378
 379 /*********************************************************************/
 380 static void kpd_keymap_handler(unsigned long data)
 381 {
 382         int i, j;
 383         bool pressed;
 384         u16 new_state[KPD_NUM_MEMS], change, mask;
 385         u16 hw_keycode, linux_keycode;
 386         kpd_get_keymap_state(new_state);
 387
 388         for (i = 0; i < KPD_NUM_MEMS; i++) {
 389                 change = new_state[i] ^ kpd_keymap_state[i];
 390                 if (!change)
 391                         continue;
 392
 393                 for (j = 0; j < 16; j++) {
 394                         mask = 1U << j;
 395                         if (!(change & mask))
 396                                 continue;
 397
 398                         hw_keycode = (i << 4) + j;
 399                         /* bit is 1: not pressed, 0: pressed */
 400                         pressed = !(new_state[i] & mask);
 401                         if (kpd_show_hw_keycode) {
 402                                 printk(KPD_SAY "(%s) HW keycode = %u\n",
 403                                        pressed ? "pressed" : "released", hw_keycode);
 404                         }
 405                         BUG_ON(hw_keycode >= KPD_NUM_KEYS);
 406                         linux_keycode = kpd_keymap[hw_keycode];
 407                         if (unlikely(linux_keycode == 0)) {
 408                                 kpd_print("Linux keycode = 0\n");
 409                                 continue;
 410                         }
 411                         kpd_aee_handler(linux_keycode, pressed);
 412
 413                         kpd_backlight_handler(pressed, linux_keycode);
 414                         input_report_key(kpd_input_dev, linux_keycode, pressed);
 415                         input_sync(kpd_input_dev);
 416                         kpd_print("report Linux keycode = %u\n", linux_keycode);
 417                 }
 418         }
 419
 420         memcpy(kpd_keymap_state, new_state, sizeof(new_state));
 421         kpd_print("save new keymap state\n");
 422 #ifdef CONFIG_OF
 423         enable_irq(kp_irqnr);
 424 #else
 425         enable_irq(MT_KP_IRQ_ID);
 426 #endif
 427 }
 428
 429 static irqreturn_t kpd_irq_handler(int irq, void *dev_id)
 430 {
 431         /* use _nosync to avoid deadlock */
 432 #ifdef CONFIG_OF
 433         disable_irq_nosync(kp_irqnr);
 434 #else
 435         disable_irq_nosync(MT_KP_IRQ_ID);
 436 #endif
 437         tasklet_schedule(&kpd_keymap_tasklet);
 438         return IRQ_HANDLED;
 439 }
 440
 441 /*********************************************************************/
 442
 443 /*****************************************************************************************/
 444 long kpd_dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 445 {
 446         /* void __user *uarg = (void __user *)arg; */
 447
 448         switch (cmd) {
 449 #if KPD_AUTOTEST
 450         case PRESS_OK_KEY:      /* KPD_AUTOTEST disable auto test setting to resolve CR ALPS00464496 */
 451                 if (test_bit(KEY_OK, kpd_input_dev->keybit)) {
 452                         printk("[AUTOTEST] PRESS OK KEY!!\n");
 453                         input_report_key(kpd_input_dev, KEY_OK, 1);
 454                         input_sync(kpd_input_dev);
 455                 } else {
 456                         printk("[AUTOTEST] Not Support OK KEY!!\n");
 457                 }
 458                 break;
 459         case RELEASE_OK_KEY:
 460                 if (test_bit(KEY_OK, kpd_input_dev->keybit)) {
 461                         printk("[AUTOTEST] RELEASE OK KEY!!\n");
 462                         input_report_key(kpd_input_dev, KEY_OK, 0);
 463                         input_sync(kpd_input_dev);
 464                 } else {
 465                         printk("[AUTOTEST] Not Support OK KEY!!\n");
 466                 }
 467                 break;
 468         case PRESS_MENU_KEY:
 469                 if (test_bit(KEY_MENU, kpd_input_dev->keybit)) {
 470                         printk("[AUTOTEST] PRESS MENU KEY!!\n");
 471                         input_report_key(kpd_input_dev, KEY_MENU, 1);
 472                         input_sync(kpd_input_dev);
 473                 } else {
 474                         printk("[AUTOTEST] Not Support MENU KEY!!\n");
 475                 }
 476                 break;
 477         case RELEASE_MENU_KEY:
 478                 if (test_bit(KEY_MENU, kpd_input_dev->keybit)) {
 479                         printk("[AUTOTEST] RELEASE MENU KEY!!\n");
 480                         input_report_key(kpd_input_dev, KEY_MENU, 0);
 481                         input_sync(kpd_input_dev);
 482                 } else {
 483                         printk("[AUTOTEST] Not Support MENU KEY!!\n");
 484                 }
 485
 486                 break;
 487         case PRESS_UP_KEY:
 488                 if (test_bit(KEY_UP, kpd_input_dev->keybit)) {
 489                         printk("[AUTOTEST] PRESS UP KEY!!\n");
 490                         input_report_key(kpd_input_dev, KEY_UP, 1);
 491                         input_sync(kpd_input_dev);
 492                 } else {
 493                         printk("[AUTOTEST] Not Support UP KEY!!\n");
 494                 }
 495                 break;
 496         case RELEASE_UP_KEY:
 497                 if (test_bit(KEY_UP, kpd_input_dev->keybit)) {
 498                         printk("[AUTOTEST] RELEASE UP KEY!!\n");
 499                         input_report_key(kpd_input_dev, KEY_UP, 0);
 500                         input_sync(kpd_input_dev);
 501                 } else {
 502                         printk("[AUTOTEST] Not Support UP KEY!!\n");
 503                 }
 504                 break;
 505         case PRESS_DOWN_KEY:
 506                 if (test_bit(KEY_DOWN, kpd_input_dev->keybit)) {
 507                         printk("[AUTOTEST] PRESS DOWN KEY!!\n");
 508                         input_report_key(kpd_input_dev, KEY_DOWN, 1);
 509                         input_sync(kpd_input_dev);
 510                 } else {
 511                         printk("[AUTOTEST] Not Support DOWN KEY!!\n");
 512                 }
 513                 break;
 514         case RELEASE_DOWN_KEY:
 515                 if (test_bit(KEY_DOWN, kpd_input_dev->keybit)) {
 516                         printk("[AUTOTEST] RELEASE DOWN KEY!!\n");
 517                         input_report_key(kpd_input_dev, KEY_DOWN, 0);
 518                         input_sync(kpd_input_dev);
 519                 } else {
 520                         printk("[AUTOTEST] Not Support DOWN KEY!!\n");
 521                 }
 522                 break;
 523         case PRESS_LEFT_KEY:
 524                 if (test_bit(KEY_LEFT, kpd_input_dev->keybit)) {
 525                         printk("[AUTOTEST] PRESS LEFT KEY!!\n");
 526                         input_report_key(kpd_input_dev, KEY_LEFT, 1);
 527                         input_sync(kpd_input_dev);
 528                 } else {
 529                         printk("[AUTOTEST] Not Support LEFT KEY!!\n");
 530                 }
 531                 break;
 532         case RELEASE_LEFT_KEY:
 533                 if (test_bit(KEY_LEFT, kpd_input_dev->keybit)) {
 534                         printk("[AUTOTEST] RELEASE LEFT KEY!!\n");
 535                         input_report_key(kpd_input_dev, KEY_LEFT, 0);
 536                         input_sync(kpd_input_dev);
 537                 } else {
 538                         printk("[AUTOTEST] Not Support LEFT KEY!!\n");
 539                 }
 540                 break;
 541
 542         case PRESS_RIGHT_KEY:
 543                 if (test_bit(KEY_RIGHT, kpd_input_dev->keybit)) {
 544                         printk("[AUTOTEST] PRESS RIGHT KEY!!\n");
 545                         input_report_key(kpd_input_dev, KEY_RIGHT, 1);
 546                         input_sync(kpd_input_dev);
 547                 } else {
 548                         printk("[AUTOTEST] Not Support RIGHT KEY!!\n");
 549                 }
 550                 break;
 551         case RELEASE_RIGHT_KEY:
 552                 if (test_bit(KEY_RIGHT, kpd_input_dev->keybit)) {
 553                         printk("[AUTOTEST] RELEASE RIGHT KEY!!\n");
 554                         input_report_key(kpd_input_dev, KEY_RIGHT, 0);
 555                         input_sync(kpd_input_dev);
 556                 } else {
 557                         printk("[AUTOTEST] Not Support RIGHT KEY!!\n");
 558                 }
 559                 break;
 560         case PRESS_HOME_KEY:
 561                 if (test_bit(KEY_HOME, kpd_input_dev->keybit)) {
 562                         printk("[AUTOTEST] PRESS HOME KEY!!\n");
 563                         input_report_key(kpd_input_dev, KEY_HOME, 1);
 564                         input_sync(kpd_input_dev);
 565                 } else {
 566                         printk("[AUTOTEST] Not Support HOME KEY!!\n");
 567                 }
 568                 break;
 569         case RELEASE_HOME_KEY:
 570                 if (test_bit(KEY_HOME, kpd_input_dev->keybit)) {
 571                         printk("[AUTOTEST] RELEASE HOME KEY!!\n");
 572                         input_report_key(kpd_input_dev, KEY_HOME, 0);
 573                         input_sync(kpd_input_dev);
 574                 } else {
 575                         printk("[AUTOTEST] Not Support HOME KEY!!\n");
 576                 }
 577                 break;
 578         case PRESS_BACK_KEY:
 579                 if (test_bit(KEY_BACK, kpd_input_dev->keybit)) {
 580                         printk("[AUTOTEST] PRESS BACK KEY!!\n");
 581                         input_report_key(kpd_input_dev, KEY_BACK, 1);
 582                         input_sync(kpd_input_dev);
 583                 } else {
 584                         printk("[AUTOTEST] Not Support BACK KEY!!\n");
 585                 }
 586                 break;
 587         case RELEASE_BACK_KEY:
 588                 if (test_bit(KEY_BACK, kpd_input_dev->keybit)) {
 589                         printk("[AUTOTEST] RELEASE BACK KEY!!\n");
 590                         input_report_key(kpd_input_dev, KEY_BACK, 0);
 591                         input_sync(kpd_input_dev);
 592                 } else {
 593                         printk("[AUTOTEST] Not Support BACK KEY!!\n");
 594                 }
 595                 break;
 596         case PRESS_CALL_KEY:
 597                 if (test_bit(KEY_CALL, kpd_input_dev->keybit)) {
 598                         printk("[AUTOTEST] PRESS CALL KEY!!\n");
 599                         input_report_key(kpd_input_dev, KEY_CALL, 1);
 600                         input_sync(kpd_input_dev);
 601                 } else {
 602                         printk("[AUTOTEST] Not Support CALL KEY!!\n");
 603                 }
 604                 break;
 605         case RELEASE_CALL_KEY:
 606                 if (test_bit(KEY_CALL, kpd_input_dev->keybit)) {
 607                         printk("[AUTOTEST] RELEASE CALL KEY!!\n");
 608                         input_report_key(kpd_input_dev, KEY_CALL, 0);
 609                         input_sync(kpd_input_dev);
 610                 } else {
 611                         printk("[AUTOTEST] Not Support CALL KEY!!\n");
 612                 }
 613                 break;
 614
 615         case PRESS_ENDCALL_KEY:
 616                 if (test_bit(KEY_ENDCALL, kpd_input_dev->keybit)) {
 617                         printk("[AUTOTEST] PRESS ENDCALL KEY!!\n");
 618                         input_report_key(kpd_input_dev, KEY_ENDCALL, 1);
 619                         input_sync(kpd_input_dev);
 620                 } else {
 621                         printk("[AUTOTEST] Not Support ENDCALL KEY!!\n");
 622                 }
 623                 break;
 624         case RELEASE_ENDCALL_KEY:
 625                 if (test_bit(KEY_ENDCALL, kpd_input_dev->keybit)) {
 626                         printk("[AUTOTEST] RELEASE ENDCALL KEY!!\n");
 627                         input_report_key(kpd_input_dev, KEY_ENDCALL, 0);
 628                         input_sync(kpd_input_dev);
 629                 } else {
 630                         printk("[AUTOTEST] Not Support ENDCALL KEY!!\n");
 631                 }
 632                 break;
 633         case PRESS_VLUP_KEY:
 634                 if (test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)) {
 635                         printk("[AUTOTEST] PRESS VOLUMEUP KEY!!\n");
 636                         input_report_key(kpd_input_dev, KEY_VOLUMEUP, 1);
 637                         input_sync(kpd_input_dev);
 638                 } else {
 639                         printk("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");
 640                 }
 641                 break;
 642         case RELEASE_VLUP_KEY:
 643                 if (test_bit(KEY_VOLUMEUP, kpd_input_dev->keybit)) {
 644                         printk("[AUTOTEST] RELEASE VOLUMEUP KEY!!\n");
 645                         input_report_key(kpd_input_dev, KEY_VOLUMEUP, 0);
 646                         input_sync(kpd_input_dev);
 647                 } else {
 648                         printk("[AUTOTEST] Not Support VOLUMEUP KEY!!\n");
 649                 }
 650                 break;
 651         case PRESS_VLDOWN_KEY:
 652                 if (test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)) {
 653                         printk("[AUTOTEST] PRESS VOLUMEDOWN KEY!!\n");
 654                         input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 1);
 655                         input_sync(kpd_input_dev);
 656                 } else {
 657                         printk("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");
 658                 }
 659                 break;
 660         case RELEASE_VLDOWN_KEY:
 661                 if (test_bit(KEY_VOLUMEDOWN, kpd_input_dev->keybit)) {
 662                         printk("[AUTOTEST] RELEASE VOLUMEDOWN KEY!!\n");
 663                         input_report_key(kpd_input_dev, KEY_VOLUMEDOWN, 0);
 664                         input_sync(kpd_input_dev);
 665                 } else {
 666                         printk("[AUTOTEST] Not Support VOLUMEDOWN KEY!!\n");
 667                 }
 668                 break;
 669         case PRESS_FOCUS_KEY:
 670                 if (test_bit(KEY_FOCUS, kpd_input_dev->keybit)) {
 671                         printk("[AUTOTEST] PRESS FOCUS KEY!!\n");
 672                         input_report_key(kpd_input_dev, KEY_FOCUS, 1);
 673                         input_sync(kpd_input_dev);
 674                 } else {
 675                         printk("[AUTOTEST] Not Support FOCUS KEY!!\n");
 676                 }
 677                 break;
 678         case RELEASE_FOCUS_KEY:
 679                 if (test_bit(KEY_FOCUS, kpd_input_dev->keybit)) {
 680                         printk("[AUTOTEST] RELEASE FOCUS KEY!!\n");
 681                         input_report_key(kpd_input_dev, KEY_FOCUS, 0);
 682                         input_sync(kpd_input_dev);
 683                 } else {
 684                         printk("[AUTOTEST] Not Support RELEASE KEY!!\n");
 685                 }
 686                 break;
 687         case PRESS_CAMERA_KEY:
 688                 if (test_bit(KEY_CAMERA, kpd_input_dev->keybit)) {
 689                         printk("[AUTOTEST] PRESS CAMERA KEY!!\n");
 690                         input_report_key(kpd_input_dev, KEY_CAMERA, 1);
 691                         input_sync(kpd_input_dev);
 692                 } else {
 693                         printk("[AUTOTEST] Not Support CAMERA KEY!!\n");
 694                 }
 695                 break;
 696         case RELEASE_CAMERA_KEY:
 697                 if (test_bit(KEY_CAMERA, kpd_input_dev->keybit)) {
 698                         printk("[AUTOTEST] RELEASE CAMERA KEY!!\n");
 699                         input_report_key(kpd_input_dev, KEY_CAMERA, 0);
 700                         input_sync(kpd_input_dev);
 701                 } else {
 702                         printk("[AUTOTEST] Not Support CAMERA KEY!!\n");
 703                 }
 704                 break;
 705         case PRESS_POWER_KEY:
 706                 if (test_bit(KEY_POWER, kpd_input_dev->keybit)) {
 707                         printk("[AUTOTEST] PRESS POWER KEY!!\n");
 708                         input_report_key(kpd_input_dev, KEY_POWER, 1);
 709                         input_sync(kpd_input_dev);
 710                 } else {
 711                         printk("[AUTOTEST] Not Support POWER KEY!!\n");
 712                 }
 713                 break;
 714         case RELEASE_POWER_KEY:
 715                 if (test_bit(KEY_POWER, kpd_input_dev->keybit)) {
 716                         printk("[AUTOTEST] RELEASE POWER KEY!!\n");
 717                         input_report_key(kpd_input_dev, KEY_POWER, 0);
 718                         input_sync(kpd_input_dev);
 719                 } else {
 720                         printk("[AUTOTEST] Not Support POWER KEY!!\n");
 721                 }
 722                 break;
 723 #endif
 724
 725         case SET_KPD_KCOL:
 726                 kpd_auto_test_for_factorymode();        /* API 3 for kpd factory mode auto-test */
 727                 printk("[kpd_auto_test_for_factorymode] test performed!!\n");
 728                 break;
 729         default:
 730                 return -EINVAL;
 731         }
 732
 733         return 0;
 734 }
 735
 736
 737 int kpd_dev_open(struct inode *inode, struct file *file)
 738 {
 739         return 0;
 740 }
 741
 742 static struct file_operations kpd_dev_fops = {
 743         .owner = THIS_MODULE,
 744         .unlocked_ioctl = kpd_dev_ioctl,
 745         .open = kpd_dev_open,
 746 };
 747
 748 /*********************************************************************/
 749 static struct miscdevice kpd_dev = {
 750         .minor = MISC_DYNAMIC_MINOR,
 751         .name = KPD_NAME,
 752         .fops = &kpd_dev_fops,
 753 };
 754
 755 static int kpd_open(struct input_dev *dev)
 756 {
 757         kpd_slide_qwerty_init();        /* API 1 for kpd slide qwerty init settings */
 758         return 0;
 759 }
 760
 761
 762 static int kpd_pdrv_probe(struct platform_device *pdev)
 763 {
 764
 765         int i, r;
 766         int err = 0;
 767
 768 #ifdef CONFIG_OF
 769         kp_base = of_iomap(pdev->dev.of_node, 0);
 770         if (!kp_base) {
 771                 pr_warn(KPD_SAY "KP iomap failed\n");
 772                 return -ENODEV;
 773         };
 774
 775         kp_irqnr = irq_of_parse_and_map(pdev->dev.of_node, 0);
 776         if (!kp_irqnr) {
 777                 pr_warn(KPD_SAY "KP get irqnr failed\n");
 778                 return -ENODEV;
 779         }
 780         pr_warn(KPD_SAY "kp base: 0x%p, addr:0x%p,  kp irq: %d\n", kp_base,&kp_base, kp_irqnr);
 781 #endif
 782
 783         kpd_ldvt_test_init();   /* API 2 for kpd LFVT test enviroment settings */
 784
 785         /* initialize and register input device (/dev/input/eventX) */
 786         kpd_input_dev = input_allocate_device();
 787         if (!kpd_input_dev)
 788                 return -ENOMEM;
 789
 790         kpd_input_dev->name = KPD_NAME;
 791         kpd_input_dev->id.bustype = BUS_HOST;
 792         kpd_input_dev->id.vendor = 0x2454;
 793         kpd_input_dev->id.product = 0x6500;
 794         kpd_input_dev->id.version = 0x0010;
 795         kpd_input_dev->open = kpd_open;
 796
 797         /* fulfill custom settings */
 798         kpd_memory_setting();
 799
 800         __set_bit(EV_KEY, kpd_input_dev->evbit);
 801
 802 #if (KPD_PWRKEY_USE_EINT || KPD_PWRKEY_USE_PMIC)
 803         __set_bit(KPD_PWRKEY_MAP, kpd_input_dev->keybit);
 804         kpd_keymap[8] = 0;
 805 #endif
 806
 807 #if !KPD_USE_EXTEND_TYPE
 808         for (i = 17; i < KPD_NUM_KEYS; i += 9)  /* only [8] works for Power key */
 809                 kpd_keymap[i] = 0;
 810 #endif
 811
 812         for (i = 0; i < KPD_NUM_KEYS; i++) {
 813                 if (kpd_keymap[i] != 0)
 814                         __set_bit(kpd_keymap[i], kpd_input_dev->keybit);
 815         }
 816
 817 #if KPD_AUTOTEST
 818         for (i = 0; i < ARRAY_SIZE(kpd_auto_keymap); i++)
 819                 __set_bit(kpd_auto_keymap[i], kpd_input_dev->keybit);
 820 #endif
 821
 822 #if KPD_HAS_SLIDE_QWERTY
 823         __set_bit(EV_SW, kpd_input_dev->evbit);
 824         __set_bit(SW_LID, kpd_input_dev->swbit);
 825 #endif
 826
 827 #ifdef KPD_PMIC_RSTKEY_MAP
 828         __set_bit(KPD_PMIC_RSTKEY_MAP, kpd_input_dev->keybit);
 829 #endif
 830
 831 #ifdef KPD_KEY_MAP
 832                 __set_bit(KPD_KEY_MAP, kpd_input_dev->keybit);
 833 #endif
 834
 835         kpd_input_dev->dev.parent = &pdev->dev;
 836         r = input_register_device(kpd_input_dev);
 837         if (r) {
 838                 printk(KPD_SAY "register input device failed (%d)\n", r);
 839                 input_free_device(kpd_input_dev);
 840                 return r;
 841         }
 842
 843         /* register device (/dev/mt6575-kpd) */
 844         kpd_dev.parent = &pdev->dev;
 845         r = misc_register(&kpd_dev);
 846         if (r) {
 847                 printk(KPD_SAY "register device failed (%d)\n", r);
 848                 input_unregister_device(kpd_input_dev);
 849                 return r;
 850         }
 851
 852         /* register IRQ and EINT */
 853         kpd_set_debounce(KPD_KEY_DEBOUNCE);
 854 #ifdef CONFIG_OF
 855         r = request_irq(kp_irqnr, kpd_irq_handler, IRQF_TRIGGER_NONE, KPD_NAME, NULL);
 856 #else
 857         r = request_irq(MT_KP_IRQ_ID, kpd_irq_handler, IRQF_TRIGGER_FALLING, KPD_NAME, NULL);
 858 #endif
 859         if (r) {
 860                 printk(KPD_SAY "register IRQ failed (%d)\n", r);
 861                 misc_deregister(&kpd_dev);
 862                 input_unregister_device(kpd_input_dev);
 863                 return r;
 864         }
 865         mt_eint_register();
 866
 867 #ifndef KPD_EARLY_PORTING       /*add for avoid early porting build err the macro is defined in custom file */
 868         long_press_reboot_function_setting();   /* /API 4 for kpd long press reboot function setting */
 869 #endif
 870         hrtimer_init(&aee_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 871         aee_timer.function = aee_timer_func;
 872
 873 #if AEE_ENABLE_5_15
 874         hrtimer_init(&aee_timer_5s, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 875         aee_timer_5s.function = aee_timer_5s_func;
 876 #endif
 877
 878         if ((err = kpd_create_attr(&kpd_pdrv.driver))) {
 879                 kpd_print("create attr file fail\n");
 880                 kpd_delete_attr(&kpd_pdrv.driver);
 881                 return err;
 882         }
 883     pr_warn(KPD_SAY "%s Done\n", __FUNCTION__);
 884         return 0;
 885 }
 886
 887 /* should never be called */
 888 static int kpd_pdrv_remove(struct platform_device *pdev)
 889 {
 890         return 0;
 891 }
 892
 893 #ifndef USE_EARLY_SUSPEND
 894 static int kpd_pdrv_suspend(struct platform_device *pdev, pm_message_t state)
 895 {
 896         kpd_suspend = true;
 897 #ifdef MTK_KP_WAKESOURCE
 898         if (call_status == 2) {
 899                 kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);
 900         } else {
 901                 kpd_wakeup_src_setting(0);
 902                 kpd_print("kpd_early_suspend wake up source disable!! (%d)\n", kpd_suspend);
 903         }
 904 #endif
 905         kpd_disable_backlight();
 906         kpd_print("suspend!! (%d)\n", kpd_suspend);
 907         return 0;
 908 }
 909
 910 static int kpd_pdrv_resume(struct platform_device *pdev)
 911 {
 912         kpd_suspend = false;
 913 #ifdef MTK_KP_WAKESOURCE
 914         if (call_status == 2) {
 915                 kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);
 916         } else {
 917                 kpd_print("kpd_early_suspend wake up source resume!! (%d)\n", kpd_suspend);
 918                 kpd_wakeup_src_setting(1);
 919         }
 920 #endif
 921         kpd_print("resume!! (%d)\n", kpd_suspend);
 922         return 0;
 923 }
 924 #else
 925 #define kpd_pdrv_suspend        NULL
 926 #define kpd_pdrv_resume         NULL
 927 #endif
 928
 929
 930 #ifdef USE_EARLY_SUSPEND
 931 static void kpd_early_suspend(struct early_suspend *h)
 932 {
 933         kpd_suspend = true;
 934 #ifdef MTK_KP_WAKESOURCE
 935         if (call_status == 2) {
 936                 kpd_print("kpd_early_suspend wake up source enable!! (%d)\n", kpd_suspend);
 937         } else {
 938                 /* kpd_wakeup_src_setting(0); */
 939                 kpd_print("kpd_early_suspend wake up source disable!! (%d)\n", kpd_suspend);
 940         }
 941 #endif
 942         kpd_disable_backlight();
 943         kpd_print("early suspend!! (%d)\n", kpd_suspend);
 944 }
 945
 946 static void kpd_early_resume(struct early_suspend *h)
 947 {
 948         kpd_suspend = false;
 949 #ifdef MTK_KP_WAKESOURCE
 950         if (call_status == 2) {
 951                 kpd_print("kpd_early_resume wake up source resume!! (%d)\n", kpd_suspend);
 952         } else {
 953                 kpd_print("kpd_early_resume wake up source enable!! (%d)\n", kpd_suspend);
 954                 /* kpd_wakeup_src_setting(1); */
 955         }
 956 #endif
 957         kpd_print("early resume!! (%d)\n", kpd_suspend);
 958 }
 959
 960 static struct early_suspend kpd_early_suspend_desc = {
 961         .level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1,
 962         .suspend = kpd_early_suspend,
 963         .resume = kpd_early_resume,
 964 };
 965 #endif
 966
 967 #ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
 968 #ifdef CONFIG_HAS_SBSUSPEND
 969 static struct sb_handler kpd_sb_handler_desc = {
 970         .level = SB_LEVEL_DISABLE_KEYPAD,
 971         .plug_in = sb_kpd_enable,
 972         .plug_out = sb_kpd_disable,
 973 };
 974 #endif
 975 #endif
 976
 977 static int __init kpd_mod_init(void)
 978 {
 979         int r;
 980
 981         r = platform_driver_register(&kpd_pdrv);
 982         if (r) {
 983                 printk(KPD_SAY "register driver failed (%d)\n", r);
 984                 return r;
 985         }
 986 #ifdef USE_EARLY_SUSPEND
 987         register_early_suspend(&kpd_early_suspend_desc);
 988 #endif
 989
 990 #ifdef CONFIG_MTK_SMARTBOOK_SUPPORT
 991 #ifdef CONFIG_HAS_SBSUSPEND
 992         register_sb_handler(&kpd_sb_handler_desc);
 993 #endif
 994 #endif
 995
 996         return 0;
 997 }
 998
 999 /* should never be called */
1000 static void __exit kpd_mod_exit(void)
1001 {
1002 }
1003 module_init(kpd_mod_init);
1004 module_exit(kpd_mod_exit);
1005
1006 module_param(kpd_show_hw_keycode, int, 0644);
1007 module_param(kpd_show_register, int, 0644);
1008
1009 MODULE_AUTHOR("yucong.xiong <yucong.xiong@mediatek.com>");
1010 MODULE_DESCRIPTION("MTK Keypad (KPD) Driver v0.4");
1011 MODULE_LICENSE("GPL");