drivers/usb/gadget/multi.c

   1 /*
   2  * multi.c -- Multifunction Composite driver
   3  *
   4  * Copyright (C) 2008 David Brownell
   5  * Copyright (C) 2008 Nokia Corporation
   6  * Copyright (C) 2009 Samsung Electronics
   7  * Author: Michal Nazarewicz (mina86@mina86.com)
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  */
  14
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18
  19 #include "u_serial.h"
  20 #if defined USB_ETH_RNDIS
  21 #  undef USB_ETH_RNDIS
  22 #endif
  23 #ifdef CONFIG_USB_G_MULTI_RNDIS
  24 #  define USB_ETH_RNDIS y
  25 #endif
  26
  27
  28 #define DRIVER_DESC             "Multifunction Composite Gadget"
  29
  30 MODULE_DESCRIPTION(DRIVER_DESC);
  31 MODULE_AUTHOR("Michal Nazarewicz");
  32 MODULE_LICENSE("GPL");
  33
  34
  35 /***************************** All the files... *****************************/
  36
  37 /*
  38  * kbuild is not very cooperative with respect to linking separately
  39  * compiled library objects into one module.  So for now we won't use
  40  * separate compilation ... ensuring init/exit sections work to shrink
  41  * the runtime footprint, and giving us at least some parts of what
  42  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  43  */
  44 #include "f_mass_storage.c"
  45
  46 #include "f_ecm.c"
  47 #include "f_subset.c"
  48 #ifdef USB_ETH_RNDIS
  49 #  include "f_rndis.c"
  50 #  include "rndis.c"
  51 #endif
  52 #include "u_ether.h"
  53
  54 USB_GADGET_COMPOSITE_OPTIONS();
  55
  56 USB_ETHERNET_MODULE_PARAMETERS();
  57
  58 /***************************** Device Descriptor ****************************/
  59
  60 #define MULTI_VENDOR_NUM        0x1d6b  /* Linux Foundation */
  61 #define MULTI_PRODUCT_NUM       0x0104  /* Multifunction Composite Gadget */
  62
  63
  64 enum {
  65         __MULTI_NO_CONFIG,
  66 #ifdef CONFIG_USB_G_MULTI_RNDIS
  67         MULTI_RNDIS_CONFIG_NUM,
  68 #endif
  69 #ifdef CONFIG_USB_G_MULTI_CDC
  70         MULTI_CDC_CONFIG_NUM,
  71 #endif
  72 };
  73
  74
  75 static struct usb_device_descriptor device_desc = {
  76         .bLength =              sizeof device_desc,
  77         .bDescriptorType =      USB_DT_DEVICE,
  78
  79         .bcdUSB =               cpu_to_le16(0x0200),
  80
  81         .bDeviceClass =         USB_CLASS_MISC /* 0xEF */,
  82         .bDeviceSubClass =      2,
  83         .bDeviceProtocol =      1,
  84
  85         /* Vendor and product id can be overridden by module parameters.  */
  86         .idVendor =             cpu_to_le16(MULTI_VENDOR_NUM),
  87         .idProduct =            cpu_to_le16(MULTI_PRODUCT_NUM),
  88 };
  89
  90
  91 static const struct usb_descriptor_header *otg_desc[] = {
  92         (struct usb_descriptor_header *) &(struct usb_otg_descriptor){
  93                 .bLength =              sizeof(struct usb_otg_descriptor),
  94                 .bDescriptorType =      USB_DT_OTG,
  95
  96                 /*
  97                  * REVISIT SRP-only hardware is possible, although
  98                  * it would not be called "OTG" ...
  99                  */
 100                 .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
 101         },
 102         NULL,
 103 };
 104
 105
 106 enum {
 107         MULTI_STRING_RNDIS_CONFIG_IDX = USB_GADGET_FIRST_AVAIL_IDX,
 108         MULTI_STRING_CDC_CONFIG_IDX,
 109 };
 110
 111 static struct usb_string strings_dev[] = {
 112         [USB_GADGET_MANUFACTURER_IDX].s = "",
 113         [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
 114         [USB_GADGET_SERIAL_IDX].s = "",
 115         [MULTI_STRING_RNDIS_CONFIG_IDX].s = "Multifunction with RNDIS",
 116         [MULTI_STRING_CDC_CONFIG_IDX].s   = "Multifunction with CDC ECM",
 117         {  } /* end of list */
 118 };
 119
 120 static struct usb_gadget_strings *dev_strings[] = {
 121         &(struct usb_gadget_strings){
 122                 .language       = 0x0409,       /* en-us */
 123                 .strings        = strings_dev,
 124         },
 125         NULL,
 126 };
 127
 128
 129
 130
 131 /****************************** Configurations ******************************/
 132
 133 static struct fsg_module_parameters fsg_mod_data = { .stall = 1 };
 134 FSG_MODULE_PARAMETERS(/* no prefix */, fsg_mod_data);
 135
 136 static struct fsg_common fsg_common;
 137
 138 static u8 host_mac[ETH_ALEN];
 139
 140 static struct usb_function_instance *fi_acm;
 141 static struct eth_dev *the_dev;
 142
 143 /********** RNDIS **********/
 144
 145 #ifdef USB_ETH_RNDIS
 146 static struct usb_function *f_acm_rndis;
 147
 148 static __init int rndis_do_config(struct usb_configuration *c)
 149 {
 150         int ret;
 151
 152         if (gadget_is_otg(c->cdev->gadget)) {
 153                 c->descriptors = otg_desc;
 154                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
 155         }
 156
 157         ret = rndis_bind_config(c, host_mac, the_dev);
 158         if (ret < 0)
 159                 return ret;
 160
 161         f_acm_rndis = usb_get_function(fi_acm);
 162         if (IS_ERR(f_acm_rndis)) {
 163                 ret = PTR_ERR(f_acm_rndis);
 164                 goto err_func_acm;
 165         }
 166
 167         ret = usb_add_function(c, f_acm_rndis);
 168         if (ret)
 169                 goto err_conf;
 170
 171         ret = fsg_bind_config(c->cdev, c, &fsg_common);
 172         if (ret < 0)
 173                 goto err_fsg;
 174
 175         return 0;
 176 err_fsg:
 177         usb_remove_function(c, f_acm_rndis);
 178 err_conf:
 179         usb_put_function(f_acm_rndis);
 180 err_func_acm:
 181         return ret;
 182 }
 183
 184 static int rndis_config_register(struct usb_composite_dev *cdev)
 185 {
 186         static struct usb_configuration config = {
 187                 .bConfigurationValue    = MULTI_RNDIS_CONFIG_NUM,
 188                 .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
 189         };
 190
 191         config.label          = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].s;
 192         config.iConfiguration = strings_dev[MULTI_STRING_RNDIS_CONFIG_IDX].id;
 193
 194         return usb_add_config(cdev, &config, rndis_do_config);
 195 }
 196
 197 #else
 198
 199 static int rndis_config_register(struct usb_composite_dev *cdev)
 200 {
 201         return 0;
 202 }
 203
 204 #endif
 205
 206
 207 /********** CDC ECM **********/
 208
 209 #ifdef CONFIG_USB_G_MULTI_CDC
 210 static struct usb_function *f_acm_multi;
 211
 212 static __init int cdc_do_config(struct usb_configuration *c)
 213 {
 214         int ret;
 215
 216         if (gadget_is_otg(c->cdev->gadget)) {
 217                 c->descriptors = otg_desc;
 218                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
 219         }
 220
 221         ret = ecm_bind_config(c, host_mac, the_dev);
 222         if (ret < 0)
 223                 return ret;
 224
 225         /* implicit port_num is zero */
 226         f_acm_multi = usb_get_function(fi_acm);
 227         if (IS_ERR(f_acm_multi))
 228                 goto err_func_acm;
 229
 230         ret = usb_add_function(c, f_acm_multi);
 231         if (ret)
 232                 goto err_conf;
 233
 234         ret = fsg_bind_config(c->cdev, c, &fsg_common);
 235         if (ret < 0)
 236                 goto err_fsg;
 237
 238         return 0;
 239 err_fsg:
 240         usb_remove_function(c, f_acm_multi);
 241 err_conf:
 242         usb_put_function(f_acm_multi);
 243 err_func_acm:
 244         return ret;
 245 }
 246
 247 static int cdc_config_register(struct usb_composite_dev *cdev)
 248 {
 249         static struct usb_configuration config = {
 250                 .bConfigurationValue    = MULTI_CDC_CONFIG_NUM,
 251                 .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
 252         };
 253
 254         config.label          = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].s;
 255         config.iConfiguration = strings_dev[MULTI_STRING_CDC_CONFIG_IDX].id;
 256
 257         return usb_add_config(cdev, &config, cdc_do_config);
 258 }
 259
 260 #else
 261
 262 static int cdc_config_register(struct usb_composite_dev *cdev)
 263 {
 264         return 0;
 265 }
 266
 267 #endif
 268
 269
 270
 271 /****************************** Gadget Bind ******************************/
 272
 273 static int __ref multi_bind(struct usb_composite_dev *cdev)
 274 {
 275         struct usb_gadget *gadget = cdev->gadget;
 276         int status;
 277
 278         if (!can_support_ecm(cdev->gadget)) {
 279                 dev_err(&gadget->dev, "controller '%s' not usable\n",
 280                         gadget->name);
 281                 return -EINVAL;
 282         }
 283
 284         /* set up network link layer */
 285         the_dev = gether_setup(cdev->gadget, dev_addr, host_addr, host_mac,
 286                                qmult);
 287         if (IS_ERR(the_dev))
 288                 return PTR_ERR(the_dev);
 289
 290         /* set up serial link layer */
 291         fi_acm = usb_get_function_instance("acm");
 292         if (IS_ERR(fi_acm)) {
 293                 status = PTR_ERR(fi_acm);
 294                 goto fail0;
 295         }
 296
 297         /* set up mass storage function */
 298         {
 299                 void *retp;
 300                 retp = fsg_common_from_params(&fsg_common, cdev, &fsg_mod_data);
 301                 if (IS_ERR(retp)) {
 302                         status = PTR_ERR(retp);
 303                         goto fail1;
 304                 }
 305         }
 306
 307         /* allocate string IDs */
 308         status = usb_string_ids_tab(cdev, strings_dev);
 309         if (unlikely(status < 0))
 310                 goto fail2;
 311         device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 312
 313         /* register configurations */
 314         status = rndis_config_register(cdev);
 315         if (unlikely(status < 0))
 316                 goto fail2;
 317
 318         status = cdc_config_register(cdev);
 319         if (unlikely(status < 0))
 320                 goto fail2;
 321         usb_composite_overwrite_options(cdev, &coverwrite);
 322
 323         /* we're done */
 324         dev_info(&gadget->dev, DRIVER_DESC "\n");
 325         fsg_common_put(&fsg_common);
 326         return 0;
 327
 328
 329         /* error recovery */
 330 fail2:
 331         fsg_common_put(&fsg_common);
 332 fail1:
 333         usb_put_function_instance(fi_acm);
 334 fail0:
 335         gether_cleanup(the_dev);
 336         return status;
 337 }
 338
 339 static int __exit multi_unbind(struct usb_composite_dev *cdev)
 340 {
 341 #ifdef CONFIG_USB_G_MULTI_CDC
 342         usb_put_function(f_acm_multi);
 343 #endif
 344 #ifdef USB_ETH_RNDIS
 345         usb_put_function(f_acm_rndis);
 346 #endif
 347         usb_put_function_instance(fi_acm);
 348         gether_cleanup(the_dev);
 349         return 0;
 350 }
 351
 352
 353 /****************************** Some noise ******************************/
 354
 355
 356 static __refdata struct usb_composite_driver multi_driver = {
 357         .name           = "g_multi",
 358         .dev            = &device_desc,
 359         .strings        = dev_strings,
 360         .max_speed      = USB_SPEED_HIGH,
 361         .bind           = multi_bind,
 362         .unbind         = __exit_p(multi_unbind),
 363         .needs_serial   = 1,
 364 };
 365
 366
 367 static int __init multi_init(void)
 368 {
 369         return usb_composite_probe(&multi_driver);
 370 }
 371 module_init(multi_init);
 372
 373 static void __exit multi_exit(void)
 374 {
 375         usb_composite_unregister(&multi_driver);
 376 }
 377 module_exit(multi_exit);