Linux之 USB驱动框架-usb_submit_urb和usb_fill_*_urb分析(6)

一、usb_fill_*_urb 函数调用流程

// 控制
static inline void usb_fill_control_urb(struct urb *urb,
                    struct usb_device *dev,
                    unsigned int pipe,
                    unsigned char *setup_packet,
                    void *transfer_buffer,
                    int buffer_length,
                    usb_complete_t complete_fn,
                    void *context)
// 中断
static inline void usb_fill_int_urb(struct urb *urb,
                    struct usb_device *dev,
                    unsigned int pipe,
                    void *transfer_buffer,
                    int buffer_length,
                    usb_complete_t complete_fn,
                    void *context,
                    int interval)
// 批量

static inline void usb_fill_bulk_urb(struct urb *urb,
                     struct usb_device *dev,
                     unsigned int pipe,
                     void *transfer_buffer,
                     int buffer_length,
                     usb_complete_t complete_fn,
                     void *context)
    
// 实时   
// 实时urb 没有和中断、控制、批量urb 类似的初始化函数，因此它们在提交到USB核心之前，需要在驱动程序中手动的初始化    
    
 

 拿其中的 usb_fill_int_urb 具体分析

static inline void usb_fill_int_urb(struct urb *urb,
                                    struct usb_device *dev,
                                    unsigned int pipe,
                                    void *transfer_buffer,
                                    int buffer_length,
                                    usb_complete_t complete_fn,
                                    void *context,
                                    int interval)
{
        urb->dev = dev;
        urb->pipe = pipe;
        urb->transfer_buffer = transfer_buffer;
        urb->transfer_buffer_length = buffer_length;
        urb->complete = complete_fn;
        urb->context = context;

        if (dev->speed == USB_SPEED_HIGH || dev->speed >= USB_SPEED_SUPER) {
                /* make sure interval is within allowed range */
                interval = clamp(interval, 1, 16);

                urb->interval = 1 << (interval - 1);
        } else {
                urb->interval = interval;
        }

        urb->start_frame = -1;
}
 

 上面含义就是填充urb 成员，其中的complete_fn 函数，是urb 执行完毕后，usb core 执行的回调函数。

完成函数的作用：

比如：调用usb_fill_int_urb(),其中complete_fn相当于中断函数，即主机读取完数据会放到指定的内存data_dma中。然后通知CPU处理这些数据，这些数据只有USB设备驱动程序知道其含义。所以要在这个完成函数中处理这些数据，如上报。

1、urb的complete 执行流程

以usb鼠标驱动为例，具体分析如下：

 usb_mouse_probe->

                usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,
                         (maxp > 8 ? 8 : maxp),
                         usb_mouse_irq, mouse, endpoint->bInterval); //填充 urb

usb_mouse_irq 为 urb 的complete 函数。

那么urb->complete 执行流程：

usb_mouse_irq  <- __usb_hcd_giveback_urb <-  usb_giveback_urb_bh

usb_giveback_urb_bh 这个函数是怎么初始化并触发执行？

 在增加usb 控制器驱动中，会调用 usb_add_hcd 函数 ，接着，在usb_add_hcd 函数中，会初始化两个软中断：

/* initialize tasklets */
        init_giveback_urb_bh(&hcd->high_prio_bh);
        init_giveback_urb_bh(&hcd->low_prio_bh);
 

 接着看 init_giveback_urb_bh ：

static void init_giveback_urb_bh(struct giveback_urb_bh *bh)
{

        spin_lock_init(&bh->lock);
        INIT_LIST_HEAD(&bh->head);
        tasklet_setup(&bh->bh, usb_giveback_urb_bh);
}

从上面可知，init_giveback_urb_bh 是初始化tasklet 软中断函数。

        

 如何调度到这个 tasklet 函数：usb_giveback_urb_bh  ？？？

答案：在主控驱动中，注册hcd 时，会调用usb_create_hcd：

ohci_hcd_s3c2410_probe -> 

        usb_create_hcd->

                __usb_create_hcd(driver, dev, dev, bus_name, NULL);->

                                timer_setup(&hcd->rh_timer, rh_timer_func, 0);

 这里创建了 timer 定时，初始化定时函数为 rh_timer_func。

rh_timer_func

/* timer callback */
static void rh_timer_func (struct timer_list *t)
{
        struct usb_hcd *_hcd = from_timer(_hcd, t, rh_timer);

        usb_hcd_poll_rh_status(_hcd);
}
 

 usb_hcd_poll_rh_status

void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
{
        struct urb      *urb;
        int             length;
        int             status;
        unsigned long   flags;
        char            buffer[6];      /* Any root hubs with > 31 ports? */

        if (unlikely(!hcd->rh_pollable))
                return;
        if (!hcd->uses_new_polling && !hcd->status_urb)
                return;

        length = hcd->driver->hub_status_data(hcd, buffer);  //检测hub是否有数据到来 
        if (length > 0) {

                /* try to complete the status urb */
                spin_lock_irqsave(&hcd_root_hub_lock, flags);
                urb = hcd->status_urb;
                if (urb) {
                        clear_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
                        hcd->status_urb = NULL;
                        if (urb->transfer_buffer_length >= length) {
                                status = 0;
                        } else {
                                status = -EOVERFLOW;
                                length = urb->transfer_buffer_length;
                        }
                        urb->actual_length = length;
                        memcpy(urb->transfer_buffer, buffer, length);

                        usb_hcd_unlink_urb_from_ep(hcd, urb);
                        usb_hcd_giveback_urb(hcd, urb, status);
                } else {
                        length = 0;
                        set_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
                }
                spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
        }

        /* The USB 2.0 spec says 256 ms.  This is close enough and won't
         * exceed that limit if HZ is 100. The math is more clunky than
         * maybe expected, this is to make sure that all timers for USB devices
         * fire at the same time to give the CPU a break in between */
        if (hcd->uses_new_polling ? HCD_POLL_RH(hcd) :
                        (length == 0 && hcd->status_urb != NULL))
                mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
}
EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status);
 

 usb_hcd_giveback_urb

void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
{
        struct giveback_urb_bh *bh;
        bool running, high_prio_bh;
        dump_stack();
        /* pass status to tasklet via unlinked */
        if (likely(!urb->unlinked))
                urb->unlinked = status;

        if (!hcd_giveback_urb_in_bh(hcd) && !is_root_hub(urb->dev)) {
                __usb_hcd_giveback_urb(urb);
                return;
        }

        if (usb_pipeisoc(urb->pipe) || usb_pipeint(urb->pipe)) {
                bh = &hcd->high_prio_bh;
                high_prio_bh = true;
        } else {
                bh = &hcd->low_prio_bh;
                high_prio_bh = false;
        }

        spin_lock(&bh->lock);
        list_add_tail(&urb->urb_list, &bh->head);
        running = bh->running;
        spin_unlock(&bh->lock);

        if (running)
                ;
        else if (high_prio_bh)
                tasklet_hi_schedule(&bh->bh);
        else
                tasklet_schedule(&bh->bh);
}
EXPORT_SYMBOL_GPL(usb_hcd_giveback_urb);

上面的tasklet 函数会调用到 tasklet_hi_schedule(&bh->bh);或者 tasklet_schedule(&bh->bh);

这样就会触发usb_giveback_urb_bh 。

初始化后这个定时函数后，什么时候使用mod_timer 触发呢？

答案：

ohci_hcd_s3c2410_probe -> 

        usb_add_hcd ->

                register_root_hub->

                        usb_get_device_descriptor->

                                          usb_get_descriptor->

                                                        usb_control_msg->

                                                                       usb_internal_control_msg->

                                                                                        usb_fill_control_urb->

                                                                                                                usb_submit_urb->

                

 从下面的usb_submit_urb 分析可知,这是主控驱动注册root_hub,那么调用rh_urb_enqueue

usb_submit_urb->

               usb_hcd_submit_urb->

                                rh_urb_enqueue->

                                                rh_queue_status->

                                                                  mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));

                        

 上面可知，主控会注册一个timer 定时函数，进行检测hub 的端口是否有数据到来，然后处理数据，处理之后，调用处理完成函数。和之前分析的  hub_wq 工作队列检测是否有usb设备连接和断开 是不一样的。工作函数hub_event会被循环执行检测是否有设备连接和断开。

 二、usb_submit_urb

usb_submit_urb 调用流程：

usb_submit_urb->

        usb_hcd_submit_urb

 usb_hcd_submit_urb 函数：

int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
{
        int                     status;
        struct usb_hcd          *hcd = bus_to_hcd(urb->dev->bus);

        /* increment urb's reference count as part of giving it to the HCD
         * (which will control it).  HCD guarantees that it either returns
         * an error or calls giveback(), but not both.
         */
        usb_get_urb(urb);
        atomic_inc(&urb->use_count);
        atomic_inc(&urb->dev->urbnum);
        usbmon_urb_submit(&hcd->self, urb);

        /* NOTE requirements on root-hub callers (usbfs and the hub
         * driver, for now):  URBs' urb->transfer_buffer must be
         * valid and usb_buffer_{sync,unmap}() not be needed, since
         * they could clobber root hub response data.  Also, control
         * URBs must be submitted in process context with interrupts
         * enabled.
         */

        if (is_root_hub(urb->dev)) {          -------------------------------------（1）
                status = rh_urb_enqueue(hcd, urb);
        } else {
                status = map_urb_for_dma(hcd, urb, mem_flags);
                if (likely(status == 0)) {
                        status = hcd->driver->urb_enqueue(hcd, urb, mem_flags); -----------（2）
                        if (unlikely(status))
                                unmap_urb_for_dma(hcd, urb);
                }
        }

        if (unlikely(status)) {
                usbmon_urb_submit_error(&hcd->self, urb, status);
                urb->hcpriv = NULL;
                INIT_LIST_HEAD(&urb->urb_list);
                atomic_dec(&urb->use_count);
                /*
                 * Order the write of urb->use_count above before the read
                 * of urb->reject below.  Pairs with the memory barriers in
                 * usb_kill_urb() and usb_poison_urb().
                 */
                smp_mb__after_atomic();

                atomic_dec(&urb->dev->urbnum);
                if (atomic_read(&urb->reject))
                        wake_up(&usb_kill_urb_queue);
                usb_put_urb(urb);
        }
        return status;
}
 

 （1）如果是 root_hub，则调用 rh_urb_enqueue 函数，

static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
{
        if (usb_endpoint_xfer_int(&urb->ep->desc))   //中断传输
                return rh_queue_status (hcd, urb);
        if (usb_endpoint_xfer_control(&urb->ep->desc))  //控制传输
                return rh_call_control (hcd, urb);
        return -EINVAL;
}
共有两个事务。

 （2）如果非root_hub ,则调用回调函数urb_enqueue

拿ohci 举例：

static const struct hc_driver ohci_hc_driver = {
        .description =          hcd_name,
        .product_desc =         "OHCI Host Controller",
        .hcd_priv_size =        sizeof(struct ohci_hcd),

        /*
         * generic hardware linkage
        */
        .irq =                  ohci_irq,
        .flags =                HCD_MEMORY | HCD_DMA | HCD_USB11,

        /*
        * basic lifecycle operations
        */
        .reset =                ohci_setup,
        .start =                ohci_start,
        .stop =                 ohci_stop,
        .shutdown =             ohci_shutdown,

        /*
         * managing i/o requests and associated device resources
        */
        .urb_enqueue =          ohci_urb_enqueue,
        .urb_dequeue =          ohci_urb_dequeue,
        .endpoint_disable =     ohci_endpoint_disable,

        /*
        * scheduling support
        */
        .get_frame_number =     ohci_get_frame,

        /*
        * root hub support
        */
        .hub_status_data =      ohci_hub_status_data,
        .hub_control =          ohci_hub_control,
#ifdef CONFIG_PM
        .bus_suspend =          ohci_bus_suspend,
        .bus_resume =           ohci_bus_resume,
#endif
        .start_port_reset =     ohci_start_port_reset,
};
 

  .urb_enqueue =          ohci_urb_enqueue,调用ohci_urb_enqueue 函数，

ohci_urb_enqueue ->td_submit_urb->ohci_writel

留一个问题：ohci 执行完urb 后，如何触发 compelte 函数？

root hub 有一个定时timer函数周期性检测，然后触发 tasklet 函数，调用urb->compelete 函数。