void uvc_function_disconnect(struct uvc_device *uvc) { struct usb_composite_dev *cdev = uvc->func.config->cdev; int ret; if ((ret = usb_function_deactivate(&uvc->func)) < 0) INFO(cdev, "UVC disconnect failed with %d\n", ret); }
static int __init uvc_function_bind(struct usb_configuration *c, struct usb_function *f) { struct usb_composite_dev *cdev = c->cdev; struct uvc_device *uvc = to_uvc(f); unsigned int max_packet_mult; unsigned int max_packet_size; struct usb_ep *ep; int ret = -EINVAL; INFO(cdev, "uvc_function_bind\n"); /* Sanity check the streaming endpoint module parameters. */ streaming_interval = clamp(streaming_interval, 1U, 16U); streaming_maxpacket = clamp(streaming_maxpacket, 1U, 3072U); streaming_maxburst = min(streaming_maxburst, 15U); /* Fill in the FS/HS/SS Video Streaming specific descriptors from the * module parameters. * * NOTE: We assume that the user knows what they are doing and won't * give parameters that their UDC doesn't support. */ if (streaming_maxpacket <= 1024) { max_packet_mult = 1; max_packet_size = streaming_maxpacket; } else if (streaming_maxpacket <= 2048) { max_packet_mult = 2; max_packet_size = streaming_maxpacket / 2; } else { max_packet_mult = 3; max_packet_size = streaming_maxpacket / 3; } uvc_fs_streaming_ep.wMaxPacketSize = min(streaming_maxpacket, 1023U); uvc_fs_streaming_ep.bInterval = streaming_interval; uvc_hs_streaming_ep.wMaxPacketSize = max_packet_size; uvc_hs_streaming_ep.wMaxPacketSize |= ((max_packet_mult - 1) << 11); uvc_hs_streaming_ep.bInterval = streaming_interval; uvc_ss_streaming_ep.wMaxPacketSize = max_packet_size; uvc_ss_streaming_ep.bInterval = streaming_interval; uvc_ss_streaming_comp.bmAttributes = max_packet_mult - 1; uvc_ss_streaming_comp.bMaxBurst = streaming_maxburst; uvc_ss_streaming_comp.wBytesPerInterval = max_packet_size * max_packet_mult * streaming_maxburst; /* Allocate endpoints. */ ep = usb_ep_autoconfig(cdev->gadget, &uvc_control_ep); if (!ep) { INFO(cdev, "Unable to allocate control EP\n"); goto error; } uvc->control_ep = ep; ep->driver_data = uvc; if (gadget_is_superspeed(c->cdev->gadget)) ep = usb_ep_autoconfig_ss(cdev->gadget, &uvc_ss_streaming_ep, &uvc_ss_streaming_comp); else if (gadget_is_dualspeed(cdev->gadget)) ep = usb_ep_autoconfig(cdev->gadget, &uvc_hs_streaming_ep); else ep = usb_ep_autoconfig(cdev->gadget, &uvc_fs_streaming_ep); if (!ep) { INFO(cdev, "Unable to allocate streaming EP\n"); goto error; } uvc->video.ep = ep; ep->driver_data = uvc; uvc_fs_streaming_ep.bEndpointAddress = uvc->video.ep->address; uvc_hs_streaming_ep.bEndpointAddress = uvc->video.ep->address; uvc_ss_streaming_ep.bEndpointAddress = uvc->video.ep->address; /* Allocate interface IDs. */ if ((ret = usb_interface_id(c, f)) < 0) goto error; uvc_iad.bFirstInterface = ret; uvc_control_intf.bInterfaceNumber = ret; uvc->control_intf = ret; if ((ret = usb_interface_id(c, f)) < 0) goto error; uvc_streaming_intf_alt0.bInterfaceNumber = ret; uvc_streaming_intf_alt1.bInterfaceNumber = ret; uvc->streaming_intf = ret; /* Copy descriptors */ f->fs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_FULL); if (gadget_is_dualspeed(cdev->gadget)) f->hs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_HIGH); if (gadget_is_superspeed(c->cdev->gadget)) f->ss_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_SUPER); /* Preallocate control endpoint request. */ uvc->control_req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL); uvc->control_buf = kmalloc(UVC_MAX_REQUEST_SIZE, GFP_KERNEL); if (uvc->control_req == NULL || uvc->control_buf == NULL) { ret = -ENOMEM; goto error; } uvc->control_req->buf = uvc->control_buf; uvc->control_req->complete = uvc_function_ep0_complete; uvc->control_req->context = uvc; /* Avoid letting this gadget enumerate until the userspace server is * active. */ if ((ret = usb_function_deactivate(f)) < 0) goto error; if (v4l2_device_register(&cdev->gadget->dev, &uvc->v4l2_dev)) { printk(KERN_INFO "v4l2_device_register failed\n"); goto error; } /* Initialise video. */ ret = uvc_video_init(&uvc->video); if (ret < 0) goto error; /* Register a V4L2 device. */ ret = uvc_register_video(uvc); if (ret < 0) { printk(KERN_INFO "Unable to register video device\n"); goto error; } return 0; error: v4l2_device_unregister(&uvc->v4l2_dev); if (uvc->vdev) video_device_release(uvc->vdev); if (uvc->control_ep) uvc->control_ep->driver_data = NULL; if (uvc->video.ep) uvc->video.ep->driver_data = NULL; if (uvc->control_req) { usb_ep_free_request(cdev->gadget->ep0, uvc->control_req); kfree(uvc->control_buf); } usb_free_all_descriptors(f); return ret; }
static int __init uvc_function_bind(struct usb_configuration *c, struct usb_function *f) { struct usb_composite_dev *cdev = c->cdev; struct uvc_device *uvc = to_uvc(f); struct usb_ep *ep; int ret = -EINVAL; INFO(cdev, "uvc_function_bind\n"); /* Allocate endpoints. */ ep = usb_ep_autoconfig(cdev->gadget, &uvc_control_ep); if (!ep) { INFO(cdev, "Unable to allocate control EP\n"); goto error; } uvc->control_ep = ep; ep->driver_data = uvc; ep = usb_ep_autoconfig(cdev->gadget, &uvc_streaming_ep); if (!ep) { INFO(cdev, "Unable to allocate streaming EP\n"); goto error; } uvc->video.ep = ep; ep->driver_data = uvc; /* Allocate interface IDs. */ if ((ret = usb_interface_id(c, f)) < 0) goto error; uvc_iad.bFirstInterface = ret; uvc_control_intf.bInterfaceNumber = ret; uvc->control_intf = ret; if ((ret = usb_interface_id(c, f)) < 0) goto error; uvc_streaming_intf_alt0.bInterfaceNumber = ret; uvc_streaming_intf_alt1.bInterfaceNumber = ret; uvc->streaming_intf = ret; /* Copy descriptors. */ f->descriptors = uvc_copy_descriptors(uvc, USB_SPEED_FULL); f->hs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_HIGH); /* Preallocate control endpoint request. */ uvc->control_req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL); uvc->control_buf = kmalloc(UVC_MAX_REQUEST_SIZE, GFP_KERNEL); if (uvc->control_req == NULL || uvc->control_buf == NULL) { ret = -ENOMEM; goto error; } uvc->control_req->buf = uvc->control_buf; uvc->control_req->complete = uvc_function_ep0_complete; uvc->control_req->context = uvc; /* Avoid letting this gadget enumerate until the userspace server is * active. */ if ((ret = usb_function_deactivate(f)) < 0) goto error; /* Initialise video. */ ret = uvc_video_init(&uvc->video); if (ret < 0) goto error; /* Register a V4L2 device. */ ret = uvc_register_video(uvc); if (ret < 0) { printk(KERN_INFO "Unable to register video device\n"); goto error; } return 0; error: uvc_function_unbind(c, f); return ret; }
static int __init uvc_function_bind(struct usb_configuration *c, struct usb_function *f) { struct usb_composite_dev *cdev = c->cdev; struct uvc_device *uvc = to_uvc(f); struct usb_ep *ep; int ret = -EINVAL; INFO(cdev, "uvc_function_bind\n"); /* sanity check the streaming endpoint module parameters */ if (streaming_interval < 1) streaming_interval = 1; if (streaming_interval > 16) streaming_interval = 16; if (streaming_mult > 2) streaming_mult = 2; if (streaming_maxburst > 15) streaming_maxburst = 15; /* * fill in the FS video streaming specific descriptors from the * module parameters */ uvc_fs_streaming_ep.wMaxPacketSize = streaming_maxpacket > 1023 ? 1023 : streaming_maxpacket; uvc_fs_streaming_ep.bInterval = streaming_interval; /* Allocate endpoints. */ ep = usb_ep_autoconfig(cdev->gadget, &uvc_fs_control_ep); if (!ep) { INFO(cdev, "Unable to allocate control EP\n"); goto error; } uvc->control_ep = ep; ep->driver_data = uvc; ep = usb_ep_autoconfig(cdev->gadget, &uvc_fs_streaming_ep); if (!ep) { INFO(cdev, "Unable to allocate streaming EP\n"); goto error; } uvc->video.ep = ep; ep->driver_data = uvc; /* Allocate interface IDs. */ if ((ret = usb_interface_id(c, f)) < 0) goto error; uvc_iad.bFirstInterface = ret; uvc_control_intf.bInterfaceNumber = ret; uvc->control_intf = ret; if ((ret = usb_interface_id(c, f)) < 0) goto error; uvc_streaming_intf_alt0.bInterfaceNumber = ret; uvc_streaming_intf_alt1.bInterfaceNumber = ret; uvc->streaming_intf = ret; /* sanity check the streaming endpoint module parameters */ if (streaming_maxpacket > 1024) streaming_maxpacket = 1024; /* Copy descriptors for FS. */ f->descriptors = uvc_copy_descriptors(uvc, USB_SPEED_FULL); /* support high speed hardware */ if (gadget_is_dualspeed(cdev->gadget)) { /* * Fill in the HS descriptors from the module parameters for the * Video Streaming endpoint. * NOTE: We assume that the user knows what they are doing and * won't give parameters that their UDC doesn't support. */ uvc_hs_streaming_ep.wMaxPacketSize = streaming_maxpacket; uvc_hs_streaming_ep.wMaxPacketSize |= streaming_mult << 11; uvc_hs_streaming_ep.bInterval = streaming_interval; uvc_hs_streaming_ep.bEndpointAddress = uvc_fs_streaming_ep.bEndpointAddress; /* Copy descriptors. */ f->hs_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_HIGH); } /* support super speed hardware */ if (gadget_is_superspeed(c->cdev->gadget)) { /* * Fill in the SS descriptors from the module parameters for the * Video Streaming endpoint. * NOTE: We assume that the user knows what they are doing and * won't give parameters that their UDC doesn't support. */ uvc_ss_streaming_ep.wMaxPacketSize = streaming_maxpacket; uvc_ss_streaming_ep.bInterval = streaming_interval; uvc_ss_streaming_comp.bmAttributes = streaming_mult; uvc_ss_streaming_comp.bMaxBurst = streaming_maxburst; uvc_ss_streaming_comp.wBytesPerInterval = streaming_maxpacket * (streaming_mult + 1) * (streaming_maxburst + 1); uvc_ss_streaming_ep.bEndpointAddress = uvc_fs_streaming_ep.bEndpointAddress; /* Copy descriptors. */ f->ss_descriptors = uvc_copy_descriptors(uvc, USB_SPEED_SUPER); } /* Preallocate control endpoint request. */ uvc->control_req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL); uvc->control_buf = kmalloc(UVC_MAX_REQUEST_SIZE, GFP_KERNEL); if (uvc->control_req == NULL || uvc->control_buf == NULL) { ret = -ENOMEM; goto error; } uvc->control_req->buf = uvc->control_buf; uvc->control_req->complete = uvc_function_ep0_complete; uvc->control_req->context = uvc; /* Avoid letting this gadget enumerate until the userspace server is * active. */ if ((ret = usb_function_deactivate(f)) < 0) goto error; /* Initialise video. */ ret = uvc_video_init(&uvc->video); if (ret < 0) goto error; /* Register a V4L2 device. */ ret = uvc_register_video(uvc); if (ret < 0) { printk(KERN_INFO "Unable to register video device\n"); goto error; } return 0; error: uvc_function_unbind(c, f); return ret; }