22_多点电容触摸屏驱动

2024-03-23 13:54:16

一、linux电容触摸屏驱动简介

1、多点触摸屏（MT）简介

​ 电容多点触摸屏驱动由以下几种类型的驱动组成：

  • IIC 设备驱动，电容触摸 IC 基本都是 IIC 接口。

  • 通过中断引脚 (INT) 向内核上报触摸信息，坐标的上报在中断服务函数中完成。

  • 触摸屏的坐标信息、屏幕按下和抬起信息都属于 input 子系统，向内核上报触摸屏坐标信息要使用 input 子系统。

    内核中有一份文档详细的讲解了多点电容触摸屏协议，文档路径为：Documentation/input/multi-touch-protocol.txt

​ 如果使用 2.x 版本的内核可能找不到 MT 协议，MT协议被分为两种类型，TypeA 和 TypeB，两种类型区别如下：

​ TypeA：适用于触摸点不能被区分或者追踪，此类型的设备上报原始数据。

​ TypeB：适用于有硬件追踪并能区分触摸点的触摸设备，此类型设备通过 slot 更新某一个触摸点的信息。

1）ABS_MT事件

​ 触摸点的信息通过一系列的 ABS_MT 事件上报给 linux 内核，只有 ABS_MT 事件是用于多点触摸的， ABS_MT 事件定义在文件 linux/input.h 中：

#define ABS_MT_SLOT		0x2f	/* MT slot being modified */
#define ABS_MT_TOUCH_MAJOR	0x30	/* Major axis of touching ellipse */
#define ABS_MT_TOUCH_MINOR	0x31	/* Minor axis (omit if circular) */
#define ABS_MT_WIDTH_MAJOR	0x32	/* Major axis of approaching ellipse */
#define ABS_MT_WIDTH_MINOR	0x33	/* Minor axis (omit if circular) */
#define ABS_MT_ORIENTATION	0x34	/* Ellipse orientation */
#define ABS_MT_POSITION_X	0x35	/* Center X touch position */
#define ABS_MT_POSITION_Y	0x36	/* Center Y touch position */
#define ABS_MT_TOOL_TYPE	0x37	/* Type of touching device */
#define ABS_MT_BLOB_ID		0x38	/* Group a set of packets as a blob */
#define ABS_MT_TRACKING_ID	0x39	/* Unique ID of initiated contact */
#define ABS_MT_PRESSURE		0x3a	/* Pressure on contact area */
#define ABS_MT_DISTANCE		0x3b	/* Contact hover distance */
#define ABS_MT_TOOL_X		0x3c	/* Center X tool position */
#define ABS_MT_TOOL_Y		0x3d	/* Center Y tool position */

​ 常用到的有：

​ ABS_MT_SLOT：用于上报触摸点 ID；

​ ABS_MT_POSITION_X：用于上报触摸点的 X 坐标；

​ ABS_MT_POSITION_Y：用于上报触摸点的 Y 坐标；

​ ABS_MT_TRACKING_ID：对于 TypeB 类型，使用 ABS_MT_TRACKING_ID 来区分触摸点。

2）input_mt_sync函数（用于TypeA）

​ 对于 Type A 类型的设备，通过 input_mt_sync 函数来隔离不同的触摸点数据信息，函数会触发SYN_MT_REPORT 事件，此事件会通知接收者获取当前触摸数据，并且准备接收下一个触摸点数据，函数原型如下：

void input_mt_sync(struct input_dev *dev)

​ dev：具体的 input_dev 设备。

3）input_mt_slot函数（用于TypeB）

​ 对于 Type A 类型的设备，通过 input_mt_slot 函数来区分不同的触摸点数据信息，input_mt_slot 函数会触发 ABS_MT_SLOT 事件，此事件会告诉接收者当前正在更新的是哪个触摸点 (slot) 的数据。函数原型如下：

void input_mt_slot(struct input_dev *dev, int slot)

​ dev：具体的 input_dev 设备。

​ slot：指定当前上报的是哪个触摸点信息。

​ 不管是哪个类型的设备，最终都要调用 input_sync 函数来标识多点触摸信息传输完成。

​ 对于 TypeA 设备，内核驱动需要一次性将触摸屏上所有的触摸点信息全部上报，每个触摸点的信息在本次上报事件流中的顺序不重要，因为事件的过滤和手指（触摸点）跟踪是在内核空间处理的。

​ 对于 TypeB 设备，使用 slot 协议区分具体的触摸点， slot 需要用到 ABS_MT_TRACKING_ID 消息，这个 ID需要硬件提供，或者通过原始数据计算出来。
​ TypeB 设备驱动需要给每个识别出来的触摸点分配一个 slot，后面使用这个 slot 来上报触摸点信息。可以通过 slot 的 ABS_MT_TRACKING_ID 来新增、替换或删除触摸点。一个非负的 ID 表示一个有效的触摸点，-1 这个 ID 表示未使用 slot。一个以前不存在的 ID 表示这是一个新加的触摸点，一个 ID 如果再也不存在了就表示删除了。

​ 如果硬件设备追踪到了比它正在上报的还要多的触摸点，那么驱动程序应该发送 BTN_TOOL_TAP 消息，并且调用input_mt_report_pointer_emulation 函数，将此函数的第二个参数 use_count 设置为 false。

4）TypeA触摸点信息上报时序

​ 对于 TypeA 设备，发送触摸点信息的时序如下：

ABS_MT_POSITION_X x[0]		//上报第一个触摸点的X坐标数据，通过 input_report_abs 函数实现，下面同理
ABS_MT_POSITION_Y y[0]		//上报第一个触摸点的Y坐标数据
SYN_MT_REPORT 				//上报SYN_MT_REPORT事件，通过调用input_mt_sync函数来实现
ABS_MT_POSITION_X x[1] 		//上报第二个触摸点的X坐标数据
ABS_MT_POSITION_Y y[1] 		//上报第二个触摸点的Y坐标数据
SYN_MT_REPORT 				//上报SYN_MT_REPORT事件
SYN_REPORT					//上报SYN_REPORT事件，通过调用input_sync函数实现

​ TypeA 设备上报触摸点示例代码：

static irqreturn_t st1232_ts_irq_handler(int irq, void *dev_id)
{
    ret = st1232_ts_read_data(ts); 		//获取所有触摸点信息
    if (ret < 0) 
        goto end;
    
    /* multi touch protocol */ 
    for (i = 0; i < MAX_FINGERS; i++) { 	//轮流上报触摸点信息
        if (!finger[i].is_valid) 
            continue;
        
        input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, finger[i].t); 
        input_report_abs(input_dev, ABS_MT_POSITION_X, finger[i].x); 
        input_report_abs(input_dev, ABS_MT_POSITION_Y, finger[i].y); 
        input_mt_sync(input_dev); 		//隔离触摸点
        count++;
    }
    
    /* SYN_REPORT */ 
    input_sync(input_dev);
    
    end: 
    return IRQ_HANDLED; 
}

5）TypeB触摸点信息上报时序

​ 对于 TypeB 设备，发送触摸点信息的时序如下：

ABS_MT_SLOT 0 			//每次上报一个触摸点坐标之前要先使用input_mt_slot函数上报当前触摸点SLOT(触摸点ID)，SLOT由触摸IC提供
ABS_MT_TRACKING_ID 45 	//每个SLOT必须关联一个ABS_MT_TRACKING_ID，通过修改 SLOT关联的 ABS_MT_TRACKING_ID 来完成对触摸点的添加、替换或删除。具体用到input_mt_report_slot_state函数，如果是添加一个新的触摸点，那么此函数的第三个参数active要设置为true linux内核会自动分配一个ABS_MT_TRACKING_ID值，不需要用户去指定具体的ABS_MT_TRACKING_ID值。
ABS_MT_POSITION_X x[0] 	//上报第一个触摸点的X坐标数据，通过 input_report_abs 函数实现，下面同理
ABS_MT_POSITION_Y y[0] 	//上报第一个触摸点的Y坐标数据
ABS_MT_SLOT 1 
ABS_MT_TRACKING_ID 46 
ABS_MT_POSITION_X x[1] 
ABS_MT_POSITION_Y y[1] 
SYN_REPORT				//上报SYN_REPORT事件，通过调用input_sync函数实现

​ 触摸点删除时序：

ABS_MT_TRACKING_ID -1 //调用input_mt_report_slot_state函数，将第三个参数active设置为false
SYN_REPORT			//上报SYN_REPORT事件，通过调用input_sync函数实现

​ TypeB 设备上报触摸点示例代码：

static void ili210x_report_events(struct input_dev *input, const struct touchdata *touchdata)
{
	int i;
	bool touch;
	unsigned int x, y;
	const struct finger *finger;

	for (i = 0; i < MAX_TOUCHES; i++) {		//循环上报所有触摸点
		input_mt_slot(input, i);		//上报ABS_MT_SLOT事件

		finger = &touchdata->finger[i];

		touch = touchdata->status & (1 << i);
		input_mt_report_slot_state(input, MT_TOOL_FINGER, touch);	//上报ABS_MT_TRACKING_ID事件
		if (touch) {
			x = finger->x_low | (finger->x_high << 8);
			y = finger->y_low | (finger->y_high << 8);

			input_report_abs(input, ABS_MT_POSITION_X, x);	//上报x坐标
			input_report_abs(input, ABS_MT_POSITION_Y, y);	//上报y坐标
		}
	}

	input_mt_report_pointer_emulation(input, false);
	input_sync(input);		//上报SYN_REPORT事件，通过调用input_sync函数实现
}

6）MT其他事件

  • ABS_MT_TOUCH_MAJOR 和 ABS_MT_WIDTH_MAJOR：上报触摸面积信息。
  • ABS_MT_TOOL_TYPE：上报触摸工具类型。目前协议支持 MT_TOOL_FINGER、 MT_TOOL_PEN 和 MT_TOOL_PALM 这三种触摸设备类型。

2、多点触摸使用的API

1）input_mt_init_slots函数

​ input_mt_init_slots 函数用于初始化 MT 的输入 slots，编写 MT 驱动的时候必须先调用此函数初始化 slots，此函数定义在文件 drivers/input/input-mt.c 中，函数原型如下所示：

int input_mt_init_slots( struct input_dev *dev, unsigned int num_slots, unsigned int flags)

​ dev：MT 设备对应的 input_dev。

​ num_slots：设备要使用的 SLOT 数量，也就是触摸点的数量。

​ flag：其他一些 flags 信息，可设置的 flags 如下所示：

#define INPUT_MT_POINTER 0x0001 /* pointer device, e.g. trackpad */ 
#define INPUT_MT_DIRECT 0x0002 /* direct device, e.g. touchscreen */ 
#define INPUT_MT_DROP_UNUSED 0x0004 /* drop contacts not seen in frame */ 
#define INPUT_MT_TRACK 0x0008 /* use in-kernel tracking */ 
#define INPUT_MT_SEMI_MT 0x0010 /* semi-mt device, finger count handled manually */

​ 可以采用或运算来同时设置多个 flags 标识。

​ 返回值：0，成功 ；负值，失败。

2）input_mt_slot函数

​ 此函数用于 Type B 类型，此函数用于产生 ABS_MT_SLOT 事件，告诉内核当前上报的是哪个触摸点的坐标数据，此函数定义在文件 include/linux/input/mt.h 中，函数原型如下所示：

void input_mt_slot(struct input_dev *dev, int slot)

​ dev：MT 设备对应的 input_dev。

​ slot：当前发送的是哪个 slot 的坐标信息，也就是哪个触摸点。

3）input_mt_report_slot_state函数

​ 此函数用于 Type B 类型，用于产生 ABS_MT_TRACKING_ID 和 ABS_MT_TOOL_TYPE， 此函数定义在文件 drivers/input/input-mt.c 中，此函数原型如下所示：

void input_mt_report_slot_state( struct input_dev *dev, unsigned int tool_type, bool active)

​ dev：MT 设备对应的 input_dev。

​ tool_type：触摸类型，可以选择 MT_TOOL_FINGER(手指)、 MT_TOOL_PEN(笔) 或 MT_TOOL_PALM(手掌)，对于多点电容触摸屏来说一般都是手指。

​ active：true，连续触摸，input 子系统内核会自动分配一个 ABS_MT_TRACKING_ID 给 slot。false，触摸点抬起，表示某个触摸点无效了，input 子系统内核会分配一个 -1 给 slot。

4）input_report_abs函数

​ Type A 和 Type B 类型都使用此函数上报触摸点坐标信息，通过 ABS_MT_POSITION_X 和 ABS_MT_POSITION_Y 事件实现 X 和 Y 轴坐标信息上报。此函数定义在文件 include/linux/input.h 中，函数原型如下所示：

void input_report_abs( struct input_dev *dev, unsigned int code, int value) 函

​ dev：MT 设备对应的 input_dev。

​ code：要上报的是什么数据，可以设置为 ABS_MT_POSITION_X 或 ABS_MT_POSITION_Y。

​ value：具体的 X 轴或 Y 轴坐标数据值。

5）input_mt_report_pointer_emulation函数

​ 如果追踪到的触摸点数量多于当前上报的数量，驱动程序使用 BTN_TOOL_TAP 事件来通知用户空间当前追踪到的触摸点总数量，然后调用 input_mt_report_pointer_emulation 函数将 use_count 参数设置为 false。否则的话将 use_count 参数设置为 true，表示当前的触摸点数量 (此函数会获取到具体的触摸点数量，不需要用户给出 )，此函数定 义在文件 drivers/input/input-mt.c 中，函数原型如下：

void input_mt_report_pointer_emulation(struct input_dev *dev, bool use_count)

​ dev：MT 设备对应的 input_dev。

​ use_count true：true，有效的触摸点数量 false，追踪到的触摸点数量多于当前上报的数量。

3、触摸驱动框架

1）IIC驱动框架

/* 设备树匹配表 */ 
static const struct i2c_device_id xxx_ts_id[] = { 
    { "xxx", 0, }, 
    { /* sentinel */ }
};

/* 设备树匹配表 */ 
static const struct of_device_id xxx_of_match[] = { 
    { .compatible = "xxx", }, 
    { /* sentinel */ } 
};

/* i2c驱动结构体 */ 
static struct i2c_driver ft5x06_ts_driver = { 
    .driver = { 
        .owner = THIS_MODULE, 
        .name = "edt_ft5x06", 
        .of_match_table = of_match_ptr(xxx_of_match), 
    }, 
    .id_table = xxx_ts_id, 
    .probe = xxx_ts_probe,
    .remove = xxx_ts_remove, 
};

/* 入口函数 */
static int __init xxx_init(void) 
{ 
    int ret = 0; 
    ret = i2c_add_driver(&xxx_ts_driver); 
    return ret; 
}

/* 出口函数 */
static void __exit xxx_exit(void) 
{ 
    i2c_del_driver(&ft5x06_ts_driver); 
}

module_init(xxx_init); 
module_exit(xxx_exit); 
MODULE_LICENSE("GPL"); 
MODULE_AUTHOR("lzk");

2）probe函数（初始化触摸IC、Input子系统）

int gt9147_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    u8 data, ret;

    gt9147.client = client;

 	/* 1，获取设备树中的中断和复位引脚 */
	gt9147.irq_pin = of_get_named_gpio(client->dev.of_node, "interrupt-gpios", 0);
	gt9147.reset_pin = of_get_named_gpio(client->dev.of_node, "reset-gpios", 0);

	/* 2，复位GT9147 */
	ret = gt9147_ts_reset(client, &gt9147);
	if(ret < 0) {
		goto fail;
    }

    /* 3，初始化GT9147 */
    data = 0x02;
    gt9147_write_regs(&gt9147, GT_CTRL_REG, &data, 1); /* 软复位 */
    mdelay(100);
    data = 0x0;
    gt9147_write_regs(&gt9147, GT_CTRL_REG, &data, 1); /* 停止软复位 */
    mdelay(100);

    /* 4,初始化GT9147，烧写固件 */
    gt9147_read_regs(&gt9147, GT_CFGS_REG, &data, 1);
    printk("GT9147 ID =%#X\r\n", data);
    if(data <  GT9147_CT[0]) {
       gt9147_send_cfg(&gt9147, 0);
    }

    /* 5，input设备注册 */
	gt9147.input = devm_input_allocate_device(&client->dev);
	if (!gt9147.input) {
		ret = -ENOMEM;
		goto fail;
	}
	gt9147.input->name = client->name;
	gt9147.input->id.bustype = BUS_I2C;
	gt9147.input->dev.parent = &client->dev;

	__set_bit(EV_KEY, gt9147.input->evbit);
	__set_bit(EV_ABS, gt9147.input->evbit);
	__set_bit(BTN_TOUCH, gt9147.input->keybit);

	input_set_abs_params(gt9147.input, ABS_X, 0, 800, 0, 0);
	input_set_abs_params(gt9147.input, ABS_Y, 0, 480, 0, 0);
	input_set_abs_params(gt9147.input, ABS_MT_POSITION_X,0, 800, 0, 0);
	input_set_abs_params(gt9147.input, ABS_MT_POSITION_Y,0, 480, 0, 0);	     
	ret = input_mt_init_slots(gt9147.input, MAX_SUPPORT_POINTS, 0);
	if (ret) {
		goto fail;
	}

	ret = input_register_device(gt9147.input);
	if (ret)
		goto fail;

    /* 6，最后初始化中断 */
	ret = gt9147_ts_irq(client, &gt9147);
	if(ret < 0) {
		goto fail;
	}
    return 0;

fail:
	return ret;
}

3）中断初始化函数

/*
 * @description     : GT9147中断初始化
 * @param - client 	: 要操作的i2c
 * @param - multidev: 自定义的multitouch设备
 * @return          : 0，成功;其他负值,失败
 */
static int gt9147_ts_irq(struct i2c_client *client, struct gt9147_dev *dev)
{
	int ret = 0;

	/* 2，申请中断,client->irq就是IO中断， */
	ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
					gt9147_irq_handler, IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
					client->name, &gt9147);
	if (ret) {
		dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
		return ret;
	}

	return 0;
}

4）中断回调函数（上报坐标点）

static irqreturn_t gt9147_irq_handler(int irq, void *dev_id)
{
    int touch_num = 0;
    int input_x, input_y;
    int id = 0;
    int ret = 0;
    u8 data;
    u8 touch_data[5];
    struct gt9147_dev *dev = dev_id;

    ret = gt9147_read_regs(dev, GT_GSTID_REG, &data, 1);
    if (data == 0x00)  {     /* 没有触摸数据，直接返回 */
        goto fail;
    } else {                 /* 统计触摸点数据 */
        touch_num = data & 0x0f;
    }

    /* 由于GT9147没有硬件检测每个触摸点按下和抬起，因此每个触摸点的抬起和按
     * 下不好处理，尝试过一些方法，但是效果都不好，因此这里暂时使用单点触摸 
     */
    if(touch_num) {         /* 单点触摸按下 */
        gt9147_read_regs(dev, GT_TP1_REG, touch_data, 5);
        id = touch_data[0] & 0x0F;
        if(id == 0) {
            input_x  = touch_data[1] | (touch_data[2] << 8);
            input_y  = touch_data[3] | (touch_data[4] << 8);

            input_mt_slot(dev->input, id);
		    input_mt_report_slot_state(dev->input, MT_TOOL_FINGER, true);
		    input_report_abs(dev->input, ABS_MT_POSITION_X, input_x);
		    input_report_abs(dev->input, ABS_MT_POSITION_Y, input_y);
        }
    } else if(touch_num == 0){                /* 单点触摸释放 */
        input_mt_slot(dev->input, id);
        input_mt_report_slot_state(dev->input, MT_TOOL_FINGER, false);
    }

	input_mt_report_pointer_emulation(dev->input, true);
    input_sync(dev->input);

    data = 0x00;                /* 向0X814E寄存器写0 */
    gt9147_write_regs(dev, GT_GSTID_REG, &data, 1);

fail:
	return IRQ_HANDLED;
}

5）IIC数据处理函数

/*
 * @description	: 从GT9147读取多个寄存器数据
 * @param - dev:  GT9147设备
 * @param - reg:  要读取的寄存器首地址
 * @param - buf:  读取到的数据
 * @param - len:  要读取的数据长度
 * @return 		: 操作结果
 */
static int gt9147_read_regs(struct gt9147_dev *dev, u16 reg, u8 *buf, int len)
{
	int ret;
    u8 regdata[2];
	struct i2c_msg msg[2];
	struct i2c_client *client = (struct i2c_client *)dev->client;
    
    /* GT9147寄存器长度为2个字节 */
    regdata[0] = reg >> 8;
    regdata[1] = reg & 0xFF;

	/* msg[0]为发送要读取的首地址 */
	msg[0].addr = client->addr;			/* ft5x06地址 */
	msg[0].flags = !I2C_M_RD;			/* 标记为发送数据 */
	msg[0].buf = &regdata[0];			/* 读取的首地址 */
	msg[0].len = 2;						/* reg长度*/

	/* msg[1]读取数据 */
	msg[1].addr = client->addr;			/* ft5x06地址 */
	msg[1].flags = I2C_M_RD;			/* 标记为读取数据*/
	msg[1].buf = buf;					/* 读取数据缓冲区 */
	msg[1].len = len;					/* 要读取的数据长度*/

	ret = i2c_transfer(client->adapter, msg, 2);
	if(ret == 2) {
		ret = 0;
	} else {
		ret = -EREMOTEIO;
	}
	return ret;
}

/*
 * @description	: 向GT9147多个寄存器写入数据
 * @param - dev:  GT9147设备
 * @param - reg:  要写入的寄存器首地址
 * @param - val:  要写入的数据缓冲区
 * @param - len:  要写入的数据长度
 * @return 	  :   操作结果
 */
static s32 gt9147_write_regs(struct gt9147_dev *dev, u16 reg, u8 *buf, u8 len)
{
	u8 b[256];
	struct i2c_msg msg;
	struct i2c_client *client = (struct i2c_client *)dev->client;
	
	b[0] = reg >> 8;			/* 寄存器首地址低8位 */
    b[1] = reg & 0XFF;			/* 寄存器首地址高8位 */
	memcpy(&b[2],buf,len);		/* 将要写入的数据拷贝到数组b里面 */

	msg.addr = client->addr;	/* gt9147地址 */
	msg.flags = 0;				/* 标记为写数据 */

	msg.buf = b;				/* 要写入的数据缓冲区 */
	msg.len = len + 2;			/* 要写入的数据长度 */

	return i2c_transfer(client->adapter, &msg, 1);
}

6）复位触摸IC函数

/*
 * @description     : 复位GT9147
 * @param - client 	: 要操作的i2c
 * @param - multidev: 自定义的multitouch设备
 * @return          : 0，成功;其他负值,失败
 */
static int gt9147_ts_reset(struct i2c_client *client, struct gt9147_dev *dev)
{
	int ret = 0;

    /* 申请复位IO*/
	if (gpio_is_valid(dev->reset_pin)) {  		
		/* 申请复位IO，并且默认输出高电平 */
		ret = devm_gpio_request_one(&client->dev,	
					dev->reset_pin, GPIOF_OUT_INIT_HIGH,
					"gt9147 reset");
		if (ret) {
			return ret;
		}
	}

    /* 申请中断IO*/
	if (gpio_is_valid(dev->irq_pin)) {  		
		/* 申请复位IO，并且默认输出高电平 */
		ret = devm_gpio_request_one(&client->dev,	
					dev->irq_pin, GPIOF_OUT_INIT_HIGH,
					"gt9147 int");
		if (ret) {
			return ret;
		}
	}

    /* 4、初始化GT9147，要严格按照GT9147时序要求 */
    gpio_set_value(dev->reset_pin, 0); /* 复位GT9147 */
    msleep(10);
    gpio_set_value(dev->reset_pin, 1); /* 停止复位GT9147 */
    msleep(10);
    gpio_set_value(dev->irq_pin, 0);    /* 拉低INT引脚 */
    msleep(50);
    gpio_direction_input(dev->irq_pin); /* INT引脚设置为输入 */

	return 0;
}
上一篇：P1678 烦恼的高考志愿


下一篇：javascript将负数转为正数的方法