9.1.触摸屏驱动概览
9.1.1、常用的2种触摸屏
(1)电阻触摸屏。驱动一般分2种：一种是SoC内置触摸屏控制器，一种是外置的专门触摸屏控制芯片，通过I2C接口和SoC通信。
(2)电容触摸屏。驱动只有一种，外接专用的电容式触摸屏控制芯片，I2C接口和SoC通信。

9.1.2、学习触摸屏驱动的关键点
(1)input子系统相关知识
(2)中断上下半部
(3)I2C子系统
(4)触摸屏芯片本身知识

9.1.3、竞争状态和同步

9.2_3.内核中的竞争状态和互斥
9.2.1、一些概念
(1)竞争状态（简称竟态）
(2)临界段、互斥锁、死锁
(3)同步（多CPU、多任务、中断）

9.2.2、解决竟态的方法
(1)原子操作 automic_t
(2)信号量、互斥锁
(3)自旋锁

9.2.3、自旋锁和信号量的使用要点
(1)自旋锁不能递归
(2)自旋锁可以用在中断上下文（信号量不可以，因为可能睡眠），但是在中断上下文中获取自旋锁之前要先禁用本地中断
(3)自旋锁的核心要求是：拥有自旋锁的代码必须不能睡眠，要一直持有CPU直到释放自旋锁
(4)信号量和读写信号量适合于保持时间较长的情况，它们会导致调用者睡眠，因此只能在进程上下文使用，而自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用。如果被保护的共享资源只在进程上下文访问，使用信号量保护该共享资源非常合适，如果对共享资源的访问时间非常短，自旋锁也可以。但是如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。自旋锁保持期间是抢占失效的，而信号量和读写信号量保持期间是可以被抢占的。自旋锁只有在内核可抢占或SMP（多处理器）的情况下才真正需要，在单CPU且不可抢占的内核下，自旋锁的所有操作都是空操作。

9.4.中断的上下半部1
9.4.1、中断处理的注意点
(1)中断上下文，不能和用户空间数据交互
(2)不能交出CPU（不能休眠、不能schedule）
(3)ISR运行时间尽可能短，越长则系统响应特性越差

9.4.2、中断下半部2种解决方案
(1)为什么要分上半部（top half，又叫顶半部）和下半部（bottom half，又叫底半部）
(2)下半部处理策略1：tasklet（小任务）
(3)下半部处理策略2：workqueue（工作队列）

9.4.3、tasklet使用实战
(1)tasklet相关接口介绍
(2)实战演示tasklet实现下半部

#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <asm/irq.h>
#include <asm/io.h>#include <mach/irqs.h>           // arch/arm/mach-s5pv210/include/mach/irqs.h
#include <linux/interrupt.h>
#include <linux/gpio.h>/** X210:** POWER  -> EINT1   -> GPH0_1* LEFT   -> EINT2   -> GPH0_2* DOWN   -> EINT3   -> GPH0_3* UP     -> KP_COL0 -> GPH2_0* RIGHT  -> KP_COL1 -> GPH2_1* MENU   -> KP_COL3 -> GPH2_3 (KEY_A)* BACK   -> KP_COL2 -> GPH2_2 (KEY_B)*/#define BUTTON_IRQ    IRQ_EINT2static struct input_dev *button_dev;// 下半部函数
void func(unsigned long data)
{int flag;printk("key-s5pv210: this is bottom half\n");s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0));     // input模式flag = gpio_get_value(S5PV210_GPH0(2));s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0f));      // eint2模式input_report_key(button_dev, KEY_LEFT, !flag);input_sync(button_dev);
}DECLARE_TASKLET(mytasklet, func, 0);static irqreturn_t button_interrupt(int irq, void *dummy)
{ printk("key-s5pv210: this is top half\n");tasklet_schedule(&mytasklet);return IRQ_HANDLED;
}static int __init button_init(void)
{ int error;error = gpio_request(S5PV210_GPH0(2), "GPH0_2");if(error)printk("key-s5pv210: request gpio GPH0(2) fail");s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0f));     // eint2模式if (request_irq(BUTTON_IRQ, button_interrupt, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "button-x210", NULL)) { printk(KERN_ERR "key-s5pv210.c: Can't allocate irq %d\n", BUTTON_IRQ);return -EBUSY; }button_dev = input_allocate_device();if (!button_dev) { printk(KERN_ERR "key-s5pv210.c: Not enough memory\n");error = -ENOMEM;goto err_free_irq; }button_dev->evbit[0] = BIT_MASK(EV_KEY);button_dev->keybit[BIT_WORD(KEY_LEFT)] = BIT_MASK(KEY_LEFT);error = input_register_device(button_dev);if (error) { printk(KERN_ERR "key-s5pv210.c: Failed to register device\n");goto err_free_dev; }return 0;err_free_dev:input_free_device(button_dev);
err_free_irq:free_irq(BUTTON_IRQ, button_interrupt);return error;
}static void __exit button_exit(void)
{ input_unregister_device(button_dev); free_irq(BUTTON_IRQ, button_interrupt);
}module_init(button_init);
module_exit(button_exit); MODULE_LICENSE("GPL");
MODULE_AUTHOR("aston <1264671872@qq.com>");
MODULE_DESCRIPTION("key driver for x210 button.");

9.5.中断的上下半部2
9.5.1、workqueue实战演示
(1)workqueue的突出特点是下半部会交给worker thead，因此下半部处于进程上下文，可以被调度，因此可以睡眠。
(2)include/linux/workqueue.h

9.5.2、中断上下半部处理原则
(1)必须立即进行紧急处理的极少量任务放入在中断的顶半部中，此时屏蔽了与自己同类型的中断，由于任务量少，所以可以迅速不受打扰地处理完紧急任务。

(2)需要较少时间的中等数量的急迫任务放在tasklet中。此时不会屏蔽任何中断（包括与自己的顶半部同类型的中断），所以不影响顶半部对紧急事务的处理；同时又不会进行用户进程调度，从而保证了自己急迫任务得以迅速完成。

(3)需要较多时间且并不急迫（允许被操作系统剥夺运行权）的大量任务放在workqueue中。此时操作系统会尽量快速处理完这个任务，但如果任务量太大，期间操作系统也会有机会调度别的用户进程运行，从而保证不会因为这个任务需要运行时间将其它用户进程无法进行。

(4)可能引起睡眠的任务放在workqueue中。因为在workqueue中睡眠是安全的。在需要获得大量的内存时、在需要获取信号量时，在需要执行阻塞式的I/O操作时，用workqueue很合适。

#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <asm/irq.h>
#include <asm/io.h>#include <mach/irqs.h>           // arch/arm/mach-s5pv210/include/mach/irqs.h
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <linux/workqueue.h>/** X210:** POWER  -> EINT1   -> GPH0_1* LEFT   -> EINT2   -> GPH0_2* DOWN   -> EINT3   -> GPH0_3* UP     -> KP_COL0 -> GPH2_0* RIGHT  -> KP_COL1 -> GPH2_1* MENU   -> KP_COL3 -> GPH2_3 (KEY_A)* BACK   -> KP_COL2 -> GPH2_2 (KEY_B)*/#define BUTTON_IRQ   IRQ_EINT2static struct input_dev *button_dev;// 下半部函数
void func(struct work_struct *work)
{int flag;printk("key-s5pv210: this is workqueue bottom half\n");s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0));       // input模式flag = gpio_get_value(S5PV210_GPH0(2));s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0f));      // eint2模式input_report_key(button_dev, KEY_LEFT, !flag);input_sync(button_dev);
}DECLARE_WORK(mywork, func);static irqreturn_t button_interrupt(int irq, void *dummy)
{ printk("key-s5pv210: this is workqueue top half\n");schedule_work(&mywork);return IRQ_HANDLED;
}static int __init button_init(void)
{ int error;error = gpio_request(S5PV210_GPH0(2), "GPH0_2");if(error)printk("key-s5pv210: request gpio GPH0(2) fail");s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0f));     // eint2模式if (request_irq(BUTTON_IRQ, button_interrupt, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "button-x210", NULL)) { printk(KERN_ERR "key-s5pv210.c: Can't allocate irq %d\n", BUTTON_IRQ);return -EBUSY; }button_dev = input_allocate_device();if (!button_dev) { printk(KERN_ERR "key-s5pv210.c: Not enough memory\n");error = -ENOMEM;goto err_free_irq; }button_dev->evbit[0] = BIT_MASK(EV_KEY);button_dev->keybit[BIT_WORD(KEY_LEFT)] = BIT_MASK(KEY_LEFT);error = input_register_device(button_dev);if (error) { printk(KERN_ERR "key-s5pv210.c: Failed to register device\n");goto err_free_dev; }return 0;err_free_dev:input_free_device(button_dev);
err_free_irq:free_irq(BUTTON_IRQ, button_interrupt);return error;
}static void __exit button_exit(void)
{ input_unregister_device(button_dev); free_irq(BUTTON_IRQ, button_interrupt);
}module_init(button_init);
module_exit(button_exit); MODULE_LICENSE("GPL");
MODULE_AUTHOR("aston <1264671872@qq.com>");
MODULE_DESCRIPTION("key driver for x210 button.");

9.6 linux内核的I2C子系统详解
9.6.1、I2C总线汇总概览
(1)三根通信线：SCL、SDA、GND

(2)同步、串行、电平、低速、近距离

(3)总线式结构，支持多个设备挂接在同一条总线上

(4)主从式结构，通信双方必须一个为主（master）一个为从（slave），主设备掌握每次通信的主动权，从设备按照主设备的节奏被动响应。每个从设备在总线中有唯一的地址（slave address），主设备通过从地址找到自己要通信的从设备（本质是广播）。

(5)I2C主要用途就是主SoC和外围设备之间的通信，最大优势是可以在总线上扩展多个外围设备的支持。常见的各种物联网传感器芯片（如gsensor、温度、湿度、光强度、酸碱度、烟雾浓度、压力等）均使用I2C接口和主SoC进行连接。

(6)电容触摸屏芯片的多个引脚构成2个接口。一个接口是I2C的，负责和主SoC连接（本身作为从设备），主SoC通过该接口初始化及控制电容触摸屏芯片、芯片通过该接口向SoC汇报触摸事件的信息（触摸坐标等），我们使用电容触摸屏时重点关注的是这个接口；另一个接口是电容触摸板的管理接口，电容触摸屏芯片通过该接口来控制触摸板硬件。该接口是电容触摸屏公司关心的，他们的触摸屏芯片内部固件编程要处理这部分，我们使用电容触摸屏的人并不关心这里。

9.6.2、linux内核的I2C驱动框架总览
(1)I2C驱动框架的主要目标是：让驱动开发者可以在内核中方便的添加自己的I2C设备的驱动程序，从而可以更容易的在linux下驱动自己的I2C接口硬件

(2)源码中I2C相关的驱动均位于：drivers/i2c目录下。linux系统提供2种I2C驱动实现方法：第一种叫i2c-dev，对应drivers/i2c/i2c-dev.c，这种方法只是封装了主机（I2C master，一般是SoC中内置的I2C控制器）的I2C基本操作，并且向应用层提供相应的操作接口，应用层代码需要自己去实现对slave的控制和操作，所以这种I2C驱动相当于只是提供给应用层可以访问slave硬件设备的接口，本身并未对硬件做任何操作，应用需要实现对硬件的操作，因此写应用的人必须对硬件非常了解，其实相当于传统的驱动中干的活儿丢给应用去做了，所以这种I2C驱动又叫做“应用层驱动”，这种方式并不主流，它的优势是把差异化都放在应用中，这样在设备比较难缠（尤其是slave是非标准I2C时）时不用动驱动，而只需要修改应用就可以实现对各种设备的驱动。这种驱动在驱动层很简单（就是i2c-dev.c）我们就不分析了。

(3)第二种I2C驱动是所有的代码都放在驱动层实现，直接向应用层提供最终结果。应用层甚至不需要知道这里面有I2C存在，譬如电容式触摸屏驱动，直接向应用层提供/dev/input/event1的操作接口，应用层编程的人根本不知道event1中涉及到了I2C。这种是我们后续分析的重点。

9.8.linux内核的I2C子系统详解3
9.8.1、I2C子系统的4个关键结构体
(1)struct i2c_adapter I2C适配器
(2)struct i2c_algorithm I2C算法
(3)struct i2c_client I2C（从机）设备信息
(4)struct i2c_driver I2C（从机）设备驱动

9.8.2、关键文件
(1)\drivers\i2c\i2c-core.c
(2)\drivers\i2c\busses目录
(3)\drivers\i2c\algos目录

9.9.linux内核的I2C子系统详解4
9.9.1、i2c-core.c初步分析
(1)smbus代码略过
(2)模块加载和卸载:bus_register(&i2c_bus_type);

9.9.2、I2C总线的匹配机制
(1)match函数
(2)probe函数
总结：I2C总线上有2条分支：i2c_client链和i2c_driver链，当任何一个driver或者client去注册时，I2C总线都会调用match函数去对client.name和driver.id_table.name进行循环匹配。如果driver.id_table中所有的id都匹配不上则说明client并没有找到一个对应的driver，没了；如果匹配上了则标明client和driver是适用的，那么I2C总线会调用自身的probe函数，自身的probe函数又会调用driver中提供的probe函数，driver中的probe函数会对设备进行硬件初始化和后续工作。

9.9.3、核心层开放给其他部分的注册接口
(1)i2c_add_adapter/i2c_add_numbered_adapter 注册adapter的
(2)i2c_add_driver 注册driver的
(3)i2c_new_device 注册client的

9.10.linux内核的I2C子系统详解5
9.10.1、adapter模块的注册
(1)平台总线方式注册
(2)找到driver和device，并且确认其配对过程
(3)probe函数

9.10.2、probe函数分析
(1)填充一个i2c_adapter结构体，并且调用接口去注册之
(2)从platform_device接收硬件信息，做必要的处理（request_mem_region & ioremap、request_irq等）
(3)对硬件做初始化（直接操作210内部I2C控制器的寄存器）

9.10.3、i2c_algorithm
(1)i2c->adap.algo = &s3c24xx_i2c_algorithm;
(2)functionality
(3)s3c24xx_i2c_doxfer

9.11_12.linux内核的I2C子系统详解6_7
9.11.1、i2c_driver的注册
(1)以gslX680的驱动为例
(2)将驱动添加到内核SI项目中
(3)i2c_driver的基本分析：name和probe

9.11.2、i2c_client从哪里来
(1)直接来源：i2c_register_board_info
smdkc110_machine_init
i2c_register_board_info

struct i2c_board_info {
char type[I2C_NAME_SIZE]; // 设备名
unsigned short flags; // 属性
unsigned short addr; // 设备从地址
void *platform_data; // 设备私有数据
struct dev_archdata *archdata;
#ifdef CONFIG_OF
struct device_node *of_node;
#endif
int irq; // 设备使用的IRQ号，对应CPU的EINT
};

(2)实现原理分析
内核维护一个链表 __i2c_board_list，这个链表上链接的是I2C总线上挂接的所有硬件设备的信息结构体。也就是说这个链表维护的是一个struct i2c_board_info结构体链表。
真正的需要的struct i2c_client在别的地方由__i2c_board_list链表中的各个节点内容来另外构建生成。

函数调用层次：
i2c_add_adapter/i2c_add_numbered_adapter
i2c_register_adapter
i2c_scan_static_board_info
i2c_new_device
device_register

总结：I2C总线的i2c_client的提供是内核通过i2c_add_adapter/i2c_add_numbered_adapter接口调用时自动生成的，生成的原料是mach-x210.c中的i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));

9.13. goodix驱动的移植实践
源码目录：\input\touchscreen\goodix.c

完整代码：

/**  Driver for Goodix Touchscreens**  Copyright (c) 2014 Red Hat Inc.*  Copyright (c) 2015 K. Merker <merker@debian.org>**  This code is based on gt9xx.c authored by andrew@goodix.com:**  2010 - 2012 Goodix Technology.*//** This program is free software; you can redistribute it and/or modify it* under the terms of the GNU General Public License as published by the Free* Software Foundation; version 2 of the License.*/#include <linux/kernel.h>
#include <linux/dmi.h>
#include <linux/firmware.h>
#include <linux/gpio/consumer.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/acpi.h>
#include <linux/of.h>
#include <asm/unaligned.h>
#include "../../gpio/gpiolib.h"struct goodix_ts_data {struct i2c_client *client;struct input_dev *input_dev;int abs_x_max;int abs_y_max;bool swapped_x_y;bool inverted_x;bool inverted_y;unsigned int max_touch_num;unsigned int int_trigger_type;int cfg_len;struct gpio_desc *gpiod_int;struct gpio_desc *gpiod_rst;u16 id;u16 version;const char *cfg_name;struct completion firmware_loading_complete;unsigned long irq_flags;
};#define GOODIX_GPIO_INT_NAME      "irq"
//#define GOODIX_GPIO_RST_NAME      "reset"
#define GOODIX_GPIO_RST_NAME        "rst"#define GOODIX_MAX_HEIGHT      854
#define GOODIX_MAX_WIDTH        480
#define GOODIX_INT_TRIGGER      1
#define GOODIX_CONTACT_SIZE     8
#define GOODIX_MAX_CONTACTS     10#define GOODIX_CONFIG_MAX_LENGTH  240
#define GOODIX_CONFIG_911_LENGTH    186
#define GOODIX_CONFIG_967_LENGTH    228/* Register defines */
#define GOODIX_REG_COMMAND      0x8040
#define GOODIX_CMD_SCREEN_OFF       0x05#define GOODIX_READ_COOR_ADDR       0x814E
#define GOODIX_REG_CONFIG_DATA      0x8047
#define GOODIX_REG_ID           0x8140#define GOODIX_BUFFER_STATUS_READY    BIT(7)
#define GOODIX_BUFFER_STATUS_TIMEOUT    20#define RESOLUTION_LOC        1
#define MAX_CONTACTS_LOC    5
#define TRIGGER_LOC     6static const unsigned long goodix_irq_flags[] = {IRQ_TYPE_EDGE_RISING,IRQ_TYPE_EDGE_FALLING,IRQ_TYPE_LEVEL_LOW,IRQ_TYPE_LEVEL_HIGH,
};/** Those tablets have their coordinates origin at the bottom right* of the tablet, as if rotated 180 degrees*/
static const struct dmi_system_id rotated_screen[] = {
#if defined(CONFIG_DMI) && defined(CONFIG_X86){.ident = "WinBook TW100",.matches = {DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),DMI_MATCH(DMI_PRODUCT_NAME, "TW100")}},{.ident = "WinBook TW700",.matches = {DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),DMI_MATCH(DMI_PRODUCT_NAME, "TW700")},},
#endif{}
};/*** goodix_i2c_read - read data from a register of the i2c slave device.** @client: i2c device.* @reg: the register to read from.* @buf: raw write data buffer.* @len: length of the buffer to write*/
static int goodix_i2c_read(struct i2c_client *client,u16 reg, u8 *buf, int len)
{struct i2c_msg msgs[2];u16 wbuf = cpu_to_be16(reg);int ret;msgs[0].flags = 0;msgs[0].addr  = client->addr;msgs[0].len   = 2;msgs[0].buf   = (u8 *)&wbuf;msgs[1].flags = I2C_M_RD;msgs[1].addr  = client->addr;msgs[1].len   = len;msgs[1].buf   = buf;ret = i2c_transfer(client->adapter, msgs, 2);return ret < 0 ? ret : (ret != ARRAY_SIZE(msgs) ? -EIO : 0);
}/*** goodix_i2c_write - write data to a register of the i2c slave device.** @client: i2c device.* @reg: the register to write to.* @buf: raw data buffer to write.* @len: length of the buffer to write*/
static int goodix_i2c_write(struct i2c_client *client, u16 reg, const u8 *buf,unsigned len)
{u8 *addr_buf;struct i2c_msg msg;int ret;addr_buf = kmalloc(len + 2, GFP_KERNEL);if (!addr_buf)return -ENOMEM;addr_buf[0] = reg >> 8;addr_buf[1] = reg & 0xFF;memcpy(&addr_buf[2], buf, len);msg.flags = 0;msg.addr = client->addr;msg.buf = addr_buf;msg.len = len + 2;ret = i2c_transfer(client->adapter, &msg, 1);kfree(addr_buf);return ret < 0 ? ret : (ret != 1 ? -EIO : 0);
}static int goodix_i2c_write_u8(struct i2c_client *client, u16 reg, u8 value)
{return goodix_i2c_write(client, reg, &value, sizeof(value));
}static int goodix_get_cfg_len(u16 id)
{switch (id) {case 911:case 9271:case 9110:case 927:case 928:return GOODIX_CONFIG_911_LENGTH;case 912:case 967:return GOODIX_CONFIG_967_LENGTH;default:return GOODIX_CONFIG_MAX_LENGTH;}
}static int goodix_ts_read_input_report(struct goodix_ts_data *ts, u8 *data)
{unsigned long max_timeout;int touch_num;int error;/** The 'buffer status' bit, which indicates that the data is valid, is* not set as soon as the interrupt is raised, but slightly after.* This takes around 10 ms to happen, so we poll for 20 ms.*/max_timeout = jiffies + msecs_to_jiffies(GOODIX_BUFFER_STATUS_TIMEOUT);do {error = goodix_i2c_read(ts->client, GOODIX_READ_COOR_ADDR,data, GOODIX_CONTACT_SIZE + 1);if (error) {dev_err(&ts->client->dev, "I2C transfer error: %d\n",error);return error;}if (data[0] & GOODIX_BUFFER_STATUS_READY) {touch_num = data[0] & 0x0f;if (touch_num > ts->max_touch_num)return -EPROTO;if((data[0]&0x80)==0)//坐标未就绪，数据无效return -EPROTO;if (touch_num > 1) {data += 1 + GOODIX_CONTACT_SIZE;error = goodix_i2c_read(ts->client,GOODIX_READ_COOR_ADDR +1 + GOODIX_CONTACT_SIZE,data,GOODIX_CONTACT_SIZE *(touch_num - 1));if (error)return error;}return touch_num;}usleep_range(1000, 2000); /* Poll every 1 - 2 ms */} while (time_before(jiffies, max_timeout));/** The Goodix panel will send spurious interrupts after a* 'finger up' event, which will always cause a timeout.*/return 0;
}static void goodix_ts_report_touch(struct goodix_ts_data *ts, u8 *coor_data)
{int id = coor_data[0] & 0x0F;int input_x = get_unaligned_le16(&coor_data[1]);int input_y = get_unaligned_le16(&coor_data[3]);int input_w = get_unaligned_le16(&coor_data[5]);/* Inversions have to happen before axis swapping */if (ts->inverted_x)input_x = ts->abs_x_max - input_x;if (ts->inverted_y)input_y = ts->abs_y_max - input_y;if (ts->swapped_x_y)swap(input_x, input_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, 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);input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
}/*** goodix_process_events - Process incoming events** @ts: our goodix_ts_data pointer** Called when the IRQ is triggered. Read the current device state, and push* the input events to the user space.*/
static void goodix_process_events(struct goodix_ts_data *ts)
{u8  point_data[1 + GOODIX_CONTACT_SIZE * GOODIX_MAX_CONTACTS];int touch_num;int i;touch_num = goodix_ts_read_input_report(ts, point_data);if (touch_num < 0)return;/** Bit 4 of the first byte reports the status of the capacitive* Windows/Home button.*/input_report_key(ts->input_dev, KEY_LEFTMETA, point_data[0] & BIT(4));for (i = 0; i < touch_num; i++)goodix_ts_report_touch(ts,&point_data[1 + GOODIX_CONTACT_SIZE * i]);input_mt_sync_frame(ts->input_dev);input_sync(ts->input_dev);
}/*** goodix_ts_irq_handler - The IRQ handler** @irq: interrupt number.* @dev_id: private data pointer.*/
static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)
{struct goodix_ts_data *ts = dev_id;goodix_process_events(ts);if (goodix_i2c_write_u8(ts->client, GOODIX_READ_COOR_ADDR, 0) < 0)dev_err(&ts->client->dev, "I2C write end_cmd error\n");return IRQ_HANDLED;
}static void goodix_free_irq(struct goodix_ts_data *ts)
{devm_free_irq(&ts->client->dev, ts->client->irq, ts);
}static int goodix_request_irq(struct goodix_ts_data *ts)
{return devm_request_threaded_irq(&ts->client->dev, ts->client->irq,NULL, goodix_ts_irq_handler,ts->irq_flags, ts->client->name, ts);
}/*** goodix_check_cfg - Checks if config fw is valid** @ts: goodix_ts_data pointer* @cfg: firmware config data*/
static int goodix_check_cfg(struct goodix_ts_data *ts,const struct firmware *cfg)
{int i, raw_cfg_len;u8 check_sum = 0;if (cfg->size > GOODIX_CONFIG_MAX_LENGTH) {dev_err(&ts->client->dev,"The length of the config fw is not correct");return -EINVAL;}raw_cfg_len = cfg->size - 2;for (i = 0; i < raw_cfg_len; i++)check_sum += cfg->data[i];check_sum = (~check_sum) + 1;if (check_sum != cfg->data[raw_cfg_len]) {dev_err(&ts->client->dev,"The checksum of the config fw is not correct");return -EINVAL;}if (cfg->data[raw_cfg_len + 1] != 1) {dev_err(&ts->client->dev,"Config fw must have Config_Fresh register set");return -EINVAL;}return 0;
}/*** goodix_send_cfg - Write fw config to device** @ts: goodix_ts_data pointer* @cfg: config firmware to write to device*/
static int goodix_send_cfg(struct goodix_ts_data *ts,const struct firmware *cfg)
{int error;error = goodix_check_cfg(ts, cfg);if (error)return error;error = goodix_i2c_write(ts->client, GOODIX_REG_CONFIG_DATA, cfg->data,cfg->size);if (error) {dev_err(&ts->client->dev, "Failed to write config data: %d",error);return error;}dev_dbg(&ts->client->dev, "Config sent successfully.");/* Let the firmware reconfigure itself, so sleep for 10ms */usleep_range(10000, 11000);return 0;
}static int goodix_int_sync(struct goodix_ts_data *ts)
{int error;error = gpiod_direction_output(ts->gpiod_int, 0);if (error)return error;msleep(50);               /* T5: 50ms */error = gpiod_direction_input(ts->gpiod_int);if (error)return error;return 0;
}/*** goodix_reset - Reset device during power on** @ts: goodix_ts_data pointer*/
static int goodix_reset(struct goodix_ts_data *ts)
{int error;/* begin select I2C slave addr */error = gpiod_direction_output(ts->gpiod_rst, 0);    if (error)return error;msleep(15);  /* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */error = gpiod_direction_output(ts->gpiod_int, ts->client->addr == 0x14);if (error){printk("[log]gpiod_direction_output int 1 err\r\n");return error;}usleep_range(100, 2000);     /* T3: > 100us */error = gpiod_direction_output(ts->gpiod_rst, 1);    if (error){printk("[log]gpiod_direction_output rst 1 err\r\n");return error;}usleep_range(6000, 10000);     /* T4: > 5ms *//* end select I2C slave addr *///error = gpiod_direction_input(ts->gpiod_rst);//if (error)//   return error;//msleep(50);              /* T5: 50ms */error = goodix_int_sync(ts);if (error)return error;return 0;
}/*** goodix_get_gpio_config - Get GPIO config from ACPI/DT** @ts: goodix_ts_data pointer*/
static int goodix_get_gpio_config(struct goodix_ts_data *ts)
{int error;struct device *dev;struct gpio_desc *gpiod;if (!ts->client)return -EINVAL;dev = &ts->client->dev;/* Get the interrupt GPIO pin number */gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_INT_NAME, GPIOD_IN);if (IS_ERR(gpiod)) {error = PTR_ERR(gpiod);if (error != -EPROBE_DEFER)dev_dbg(dev, "Failed to get %s GPIO: %d\n",GOODIX_GPIO_INT_NAME, error);return error;}ts->gpiod_int = gpiod;/* Get the reset line GPIO pin number */gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_RST_NAME, GPIOD_IN);if (IS_ERR(gpiod)) {error = PTR_ERR(gpiod);if (error != -EPROBE_DEFER)dev_dbg(dev, "Failed to get %s GPIO: %d\n",GOODIX_GPIO_RST_NAME, error);return error;}ts->gpiod_rst = gpiod;return 0;
}/*** goodix_read_config - Read the embedded configuration of the panel** @ts: our goodix_ts_data pointer** Must be called during probe*/
static void goodix_read_config(struct goodix_ts_data *ts)
{u8 config[GOODIX_CONFIG_MAX_LENGTH];int error;error = goodix_i2c_read(ts->client, GOODIX_REG_CONFIG_DATA,config, ts->cfg_len);if (error) {dev_warn(&ts->client->dev,"Error reading config (%d), using defaults\n",error);ts->abs_x_max = GOODIX_MAX_WIDTH;ts->abs_y_max = GOODIX_MAX_HEIGHT;if (ts->swapped_x_y)swap(ts->abs_x_max, ts->abs_y_max);ts->int_trigger_type = GOODIX_INT_TRIGGER;ts->max_touch_num = GOODIX_MAX_CONTACTS;return;}ts->abs_x_max = get_unaligned_le16(&config[RESOLUTION_LOC]);ts->abs_y_max = get_unaligned_le16(&config[RESOLUTION_LOC + 2]);if (ts->swapped_x_y)swap(ts->abs_x_max, ts->abs_y_max);ts->int_trigger_type = config[TRIGGER_LOC] & 0x03;ts->max_touch_num = config[MAX_CONTACTS_LOC] & 0x0f;if (!ts->abs_x_max || !ts->abs_y_max || !ts->max_touch_num) {dev_err(&ts->client->dev,"Invalid config, using defaults\n");ts->abs_x_max = GOODIX_MAX_WIDTH;ts->abs_y_max = GOODIX_MAX_HEIGHT;if (ts->swapped_x_y)swap(ts->abs_x_max, ts->abs_y_max);ts->max_touch_num = GOODIX_MAX_CONTACTS;}if (dmi_check_system(rotated_screen)) {ts->inverted_x = true;ts->inverted_y = true;dev_dbg(&ts->client->dev,"Applying '180 degrees rotated screen' quirk\n");}
}/*** goodix_read_version - Read goodix touchscreen version** @ts: our goodix_ts_data pointer*/
static int goodix_read_version(struct goodix_ts_data *ts)
{int error;u8 buf[6];char id_str[5];error = goodix_i2c_read(ts->client, GOODIX_REG_ID, buf, sizeof(buf));if (error) {dev_err(&ts->client->dev, "read version failed: %d\n", error);return error;}memcpy(id_str, buf, 4);id_str[4] = 0;if (kstrtou16(id_str, 10, &ts->id))ts->id = 0x1001;ts->version = get_unaligned_le16(&buf[4]);dev_info(&ts->client->dev, "ID %d, version: %04x\n", ts->id,ts->version);return 0;
}/*** goodix_i2c_test - I2C test function to check if the device answers.** @client: the i2c client*/
static int goodix_i2c_test(struct i2c_client *client)
{int retry = 0;int error;u8 test;while (retry++ < 2) {error = goodix_i2c_read(client, GOODIX_REG_CONFIG_DATA,&test, 1);if (!error)return 0;dev_err(&client->dev, "i2c test failed attempt %d: %d\n",retry, error);msleep(20);}return error;
}/*** goodix_request_input_dev - Allocate, populate and register the input device** @ts: our goodix_ts_data pointer** Must be called during probe*/
static int goodix_request_input_dev(struct goodix_ts_data *ts)
{int error;ts->input_dev = devm_input_allocate_device(&ts->client->dev);if (!ts->input_dev) {dev_err(&ts->client->dev, "Failed to allocate input device.");return -ENOMEM;}input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X,0, ts->abs_x_max, 0, 0);input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y,0, ts->abs_y_max, 0, 0);input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);input_mt_init_slots(ts->input_dev, ts->max_touch_num,INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);ts->input_dev->name = "Goodix Capacitive TouchScreen";ts->input_dev->phys = "input/ts";ts->input_dev->id.bustype = BUS_I2C;ts->input_dev->id.vendor = 0x0416;ts->input_dev->id.product = ts->id;ts->input_dev->id.version = ts->version;/* Capacitive Windows/Home button on some devices */input_set_capability(ts->input_dev, EV_KEY, KEY_LEFTMETA);error = input_register_device(ts->input_dev);if (error) {dev_err(&ts->client->dev,"Failed to register input device: %d", error);return error;}return 0;
}/*** goodix_configure_dev - Finish device initialization** @ts: our goodix_ts_data pointer** Must be called from probe to finish initialization of the device.* Contains the common initialization code for both devices that* declare gpio pins and devices that do not. It is either called* directly from probe or from request_firmware_wait callback.*/
static int goodix_configure_dev(struct goodix_ts_data *ts)
{int error;ts->swapped_x_y = device_property_read_bool(&ts->client->dev,"touchscreen-swapped-x-y");ts->inverted_x = device_property_read_bool(&ts->client->dev,"touchscreen-inverted-x");ts->inverted_y = device_property_read_bool(&ts->client->dev,"touchscreen-inverted-y");goodix_read_config(ts);error = goodix_request_input_dev(ts);if (error)return error;ts->irq_flags = goodix_irq_flags[ts->int_trigger_type] | IRQF_ONESHOT;error = goodix_request_irq(ts);if (error) {dev_err(&ts->client->dev, "request IRQ failed: %d\n", error);return error;}return 0;
}/*** goodix_config_cb - Callback to finish device init** @ts: our goodix_ts_data pointer** request_firmware_wait callback that finishes* initialization of the device.*/
static void goodix_config_cb(const struct firmware *cfg, void *ctx)
{struct goodix_ts_data *ts = ctx;int error;if (cfg) {/* send device configuration to the firmware */error = goodix_send_cfg(ts, cfg);if (error)goto err_release_cfg;}goodix_configure_dev(ts);err_release_cfg:release_firmware(cfg);complete_all(&ts->firmware_loading_complete);
}static int goodix_ts_probe(struct i2c_client *client,const struct i2c_device_id *id)
{struct goodix_ts_data *ts;int error;dev_dbg(&client->dev, "I2C Address: 0x%02x\n", client->addr);if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {dev_err(&client->dev, "I2C check functionality failed.\n");return -ENXIO;}ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);if (!ts)return -ENOMEM;ts->client = client;i2c_set_clientdata(client, ts);init_completion(&ts->firmware_loading_complete);error = goodix_get_gpio_config(ts);if (error){printk("[log]goodix_get_gpio_config\r\n");return error;}if (ts->gpiod_int && ts->gpiod_rst) {/* reset the controller */error = goodix_reset(ts);if (error) {dev_err(&client->dev, "Controller reset failed.\n");return error;}}error = goodix_i2c_test(client);if (error) {printk("[log]I2C communication failure: %d\n",error);dev_err(&client->dev, "I2C communication failure: %d\n", error);return error;}error = goodix_read_version(ts);if (error) {printk("[log]Read version failed.\n");dev_err(&client->dev, "Read version failed.\n");return error;}ts->cfg_len = goodix_get_cfg_len(ts->id);if (ts->gpiod_int && ts->gpiod_rst) {/* update device config */ts->cfg_name = devm_kasprintf(&client->dev, GFP_KERNEL,"goodix_%d_cfg.bin", ts->id);if (!ts->cfg_name)return -ENOMEM;error = request_firmware_nowait(THIS_MODULE, true, ts->cfg_name,&client->dev, GFP_KERNEL, ts,goodix_config_cb);if (error) {dev_err(&client->dev,"Failed to invoke firmware loader: %d\n",error);return error;}return 0;} else {error = goodix_configure_dev(ts);if (error)return error;}return 0;
}static int goodix_ts_remove(struct i2c_client *client)
{struct goodix_ts_data *ts = i2c_get_clientdata(client);if (ts->gpiod_int && ts->gpiod_rst)wait_for_completion(&ts->firmware_loading_complete);return 0;
}static int __maybe_unused goodix_suspend(struct device *dev)
{struct i2c_client *client = to_i2c_client(dev);struct goodix_ts_data *ts = i2c_get_clientdata(client);int error;/* We need gpio pins to suspend/resume */if (!ts->gpiod_int || !ts->gpiod_rst) {disable_irq(client->irq);return 0;}wait_for_completion(&ts->firmware_loading_complete);/* Free IRQ as IRQ pin is used as output in the suspend sequence */goodix_free_irq(ts);/* Output LOW on the INT pin for 5 ms */error = gpiod_direction_output(ts->gpiod_int, 0);if (error) {goodix_request_irq(ts);return error;}usleep_range(5000, 6000);error = goodix_i2c_write_u8(ts->client, GOODIX_REG_COMMAND,GOODIX_CMD_SCREEN_OFF);if (error) {dev_err(&ts->client->dev, "Screen off command failed\n");gpiod_direction_input(ts->gpiod_int);goodix_request_irq(ts);return -EAGAIN;}/** The datasheet specifies that the interval between sending screen-off* command and wake-up should be longer than 58 ms. To avoid waking up* sooner, delay 58ms here.*/msleep(58);return 0;
}static int __maybe_unused goodix_resume(struct device *dev)
{struct i2c_client *client = to_i2c_client(dev);struct goodix_ts_data *ts = i2c_get_clientdata(client);int error;if (!ts->gpiod_int || !ts->gpiod_rst) {enable_irq(client->irq);return 0;}/** Exit sleep mode by outputting HIGH level to INT pin* for 2ms~5ms.*/error = gpiod_direction_output(ts->gpiod_int, 1);if (error)return error;usleep_range(2000, 5000);error = goodix_int_sync(ts);if (error)return error;error = goodix_request_irq(ts);if (error)return error;return 0;
}static SIMPLE_DEV_PM_OPS(goodix_pm_ops, goodix_suspend, goodix_resume);static const struct i2c_device_id goodix_ts_id[] = {{ "GDIX1001:00", 0 },{ }
};
MODULE_DEVICE_TABLE(i2c, goodix_ts_id);#ifdef CONFIG_ACPI
static const struct acpi_device_id goodix_acpi_match[] = {{ "GDIX1001", 0 },{ "GDIX1002", 0 },{ }
};
MODULE_DEVICE_TABLE(acpi, goodix_acpi_match);
#endif#ifdef CONFIG_OF
static const struct of_device_id goodix_of_match[] = {{ .compatible = "goodix,gt911" },{ .compatible = "goodix,gt9110" },{ .compatible = "goodix,gt912" },{ .compatible = "goodix,gt927" },{ .compatible = "goodix,gt9271" },{ .compatible = "goodix,gt928" },{ .compatible = "goodix,gt967" },{ }
};
MODULE_DEVICE_TABLE(of, goodix_of_match);
#endifstatic struct i2c_driver goodix_ts_driver = {.probe = goodix_ts_probe,.remove = goodix_ts_remove,.id_table = goodix_ts_id,.driver = {.name = "Goodix-TS",.acpi_match_table = ACPI_PTR(goodix_acpi_match),.of_match_table = of_match_ptr(goodix_of_match),.pm = &goodix_pm_ops,},
};
module_i2c_driver(goodix_ts_driver);MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
MODULE_DESCRIPTION("Goodix touchscreen driver");
MODULE_LICENSE("GPL v2");

9.13.2、在内核配置中添加CONFIG项
(1)定义一个宏名，譬如CONFIG_TOUCHSCREEN_GOODIX
(2)在代码中使用宏来条件编译
(3)在Makefile中使用宏来条件配置
obj-$(CONFIG_TOUCHSCREEN_GOODIX)    += goodix.o

(4)在Kconfig项目中添加宏的配置项
config TOUCHSCREEN_GOODIX
    tristate "Goodix I2C touchscreen"
    depends on I2C
    depends on GPIOLIB || COMPILE_TEST
    help
      Say Y here if you have the Goodix touchscreen (such as one
      installed in Onda v975w tablets) connected to your
      system. It also supports 5-finger chip models, which can be
      found on ARM tablets, like Wexler TAB7200 and MSI Primo73.

If unsure, say N.

To compile this driver as a module, choose M here: the
      module will be called goodix.

(5)make menuconfig并选择Y或者N

9.触摸屏驱动（IIC）移植实战相关推荐

1. NUC972触摸屏驱动移植过程分析（一）

   https://blog.csdn.net/b7376811/article/details/86514683 因为下一个项目可能会用到触摸屏,所以这段时间对触摸屏的驱动的移植进行了研究,今天正好有机 ...

2. F1C100S电阻触摸屏驱动

   https://whycan.cn/t_2143.html 移植触摸屏驱动. 移植后遇到的问题,触摸中断一直在触发.[原因:由于rtp引脚复用没有设置] //读0x01C20800寄存器,可以看到没有 ...

3. Exynos4412——触摸屏驱动

   CSDN仅用于增加百度收录权重,排版未优化,日常不维护.请访问:www.hceng.cn 查看.评论. 本博文对应地址: https://hceng.cn/2017/12/26/Exynos4412- ...

4. 9.触摸屏驱动移植实战

   转自 https://edu.csdn.net/lecturer/505 朱老师物联网大讲堂 <5.linux驱动开发-第9部分-5.9.触摸屏驱动移植实战> 第一部分.章节目录 5.9. ...

5. GSLX680触摸屏驱动移植

   GSLX680 触摸屏 触摸屏按照触摸屏的工作原理和传输信息的介质,可以分为四种,它们分别为电阻式.电容感应式.红外线式以及表面声波式.GSLX680 为电容式触摸屏,挂接在I2C总线上,通过I2C总 ...

6. FL2440移植LINUX-3.4.2 -- 按键驱动和触摸屏驱动移植

   (一)先移植按键输入子系统驱动: 拿过去编译,改错,然后insmod: (二)触摸屏驱动拿过去编译,改错,然后insmod: 触摸屏驱动的使用: 编译: tar xzf tslib-1.4.tar.g ...

7. 移植基于linux-2.6.26.5内核s3c2410触摸屏驱动移植

   移植基于linux-2.6.26.5内核s3c2410触摸屏驱动移植的过程记录下来: (1)首先打一个补丁:s3c2410_touchscreen.patch, 在内核解压的根目录下 patch -N ...

8. usb触摸屏驱动移植

   最近公司产品在原有基础上增加一个触摸功能,因电路已经定型,只有usb接口引出来,所以只能选用市面上usb接口的触摸屏,联系了多家触摸屏代理商,移植时都存在问题. 公司产品用的平台是: PXA270 + ...

9. NUC972触摸屏驱动移植过程分析（二）

   https://blog.csdn.net/b7376811/article/details/86607529 今天继续分析NUC972的触摸屏驱动移植过程,上一节主要分析了触摸屏需要数据,今天来分析 ...

10. SylixOS GSLX680触摸屏驱动移植

    GSLX680 触摸屏 触摸屏按照触摸屏的工作原理和传输信息的介质,可以分为四种,它们分别为电阻式.电容感应式.红外线式以及表面声波式.GSLX680 为电容式触摸屏,挂接在I2C总线上,通过I2C总 ...

最新文章

1. python分析基金数据,[Python数据分析]numpy基金会,基础
2. thymeleaf rs 查询结果_第十一章 JDBC与MySQL数据库(10)——通用查询
3. 【Ubuntu】安装Java和Eclipse
4. centos php5.3 yum 安装 php53-mcrypt
5. Apache ab测试工具使用方法（无参、get传参、post传参）
6. C++笔记——析构函数
7. dp笔记：关于DP算法和滚动数组优化的思考
8. python条件语句练习题_python学习-7 条件语句 while循环 + 练习题
9. Revit工作时处理CAD图层的5种方法，快get起来
10. 负载均衡与分布式网络存储技术简介
11. 攒机笔记十六：制作pe盘
12. 人脸检测——RetinaFace
13. 网红前端盼哥模拟面试总结
14. 程序员的996简史！我们是怎么一步步陷入996工作制的
15. 洛谷P1433 吃奶酪--Java解法(货郎担问题)
16. 基于matlab的有噪声语音信号处理,基于matlab的有噪声语音信号处理毕设
17. 如何导入本地镜像到阿里云ECS服务器
18. 【时间序列】自回归模型
19. 实战：用Concourse实现端到端的蓝绿部署
20. 青少年趣味编程之Mabot舞蹈派对机器人

热门文章

1. UE4如何贴混合贴图_八猴,Unity,UE4,还原SubstancePainter贴图
2. 二级计算机vfp知识,全国计算机vfp二级考试
3. c语言学生综合测评系统_学生综合评价系统
4. php的UDP攻击,phpddos应对 最近新起一种udp flood的攻击形式
5. 十大电子元器件及其相关基础知识
6. js去空格、去重函数
7. linux系统vmd软件如何使用,科学网—VMD (linux下分子可视化软件) - 刘雪静的博文...
8. “实时SPC软件”的“实时”性指什么？一探究竟！
9. 切莫止步于 TOGAF® 认证
10. 脑力大挑战，1分钟 Serverless 部署“线上魔方”赢魔方