drivers/usb/gadget/legacy/ncm.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * ncm.c -- NCM gadget driver
   4  *
   5  * Copyright (C) 2010 Nokia Corporation
   6  * Contact: Yauheni Kaliuta <yauheni.kaliuta@nokia.com>
   7  *
   8  * The driver borrows from ether.c which is:
   9  *
  10  * Copyright (C) 2003-2005,2008 David Brownell
  11  * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
  12  * Copyright (C) 2008 Nokia Corporation
  13  */
  14
  15 /* #define DEBUG */
  16 /* #define VERBOSE_DEBUG */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/usb/composite.h>
  21
  22 #include "u_ether.h"
  23 #include "u_ncm.h"
  24
  25 #define DRIVER_DESC             "NCM Gadget"
  26
  27 /*-------------------------------------------------------------------------*/
  28
  29 /* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
  30  * Instead:  allocate your own, using normal USB-IF procedures.
  31  */
  32
  33 /* Thanks to NetChip Technologies for donating this product ID.
  34  * It's for devices with only CDC Ethernet configurations.
  35  */
  36 #define CDC_VENDOR_NUM          0x0525  /* NetChip */
  37 #define CDC_PRODUCT_NUM         0xa4a1  /* Linux-USB Ethernet Gadget */
  38
  39 /*-------------------------------------------------------------------------*/
  40 USB_GADGET_COMPOSITE_OPTIONS();
  41
  42 USB_ETHERNET_MODULE_PARAMETERS();
  43
  44 static struct usb_device_descriptor device_desc = {
  45         .bLength =              sizeof device_desc,
  46         .bDescriptorType =      USB_DT_DEVICE,
  47
  48         /* .bcdUSB = DYNAMIC */
  49
  50         .bDeviceClass =         USB_CLASS_COMM,
  51         .bDeviceSubClass =      0,
  52         .bDeviceProtocol =      0,
  53         /* .bMaxPacketSize0 = f(hardware) */
  54
  55         /* Vendor and product id defaults change according to what configs
  56          * we support.  (As does bNumConfigurations.)  These values can
  57          * also be overridden by module parameters.
  58          */
  59         .idVendor =             cpu_to_le16 (CDC_VENDOR_NUM),
  60         .idProduct =            cpu_to_le16 (CDC_PRODUCT_NUM),
  61         /* .bcdDevice = f(hardware) */
  62         /* .iManufacturer = DYNAMIC */
  63         /* .iProduct = DYNAMIC */
  64         /* NO SERIAL NUMBER */
  65         .bNumConfigurations =   1,
  66 };
  67
  68 static const struct usb_descriptor_header *otg_desc[2];
  69
  70 /* string IDs are assigned dynamically */
  71 static struct usb_string strings_dev[] = {
  72         [USB_GADGET_MANUFACTURER_IDX].s = "",
  73         [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
  74         [USB_GADGET_SERIAL_IDX].s = "",
  75         {  } /* end of list */
  76 };
  77
  78 static struct usb_gadget_strings stringtab_dev = {
  79         .language       = 0x0409,       /* en-us */
  80         .strings        = strings_dev,
  81 };
  82
  83 static struct usb_gadget_strings *dev_strings[] = {
  84         &stringtab_dev,
  85         NULL,
  86 };
  87
  88 static struct usb_function_instance *f_ncm_inst;
  89 static struct usb_function *f_ncm;
  90
  91 /*-------------------------------------------------------------------------*/
  92
  93 static int ncm_do_config(struct usb_configuration *c)
  94 {
  95         int status;
  96
  97         /* FIXME alloc iConfiguration string, set it in c->strings */
  98
  99         if (gadget_is_otg(c->cdev->gadget)) {
 100                 c->descriptors = otg_desc;
 101                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
 102         }
 103
 104         f_ncm = usb_get_function(f_ncm_inst);
 105         if (IS_ERR(f_ncm))
 106                 return PTR_ERR(f_ncm);
 107
 108         status = usb_add_function(c, f_ncm);
 109         if (status < 0) {
 110                 usb_put_function(f_ncm);
 111                 return status;
 112         }
 113
 114         return 0;
 115 }
 116
 117 static struct usb_configuration ncm_config_driver = {
 118         /* .label = f(hardware) */
 119         .label                  = "CDC Ethernet (NCM)",
 120         .bConfigurationValue    = 1,
 121         /* .iConfiguration = DYNAMIC */
 122         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
 123 };
 124
 125 /*-------------------------------------------------------------------------*/
 126
 127 static int gncm_bind(struct usb_composite_dev *cdev)
 128 {
 129         struct usb_gadget       *gadget = cdev->gadget;
 130         struct f_ncm_opts       *ncm_opts;
 131         int                     status;
 132
 133         f_ncm_inst = usb_get_function_instance("ncm");
 134         if (IS_ERR(f_ncm_inst))
 135                 return PTR_ERR(f_ncm_inst);
 136
 137         ncm_opts = container_of(f_ncm_inst, struct f_ncm_opts, func_inst);
 138
 139         gether_set_qmult(ncm_opts->net, qmult);
 140         if (!gether_set_host_addr(ncm_opts->net, host_addr))
 141                 pr_info("using host ethernet address: %s", host_addr);
 142         if (!gether_set_dev_addr(ncm_opts->net, dev_addr))
 143                 pr_info("using self ethernet address: %s", dev_addr);
 144
 145         /* Allocate string descriptor numbers ... note that string
 146          * contents can be overridden by the composite_dev glue.
 147          */
 148
 149         status = usb_string_ids_tab(cdev, strings_dev);
 150         if (status < 0)
 151                 goto fail;
 152         device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
 153         device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 154
 155         if (gadget_is_otg(gadget) && !otg_desc[0]) {
 156                 struct usb_descriptor_header *usb_desc;
 157
 158                 usb_desc = usb_otg_descriptor_alloc(gadget);
 159                 if (!usb_desc)
 160                         goto fail;
 161                 usb_otg_descriptor_init(gadget, usb_desc);
 162                 otg_desc[0] = usb_desc;
 163                 otg_desc[1] = NULL;
 164         }
 165
 166         status = usb_add_config(cdev, &ncm_config_driver,
 167                                 ncm_do_config);
 168         if (status < 0)
 169                 goto fail1;
 170
 171         usb_composite_overwrite_options(cdev, &coverwrite);
 172         dev_info(&gadget->dev, "%s\n", DRIVER_DESC);
 173
 174         return 0;
 175
 176 fail1:
 177         kfree(otg_desc[0]);
 178         otg_desc[0] = NULL;
 179 fail:
 180         usb_put_function_instance(f_ncm_inst);
 181         return status;
 182 }
 183
 184 static int gncm_unbind(struct usb_composite_dev *cdev)
 185 {
 186         if (!IS_ERR_OR_NULL(f_ncm))
 187                 usb_put_function(f_ncm);
 188         if (!IS_ERR_OR_NULL(f_ncm_inst))
 189                 usb_put_function_instance(f_ncm_inst);
 190         kfree(otg_desc[0]);
 191         otg_desc[0] = NULL;
 192
 193         return 0;
 194 }
 195
 196 static struct usb_composite_driver ncm_driver = {
 197         .name           = "g_ncm",
 198         .dev            = &device_desc,
 199         .strings        = dev_strings,
 200         .max_speed      = USB_SPEED_SUPER,
 201         .bind           = gncm_bind,
 202         .unbind         = gncm_unbind,
 203 };
 204
 205 module_usb_composite_driver(ncm_driver);
 206
 207 MODULE_DESCRIPTION(DRIVER_DESC);
 208 MODULE_AUTHOR("Yauheni Kaliuta");
 209 MODULE_LICENSE("GPL");