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 gfs_do_ecm_config(struct usb_configuration *c) { ENTER(); return __gfs_do_config(c, can_support_ecm(c->cdev->gadget) ? ecm_bind_config : geth_bind_config, gfs_hostaddr); }
/* * We _always_ have an ECM, CDC Subset, or EEM configuration. */ static int __init eth_do_config(struct usb_configuration *c) { /* FIXME alloc iConfiguration string, set it in c->strings */ if (use_eem) return eem_bind_config(c); else if (can_support_ecm(c->cdev->gadget)) return ecm_bind_config(c, hostaddr); else return geth_bind_config(c, hostaddr); }
/* * We _always_ have an ECM or CDC Subset configuration. */ static int __init eth_do_config(struct usb_configuration *c) { /* FIXME alloc iConfiguration string, set it in c->strings */ if (gadget_is_otg(c->cdev->gadget)) { c->descriptors = otg_desc; c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; } if (can_support_ecm(c->cdev->gadget)) return ecm_bind_config(c, hostaddr); else return geth_bind_config(c, hostaddr); }
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 eth_do_config(struct usb_configuration *c) { if (gadget_is_otg(c->cdev->gadget)) { c->descriptors = otg_desc; c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; } if (use_eem) return eem_bind_config(c); else if (can_support_ecm(c->cdev->gadget)) return ecm_bind_config(c, hostaddr); else return geth_bind_config(c, hostaddr); }
/* * We _always_ have an ECM, CDC Subset, or EEM configuration. */ static int __init eth_do_config(struct usb_configuration *c) { int status = 0; /* FIXME alloc iConfiguration string, set it in c->strings */ if (gadget_is_otg(c->cdev->gadget)) { c->descriptors = otg_desc; c->bmAttributes |= USB_CONFIG_ATT_WAKEUP; } if (use_eem) { f_eem = usb_get_function(fi_eem); if (IS_ERR(f_eem)) return PTR_ERR(f_eem); status = usb_add_function(c, f_eem); if (status < 0) usb_put_function(f_eem); return status; } else if (can_support_ecm(c->cdev->gadget)) { f_ecm = usb_get_function(fi_ecm); if (IS_ERR(f_ecm)) return PTR_ERR(f_ecm); status = usb_add_function(c, f_ecm); if (status < 0) usb_put_function(f_ecm); return status; } else { f_geth = usb_get_function(fi_geth); if (IS_ERR(f_geth)) return PTR_ERR(f_geth); status = usb_add_function(c, f_geth); if (status < 0) usb_put_function(f_geth); return status; } }
static int __init eth_bind(struct usb_composite_dev *cdev) { int gcnum; struct usb_gadget *gadget = cdev->gadget; int status; /* set up network link layer */ status = gether_setup(cdev->gadget, hostaddr); if (status < 0) return status; /* set up main config label and device descriptor */ if (use_eem) { /* EEM */ eth_config_driver.label = "CDC Ethernet (EEM)"; device_desc.idVendor = cpu_to_le16(EEM_VENDOR_NUM); device_desc.idProduct = cpu_to_le16(EEM_PRODUCT_NUM); } else if (can_support_ecm(cdev->gadget)) { /* ECM */ eth_config_driver.label = "CDC Ethernet (ECM)"; } else { /* CDC Subset */ eth_config_driver.label = "CDC Subset/SAFE"; device_desc.idVendor = cpu_to_le16(SIMPLE_VENDOR_NUM); device_desc.idProduct = cpu_to_le16(SIMPLE_PRODUCT_NUM); if (!has_rndis()) device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC; } if (has_rndis()) { /* RNDIS plus ECM-or-Subset */ device_desc.idVendor = cpu_to_le16(RNDIS_VENDOR_NUM); device_desc.idProduct = cpu_to_le16(RNDIS_PRODUCT_NUM); device_desc.bNumConfigurations = 2; } gcnum = usb_gadget_controller_number(gadget); if (gcnum >= 0) device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum); else { /* We assume that can_support_ecm() tells the truth; * but if the controller isn't recognized at all then * that assumption is a bit more likely to be wrong. */ dev_warn(&gadget->dev, "controller '%s' not recognized; trying %s\n", gadget->name, eth_config_driver.label); device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099); } /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ /* device descriptor strings: manufacturer, product */ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", init_utsname()->sysname, init_utsname()->release, gadget->name); status = usb_string_id(cdev); if (status < 0) goto fail; strings_dev[STRING_MANUFACTURER_IDX].id = status; device_desc.iManufacturer = status; status = usb_string_id(cdev); if (status < 0) goto fail; strings_dev[STRING_PRODUCT_IDX].id = status; device_desc.iProduct = status; /* register our configuration(s); RNDIS first, if it's used */ if (has_rndis()) { status = usb_add_config(cdev, &rndis_config_driver, rndis_do_config); if (status < 0) goto fail; } status = usb_add_config(cdev, ð_config_driver, eth_do_config); if (status < 0) goto fail; dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC); return 0; fail: gether_cleanup(); return status; }
static int __init 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 */ fsg_common = fsg_common_from_params(0, cdev, &mod_data); if (IS_ERR(fsg_common)) { status = PTR_ERR(fsg_common); goto fail1; } gcnum = usb_gadget_controller_number(gadget); if (gcnum >= 0) device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum); else { /* We assume that can_support_ecm() tells the truth; * but if the controller isn't recognized at all then * that assumption is a bit more likely to be wrong. */ // WARNING(cdev, "controller '%s' not recognized\n", // gadget->name); device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099); } /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ /* device descriptor strings: manufacturer, product */ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", init_utsname()->sysname, init_utsname()->release, gadget->name); status = usb_string_id(cdev); if (status < 0) goto fail2; strings_dev[STRING_MANUFACTURER_IDX].id = status; device_desc.iManufacturer = status; status = usb_string_id(cdev); if (status < 0) goto fail2; strings_dev[STRING_PRODUCT_IDX].id = status; device_desc.iProduct = status; status = usb_string_id(cdev); if (status < 0) goto fail2; strings_dev[STRING_SERIAL_IDX].id = status; device_desc.iSerialNumber = status; #ifdef USB_ETH_RNDIS /* register our first configuration */ status = usb_add_config(cdev, &rndis_config_driver); if (status < 0) goto fail2; #endif #ifdef CONFIG_USB_G_MULTI_CDC /* register our second configuration */ status = usb_add_config(cdev, &cdc_config_driver); if (status < 0) goto fail2; #endif dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n"); fsg_common_put(fsg_common); return 0; fail2: fsg_common_put(fsg_common); fail1: gserial_cleanup(); fail0: gether_cleanup(); return status; }
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; }
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; }
static int cdc_bind(struct usb_composite_dev *cdev) { int gcnum; 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; gcnum = usb_gadget_controller_number(gadget); if (gcnum >= 0) device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum); else { /* We assume that can_support_ecm() tells the truth; * but if the controller isn't recognized at all then * that assumption is a bit more likely to be wrong. */ WARNING(cdev, "controller '%s' not recognized; trying %s\n", gadget->name, cdc_config_driver.label); device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099); } /* Allocate string descriptor numbers ... note that string * contents can be overridden by the composite_dev glue. */ /* device descriptor strings: manufacturer, product */ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", init_utsname()->sysname, init_utsname()->release, gadget->name); status = usb_string_id(cdev); if (status < 0) goto fail1; strings_dev[STRING_MANUFACTURER_IDX].id = status; device_desc.iManufacturer = status; status = usb_string_id(cdev); if (status < 0) goto fail1; strings_dev[STRING_PRODUCT_IDX].id = status; device_desc.iProduct = status; /* register our configuration */ status = usb_add_config(cdev, &cdc_config_driver); if (status < 0) goto fail1; dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC); return 0; fail1: gserial_cleanup(); fail0: gether_cleanup(); 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; }
/** * ecm_bind_config - add CDC Ethernet network link to a configuration * @c: the configuration to support the network link * @ethaddr: a buffer in which the ethernet address of the host side * side of the link was recorded * Context: single threaded during gadget setup * * Returns zero on success, else negative errno. * * Caller must have called @gether_setup(). Caller is also responsible * for calling @gether_cleanup() before module unload. */ int ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]) { struct f_ecm *ecm; int status; if (!can_support_ecm(c->cdev->gadget) || !ethaddr) return -EINVAL; /* maybe allocate device-global string IDs */ if (ecm_string_defs[0].id == 0) { /* control interface label */ status = 5; if (status < 0) return status; ecm_string_defs[0].id = status; ecm_control_intf.iInterface = status; #ifdef CONFIG_LGE_USB_GADGET_DRIVER /* MAC address */ status = usb_string_id(c->cdev); if (status < 0) return status; ecm_string_defs[1].id = status; pr_info("%s: iMACAddress = %d\n", __func__, status); ecm_desc.iMACAddress = status; #endif /* data interface label */ status = usb_string_id(c->cdev); if (status < 0) return status; ecm_string_defs[2].id = status; ecm_data_intf.iInterface = status; /* NOTE : if NOT defined */ #ifndef CONFIG_LGE_USB_GADGET_DRIVER /* MAC address */ status = usb_string_id(c->cdev); if (status < 0) return status; ecm_string_defs[1].id = status; ecm_desc.iMACAddress = status; #endif } /* allocate and initialize one new instance */ ecm = kzalloc(sizeof *ecm, GFP_KERNEL); if (!ecm) return -ENOMEM; /* export host's Ethernet address in CDC format */ snprintf(ecm->ethaddr, sizeof ecm->ethaddr, "%02X%02X%02X%02X%02X%02X", ethaddr[0], ethaddr[1], ethaddr[2], ethaddr[3], ethaddr[4], ethaddr[5]); ecm_string_defs[1].s = ecm->ethaddr; ecm->port.cdc_filter = DEFAULT_FILTER; #ifdef CONFIG_LGE_USB_GADGET_DRIVER ecm->port.func.name = "ecm"; #else ecm->port.func.name = "cdc_ethernet"; #endif ecm->port.func.strings = ecm_strings; /* descriptors are per-instance copies */ ecm->port.func.bind = ecm_bind; ecm->port.func.unbind = ecm_unbind; ecm->port.func.set_alt = ecm_set_alt; ecm->port.func.get_alt = ecm_get_alt; ecm->port.func.setup = ecm_setup; ecm->port.func.disable = ecm_disable; ecm->port.func.suspend = ecm_suspend; ecm->port.func.resume = ecm_resume; status = usb_add_function(c, &ecm->port.func); if (status) { ecm_string_defs[1].s = NULL; kfree(ecm); } return status; }
static int __init eth_bind(struct usb_composite_dev *cdev) { int gcnum; struct usb_gadget *gadget = cdev->gadget; int status; status = gether_setup(cdev->gadget, hostaddr); if (status < 0) return status; if (use_eem) { eth_config_driver.label = "CDC Ethernet (EEM)"; device_desc.idVendor = cpu_to_le16(EEM_VENDOR_NUM); device_desc.idProduct = cpu_to_le16(EEM_PRODUCT_NUM); } else if (can_support_ecm(cdev->gadget)) { eth_config_driver.label = "CDC Ethernet (ECM)"; } else { eth_config_driver.label = "CDC Subset/SAFE"; device_desc.idVendor = cpu_to_le16(SIMPLE_VENDOR_NUM); device_desc.idProduct = cpu_to_le16(SIMPLE_PRODUCT_NUM); if (!has_rndis()) device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC; } if (has_rndis()) { device_desc.idVendor = cpu_to_le16(RNDIS_VENDOR_NUM); device_desc.idProduct = cpu_to_le16(RNDIS_PRODUCT_NUM); device_desc.bNumConfigurations = 2; } gcnum = usb_gadget_controller_number(gadget); if (gcnum >= 0) device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum); else { dev_warn(&gadget->dev, "controller '%s' not recognized; trying %s\n", gadget->name, eth_config_driver.label); device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099); } snprintf(manufacturer, sizeof manufacturer, "%s %s with %s", init_utsname()->sysname, init_utsname()->release, gadget->name); status = usb_string_id(cdev); if (status < 0) goto fail; strings_dev[STRING_MANUFACTURER_IDX].id = status; device_desc.iManufacturer = status; status = usb_string_id(cdev); if (status < 0) goto fail; strings_dev[STRING_PRODUCT_IDX].id = status; device_desc.iProduct = status; if (has_rndis()) { status = usb_add_config(cdev, &rndis_config_driver); if (status < 0) goto fail; } status = usb_add_config(cdev, ð_config_driver); if (status < 0) goto fail; dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC); return 0; fail: gether_cleanup(); return status; }