INPUT输入子系统——按键

struct input_dev {
const char *name; // input设备的名字
const char *phys; //
const char *uniq; //
struct input_id id; // // 这些是用来表示该input设备能够上报的事件类型有哪些 是用位的方式来表示的
unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
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)];
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 keycodemax;
unsigned int keycodesize;
void *keycode;
int (*setkeycode)(struct input_dev *dev,
unsigned int scancode, unsigned int keycode);
int (*getkeycode)(struct input_dev *dev,
unsigned int scancode, unsigned int *keycode); struct ff_device *ff; unsigned int repeat_key;
struct timer_list timer; int sync; int abs[ABS_CNT];
int rep[REP_MAX + ]; unsigned long key[BITS_TO_LONGS(KEY_CNT)];
unsigned long led[BITS_TO_LONGS(LED_CNT)];
unsigned long snd[BITS_TO_LONGS(SND_CNT)];
unsigned long sw[BITS_TO_LONGS(SW_CNT)]; int absmax[ABS_CNT];
int absmin[ABS_CNT];
int absfuzz[ABS_CNT];
int absflat[ABS_CNT];
int absres[ABS_CNT]; int (*open)(struct input_dev *dev); // 设备的open函数
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); // 上报事件 struct input_handle *grab; spinlock_t event_lock;
struct mutex mutex; unsigned int users;
bool going_away; struct device dev; // 内置的device结构体变量 struct list_head h_list; // 用来挂接input_dev 设备连接的所有handle 的一个链表头
struct list_head node; // 作为链表节点挂接到 input_dev_list 链表上 (input_dev_list链表是input核心层维护的一个用来挂接所有input设备的一个链表头)
};

struct input_handler { void *private; // 私有数据 void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value); // handler用于向上层上报输入事件的函数
bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
bool (*match)(struct input_handler *handler, struct input_dev *dev); // match 函数用来匹配handler 与 input_dev 设备
int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id); // 当handler 与 input_dev 匹配成功之后用来连接
void (*disconnect)(struct input_handle *handle); // 断开handler 与 input_dev 之间的连接
void (*start)(struct input_handle *handle); const struct file_operations *fops; // 一个file_operations 指针
int minor; // 该handler 的编号 (在input_table 数组中用来计算数组下标) input_table数组就是input子系统用来管理注册的handler的一个数据结构
const char *name; // handler的名字 const struct input_device_id *id_table; // 指向一个 input_device_id 类型的数组，用来进行与input设备匹配时用到的信息 struct list_head h_list; // 用来挂接handler 上连接的所有handle 的一个链表头
struct list_head node; // 作为一个链表节点挂接到 input_handler_list 链表上(input_handler_list 链表是一个由上层handler参维护的一个用来挂接所有注册的handler的链表头)
};

struct input_device_id { kernel_ulong_t flags; // 这个flag 表示我们的这个 input_device_id 是用来匹配下面的4个情况的哪一项
// flag == 1表示匹配总线 2表示匹配供应商 4表示匹配产品 8表示匹配版本
__u16 bustype;
__u16 vendor;
__u16 product;
__u16 version; kernel_ulong_t evbit[INPUT_DEVICE_ID_EV_MAX / BITS_PER_LONG + ];
kernel_ulong_t keybit[INPUT_DEVICE_ID_KEY_MAX / BITS_PER_LONG + ];
kernel_ulong_t relbit[INPUT_DEVICE_ID_REL_MAX / BITS_PER_LONG + ];
kernel_ulong_t absbit[INPUT_DEVICE_ID_ABS_MAX / BITS_PER_LONG + ];
kernel_ulong_t mscbit[INPUT_DEVICE_ID_MSC_MAX / BITS_PER_LONG + ];
kernel_ulong_t ledbit[INPUT_DEVICE_ID_LED_MAX / BITS_PER_LONG + ];
kernel_ulong_t sndbit[INPUT_DEVICE_ID_SND_MAX / BITS_PER_LONG + ];
kernel_ulong_t ffbit[INPUT_DEVICE_ID_FF_MAX / BITS_PER_LONG + ];
kernel_ulong_t swbit[INPUT_DEVICE_ID_SW_MAX / BITS_PER_LONG + ]; kernel_ulong_t driver_info;
};

static int __init input_init(void)
{
int err; input_init_abs_bypass(); err = class_register(&input_class); // 创建设备类 /sys/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); // 注册字符设备驱动 主设备号13 input_fops 中只实现了open函数，所以他的原理其实和misc其实是一样的
if (err) {
printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
goto fail2;
} return ; fail2: input_proc_exit();
fail1: class_unregister(&input_class);
return err;
}

struct input_dev *input_allocate_device(void)
{
struct input_dev *dev; // 定义一个 input_dev 指针 dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); // 申请分配内存
if (dev) {
dev->dev.type = &input_dev_type; // 确定input设备的 设备类型 input_dev_type
dev->dev.class = &input_class; // 确定input设备所属的设备类 class
device_initialize(&dev->dev); // input设备的初始化
mutex_init(&dev->mutex); // 互斥锁初始化
spin_lock_init(&dev->event_lock); // 自旋锁初始化
INIT_LIST_HEAD(&dev->h_list); // input_dev -> h_list 链表初始化
INIT_LIST_HEAD(&dev->node); // input_dev -> node 链表初始化 __module_get(THIS_MODULE);
} return dev;
}

int input_register_device(struct input_dev *dev) // 注册input输入设备
{
static atomic_t input_no = ATOMIC_INIT();
struct input_handler *handler; // 定义一个 input_handler 结构体指针
const char *path;
int error; /* Every input device generates EV_SYN/SYN_REPORT events. */
__set_bit(EV_SYN, dev->evbit); // 每一个input输入设备都会发生这个事件 /* KEY_RESERVED is not supposed to be transmitted to userspace. */
__clear_bit(KEY_RESERVED, dev->keybit); // 清除KEY_RESERVED 事件对应的bit位，也就是不传输这种类型的事件 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
input_cleanse_bitmasks(dev); // 确保input_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] = ;
dev->rep[REP_PERIOD] = ;
} if (!dev->getkeycode)
dev->getkeycode = input_default_getkeycode; if (!dev->setkeycode)
dev->setkeycode = input_default_setkeycode; dev_set_name(&dev->dev, "input%ld", // 设置input设备对象的名字 input+数字
(unsigned long) atomic_inc_return(&input_no) - ); error = device_add(&dev->dev); // 添加设备 例如: /sys/devices/virtual/input/input0
if (error)
return error; path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); // 获取input设备对象所在的路径 /sys/devices/virtual/input/input_xxx
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_dev->node 作为节点挂接到 input_dev_list 链表上 list_for_each_entry(handler, &input_handler_list, node) // 遍历input_handler_list 链表上的所有handler
input_attach_handler(dev, handler); // 将handler与input设备进行匹配 input_wakeup_procfs_readers(); // 更新proc 文件系统 mutex_unlock(&input_mutex); return ;
}

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id; // 定义一个input_device_id 的指针
int error; id = input_match_device(handler, dev); // 通过这个函数进行handler与input设备的匹配工作
if (!id)
return -ENODEV; error = handler->connect(handler, dev, id); // 匹配成功则调用 handler 中的 connect 函数进行连接
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;
}static const struct input_device_id *input_match_device(struct input_handler *handler,
struct input_dev *dev)
{
const struct input_device_id *id; // 定义一个 input_device_id 指针
int i; for (id = handler->id_table; id->flags || id->driver_info; id++) { // 依次遍历handler->id_table 所指向的input_device_id 数组中的各个元素
// 依次进行下面的匹配过程
if (id->flags & INPUT_DEVICE_ID_MATCH_BUS) // 匹配总线
if (id->bustype != dev->id.bustype)
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); if (!handler->match || handler->match(handler, dev))
return id; // 如果数组中的某个匹配成功了就返回他的地址
} return NULL;
}

#include <linux/init.h> // __init __exit
#include <linux/module.h> // module_init module_exit
#include <mach/regs-gpio.h>
#include <mach/gpio-bank.h>#include <mach/gpio.h>
#include <linux/leds.h>
#include <asm/string.h> #include <linux/platform_device.h>#include <linux/input.h>
#include "button_device_driver.h"#define BUTTON_GPIO_CONFIG 0xFF/* KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT
* LEFT -> EINT2 -> GPH0_2
* DOWN -> EINT3 -> GPH0_3
* UP -> KP_COL0 -> GPH2_0
* RIGHT -> KP_COL1 -> GPH2_1
* MENU -> KP_COL3 -> GPH2_3 (KEY_A)
* BACK -> KP_COL2 -> GPH2_2 (KEY_B)
*/void s5pv210_button_release(struct device *dev);struct gpioIRQ button_irq[] =
{
{
"button_Left_IRQ",
BUTTON_LEFT_IRQ,
IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,
},
{
"button_down_IRQ",
BUTTON_DOWN_IRQ,
IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING,
}
};
static struct s5pv210_button_platdata x210_button_pdata[] = {
[]={
.name = "button_Left",
.gpio = S5PV210_GPH0(),
.gpio_cfg = BUTTON_GPIO_CONFIG,
.button_code= KEY_LEFT,
.button_irq = &button_irq[],
},
[]={
.name = "button_down",
.gpio = S5PV210_GPH0(),
.gpio_cfg = BUTTON_GPIO_CONFIG,
.button_code= KEY_DOWN,
.button_irq = &button_irq[],
}
};static struct platform_device s5pv210_device_button = {
.name = "s5pv210-button",
.id = -,
.dev = {
.platform_data = &x210_button_pdata,
.release = s5pv210_button_release,
},
};
void s5pv210_button_release(struct device *dev)
{
printk(KERN_WARNING "s5pv210_button_release successful \n");
}static int __init s5pv210_button_init(void)
{
int ret = -;
printk(KERN_INFO "device.c : s5pv210_button_init successful \n");
ret = platform_device_register(&s5pv210_device_button);
if (ret < )
{
printk(KERN_WARNING "platform_add_devices fail \n");
}
return ret;
}static void __exit s5pv210_button_exit(void)
{
printk(KERN_INFO "device.c : s5pv210_button_exit successful \n"); platform_device_unregister(&s5pv210_device_button);
}module_init(s5pv210_button_init);
module_exit(s5pv210_button_exit);// MODULE_xxx这种宏作用是用来添加模块描述信息
MODULE_LICENSE("GPL"); // 描述模块的许可证
MODULE_AUTHOR("musk"); // 描述模块的作者
MODULE_DESCRIPTION("x210 button device"); // 描述模块的介绍信息
MODULE_ALIAS("button_device"); // 描述模块的别名信息
3.2.. button_driver.c#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <asm/irq.h>
#include <asm/io.h>#include <mach/irqs.h>#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>#include "button_device_driver.h"
#include <linux/kernel.h>
/*
* POWER -> EINT1 -> GPH0_1
* LEFT -> EINT2 -> GPH0_2
* DOWN -> EINT3 -> GPH0_3
* UP -> KP_COL0 -> GPH2_0
* RIGHT -> KP_COL1 -> GPH2_1
* MENU -> KP_COL3 -> GPH2_3 (KEY_A)
* BACK -> KP_COL2 -> GPH2_2 (KEY_B)
*/static struct input_dev *button_dev;static irqreturn_t button_interrupt(int irq, void *dummy)
{ struct platform_device *pdev = (struct platform_device *)dummy;
struct s5pv210_button_platdata *pdata = pdev->dev.platform_data;
if(dummy == NULL)
{
printk("\n button_interrupt fail;irq = %d\n",irq);
return -;
}
printk("\n irq = %d\n",irq);
if(irq == pdata[].button_irq->irq)
{
s3c_gpio_cfgpin(pdata[].gpio, S3C_GPIO_SFN(0x00));
input_report_key(button_dev, pdata[].button_code,!gpio_get_value(pdata[].gpio));
s3c_gpio_cfgpin(pdata[].gpio, S3C_GPIO_SFN(0x0f));
}
if(irq == pdata[].button_irq->irq)
{
s3c_gpio_cfgpin(pdata[].gpio, S3C_GPIO_SFN(0x00));
input_report_key(button_dev, pdata[].button_code,!gpio_get_value(pdata[].gpio));
s3c_gpio_cfgpin(pdata[].gpio, S3C_GPIO_SFN(0x0f));
}
input_sync(button_dev); return IRQ_HANDLED;
}static int s5pv210_button_probe(struct platform_device *pdev)
{
int error,ret;
struct s5pv210_button_platdata *pdata = pdev->dev.platform_data;
printk(KERN_INFO "button_driver.c: s5pv210_button_probe successful\n");
if (request_irq(pdata[].button_irq->irq, button_interrupt, pdata[].button_irq->irq_trigger, pdata[].button_irq->name, pdev))
{
printk(KERN_ERR "key-s5pv210.c: Can't allocate irq %d\n", pdata[].button_irq->irq);
return -EBUSY;
}
ret = gpio_request(pdata[].gpio, pdata[].name);
if(ret)
printk("button-driver: request %s fail", pdata[].name);
s3c_gpio_cfgpin(pdata[].gpio, S3C_GPIO_SFN(pdata[].gpio_cfg)); if (request_irq(pdata[].button_irq->irq, button_interrupt, pdata[].button_irq->irq_trigger, pdata[].button_irq->name, pdev))
{
printk(KERN_ERR "key-s5pv210.c: Can't allocate irq %d\n", pdata[].button_irq->irq);
return -EBUSY;
}
ret = gpio_request(pdata[].gpio, pdata[].name);
if(ret)
printk(KERN_ERR "button-driver: request %s fail", pdata[].name);
s3c_gpio_cfgpin(pdata[].gpio, S3C_GPIO_SFN(pdata[].gpio_cfg)); button_dev = input_allocate_device();
if (!button_dev)
{
printk(KERN_ERR "button.c: Not enough memory\n");
error = -ENOMEM;
goto err_free_irq;
} set_bit(EV_KEY, button_dev->evbit); set_bit(pdata[].button_code, button_dev->keybit);
set_bit(pdata[].button_code, button_dev->keybit); error = input_register_device(button_dev);
if (error)
{
printk(KERN_ERR "button_driver.c: Failed to register device\n");
goto err_free_dev;
}
return ; err_free_dev:
input_free_device(button_dev); err_free_irq:
free_irq(pdata[].button_irq->irq, pdev);
free_irq(pdata[].button_irq->irq, pdev);
gpio_free(pdata[].gpio);
gpio_free(pdata[].gpio); return error;
}static int s5pv210_button_remove(struct platform_device *pdev)
{
struct s5pv210_button_platdata *pdata = pdev->dev.platform_data;
printk(KERN_INFO "button_driver.c: s5pv210_button_remove successful\n"); free_irq(IRQ_EINT2, pdev);
free_irq(IRQ_EINT3, pdev);
gpio_free(pdata[].gpio);
gpio_free(pdata[].gpio);
input_unregister_device(button_dev); return ;
}static struct platform_driver s5pv210_button_driver = {
.probe = s5pv210_button_probe,
.remove = s5pv210_button_remove,
.driver = {
.name = "s5pv210-button",
.owner = THIS_MODULE,
}
};static int __init s5pv210_button_init(void)
{
return platform_driver_register(&s5pv210_button_driver);
}
static void __exit s5pv210_button_exit(void)
{
platform_driver_unregister(&s5pv210_button_driver);
}module_init(s5pv210_button_init);
module_exit(s5pv210_button_exit);MODULE_AUTHOR("musk");
MODULE_DESCRIPTION("s5pv210 button driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("button-s5pv210");
3.2.. button_device_driver.h#ifndef __BUTTON_DEVICE_DRIVER_H
#define __BUTTON_DEVICE_DRIVER_H #define BUTTON_LEFT_IRQ IRQ_EINT2
#define BUTTON_DOWN_IRQ IRQ_EINT3#include <mach/irqs.h>
#include <linux/interrupt.h>struct gpioIRQ {
char *name;
unsigned int irq;
unsigned long irq_trigger;};
struct s5pv210_button_platdata {
char *name; unsigned int gpio;
unsigned int gpio_cfg;
unsigned int button_code;
struct gpioIRQ *button_irq;
};#endif /* __ASM_ARCH_LEDSGPIO_H */