利用电阻式触摸屏分析input子系统的内部联系

前面对s3c2410的触摸屏驱动进行了分析，现深入一层，对其所在的输入子系统进行刺探。

首先引用一个不错的帖子，对2.6内核的输入子系统进行一个大致的描述：

引：

在做触摸屏？对于输入子系统，相信你也早看了网上一些介绍文章文章了，
读一下就可了解对其基本架构，剩下的只是一些源码细节阅读。

输入子系统的3层间的联系是很简单的，驱动层的核心结构为struct input_dev：
struct input_dev {
    ...
    struct list_head        h_list;
    ...
};
在input_register_device时就会将input_dev与input_handle联系起来；
所谓联系就是将有关的input_handle链入以input_dev中h_list为Hash头的链中；

而事件处理层的核心结构是struct input_handler：
struct input_handler {
    ...
    struct list_head        h_list;
    ...
};
在input_register_handler时同样会将input_handler与input_handle联系起来，
所谓联系就是将有关的input_handle链入以input_handler中h_list为Hash头的链中；

由上可见input_handle即是一个用于关联驱动层input_dev和事件处理
层input_handler的中间结构：
struct input_handle {
    ...
    struct input_dev *dev;
    struct input_handler *handler;
    struct list_head        d_node;
    struct list_head        h_node;
};
其中d_node用于input_dev链，h_node用于input_handler链，有了input_handle，
就把相关dev与handler联系起来，相互能容易的找到。

注：
    原文请看一下网址：


看了以上的内容，相信你对2.6内核的输入子系统应该有个大概的了解了，
现在我就input_dev、input_handle、input_handler这三者建立联系的过程进行详细的分析：

触摸屏驱动中，s3c2410ts_probe函数的最后一步，调用input_register_device函数开始进入三者建立联系的过程：

void input_register_device(struct input_dev *dev)
{
        struct input_handle *handle;
        struct input_handler *handler;
        struct input_device_id *id;
........................................................................................
        INIT_LIST_HEAD(&dev->h_list);
        list_add_tail(&dev->node, &input_dev_list);

        list_for_each_entry(handler, &input_handler_list, node)
               if (!handler->blacklist || !input_match_device(handler->blacklist, dev))
                       if ((id = input_match_device(handler->id_table, dev)))
                               if ((handle = handler->connect(handler, dev, id)))
                                      input_link_handle(handle);
..........................................................................................

}
注：
        我只保留重要的部分，省略号部分不是我关心的，以下同。

list_for_each_entry(handler, &input_handler_list, node)的作用在于：
从input_handler_list的链表中提取input_handler的指针。

##################################################################################
那这个input_handler的指针又是何时存放在input_handler_list链表里面的呢？
答案是像tsdev.c这些接口驱动里面调用input_register_handler
进而调用list_add_tail(&handler->node, &input_handler_list);
把其input_handler指针加进input_handler_list里面，详细请查看源码，在此不做详细分析。
###################################################################################

获取了input_handler指针后通过input_match_device进行匹配选择：
static struct input_device_id *input_match_device(struct input_device_id *id, struct input_dev *dev)
{
        int i;

        for (; id->flags || id->driver_info; id++) {
................................................................

               MATCH_BIT(evbit,  EV_MAX);
               MATCH_BIT(keybit, KEY_MAX);
               MATCH_BIT(relbit, REL_MAX);
               MATCH_BIT(absbit, ABS_MAX);
               MATCH_BIT(mscbit, MSC_MAX);
               MATCH_BIT(ledbit, LED_MAX);
               MATCH_BIT(sndbit, SND_MAX);
               MATCH_BIT(ffbit,  FF_MAX);
               MATCH_BIT(swbit,  SW_MAX);

               return id;
        }

        return NULL;
}

该函数拿刚才获得的input_handler指针所拥有的特性表handler->id_table
与我们所注册的input_dev的特性表dev.id进行对照。

仍以触摸屏驱动s3c2410-ts.c与触摸屏接口tsdev.c为例：
s3c2410-ts.c：
        ts.dev.evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);
        ts.dev.keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
        input_set_abs_params(&ts.dev, ABS_X, 0, 0x3FF, 0, 0);
        input_set_abs_params(&ts.dev, ABS_Y, 0, 0x3FF, 0, 0);
        input_set_abs_params(&ts.dev, ABS_PRESSURE, 0, 1, 0, 0);
        ts.dev.id.bustype = BUS_RS232;
        ts.dev.id.vendor = 0xDEAD;
        ts.dev.id.product = 0xBEEF;
        ts.dev.id.version = S3C2410TSVERSION;

tsdev.c：
static struct input_device_id tsdev_ids[] = {
        {
              .flags   = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT
                       | INPUT_DEVICE_ID_MATCH_RELBIT,
              .evbit   = { BIT(EV_KEY) | BIT(EV_REL) },
              .keybit  = { [LONG(BTN_LEFT)] = BIT(BTN_LEFT) },
              .relbit  = { BIT(REL_X) | BIT(REL_Y) },
         },/* A mouse like device, at least one button, two relative axes */

        {
              .flags   = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_KEYBIT
                       | INPUT_DEVICE_ID_MATCH_ABSBIT,
              .evbit   = { BIT(EV_KEY) | BIT(EV_ABS) },
              .keybit  = { [LONG(BTN_TOUCH)] = BIT(BTN_TOUCH) },
              .absbit  = { BIT(ABS_X) | BIT(ABS_Y) },
         },/* A tablet like device, at least touch detection, two absolute axes */

        {
              .flags   = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_ABSBIT,
              .evbit   = { BIT(EV_ABS) },
              .absbit  = { BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE) },
         },/* A tablet like device with several gradations of pressure */

        {},/* Terminating entry */
};

可以看到，tsdev.c接口定义了三项特性，对应id为0、1、2，
input_match_device函数依次取出其中的选项与s3c2410-ts.c里面定义的input_dev的选项进行对比。
这里对比的标准是tsdev.c里面定义的选项s3c2410-ts.c里面必须满足，否则continue，继续判断下一个id号的选项。
详细请看MATCH_BIT这个宏的定义：
#define MATCH_BIT(bit, max) \
               for (i = 0; i < NBITS(max); i++) \
                       if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
                               break; \
               if (i != NBITS(max)) \
                       continue;

例如：
        在这里，tsdev.c定义的id为0的选项里面定义的BIT(EV_REL)这一项
在s3c2410-ts.c里面定义的input_dev设备上是不具备的，
所以，执行到MATCH_BIT(evbit,  EV_MAX);后直接continue，
继续判断tsdev.c里面id为1的选项，直到找到合适的，然后返回真，否则返回NULL。

###########################################################################################
在list_for_each_entry(handler, &input_handler_list, node)
这个大循环里与我们所注册的input_dev所匹配的不限于一个接口，
例如，以下是我的调试记录：
s3c2410 TouchScreen successfully loaded
kbd
input_match_device

mousedev
input_match_device
mousedev_connect

joydev
input_match_device

evdev
input_match_device
evdev_connect

tsdev
input_match_device
tsdev_connect

evbug
input_match_device
evbug_connect
可以看到，对于s3c2410-ts.c里面定义的input_dev设备，同时与其匹配的就有
mousedev、evdev、tsdev、evbug等众多接口(不知道我的理解是否正确，如果理解错了，还望指正^_^)
###########################################################################################

找到匹配的选项以后，就可以开始着手把input_dev、input_handle、input_handler这三者联系齐来了，具体调用
handle = handler->connect(handler, dev, id)函数，
主要的目的是填充input_handle结构，然后接着调用
input_link_handle(handle)函数：

static void input_link_handle(struct input_handle *handle)
{
        list_add_tail(&handle->d_node, &handle->dev->h_list);
        list_add_tail(&handle->h_node, &handle->handler->h_list);
}

看到吧，就是上面那位大侠提到的，把input_handle分别链入input_dev和input_handler中h_list为Hash头的链中。

好了，到此，input_dev、input_handle、input_handler这三者总算是联系起来了^_^

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

上文介绍了input_dev、input_handle、input_handler三者是如何联系起来了，现在继续介绍如何通过它们来传递信息。
在开始之前还是先引用一位大侠的帖子：

引：

现在看用户获取触摸屏输入的一个流程(以tsdev为例/drivers/input/tsdev.c)：
static struct file_operations tsdev_fops = {
        .owner =        THIS_MODULE,
        .open =         tsdev_open,
        .release =      tsdev_release,
        .read =         tsdev_read,
        .poll =         tsdev_poll,
        .fasync =       tsdev_fasync,
        .ioctl =        tsdev_ioctl,
};
假设所有初始化早已完成，用户open该设备后，使用read系统调用进入内核，系统
转移控制到tsdev_read，使用wait_event_interruptible等待事件。

此时驱动层得到用户输入，于是调用input_report_abs，input_report_abs只是
input_event的简单包装：
static inline void input_report_abs(struct input_dev *dev, 
                                     unsigned int code, int value)
{
        input_event(dev, EV_ABS, code, value);
}

void input_event(struct input_dev *dev, unsigned int type, 
                                  unsigned int code, int value)
{
    ...
    switch (type) {
        ...
        case EV_ABS:
            ...
            break;
        ...
    }
    ...

    if (dev->grab)
        dev->grab->handler->event(dev->grab, type, code, value);
    else
        list_for_each_entry(handle, &dev->h_list, d_node)
            if (handle->open)
                handle->handler->event(handle, type, code, value);
}
前面的处理关系具体设备，见最后对handler函数的调用，就是从input_dev的h_list链
上的input_handle获得每一个相关input_handler，并调用其中的event函数，对tsdev
来说：
static struct input_handler tsdev_handler = {
        .event =        tsdev_event,
        .connect =      tsdev_connect,
        .disconnect =   tsdev_disconnect,
        .fops =         &tsdev_fops,
        .minor =        TSDEV_MINOR_BASE,
        .name =         "tsdev",
        .id_table =     tsdev_ids,
};
即调用tsdev_event函数，接着看：
static void tsdev_event(struct input_handle *handle, unsigned int type,
                        unsigned int code, int value)
{
    ...
    switch (type) {
        case EV_ABS:
            break;
    ...
    list_for_each_entry(list, &tsdev->list, node) {
        int x, y, tmp;
        do_gettimeofday(&time);
        list->event[list->head].millisecs = time.tv_usec / 100;
        list->event[list->head].pressure = tsdev->pressure;

        x = tsdev->x;
        y = tsdev->y;
        /* Calibration */
        if (!list->raw) {
            x = ((x * tsdev->cal.xscale) >> 8) + tsdev->cal.xtrans;
            y = ((y * tsdev->cal.yscale) >> 8) + tsdev->cal.ytrans;
            if (tsdev->cal.xyswap) {
                tmp = x; x = y; y = tmp;
            }
        }

        list->event[list->head].x = x;
        list->event[list->head].y = y;
        list->head = (list->head + 1) & (TSDEV_BUFFER_SIZE - 1);
        kill_fasync(&list->fasync, SIGIO, POLL_IN);
    }
    wake_up_interruptible(&tsdev->wait);
}
它填充数据，并唤醒等待着的请求。于是前面等待着的read请求就可继续了，
回到tsdev_read中，copy_to_user拷贝数据，最后返回用户层。


一个简单流程就结束了。

注：
    原文请看以下网址：


看了以上的内容，相信你对2.6内核的输入子系统的消息传递过程应该有个大概的了解了，现在我就如何通过input_dev、input_handle、input_handler这三者传递信息进行详细的分析：
################
从开始
################
static ssize_t tsdev_read(struct file *file, char __user *buffer, size_t count,
                          loff_t * ppos)
{
        struct tsdev_list *list = file->private_data;
        int retval = 0;

     /* 设备存在(exist=1:在tsdev_connect函数里设置)，但缓冲中无数据，而又配置为非阻塞读取方式，直接返回 */
        if (list->head == list->tail && list->tsdev->exist && (file->f_flags & O_NONBLOCK))
                return -EAGAIN;
     /* 否则睡眠等待数据都来临 */
        retval = wait_event_interruptible(list->tsdev->wait,
                        list->head != list->tail || !list->tsdev->exist);
     /* 被信号中断唤醒，直接返回 */
        if (retval)
                return retval;
     /* 检查设备是否还存在，不存在(exist=0:在tsdev_disconnect函数中设置)的话直接返回 */
        if (!list->tsdev->exist)
                return -ENODEV;
     /* 有数据，循环读取用户所需要都数据 */
        while (list->head != list->tail &&
               retval + sizeof (struct ts_event) <= count) {
                if (copy_to_user (buffer + retval, list->event + list->tail,
                                  sizeof (struct ts_event)))
                        return -EFAULT;
                list->tail = (list->tail + 1) & (TSDEV_BUFFER_SIZE - 1);//更新读指针
                retval += sizeof (struct ts_event);//更新读字节数
        }

        return retval;
}

#################
3c2410-ts.c>
#################
        input_report_abs(&ts.dev, ABS_X, ts.xp);
        input_report_abs(&ts.dev, ABS_Y, ts.yp);
 
        input_report_key(&ts.dev, BTN_TOUCH, 1);
        input_report_abs(&ts.dev, ABS_PRESSURE, 1);
        input_sync(&ts.dev);

###########################

###########################
static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
{
        input_event(dev, EV_ABS, code, value);
}


##########################

##########################
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
struct input_handle *handle;
........................................................................................................
        switch (type) {
                case EV_ABS:

                        if (code > ABS_MAX || !test_bit(code, dev->absbit))//一些条件测试
                                return;

                        if (dev->absfuzz[code]) {
                                if ((value > dev->abs[code] - (dev->absfuzz[code] >> 1)) &&
                                    (value < dev->abs[code] + (dev->absfuzz[code] >> 1)))
                                        return;

                                if ((value > dev->abs[code] - dev->absfuzz[code]) &&
                                    (value < dev->abs[code] + dev->absfuzz[code]))
                                        value = (dev->abs[code] * 3 + value) >> 2;

                                if ((value > dev->abs[code] - (dev->absfuzz[code] << 1)) &&
                                    (value < dev->abs[code] + (dev->absfuzz[code] << 1)))
                                        value = (dev->abs[code] + value) >> 1;
                        }

                        if (dev->abs[code] == value)//比较当前值与上一次都值是否相同，相同则不作处理
                                return;

                        dev->abs[code] = value;//备份当前值，以便下一次作比较
                        break;
...............................................................................................................
        if (type != EV_SYN)
                dev->sync = 0;

        if (dev->grab)
                dev->grab->handler->event(dev->grab, type, code, value);
        else
                list_for_each_entry(handle, &dev->h_list, d_node)//通过input_dev找出与其联系的input_handle
                        if (handle->open)//相应的接口设备(比如tsdev)被打开(通过调用tsdev.c的tsdev_open函数进而调用input_open_device
                         函数增加handle->open的计数值)
                                handle->handler->event(handle, type, code, value);//调用该接口设备的event函数对数据进行处理
}

################
在结束
################
static void tsdev_event(struct input_handle *handle, unsigned int type,
                        unsigned int code, int value)
{
        struct tsdev *tsdev = handle->private;
        struct tsdev_list *list;
        struct timeval time;

        switch (type) {
        case EV_ABS:
                switch (code) {
                case ABS_X:
                        tsdev->x = value;//记录x坐标值
                        break;
                case ABS_Y:
                        tsdev->y = value;//记录y坐标值
                        break;
                case ABS_PRESSURE:
                        if (value > handle->dev->absmax[ABS_PRESSURE])
                                value = handle->dev->absmax[ABS_PRESSURE];
                        value -= handle->dev->absmin[ABS_PRESSURE];
                        if (value < 0)
                                value = 0;
                        tsdev->pressure = value;//记录触摸屏的按压状态
                        break;
                }
                break;
...................................................................................................
        if (type != EV_SYN || code != SYN_REPORT)//键值的传递以EV_SYN为结束标志(通过input_sync函数)，等到数据都填充好tsdev结构后再统一发送出去，否则直接返回，继续填充另一个数据
                return;

        list_for_each_entry(list, &tsdev->list, node) {    //通过tsdev获取struct tsdev_list结构(在tsdev_open函数中定义):
                                //list_add_tail(&list->node, &tsdev_table[i]->list);
                int x, y, tmp;

                do_gettimeofday(&time);            //填充事件的时间
                list->event[list->head].millisecs = time.tv_usec / 100;
                list->event[list->head].pressure = tsdev->pressure;//填充触摸屏的状态

                x = tsdev->x;
                y = tsdev->y;

                /* Calibration */
                if (!list->raw) {
                        x = ((x * tsdev->cal.xscale) >> 8) + tsdev->cal.xtrans;
                        y = ((y * tsdev->cal.yscale) >> 8) + tsdev->cal.ytrans;
                        if (tsdev->cal.xyswap) {
                                tmp = x; x = y; y = tmp;
                        }
                }

                list->event[list->head].x = x;        //填充x坐标值
                list->event[list->head].y = y;        //填充y坐标值
                list->head = (list->head + 1) & (TSDEV_BUFFER_SIZE - 1);//更新写指针
                kill_fasync(&list->fasync, SIGIO, POLL_IN);
        }
        wake_up_interruptible(&tsdev->wait);//唤醒睡眠在tsdev->wait下等待数据都进程读取数据。至此，数据传递过程结束，开始新一轮的数据传递。
}