触摸屏驱动代码

最新推荐文章于 2023-01-23 09:11:29 发布
最新推荐文章于 2023-01-23 09:11:29 发布
阅读量1.3k 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44981258/article/details/107022009
版权
本文主要介绍如何根据触摸屏厂商和型号编写驱动代码，虽然各型号间存在相似性。现在，我们将展示具体的驱动实现代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

根据TP的厂商和型号写相应的代码，不过大致都是差不多的，话不多说。
来吧！展示！上驱动代码：

/* drivers/input/touchscreen/gt9x.c*/
#include <linux/regulator/consumer.h>
#include "gt9xx.h"
#include <linux/of_gpio.h>
#include <linux/irq.h>
#include <linux/module.h>
#include <linux/input/mt.h>
#include <linux/debugfs.h>
#include <linux/interrupt.h>
#include <linux/delay.h>

#define GOODIX_DEV_NAME	"Goodix-CTP"
#define CFG_MAX_TOUCH_POINTS	5
#define GOODIX_COORDS_ARR_SIZE	4
#define MAX_BUTTONS		4

#define CFG_GROUP_LEN(p_cfg_grp)  (sizeof(p_cfg_grp) / sizeof(p_cfg_grp[0]))

#define GOODIX_VTG_MIN_UV	2600000
#define GOODIX_VTG_MAX_UV	3300000
#define GOODIX_I2C_VTG_MIN_UV	1800000
#define GOODIX_I2C_VTG_MAX_UV	1800000
#define GOODIX_VDD_LOAD_MIN_UA	0
#define GOODIX_VDD_LOAD_MAX_UA	10000
#define GOODIX_VIO_LOAD_MIN_UA	0
#define GOODIX_VIO_LOAD_MAX_UA	10000

//#define RESET_DELAY_T3_US	200	/* T3: > 100us */
#define RESET_DELAY_T4		20	/* T4: > 5ms */

#define PHY_BUF_SIZE		32
#define PROP_NAME_SIZE		24

#define GTP_MAX_TOUCH		5
#define GTP_ESD_CHECK_CIRCLE_MS	2000

static void gtp_int_sync(struct goodix_ts_data *ts, int ms);
static int gtp_i2c_test(struct i2c_client *client);
static int goodix_power_off(struct goodix_ts_data *ts);
static int goodix_power_on(struct goodix_ts_data *ts);

#if defined(CONFIG_FB)
static int fb_notifier_callback(struct notifier_block *self,
				unsigned long event, void *data);
static int goodix_ts_suspend(struct device *dev);
static int goodix_ts_resume(struct device *dev);
#elif defined(CONFIG_HAS_EARLYSUSPEND)
static void goodix_ts_early_suspend(struct early_suspend *h);
static void goodix_ts_late_resume(struct early_suspend *h);
#endif

#if GTP_ESD_PROTECT
static struct delayed_work gtp_esd_check_work;
static struct workqueue_struct *gtp_esd_check_workqueue;
static void gtp_esd_check_func(struct work_struct *work);
static int gtp_init_ext_watchdog(struct i2c_client *client);
#endif

enum doze {
   
	DOZE_DISABLED = 0,
	DOZE_ENABLED = 1,
	DOZE_WAKEUP = 2,
};
static enum doze doze_status = DOZE_DISABLED;
static s8 gtp_enter_doze(struct goodix_ts_data *ts);

bool init_done;
static u8 chip_gt9xxs;  /* true if ic is gt9xxs, like gt915s */
u8 grp_cfg_version;
struct i2c_client  *i2c_connect_client;

#define GTP_DEBUGFS_DIR			"ts_debug"
#define GTP_DEBUGFS_FILE_SUSPEND	"suspend"
#define GTP_DEBUGFS_FILE_DATA		"data"
#define GTP_DEBUGFS_FILE_ADDR		"addr"

/*******************************************************
Function:
	Read data from the i2c slave device.
Input:
	client:     i2c device.
	buf[0~1]:   read start address.
	buf[2~len-1]:   read data buffer.
	len:    GTP_ADDR_LENGTH + read bytes count
Output:
	numbers of i2c_msgs to transfer:
		2: succeed, otherwise: failed
*********************************************************/
int gtp_i2c_read(struct i2c_client *client, u8 *buf, int len)
{
   
	struct goodix_ts_data *ts = i2c_get_clientdata(client);
	int ret = -EIO;
	u8 retries;
	struct i2c_msg msgs[2] = {
   
		{
   
			.flags	= !I2C_M_RD,
			.addr	= client->addr,
			.len	= GTP_ADDR_LENGTH,
			.buf	= &buf[0],
		},
		{
   
			.flags	= I2C_M_RD,
			.addr	= client->addr,
			.len	= len - GTP_ADDR_LENGTH,
			.buf	= &buf[GTP_ADDR_LENGTH],
		},
	};

	for (retries = 0; retries < GTP_I2C_RETRY_5; retries++) {
   
		ret = i2c_transfer(client->adapter, msgs, 2);
		if (ret == 2)
			break;
//		dev_err(&client->dev, "I2C retry: %d\n", retries + 1);
	}
	if (retries == GTP_I2C_RETRY_5) {
   
		dev_err(&client->dev, "I2C retry times: %d\n", GTP_I2C_RETRY_5);
		if (ts->pdata->slide_wakeup)
			/* reset chip would quit doze mode */
			if (DOZE_ENABLED == doze_status)
				return ret;

		if (init_done)
			gtp_reset_guitar(ts, 10);
		else
			dev_warn(&client->dev,
				"gtp_reset_guitar exit init_done=%d:\n",
				init_done);
	}
	return ret;
}

/*******************************************************
Function:
	Write data to the i2c slave device.
Input:
	client:     i2c device.
	buf[0~1]:   write start address.
	buf[2~len-1]:   data buffer
	len:    GTP_ADDR_LENGTH + write bytes count
Output:
	numbers of i2c_msgs to transfer:
	1: succeed, otherwise: failed
*********************************************************/
int gtp_i2c_write(struct i2c_client *client, u8 *buf, int len)
{
   
	struct goodix_ts_data *ts = i2c_get_clientdata(client);
	int ret = -EIO;
	u8 retries;
	struct i2c_msg msg = {
   
		.flags = !I2C_M_RD,
		.addr = client->addr,
		.len = len,
		.buf = buf,
	};

	for (retries = 0; retries < GTP_I2C_RETRY_5; retries++) {
   
		ret = i2c_transfer(client->adapter, &msg, 1);
		if (ret == 1)
			break;
		dev_err(&client->dev, "I2C retry: %d\n", retries + 1);
	}
	if ((retries == GTP_I2C_RETRY_5)) {
   
		if (ts->pdata->slide_wakeup)
			if (DOZE_ENABLED == doze_status)
				return ret;

		if (init_done)
			gtp_reset_guitar(ts, 10);
		else
			dev_warn(&client->dev,
				"gtp_reset_guitar exit init_done=%d:\n",
				init_done);
	}
	return ret;
}

/*******************************************************
Function:
	i2c read twice, compare the results
Input:
	client:  i2c device
	addr:    operate address
	rxbuf:   read data to store, if compare successful
	len:     bytes to read
Output:
	FAIL:    read failed
	SUCCESS: read successful
*********************************************************/
int gtp_i2c_read_dbl_check(struct i2c_client *client,
			u16 addr, u8 *rxbuf, int len)
{
   
	u8 buf[16] = {
   0};
	u8 confirm_buf[16] = {
   0};
	u8 retry = 0;

	while (retry++ < GTP_I2C_RETRY_3) {
   
		memset(buf, 0xAA, 16);
		buf[0] = (u8)(addr >> 8);
		buf[1] = (u8)(addr & 0xFF);
		gtp_i2c_read(client, buf, len + 2);

		memset(confirm_buf, 0xAB, 16);
		confirm_buf[0] = (u8)(addr >> 8);
		confirm_buf[1] = (u8)(addr & 0xFF);
		gtp_i2c_read(client, confirm_buf, len + 2);

		if (!memcmp(buf, confirm_buf, len + 2))
			break;
	}
	if (retry < GTP_I2C_RETRY_3) {
   
		memcpy(rxbuf, confirm_buf + 2, len);
		return SUCCESS;
	} else {
   
		dev_err(&client->dev,
			"i2c read 0x%04X, %d bytes, double check failed!",
			addr, len);
		return FAIL;
	}
}

/*******************************************************
Function:
	Send config data.
Input:
	client: i2c device.
Output:
	result of i2c write operation.
	> 0: succeed, otherwise: failed
*********************************************************/
int gtp_send_cfg(struct goodix_ts_data *ts)
{
   
	int ret = 0;
	int retry;

	if (ts->pdata->driver_send_cfg) {
   
		if (ts->fixed_cfg) {
   
			dev_dbg(&ts->client->dev,
				"Ic fixed config, no config sent!");
			ret = 2;
		} else {
   
			for (retry = 0; retry < GTP_I2C_RETRY_5; retry++) {
   
				ret = gtp_i2c_write(ts->client,
					ts->config_data,
					GTP_CONFIG_MAX_LENGTH +
						GTP_ADDR_LENGTH);
				if (ret > 0)
					break;
			}
		}
	}

	return ret;
}

/*******************************************************
Function:
	Disable irq function
Input:
	ts: goodix i2c_client private data
Output:
	None.
*********************************************************/
void gtp_irq_disable(struct goodix_ts_data *ts)
{
   
	unsigned long irqflags;

	spin_lock_irqsave(&ts->irq_lock, irqflags);
	if (!ts->irq_is_disabled) {
   
		ts->irq_is_disabled = true;
		disable_irq_nosync(ts->client->irq);
	}
	spin_unlock_irqrestore(&ts->irq_lock, irqflags);
}

/*******************************************************
Function:
	Enable irq function
Input:
	ts: goodix i2c_client private data
Output:
	None.
*********************************************************/
void gtp_irq_enable(struct goodix_ts_data *ts)
{
   
	unsigned long irqflags = 0;

	spin_lock_irqsave(&ts->irq_lock, irqflags);
	if (ts->irq_is_disabled) {
   
		enable_irq(ts->client->irq);
		ts->irq_is_disabled = false;
	}
	spin_unlock_irqrestore(&ts->irq_lock, irqflags);
}

/*******************************************************
Function:
	Report touch point event
Input:
	ts: goodix i2c_client private data
	id: trackId
	x:  input x coordinate
	y:  input y coordinate
	w:  input pressure
Output:
	None.
*********************************************************/
static void gtp_touch_down(struct goodix_ts_data *ts, int id, int x, int y,
		int w)
{
   
	if (ts->pdata->change_x2y)
		swap(x, y);

	input_mt_slot(ts->input_dev, id);
	input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
	input_report_abs(ts->input_dev, ABS_MT_POSITION_X, x);
	input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, y);
	input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, w);
	input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, w);
}

/*******************************************************
Function:
	Report touch release event
Input:
	ts: goodix i2c_client private data
Output:
	None.
*********************************************************/
static void gtp_touch_up(struct goodix_ts_data *ts, int id)
{
   
	input_mt_slot(ts->input_dev, id);
	input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
}



/*******************************************************
Function:
	Goodix touchscreen work function
Input:
	work: work struct of goodix_workqueue
Output:
	None.
*********************************************************/
static void goodix_ts_work_func(struct work_struct *work)
{
   
	u8 end_cmd[3] = {
    GTP_READ_COOR_ADDR >> 8,
			GTP_READ_COOR_ADDR & 0xFF, 0};
	u8 point_data[2 + 1 + 8 * GTP_MAX_TOUCH + 1] = {
   
			GTP_READ_COOR_ADDR >> 8,
			GTP_READ_COOR_ADDR & 0xFF};
	u8 touch_num = 0;
	u8 finger = 0;
	static u16 pre_touch;
	static u8 pre_key;
	static u8 pre_pen;
	u8 key_value = 0;
	u8 *coor_data = NULL;
	s32 input_x = 0;
	s32 input_y = 0;
	s32 input_w = 0;
	s32 id = 0;
	s32 i = 0;
	int ret = -1;
	struct goodix_ts_data *ts = NULL;
	u8 doze_buf[3] = {
   0x81, 0x4B};

	ts = container_of(work, struct goodix_ts_data, work);
#ifdef CONFIG_GT9XX_TOUCHPANEL_UPDATE
	if (ts->enter_update)
		return;
#endif

	if (ts->pdata->slide_wakeup) {
   
		if (DOZE_ENABLED == doze_status) {
   
			ret = gtp_i2c_read(ts->client, doze_buf, 3);
			if (ret > 0) {
   
				if (doze_buf[2] == 0xAA) {
   
					dev_dbg(&ts->client->dev,
						"Slide(0xAA) To Light up the screen!");
					doze_status = DOZE_WAKEUP;
					input_report_key(
						ts->input_dev, KEY_POWER, 1);
					input_sync(ts->input_dev);
					input_report_key(
						ts->input_dev, KEY_POWER, 0);
					input_sync(ts->input_dev);
					/* clear 0x814B */
					doze_buf[2] = 0x00;
					gtp_i2c_write(ts->client, doze_buf, 3);
				} else if (doze_buf[2] == 0xBB) {
   
					dev_dbg(&ts->client->dev,
						"Slide(0xBB) To Light up the screen!");
					doze_status = DOZE_WAKEUP;
					input_report_key(ts->input_dev,
								KEY_POWER, 1);
					input_sync(ts->input_dev);
					input_report_key(ts->input_dev,
								KEY_POWER, 0);
					input_sync(ts->input_dev);
					/* clear 0x814B*/
					doze_buf[2] = 0x00;
					gtp_i2c_write(ts->client, doze_buf, 3);
				} else if (0xC0 == (doze_buf[2] & 0xC0)) {
   
					dev_dbg(&ts->client->dev,
						"double click to light up the screen!");
					doze_status = DOZE_WAKEUP;
					input_report_key(ts->input_dev,
								KEY_POWER, 1);
					input_sync(ts->input_dev);
					input_report_key(ts->input_dev,
								KEY_POWER, 0);
					input_sync(ts->input_dev);
					/* clear 0x814B */
					doze_buf[2] = 0x00;
					gtp_i2c_write(ts->client, doze_buf, 3);
				} else {
   
					gtp_enter_doze(ts);
				}
			}
			if (ts->use_irq)
				gtp_irq_enable(ts);

			return;
		}
	}

	ret = gtp_i2c_read(ts->client, point_data, 12);
	if (ret < 0) {
   
		dev_err(&ts->client->dev,
				"I2C transfer error. errno:%d\n ", ret);
		goto exit_work_func;
	}

	finger = point_data[GTP_ADDR_LENGTH];
	if ((finger & 0x80) == 0)
		goto exit_work_func;

	touch_num = finger & 0x0f;
	if (touch_num > GTP_MAX_TOUCH)
		goto exit_work_func;

	if (touch_num > 1) {
   
		u8 buf[8 * GTP_MAX_TOUCH] = {
    (GTP_READ_COOR_ADDR + 10) >> 8,
				(GTP_READ_COOR_ADDR + 10) & 0xff };

		ret = gtp_i2c_read(ts->client, buf,
				2 + 8 * (touch_num - 1));
		memcpy(&point_data[12], &buf[2], 8 * (touch_num - 1));
	}


	key_value = point_data[3 + 8 * touch_num];

	if (key_value || pre_key) {
   
		for (i = 0; i < ts->pdata->num_button; i++) {
   
			input_report_key(ts->input_dev,
				ts->pdata->button_map[i],
				key_value & (0x01<<i));
		}
		touch_num = 0;
		pre_touch = 0;
	}

	pre_key = key_value;

	if (ts->pdata->with_pen) {
   
		if (pre_pen && (touch_num == 0)) {
   
			dev_dbg(&ts->client->dev, "Pen touch UP(Slot)!");
			input_report_key(ts->input_dev, BTN_TOOL_PEN, 0);
			input_mt_slot(ts->input_dev, 5);
			input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, -1);
			pre_pen = 0;
		}
	}

	if (pre_touch || touch_num) {
   
		s32 pos = 0;
		u16 touch_index = 0;

		coor_data = &point_data[3];
		if (touch_num) {
   
			id = coor_data[pos] & 0x0F;
			if (ts->pdata->with_pen) {
   
				id = coor_data[pos];
				if (id == 128) {
   
					dev_dbg(&ts->client->dev,
							"Pen touch DOWN(Slot)!");
					input_x  = coor_data[pos + 1]
						| (coor_data[pos + 2] << 8);
					input_y  = coor_data[pos + 3]
						| (coor_data[pos + 4] << 8);
					input_w  = coor_data[pos + 5]
						| (coor_data[pos + 6] << 8);

					input_report_key(ts->input_dev,
						BTN_TOOL_PEN, 1);
					input_mt_slot(ts->input_dev, 5);
					input_report_abs(ts->input_dev,
						ABS_MT_TRACKING_ID, 5);
					input_report_abs(ts->input_dev,
						ABS_MT_POSITION_X, input_x);
					input_report_abs(ts->input_dev,
						ABS_MT_POSITION_Y, input_y);
					input_report_abs(ts->input_dev,
						ABS_MT_TOUCH_MAJOR, input_w);
					dev_dbg(&ts->client->dev,
						"Pen/Stylus: (%d, %d)[%d]",
						input_x, input_y, input_w);
					pre_pen = 1;
					pre_touch = 0;
				}
			}

			touch_index |= (0x01<<id);
		}

		for (i = 0; i < GTP_MAX_TOUCH; i++) {
   
			if (ts->pdata->with_pen)
				if (pre_pen == 1)
					break;

			if (touch_index & (0x01<<i)) {
   
				input_x = coor_data[pos + 1] |
						coor_data[pos + 2] << 8;
				input_y = coor_data[pos + 3] |
						coor_data[pos + 4] << 8;
				input_w = coor_data[pos + 5] |
						coor_data[pos + 6] << 8;

				gtp_touch_down(ts, id,
						input_x, input_y, input_w);
				pre_touch |= 0x01 << i;

				pos += 8;
				id = coor_data[pos] & 0x0F;
				touch_index |= (0x01<<id);
			} else {
   
				gtp_touch_up(ts, i);
				pre_touch &= ~(0x01
最低0.47元/天 解锁文章
Love.Wu
关注
触摸屏驱动代码的实现
10-05
里面包含触摸屏单点，双击，长按，滑动等驱动实现代码
触摸屏驱动的示例代码
12-04
触摸屏驱动sample code，包括驱动的加载，中断申请，数据读取上报
gslx680触摸屏驱动源码码分析(gslX680.c)
weixin_42031299的博客
07-05 2708
I2C子系统
触摸屏驱动
lee_jimmy的博客
12-24 4231
前言        之前有篇文章简单介绍过触摸屏的工作原理，可以参考一下：电阻触摸屏原理简述。测出某个点的电压值后，我们就可以通过启动ADC模块，将电压转换为X，Y坐标了。        现在我们想写一个基于Linux系统的触摸屏驱动程序，先把程序的步骤写出来： 触摸屏的使用过程: 1、按下，产生中断 2、在中断程序里，启动ADC转换x,y坐标 3、ADC结束，产生ADC中断 4、在ADC中...
GT911触摸屏驱动代码(ALIENTEK-MD0700R V1.4 )
最新发布
08-24
总结，配置GT911触摸屏驱动在STM32H743上涉及STM32CubeMX的外设设置、驱动代码编写、中断处理，以及TouchGFX中的输入设备配置。通过这些步骤，我们可以实现一个高效、响应灵敏的触摸屏交互系统。在压缩包中提供的...
嵌入式linux触摸屏驱动源代码和Makefile编译驱动文件源代码
05-27
本资源包含了触摸屏驱动的源代码和Makefile，这对于开发者来说是宝贵的参考资料，可以帮助他们理解和实现自定义的嵌入式设备驱动。 首先，让我们详细探讨触摸屏驱动的原理。触摸屏驱动通常由两部分组成：硬件接口层...
触摸屏触摸程序源码
09-20
电容屏触摸功能测试源代码 仅提供主程序界面源代码，工程文件缺少HermitAndroid和HermitLibrary两个文件。需要请发信至ysleee@163.com
TFT显示屏驱动代码（ILI9320）
08-06
stm32下TFT显示屏驱动代码（ILI9320），修改相关硬件引脚就可移植，很方便。
嵌入式的触摸屏源代码（ads版）
06-02
这个是用于ARM9平台的嵌入式源代码。能完成触摸屏的功能。
LCD显示屏驱动
11-07
本驱动是针对STM32系列单片机写的,适用于ST7565芯片的显示屏,请按你的硬件连接修改<Lcd_Drever.h>里的相关内容,
3543触摸屏示例程序源代码
02-02
3543触摸屏示例程序源代码。个人认为不错，值得参考
7寸触摸屏驱动
08-22
本驱动是7寸屏的C语言驱动代码，基于STM32F103单片机。使用方便。
触摸板的库源代码
10-24
触摸板的优化算法库源代码，可在linux下编译，通用于各个平台
STM32编写OLED显示屏驱动
m0_49476241的博客
01-23 8309
这篇文章将带大家学习如何编写OLED显示屏的驱动程序。这里我使用的是HAL库的硬件IIC，OLED屏幕使用的是SSD1306的。这里需要参考SSD1306的数据手册来编写驱动程序。这篇文章主要就是讲解了如何编写OLED的驱动程序。
我的触摸屏驱动源代码
slippercat的专栏
04-03 4187
/*C头文件*/#include "au_types.h"#define  DEVICE_NAME         "tpanel"#define    IRQ_1              7#define    GPIO_1_PORT        GPIO_1#define    GPIO_1_PORT_ADDR   GPIO_1_BASE// 触摸屏返回值结构体typedef
基本屏幕驱动实现
whime
10-30 2269
       实现一个新的驱动实现文件screen.c和一个驱动接口文件screen.h,实现屏幕输出功能，代替C语言printf函数。（不知道为啥做这个） 在头文件中定义一些端口常数：   screen.c:    在计算screen_offset时，offset=（row*80+col）*2，使用以下端口访问方式写入offset。  获得光标位置：使用特殊的...
LCD驱动源码分析(s3cfb.c)
weixin_42031299的博客
05-25 1110
1、驱动源码分析大致思路 (1)分析LCD驱动首先需要分析内核的帧缓冲子系统，因为LCD驱动就是按照帧缓冲子系统提供的注册接口来注册的； (2)内核帧缓冲子系统参考博客：https://blog.youkuaiyun.com/weixin_42031299/article/details/124904906 (3)先分析LCD驱动的加载和卸载； (4)梳理清楚应用是如果调用到LCD驱动的； (5)LCD驱动的源码大致分为两部分：一部分是Soc的LCD控制器，一方面是LCD本身，两者都是去查阅数据手册； (6)LCD和
GT911触摸屏驱动代码分析及移植指南
GT911是一款由Goodix公司生产的触摸屏控制器，广泛应用于各类触摸屏设备中，尤其是在嵌入式系统中，如平板电脑和智能手机等。本资料集提供了GT911的驱动代码，以支持基于STM32微控制器的嵌入式系统开发。驱动代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值