s3c2440触摸屏驱动分析（LINUX2.6）（2）

int __init EmbedSky_ts_init(void)
{
return driver_register(&EmbedSky_ts_driver);
}

static struct device_driver EmbedSky_ts_driver = {
.name = "EmbedSky-ts",
.bus = &platform_bus_type,
.probe = EmbedSky_ts_probe,
.remove = EmbedSky_ts_remove,
};
我们来主要分析一下EmbedSky_ts_probe，它是最为贴近我们INPUT子系统的。我们先来分析与INPUT子系统无关的部分，与具体硬件相关的部分。

struct s3c2410_ts_mach_info *info;

info = ( struct s3c2410_ts_mach_info *)dev->platform_data;
注：
s3c2410_ts_mach_info这个结构需要我们去填充，里面存放的是触摸屏需要的一些配置参数。这个数据结构的位置在/arch/arm/mach-s3c2410/dev.c。我们来看看他的具体内容吧。

static struct s3c2410_ts_mach_info sbc2410_ts_platdata = {
.delay = 10000,
.presc = 49,
.oversampling_shift = 2,
};

struct platform_device s3c_device_ts = {
.name = "s3c2410-ts",
.id = -1,
.dev = {
.platform_data = &sbc2410_ts_platdata,
}
};
EXPORT_SYMBOL(s3c_device_ts);

接下来我们继续回到EmbedSky_ts_probe中去。

adc_clock = clk_get(NULL, "adc");
if (!adc_clock) {
printk(KERN_ERR "failed to get adc clock source/n");
return -ENOENT;
}
clk_enable(adc_clock);

这是对系统时钟的获得。

base_addr=ioremap(S3C2410_PA_ADC,0x20);
if (base_addr == NULL) {
printk(KERN_ERR "Failed to remap register block/n");
return -ENOMEM;
}
映射触摸屏的控制寄存器。

EmbedSky_ts_connect();

配置相应的GPIO的功能。

if ((info->delay&0xffff) > 0)
writel(info->delay & 0xffff, base_addr+S3C2410_ADCDLY);

writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);

预分频的功能配置。

ADCDLY寄存器的用法：在正常转换模式，独立X/Y位置转换模式和自动X/Y位置转换模式下，X/Y位置转换延迟值。

当在等待中断模式中有触笔按下时，这个寄存器在间歇的几个毫秒时间内，为自动X/Y位置转换产生中断信号（INT_TC）好处在于在等待中断的时候还可以进行AD转换。

以下是关于INPUT子系统的分析：

memset(&ts, 0, sizeof(struct EmbedSky_ts));//全局变量static struct EmbedSky_ts ts;

ts.dev = input_allocate_device();

input设备注册分析：

struct input_dev *input_allocate_device(void)
{
struct input_dev *dev;

dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);//向内核申请存放input_dev结构体的内存空间
if (dev) {
dev->dev.type = &input_dev_type;
dev->dev.class = &input_class;
device_initialize(&dev->dev);//对于设备的初始化现在本人还没有水平分析
mutex_init(&dev->mutex);
spin_lock_init(&dev->event_lock);
INIT_LIST_HEAD(&dev->h_list);//初始化队列，这个很重要
INIT_LIST_HEAD(&dev->node);

__module_get(THIS_MODULE);
}

return dev;
}

总的来说，就是向内核申请一个input_dev结构体，然后初始化。

ts.dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);

对设备所支持的事件进行置位，它支持同步(EN_SYN)、按键(EN_KEY)、绝对坐标(EV_ABS)事件。

ts.dev->keybit[BIT_WORD(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);

以上三行是对ads事件的参数进行参数设置。功能和上述键值是类似的设置。

static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat)
{
dev->absmin[axis] = min;//以上三行都对最大值和最小值进行设置。ABS_X,ABS_Y设置最大值为0x3ff，最小值为0。ABS_PRESSURE设置为最大值1，最小值为0。

dev->absmax[axis] = max;
dev->absfuzz[axis] = fuzz;
dev->absflat[axis] = flat;

dev->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);//说明支持的三个事件ABS_X,ABS_Y,ABS_PRESSURE。
}

sprintf(ts.phys, "ts0");

ts.dev->private = &ts;
ts.dev->name = EmbedSky_ts_name;
ts.dev->phys = ts.phys;
ts.dev->id.bustype = BUS_RS232;
ts.dev->id.vendor = 0xDEAD;
ts.dev->id.product = 0xBEEF;
ts.dev->id.version = S3C2410TSVERSION;

ts.shift = info->oversampling_shift;
/*
这个比较重要，配置输入数据的缓存区大小，
在这里oversampling_shift设为2，也就是缓存区的大小为4(1<<2)
*/

if (request_irq(IRQ_ADC, stylus_action, SA_SAMPLE_RANDOM, "s3c2410_action", ts.dev))
{
printk(KERN_ERR "EmbedSky_ts.c: Could not allocate ts IRQ_ADC !/n");
iounmap(base_addr);
return -EIO;
}
if (request_irq(IRQ_TC, stylus_updown, SA_SAMPLE_RANDOM,
"s3c2410_action", ts.dev)) {
printk(KERN_ERR "EmbedSky_ts.c: Could not allocate ts IRQ_TC !/n");
iounmap(base_addr);
return -EIO;
}

都是申请中断号，具体的在前面那篇已经分析过了。大家可以回去看看。

input_register_device(ts.dev);

这个很重要，我们来分析其中的代码，代码如下：

int input_register_device(struct input_dev *dev)
{
static atomic_t input_no = ATOMIC_INIT(0);
struct input_handler *handler;
const char *path;
int error;

__set_bit(EV_SYN, dev->evbit);//所有设备都支持这样的事件。

/*
* If delay and period are pre-set by the driver, then autorepeating
* is handled by the driver itself and we don't do it in input.c.
*/

init_timer(&dev->timer);
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
dev->timer.data = (long) dev;
dev->timer.function = input_repeat_key;
dev->rep[REP_DELAY] = 250;
dev->rep[REP_PERIOD] = 33;
}//.如果dev->rep[REP_DELAY]和dev->rep[REP_PERIOD]没有设值，则将其赋默认值。这主要是处理重复按键的.

if (!dev->getkeycode)

dev->getkeycode = input_default_getkeycode;

if (!dev->setkeycode)
dev->setkeycode = input_default_setkeycode;//这两个操作函数就可以用来取键的扫描码和设置键的扫描码。

snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id),
"input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);

error = device_add(&dev->dev);//然后调用device_add()将input_dev中封装的device注册到sysfs
if (error)
return error;

path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
printk(KERN_INFO "input: %s as %s/n",
dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
kfree(path);

error = mutex_lock_interruptible(&input_mutex);
if (error) {
device_del(&dev->dev);
return error;
}
list_add_tail(&dev->node, &input_dev_list);//将input device 挂到input_dev_list链表上

list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler);//对每一个挂在input_handler_list的handler调用input_attach_handler().

input_wakeup_procfs_readers();

mutex_unlock(&input_mutex);

return 0;
}

我们来看下匹配的函数调用：

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
int error;

if (handler->blacklist && input_match_device(handler->blacklist, dev))
return -ENODEV;

id = input_match_device(handler->id_table, dev);//如果两次input_match_device都成功了，就执行下面重要的connect
if (!id)
return -ENODEV;

error = handler->connect(handler, dev, id);
if (error && error != -ENODEV)
printk(KERN_ERR
"input: failed to attach handler %s to device %s, "
"error: %d/n",
handler->name, kobject_name(&dev->dev.kobj), error);

return error;
}
input_match_device会对两个参数进行匹配，具体的匹配过程如下：

static const struct input_device_id *input_match_device(const struct input_device_id *id,
struct input_dev *dev)
{
int i;

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

if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
if (id->bustype != dev->id.bustype)//可以看出dev的id成员的赋值都是在先前的EmbedSky_ts_probe函数里面完成的。
continue;

if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
if (id->vendor != dev->id.vendor)
continue;

if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
if (id->product != dev->id.product)
continue;

if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
if (id->version != dev->id.version)
continue;

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;
}
现在问题出现了，哪里定义了const struct input_device_id *id这个变量，找到它才可以知道它的flag是怎么设置的。在先前的input_register_device函数中，大家还记不记得list_for_each_entry(handler, &input_handler_list, node)这条语句，可以说在input文件夹下的apm-power.c、evbug.c、evdev.c、ff-core.c、ff-memless.c......和文件tsdev.c，这些文件都是对应不同input_dev结构体的逻辑层，换句话说，在这些文件都会申请和初始化input_handler结构体。对应的就会有input_handler_list这样的队列生成。我们来看下以下代码（以tsdev.c为例）

static int __init tsdev_init(void)
{
return input_register_handler(&tsdev_handler);//这个很重要，进过这里处理后就会有一个input_handler结构体产生了。
}

我们来仔细看看它的代码吧：

int input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
int retval;

retval = mutex_lock_interruptible(&input_mutex);
if (retval)
return retval;

INIT_LIST_HEAD(&handler->h_list);

if (handler->fops != NULL) {
if (input_table[handler->minor >> 5]) {
retval = -EBUSY;
goto out;
}
input_table[handler->minor >> 5] = handler;
}//handler->minor表示对应input设备节点的次设备号，把handler的次设备号左移5位，可以看出一个handler可以支持32个设备，这个是个理论值，在下面你会看到特殊情tsdev_handler只是支持16个设备。

list_add_tail(&handler->node, &input_handler_list);//然后将handler挂到input_handler_list中

list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler);//然后将其与挂在input_dev_list中的input device匹配

input_wakeup_procfs_readers();

out:
mutex_unlock(&input_mutex);
return retval;
}

由上可以看出，这里把tsdev_handler挂在input_handler_list队列中，以便后面的匹配（如下会有详解的）。
这样与我们本文讨论相关的文件就是tsdev.c，我们进去看看可不可以找到我们先前需要的id。

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,
};

注意到这里的minor成员，TSDEV_MINOR_BASE=128，可以知道tsdev_handler代表的设备范围是从（13，128）到（13，128+16）这里为什么是16，看到下面你就知道了。

可以看到最后一项就是我们需要的，我们再往里看看：

static const 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 = { [BTN_LEFT/32] = 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 = { [BTN_TOUCH/32] = 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 */
};
这么一大串其实就是一个数组，可以看到我们先前要找的flag了吧。现在我们回去先前的代码input_match_device中去。

MATCH_BIT宏的定义如下：
#define MATCH_BIT(bit, max) /
for (i = 0; i < BITS_TO_LONGS(max); i++) /
if ((id->bit[i] & dev->bit[i]) != id->bit[i]) /
break; /
if (i != BITS_TO_LONGS(max)) /
continue;
由上的flag可以看出，匹配直接运行到MATCH_BIT的宏里面了。可以看出，只有当iput device和input handler的id成员在evbit, keybit,… swbit项相同才会匹配成功。如果半途匹配不成功就直接 if ((id->bit[i] & dev->bit[i]) != id->bit[i])break;只要不是完全相同的话，就会执行if (i != BITS_TO_LONGS(max)) continue;这样就不进行下面的对比，直接是id++（也就是说进行数组的下一个单元的对比）。

简而言之,注册input device的过程就是为input device设置默认值，并将其挂以input_dev_list.与挂载在input_handler_list中的handler相匹配。如果匹配成功，就会调用handler的connect函数.
input_match_device这个匹配成功以后就执行下面这条语句：
error = handler->connect(handler, dev, id);
很明显我们又要回到tsdev.c文件里面寻找connect,在上面贴出的tsdev_handler结构体当中，你会发现一个成员：tsdev_connect。我们来看看它的具体代码吧：
static int tsdev_connect(struct input_handler *handler, struct input_dev *dev,
const struct input_device_id *id)
{
struct tsdev *tsdev;
int delta;
int minor;
int error;
for (minor = 0; minor < TSDEV_MINORS / 2; minor++)
if (!tsdev_table[minor])
break;
很明显在寻找tsdev_table数组中空的单元，TSDEV_MINORS 为32，则代表tsdev_table数组支持16个设备，tsdev_table是tsdev类型的数组
if (minor == TSDEV_MINORS) {
printk(KERN_ERR "tsdev: no more free tsdev devices/n");
return -ENFILE;
}
tsdev = kzalloc(sizeof(struct tsdev), GFP_KERNEL);//找到之后就向内核申请一个这样结构体的内存空间。
if (!tsdev)
return -ENOMEM;
INIT_LIST_HEAD(&tsdev->client_list);
spin_lock_init(&tsdev->client_lock);
mutex_init(&tsdev->mutex);
init_waitqueue_head(&tsdev->wait);
snprintf(tsdev->name, sizeof(tsdev->name), "ts%d", minor);
tsdev->exist = 1;
tsdev->minor = minor;
tsdev->handle.dev = dev;//使dev封装到handle结构体当中
tsdev->handle.name = tsdev->name;
tsdev->handle.handler = handler;//使handler封装到handle结构体当中
tsdev->handle.private = tsdev;
由此可以看出handler和dev两者联系到一起了。我们可以把handle看成是handler和input device的信息集合体。.在这个结构里集合了匹配成功的handler和input device。
delta = dev->absmax [ABS_X] - dev->absmin [ABS_X] + 1;
if (delta == 0)
delta = 1;
tsdev->cal.xscale = (xres << 8) / delta;
tsdev->cal.xtrans = - ((dev->absmin [ABS_X] * tsdev->cal.xscale) >> 8);
delta = dev->absmax [ABS_Y] - dev->absmin [ABS_Y] + 1;
if (delta == 0)
delta = 1;
tsdev->cal.yscale = (yres << 8) / delta;
tsdev->cal.ytrans = - ((dev->absmin [ABS_Y] * tsdev->cal.yscale) >> 8);
这几行的功能应该是校准用的。
strlcpy(tsdev->dev.bus_id, tsdev->name, sizeof(tsdev->dev.bus_id));
tsdev->dev.devt = MKDEV(INPUT_MAJOR, TSDEV_MINOR_BASE + minor);//INPUT_MAJOR是主设备号，TSDEV_MINOR_BASE+minor是次设备号
tsdev->dev.class = &input_class;
tsdev->dev.parent = &dev->dev;
tsdev->dev.release = tsdev_free;
device_initialize(&tsdev->dev);

在这段代码里主要完成tsdev封装的device的初始化.注意在这里,使它所属的类指向input_class.这样在/sysfs中创建的设备目录就会在/sys/class/input/下面显示.
error = input_register_handle(&tsdev->handle);//这个注册很重要，主要是为了完成对handle的封装。
我们来仔细来分析这段代码，代码如下：
int input_register_handle(struct input_handle *handle)
{
struct input_handler *handler = handle->handler;
struct input_dev *dev = handle->dev;
int error;
/*
* We take dev->mutex here to prevent race with
* input_release_device().
*/
error = mutex_lock_interruptible(&dev->mutex);
if (error)
return error;
list_add_tail_rcu(&handle->d_node, &dev->h_list);//将handle挂到所对应input device的h_list链表上
mutex_unlock(&dev->mutex);
synchronize_rcu();
/*
* Since we are supposed to be called from ->connect()
* which is mutually exclusive with ->disconnect()
* we can't be racing with input_unregister_handle()
* and so separate lock is not needed here.
*/
list_add_tail(&handle->h_node, &handler->h_list);//还将handle挂到对应的handler的hlist链表上
if (handler->start)
handler->start(handle);
return 0;
}
其实代码很简单，就是为了把handle,handler还有input_dev关联起来。
我们再次回到tsdev_connect当中，代码如下：
if (error)
goto err_free_tsdev;
error = tsdev_install_chrdev(tsdev);
我们来看tsdev_install_chrdev具体的代码，代码如下：
static int tsdev_install_chrdev(struct tsdev *tsdev)
{
tsdev_table[tsdev->minor] = tsdev;
return 0;
}
作用就是把tsdev加入到tsdev_table数组中去。我们再回去原来的代码中去，代码如下：
if (error)
goto err_unregister_handle;
error = device_add(&tsdev->dev);
if (error)
goto err_cleanup_tsdev;
return 0;
err_cleanup_tsdev:
tsdev_cleanup(tsdev);
err_unregister_handle:
input_unregister_handle(&tsdev->handle);
err_free_tsdev:
put_device(&tsdev->dev);
return error;
}
剩下就是一些简单的结尾工作了。好了，现在基本把input_register_device分析了一通了。其实作用很简单，就是为了找到与之匹配的input_handler(本文就是tsdev_handler)然后再使用connect使input_dev和input_handler关联起来，其中handle起到了最大的作用。关于两者是如何匹配的，也是本文关注的地方。