linux/drivers/usb/gadget/legacy/cdc2.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * cdc2.c -- CDC Composite driver, with ECM and ACM support
   4 *
   5 * Copyright (C) 2008 David Brownell
   6 * Copyright (C) 2008 Nokia Corporation
   7 */
   8
   9#include <linux/kernel.h>
  10#include <linux/module.h>
  11
  12#include "u_ether.h"
  13#include "u_serial.h"
  14#include "u_ecm.h"
  15
  16
  17#define DRIVER_DESC             "CDC Composite Gadget"
  18#define DRIVER_VERSION          "King Kamehameha Day 2008"
  19
  20/*-------------------------------------------------------------------------*/
  21
  22/* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
  23 * Instead:  allocate your own, using normal USB-IF procedures.
  24 */
  25
  26/* Thanks to NetChip Technologies for donating this product ID.
  27 * It's for devices with only this composite CDC configuration.
  28 */
  29#define CDC_VENDOR_NUM          0x0525  /* NetChip */
  30#define CDC_PRODUCT_NUM         0xa4aa  /* CDC Composite: ECM + ACM */
  31
  32USB_GADGET_COMPOSITE_OPTIONS();
  33
  34USB_ETHERNET_MODULE_PARAMETERS();
  35
  36/*-------------------------------------------------------------------------*/
  37
  38static struct usb_device_descriptor device_desc = {
  39        .bLength =              sizeof device_desc,
  40        .bDescriptorType =      USB_DT_DEVICE,
  41
  42        /* .bcdUSB = DYNAMIC */
  43
  44        .bDeviceClass =         USB_CLASS_COMM,
  45        .bDeviceSubClass =      0,
  46        .bDeviceProtocol =      0,
  47        /* .bMaxPacketSize0 = f(hardware) */
  48
  49        /* Vendor and product id can be overridden by module parameters.  */
  50        .idVendor =             cpu_to_le16(CDC_VENDOR_NUM),
  51        .idProduct =            cpu_to_le16(CDC_PRODUCT_NUM),
  52        /* .bcdDevice = f(hardware) */
  53        /* .iManufacturer = DYNAMIC */
  54        /* .iProduct = DYNAMIC */
  55        /* NO SERIAL NUMBER */
  56        .bNumConfigurations =   1,
  57};
  58
  59static const struct usb_descriptor_header *otg_desc[2];
  60
  61/* string IDs are assigned dynamically */
  62static struct usb_string strings_dev[] = {
  63        [USB_GADGET_MANUFACTURER_IDX].s = "",
  64        [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
  65        [USB_GADGET_SERIAL_IDX].s = "",
  66        {  } /* end of list */
  67};
  68
  69static struct usb_gadget_strings stringtab_dev = {
  70        .language       = 0x0409,       /* en-us */
  71        .strings        = strings_dev,
  72};
  73
  74static struct usb_gadget_strings *dev_strings[] = {
  75        &stringtab_dev,
  76        NULL,
  77};
  78
  79/*-------------------------------------------------------------------------*/
  80static struct usb_function *f_acm;
  81static struct usb_function_instance *fi_serial;
  82
  83static struct usb_function *f_ecm;
  84static struct usb_function_instance *fi_ecm;
  85
  86/*
  87 * We _always_ have both CDC ECM and CDC ACM functions.
  88 */
  89static int cdc_do_config(struct usb_configuration *c)
  90{
  91        int     status;
  92
  93        if (gadget_is_otg(c->cdev->gadget)) {
  94                c->descriptors = otg_desc;
  95                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
  96        }
  97
  98        f_ecm = usb_get_function(fi_ecm);
  99        if (IS_ERR(f_ecm)) {
 100                status = PTR_ERR(f_ecm);
 101                goto err_get_ecm;
 102        }
 103
 104        status = usb_add_function(c, f_ecm);
 105        if (status)
 106                goto err_add_ecm;
 107
 108        f_acm = usb_get_function(fi_serial);
 109        if (IS_ERR(f_acm)) {
 110                status = PTR_ERR(f_acm);
 111                goto err_get_acm;
 112        }
 113
 114        status = usb_add_function(c, f_acm);
 115        if (status)
 116                goto err_add_acm;
 117        return 0;
 118
 119err_add_acm:
 120        usb_put_function(f_acm);
 121err_get_acm:
 122        usb_remove_function(c, f_ecm);
 123err_add_ecm:
 124        usb_put_function(f_ecm);
 125err_get_ecm:
 126        return status;
 127}
 128
 129static struct usb_configuration cdc_config_driver = {
 130        .label                  = "CDC Composite (ECM + ACM)",
 131        .bConfigurationValue    = 1,
 132        /* .iConfiguration = DYNAMIC */
 133        .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
 134};
 135
 136/*-------------------------------------------------------------------------*/
 137
 138static int cdc_bind(struct usb_composite_dev *cdev)
 139{
 140        struct usb_gadget       *gadget = cdev->gadget;
 141        struct f_ecm_opts       *ecm_opts;
 142        int                     status;
 143
 144        if (!can_support_ecm(cdev->gadget)) {
 145                dev_err(&gadget->dev, "controller '%s' not usable\n",
 146                                gadget->name);
 147                return -EINVAL;
 148        }
 149
 150        fi_ecm = usb_get_function_instance("ecm");
 151        if (IS_ERR(fi_ecm))
 152                return PTR_ERR(fi_ecm);
 153
 154        ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst);
 155
 156        gether_set_qmult(ecm_opts->net, qmult);
 157        if (!gether_set_host_addr(ecm_opts->net, host_addr))
 158                pr_info("using host ethernet address: %s", host_addr);
 159        if (!gether_set_dev_addr(ecm_opts->net, dev_addr))
 160                pr_info("using self ethernet address: %s", dev_addr);
 161
 162        fi_serial = usb_get_function_instance("acm");
 163        if (IS_ERR(fi_serial)) {
 164                status = PTR_ERR(fi_serial);
 165                goto fail;
 166        }
 167
 168        /* Allocate string descriptor numbers ... note that string
 169         * contents can be overridden by the composite_dev glue.
 170         */
 171
 172        status = usb_string_ids_tab(cdev, strings_dev);
 173        if (status < 0)
 174                goto fail1;
 175        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
 176        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 177
 178        if (gadget_is_otg(gadget) && !otg_desc[0]) {
 179                struct usb_descriptor_header *usb_desc;
 180
 181                usb_desc = usb_otg_descriptor_alloc(gadget);
 182                if (!usb_desc) {
 183                        status = -ENOMEM;
 184                        goto fail1;
 185                }
 186                usb_otg_descriptor_init(gadget, usb_desc);
 187                otg_desc[0] = usb_desc;
 188                otg_desc[1] = NULL;
 189        }
 190
 191        /* register our configuration */
 192        status = usb_add_config(cdev, &cdc_config_driver, cdc_do_config);
 193        if (status < 0)
 194                goto fail2;
 195
 196        usb_composite_overwrite_options(cdev, &coverwrite);
 197        dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n",
 198                        DRIVER_DESC);
 199
 200        return 0;
 201
 202fail2:
 203        kfree(otg_desc[0]);
 204        otg_desc[0] = NULL;
 205fail1:
 206        usb_put_function_instance(fi_serial);
 207fail:
 208        usb_put_function_instance(fi_ecm);
 209        return status;
 210}
 211
 212static int cdc_unbind(struct usb_composite_dev *cdev)
 213{
 214        usb_put_function(f_acm);
 215        usb_put_function_instance(fi_serial);
 216        if (!IS_ERR_OR_NULL(f_ecm))
 217                usb_put_function(f_ecm);
 218        if (!IS_ERR_OR_NULL(fi_ecm))
 219                usb_put_function_instance(fi_ecm);
 220        kfree(otg_desc[0]);
 221        otg_desc[0] = NULL;
 222
 223        return 0;
 224}
 225
 226static struct usb_composite_driver cdc_driver = {
 227        .name           = "g_cdc",
 228        .dev            = &device_desc,
 229        .strings        = dev_strings,
 230        .max_speed      = USB_SPEED_SUPER,
 231        .bind           = cdc_bind,
 232        .unbind         = cdc_unbind,
 233};
 234
 235module_usb_composite_driver(cdc_driver);
 236
 237MODULE_DESCRIPTION(DRIVER_DESC);
 238MODULE_AUTHOR("David Brownell");
 239MODULE_LICENSE("GPL");
 240