Use Timer Method（1）
定时器操作的步骤：
1.定义一个timer_list结构体：static struct timer_list button_timer;
2.定时器超时调用的函数：button_timer.function = button_timer_function;
给定时器操作函数传的参数：button_timer.data=test;
根据该定义该timer_list的参数初始化定时器：init_timer(&button_timer);
激活定时器：add_timer(&button_timer);
注：setup_timer(&button_timer,button_timer_function,test); 这个可代替上面的2步。最简单的方法是调用 setup_timer，
该函数初始化计时器并设置用户提供的回调函数和上下文。
3. 在中断处理函数中，mod_timer(&button_timer, jiffies+HZ/100); //10ms
注：动态定时器不需要手动释放，mod_timer超时执行之后，就会自动释放。
1.添加头文件
#include <linux/timer.h>
2.定义一个timer_list结构体成员
struct timer_list t1;
3.初始化定时器
init_timer(&t1);
4.填充t1成员
t1.function=&timer_fn; //回调函数
t1.expires=jiffies+HZ; //定时值
t1.data=HZ; //回调函数参数
5.添加定时器回调函数
void timer_fn(unsigned long i) //注意函数格式:返回void,参数unsigned long
{
printk("1s over!n");
t1.expires=jiffies+i; //定时值
add_timer(&t1); //修改定时器值add_timer会调用mod_timer
}
6.添加定时器
add_timer(&t1);
7修改定时值
add_timer(&t1);
或者
mod_timer(&t1,jiffies+HZ);
一般放在回调函数里面重装定时器定时值
示例分析如下：
下面的文章是基于mini2440的gpio按键来讲解input子系统。
以mini2440为例，用该板的bsp文件，进行input子系统的讲解.所用的版本为android4.0.
先来看下板级支持文件都注册了那些资源。
下面是五个按键的资源：
#define KEY_POWER 116 /* SC System Power Down */
#define KEY_F1 59
#define KEY_F2 60
#define KEY_F3 61
#define KEY_F5 63
struct gpio_keys_button {
/* Configuration parameters */
unsigned int code; /* input event code (KEY_*, SW_*) *///上报事件的code
int gpio;//所用的gpio引脚
int active_low;//是否低电平有效
const char *desc; //该按键的描述符
unsigned int type; /* input event type (EV_KEY, EV_SW, EV_ABS) */
int wakeup; /* configure the button as a wake-up source */
int debounce_interval; /* debounce ticks interval in msecs */
bool can_disable;
int value; /* axis value for EV_ABS */
};
static struct gpio_keys_button mini2440_buttons[] = {
{
.gpio = S3C2410_GPG(0), /* K1 */
.code = KEY_F1,
.desc = "Button 1",
.active_low = 1,
},
{
.gpio = S3C2410_GPG(3), /* K2 */
.code = KEY_F2,
.desc = "Button 2",
.active_low = 1,
},
{
.gpio = S3C2410_GPG(5), /* K3 */
.code = KEY_F3,
.desc = "Button 3",
.active_low = 1,
},
{
.gpio = S3C2410_GPG(6), /* K4 */
.code = KEY_POWER,
.desc = "Power",
.active_low = 1,
},
{
.gpio = S3C2410_GPG(7), /* K5 */
.code = KEY_F5,
.desc = "Button 5",
.active_low = 1,
},
};
/*下面是平台数据的声明*/
struct gpio_keys_platform_data {
struct gpio_keys_button *buttons;
int nbuttons;
unsigned int poll_interval; /* polling interval in msecs -
for polling driver only */
unsigned int rep:1; /* enable input subsystem auto repeat */
int (*enable)(struct device *dev);
void (*disable)(struct device *dev);
const char *name; /* input device name */
};
static struct gpio_keys_platform_data mini2440_button_data = {
.buttons = mini2440_buttons,
.nbuttons = ARRAY_SIZE(mini2440_buttons),
};
/*下面是平台设备的声明*/
struct platform_device {
const char * name;
int id;
struct device dev;
u32 num_resources;
struct resource * resource;
const struct platform_device_id *id_entry;
/* MFD cell pointer */
struct mfd_cell *mfd_cell;
/* arch specific additions */
struct pdev_archdata archdata;
};
static struct platform_device mini2440_button_device = {
.name = "gpio-keys",
.id = -1,
.dev = {
.platform_data = &mini2440_button_data,
}
};
static struct platform_device *mini2440_devices[] __initdata = {
...................
&mini2440_button_device,
………
};
static void __init mini2440_init(void)
{
.............................
platform_add_devices(mini2440_devices, ARRAY_SIZE(mini2440_devices));
……………
}
MACHINE_START(MINI2440, "MINI2440")
/* Maintainer: Michel Pollet */
.boot_params = S3C2410_SDRAM_PA + 0x100,
.map_io = mini2440_map_io,
.init_machine = mini2440_init,
.init_irq = s3c24xx_init_irq,
.timer = &s3c24xx_timer,
MACHINE_END
上面是把该设备注册到平台总线上。
下面看下平台驱动的注册：
static struct platform_driver gpio_keys_device_driver = {
.probe = gpio_keys_probe,
.remove = __devexit_p(gpio_keys_remove),
.driver = {
.name = "gpio-keys",
.owner = THIS_MODULE,
}
};
static int __init gpio_keys_init(void)
{
return platform_driver_register(&gpio_keys_device_driver);
}
module_init(gpio_keys_init);
在注册平台驱动时，如果成功匹配平台设备后，会调用平台驱动的probe函数。
下面看下该驱动的probe函数。
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
/*取出再bsp文件注册的平台数据*/
struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
/*这里出现了一个新的结构体，该结构体定义如下*/
/*struct gpio_keys_drvdata {
struct input_dev *input;
struct mutex disable_lock;
unsigned int n_buttons;
int (*enable)(struct device *dev);
void (*disable)(struct device *dev);
struct gpio_button_data data[0];
};*/
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct input_dev *input;
/*分配gpio_keys_drvdata结构体内存*/
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
/*分配一个input结构体，并初始化部分成员*/
input = input_allocate_device();
/*为ddata的各个成员变量赋值*/
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
mutex_init(&ddata->disable_lock);
/*把ddata设备pdev平台设备的driver data*/
platform_set_drvdata(pdev, ddata);
/*把ddata设备input设备的driver data*/
input_set_drvdata(input, ddata);
/*设置input设备的各个成员变量*/
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* 根据pdata的rep成员值，设备input子系统的功能*/
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
/*取出pdata中得资源进行赋值*/
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
/*为三目运算符，相当于button->type ?: button->type:EV_KEY;*/
unsigned int type = button->type ?: EV_KEY;
bdata->input = input;//
bdata->button = button;
error = gpio_keys_setup_key(pdev, bdata, button);
if (button->wakeup)//该键能否作为唤醒源？
wakeup = 1;
input_set_capability(input, type, button->code);
}
}
error = input_register_device(input);
/* get current state of buttons */
for (i = 0; i < pdata->nbuttons; i++)
gpio_keys_report_event(&ddata->data[i]);
input_sync(input);
device_init_wakeup(&pdev->dev, wakeup);
return 0;
}
下面逐步分解上面标成粉色的函数。
第一个分配一个input dev并进行初始化
struct input_dev *input_allocate_device(void)
{
struct input_dev *dev;
dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
if (dev) {
dev->dev.type = &input_dev_type;
dev->dev.class = &input_class;
device_initialize(&dev->dev);
mutex_init(&dev->mutex);
spin_lock_init(&dev->event_lock);
INIT_LIST_HEAD(&dev->h_list);
INIT_LIST_HEAD(&dev->node);
}
return dev;
}
分析第二个：
static int __devinit gpio_keys_setup_key(struct platform_device *pdev,
struct gpio_button_data *bdata,
struct gpio_keys_button *button)
{
/*取出按键的描述符*/
const char *desc = button->desc ? button->desc : "gpio_keys";
struct device *dev = &pdev->dev;
/*设置该bdata的定时器函数*/
setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata);
/*设置该bdata的work函数*/
INIT_WORK(&bdata->work, gpio_keys_work_func);
/*申请button的gpio*/
error = gpio_request(button->gpio, desc);
/*设置gpio的方向*/
error = gpio_direction_input(button->gpio);
// button->debounce_interval = 5; //可以通过改变debounce_interval 的值修改驱动时间
if (button->debounce_interval) { //设置gpio的去抖间隔
error = gpio_set_debounce(button->gpio,
button->debounce_interval * 1000);
/* use timer if gpiolib doesn't provide debounce */
if (error < 0)
bdata->timer_debounce = button->debounce_interval;
}
irq = gpio_to_irq(button->gpio); //该gpio引脚对应分配的中断
irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
if (!button->can_disable)
irqflags |= IRQF_SHARED;
/*注册该irq的中断处理函数，并设置标记*/
error = request_any_context_irq(irq, gpio_keys_isr, irqflags, desc, bdata);
其中中断处理函数如下：
static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
{
struct gpio_button_data *bdata = dev_id;
struct gpio_keys_button *button = bdata->button;
BUG_ON(irq != gpio_to_irq(button->gpio));
if (bdata->timer_debounce)//如果有去抖间隔则修改定时器
mod_timer(&bdata->timer,
jiffies + msecs_to_jiffies(bdata->timer_debounce));
else
schedule_work(&bdata->work);//如果没有，直接执行work
return IRQ_HANDLED;
}
}
如果定时器到期，则执行定时器处理函数：
static void gpio_keys_timer(unsigned long _data)
{
struct gpio_button_data *data = (struct gpio_button_data *)_data;
schedule_work(&data->work);//执行相应的work
}
中断处理的结果是执行相应的work。看下work函数
static void gpio_keys_work_func(struct work_struct *work)
{
struct gpio_button_data *bdata =
container_of(work, struct gpio_button_data, work);
gpio_keys_report_event(bdata);//用input子系统，向上层报事件
}
第三个函数，设置该input dev的能力记录本设备对那些事件感兴趣
void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
{
switch (type) {
case EV_KEY:
__set_bit(code, dev->keybit);// 比如按键,应该对哪些键值的按键进行处理(对于其它按键不予理睬)
break;
__set_bit(type, dev->evbit);
}
第四个函数：向input核心注册input设备
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);//确保在dev->evbit中没有支持的能力被清除掉
if (!dev->hint_events_per_packet)
dev->hint_events_per_packet = input_estimate_events_per_packet(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;
}
/*设置input dev成员变量的处理函数*/
if (!dev->getkeycode)
dev->getkeycode = input_default_getkeycode;
if (!dev->setkeycode)
dev->setkeycode = input_default_setkeycode;
/*设置该dev name*/
dev_set_name(&dev->dev, "input%ld",
(unsigned long) atomic_inc_return(&input_no) - 1);
error = device_add(&dev->dev);//把该设备增加到设备驱动模型中
/*把该dev加入到input_dev_list 链表*/
list_add_tail(&dev->node, &input_dev_list);
/*遍历input_hander_list链表中得hander，以便匹配input dev*/
list_for_each_entry(handler, &input_handler_list, node)
input_attach_handler(dev, handler);
return 0;
}
下面看下匹配函数：
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
id = input_match_device(handler, dev);//返回匹配成功的id
error = handler->connect(handler, dev, id);//如果匹配成功，则调用hander的connect函数
return error;
}
下面主要看下match的过程：
static const struct input_device_id *input_match_device(struct input_handler *handler,
struct input_dev *dev)
{
const struct input_device_id *id;
for (id = handler->id_table; id->flags || id->driver_info; id++) {
if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)//如果是匹配bus，则比较id.bus
if (id->bustype != dev->id.bustype)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR) //如果是匹配vender则比较id.vender
if (id->vendor != dev->id.vendor)
continue;
//如果是匹配product则比较id.product
if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
if (id->product != dev->id.product)
continue;
//如果是匹配versiont则比较id.version
if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
if (id->version != dev->id.version)
continue;
/*如果hander支持该能力，则dev也要支持，否则不匹配*/
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);
下面看下这个宏：
#define MATCH_BIT(bit, max)
for (i = 0; i < BITS_TO_LONGS(max); i++)
if ((id->bit[i] & dev->bit[i]) != id->bit[i])
break;
if (i != BITS_TO_LONGS(max))
continue;
/*如果hander的match空，则返回该id，或者调用match继续匹配，匹配成员的话也返回id*/
if (!handler->match || handler->match(handler, dev))
return id;
}
return NULL;
}
上面input dev已经注册完了，下面看看hander的注册.
static const struct input_device_id evdev_ids[] = {
{ .driver_info = 1 }, /* Matches all devices 来则不拒，公交车*/
{ }, /* Terminating zero entry */
};
MODULE_DEVICE_TABLE(input, evdev_ids);
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 int __init evdev_init(void)
{
return input_register_handler(&evdev_handler);
}
module_init(evdev_init);
下面看下hander的注册：
static struct input_handler *input_table[8];
int input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
int retval;
INIT_LIST_HEAD(&handler->h_list);
if (handler->fops != NULL) {
if (input_table[handler->minor >> 5]) {//判断input_table的相应项是否被占用
retval = -EBUSY;
goto out;
}
input_table[handler->minor >> 5] = handler; // 如果没有占用，则把hander填入
}
/*把要注册的hander加入input_handler_list链表中*/
list_add_tail(&handler->node, &input_handler_list);
/*遍历input_dev_list链表上得每一个dev，去匹配该hander*/
list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler);//开始进行匹配
}
匹配成功后，返回匹配成功的id，然后调用该handler的connect函数。
static struct evdev *evdev_table[EVDEV_MINORS]; //evdev的容器
static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
const struct input_device_id *id)
{
struct evdev *evdev;
int minor;
/*在容器中找个空闲的地方*/
for (minor = 0; minor < EVDEV_MINORS; minor++)
if (!evdev_table[minor])
break;
/*分配一个evdev变量*/
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
/*初始化该evdev的成员变量*/
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 = true;
evdev->minor = minor;
/*初始化该evdev的成员变量handle，handle相当于是红娘连接input dev和相应的hander*/
evdev->handle.dev = input_get_device(dev);//增加该dev的引用计数
evdev->handle.name = dev_name(&evdev->dev);//设置该evdev的name
evdev->handle.handler = handler;
evdev->handle.private = evdev;//设置hander的私有数据,这个在下面会用到
/*初始化该evdev的成员变量dev*/
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);
/*注册上面初始化好的handle*/
error = input_register_handle(&evdev->handle);
/*安装evdev，其实就是放到全局的evdev_table 数组中*/
error = evdev_install_chrdev(evdev);
该函数如下：
static int evdev_install_chrdev(struct evdev *evdev)
{
evdev_table[evdev->minor] = evdev;
return 0;
}
/*把该evdev设备增加到设备驱动模型中*/
error = device_add(&evdev->dev);
return 0;
}
下面主要看input_register_handle干了啥活？
int input_register_handle(struct input_handle *handle)
{
struct input_handler *handler = handle->handler;
struct input_dev *dev = handle->dev;
list_add_tail_rcu(&handle->d_node, &dev->h_list);//加入到dev hist链表的末尾
list_add_tail_rcu(&handle->h_node, &handler->h_list);//加入到hander的hist尾部
return 0;
注册的过程也就是把该handle加入dev和hander的链表中
}
该搭的关系已经搞好啦，下面就是要用啦，用的时候看三者是怎么配合的。
下面看现在中断处理中，是如何用的？
上面有说过，在中断发生后，会调用work，在work中去处理上报键值：上报函数如下：
static void gpio_keys_report_event(struct gpio_button_data *bdata)
{
struct gpio_keys_button *button = bdata->button;//取出每一个键的结构体
struct input_dev *input = bdata->input; //把该键的input设备也取出来
unsigned int type = button->type ?: EV_KEY; //类型为key
int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low;
input_event(input, type, button->code, !!state);
input_sync(input);
}
继续分析：
void input_event(struct input_dev *dev,unsigned int type, unsigned int code, int value)
{
if (is_event_supported(type, dev->evbit, EV_MAX)) {//判断该事件是否被支持
……….
input_handle_event(dev, type, code, value);
..................
}
}
下面继续跟踪：
static void input_handle_event(struct input_dev *dev,unsigned int type, unsigned int code, int value)
{
int disposition = INPUT_IGNORE_EVENT;
switch (type) {
case EV_KEY:
if (is_event_supported(code, dev->keybit, KEY_MAX) && /判断该code是否被支持
!!test_bit(code, dev->key) != value) {
if (value != 2) {
__change_bit(code, dev->key);
if (value)
input_start_autorepeat(dev, code);
else
input_stop_autorepeat(dev);
}
disposition = INPUT_PASS_TO_HANDLERS;
}
break;
}
if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
dev->sync = false;
if (disposition & INPUT_PASS_TO_HANDLERS)
input_pass_event(dev, type, code, value);
}
继续跟踪该函数：
static void input_pass_event(struct input_dev *dev,
unsigned int type, unsigned int code, int value)
{
struct input_handler *handler;
struct input_handle *handle;
list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
if (!handle->open)//如果该handle没有被打开，则找下一个handle
continue;
handler = handle->handler;
if (!handler->filter) {
handler->event(handle, type, code, value);//调用handler的event函数
}
}
}
跟踪该函数：
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;
/*填充event，要上报的事件结构体*/
/*该事件发生的时间*/
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;
/*遍历evdev的client链表*/
list_for_each_entry_rcu(client, &evdev->client_list, node)
evdev_pass_event(client, &event);
}
下面看传递函数：
static void evdev_pass_event(struct evdev_client *client,struct input_event *event)
{
client->buffer[client->head++] = *event;//把传递的事件赋值给client的buffer中
client->head &= client->bufsize - 1;//管理循环缓冲区
}
*******************************************************************************
下面看下提供给上层的接口
下面看下hander的evdev_fops函数操作结构体：
看下具体的实现：
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,
.fasync = evdev_fasync,
.flush = evdev_flush,
.llseek = no_llseek,
};
下面具体看下open函数：
static int evdev_open(struct inode *inode, struct file *file)
{
struct evdev *evdev;
struct evdev_client *client;
int i = iminor(inode) - EVDEV_MINOR_BASE;
unsigned int bufsize;
evdev = evdev_table[i];//根据inode的值取出evdev的值
/*为client分配缓存*/
bufsize = evdev_compute_buffer_size(evdev->handle.dev);
/*为每一个打开实例，分配一个client结构体*/
client = kzalloc(sizeof(struct evdev_client) +
bufsize * sizeof(struct input_event),
GFP_KERNEL);
/*初始化client的各个成员变量*/
client->bufsize = bufsize;
spin_lock_init(&client->buffer_lock);
snprintf(client->name, sizeof(client->name), "%s-%d",
dev_name(&evdev->dev), task_tgid_vnr(current));
client->evdev = evdev;//和该client关联的evdev
evdev_attach_client(evdev, client); //把该client加入该evdev的client链表中
下面是该函数的实现：
static void evdev_attach_client(struct evdev *evdev,struct evdev_client *client)
{
//把该client加入该evdev的client链表中
list_add_tail_rcu(&client->node, &evdev->client_list);
}
error = evdev_open_device(evdev);
file->private_data = client;//把该client挂载到file的私有结构体下
nonseekable_open(inode, file);
return 0;
}
下面接着看evdev_open_device(evdev);函数
static int evdev_open_device(struct evdev *evdev)
{
int retval;
if (!evdev->exist)//在connenct的时候就被设置为true
retval = -ENODEV;
else if (!evdev->open++) {
retval = input_open_device(&evdev->handle);
if (retval)
evdev->open--;
}
return retval;
}
看下最后一个函数：
int input_open_device(struct input_handle *handle)
{
struct input_dev *dev = handle->dev;
int retval;
handle->open++;//打开的计数器加1
if (!dev->users++ && dev->open)
retval = dev->open(dev);//该函数为空
return retval;
}
下一个目标是分析read函数：
static ssize_t evdev_read(struct file *file, char __user *buffer,
size_t count, loff_t *ppos)
{
struct evdev_client *client = file->private_data;
struct evdev *evdev = client->evdev;
struct input_event event;
while (retval + input_event_size() <= count &&evdev_fetch_next_event(client, &event)) {
if (input_event_to_user(buffer + retval, &event))
return -EFAULT;
retval += input_event_size();
}
return retval;
}
看下里面的两个细节
static int evdev_fetch_next_event(struct evdev_client *client,struct input_event *event)
{
int have_event;
have_event = client->packet_head != client->tail;
if (have_event) {
*event = client->buffer[client->tail++];
client->tail &= client->bufsize - 1;
}
return have_event;
}
/**/
int input_event_to_user(char __user *buffer,const struct input_event *event)
{
if (copy_to_user(buffer, event, sizeof(struct input_event)))
return -EFAULT;
return 0;
}
***************************************************************************
下面再看看input class是咋回事?
static const struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
.llseek = noop_llseek,
};
struct class input_class = {
.name = "input",
.devnode = input_devnode,
};
static int __init input_init(void)
{
/*注册input class*/
err = class_register(&input_class);
/*注册input dev字符设备，其中#define INPUT_MAJOR 13*/
err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
return 0;
}
subsys_initcall(input_init);
***************************************************************************
看input_fops 中的input_open_file
static int input_open_file(struct inode *inode, struct file *file)
{
struct input_handler *handler;
const struct file_operations *old_fops, *new_fops = NULL;
handler = input_table[iminor(inode) >> 5];//根据上层传入的inode结构体，找到对应的handler
if (handler)//如果handler不为空，则取出该handler的fops指针赋值给新的new_fops
new_fops = fops_get(handler->fops);
old_fops = file->f_op;//备份老的
file->f_op = new_fops;//赋值新的，以后的对该设备的操作都会映射到该操作结构体
err = new_fops->open(inode, file);//调用新的open函数
if (err) {如果出错，则回退
fops_put(file->f_op);
file->f_op = fops_get(old_fops);
}
}
