linux usb驱动移植（1）

1. USB总线

1.1 usb总线定义

在linux 设备模型中，总线由bus_type 结构表示，我们所用的 I2C、SPI、USB 都是用这个结构体来定义的。该结构体定义在 include/linux/device.h文件中：

struct bus_type {
        const char              *name;
        const char              *dev_name;
        struct device           *dev_root;
        const struct attribute_group **bus_groups;
        const struct attribute_group **dev_groups;
        const struct attribute_group **drv_groups;

        int (*match)(struct device *dev, struct device_driver *drv);
        int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
        int (*probe)(struct device *dev);
        int (*remove)(struct device *dev);
        void (*shutdown)(struct device *dev);

        int (*online)(struct device *dev);
        int (*offline)(struct device *dev);

        int (*suspend)(struct device *dev, pm_message_t state);
        int (*resume)(struct device *dev);

        int (*num_vf)(struct device *dev);

        int (*dma_configure)(struct device *dev);

        const struct dev_pm_ops *pm;

        const struct iommu_ops *iommu_ops;

        struct subsys_private *p;
        struct lock_class_key lock_key;

        bool need_parent_lock;
};

其中部分字段的含义如下：

• name：总线名称；
• bus_groups：总线属性;
• dev_groups：该总线上所有设备的默认属性;
• drv_groups：该总线上所有驱动的默认属性；
• match：当有新的设备或驱动添加到总线上时match函数被调用，如果设备和驱动可以匹配，返回0；
• uevent：当一个设备添加、移除或添加环境变量时，函数调用；
• probe：当有新设备或驱动添加时，probe函数调用，并且回调该驱动的probe函数来初始化相关联的设备；
• remove：设备移除时调用remove函数；
• shutdown：设备关机时调用shutdown函数；
• suspend：设备进入睡眠时调用suspend函数；
• resume：设备唤醒时调用resume函数；
• pm：总线的电源管理选项，并回调设备驱动的电源管理模块；

usb总线是 bus_type 类型的全局变量，这个变量已经被 linux 内核赋值好了，其结构体成员对应的函数也已经在内核里面写好，定义在drivers/usb/core/driver.c：

struct bus_type usb_bus_type = {
        .name =         "usb",
        .match =        usb_device_match,
        .uevent =       usb_uevent,
        .need_parent_lock =     true,
};

这里我们重点关注BUS匹配函数usb_device_match即可。

1.2 usb设备和驱动匹配

1.2.1 usb_device_match

usb_bus_type 中的usb_device_match就是用来进行驱动和设备匹配的函数，不同的总线对应的match 函数肯定不一样，这个我们不用管，内核都会写好。

我们所用的BUS总线对应的 match 函数是 usb_device_match函数，该函数定义在drivers/usb/core/driver.c：

static int usb_device_match(struct device *dev, struct device_driver *drv)
{
        /* devices and interfaces are handled separately */
        if (is_usb_device(dev)) {

                /* interface drivers never match devices */
                if (!is_usb_device_driver(drv))
                        return 0;

                /* TODO: Add real matching code */
                return 1;

        } else if (is_usb_interface(dev)) {
                struct usb_interface *intf;
                struct usb_driver *usb_drv;
                const struct usb_device_id *id;

                /* device drivers never match interfaces */
                if (is_usb_device_driver(drv))
                        return 0;

                intf = to_usb_interface(dev);
                usb_drv = to_usb_driver(drv);

                id = usb_match_id(intf, usb_drv->id_table);
                if (id)
                        return 1;

                id = usb_match_dynamic_id(intf, usb_drv);
                if (id)
                        return 1;
        }

        return 0;
}

在介绍这段之前，我们先来介绍一下usb设备和usb接口的区别：

• 对于usb设备，使用struct usb_device类型表示，dev成员的type成员会设置成usb_device_type；
• 对于usb接口，使用struct usb_interface类型表示，dev成员的type成员则会设成usb_if_device_type；

接着我们再来说一下usb设备驱动和usb接口驱动的区别：

• 对于usb设备驱动，使用struct usb_device_driver类型表示，是通过usb_register_device_driver函数来注册的，这个后面会介绍；
• 对于usb接口驱动，使用struct usb_driver类型表示，是通过usb_register函数来注册的，这个后面会介绍；
  不管是设备驱动usb_device_driver，还是接口驱动usb_driver数据结构中都包含了struct usbdrv_wrap项，其定义如下：

struct usbdrv_wrap {
    struct device_driver driver;
    int for_devices;
}

数据结构中的for_devices用来表示该驱动是设备驱动还是接口驱动，如果为设备驱动，则在用usb_register_device_driver注册时，会将该变量for_devices设置成1，而接口驱动则设为0。usb_device_match中的is_usb_device_driver函数就是通过获取上而结构中的for_devices来进行判断是设备还是接口驱动的。

接着我们再来分析一下上面的代码，该函数有两个参数：设备和设备驱动，该函数可以分为两部分，一部分用于匹配usb设备，另一部分用于匹配usb接口；

• 对于usb设备，当匹配的是usb设备驱动时，将会匹配成功，实际上所有的usb设备对应的设备驱动都是usb_generic_driver，该设备驱动在usb子系统初始化时注册；
• 对于usb接口，先用is_usb_device_driver来进行判断，如果不是usb设备驱动则继续判断，否则退出；然后再通过usb_match_id函数来判断接口和接口驱动中的usb_device_id是否匹配。

驱动工程师的工作基本上集中在接口驱动上，所以通常是通过usb_register来注册usb接口驱动的。

1.2.2 usb_match_id

const struct usb_device_id *usb_match_id(struct usb_interface *interface,
                                         const struct usb_device_id *id)
{
        /* proc_connectinfo in devio.c may call us with id == NULL. */
        if (id == NULL)
                return NULL;

        /* It is important to check that id->driver_info is nonzero,
           since an entry that is all zeroes except for a nonzero
           id->driver_info is the way to create an entry that
           indicates that the driver want to examine every
           device and interface. */
        for (; id->idVendor || id->idProduct || id->bDeviceClass ||
               id->bInterfaceClass || id->driver_info; id++) {
                if (usb_match_one_id(interface, id))
                        return id;
        }

        return NULL;
}

1.2.3 usb_match_one_id

/* returns 0 if no match, 1 if match */
int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
{
        if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
            id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
                return 0;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
            id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
                return 0;

        /* No need to test id->bcdDevice_lo != 0, since 0 is never
           greater than any unsigned number. */
        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
            (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
                return 0;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
            (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
                return 0;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
            (id->bDeviceClass != dev->descriptor.bDeviceClass))
                return 0;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
            (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
                return 0;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
            (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
                return 0;

        return 1;
}

/* returns 0 if no match, 1 if match */
int usb_match_one_id_intf(struct usb_device *dev,
                          struct usb_host_interface *intf,
                          const struct usb_device_id *id)
{
        /* The interface class, subclass, protocol and number should never be
         * checked for a match if the device class is Vendor Specific,
         * unless the match record specifies the Vendor ID. */
        if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
                        !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
                        (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
                                USB_DEVICE_ID_MATCH_INT_SUBCLASS |
                                USB_DEVICE_ID_MATCH_INT_PROTOCOL |
                                USB_DEVICE_ID_MATCH_INT_NUMBER)))
                return 0;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
            (id->bInterfaceClass != intf->desc.bInterfaceClass))
                return 0;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
            (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
                return 0;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
            (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
                return 0;

        if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER) &&
            (id->bInterfaceNumber != intf->desc.bInterfaceNumber))
                return 0;

        return 1;
}

/* returns 0 if no match, 1 if match */
int usb_match_one_id(struct usb_interface *interface,
                     const struct usb_device_id *id)
{
        struct usb_host_interface *intf;
        struct usb_device *dev;

        /* proc_connectinfo in devio.c may call us with id == NULL. */
        if (id == NULL)
                return 0;

        intf = interface->cur_altsetting;
        dev = interface_to_usbdev(interface);

        if (!usb_match_device(dev, id))
                return 0;

        return usb_match_one_id_intf(dev, intf, id);
}

实际上这里就是将usb设备（usb设备的设备描述符信息、以及接口描述符信息）的信息和usb_driver驱动id_table信息进行匹配，如果匹配成功，则返回1，否则返回0.

1.3 usb总线注册

usb的总线注册是由usb_init函数完成，该函数也是usb子系统的入口函数，代码实现在drivers/usb/core/usb.c文件中，模块入口/出口函数如下：

subsys_initcall(usb_init);
module_exit(usb_exit);

usb_init函数代码：

/*
 * Init
 */
static int __init usb_init(void)
{
        int retval;
        if (usb_disabled()) {
                pr_info("%s: USB support disabled\n", usbcore_name);
                return 0;
        }
        usb_init_pool_max();

        usb_debugfs_init();

        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;
}

在usb_init函数中主要有如下的三个主要函数:

• 通过usb_debugfs_init初始化usb debugfs；
• 通过bus_register注册usb总线usb_bus_type；
• 通过bus_register_notifier注册usb总线通知链；
• 通过usb_major_init注册usb控制器字符设备，主设备编号为181，字符设备名称为usb；
• 通过usb_register注册usbfs驱动；
• 通过usb_devio_init注册usb设备字符设备，主设备编号为189，字符设备名称为usb_device；
• 通过usb_hub_init初始化usb hub接口驱动;
• 通过usb_register_device_driver注册usb设备驱动.

2. usb子系统初始化

由于usb_init函数比较复杂，这里就单独一小节进行介绍。

2.1 usb_debugfs_init()

usb_debugfs_init函数定义在drivers/usb/core/usb.c文件中：

static void usb_debugfs_init(void)
{
        usb_debug_root = debugfs_create_dir("usb", NULL);
        debugfs_create_file("devices", 0444, usb_debug_root, NULL,
                            &usbfs_devices_fops);
}

其主要作用就是在debug文件系统中创建一个usb目录，然后在usb目录下面创建一个devices的文件。

要使用debugfs下面的usb功能，需要先挂着debug文件系统，具体初始化了啥调试接口,看下usbfs_devices_fops操作函数集。

mount -t debugfs none $(debugfs) 

2.2 bus_register(&usb_bus_type)

struct bus_type usb_bus_type = {
        .name =         "usb",
        .match =        usb_device_match,
        .uevent =       usb_uevent,
        .need_parent_lock =     true,
};

bus_register中创建了两个链表，一个为设备链表，一个为驱动链表：

klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
klist_init(&priv->klist_drivers, NULL, NULL);

usb总线设备链表上挂载的是usb设备或者usb接口，而在usb总线驱动链表上挂在的是usb设备驱动或者是usb接口驱动。

无论是usb设备还是usb接口，其设备基类都是struct device，该类型包含一个成员是bus，类型为struct bus_type，会被初始化为usb_bus_type。

无论是usb设备驱动还是usb接口驱动，其驱动基类都是struct device_driver，该类型包含一个成员是bus，类型为struct bus_type，会被初始化为usb_bus_type。

usb总线上设备链表上的设备和驱动链表上的驱动的匹配函数是usb_device_match，这个上面已经介绍过了。

bus_register函数调用后，就会在用户空间生成usb相关文件，执行如下命令：

root:~# ls /sys/bus/usb
devices  drivers  drivers_autoprobe  drivers_probe  uevent

/sys/bus/usb/devices里用来存放的是usb设备，/sys/bus/usb/drivers里用来存放的是usb驱动：

root:~# ls /sys/bus/usb/devices
1-0:1.0  2-0:1.0  2-1  2-1:1.0  2-2  2-2.1  2-2:1.0  2-2.1:1.0  2-2.1:1.1  usb1  usb2
root:~# ls /sys/bus/usb/drivers
btusb  hub  usb  usbfs  usbhid

2.3 bus_register_notifier(&usb_bus_type,&usb_bus_nb)

bus_register_notifier函数定义在drivers/base/bus.c:

int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb)
{
    return blocking_notifier_chain_register(&bus->p->bus_notifier, nb);
}

usb_bus_nb定义在drivers/usb/core/usb.c：

static struct notifier_block usb_bus_nb = {
        .notifier_call = usb_bus_notify,
};

这里注册了usb总线通知链，当向usb_bus_type添加删除设备的时候会调用usb_bus_nb指定的notifier_cal方法,即usb_bus_notify：

/*
 * Notifications of device and interface registration
 */
static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
                void *data)
{
        struct device *dev = data;

        switch (action) {
        case BUS_NOTIFY_ADD_DEVICE:       // 添加设备
                if (dev->type == &usb_device_type)   // usb设备
                        (void) usb_create_sysfs_dev_files(to_usb_device(dev));
                else if (dev->type == &usb_if_device_type)   // usb接口
                        usb_create_sysfs_intf_files(to_usb_interface(dev));
                break;

        case BUS_NOTIFY_DEL_DEVICE:          // 删除设备
                if (dev->type == &usb_device_type)   // usb设备
                        usb_remove_sysfs_dev_files(to_usb_device(dev));
                else if (dev->type == &usb_if_device_type)  // usb接口
                        usb_remove_sysfs_intf_files(to_usb_interface(dev));
                break;
        }
        return 0;
}

2.4 usb_major_init()

usb_major_init函数定义在drivers/usb/core/file.c：

int usb_major_init(void)
{
        int error;

        error = register_chrdev(USB_MAJOR, "usb", &usb_fops);
        if (error)
                printk(KERN_ERR "Unable to get major %d for usb devices\n",
                       USB_MAJOR);

        return error;
}

这里使用register_chrdev向内核注册usb主控制器字符设备，字符设备的名称为usb，字符设备的主设备号为USB_MAJOR(180)，设备操作为usb_fops。

register_chrdev封装了register_chrdev_region、cdev_alloc、cdev_add相关逻辑，这里不介绍了。

其中usb_fops定义为：

static const struct file_operations usb_fops = {
        .owner =        THIS_MODULE,
        .open =         usb_open,
        .llseek =       noop_llseek,
};

2.5 usb_register(&usbfs_driver)

用usb_register宏向linux内核注册usb接口驱动usbfs_driver，usbfs_driver定义在drivers/usb/core/devio.c：

struct usb_driver usbfs_driver = {
        .name =         "usbfs",
        .probe =        driver_probe,
        .disconnect =   driver_disconnect,
        .suspend =      driver_suspend,
        .resume =       driver_resume,
};

usb_rigister宏定义在include/linux/usb.h文件中：

/* use a define to avoid include chaining to get THIS_MODULE & friends */
#define usb_register(driver) \
        usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)

/**
 * usb_register_driver - register a USB interface driver
 * @new_driver: USB operations for the interface driver
 * @owner: module owner of this driver.
 * @mod_name: module name string
 *
 * Registers a USB interface driver with the USB core.  The list of
 * unattached interfaces will be rescanned whenever a new driver is
 * added, allowing the new driver to attach to any recognized interfaces.
 *
 * Return: A negative error code on failure and 0 on success.
 *
 * NOTE: if you want your driver to use the USB major number, you must call
 * usb_register_dev() to enable that functionality.  This function no longer
 * takes care of that.
 */
int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
                        const char *mod_name)
{
        int retval = 0;

        if (usb_disabled())
                return -ENODEV;

        new_driver->drvwrap.for_devices = 0;
        new_driver->drvwrap.driver.name = new_driver->name;
        new_driver->drvwrap.driver.bus = &usb_bus_type;
        new_driver->drvwrap.driver.probe = usb_probe_interface;
        new_driver->drvwrap.driver.remove = usb_unbind_interface;
        new_driver->drvwrap.driver.owner = owner;
        new_driver->drvwrap.driver.mod_name = mod_name;
        spin_lock_init(&new_driver->dynids.lock);
        INIT_LIST_HEAD(&new_driver->dynids.list);

        retval = driver_register(&new_driver->drvwrap.driver);
        if (retval)
                goto out;

        retval = usb_create_newid_files(new_driver);
        if (retval)
                goto out_newid;

        pr_info("%s: registered new interface driver %s\n",
                        usbcore_name, new_driver->name);

out:
        return retval;

out_newid:
        driver_unregister(&new_driver->drvwrap.driver);

        printk(KERN_ERR "%s: error %d registering interface "
                        "       driver %s\n",
                        usbcore_name, retval, new_driver->name);
        goto out;
}

这里首先初始化usb接口驱动里的驱动基类driver，然后调用driver_register进行驱动注册，关于驱动注册函数driver_register具体参考linux驱动移植-总线设备驱动。

这里简单介绍一下driver_register函数执行流程：

• 将usb接口驱动添加到usb总线上(usb_bus_type)；
• 遍历usb总线上的所有usb接口，然后调用usb_device_match进行usb接口驱动和usb接口的匹配；
• 匹配成功后最终会执行usb接口驱动的probe函数，过程中的驱动基类driver的probe函数和 usb_probe_interface 函数都是达到这个目的的中转函数而已。

2.6 usb_devio_init()

usb_devio_init函数实现在drivers/usb/core/devio.c：

int __init usb_devio_init(void)
{
        int retval;

        retval = register_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX,
                                        "usb_device");
        if (retval) {
                printk(KERN_ERR "Unable to register minors for usb_device\n");
                goto out;
        }
        cdev_init(&usb_device_cdev, &usbdev_file_operations);
        retval = cdev_add(&usb_device_cdev, USB_DEVICE_DEV, USB_DEVICE_MAX);
        if (retval) {
                printk(KERN_ERR "Unable to get usb_device major %d\n",
                       USB_DEVICE_MAJOR);
                goto error_cdev;
        }
        usb_register_notify(&usbdev_nb);
out:
        return retval;

error_cdev:
        unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
        goto out;
}

首先使用register_chrdev_region来静态注册一组字符设备编号，主设备编号为USB_DEVICE_DEV(189)，次设备编号从0~USB_DEVICE_MAX，字符设备名称为usb_device。

然后使用cdev_init初始化字符设备结构体cdev，usbdev_file_operations结构体放入cdev-> ops 里。

最后使用cdev_add将字符设备usb_device_cdev添加到系统，并将USB_DEVICE_DEV(定义为 MKDEV(USB_DEVICE_MAJOR, 0)，即起始设备编号)放入cdev-> dev里, USB_DEVICE_MAX放入cdev->count里。

函数的最后又使用usb_register_notify注册了usb设备通知链。

2.7 usb_register_notify(&usbdev_nb)

usbdev_nb定义在 drivers/usb/core/devio.c：

static struct notifier_block usbdev_nb = {
        .notifier_call =        usbdev_notify,
};

usb_register_notify函数定义在drivers/usb/core/notify.c：

/**
 * usb_register_notify - register a notifier callback whenever a usb change happens
 * @nb: pointer to the notifier block for the callback events.
 *
 * These changes are either USB devices or busses being added or removed.
 */
void usb_register_notify(struct notifier_block *nb)
{
        blocking_notifier_chain_register(&usb_notifier_list, nb);
}

usb通知链表头为usb_notifier_list:

static BLOCKING_NOTIFIER_HEAD(usb_notifier_list);

在drivers/usb/core/notify.c文件中,有四个函数对usb_notifier_list中发送通知，这四个函数如下:

void usb_notify_add_device(struct usb_device *udev)
{
        blocking_notifier_call_chain(&usb_notifier_list, USB_DEVICE_ADD, udev);
}

void usb_notify_remove_device(struct usb_device *udev)
{
        /* Protect against simultaneous usbfs open */
        mutex_lock(&usbfs_mutex);
        blocking_notifier_call_chain(&usb_notifier_list,
                        USB_DEVICE_REMOVE, udev);
        mutex_unlock(&usbfs_mutex);
}

void usb_notify_add_bus(struct usb_bus *ubus)
{
        blocking_notifier_call_chain(&usb_notifier_list, USB_BUS_ADD, ubus);
}

void usb_notify_remove_bus(struct usb_bus *ubus)
{
        blocking_notifier_call_chain(&usb_notifier_list, USB_BUS_REMOVE, ubus);
}

当这些事件发生后会调用usbdev_nb指定的notifier_cal方法，即usbdev_notify：

static int usbdev_notify(struct notifier_block *self,
                               unsigned long action, void *dev)
{
        switch (action) {
        case USB_DEVICE_ADD:  // 设备添加
                break;
        case USB_DEVICE_REMOVE:  // 设备删除
                usbdev_remove(dev);
                break;
        }
        return NOTIFY_OK;
}

2.8 usb_hub_init()

int usb_hub_init(void)
{
        if (usb_register(&hub_driver) < 0) {
                printk(KERN_ERR "%s: can't register hub driver\n",
                        usbcore_name);
                return -1;
        }

        /*
         * The workqueue needs to be freezable to avoid interfering with
         * USB-PERSIST port handover. Otherwise it might see that a full-speed
         * device was gone before the EHCI controller had handed its port
         * over to the companion full-speed controller.
         */
        hub_wq = alloc_workqueue("usb_hub_wq", WQ_FREEZABLE, 0);
        if (hub_wq)
                return 0;

        /* Fall through if kernel_thread failed */
        usb_deregister(&hub_driver);
        pr_err("%s: can't allocate workqueue for usb hub\n", usbcore_name);

        return -1;
}

该函数主要做了以下工作：

• 通过usb_register向usb总线注册hub_driver接口驱动，指定了probe，disconnect，suspend，resume，id_table等相关函数。可以猜测，在根hub创建后，会执行此处的hub_probe函数。
• 创建新的工作队列，工作队列名称为usb_hub_wq，标志位为WQ_FREEZABLE；参数WQ＿FREEZABLE表示工作线程在挂起时候，需要先完成当前队列的所有工作之后才能挂起。创建好队列后，需要定义一个工作用于完成实际的任务。

hub_driver全局变量定义如下：

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 = 1,
};

2.9 usb_register_device_drive(&usb_generic_driver, THIS_MODULE)

usb_register_device_driver函数用于注册通用设备驱动usb_generic_driver，usb_generic_driver定义在drivers/usb/core/generic.c：

struct usb_device_driver usb_generic_driver = {
        .name = "usb",
        .probe = generic_probe,
        .disconnect = generic_disconnect,
#ifdef  CONFIG_PM
        .suspend = generic_suspend,
        .resume = generic_resume,
#endif
        .supports_autosuspend = 1,
};

所有的usb设备注册到usb总线后，都会和usb_generic_driver驱动匹配成功，也就是都会会执行generic_probe。

usb_register_device_driver定义在drivers/usb/core/driver.c文件中：

/**
 * usb_register_device_driver - register a USB device (not interface) driver
 * @new_udriver: USB operations for the device driver
 * @owner: module owner of this driver.
 *
 * Registers a USB device driver with the USB core.  The list of
 * unattached devices will be rescanned whenever a new driver is
 * added, allowing the new driver to attach to any recognized devices.
 *
 * Return: A negative error code on failure and 0 on success.
 */
int usb_register_device_driver(struct usb_device_driver *new_udriver,
                struct module *owner)
{
        int retval = 0;

        if (usb_disabled())
                return -ENODEV;

        new_udriver->drvwrap.for_devices = 1;
        new_udriver->drvwrap.driver.name = new_udriver->name;
        new_udriver->drvwrap.driver.bus = &usb_bus_type;
        new_udriver->drvwrap.driver.probe = usb_probe_device;
        new_udriver->drvwrap.driver.remove = usb_unbind_device;
        new_udriver->drvwrap.driver.owner = owner;

        retval = driver_register(&new_udriver->drvwrap.driver);

        if (!retval)
                pr_info("%s: registered new device driver %s\n",
                        usbcore_name, new_udriver->name);
        else
                printk(KERN_ERR "%s: error %d registering device "
                        "       driver %s\n",
                        usbcore_name, retval, new_udriver->name);

        return retval;
}

这里首先初始化us设备口驱动里的驱动基类driver，然后调用driver_register进行驱动注册，关于驱动注册函数driver_register具体参考linux驱动移植-总线设备驱动。

这里简单介绍一下driver_register函数执行流程

• 将usb设备驱动添加到usb总线上；
• 遍历usb总线上的所有usb设备，然后进行usb设备驱动和usb设备的匹配；
• 匹配成功后最终会执行usb设备驱动的probe函数，过程中的驱动基类driver的probe函数和 usb_probe_device函数都是达到这个目的的中转函数而已。

3. usb接口驱动

3.1 usb接口驱动定义

在linux 设备模型中，usb接口驱动由usb_driver 结构表示，该结构体定义在 include/linux/usb.h文件中：

struct usb_driver {
        const char *name;

        int (*probe) (struct usb_interface *intf,
                      const struct usb_device_id *id);

        void (*disconnect) (struct usb_interface *intf);

        int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code,
                        void *buf);

        int (*suspend) (struct usb_interface *intf, pm_message_t message);
        int (*resume) (struct usb_interface *intf);
        int (*reset_resume)(struct usb_interface *intf);

        int (*pre_reset)(struct usb_interface *intf);
        int (*post_reset)(struct usb_interface *intf);

        const struct usb_device_id *id_table;

        struct usb_dynids dynids;
        struct usbdrv_wrap drvwrap;
        unsigned int no_dynamic_id:1;
        unsigned int supports_autosuspend:1;
        unsigned int disable_hub_initiated_lpm:1;
        unsigned int soft_unbind:1;
};

其中部分成员的含义如下：

• probe：当usb接口驱动和usb接口匹配成功之后，就会调用probe函数，usb接口驱动所有的资源的注册和初始化全部放在probe函数中；
• id_table：往往一个usb接口驱动可能能同时支持多个usb接口，这些usb接口的标识信息都放在该结构体数组中；
• drvwrap：为struct usbdrv_wrap结构体类型，其中有一个成员为struct device_driver类型，即驱动基类，驱动基类，内核维护的所有的驱动必须包含该成员；

usb_driver中的id_table在usb总线进行usb接口驱动和usb接口匹配时使用，id_table是一个数组，里面每个元素类型都是usb_device_id ，指定了满足某些规则的的usb接口会和usb接口驱动匹配，usb_device_id 结构定义在include/linux/mod_devicetable.h文件中：

struct usb_device_id {
        /* which fields to match against? */
        __u16           match_flags;

        /* Used for product specific matches; range is inclusive */
        __u16           idVendor;
        __u16           idProduct;
        __u16           bcdDevice_lo;
        __u16           bcdDevice_hi;

        /* Used for device class matches */
        __u8            bDeviceClass;
        __u8            bDeviceSubClass;
        __u8            bDeviceProtocol;

        /* Used for interface class matches */
        __u8            bInterfaceClass;
        __u8            bInterfaceSubClass;
        __u8            bInterfaceProtocol;

        /* Used for vendor-specific interface matches */
        __u8            bInterfaceNumber;

        /* not matched against */
        kernel_ulong_t  driver_info
                __attribute__((aligned(sizeof(kernel_ulong_t))));
};

usb_driver成员drvwrap中成员driver是一个驱动基类，相当于驱动具有的最基础的属性，driver是struct device_driver类型，定义在include/linux/device.h文件中。

3.2 usb接口驱动注册

用usb_register宏向linux内核注册usb接口驱动，usb_register这个上面介绍了，不再重复介绍。

3.3 usb接口驱动卸载

用usb_deregister函数卸载usb接口驱动，函数定义在drivers/usb/core/driver.c文件中：

void usb_deregister(struct usb_driver *driver)
{
        pr_info("%s: deregistering interface driver %s\n",
                        usbcore_name, driver->name);

        usb_remove_newid_files(driver);
        driver_unregister(&driver->drvwrap.driver);
        usb_free_dynids(driver);
}

可以看到最终调用的driver_unregister，这里就不具体介绍了。

4. usb设备驱动

4.1 usb设备驱动定义

在linux 设备模型中，usb设备驱动由usb_device_driver 结构表示，该结构体定义在 include/linux/usb.h文件中：

struct usb_device_driver {
        const char *name;

        int (*probe) (struct usb_device *udev);
        void (*disconnect) (struct usb_device *udev);

        int (*suspend) (struct usb_device *udev, pm_message_t message);
        int (*resume) (struct usb_device *udev, pm_message_t message);
        struct usbdrv_wrap drvwrap;
        unsigned int supports_autosuspend:1;
};

4.2 usb设备驱动注册

用usb_device_driver 结构体定义好usb设备驱动后，用usb_register_device_driver函数向linux内核注册usb设备驱动，usb_register_device_driver这个上面介绍了，不再重复介绍。

4.3 usb设备驱动卸载

用usb_deregister_device_driver函数卸载us设备口驱动，函数定义在drivers/usb/core/driver.c文件中：

void usb_deregister_device_driver(struct usb_device_driver *udriver)
{
        pr_info("%s: deregistering device driver %s\n",
                        usbcore_name, udriver->name);

        driver_unregister(&udriver->drvwrap.driver);
}