浅析linux 2.6.23驱动自动匹配设备driver_attach()函数

 

浅析linux 2.6.23驱动自动匹配设备driver_attach()函数

int driver_attach(struct device_driver * drv)
{
    return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
}
调用该函数,那么drv驱动程序会和drv所在总线上连接了的物理设备进行一一匹配,再来看看下面:
int bus_for_each_dev(struct bus_type * bus, struct device * start,
         void * data, int (*fn)(struct device *, void *))
{
    struct klist_iter i;//专门用于遍历的链表结构体,其中i_cur是遍历移动的关键
    struct device * dev;
    int error = 0;

    if (!bus)
        return -EINVAL;

    klist_iter_init_node(&bus->klist_devices, &i,
             (start ? &start->knode_bus : NULL));
    //i->i_klist = &bus->klist_devices;
    //i->i_head = &bus->klist_devices.k_list;
    //i->i_cur     = NULL;//表示从最前端开始遍历挂接到bus总线上的整个设备链条.
    while ((dev = next_device(&i)) && !error)
    //dev为该bus总线链表上的一个设备,[就像一根藤条上的一朵小花gliethttp_20071025]
    //这些device设备把自己的&device->knode_bus链表单元链接到了bus->klist_devices上
    //这也说明名字为knode_bus的list单元将是要被挂接到bus->klist_devices的链表上
    //同理&device->knode_driver将是这个device设备链接到drivers驱动上的list节点识别单元
    //见driver_bound()->klist_add_tail(&dev->knode_driver, &dev->driver->klist_devices);
        error = fn(dev, data);//调用__driver_attach函数,进行匹配运算
    klist_iter_exit(&i);
    return error;//成功匹配返回0
}[url]http://www.qiusuo365.com[/url]
struct klist_iter {
    struct klist        * i_klist;
    struct list_head    * i_head;
    struct klist_node    * i_cur;
};
void klist_iter_init_node(struct klist * k, struct klist_iter * i, struct klist_node * n)
{
    i->i_klist = k;            //需要被遍历的klist
    i->i_head = &k->k_list;    //开始的链表头
    i->i_cur = n;            //当前位置对应的klist_node节点,next_device()会从当前n开始一直搜索到
                            //链表的结尾,也就是i_head->prev处停止
    if (n)
        kref_get(&n->n_ref);//引用计数加1
}
static struct device * next_device(struct klist_iter * i)
{
    struct klist_node * n = klist_next(i);
    return n ? container_of(n, struct device, knode_bus) : NULL;
    //因为n是device->knode_bus的指针,所以container_of将返回device的指针
}
struct klist_node * klist_next(struct klist_iter * i)
{
    struct list_head * next;
    struct klist_node * lnode = i->i_cur;
    struct klist_node * knode = NULL;//赋0,当next == i->i_head时用于退出
    void (*put)(struct klist_node *) = i->i_klist->put;

    spin_lock(&i->i_klist->k_lock);
    if (lnode) {
        next = lnode->n_node.next;
        if (!klist_dec_and_del(lnode))//释放前一个i_cur对象的引用计数
            put = NULL;//klist_dec_and_del成功的对引用计数做了减1操作,那么失效用户定义put
    } else
        next = i->i_head->next;//如果lnode=0,那么从链表头开始,所以head->next指向第1个实际对象

    if (next != i->i_head) {//head并不链接设备,所以head无效
    //当next == i->i_head时,说明已经遍历到了head牵头的链表的末尾,回环到了head,
    //所以knode将不会进行赋值,这时knode=0,while ((dev = next_device(&i)) && !error)因为0而退出
        knode = to_klist_node(next);//调用container_of()获取klist_node->n_node中klist_node地址
        kref_get(&knode->n_ref);//对该node的引用计数加1
    }
    i->i_cur = knode;//记住当前遍历到的对象,当next == i->i_head时,knode=0
    spin_unlock(&i->i_klist->k_lock);
    if (put && lnode)
        put(lnode);
    return knode;
}
static int klist_dec_and_del(struct klist_node * n)
{
    return kref_put(&n->n_ref, klist_release);//对该node的引用计数减1,如果引用计数到达0,那么调用klist_release
}
static void klist_release(struct kref * kref)
{
    struct klist_node * n = container_of(kref, struct klist_node, n_ref);

    list_del(&n->n_node);//从节点链表上摘掉该node节点
    complete(&n->n_removed);//
    n->n_klist = NULL;
}
void fastcall complete(struct completion *x)
{
    unsigned long flags;
    spin_lock_irqsave(&x->wait.lock, flags);//关闭中断,防止并发
    x->done++;
    //唤醒因为某些原因悬停在klist_node->n_removed等待队列上的task们
    //这种现象之一是:__device_release_driver()删除挂接在设备上的driver时,会出现
    //删除task小憩在node的wait上
    __wake_up_common(&x->wait, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE,
             1, 0, NULL);
    spin_unlock_irqrestore(&x->wait.lock, flags);//恢复中断
}
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
             int nr_exclusive, int sync, void *key)
{
    struct list_head *tmp, *next;

    list_for_each_safe(tmp, next, &q->task_list) {//遍历以head牵头的链表上的task们
        wait_queue_t *curr = list_entry(tmp, wait_queue_t, task_list);
        unsigned flags = curr->flags;

        if (curr->func(curr, mode, sync, key) &&//调用wait上准备好了的回调函数func
                (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
            break;
    }
}
//抛开链表上的head,当最后一个post==head时,说明链表已经遍历结束(gliethttp_20071025)
#define list_for_each_safe(pos, n, head) /
    for (pos = (head)->next, n = pos->next; pos != (head); /
        pos = n, n = pos->next)
void klist_iter_exit(struct klist_iter * i)
{
    if (i->i_cur) {
//对于正常遍历的退出,i->i_cur会等于0,如果找到了匹配对象,提前退出了,那么就会在这里对引用进行释放
        klist_del(i->i_cur);
        i->i_cur = NULL;
    }
}
static int __driver_attach(struct device * dev, void * data)
{
    struct device_driver * drv = data;
//data就是打算把自己匹配到bus上挂接的合适设备上的driver驱动
    if (dev->parent)
        down(&dev->parent->sem);//使用信号量保护下面的操作
    down(&dev->sem);
    if (!dev->driver)//如果当前这个dev设备还没有挂接一个driver驱动
        driver_probe_device(drv, dev);//那么尝试该dev是否适合被该drv驱动管理
    up(&dev->sem);
    if (dev->parent)
        up(&dev->parent->sem);

    return 0;
}
int driver_probe_device(struct device_driver * drv, struct device * dev)
{
    int ret = 0;

    if (!device_is_registered(dev))//设备是否已经被bus总线认可
        return -ENODEV;
    if (drv->bus->match && !drv->bus->match(dev, drv))
    //调用该driver驱动自定义的match函数,如:usb_device_match(),查看
    //这个设备是否符合自己,drv->bus->match()返回1,表示本drv认可该设备
    //否则,goto done,继续检测下一个device设备是否和本drv匹配
        goto done;

    pr_debug("%s: Matched Device %s with Driver %s/n",
         drv->bus->name, dev->bus_id, drv->name);
    //这下来真的了,
    ret = really_probe(dev, drv);

done:
    return ret;
}
static inline int device_is_registered(struct device *dev)
{
    return dev->is_registered;//当调用bus_attach_device()之后,is_registered=1
}
static int really_probe(struct device *dev, struct device_driver *drv)
{
    int ret = 0;

    atomic_inc(&probe_count);
    pr_debug("%s: Probing driver %s with device %s/n",
         drv->bus->name, drv->name, dev->bus_id);
    WARN_ON(!list_empty(&dev->devres_head));

    dev->driver = drv;//管理本dev的驱动指针指向drv
    if (driver_sysfs_add(dev)) {//将driver和dev使用link,链接到一起,使他们真正相关
        printk(KERN_ERR "%s: driver_sysfs_add(%s) failed/n",
            __FUNCTION__, dev->bus_id);
        goto probe_failed;
    }

    if (dev->bus->probe) {//总线提供了设备探测函数
        ret = dev->bus->probe(dev);
        if (ret)
            goto probe_failed;
    } else if (drv->probe) {//驱动自己提供了设备探测函数
    //因为drv驱动自己也不想管理那些意外的非法设备
    //所以一般drv都会提供这个功能,相反
    //比如:usb_bus_type没有提供probe,而usb驱动提供了usb_probe_interface
    //来确认我这个driver软件真的能够管理这个device设备
        ret = drv->probe(dev);
        if (ret)
            goto probe_failed;
    }

    driver_bound(dev);
    ret = 1;
    pr_debug("%s: Bound Device %s to Driver %s/n",
         drv->bus->name, dev->bus_id, drv->name);
    goto done;

probe_failed:
    devres_release_all(dev);
    driver_sysfs_remove(dev);
    dev->driver = NULL;

    if (ret != -ENODEV && ret != -ENXIO) {
        printk(KERN_WARNING
         "%s: probe of %s failed with error %d/n",
         drv->name, dev->bus_id, ret);
    }
    ret = 0;
done:
    atomic_dec(&probe_count);
    wake_up(&probe_waitqueue);
    return ret;
}
static void driver_bound(struct device *dev)
{
    if (klist_node_attached(&dev->knode_driver)) {
    //本dev已经挂到了某个driver驱动的klist_devices链条上了
    //感觉不应该发生
        printk(KERN_WARNING "%s: device %s already bound/n",
            __FUNCTION__, kobject_name(&dev->kobj));
        return;
    }

    pr_debug("bound device '%s' to driver '%s'/n",
         dev->bus_id, dev->driver->name);

    if (dev->bus)
        blocking_notifier_call_chain(&dev->bus->bus_notifier,
                     BUS_NOTIFY_BOUND_DRIVER, dev);
    //将本dev的knode_driver链表结构体节点挂接到该driver->klist_devices上
    //这样driver所管理的device设备又多了1个,
    //也可以说又多了1个device设备使用本driver驱动管理它自己(gilethttp_20071025).
    klist_add_tail(&dev->knode_driver, &dev->driver->klist_devices);
}
以上的理解还缺少各种知识的汇集性(因为自己还缺少很多知识),甚至会存在若干错误性,当然正如开花的植物一样,一根藤条上需要开的花分几种,有已经绽开的,有含苞待放的,有蓄势待发的,还有10天以后才能显露的,那就让时间来完善吧,只要植物不被若干因素kill掉,我相信花会慢慢的开将来.