输入子系统基本框架

ubuntu@xubuntu:~/share/rk3399/kernel/drivers$ cd input

ubuntu@xubuntu:~/share/rk3399/kernel/drivers/input$ ls evdev.*

evdev.c evdev.o # 编译过了

ubuntu@xubuntu:~/share/rk3399/kernel/drivers/input$ ls input.*

input.c input.o # 编译过了

ubuntu@xubuntu:~/share/rk3399/kernel/drivers/input$

unsigned long evbit[NBITS(EV_MAX)]; // 能产生哪类事件 每一种类型的事件都
在 input_dev.evbit 中用一个位来表示,构成
//一个位图,某位为 1 表示该输入设备支持这类事件,否则不支持. 可查看 EV_MAX 宏可知
支持 10 多种类型
unsigned long keybit[NBITS(KEY_MAX)]; // 能产生哪些按键
unsigned long relbit[NBITS(REL_MAX)]; // 能产生哪些相对位移: x,y,z
unsigned long absbit[NBITS(ABS_MAX)]; // 能产生哪些绝对位移: x,y,z
buttons_dev->evbit[0] |= BIT(EV_KEY); /* 能产生按键类事件 */

struct input_dev *input_allocate_device(void) 分配输入设备
void input_free_device(struct input_dev *dev) 释放输入设备
int input_register_device(struct input_dev *dev) 注册输入设备,返回值为 0 成功
void input_unregister_device(struct input_dev *dev) 注销输入设备

struct input_event {

        struct timeval time; //时间戳

        __u16 type; //事件类型

        __u16 code; //事件代码

        __s32 value; //事件值，如坐标的偏移值 如果是按键 0 松开 ,1 按下

};

代码分析：

原则
1.两条主线
2.见名之意  函数名  宏名 猜是什么功能
3.搜索引擎

===================================
1.看分层

1.1看自己写的驱动层

ret = input_register_device(button_dev);
    |
    |
    list_add_tail(&dev->node, &input_dev_list);//输入设备dev加入链表input_dev_list
    list_for_each_entry(handler, &input_handler_list, node)
        input_attach_handler(dev, handler);//搜索input_handler_list链表，每搜索一个handler
        //调用input_attach_handler
            |
            |
            id = input_match_device(handler, dev);//输入设备dev和handler事件处理器匹配
            error = handler->connect(handler, dev, id);//匹配成功调用connect函数指针
            //谁来定义这个函数？？？
            
1.2看事件处理层 evdev.c

input_register_handler(&evdev_handler);
    |
    |
    list_add_tail(&handler->node, &input_handler_list);//handler事件处理对象加入链表input_handler_list
    list_for_each_entry(dev, &input_dev_list, node)//搜索input_dev_list链表，每搜索一个dev
        input_attach_handler(dev, handler);
            |
            |
            id = input_match_device(handler, dev);//输入设备dev和handler事件处理器匹配
            error = handler->connect(handler, dev, id);//匹配成功调用connect函数指针
            
            
小结：
dev和handler匹配最终会调用connect函数
这个connect函数的定义是在evdev.c evdev_connect函数中实现

//evdev_handler对象是evdev.c创建的
static struct input_handler evdev_handler = {
    .event        = evdev_event,
    .events        = evdev_events,
    .connect    = evdev_connect,
    .disconnect    = evdev_disconnect,
    .legacy_minors    = true,
    .minor        = EVDEV_MINOR_BASE,
    .name        = "evdev",
    .id_table    = evdev_ids,
};

//本地结构体  
struct evdev {
    int open;
    struct input_handle handle;//保存 dev和handler相关信息
    wait_queue_head_t wait;
    ...
    struct list_head client_list;
    ...
    struct device dev;
    struct cdev cdev;    
};

.connect    = evdev_connect,
static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
             const struct input_device_id *id)
        |
        |
        minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true);//申请次设备号
        //从64开始分配 最多32个 minor=0----31
        evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
        init_waitqueue_head(&evdev->wait); //初始化等待队列
        dev_no = minor;
        dev_set_name(&evdev->dev, "event%d", dev_no); //设备文件名  eventx
        
        //初始化handle对象
        evdev->handle.dev = input_get_device(dev);
        evdev->handle.name = dev_name(&evdev->dev);
        evdev->handle.handler = handler;
        evdev->handle.private = evdev;
        
        //创建设备文件准备的
        evdev->dev.devt = MKDEV(INPUT_MAJOR, minor);
        evdev->dev.class = &input_class;
        evdev->dev.parent = &dev->dev;
        evdev->dev.release = evdev_free;
        device_initialize(&evdev->dev);
        
        //初始化handle对象
        error = input_register_handle(&evdev->handle);
        
        //字符设备驱动注册
        cdev_init(&evdev->cdev, &evdev_fops);
        error = cdev_add(&evdev->cdev, evdev->dev.devt, 1);
        // 创建设备文件
        error = device_add(&evdev->dev);
        
        /*
        参考
        device_create
            device_initialize(dev)
            retval = device_add(dev);
        */
        
1.3看核心层  input.c
 __init input_init(void)
    |
    |
    err = class_register(&input_class);  // sys/class
    err = input_proc_init();  //cat /proc/bus/input/devices
    
    err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
                     INPUT_MAX_CHAR_DEVICES, "input");//申请主设备号
                     

2.应用和驱动调用关系
应用===》驱动

open(argv[1], O_RDWR)
    |
    |
    sys_open
        |
        |
        evdev_open
            |
            |
            struct evdev *evdev = container_of(inode->i_cdev, struct evdev, cdev);//注册cdev找到本地对象evdev
            struct evdev_client *client;
            client = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
            client->evdev = evdev;//保存evdev到client对象中
            file->private_data = client;//将client保存私有数据对象中
            

static const struct file_operations evdev_fops = {
    .owner        = THIS_MODULE,
    .read        = evdev_read,
    .write        = evdev_write,
    .poll        = evdev_poll,
    .open        = evdev_open,
    .release    = evdev_release,
    .unlocked_ioctl    = evdev_ioctl,
#ifdef CONFIG_COMPAT
    .compat_ioctl    = evdev_ioctl_compat,
#endif
    .fasync        = evdev_fasync,
    .flush        = evdev_flush,
    .llseek        = no_llseek,
};

//读输入设备的函数
static ssize_t evdev_read(struct file *file, char __user *buffer,
              size_t count, loff_t *ppos)
    |
    |
    struct evdev_client *client = file->private_data;//读私有数据的client对象
    struct evdev *evdev = client->evdev;
    input_event_to_user(buffer + read, &event); //拷贝数据到用户空间
    if (!(file->f_flags & O_NONBLOCK)) {
        error = wait_event_interruptible(evdev->wait, //休眠
                client->packet_head != client->tail ||
                !evdev->exist || client->revoked);
        if (error)
            return error;
    }
    
    

//硬件产生中断

input_report_key(button_dev, KEY_A, 0);//上报 键码 松开
    |
    |
    input_event
        |
        |
        if (handler->events)
            handler->events(handle, vals, count);
        else if (handler->event)
            for (v = vals; v != vals + count; v++)
                handler->event(handle, v->type, v->code, v->value);

实际上是调用
static struct input_handler evdev_handler = {
    .event        = evdev_event,
    .events        = evdev_events,        

}
    |
    |
    if (wakeup)
        wake_up_interruptible(&evdev->wait);