TSP驱动理论与实例分析

---

前言

如果是从IIC协议跳转过来的，那么还需要了解一个 input 子系统。
触摸屏驱动虽然用的协议是 IIC，也就是说驱动架构是 IIC 驱动，但是在IIC驱动中又把任务都丢给了 input 子系统，而且还要再 IIC 消息中还包装硬件业务。
内核未修改过的源码位置：kernel/drivers/input/touchscreen/edt-ft5x06.c

先来了解一下 FT5x06系列的芯片。

内部框图如下：

与主控制器的连接示意图如下：

串行接口支持I2C（最大400KHz）和SPI，I2C的通信格式如下：

一、设备树编写

先上触屏芯片硬件原理图：


绿色的框框里就是IIC触屏模块的4个引脚，分别是：IIC时钟、IIC数据、中断引脚、复位引脚
知道这4个管脚之后，就可以直接配置设备树了吗？？？
那肯定不行啊，从机地址是多少？中断是什么电平触发？复位呢？这些都需要知道。还有就是要传给驱动什么参数好？例如屏幕大小，不传当然也可以，但是这些特定的东西在设备树解决明显就更好。这样驱动就可以用在不同大小的屏幕上了。

IIC设备地址：

I2C协议格式中slave address = chip address由7位地址D[7:1]组成 + 1位R/W读写位D[0]组成的。
I2C通用器件的器件地址=种类型号(D[7:4])+及寻址码D[3:1]组成的，共7位。

• 高4位代表器件类型：由D7-D4 决定的
  这是由半导公司生产时就已固定此类型的了，也就是说这4位已是固定的。
• 低3位：用户自定义地址码
  触屏芯片的数据手册直接就给出了：0111 000，这样的从机地址，那么可以确定生产商已经写死了从机地址了。
  0111 000 等价于16进制的：0x38
  那么设备树中的 reg 属性就为：reg = <0x38>;
  

复位管脚配置

可以看到管脚是 GPIO0_B6，这个先放一边，看芯片手册如何描述这个管脚。

没有过多的描述，就是没事干就把它置为低电平就可以，并且有事也是处理器给发信号，所以连接该管家的gpio是输出模式。
reset-gpio = <&gpio0 RK_PB6 GPIO_ACTIVE_LOW>; //引用gpio0 将RK_PB6号管脚设置为低电平

中断管脚配置

可以看到管脚是 GPIO3_A5，并且是向处理器输入的。这个先放一边，看芯片手册如何描述这个管脚。

reset-gpio = <&gpio0 RK_PB6 GPIO_ACTIVE_LOW>;    //引用gpio0 将RK_PB6号管脚设置为低电平

这个管脚有点厉害，整个屏幕，不管你碰到哪里，都会由这个管脚向处理器发送一个信号，处理器可以配置这个管脚的信号为中断信号。

芯片手册中的中断描述全在这里了。当有一个有效的触控点时，INT会被拉起，当触控结束时就会变低。
所以就可以确定为：屏幕被触碰，INT 引脚向处理器输出脉冲信号。
那么我们就配置GPIO3_A5 为输入模式，上升沿触发中断。

touch-gpio = <&gpio3 RK_PA5 IRQ_TYPE_EDGE_RISING>;    //这里很变态，直接对GPIO3_A5描述为上升沿触发中断，那么GPIO3_A5就是常态输入模式+低电平了……
interrupt-parent = <&gpio3>;                          //说明中断IO所属的组是 GPIO3
interrupts = <RK_PA5 IRQ_TYPE_LEVEL_LOW>;             //要区分上面的中断触发条件，这里设置RK_PA5 号管脚设置为低电平触发

对初学者来说，这里非常离谱，但是其实并离谱，因为一个描述 gpio3 控制器，一个是描述中断控制器，习惯一下，后面没有更离谱的了。

总体的设备树就可以确定了，如下：

/* 针对触屏芯片 ft5x06 的设备树 */
&i2c1 {
    status = "okay";
    ft5x061:ft5x06@38 {
                status = "okay";
                compatible = "edt,edt-ft5306";                       //驱动匹配名
                reg = <0x38>;                                        //IIC从机地址
                touch-gpio = <&gpio3 RK_PA5 IRQ_TYPE_EDGE_RISING>;
                interrupt-parent = <&gpio3>;
                interrupts = <RK_PA5 IRQ_TYPE_LEVEL_LOW>;            //中断信号输入管脚为GPIO3的A5
                reset-gpio = <&gpio0 RK_PB6 GPIO_ACTIVE_LOW>;        //复位输出管脚为GPIO0的B6
                /* 屏幕尺寸参数，这些属于厂商驱动实现的，我们需要改设备树即可*/
                touchscreen-size-x = <800>;
                touchscreen-size-y = <1280>;
                touch_type = <1>;
    };
};

/* 需要看 IIC1 控制器配置的可以看一下，下面两个是原厂配好的，我们需要会引用 */
i2c1 {
    /omit-if-no-ref/
    i2c1_xfer: i2c1-xfer {
        rockchip,pins =
            /* i2c1_scl */
            <0 RK_PB3 1 &pcfg_pull_none_smt>,
            /* i2c1_sda */
            <0 RK_PB4 1 &pcfg_pull_none_smt>;
     };
    };
i2c1: i2c@fe5a0000 {
        compatible = "rockchip,rk3399-i2c";
        reg = <0x0 0xfe5a0000 0x0 0x1000>;
        clocks = <&cru CLK_I2C1>, <&cru PCLK_I2C1>;
        clock-names = "i2c", "pclk";
        interrupts = <GIC_SPI 47 IRQ_TYPE_LEVEL_HIGH>;
        pinctrl-names = "default";
        pinctrl-0 = <&i2c1_xfer>;
        #address-cells = <1>;
        #size-cells = <0>;
        status = "disabled";
    };

二、驱动分析

注意一件事：工作的时候千万不要自己写驱动！！！
还有就是这个芯片中会有几种不同的工作模式，不同的工作模式所用的寄存器有差异，这个要根据芯片手册来实现。
但是成熟的芯片一般都是应用很广的，一般驱动工程师只需要知道它有这个功能，移植的时候可以避开迷惑就够了。

数据设定和数据结构

/* 触摸屏设备寄存器地址 */
#define WORK_REGISTER_THRESHOLD      0x00
#define WORK_REGISTER_REPORT_RATE    0x08
#define WORK_REGISTER_GAIN          0x30
#define WORK_REGISTER_OFFSET      0x31
#define WORK_REGISTER_NUM_X          0x33
#define WORK_REGISTER_NUM_Y          0x34
/* 触摸屏设备固件版本 */
#define M09_REGISTER_THRESHOLD     0x80
#define M09_REGISTER_GAIN         0x92
#define M09_REGISTER_OFFSET         0x93
#define M09_REGISTER_NUM_X         0x94
#define M09_REGISTER_NUM_Y         0x95
/* 无效寄存器 */
#define NO_REGISTER                 0xff
/*工作模式*/
#define WORK_REGISTER_OPMODE     0x3c
#define FACTORY_REGISTER_OPMODE     0x01
/*触摸事件*/
#define TOUCH_EVENT_DOWN         0x00    //按下
#define TOUCH_EVENT_UP             0x01    //抬起
#define TOUCH_EVENT_ON             0x02
    //接触
#define TOUCH_EVENT_RESERVED     0x03    //保留

#define EDT_NAME_LEN                23 //设备名长度
#define EDT_SWITCH_MODE_RETRIES        10 //切换I2C模式延时（命令模式，数据模式）
#define EDT_SWITCH_MODE_DELAY        5 /* msec */
#define EDT_RAW_DATA_RETRIES        100
//用于dev_dbg调试的重发次数
#define EDT_RAW_DATA_DELAY            1000 /* usec */

enum edt_ver {
    EDT_M06,
    EDT_M09,
    EDT_M12,
    GENERIC_FT,
};

struct edt_reg_addr {
    int reg_threshold;
    int reg_report_rate;
    int reg_gain;
    int reg_offset;
    int reg_num_x;
    int reg_num_y;
};

struct edt_ft5x06_ts_data {
    struct i2c_client *client;
    struct input_dev *input;
    struct touchscreen_properties prop;
 u16 num_x;
 u16 num_y;

    struct gpio_desc *reset_gpio;
    struct gpio_desc *wake_gpio;

#if defined(CONFIG_DEBUG_FS)
    struct dentry *debug_dir;
 u8 *raw_buffer;
 size_t raw_bufsize;
#endif

    struct mutex mutex;
    bool factory_mode;
    int threshold;
    int gain;
    int offset;
    int report_rate;
    int max_support_points;

    char name[EDT_NAME_LEN];

    struct edt_reg_addr reg_addr;
    enum edt_ver version;
};

struct edt_i2c_chip_data {
    int  max_support_points;
};

probe 解析

static int edt_ft5x06_ts_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
    const struct edt_i2c_chip_data *chip_data;
    struct edt_ft5x06_ts_data *tsdata;    //设备结构体
 u8 buf[2] = { 0xfc, 0x00 };           //用于I2C发送地址+读写位：fc00，0为写，1为读，先写入地址再接收回应
    struct input_dev *input;
              //输入设备
    unsigned long irq_flags;
              //中断号
    int error;
    char fw_version[EDT_NAME_LEN];        //固件版本名

    dev_dbg(&client->dev, "probing for EDT FT5x06 I2C\n");

 tsdata = devm_kzalloc(&client->dev, sizeof(*tsdata), GFP_KERNEL); //给设备（结构体）申请内核内存
    if (!tsdata) {
        dev_err(&client->dev, "failed to allocate driver data.\n");
        return -ENOMEM;
    }

 chip_data = of_device_get_match_data(&client->dev);    //匹配触摸屏设备数据
    if (!chip_data)
        chip_data = (const struct edt_i2c_chip_data *)id->driver_data;
    if (!chip_data || !chip_data->max_support_points) {
        dev_err(&client->dev, "invalid or missing chip data\n");
        return -EINVAL;
    }

 tsdata->max_support_points = chip_data->max_support_points; //多点触摸的最大点数

 tsdata->reset_gpio = devm_gpiod_get_optional(&client->dev,
"reset", GPIOD_OUT_HIGH); //获取复位管脚的GPIO描述符
    if (IS_ERR(tsdata->reset_gpio)) {
        error = PTR_ERR(tsdata->reset_gpio);
        dev_err(&client->dev,
"Failed to request GPIO reset pin, error %d\n", error);
        return error;
    }

 tsdata->wake_gpio = devm_gpiod_get_optional(&client->dev,
 "wake", GPIOD_OUT_LOW); //获取唤醒管脚的GPIO描述符
    if (IS_ERR(tsdata->wake_gpio)) {
        error = PTR_ERR(tsdata->wake_gpio);
        dev_err(&client->dev,
"Failed to request GPIO wake pin, error %d\n", error);
        return error;
    }

    if (tsdata->wake_gpio) {
        usleep_range(5000, 6000);    //延时可以接受的范围是0.05s~0.06s
        gpiod_set_value_cansleep(tsdata->wake_gpio, 1); 
        //在队列中等待访问引脚，可能会进入睡眠，不能作用于中断，访问必须通过消息总线比如I2C或者SPI，这些需要在队列中访问
        //设置为高电平
    }

    if (tsdata->reset_gpio) {
        usleep_range(5000, 6000);    //延时可以接受的范围是0.05s~0.06s
        gpiod_set_value_cansleep(tsdata->reset_gpio, 0); //设置为低电平
        msleep(300);    //延时300ms
    }

 input = devm_input_allocate_device(&client->dev);    //申请输入设备
    if (!input) {
        dev_err(&client->dev, "failed to allocate input device.\n");
        return -ENOMEM;
    }

    mutex_init(&tsdata->mutex);      //初始化设备锁
 tsdata->client = client;         //设置设备通信使用的 IIC 客户端
 tsdata->input = input;           //使用申请到的输入设备
 tsdata->factory_mode = false;    //不用工厂模式

 error = edt_ft5x06_ts_identify(client, tsdata, fw_version);    //可以不理
    if (error) {
        dev_err(&client->dev, "touchscreen probe failed\n");
        return error;
    }

    /*
  * Dummy read access. EP0700MLP1 returns bogus data on the first
  * register read access and ignores writes.伪读取访问。EP0700MLP1在第一次寄存器读取访问时返回伪数据并忽略写入。
  */
    edt_ft5x06_ts_readwrite(tsdata->client, 2, buf, 2, buf); //buf[2] = { 0xfc, 0x00 }，地址+读写位：fc00，0为写，1为读，先写入地址再接收回应

    edt_ft5x06_ts_set_regs(tsdata); //设置触摸屏设备的寄存器地址
    edt_ft5x06_ts_get_defaults(&client->dev, tsdata);
//获取设定的阈值、gain、偏移量并写入设备结构体
    edt_ft5x06_ts_get_parameters(tsdata); //获取触摸屏各种参数

    dev_dbg(&client->dev,
        "Model \"%s\", Rev. \"%s\", %dx%d sensors\n",
        tsdata->name, fw_version, tsdata->num_x, tsdata->num_y);

 input->name = tsdata->name; //输入设备的名字用触摸屏设备的名字
 input->id.bustype = BUS_I2C;
 //输入设备的总线类型
 input->dev.parent = &client->dev; //父设备指定为触摸屏设备的i2c设备

    if (tsdata->version == EDT_M06 ||
     tsdata->version == EDT_M09 ||
     tsdata->version == EDT_M12) {
        /* 设置上报的值的范围，dev：input_dev结构体
，axis：上报的数值，
min：最小值，
max：最大值，
fuzz：数据偏差值，
flat：平滑位置 */
        input_set_abs_params(input, ABS_MT_POSITION_X,
 0, tsdata->num_x * 64 - 1, 0, 0); //设置x坐标范围
        input_set_abs_params(input, ABS_MT_POSITION_Y,
 0, tsdata->num_y * 64 - 1, 0, 0); //设置y坐标范围
    } else {
        /* Unknown maximum values. Specify via devicetree */
        input_set_abs_params(input, ABS_MT_POSITION_X,
 0, 65535, 0, 0);
        input_set_abs_params(input, ABS_MT_POSITION_Y,
 0, 65535, 0, 0);
    }
 /* touchscreen_parse_properties 用于解析设备树的配置，除了管脚地址和复用，还有屏幕的各种参数 */

    touchscreen_parse_properties(input, true, &tsdata->prop);

 error = input_mt_init_slots(input, tsdata->max_support_points,
 INPUT_MT_DIRECT);  
    if (error) {
        dev_err(&client->dev, "Unable to init MT slots.\n");
        return error;
    }

    i2c_set_clientdata(client, tsdata);

 irq_flags = irq_get_trigger_type(client->irq); //获取中断类型
    if (irq_flags == IRQF_TRIGGER_NONE)
    irq_flags = IRQF_TRIGGER_FALLING; //没设置中断类型就设置成下降沿触发
    irq_flags |= IRQF_ONESHOT; //一次性中断请求标志位。当一个中断线路设置了这个标志位时，只有在中断处理程序完成之后才能再次触发该中断

/* 请求中断号，devm 的申请卸载设备会自动释放的 */
 error = devm_request_threaded_irq(&client->dev, client->irq,
                    NULL, edt_ft5x06_ts_isr, irq_flags,
                    client->name, tsdata);
    if (error) {
        dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
        return error;
    }
 /* 设备文件增加到组中,就是再加一层目录封装*/

 error = devm_device_add_group(&client->dev, &edt_ft5x06_attr_group);
    if (error)
        return error;

 error = input_register_device(input); //注册输入设备
    if (error)
        return error;

    edt_ft5x06_ts_prepare_debugfs(tsdata, dev_driver_string(&client->dev));
    device_init_wakeup(&client->dev, 1); //唤醒触摸屏设备

    dev_dbg(&client->dev,
        "EDT FT5x06 initialized: IRQ %d, WAKE pin %d, Reset pin %d.\n",
        client->irq,
        tsdata->wake_gpio ? desc_to_gpio(tsdata->wake_gpio) : -1,
        tsdata->reset_gpio ? desc_to_gpio(tsdata->reset_gpio) : -1);

    return 0;
}

一些解析：

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

初始化 MT 的输入，使用前必须先初始化。
slots，num_slots：设备要使用的 SLOT 数量，也就是触摸点的数量
flags：其他一些 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_UNUSED0x0004 / 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

struct gpio_desc *__must_check 
evm_gpiod_get_index(struct device *dev,        //设备节点
                    const char *con_id,        //设备树中 GPIO 的名字
                    enum gpiod_flags flags);   //GPIO方向和状态的标志，例如输入、输出、上拉、下拉
/* 返回一个指向 struct gpio_desc 的指针，表示获取的 GPIO 描述符 */

devm_gpiod_get_optional -> 
　devm_gpiod_get_index_optional -> //index为0 
　　devm_gpiod_get_index -> 
　　　gpiod_get_index

int desc_to_gpio(const struct gpio_desc *desc)
struct gpio_desc *gpio_to_desc(unsigned gpio)
/* 旧的 GPIO 系统使用基于标号的结构而不是基于描述符。可以使用如下两个函数进行相互转换 */

硬件相关基础设定

（非半导体厂不用理会）

static void
edt_ft5x06_ts_set_regs(struct edt_ft5x06_ts_data *tsdata)
{
    struct edt_reg_addr *reg_addr = &tsdata->reg_addr;

    switch (tsdata->version) {
    case EDT_M06:
        reg_addr->reg_threshold = WORK_REGISTER_THRESHOLD;
        reg_addr->reg_report_rate = WORK_REGISTER_REPORT_RATE;
        reg_addr->reg_gain = WORK_REGISTER_GAIN;
        reg_addr->reg_offset = WORK_REGISTER_OFFSET;
        reg_addr->reg_num_x = WORK_REGISTER_NUM_X;
        reg_addr->reg_num_y = WORK_REGISTER_NUM_Y;
        break;

    case EDT_M09:
    case EDT_M12:
        reg_addr->reg_threshold = M09_REGISTER_THRESHOLD;
        reg_addr->reg_report_rate = NO_REGISTER;
        reg_addr->reg_gain = M09_REGISTER_GAIN;
        reg_addr->reg_offset = M09_REGISTER_OFFSET;
        reg_addr->reg_num_x = M09_REGISTER_NUM_X;
        reg_addr->reg_num_y = M09_REGISTER_NUM_Y;
        break;

    case GENERIC_FT:
        /* this is a guesswork */
        reg_addr->reg_threshold = M09_REGISTER_THRESHOLD;
        reg_addr->reg_gain = M09_REGISTER_GAIN;
        reg_addr->reg_offset = M09_REGISTER_OFFSET;
        break;
    }
}

IIC读取函数解析

static int 
edt_ft5x06_ts_readwrite(struct i2c_client *client,
                        u16 wr_len, u8 *wr_buf,
                        u16 rd_len, u8 *rd_buf)
{
    struct i2c_msg wrmsg[2];
    int i = 0;
    int ret;

    if (wr_len) {
        wrmsg[i].addr  = client->addr;    //I2C器件地址
        wrmsg[i].flags = 0;               //标记为发送
        wrmsg[i].len = wr_len;            //地址长度
        wrmsg[i].buf = wr_buf;            //要写的地址
        i++;                              //写完用第二个缓存区去读数据
    }
    if (rd_len) {
        wrmsg[i].addr  = client->addr;
        wrmsg[i].flags = I2C_M_RD;        //标记为读数据
        wrmsg[i].len = rd_len;            //数据长度
        wrmsg[i].buf = rd_buf;            //用来装
读取的数据
        i++;
    }

 ret = i2c_transfer(client->adapter, wrmsg, i);
    if (ret < 0)
        return ret;
    if (ret != i)
        return -EIO;

    return 0;
}
/* 选择寄存器地址写入数据 */
static int edt_ft5x06_register_write(struct edt_ft5x06_ts_data *tsdata,
 u8 addr, u8 value)
{
 u8 wrbuf[4];

    switch (tsdata->version) {
    case EDT_M06:
        wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc;
        wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f;
        wrbuf[2] = value;
        wrbuf[3] = wrbuf[0] ^ wrbuf[1] ^ wrbuf[2];
        return edt_ft5x06_ts_readwrite(tsdata->client, 4,
 wrbuf, 0, NULL);
    case EDT_M09:
    case EDT_M12:
    case GENERIC_FT:            //这个多正常啊，直接地址和数据解决
        wrbuf[0] = addr;
        wrbuf[1] = value;

        return edt_ft5x06_ts_readwrite(tsdata->client, 2,
 wrbuf, 0, NULL);

    default:
        return -EINVAL;
    }
}

static int edt_ft5x06_register_read(struct edt_ft5x06_ts_data *tsdata,
 u8 addr)
{
 u8 wrbuf[2], rdbuf[2];
    int error;
 

    switch (tsdata->version) {
    case EDT_M06:
        wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc;
        wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f;
        wrbuf[1] |= tsdata->factory_mode ? 0x80 : 0x40;

        error = edt_ft5x06_ts_readwrite(tsdata->client, 2, wrbuf, 2,
 rdbuf);
        if (error)
            return error;

        if ((wrbuf[0] ^ wrbuf[1] ^ rdbuf[0]) != rdbuf[1]) {
            dev_err(&tsdata->client->dev,
"crc error: 0x%02x expected, got 0x%02x\n",
                wrbuf[0] ^ wrbuf[1] ^ rdbuf[0],
 rdbuf[1]);
            return -EIO;
        }
        break;

    case EDT_M09:
    case EDT_M12:
    case GENERIC_FT:            //直接地址过去，数据过来
        wrbuf[0] = addr;
        error = edt_ft5x06_ts_readwrite(tsdata->client, 1,
 wrbuf, 1, rdbuf);
        if (error)
            return error;
        break;

    default:
        return -EINVAL;
    }

    return rdbuf[0];    //返回读取到的数据
}

设备模型添加

/* 这部分注册了多个文件，用于读写对应寄存器的值，方便驱动调试和应用开发，非常精彩 */
static ssize_t edt_ft5x06_setting_show(struct device *dev,
 struct device_attribute *dattr,
char *buf)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
    struct edt_ft5x06_attribute *attr =
container_of(dattr, struct edt_ft5x06_attribute, dattr);
 u8 *field = (u8 *)tsdata + attr->field_offset;
    int val;
 size_t count = 0;
    int error = 0;
 u8 addr;

    mutex_lock(&tsdata->mutex);

    if (tsdata->factory_mode) {
        error = -EIO;
        goto out;
    }

    switch (tsdata->version) {
    case EDT_M06:
        addr = attr->addr_m06;
        break;

    case EDT_M09:
    case EDT_M12:
    case GENERIC_FT:
        addr = attr->addr_m09;
        break;

    default:
        error = -ENODEV;
        goto out;
    }

    if (addr != NO_REGISTER) {
     val = edt_ft5x06_register_read(tsdata, addr);
     if (val < 0) {
         error = val;
         dev_err(&tsdata->client->dev,
"Failed to fetch attribute %s, error %d\n",
 dattr->attr.name, error);
         goto out;
     }
    } else
        val = *field;


    if (val != *field) {
     dev_warn(&tsdata->client->dev,
"%s: read (%d) and stored value (%d) differ\n",
 dattr->attr.name, val, *field);
     *field = val;
    }

 count = scnprintf(buf, PAGE_SIZE, "%d\n", val);

out:
    mutex_unlock(&tsdata->mutex);
    return error ?: count;
}

static ssize_t edt_ft5x06_setting_store(struct device *dev,
struct device_attribute *dattr,
const char *buf, size_t count)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
    struct edt_ft5x06_attribute *attr =
container_of(dattr, struct edt_ft5x06_attribute, dattr);
 u8 *field = (u8 *)tsdata + attr->field_offset;
    unsigned int val;
    int error;
 u8 addr;

    mutex_lock(&tsdata->mutex);

    if (tsdata->factory_mode) {
        error = -EIO;
        goto out;
    }

 error = kstrtouint(buf, 0, &val);
    if (error)
        goto out;

    if (val < attr->limit_low || val > attr->limit_high) {
        error = -ERANGE;
        goto out;
    }

    switch (tsdata->version) {
    case EDT_M06:
        addr = attr->addr_m06;
        break;

    case EDT_M09:
    case EDT_M12:
    case GENERIC_FT:
        addr = attr->addr_m09;
        break;

    default:
        error = -ENODEV;
        goto out;
    }

    if (addr != NO_REGISTER) {
    error = edt_ft5x06_register_write(tsdata, addr, val);
    if (error) {
        dev_err(&tsdata->client->dev,
"Failed to update attribute %s, error: %d\n",
 dattr->attr.name, error);
        goto out;
    }
    }
    *field = val;

out:
    mutex_unlock(&tsdata->mutex);
    return error ?: count;
}

struct edt_ft5x06_attribute {
    struct device_attribute dattr;
    size_t field_offset;
    u8 limit_low;
    u8 limit_high;
    u8 addr_m06;
    u8 addr_m09;
};

#define EDT_ATTR(_field, _mode, _addr_m06, _addr_m09,            \
        _limit_low, _limit_high)                \
    struct edt_ft5x06_attribute edt_ft5x06_attr_##_field = {    \
        .dattr = __ATTR(_field, _mode,                \
                edt_ft5x06_setting_show,        \
                edt_ft5x06_setting_store),        \
        .field_offset = offsetof(struct edt_ft5x06_ts_data, _field), \
        .addr_m06 = _addr_m06,                    \
        .addr_m09 = _addr_m09,                    \
        .limit_low = _limit_low,                \
        .limit_high = _limit_high,                \
    }

/* m06, m09: range 0-31, m12: range 0-5 */
static EDT_ATTR(gain, S_IWUSR | S_IRUGO, WORK_REGISTER_GAIN,
        M09_REGISTER_GAIN, 0, 31);
/* m06, m09: range 0-31, m12: range 0-16 */
static EDT_ATTR(offset, S_IWUSR | S_IRUGO, WORK_REGISTER_OFFSET,
        M09_REGISTER_OFFSET, 0, 31);
/* m06: range 20 to 80, m09: range 0 to 30, m12: range 1 to 255... */
static EDT_ATTR(threshold, S_IWUSR | S_IRUGO, WORK_REGISTER_THRESHOLD,
        M09_REGISTER_THRESHOLD, 0, 255);
/* m06: range 3 to 14, m12: (0x64: 100Hz) */
static EDT_ATTR(report_rate, S_IWUSR | S_IRUGO, WORK_REGISTER_REPORT_RATE,
        NO_REGISTER, 0, 255);

static struct attribute *edt_ft5x06_attrs[] = {
    &edt_ft5x06_attr_gain.dattr.attr,
    &edt_ft5x06_attr_offset.dattr.attr,
    &edt_ft5x06_attr_threshold.dattr.attr,
    &edt_ft5x06_attr_report_rate.dattr.attr,
    NULL
};

static const struct attribute_group edt_ft5x06_attr_group = {
    .attrs = edt_ft5x06_attrs,
};

中断服务函数

static irqreturn_t edt_ft5x06_ts_isr(int irq, void *dev_id)
{
    struct edt_ft5x06_ts_data *tsdata = dev_id;
    struct device *dev = &tsdata->client->dev;
    u8 cmd;
 u8 rdbuf[63];
    int i, type, x, y, id;
    int offset, tplen, datalen, crclen;
    int error;

    switch (tsdata->version) {
    case EDT_M06:
        cmd = 0xf9; /* tell the controller to send touch data */
        offset = 5; /* where the actual touch data starts */
        tplen = 4;  /* data comes in so called frames */
        crclen = 1; /* length of the crc data */
        break;

    case EDT_M09:
    case EDT_M12:
    case GENERIC_FT:
        cmd = 0x0;     //请求发送触点数据
        offset = 3;    //偏移1位，也就是从 0x00+3开始是触摸值
        tplen = 6;     //一个触点有6个寄存器来保存触摸值
        crclen = 0;    //不校验
        break;

    default:
        goto out;
    }

    memset(rdbuf, 0, sizeof(rdbuf));
 datalen = tplen * tsdata->max_support_points + offset + crclen; //一帧数据的长度
 /*读取 cmd 返回的数据 */

 error = edt_ft5x06_ts_readwrite(tsdata->client,
sizeof(cmd), &cmd,
 datalen, rdbuf);
 if (error) {
        dev_err_ratelimited(dev, "Unable to fetch data, error: %d\n",
 error);
        goto out;
    }

    /* M09/M12 does not send header or CRC */
    if (tsdata->version == EDT_M06) {
        if (rdbuf[0] != 0xaa || rdbuf[1] != 0xaa ||
 rdbuf[2] != datalen) {
            dev_err_ratelimited(dev,
"Unexpected header: %02x%02x%02x!\n",
                    rdbuf[0], rdbuf[1], rdbuf[2]);
            goto out;
        }

        if (!edt_ft5x06_ts_check_crc(tsdata, rdbuf, datalen))
            goto out;
    }
 /*处理多个点的数据 */
    for (i = 0; i < tsdata->max_support_points; i++) {
        u8 *buf = &rdbuf[i * tplen + offset];
        bool down;

        type = buf[0] >> 6;            //先获取触摸类型
        /* ignore Reserved events */
        if (type == TOUCH_EVENT_RESERVED) //没意义的直接不理
            continue;

        /* M06 sometimes sends bogus coordinates in TOUCH_DOWN */
        if (tsdata->version == EDT_M06 && type == TOUCH_EVENT_DOWN)
            continue;
        //buf:[i * tplen + offset]，需要结合帧数据格式分析

        x = ((buf[0] << 8) | buf[1]) & 0x0fff;    //x坐标，只要前3个字节，4个位左移8位会变成12个位
        y = ((buf[2] << 8) | buf[3]) & 0x0fff;    //y坐标，只要前3个字节，同理
        id = (buf[2] >> 4) & 0x0f;                //触点id值，只要一个字节，这么，只要一个数字而已
        down = type != TOUCH_EVENT_UP;
        /*此函数用于 Type B 类型，此函数用于产生 ABS_MT_SLOT 事件，告诉内核当前上报的是哪个触摸点的坐标数据
        slot：当前发送的是哪个 slot 的坐标信息，也就是哪个触摸点
        */

        input_mt_slot(tsdata->input, id);
        /*此函数用于 Type B 类型，用于产生 ABS_MT_TRACKING_ID 和 ABS_MT_TOOL_TYPE 事件， ABS_MT_TRACKING_ID 事 件 给 slot 关联一个 ABS_MT_TRACKING_ID ，
        ABS_MT_TOOL_TYPE 事件指定触摸类型（可以选择 MT_TOOL_FINGER(手指)、MT_TOOL_PEN(笔)或MT_TOOL_PALM(手掌)，对于多点电容触摸屏来说一般都是手指）
        active：true，连续触摸，input 子系统内核会自动分配一个 ABS_MT_TRACKING_ID 给 slot。
false，触摸点抬起，表示某个触摸点无效了，input 子系统内核会分配一个-1 给 slot，表示触摸
点溢出。
        */
        input_mt_report_slot_state(tsdata->input, MT_TOOL_FINGER, down);

        if (!down)
            continue;
        /* 坐标上报函数，可以直接调用input_report_abs进行更灵活的上报 */

        touchscreen_report_pos(tsdata->input, &tsdata->prop, x, y,
 true);
    }
 /*如果追踪到的触摸点数量多于当前上报的数量，驱动程序使用 BTN_TOOL_TAP 事件来通
 知用户空间当前追踪到的触摸点总数量，然后调用 input_mt_report_pointer_emulation 函数将
 use_count 参数设置为 false。否则将 use_count 参数设置为 true，表示当前的触摸点数量有效。
 */

    input_mt_report_pointer_emulation(tsdata->input, true); 
    input_sync(tsdata->input); //同步信号

out:
    return IRQ_HANDLED;
}

关于上面为什么 x、y 坐标是三个字节？
数据手册中已经给出了答案，从 0x03到0x04两个地址中的数据共16位，其中 [11:0] 12位是第一个触点的 X 坐标。其他的同理。
然后为什么要移8个位呢？因为实际数据只有一个字节，要凑3个字节，当然，和控制器的读写顺序有关，这部分就不是我们非原厂驱动工程师该管的了。

总结

1. 注册 i2c_driver
2. probe中：
   a. 硬件初始化
   b. 设置中断和中断服务函数
   c. 创建设备模型和属性
   d. 注册 input 设备：input_register_device()
3. 编写中断服务函数
   a. 使用IIC协议去读取从机的数据
   b. 上报输入事件和数据
   
   
   我们需要实现的是设备树、i2c_client、i2c_driver、input_dev。

本驱动相对于原版驱动的改动

注意：右边是原版

增加了几个固件版本，M06是很难用的一个版本；如果没有要求兼容多个固件版本，直接去掉版本兼容相关的程序，实际功能并不会收到影响。

增加触屏设备文件属性

M09、M12、通用版本采用相同的触点上报规则

两个函数都是上报坐标信息，但是原版显然更灵活

EDT_ATTR() 用于声明属性文件结构体，参数从左到右分别是：field、_mode、_addr_m06、_addr_m09、limit_low、limit_high
用于查询设备数据偏移量、工作模式、固件版本、阈值限制


版本控制，没什么好说的

没预设数据就从设备里面请求

获取 x、y 的最大值，也就是屏幕大小

设置触摸屏设备中的寄存器地址，后期通过I2C从这些地址中获取数据
probe ：

input_set_abs_params 将设备树上的屏幕尺寸设置给了输入设备。
原驱动中因为没有固定哪个版本的芯片，所以没有指定特定的输入设备数据，移植驱动时需要添加必要的输入设备数据。

本质上没有区别，使用 devm 前缀的API申请资源会在设备被卸载时自动清理。

使用 devm 前缀的API申请资源不需要释放。

修改最大触点支持、传统设备匹配方法、设备匹配方法。

将驱动添加到内核

将驱动添加到内核，系统启动时就会自动挂载，不需要再手动挂载了。

1. 将驱动文件放到合适的位置
   ft5x06.c 是个触摸屏驱动，linux 内核里将触摸屏驱动放到了 drivers/input/touchscreen 目录下，因此将 ft5x06.c 也拷贝到此目录下。
2. 修改Makefile
   修改 drivers/input/touchscreen 目录下的 Makefile，在最下面添加一行：

obj-y += ft5x06.o

这样就将驱动文件添加进了内核编译。修改完成以后重新编译 linux 内核，然后用新的 uImage 启动开发板。如果驱动添加成功，系统启动的时候就会输出下图信息：

tslib 移植与使用

tslib 是一个开源的第三方库，用于触摸屏性能调试，使用电阻屏的时候一般使用 tslib 进行校准。虽然电容屏不需要校准，但是由于电容屏加工的原因，有的时候其不一定精准，因此有时候也需要进行校准。
移植部分在之前的《input 子系统理论与实例分析》中有链接。

在 buildroot 的 menuconfig 中使能 tslib 库：

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

然后使用sudo make编译出文件系统，并解压到 nfs 的对应目录即可。

使用内核自带的驱动

内核自带的 FT5426 的驱动文件为 drivers/input/touchscreen/edt-ft5x06.c，此驱动文件不仅能够驱动 FT5426，FT5206、FT5406 这些都可以驱动。
先将之前添加进内核编译的自己的驱动去除，将Makefile中添加的命令去掉即可。

1. 使能内核自带的 FT5X06 驱动

在 Linux 内核的 menuconfig 进行使能：

2. 修改设备树
   修改之前编写的 ft5426 设备节点，添加 compatible 属性。edt-ft5x06.c 所支持的 compatible 属性列表如下：
   
   将 compatible 属性修改为某一个兼容值即可。

ft5426: ft5426@38 {
	status = "okay";
    compatible = "edt,edt-ft5306";                       //驱动匹配名
    reg = <0x38>;                                        //IIC从机地址
    touch-gpio = <&gpio3 RK_PA5 IRQ_TYPE_EDGE_RISING>;
    interrupt-parent = <&gpio3>;
    interrupts = <RK_PA5 IRQ_TYPE_LEVEL_LOW>;            //中断信号输入管脚为GPIO3的A5
    reset-gpio = <&gpio0 RK_PB6 GPIO_ACTIVE_LOW>;        //复位输出管脚为GPIO0的B6
    touchscreen-size-x = <800>;
    touchscreen-size-y = <1280>;
    touch_type = <1>;
};

其他参考资料
某个课程设计：https://blog.csdn.net/zhoyixing/article/details/9380377
正点原子触摸屏驱动的讲解：http://www.taodudu.cc/news/show-5456347.html?action=onClick
https://it.cha138.com/shida/show-460929.html
https://blog.51cto.com/u_15688123/5870443