drivers/usb/gadget/android.c

   1 /*
   2  * Gadget Driver for Android
   3  *
   4  * Copyright (C) 2008 Google, Inc.
   5  * Author: Mike Lockwood <lockwood@android.com>
   6  *         Benoit Goby <benoit@android.com>
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  */
  18
  19 #include <linux/init.h>
  20 #include <linux/module.h>
  21 #include <linux/fs.h>
  22 #include <linux/delay.h>
  23 #include <linux/kernel.h>
  24 #include <linux/utsname.h>
  25 #include <linux/platform_device.h>
  26
  27 #include <linux/usb/ch9.h>
  28 #include <linux/usb/composite.h>
  29 #include <linux/usb/gadget.h>
  30
  31 #include "gadget_chips.h"
  32
  33 #include "f_fs.c"
  34 #include "f_audio_source.c"
  35 #include "f_mass_storage.c"
  36 #include "f_mtp.c"
  37 #include "f_accessory.c"
  38 #define USB_ETH_RNDIS y
  39 #include "f_rndis.c"
  40 #include "rndis.c"
  41 #include "u_ether.c"
  42
  43 MODULE_AUTHOR("Mike Lockwood");
  44 MODULE_DESCRIPTION("Android Composite USB Driver");
  45 MODULE_LICENSE("GPL");
  46 MODULE_VERSION("1.0");
  47
  48 static const char longname[] = "Gadget Android";
  49
  50 /* Default vendor and product IDs, overridden by userspace */
  51 #define VENDOR_ID               0x2207
  52 #define PRODUCT_ID              0x2910
  53
  54 struct android_usb_function {
  55         char *name;
  56         void *config;
  57
  58         struct device *dev;
  59         char *dev_name;
  60         struct device_attribute **attributes;
  61
  62         /* for android_dev.enabled_functions */
  63         struct list_head enabled_list;
  64
  65         /* Optional: initialization during gadget bind */
  66         int (*init)(struct android_usb_function *, struct usb_composite_dev *);
  67         /* Optional: cleanup during gadget unbind */
  68         void (*cleanup)(struct android_usb_function *);
  69         /* Optional: called when the function is added the list of
  70          *              enabled functions */
  71         void (*enable)(struct android_usb_function *);
  72         /* Optional: called when it is removed */
  73         void (*disable)(struct android_usb_function *);
  74
  75         int (*bind_config)(struct android_usb_function *,
  76                            struct usb_configuration *);
  77
  78         /* Optional: called when the configuration is removed */
  79         void (*unbind_config)(struct android_usb_function *,
  80                               struct usb_configuration *);
  81         /* Optional: handle ctrl requests before the device is configured */
  82         int (*ctrlrequest)(struct android_usb_function *,
  83                                         struct usb_composite_dev *,
  84                                         const struct usb_ctrlrequest *);
  85 };
  86
  87 struct android_dev {
  88         struct android_usb_function **functions;
  89         struct list_head enabled_functions;
  90         struct usb_composite_dev *cdev;
  91         struct device *dev;
  92
  93         bool enabled;
  94         int disable_depth;
  95         struct mutex mutex;
  96         bool connected;
  97         bool sw_connected;
  98         struct work_struct work;
  99         char ffs_aliases[256];
 100 };
 101
 102 static struct class *android_class;
 103 static struct android_dev *_android_dev;
 104 static int android_bind_config(struct usb_configuration *c);
 105 static void android_unbind_config(struct usb_configuration *c);
 106
 107 /* string IDs are assigned dynamically */
 108 #define STRING_MANUFACTURER_IDX         0
 109 #define STRING_PRODUCT_IDX              1
 110 #define STRING_SERIAL_IDX               2
 111
 112 static char manufacturer_string[256];
 113 static char product_string[256];
 114 static char serial_string[256];
 115
 116 /* String Table */
 117 static struct usb_string strings_dev[] = {
 118         [STRING_MANUFACTURER_IDX].s = manufacturer_string,
 119         [STRING_PRODUCT_IDX].s = product_string,
 120         [STRING_SERIAL_IDX].s = serial_string,
 121         {  }                    /* end of list */
 122 };
 123
 124 static struct usb_gadget_strings stringtab_dev = {
 125         .language       = 0x0409,       /* en-us */
 126         .strings        = strings_dev,
 127 };
 128
 129 static struct usb_gadget_strings *dev_strings[] = {
 130         &stringtab_dev,
 131         NULL,
 132 };
 133
 134 static struct usb_device_descriptor device_desc = {
 135         .bLength              = sizeof(device_desc),
 136         .bDescriptorType      = USB_DT_DEVICE,
 137         .bcdUSB               = __constant_cpu_to_le16(0x0200),
 138         .bDeviceClass         = USB_CLASS_PER_INTERFACE,
 139         .idVendor             = __constant_cpu_to_le16(VENDOR_ID),
 140         .idProduct            = __constant_cpu_to_le16(PRODUCT_ID),
 141         .bcdDevice            = __constant_cpu_to_le16(0xffff),
 142         .bNumConfigurations   = 1,
 143 };
 144
 145 static struct usb_configuration android_config_driver = {
 146         .label          = "android",
 147         .unbind         = android_unbind_config,
 148         .bConfigurationValue = 1,
 149         .bmAttributes   = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 150         .MaxPower       = 500, /* 500ma */
 151 };
 152
 153 static void android_work(struct work_struct *data)
 154 {
 155         struct android_dev *dev = container_of(data, struct android_dev, work);
 156         struct usb_composite_dev *cdev = dev->cdev;
 157         char *disconnected[2] = { "USB_STATE=DISCONNECTED", NULL };
 158         char *connected[2]    = { "USB_STATE=CONNECTED", NULL };
 159         char *configured[2]   = { "USB_STATE=CONFIGURED", NULL };
 160         char **uevent_envp = NULL;
 161         unsigned long flags;
 162
 163         spin_lock_irqsave(&cdev->lock, flags);
 164         if (cdev->config)
 165                 uevent_envp = configured;
 166         else if (dev->connected != dev->sw_connected)
 167                 uevent_envp = dev->connected ? connected : disconnected;
 168         dev->sw_connected = dev->connected;
 169         spin_unlock_irqrestore(&cdev->lock, flags);
 170
 171         if (uevent_envp) {
 172                 kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, uevent_envp);
 173                 pr_info("%s: sent uevent %s\n", __func__, uevent_envp[0]);
 174         } else {
 175                 pr_info("%s: did not send uevent (%d %d %p)\n", __func__,
 176                          dev->connected, dev->sw_connected, cdev->config);
 177         }
 178 }
 179
 180 static void android_enable(struct android_dev *dev)
 181 {
 182         struct usb_composite_dev *cdev = dev->cdev;
 183
 184         if (WARN_ON(!dev->disable_depth))
 185                 return;
 186
 187         if (--dev->disable_depth == 0) {
 188                 usb_add_config(cdev, &android_config_driver,
 189                                         android_bind_config);
 190                 usb_gadget_connect(cdev->gadget);
 191         }
 192 }
 193
 194 static void android_disable(struct android_dev *dev)
 195 {
 196         struct usb_composite_dev *cdev = dev->cdev;
 197
 198         if (dev->disable_depth++ == 0) {
 199                 usb_gadget_disconnect(cdev->gadget);
 200                 /* Cancel pending control requests */
 201                 usb_ep_dequeue(cdev->gadget->ep0, cdev->req);
 202                 usb_remove_config(cdev, &android_config_driver);
 203         }
 204 }
 205
 206 /*-------------------------------------------------------------------------*/
 207 /* Supported functions initialization */
 208
 209 struct functionfs_config {
 210         bool opened;
 211         bool enabled;
 212         struct ffs_data *data;
 213 };
 214
 215 static int ffs_function_init(struct android_usb_function *f,
 216                              struct usb_composite_dev *cdev)
 217 {
 218         f->config = kzalloc(sizeof(struct functionfs_config), GFP_KERNEL);
 219         if (!f->config)
 220                 return -ENOMEM;
 221
 222         return functionfs_init();
 223 }
 224
 225 static void ffs_function_cleanup(struct android_usb_function *f)
 226 {
 227         functionfs_cleanup();
 228         kfree(f->config);
 229 }
 230
 231 static void ffs_function_enable(struct android_usb_function *f)
 232 {
 233         struct android_dev *dev = _android_dev;
 234         struct functionfs_config *config = f->config;
 235
 236         config->enabled = true;
 237
 238         /* Disable the gadget until the function is ready */
 239         if (!config->opened)
 240                 android_disable(dev);
 241 }
 242
 243 static void ffs_function_disable(struct android_usb_function *f)
 244 {
 245         struct android_dev *dev = _android_dev;
 246         struct functionfs_config *config = f->config;
 247
 248         config->enabled = false;
 249
 250         /* Balance the disable that was called in closed_callback */
 251         if (!config->opened)
 252                 android_enable(dev);
 253 }
 254
 255 static int ffs_function_bind_config(struct android_usb_function *f,
 256                                     struct usb_configuration *c)
 257 {
 258         struct functionfs_config *config = f->config;
 259         return functionfs_bind_config(c->cdev, c, config->data);
 260 }
 261
 262 static ssize_t
 263 ffs_aliases_show(struct device *pdev, struct device_attribute *attr, char *buf)
 264 {
 265         struct android_dev *dev = _android_dev;
 266         int ret;
 267
 268         mutex_lock(&dev->mutex);
 269         ret = sprintf(buf, "%s\n", dev->ffs_aliases);
 270         mutex_unlock(&dev->mutex);
 271
 272         return ret;
 273 }
 274
 275 static ssize_t
 276 ffs_aliases_store(struct device *pdev, struct device_attribute *attr,
 277                                         const char *buf, size_t size)
 278 {
 279         struct android_dev *dev = _android_dev;
 280         char buff[256];
 281
 282         mutex_lock(&dev->mutex);
 283
 284         if (dev->enabled) {
 285                 mutex_unlock(&dev->mutex);
 286                 return -EBUSY;
 287         }
 288
 289         strlcpy(buff, buf, sizeof(buff));
 290         strlcpy(dev->ffs_aliases, strim(buff), sizeof(dev->ffs_aliases));
 291
 292         mutex_unlock(&dev->mutex);
 293
 294         return size;
 295 }
 296
 297 static DEVICE_ATTR(aliases, S_IRUGO | S_IWUSR, ffs_aliases_show,
 298                                                ffs_aliases_store);
 299 static struct device_attribute *ffs_function_attributes[] = {
 300         &dev_attr_aliases,
 301         NULL
 302 };
 303
 304 static struct android_usb_function ffs_function = {
 305         .name           = "ffs",
 306         .init           = ffs_function_init,
 307         .enable         = ffs_function_enable,
 308         .disable        = ffs_function_disable,
 309         .cleanup        = ffs_function_cleanup,
 310         .bind_config    = ffs_function_bind_config,
 311         .attributes     = ffs_function_attributes,
 312 };
 313
 314 static int functionfs_ready_callback(struct ffs_data *ffs)
 315 {
 316         struct android_dev *dev = _android_dev;
 317         struct functionfs_config *config = ffs_function.config;
 318         int ret = 0;
 319
 320         mutex_lock(&dev->mutex);
 321
 322         ret = functionfs_bind(ffs, dev->cdev);
 323         if (ret)
 324                 goto err;
 325
 326         config->data = ffs;
 327         config->opened = true;
 328
 329         if (config->enabled)
 330                 android_enable(dev);
 331
 332 err:
 333         mutex_unlock(&dev->mutex);
 334         return ret;
 335 }
 336
 337 static void functionfs_closed_callback(struct ffs_data *ffs)
 338 {
 339         struct android_dev *dev = _android_dev;
 340         struct functionfs_config *config = ffs_function.config;
 341
 342         mutex_lock(&dev->mutex);
 343
 344         if (config->enabled)
 345                 android_disable(dev);
 346
 347         config->opened = false;
 348         config->data = NULL;
 349
 350         if (!WARN_ON(!ffs->gadget)) {
 351                 dev->cdev->next_string_id -= ffs->strings_count;
 352         }
 353         functionfs_unbind(ffs);
 354
 355         mutex_unlock(&dev->mutex);
 356 }
 357
 358 static void *functionfs_acquire_dev_callback(const char *dev_name)
 359 {
 360         return 0;
 361 }
 362
 363 static void functionfs_release_dev_callback(struct ffs_data *ffs_data)
 364 {
 365 }
 366
 367 #define MAX_ACM_INSTANCES 4
 368 struct acm_function_config {
 369         int instances;
 370         int instances_on;
 371         struct usb_function *f_acm[MAX_ACM_INSTANCES];
 372         struct usb_function_instance *f_acm_inst[MAX_ACM_INSTANCES];
 373 };
 374
 375 static int
 376 acm_function_init(struct android_usb_function *f,
 377                 struct usb_composite_dev *cdev)
 378 {
 379         int i;
 380         int ret;
 381         struct acm_function_config *config;
 382
 383         config = kzalloc(sizeof(struct acm_function_config), GFP_KERNEL);
 384         if (!config)
 385                 return -ENOMEM;
 386         f->config = config;
 387
 388         for (i = 0; i < MAX_ACM_INSTANCES; i++) {
 389                 config->f_acm_inst[i] = usb_get_function_instance("acm");
 390                 if (IS_ERR(config->f_acm_inst[i])) {
 391                         ret = PTR_ERR(config->f_acm_inst[i]);
 392                         goto err_usb_get_function_instance;
 393                 }
 394                 config->f_acm[i] = usb_get_function(config->f_acm_inst[i]);
 395                 if (IS_ERR(config->f_acm[i])) {
 396                         ret = PTR_ERR(config->f_acm[i]);
 397                         goto err_usb_get_function;
 398                 }
 399         }
 400         return 0;
 401 err_usb_get_function_instance:
 402         while (i-- > 0) {
 403                 usb_put_function(config->f_acm[i]);
 404 err_usb_get_function:
 405                 usb_put_function_instance(config->f_acm_inst[i]);
 406         }
 407         return ret;
 408 }
 409
 410 static void acm_function_cleanup(struct android_usb_function *f)
 411 {
 412         int i;
 413         struct acm_function_config *config = f->config;
 414
 415         for (i = 0; i < MAX_ACM_INSTANCES; i++) {
 416                 usb_put_function(config->f_acm[i]);
 417                 usb_put_function_instance(config->f_acm_inst[i]);
 418         }
 419         kfree(f->config);
 420         f->config = NULL;
 421 }
 422
 423 static int
 424 acm_function_bind_config(struct android_usb_function *f,
 425                 struct usb_configuration *c)
 426 {
 427         int i;
 428         int ret = 0;
 429         struct acm_function_config *config = f->config;
 430
 431         config->instances_on = config->instances;
 432         for (i = 0; i < config->instances_on; i++) {
 433                 ret = usb_add_function(c, config->f_acm[i]);
 434                 if (ret) {
 435                         pr_err("Could not bind acm%u config\n", i);
 436                         goto err_usb_add_function;
 437                 }
 438         }
 439
 440         return 0;
 441
 442 err_usb_add_function:
 443         while (i-- > 0)
 444                 usb_remove_function(c, config->f_acm[i]);
 445         return ret;
 446 }
 447
 448 static void acm_function_unbind_config(struct android_usb_function *f,
 449                                        struct usb_configuration *c)
 450 {
 451         int i;
 452         struct acm_function_config *config = f->config;
 453
 454         for (i = 0; i < config->instances_on; i++)
 455                 usb_remove_function(c, config->f_acm[i]);
 456 }
 457
 458 static ssize_t acm_instances_show(struct device *dev,
 459                 struct device_attribute *attr, char *buf)
 460 {
 461         struct android_usb_function *f = dev_get_drvdata(dev);
 462         struct acm_function_config *config = f->config;
 463         return sprintf(buf, "%d\n", config->instances);
 464 }
 465
 466 static ssize_t acm_instances_store(struct device *dev,
 467                 struct device_attribute *attr, const char *buf, size_t size)
 468 {
 469         struct android_usb_function *f = dev_get_drvdata(dev);
 470         struct acm_function_config *config = f->config;
 471         int value;
 472
 473         sscanf(buf, "%d", &value);
 474         if (value > MAX_ACM_INSTANCES)
 475                 value = MAX_ACM_INSTANCES;
 476         config->instances = value;
 477         return size;
 478 }
 479
 480 static DEVICE_ATTR(instances, S_IRUGO | S_IWUSR, acm_instances_show,
 481                                                  acm_instances_store);
 482 static struct device_attribute *acm_function_attributes[] = {
 483         &dev_attr_instances,
 484         NULL
 485 };
 486
 487 static struct android_usb_function acm_function = {
 488         .name           = "acm",
 489         .init           = acm_function_init,
 490         .cleanup        = acm_function_cleanup,
 491         .bind_config    = acm_function_bind_config,
 492         .unbind_config  = acm_function_unbind_config,
 493         .attributes     = acm_function_attributes,
 494 };
 495
 496
 497 static int
 498 mtp_function_init(struct android_usb_function *f,
 499                 struct usb_composite_dev *cdev)
 500 {
 501         return mtp_setup();
 502 }
 503
 504 static void mtp_function_cleanup(struct android_usb_function *f)
 505 {
 506         mtp_cleanup();
 507 }
 508
 509 static int
 510 mtp_function_bind_config(struct android_usb_function *f,
 511                 struct usb_configuration *c)
 512 {
 513         return mtp_bind_config(c, false);
 514 }
 515
 516 static int
 517 ptp_function_init(struct android_usb_function *f,
 518                 struct usb_composite_dev *cdev)
 519 {
 520         /* nothing to do - initialization is handled by mtp_function_init */
 521         return 0;
 522 }
 523
 524 static void ptp_function_cleanup(struct android_usb_function *f)
 525 {
 526         /* nothing to do - cleanup is handled by mtp_function_cleanup */
 527 }
 528
 529 static int
 530 ptp_function_bind_config(struct android_usb_function *f,
 531                 struct usb_configuration *c)
 532 {
 533         return mtp_bind_config(c, true);
 534 }
 535
 536 static int mtp_function_ctrlrequest(struct android_usb_function *f,
 537                                         struct usb_composite_dev *cdev,
 538                                         const struct usb_ctrlrequest *c)
 539 {
 540         return mtp_ctrlrequest(cdev, c);
 541 }
 542
 543 static struct android_usb_function mtp_function = {
 544         .name           = "mtp",
 545         .init           = mtp_function_init,
 546         .cleanup        = mtp_function_cleanup,
 547         .bind_config    = mtp_function_bind_config,
 548         .ctrlrequest    = mtp_function_ctrlrequest,
 549 };
 550
 551 /* PTP function is same as MTP with slightly different interface descriptor */
 552 static struct android_usb_function ptp_function = {
 553         .name           = "ptp",
 554         .init           = ptp_function_init,
 555         .cleanup        = ptp_function_cleanup,
 556         .bind_config    = ptp_function_bind_config,
 557 };
 558
 559
 560 struct rndis_function_config {
 561         u8      ethaddr[ETH_ALEN];
 562         u32     vendorID;
 563         char    manufacturer[256];
 564         /* "Wireless" RNDIS; auto-detected by Windows */
 565         bool    wceis;
 566         struct eth_dev *dev;
 567 };
 568
 569 static int
 570 rndis_function_init(struct android_usb_function *f,
 571                 struct usb_composite_dev *cdev)
 572 {
 573         f->config = kzalloc(sizeof(struct rndis_function_config), GFP_KERNEL);
 574         if (!f->config)
 575                 return -ENOMEM;
 576         return 0;
 577 }
 578
 579 static void rndis_function_cleanup(struct android_usb_function *f)
 580 {
 581         kfree(f->config);
 582         f->config = NULL;
 583 }
 584
 585 static int
 586 rndis_function_bind_config(struct android_usb_function *f,
 587                 struct usb_configuration *c)
 588 {
 589         int ret;
 590         struct eth_dev *dev;
 591         struct rndis_function_config *rndis = f->config;
 592
 593         if (!rndis) {
 594                 pr_err("%s: rndis_pdata\n", __func__);
 595                 return -1;
 596         }
 597
 598         pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
 599                 rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
 600                 rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
 601
 602         dev = gether_setup_name(c->cdev->gadget, rndis->ethaddr, "rndis");
 603         if (IS_ERR(dev)) {
 604                 ret = PTR_ERR(dev);
 605                 pr_err("%s: gether_setup failed\n", __func__);
 606                 return ret;
 607         }
 608         rndis->dev = dev;
 609
 610         if (rndis->wceis) {
 611                 /* "Wireless" RNDIS; auto-detected by Windows */
 612                 rndis_iad_descriptor.bFunctionClass =
 613                                                 USB_CLASS_WIRELESS_CONTROLLER;
 614                 rndis_iad_descriptor.bFunctionSubClass = 0x01;
 615                 rndis_iad_descriptor.bFunctionProtocol = 0x03;
 616                 rndis_control_intf.bInterfaceClass =
 617                                                 USB_CLASS_WIRELESS_CONTROLLER;
 618                 rndis_control_intf.bInterfaceSubClass =  0x01;
 619                 rndis_control_intf.bInterfaceProtocol =  0x03;
 620         }
 621
 622         return rndis_bind_config_vendor(c, rndis->ethaddr, rndis->vendorID,
 623                                            rndis->manufacturer, rndis->dev);
 624 }
 625
 626 static void rndis_function_unbind_config(struct android_usb_function *f,
 627                                                 struct usb_configuration *c)
 628 {
 629         struct rndis_function_config *rndis = f->config;
 630         gether_cleanup(rndis->dev);
 631 }
 632
 633 static ssize_t rndis_manufacturer_show(struct device *dev,
 634                 struct device_attribute *attr, char *buf)
 635 {
 636         struct android_usb_function *f = dev_get_drvdata(dev);
 637         struct rndis_function_config *config = f->config;
 638         return sprintf(buf, "%s\n", config->manufacturer);
 639 }
 640
 641 static ssize_t rndis_manufacturer_store(struct device *dev,
 642                 struct device_attribute *attr, const char *buf, size_t size)
 643 {
 644         struct android_usb_function *f = dev_get_drvdata(dev);
 645         struct rndis_function_config *config = f->config;
 646
 647         if (size >= sizeof(config->manufacturer))
 648                 return -EINVAL;
 649         if (sscanf(buf, "%s", config->manufacturer) == 1)
 650                 return size;
 651         return -1;
 652 }
 653
 654 static DEVICE_ATTR(manufacturer, S_IRUGO | S_IWUSR, rndis_manufacturer_show,
 655                                                     rndis_manufacturer_store);
 656
 657 static ssize_t rndis_wceis_show(struct device *dev,
 658                 struct device_attribute *attr, char *buf)
 659 {
 660         struct android_usb_function *f = dev_get_drvdata(dev);
 661         struct rndis_function_config *config = f->config;
 662         return sprintf(buf, "%d\n", config->wceis);
 663 }
 664
 665 static ssize_t rndis_wceis_store(struct device *dev,
 666                 struct device_attribute *attr, const char *buf, size_t size)
 667 {
 668         struct android_usb_function *f = dev_get_drvdata(dev);
 669         struct rndis_function_config *config = f->config;
 670         int value;
 671
 672         if (sscanf(buf, "%d", &value) == 1) {
 673                 config->wceis = value;
 674                 return size;
 675         }
 676         return -EINVAL;
 677 }
 678
 679 static DEVICE_ATTR(wceis, S_IRUGO | S_IWUSR, rndis_wceis_show,
 680                                              rndis_wceis_store);
 681
 682 static ssize_t rndis_ethaddr_show(struct device *dev,
 683                 struct device_attribute *attr, char *buf)
 684 {
 685         struct android_usb_function *f = dev_get_drvdata(dev);
 686         struct rndis_function_config *rndis = f->config;
 687         return sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
 688                 rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
 689                 rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
 690 }
 691
 692 static ssize_t rndis_ethaddr_store(struct device *dev,
 693                 struct device_attribute *attr, const char *buf, size_t size)
 694 {
 695         struct android_usb_function *f = dev_get_drvdata(dev);
 696         struct rndis_function_config *rndis = f->config;
 697
 698         if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
 699                     (int *)&rndis->ethaddr[0], (int *)&rndis->ethaddr[1],
 700                     (int *)&rndis->ethaddr[2], (int *)&rndis->ethaddr[3],
 701                     (int *)&rndis->ethaddr[4], (int *)&rndis->ethaddr[5]) == 6)
 702                 return size;
 703         return -EINVAL;
 704 }
 705
 706 static DEVICE_ATTR(ethaddr, S_IRUGO | S_IWUSR, rndis_ethaddr_show,
 707                                                rndis_ethaddr_store);
 708
 709 static ssize_t rndis_vendorID_show(struct device *dev,
 710                 struct device_attribute *attr, char *buf)
 711 {
 712         struct android_usb_function *f = dev_get_drvdata(dev);
 713         struct rndis_function_config *config = f->config;
 714         return sprintf(buf, "%04x\n", config->vendorID);
 715 }
 716
 717 static ssize_t rndis_vendorID_store(struct device *dev,
 718                 struct device_attribute *attr, const char *buf, size_t size)
 719 {
 720         struct android_usb_function *f = dev_get_drvdata(dev);
 721         struct rndis_function_config *config = f->config;
 722         int value;
 723
 724         if (sscanf(buf, "%04x", &value) == 1) {
 725                 config->vendorID = value;
 726                 return size;
 727         }
 728         return -EINVAL;
 729 }
 730
 731 static DEVICE_ATTR(vendorID, S_IRUGO | S_IWUSR, rndis_vendorID_show,
 732                                                 rndis_vendorID_store);
 733
 734 static struct device_attribute *rndis_function_attributes[] = {
 735         &dev_attr_manufacturer,
 736         &dev_attr_wceis,
 737         &dev_attr_ethaddr,
 738         &dev_attr_vendorID,
 739         NULL
 740 };
 741
 742 static struct android_usb_function rndis_function = {
 743         .name           = "rndis",
 744         .init           = rndis_function_init,
 745         .cleanup        = rndis_function_cleanup,
 746         .bind_config    = rndis_function_bind_config,
 747         .unbind_config  = rndis_function_unbind_config,
 748         .attributes     = rndis_function_attributes,
 749 };
 750
 751
 752 struct mass_storage_function_config {
 753         struct fsg_config fsg;
 754         struct fsg_common *common;
 755 };
 756
 757 static int mass_storage_function_init(struct android_usb_function *f,
 758                                         struct usb_composite_dev *cdev)
 759 {
 760         struct mass_storage_function_config *config;
 761         struct fsg_common *common;
 762         int err, i;
 763         const char *name[2];
 764
 765         config = kzalloc(sizeof(struct mass_storage_function_config),
 766                                                                 GFP_KERNEL);
 767         if (!config)
 768                 return -ENOMEM;
 769
 770         config->fsg.nluns = 2;
 771         name[0] = "lun";
 772         name[1] = "lun1";
 773         for (i = 0; i < config->fsg.nluns; i++) {
 774                 config->fsg.luns[i].removable = 1;
 775                 config->fsg.luns[i].nofua = 1;
 776         }
 777
 778         common = fsg_common_init(NULL, cdev, &config->fsg);
 779         if (IS_ERR(common)) {
 780                 kfree(config);
 781                 return PTR_ERR(common);
 782         }
 783
 784         for (i = 0; i < config->fsg.nluns; i++) {
 785                 err = sysfs_create_link(&f->dev->kobj,
 786                                         &common->luns[i].dev.kobj,
 787                                         name[i]);
 788                 if (err)
 789                         goto error;
 790         }
 791
 792         config->common = common;
 793         f->config = config;
 794         return 0;
 795 error:
 796         for (; i > 0 ; i--)
 797                 sysfs_remove_link(&f->dev->kobj, name[i-1]);
 798         fsg_common_release(&common->ref);
 799         kfree(config);
 800         return err;
 801 }
 802
 803 static void mass_storage_function_cleanup(struct android_usb_function *f)
 804 {
 805         kfree(f->config);
 806         f->config = NULL;
 807 }
 808
 809 static int mass_storage_function_bind_config(struct android_usb_function *f,
 810                                                 struct usb_configuration *c)
 811 {
 812         struct mass_storage_function_config *config = f->config;
 813         return fsg_bind_config(c->cdev, c, config->common);
 814 }
 815
 816 static ssize_t mass_storage_inquiry_show(struct device *dev,
 817                                 struct device_attribute *attr, char *buf)
 818 {
 819         struct android_usb_function *f = dev_get_drvdata(dev);
 820         struct mass_storage_function_config *config = f->config;
 821         return sprintf(buf, "%s\n", config->common->inquiry_string);
 822 }
 823
 824 static ssize_t mass_storage_inquiry_store(struct device *dev,
 825                 struct device_attribute *attr, const char *buf, size_t size)
 826 {
 827         struct android_usb_function *f = dev_get_drvdata(dev);
 828         struct mass_storage_function_config *config = f->config;
 829         if (size >= sizeof(config->common->inquiry_string))
 830                 return -EINVAL;
 831         if (sscanf(buf, "%s", config->common->inquiry_string) != 1)
 832                 return -EINVAL;
 833         return size;
 834 }
 835
 836 static DEVICE_ATTR(inquiry_string, S_IRUGO | S_IWUSR,
 837                                         mass_storage_inquiry_show,
 838                                         mass_storage_inquiry_store);
 839
 840 static struct device_attribute *mass_storage_function_attributes[] = {
 841         &dev_attr_inquiry_string,
 842         NULL
 843 };
 844
 845 static struct android_usb_function mass_storage_function = {
 846         .name           = "mass_storage",
 847         .init           = mass_storage_function_init,
 848         .cleanup        = mass_storage_function_cleanup,
 849         .bind_config    = mass_storage_function_bind_config,
 850         .attributes     = mass_storage_function_attributes,
 851 };
 852
 853
 854 static int accessory_function_init(struct android_usb_function *f,
 855                                         struct usb_composite_dev *cdev)
 856 {
 857         return acc_setup();
 858 }
 859
 860 static void accessory_function_cleanup(struct android_usb_function *f)
 861 {
 862         acc_cleanup();
 863 }
 864
 865 static int accessory_function_bind_config(struct android_usb_function *f,
 866                                                 struct usb_configuration *c)
 867 {
 868         return acc_bind_config(c);
 869 }
 870
 871 static int accessory_function_ctrlrequest(struct android_usb_function *f,
 872                                                 struct usb_composite_dev *cdev,
 873                                                 const struct usb_ctrlrequest *c)
 874 {
 875         return acc_ctrlrequest(cdev, c);
 876 }
 877
 878 static struct android_usb_function accessory_function = {
 879         .name           = "accessory",
 880         .init           = accessory_function_init,
 881         .cleanup        = accessory_function_cleanup,
 882         .bind_config    = accessory_function_bind_config,
 883         .ctrlrequest    = accessory_function_ctrlrequest,
 884 };
 885
 886 static int audio_source_function_init(struct android_usb_function *f,
 887                         struct usb_composite_dev *cdev)
 888 {
 889         struct audio_source_config *config;
 890
 891         config = kzalloc(sizeof(struct audio_source_config), GFP_KERNEL);
 892         if (!config)
 893                 return -ENOMEM;
 894         config->card = -1;
 895         config->device = -1;
 896         f->config = config;
 897         return 0;
 898 }
 899
 900 static void audio_source_function_cleanup(struct android_usb_function *f)
 901 {
 902         kfree(f->config);
 903 }
 904
 905 static int audio_source_function_bind_config(struct android_usb_function *f,
 906                                                 struct usb_configuration *c)
 907 {
 908         struct audio_source_config *config = f->config;
 909
 910         return audio_source_bind_config(c, config);
 911 }
 912
 913 static void audio_source_function_unbind_config(struct android_usb_function *f,
 914                                                 struct usb_configuration *c)
 915 {
 916         struct audio_source_config *config = f->config;
 917
 918         config->card = -1;
 919         config->device = -1;
 920 }
 921
 922 static ssize_t audio_source_pcm_show(struct device *dev,
 923                 struct device_attribute *attr, char *buf)
 924 {
 925         struct android_usb_function *f = dev_get_drvdata(dev);
 926         struct audio_source_config *config = f->config;
 927
 928         /* print PCM card and device numbers */
 929         return sprintf(buf, "%d %d\n", config->card, config->device);
 930 }
 931
 932 static DEVICE_ATTR(pcm, S_IRUGO, audio_source_pcm_show, NULL);
 933
 934 static struct device_attribute *audio_source_function_attributes[] = {
 935         &dev_attr_pcm,
 936         NULL
 937 };
 938
 939 static struct android_usb_function audio_source_function = {
 940         .name           = "audio_source",
 941         .init           = audio_source_function_init,
 942         .cleanup        = audio_source_function_cleanup,
 943         .bind_config    = audio_source_function_bind_config,
 944         .unbind_config  = audio_source_function_unbind_config,
 945         .attributes     = audio_source_function_attributes,
 946 };
 947
 948 static struct android_usb_function *supported_functions[] = {
 949         &ffs_function,
 950         &acm_function,
 951         &mtp_function,
 952         &ptp_function,
 953         &rndis_function,
 954         &mass_storage_function,
 955         &accessory_function,
 956         &audio_source_function,
 957         NULL
 958 };
 959
 960
 961 static int android_init_functions(struct android_usb_function **functions,
 962                                   struct usb_composite_dev *cdev)
 963 {
 964         struct android_dev *dev = _android_dev;
 965         struct android_usb_function *f;
 966         struct device_attribute **attrs;
 967         struct device_attribute *attr;
 968         int err;
 969         int index = 0;
 970
 971         for (; (f = *functions++); index++) {
 972                 f->dev_name = kasprintf(GFP_KERNEL, "f_%s", f->name);
 973                 f->dev = device_create(android_class, dev->dev,
 974                                 MKDEV(0, index), f, f->dev_name);
 975                 if (IS_ERR(f->dev)) {
 976                         pr_err("%s: Failed to create dev %s", __func__,
 977                                                         f->dev_name);
 978                         err = PTR_ERR(f->dev);
 979                         goto err_create;
 980                 }
 981
 982                 if (f->init) {
 983                         err = f->init(f, cdev);
 984                         if (err) {
 985                                 pr_err("%s: Failed to init %s", __func__,
 986                                                                 f->name);
 987                                 goto err_out;
 988                         }
 989                 }
 990
 991                 attrs = f->attributes;
 992                 if (attrs) {
 993                         while ((attr = *attrs++) && !err)
 994                                 err = device_create_file(f->dev, attr);
 995                 }
 996                 if (err) {
 997                         pr_err("%s: Failed to create function %s attributes",
 998                                         __func__, f->name);
 999                         goto err_out;
1000                 }
1001         }
1002         return 0;
1003
1004 err_out:
1005         device_destroy(android_class, f->dev->devt);
1006 err_create:
1007         kfree(f->dev_name);
1008         return err;
1009 }
1010
1011 static void android_cleanup_functions(struct android_usb_function **functions)
1012 {
1013         struct android_usb_function *f;
1014
1015         while (*functions) {
1016                 f = *functions++;
1017
1018                 if (f->dev) {
1019                         device_destroy(android_class, f->dev->devt);
1020                         kfree(f->dev_name);
1021                 }
1022
1023                 if (f->cleanup)
1024                         f->cleanup(f);
1025         }
1026 }
1027
1028 static int
1029 android_bind_enabled_functions(struct android_dev *dev,
1030                                struct usb_configuration *c)
1031 {
1032         struct android_usb_function *f;
1033         int ret;
1034
1035         list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1036                 ret = f->bind_config(f, c);
1037                 if (ret) {
1038                         pr_err("%s: %s failed", __func__, f->name);
1039                         return ret;
1040                 }
1041         }
1042         return 0;
1043 }
1044
1045 static void
1046 android_unbind_enabled_functions(struct android_dev *dev,
1047                                struct usb_configuration *c)
1048 {
1049         struct android_usb_function *f;
1050
1051         list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1052                 if (f->unbind_config)
1053                         f->unbind_config(f, c);
1054         }
1055 }
1056
1057 static int android_enable_function(struct android_dev *dev, char *name)
1058 {
1059         struct android_usb_function **functions = dev->functions;
1060         struct android_usb_function *f;
1061         while ((f = *functions++)) {
1062                 if (!strcmp(name, f->name)) {
1063                         list_add_tail(&f->enabled_list,
1064                                                 &dev->enabled_functions);
1065                         return 0;
1066                 }
1067         }
1068         return -EINVAL;
1069 }
1070
1071 /*-------------------------------------------------------------------------*/
1072 /* /sys/class/android_usb/android%d/ interface */
1073
1074 static ssize_t
1075 functions_show(struct device *pdev, struct device_attribute *attr, char *buf)
1076 {
1077         struct android_dev *dev = dev_get_drvdata(pdev);
1078         struct android_usb_function *f;
1079         char *buff = buf;
1080
1081         mutex_lock(&dev->mutex);
1082
1083         list_for_each_entry(f, &dev->enabled_functions, enabled_list)
1084                 buff += sprintf(buff, "%s,", f->name);
1085
1086         mutex_unlock(&dev->mutex);
1087
1088         if (buff != buf)
1089                 *(buff-1) = '\n';
1090         return buff - buf;
1091 }
1092
1093 static ssize_t
1094 functions_store(struct device *pdev, struct device_attribute *attr,
1095                                const char *buff, size_t size)
1096 {
1097         struct android_dev *dev = dev_get_drvdata(pdev);
1098         char *name;
1099         char buf[256], *b;
1100         char aliases[256], *a;
1101         int err;
1102         int is_ffs;
1103         int ffs_enabled = 0;
1104
1105         mutex_lock(&dev->mutex);
1106
1107         if (dev->enabled) {
1108                 mutex_unlock(&dev->mutex);
1109                 return -EBUSY;
1110         }
1111
1112         INIT_LIST_HEAD(&dev->enabled_functions);
1113
1114         strlcpy(buf, buff, sizeof(buf));
1115         b = strim(buf);
1116
1117         while (b) {
1118                 name = strsep(&b, ",");
1119                 if (!name)
1120                         continue;
1121
1122                 is_ffs = 0;
1123                 strlcpy(aliases, dev->ffs_aliases, sizeof(aliases));
1124                 a = aliases;
1125
1126                 while (a) {
1127                         char *alias = strsep(&a, ",");
1128                         if (alias && !strcmp(name, alias)) {
1129                                 is_ffs = 1;
1130                                 break;
1131                         }
1132                 }
1133
1134                 if (is_ffs) {
1135                         if (ffs_enabled)
1136                                 continue;
1137                         err = android_enable_function(dev, "ffs");
1138                         if (err)
1139                                 pr_err("android_usb: Cannot enable ffs (%d)",
1140                                                                         err);
1141                         else
1142                                 ffs_enabled = 1;
1143                         continue;
1144                 }
1145
1146                 err = android_enable_function(dev, name);
1147                 if (err)
1148                         pr_err("android_usb: Cannot enable '%s' (%d)",
1149                                                            name, err);
1150         }
1151
1152         mutex_unlock(&dev->mutex);
1153
1154         return size;
1155 }
1156
1157 static ssize_t enable_show(struct device *pdev, struct device_attribute *attr,
1158                            char *buf)
1159 {
1160         struct android_dev *dev = dev_get_drvdata(pdev);
1161         return sprintf(buf, "%d\n", dev->enabled);
1162 }
1163
1164 static ssize_t enable_store(struct device *pdev, struct device_attribute *attr,
1165                             const char *buff, size_t size)
1166 {
1167         struct android_dev *dev = dev_get_drvdata(pdev);
1168         struct usb_composite_dev *cdev = dev->cdev;
1169         struct android_usb_function *f;
1170         int enabled = 0;
1171
1172
1173         if (!cdev)
1174                 return -ENODEV;
1175
1176         mutex_lock(&dev->mutex);
1177
1178         sscanf(buff, "%d", &enabled);
1179         if (enabled && !dev->enabled) {
1180                 /*
1181                  * Update values in composite driver's copy of
1182                  * device descriptor.
1183                  */
1184                 cdev->desc.idVendor = device_desc.idVendor;
1185                 cdev->desc.idProduct = device_desc.idProduct;
1186                 cdev->desc.bcdDevice = device_desc.bcdDevice;
1187                 cdev->desc.bDeviceClass = device_desc.bDeviceClass;
1188                 cdev->desc.bDeviceSubClass = device_desc.bDeviceSubClass;
1189                 cdev->desc.bDeviceProtocol = device_desc.bDeviceProtocol;
1190                 list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1191                         if (f->enable)
1192                                 f->enable(f);
1193                 }
1194                 android_enable(dev);
1195                 dev->enabled = true;
1196         } else if (!enabled && dev->enabled) {
1197                 android_disable(dev);
1198                 list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1199                         if (f->disable)
1200                                 f->disable(f);
1201                 }
1202                 dev->enabled = false;
1203         } else {
1204                 pr_err("android_usb: already %s\n",
1205                                 dev->enabled ? "enabled" : "disabled");
1206         }
1207
1208         mutex_unlock(&dev->mutex);
1209         return size;
1210 }
1211
1212 static ssize_t state_show(struct device *pdev, struct device_attribute *attr,
1213                            char *buf)
1214 {
1215         struct android_dev *dev = dev_get_drvdata(pdev);
1216         struct usb_composite_dev *cdev = dev->cdev;
1217         char *state = "DISCONNECTED";
1218         unsigned long flags;
1219
1220         if (!cdev)
1221                 goto out;
1222
1223         spin_lock_irqsave(&cdev->lock, flags);
1224         if (cdev->config)
1225                 state = "CONFIGURED";
1226         else if (dev->connected)
1227                 state = "CONNECTED";
1228         spin_unlock_irqrestore(&cdev->lock, flags);
1229 out:
1230         return sprintf(buf, "%s\n", state);
1231 }
1232
1233 #define DESCRIPTOR_ATTR(field, format_string)                           \
1234 static ssize_t                                                          \
1235 field ## _show(struct device *dev, struct device_attribute *attr,       \
1236                 char *buf)                                              \
1237 {                                                                       \
1238         return sprintf(buf, format_string, device_desc.field);          \
1239 }                                                                       \
1240 static ssize_t                                                          \
1241 field ## _store(struct device *dev, struct device_attribute *attr,      \
1242                 const char *buf, size_t size)                           \
1243 {                                                                       \
1244         int value;                                                      \
1245         if (sscanf(buf, format_string, &value) == 1) {                  \
1246                 device_desc.field = value;                              \
1247                 return size;                                            \
1248         }                                                               \
1249         return -1;                                                      \
1250 }                                                                       \
1251 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
1252
1253 #define DESCRIPTOR_STRING_ATTR(field, buffer)                           \
1254 static ssize_t                                                          \
1255 field ## _show(struct device *dev, struct device_attribute *attr,       \
1256                 char *buf)                                              \
1257 {                                                                       \
1258         return sprintf(buf, "%s", buffer);                              \
1259 }                                                                       \
1260 static ssize_t                                                          \
1261 field ## _store(struct device *dev, struct device_attribute *attr,      \
1262                 const char *buf, size_t size)                           \
1263 {                                                                       \
1264         if (size >= sizeof(buffer))                                     \
1265                 return -EINVAL;                                         \
1266         return strlcpy(buffer, buf, sizeof(buffer));                    \
1267 }                                                                       \
1268 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
1269
1270
1271 DESCRIPTOR_ATTR(idVendor, "%04x\n")
1272 DESCRIPTOR_ATTR(idProduct, "%04x\n")
1273 DESCRIPTOR_ATTR(bcdDevice, "%04x\n")
1274 DESCRIPTOR_ATTR(bDeviceClass, "%d\n")
1275 DESCRIPTOR_ATTR(bDeviceSubClass, "%d\n")
1276 DESCRIPTOR_ATTR(bDeviceProtocol, "%d\n")
1277 DESCRIPTOR_STRING_ATTR(iManufacturer, manufacturer_string)
1278 DESCRIPTOR_STRING_ATTR(iProduct, product_string)
1279 DESCRIPTOR_STRING_ATTR(iSerial, serial_string)
1280
1281 static DEVICE_ATTR(functions, S_IRUGO | S_IWUSR, functions_show,
1282                                                  functions_store);
1283 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, enable_show, enable_store);
1284 static DEVICE_ATTR(state, S_IRUGO, state_show, NULL);
1285
1286 static struct device_attribute *android_usb_attributes[] = {
1287         &dev_attr_idVendor,
1288         &dev_attr_idProduct,
1289         &dev_attr_bcdDevice,
1290         &dev_attr_bDeviceClass,
1291         &dev_attr_bDeviceSubClass,
1292         &dev_attr_bDeviceProtocol,
1293         &dev_attr_iManufacturer,
1294         &dev_attr_iProduct,
1295         &dev_attr_iSerial,
1296         &dev_attr_functions,
1297         &dev_attr_enable,
1298         &dev_attr_state,
1299         NULL
1300 };
1301
1302 /*-------------------------------------------------------------------------*/
1303 /* Composite driver */
1304
1305 static int android_bind_config(struct usb_configuration *c)
1306 {
1307         struct android_dev *dev = _android_dev;
1308         int ret = 0;
1309
1310         ret = android_bind_enabled_functions(dev, c);
1311         if (ret)
1312                 return ret;
1313
1314         return 0;
1315 }
1316
1317 static void android_unbind_config(struct usb_configuration *c)
1318 {
1319         struct android_dev *dev = _android_dev;
1320
1321         android_unbind_enabled_functions(dev, c);
1322 }
1323
1324 static int android_bind(struct usb_composite_dev *cdev)
1325 {
1326         struct android_dev *dev = _android_dev;
1327         struct usb_gadget       *gadget = cdev->gadget;
1328         int                     id, ret;
1329
1330         /*
1331          * Start disconnected. Userspace will connect the gadget once
1332          * it is done configuring the functions.
1333          */
1334         usb_gadget_disconnect(gadget);
1335
1336         ret = android_init_functions(dev->functions, cdev);
1337         if (ret)
1338                 return ret;
1339
1340         /* Allocate string descriptor numbers ... note that string
1341          * contents can be overridden by the composite_dev glue.
1342          */
1343         id = usb_string_id(cdev);
1344         if (id < 0)
1345                 return id;
1346         strings_dev[STRING_MANUFACTURER_IDX].id = id;
1347         device_desc.iManufacturer = id;
1348
1349         id = usb_string_id(cdev);
1350         if (id < 0)
1351                 return id;
1352         strings_dev[STRING_PRODUCT_IDX].id = id;
1353         device_desc.iProduct = id;
1354
1355         /* Default strings - should be updated by userspace */
1356         strncpy(manufacturer_string, "Android", sizeof(manufacturer_string)-1);
1357         strncpy(product_string, "Android", sizeof(product_string) - 1);
1358         strncpy(serial_string, "0123456789ABCDEF", sizeof(serial_string) - 1);
1359
1360         id = usb_string_id(cdev);
1361         if (id < 0)
1362                 return id;
1363         strings_dev[STRING_SERIAL_IDX].id = id;
1364         device_desc.iSerialNumber = id;
1365         device_desc.bcdDevice = cpu_to_le16(get_default_bcdDevice());
1366
1367         usb_gadget_set_selfpowered(gadget);
1368         dev->cdev = cdev;
1369
1370         return 0;
1371 }
1372
1373 static int android_usb_unbind(struct usb_composite_dev *cdev)
1374 {
1375         struct android_dev *dev = _android_dev;
1376
1377         cancel_work_sync(&dev->work);
1378         android_cleanup_functions(dev->functions);
1379         return 0;
1380 }
1381
1382 /* HACK: android needs to override setup for accessory to work */
1383 static int (*composite_setup_func)(struct usb_gadget *gadget, const struct usb_ctrlrequest *c);
1384
1385 static int
1386 android_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c)
1387 {
1388         struct android_dev              *dev = _android_dev;
1389         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
1390         struct usb_request              *req = cdev->req;
1391         struct android_usb_function     *f;
1392         int value = -EOPNOTSUPP;
1393         unsigned long flags;
1394
1395         req->zero = 0;
1396         req->length = 0;
1397         gadget->ep0->driver_data = cdev;
1398
1399         list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1400                 if (f->ctrlrequest) {
1401                         value = f->ctrlrequest(f, cdev, c);
1402                         if (value >= 0)
1403                                 break;
1404                 }
1405         }
1406
1407         /* Special case the accessory function.
1408          * It needs to handle control requests before it is enabled.
1409          */
1410         if (value < 0)
1411                 value = acc_ctrlrequest(cdev, c);
1412
1413         if (value < 0)
1414                 value = composite_setup_func(gadget, c);
1415
1416         spin_lock_irqsave(&cdev->lock, flags);
1417         if (!dev->connected) {
1418                 dev->connected = 1;
1419                 schedule_work(&dev->work);
1420         } else if (c->bRequest == USB_REQ_SET_CONFIGURATION &&
1421                                                 cdev->config) {
1422                 schedule_work(&dev->work);
1423         }
1424         spin_unlock_irqrestore(&cdev->lock, flags);
1425
1426         return value;
1427 }
1428
1429 static void android_disconnect(struct usb_composite_dev *cdev)
1430 {
1431         struct android_dev *dev = _android_dev;
1432
1433         /* accessory HID support can be active while the
1434            accessory function is not actually enabled,
1435            so we need to inform it when we are disconnected.
1436          */
1437         acc_disconnect();
1438
1439         dev->connected = 0;
1440         schedule_work(&dev->work);
1441 }
1442
1443 static struct usb_composite_driver android_usb_driver = {
1444         .name           = "android_usb",
1445         .dev            = &device_desc,
1446         .strings        = dev_strings,
1447         .bind           = android_bind,
1448         .unbind         = android_usb_unbind,
1449         .disconnect     = android_disconnect,
1450         .max_speed      = USB_SPEED_HIGH,
1451 };
1452
1453 static int android_create_device(struct android_dev *dev)
1454 {
1455         struct device_attribute **attrs = android_usb_attributes;
1456         struct device_attribute *attr;
1457         int err;
1458
1459         dev->dev = device_create(android_class, NULL,
1460                                         MKDEV(0, 0), NULL, "android0");
1461         if (IS_ERR(dev->dev))
1462                 return PTR_ERR(dev->dev);
1463
1464         dev_set_drvdata(dev->dev, dev);
1465
1466         while ((attr = *attrs++)) {
1467                 err = device_create_file(dev->dev, attr);
1468                 if (err) {
1469                         device_destroy(android_class, dev->dev->devt);
1470                         return err;
1471                 }
1472         }
1473         return 0;
1474 }
1475
1476
1477 static int __init init(void)
1478 {
1479         struct android_dev *dev;
1480         int err;
1481
1482         android_class = class_create(THIS_MODULE, "android_usb");
1483         if (IS_ERR(android_class))
1484                 return PTR_ERR(android_class);
1485
1486         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1487         if (!dev) {
1488                 err = -ENOMEM;
1489                 goto err_dev;
1490         }
1491
1492         dev->disable_depth = 1;
1493         dev->functions = supported_functions;
1494         INIT_LIST_HEAD(&dev->enabled_functions);
1495         INIT_WORK(&dev->work, android_work);
1496         mutex_init(&dev->mutex);
1497
1498         err = android_create_device(dev);
1499         if (err) {
1500                 pr_err("%s: failed to create android device %d", __func__, err);
1501                 goto err_create;
1502         }
1503
1504         _android_dev = dev;
1505
1506         err = usb_composite_probe(&android_usb_driver);
1507         if (err) {
1508                 pr_err("%s: failed to probe driver %d", __func__, err);
1509                 goto err_probe;
1510         }
1511
1512         /* HACK: exchange composite's setup with ours */
1513         composite_setup_func = android_usb_driver.gadget_driver.setup;
1514         android_usb_driver.gadget_driver.setup = android_setup;
1515
1516         return 0;
1517
1518 err_probe:
1519         device_destroy(android_class, dev->dev->devt);
1520 err_create:
1521         kfree(dev);
1522 err_dev:
1523         class_destroy(android_class);
1524         return err;
1525 }
1526 late_initcall(init);
1527
1528 static void __exit cleanup(void)
1529 {
1530         usb_composite_unregister(&android_usb_driver);
1531         class_destroy(android_class);
1532         kfree(_android_dev);
1533         _android_dev = NULL;
1534 }
1535 module_exit(cleanup);