static int hub_port_wait_reset(struct usb_hub *hub, int port1,
                struct usb_device *udev, unsigned int delay)
{
    int delay_time, ret;
    u16 portstatus;
    u16 portchange;
    //重试到500
    for (delay_time = 0;delay_time < HUB_RESET_TIMEOUT;delay_time += delay)
    {
        /* wait to give the device a chance to reset */
        msleep(delay);
        /* read and decode port status */
        //读取并解析端口状态
        //读取端口
        ret = hub_port_status(hub, port1, &portstatus, &portchange);
        if (ret < 0)
            return ret;
        /* Device went away? */
        //检测端口的连接位
        if (!(portstatus & USB_PORT_STAT_CONNECTION))
            return -ENOTCONN;
        /* bomb out completely if the connection bounced */
        //检测端口的最近连接状态改变位
        if ((portchange & USB_PORT_STAT_C_CONNECTION))
            return -ENOTCONN;
        /* if we`ve finished resetting, then break out of the loop */
        //检测端口的复位位及端口有效位
        if (!(portstatus & USB_PORT_STAT_RESET) && (portstatus & USB_PORT_STAT_ENABLE))
        {
            //设备为wsu
            if (hub_is_wusb(hub))
                udev->speed = USB_SPEED_VARIABLE;
            //检测端口的高速设备位
            else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
                udev->speed = USB_SPEED_HIGH;
            //检测端口的低速设备位
            else if (portstatus & USB_PORT_STAT_LOW_SPEED)
                udev->speed = USB_SPEED_LOW;
            //设备为全速设备
            else
                udev->speed = USB_SPEED_FULL;
            return 0;
        }
        /* switch to the long delay after two short delay failures */
        if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
            delay = HUB_LONG_RESET_TIME;
        dev_dbg (hub->intfdev,"port %d not reset yet, waiting %dms\n",port1, delay);
    }
    return -EBUSY;
}

static int uhci_urb_enqueue(struct usb_hcd *hcd,
        struct urb *urb, gfp_t mem_flags)
{
    int ret;
    struct uhci_hcd *uhci = hcd_to_uhci(hcd);
    unsigned long flags;
    struct urb_priv *urbp;
    struct uhci_qh *qh;
    spin_lock_irqsave(&uhci->lock, flags);
    //连接urb到端点上
    ret = usb_hcd_link_urb_to_ep(hcd, urb);
    if (ret)
        goto done_not_linked;
    ret = -ENOMEM;
    //分配一个urbp结构,并互相连接urbp和urb
    urbp = uhci_alloc_urb_priv(uhci, urb);
    if (!urbp)
        goto done;
    //检测urb所连接的端点是否有qh
    if (urb->ep->hcpriv)
        qh = urb->ep->hcpriv;
    else
    {
        qh = uhci_alloc_qh(uhci, urb->dev, urb->ep);
        if (!qh)
            goto err_no_qh;
    }
    //连接qh到urbp
    urbp->qh = qh;
    //检测qh的类型
    switch (qh->type)
    {
        //控制
        case USB_ENDPOINT_XFER_CONTROL:
            ret = uhci_submit_control(uhci, urb, qh);
            break;
        //块
        case USB_ENDPOINT_XFER_BULK:
            ret = uhci_submit_bulk(uhci, urb, qh);
            break;
        //中断
        case USB_ENDPOINT_XFER_INT:
            ret = uhci_submit_interrupt(uhci, urb, qh);
            break;
        //等时
        case USB_ENDPOINT_XFER_ISOC:
            urb->error_count = 0;
            ret = uhci_submit_isochronous(uhci, urb, qh);
            break;
    }
    if (ret != 0)
        goto err_submit_failed;
    /* Add this URB to the QH */
    //连接qh到urbp中
    urbp->qh = qh;
    //连接urbp进qh中
    list_add_tail(&urbp->node, &qh->queue);
    /* If the new URB is the first and only one on this QH then either
     * the QH is new and idle or else it's unlinked and waiting to
     * become idle, so we can activate it right away. But only if the
     * queue isn't stopped. */
     //检测该qh是否只连接了一个urb
     //检测该qh是否处于停止状态
    if (qh->queue.next == &urbp->node && !qh->is_stopped)
    {
        uhci_activate_qh(uhci, qh);
        uhci_urbp_wants_fsbr(uhci, urbp);
    }
    goto done;
err_submit_failed:
    if (qh->state == QH_STATE_IDLE)
        uhci_make_qh_idle(uhci, qh);    /* Reclaim unused QH */
err_no_qh:
    uhci_free_urb_priv(uhci, urbp);
done:
    if (ret)
        usb_hcd_unlink_urb_from_ep(hcd, urb);
done_not_linked:
    spin_unlock_irqrestore(&uhci->lock, flags);
    return ret;
}


static struct uhci_qh *uhci_alloc_qh(struct uhci_hcd *uhci,
        struct usb_device *udev, struct usb_host_endpoint *hep)
{
    dma_addr_t dma_handle;
    struct uhci_qh *qh;
    qh = dma_pool_alloc(uhci->qh_pool, GFP_ATOMIC, &dma_handle);
    if (!qh)
        return NULL;
    memset(qh, 0, sizeof(*qh));
    //保存dma块地址
    qh->dma_handle = dma_handle;
    //设置该qh的连接和部件都为终点
    qh->element = UHCI_PTR_TERM;
    qh->link = UHCI_PTR_TERM;
    INIT_LIST_HEAD(&qh->queue);
    INIT_LIST_HEAD(&qh->node);
    //普通qh
    if (udev)
    {    
        //取得端点的传输类型
        qh->type = hep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
        //检测是否为等时传输
        if (qh->type != USB_ENDPOINT_XFER_ISOC)
        {
            //分配一个虚拟td
            qh->dummy_td = uhci_alloc_td(uhci);
            //检测分配是否成功
            if (!qh->dummy_td)
            {
                dma_pool_free(uhci->qh_pool, qh, dma_handle);
                return NULL;
            }
        }
        //设置qh的状态为空闲
        qh->state = QH_STATE_IDLE;
        //连接端点到qh
        qh->hep = hep;
        //连接usb设备到qh
        qh->udev = udev;
        //连接该qh到端点
        hep->hcpriv = qh;
        //检测qh的类型是否为中断或等时
        if (qh->type == USB_ENDPOINT_XFER_INT || qh->type == USB_ENDPOINT_XFER_ISOC)
            qh->load = usb_calc_bus_time(udev->speed,
                    usb_endpoint_dir_in(&hep->desc),
                    qh->type == USB_ENDPOINT_XFER_ISOC,
                    le16_to_cpu(hep->desc.wMaxPacketSize))
                / 1000 + 1;
    }
     //龙骨qh
    else
    {        /* Skeleton QH */
        qh->state = QH_STATE_ACTIVE;
        qh->type = -1;
    }
    return qh;
}


static int uhci_submit_control(struct uhci_hcd *uhci, struct urb *urb,
        struct uhci_qh *qh)
{
    struct uhci_td *td;
    unsigned long destination, status;
    //取得端点的包的最大大小
    int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize);
    //取得urb的资料传输长度
    int len = urb->transfer_buffer_length;
    //取得要传输的数据
    dma_addr_t data = urb->transfer_dma;
    __le32 *plink;
    struct urb_priv *urbp = urb->hcpriv;
    int skel;
    /* The "pipe" thing contains the destination in bits 8--18 */
    //设置设备地址和端点并设置为setup事务
    destination = (urb->pipe & PIPE_DEVEP_MASK) | USB_PID_SETUP;
    /* 3 errors, dummy TD remains inactive */
    //设置状态为最大允许3个错误
    status = uhci_maxerr(3);
    //检测urb连接的设备是否为低速设备
    if (urb->dev->speed == USB_SPEED_LOW)
        status |= TD_CTRL_LS;
    /*
     * Build the TD for the control request setup packet
     */
     //取得虚拟td
    td = qh->dummy_td;
    //添加虚拟td到urbp的队列中
    uhci_add_td_to_urbp(td, urbp);
    //填充td结构(控制传输中数据阶段的8字节内容)
    uhci_fill_td(td, status, destination | uhci_explen(8),urb->setup_dma);
    //取得td的连接地址
    plink = &td->link;
    //设置td的状态为有效
    status |= TD_CTRL_ACTIVE;
    /*
     * If direction is "send", change the packet ID from SETUP (0x2D)
     * to OUT (0xE1). Else change it from SETUP to IN (0x69) and
     * set Short Packet Detect (SPD) for all data packets.
     *
     * 0-length transfers always get treated as "send".
     */
    //检测是否为传入或者长度为0
    if (usb_pipeout(urb->pipe) || len == 0)
        //取消setup事务标志并设为out事务
        destination ^= (USB_PID_SETUP ^ USB_PID_OUT);
    else
    {
        //取消setup事务标志并设为in事务
        destination ^= (USB_PID_SETUP ^ USB_PID_IN);
        //设置短包检测位
        status |= TD_CTRL_SPD;
    }
    /*
     * Build the DATA TDs
     */
    while (len > 0)
    {
        int pktsze = maxsze;
        /* The last data packet */
        //最后一个数据包
        if (len <= pktsze)
        {        
            pktsze = len;
            //取消短包检测位
            status &= ~TD_CTRL_SPD;
        }
        //分配一个td
        td = uhci_alloc_td(uhci);
        //分配失败则返回错误
        if (!td)
            goto nomem;
        //连接该td
        *plink = LINK_TO_TD(td);
        /* Alternate Data0/1 (start with Data1) */
        //设置toggle标记
        destination ^= TD_TOKEN_TOGGLE;
        //连接该td进urbp
        uhci_add_td_to_urbp(td, urbp);
        //填充td,也就是连接数据
        uhci_fill_td(td, status, destination | uhci_explen(pktsze),data);
        //更新plink
        plink = &td->link;
        //数据起始位置增加pktsze
        data += pktsze;
        //数据大小减去pktsze
        len -= pktsze;
    }
    /*
     * Build the final TD for control status
     */
     //分配一个td
    td = uhci_alloc_td(uhci);
    //分配出错则返回错误
    if (!td)
        goto nomem;
    //连接该td
    *plink = LINK_TO_TD(td);
    /* Change direction for the status transaction */
    //根据数据阶段的in out事务,设为反方向的事务
    destination ^= (USB_PID_IN ^ USB_PID_OUT);
    //设置toggle标记
    destination |= TD_TOKEN_TOGGLE;        /* End in Data1 */
    //添加该td进urbp
    uhci_add_td_to_urbp(td, urbp);
    //填充该td,数据长度为0
    uhci_fill_td(td, status | TD_CTRL_IOC,destination | uhci_explen(0), 0);

//更新plink
    plink = &td->link;
    /*
     * Build the new dummy TD and activate the old one
     */
     //分配一个td
    td = uhci_alloc_td(uhci);
    //分配出错则返回错误
    if (!td)
        goto nomem;
    //连接该td
    *plink = LINK_TO_TD(td);
    //填充该td,设置为out事务,数据长度为0,状态为0
    //不激活该TD
    uhci_fill_td(td, 0, USB_PID_OUT | uhci_explen(0), 0);
    wmb();
    //设置原虚拟td的状态为有效的td
    qh->dummy_td->status |= __constant_cpu_to_le32(TD_CTRL_ACTIVE);
    //连接新的虚拟td
    qh->dummy_td = td;
    /* Low-speed transfers get a different queue, and won't hog the bus.
     * Also, some devices enumerate better without FSBR; the easiest way
     * to do that is to put URBs on the low-speed queue while the device
     * isn't in the CONFIGURED state. */
    //判断urb所连接的usb设备的传输速度是否为低速
    //并且状态不为配置
    if (urb->dev->speed == USB_SPEED_LOW || urb->dev->state != USB_STATE_CONFIGURED)
        //取得低速龙骨号
        skel = SKEL_LS_CONTROL;
    else
    {
        //取得全速龙骨号
        skel = SKEL_FS_CONTROL;
        uhci_add_fsbr(uhci, urb);
    }
    //如果qh的状态不为有效则设置龙骨队列的号码
    if (qh->state != QH_STATE_ACTIVE)
        qh->skel = skel;
    //剔除setup事务中的8字节命令数据
    urb->actual_length = -8;    /* Account for the SETUP packet */
    return 0;
nomem:
    /* Remove the dummy TD from the td_list so it doesn't get freed */
    uhci_remove_td_from_urbp(qh->dummy_td);
    return -ENOMEM;
}


static void uhci_activate_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
{
    WARN_ON(list_empty(&qh->queue));
    /* Set the element pointer if it isn't set already.
     * This isn't needed for Isochronous queues, but it doesn't hurt. */
     //检测该qh的部件是否为终点
     //为终点则将部件连接到qh队列的下一个qh的第一个td
    if (qh_element(qh) == UHCI_PTR_TERM)
    {
        struct urb_priv *urbp = list_entry(qh->queue.next,struct urb_priv, node);
        struct uhci_td *td = list_entry(urbp->td_list.next,struct uhci_td, list);
        qh->element = LINK_TO_TD(td);
    }
    /* Treat the queue as if it has just advanced */
    qh->wait_expired = 0;
    //记录当前时间片到前进计数器中
    qh->advance_jiffies = jiffies;
    //检测qh是否已经启动
    if (qh->state == QH_STATE_ACTIVE)
        return;
    //设置qh的状态为启动
    qh->state = QH_STATE_ACTIVE;
    /* Move the QH from its old list to the correct spot in the appropriate
     * skeleton's list */
     //检测该qh是否为下一个扫描的qh
    if (qh == uhci->next_qh)
        //修改下一个扫描的qh为当前qh队列中的下一个
        uhci->next_qh = list_entry(qh->node.next, struct uhci_qh,node);
    list_del(&qh->node);
    //检测是否为等时传输
    if (qh->skel == SKEL_ISO)
        link_iso(uhci, qh);
    //检测是否为中断传输
    else if (qh->skel < SKEL_ASYNC)
        link_interrupt(uhci, qh);
    //控制传输和块传输
    else
        link_async(uhci, qh);
}


static void link_async(struct uhci_hcd *uhci, struct uhci_qh *qh)
{
    struct uhci_qh *pqh;
    __le32 link_to_new_qh;
    /* Find the predecessor QH for our new one and insert it in the list.
     * The list of QHs is expected to be short, so linear search won't
     * take too long. */
    //反向历遍uhci的9号龙骨qh上的qh
    //寻找适当的龙骨号进行插入
    list_for_each_entry_reverse(pqh, &uhci->skel_async_qh->node, node)
    {
        if (pqh->skel <= qh->skel)
            break;
    }
    //添加该qh到龙骨的qh队列中
    list_add(&qh->node, &pqh->node);
    /* Link it into the schedule */
    //修改该qh的硬件连接为要插入的qh的连接对象
    qh->link = pqh->link;
    wmb();
    //取得该qh的硬件地址
    link_to_new_qh = LINK_TO_QH(qh);
    //连接该qh的硬件地址
    pqh->link = link_to_new_qh;
    /* If this is now the first FSBR QH, link the terminating skeleton
     * QH to it. */
    if (pqh->skel < SKEL_FSBR && qh->skel >= SKEL_FSBR)
        uhci->skel_term_qh->link = link_to_new_qh;
}


static void uhci_scan_schedule(struct uhci_hcd *uhci)
{
    int i;
    struct uhci_qh *qh;
    /* Don't allow re-entrant calls */
    //只能在一个时间的一个线程内运行
    //有别的线程占用则返回
    if (uhci->scan_in_progress)
    {
        uhci->need_rescan = 1;
        return;
    }
    //设置标志位,不允许别的线程进入这个函数
    uhci->scan_in_progress = 1;
rescan:
    //清除重新扫描标志位
    uhci->need_rescan = 0;
    //清除fsbr需要标志位
    uhci->fsbr_is_wanted = 0;
    //正在调度队列,不希望产生td的中断
    uhci_clear_next_interrupt(uhci);
    //取得当前帧号
    uhci_get_current_frame_number(uhci);
    //设置当前扫描的帧号
    uhci->cur_iso_frame = uhci->frame_number;
    /* Go through all the QH queues and process the URBs in each one */
    //历遍0号到9号龙骨qh
    for (i = 0; i < UHCI_NUM_SKELQH - 1; ++i)
    {
        //获取龙骨qh所连接的第一个qh
        uhci->next_qh = list_entry(uhci->skelqh[i]->node.next,struct uhci_qh, node);
        //历遍龙骨qh所连接的qh
        while ((qh = uhci->next_qh) != uhci->skelqh[i])
        {
            //取得下一个qh
            uhci->next_qh = list_entry(qh->node.next,struct uhci_qh, node);
            //检测该qh队列中的td是否处理过
            if (uhci_advance_check(uhci, qh))
            {
                //扫描qh
                uhci_scan_qh(uhci, qh);
                if (qh->state == QH_STATE_ACTIVE)
                {
                    uhci_urbp_wants_fsbr(uhci,list_entry(qh->queue.next, struct urb_priv, node));
                }
            }
        }
    }
    //设置最后扫描的帧号
    uhci->last_iso_frame = uhci->cur_iso_frame;
    //检测是否需要再扫描
    if (uhci->need_rescan)
        goto rescan;
    //清除扫描标志位
    uhci->scan_in_progress = 0;
    if (uhci->fsbr_is_on && !uhci->fsbr_is_wanted && !uhci->fsbr_expiring)
    {
        uhci->fsbr_expiring = 1;
        mod_timer(&uhci->fsbr_timer, jiffies + FSBR_OFF_DELAY);
    }
    //检测0号龙骨qh是否有qh队列
    if (list_empty(&uhci->skel_unlink_qh->node))
        uhci_clear_next_interrupt(uhci);
    else
        uhci_set_next_interrupt(uhci);
}


static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh)
{
    struct urb_priv *urbp = NULL;
    struct uhci_td *td;
    int ret = 1;
    unsigned status;
    //不检测同步传输队列
    if (qh->type == USB_ENDPOINT_XFER_ISOC)
        goto done;
    /* Treat an UNLINKING queue as though it hasn't advanced.
     * This is okay because reactivation will treat it as though
     * it has advanced, and if it is going to become IDLE then
     * this doesn't matter anyway. Furthermore it's possible
     * for an UNLINKING queue not to have any URBs at all, or
     * for its first URB not to have any TDs (if it was dequeued
     * just as it completed). So it's not easy in any case to
     * test whether such queues have advanced. */
    //检测qh是否为有效状态
    if (qh->state != QH_STATE_ACTIVE)
    {
        urbp = NULL;
        status = 0;
    }
    else
    {
        //取得qh所连接的第一个urbp
        urbp = list_entry(qh->queue.next, struct urb_priv, node);
        //取得urbp所连接的第一个td
        td = list_entry(urbp->td_list.next, struct uhci_td, list);
        //取得td的状态字段
        status = td_status(td);
        //检测td是否为有效状态
        if (!(status & TD_CTRL_ACTIVE))
        {
            /* We're okay, the queue has advanced */
            //TD为无效状态则说明该TD已经被处理
            //队列前进了
            //设置等待到期标志为0
            qh->wait_expired = 0;
            //记录现在的时间片
            qh->advance_jiffies = jiffies;
            goto done;
        }
        ret = 0;
    }
    /* The queue hasn't advanced; check for timeout */
    //检测qh的等待到期位
    if (qh->wait_expired)
        goto done;
    //检测qh的处理时间是否过期
    if (time_after(jiffies, qh->advance_jiffies + QH_WAIT_TIMEOUT))
    {
        /* Detect the Intel bug and work around it */
        //排除intel的bug
        //检测是否有post_td
        //并且post_td是否为qh的唯一一个td
        if (qh->post_td && qh_element(qh) == LINK_TO_TD(qh->post_td))
        {
            //设置qh的元件为post_td的连接
            qh->element = qh->post_td->link;
            //记录现在的时间片
            qh->advance_jiffies = jiffies;
            ret = 1;
            goto done;
        }
        //设置等待到期位为1
        qh->wait_expired = 1;
        /* If the current URB wants FSBR, unlink it temporarily
         * so that we can safely set the next TD to interrupt on
         * completion. That way we'll know as soon as the queue
         * starts moving again. */
         //检测urbp是否存在
         //检测urbp的fsbr位是否为真
         //检测qh第一个td的IOC位是否为0
        if (urbp && urbp->fsbr && !(status & TD_CTRL_IOC))
            //从uhci硬件队列中剔除该qh
            uhci_unlink_qh(uhci, qh);
    }
    else
    {
        /* Unmoving but not-yet-expired queues keep FSBR alive */
        if (urbp)
            uhci_urbp_wants_fsbr(uhci, urbp);
    }
done:
    return ret;
}


static void uhci_scan_qh(struct uhci_hcd *uhci, struct uhci_qh *qh)
{
    struct urb_priv *urbp;
    struct urb *urb;
    int status;
    //历遍连接到该qh的所有urbp
    while (!list_empty(&qh->queue))
    {
        //取得urbp
        urbp = list_entry(qh->queue.next, struct urb_priv, node);
        //取得对应的urb
        urb = urbp->urb;
        //检测该qh的类型是否为同步传输
        if (qh->type == USB_ENDPOINT_XFER_ISOC)
            status = uhci_result_isochronous(uhci, urb);
        else
            status = uhci_result_common(uhci, urb);
        if (status == -EINPROGRESS)
            break;
        /* Dequeued but completed URBs can't be given back unless
         * the QH is stopped or has finished unlinking. */
         //检测urb的卸载位
        if (urb->unlinked)
        {
            //检测qh的状态是否为卸载中
            //检测uhci的当前扫描帧号加上停止标志是否等于
            //qh的卸载帧号
            if (QH_FINISHED_UNLINKING(qh))
                //设置qh的停止位为真
                qh->is_stopped = 1;
            //检测qh的停止位
            else if (!qh->is_stopped)
                return;
        }
        //返还urb给驱动程序
        uhci_giveback_urb(uhci, qh, urb, status);
        if (status < 0)
            break;
    }
    /* If the QH is neither stopped nor finished unlinking (normal case),
     * our work here is done. */
    //检测qh的状态是否为卸载中
    //检测uhci的当前扫描帧号加上停止标志是否等于
    //qh的卸载帧号
    if (QH_FINISHED_UNLINKING(qh))
        //设置qh的停止位为真
        qh->is_stopped = 1;
    检测qh的停止位
    else if (!qh->is_stopped)
        return;
    /* Otherwise give back each of the dequeued URBs */
restart:
    //历遍连接到qh的所有urbp
    list_for_each_entry(urbp, &qh->queue, node)
    {
        //取得urb
        urb = urbp->urb;
        //检测卸载标识
        if (urb->unlinked)
        {
            /* Fix up the TD links and save the toggles for
             * non-Isochronous queues. For Isochronous queues,
             * test for too-recent dequeues. */
            if (!uhci_cleanup_queue(uhci, qh, urb))
            {
                //设置qh的停止标识为0
                qh->is_stopped = 0;
                return;
            }
            //归还urb给驱动程序
            uhci_giveback_urb(uhci, qh, urb, 0);
            goto restart;
        }
    }
    //设置qh的停止标识为0
    qh->is_stopped = 0;
    /* There are no more dequeued URBs. If there are still URBs on the
     * queue, the QH can now be re-activated. */
     //检测qh的urbp队列是否为空
    if (!list_empty(&qh->queue))
    {
        //检测qh是否需要修正toggle
        if (qh->needs_fixup)
            uhci_fixup_toggles(qh, 0);
        /* If the first URB on the queue wants FSBR but its time
         * limit has expired, set the next TD to interrupt on
         * completion before reactivating the QH. */
         //取得urbp
        urbp = list_entry(qh->queue.next, struct urb_priv, node);
        //检测该urbp是否使用fsbr
        //检测qh是否等待到期
        if (urbp->fsbr && qh->wait_expired)
        {
            //取得urbp的td
            struct uhci_td *td = list_entry(urbp->td_list.next,struct uhci_td, list);
            //设置完成启动中断位
            td->status |= __cpu_to_le32(TD_CTRL_IOC);
        }
        //激活该qh
        uhci_activate_qh(uhci, qh);
    }
    /* The queue is empty. The QH can become idle if it is fully
     * unlinked. */
    else if (QH_FINISHED_UNLINKING(qh))
        uhci_make_qh_idle(uhci, qh);
}


static int uhci_result_common(struct uhci_hcd *uhci, struct urb *urb)
{
    //取得urbp
    struct urb_priv *urbp = urb->hcpriv;
    struct uhci_qh *qh = urbp->qh;
    struct uhci_td *td, *tmp;
    unsigned status;
    int ret = 0;
    //历遍连接到该urbp的所有td
    list_for_each_entry_safe(td, tmp, &urbp->td_list, list)
    {
        unsigned int ctrlstat;
        int len;
        //取得td的控制状态字段
        ctrlstat = td_status(td);
        //取得控制状态字段的17 18 20 21 22 23位
        status = uhci_status_bits(ctrlstat);
        //检测有效位是否为真
        //为真则说明该td尚未进行传输,完成处理
        if (status & TD_CTRL_ACTIVE)
            return -EINPROGRESS;
        //取得该td实际传输的数据长度
        len = uhci_actual_length(ctrlstat);
        //计算所有事务实际取得的数据长度
        urb->actual_length += len;
        //检测状态字段是否全为0
        if (status)
        {
            //取得令牌字段然后检测传输方向是否为输出
            //检测状态字段的各种错误位
            ret = uhci_map_status(status,uhci_packetout(td_token(td)));
            if ((debug == 1 && ret != -EPIPE) || debug > 1)
            {
                /* Some debugging code */
                dev_dbg(&urb->dev->dev,"%s: failed with status %x\n",__func__, status);

if (debug > 1 && errbuf)
                {
                    /* Print the chain for debugging */
                    uhci_show_qh(uhci, urbp->qh, errbuf,ERRBUF_LEN, 0);
                    
                    lprintk(errbuf);
                }
            }
        /* Did we receive a short packet? */
        }
        //检测传输长度是否小于预期长度(短包)
        else if (len < uhci_expected_length(td_token(td)))
        {
            /* For control transfers, go to the status TD if
             * this isn't already the last data TD */
             //检测qh的传输类型是否为控制
            if (qh->type == USB_ENDPOINT_XFER_CONTROL)
            {
                //因为在控制传输中最后一个td为状态事务
                //最后一个数据td为状态td的上一个
                //所以检测该td是否为最后一个数据td
                if (td->list.next != urbp->td_list.prev)
                    ret = 1;
            }
            /* For bulk and interrupt, this may be an error */
            //检测urb是否接受短包
            else if (urb->transfer_flags & URB_SHORT_NOT_OK)
                ret = -EREMOTEIO;
            /* Fixup needed only if this isn't the URB's last TD */
            //检测该td是否为为队列的最后一个td
            else if (&td->list != urbp->td_list.prev)
                ret = 1;
        }
        //从urbp中移除该td
        uhci_remove_td_from_urbp(td);
        //释放最后一个完成传输的td
        if (qh->post_td)
            uhci_free_td(uhci, qh->post_td);
        //连接该td到qh上
        qh->post_td = td;
        if (ret != 0)
            goto err;
    }
    return ret;
err:
    if (ret < 0)
    {
        /* Note that the queue has stopped and save
         * the next toggle value */
        qh->element = UHCI_PTR_TERM;
        qh->is_stopped = 1;
        qh->needs_fixup = (qh->type != USB_ENDPOINT_XFER_CONTROL);
        qh->initial_toggle = uhci_toggle(td_token(td)) ^ (ret == -EREMOTEIO);
    }
    else        /* Short packet received */
        //进行短包处理
        ret = uhci_fixup_short_transfer(uhci, qh, urbp);
    return ret;
}


code uint8 DeviceDescriptor[0x12]= //设备描述符为18字节

{
//bLength字段。设备描述符的长度为18(0x12)字节
 0x12,
//bDescriptorType字段。设备描述符的编号为0x01
 0x01,
//bcdUSB字段。这里设置版本为USB1.1，即0x0110。
//由于是小端结构，所以低字节在先，即0x10，0x01。
 0x10,
 0x01,
//bDeviceClass字段。我们不在设备描述符中定义设备类，
//而在接口描述符中定义设备类，所以该字段的值为0。
 0x00,
//bDeviceSubClass字段。bDeviceClass字段为0时，该字段也为0。
 0x00,
//bDeviceProtocol字段。bDeviceClass字段为0时，该字段也为0。
 0x00,
//bMaxPacketSize0字段。PDIUSBD12的端点0大小的16字节。
 0x10,
//idVender字段。厂商ID号，我们这里取0x8888，仅供实验用。
//实际产品不能随便使用厂商ID号，必须跟USB协会申请厂商ID号。
//注意小端模式，低字节在先。
 0x88,
 0x88,
//idProduct字段。产品ID号，由于是第一个实验，我们这里取0x0001。
//注意小端模式，低字节应该在前。
 0x01,
 0x00,
//bcdDevice字段。我们这个USB鼠标刚开始做，就叫它1.0版吧，即0x0100。
//小端模式，低字节在先。
 0x00,
 0x01,
//iManufacturer字段。厂商字符串的索引值，为了方便记忆和管理，
//字符串索引就从1开始吧。
 0x01
//iProduct字段。产品字符串的索引值。刚刚用了1，这里就取2吧。
//注意字符串索引值不要使用相同的值。
 0x02,
//iSerialNumber字段。设备的序列号字符串索引值。
//这里取3就可以了。
 0x03,
//bNumConfigurations字段。该设备所具有的配置数。
//我们只需要一种配置就行了，因此该值设置为1。
 0x01
};


while(1) //死循环
{
          if(D12GetIntPin()==0) //如果有中断发生
          {
               D12WriteCommand(READ_INTERRUPT_REGISTER); //写读中断寄存器的命令
               InterruptSource=D12ReadByte(); //读回第一字节的中断寄存器
               if(InterruptSource&0x80)UsbBusSuspend(); //总线挂起中断处理
               if(InterruptSource&0x40)UsbBusReset(); //总线复位中断处理
               if(InterruptSource&0x01)UsbEp0Out(); //端点0输出中断处理
               if(InterruptSource&0x02)UsbEp0In(); //端点0输入中断处理
               if(InterruptSource&0x04)UsbEp1Out(); //端点1输出中断处理
               if(InterruptSource&0x08)UsbEp1In(); //端点1输入中断处理
               if(InterruptSource&0x10)UsbEp2Out(); //端点2输出中断处理
               if(InterruptSource&0x20)UsbEp2In(); //端点2输入中断处理
          }
}

void UsbEp0Out(void)
{
#ifdef DEBUG0
     Prints("USB端点0输出中断。\r\n");
#endif
     //读取端点0输出最后传输状态，该操作清除中断标志
     //并判断第5位是否为1，如果是，则说明是建立包
     if(D12ReadEndpointLastStatus(0)&0x20)
     {
        D12ReadEndpointBuffer(0,16,Buffer); //读建立过程数据
         D12AcknowledgeSetup(); //应答建立包
          D12ClearBuffer(); //清缓冲区
          //将缓冲数据填到设备请求的各字段中
          bmRequestType=Buffer[0];
          bRequest=Buffer[1];
          wValue=Buffer[2]+(((uint16)Buffer[3])<<8);
          wIndex=Buffer[4]+(((uint16)Buffer[5])<<8);
          wLength=Buffer[6]+(((uint16)Buffer[7])<<8);
          //下面的代码判断具体的请求，并根据不同的请求进行相关操作
          //如果D7位为1，则说明是输入请求
          if((bmRequestType&0x80)==0x80)
          {
               //根据bmRequestType的D6~5位散转，D6~5位表示请求的类型
               //0为标准请求，1为类请求，2为厂商请求。
               switch((bmRequestType>>5)&0x03)
               {
                    case 0: //标准请求
#ifdef DEBUG0
                          Prints("USB标准输入请求：");
#endif
     //USB协议定义了几个标准输入请求，我们实现这些标准请求即可
     //请求的代码在bRequest中，对不同的请求代码进行散转
     //事实上，我们还需要对接收者进行散转，因为不同的请求接收者
     //是不一样的。接收者在bmRequestType的D4~D0位中定义。
     //我们这里为了简化操作，有些就省略了对接收者的判断。
     //例如获取描述符的请求，只根据描述符的类型来区别。
                         switch(bRequest)
                         {
                              case GET_CONFIGURATION: //获取配置
#ifdef DEBUG0
                                Prints("获取配置。\r\n");
#endif
                                  break;
                              case GET_DESCRIPTOR: //获取描述符
#ifdef DEBUG0
                            Prints("获取描述符——");
#endif
       //对描述符类型进行散转，对于全速设备，
       //标准请求只支持发送到设备的设备、配置、字符串三种描述符
                               switch((wValue>>8)&0xFF)
                                {
                                     case DEVICE_DESCRIPTOR: //设备描述符
#ifdef DEBUG0
                                           Prints("设备描述符。\r\n");
#endif
                                          pSendData=DeviceDescriptor; //需要发送的数据
          //判断请求的字节数是否比实际需要发送的字节数多
          //这里请求的是设备描述符，因此数据长度就是
          //DeviceDescriptor[0]。如果请求的比实际的长，
          //那么只返回实际长度的数据
                                    if(wLength>DeviceDescriptor[0])
                                    {
                                        SendLength=DeviceDescriptor[0];
                                        if(SendLength%DeviceDescriptor[7]==0) //并且刚好是整数个数据包时
                                        {
                                            NeedZeroPacket=1; //需要返回0长度的数据包
                                        }
                                    }
                                    else
                                    {
                                        SendLength=wLength;
                                    }
                                    //将数据通过EP0返回
                                    UsbEp0SendData();
                                    break;
......................
......................
}


void UsbEp0SendData(void)
{
 //将数据写到端点中去准备发送
 //写之前要先判断一下需要发送的数据是否比端点0
 //最大长度大，如果超过端点大小，则一次只能发送
 //最大包长的数据。端点0的最大包长在DeviceDescriptor[7]
     if(SendLength>DeviceDescriptor[7])
     {
          //按最大包长度发送
          D12WriteEndpointBuffer(1,DeviceDescriptor[7],pSendData);
          //发送后剩余字节数减少最大包长
          SendLength-=DeviceDescriptor[7];
          //发送一次后指针位置要调整
          pSendData+= DeviceDescriptor[7];
     }
     else
     {
          if(SendLength!=0)
          {
               //不够最大包长，可以直接发送
               D12WriteEndpointBuffer(1,SendLength,pSendData);
               //发送完毕后，SendLength长度变为0
               SendLength=0;
          }
          else //如果要发送的数据包长度为0
          {
               if(NeedZeroPacket==1) //如果需要发送0长度数据
               {
                    D12WriteEndpointBuffer(1,0,pSendData); //发送0长度数据包
                    NeedZeroPacket=0; //清需要发送0长度数据包标志

}
          }
     }
}
D12WriteEndpointBuffer为真正发送数据的函数, D12WriteEndpointBuffer的代码如下
uint8 D12WriteEndpointBuffer(uint8 Endp,uint8 Len,uint8 * Buf)
{
     uint8 i;
     D12SelectEndpoint(Endp); //选择端点
     D12WriteCommand(D12_WRITE_BUFFER); //写Write Buffer命令
     D12WriteByte(0); //该字节必须写0
     D12WriteByte(Len); //写需要发送数据的长度
#ifdef DEBUG1 //如果定义了DEBUG1，则需要显示调试信息
     Prints("写端点");
     PrintLongInt(Endp/2); //端点号。由于D12特殊的端点组织形式，
                       //这里的0和1分别表示端点0的输出和输入；
                       //而2、3分别表示端点1的输出和输入；
                       // 3、4分别表示端点2的输出和输入。
                       //因此要除以2才显示对应的端点。
     Prints("缓冲区");
     PrintLongInt(Len); //写入的字节数
     Prints("字节。\r\n");
#endif
     D12SetPortOut(); //将数据口设置为输出状态（注意这里为空宏，移植时可能有用）
     for(i=0;i<Len;i++)
     {
          //这里不直接调用写一字节的函数，而直接在这里模拟时序，可以节省时间
          D12ClrWr(); //WR置低
          D12SetData(*(Buf+i)); //将数据放到数据线上
          D12SetWr(); //WR置高，完成一字节写
#ifdef DEBUG1
          PrintHex(*(Buf+i)); //如果需要显示调试信息，则显示发送的数据
          if((i+1)%16==0)Prints("\r\n"); //每16字节换行一次
#endif
      }
#ifdef DEBUG1
     if((Len%16)!=0)
        Prints("\r\n"); //换行

#endif
     D12SetPortIn(); //数据口切换到输入状态
     D12ValidateBuffer(); //使端点数据有效
     return Len; //返回Len
}