MTK touchscreen 流程

1. kernel-3.18/drivers/input/touchscreen/mediatek/tpd_common_probe.c

 static int __init tpd_probe_init(void)
 {
     tpd_device_init();
     return ;
 }

2. kernel-3.18/drivers/input/touchscreen/mediatek/mtk_tpd.c

 int tpd_device_init(void)
 {
     int res = ;

     tpd_init_workqueue = create_singlethread_workqueue("mtk-tpd");
     INIT_WORK(&tpd_init_work, tpd_init_work_callback);

     res = queue_work(tpd_init_workqueue, &tpd_init_work);
     if (!res)
         pr_err("tpd : touch device init failed res:%d\n", res);
     return ;
 }

3. kernel-3.18/drivers/input/touchscreen/mediatek/mtk_tpd.c

 /* called when loaded into kernel */
 static void tpd_init_work_callback(struct work_struct *work)
 {
     TPD_DEBUG("MediaTek touch panel driver init\n");

     if (platform_driver_register(&tpd_driver) != )
         TPD_DMESG("unable to register touch panel driver.\n");
 }

platform_device 和 platform_driver 匹配后，调用tpd_probe

 static struct platform_driver tpd_driver = {
     .remove = tpd_remove,
     .shutdown = NULL,
     .probe = tpd_probe,
     .driver = {
             .name = TPD_DEVICE,
             .pm = &tpd_pm_ops,
             .owner = THIS_MODULE,
             .of_match_table = touch_of_match,
     },
 };

 /* touch panel probe */
 static int tpd_probe(struct platform_device *pdev)
 {
     int touch_type = ;    /* 0:R-touch, 1: Cap-touch */
     int i = ;
 #ifndef CONFIG_CUSTOM_LCM_X
 #ifdef CONFIG_LCM_WIDTH
     unsigned long tpd_res_x = , tpd_res_y = ;
     int ret = ;
 #endif
 #endif

     TPD_DMESG("enter %s, %d\n", __func__, __LINE__);

     if (misc_register(&tpd_misc_device))
         pr_err("mtk_tpd: tpd_misc_device register failed\n");
     tpd_get_gpio_info(pdev);
     tpd = kmalloc(sizeof(struct tpd_device), GFP_KERNEL);
     if (tpd == NULL)
         return -ENOMEM;
     memset(tpd, , sizeof(struct tpd_device));

     /* allocate input device */
     tpd->dev = input_allocate_device();
     if (tpd->dev == NULL) {
         kfree(tpd);
         return -ENOMEM;
     }
     /* TPD_RES_X = simple_strtoul(LCM_WIDTH, NULL, 0); */
     /* TPD_RES_Y = simple_strtoul(LCM_HEIGHT, NULL, 0); */

     #ifdef CONFIG_MTK_LCM_PHYSICAL_ROTATION
     if ( == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "", )
         ||  == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "", )) {
 #ifdef CONFIG_MTK_FB    /*Fix build errors,as some projects  cannot support these apis while bring up*/
         TPD_RES_Y = DISP_GetScreenWidth();
         TPD_RES_X = DISP_GetScreenHeight();
 #endif
     } else
     #endif
     {
 #ifdef CONFIG_CUSTOM_LCM_X
 #ifndef CONFIG_MTK_FPGA
 #ifdef CONFIG_MTK_FB    /*Fix build errors,as some projects  cannot support these apis while bring up*/
         TPD_RES_X = DISP_GetScreenWidth();
         TPD_RES_Y = DISP_GetScreenHeight();
 #else/*for some projects, we do not use mtk framebuffer*/
     TPD_RES_X = tpd_dts_data.tpd_resolution[];
     TPD_RES_Y = tpd_dts_data.tpd_resolution[];
 #endif
 #endif
 #else
 #ifdef CONFIG_LCM_WIDTH
         ret = kstrtoul(CONFIG_LCM_WIDTH, , &tpd_res_x);
         if (ret < ) {
             pr_err("Touch down get lcm_x failed");
             return ret;
         }
         TPD_RES_X = tpd_res_x;
         ret = kstrtoul(CONFIG_LCM_HEIGHT, , &tpd_res_y);
         if (ret < ) {
             pr_err("Touch down get lcm_y failed");
             return ret;
         }
         TPD_RES_Y = tpd_res_y;
 #endif
 #endif
     }

     if ( == TPD_RES_X)
         TPD_RES_X = ;
     if ( == TPD_RES_Y)
         TPD_RES_Y = ;
     pr_debug("mtk_tpd: TPD_RES_X = %lu, TPD_RES_Y = %lu\n", TPD_RES_X, TPD_RES_Y);

     tpd_mode = TPD_MODE_NORMAL;
     tpd_mode_axis = ;
     tpd_mode_min = TPD_RES_Y / ;
     tpd_mode_max = TPD_RES_Y;
     tpd_mode_keypad_tolerance = TPD_RES_X * TPD_RES_X / ;
     /* struct input_dev dev initialization and registration */
     tpd->dev->name = TPD_DEVICE;
     set_bit(EV_ABS, tpd->dev->evbit);
     set_bit(EV_KEY, tpd->dev->evbit);
     set_bit(ABS_X, tpd->dev->absbit);
     set_bit(ABS_Y, tpd->dev->absbit);
     set_bit(ABS_PRESSURE, tpd->dev->absbit);
 #if !defined(CONFIG_MTK_S3320) && !defined(CONFIG_MTK_S3320_47)\
     && !defined(CONFIG_MTK_S3320_50) && !defined(CONFIG_MTK_MIT200) \
     && !defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S3528) && !defined(CONFIG_MTK_S7020) \
     && !defined(CONFIG_TOUCHSCREEN_MTK_SYNAPTICS_3320_50)
     set_bit(BTN_TOUCH, tpd->dev->keybit);
 #endif /* CONFIG_MTK_S3320 */
     set_bit(INPUT_PROP_DIRECT, tpd->dev->propbit);

     /* save dev for regulator_get() before tpd_local_init() */
     tpd->tpd_dev = &pdev->dev;
     for (i = ; i < TP_DRV_MAX_COUNT; i++) {
         /* add tpd driver into list */
         if (tpd_driver_list[i].tpd_device_name != NULL) {
             tpd_driver_list[i].tpd_local_init();
             /* msleep(1); */
             if (tpd_load_status == ) {
                 TPD_DMESG("[mtk-tpd]tpd_probe, tpd_driver_name=%s\n",
                       tpd_driver_list[i].tpd_device_name);
                 g_tpd_drv = &tpd_driver_list[i];
                 break;
             }
         }
     }
     if (g_tpd_drv == NULL) {
         if (tpd_driver_list[].tpd_device_name != NULL) {
             g_tpd_drv = &tpd_driver_list[];
             /* touch_type:0: r-touch, 1: C-touch */
             touch_type = ;
             g_tpd_drv->tpd_local_init();
             TPD_DMESG("[mtk-tpd]Generic touch panel driver\n");
         } else {
             TPD_DMESG("[mtk-tpd]cap touch and Generic touch both are not loaded!!\n");
             return ;
         }
     }
     touch_resume_workqueue = create_singlethread_workqueue("touch_resume");
     INIT_WORK(&touch_resume_work, touch_resume_workqueue_callback);
     /* use fb_notifier */
     tpd_fb_notifier.notifier_call = tpd_fb_notifier_callback;
     if (fb_register_client(&tpd_fb_notifier))
         TPD_DMESG("register fb_notifier fail!\n");
     /* TPD_TYPE_CAPACITIVE handle */
     if (touch_type == ) {

         set_bit(ABS_MT_TRACKING_ID, tpd->dev->absbit);
         set_bit(ABS_MT_TOUCH_MAJOR, tpd->dev->absbit);
         set_bit(ABS_MT_TOUCH_MINOR, tpd->dev->absbit);
         set_bit(ABS_MT_POSITION_X, tpd->dev->absbit);
         set_bit(ABS_MT_POSITION_Y, tpd->dev->absbit);
         input_set_abs_params(tpd->dev, ABS_MT_POSITION_X, , TPD_RES_X, , );
         input_set_abs_params(tpd->dev, ABS_MT_POSITION_Y, , TPD_RES_Y, , );
 #if defined(CONFIG_MTK_S3320) || defined(CONFIG_MTK_S3320_47) \
     || defined(CONFIG_MTK_S3320_50) || defined(CONFIG_MTK_MIT200) \
     || defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S3528) || defined(CONFIG_MTK_S7020) \
     || defined(CONFIG_TOUCHSCREEN_MTK_SYNAPTICS_3320_50)
         input_set_abs_params(tpd->dev, ABS_MT_PRESSURE, , , , );
         input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MAJOR, , , , );
         input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MINOR, , , , );
         input_mt_init_slots(tpd->dev, , );
 #else
         input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MAJOR, , , , );
         input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MINOR, , , , );
 #endif /* CONFIG_MTK_S3320 */
         TPD_DMESG("Cap touch panel driver\n");
     }
     input_set_abs_params(tpd->dev, ABS_X, , TPD_RES_X, , );
     input_set_abs_params(tpd->dev, ABS_Y, , TPD_RES_Y, , );
     input_abs_set_res(tpd->dev, ABS_X, TPD_RES_X);
     input_abs_set_res(tpd->dev, ABS_Y, TPD_RES_Y);
     input_set_abs_params(tpd->dev, ABS_PRESSURE, , , , );
     input_set_abs_params(tpd->dev, ABS_MT_TRACKING_ID, , , , );

     if (input_register_device(tpd->dev))
         TPD_DMESG("input_register_device failed.(tpd)\n");
     else
         tpd_register_flag = ;
     if (g_tpd_drv->tpd_have_button)
         tpd_button_init();

     if (g_tpd_drv->attrs.num)
         tpd_create_attributes(&pdev->dev, &g_tpd_drv->attrs);

     return ;
 }