10.2多点触摸屏驱动

最新推荐文章于 2024-04-13 20:06:11 发布
最新推荐文章于 2024-04-13 20:06:11 发布
阅读量1.2k 收藏 13
点赞数 22
分类专栏： linux驱动开发 文章标签： linux 驱动开发 嵌入式硬件 arm开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lf282481431/article/details/135025602
版权

多点电容触摸（MT）协议

多点电容触摸（MT）协议是 input 子系统的一部分， MT 协议被分为两种类型，分别是 Type A 和 Type B ：

  • Type A ：适用于触摸点不能被区分或者追踪的设备（即硬件上没有触摸 ID）
  • Type B ：适用于有硬件追踪并能区分触摸点的触摸设备
    触摸点的信息通过一系列的 ABS_MT_* 事件上报给 linux 内核，常用的 ABS_MT 事件有：
  • ABS_MT_SLOT ：表示后面上报的是相应 slot 的触摸信息，用于分割 Type B 类型触摸点
  • ABS_MT_TRACKING_ID ：上报触摸 ID 事件， slot 从松开到按下时系统自动分配 TRACKING_ID
  • ABS_MT_POSITION_X ：上报绝对坐标X
  • ABS_MT_POSITION_Y ：上报绝对坐标Y
  • SYN_MT_REPORT：表示前面已经上报完一个触摸点数据，用于分割 Type A 类型触摸点
    对于 Type B 类型采用 ABS_MT_SLOT 分割触摸点，并用 ABS_MT_TRACKING_ID 上报触摸点 ID，对于 Type A 类型则采用 SYN_MT_REPORT 事件来分割触摸点。

多点触摸所常用 API

/* 初始化 slots
 * dev ：MT 设备对应的 input_dev
 * num_slots ：设备要使用的 SLOT 数量，也就是触摸点的数量
 * flags :其他一些 flags 信息，如 INPUT_MT_POINTER 表示触摸板设备，INPUT_MT_DIRECT 表示触摸屏设备
 **/
int input_mt_init_slots(struct input_dev *dev, unsigned int num_slots, unsigned int flags)

/* 通过 slot 上报 ABS_MT_SLOT 事件
 * dev ：MT 设备对应的 input_dev
 * slot ：指定产生 ABS_MT_SLOT 事件 slot
 **/
void input_mt_slot(struct input_dev *dev, int slot)

/* 上报触摸点的状态，用于产生 ABS_MT_TRACKING_ID 和 ABS_MT_TOOL_TYPE 事件
 * dev ：MT 设备对应的 input_dev
 * tool_type ：触摸类型， MT_TOOL_FINGER (手指)、 MT_TOOL_PEN (笔)、 MT_TOOL_PALM (手掌)
 * active ：触摸状态， true 表示按下，如果是第一次按下系统会为其分配一个 ID ，false 表示抬起
 **/
bool input_mt_report_slot_state(struct input_dev *dev, unsigned int tool_type, bool active)

/* 上报绝对坐标事件
 * dev ：MT 设备对应的 input_dev
 * code ：事件类型，ABS_MT_POSITION_X 或 ABS_MT_POSITION_Y 分别表示 X 轴和 Y 轴，
 * value ： X 轴或 Y 轴坐标值
 **/
void input_report_abs(struct input_dev *dev,unsigned int code, int value)

/* 单点触摸模拟
 * dev ：MT 设备对应的 input_dev
 * use_count ：为 true 则要上报触摸点数
 **/
void input_mt_report_pointer_emulation(struct input_dev *dev, bool use_count)

/* 用于产生 SYN_MT_REPORT 事件
 * dev ：MT 设备对应的 input_dev
 **/
void input_mt_sync(struct input_dev *dev)

/* 上报触摸坐标
 * input ：MT 设备对应的 input_dev
 * prop ：prop触摸屏特性
 * x,y ：触摸坐标
 * multitouch ：是否是多点触摸，true表示多点触摸
 **/
void touchscreen_report_pos(struct input_dev *input, const struct touchscreen_properties *prop, unsigned int x, unsigned int y, bool multitouch)

/* 根据设备树配置初始化触摸屏特性，根据input对象absbit的设置完成对absinfo的配置
 * input ：MT 设备对应的 input_dev
 * multitouch ：是否是多点触摸，true表示多点触摸
 * prop ：返回触摸屏特性
 **/
void touchscreen_parse_properties(struct input_dev *input, bool multitouch, struct touchscreen_properties *prop)

上报触摸事件

Type A 上报顺序：

1. ABS_MT_POSITION_X        通过 ABS_MT_POSITION_X 上报第一个触摸点的 X 坐标数据，input_report_abs
2. ABS_MT_POSITION_Y        通过 ABS_MT_POSITION_Y 上报第一个触摸点的 Y 坐标数据，input_report_abs
3. SYN_MT_REPORT            上报 SYN_MT_REPORT 事件，input_mt_sync
4. ABS_MT_POSITION_X        通过 ABS_MT_POSITION_X 上报第二个触摸点的 X 坐标数据
5. ABS_MT_POSITION_Y        通过 ABS_MT_POSITION_Y 上报第二个触摸点的 Y 坐标数据
6. SYN_MT_REPORT            上报 SYN_MT_REPORT 事件
......                      继续上报剩余的坐标
7. SYN_REPORT               上报 SYN_REPORT 事件，input_sync

Type B 上报顺序：

1. ABS_MT_SLOT             上报第一个触摸点的 ABS_MT_SLOT 事件，input_mt_slot
2.  ABS_MT_TRACKING_ID     通过 ABS_MT_TRACKING_ID 上报第一个触摸点的 ID，input_mt_report_slot_state
3. ABS_MT_POSITION_X       通过 ABS_MT_POSITION_X 上报第一个触摸点的 X 坐标数据，input_report_abs
4. ABS_MT_POSITION_Y       通过 ABS_MT_POSITION_Y 上报第一个触摸点的 Y 坐标数据，input_report_abs
5. ABS_MT_SLOT             上报第二个触摸点的 ABS_MT_SLOT 事件
6. ABS_MT_TRACKING_ID	   通过 ABS_MT_TRACKING_ID 上报第二个触摸点的 ID
7. ABS_MT_POSITION_X       通过 ABS_MT_POSITION_X 上报第二个触摸点的 X 坐标数据
8. ABS_MT_POSITION_Y       通过 ABS_MT_POSITION_Y 上报第二个触摸点的 Y 坐标数据
......
9. SYN_REPORT             上报 SYN_REPORT 事件，input_sync

移植 tslib

tslib 是一个开源的用于操作触摸屏的库，它可以简化触摸屏编程，同时也集成了一些触摸屏测试工具，其移植过程如下：

基于 buildroot 移植

buildroot中集成了tslib，在编译时选择其即可

make menuconfig
-> Target packages 
	-> Libraries 
		-> Hardware handling 
			-> [*] tslib

基于源码移植

  1. 解压 tslib ，并进入源码目录
tar -vxf tslib-1.21.tar.xz
cd tslib-1.21/
  1. 配置 tslib
#--host=arm-none-linux-gnueabihf编译器前缀
#--prefix=/安装到目标机的目录
./configure --host=arm-none-linux-gnueabihf --prefix=/
  1. 编译 tslib
make
  1. 安装 tslib
#会在当前目录下创建一个tmp目录，并将此目录作为目标机的跟目录进行安装
make install DESTDIR=$PWD/tmp
  1. 将安装后得到的头文件和库文件拷贝到工具链中（如果不基于 tslib 开发应用程序可以忽略此步骤）
#/usr/local/arm/gcc-arm-9.2-2019.12-x86_64-arm-none-linux-gnueabihf/arm-none-linux-gnueabihf/libc/usr/include是工具链头文件路径
cp ./tmp/include/* /usr/local/arm/gcc-arm-9.2-2019.12-x86_64-arm-none-linux-gnueabihf/arm-none-linux-gnueabihf/libc/usr/include
#/usr/local/arm/gcc-arm-9.2-2019.12-x86_64-arm-none-linux-gnueabihf/arm-none-linux-gnueabihf/libc/usr/lib是工具链库文件路径
cp -d ./tmp/lib/*so* /usr/local/arm/gcc-arm-9.2-2019.12-x86_64-arm-none-linux-gnueabihf/arm-none-linux-gnueabihf/libc/usr/lib
  1. 将安装后得到的文件拷贝到目标板跟文件系统中
#../../../../rootfs/是nfs根文件系统目录
cp -r tmp/* ../../../../rootfs/

基于 tslib 开发应用程序

  1. 使用 ts_setup 打开触摸屏设备，并初始化 tslib
  2. 使用 ioctl(int ts_fd(struct tsdev *ts), EVIOCGABS(ABS_MT_SLOT), struct input_absinfo *slot) 获取触摸屏的 slot 信息，并计算触摸点数
  3. 使用 ts_read_mt 读取触摸屏数据
  4. 最后通过 ts_close 关闭触摸屏设备

tslib 常用函数

//ts_sample结构体
struct ts_sample {
	//X 坐标
	int x;
	//Y 坐标
	int y;
	//按压力大小
	unsigned int pressure;
	//时间
	struct timeval tv;
};
//ts_sample_mt结构体
struct ts_sample_mt {
	//X 坐标
	int x; 
	//Y 坐标
	int y; 
	//按压力大小
	unsigned int pressure;
	//触摸点 slot
	int slot;
	//ID
	int tracking_id;
	int tool_type;
	int tool_x;
	int tool_y;
	unsigned int touch_major;
	unsigned int width_major;
	unsigned int touch_minor;
	unsigned int width_minor;
	int orientation;
	int distance;
	int blob_id;
	//时间
	struct timeval tv;
	//BTN_TOUCH 的状态
	short pen_down;
	//此次样本是否有效标志 触摸点数据是否发生更新
	short valid;
};

/* 打开触摸屏设备，并初始化 tslib
 * dev_name 触摸设备名称，为NULL则会在系统中搜索
 * nonblock 是否阻塞
 * 成功返回tslib设备句柄
 **/
struct tsdev *ts_setup(const char *dev_name, int nonblock)

/* 读取多点触摸屏数据
 * ts tslib设备句柄
 * samp 指向一个struct ts_sample_mt *对象，用于返回触摸坐标
 * nr 表示采样次数，采样值依次存入samp[0][0] samp[0][1] ... samp[0][max_slots] samp[1][0] samp[1][1] ...
 *    samp[1][max_slots] ... 中
 * 成功返回实际采样次数
 **/
int ts_read_mt(struct tsdev *ts, struct ts_sample_mt **samp, int max_slots, int nr)

/* 读取单点触摸屏数据
 * ts tslib设备句柄
 * samp：指向一个 struct ts_sample 对象，用于返回触摸坐标
 *  nr ：表示采样次数。
 * 成功返回实际采样次数
 **/
int ts_read(struct tsdev *ts, struct ts_sample *samp, int nr)

/* 关闭触摸屏设备，并释放tslib资源
 * ts tslib设备句柄
 * 成功返回0
 **/
int ts_close(struct tsdev *ts)

编写GT1151驱动

硬件原理图

在这里插入图片描述
在这里插入图片描述

GT1151寄存器简介

配置信息：
在这里插入图片描述
其中配置信息的byte1~4表示触摸屏尺寸：
在这里插入图片描述
产品ID：
在这里插入图片描述触摸坐标：
虽然一共有10组触摸点坐标寄存器组，但是它最多支持同时跟踪5个触摸点
在这里插入图片描述

驱动代码编写

设备树编写

在顶层设备树中引用i2c2节点，并加入如下内容：

&i2c2 {
	pinctrl-names = "default", "sleep";
	pinctrl-0 = <&i2c2_pins_a>;
	pinctrl-1 = <&i2c2_pins_sleep_a>;
	status = "okay";

	gt91xx@14 {
		compatible = "alientek,gt91xx";
		reg = <0x14>;
		x-size = <800>;
		y-size = <480>;
		reset-gpios = <&gpioh 15 GPIO_ACTIVE_LOW>;
		irq-gpios = <&gpioi 1 GPIO_ACTIVE_LOW>;
		interrupt-parent = <&gpioi>;
		interrupts = <1 IRQ_TYPE_EDGE_FALLING>;
	};
};

在 stm32mp15-pinctrl.dtsi 的 &pinctrl 节点中修改 i2c2 的引脚配置为如下内容

	i2c2_pins_a: i2c2-0 {
		pins {
			pinmux = <STM32_PINMUX('H', 4, AF4)>, /* I2C2_SCL */
				 <STM32_PINMUX('H', 5, AF4)>; /* I2C2_SDA */
			bias-disable;
			drive-open-drain;
			slew-rate = <0>;
		};
	};

	i2c2_pins_sleep_a: i2c2-1 {
		pins {
			pinmux = <STM32_PINMUX('H', 4, ANALOG)>, /* I2C2_SCL */
				 <STM32_PINMUX('H', 5, ANALOG)>; /* I2C2_SDA */
		};
	};

注意：设备树的内容需要根据硬件实际连接进行修改
用make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabihf- dtbs -j8编译设备树，然后用新的.dtb文件启动系统

驱动代码编写

驱动代码主要包括以下几个部分：

  1. 初始化GT1151硬件
  2. 初始化并注册触摸屏输入设备
  3. 注册触摸屏中断
  4. 在触摸屏中断中上报触摸点信息
    完整的驱动代码如下所示：
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/input/touchscreen.h>

#define GT1151_CONFIG_REG		0x8050		//配置寄存器起始
#define GT1151_PRODUCT_ID_REG	0x8140		//产品ID寄存器
#define GT1151Q_GSTID_REG		0x814E		//GT1151Q当前检测到的触摸情况
#define GT1151Q_TP1_REG			0x814F		//第1个触摸点数据地址
#define GT1151Q_TP2_REG			0x8157		//第2个触摸点数据地址
#define GT1151Q_TP3_REG			0x815F		//第3个触摸点数据地址
#define GT1151Q_TP4_REG			0x8167		//第4个触摸点数据地址
#define GT1151Q_TP5_REG			0x816F		//第5个触摸点数据地址

//配置数据长度
#define GT1151_HW_CONFIG_LEN	239
//支持的触摸点数量
#define GTP_MAX_TOUCH			5

typedef struct gt1151 {
	struct input_dev *inputdev;						/* 输入设备句柄 */
	struct i2c_client *client;						/* I2C client句柄 */
	int rst_pin;									/* 复位引脚 */
	int intr_pin;									/* 中断引脚 */
	uint32_t x_range;								/* 触摸屏宽度 */
	uint32_t y_range;								/* 触摸屏高度 */
	uint8_t last_touch_state[GTP_MAX_TOUCH];		/* 缓存各个触摸点上一次的触摸状态 */
	uint8_t write_buffer[512];						/* I2C写数据缓存 */
	uint8_t gt1151_config[GT1151_HW_CONFIG_LEN];	/* gt1151配置数据缓存 */
}gt1151_t;

static const uint16_t tp_reg[GTP_MAX_TOUCH] = {
#if GTP_MAX_TOUCH >= 1
	GT1151Q_TP1_REG,
#endif
#if GTP_MAX_TOUCH >= 2
	GT1151Q_TP2_REG,
#endif
#if GTP_MAX_TOUCH >= 3
	GT1151Q_TP3_REG,
#endif
#if GTP_MAX_TOUCH >= 4
	GT1151Q_TP4_REG,
#endif
#if GTP_MAX_TOUCH >= 5
	GT1151Q_TP5_REG,
#endif
};

static int gt1151_read(gt1151_t *gt1151, uint16_t reg, uint8_t *data, uint16_t lenght)
{
	uint8_t addr[2];
	struct i2c_msg msg[2];

	addr[0] = (uint8_t)((reg >> 8) & 0xFF);
	addr[1] = (uint8_t)(reg & 0xFF);

	//从机地址
	msg[0].addr = gt1151->client->addr;
	//表示写
	msg[0].flags = 0;
	//buf是一个指针,指向了要发送的数据
	msg[0].buf = addr;
	//msg[0].buf的数据长度
	msg[0].len = 2;

	msg[1].addr = gt1151->client->addr;
	//表示读
	msg[1].flags = I2C_M_RD;
	msg[1].buf = data;
	msg[1].len = lenght;
	if(i2c_transfer(gt1151->client->adapter, msg, 2)  == 2)
		return 0;
	else 
		return -EIO;
}

static int gt1151_write(gt1151_t *gt1151, uint16_t reg, uint8_t *data, uint16_t lenght)
{
	struct i2c_msg msg[1];
	
	if(lenght > sizeof(gt1151->write_buffer)-2)
		return -EIO;

	memset(gt1151->write_buffer, 0, sizeof(gt1151->write_buffer));
	//只能用一个msg发送，分多个msg时msg衔接的时候不会等待设备的ACK信号，可能会导致失败
	gt1151->write_buffer[0] = (uint8_t)((reg >> 8) & 0xFF);
	gt1151->write_buffer[1] = (uint8_t)(reg & 0xFF);
	memcpy(&gt1151->write_buffer[2], data, lenght);

	//从机地址
	msg[0].addr = gt1151->client->addr;
	//表示写
	msg[0].flags = 0;
	//buf是一个指针,指向了要发送的数据
	msg[0].buf = gt1151->write_buffer;
	//msg[0].buf的数据长度
	msg[0].len = 2 + lenght;
	if(i2c_transfer(gt1151->client->adapter, msg, 1)  == 1)
		return 0;
	else
		return -EIO;
}

static irqreturn_t gt1151_irq_thread(int irq, void *arg)
{
	uint8_t i;
	uint8_t clr_intr;
	uint8_t touch_number;
	uint8_t phy_id;
	uint16_t x_coordinate;
	uint16_t y_coordinate;
	int32_t result;
	uint8_t buffer[5];
	uint8_t now_touch_state[GTP_MAX_TOUCH];
	gt1151_t *gt1151 = (gt1151_t*)arg;

	//读取触摸状态寄存器
	result = gt1151_read(gt1151, GT1151Q_GSTID_REG, buffer, 1);
	if(result != 0)
	{
		printk("read reg failed\r\n");
		return IRQ_HANDLED;
	}

	//获取触摸点数
	touch_number = buffer[0] & 0x0F;

	//复位当前触摸状态
	memset(now_touch_state, 0, sizeof(now_touch_state));
	//依次处理触摸点
	for(i = 0; (i < touch_number) && (i < GTP_MAX_TOUCH); i++) 
	{
		//读取一个触摸点
		result = gt1151_read(gt1151, tp_reg[i], buffer, 5);
		if(result != 0)
		{
			printk("read reg failed\r\n");
			return IRQ_HANDLED;
		}

		//获取触摸点ID，这里通过物理ID来区分slot
		phy_id = buffer[0] & 0x0F;
		//ID不合法
		if(phy_id >= GTP_MAX_TOUCH)
			continue;

		//获取触摸坐标
		x_coordinate = buffer[1] | (buffer[2] << 8);
		y_coordinate = buffer[3] | (buffer[4] << 8);
		//记录当前触摸点的状态
		now_touch_state[phy_id] = 1;

		//通过第phy_id个slot上报ABS_MT_SLOT事件，表示即将上报第phy_id的触摸信息
		input_mt_slot(gt1151->inputdev, phy_id);
		//上报触摸状态
		input_mt_report_slot_state(gt1151->inputdev, MT_TOOL_FINGER, true);
		//上报触摸坐标
		input_report_abs(gt1151->inputdev, ABS_MT_POSITION_X, x_coordinate);
		input_report_abs(gt1151->inputdev, ABS_MT_POSITION_Y, y_coordinate);
	}

	//处理松开的点
	for(i = 0; i < GTP_MAX_TOUCH; i++)
	{
		//上一次处于按下状态而此次处于松开状态
		if((!now_touch_state[i]) && (gt1151->last_touch_state[i]))
		{
			//触摸ID
			phy_id = i;

			//上报触摸信息
			input_mt_slot(gt1151->inputdev, phy_id);
			input_mt_report_slot_state(gt1151->inputdev, MT_TOOL_FINGER, false);
		}
	}

	//记录此次触摸状态
	memcpy(gt1151->last_touch_state, now_touch_state, sizeof(gt1151->last_touch_state));

	//进行单点触摸模拟，并上报触摸点数
	input_mt_report_pointer_emulation(gt1151->inputdev, true);
	//上报完成，进行事件同步
	input_sync(gt1151->inputdev);

	//清除触摸屏中断标志
	clr_intr = 0x00;
	gt1151_write(gt1151, GT1151Q_GSTID_REG, &clr_intr, 1);

	//返回IRQ_HANDLED，表示中断被成功处理
	return IRQ_HANDLED;
}

static int gt1151_reset(gt1151_t *gt1151)
{
	uint8_t data;

	if(gt1151->client->addr != 0x14)
	{
		printk("address bad\r\n");
		return -EINVAL;
	}

	//进行软件复位
	data = 0x02;
	gt1151_write(gt1151, 0X8040, &data, 1);
	mdelay(100);
	data = 0x0;
	gt1151_write(gt1151, 0X8040, &data, 1);
	mdelay(100);

	return 0;
}

static int32_t gt1151_config(gt1151_t *gt1151)
{
	uint16_t checksum;
	int i;
	int result;
	uint8_t buffer[5];
	uint8_t *config = gt1151->gt1151_config;
	uint16_t cfg_len = GT1151_HW_CONFIG_LEN;

	//读取产品ID
	gt1151_read(gt1151, GT1151_PRODUCT_ID_REG, buffer, 4);
	buffer[4] = '\0';
	printk("gt1151 ID: %s\r\n", (char*)buffer);

	//加载配置数据
	result = gt1151_read(gt1151, GT1151_CONFIG_REG, config, cfg_len);
	if(result != 0)
	{
		printk("load config failed\r\n");
		return result;
	}

	//配置触摸屏尺寸
	config[1] = gt1151->x_range & 0xFF;
	config[2] = gt1151->x_range >> 8;
	config[3] = gt1151->y_range & 0xFF;
	config[4] = gt1151->y_range >> 8;

	//计算和校验
	checksum = 0;
	for (i = 0; i < (cfg_len - 3); i += 2) 
		checksum += ((uint16_t)config[i] << 8) + config[i+1];
	checksum = 0 - checksum;
	config[cfg_len-3] = (uint8_t)(checksum >> 8);
	config[cfg_len-2] = (uint8_t)(checksum & 0xFF);
	config[cfg_len-1] = 0x01;

	//更新配置数据
	return gt1151_write(gt1151, GT1151_CONFIG_REG, config, cfg_len);
}

static int gt1151_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	int result;
	uint32_t irq_flags;
	gt1151_t *gt1151;

	printk("%s\r\n", __FUNCTION__);

	//分配gt1151设备
	gt1151 = devm_kmalloc(&client->dev, sizeof(gt1151_t), GFP_KERNEL);
	if(!gt1151)
	{
		printk("malloc mem failed\r\n");
		return -ENOMEM;
	}
	memset(gt1151, 0, sizeof(gt1151_t));

	//在client中设置驱动私有数据
	client->dev.driver_data = gt1151;

	gt1151->client = client;
	//尺寸默认800*480
	gt1151->x_range = 800;
	gt1151->y_range = 480;

	//获取GPIO号
	gt1151->rst_pin = of_get_named_gpio(client->dev.of_node, "reset-gpios", 0);
	if(gt1151->rst_pin < 0)
	{
		printk("get reset gpio failed\r\n");
		return gt1151->rst_pin;
	}
	gt1151->intr_pin = of_get_named_gpio(client->dev.of_node, "interrupt-gpios", 0);
	if(gt1151->intr_pin < 0)
	{
		printk("get irq gpio failed\r\n");
		return gt1151->intr_pin;
	}

	//申请GPIO
	result = devm_gpio_request(&client->dev, gt1151->rst_pin, "gt1151-reset");
	if(result != 0)
	{
		printk("request reset gpio failed\r\n");
		return result;
	}
	result = devm_gpio_request(&client->dev, gt1151->intr_pin, "gt1151-irq");
	if(result != 0)
	{
		printk("request irq gpio failed\r\n");
		return result;
	}

	//获取尺寸
	of_property_read_u32(client->dev.of_node, "x-size", &gt1151->x_range);
	of_property_read_u32(client->dev.of_node, "y-size", &gt1151->y_range);
	printk("size:%d*%d\r\n", gt1151->x_range, gt1151->y_range);

	//复位gt1151
	result = gt1151_reset(gt1151);
	if(result != 0)
	{
		printk("reset failed\r\n");
		return result;
	}

	//配置gt1151
	result = gt1151_config(gt1151);
	if(result != 0)
	{
		printk("config failed\r\n");
		return result;
	}

	//分配输入设备
	gt1151->inputdev = devm_input_allocate_device(&client->dev);
	if(!gt1151->inputdev)
	{
		printk("alloc input device failed\r\n");
		return -ENOMEM;
	}

	//初始化输入设备
	gt1151->inputdev->name = client->name;
	gt1151->inputdev->id.bustype = BUS_I2C;
	// // input_mt_init_slots 函数的 flags 为 INPUT_MT_DIRECT 会设置此事件
	// __set_bit(EV_KEY, gt1151->inputdev->evbit);
	// // input_set_abs_params 函数会设置此事件
	// __set_bit(EV_ABS, gt1151->inputdev->evbit);
	// // input_mt_init_slots 函数的 flags 为 INPUT_MT_DIRECT 会设置此按键
	// __set_bit(BTN_TOUCH, gt1151->inputdev->keybit);
	//  // input_mt_init_slots 函数的 flags 为 INPUT_MT_DIRECT 会设置此位
	//__set_bit(INPUT_PROP_DIRECT, gt1151->inputdev->propbit);
	input_set_abs_params(gt1151->inputdev, ABS_X, 0, gt1151->x_range, 0, 0);
	input_set_abs_params(gt1151->inputdev, ABS_Y, 0, gt1151->y_range, 0, 0);
	input_set_abs_params(gt1151->inputdev, ABS_MT_POSITION_X, 0, gt1151->x_range, 0, 0);
	input_set_abs_params(gt1151->inputdev, ABS_MT_POSITION_Y, 0, gt1151->y_range, 0, 0);
	// result = input_mt_init_slots(gt1151->inputdev, GTP_MAX_TOUCH, 0);
	//flags为INPUT_MT_DIRECT会设置EV_KEY、BTN_TOUCH事件，并将ABS_MT_POSITION_X和ABS_MT_POSITION_Y拷贝到ABS_X和ABS_Y
	result = input_mt_init_slots(gt1151->inputdev, GTP_MAX_TOUCH, INPUT_MT_DIRECT);
	if(result != 0)
	{
		printk("mt init failed\r\n");
		return result;
	}

	//注册输入设备
	result = input_register_device(gt1151->inputdev);
	if(result != 0)
	{
		printk("input register failed\r\n");
		return result;
	}

	//设置中断引脚为输入
	gpio_direction_input(gt1151->intr_pin);
	//获取中断触发方式
	irq_flags = irq_get_trigger_type(gt1151->client->irq);
	if(irq_flags == IRQF_TRIGGER_NONE)
		irq_flags = IRQF_TRIGGER_FALLING;
	//中断处理过程中暂时关闭此中断
	irq_flags |= IRQF_ONESHOT;
	//注册中断处理函数
	result = devm_request_threaded_irq(&client->dev, client->irq, NULL, gt1151_irq_thread, irq_flags, client->name, gt1151);
	if(result != 0)
	{
		printk("request irq failed\r\n");
		input_unregister_device(gt1151->inputdev);
		return result;
	}

	return 0;
}

static int gt1151_remove(struct i2c_client *client)
{
	gt1151_t *gt1151;

	printk("%s\r\n", __FUNCTION__);

	gt1151 = client->dev.driver_data;
	input_unregister_device(gt1151->inputdev);

	return 0;
}

static const struct i2c_device_id gt1151_id[] = {
	//采用设备树匹配，这里可以为空
	{"atk-gt1151", 0},
	{ /* Sentinel */ }
};

static const struct of_device_id gt1151_of_match[] = {
	{ .compatible = "atk-gt1151"},
	{ /* Sentinel */ }
};

static struct i2c_driver gt1151_driver = {
	.probe = gt1151_probe,
	.remove = gt1151_remove,
	.driver = {
			.owner = THIS_MODULE,
			.name = "gt1151",
			.of_match_table = gt1151_of_match, 
		},
	//I2C驱动的此项参数不能为NULL
	.id_table = gt1151_id, 
};

static int __init gt1151_init(void)
{
	int result;

	printk("%s\r\n", __FUNCTION__);

	result = i2c_add_driver(&gt1151_driver);
	if(result != 0)
	{
		printk("add gt1151 driver failed\r\n");
		return result;
	}
	return 0;
}

static void __exit gt1151_exit(void)
{
	printk("%s\r\n", __FUNCTION__);

	i2c_del_driver(&gt1151_driver);
}

module_init(gt1151_init);
module_exit(gt1151_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("csdn");
MODULE_DESCRIPTION("gt1151 driver");

驱动测试程序编写

驱动测试程序基于tslib进行编写，在编写驱动测试程序前需要完成对tslib的移植，确保编译工具链中有tslib的库文件和头文件，根文件系统中有tslib的库文件，在连接时还需要 -lts 去连接tslib的库文件。驱动测试程序的完整代码如下所示：

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/time.h>
#include <getopt.h>
#include <errno.h>
#include <unistd.h>
#include <linux/input.h>
#include <sys/ioctl.h>
#include "tslib.h"

int main(void)
{
	int i;
	int result;
	int32_t max_slots;
	struct tsdev *ts;
	struct ts_sample_mt *samp_mt[1];
	struct input_absinfo slot;

	//打开触摸屏设备，并初始化tslib
	ts = ts_setup(NULL, 0);
	if(!ts)
	{
		printf("tslib setup failed\r\n");
		return -1;
	}
	//获取触摸屏信息
	if(ioctl(ts_fd(ts), EVIOCGABS(ABS_MT_SLOT), &slot) < 0)
	{
		ts_close(ts);
		printf("get device info failed\r\n");
		return -1;
	}
	max_slots = slot.maximum + 1 - slot.minimum;
	//根据触摸点数分配缓存触摸点的内存
	samp_mt[0] = malloc(max_slots*sizeof(struct ts_sample_mt));
	if(!samp_mt[0])
	{
		ts_close(ts);
		printf("alloc memory failed\r\n");
		return -1;
	}
	
	while(1)
	{
		result = ts_read_mt(ts, samp_mt, max_slots, 1);
		if (result < 0) {
			printf("ts_read_mt err\n");
			ts_close(ts);
			free(samp_mt[0]);
			return -1;
		}
		
		for (i = 0; i < max_slots; i++)
		{
			if (samp_mt[0][i].valid)
			{
				printf("slot %d\tid=%d\tx=%d\ty=%d\r\n",
				samp_mt[0][i].slot, samp_mt[0][i].tracking_id, samp_mt[0][i].x, samp_mt[0][i].y);
			}
		}
	}
}

上机测试

  1. 根据硬件原理图对设备树进行修改，然后用命令make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabihf- dtbs -j8编译设备树，并用新的设备树启动目标板。
  2. 从这里下载代码并进行编译，然后将编译出来的.ko文件和.out文件拷贝到目标板根文件系统的root目录中
  3. 执行命令insmod gt1151.ko加载触摸屏驱动
    在这里插入图片描述
  4. 执行命令./tslib_app.out运行测试程序，此时用手指触摸触摸屏，便可看到输出的触摸点信息在这里插入图片描述
lf282481431
关注
  • 22
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下的触摸屏驱动
weiqing的专栏
12-17 1万+
版权所有，转载请说明转自 http://my.csdn.net/weiqing1981127   一．触摸屏理论概述 对于触摸屏驱动，我们主要需要掌握触摸屏驱动代码和应用层测试代码。下面讲的是基于Mini2440的触摸屏驱动，现在的驱动我们都将设备和驱动分离，挂在平台设备总线上，让设备和驱动去匹配。而我们在linu2.6.32.2内核版本中的触摸屏驱动仍然没有将设备和驱动分离，这样就不存在匹
触摸屏驱动开发——转载
gooogleman#foxmail.com
03-14 6094
说明：本文来自网络，但是没有署名作者，所以我也不知道是谁的，如果原作者看到，请通知我，我会给标明作者触摸屏驱动开发1.触摸屏驱动程序的模型1.1 分层触摸屏驱动层序结构本触摸屏驱动采用那个分层驱动程序结构，其驱动模型如下图所示，这种结构将驱动程序代码区分为上层模型设备驱动层(MDD),下层是依赖平台的驱动层(PDD)。其中MDD层通常无需修改就可以直接使用，改部分提供面向GWES的
触摸驱动
rn2sw的博客
08-03 372
触摸的信息，是触摸屏这样的触摸设备向 input core 上报 MT 消息传递的。 这些 MT消息，可以通过 设备文件的接口，被应用程序读取到。 将 multi-touch-protocol.txt 文档翻译了一下，有些地方感觉理解得不太正确，还请指正。 可以在内核目录中找到这个文件：Documentation/input/multi-touch-protocol.txt ------------------------------------------------------------------
Windows多点触摸USB协议_多点触摸HID报文
04-20
用于Windows触摸和基于笔的计算机的数字转换器驱动说明,触摸屏、多点触摸的USB协议，设备描述符，HID报文说明
联想触摸驱动
03-29
联想触摸驱动
基础电子中的可支持10.2英寸触摸屏的电容式触控IC
11-11
苏州瀚瑞微电子有限公司日前开发出了能支持到10.2英寸触摸屏的电容式触控IC，从而第一次使得上网本、数码相框、便携式DVD、广告机、车载GPS导航仪、MID和PMP等便携式设备也能采用触摸屏。该公司市场主任钟刚表示，...
MX250显卡驱动+cuda10.2+cudnn10.2
09-01
总之，MX250显卡驱动、CUDA 10.2和cuDNN 10.2的组合为用户提供了在轻量级设备上进行高效计算和深度学习的可能。对于那些需要在移动设备上进行轻度AI任务的开发者和研究人员而言，这是一个非常实用的解决方案。
ojdbc14-10.2.0.5.0.jar驱动.rar
02-24
ojdbc14-10.2.0.5.0.jar驱动是一款专为Oracle数据库设计的Java JDBC驱动程序，主要用于帮助Java应用程序与Oracle数据库进行通信。Oracle JDBC驱动分为多个版本，其中ojdbc14是针对JDBC 3.0规范的一个版本，适用于...
Oracle驱动10.2.0.3.0
03-09
下载的时候需吧，jar后边的多余的名字删掉
oracle 10.2.0.4安装包 windows
06-10
oracle 10.2.0.4安装包 windows
触摸屏驱动Touchkit（win7专用版）
11-02
本驱动支持X86和X64位XP/WIN7系统，理论上WIN10还可以用，直接运行setup.exe安装程序安装即可！安装过程中会让你选择，到时候你可以根据需要选择驱动，一般是选择安装PS/2接口界面驱动
win7触摸屏驱动
04-03
这个是win7的触摸屏驱动程序,下载后回复短信,会有人指导你们安装.
华硕笔记本触摸板驱动
12-24
华硕笔记本触摸板驱动下载
万能触屏驱动
02-17
万能触屏驱动
GT1151.zip MTK6765/62 汇顶gt1151 touchpanel 的sample code
09-02
MTK 平台sample code，超级经典，几乎所有TP IC 的driver code都参考此代码来实作去适配MTK 的cpu ， 里面包含有中断，内核线程，休眠唤醒，GPIO, DTS 内核的知识点
Harmony鸿蒙南向外设驱动开发-Touchscreen
最新发布
m0_64420071的博客
04-13 893
Touchscreen驱动用于驱动触摸屏使其正常工作
STM32MP157驱动开发——多点电容触摸屏驱动
weixin_45682654的博客
12-28 2817
Linux下的多点电容屏幕驱动的开发流程。
05_触摸屏驱动
qq_34968572的博客
06-05 1200
一：触摸屏驱动简介 触摸屏驱动采用第二章所讲的“输入子系统”框架，用户根据触摸屏编写设备驱动程序input_dev，输入子系统会调用纯软件部分tsdev.c与之匹配，详细参考：https://blog.csdn.net/qq_34968572/article/details/89875957 二：触摸屏硬件介绍 电阻式触摸屏是一种传感器，它将矩形区域中触摸点（...
电容触摸屏驱动（Linux驱动开发篇）
栋哥修炼日记
02-15 8080
1.简介 电容屏只需要手指轻触即可，而电阻屏是需要手指 给予一定的压力才有反应，而且电容屏不需要校准。 如果要做人机交互设备的开发，多点电容触摸屏基本是不可能绕过去的。 2. 驱动器件 正点原子ATK-7016 这款屏幕其实是由 TFT LCD+触摸屏组合起来的。底下是 LCD 面板，上面是触摸面板，将两个封装到一起就成了带有触摸屏的 LCD 屏幕 电容触摸屏也是需要一个驱动 IC的，驱动 IC 一般会提供一个 I2C 接口给主控制器主控制器可以通过 I2C 接口来读取驱动 IC里面的触摸坐标数据 A
pytorch10.2
08-21
要在Windows上安装PyTorch 10.2，在Anaconda Prompt中按照以下步骤操作： 1. 创建一个新的PyTorch环境，可以使用以下命令： conda create -n pytorch10.2 python=3.9 2. 激活创建的环境： conda activate pytorch10.2 3. 使用以下命令下载和安装PyTorch： pip install torch==1.9.0+cu102 torchvision==0.10.0+cu102 torchaudio==0.9.0 -f https://download.pytorch.org/whl/torch_stable.html 4. 安装完成后，您可以在Python中进行测试。首先进入Python环境： python 5. 然后导入torch模块并检查CUDA是否可用： import torch torch.cuda.is_available() 这样就可以完成在Windows上安装PyTorch 10.2的过程了。请注意，步骤和命令可能会有所不同，具体取决于您的环境和需求。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [CUDA（10.2）＋PyTorch安装加配置 详细完整教程](https://blog.csdn.net/Ang_go/article/details/122329715)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值