linux 设备链表,LINUX设备驱动之serio总线(一)

最新推荐文章于 2022-12-15 20:42:01 发布

weixin_39835965

最新推荐文章于 2022-12-15 20:42:01 发布

阅读量361

点赞数

文章标签： linux 设备链表

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