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