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