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

这篇文章主要是分析tsdev的设备结点的访问的，通过此分析，也会领悟到整个中断过程和事件上报（event处理）的过程。关于设备结点的访问肯定离不开我们平时谈到的操作指针，与tsdev设备对应的操作指针就是&tsdev_fops（其是tsdev_handler结构体中的一员）。这时有人肯定有一点疑惑，在input文件夹下那么多的.c文件，每个文件都会有对应的input_handler结构体，也就是会有相应的&input_fops指针操作指针，这样一来，我们怎么知道使用哪个操作指针哦？好的，我们先来看看以下代码：

input子系统的初始化

static int __init input_init(void)

{

         int err;

 

         err = class_register(&input_class);//这里注册了一个类，所有的input device都是属于此类的，在sys系统表现为所有input device都会在/dev/class/input目录下。

         if (err) {

                   printk(KERN_ERR "input: unable to register input_dev class/n");

                   return err;

         }

 

         err = input_proc_init();//在/proc下面建立相关的交互文件.

         if (err)

                   goto fail1;

 

         err = register_chrdev(INPUT_MAJOR, "input", &input_fops);//然后注册主设备号INPUT_MAJOR（13）,次设备号0~255，操作指针是&input_fops

         if (err) {

                   printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);

                   goto fail2;

         }

 

         return 0;

 

 fail2:        input_proc_exit();

 fail1:        class_unregister(&input_class);

         return err;

}

Input_fops定义如下:

static const struct file_operations input_fops = {

         .owner = THIS_MODULE,

         .open = input_open_file,

};

打开文件所对应的操作函数为input_open_file.代码如下示:

static int input_open_file(struct inode *inode, struct file *file)

{

         struct input_handler *handler = input_table[iminor(inode) >> 5];

         const struct file_operations *old_fops, *new_fops = NULL;

         int err;

 

         /* No load-on-demand here? */

         if (!handler || !(new_fops = fops_get(handler->fops)))

                   return -ENODEV;//找到handler后就判断它是否存在，同时判断它是否有操作指针。

iminor(inode)作用是通过设备结点，可以求出设备的次设备号。input_table是input_handler结构体的全局数组，通过次设备号右移5位后，在数组中找到相应的handler。到这里就有点眉目了吧，我们通过input_table这个全局数组，很方便的找到了我们设备对应input_handler。对于我们上面的实例，我们可以通过tsdev中设备的此设备号，得到对应的tsdev_handler。

         if (!new_fops->open) {

                   fops_put(new_fops);

                   return -ENODEV;

         }

         old_fops = file->f_op;

         file->f_op = new_fops;//以上两行完成了对handler->fops操作指针的保存

 

         err = new_fops->open(inode, file);//如果存在open就调用

 

         if (err) {

                   fops_put(file->f_op);

                   file->f_op = fops_get(old_fops);

         }

         fops_put(old_fops);

         return err;

}

到这里大家应该明白了吧，总的来说，如果对设备结点进行open操作后，由上诉代码就会完成其设备对应的handler的查找，再转向对handler的操作指针中open函数的调用。具体问题具体分析，我们现在来分析一下tsdev_open的代码吧。

static int tsdev_open(struct inode *inode, struct file *file)
{
 int i = iminor(inode) - TSDEV_MINOR_BASE;//这样就可以得到在tsdev_table[]中的序号了
 struct tsdev_client *client;
 struct tsdev *tsdev;
 int error;

 if (i >= TSDEV_MINORS)
  return -ENODEV;

 error = mutex_lock_interruptible(&tsdev_table_mutex);
 if (error)
    return error;
 tsdev = tsdev_table[i & TSDEV_MINOR_MASK];//然后在数组中取出对应的tsdev
 if (tsdev)
    get_device(&tsdev->dev);//增加tsdev中的device的引用计数
 mutex_unlock(&tsdev_table_mutex);

 if (!tsdev)
    return -ENODEV;

 client = kzalloc(sizeof(struct tsdev_client), GFP_KERNEL);//向内核申请一个tsdev_client的数据结构的空间
 if (!client) {
  error = -ENOMEM;
  goto err_put_tsdev;
 }

 spin_lock_init(&client->buffer_lock);
 client->tsdev = tsdev;//使tsdev与client联系起来
 client->raw = i >= TSDEV_MINORS / 2;
 tsdev_attach_client(tsdev, client);//把client挂在tsdev的client_list列表上

 error = tsdev_open_device(tsdev);
 if (error)
  goto err_free_client;

 file->private_data = client;//将client赋给file的私有区
 return 0;

 err_free_client:
          tsdev_detach_client(tsdev, client);
          kfree(client);
 err_put_tsdev:
          put_device(&tsdev->dev);
          return error;
}

我们来分析一下tsdev_open_device的代码：

static int tsdev_open_device(struct tsdev *tsdev)
{
 int retval;

 retval = mutex_lock_interruptible(&tsdev->mutex);
 if (retval)
  return retval;

 if (!tsdev->exist)
  retval = -ENODEV;
 else if (!tsdev->open++) {
  retval = input_open_device(&tsdev->handle);
  if (retval)
   tsdev->open--;
 }

 mutex_unlock(&tsdev->mutex);
 return retval;
}

可以看出input_open_device是重点，else if（!tsdev->open++）可以看出判断是否是第一次打开的。如果是第一次打开就调用input_open_device函数，我们来分析一下这个函数代码吧:

int input_open_device(struct input_handle *handle)
{
 struct input_dev *dev = handle->dev;//从handle中获得input_dev结构体
 int retval;

 retval = mutex_lock_interruptible(&dev->mutex);
 if (retval)
     return retval;

 if (dev->going_away) {
     retval = -ENODEV;
     goto out;
 }

 handle->open++;//增加handle的引用计数

 if (!dev->users++ && dev->open)//如果是第一次打开的，并且dev存在open函数，这样就直接调用dev->open(dev)
     retval = dev->open(dev);

 if (retval) {
  dev->users--;
  if (!--handle->open) {
    synchronize_rcu();
  }
 }

 out:
      mutex_unlock(&dev->mutex);
      return retval;
}

可以看出这里存在原子操作。

在分析对设备结点read和write的时候，我们先来分析一下tsdev的事件处理。还记得我们在第一篇文章中分析了触摸屏的中断了吗？每次触笔按下，AD数据转换，最后到触笔抬起的整个过程中，有两次事件上报，一次是AD几次数据转换后的值，填充到ts.xp和ts.yp的数据缓冲区里，当填满后再求均值，最后把key和abs事件上报。第二次事件上报是，当触笔抬起的时候将key和abs的事件上报。好的，现在我们来好好分析一下吧。

我们先来分析第一次的事件上报的过程吧，我们又回到touch_timer_fire函数代码当中来，注意一下的代码：

    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);

想必大家很熟悉了，其实这3者都封装了input_event函数，我们拿其中一个来分析一下吧！

static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
{
 input_event(dev, EV_ABS, code, value);/可以看到是对EV_ABS事件的处理
}
我们继续深入：

void input_event(struct input_dev *dev,
   unsigned int type, unsigned int code, int value)//这里的参数对应的顺序是：ts.dev,EV_ABS,ABS_X,ts.xp
{
 unsigned long flags;

 if (is_event_supported(type, dev->evbit, EV_MAX)) {//首先判断设备是否支持这类功能

  spin_lock_irqsave(&dev->event_lock, flags);
  add_input_randomness(type, code, value);
  input_handle_event(dev, type, code, value);//这个函数很重要，我们来看看这里面的代码吧
  spin_unlock_irqrestore(&dev->event_lock, flags);
 }
}

这个代码很长，我们不需要全看，我们只需要看看我们需要的部分。

static void input_handle_event(struct input_dev *dev,
          unsigned int type, unsigned int code, int value)
{
 int disposition = INPUT_IGNORE_EVENT;

 switch (type) {//很明显，type是EV_ABS

 case EV_SYN:
  switch (code) {
  case SYN_CONFIG:
   disposition = INPUT_PASS_TO_ALL;
   break;

  case SYN_REPORT:
   if (!dev->sync) {
    dev->sync = 1;
    disposition = INPUT_PASS_TO_HANDLERS;
   }
   break;
  }
  break;

 case EV_KEY:
  if (is_event_supported(code, dev->keybit, KEY_MAX) &&
      !!test_bit(code, dev->key) != value) {

   if (value != 2) {
    __change_bit(code, dev->key);
    if (value)
     input_start_autorepeat(dev, code);
   }

   disposition = INPUT_PASS_TO_HANDLERS;
  }
  break;

 case EV_SW:
  if (is_event_supported(code, dev->swbit, SW_MAX) &&
      !!test_bit(code, dev->sw) != value) {

   __change_bit(code, dev->sw);
   disposition = INPUT_PASS_TO_HANDLERS;
  }
  break;

 case EV_ABS://这里就是我们需要关注的地方了，
  if (is_event_supported(code, dev->absbit, ABS_MAX)) {//这里判断是否支持ABS_X这个值

   value = input_defuzz_abs_event(value,
     dev->abs[code], dev->absfuzz[code]);//这个函数的具体操作我还是没办法弄明白，希望明白的同志和我说一声啦！

   if (dev->abs[code] != value) {//如果不同，我们就把新的value赋给abs[code]。
    dev->abs[code] = value;
    disposition = INPUT_PASS_TO_HANDLERS;//这个很重要，为最后的操作做好了铺垫。我们直接来看看程序的结尾处吧！
   }
  }
  break;

 case EV_REL:
  if (is_event_supported(code, dev->relbit, REL_MAX) && value)
   disposition = INPUT_PASS_TO_HANDLERS;

  break;

 case EV_MSC:
  if (is_event_supported(code, dev->mscbit, MSC_MAX))
   disposition = INPUT_PASS_TO_ALL;

  break;

 case EV_LED:
  if (is_event_supported(code, dev->ledbit, LED_MAX) &&
      !!test_bit(code, dev->led) != value) {

   __change_bit(code, dev->led);
   disposition = INPUT_PASS_TO_ALL;
  }
  break;

 case EV_SND:
  if (is_event_supported(code, dev->sndbit, SND_MAX)) {

   if (!!test_bit(code, dev->snd) != !!value)
    __change_bit(code, dev->snd);
   disposition = INPUT_PASS_TO_ALL;
  }
  break;

 case EV_REP:
  if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
   dev->rep[code] = value;
   disposition = INPUT_PASS_TO_ALL;
  }
  break;

 case EV_FF:
  if (value >= 0)
   disposition = INPUT_PASS_TO_ALL;
  break;

 case EV_PWR:
  disposition = INPUT_PASS_TO_ALL;
  break;
 }

 if (type != EV_SYN)
  dev->sync = 0;

 if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
  dev->event(dev, type, code, value);

 if (disposition & INPUT_PASS_TO_HANDLERS)
  input_pass_event(dev, type, code, value);//很明显，我们满足if语句里面的要求，我们再往下看看吧！
}

static void input_pass_event(struct input_dev *dev,
        unsigned int type, unsigned int code, int value)
{
 struct input_handle *handle;

 rcu_read_lock();

 handle = rcu_dereference(dev->grab);
 if (handle)//如果input device 被强制指定了handler的话，我们就执行指定的handler的event函数。关于如何强制指定handler是与ioctl标志为EVIOCGRAB有关的。
  handle->handler->event(handle, type, code, value);
 else//如果不是强制的话，我们就来遍历dev->h_list列表，我们知道handle是挂在这个链表上面的。
  list_for_each_entry_rcu(handle, &dev->h_list, d_node)//这个就是一个遍历过程，目的就是为了找到哪个handle被打开了，只有handle被打开后，它才可以接受事件，我们也就可以调用其对应的handler->event了。
   if (handle->open)
    handle->handler->event(handle,
       type, code, value);
 rcu_read_unlock();
}
在tsdev中.这个event函数对应的代码为:

static void tsdev_event(struct input_handle *handle, unsigned int type,
   unsigned int code, int value)
{
 struct tsdev *tsdev = handle->private;
 struct input_dev *dev = handle->dev;
 int wake_up_readers = 0;

 switch (type) {

 case EV_ABS:
  switch (code) {

  case ABS_X:
   tsdev->x = value;
   break;

  case ABS_Y:
   tsdev->y = value;
   break;

  case ABS_PRESSURE:
   if (value > dev->absmax[ABS_PRESSURE])
    value = dev->absmax[ABS_PRESSURE];
   value -= dev->absmin[ABS_PRESSURE];
   if (value < 0)
    value = 0;
   tsdev->pressure = value;
   break;
  }
  break;

我只是截取了与我们有关的本分