static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
   u16 wIndex, char *buf, u16 wLength)
{
 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
 int status, lstatus, retval = 0, len = 0;
 unsigned int port = wIndex - 1;
 unsigned long port_addr = uhci->io_addr + USBPORTSC1 + 2 * port;
 u16 wPortChange, wPortStatus;
 unsigned long flags;
 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) || uhci->dead)
  return -ETIMEDOUT;
 spin_lock_irqsave(&uhci->lock, flags);
 switch (typeReq)
 {
 //获取集线器状态
 case GetHubStatus:
  *(__le32 *)buf = cpu_to_le32();
  OK(4); /* hub power */
 //获取端口状态
 case GetPortStatus:
  //要求的端口号大于实际集线器有的端口数
  if (port >= uhci->rh_numports)
   goto err;
  uhci_check_ports(uhci);
  //获得对应的端口地址的寄存器数据
  status = inw(port_addr);
  /* Intel controllers report the OverCurrent bit active on.
   * VIA controllers report it active off, so we'll adjust the
   * bit value. (It's not standardized in the UHCI spec.)
   */
   //检测是否为VIA的产品
  if (to_pci_dev(hcd->self.controller)->vendor == PCI_VENDOR_ID_VIA)
   status ^= USBPORTSC_OC;
  /* UHCI doesn't support C_RESET (always false) */
  wPortChange = lstatus = 0;
  //检测连接状态改变位
  if (status & USBPORTSC_CSC)
   wPortChange |= USB_PORT_STAT_C_CONNECTION;
  //检测端口有效状态改变位
  if (status & USBPORTSC_PEC)
   wPortChange |= USB_PORT_STAT_C_ENABLE;
  //检测过电保护改变位
  if ((status & USBPORTSC_OCC) && !ignore_oc)
   wPortChange |= USB_PORT_STAT_C_OVERCURRENT;
  //检测端口悬挂位
  if (test_bit(port, &uhci->port_c_suspend)) 
  {
   wPortChange |= USB_PORT_STAT_C_SUSPEND;
   lstatus |= 1;
  }
  //检测端口恢复位
  if (test_bit(port, &uhci->resuming_ports))
   lstatus |= 4;
  /* UHCI has no power switching (always on) */
  //设置端口供电状态为正常
  wPortStatus = USB_PORT_STAT_POWER;
  //检测当前连接状态位
  if (status & USBPORTSC_CCS)
   wPortStatus |= USB_PORT_STAT_CONNECTION;
  //检测端口有效位
  if (status & USBPORTSC_PE) 
  {
   wPortStatus |= USB_PORT_STAT_ENABLE;
   //检测端口挂起/恢复位
   if (status & SUSPEND_BITS)
    wPortStatus |= USB_PORT_STAT_SUSPEND;
  }
  //检测电源超载位
  if (status & USBPORTSC_OC)
   wPortStatus |= USB_PORT_STAT_OVERCURRENT;
  //检测端口复位位
  if (status & USBPORTSC_PR)
   wPortStatus |= USB_PORT_STAT_RESET;
  //检测端口连接的设备是否为低速设备
  if (status & USBPORTSC_LSDA)
   wPortStatus |= USB_PORT_STAT_LOW_SPEED;
  if (wPortChange)
   dev_dbg(uhci_dev(uhci), "port %d portsc %04x,%02x\n",wIndex, status,lstatus);
  //将状态信息复制到buf的前2字节
  *(__le16 *)buf = cpu_to_le16(wPortStatus);
  //将状态改变信息复制到buf的后2字节
  *(__le16 *)(buf + 2) = cpu_to_le16(wPortChange);
  OK(4);
 case SetHubFeature: /* We don't implement these */
 case ClearHubFeature:
  switch (wValue) 
  {
  case C_HUB_OVER_CURRENT:
  case C_HUB_LOCAL_POWER:
   OK();
  default:
   goto err;
  }
  break;
 case SetPortFeature:
  if (port >= uhci->rh_numports)
   goto err;
  switch (wValue)
  {
  case USB_PORT_FEAT_SUSPEND:
   SET_RH_PORTSTAT(USBPORTSC_SUSP);
   OK();
  case USB_PORT_FEAT_RESET:
   //端口发送复位信号
   SET_RH_PORTSTAT(USBPORTSC_PR);
   /* Reset terminates Resume signalling */
   //停止发送恢复信号
   uhci_finish_suspend(uhci, port, port_addr);
   /* USB v2.0 7.1.7.5 */
   uhci->ports_timeout = jiffies + msecs_to_jiffies(50);
   OK();
  case USB_PORT_FEAT_POWER:
   /* UHCI has no power switching */
   OK();
  default:
   goto err;
  }
  break;
 case ClearPortFeature:
  //检测端口号是否大于集线器的端口数
  if (port >= uhci->rh_numports)
   goto err;
  switch (wValue) 
  {
  case USB_PORT_FEAT_ENABLE:
   CLR_RH_PORTSTAT(USBPORTSC_PE);
   /* Disable terminates Resume signalling */
   uhci_finish_suspend(uhci, port, port_addr);
   OK();
  case USB_PORT_FEAT_C_ENABLE:
   CLR_RH_PORTSTAT(USBPORTSC_PEC);
   OK();
  case USB_PORT_FEAT_SUSPEND:
   if (!(inw(port_addr) & USBPORTSC_SUSP)) 
   {
    /* Make certain the port isn't suspended */
    uhci_finish_suspend(uhci, port, port_addr);
   } 
   else if (!test_and_set_bit(port,&uhci->resuming_ports)) 
   {
    SET_RH_PORTSTAT(USBPORTSC_RD);
    /* The controller won't allow RD to be set
     * if the port is disabled. When this happens
     * just skip the Resume signalling.
     */
    if (!(inw(port_addr) & USBPORTSC_RD))
     uhci_finish_suspend(uhci, port,
       port_addr);
    else
     /* USB v2.0 7.1.7.7 */
     uhci->ports_timeout = jiffies +
      msecs_to_jiffies(20);
   }
   OK();
  case USB_PORT_FEAT_C_SUSPEND:
   clear_bit(port, &uhci->port_c_suspend);
   OK();
  case USB_PORT_FEAT_POWER:
   /* UHCI has no power switching */
   goto err;
  case USB_PORT_FEAT_C_CONNECTION:
   CLR_RH_PORTSTAT(USBPORTSC_CSC);
   OK();
  case USB_PORT_FEAT_C_OVER_CURRENT:
   CLR_RH_PORTSTAT(USBPORTSC_OCC);
   OK();
  case USB_PORT_FEAT_C_RESET:
   /* this driver won't report these */
   OK();
  default:
   goto err;
  }
  break;
 case GetHubDescriptor:
  len = min_t(unsigned int, sizeof(root_hub_hub_des), wLength);
  memcpy(buf, root_hub_hub_des, len);
  if (len > 2)
   buf[2] = uhci->rh_numports;
  OK(len);
 default:
err:
  retval = -EPIPE;
 }
 spin_unlock_irqrestore(&uhci->lock, flags);
 return retval;
}


int usb_get_status(struct usb_device *dev, int type, int target, void *data)
{
 int ret;
 u16 *status = kmalloc(sizeof(*status), GFP_KERNEL);
 if (!status)
  return -ENOMEM;
 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  USB_REQ_GET_STATUS, USB_DIR_IN | type, 0, target, status,
  sizeof(*status), USB_CTRL_GET_TIMEOUT);
 *(u16 *)data = *status;
 kfree(status);
 return ret;
}


static int hub_hub_status(struct usb_hub *hub,
  u16 *status, u16 *change)
{
 int ret;
 mutex_lock(&hub->status_mutex);
 //取得集线器状态
 ret = get_hub_status(hub->hdev, &hub->status->hub);
 if (ret < 0)
  dev_err (hub->intfdev,"%s failed (err = %d)\n", __func__, ret);
 else 
 {
  *status = le16_to_cpu(hub->status->hub.wHubStatus);
  *change = le16_to_cpu(hub->status->hub.wHubChange);
  ret = 0;
 }
 mutex_unlock(&hub->status_mutex);
 return ret;
}


static int get_hub_status(struct usb_device *hdev,
  struct usb_hub_status *data)
{
 int i, status = -ETIMEDOUT;
 for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) 
 {
  status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
   USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
   data, sizeof(*data), USB_STS_TIMEOUT);
 }
 return status;
}


static void hub_power_on(struct usb_hub *hub)
{
 int port1;
 unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
 u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 /* Enable power on each port. Some hubs have reserved values
  * of LPSM (> 2) in their descriptors, even though they are
  * USB 2.0 hubs. Some hubs do not implement port-power switching
  * but only emulate it. In all cases, the ports won't work
  * unless we send these messages to the hub.
  */
 if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
  dev_dbg(hub->intfdev, "enabling power on all ports\n");
 else
  dev_dbg(hub->intfdev, "trying to enable port power on " "non-switchable hub\n");
 //历遍端口
 for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
  //设置端口的灵巧电源分配
  set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
 /* Wait at least 100 msec for power to become stable */
 msleep(max(pgood_delay, (unsigned) 100));
}


static int set_port_feature(struct usb_device *hdev, int port1, int feature)
{
 return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
  USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,
  NULL, 0, 1000);
}


static void hub_activate(struct usb_hub *hub)
{
 int status;
 hub->quiescing = 0;
 hub->activating = 1;
 //发送中断urb
 status = usb_submit_urb(hub->urb, GFP_NOIO);
 
 if (status < 0)
  dev_err(hub->intfdev, "activate --> %d\n", status);

 if (hub->has_indicators && blinkenlights)
  schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
 /* scan all ports ASAP */
 kick_khubd(hub);
}


static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
{
 int retval;
 unsigned long flags;
 int len = 1 + (urb->dev->maxchild / 8);
 spin_lock_irqsave (&hcd_root_hub_lock, flags);
 if (hcd->status_urb || urb->transfer_buffer_length < len) 
 {
  dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
  retval = -EINVAL;
  goto done;
 }
 //连接urb到端点
 retval = usb_hcd_link_urb_to_ep(hcd, urb);
 if (retval)
  goto done;
 //连接urb到主机控制器驱动上
 hcd->status_urb = urb;
 //连接主机控制器驱动到urb的私有数据上
 urb->hcpriv = hcd; /* indicate it's queued */
 if (!hcd->uses_new_polling)
  mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
 /* If a status change has already occurred, report it ASAP */
 else if (hcd->poll_pending)
  mod_timer(&hcd->rh_timer, jiffies);
 retval = 0;
 done:
 spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
 return retval;
}


void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
{
 struct urb *urb;
 int length;
 unsigned long flags;
 char buffer[4]; /* Any root hubs with > 31 ports? */
 //检测主机控制器驱动是否已经注册
 if (unlikely(!hcd->rh_registered))
  return;
 if (!hcd->uses_new_polling && !hcd->status_urb)
  return;
 //进行集线器设备状态检测
 length = hcd->driver->hub_status_data(hcd, buffer);
 //端口有设备
 if (length > 0)
 {
  /* try to complete the status urb */
  spin_lock_irqsave(&hcd_root_hub_lock, flags);
  urb = hcd->status_urb;
  //检测urb是否存在
  if (urb) 
  {
   hcd->poll_pending = 0;
   //清除hcd的状态urb
   hcd->status_urb = NULL;
   //置实际传输长度为1
   urb->actual_length = length;
   //拷贝端口状态描述组到urb中
   memcpy(urb->transfer_buffer, buffer, length);
   //卸载urb与节点的连接
   usb_hcd_unlink_urb_from_ep(hcd, urb);
   spin_unlock(&hcd_root_hub_lock);
   //返回urb给驱动程序
   usb_hcd_giveback_urb(hcd, urb, 0);
   spin_lock(&hcd_root_hub_lock);
  } 
  else 
  {
   length = 0;
   hcd->poll_pending = 1;
  }
  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 inbetween */
 //每间隔HZ/4就执行一次hcd->rh_timer中指定的函数
 if (hcd->uses_new_polling ? hcd->poll_rh :(length == 0 && hcd->status_urb !=NULL))
  mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
}


static int uhci_hub_status_data(struct usb_hcd *hcd, char *buf)
{
 //取得uhci_hcd结构
 struct uhci_hcd *uhci = hcd_to_uhci(hcd);
 unsigned long flags;
 int status = 0;
 spin_lock_irqsave(&uhci->lock, flags);
 //调度uhci中的帧队列
 uhci_scan_schedule(uhci);
 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) || uhci->dead)
  goto done;
 //检测端口
 uhci_check_ports(uhci);
 //获得端口状态
 status = get_hub_status_data(uhci, buf);
 //检测根集线器的状态
 switch (uhci->rh_state) 
 {
     case UHCI_RH_SUSPENDING:
     case UHCI_RH_SUSPENDED:
  /* if port change, ask to be resumed */
  if (status)
   //唤醒根集线器
   usb_hcd_resume_root_hub(hcd);
  break;
     case UHCI_RH_AUTO_STOPPED:
  /* if port change, auto start */
  if (status)
   //唤醒主机控制器
   wakeup_rh(uhci);
  break;
     //uhci的状态为运行
     case UHCI_RH_RUNNING:
  /* are any devices attached? */
  //检测是否有连接的设备
  if (!any_ports_active(uhci)) 
  {
   //改变uhci的状态为运行但无设备
   uhci->rh_state = UHCI_RH_RUNNING_NODEVS;
   //改变uhci的自动停止时间
   uhci->auto_stop_time = jiffies + HZ;
  }
  break;
     //uhci的状态为运行但无设备
     case UHCI_RH_RUNNING_NODEVS:
  /* auto-stop if nothing connected for 1 second */
  //检测是否有连接的设备
  if (any_ports_active(uhci))
   //改变uhci的状态为运行
   uhci->rh_state = UHCI_RH_RUNNING;
  //检测jiffies是否大于uhci->auto_stop_time
  else if (time_after_eq(jiffies, uhci->auto_stop_time))
   //悬挂主机控制器
   suspend_rh(uhci, UHCI_RH_AUTO_STOPPED);
  break;
     default:
  break;
 }
done:
 spin_unlock_irqrestore(&uhci->lock, flags);
 return status;
}


static void uhci_check_ports(struct uhci_hcd *uhci)
{
 unsigned int port;
 unsigned long port_addr;
 int status;
 //历遍根集线器的所有端口
 for (port = 0; port < uhci->rh_numports; ++port) 
 {
  //获取端口的地址
  port_addr = uhci->io_addr + USBPORTSC1 + 2 * port;
  //读取端口状态
  status = inw(port_addr);
  //判断端口是否为重置状态
  if (unlikely(status & USBPORTSC_PR)) 
  {
   //判断jiffies是否大于uhci->ports_timeout
   //也就是判断端口的复位信号是否足够长了
   if (time_after_eq(jiffies, uhci->ports_timeout)) 
   {
    //清除端口的复位状态,停止发送复位信号
    CLR_RH_PORTSTAT(USBPORTSC_PR);
    //延迟10微妙
    udelay(10);
    /* HP's server management chip requires
     * a longer delay. */
     //测试是否为惠普产品,惠普产品需要更长的延迟
    if (to_pci_dev(uhci_dev(uhci))->vendor == PCI_VENDOR_ID_HP)
     wait_for_HP(port_addr);
    /* If the port was enabled before, turning
     * reset on caused a port enable change.
     * Turning reset off causes a port connect
     * status change. Clear these changes. */
     //清除连接状态改变位和端点使能改变位
    CLR_RH_PORTSTAT(USBPORTSC_CSC | USBPORTSC_PEC);
    //设置端点使能位
    SET_RH_PORTSTAT(USBPORTSC_PE);
   }
  }
  //判断端口是否为探测恢复状态
  if (unlikely(status & USBPORTSC_RD)) 
  {
   //检测uhci的恢复位上对应端口的状态
   if (!test_bit(port, &uhci->resuming_ports))
   {
    /* Port received a wakeup request */
    //设置对应端口的恢复位
    set_bit(port, &uhci->resuming_ports);
    //为恢复延迟设定再检测时间
    uhci->ports_timeout = jiffies + msecs_to_jiffies(20);
    /* Make sure we see the port again
     * after the resuming period is over. */
    mod_timer(&uhci_to_hcd(uhci)->rh_timer,uhci->ports_timeout);
   } 
   else if (time_after_eq(jiffies,uhci->ports_timeout)) 
   {
    uhci_finish_suspend(uhci, port, port_addr);
   }
  }
 }
}


static inline int get_hub_status_data(struct uhci_hcd *uhci, char *buf)
{
 int port;
 //检测RWC的三个状态改变位
 int mask = RWC_BITS;
 /* Some boards (both VIA and Intel apparently) report bogus
  * overcurrent indications, causing massive log spam unless
  * we completely ignore them. This doesn't seem to be a problem
  * with the chipset so much as with the way it is connected on
  * the motherboard; if the overcurrent input is left to float
  * then it may constantly register false positives. */
 if (ignore_oc)
  mask &= ~USBPORTSC_OCC;
 *buf = 0;
 //历遍根集线器上的端口
 for (port = 0; port < uhci->rh_numports; ++port) 
 {
  //检测端口的状态改变位,或者端口悬挂位
  if ((inw(uhci->io_addr + USBPORTSC1 + port * 2) & mask) || test_bit(port,&uhci->port_c_suspend))
   //记录端口号
   *buf |= (1 << (port + 1));
 } 
 return !!*buf;
}