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 0;
}

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

int tpd_device_init(void)
{
    int res = 0;

    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
", res);
    return 0;
}

 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
");
    
    if (platform_driver_register(&tpd_driver) != 0)
        TPD_DMESG("unable to register touch panel driver.
");
}

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 = 1;    /* 0:R-touch, 1: Cap-touch */
    int i = 0;
#ifndef CONFIG_CUSTOM_LCM_X
#ifdef CONFIG_LCM_WIDTH
    unsigned long tpd_res_x = 0, tpd_res_y = 0;
    int ret = 0;
#endif
#endif

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

    if (misc_register(&tpd_misc_device))
        pr_err("mtk_tpd: tpd_misc_device register failed
");
    tpd_get_gpio_info(pdev);
    tpd = kmalloc(sizeof(struct tpd_device), GFP_KERNEL);
    if (tpd == NULL)
        return -ENOMEM;
    memset(tpd, 0, 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 (0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "90", 2)
        || 0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "270", 3)) {
#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[0];
    TPD_RES_Y = tpd_dts_data.tpd_resolution[1];
#endif
#endif
#else
#ifdef CONFIG_LCM_WIDTH
        ret = kstrtoul(CONFIG_LCM_WIDTH, 0, &tpd_res_x);
        if (ret < 0) {
            pr_err("Touch down get lcm_x failed");
            return ret;
        }
        TPD_RES_X = tpd_res_x;
        ret = kstrtoul(CONFIG_LCM_HEIGHT, 0, &tpd_res_y);
        if (ret < 0) {
            pr_err("Touch down get lcm_y failed");
            return ret;
        }
        TPD_RES_Y = tpd_res_y;
#endif
#endif
    }

    if (2560 == TPD_RES_X)
        TPD_RES_X = 2048;
    if (1600 == TPD_RES_Y)
        TPD_RES_Y = 1536;
    pr_debug("mtk_tpd: TPD_RES_X = %lu, TPD_RES_Y = %lu
", TPD_RES_X, TPD_RES_Y);

    tpd_mode = TPD_MODE_NORMAL;
    tpd_mode_axis = 0;
    tpd_mode_min = TPD_RES_Y / 2;
    tpd_mode_max = TPD_RES_Y;
    tpd_mode_keypad_tolerance = TPD_RES_X * TPD_RES_X / 1600;
    /* 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 = 1; 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 == 1) {
                TPD_DMESG("[mtk-tpd]tpd_probe, tpd_driver_name=%s
",
                      tpd_driver_list[i].tpd_device_name);
                g_tpd_drv = &tpd_driver_list[i];
                break;
            }
        }
    }
    if (g_tpd_drv == NULL) {
        if (tpd_driver_list[0].tpd_device_name != NULL) {
            g_tpd_drv = &tpd_driver_list[0];
            /* touch_type:0: r-touch, 1: C-touch */
            touch_type = 0;
            g_tpd_drv->tpd_local_init();
            TPD_DMESG("[mtk-tpd]Generic touch panel driver
");
        } else {
            TPD_DMESG("[mtk-tpd]cap touch and Generic touch both are not loaded!!
");
            return 0;
        }
    }
    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!
");
    /* TPD_TYPE_CAPACITIVE handle */
    if (touch_type == 1) {

        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, 0, TPD_RES_X, 0, 0);
        input_set_abs_params(tpd->dev, ABS_MT_POSITION_Y, 0, TPD_RES_Y, 0, 0);
#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, 0, 255, 0, 0);
        input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MAJOR, 0, 15, 0, 0);
        input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MINOR, 0, 15, 0, 0);
        input_mt_init_slots(tpd->dev, 10, 0);
#else
        input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MAJOR, 0, 100, 0, 0);
        input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MINOR, 0, 100, 0, 0);
#endif /* CONFIG_MTK_S3320 */
        TPD_DMESG("Cap touch panel driver
");
    }
    input_set_abs_params(tpd->dev, ABS_X, 0, TPD_RES_X, 0, 0);
    input_set_abs_params(tpd->dev, ABS_Y, 0, TPD_RES_Y, 0, 0);
    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, 0, 255, 0, 0);
    input_set_abs_params(tpd->dev, ABS_MT_TRACKING_ID, 0, 10, 0, 0);

    if (input_register_device(tpd->dev))
        TPD_DMESG("input_register_device failed.(tpd)
");
    else
        tpd_register_flag = 1;
    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 0;
}