static struct usb_interface_descriptor uvc_streaming_intf_alt0 = {
 .bLength  = USB_DT_INTERFACE_SIZE,
 .bDescriptorType = USB_DT_INTERFACE,
 .bInterfaceNumber = UVC_INTF_VIDEO_STREAMING,
 .bAlternateSetting = 0,
 .bNumEndpoints  = 1,            /* alt0 挂一个bulk 端点*/
 .bInterfaceClass = USB_CLASS_VIDEO,
 .bInterfaceSubClass = UVC_SC_VIDEOSTREAMING,
 .bInterfaceProtocol = 0x00,
 .iInterface  = 0,
};

static struct usb_endpoint_descriptor uvc_hs_streaming_ep = {
 .bLength  = USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bEndpointAddress = USB_DIR_IN,
 .bmAttributes  = USB_ENDPOINT_XFER_BULK,
    .wMaxPacketSize = 512,
    .bInterval = 0,
};

static int uvc_start_streaming(struct vb2_queue *vq, unsigned int count)
{
 struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
 struct uvc_streaming *stream = uvc_queue_to_stream(queue);
 unsigned long flags;
 int ret;
 queue->buf_used = 0;
 ret = uvc_video_enable(stream, 1);
 if (ret == 0)
  return 0;
 spin_lock_irqsave(&queue->irqlock, flags);
 uvc_queue_return_buffers(queue, UVC_BUF_STATE_QUEUED);
 spin_unlock_irqrestore(&queue->irqlock, flags);
 return ret;
}

static void uvc_stop_streaming(struct vb2_queue *vq)
{
 struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
 struct uvc_streaming *stream = uvc_queue_to_stream(queue);
 unsigned long flags;
 uvc_video_enable(stream, 0);
 spin_lock_irqsave(&queue->irqlock, flags);
 uvc_queue_return_buffers(queue, UVC_BUF_STATE_ERROR);
 spin_unlock_irqrestore(&queue->irqlock, flags);
}

/*
 * Enable or disable the video stream.
 */
int uvc_video_enable(struct uvc_streaming *stream, int enable)
{
 int ret;
 if (!enable) {
  uvc_uninit_video(stream, 1);
  if (stream->intf->num_altsetting > 1) {
   usb_set_interface(stream->dev->udev,
       stream->intfnum, 0);
  } else {
   /* UVC doesn't specify how to inform a bulk-based device
    * when the video stream is stopped. Windows sends a
    * CLEAR_FEATURE(HALT) request to the video streaming
    * bulk endpoint, mimic the same behaviour.
    */
   unsigned int epnum = stream->header.bEndpointAddress
        & USB_ENDPOINT_NUMBER_MASK;
   unsigned int dir = stream->header.bEndpointAddress
      & USB_ENDPOINT_DIR_MASK;
   unsigned int pipe;
   pipe = usb_sndbulkpipe(stream->dev->udev, epnum) | dir;
   usb_clear_halt(stream->dev->udev, pipe);
  }
  uvc_video_clock_cleanup(stream);
  return 0;
 }
 ret = uvc_video_clock_init(stream);
 if (ret < 0)
  return ret;
 /* Commit the streaming parameters. */
 ret = uvc_commit_video(stream, &stream->ctrl);
 if (ret < 0)
  goto error_commit;
 ret = uvc_init_video(stream, GFP_KERNEL);
 if (ret < 0)
  goto error_video;
 return 0;
error_video:
 usb_set_interface(stream->dev->udev, stream->intfnum, 0);
error_commit:
 uvc_video_clock_cleanup(stream);
 return ret;
}

/*
 * Initialize isochronous/bulk URBs and allocate transfer buffers.
 */
static int uvc_init_video(struct uvc_streaming *stream, gfp_t gfp_flags)
{
 struct usb_interface *intf = stream->intf;
 struct usb_host_endpoint *ep;
 unsigned int i;
 int ret;
 stream->sequence = -1;
 stream->last_fid = -1;
 stream->bulk.header_size = 0;
 stream->bulk.skip_payload = 0;
 stream->bulk.payload_size = 0;
 uvc_video_stats_start(stream);
 if (intf->num_altsetting > 1) {
  struct usb_host_endpoint *best_ep = NULL;
  unsigned int best_psize = UINT_MAX;
  unsigned int bandwidth;
  unsigned int uninitialized_var(altsetting);
  int intfnum = stream->intfnum;
  /* Isochronous endpoint, select the alternate setting. */
  bandwidth = stream->ctrl.dwMaxPayloadTransferSize;
  if (bandwidth == 0) {
   uvc_trace(UVC_TRACE_VIDEO, "Device requested null "
    "bandwidth, defaulting to lowest.\n");
   bandwidth = 1;
  } else {
   uvc_trace(UVC_TRACE_VIDEO, "Device requested %u "
    "B/frame bandwidth.\n", bandwidth);
  }
  for (i = 0; i < intf->num_altsetting; ++i) {
   struct usb_host_interface *alts;
   unsigned int psize;
   alts = &intf->altsetting[i];
   ep = uvc_find_endpoint(alts,
    stream->header.bEndpointAddress);
   if (ep == NULL)
    continue;
   /* Check if the bandwidth is high enough. */
   psize = uvc_endpoint_max_bpi(stream->dev->udev, ep);
   if (psize >= bandwidth && psize <= best_psize) {
    altsetting = alts->desc.bAlternateSetting;
    best_psize = psize;
    best_ep = ep;
   }
  }
  if (best_ep == NULL) {
   uvc_trace(UVC_TRACE_VIDEO, "No fast enough alt setting "
    "for requested bandwidth.\n");
   return -EIO;
  }
  uvc_trace(UVC_TRACE_VIDEO, "Selecting alternate setting %u "
   "(%u B/frame bandwidth).\n", altsetting, best_psize);
  ret = usb_set_interface(stream->dev->udev, intfnum, altsetting);
  if (ret < 0)
   return ret;
  ret = uvc_init_video_isoc(stream, best_ep, gfp_flags);
 } else {
  /* Bulk endpoint, proceed to URB initialization. */
  ep = uvc_find_endpoint(&intf->altsetting[0],
    stream->header.bEndpointAddress);
  if (ep == NULL)
   return -EIO;
  /* Reject broken descriptors. */
  if (usb_endpoint_maxp(&ep->desc) == 0)
   return -EIO;
  ret = uvc_init_video_bulk(stream, ep, gfp_flags);
 }
 if (ret < 0)
  return ret;
 /* Submit the URBs. */
 for (i = 0; i < UVC_URBS; ++i) {
  ret = usb_submit_urb(stream->urb[i], gfp_flags);
  if (ret < 0) {
   uvc_printk(KERN_ERR, "Failed to submit URB %u "
     "(%d).\n", i, ret);
   uvc_uninit_video(stream, 1);
   return ret;
  }
 }
 /* The Logitech C920 temporarily forgets that it should not be adjusting
  * Exposure Absolute during init so restore controls to stored values.
  */
 if (stream->dev->quirks & UVC_QUIRK_RESTORE_CTRLS_ON_INIT)
  uvc_ctrl_restore_values(stream->dev);
 return 0;
}