LINUX下USB1.1设备学习小记(4)_uhci(4)

static int register_root_hub(struct usb_hcd *hcd)
{
 struct device *parent_dev = hcd->self.controller;
 struct usb_device *usb_dev = hcd->self.root_hub;
 const int devnum = 1;
 int retval;
 //设置设备的设备号为1
 usb_dev->devnum = devnum;
 //uhci总线的设备计数器+1
 usb_dev->bus->devnum_next = devnum + 1;
 //初始化设备位表
 memset (&usb_dev->bus->devmap.devicemap, 0,sizeof usb_dev->bus->devmap.devicemap);
 //占用设备表的第1位
 set_bit (devnum, usb_dev->bus->devmap.devicemap);
 //设置设备状态为USB_STATE_ADDRESS
 usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
 mutex_lock(&usb_bus_list_lock);
 //设置端点0包的最大值
 usb_dev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);
 //取得设备描述符
 retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
 //检测返回的描述符大小和设备描述符的大小是否一致
 if (retval != sizeof usb_dev->descriptor)
 {
  mutex_unlock(&usb_bus_list_lock);
  
  dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
    usb_dev->dev.bus_id, retval);
  
  return (retval < 0) ? retval : -EMSGSIZE;
 }
 //建立设备
 retval = usb_new_device (usb_dev);
 if (retval)
 {
  dev_err (parent_dev, "can't register root hub for %s, %d\n",usb_dev->dev.bus_id, retval);
 }
 mutex_unlock(&usb_bus_list_lock);
 if (retval == 0)
 {
  spin_lock_irq (&hcd_root_hub_lock);
  //设置注册标识为1
  hcd->rh_registered = 1;
  spin_unlock_irq (&hcd_root_hub_lock);
  /* Did the HC die before the root hub was registered? */
  if (hcd->state == HC_STATE_HALT)
   usb_hc_died (hcd); /* This time clean up */
 }
 return retval;
}

int usb_get_device_descriptor(struct usb_device *dev, unsigned int size)
{
 struct usb_device_descriptor *desc;
 int ret;
 if (size > sizeof(*desc))
  return -EINVAL;
 //分配设备描述符所需要的空间
 desc = kmalloc(sizeof(*desc), GFP_NOIO);
 if (!desc)
  return -ENOMEM;
 //取得描述符,类型为设备
 ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, size);
 if (ret >= 0)
  //拷贝设备描述符到usb_device中
  memcpy(&dev->descriptor, desc, size);
 kfree(desc);
 return ret;
}

int usb_get_descriptor(struct usb_device *dev, unsigned char type,
         unsigned char index, void *buf, int size)
{
 int i;
 int result;
 //buf清0
 memset(buf, 0, size); /* Make sure we parse really received data */
 //重试3次
 for (i = 0; i < 3; ++i)
 {
  /* retry on length 0 or error; some devices are flakey */
  //发送控制消息
  result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
    USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
    (type << 8) + index, 0, buf, size,
    USB_CTRL_GET_TIMEOUT);
  if (result <= 0 && result != -ETIMEDOUT)
   continue;
  if (result > 1 && ((u8 *)buf)[1] != type)
  {
   result = -EPROTO;
   continue;
  }
  break;
 }
 return result;
}

int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
      __u8 requesttype, __u16 value, __u16 index, void *data,
      __u16 size, int timeout)
{
 struct usb_ctrlrequest *dr;
 int ret;
 //为控制请求结构分配空间
 dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
 if (!dr)
  return -ENOMEM;
 //组建8字节的控制请求字段
 dr->bRequestType = requesttype;
 dr->bRequest = request;
 dr->wValue = cpu_to_le16p(&value);
 dr->wIndex = cpu_to_le16p(&index);
 dr->wLength = cpu_to_le16p(&size);
 /* dbg("usb_control_msg"); */
 //发送控制消息
 ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout);
 kfree(dr);
 return ret;
}

static int usb_internal_control_msg(struct usb_device *usb_dev,
        unsigned int pipe,
        struct usb_ctrlrequest *cmd,
        void *data, int len, int timeout)
{
 struct urb *urb;
 int retv;
 int length;
 //取得一个初始化好的URB结构
 urb = usb_alloc_urb(0, GFP_NOIO);
 if (!urb)
  return -ENOMEM;
 //填充该URB结构
 usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char *)cmd, data,
        len, usb_api_blocking_completion, NULL);
 //发送它
 retv = usb_start_wait_urb(urb, timeout, &length);
 //检测错误标识
 if (retv < 0)
  //返回错误标识
  return retv;
 else
  //返回传输的数据长度
  return length;
}

static int usb_start_wait_urb(struct urb *urb, int timeout, int *actual_length)
{
 struct api_context ctx;
 unsigned long expire;
 int retval;
 init_completion(&ctx.done);
 urb->context = &ctx;
 urb->actual_length = 0;
 //发送URB
 retval = usb_submit_urb(urb, GFP_NOIO);
 //检测错误标识
 if (unlikely(retval))
  goto out;
 expire = timeout ? msecs_to_jiffies(timeout) : MAX_SCHEDULE_TIMEOUT;
 //等待urb的完成
 if (!wait_for_completion_timeout(&ctx.done, expire))
 {
  usb_kill_urb(urb);
  retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status);
  dev_dbg(&urb->dev->dev,
   "%s timed out on ep%d%s len=%d/%d\n",
   current->comm,
   usb_endpoint_num(&urb->ep->desc),
   usb_urb_dir_in(urb) ? "in" : "out",
   urb->actual_length,
   urb->transfer_buffer_length);
 }
 else
  retval = ctx.status;
out:
 if (actual_length)
  //取得实际传输数据的大小
  *actual_length = urb->actual_length;
 //释放urb结构
 usb_free_urb(urb);
 return retval;
}

int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
{
 int xfertype, max;
 struct usb_device *dev;
 struct usb_host_endpoint *ep;
 int is_out;
 //判断urb是否存在 
 //hcpriv私有数据是否存在 
 //完成函数是否存在
 if (!urb || urb->hcpriv || !urb->complete)
  return -EINVAL;
 //取得urb所关联的usb设备
 dev = urb->dev;
 //检测usb设备是否存在并且状态低于默认
 if ((!dev) || (dev->state < USB_STATE_DEFAULT))
  return -ENODEV;
 /* For now, get the endpoint from the pipe. Eventually drivers
  * will be required to set urb->ep directly and we will eliminate
  * urb->pipe.
  */
  //通过管道计算需要使用的usb设备端点号
 ep = (usb_pipein(urb->pipe) ? dev->ep_in : dev->ep_out)[usb_pipeendpoint(urb->pipe)];
 if (!ep)
  return -ENOENT;
 //关联urb与端点
 urb->ep = ep;
 //设置urb的状态
 urb->status = -EINPROGRESS;
 //初始化实际传送的空间大小
 urb->actual_length = 0;
 /* Lots of sanity checks, so HCDs can rely on clean data
  * and don't need to duplicate tests
  */
  //取得端点的传输类型
 xfertype = usb_endpoint_type(&ep->desc);
 //传输类型为控制信息
 if (xfertype == USB_ENDPOINT_XFER_CONTROL)
 {
  //取得控制请求结构
  struct usb_ctrlrequest *setup = (struct usb_ctrlrequest *) urb->setup_packet;
  //检测控制请求是否为空
  if (!setup)
   return -ENOEXEC;
  //检测请求类型的要求是否为传入
  is_out = !(setup->bRequestType & USB_DIR_IN) || !setup->wLength;
 }
 else
 {
  //检测端点的传输方向
  is_out = usb_endpoint_dir_out(&ep->desc);
 }
 /* Cache the direction for later use */
 urb->transfer_flags = (urb->transfer_flags & ~URB_DIR_MASK) | (is_out ? URB_DIR_OUT : URB_DIR_IN);
 //端点的传输类型不为控制,且设备的状态小于设置则返回出错
 if (xfertype != USB_ENDPOINT_XFER_CONTROL && dev->state < USB_STATE_CONFIGURED)
  return -ENODEV;
 //取得包的最大长度
 max = le16_to_cpu(ep->desc.wMaxPacketSize);
 //包的长度小于0则返回出错
 if (max <= 0)
 {
  dev_dbg(&dev->dev,
   "bogus endpoint ep%d%s in %s (bad maxpacket %d)\n",
   usb_endpoint_num(&ep->desc), is_out ? "out" : "in",
   __func__, max);
  return -EMSGSIZE;
 }
 /* periodic transfers limit size per frame/uframe,
  * but drivers only control those sizes for ISO.
  * while we're checking, initialize return status.
  */
  //判断传输类型是否为等时
 if (xfertype == USB_ENDPOINT_XFER_ISOC)
 {
  int n, len;
  /* "high bandwidth" mode, 1-3 packets/uframe? */
  if (dev->speed == USB_SPEED_HIGH)
  {
   int mult = 1 + ((max >> 11) & 0x03);
   max &= 0x07ff;
   max *= mult;
  }
  if (urb->number_of_packets <= 0)
   return -EINVAL;
  for (n = 0; n < urb->number_of_packets; n++)
  {
   len = urb->iso_frame_desc[n].length;
   if (len < 0 || len > max)
    return -EMSGSIZE;
   urb->iso_frame_desc[n].status = -EXDEV;
   urb->iso_frame_desc[n].actual_length = 0;
  }
 }
 /* the I/O buffer must be mapped/unmapped, except when length=0 */
 //检测需要传输的数据要求的大小,小于0则返回出错
 if (urb->transfer_buffer_length < 0)
  return -EMSGSIZE;
 /*
  * Force periodic transfer intervals to be legal values that are
  * a power of two (so HCDs don't need to).
  *
  * FIXME want bus->{intr,iso}_sched_horizon values here. Each HC
  * supports different values... this uses EHCI/UHCI defaults (and
  * EHCI can use smaller non-default values).
  */
  //判断传输类型
 switch (xfertype)
 {
 //等时传输
 case USB_ENDPOINT_XFER_ISOC:
 //中断传输
 case USB_ENDPOINT_XFER_INT:
  /* too small? */
  if (urb->interval <= 0)
   return -EINVAL;
  /* too big? */
  //判断传输速度
  switch (dev->speed)
  {
  //高速
  case USB_SPEED_HIGH: /* units are microframes */
   /* NOTE usb handles 2^15 */
   if (urb->interval > (1024 * 8))
    urb->interval = 1024 * 8;
   max = 1024 * 8;
   break;
  //全速
  case USB_SPEED_FULL: /* units are frames/msec */
  //低速
  case USB_SPEED_LOW:
   if (xfertype == USB_ENDPOINT_XFER_INT)
   {
    if (urb->interval > 255)
     return -EINVAL;
    /* NOTE ohci only handles up to 32 */
    max = 128;
   }
   else
   {
    if (urb->interval > 1024)
     urb->interval = 1024;
    /* NOTE usb and ohci handle up to 2^15 */
    max = 1024;
   }
   break;
  default:
   return -EINVAL;
  }
  /* Round down to a power of 2, no more than max */
  urb->interval = min(max, 1 << ilog2(urb->interval));
 }
 //发送urb
 return usb_hcd_submit_urb(urb, mem_flags);
}

int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
{
 int status;
 //取得host控制器驱动
 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.
  */
  //为urb建立DMA缓存
 status = map_urb_for_dma(hcd, urb, mem_flags);
 //检测映射是否成功
 if (unlikely(status))
 {
  usbmon_urb_submit_error(&hcd->self, urb, status);
  goto error;
 }
 //判断接收设备是否为根集线器
 if (is_root_hub(urb->dev))
  status = rh_urb_enqueue(hcd, urb);
 else
  status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
 //判断传输是否成功
 if (unlikely(status))
 {
  usbmon_urb_submit_error(&hcd->self, urb, status);
  unmap_urb_for_dma(hcd, urb);
 error:
  urb->hcpriv = NULL;
  INIT_LIST_HEAD(&urb->urb_list);
  atomic_dec(&urb->use_count);
  atomic_dec(&urb->dev->urbnum);
  if (urb->reject)
   wake_up(&usb_kill_urb_queue);
  usb_put_urb(urb);
 }
 //返回错误标识
 return status;
}

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

static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
{
 struct usb_ctrlrequest *cmd;
  u16 typeReq, wValue, wIndex, wLength;
 u8 *ubuf = urb->transfer_buffer;
 u8 tbuf [sizeof (struct usb_hub_descriptor)]
  __attribute__((aligned(4)));
 const u8 *bufp = tbuf;
 int len = 0;
 int status;
 int n;
 u8 patch_wakeup = 0;
 u8 patch_protocol = 0;
 might_sleep();
 spin_lock_irq(&hcd_root_hub_lock);
 //添加URB进端点队列
 status = usb_hcd_link_urb_to_ep(hcd, urb);
 spin_unlock_irq(&hcd_root_hub_lock);
 if (status)
  return status;
 //设置URB的私有信息为usb_hcd
 urb->hcpriv = hcd; /* Indicate it's queued */
 //取得控制请求结构
 cmd = (struct usb_ctrlrequest *) urb->setup_packet;
 typeReq = (cmd->bRequestType << 8) | cmd->bRequest;
 wValue = le16_to_cpu (cmd->wValue);
 wIndex = le16_to_cpu (cmd->wIndex);
 wLength = le16_to_cpu (cmd->wLength);
 if (wLength > urb->transfer_buffer_length)
  goto error;
 urb->actual_length = 0;
 //判断请求类型
 switch (typeReq)
 {
 /* DEVICE REQUESTS */
 /* The root hub's remote wakeup enable bit is implemented using
  * driver model wakeup flags. If this system supports wakeup
  * through USB, userspace may change the default "allow wakeup"
  * policy through sysfs or these calls.
  *
  * Most root hubs support wakeup from downstream devices, for
  * runtime power management (disabling USB clocks and reducing
  * VBUS power usage). However, not all of them do so; silicon,
  * board, and BIOS bugs here are not uncommon, so these can't
  * be treated quite like external hubs.
  *
  * Likewise, not all root hubs will pass wakeup events upstream,
  * to wake up the whole system. So don't assume root hub and
  * controller capabilities are identical.
  */
 //请求设备信息| 标准类型| 接收为设备,信息为取得状态
 case DeviceRequest | USB_REQ_GET_STATUS:
  tbuf [0] = (device_may_wakeup(&hcd->self.root_hub->dev)
     << USB_DEVICE_REMOTE_WAKEUP)
    | (1 << USB_DEVICE_SELF_POWERED);
  tbuf [1] = 0;
  len = 2;
  break;
 //设置设备信息| 标准类型| 接收为设备,信息为清除特征
 case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
  if (wValue == USB_DEVICE_REMOTE_WAKEUP)
   device_set_wakeup_enable(&hcd->self.root_hub->dev, 0);
  else
   goto error;
  break;
 //设置设备信息| 标准类型| 接收为设备,信息为设置特征
 case DeviceOutRequest | USB_REQ_SET_FEATURE:
  if (device_can_wakeup(&hcd->self.root_hub->dev) && wValue == USB_DEVICE_REMOTE_WAKEUP)
   device_set_wakeup_enable(&hcd->self.root_hub->dev, 1);
  else
   goto error;
  break;
 //请求设备信息| 标准类型| 接收为设备,信息为取得配置
 case DeviceRequest | USB_REQ_GET_CONFIGURATION:
  tbuf [0] = 1;
  len = 1;
   /* FALLTHROUGH */
 //设置设备信息| 标准类型| 接收为设备,信息为设置配置
 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
  break;
 //请求设备信息| 标准类型| 接收为设备,信息为取得描述符
 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
  switch (wValue & 0xff00)
  {
  //设备描述符
  case USB_DT_DEVICE << 8:
   if (hcd->driver->flags & HCD_USB2)
    bufp = usb2_rh_dev_descriptor;
   else if (hcd->driver->flags & HCD_USB11)
    bufp = usb11_rh_dev_descriptor;
   else
    goto error;
   len = 18;
   if (hcd->has_tt)
    patch_protocol = 1;
   break;
  //设置描述符
  case USB_DT_CONFIG << 8:
   if (hcd->driver->flags & HCD_USB2)
   {
    bufp = hs_rh_config_descriptor;
    len = sizeof hs_rh_config_descriptor;
   }
   else
   {
    bufp = fs_rh_config_descriptor;
    len = sizeof fs_rh_config_descriptor;
   }
   
   if (device_can_wakeup(&hcd->self.root_hub->dev))
    patch_wakeup = 1;
   break;
  //字符描述符
  case USB_DT_STRING << 8:
   n = rh_string (wValue & 0xff, hcd, ubuf, wLength);
   if (n < 0)
    goto error;
   urb->actual_length = n;
   break;
  default:
   goto error;
  }
  break;
 //请求设备信息| 标准类型| 接收为设备,信息为取得接口
 case DeviceRequest | USB_REQ_GET_INTERFACE:
  tbuf [0] = 0;
  len = 1;
   /* FALLTHROUGH */
 //设置设备信息| 标准类型| 接收为设备,信息为设置接口
 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
  break;
 //设置设备信息| 标准类型| 接收为设备,信息为设置地址
 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
  //wValue == urb->dev->devaddr
  dev_dbg (hcd->self.controller, "root hub device address %d\n",wValue);
  break;
 /* INTERFACE REQUESTS (no defined feature/status flags) */
 /* ENDPOINT REQUESTS */
 //请求端点信息| 标准类型| 接收为接口,信息为设置状态
 case EndpointRequest | USB_REQ_GET_STATUS:
  // ENDPOINT_HALT flag
  tbuf [0] = 0;
  tbuf [1] = 0;
  len = 2;
   /* FALLTHROUGH */
 //设置端点信息| 标准类型| 接收为接口,信息为清除特征
 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
 //设置端点信息| 标准类型| 接收为接口,信息为设置特征
 case EndpointOutRequest | USB_REQ_SET_FEATURE:
  dev_dbg (hcd->self.controller, "no endpoint features yet\n");
  break;
 /* CLASS REQUESTS (and errors) */
 //默认类型
 default:
  //非标准的请求
  /* non-generic request */
  switch (typeReq)
  {
  //取得集线器状态
  case GetHubStatus:
  //取得端口状态
  case GetPortStatus:
   len = 4;
   break;
  //取得集线器描述符
  case GetHubDescriptor:
   len = sizeof (struct usb_hub_descriptor);
   break;
  }
  //运行host控制器驱动的hub_control函数
  status = hcd->driver->hub_control (hcd,typeReq, wValue, wIndex,tbuf, wLength);
  break;
error:
  /* "protocol stall" on error */
  status = -EPIPE;
 }
 //检测错误描述符
 if (status)
 {
  //设置需要复制的长度为0
  len = 0;
  if (status != -EPIPE)
  {
   dev_dbg (hcd->self.controller,
    "CTRL: TypeReq=0x%x val=0x%x "
    "idx=0x%x len=%d ==> %d\n",
    typeReq, wValue, wIndex,
    wLength, status);
  }
 }
 //检测需要复制的大小
 if (len)
 {
  //检测需要传输的数据大小,小于len则以要传输的大小为准
  if (urb->transfer_buffer_length < len)
   len = urb->transfer_buffer_length;
  //设置实际传输的数据大小
  urb->actual_length = len;
  // always USB_DIR_IN, toward host
  //复制大小为len的bufp信息到ubuf中
  memcpy (ubuf, bufp, len);
  /* report whether RH hardware supports remote wakeup */
  if (patch_wakeup &&len > offsetof (struct usb_config_descriptor,bmAttributes))
   ((struct usb_config_descriptor *)ubuf)->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
  /* report whether RH hardware has an integrated TT */
  if (patch_protocol &&len > offsetof(struct usb_device_descriptor,bDeviceProtocol))
   ((struct usb_device_descriptor *) ubuf)->bDeviceProtocol = 1;
 }
 /* any errors get returned through the urb completion */
 spin_lock_irq(&hcd_root_hub_lock);
 //卸载urb与端点的连接
 usb_hcd_unlink_urb_from_ep(hcd, urb);
 /* This peculiar use of spinlocks echoes what real HC drivers do.
  * Avoiding calls to local_irq_disable/enable makes the code
  * RT-friendly.
  */
 spin_unlock(&hcd_root_hub_lock);
 //返回urb
 usb_hcd_giveback_urb(hcd, urb, status);
 spin_lock(&hcd_root_hub_lock);
 spin_unlock_irq(&hcd_root_hub_lock);
 return 0;
}

void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
{
 //卸载urb的私有数据
 urb->hcpriv = NULL;
 //检测urb的连接状态
 if (unlikely(urb->unlinked))
  status = urb->unlinked;
 else if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
   urb->actual_length < urb->transfer_buffer_length &&
   !status))
  status = -EREMOTEIO;
 //卸载urb的dma缓存映射
 unmap_urb_for_dma(hcd, urb);
 //usbmon_urb_complete(&hcd->self, urb, status);
 usb_unanchor_urb(urb);
 /* pass ownership to the completion handler */
 //设置urb的状态
 urb->status = status;
 //运行urb的完成函数
 urb->complete (urb);
 atomic_dec (&urb->use_count);
 if (unlikely (urb->reject))
  wake_up (&usb_kill_urb_queue);
 usb_put_urb (urb);
}

int usb_new_device(struct usb_device *udev)
{
 int err;
 //探测怪癖
 usb_detect_quirks(udev); /* Determine quirks */
 //取得设备设置
 err = usb_configure_device(udev); /* detect & probe dev/intfs */
 if (err < 0)
  goto fail;
 /* export the usbdev device-node for libusb */
 //获取设备号
 udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
 /* Increment the parent's count of unsuspended children */
 if (udev->parent)
  usb_autoresume_device(udev->parent);
 /* Register the device. The device driver is responsible
  * for adding the device files to sysfs and for configuring
  * the device.
  */
  //注册设备到sysfs中
 err = device_add(&udev->dev);
 
 if (err)
 {
  dev_err(&udev->dev, "can't device_add, error %d\n", err);
  goto fail;
 }
 /* put device-specific files into sysfs */
 //建立USB设备的属性文件
 usb_create_sysfs_dev_files(udev);
 /* Tell the world! */
 //输出设备信息
 announce_device(udev);
 return err;
fail:
 usb_set_device_state(udev, USB_STATE_NOTATTACHED);
 return err;
};

static int usb_configure_device(struct usb_device *udev)
{
 int err;
 if (udev->config == NULL)
 {
  //取得设置
  err = usb_get_configuration(udev);
  if (err < 0)
  {
   dev_err(&udev->dev, "can't read configurations, error %d\n",err);
   goto fail;
  }
 }
 if (udev->wusb == 1 && udev->authorized == 0)
 {
  udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
  udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
  udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
 }
 else
 {
  /* read the standard strings and cache them if present */
  //设置产品信息
  udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
  //设置厂商信息
  udev->manufacturer = usb_cache_string(udev,udev->descriptor.iManufacturer);
  //取得设备的串口号码
  udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
 }
 err = usb_configure_device_otg(udev);
fail:
 return err;
}