目录
1 input子系统整体架构
2 input子系统驱动框架分析
2.1 怎么添加input_dev
2.2 input_dev和input_handler匹配后，connec函数做了什么
3 input子系统读数据流程
3.1 open输入设备流程
3.2 read读取输入事件流程
4 应用程序读取的输入数据是怎样的
4.1 type：表示哪类事件
4.2 code:表示该类事件下的哪一个事件
4.3 value：表示事件值
4.4 事件之间的界线
5 APP读取输入事件代码
5.1 get_input_info.c
5.2 input_read.c
5.3 input_read_poll.c
5.4 input_read_select.c
5.5 input_read_fasync.c
6 input应用程序调试技巧
6.1 确定设备信息
6.2使用命令读取数据
7 tslib
7.1 tslib框架分析
7.2交叉编译、测试tslib
7.2.1 交叉编译tslib
7.2.2 测试tslib
7.3 使用tslib编写程序
参考文献：
根据费曼学习法把知识点讲出来能够加深自己对知识点的理解，于是我录制了一个讲解input输入子系统框架的学习视频：
1 input子系统整体架构
如上图所示是Linux内核中input子系统的整体架构图，
- 用户空间：用户可以直接用open,read,write访问输入设备，也可以利用tslib等一些库来使用输入设备。
- input handler事件处理层：用户往下首先是input handler事件处理层，该层用于处理下面核心层上报的输入事件，然后往上给用户空间提供访问接口。
- input 核心层：input核心层起到一个承上启下的作用，接受来自底层的输入事件转发给上层的handler，另外核心层还定义了一些注册函数。
- input device输入设备层：这一层是硬件相关的驱动，从硬件获得数据，转换为标准的输入事件，然后向上汇报。
2 input子系统驱动框架分析
如上图所示为输入子系统的设备层，核心层和处理层之间的关系，当我们用input_register_handler 函数添加handler的时候，会将其添加到input.c里面的一个链表中，同样当我们用input_register_device添加input_dev的时候，会将其添加到input.c的input_dev链表中，然后无论是我们添加handler还是添加device，内核都会对两者进行match，当发现某个device和handler相匹配的时候，就会调用handler里面的connect函数，然后再connect函数里面去申请input_handle结构体，这个input_handle结构体里面保存着匹配的input_handler和input_dev。
2.1 怎么添加input_dev
接下来将分别看一下我们怎么添加input_dev也就是上图中的左下角的input_dev是怎么被添加上的，然后再看一下右边connect函数内部的细节。
上图是以内核中的按键输入驱动为例，看一下是怎么添加input_dev的，从左边可以看到，首先我们编写设备树文件，然后设备树文件会被解析成platform_device，然后利用函数of_device_add添加到platform_bus_type的设备链表中，然后我们还会编写一个platform_driver驱动结构体，然后利用platform_driver_register函数将驱动注册内核中，无论我们添加驱动还是添加设备，内核都会去对设备和驱动进行匹配，匹配成功后就会调用驱动结构体里面的probe函数，也就是上图中的gpio_keys_probe函数，然后在probe函数中ongoing会申请input_dev结构体，并且利用input_register_device函数将设备注册到input系统的设备链表中。
上图是以内核中的I2C接口的触摸屏驱动为例，看一下怎么添加input_dev的，这个图和前面的按键那个图类似，注意区别就是，对于i2c设备来说，它是挂载i2c_bus_type上面的不是platform_bus上的，其他的地方是类似的，就不再赘述了。
这里需要补充的一点是在connect函数中还有一个gtp_request_irq(ts);函数，这里是申请中断的，然后进一步调用了ret = request_threaded_irq(ts->client->irq, NULL,gtp_irq_handler,ts->pdata->irq_flags | IRQF_ONESHOT,ts->client->name,ts);函数，这里设置了中断处理函数是gtp_irq_handler，在gtp_irq_handler函数里面就是真正读取触摸屏数据的最底层的硬件函数了，里面就是调用i2c_transfer函数读取数据的了。
2.2 input_dev和input_handler匹配后，connec函数做了什么
前面看了怎么把input_dev添加到内核中，接下来看一下当input_dev和input_handler匹配后调用connect函数内部的细节，上图就是connect函数内部细节流程，
在connect函数里面我们可以猜一下，无非就是分配、设置、注册结构体，具体看一下里面，首先是申请了一个evdev结构体，然后我们可以看到这个evdev结构体里面又包含了input_handle结构体，然后这个input_handle结构体里面有两个重要成员就是input_dev和input_handler,这两个就是用来保存匹配的input_dev和input_handler的；
再往下可以看到list_add_tail_rcu(&handle->d_node, &dev->h_list);和list_add_tail_rcu(&handle->h_node, &handler->h_list);，这两个函数的意思就是把handle又分别保存到了input_handler和input_dev的链表中了。
再往下就是注册字符设备驱动程序，其中包含一个file_operations结构体，那么当应用程序调用open/read/write函数的时候就会调用这里的file_ops结构体里面的函数。
3 input子系统读数据流程
接下来我们看一下读取input输入事件数据的流程，先看一下open的流程。
3.1 open输入设备流程
上图就是open打开输入设备的流程，当我们调用open函数时，进一步会调用evdev_fops结构体里面的evdev_open函数，这个函数里面首先申请一个client，这个client就对应着我们的用户程序，然后会将这个client和evdev进行绑定，也就是把用户和输入设备绑定了。
3.2 read读取输入事件流程
如上图所示是read流程，先从最上面开始看，当应用程序调用read函数时，进一步会调用到evdev_read函数，然后在evdev_read函数中，如果有数据那么直接读取，如果没有数据，那么休眠等待。
好了，接下来再从图的最下面往上看，前面说了没数据就休眠，然后过一会硬件输入设备被操作了或者被按下了，然后就会产生中断，这时候就会进入中断处理函数，然后就会利用处理函数gpio_keys_gpio_work_func进行处理，然后这个函数一层层看下去最终就是调用input_event上报输入事件。
然后input_event其实就是核心层了，然后看一下input_event函数做了什么，这个函数一层层调用最终是调用到了input_to_handler函数，这个函数的源码大体可以看到，如果input_handler定义了filter就用filter函数处理，如果定义了input_handler->events函数那就用events函数处理，这里就是用events处理的。
那么这时候就去看input_handler->events函数，这个函数里面利用__pass_event(client, &event);把数据传给client,这个client是在open时候分配的。然后唤醒前面休眠的程序，这时候evdev_read函数就会被唤醒，然后读取输入事件。
至此，输入事件的read过程结束。
4 应用程序读取的输入数据是怎样的
应用程序得到的其实是一系列的输入事件，就是一个一个“struct input_event”，它定义如下：
每个输入事件input_event中都含有发生时间：timeval表示的是“自系统启动以来过了多少时间”，它是一个结构体，含有“tv_sec、tv_usec”两项(即秒、微秒)。
输入事件input_event中更重要的是：type(哪类事件)、code(哪个事件)、value(事件值)，细讲如下：
4.1 type：表示哪类事件
比如EV_KEY表示按键类、EV_REL表示相对位移(比如鼠标)，EV_ABS表示绝对位置(比如触摸屏)。有这几类事件(参考Linux内核头文件)：
4.2 code:表示该类事件下的哪一个事件
比如对于EV_KEY(按键)类事件，它表示键盘。键盘上有很多按键，比如数字键1、2、3，字母键A、B、C里等。所以可以有这些事件：
对于触摸屏，它提供的是绝对位置信息，有X方向、Y方向，还有压力值。所以code值有这些：
4.3 value：表示事件值
对于按键，它的value可以是0(表示按键被按下)、1(表示按键被松开)、2(表示长按)；
对于触摸屏，它的value就是坐标值、压力值。
4.4 事件之间的界线
APP读取数据时，可以得到一个或多个数据，比如一个触摸屏的一个触点会上报X、Y位置信息，也可能会上报压力值。
APP怎么知道它已经读到了完整的数据？
驱动程序上报完一系列的数据后，会上报一个“同步事件”，表示数据上报完毕。APP读到“同步事件”时，就知道已经读完了当前的数据。
同步事件也是一个input_event结构体，它的type、code、value三项都是0。
5 APP读取输入事件代码
5.1 get_input_info.c
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
/* ./01_get_input_info /dev/input/event0 */
int main(int argc, char **argv)
{
int fd;
int err;
int len;
int i;
unsigned char byte;
int bit;
struct input_id id;
unsigned int evbit[2];
char *ev_names[] = {
"EV_SYN ",
"EV_KEY ",
"EV_REL ",
"EV_ABS ",
"EV_MSC ",
"EV_SW ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"EV_LED ",
"EV_SND ",
"NULL ",
"EV_REP ",
"EV_FF ",
"EV_PWR ",
};
if (argc != 2)
{
printf("Usage: %s <dev>\n", argv[0]);
return -1;
}
fd = open(argv[1], O_RDWR);
if (fd < 0)
{
printf("open %s err\n", argv[1]);
return -1;
}
err = ioctl(fd, EVIOCGID, &id);
if (err == 0)
{
printf("bustype = 0x%x\n", id.bustype );
printf("vendor = 0x%x\n", id.vendor );
printf("product = 0x%x\n", id.product );
printf("version = 0x%x\n", id.version );
}
len = ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
if (len > 0 && len <= sizeof(evbit))
{
printf("support ev type: ");
for (i = 0; i < len; i++)
{
byte = ((unsigned char *)evbit)[i];
for (bit = 0; bit < 8; bit++)
{
if (byte & (1<<bit)) {
printf("%s ", ev_names[i*8 + bit]);
}
}
}
printf("\n");
}
return 0;
}
5.2 input_read.c
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
/* ./01_get_input_info /dev/input/event0 noblock */
int main(int argc, char **argv)
{
int fd;
int err;
int len;
int i;
unsigned char byte;
int bit;
struct input_id id;
unsigned int evbit[2];
struct input_event event;
char *ev_names[] = {
"EV_SYN ",
"EV_KEY ",
"EV_REL ",
"EV_ABS ",
"EV_MSC ",
"EV_SW ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"EV_LED ",
"EV_SND ",
"NULL ",
"EV_REP ",
"EV_FF ",
"EV_PWR ",
};
if (argc < 2)
{
printf("Usage: %s <dev> [noblock]\n", argv[0]);
return -1;
}
if (argc == 3 && !strcmp(argv[2], "noblock"))
{
fd = open(argv[1], O_RDWR | O_NONBLOCK);
}
else
{
fd = open(argv[1], O_RDWR);
}
if (fd < 0)
{
printf("open %s err\n", argv[1]);
return -1;
}
err = ioctl(fd, EVIOCGID, &id);
if (err == 0)
{
printf("bustype = 0x%x\n", id.bustype );
printf("vendor = 0x%x\n", id.vendor );
printf("product = 0x%x\n", id.product );
printf("version = 0x%x\n", id.version );
}
len = ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
if (len > 0 && len <= sizeof(evbit))
{
printf("support ev type: ");
for (i = 0; i < len; i++)
{
byte = ((unsigned char *)evbit)[i];
for (bit = 0; bit < 8; bit++)
{
if (byte & (1<<bit)) {
printf("%s ", ev_names[i*8 + bit]);
}
}
}
printf("\n");
}
while (1)
{
len = read(fd, &event, sizeof(event));
if (len == sizeof(event))
{
printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\n", event.type, event.code, event.value);
}
else
{
printf("read err %d\n", len);
}
}
return 0;
}
5.3 input_read_poll.c
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <poll.h>
/* ./01_get_input_info /dev/input/event0 */
int main(int argc, char **argv)
{
int fd;
int err;
int len;
int ret;
int i;
unsigned char byte;
int bit;
struct input_id id;
unsigned int evbit[2];
struct input_event event;
struct pollfd fds[1];
nfds_t nfds = 1;
char *ev_names[] = {
"EV_SYN ",
"EV_KEY ",
"EV_REL ",
"EV_ABS ",
"EV_MSC ",
"EV_SW ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"EV_LED ",
"EV_SND ",
"NULL ",
"EV_REP ",
"EV_FF ",
"EV_PWR ",
};
if (argc != 2)
{
printf("Usage: %s <dev>\n", argv[0]);
return -1;
}
fd = open(argv[1], O_RDWR | O_NONBLOCK);
if (fd < 0)
{
printf("open %s err\n", argv[1]);
return -1;
}
err = ioctl(fd, EVIOCGID, &id);
if (err == 0)
{
printf("bustype = 0x%x\n", id.bustype );
printf("vendor = 0x%x\n", id.vendor );
printf("product = 0x%x\n", id.product );
printf("version = 0x%x\n", id.version );
}
len = ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
if (len > 0 && len <= sizeof(evbit))
{
printf("support ev type: ");
for (i = 0; i < len; i++)
{
byte = ((unsigned char *)evbit)[i];
for (bit = 0; bit < 8; bit++)
{
if (byte & (1<<bit)) {
printf("%s ", ev_names[i*8 + bit]);
}
}
}
printf("\n");
}
while (1)
{
fds[0].fd = fd;
fds[0].events = POLLIN;
fds[0].revents = 0;
ret = poll(fds, nfds, 5000);
if (ret > 0)
{
if (fds[0].revents == POLLIN)
{
while (read(fd, &event, sizeof(event)) == sizeof(event))
{
printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\n", event.type, event.code, event.value);
}
}
}
else if (ret == 0)
{
printf("time out\n");
}
else
{
printf("poll err\n");
}
}
return 0;
}
5.4 input_read_select.c
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>
/* According to earlier standards */
#include <sys/time.h>
/* ./01_get_input_info /dev/input/event0 */
int main(int argc, char **argv)
{
int fd;
int err;
int len;
int ret;
int i;
unsigned char byte;
int bit;
struct input_id id;
unsigned int evbit[2];
struct input_event event;
int nfds;
struct timeval tv;
fd_set readfds;
char *ev_names[] = {
"EV_SYN ",
"EV_KEY ",
"EV_REL ",
"EV_ABS ",
"EV_MSC ",
"EV_SW ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"EV_LED ",
"EV_SND ",
"NULL ",
"EV_REP ",
"EV_FF ",
"EV_PWR ",
};
if (argc != 2)
{
printf("Usage: %s <dev>\n", argv[0]);
return -1;
}
fd = open(argv[1], O_RDWR | O_NONBLOCK);
if (fd < 0)
{
printf("open %s err\n", argv[1]);
return -1;
}
err = ioctl(fd, EVIOCGID, &id);
if (err == 0)
{
printf("bustype = 0x%x\n", id.bustype );
printf("vendor = 0x%x\n", id.vendor );
printf("product = 0x%x\n", id.product );
printf("version = 0x%x\n", id.version );
}
len = ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
if (len > 0 && len <= sizeof(evbit))
{
printf("support ev type: ");
for (i = 0; i < len; i++)
{
byte = ((unsigned char *)evbit)[i];
for (bit = 0; bit < 8; bit++)
{
if (byte & (1<<bit)) {
printf("%s ", ev_names[i*8 + bit]);
}
}
}
printf("\n");
}
while (1)
{
/* 设置超时时间 */
tv.tv_sec = 5;
tv.tv_usec = 0;
/* 想监测哪些文件? */
FD_ZERO(&readfds); /* 先全部清零 */
FD_SET(fd, &readfds); /* 想监测fd */
/* 函数原型为:
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
* 我们为了"read"而监测, 所以只需要提供readfds
*/
nfds = fd + 1; /* nfds 是最大的文件句柄+1, 注意: 不是文件个数, 这与poll不一样 */
ret = select(nfds, &readfds, NULL, NULL, &tv);
if (ret > 0) /* 有文件可以提供数据了 */
{
/* 再次确认fd有数据 */
if (FD_ISSET(fd, &readfds))
{
while (read(fd, &event, sizeof(event)) == sizeof(event))
{
printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\n", event.type, event.code, event.value);
}
}
}
else if (ret == 0) /* 超时 */
{
printf("time out\n");
}
else /* -1: error */
{
printf("select err\n");
}
}
return 0;
}
5.5 input_read_fasync.c
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
int fd;
void my_sig_handler(int sig)
{
struct input_event event;
while (read(fd, &event, sizeof(event)) == sizeof(event))
{
printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\n", event.type, event.code, event.value);
}
}
/* ./05_input_read_fasync /dev/input/event0 */
int main(int argc, char **argv)
{
int err;
int len;
int ret;
int i;
unsigned char byte;
int bit;
struct input_id id;
unsigned int evbit[2];
unsigned int flags;
int count = 0;
char *ev_names[] = {
"EV_SYN ",
"EV_KEY ",
"EV_REL ",
"EV_ABS ",
"EV_MSC ",
"EV_SW ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"NULL ",
"EV_LED ",
"EV_SND ",
"NULL ",
"EV_REP ",
"EV_FF ",
"EV_PWR ",
};
if (argc != 2)
{
printf("Usage: %s <dev>\n", argv[0]);
return -1;
}
/* 注册信号处理函数 */
signal(SIGIO, my_sig_handler);
/* 打开驱动程序 */
fd = open(argv[1], O_RDWR | O_NONBLOCK);
if (fd < 0)
{
printf("open %s err\n", argv[1]);
return -1;
}
err = ioctl(fd, EVIOCGID, &id);
if (err == 0)
{
printf("bustype = 0x%x\n", id.bustype );
printf("vendor = 0x%x\n", id.vendor );
printf("product = 0x%x\n", id.product );
printf("version = 0x%x\n", id.version );
}
len = ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), &evbit);
if (len > 0 && len <= sizeof(evbit))
{
printf("support ev type: ");
for (i = 0; i < len; i++)
{
byte = ((unsigned char *)evbit)[i];
for (bit = 0; bit < 8; bit++)
{
if (byte & (1<<bit)) {
printf("%s ", ev_names[i*8 + bit]);
}
}
}
printf("\n");
}
/* 把APP的进程号告诉驱动程序 */
fcntl(fd, F_SETOWN, getpid());
/* 使能"异步通知" */
flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags | FASYNC);
while (1)
{
printf("main loop count = %d\n", count++);
sleep(2);
}
return 0;
}
6 input应用程序调试技巧
6.1 确定设备信息
输入设备的设备节点名为/dev/input/eventX(也可能是/dev/eventX，X表示0、1、2等数字)。查看设备节点，可以执行以下命令：
ls /dev/input/* -l
或
ls /dev/event* -l
可以看到类似下面的信息：
怎么知道这些设备节点对应什么硬件呢？可以在板子上执行以下命令：
cat /proc/bus/input/devices这条指令的含义就是获取与event对应的相关设备信息，可以看到类似以下的结果：
那么这里的I、N、P、S、U、H、B对应的每一行是什么含义呢？其实就对应这个结构体
I:id of the device(设备ID)该参数由结构体struct input_id来进行描述，
N:name of the device 设备名称
P:physical path to the device in the system hierarchy 系统层次结构中设备的物理路径。
S:sysfs path 位于sys文件系统的路径
U:unique identification code for the device(if device has it) 设备的唯一标识码
H:list of input handles associated with the device. 与设备关联的输入句柄列表。
B:bitmaps(位图) PROP:device properties and quirks(设备属性) EV:types of events supported by the device(设备支持的事件类型) KEY:keys/buttons this device has(此设备具有的键/按钮) MSC:miscellaneous events supported by the device(设备支持的其他事件) LED:leds present on the device(设备上的指示灯)
值得注意的是B位图，比如上图中“B: EV=b”用来表示该设备支持哪类输入事件。b的二进制是1011，bit0、1、3为1，表示该设备支持0、1、3这三类事件，即EV_SYN、EV_KEY、EV_ABS。
再举一个例子，“B: ABS=2658000 3”如何理解？它表示该设备支持EV_ABS这一类事件中的哪一些事件。这是2个32位的数字：0x2658000、0x3，高位在前低位在后，组成一个64位的数字：“0x2658000,00000003”，数值为1的位有：0、1、47、48、50、53、54，即：0、1、0x2f、0x30、0x32、0x35、0x36，对应以下这些宏：
即这款输入设备支持上述的ABS_X、ABS_Y、ABS_MT_SLOT、ABS_MT_TOUCH_MAJOR、ABS_MT_WIDTH_MAJOR、ABS_MT_POSITION_X、ABS_MT_POSITION_Y这些绝对位置事件。
6.2使用命令读取数据
调试输入系统时，直接执行类似下面的命令，然后操作对应的输入设备即可读出数据：
hexdump /dev/input/event0在开发板上执行上述命令之后，点击按键或是点击触摸屏，就会打印以下信息：
上图中的type为3，对应EV_ABS；code为0x35对应ABS_MT_POSITION_X；code为0x36对应ABS_MT_POSITION_Y。
上图中还发现有2个同步事件：它的type、code、value都为0。表示电容屏上报了2次完整的数据。
7 tslib
tslib是一个触摸屏的开源库，可以使用它来访问触摸屏设备，可以给输入设备添加各种“filter”(过滤器，就是各种处理)，地址是：tslib。
编译tslib后，可以得到libts库，还可以得到各种工具：较准工具、测试工具。
7.1 tslib框架分析
tslib的主要代码如下：
核心在于“plugins”目录里的“插件”，或称为“module”。这个目录下的每个文件都是一个module，每个module都提供2个函数：read、read_mt，前者用于读取单点触摸屏的数据，后者用于读取多点触摸屏的数据。
要分析tslib的框架，先看看示例程序怎么使用，我们参考ts_test.c和ts_test_mt.c，前者用于一般触摸屏(比如电阻屏、单点电容屏)，后者用于多点触摸屏。
一个图就可以弄清楚tslib的框架：
调用ts_open后，可以打开某个设备节点，构造出一个tsdev结构体。
然后调用ts_config读取配置文件的处理，假设/etc/ts.conf内容如下：
module_raw input
module pthres pmin=1
module dejitter delta=100
module linear
每行表示一个“module”或“moduel_raw”。
对于所有的“module”，都会插入tsdev.list链表头，也就是tsdev.list执行配置文件中最后一个“module”，配置文件中第一个“module”位于链表的尾部。
对于所有的“module_raw”，都会插入tsdev.list_raw链表头，一般只有一个“module_raw”。
注意：tsdev.list中最后一个“module”会指向ts_dev.list_raw的头部。
无论是调用ts_read还是ts_read_mt，都是通过tsdev.list中的模块来处理数据的。这写模块是递归调用的，比如linear模块的read函数如下：
linear模块的read_raw函数如下：
因为是递归调用，所有最先使用input模块读取设备节点得到原始数据，再依次经过pthres模块、dejitter模块、linear模块处理后，才返回最终数据。
7.2交叉编译、测试tslib
7.2.1 交叉编译tslib
在编译之前要设置交叉编译工具链
对于IMX6ULL，命令如下
export ARCH=arm
export CROSS_COMPILE=arm-linux-gnueabihf-
export PATH=$PATH:/data/chw/imx6ull_20230512/bsp/100ask_imx6ull-sdk/ToolChain/arm-buildroot-linux-gnueabihf_sdk-buildroot/bin
交叉编译tslib
./configure --host=arm-linux-gnueabihf --prefix=/
make
make install DESTDIR=$PWD/tmp
确定工具链中头文件、库文件目录：
echo 'main(){}'| arm-buildroot-linux-gnueabihf-gcc -E -v -
把头文件、库文件放到工具链目录下
cd tslib-1.21/tmp/
cp include/* /data/chw/imx6ull_20230512/bsp/100ask_imx6ull-sdk/ToolChain/arm-buildroot-linux-gnueabihf_sdk-buildroot/arm-buildroot-linux-gnueabihf/sysroot/usr/include
cp -d lib/*so* /data/chw/imx6ull_20230512/bsp/100ask_imx6ull-sdk/ToolChain/arm-buildroot-linux-gnueabihf_sdk-buildroot/arm-buildroot-linux-gnueabihf/sysroot/usr/lib/
7.2.2 测试tslib
把库文件放到单板上：运行程序要用。先在开发板上使用NFS挂载Ubuntu的目录，再把前面编译出来的tslib-1.21/tmp/部分文件复制到板子上，示例命令如下：
cp /mnt/tslib-1.21/tmp/lib/* -drf /lib
cp /mnt/tslib-1.21/tmp/bin/* /bin
cp /mnt/tslib-1.21/tmp/etc/ts.conf -d /etc
对于IMX6ULL，首先需要关闭默认的qt gui程序，才可以执行ts_test_mt测试命令，关闭qt命令如下所示：
mv /etc/init.d/S07hmi /root
reboot
在单板上执行测试程序：
ts_test_mt
7.3 使用tslib编写程序
驱动程序使用slot、tracking_id来标识一个触点；当tracking_id等于-1时，标识这个触点被松开了。
触摸屏可能支持多个触点，比如5个：tslib为了简化处理，即使只有2个触点，ts_read_mt函数也会返回5个触点数据，可以根据标志位判断数据是否有效。
ts_read_mt函数原型如下：
假设nr设置为1，max_slots设置为5，那么读到的数据保存在：samp[0][0]、samp[0][1]、samp[0][2]、samp[0][3]、samp[0][4]中。
假设nr设置为1，max_slots设置为5，那么督导的数据保存在：samp[0][0]、samp[0][1]、samp[0][2]、samp[0][3]、samp[0][4]和samp[1][0]、samp[1][1]、samp[1][2]、samp[1][3]、samp[1][4]中。
ts_sample_mt结构体如下：
实现一个程序，不断打印2个触点的距离。
思路：假设是5点触摸屏，调用一次ts_read_mt可以得到5个新数据；使用新旧数据进行判断，如果有2个触点，就打印出距离。
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <getopt.h>
#include <linux/input.h>
#include <sys/ioctl.h>
#include <tslib.h>
int distance(struct ts_sample_mt *point1, struct ts_sample_mt *point2)
{
int x = point1->x - point2->x;
int y = point1->y - point2->y;
return x*x + y*y;
}
int main(int argc, char **argv)
{
struct tsdev *ts;
int i;
int ret;
struct ts_sample_mt **samp_mt;
struct ts_sample_mt **pre_samp_mt;
int max_slots;
int point_pressed[20];
struct input_absinfo slot;
int touch_cnt = 0;
ts = ts_setup(NULL, 0);
if (!ts)
{
printf("ts_setup err\n");
return -1;
}
if (ioctl(ts_fd(ts), EVIOCGABS(ABS_MT_SLOT), &slot) < 0) {
perror("ioctl EVIOGABS");
ts_close(ts);
return errno;
}
max_slots = slot.maximum + 1 - slot.minimum;
samp_mt = malloc(sizeof(struct ts_sample_mt *));
if (!samp_mt) {
ts_close(ts);
return -ENOMEM;
}
samp_mt[0] = calloc(max_slots, sizeof(struct ts_sample_mt));
if (!samp_mt[0]) {
free(samp_mt);
ts_close(ts);
return -ENOMEM;
}
pre_samp_mt = malloc(sizeof(struct ts_sample_mt *));
if (!pre_samp_mt) {
ts_close(ts);
return -ENOMEM;
}
pre_samp_mt[0] = calloc(max_slots, sizeof(struct ts_sample_mt));
if (!pre_samp_mt[0]) {
free(pre_samp_mt);
ts_close(ts);
return -ENOMEM;
}
for ( i = 0; i < max_slots; i++)
pre_samp_mt[0][i].valid = 0;
while (1)
{
ret = ts_read_mt(ts, samp_mt, max_slots, 1);
if (ret < 0) {
printf("ts_read_mt err\n");
ts_close(ts);
return -1;
}
for (i = 0; i < max_slots; i++)
{
if (samp_mt[0][i].valid)
{
memcpy(&pre_samp_mt[0][i], &samp_mt[0][i], sizeof(struct ts_sample_mt));
}
}
touch_cnt = 0;
for (i = 0; i < max_slots; i++)
{
if (pre_samp_mt[0][i].valid && pre_samp_mt[0][i].tracking_id != -1)
point_pressed[touch_cnt++] = i;
}
if (touch_cnt == 2)
{
printf("distance: %08d\n", distance(&pre_samp_mt[0][point_pressed[0]], &pre_samp_mt[0][point_pressed[1]]));
}
}
return 0;
}
参考文献：
八、INPUT子系统和内核自带的GPIO按键驱动_乔碧萝成都分萝的博客-CSDN博客
