static int midi_bind(struct usb_composite_dev *cdev) { struct f_midi_opts *midi_opts; int status; fi_midi = usb_get_function_instance("midi"); if (IS_ERR(fi_midi)) return PTR_ERR(fi_midi); midi_opts = container_of(fi_midi, struct f_midi_opts, func_inst); midi_opts->index = index; midi_opts->id = id; midi_opts->in_ports = in_ports; midi_opts->out_ports = out_ports; midi_opts->buflen = buflen; midi_opts->qlen = qlen; status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto put; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; midi_config.iConfiguration = strings_dev[STRING_DESCRIPTION_IDX].id; status = usb_add_config(cdev, &midi_config, midi_bind_config); if (status < 0) goto put; usb_composite_overwrite_options(cdev, &coverwrite); pr_info("%s\n", longname); return 0; put: usb_put_function_instance(fi_midi); return status; }
static int __init gncm_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; int status; /* set up network link layer */ the_dev = gether_setup(cdev->gadget, hostaddr); if (IS_ERR(the_dev)) return PTR_ERR(the_dev); /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; status = usb_add_config(cdev, &ncm_config_driver, ncm_do_config); if (status < 0) goto fail; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&gadget->dev, "%s\n", DRIVER_DESC); return 0; fail: gether_cleanup(the_dev); return status; }
static int __init webcam_bind(struct usb_composite_dev *cdev) { int ret; /* Allocate string descriptor numbers ... note that string contents * can be overridden by the composite_dev glue. */ ret = usb_string_ids_tab(cdev, webcam_strings); if (ret < 0) goto error; webcam_device_descriptor.iManufacturer = webcam_strings[USB_GADGET_MANUFACTURER_IDX].id; webcam_device_descriptor.iProduct = webcam_strings[USB_GADGET_PRODUCT_IDX].id; webcam_config_driver.iConfiguration = webcam_strings[STRING_DESCRIPTION_IDX].id; /* Register our configuration. */ if ((ret = usb_add_config(cdev, &webcam_config_driver, webcam_config_bind)) < 0) goto error; usb_composite_overwrite_options(cdev, &coverwrite); INFO(cdev, "Webcam Video Gadget\n"); return 0; error: webcam_unbind(cdev); return ret; }
static int __init gs_bind(struct usb_composite_dev *cdev) { int status; struct usb_gadget *gadget = cdev->gadget; /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ if (gadget->vendor_id && gadget->product_id) { device_desc.idVendor = cpu_to_le16(gadget->vendor_id); device_desc.idProduct = cpu_to_le16(gadget->product_id); } else { device_desc.idVendor = cpu_to_le16(GS_VENDOR_ID); if (use_acm) device_desc.idProduct = cpu_to_le16(GS_CDC_PRODUCT_ID); else device_desc.idProduct = cpu_to_le16(GS_PRODUCT_ID); } strings_dev[USB_GADGET_MANUFACTURER_IDX].s = gadget->manufacturer; strings_dev[USB_GADGET_PRODUCT_IDX].s = gadget->productname; status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; status = strings_dev[STRING_DESCRIPTION_IDX].id; serial_config_driver.iConfiguration = status; if (gadget_is_otg(cdev->gadget)) { serial_config_driver.descriptors = otg_desc; serial_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; } /* register our configuration */ if (use_acm) { status = serial_register_ports(cdev, &serial_config_driver, "acm"); usb_ep_autoconfig_reset(cdev->gadget); } else if (use_obex) status = serial_register_ports(cdev, &serial_config_driver, "obex"); else { status = serial_register_ports(cdev, &serial_config_driver, "gser"); } if (status < 0) goto fail; usb_composite_overwrite_options(cdev, &coverwrite); INFO(cdev, "%s\n", GS_VERSION_NAME); return 0; fail: return status; }
static int gs_bind(struct usb_composite_dev *cdev) { int status; /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; status = strings_dev[STRING_DESCRIPTION_IDX].id; serial_config_driver.iConfiguration = status; if (gadget_is_otg(cdev->gadget)) { if (!otg_desc[0]) { struct usb_descriptor_header *usb_desc; usb_desc = usb_otg_descriptor_alloc(cdev->gadget); if (!usb_desc) { status = -ENOMEM; goto fail; } usb_otg_descriptor_init(cdev->gadget, usb_desc); otg_desc[0] = usb_desc; otg_desc[1] = NULL; } serial_config_driver.descriptors = otg_desc; serial_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; } /* register our configuration */ if (use_acm) { status = serial_register_ports(cdev, &serial_config_driver, "acm"); usb_ep_autoconfig_reset(cdev->gadget); } else if (use_obex) status = serial_register_ports(cdev, &serial_config_driver, "obex"); else { status = serial_register_ports(cdev, &serial_config_driver, "gser"); } if (status < 0) goto fail1; usb_composite_overwrite_options(cdev, &coverwrite); INFO(cdev, "%s\n", GS_VERSION_NAME); return 0; fail1: kfree(otg_desc[0]); otg_desc[0] = NULL; fail: return status; }
static int __init cdc_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; struct f_ecm_opts *ecm_opts; int status; if (!can_support_ecm(cdev->gadget)) { dev_err(&gadget->dev, "controller '%s' not usable\n", gadget->name); return -EINVAL; } fi_ecm = usb_get_function_instance("ecm"); if (IS_ERR(fi_ecm)) return PTR_ERR(fi_ecm); ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst); gether_set_qmult(ecm_opts->net, qmult); if (!gether_set_host_addr(ecm_opts->net, host_addr)) pr_info("using host ethernet address: %s", host_addr); if (!gether_set_dev_addr(ecm_opts->net, dev_addr)) pr_info("using self ethernet address: %s", dev_addr); fi_serial = usb_get_function_instance("acm"); if (IS_ERR(fi_serial)) { status = PTR_ERR(fi_serial); goto fail; } /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail1; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; /* register our configuration */ status = usb_add_config(cdev, &cdc_config_driver, cdc_do_config); if (status < 0) goto fail1; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC); return 0; fail1: usb_put_function_instance(fi_serial); fail: usb_put_function_instance(fi_ecm); return status; }
static int __init cdc_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; int status; if (!can_support_ecm(cdev->gadget)) { dev_err(&gadget->dev, "controller '%s' not usable\n", gadget->name); return -EINVAL; } /* set up network link layer */ status = gether_setup(cdev->gadget, hostaddr); if (status < 0) return status; /* set up serial link layer */ status = gserial_setup(cdev->gadget, 1); if (status < 0) goto fail0; /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail1; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; /* register our configuration */ status = usb_add_config(cdev, &cdc_config_driver, cdc_do_config); if (status < 0) goto fail1; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC); return 0; fail1: gserial_cleanup(); fail0: gether_cleanup(); return status; }
static int __init acm_ms_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; int status; void *retp; /* set up serial link layer */ status = gserial_alloc_line(&tty_line); if (status < 0) return status; /* set up mass storage function */ retp = fsg_common_from_params(&fsg_common, cdev, &fsg_mod_data); if (IS_ERR(retp)) { status = PTR_ERR(retp); goto fail0; } /* * Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail1; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; /* register our configuration */ status = usb_add_config(cdev, &acm_ms_config_driver, acm_ms_do_config); if (status < 0) goto fail1; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC); fsg_common_put(&fsg_common); return 0; /* error recovery */ fail1: fsg_common_put(&fsg_common); fail0: gserial_free_line(tty_line); return status; }
static int __init msg_bind(struct usb_composite_dev *cdev) { int status; status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) return status; msg_device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; status = usb_add_config(cdev, &msg_config_driver, msg_do_config); if (status < 0) return status; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&cdev->gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n"); set_bit(0, &msg_registered); return 0; }
static int __init midi_bind(struct usb_composite_dev *cdev) { int status; status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) return status; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; midi_config.iConfiguration = strings_dev[STRING_DESCRIPTION_IDX].id; status = usb_add_config(cdev, &midi_config, midi_bind_config); if (status < 0) return status; usb_composite_overwrite_options(cdev, &coverwrite); pr_info("%s\n", longname); return 0; }
static int __init gncm_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; struct f_ncm_opts *ncm_opts; int status; f_ncm_inst = usb_get_function_instance("ncm"); if (IS_ERR(f_ncm_inst)) return PTR_ERR(f_ncm_inst); ncm_opts = container_of(f_ncm_inst, struct f_ncm_opts, func_inst); gether_set_qmult(ncm_opts->net, qmult); if (!gether_set_host_addr(ncm_opts->net, host_addr)) pr_info("using host ethernet address: %s", host_addr); if (!gether_set_dev_addr(ncm_opts->net, dev_addr)) pr_info("using self ethernet address: %s", dev_addr); /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; status = usb_add_config(cdev, &ncm_config_driver, ncm_do_config); if (status < 0) goto fail; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&gadget->dev, "%s\n", DRIVER_DESC); return 0; fail: usb_put_function_instance(f_ncm_inst); return status; }
static int __init audio_bind(struct usb_composite_dev *cdev) { int status; status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; status = usb_add_config(cdev, &audio_config_driver, audio_do_config); if (status < 0) goto fail; usb_composite_overwrite_options(cdev, &coverwrite); INFO(cdev, "%s, version: %s\n", DRIVER_DESC, DRIVER_VERSION); return 0; fail: return status; }
static int usb_target_bind(struct usb_composite_dev *cdev) { int ret; ret = usb_string_ids_tab(cdev, usbg_us_strings); if (ret) return ret; usbg_device_desc.iManufacturer = usbg_us_strings[USB_GADGET_MANUFACTURER_IDX].id; usbg_device_desc.iProduct = usbg_us_strings[USB_GADGET_PRODUCT_IDX].id; usbg_device_desc.iSerialNumber = usbg_us_strings[USB_GADGET_SERIAL_IDX].id; usbg_config_driver.iConfiguration = usbg_us_strings[USB_G_STR_CONFIG].id; ret = usb_add_config(cdev, &usbg_config_driver, tcm_do_config); if (ret) return ret; usb_composite_overwrite_options(cdev, &coverwrite); return 0; }
static int __ref multi_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; int status, gcnum; if (!can_support_ecm(cdev->gadget)) { dev_err(&gadget->dev, "controller '%s' not usable\n", gadget->name); return -EINVAL; } /* set up network link layer */ status = gether_setup(cdev->gadget, hostaddr); if (status < 0) return status; /* set up serial link layer */ status = gserial_setup(cdev->gadget, 1); if (status < 0) goto fail0; /* set up mass storage function */ { void *retp; retp = fsg_common_from_params(&fsg_common, cdev, &fsg_mod_data); if (IS_ERR(retp)) { status = PTR_ERR(retp); goto fail1; } } /* set bcdDevice */ gcnum = usb_gadget_controller_number(gadget); if (gcnum >= 0) { device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum); } else { WARNING(cdev, "controller '%s' not recognized\n", gadget->name); device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099); } /* allocate string descriptor numbers */ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", init_utsname()->sysname, init_utsname()->release, gadget->name); status = usb_string_ids_tab(cdev, strings_dev); if (unlikely(status < 0)) goto fail2; device_desc.iManufacturer = strings_dev[MULTI_STRING_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[MULTI_STRING_PRODUCT_IDX].id; /* register configurations */ status = rndis_config_register(cdev); if (unlikely(status < 0)) goto fail2; status = cdc_config_register(cdev); if (unlikely(status < 0)) goto fail2; /* we're done */ dev_info(&gadget->dev, DRIVER_DESC "\n"); fsg_common_put(&fsg_common); return 0; /* error recovery */ fail2: fsg_common_put(&fsg_common); fail1: gserial_cleanup(); fail0: gether_cleanup(); return status; }
/** * uvc_bind_config - add a UVC function to a configuration * @c: the configuration to support the UVC instance * Context: single threaded during gadget setup * * Returns zero on success, else negative errno. * * Caller must have called @uvc_setup(). Caller is also responsible for * calling @uvc_cleanup() before module unload. */ int __init uvc_bind_config(struct usb_configuration *c, const struct uvc_descriptor_header * const *fs_control, const struct uvc_descriptor_header * const *ss_control, const struct uvc_descriptor_header * const *fs_streaming, const struct uvc_descriptor_header * const *hs_streaming, const struct uvc_descriptor_header * const *ss_streaming) { struct uvc_device *uvc; int ret = 0; /* TODO Check if the USB device controller supports the required * features. */ if (!gadget_is_dualspeed(c->cdev->gadget)) return -EINVAL; uvc = kzalloc(sizeof(*uvc), GFP_KERNEL); if (uvc == NULL) return -ENOMEM; uvc->state = UVC_STATE_DISCONNECTED; /* Validate the descriptors. */ if (fs_control == NULL || fs_control[0] == NULL || fs_control[0]->bDescriptorSubType != UVC_VC_HEADER) goto error; if (ss_control == NULL || ss_control[0] == NULL || ss_control[0]->bDescriptorSubType != UVC_VC_HEADER) goto error; if (fs_streaming == NULL || fs_streaming[0] == NULL || fs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER) goto error; if (hs_streaming == NULL || hs_streaming[0] == NULL || hs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER) goto error; if (ss_streaming == NULL || ss_streaming[0] == NULL || ss_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER) goto error; uvc->desc.fs_control = fs_control; uvc->desc.ss_control = ss_control; uvc->desc.fs_streaming = fs_streaming; uvc->desc.hs_streaming = hs_streaming; uvc->desc.ss_streaming = ss_streaming; /* String descriptors are global, we only need to allocate string IDs * for the first UVC function. UVC functions beyond the first (if any) * will reuse the same IDs. */ if (uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id == 0) { ret = usb_string_ids_tab(c->cdev, uvc_en_us_strings); if (ret) goto error; uvc_iad.iFunction = uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id; uvc_control_intf.iInterface = uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id; ret = uvc_en_us_strings[UVC_STRING_STREAMING_IDX].id; uvc_streaming_intf_alt0.iInterface = ret; uvc_streaming_intf_alt1.iInterface = ret; } /* Register the function. */ uvc->func.name = "uvc"; uvc->func.strings = uvc_function_strings; uvc->func.bind = uvc_function_bind; uvc->func.unbind = uvc_function_unbind; uvc->func.get_alt = uvc_function_get_alt; uvc->func.set_alt = uvc_function_set_alt; uvc->func.disable = uvc_function_disable; uvc->func.setup = uvc_function_setup; ret = usb_add_function(c, &uvc->func); if (ret) kfree(uvc); return ret; error: kfree(uvc); return ret; }
static int __ref multi_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; int status; if (!can_support_ecm(cdev->gadget)) { dev_err(&gadget->dev, "controller '%s' not usable\n", gadget->name); return -EINVAL; } /* set up network link layer */ the_dev = gether_setup(cdev->gadget, dev_addr, host_addr, host_mac, qmult); if (IS_ERR(the_dev)) return PTR_ERR(the_dev); /* set up serial link layer */ fi_acm = usb_get_function_instance("acm"); if (IS_ERR(fi_acm)) { status = PTR_ERR(fi_acm); goto fail0; } /* set up mass storage function */ { void *retp; retp = fsg_common_from_params(&fsg_common, cdev, &fsg_mod_data); if (IS_ERR(retp)) { status = PTR_ERR(retp); goto fail1; } } /* allocate string IDs */ status = usb_string_ids_tab(cdev, strings_dev); if (unlikely(status < 0)) goto fail2; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; /* register configurations */ status = rndis_config_register(cdev); if (unlikely(status < 0)) goto fail2; status = cdc_config_register(cdev); if (unlikely(status < 0)) goto fail2; usb_composite_overwrite_options(cdev, &coverwrite); /* we're done */ dev_info(&gadget->dev, DRIVER_DESC "\n"); fsg_common_put(&fsg_common); return 0; /* error recovery */ fail2: fsg_common_put(&fsg_common); fail1: usb_put_function_instance(fi_acm); fail0: gether_cleanup(the_dev); return status; }
int rndis_bind_config_vendor(struct usb_configuration *c, u8 ethaddr[ETH_ALEN], u32 vendorID, const char *manufacturer, struct eth_dev *dev) { struct f_rndis *rndis; int status; if (!can_support_rndis(c) || !ethaddr) return -EINVAL; /* setup RNDIS itself */ status = rndis_init(); if (status < 0) return status; if (rndis_string_defs[0].id == 0) { status = usb_string_ids_tab(c->cdev, rndis_string_defs); if (status) return status; rndis_control_intf.iInterface = rndis_string_defs[0].id; rndis_data_intf.iInterface = rndis_string_defs[1].id; rndis_iad_descriptor.iFunction = rndis_string_defs[2].id; } /* allocate and initialize one new instance */ status = -ENOMEM; rndis = kzalloc(sizeof *rndis, GFP_KERNEL); if (!rndis) goto fail; __rndis = rndis; memcpy(rndis->ethaddr, ethaddr, ETH_ALEN); rndis->vendorID = vendorID; rndis->manufacturer = manufacturer; rndis->port.ioport = dev; /* RNDIS activates when the host changes this filter */ rndis->port.cdc_filter = 0; /* RNDIS has special (and complex) framing */ rndis->port.header_len = sizeof(struct rndis_packet_msg_type); rndis->port.wrap = rndis_add_header; rndis->port.unwrap = rndis_rm_hdr; rndis->port.ul_max_pkts_per_xfer = rndis_ul_max_pkt_per_xfer; rndis->port.dl_max_pkts_per_xfer = rndis_dl_max_pkt_per_xfer; rndis->port.rx_trigger_enabled = rx_trigger_enabled; rndis->port.func.name = "rndis"; rndis->port.func.strings = rndis_strings; /* descriptors are per-instance copies */ rndis->port.func.bind = rndis_bind; rndis->port.func.unbind = rndis_unbind; rndis->port.func.set_alt = rndis_set_alt; rndis->port.func.setup = rndis_setup; rndis->port.func.disable = rndis_disable; status = usb_add_function(c, &rndis->port.func); if (status) { kfree(rndis); fail: rndis_exit(); } return status; }
static int zero_bind(struct usb_composite_dev *cdev) { struct f_ss_opts *ss_opts; struct f_lb_opts *lb_opts; int status; /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) return status; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; device_desc.iSerialNumber = strings_dev[USB_GADGET_SERIAL_IDX].id; setup_timer(&autoresume_timer, zero_autoresume, (unsigned long) cdev); func_inst_ss = usb_get_function_instance("SourceSink"); if (IS_ERR(func_inst_ss)) return PTR_ERR(func_inst_ss); ss_opts = container_of(func_inst_ss, struct f_ss_opts, func_inst); ss_opts->pattern = gzero_options.pattern; ss_opts->isoc_interval = gzero_options.isoc_interval; ss_opts->isoc_maxpacket = gzero_options.isoc_maxpacket; ss_opts->isoc_mult = gzero_options.isoc_mult; ss_opts->isoc_maxburst = gzero_options.isoc_maxburst; ss_opts->bulk_buflen = gzero_options.bulk_buflen; func_ss = usb_get_function(func_inst_ss); if (IS_ERR(func_ss)) { status = PTR_ERR(func_ss); goto err_put_func_inst_ss; } func_inst_lb = usb_get_function_instance("Loopback"); if (IS_ERR(func_inst_lb)) { status = PTR_ERR(func_inst_lb); goto err_put_func_ss; } lb_opts = container_of(func_inst_lb, struct f_lb_opts, func_inst); lb_opts->bulk_buflen = gzero_options.bulk_buflen; lb_opts->qlen = gzero_options.qlen; func_lb = usb_get_function(func_inst_lb); if (IS_ERR(func_lb)) { status = PTR_ERR(func_lb); goto err_put_func_inst_lb; } sourcesink_driver.iConfiguration = strings_dev[USB_GZERO_SS_DESC].id; loopback_driver.iConfiguration = strings_dev[USB_GZERO_LB_DESC].id; /* support autoresume for remote wakeup testing */ sourcesink_driver.bmAttributes &= ~USB_CONFIG_ATT_WAKEUP; loopback_driver.bmAttributes &= ~USB_CONFIG_ATT_WAKEUP; sourcesink_driver.descriptors = NULL; loopback_driver.descriptors = NULL; if (autoresume) { sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; autoresume_step_ms = autoresume * 1000; } /* support OTG systems */ if (gadget_is_otg(cdev->gadget)) { if (!otg_desc[0]) { struct usb_descriptor_header *usb_desc; usb_desc = usb_otg_descriptor_alloc(cdev->gadget); if (!usb_desc) { status = -ENOMEM; goto err_conf_flb; } usb_otg_descriptor_init(cdev->gadget, usb_desc); otg_desc[0] = usb_desc; otg_desc[1] = NULL; } sourcesink_driver.descriptors = otg_desc; sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; loopback_driver.descriptors = otg_desc; loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP; } /* Register primary, then secondary configuration. Note that * SH3 only allows one config... */ if (loopdefault) { usb_add_config_only(cdev, &loopback_driver); usb_add_config_only(cdev, &sourcesink_driver); } else { usb_add_config_only(cdev, &sourcesink_driver); usb_add_config_only(cdev, &loopback_driver); } status = usb_add_function(&sourcesink_driver, func_ss); if (status) goto err_free_otg_desc; usb_ep_autoconfig_reset(cdev->gadget); status = usb_add_function(&loopback_driver, func_lb); if (status) goto err_free_otg_desc; usb_ep_autoconfig_reset(cdev->gadget); usb_composite_overwrite_options(cdev, &coverwrite); INFO(cdev, "%s, version: " DRIVER_VERSION "\n", longname); return 0; err_free_otg_desc: kfree(otg_desc[0]); otg_desc[0] = NULL; err_conf_flb: usb_put_function(func_lb); func_lb = NULL; err_put_func_inst_lb: usb_put_function_instance(func_inst_lb); func_inst_lb = NULL; err_put_func_ss: usb_put_function(func_ss); func_ss = NULL; err_put_func_inst_ss: usb_put_function_instance(func_inst_ss); func_inst_ss = NULL; return status; }
static int msg_bind(struct usb_composite_dev *cdev) { static const struct fsg_operations ops = { .thread_exits = msg_thread_exits, }; struct fsg_opts *opts; struct fsg_config config; int status; fi_msg = usb_get_function_instance("mass_storage"); if (IS_ERR(fi_msg)) return PTR_ERR(fi_msg); fsg_config_from_params(&config, &mod_data, fsg_num_buffers); opts = fsg_opts_from_func_inst(fi_msg); opts->no_configfs = true; status = fsg_common_set_num_buffers(opts->common, fsg_num_buffers); if (status) goto fail; fsg_common_set_ops(opts->common, &ops); status = fsg_common_set_cdev(opts->common, cdev, config.can_stall); if (status) goto fail_set_cdev; fsg_common_set_sysfs(opts->common, true); status = fsg_common_create_luns(opts->common, &config); if (status) goto fail_set_cdev; fsg_common_set_inquiry_string(opts->common, config.vendor_name, config.product_name); status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail_string_ids; msg_device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; if (gadget_is_otg(cdev->gadget) && !otg_desc[0]) { struct usb_descriptor_header *usb_desc; usb_desc = usb_otg_descriptor_alloc(cdev->gadget); if (!usb_desc) goto fail_string_ids; usb_otg_descriptor_init(cdev->gadget, usb_desc); otg_desc[0] = usb_desc; otg_desc[1] = NULL; } status = usb_add_config(cdev, &msg_config_driver, msg_do_config); if (status < 0) goto fail_otg_desc; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&cdev->gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n"); set_bit(0, &msg_registered); return 0; fail_otg_desc: kfree(otg_desc[0]); otg_desc[0] = NULL; fail_string_ids: fsg_common_remove_luns(opts->common); fail_set_cdev: fsg_common_free_buffers(opts->common); fail: usb_put_function_instance(fi_msg); return status; }
static int __ref multi_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; #ifdef CONFIG_USB_G_MULTI_CDC struct f_ecm_opts *ecm_opts; #endif #ifdef USB_ETH_RNDIS struct f_rndis_opts *rndis_opts; #endif struct fsg_opts *fsg_opts; struct fsg_config config; int status; if (!can_support_ecm(cdev->gadget)) { dev_err(&gadget->dev, "controller '%s' not usable\n", gadget->name); return -EINVAL; } #ifdef CONFIG_USB_G_MULTI_CDC fi_ecm = usb_get_function_instance("ecm"); if (IS_ERR(fi_ecm)) return PTR_ERR(fi_ecm); ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst); gether_set_qmult(ecm_opts->net, qmult); if (!gether_set_host_addr(ecm_opts->net, host_addr)) pr_info("using host ethernet address: %s", host_addr); if (!gether_set_dev_addr(ecm_opts->net, dev_addr)) pr_info("using self ethernet address: %s", dev_addr); #endif #ifdef USB_ETH_RNDIS fi_rndis = usb_get_function_instance("rndis"); if (IS_ERR(fi_rndis)) { status = PTR_ERR(fi_rndis); goto fail; } rndis_opts = container_of(fi_rndis, struct f_rndis_opts, func_inst); gether_set_qmult(rndis_opts->net, qmult); if (!gether_set_host_addr(rndis_opts->net, host_addr)) pr_info("using host ethernet address: %s", host_addr); if (!gether_set_dev_addr(rndis_opts->net, dev_addr)) pr_info("using self ethernet address: %s", dev_addr); #endif #if (defined CONFIG_USB_G_MULTI_CDC && defined USB_ETH_RNDIS) /* * If both ecm and rndis are selected then: * 1) rndis borrows the net interface from ecm * 2) since the interface is shared it must not be bound * twice - in ecm's _and_ rndis' binds, so do it here. */ gether_set_gadget(ecm_opts->net, cdev->gadget); status = gether_register_netdev(ecm_opts->net); if (status) goto fail0; rndis_borrow_net(fi_rndis, ecm_opts->net); ecm_opts->bound = true; #endif /* set up serial link layer */ fi_acm = usb_get_function_instance("acm"); if (IS_ERR(fi_acm)) { status = PTR_ERR(fi_acm); goto fail0; } /* set up mass storage function */ fi_msg = usb_get_function_instance("mass_storage"); if (IS_ERR(fi_msg)) { status = PTR_ERR(fi_msg); goto fail1; } fsg_config_from_params(&config, &fsg_mod_data, fsg_num_buffers); fsg_opts = fsg_opts_from_func_inst(fi_msg); fsg_opts->no_configfs = true; status = fsg_common_set_num_buffers(fsg_opts->common, fsg_num_buffers); if (status) goto fail2; status = fsg_common_set_nluns(fsg_opts->common, config.nluns); if (status) goto fail_set_nluns; status = fsg_common_set_cdev(fsg_opts->common, cdev, config.can_stall); if (status) goto fail_set_cdev; fsg_common_set_sysfs(fsg_opts->common, true); status = fsg_common_create_luns(fsg_opts->common, &config); if (status) goto fail_set_cdev; fsg_common_set_inquiry_string(fsg_opts->common, config.vendor_name, config.product_name); /* allocate string IDs */ status = usb_string_ids_tab(cdev, strings_dev); if (unlikely(status < 0)) goto fail_string_ids; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; /* register configurations */ status = rndis_config_register(cdev); if (unlikely(status < 0)) goto fail_string_ids; status = cdc_config_register(cdev); if (unlikely(status < 0)) goto fail_string_ids; usb_composite_overwrite_options(cdev, &coverwrite); /* we're done */ dev_info(&gadget->dev, DRIVER_DESC "\n"); return 0; /* error recovery */ fail_string_ids: fsg_common_remove_luns(fsg_opts->common); fail_set_cdev: fsg_common_free_luns(fsg_opts->common); fail_set_nluns: fsg_common_free_buffers(fsg_opts->common); fail2: usb_put_function_instance(fi_msg); fail1: usb_put_function_instance(fi_acm); fail0: #ifdef USB_ETH_RNDIS usb_put_function_instance(fi_rndis); fail: #endif #ifdef CONFIG_USB_G_MULTI_CDC usb_put_function_instance(fi_ecm); #endif return status; }
static int acm_ms_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; struct fsg_opts *opts; struct fsg_config config; int status; f_acm_inst = usb_get_function_instance("acm"); if (IS_ERR(f_acm_inst)) return PTR_ERR(f_acm_inst); fi_msg = usb_get_function_instance("mass_storage"); if (IS_ERR(fi_msg)) { status = PTR_ERR(fi_msg); goto fail_get_msg; } /* set up mass storage function */ fsg_config_from_params(&config, &fsg_mod_data, fsg_num_buffers); opts = fsg_opts_from_func_inst(fi_msg); opts->no_configfs = true; status = fsg_common_set_num_buffers(opts->common, fsg_num_buffers); if (status) goto fail; status = fsg_common_set_cdev(opts->common, cdev, config.can_stall); if (status) goto fail_set_cdev; fsg_common_set_sysfs(opts->common, true); status = fsg_common_create_luns(opts->common, &config); if (status) goto fail_set_cdev; fsg_common_set_inquiry_string(opts->common, config.vendor_name, config.product_name); /* * Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail_string_ids; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; if (gadget_is_otg(gadget) && !otg_desc[0]) { struct usb_descriptor_header *usb_desc; usb_desc = usb_otg_descriptor_alloc(gadget); if (!usb_desc) goto fail_string_ids; usb_otg_descriptor_init(gadget, usb_desc); otg_desc[0] = usb_desc; otg_desc[1] = NULL; } /* register our configuration */ status = usb_add_config(cdev, &acm_ms_config_driver, acm_ms_do_config); if (status < 0) goto fail_otg_desc; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC); return 0; /* error recovery */ fail_otg_desc: kfree(otg_desc[0]); otg_desc[0] = NULL; fail_string_ids: fsg_common_remove_luns(opts->common); fail_set_cdev: fsg_common_free_buffers(opts->common); fail: usb_put_function_instance(fi_msg); fail_get_msg: usb_put_function_instance(f_acm_inst); return status; }
static int audio_bind(struct usb_composite_dev *cdev) { #ifndef CONFIG_GADGET_UAC1 struct f_uac2_opts *uac2_opts; #else #ifndef CONFIG_GADGET_UAC1_LEGACY struct f_uac1_opts *uac1_opts; #else struct f_uac1_legacy_opts *uac1_opts; #endif #endif int status; #ifndef CONFIG_GADGET_UAC1 fi_uac2 = usb_get_function_instance("uac2"); if (IS_ERR(fi_uac2)) return PTR_ERR(fi_uac2); #else #ifndef CONFIG_GADGET_UAC1_LEGACY fi_uac1 = usb_get_function_instance("uac1"); #else fi_uac1 = usb_get_function_instance("uac1_legacy"); #endif if (IS_ERR(fi_uac1)) return PTR_ERR(fi_uac1); #endif #ifndef CONFIG_GADGET_UAC1 uac2_opts = container_of(fi_uac2, struct f_uac2_opts, func_inst); uac2_opts->p_chmask = p_chmask; uac2_opts->p_srate = p_srate; uac2_opts->p_ssize = p_ssize; uac2_opts->c_chmask = c_chmask; uac2_opts->c_srate = c_srate; uac2_opts->c_ssize = c_ssize; uac2_opts->req_number = UAC2_DEF_REQ_NUM; #else #ifndef CONFIG_GADGET_UAC1_LEGACY uac1_opts = container_of(fi_uac1, struct f_uac1_opts, func_inst); uac1_opts->p_chmask = p_chmask; uac1_opts->p_srate = p_srate; uac1_opts->p_ssize = p_ssize; uac1_opts->c_chmask = c_chmask; uac1_opts->c_srate = c_srate; uac1_opts->c_ssize = c_ssize; uac1_opts->req_number = UAC1_DEF_REQ_NUM; #else /* CONFIG_GADGET_UAC1_LEGACY */ uac1_opts = container_of(fi_uac1, struct f_uac1_legacy_opts, func_inst); uac1_opts->fn_play = fn_play; uac1_opts->fn_cap = fn_cap; uac1_opts->fn_cntl = fn_cntl; uac1_opts->req_buf_size = req_buf_size; uac1_opts->req_count = req_count; uac1_opts->audio_buf_size = audio_buf_size; #endif /* CONFIG_GADGET_UAC1_LEGACY */ #endif status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto fail; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; if (gadget_is_otg(cdev->gadget) && !otg_desc[0]) { struct usb_descriptor_header *usb_desc; usb_desc = usb_otg_descriptor_alloc(cdev->gadget); if (!usb_desc) goto fail; usb_otg_descriptor_init(cdev->gadget, usb_desc); otg_desc[0] = usb_desc; otg_desc[1] = NULL; } status = usb_add_config(cdev, &audio_config_driver, audio_do_config); if (status < 0) goto fail_otg_desc; usb_composite_overwrite_options(cdev, &coverwrite); INFO(cdev, "%s, version: %s\n", DRIVER_DESC, DRIVER_VERSION); return 0; fail_otg_desc: kfree(otg_desc[0]); otg_desc[0] = NULL; fail: #ifndef CONFIG_GADGET_UAC1 usb_put_function_instance(fi_uac2); #else usb_put_function_instance(fi_uac1); #endif return status; }
static int nokia_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; struct fsg_opts *fsg_opts; struct fsg_config fsg_config; int status; status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto err_usb; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; status = strings_dev[STRING_DESCRIPTION_IDX].id; nokia_config_500ma_driver.iConfiguration = status; nokia_config_100ma_driver.iConfiguration = status; if (!gadget_is_altset_supported(gadget)) { status = -ENODEV; goto err_usb; } fi_phonet = usb_get_function_instance("phonet"); if (IS_ERR(fi_phonet)) pr_debug("could not find phonet function\n"); fi_obex1 = usb_get_function_instance("obex"); if (IS_ERR(fi_obex1)) pr_debug("could not find obex function 1\n"); fi_obex2 = usb_get_function_instance("obex"); if (IS_ERR(fi_obex2)) pr_debug("could not find obex function 2\n"); fi_acm = usb_get_function_instance("acm"); if (IS_ERR(fi_acm)) { status = PTR_ERR(fi_acm); goto err_obex2_inst; } fi_ecm = usb_get_function_instance("ecm"); if (IS_ERR(fi_ecm)) { status = PTR_ERR(fi_ecm); goto err_acm_inst; } fi_msg = usb_get_function_instance("mass_storage"); if (IS_ERR(fi_msg)) { status = PTR_ERR(fi_msg); goto err_ecm_inst; } /* set up mass storage function */ fsg_config_from_params(&fsg_config, &fsg_mod_data, fsg_num_buffers); fsg_config.vendor_name = "Nokia"; fsg_config.product_name = "N900"; fsg_opts = fsg_opts_from_func_inst(fi_msg); fsg_opts->no_configfs = true; status = fsg_common_set_num_buffers(fsg_opts->common, fsg_num_buffers); if (status) goto err_msg_inst; status = fsg_common_set_cdev(fsg_opts->common, cdev, fsg_config.can_stall); if (status) goto err_msg_buf; fsg_common_set_sysfs(fsg_opts->common, true); status = fsg_common_create_luns(fsg_opts->common, &fsg_config); if (status) goto err_msg_buf; fsg_common_set_inquiry_string(fsg_opts->common, fsg_config.vendor_name, fsg_config.product_name); /* finally register the configuration */ status = usb_add_config(cdev, &nokia_config_500ma_driver, nokia_bind_config); if (status < 0) goto err_msg_luns; status = usb_add_config(cdev, &nokia_config_100ma_driver, nokia_bind_config); if (status < 0) goto err_put_cfg1; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&gadget->dev, "%s\n", NOKIA_LONG_NAME); return 0; err_put_cfg1: usb_put_function(f_acm_cfg1); if (!IS_ERR_OR_NULL(f_obex1_cfg1)) usb_put_function(f_obex1_cfg1); if (!IS_ERR_OR_NULL(f_obex2_cfg1)) usb_put_function(f_obex2_cfg1); if (!IS_ERR_OR_NULL(f_phonet_cfg1)) usb_put_function(f_phonet_cfg1); usb_put_function(f_ecm_cfg1); err_msg_luns: fsg_common_remove_luns(fsg_opts->common); err_msg_buf: fsg_common_free_buffers(fsg_opts->common); err_msg_inst: usb_put_function_instance(fi_msg); err_ecm_inst: usb_put_function_instance(fi_ecm); err_acm_inst: usb_put_function_instance(fi_acm); err_obex2_inst: if (!IS_ERR(fi_obex2)) usb_put_function_instance(fi_obex2); if (!IS_ERR(fi_obex1)) usb_put_function_instance(fi_obex1); if (!IS_ERR(fi_phonet)) usb_put_function_instance(fi_phonet); err_usb: return status; }
static int __init nokia_bind(struct usb_composite_dev *cdev) { struct usb_gadget *gadget = cdev->gadget; int status; status = usb_string_ids_tab(cdev, strings_dev); if (status < 0) goto err_usb; device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id; device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id; status = strings_dev[STRING_DESCRIPTION_IDX].id; nokia_config_500ma_driver.iConfiguration = status; nokia_config_100ma_driver.iConfiguration = status; if (!gadget_supports_altsettings(gadget)) { status = -ENODEV; goto err_usb; } fi_phonet = usb_get_function_instance("phonet"); if (IS_ERR(fi_phonet)) pr_debug("could not find phonet function\n"); fi_obex1 = usb_get_function_instance("obex"); if (IS_ERR(fi_obex1)) pr_debug("could not find obex function 1\n"); fi_obex2 = usb_get_function_instance("obex"); if (IS_ERR(fi_obex2)) pr_debug("could not find obex function 2\n"); fi_acm = usb_get_function_instance("acm"); if (IS_ERR(fi_acm)) { status = PTR_ERR(fi_acm); goto err_obex2_inst; } fi_ecm = usb_get_function_instance("ecm"); if (IS_ERR(fi_ecm)) { status = PTR_ERR(fi_ecm); goto err_acm_inst; } /* finally register the configuration */ status = usb_add_config(cdev, &nokia_config_500ma_driver, nokia_bind_config); if (status < 0) goto err_ecm_inst; status = usb_add_config(cdev, &nokia_config_100ma_driver, nokia_bind_config); if (status < 0) goto err_put_cfg1; usb_composite_overwrite_options(cdev, &coverwrite); dev_info(&gadget->dev, "%s\n", NOKIA_LONG_NAME); return 0; err_put_cfg1: usb_put_function(f_acm_cfg1); if (!IS_ERR_OR_NULL(f_obex1_cfg1)) usb_put_function(f_obex1_cfg1); if (!IS_ERR_OR_NULL(f_obex2_cfg1)) usb_put_function(f_obex2_cfg1); if (!IS_ERR_OR_NULL(f_phonet_cfg1)) usb_put_function(f_phonet_cfg1); usb_put_function(f_ecm_cfg1); err_ecm_inst: usb_put_function_instance(fi_ecm); err_acm_inst: usb_put_function_instance(fi_acm); err_obex2_inst: if (!IS_ERR(fi_obex2)) usb_put_function_instance(fi_obex2); if (!IS_ERR(fi_obex1)) usb_put_function_instance(fi_obex1); if (!IS_ERR(fi_phonet)) usb_put_function_instance(fi_phonet); err_usb: return status; }