简单聊一下多点触控协议

前言

前面简单聊了一下多点触控协议，接下来找个驱动来看看具体实现。目前市面上多点触控芯片用得比较多的主要是汇顶和敦泰。我们找一款敦泰的芯片来看看。

多点触控驱动分析

Linux版本：5.10

芯片：FT5436 (10点触控芯片)

通信接口: I2C

(1)加载和卸载函数

static const struct i2c_device_id fts_ts_id[] = {
    {FTS_DRIVER_NAME, 0},
    {},
};


//设备树匹配
static const struct of_device_id fts_dt_match[] = {
    {.compatible = "focaltech,ft5436", },
    {},
};
MODULE_DEVICE_TABLE(of, fts_dt_match);


static struct i2c_driver fts_ts_driver = {
    .probe = fts_ts_probe,
    .remove = fts_ts_remove,
    .driver = {
        .name = FTS_DRIVER_NAME,
        .owner = THIS_MODULE,
        .of_match_table = of_match_ptr(fts_dt_match),
    },
    .id_table = fts_ts_id,
};


static int __init fts_ts_init(void)
{
    int ret = 0;


    FTS_FUNC_ENTER();
    //添加i2c设备驱动
    ret = i2c_add_driver(&fts_ts_driver);
    if ( ret != 0 ) {
        FTS_ERROR("Focaltech touch screen driver init failed!");
    }
    FTS_FUNC_EXIT();
    return ret;
}


static void __exit fts_ts_exit(void)
{
    i2c_del_driver(&fts_ts_driver);
}
module_init(fts_ts_init);
module_exit(fts_ts_exit);

FT5436使用I2C接口进行通信，所以注册i2c_driver。

(2)probe()函数

static int fts_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int ret = 0;
    struct fts_ts_data *ts_data = NULL;


    FTS_INFO("Touch Screen(I2C BUS) driver prboe...");
    //检查I2C功能
    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
        FTS_ERROR("I2C not supported");
        return -ENODEV;
    }


    //为结构体分配内存
    ts_data = (struct fts_ts_data *)kzalloc(sizeof(*ts_data), GFP_KERNEL);
    if (!ts_data) {
        FTS_ERROR("allocate memory for fts_data fail");
        return -ENOMEM;
    }


    //保存数据,方便后面使用
    fts_data = ts_data;
    ts_data->client = client; //i2c设备
    ts_data->dev = &client->dev;
    ts_data->log_level = 1;
    ts_data->fw_is_running = 0;
    i2c_set_clientdata(client, ts_data);
    //进入真正的probe流程
    ret = fts_ts_probe_entry(ts_data);
//......


    FTS_INFO("Touch Screen(I2C BUS) driver prboe successfully");
    return 0;
}

初始化结构体，保存i2c设备，然后调用fts_ts_probe_entry进入设备的初始化。

static int fts_ts_probe_entry(struct fts_ts_data *ts_data)
{
    int ret = 0;
    int pdata_size = sizeof(struct fts_ts_platform_data);
    struct device_node *np = ts_data->dev->of_node;


    FTS_FUNC_ENTER();
    FTS_INFO("%s", FTS_DRIVER_VERSION);
    ts_data->pdata = kzalloc(pdata_size, GFP_KERNEL);
    if (!ts_data->pdata) {
        FTS_ERROR("allocate memory for platform_data fail");
        return -ENOMEM;
    }
    //获取平台数据
    if (ts_data->dev->of_node) {
        //dts解析
        ret = fts_parse_dt(ts_data->dev, ts_data->pdata);
        if (ret)
            FTS_ERROR("device-tree parse fail");
    } else {
        if (ts_data->dev->platform_data) {
            memcpy(ts_data->pdata, ts_data->dev->platform_data, pdata_size);
        } else {
            FTS_ERROR("platform_data is null");
            return -ENODEV;
        }
    }
    //创建工作队列
    ts_data->ts_workqueue = create_singlethread_workqueue("fts_wq");
    //.....


    //在输入子系统中注册设备
    ret = fts_input_init(ts_data);
    if (ret) {
        FTS_ERROR("input initialize fail");
        goto err_input_init;
    }
    //......
    //gpio配置(中断,复位)
    ret = fts_gpio_configure(ts_data);
    if (ret) {
        FTS_ERROR("configure the gpios fail");
        goto err_gpio_config;
    }


    //.....
    //创建proc调试接口
    ret = fts_create_apk_debug_channel(ts_data);
    if (ret) {
        FTS_ERROR("create apk debug node fail");
    }
    //创建sys调试接口
    ret = fts_create_sysfs(ts_data);
    if (ret) {
        FTS_ERROR("create sysfs node fail");
    }


#if FTS_POINT_REPORT_CHECK_EN
    //初始化work(用于处理中断数据)
    ret = fts_point_report_check_init(ts_data);
    if (ret) {
        FTS_ERROR("init point report check fail");
    }
#endif
    //.....
    //注册中断
    ret = fts_irq_registration(ts_data);
    //.....
    //初始化固件更新功能(用于为Touch模组更新固件)
    ret = fts_fwupg_init(ts_data);
    if (ret) {
        FTS_ERROR("init fw upgrade fail");
    }
    //配置休眠唤醒
#if defined(CONFIG_FB)
    if (ts_data->ts_workqueue) {
        INIT_WORK(&ts_data->resume_work, fts_resume_work);
    }
    ts_data->tp.tp_resume = fts_ts_late_resume;
    ts_data->tp.tp_suspend = fts_ts_early_suspend;
    //通过LCD屏亮灭来决定唤醒
    tp_register_fb(&ts_data->tp);
#elif defined(CONFIG_HAS_EARLYSUSPEND)
    ts_data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + FTS_SUSPEND_LEVEL;
    ts_data->early_suspend.suspend = fts_ts_early_suspend;
    ts_data->early_suspend.resume = fts_ts_late_resume;
    register_early_suspend(&ts_data->early_suspend);
#endif
    //使能中断唤醒
    if (of_property_read_bool(np, "wakeup-source"))
    {
        device_init_wakeup(&ts_data->client->dev, 1);
        enable_irq_wake(ts_data->irq);
    }


    FTS_FUNC_EXIT();
    return 0;
    //......
}

上面主要完成如下工作:

1.解析dts

2.创建工作队列(处理中断下半部)

3.注册输入子系统设备

4.初始化GPIO(中断和复位)

5.创建proc和sys调试接口

6.注册中断

7.初始化固件更新功能(用于升级Touch芯片上的固件)

8.配置休眠唤醒

(3)注册输入设备

static int fts_input_init(struct fts_ts_data *ts_data)
{
    int ret = 0;
    int key_num = 0;
    struct fts_ts_platform_data *pdata = ts_data->pdata;
    struct input_dev *input_dev;


    FTS_FUNC_ENTER();
    //分配输入设备(input_dev)
    input_dev = input_allocate_device();
    if (!input_dev) {
        FTS_ERROR("Failed to allocate memory for input device");
        return -ENOMEM;
    }


    /* Init and register Input device */
    input_dev->name = FTS_DRIVER_NAME;


    input_dev->id.bustype = BUS_I2C;
    input_dev->dev.parent = ts_data->dev;


    input_set_drvdata(input_dev, ts_data);


    __set_bit(EV_SYN, input_dev->evbit); //同步事件
    __set_bit(EV_ABS, input_dev->evbit); //绝对坐标事件(比如X,Y坐标信息)
    __set_bit(EV_KEY, input_dev->evbit); //按键事件
    __set_bit(BTN_TOUCH, input_dev->keybit);
    __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);


    if (pdata->have_key) {
        FTS_INFO("set key capabilities");
        for (key_num = 0; key_num < pdata->key_number; key_num++)
            input_set_capability(input_dev, EV_KEY, pdata->keys[key_num]);
    }


#if FTS_MT_PROTOCOL_B_EN
    //Type B协议
    //初始化SLOT(最大触点数)
    input_mt_init_slots(input_dev, pdata->max_touch_number, INPUT_MT_DIRECT);
#else
    input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, 0x0F, 0, 0);
#endif
    //设置X,Y,接触轴
    input_set_abs_params(input_dev, ABS_MT_POSITION_X, pdata->x_min, pdata->x_max, 0, 0);
    input_set_abs_params(input_dev, ABS_MT_POSITION_Y, pdata->y_min, pdata->y_max, 0, 0);
    input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 0xFF, 0, 0);
#if FTS_REPORT_PRESSURE_EN
    //设置压力值
    input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 0xFF, 0, 0);
#endif
    //注册输入设备
    ret = input_register_device(input_dev);
    //.....


    ts_data->input_dev = input_dev;


    FTS_FUNC_EXIT();
    return 0;
}

设置支持的输入事件，然后注册到输入子系统中。

(4)中断处理

static irqreturn_t fts_irq_handler(int irq, void *data)
{
    struct fts_ts_data *ts_data = (struct fts_ts_data *)data;


    if (!ts_data) {
        FTS_ERROR("[INTR]: Invalid fts_ts_data");
        return IRQ_HANDLED;
    }


    if (device_can_wakeup(&ts_data->client->dev))
        pm_stay_awake(&ts_data->client->dev);        
    //读取数据
    fts_irq_read_report();
    if (device_can_wakeup(&ts_data->client->dev))
        pm_relax(&ts_data->client->dev);


    return IRQ_HANDLED;
}

static void fts_irq_read_report(void)
{
    int ret = 0;
    struct fts_ts_data *ts_data = fts_data;
    //.....


#if FTS_POINT_REPORT_CHECK_EN
    //添加work到工作队列中(延迟)
    fts_prc_queue_work(ts_data);
#endif
    //读取touch数据
    ret = fts_read_parse_touchdata(ts_data);
    if (ret == 0) {
        mutex_lock(&ts_data->report_mutex);
        //上报数据
#if FTS_MT_PROTOCOL_B_EN
        fts_input_report_b(ts_data); //Type B
#else
        fts_input_report_a(ts_data); //Type A
#endif
        mutex_unlock(&ts_data->report_mutex);
    }
    //......
}

读取touch数据并解析，然后进行事件上报。

(5)读取和解析数据

static int fts_read_parse_touchdata(struct fts_ts_data *data)
{
    int ret = 0;
    int i = 0;
    u8 pointid = 0;
    int base = 0;
    struct ts_event *events = data->events;
    int max_touch_num = data->pdata->max_touch_number;
    u8 *buf = data->point_buf;
    //通过I2C读取芯片数据
    ret = fts_read_touchdata(data);
    if (ret) {
        return ret;
    }


    //对读取到的数据进行解析
    data->point_num = buf[FTS_TOUCH_POINT_NUM] & 0x0F;
    data->touch_point = 0;


    if (data->ic_info.is_incell) {
        if ((data->point_num == 0x0F) && (buf[2] == 0xFF) && (buf[3] == 0xFF)
            && (buf[4] == 0xFF) && (buf[5] == 0xFF) && (buf[6] == 0xFF)) {
            FTS_DEBUG("touch buff is 0xff, need recovery state");
            fts_release_all_finger();
            fts_tp_state_recovery(data);
            return -EIO;
        }
    }
    //.....
    for (i = 0; i < max_touch_num; i++) {
        base = FTS_ONE_TCH_LEN * i;
        pointid = (buf[FTS_TOUCH_ID_POS + base]) >> 4;
        if (pointid >= FTS_MAX_ID)
            break;
        else if (pointid >= max_touch_num) {
            FTS_ERROR("ID(%d) beyond max_touch_number", pointid);
            return -EINVAL;
        }


        data->touch_point++;
        events[i].x = ((buf[FTS_TOUCH_X_H_POS + base] & 0x0F) << 8) +
                      (buf[FTS_TOUCH_X_L_POS + base] & 0xFF);
        events[i].y = ((buf[FTS_TOUCH_Y_H_POS + base] & 0x0F) << 8) +
                      (buf[FTS_TOUCH_Y_L_POS + base] & 0xFF);
        events[i].flag = buf[FTS_TOUCH_EVENT_POS + base] >> 6;
        events[i].id = buf[FTS_TOUCH_ID_POS + base] >> 4;
        events[i].area = buf[FTS_TOUCH_AREA_POS + base] >> 4;
        events[i].p =  buf[FTS_TOUCH_PRE_POS + base];


        if (EVENT_DOWN(events[i].flag) && (data->point_num == 0)) {
            FTS_INFO("abnormal touch data from fw");
            return -EIO;
        }
    }


    if (data->touch_point == 0) {
        FTS_INFO("no touch point information");
        return -EIO;
    }


    return 0;
}

fts_read_touchdata()从芯片中读出数据，然后对数据进行解析。

(6)事件上报

static int fts_input_report_b(struct fts_ts_data *data)
{
    int i = 0;
    int uppoint = 0;
    int touchs = 0;
    bool va_reported = false;
    u32 max_touch_num = data->pdata->max_touch_number;
    struct ts_event *events = data->events;


    for (i = 0; i < data->touch_point; i++) {
        if (fts_input_report_key(data, i) == 0) {
            continue;
        }


        va_reported = true;
        //上报ABS_MT_SLOT事件
        input_mt_slot(data->input_dev, events[i].id);


        //按下/抬起手指
        if (EVENT_DOWN(events[i].flag)) {
            //上报手指按下和坐标等信息


            //使用MT_TOOL_FINGER来确定按下和抬起，
            //就不需要使用ABS_MT_TRACKING_ID来控制触点的生命周期了
            input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, true);


#if FTS_REPORT_PRESSURE_EN
            if (events[i].p <= 0) {
                events[i].p = 0x3f;
            }
            //上报压力值
            input_report_abs(data->input_dev, ABS_MT_PRESSURE, events[i].p);
#endif
            if (events[i].area <= 0) {
                events[i].area = 0x09;
            }
            //上报触点的主轴长度
            input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, events[i].area);
            //上报X,Y坐标
            input_report_abs(data->input_dev, ABS_MT_POSITION_X, events[i].x);
            input_report_abs(data->input_dev, ABS_MT_POSITION_Y, events[i].y);


            touchs |= BIT(events[i].id);
            data->touchs |= BIT(events[i].id);
            //......
        } else {
            uppoint++;
            //上报手指抬起
            input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, false);
            data->touchs &= ~BIT(events[i].id);
            if (data->log_level >= 1) {
                FTS_DEBUG("[B]P%d UP!", events[i].id);
            }
        }
    }


    if (unlikely(data->touchs ^ touchs)) {
        for (i = 0; i < max_touch_num; i++)  {
            if (BIT(i) & (data->touchs ^ touchs)) {
                if (data->log_level >= 1) {
                    FTS_DEBUG("[B]P%d UP!", i);
                }
                va_reported = true;
                input_mt_slot(data->input_dev, i);
                input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, false);
            }
        }
    }
    data->touchs = touchs;
    //上报Touch按键事件
    if (va_reported) {
        /* touchs==0, there's no point but key */
        if (EVENT_NO_DOWN(data) || (!touchs)) {
            //所有触点都抬起了
            if (data->log_level >= 1) {
                FTS_DEBUG("[B]Points All Up!");
            }
            input_report_key(data->input_dev, BTN_TOUCH, 0);
        } else {
            input_report_key(data->input_dev, BTN_TOUCH, 1);
        }
    }
    //同步(告诉上层本次上报结束)
    input_sync(data->input_dev);
    return 0;
}

上报各种事件(MT_TOOL_FINGER/ABS_MT_POSITION_X/ABS_MT_POSITION_Y等 )给上层。

总结

整体分析下来，会发现多点触控驱动并不难，主要就是注册为输入子系统，然后中断触发后读取触控数据，最后通过输入子系统上报数据。所有输入子系统的驱动基本都是这个套路。

审核编辑：刘清