您的位置: 首页  >  IT文章  >  输入子系统模型解析和原理分析

输入子系统模型解析和原理分析

分类: IT文章 • 2023-12-15 15:28:37
一、输入子系统模型解析
1.为什么需要输入子系统
按写按键驱动时：需要注册1个字符启动；open，read与用户程序交互；硬件设置。
这些数据都是要输入的，所以可以全部整合成输入子系统。

2.输入子系统的模型
输入子系统模型解析和原理分析
输入子系统由设备驱动层(input device driver)，核心层(input core)和事件驱动层(event driver)三部份组成。
任何一次输入事件，如鼠标移动，按键按下，都需要通过InputDeviceDriver->InputCore->EventDrive才能到达用户空间的应用程序。
设备驱动层：
将底层的硬件输入转化为统一事件型式，向输入核心（InputCore）汇报。
输入核心层：
为设备驱动层提供输入设备注册与操作接口，如：nput_register_device；通知事件处理层对事件进行处理；
事件驱动层：
主要作用是和用户空间交互，如提供read,open等设备方法，创建设备文件等。

3.编写代码
key.c
  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/miscdevice.h>
  4. #include <linux/fs.h>
  5. #include <asm/uaccess.h>
  6. #include <linux/io.h>
  7. #include <linux/irqreturn.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/uaccess.h>
  10. #include <linux/input.h> /*上报的按键编号*/

  12. #define GPFCON (volatile unsigned long*) 0x56000050
  13. #define GPFDAT (volatile unsigned long*) 0x56000054

  15. unsigned int *gpio_data;

  17. struct work_struct *work1;

  19. struct timer_list key_timer;

  21. wait_queue_head_t key_q;

  23. unsigned int key_num = 0;

  25. struct input_dev *button_dev;                             //创建input_dev结构

  27. void key_timer_func(unsigned long data)
  28. {
  29.     unsigned int key_val;
  30.     key_val = readw(gpio_data);
  31.     if((key_val & 0x01) == 0)
  32.     {
  33.         key_num = 4;
  34.         input_report_key(button_dev, KEY_4, 1);                                   //上报事件，button_dev结构发送了KEY_4事件，按下了                           
  35.     }
  36.     else if((key_val& 0x02) == 0)
  37.     {
  38.         key_num = 1;
  39.         input_report_key(button_dev, KEY_1, 1);                                   //上报事件
  40.     }
  41.     else if((key_val & 0x04) == 0)
  42.     {
  43.         key_num = 3;
  44.         input_report_key(button_dev, KEY_3, 1);                                   //上报事件                                      
  45.     }
  46.     else if((key_val & 0x10) == 0)
  47.     {
  48.         key_num = 2;
  49.         input_report_key(button_dev, KEY_2, 1);                                   //上报事件
  50.     }

  52.     input_sync(button_dev);                                                       //上报结束
  53. }

  55. void work1_func(struct work_struct *work)
  56. {
  57.     mod_timer(&key_timer, jiffies + HZ/10);
  58. }

  60. irqreturn_t key_int(int irq, void *dev_id)
  61. {
  62.     //1.检测是否发生了按键中断
  63.     
  64.     //2.清除已经发生的按键中断
  65.    
  66.     //3.提交下半部
  67.     schedule_work(work1);

  69.     return IRQ_HANDLED;
  70. }

  72. void key_hw_init()
  73. {
  74.     unsigned int *gpio_config;
  75.     unsigned short data;
  76.     
  77.     gpio_config = ioremap(GPFCON, 4);
  78.     gpio_data = ioremap(GPFDAT, 4);
  79.     data = readw(gpio_config);
  80.     data &= ~0x33f;
  81.     data |= 0x22a;
  82.     writew(data, gpio_config);
  83. }

  85. static int button_init()
  86. {
  87.     int ret;
  88.     //分配输入型设备结构
  89.     button_dev = input_allocate_device();                              //分配input_dev结构
  90.     
  91.     //申明所支持的事件类型
  92.     set_bit(EV_KEY, button_dev->evbit);                                //申明驱动可能上报的事件类型

  94.     /*上报可能的键编号*/
  95.     set_bit(KEY_1,button_dev->keybit);                                 //申明可能上报的
  96.     set_bit(KEY_2,button_dev->keybit);
  97.     set_bit(KEY_3,button_dev->keybit);
  98.     set_bit(KEY_4,button_dev->keybit);

  100.     /*注册输入型设备*/
  101.     input_register_device(button_dev);                                  //注册input_dev结构

  103.     //按键初始化
  104.     key_hw_init();

  106.     //注册中断处理程序
  107.     ret = request_irq(IRQ_EINT0, &key_int, IRQF_TRIGGER_FALLING, "tq2440key", 0);
  108.     ret = request_irq(IRQ_EINT1, &key_int, IRQF_TRIGGER_FALLING, "tq2440key", 0);
  109.     ret = request_irq(IRQ_EINT2, &key_int, IRQF_TRIGGER_FALLING, "tq2440key", 0);
  110.     ret = request_irq(IRQ_EINT4, &key_int, IRQF_TRIGGER_FALLING, "tq2440key", 0);

  112.     //创建工作
  113.     work1 = kmalloc(sizeof(struct work_struct), GFP_KERNEL);
  114.     INIT_WORK(work1, work1_func);

  116.     //初始化定时器
  117.     init_timer(&key_timer);
  118.     key_timer.function = key_timer_func;

  120.     //注册定时器
  121.     add_timer(&key_timer);

  123.     //初始化等待队列
  124.     init_waitqueue_head(&key_q);
  125.     return 0;
  126. }

  128. static void button_exit()
  129. {
  130.     input_unregister_device(button_dev);                                        //注销input_dev结构
  131. }

  133. module_init(button_init);
  134. module_exit(button_exit);
key_app.c:
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <sys/ioctl.h>
  5. #include <sys/types.h>
  6. #include <sys/stat.h>
  7. #include <fcntl.h>
  8. #include <sys/select.h>
  9. #include <sys/time.h>
  10. #include <errno.h>
  11. #include <linux/input.h>
  12. int main(void)
  13. {
  14.     int buttons_fd;
  15.     int key_value,i=0,count;

  17.     struct input_event ev_key;
  18.     buttons_fd = open("/dev/event1", O_RDWR);                                              //这里的设备名为/dev/evnet1
  19.     if (buttons_fd < 0) {
  20.         perror("open device buttons");
  21.         exit(1);
  22.     }

  24.     for (;;) {
  25.         count = read(buttons_fd,&ev_key,sizeof(struct input_event));                       //从设备中读取input_event事件
  26.     //    printf("count=%d ",count);
  27.         for(i=0; i<(int)count/sizeof(struct input_event); i++)
  28.             if(EV_KEY==ev_key.type)
  29.                 printf("type:%d,code:%d,value:%d ", ev_key.type,ev_key.code-1,ev_key.value);
  30.             if(EV_SYN==ev_key.type)
  31.                 printf("syn event ");

  33.     }

  35.     close(buttons_fd);
  36.     return 0;
  37. }
二、输入子系统原理分析
1.子系统核心架构
输入子系统模型解析和原理分析
2.输入子系统设备注册
2.1设备注册
input_register_device:
  1. int input_register_device(struct input_dev *dev)
  2. {
  3.     static atomic_t input_no = ATOMIC_INIT(0);
  4.     struct input_handler *handler;
  5.     const char *path;
  6.     int error;

  8.     __set_bit(EV_SYN, dev->evbit);

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

  15.     init_timer(&dev->timer);
  16.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
  17.         dev->timer.data = (long) dev;
  18.         dev->timer.function = input_repeat_key;
  19.         dev->rep[REP_DELAY] = 250;
  20.         dev->rep[REP_PERIOD] = 33;
  21.     }

  23.     if (!dev->getkeycode)
  24.         dev->getkeycode = input_default_getkeycode;

  26.     if (!dev->setkeycode)
  27.         dev->setkeycode = input_default_setkeycode;

  29.     dev_set_name(&dev->dev, "input%ld",
  30.          (unsigned long) atomic_inc_return(&input_no) - 1);

  32.     error = device_add(&dev->dev);
  33.     if (error)
  34.         return error;

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

  41.     error = mutex_lock_interruptible(&input_mutex);
  42.     if (error) {
  43.         device_del(&dev->dev);
  44.         return error;
  45.     }

  47.     list_add_tail(&dev->node, &input_dev_list);

  49.     list_for_each_entry(handler, &input_handler_list, node)                                       //从input_handler_list遍历找到能处理input_dev的handler
  50.         input_attach_handler(dev, handler);                                                       //将dev设备和handler处理事件匹配

  52.     input_wakeup_procfs_readers();

  54.     mutex_unlock(&input_mutex);

  56.     return 0;
  57. }
input_attach_handler:
  1. static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
  2. {
  3.     const struct input_device_id *id;
  4.     int error;

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

  9.     id = input_match_device(handler->id_table, dev);                                  //handler中有id_table（ID表）和dev
  10.     if (!id)
  11.         return -ENODEV;

  13.     error = handler->connect(handler, dev, id);                                       //找到对应的id后进行匹配,handler和dev之间
  14.     if (error && error != -ENODEV)
  15.         printk(KERN_ERR
  16.             "input: failed to attach handler %s to device %s, "
  17.             "error: %d ",
  18.             handler->name, kobject_name(&dev->dev.kobj), error);

  20.     return error;
  21. }
evdev.c>>evdev_handler（事件层）:
  1. static struct input_handler evdev_handler = {
  2.     .event        = evdev_event,                                                //event事件，下面会用到（事件处理）
  3.     .connect    = evdev_connect,                                                //连接函数
  4.     .disconnect    = evdev_disconnect,
  5.     .fops        = &evdev_fops,                                                 //操作函数集，在下面事件上报时，open中使用
  6.     .minor        = EVDEV_MINOR_BASE,
  7.     .name        = "evdev",
  8.     .id_table    = evdev_ids,                                                  //事件驱动id表
  9. };
evdev_connect:
  1. static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
  2.              const struct input_device_id *id)
  3. {
  4.     struct evdev *evdev;
  5.     int minor;
  6.     int error;

  8.     for (minor = 0; minor < EVDEV_MINORS; minor++)                                      //检查minor是否在evdev_table中
  9.         if (!evdev_table[minor])
  10.             break;

  12.     if (minor == EVDEV_MINORS) {                                                        //检查minor是否有空闲
  13.         printk(KERN_ERR "evdev: no more free evdev devices ");
  14.         return -ENFILE;
  15.     }

  17.     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);                                   //分配evdev空间
  18.     if (!evdev)
  19.         return -ENOMEM;

  21.     INIT_LIST_HEAD(&evdev->client_list);                                                 //加入链表
  22.     spin_lock_init(&evdev->client_lock);                                                 //初始化自旋锁
  23.     mutex_init(&evdev->mutex);                                                           //初始化mutex
  24.     init_waitqueue_head(&evdev->wait);

  26.     snprintf(evdev->name, sizeof(evdev->name), "event%d", minor);
  27.     evdev->exist = 1;                                                                    //evdev初始化
  28.     evdev->minor = minor;

  30.     evdev->handle.dev = input_get_device(dev);
  31.     evdev->handle.name = evdev->name;
  32.     evdev->handle.handler = handler;
  33.     evdev->handle.private = evdev;

  35.     dev_set_name(&evdev->dev, evdev->name);
  36.     evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
  37.     evdev->dev.class = &input_class;                                                     //指定input_class
  38.     evdev->dev.parent = &dev->dev;
  39.     evdev->dev.release = evdev_free;
  40.     device_initialize(&evdev->dev);

  42.     error = input_register_handle(&evdev->handle);
  43.     if (error)
  44.         goto err_free_evdev;

  46.     error = evdev_install_chrdev(evdev);                                               
  47.     if (error)
  48.         goto err_unregister_handle;

  50.     error = device_add(&evdev->dev);                                                      //自动创建设备文件设备
  51.     if (error)
  52.         goto err_cleanup_evdev;

  54.     return 0;

  56.  err_cleanup_evdev:
  57.     evdev_cleanup(evdev);
  58.  err_unregister_handle:
  59.     input_unregister_handle(&evdev->handle);
  60.  err_free_evdev:
  61.     put_device(&evdev->dev);
  62.     return error;
  63. }
但是这里没有注册硬件驱动，实在input_init中注册了硬件驱动:
  1. static int __init input_init(void)
  2. {
  3.     int err;

  5.     input_init_abs_bypass();

  7.     err = class_register(&input_class);
  8.     if (err) {
  9.         printk(KERN_ERR "input: unable to register input_dev class ");
  10.         return err;
  11.     }

  13.     err = input_proc_init();
  14.     if (err)
  15.         goto fail1;

  17.     err = register_chrdev(INPUT_MAJOR, "input", &input_fops);                                  //这里注册驱动的函数（老版本的）,input_fops是操作函数集
  18.     if (err) {
  19.         printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
  20.         goto fail2;
  21.     }

  23.     return 0;

  25.  fail2:    input_proc_exit();
  26.  fail1:    class_unregister(&input_class);
  27.     return err;
  28. }

2.2 事件上报
input_report_key:
  1. static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
  2. {
  3.     input_event(dev, EV_KEY, code, !!value);                                        //调用input_event函数
  4. }
input_event:
  1. void input_event(struct input_dev *dev,
  2.          unsigned int type, unsigned int code, int value)
  3. {
  4.     unsigned long flags;

  6.     if (is_event_supported(type, dev->evbit, EV_MAX)) {                                      //判断上报的事件，是不是之前注册过的

  8.         spin_lock_irqsave(&dev->event_lock, flags);
  9.         add_input_randomness(type, code, value);
  10.         input_handle_event(dev, type, code, value);
  11.         spin_unlock_irqrestore(&dev->event_lock, flags);
  12.     }
  13. }
input_handle_event:
  1. static void input_handle_event(struct input_dev *dev,
  2.              unsigned int type, unsigned int code, int value)
  3. {
  4.     int disposition = INPUT_IGNORE_EVENT;

  6.     ..........  

  8.     if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
  9.         dev->sync = 0;

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

  14.     if (disposition & INPUT_PASS_TO_HANDLERS)
  15.         input_pass_event(dev, type, code, value);                                          //此处调用input_pass_event，看名字就是传递事件
  16. }
input_pass_event:
  1. static void input_pass_event(struct input_dev *dev,
  2.              unsigned int type, unsigned int code, int value)
  3. {
  4.     struct input_handle *handle;

  6.     rcu_read_lock();

  8.     handle = rcu_dereference(dev->grab);
  9.     if (handle)
  10.         handle->handler->event(handle, type, code, value);                                           //这里handle和handler，在注册时建立联系了。事件来了，就用event来处理
  11.     else
  12.         list_for_each_entry_rcu(handle, &dev->h_list, d_node)
  13.             if (handle->open)
  14.                 handle->handler->event(handle,
  15.                             type, code, value);
  16.     rcu_read_unlock();
  17. }
evdev_event:
  1. static void evdev_event(struct input_handle *handle,
  2.             unsigned int type, unsigned int code, int value)
  3. {
  4.     struct evdev *evdev = handle->private;                                   
  5.     struct evdev_client *client;
  6.     struct input_event event;

  8.     do_gettimeofday(&event.time);                                              //写入事件的type,code,value
  9.     event.type = type;
  10.     event.code = code;
  11.     event.value = value;

  13.     rcu_read_lock();

  15.     client = rcu_dereference(evdev->grab);
  16.     if (client)
  17.         evdev_pass_event(client, &event);                                       //调用保存event
  18.     else
  19.         list_for_each_entry_rcu(client, &evdev->client_list, node)
  20.             evdev_pass_event(client, &event);

  22.     rcu_read_unlock();

  24.     wake_up_interruptible(&evdev->wait);
  25. }
evdev_pass_event:
  1. static void evdev_pass_event(struct evdev_client *client,
  2.              struct input_event *event)
  3. {
  4.     /*
  5.      * Interrupts are disabled, just acquire the lock
  6.      */
  7.     spin_lock(&client->buffer_lock);
  8.     client->buffer[client->head++] = *event;                                                           //将事件保存到buff中
  9.     client->head &= EVDEV_BUFFER_SIZE - 1;
  10.     spin_unlock(&client->buffer_lock);

  12.     kill_fasync(&client->fasync, SIGIO, POLL_IN);
  13. }

2.3 应用程序如何关联驱动
input_fops:
  1. static const struct file_operations input_fops = {
  2.     .owner = THIS_MODULE,
  3.     .open = input_open_file,                                     //打开设备
  4. };
input_open_file:
  1. static int input_open_file(struct inode *inode, struct file *file)
  2. {
  3.     struct input_handler *handler;
  4.     const struct file_operations *old_fops, *new_fops = NULL;
  5.     int err;

  7.     lock_kernel();
  8.     /* No load-on-demand here? */
  9.     handler = input_table[iminor(inode) >> 5];
  10.     if (!handler || !(new_fops = fops_get(handler->fops))) {                                //将handler->fops赋值给new_fops,handler是evdev_handler（也有file_operations)
  11.         err = -ENODEV;
  12.         goto out;
  13.     }

  15.     /*
  16.      * That's _really_ odd. Usually NULL ->open means "nothing special",
  17.      * not "no device". Oh, well...
  18.      */
  19.     if (!new_fops->open) {
  20.         fops_put(new_fops);                                                 
  21.         err = -ENODEV;
  22.         goto out;
  23.     }
  24.     old_fops = file->f_op;                                  
  25.     file->f_op = new_fops;                                                                   //这里将替换的new_fops替换了，打开时的fops。下一次读的时候就会调用evdev_handler中的操作集了。如读

  27.     err = new_fops->open(inode, file);

  29.     if (err) {
  30.         fops_put(file->f_op);
  31.         file->f_op = fops_get(old_fops);
  32.     }
  33.     fops_put(old_fops);
  34. out:
  35.     unlock_kernel();
  36.     return err;
  37. }
evdev_fops（handler->fops）:
  1. static const struct file_operations evdev_fops = {                                  //各种操作集在这里，事件中的只有open
  2.     .owner        = THIS_MODULE,
  3.     .read        = evdev_read,
  4.     .write        = evdev_write,
  5.     .poll        = evdev_poll,
  6.     .open        = evdev_open,
  7.     .release    = evdev_release,
  8.     .unlocked_ioctl    = evdev_ioctl,
  9. #ifdef CONFIG_COMPAT
  10.     .compat_ioctl    = evdev_ioctl_compat,
  11. #endif
  12.     .fasync        = evdev_fasync,
  13.     .flush        = evdev_flush
  14. };
其中evdev_read:
  1. static ssize_t evdev_read(struct file *file, char __user *buffer,
  2.              size_t count, loff_t *ppos)
  3. {
  4.     struct evdev_client *client = file->private_data;
  5.     struct evdev *evdev = client->evdev;
  6.     struct input_event event;
  7.     int retval;

  9.     if (count < input_event_size())
  10.         return -EINVAL;

  12.     if (client->head == client->tail && evdev->exist &&
  13.      (file->f_flags & O_NONBLOCK))
  14.         return -EAGAIN;

  16.     retval = wait_event_interruptible(evdev->wait,
  17.         client->head != client->tail || !evdev->exist);
  18.     if (retval)
  19.         return retval;

  21.     if (!evdev->exist)
  22.         return -ENODEV;

  24.     while (retval + input_event_size() <= count &&
  25.      evdev_fetch_next_event(client, &event)) {

  27.         if (input_event_to_user(buffer + retval, &event))                               //将信息传递给用户层
  28.             return -EFAULT;

  30.         retval += input_event_size();
  31.     }

  33.     return retval;
  34. }
evdev_fetch_next_event:
  1. static int evdev_fetch_next_event(struct evdev_client *client,
  2.                  struct input_event *event)
  3. {
  4.     int have_event;

  6.     spin_lock_irq(&client->buffer_lock);

  8.     have_event = client->head != client->tail;
  9.     if (have_event) {
  10.         *event = client->buffer[client->tail++];                                                //在Buffer中取出事件
  11.         client->tail &= EVDEV_BUFFER_SIZE - 1;
  12.     }

  14.     spin_unlock_irq(&client->buffer_lock);

  16.     return have_event;
  17. }


相关推荐