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