=============  本系列参考  =============

《圈圈教你玩USB》、《Linux那些事儿之我是USB》

协议文档：https://www.usb.org/document-library/usb-20-specification  usb_20_20190524/usb_20.pdf

调试工具：Beagle USB 480 逻辑分析仪、sys/kernel/debug/usb/usbmon/

代码：linux-3.10.65/drivers/usb/core/hub.c

====================================

前言

　　由于USB设备是先被hub识别的， 所以这次先分析hub代码， 与前面两篇博文连贯起来

一、 hub加载

　　在USB子系统核心模块被调用：

/* drivers/usb/core/usb.c */

static int __init usb_init(void)

{

    int retval;

    if (nousb) {

        pr_info("%s: USB support disabled\n", usbcore_name);

        return ;

    }

    retval = usb_debugfs_init();

    if (retval)

        goto out;

    usb_acpi_register();

    retval = bus_register(&usb_bus_type);

    if (retval)

        goto bus_register_failed;

    retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);

    if (retval)

        goto bus_notifier_failed;

    retval = usb_major_init();

    if (retval)

        goto major_init_failed;

    retval = usb_register(&usbfs_driver);

    if (retval)

        goto driver_register_failed;

    retval = usb_devio_init();

    if (retval)

        goto usb_devio_init_failed;

    retval = usb_hub_init();

    if (retval)

        goto hub_init_failed;

    retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);

    if (!retval)

        goto out;

    usb_hub_cleanup();

hub_init_failed:

    usb_devio_cleanup();

usb_devio_init_failed:

    usb_deregister(&usbfs_driver);

driver_register_failed:

    usb_major_cleanup();

major_init_failed:

    bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);

bus_notifier_failed:

    bus_unregister(&usb_bus_type);

bus_register_failed:

    usb_acpi_unregister();

    usb_debugfs_cleanup();

out:

    return retval;

}

/*

 * Cleanup

 */

static void __exit usb_exit(void)

{

    /* This will matter if shutdown/reboot does exitcalls. */

    if (nousb)

        return;

    usb_deregister_device_driver(&usb_generic_driver);

    usb_major_cleanup();

    usb_deregister(&usbfs_driver);

    usb_devio_cleanup();

    usb_hub_cleanup();

    bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);

    bus_unregister(&usb_bus_type);

    usb_acpi_unregister();

    usb_debugfs_cleanup();

}

subsys_initcall(usb_init);

module_exit(usb_exit);

MODULE_LICENSE("GPL");
/* drivers/usb/core/hub.c */

static struct usb_driver hub_driver = {

    .name =        "hub",

    .probe =    hub_probe,

    .disconnect =    hub_disconnect,

    .suspend =    hub_suspend,

    .resume =    hub_resume,

    .reset_resume =    hub_reset_resume,

    .pre_reset =    hub_pre_reset,

    .post_reset =    hub_post_reset,

    .unlocked_ioctl = hub_ioctl,

    .id_table =    hub_id_table,

    .supports_autosuspend =    ,

};

int usb_hub_init(void)

{

    if (usb_register(&hub_driver) < ) {

        printk(KERN_ERR "%s: can't register hub driver\n",

            usbcore_name);

        return -;

    }

    khubd_task = kthread_run(hub_thread, NULL, "khubd");

    if (!IS_ERR(khubd_task))

        return ;

    /* Fall through if kernel_thread failed */

    usb_deregister(&hub_driver);

    printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);

    return -;

}

　　

　　usb_hub_init()就做两件事， 一是注册驱动--针对hub接口设备的驱动， 二是创建内核线程“khubd”， 我们后续会详解　　

　　记住hub本省也是个usb设备， 跟普通的U盘使用的都是同样的结构体， 当有hub设备被创建时，hub驱动的probe()将会match调用， 那问题来了，一个普通设备是被hub创建的， 那hub设备是谁创建的呢？

很显然最初的root hub设备必须是静态创建的， 且这部分代码没放在hub.c， 而是放到了hcd.c， 可以看出一个Host必然有一个root hub， 是绑定的！

int usb_add_hcd(struct usb_hcd *hcd, unsigned int irqnum, unsigned long irqflags)

{

    int retval;

    struct usb_device *rhdev;

    /* 1. 创建一个root hub设备 */

    if ((rhdev = usb_alloc_dev(NULL, &hcd->self, )) == NULL) {

        dev_err(hcd->self.controller, "unable to allocate root hub\n");

        retval = -ENOMEM;

        goto err_allocate_root_hub;

    }

    /* 2. 让hcd与root hub 紧紧地绑在一起！ */

    hcd->self.root_hub = rhdev;

    /* 3. 注册usb设备 */

    if ((retval = register_root_hub(hcd)) != )

        goto err_register_root_hub;

    return retval;

}

EXPORT_SYMBOL_GPL(usb_add_hcd);

=========================================

/* root hub 设备默认就接在Host， 不是热拔插 */

static int register_root_hub(struct usb_hcd *hcd)

{

    struct device *parent_dev = hcd->self.controller;

    struct usb_device *usb_dev = hcd->self.root_hub;

    int retval;

    /* 4. 有效设备地址1~127， root hub默认使用地址1 */

    usb_dev->devnum = ;

    /* 5. 直接进入地址阶段 */

    usb_set_device_state(usb_dev, USB_STATE_ADDRESS);

    /* 6. 直接设置ep0 size=64， 看来是协议规定的了 */

    usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16();

    /* 7. root hub 也是设备， 也要获取各种描述符 */

    retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);

    retval = usb_get_bos_descriptor(usb_dev);

    /* 8. 注册设备（是注册usb_device， 不是usb_interface） */

    retval = usb_new_device (usb_dev);

    return retval;

}

　　

着重说明usb_generic_driver会与所有的usb_device进行match， 然后选择合适的配置描述符，设置配置描述符时自然就设置interace， 也即创建usb_interface， 这个接口设备才是各个驱动对应的设备， 比如我们现在讨论的hub_driver

就是针对hub的usb_interface， 不是hub的usb_device，  usb_device代表是这个设备整体抽象， usb_interface代表是具体的某样功能， 需要具体的驱动操作。

　　当注册一个USB Host时就静态创建root hub设备， 经过简单初始化后注册就会与usb_generic_driver 进行match创建具体的usb_interface， 当注册接口设备时就会match到hub_driver.probe()， 我们继续看看probe做了啥

二、hub驱动probe()

static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)

{

    struct usb_host_interface *desc;

    struct usb_endpoint_descriptor *endpoint;

    struct usb_device *hdev;

    struct usb_hub *hub;

    desc = intf->cur_altsetting;

    /* 1. 要求除了ep0， 必须有且只有一个ep 还是INT型 */

    if (desc->desc.bNumEndpoints != )

        goto descriptor_error;

    endpoint = &desc->endpoint[].desc;

    if (!usb_endpoint_is_int_in(endpoint))

        goto descriptor_error;

    /* 2. 这是和普通设备的区别， 除了用usb_device描述外，hub还会创建usb_hub和usb_port */

    hub = kzalloc(sizeof(*hub), GFP_KERNEL);

    dev_info (&intf->dev, "USB hub found\n");

    if (hub_configure(hub, endpoint) >= )

        return ;

}

        static int hub_configure(struct usb_hub *hub, struct usb_endpoint_descriptor *endpoint)

        {

            /* 3. 主要获取hub有多少个port */

            ret = get_hub_descriptor(hdev, hub->descriptor);

            hdev->maxchild = hub->descriptor->bNbrPorts;

            /* 4. 这也是和普通外设的区别， 会创建port， 这里只是创建指针， 真正创建在后面 */

            hub->ports = kzalloc(hdev->maxchild * sizeof(struct usb_port *), GFP_KERNEL);

            /* 5. hub内部高速与全/低速不可兼容， 所以需要两部分传输电路， 根据需要进行切换

                  SINGLE_TT指的是hub只有一个转换电路针对整个hub，MULTI_TT表示每个port都有个TT转换电路可以针对每个port（土豪）

                  TTTT指的是转换电路后需要多少时间才稳定， 只有稳定了才可以传输数据*/

            switch (hdev->descriptor.bDeviceProtocol) {

            case USB_HUB_PR_FS:

                break;

            case USB_HUB_PR_HS_SINGLE_TT:

                dev_dbg(hub_dev, "Single TT\n");

                hub->tt.hub = hdev;

                break;

            case USB_HUB_PR_HS_MULTI_TT:

                ret = usb_set_interface(hdev, , );

                if (ret == ) {

                    dev_dbg(hub_dev, "TT per port\n");

                    hub->tt.multi = ;

                } else

                    dev_err(hub_dev, "Using single TT (err %d)\n",

                        ret);

                hub->tt.hub = hdev;

                break;

            case USB_HUB_PR_SS:

                /* USB 3.0 hubs don't have a TT */

                break;

            default:

                dev_dbg(hub_dev, "Unrecognized hub protocol %d\n",

                    hdev->descriptor.bDeviceProtocol);

                break;

            }

            /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */

            switch (wHubCharacteristics & HUB_CHAR_TTTT) {

                case HUB_TTTT_8_BITS:

                    if (hdev->descriptor.bDeviceProtocol != ) {

                        hub->tt.think_time = ;

                        dev_dbg(hub_dev, "TT requires at most %d "

                                "FS bit times (%d ns)\n",

                            , hub->tt.think_time);

                    }

                    break;

                case HUB_TTTT_16_BITS:

                    hub->tt.think_time =  * ;

                    dev_dbg(hub_dev, "TT requires at most %d "

                            "FS bit times (%d ns)\n",

                        , hub->tt.think_time);

                    break;

                case HUB_TTTT_24_BITS:

                    hub->tt.think_time =  * ;

                    dev_dbg(hub_dev, "TT requires at most %d "

                            "FS bit times (%d ns)\n",

                        , hub->tt.think_time);

                    break;

                case HUB_TTTT_32_BITS:

                    hub->tt.think_time =  * ;

                    dev_dbg(hub_dev, "TT requires at most %d "

                            "FS bit times (%d ns)\n",

                        , hub->tt.think_time);

                    break;

            }

            /* 7. 申请一个urb并填充， 后续在hub_activate会调用usb_submit_urb */

            hub->urb = usb_alloc_urb(, GFP_KERNEL);

            usb_fill_int_urb(hub->urb, hdev, pipe, *hub->buffer, maxp, hub_irq, hub, endpoint->bInterval);

            /* 8. 真正创建usb_port设备 */

            for (i = ; i < hdev->maxchild; i++) {

                ret = usb_hub_create_port_device(hub, i + );

                if (ret < ) {

                    dev_err(hub->intfdev,

                        "couldn't create port%d device.\n", i + );

                    hdev->maxchild = i;

                    goto fail_keep_maxchild;

                }

            }

            /* 9. 激活 */

            hub_activate(hub, HUB_INIT);

            return ;

        }

                                static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)

                                {

                                    struct usb_device *hdev = hub->hdev;

                                    for (port1 = ; port1 <= hdev->maxchild; ++port1) {

                                        struct usb_device *udev = hub->ports[port1 - ]->child;

                                        u16 portstatus, portchange;

                                        portstatus = portchange = ;

                                        status = hub_port_status(hub, port1, &portstatus, &portchange);

                                            if (udev || (portstatus & USB_PORT_STAT_CONNECTION) || (portstatus & USB_PORT_STAT_OVERCURRENT))

                                                /* 10. 前面读取portstatus&portchange 就是为了标志change_bits， 因为内核线程会读取看有没有变化

                                                    其实内核线程也会调用hub_port_status，我觉得可以不需要change_bits， 之所以存在是线程khubd

                                                    一运行就第一时间知道有没有设备插入， 或者线程读之前是不是状态又发生了变化*/

                                                set_bit(port1, hub->change_bits);

                                    }

                                    /* 11. 第一次提交urb，后续的提交就在urb的回调函数hub_irq()里调用 */

                                    status = usb_submit_urb(hub->urb, GFP_NOIO);

                                    /* 12. 其实submit后就会调用回调函数hub_irq(), 里面就会调用kick_khubd(hub)，不知道为何这里重复调用一次 */

                                    kick_khubd(hub);

                                }

　　整个核心就是创建usb_hub结构体、获取hub描述符知道多少个port后又创建usb_port结构体、初始化TT转换电路、然后顺便读取状态看有没有外设插入， 之所以说是顺便是因为内核线程khubd才是主业做这个查询状态的， 无论是这次顺带读还是

khubd读总得有个urb， 所以就申请一个urb，采用中断传输模式， 并触发第一次submit提交， 然后在回调函数再次提交urb

三、 内核线程khubd

　　上面probe()是针对每个hub设备都会有的行为， 创建usb_hub、usb_port，申请一个urb， 但有一个共同操作， 就是内核线程khubd， 所以它放在usb_hub_init()

hub_thread()

    -> hub_events()：

            /* 1. 处理每个hub， 并从链表删除这个hub */

            while () {

                /* 2. 如果链表空了就退出 */

                if (list_empty(&hub_event_list)) {

                    spin_unlock_irq(&hub_event_lock);

                    break;

                }

                tmp = hub_event_list.next;

                list_del_init(tmp);

                hub = list_entry(tmp, struct usb_hub, event_list);

                hub_dev = hub->intfdev;

                intf = to_usb_interface(hub_dev);

                /* 3. 处理每个hub的每个port */

                for (i = ; i <= hub->descriptor->bNbrPorts; i++) {

                    /* 4. 早前提到的顺带读取状态会操作change_bits */

                    connect_change = test_bit(i, hub->change_bits);

                    ret = hub_port_status(hub, i, &portstatus, &portchange);

                    printk("ret=%d, portstatus=0x%x, portchange=0x%x\n", ret, portstatus, portchange);

                    if (portchange & USB_PORT_STAT_C_CONNECTION) {

                        usb_clear_port_feature(hdev, i,

                            USB_PORT_FEAT_C_CONNECTION);

                        connect_change = ;

                    }

                    /* 5. 如果有设备插入， 则创建新的设备 */

                    if (connect_change)

                        hub_port_connect_change(hub, i, portstatus, portchange);

                } /* end for i */

            } /* end while (1) */

　　线程就是不断从链表取出hub， 然后扫描hub的所有port看有没有外设插入， 有的话就通过hub_port_connect_change()创建， 这样所有的hub，所有的port就都被访问到了， 那链表的hub是什么时候挂上去的呢？

这就是上面提到的urb， 每个hub外设都会申请一个urb， 采用中断传输， 传输的内容就是读取hub的状态， 如果状态改变， 则将这个hub挂到链表上去， 同时启动内核线程， 线程自然就会处理这些hub了！

　　

static void hub_port_connect_change(struct usb_hub *hub, int port1, u16 portstatus, u16 portchange)

{

        udev = usb_alloc_dev(hdev, hdev->bus, port1);

        choose_devnum(udev);

        hub_port_init(hub, udev, port1, i);

            -> hub_port_reset()

            -> usb_get_device_descriptor

            -> hub_port_reset

            -> usb_get_device_descriptor

        usb_new_device(udev);

}

最新文章

  1. java 多线程 1 线程 进程
  2. 微信共享收货地址 edit_address:fail 吐白沫级解决方案
  3. Jboss EAP：native management API学习
  4. MySQL删除/更新数据时报1175错误
  5. 基于iSCSI的SQL Server 2012群集测试(五)--镜像，作业，复制分发测试
  6. Ubuntu中wine安装的程序如何卸载
  7. msyql 字节问题
  8. [EXCEL] 在单元格中自动输入时间和日期
  9. 【转】Java与C#语言级比较
  10. 201521123068 《java程序设计》 第11周学习总结
  11. 最全的iOS数据存储方法
  12. 1.1 WEB API 在帮助文档页面进行测试
  13. 利用 socket 发送 get/post 请求
  14. 安装PyCharm开发工具
  15. ubuntu环境部署项目
  16. java ArrayList去重
  17. C# 准确获取系统 CPU 使用率
  18. Python 命名笔记
  19. 廖雪峰Java2面向对象编程-5包和classpath-1包package
  20. jquery ajax 上传文件

热门文章

  1. Operation之变换操作符
  2. oracle plsql 自定义异常
  3. Multi-Channel Buffers
  4. Mac下进入MySQL命令行
  5. go 垃圾回收机制
  6. 【tensorflow-v2.0】如何查看模型的输入输出流的属性
  7. Java中常量以及常量池
  8. [xsy3553]游戏
  9. STL源码之traits编程技法
  10. elasticsearch 常见查询及聚合的JAVA API