LINUX设备驱动之serio总线(一)

serio总线也是kernel中的一种虚拟的串行输入输出总线，源码\drivers\input\serio目录下有很多与之相关的驱动程序。

一．serio初始化

和之前分析platform总线一样，在系统启动时初始化时也创建了serio_bus总线：

static int __init serio_init(void)

{

int error;

error = bus_register(&serio_bus);

if (error) {

printk(KERN_ERR "serio: failed to register serio bus, error: %d\n", error);

return error;

}

serio_task = kthread_run(serio_thread, NULL, "kseriod");

if (IS_ERR(serio_task)) {

bus_unregister(&serio_bus);

error = PTR_ERR(serio_task);

printk(KERN_ERR "serio: Failed to start kseriod, error: %d\n", error);

return error;

}

return 0;

}

serio_bus定义如下：

static struct bus_type serio_bus = {

.name = "serio",

.dev_attrs = serio_device_attrs,

.drv_attrs = serio_driver_attrs,

.match = serio_bus_match,

.uevent = serio_uevent,

.probe = serio_driver_probe,

.remove = serio_driver_remove,

.shutdown = serio_shutdown,

#ifdef CONFIG_PM

.pm = &serio_pm_ops,

#endif

};

其中的各个函数将在使用到的地方再作分析。

初始化函数serio_init()首先注册了serio_bus总线，然后创建了一个内核线程serio_thread，这个内核线程做什么用的呢？之前分析platform总线并没有这个线程，这里为什么要用它？我们先看看serio_thread内核线程的内容：

static int serio_thread(void *nothing)

{

set_freezable();

do {

serio_handle_event();

wait_event_freezable(serio_wait,

kthread_should_stop() || !list_empty(&serio_event_list));

} while (!kthread_should_stop());

printk(KERN_DEBUG "serio: kseriod exiting\n");

return 0;

}

该线程首先执行serio_handle_event()函数，然后在serio_wait等待队列上休眠，如果kthread_should_stop()返回0的时候也即模块移除调用kthread_stop(serio_task)时，serio_thread线程返回。我们猜想：在某个时候往serio_event_list链表上添加成员时唤醒或等到下一时钟周期唤醒serio_wait工作队列，这时候就会去执行serio_handle_event()函数，这个函数将会对serio_event_list进行操作，为什么要把事件的处理放在内核线程中呢？因为在产生事件时是在关中断状态，同时需要同步，要获得锁，在后面的分析中我们会看到这个锁是serio_event_lock，而不能让事件长时间处在关中断状态并且占有着锁，所以延后了事件的处理，先释放该锁并恢复中断状态。在后面的代码分析中我们将看到这点。

serio_handle_event()函数如下：

static void serio_handle_event(void)

{

struct serio_event *event;

mutex_lock(&serio_mutex);

/*

* Note that we handle only one event here to give swsusp

* a chance to freeze kseriod thread. Serio events should

* be pretty rare so we are not concerned about taking

* performance hit.

*/

if ((event = serio_get_event())) {

switch (event->type) {

case SERIO_REGISTER_PORT:

serio_add_port(event->object);

break;

case SERIO_RECONNECT_PORT:

serio_reconnect_port(event->object);

break;

case SERIO_RESCAN_PORT:

serio_disconnect_port(event->object);

serio_find_driver(event->object);

break;

case SERIO_RECONNECT_CHAIN:

serio_reconnect_chain(event->object);

break;

case SERIO_ATTACH_DRIVER:

serio_attach_driver(event->object);

break;

default:

break;

}

serio_remove_duplicate_events(event);

serio_free_event(event);

}

mutex_unlock(&serio_mutex);

}

没错它就是在serio_event_list上获得事件，并将其在serio_event_list上删除，看下面这个函数：

static struct serio_event *serio_get_event(void)

{

struct serio_event *event;

struct list_head *node;

unsigned long flags;

spin_lock_irqsave(&serio_event_lock, flags);

if (list_empty(&serio_event_list)) {

spin_unlock_irqrestore(&serio_event_lock, flags);

return NULL;

}

node = serio_event_list.next;

event = list_entry(node, struct serio_event, node);

list_del_init(node);

spin_unlock_irqrestore(&serio_event_lock, flags);

return event;

}

获得事件后根据事件的类型作相应的事件处理，一共有五种事件，看下面定义：

enum serio_event_type {

SERIO_RESCAN_PORT,

SERIO_RECONNECT_PORT,

SERIO_RECONNECT_CHAIN,

SERIO_REGISTER_PORT,

SERIO_ATTACH_DRIVER,

};

对于这些事件我们在用到时再作分析。

处理完事件后调用serio_remove_duplicate_events(event)删除链表上具有相同请求的事件，因为在事件被处理前有可能已经多次请求该事件。然后调用serio_free_event(event)减少相应的计数，释放其内存空间。

二．serio设备的注册

先看看serio的数据结构：

struct serio {

void *port_data;

char name[32];

char phys[32];

bool manual_bind;

bool registered; /* port has been fully registered with driver core */

struct serio_device_id id;

spinlock_t lock; /* protects critical sections from port's interrupt handler */

int (*write)(struct serio *, unsigned char);

int (*open)(struct serio *);

void (*close)(struct serio *);

int (*start)(struct serio *);

void (*stop)(struct serio *);

struct serio *parent, *child;

unsigned int depth; /* level of nesting in serio hierarchy */

struct serio_driver *drv; /* accessed from interrupt, must be protected by serio->lock and serio->sem */

struct mutex drv_mutex; /* protects serio->drv so attributes can pin driver */

struct device dev;

struct list_head node;

};

该结构包含了write、open、close、start、stop函数，这些函数将会在事件处理中用到。

我们接着看serio设备的注册函数：

static inline void serio_register_port(struct serio *serio)

{

__serio_register_port(serio, THIS_MODULE);

}

转入__serio_register_port(serio, THIS_MODULE)：

void __serio_register_port(struct serio *serio, struct module *owner)

{

serio_init_port(serio);

serio_queue_event(serio, owner, SERIO_REGISTER_PORT);

}

先调用serio_init_port(serio)进行初始化：

static void serio_init_port(struct serio *serio)

{

static atomic_t serio_no = ATOMIC_INIT(0);

__module_get(THIS_MODULE);

INIT_LIST_HEAD(&serio->node);

spin_lock_init(&serio->lock);

mutex_init(&serio->drv_mutex);

device_initialize(&serio->dev);

dev_set_name(&serio->dev, "serio%ld",

(long)atomic_inc_return(&serio_no) - 1);

serio->dev.bus = &serio_bus;

serio->dev.release = serio_release_port;

if (serio->parent) {

serio->dev.parent = &serio->parent->dev;

serio->depth = serio->parent->depth + 1;

} else

serio->depth = 0;

lockdep_set_subclass(&serio->lock, serio->depth);

}

对serio的大部分字段初始化以及初始化其内嵌的dev，从对depth的初始化中可以看出它表示该设备是第几代孩子，如果是第0代，其sysfs将会在sys/devices下。

__serio_register_port()函数接着调用serio_queue_event(serio, owner, SERIO_REGISTER_PORT)

看下这个函数：

static int serio_queue_event(void *object, struct module *owner,

enum serio_event_type event_type)

{

unsigned long flags;

struct serio_event *event;

int retval = 0;

spin_lock_irqsave(&serio_event_lock, flags);

/*

* Scan event list for the other events for the same serio port,

* starting with the most recent one. If event is the same we

* do not need add new one. If event is of different type we

* need to add this event and should not look further because

* we need to preseve sequence of distinct events.

*/

list_for_each_entry_reverse(event, &serio_event_list, node) {

if (event->object == object) {

if (event->type == event_type)

goto out;

break;

}

}

event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC);

if (!event) {

printk(KERN_ERR

"serio: Not enough memory to queue event %d\n",

event_type);

retval = -ENOMEM;

goto out;

}

if (!try_module_get(owner)) {

printk(KERN_WARNING

"serio: Can't get module reference, dropping event %d\n",

event_type);

kfree(event);

retval = -EINVAL;

goto out;

}

event-> type = event_type;

event->object = object;

event->owner = owner;

list_add_tail(&event->node, & serio_event_list);

wake_up(&serio_wait);

out:

spin_unlock_irqrestore(&serio_event_lock, flags);

return retval;

}

从这个函数首先保存中断状态，关中断并获得serio_event_lock自旋锁，接着检查参数object代表的event是否在链表serio_event_list上已经存在，如果存在则退出，否则分配一个serio_event内存空间，并用输入参数初始化它的type、object和owner字段，并将其加到serio_event_list链表尾部，然后唤醒等待列表serio_wait，恢复中断和释放锁，这里我们看到，和前面的分析一致。

serio_event结构体定义如下：

struct serio_event {

enum serio_event_type type;

void *object;

struct module *owner;

struct list_head node;

};

对于serio设备的注册，在调用serio_queue_event()是事件的类型参数为SERIO_REGISTER_PORT，我们看看serio_thread内核线程中相应的处理：

.

.

switch (event->type) {

case SERIO_REGISTER_PORT:

serio_add_port(event->object);

break;

.

.

它将调用serio_add_port(event->object)，看一下这个函数：

static void serio_add_port(struct serio *serio)

{

int error;

if (serio ->parent) {

serio_pause_rx(serio->parent);

serio->parent->child = serio;

serio_continue_rx(serio->parent);

}

list_add_tail(&serio->node, &serio_list);

if (serio->start)

serio->start(serio);

error = device_add(&serio->dev);

if (error)

printk(KERN_ERR

"serio: device_add() failed for %s (%s), error: %d\n",

serio->phys, serio->name, error);

else {

serio->registered = true;

error = sysfs_create_group(&serio->dev.kobj, &serio_id_attr_group);

if (error)

printk(KERN_ERR

"serio: sysfs_create_group() failed for %s (%s), error: %d\n",

serio->phys, serio->name, error);

}

}

如果serio->存在，则设置其父子关系，接着调用list_add_tail(&serio->node, &serio_list)将serio插入到serio_list链表尾部，如果serio->start存在，则调用它，然后调用device_add(&serio->dev)将其注册到相应的总线上。

删除总线上已注册的serio设备要调用serio_unregister_port（），函数代码如下：

void serio_unregister_port(struct serio *serio)

{

mutex_lock(&serio_mutex);

serio_disconnect_port(serio);

serio_destroy_port(serio);

mutex_unlock(&serio_mutex);

}

删除其后代子孙及他们的驱动关联，看下相应的函数：

static void serio_disconnect_port(struct serio *serio)

{

struct serio *s, *parent;

if (serio->child) {

/*

* Children ports should be disconnected and destroyed

* first, staring with the leaf one, since we don't want

* to do recursion

*/

for (s = serio; s->child; s = s->child)

/* empty */;

do {

parent = s->parent;

device_release_driver(&s->dev);

serio_destroy_port(s);

} while ((s = parent) != serio);

}

/*

* Ok, no children left, now disconnect this port

*/

device_release_driver(&serio->dev);

}

找到最末代的子孙，然后一次往上代删除其驱动关联和设备，最后删除serio本身驱动关联和设备。

device_release_driver()函数将删除它和driver以及bus的关联，请参考本站设备模型部分内容。

serio_destroy_port()函数如下：

static void serio_destroy_port(struct serio *serio)

{

struct serio *child;

child = serio_get_pending_child(serio);

if (child) {

serio_remove_pending_events(child);

put_device(&child->dev);

}

if (serio->stop)

serio->stop(serio);

if (serio->parent) {

serio_pause_rx(serio->parent);

serio->parent->child = NULL;

serio_continue_rx(serio->parent);

serio->parent = NULL;

}

if (serio->registered) {

sysfs_remove_group(&serio->dev.kobj, &serio_id_attr_group);

device_del(&serio->dev);

serio->registered = false;

}

list_del_init(&serio->node);

serio_remove_pending_events(serio);

put_device(&serio->dev);

}

如果serio_event_list链表上存在未完成注册的该serio的孩子，则先删除它，看下面两个函数：

static struct serio *serio_get_pending_child(struct serio *parent)

{

struct serio_event *event;

struct serio *serio, *child = NULL;

unsigned long flags;

spin_lock_irqsave(&serio_event_lock, flags);

list_for_each_entry(event, &serio_event_list, node) {

if (event->type == SERIO_REGISTER_PORT) {

serio = event->object;

if (serio->parent == parent) {

child = serio;

break;

}

}

}

spin_unlock_irqrestore(&serio_event_lock, flags);

return child;

}

static void serio_remove_pending_events(void *object)

{

struct list_head *node, *next;

struct serio_event *event;

unsigned long flags;

spin_lock_irqsave(&serio_event_lock, flags);

list_for_each_safe(node, next, &serio_event_list) {

event = list_entry(node, struct serio_event, node);

if (event->object == object) {

list_del_init(node);

serio_free_event(event);

}

}

spin_unlock_irqrestore(&serio_event_lock, flags);

}

这两个函数很容易就看懂，不再分析，接着继续serio_destroy_port()，如果serio->stop存在，则调用它，也即在设备删除时会调用它，痛上面的start函数，我们在编写具体的设备驱动时要编写这些对应的函数，还有另外三个函数write、open、close，还后面会分析到。

serio_destroy_port()接着serio断开与它的父设备的关系，删除group调用device_del()删除内嵌的device，清registered标志，然后在链表serio_list上删除serio->node，删除serio_event_list链表上与它相关的所有事件请求，最后调用put_device(&serio->dev)减少其计数，如果计数为0则释放其内存空间。

serio_unregister_port()分析完了。

接着看serio_thread内核线程中对另外四种类型事件的处理，首先看SERIO_ATTACH_DRIVER对应的操作：

case SERIO_ATTACH_DRIVER:

serio_attach_driver(event->object);

break;

serio_attach_driver()函数如下：

static void serio_attach_driver(struct serio_driver *drv)

{

int error;

error = driver_attach(&drv->driver);

if (error)

printk(KERN_WARNING

"serio: driver_attach() failed for %s with error %d\n",

drv->driver.name, error);

}

进行一次设备驱动，driver_attach()将扫面总线上所有的设备，如果和drv->driver匹配则将它们关联。

接着看SERIO_RESCAN_PORT对应的操作：

case SERIO_RESCAN_PORT:

serio_disconnect_port(event->object);

serio_find_driver(event->object);

break;

serio_disconnect_port函数在上面分析serio_unregister_port()已经分析，这里不再累赘。

serio_find_driver() 函数如下：

static void serio_find_driver(struct serio *serio)

{

int error;

error = device_attach(&serio->dev);

if (error < 0)

printk(KERN_WARNING

"serio: device_attach() failed for %s (%s), error: %d\n",

serio->phys, serio->name, error);

}

它调用device_attach()去匹配总线上的驱动，如果找到合适的驱动就将它们关联，这个函数在本站设备驱动模型的文章中已经详述。

接着看SERIO_RECONNECT_PORT对应的操作：

case SERIO_RECONNECT_PORT:

serio_reconnect_port(event->object);

break;

serio_reconnect_port ()函数如下：

static int serio_reconnect_port(struct serio *serio)

{

int error = serio_reconnect_driver(serio);

if (error) {

serio_disconnect_port(serio);

serio_find_driver(serio);

}

return error;

}

断开关联重新匹配驱动。

接着看SERIO_RECONNECT_CHAIN对应的操作：

case SERIO_RECONNECT_CHAIN:

serio_reconnect_chain(event->object);

break;

serio_reconnect_chain ()函数如下：

static void serio_reconnect_chain(struct serio *serio)

{

do {

if (serio_reconnect_port(serio)) {

/* Ok, old children are now gone, we are done */

break;

}

serio = serio->child;

} while (serio);

}

扩充了SERIO_RECONNECT_PORT事件，如果serio的子孙后代存在，则对它们做相同的操作。

至此，所有的事件处理都分析完了。