linux驱动(六):input(key)

        本文主要探讨210的input子系统。

input子系统
        
input子系统包含:设备驱动层,输入核心层,事件驱动层
        事件处理层:接收核心层上报事件选择对应struct input_handler处理,每个input_handler对象处理一类事件,同类事件的设备驱动共用同一handler
        核心层:连接设备驱动层和事件处理层,为设备驱动层提供输入设备驱动接口(struct input_dev)以及输入设备驱动注册函数(input_register_device),为事件处理层提供输入事件驱动接口,通知事件处理层对事件处理
        设备驱动层:获取硬件设备信息,并转换为核心层定义的规范事件后提交给核心层,每个设备均被描述为struct input_dev对象

linux驱动(六):input(key)_第1张图片

结构体

        input_dev结构体是硬件驱动层代表input设备结构体

// include/linux/input.h 
struct input_dev {
    const char *name;            /* 设备名称 */
    const char *phys;            /* 设备在系统中的路径 */
    const char *uniq;            /* 设备唯一id */
    struct input_id id;          /* input设备id号 */

    unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)]; 

    unsigned long evbit[BITS_TO_LONGS(EV_CNT)];        /* 设备支持的事件类型,主要有EV_SYNC,EV_KEY,EV_KEY,EV_REL,EV_ABS等*/    
    unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];        /* 按键所对应的位图 */
    unsigned long relbit[BITS_TO_LONGS(REL_CNT)];        /* 相对坐标对应位图 */
    unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];        /* 决定左边对应位图 */
    unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];        /* 支持其他事件 */
    unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];        /* 支持led事件 */
    unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];        /* 支持声音事件 */
    unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];            /* 支持受力事件 */
    unsigned long swbit[BITS_TO_LONGS(SW_CNT)];            /* 支持开关事件 */

    unsigned int hint_events_per_packet;            /*  平均事件数*/

    unsigned int keycodemax;            /* 支持最大按键数 */
    unsigned int keycodesize;            /* 每个键值字节数 */
    void *keycode;            /* 存储按键值的数组的首地址 */

    int (*setkeycode)(struct input_dev *dev,
              const struct input_keymap_entry *ke,
              unsigned int *old_keycode);
    int (*getkeycode)(struct input_dev *dev,
              struct input_keymap_entry *ke);

    struct ff_device *ff;        /* 设备关联的反馈结构,如果设备支持 */

    unsigned int repeat_key;    /* 最近一次按键值,用于连击 */
    struct timer_list timer;    /* 自动连击计时器 */

    int rep[REP_CNT];             /* 自动连击参数 */

    struct input_mt *mt;        /* 多点触控区域 */

    struct input_absinfo *absinfo;        /* 存放绝对值坐标的相关参数数组 */

    unsigned long key[BITS_TO_LONGS(KEY_CNT)];    /* 反应设备当前的按键状态 */
    unsigned long led[BITS_TO_LONGS(LED_CNT)];    /* 反应设备当前的led状态 */
    unsigned long snd[BITS_TO_LONGS(SND_CNT)];    /* 反应设备当前的声音状态 */
    unsigned long sw[BITS_TO_LONGS(SW_CNT)];    /* 反应设备当前的开关状态 */

    int (*open)(struct input_dev *dev);        /* 第一次打开设备时调用,初始化设备用 */
    void (*close)(struct input_dev *dev);        /* 最后一个应用程序释放设备事件,关闭设备 */
    int (*flush)(struct input_dev *dev, struct file *file);        /* 用于处理传递设备的事件 */
    int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);    /* 事件处理函数,主要是接收用户下发的命令,如点亮led */

    struct input_handle __rcu *grab;        /* 当前占有设备的input_handle */

    spinlock_t event_lock;        /* 事件锁 */
    struct mutex mutex;            /* 互斥体 */

    unsigned int users;        /* 打开该设备的用户数量(input_handle) */
    bool going_away;            /* 标记正在销毁的设备 */

    struct device dev;        /* 设备 */

    struct list_head    h_list;        /* 设备所支持的input handle */
    struct list_head    node;        /* 用于将此input_dev连接到input_dev_list */

    unsigned int num_vals;        /* 当前帧中排队的值数 */
    unsigned int max_vals;        /*  队列最大的帧数*/
    struct input_value *vals;    /*  当前帧中排队的数组*/

    bool devres_managed;        /* 表示设备被devres 框架管理,不需要明确取消和释放*/
};

        input_handler结构体是事件层代表事件处理器

// include/linux/input.h 
struct input_handler {

    void *private;        /* 存放handle数据 */

    void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
    void (*events)(struct input_handle *handle,
               const struct input_value *vals, unsigned int count);
    bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
    bool (*match)(struct input_handler *handler, struct input_dev *dev);
    int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
    void (*disconnect)(struct input_handle *handle);
    void (*start)(struct input_handle *handle);

    const struct file_operations *fops;

    bool legacy_minors;
    int minor;
    const char *name;        /* 名字 */

    const struct input_device_id *id_table;        /* input_dev匹配用的id */

    struct list_head    h_list;    /* 用于链接和handler相关的handle,input_dev与input_handler配对之后就会生成一个input_handle结构 */
    struct list_head    node;    /* 用于将该handler链入input_handler_list,链接所有注册到内核的所有注册到内核的事件处理器 */
};


        input_handle结构体属于核心层代表配对input设备(input_dev)与input事件处理器(input_handler)

// include/linux/input.h 
struct input_handle {

    void *private;                /* 数据指针 */

    int open;                    /* 打开标志,每个input_handle 打开后才能操作 */
    const char *name;            /* 设备名称 */

    struct input_dev *dev;            /* 指向所属的input_dev */
    struct input_handler *handler;    /* 指向所属的input_handler */

    struct list_head    d_node;        /* 用于链入所指向的input_dev的handle链表 */
    struct list_head    h_node;        /* 用于链入所指向的input_handler的handle链表 */
};

        Evdev字符设备事件结构体

/* drivers/input/evdev.c */
struct evdev {
        int open;    /* 设备被打开的计数 */
        struct input_handle handle;  /* 关联的input_handle */ 
        wait_queue_head_t wait;  /* 等待队列,当前进程读取设备,没有事件产生时,
进程就会sleep */
        struct evdev_client __rcu *grab;  /* event响应 */
struct list_head client_list;  /* evdev_client链表,说明evdev设备可以处理多个 evdev _client,可以有多个进程访问evdev设备 */
        spinlock_t client_lock;
        struct mutex mutex;
        struct device dev;
        struct cdev cdev;
        bool exist;   /* 设备存在判断 */
};

        evdev_client字符设备事件响应结构体

struct evdev_client {
    unsigned int head;                 /* 动态索引,每加入一个event到buffer中,head++ */
    unsigned int tail;                /* 动态索引,每取出一个buffer中到event,tail++ */
    unsigned int packet_head;         /* 数据包头部 */
    spinlock_t buffer_lock; 
    struct fasync_struct *fasync;     /* 异步通知函数 */
    struct evdev *evdev;
    struct list_head node;            /* evdev_client链表项 */
    int clkid;
    bool revoked;
    unsigned int bufsize;
    struct input_event buffer[];        /* 用来存放input_dev事件缓冲区 */
};


        evdev_handler事件处理函数结构体

/* drivers/input/input.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", /* handler名称 */
        .id_table    = evdev_ids, /* 断开该链接 */
};

        input_event结构体(按键编码信息)

/* drivers/input/evdev.c */
struct input_event {                                                            
    struct timeval time;   /* 事件发生的时间  */                                
    __u16 type;             /* 事件类型 */                                      
    __u16 code;             /* 事件码 */                                        
    __s32 value;            /* 事件值 */                                        
};

 

inputcore

subsys_initcall(input_init);
module_exit(input_exit);
static int __init input_init(void)
{
    int err;

    input_init_abs_bypass();

    err = class_register(&input_class);
    if (err) {
        printk(KERN_ERR "input: unable to register input_dev class\n");
        return err;
    }

    err = input_proc_init();
    if (err)
        goto fail1;

    err = register_chrdev(INPUT_MAJOR, "input", &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;
}
struct class input_class = {
    .name        = "input",
    .devnode    = input_devnode,
};
#define INPUT_MAJOR        13
static const struct file_operations input_fops = {
    .owner = THIS_MODULE,
    .open = input_open_file,
};

        class_register注册输入设备类/sys/class/input
        input_proc_init注册proce文件/proc/bus/input
        register_chrdevs注册设备注册,主设备号为13

linux驱动(六):input(key)_第2张图片

static int input_open_file(struct inode *inode, struct file *file)
{
    struct input_handler *handler;
    const struct file_operations *old_fops, *new_fops = NULL;
    int err;

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

    /* No load-on-demand here? */
    handler = input_table[iminor(inode) >> 5];
    if (handler)
        new_fops = fops_get(handler->fops);

    mutex_unlock(&input_mutex);

    /*
     * That's _really_ odd. Usually NULL ->open means "nothing special",
     * not "no device". Oh, well...
     */
    if (!new_fops || !new_fops->open) {
        fops_put(new_fops);
        err = -ENODEV;
        goto out;
    }

    old_fops = file->f_op;
    file->f_op = new_fops;

    err = new_fops->open(inode, file);
    if (err) {
        fops_put(file->f_op);
        file->f_op = fops_get(old_fops);
    }
    fops_put(old_fops);
out:
    return err;
}
static const struct file_operations input_fops = {
    .owner = THIS_MODULE,
    .open = input_open_file,
};
static struct input_handler *input_table[8];

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

        获取子设备号并除以32的值为input驱动数组号,来获取对应input_handler中的fops
        input_table为input_register_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;
    }

    list_add_tail(&handler->node, &input_handler_list);

    list_for_each_entry(dev, &input_dev_list, node)
        input_attach_handler(dev, handler);

    input_wakeup_procfs_readers();

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

static int __init evdev_init(void)
{
    return input_register_handler(&evdev_handler);
}

        依据evdev.c分析input_register_hndler

static struct input_handler evdev_handler = {
    .event        = evdev_event,
    .connect    = evdev_connect,
    .disconnect    = evdev_disconnect,
    .fops        = &evdev_fops,
    .minor        = EVDEV_MINOR_BASE,
    .name        = "evdev",
    .id_table    = evdev_ids,
};
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
}
#define EVDEV_MINOR_BASE    64
static const struct input_device_id evdev_ids[] = {
    { .driver_info = 1 },    /* Matches all devices */
    { },            /* Terminating zero entry */
};
static void evdev_event(struct input_handle *handle,
            unsigned int type, unsigned int code, int value)
{
    struct evdev *evdev = handle->private;
    struct evdev_client *client;
    struct input_event event;
    struct timespec ts;

    ktime_get_ts(&ts);
    event.time.tv_sec = ts.tv_sec;
    event.time.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
    event.type = type;
    event.code = code;
    event.value = value;

    rcu_read_lock();

    client = rcu_dereference(evdev->grab);
    if (client)
        evdev_pass_event(client, &event);
    else
        list_for_each_entry_rcu(client, &evdev->client_list, node)
            evdev_pass_event(client, &event);

    rcu_read_unlock();

    wake_up_interruptible(&evdev->wait);
}
static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
             const struct input_device_id *id)
{
    struct evdev *evdev;
    int minor;
    int error;

    for (minor = 0; minor < EVDEV_MINORS; minor++)
        if (!evdev_table[minor])
            break;

    if (minor == EVDEV_MINORS) {
        printk(KERN_ERR "evdev: no more free evdev devices\n");
        return -ENFILE;
    }

    evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
    if (!evdev)
        return -ENOMEM;

    INIT_LIST_HEAD(&evdev->client_list);
    spin_lock_init(&evdev->client_lock);
    mutex_init(&evdev->mutex);
    init_waitqueue_head(&evdev->wait);

    dev_set_name(&evdev->dev, "event%d", minor);
    evdev->exist = 1;
    evdev->minor = minor;

    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, EVDEV_MINOR_BASE + minor);
    evdev->dev.class = &input_class;
    evdev->dev.parent = &dev->dev;
    evdev->dev.release = evdev_free;
    device_initialize(&evdev->dev);

    error = input_register_handle(&evdev->handle);
    if (error)
        goto err_free_evdev;

    error = evdev_install_chrdev(evdev);
    if (error)
        goto err_unregister_handle;

    error = device_add(&evdev->dev);
    if (error)
        goto err_cleanup_evdev;

    return 0;

 err_cleanup_evdev:
    evdev_cleanup(evdev);
 err_unregister_handle:
    input_unregister_handle(&evdev->handle);
 err_free_evdev:
    put_device(&evdev->dev);
    return error;
}
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;

    /*
     * Filters go to the head of the list, normal handlers
     * to the tail.
     */
    if (handler->filter)
        list_add_rcu(&handle->d_node, &dev->h_list);
    else
        list_add_tail_rcu(&handle->d_node, &dev->h_list);

    mutex_unlock(&dev->mutex);

    /*
     * 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_rcu(&handle->h_node, &handler->h_list);

    if (handler->start)
        handler->start(handle);

    return 0;
}

        input_register_handler为事件注册函数,struct input_handler为事件处理结构体
        evdev_init调用input_register_handler和struct input_handler evdev_handler注册evdev设备事件
        evdev_fops为edev类型设备操作函数,EVDEV_MINOR_BASE为64存在input_table[2]中
        id_table为handler支持的输入设备(input_dev->id==input_handler->id_table,调用connect) 

设备驱动层

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;

    /* Every input device generates EV_SYN/SYN_REPORT events. */
    __set_bit(EV_SYN, dev->evbit);

    /* KEY_RESERVED is not supposed to be transmitted to userspace. */
    __clear_bit(KEY_RESERVED, dev->keybit);

    /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
    input_cleanse_bitmasks(dev);

    /*
     * 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;
    }

    if (!dev->getkeycode)
        dev->getkeycode = input_default_getkeycode;

    if (!dev->setkeycode)
        dev->setkeycode = input_default_setkeycode;

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

    error = device_add(&dev->dev);
    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);

    list_for_each_entry(handler, &input_handler_list, node)
        input_attach_handler(dev, 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;

    id = input_match_device(handler, dev);
    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;
}
list_add_tail(&dev->node, &input_dev_list);
list_for_each_entry(handler, &input_handler_list, node)input_attach_handler(dev, handler);

        将要注册input_dev驱动设备放在input_dev_list链表中,调用input_attach_handler函数,将每个input_handle的id_table进连接接
        注册input_handler类同设备注册通过inputhandle将input_handler和input_dev连接(id匹配)

int input_register_handler(struct input_handler *handler)
{
    ......
 
    list_add_tail(&handler->node, &input_handler_list);
 
    list_for_each_entry(dev, &input_dev_list, node)
        input_attach_handler(dev, handler);
 
    ......
}

核心层提供给设备驱动层的接口函数

struct input_dev *input_allocate_device(void);
分配input_dev内存
void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code);
设置输入设备上报事件,input_set_capability(dev, EV_KEY, KEY_E);
dev:input_dev结构体,type上报事件类型,code上报具体事件
int input_register_device(struct input_dev *dev);
input核心层注册设备

demo:

        210内核自带轮循方式检测按键,自写中断方式

button-x210.c

#include  
#include  
#include 
#include  
#include 
#include 
#include 
#include 

#define BUTTON_IRQ_LEFT         IRQ_EINT2

static struct input_dev *button_dev;

static irqreturn_t button_interrupt(int irq, void *dummy) 
{ 
        int flag;
 
        //中断产生,设置gpio为输入模式下获取gpio号
        s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0));
        flag = gpio_get_value(S5PV210_GPH0(2));

        //重新置为中断模式
        s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0f));
 
        //上报按键中断事件
        input_report_key(button_dev, KEY_LEFT, !flag);

        //同步按键中断
        input_sync(button_dev);
 
        return IRQ_HANDLED;
}

static int __init button_init(void) 
{ 
        int error;

        //申请gpio
        error = gpio_request(S5PV210_GPH0(2), "GPH0_2");
        if(error)
        {
                printk("button-x210.c: request gpio GPH0(2) fail");
                return -EBUSY;
        }

        //配置gpio为中断模式
        s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_SFN(0x0f));

        //申请中断
        if (request_irq(BUTTON_IRQ_LEFT, button_interrupt, 0, "button", NULL)) 
        { 
                printk(KERN_ERR "button-x210.c: Can't allocate irq %d\n", BUTTON_IRQ_LEFT);
                goto err_free_gpio;
                return -EBUSY; 
        }

        //申请设备内存
        button_dev = input_allocate_device();
        if (!button_dev) 
        { 
                printk(KERN_ERR "button-x210.c: Not enough memory\n");
                error = -ENOMEM;
                goto err_free_irq; 
        }

        //设备初始化
        button_dev->name = "x210";

        //设置设备上报事件
        input_set_capability(button_dev, EV_KEY, KEY_LEFT);

        //设备注册
        error = input_register_device(button_dev);
        if (error) 
        { 
                printk(KERN_ERR "button-x210.c: Failed to register device\n");
                goto err_free_dev; 
        }
                return 0;
        err_free_dev:
                input_free_device(button_dev);
        err_free_irq:
                free_irq(BUTTON_IRQ_LEFT, button_interrupt);
        err_free_gpio:
                gpio_free(S5PV210_GPH0(2));

        return error; 
}

static void __exit button_exit(void) 
{ 
        input_unregister_device(button_dev); 
        input_free_device(button_dev);
        free_irq(BUTTON_IRQ_LEFT, NULL);
        gpio_free(S5PV210_GPH0(2));
}

module_init(button_init); 
module_exit(button_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("cxb");
MODULE_DESCRIPTION("button  module");
MODULE_ALIAS("button");

button.c 

#include 
#include 
#include 
#include 
#include 
#include 
 
#define X210_KEY        "/dev/input/event2"
 
 
int main(void)
{
        int fd = -1, ret = -1;
        struct input_event ev;

        fd = open(X210_KEY, O_RDONLY);
        if (fd < 0)
        {
                perror("open");
                return -1;
        }

        while (1)
        {
                memset(&ev, 0, sizeof(struct input_event));
                ret = read(fd, &ev, sizeof(struct input_event));
                if (ret != sizeof(struct input_event))
                {
                        perror("read");
                        close(fd);
                        return -1;
                }

                printf("-------------------------\n");
                printf("type: %hd\n", ev.type);
                printf("code: %hd\n", ev.code);
                printf("value: %d\n", ev.value);
                printf("\n");
        }

        close(fd);

        return 0;
}

操作流程: 

cd /root/kernel/arch/arm/mach-s5pv210

rm button-x210.o

vim Makefile

#obj-$(CONFIG_MACH_SMDKV210)    += button-x210.o

make -j8

linux驱动(六):input(key)_第3张图片 linux驱动(六):input(key)_第4张图片

你可能感兴趣的:(linux,驱动开发,c语言)