usb linux 驱动

我们这里只是讨论usb 驱动的原理 不会涉及到usb的协议

UHCI: intel, 低速（1.5Mbps）/全速（12Mbps）

OHCI：Microsoft 低速/全速

EHCI：高速（480Mbps）

 

调用的形式为：

hub_irq->kick_khubd -> hub_thread -> hub_events -> hub_port_connect_change->hub_port_init 里面会打印出发现一个新的usb设备

 

hub_port_init 函数：

static int
hub_port_init(struct usb_hub *hub, struct usb_device *udev, int port1,
        int retry_counter)
{
    struct usb_device    *hdev = hub->hdev;
    struct usb_hcd        *hcd = bus_to_hcd(hdev->bus);
    struct usb_port        *port_dev = hub->ports[port1 - 1];
    int            retries, operations, retval, i;
    unsigned        delay = HUB_SHORT_RESET_TIME;
    enum usb_device_speed    oldspeed = udev->speed;
    const char        *speed;
    int            devnum = udev->devnum;
    const char        *driver_name;
    bool            do_new_scheme;

    /* root hub ports have a slightly longer reset period
     * (from USB 2.0 spec, section 7.1.7.5)
     */
    if (!hdev->parent) {
        delay = HUB_ROOT_RESET_TIME;
        if (port1 == hdev->bus->otg_port)
            hdev->bus->b_hnp_enable = 0;
    }

    /* Some low speed devices have problems with the quick delay, so */
    /*  be a bit pessimistic with those devices. RHbug #23670 */
    if (oldspeed == USB_SPEED_LOW)
        delay = HUB_LONG_RESET_TIME;

    mutex_lock(hcd->address0_mutex);

    /* Reset the device; full speed may morph to high speed */
    /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
    retval = hub_port_reset(hub, port1, udev, delay, false);
    if (retval < 0)        /* error or disconnect */
        goto fail;
    /* success, speed is known */

    retval = -ENODEV;

    /* Don't allow speed changes at reset, except usb 3.0 to faster */
    if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed &&
        !(oldspeed == USB_SPEED_SUPER && udev->speed > oldspeed)) {
        dev_dbg(&udev->dev, "device reset changed speed!\n");
        goto fail;
    }
    oldspeed = udev->speed;

    /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...
     * it's fixed size except for full speed devices.
     * For Wireless USB devices, ep0 max packet is always 512 (tho
     * reported as 0xff in the device descriptor). WUSB1.0[4.8.1].
     */
    switch (udev->speed) {
    case USB_SPEED_SUPER_PLUS:
    case USB_SPEED_SUPER:
    case USB_SPEED_WIRELESS:    /* fixed at 512 */
        udev->ep0.desc.wMaxPacketSize = cpu_to_le16(512);
        break;
    case USB_SPEED_HIGH:        /* fixed at 64 */
        udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
        break;
    case USB_SPEED_FULL:        /* 8, 16, 32, or 64 */
        /* to determine the ep0 maxpacket size, try to read
         * the device descriptor to get bMaxPacketSize0 and
         * then correct our initial guess.
         */
        udev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
        break;
    case USB_SPEED_LOW:        /* fixed at 8 */
        udev->ep0.desc.wMaxPacketSize = cpu_to_le16(8);
        break;
    default:
        goto fail;
    }

    if (udev->speed == USB_SPEED_WIRELESS)
        speed = "variable speed Wireless";
    else
        speed = usb_speed_string(udev->speed);

    /*
     * The controller driver may be NULL if the controller device
     * is the middle device between platform device and roothub.
     * This middle device may not need a device driver due to
     * all hardware control can be at platform device driver, this
     * platform device is usually a dual-role USB controller device.
     */
    if (udev->bus->controller->driver)
        driver_name = udev->bus->controller->driver->name;
    else
        driver_name = udev->bus->sysdev->driver->name;

    if (udev->speed < USB_SPEED_SUPER)
        dev_info(&udev->dev,
                "%s %s USB device number %d using %s\n",
                (udev->config) ? "reset" : "new", speed,
                devnum, driver_name);

    /* Set up TT records, if needed  */
    if (hdev->tt) {
        udev->tt = hdev->tt;
        udev->ttport = hdev->ttport;
    } else if (udev->speed != USB_SPEED_HIGH
            && hdev->speed == USB_SPEED_HIGH) {
        if (!hub->tt.hub) {
            dev_err(&udev->dev, "parent hub has no TT\n");
            retval = -EINVAL;
            goto fail;
        }
        udev->tt = &hub->tt;
        udev->ttport = port1;
    }

    /* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?
     * Because device hardware and firmware is sometimes buggy in
     * this area, and this is how Linux has done it for ages.
     * Change it cautiously.
     *
     * NOTE:  If use_new_scheme() is true we will start by issuing
     * a 64-byte GET_DESCRIPTOR request.  This is what Windows does,
     * so it may help with some non-standards-compliant devices.
     * Otherwise we start with SET_ADDRESS and then try to read the
     * first 8 bytes of the device descriptor to get the ep0 maxpacket
     * value.
     */
    do_new_scheme = use_new_scheme(udev, retry_counter, port_dev);

    for (retries = 0; retries < GET_DESCRIPTOR_TRIES; (++retries, msleep(100))) {
        if (do_new_scheme) {
            struct usb_device_descriptor *buf;
            int r = 0;

            retval = hub_enable_device(udev);
            if (retval < 0) {
                dev_err(&udev->dev,
                    "hub failed to enable device, error %d\n",
                    retval);
                goto fail;
            }

#define GET_DESCRIPTOR_BUFSIZE    64
            buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
            if (!buf) {
                retval = -ENOMEM;
                continue;
            }

            /* Retry on all errors; some devices are flakey.
             * 255 is for WUSB devices, we actually need to use
             * 512 (WUSB1.0[4.8.1]).
             */
            for (operations = 0; operations < GET_MAXPACKET0_TRIES;
                    ++operations) {
                buf->bMaxPacketSize0 = 0;
                r = usb_control_msg(udev, usb_rcvaddr0pipe(),
                    USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
                    USB_DT_DEVICE << 8, 0,
                    buf, GET_DESCRIPTOR_BUFSIZE,
                    initial_descriptor_timeout);
                switch (buf->bMaxPacketSize0) {
                case 8: case 16: case 32: case 64: case 255:
                    if (buf->bDescriptorType ==
                            USB_DT_DEVICE) {
                        r = 0;
                        break;
                    }
                    fallthrough;
                default:
                    if (r == 0)
                        r = -EPROTO;
                    break;
                }
                /*
                 * Some devices time out if they are powered on
                 * when already connected. They need a second
                 * reset. But only on the first attempt,
                 * lest we get into a time out/reset loop
                 */
                if (r == 0 || (r == -ETIMEDOUT &&
                        retries == 0 &&
                        udev->speed > USB_SPEED_FULL))
                    break;
            }
            udev->descriptor.bMaxPacketSize0 =
                    buf->bMaxPacketSize0;
            kfree(buf);

            retval = hub_port_reset(hub, port1, udev, delay, false);
            if (retval < 0)        /* error or disconnect */
                goto fail;
            if (oldspeed != udev->speed) {
                dev_dbg(&udev->dev,
                    "device reset changed speed!\n");
                retval = -ENODEV;
                goto fail;
            }
            if (r) {
                if (r != -ENODEV)
                    dev_err(&udev->dev, "device descriptor read/64, error %d\n",
                            r);
                retval = -EMSGSIZE;
                continue;
            }
#undef GET_DESCRIPTOR_BUFSIZE
        }

        /*
         * If device is WUSB, we already assigned an
         * unauthorized address in the Connect Ack sequence;
         * authorization will assign the final address.
         */
        if (udev->wusb == 0) {
            for (operations = 0; operations < SET_ADDRESS_TRIES; ++operations) {
                retval = hub_set_address(udev, devnum);
                if (retval >= 0)
                    break;
                msleep(200);
            }
            if (retval < 0) {
                if (retval != -ENODEV)
                    dev_err(&udev->dev, "device not accepting address %d, error %d\n",
                            devnum, retval);
                goto fail;
            }
            if (udev->speed >= USB_SPEED_SUPER) {
                devnum = udev->devnum;
                dev_info(&udev->dev,
                        "%s SuperSpeed%s%s USB device number %d using %s\n",
                        (udev->config) ? "reset" : "new",
                     (udev->speed == USB_SPEED_SUPER_PLUS) ?
                            " Plus" : "",
                     (udev->ssp_rate == USB_SSP_GEN_2x2) ?
                            " Gen 2x2" :
                     (udev->ssp_rate == USB_SSP_GEN_2x1) ?
                            " Gen 2x1" :
                     (udev->ssp_rate == USB_SSP_GEN_1x2) ?
                            " Gen 1x2" : "",
                     devnum, driver_name);
            }

            /* cope with hardware quirkiness:
             *  - let SET_ADDRESS settle, some device hardware wants it
             *  - read ep0 maxpacket even for high and low speed,
             */
            msleep(10);
            if (do_new_scheme)
                break;
        }

        retval = usb_get_device_descriptor(udev, 8);
        if (retval < 8) {
            if (retval != -ENODEV)
                dev_err(&udev->dev,
                    "device descriptor read/8, error %d\n",
                    retval);
            if (retval >= 0)
                retval = -EMSGSIZE;
        } else {
            u32 delay;

            retval = 0;

            delay = udev->parent->hub_delay;
            udev->hub_delay = min_t(u32, delay,
                        USB_TP_TRANSMISSION_DELAY_MAX);
            retval = usb_set_isoch_delay(udev);
            if (retval) {
                dev_dbg(&udev->dev,
                    "Failed set isoch delay, error %d\n",
                    retval);
                retval = 0;
            }
            break;
        }
    }
    if (retval)
        goto fail;

    /*
     * Some superspeed devices have finished the link training process
     * and attached to a superspeed hub port, but the device descriptor
     * got from those devices show they aren't superspeed devices. Warm
     * reset the port attached by the devices can fix them.
     */
    if ((udev->speed >= USB_SPEED_SUPER) &&
            (le16_to_cpu(udev->descriptor.bcdUSB) < 0x0300)) {
        dev_err(&udev->dev, "got a wrong device descriptor, "
                "warm reset device\n");
        hub_port_reset(hub, port1, udev,
                HUB_BH_RESET_TIME, true);
        retval = -EINVAL;
        goto fail;
    }

    if (udev->descriptor.bMaxPacketSize0 == 0xff ||
            udev->speed >= USB_SPEED_SUPER)
        i = 512;
    else
        i = udev->descriptor.bMaxPacketSize0;
    if (usb_endpoint_maxp(&udev->ep0.desc) != i) {
        if (udev->speed == USB_SPEED_LOW ||
                !(i == 8 || i == 16 || i == 32 || i == 64)) {
            dev_err(&udev->dev, "Invalid ep0 maxpacket: %d\n", i);
            retval = -EMSGSIZE;
            goto fail;
        }
        if (udev->speed == USB_SPEED_FULL)
            dev_dbg(&udev->dev, "ep0 maxpacket = %d\n", i);
        else
            dev_warn(&udev->dev, "Using ep0 maxpacket: %d\n", i);
        udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
        usb_ep0_reinit(udev);
    }

    retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
    if (retval < (signed)sizeof(udev->descriptor)) {
        if (retval != -ENODEV)
            dev_err(&udev->dev, "device descriptor read/all, error %d\n",
                    retval);
        if (retval >= 0)
            retval = -ENOMSG;
        goto fail;
    }

    usb_detect_quirks(udev);

    if (udev->wusb == 0 && le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0201) {
        retval = usb_get_bos_descriptor(udev);
        if (!retval) {
            udev->lpm_capable = usb_device_supports_lpm(udev);
            usb_set_lpm_parameters(udev);
        }
    }

    retval = 0;
    /* notify HCD that we have a device connected and addressed */
    if (hcd->driver->update_device)
        hcd->driver->update_device(hcd, udev);
    hub_set_initial_usb2_lpm_policy(udev);
fail:
    if (retval) {
        hub_port_disable(hub, port1, 0);
        update_devnum(udev, devnum);    /* for disconnect processing */
    }
    mutex_unlock(hcd->address0_mutex);
    return retval;
}

 

在这个函数中首先重新连接了一次usb口

line34 行：retval = hub_port_reset(hub, port1, udev, delay, false);  

line42行： 

if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed &&
!(oldspeed == USB_SPEED_SUPER && udev->speed > oldspeed)) {
dev_dbg(&udev->dev, "device reset changed speed!\n");

这里 查看usb的速度是不是变化了 如果变化了则报错

后面从P54行到P75行表示的是速度和msg的packetsize的对应关系

line 127：

use_new_scheme 在usb3.0 中此enumeration scheme会造成USB3 在默认的状态下接收到数据。所以usb3 需要禁止这个枚举。

 

line 251：retval = usb_get_device_descriptor(udev, 8);

获得usb的描述符

如果得到描述符 那么我们就分配一个地址

 

usb_control_msg(udev, usb_rcvaddr0pipe) 这个函数是建立一个控制的urb 

 

 

 

 

USB 总线驱动程序的作用

1. 识别USB设备

1.1 分配地址 并告诉USB设备（set address）

1.2 发出命令获取描述符

2.查找并安装对应的设备驱动程序

 

3. 提供USB读写的函数

 

由于最新的linux版本usb的源码和之前的相差比较大所以我们直接参考官方文档给出的方法去做：

1.首先完成usb_driver 这个结构体

 

 

 其中,supports_autosuspend 表示的是是否支持usb自动悬挂。

USB 初始化

 

 

 ubs_register函数会把skel_driver 结构体注册到总线设备中。

 

 

 usb_deregister 会把注册的driver注销掉。

为了支持usb热插拔 我们需要MODULE_DEVICE_TABLE

 

上面的表只是一个例子 下面给一个真的table

static const struct usb_device_id usb_kbd_id_table[] = {
    { USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
        USB_INTERFACE_PROTOCOL_KEYBOARD) },
    { }                        /* Terminating entry */
};

这个就是真的keyboard的table

 最后就是当usb的deviceID和driver注册的一样的时候就会call probe函数。

请注意 这里面driver的名字可以随便写因为usb设备貌似不看名字。

 

probe函数中经常用的知识点：

static int usb_kbd_probe(struct usb_interface *iface,
const struct usb_device_id *id)

 

1.struct usb_device *dev = interface_to_usbdev(iface) //这句说是把usb_interface 结构体转化为usb_device.

2. USB endpoint: endpoints指的是usb硬件的一个buffer 主设备都是从这个buffer中读或者写数据。usb设备中至少有一个endpoint 在地址0的位置可读可写这个endpoint是为了hotplug上去之后识别用的。

3.usb_host_interface 这是一个usb主的结构体。

4. bNumEndpoints 表示双向的Endpoints 必须只有一个 且在address0

5. usb_endpoint_is_int_in 是否endpoint是输入 方向（一边的device都是输入 从机）

6.pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress); 创建一个和end point相连接的pipe 注意pipe是一个软件的概念 通道

7. URB：usb传输的数据块，包含usb信息的所有元素 可以用usb_submit_urb()去发送 如果发送出去返回成功信号。

8. usb_buff =  usb_alloc_coherent(dev, len, GFP_ATOMIC, &usb_buf_phys) 这个函数分配usb的buffer  表示最后存到哪里

9. usb_make_path(dev, mouse->phys, sizeof(mouse->phys)); 找到mouse->phy 的绝对路径
10. usb_fill_bulk_urb: 把数据写入urb

11.usb_submit_urb 此函数会把数据发送出去

 

12 usb_bulk_msg  函数是作为读usb里面的数据