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         functionfs_unbind(ffs);
 351
 352         mutex_unlock(&dev->mutex);
 353 }
 354
 355 static void *functionfs_acquire_dev_callback(const char *dev_name)
 356 {
 357         return 0;
 358 }
 359
 360 static void functionfs_release_dev_callback(struct ffs_data *ffs_data)
 361 {
 362 }
 363
 364 #define MAX_ACM_INSTANCES 4
 365 struct acm_function_config {
 366         int instances;
 367         int instances_on;
 368         struct usb_function *f_acm[MAX_ACM_INSTANCES];
 369         struct usb_function_instance *f_acm_inst[MAX_ACM_INSTANCES];
 370 };
 371
 372 static int
 373 acm_function_init(struct android_usb_function *f,
 374                 struct usb_composite_dev *cdev)
 375 {
 376         int i;
 377         int ret;
 378         struct acm_function_config *config;
 379
 380         config = kzalloc(sizeof(struct acm_function_config), GFP_KERNEL);
 381         if (!config)
 382                 return -ENOMEM;
 383         f->config = config;
 384
 385         for (i = 0; i < MAX_ACM_INSTANCES; i++) {
 386                 config->f_acm_inst[i] = usb_get_function_instance("acm");
 387                 if (IS_ERR(config->f_acm_inst[i])) {
 388                         ret = PTR_ERR(config->f_acm_inst[i]);
 389                         goto err_usb_get_function_instance;
 390                 }
 391                 config->f_acm[i] = usb_get_function(config->f_acm_inst[i]);
 392                 if (IS_ERR(config->f_acm[i])) {
 393                         ret = PTR_ERR(config->f_acm[i]);
 394                         goto err_usb_get_function;
 395                 }
 396         }
 397         return 0;
 398 err_usb_get_function_instance:
 399         while (i-- > 0) {
 400                 usb_put_function(config->f_acm[i]);
 401 err_usb_get_function:
 402                 usb_put_function_instance(config->f_acm_inst[i]);
 403         }
 404         return ret;
 405 }
 406
 407 static void acm_function_cleanup(struct android_usb_function *f)
 408 {
 409         int i;
 410         struct acm_function_config *config = f->config;
 411
 412         for (i = 0; i < MAX_ACM_INSTANCES; i++) {
 413                 usb_put_function(config->f_acm[i]);
 414                 usb_put_function_instance(config->f_acm_inst[i]);
 415         }
 416         kfree(f->config);
 417         f->config = NULL;
 418 }
 419
 420 static int
 421 acm_function_bind_config(struct android_usb_function *f,
 422                 struct usb_configuration *c)
 423 {
 424         int i;
 425         int ret = 0;
 426         struct acm_function_config *config = f->config;
 427
 428         config->instances_on = config->instances;
 429         for (i = 0; i < config->instances_on; i++) {
 430                 ret = usb_add_function(c, config->f_acm[i]);
 431                 if (ret) {
 432                         pr_err("Could not bind acm%u config\n", i);
 433                         goto err_usb_add_function;
 434                 }
 435         }
 436
 437         return 0;
 438
 439 err_usb_add_function:
 440         while (i-- > 0)
 441                 usb_remove_function(c, config->f_acm[i]);
 442         return ret;
 443 }
 444
 445 static void acm_function_unbind_config(struct android_usb_function *f,
 446                                        struct usb_configuration *c)
 447 {
 448         int i;
 449         struct acm_function_config *config = f->config;
 450
 451         for (i = 0; i < config->instances_on; i++)
 452                 usb_remove_function(c, config->f_acm[i]);
 453 }
 454
 455 static ssize_t acm_instances_show(struct device *dev,
 456                 struct device_attribute *attr, char *buf)
 457 {
 458         struct android_usb_function *f = dev_get_drvdata(dev);
 459         struct acm_function_config *config = f->config;
 460         return sprintf(buf, "%d\n", config->instances);
 461 }
 462
 463 static ssize_t acm_instances_store(struct device *dev,
 464                 struct device_attribute *attr, const char *buf, size_t size)
 465 {
 466         struct android_usb_function *f = dev_get_drvdata(dev);
 467         struct acm_function_config *config = f->config;
 468         int value;
 469
 470         sscanf(buf, "%d", &value);
 471         if (value > MAX_ACM_INSTANCES)
 472                 value = MAX_ACM_INSTANCES;
 473         config->instances = value;
 474         return size;
 475 }
 476
 477 static DEVICE_ATTR(instances, S_IRUGO | S_IWUSR, acm_instances_show,
 478                                                  acm_instances_store);
 479 static struct device_attribute *acm_function_attributes[] = {
 480         &dev_attr_instances,
 481         NULL
 482 };
 483
 484 static struct android_usb_function acm_function = {
 485         .name           = "acm",
 486         .init           = acm_function_init,
 487         .cleanup        = acm_function_cleanup,
 488         .bind_config    = acm_function_bind_config,
 489         .unbind_config  = acm_function_unbind_config,
 490         .attributes     = acm_function_attributes,
 491 };
 492
 493
 494 static int
 495 mtp_function_init(struct android_usb_function *f,
 496                 struct usb_composite_dev *cdev)
 497 {
 498         return mtp_setup();
 499 }
 500
 501 static void mtp_function_cleanup(struct android_usb_function *f)
 502 {
 503         mtp_cleanup();
 504 }
 505
 506 static int
 507 mtp_function_bind_config(struct android_usb_function *f,
 508                 struct usb_configuration *c)
 509 {
 510         return mtp_bind_config(c, false);
 511 }
 512
 513 static int
 514 ptp_function_init(struct android_usb_function *f,
 515                 struct usb_composite_dev *cdev)
 516 {
 517         /* nothing to do - initialization is handled by mtp_function_init */
 518         return 0;
 519 }
 520
 521 static void ptp_function_cleanup(struct android_usb_function *f)
 522 {
 523         /* nothing to do - cleanup is handled by mtp_function_cleanup */
 524 }
 525
 526 static int
 527 ptp_function_bind_config(struct android_usb_function *f,
 528                 struct usb_configuration *c)
 529 {
 530         return mtp_bind_config(c, true);
 531 }
 532
 533 static int mtp_function_ctrlrequest(struct android_usb_function *f,
 534                                         struct usb_composite_dev *cdev,
 535                                         const struct usb_ctrlrequest *c)
 536 {
 537         return mtp_ctrlrequest(cdev, c);
 538 }
 539
 540 static struct android_usb_function mtp_function = {
 541         .name           = "mtp",
 542         .init           = mtp_function_init,
 543         .cleanup        = mtp_function_cleanup,
 544         .bind_config    = mtp_function_bind_config,
 545         .ctrlrequest    = mtp_function_ctrlrequest,
 546 };
 547
 548 /* PTP function is same as MTP with slightly different interface descriptor */
 549 static struct android_usb_function ptp_function = {
 550         .name           = "ptp",
 551         .init           = ptp_function_init,
 552         .cleanup        = ptp_function_cleanup,
 553         .bind_config    = ptp_function_bind_config,
 554 };
 555
 556
 557 struct rndis_function_config {
 558         u8      ethaddr[ETH_ALEN];
 559         u32     vendorID;
 560         char    manufacturer[256];
 561         /* "Wireless" RNDIS; auto-detected by Windows */
 562         bool    wceis;
 563         struct eth_dev *dev;
 564 };
 565
 566 static int
 567 rndis_function_init(struct android_usb_function *f,
 568                 struct usb_composite_dev *cdev)
 569 {
 570         f->config = kzalloc(sizeof(struct rndis_function_config), GFP_KERNEL);
 571         if (!f->config)
 572                 return -ENOMEM;
 573         return 0;
 574 }
 575
 576 static void rndis_function_cleanup(struct android_usb_function *f)
 577 {
 578         kfree(f->config);
 579         f->config = NULL;
 580 }
 581
 582 static int
 583 rndis_function_bind_config(struct android_usb_function *f,
 584                 struct usb_configuration *c)
 585 {
 586         int ret;
 587         struct eth_dev *dev;
 588         struct rndis_function_config *rndis = f->config;
 589
 590         if (!rndis) {
 591                 pr_err("%s: rndis_pdata\n", __func__);
 592                 return -1;
 593         }
 594
 595         pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
 596                 rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
 597                 rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
 598
 599         dev = gether_setup_name(c->cdev->gadget, rndis->ethaddr, "rndis");
 600         if (IS_ERR(dev)) {
 601                 ret = PTR_ERR(dev);
 602                 pr_err("%s: gether_setup failed\n", __func__);
 603                 return ret;
 604         }
 605         rndis->dev = dev;
 606
 607         if (rndis->wceis) {
 608                 /* "Wireless" RNDIS; auto-detected by Windows */
 609                 rndis_iad_descriptor.bFunctionClass =
 610                                                 USB_CLASS_WIRELESS_CONTROLLER;
 611                 rndis_iad_descriptor.bFunctionSubClass = 0x01;
 612                 rndis_iad_descriptor.bFunctionProtocol = 0x03;
 613                 rndis_control_intf.bInterfaceClass =
 614                                                 USB_CLASS_WIRELESS_CONTROLLER;
 615                 rndis_control_intf.bInterfaceSubClass =  0x01;
 616                 rndis_control_intf.bInterfaceProtocol =  0x03;
 617         }
 618
 619         return rndis_bind_config_vendor(c, rndis->ethaddr, rndis->vendorID,
 620                                            rndis->manufacturer, rndis->dev);
 621 }
 622
 623 static void rndis_function_unbind_config(struct android_usb_function *f,
 624                                                 struct usb_configuration *c)
 625 {
 626         struct rndis_function_config *rndis = f->config;
 627         gether_cleanup(rndis->dev);
 628 }
 629
 630 static ssize_t rndis_manufacturer_show(struct device *dev,
 631                 struct device_attribute *attr, char *buf)
 632 {
 633         struct android_usb_function *f = dev_get_drvdata(dev);
 634         struct rndis_function_config *config = f->config;
 635         return sprintf(buf, "%s\n", config->manufacturer);
 636 }
 637
 638 static ssize_t rndis_manufacturer_store(struct device *dev,
 639                 struct device_attribute *attr, const char *buf, size_t size)
 640 {
 641         struct android_usb_function *f = dev_get_drvdata(dev);
 642         struct rndis_function_config *config = f->config;
 643
 644         if (size >= sizeof(config->manufacturer))
 645                 return -EINVAL;
 646         if (sscanf(buf, "%s", config->manufacturer) == 1)
 647                 return size;
 648         return -1;
 649 }
 650
 651 static DEVICE_ATTR(manufacturer, S_IRUGO | S_IWUSR, rndis_manufacturer_show,
 652                                                     rndis_manufacturer_store);
 653
 654 static ssize_t rndis_wceis_show(struct device *dev,
 655                 struct device_attribute *attr, char *buf)
 656 {
 657         struct android_usb_function *f = dev_get_drvdata(dev);
 658         struct rndis_function_config *config = f->config;
 659         return sprintf(buf, "%d\n", config->wceis);
 660 }
 661
 662 static ssize_t rndis_wceis_store(struct device *dev,
 663                 struct device_attribute *attr, const char *buf, size_t size)
 664 {
 665         struct android_usb_function *f = dev_get_drvdata(dev);
 666         struct rndis_function_config *config = f->config;
 667         int value;
 668
 669         if (sscanf(buf, "%d", &value) == 1) {
 670                 config->wceis = value;
 671                 return size;
 672         }
 673         return -EINVAL;
 674 }
 675
 676 static DEVICE_ATTR(wceis, S_IRUGO | S_IWUSR, rndis_wceis_show,
 677                                              rndis_wceis_store);
 678
 679 static ssize_t rndis_ethaddr_show(struct device *dev,
 680                 struct device_attribute *attr, char *buf)
 681 {
 682         struct android_usb_function *f = dev_get_drvdata(dev);
 683         struct rndis_function_config *rndis = f->config;
 684         return sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
 685                 rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
 686                 rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
 687 }
 688
 689 static ssize_t rndis_ethaddr_store(struct device *dev,
 690                 struct device_attribute *attr, const char *buf, size_t size)
 691 {
 692         struct android_usb_function *f = dev_get_drvdata(dev);
 693         struct rndis_function_config *rndis = f->config;
 694
 695         if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
 696                     (int *)&rndis->ethaddr[0], (int *)&rndis->ethaddr[1],
 697                     (int *)&rndis->ethaddr[2], (int *)&rndis->ethaddr[3],
 698                     (int *)&rndis->ethaddr[4], (int *)&rndis->ethaddr[5]) == 6)
 699                 return size;
 700         return -EINVAL;
 701 }
 702
 703 static DEVICE_ATTR(ethaddr, S_IRUGO | S_IWUSR, rndis_ethaddr_show,
 704                                                rndis_ethaddr_store);
 705
 706 static ssize_t rndis_vendorID_show(struct device *dev,
 707                 struct device_attribute *attr, char *buf)
 708 {
 709         struct android_usb_function *f = dev_get_drvdata(dev);
 710         struct rndis_function_config *config = f->config;
 711         return sprintf(buf, "%04x\n", config->vendorID);
 712 }
 713
 714 static ssize_t rndis_vendorID_store(struct device *dev,
 715                 struct device_attribute *attr, const char *buf, size_t size)
 716 {
 717         struct android_usb_function *f = dev_get_drvdata(dev);
 718         struct rndis_function_config *config = f->config;
 719         int value;
 720
 721         if (sscanf(buf, "%04x", &value) == 1) {
 722                 config->vendorID = value;
 723                 return size;
 724         }
 725         return -EINVAL;
 726 }
 727
 728 static DEVICE_ATTR(vendorID, S_IRUGO | S_IWUSR, rndis_vendorID_show,
 729                                                 rndis_vendorID_store);
 730
 731 static struct device_attribute *rndis_function_attributes[] = {
 732         &dev_attr_manufacturer,
 733         &dev_attr_wceis,
 734         &dev_attr_ethaddr,
 735         &dev_attr_vendorID,
 736         NULL
 737 };
 738
 739 static struct android_usb_function rndis_function = {
 740         .name           = "rndis",
 741         .init           = rndis_function_init,
 742         .cleanup        = rndis_function_cleanup,
 743         .bind_config    = rndis_function_bind_config,
 744         .unbind_config  = rndis_function_unbind_config,
 745         .attributes     = rndis_function_attributes,
 746 };
 747
 748
 749 struct mass_storage_function_config {
 750         struct fsg_config fsg;
 751         struct fsg_common *common;
 752 };
 753
 754 static int mass_storage_function_init(struct android_usb_function *f,
 755                                         struct usb_composite_dev *cdev)
 756 {
 757         struct mass_storage_function_config *config;
 758         struct fsg_common *common;
 759         int err;
 760
 761         config = kzalloc(sizeof(struct mass_storage_function_config),
 762                                                                 GFP_KERNEL);
 763         if (!config)
 764                 return -ENOMEM;
 765
 766         config->fsg.nluns = 2;
 767         config->fsg.luns[0].removable = 1;
 768         config->fsg.luns[1].removable = 1;
 769
 770         common = fsg_common_init(NULL, cdev, &config->fsg);
 771         if (IS_ERR(common)) {
 772                 kfree(config);
 773                 return PTR_ERR(common);
 774         }
 775
 776         err = sysfs_create_link(&f->dev->kobj,
 777                                 &common->luns[0].dev.kobj,
 778                                 "lun");
 779         err = sysfs_create_link(&f->dev->kobj,
 780                                 &common->luns[1].dev.kobj,
 781                                 "lun1");
 782         if (err) {
 783                 kfree(config);
 784                 return err;
 785         }
 786
 787         config->common = common;
 788         f->config = config;
 789         return 0;
 790 }
 791
 792 static void mass_storage_function_cleanup(struct android_usb_function *f)
 793 {
 794         kfree(f->config);
 795         f->config = NULL;
 796 }
 797
 798 static int mass_storage_function_bind_config(struct android_usb_function *f,
 799                                                 struct usb_configuration *c)
 800 {
 801         struct mass_storage_function_config *config = f->config;
 802         return fsg_bind_config(c->cdev, c, config->common);
 803 }
 804
 805 static ssize_t mass_storage_inquiry_show(struct device *dev,
 806                                 struct device_attribute *attr, char *buf)
 807 {
 808         struct android_usb_function *f = dev_get_drvdata(dev);
 809         struct mass_storage_function_config *config = f->config;
 810         return sprintf(buf, "%s\n", config->common->inquiry_string);
 811 }
 812
 813 static ssize_t mass_storage_inquiry_store(struct device *dev,
 814                 struct device_attribute *attr, const char *buf, size_t size)
 815 {
 816         struct android_usb_function *f = dev_get_drvdata(dev);
 817         struct mass_storage_function_config *config = f->config;
 818         if (size >= sizeof(config->common->inquiry_string))
 819                 return -EINVAL;
 820         if (sscanf(buf, "%s", config->common->inquiry_string) != 1)
 821                 return -EINVAL;
 822         return size;
 823 }
 824
 825 static DEVICE_ATTR(inquiry_string, S_IRUGO | S_IWUSR,
 826                                         mass_storage_inquiry_show,
 827                                         mass_storage_inquiry_store);
 828
 829 static struct device_attribute *mass_storage_function_attributes[] = {
 830         &dev_attr_inquiry_string,
 831         NULL
 832 };
 833
 834 static struct android_usb_function mass_storage_function = {
 835         .name           = "mass_storage",
 836         .init           = mass_storage_function_init,
 837         .cleanup        = mass_storage_function_cleanup,
 838         .bind_config    = mass_storage_function_bind_config,
 839         .attributes     = mass_storage_function_attributes,
 840 };
 841
 842
 843 static int accessory_function_init(struct android_usb_function *f,
 844                                         struct usb_composite_dev *cdev)
 845 {
 846         return acc_setup();
 847 }
 848
 849 static void accessory_function_cleanup(struct android_usb_function *f)
 850 {
 851         acc_cleanup();
 852 }
 853
 854 static int accessory_function_bind_config(struct android_usb_function *f,
 855                                                 struct usb_configuration *c)
 856 {
 857         return acc_bind_config(c);
 858 }
 859
 860 static int accessory_function_ctrlrequest(struct android_usb_function *f,
 861                                                 struct usb_composite_dev *cdev,
 862                                                 const struct usb_ctrlrequest *c)
 863 {
 864         return acc_ctrlrequest(cdev, c);
 865 }
 866
 867 static struct android_usb_function accessory_function = {
 868         .name           = "accessory",
 869         .init           = accessory_function_init,
 870         .cleanup        = accessory_function_cleanup,
 871         .bind_config    = accessory_function_bind_config,
 872         .ctrlrequest    = accessory_function_ctrlrequest,
 873 };
 874
 875 static int audio_source_function_init(struct android_usb_function *f,
 876                         struct usb_composite_dev *cdev)
 877 {
 878         struct audio_source_config *config;
 879
 880         config = kzalloc(sizeof(struct audio_source_config), GFP_KERNEL);
 881         if (!config)
 882                 return -ENOMEM;
 883         config->card = -1;
 884         config->device = -1;
 885         f->config = config;
 886         return 0;
 887 }
 888
 889 static void audio_source_function_cleanup(struct android_usb_function *f)
 890 {
 891         kfree(f->config);
 892 }
 893
 894 static int audio_source_function_bind_config(struct android_usb_function *f,
 895                                                 struct usb_configuration *c)
 896 {
 897         struct audio_source_config *config = f->config;
 898
 899         return audio_source_bind_config(c, config);
 900 }
 901
 902 static void audio_source_function_unbind_config(struct android_usb_function *f,
 903                                                 struct usb_configuration *c)
 904 {
 905         struct audio_source_config *config = f->config;
 906
 907         config->card = -1;
 908         config->device = -1;
 909 }
 910
 911 static ssize_t audio_source_pcm_show(struct device *dev,
 912                 struct device_attribute *attr, char *buf)
 913 {
 914         struct android_usb_function *f = dev_get_drvdata(dev);
 915         struct audio_source_config *config = f->config;
 916
 917         /* print PCM card and device numbers */
 918         return sprintf(buf, "%d %d\n", config->card, config->device);
 919 }
 920
 921 static DEVICE_ATTR(pcm, S_IRUGO, audio_source_pcm_show, NULL);
 922
 923 static struct device_attribute *audio_source_function_attributes[] = {
 924         &dev_attr_pcm,
 925         NULL
 926 };
 927
 928 static struct android_usb_function audio_source_function = {
 929         .name           = "audio_source",
 930         .init           = audio_source_function_init,
 931         .cleanup        = audio_source_function_cleanup,
 932         .bind_config    = audio_source_function_bind_config,
 933         .unbind_config  = audio_source_function_unbind_config,
 934         .attributes     = audio_source_function_attributes,
 935 };
 936
 937 static struct android_usb_function *supported_functions[] = {
 938         &ffs_function,
 939         &acm_function,
 940         &mtp_function,
 941         &ptp_function,
 942         &rndis_function,
 943         &mass_storage_function,
 944         &accessory_function,
 945         &audio_source_function,
 946         NULL
 947 };
 948
 949
 950 static int android_init_functions(struct android_usb_function **functions,
 951                                   struct usb_composite_dev *cdev)
 952 {
 953         struct android_dev *dev = _android_dev;
 954         struct android_usb_function *f;
 955         struct device_attribute **attrs;
 956         struct device_attribute *attr;
 957         int err;
 958         int index = 0;
 959
 960         for (; (f = *functions++); index++) {
 961                 f->dev_name = kasprintf(GFP_KERNEL, "f_%s", f->name);
 962                 f->dev = device_create(android_class, dev->dev,
 963                                 MKDEV(0, index), f, f->dev_name);
 964                 if (IS_ERR(f->dev)) {
 965                         pr_err("%s: Failed to create dev %s", __func__,
 966                                                         f->dev_name);
 967                         err = PTR_ERR(f->dev);
 968                         goto err_create;
 969                 }
 970
 971                 if (f->init) {
 972                         err = f->init(f, cdev);
 973                         if (err) {
 974                                 pr_err("%s: Failed to init %s", __func__,
 975                                                                 f->name);
 976                                 goto err_out;
 977                         }
 978                 }
 979
 980                 attrs = f->attributes;
 981                 if (attrs) {
 982                         while ((attr = *attrs++) && !err)
 983                                 err = device_create_file(f->dev, attr);
 984                 }
 985                 if (err) {
 986                         pr_err("%s: Failed to create function %s attributes",
 987                                         __func__, f->name);
 988                         goto err_out;
 989                 }
 990         }
 991         return 0;
 992
 993 err_out:
 994         device_destroy(android_class, f->dev->devt);
 995 err_create:
 996         kfree(f->dev_name);
 997         return err;
 998 }
 999
1000 static void android_cleanup_functions(struct android_usb_function **functions)
1001 {
1002         struct android_usb_function *f;
1003
1004         while (*functions) {
1005                 f = *functions++;
1006
1007                 if (f->dev) {
1008                         device_destroy(android_class, f->dev->devt);
1009                         kfree(f->dev_name);
1010                 }
1011
1012                 if (f->cleanup)
1013                         f->cleanup(f);
1014         }
1015 }
1016
1017 static int
1018 android_bind_enabled_functions(struct android_dev *dev,
1019                                struct usb_configuration *c)
1020 {
1021         struct android_usb_function *f;
1022         int ret;
1023
1024         list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1025                 ret = f->bind_config(f, c);
1026                 if (ret) {
1027                         pr_err("%s: %s failed", __func__, f->name);
1028                         return ret;
1029                 }
1030         }
1031         return 0;
1032 }
1033
1034 static void
1035 android_unbind_enabled_functions(struct android_dev *dev,
1036                                struct usb_configuration *c)
1037 {
1038         struct android_usb_function *f;
1039
1040         list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1041                 if (f->unbind_config)
1042                         f->unbind_config(f, c);
1043         }
1044 }
1045
1046 static int android_enable_function(struct android_dev *dev, char *name)
1047 {
1048         struct android_usb_function **functions = dev->functions;
1049         struct android_usb_function *f;
1050         while ((f = *functions++)) {
1051                 if (!strcmp(name, f->name)) {
1052                         list_add_tail(&f->enabled_list,
1053                                                 &dev->enabled_functions);
1054                         return 0;
1055                 }
1056         }
1057         return -EINVAL;
1058 }
1059
1060 /*-------------------------------------------------------------------------*/
1061 /* /sys/class/android_usb/android%d/ interface */
1062
1063 static ssize_t
1064 functions_show(struct device *pdev, struct device_attribute *attr, char *buf)
1065 {
1066         struct android_dev *dev = dev_get_drvdata(pdev);
1067         struct android_usb_function *f;
1068         char *buff = buf;
1069
1070         mutex_lock(&dev->mutex);
1071
1072         list_for_each_entry(f, &dev->enabled_functions, enabled_list)
1073                 buff += sprintf(buff, "%s,", f->name);
1074
1075         mutex_unlock(&dev->mutex);
1076
1077         if (buff != buf)
1078                 *(buff-1) = '\n';
1079         return buff - buf;
1080 }
1081
1082 static ssize_t
1083 functions_store(struct device *pdev, struct device_attribute *attr,
1084                                const char *buff, size_t size)
1085 {
1086         struct android_dev *dev = dev_get_drvdata(pdev);
1087         char *name;
1088         char buf[256], *b;
1089         char aliases[256], *a;
1090         int err;
1091         int is_ffs;
1092         int ffs_enabled = 0;
1093
1094         mutex_lock(&dev->mutex);
1095
1096         if (dev->enabled) {
1097                 mutex_unlock(&dev->mutex);
1098                 return -EBUSY;
1099         }
1100
1101         INIT_LIST_HEAD(&dev->enabled_functions);
1102
1103         strlcpy(buf, buff, sizeof(buf));
1104         b = strim(buf);
1105
1106         while (b) {
1107                 name = strsep(&b, ",");
1108                 if (!name)
1109                         continue;
1110
1111                 is_ffs = 0;
1112                 strlcpy(aliases, dev->ffs_aliases, sizeof(aliases));
1113                 a = aliases;
1114
1115                 while (a) {
1116                         char *alias = strsep(&a, ",");
1117                         if (alias && !strcmp(name, alias)) {
1118                                 is_ffs = 1;
1119                                 break;
1120                         }
1121                 }
1122
1123                 if (is_ffs) {
1124                         if (ffs_enabled)
1125                                 continue;
1126                         err = android_enable_function(dev, "ffs");
1127                         if (err)
1128                                 pr_err("android_usb: Cannot enable ffs (%d)",
1129                                                                         err);
1130                         else
1131                                 ffs_enabled = 1;
1132                         continue;
1133                 }
1134
1135                 err = android_enable_function(dev, name);
1136                 if (err)
1137                         pr_err("android_usb: Cannot enable '%s' (%d)",
1138                                                            name, err);
1139         }
1140
1141         mutex_unlock(&dev->mutex);
1142
1143         return size;
1144 }
1145
1146 static ssize_t enable_show(struct device *pdev, struct device_attribute *attr,
1147                            char *buf)
1148 {
1149         struct android_dev *dev = dev_get_drvdata(pdev);
1150         return sprintf(buf, "%d\n", dev->enabled);
1151 }
1152
1153 static ssize_t enable_store(struct device *pdev, struct device_attribute *attr,
1154                             const char *buff, size_t size)
1155 {
1156         struct android_dev *dev = dev_get_drvdata(pdev);
1157         struct usb_composite_dev *cdev = dev->cdev;
1158         struct android_usb_function *f;
1159         int enabled = 0;
1160
1161
1162         if (!cdev)
1163                 return -ENODEV;
1164
1165         mutex_lock(&dev->mutex);
1166
1167         sscanf(buff, "%d", &enabled);
1168         if (enabled && !dev->enabled) {
1169                 /*
1170                  * Update values in composite driver's copy of
1171                  * device descriptor.
1172                  */
1173                 cdev->desc.idVendor = device_desc.idVendor;
1174                 cdev->desc.idProduct = device_desc.idProduct;
1175                 cdev->desc.bcdDevice = device_desc.bcdDevice;
1176                 cdev->desc.bDeviceClass = device_desc.bDeviceClass;
1177                 cdev->desc.bDeviceSubClass = device_desc.bDeviceSubClass;
1178                 cdev->desc.bDeviceProtocol = device_desc.bDeviceProtocol;
1179                 list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1180                         if (f->enable)
1181                                 f->enable(f);
1182                 }
1183                 android_enable(dev);
1184                 dev->enabled = true;
1185         } else if (!enabled && dev->enabled) {
1186                 android_disable(dev);
1187                 list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1188                         if (f->disable)
1189                                 f->disable(f);
1190                 }
1191                 dev->enabled = false;
1192         } else {
1193                 pr_err("android_usb: already %s\n",
1194                                 dev->enabled ? "enabled" : "disabled");
1195         }
1196
1197         mutex_unlock(&dev->mutex);
1198         return size;
1199 }
1200
1201 static ssize_t state_show(struct device *pdev, struct device_attribute *attr,
1202                            char *buf)
1203 {
1204         struct android_dev *dev = dev_get_drvdata(pdev);
1205         struct usb_composite_dev *cdev = dev->cdev;
1206         char *state = "DISCONNECTED";
1207         unsigned long flags;
1208
1209         if (!cdev)
1210                 goto out;
1211
1212         spin_lock_irqsave(&cdev->lock, flags);
1213         if (cdev->config)
1214                 state = "CONFIGURED";
1215         else if (dev->connected)
1216                 state = "CONNECTED";
1217         spin_unlock_irqrestore(&cdev->lock, flags);
1218 out:
1219         return sprintf(buf, "%s\n", state);
1220 }
1221
1222 #define DESCRIPTOR_ATTR(field, format_string)                           \
1223 static ssize_t                                                          \
1224 field ## _show(struct device *dev, struct device_attribute *attr,       \
1225                 char *buf)                                              \
1226 {                                                                       \
1227         return sprintf(buf, format_string, device_desc.field);          \
1228 }                                                                       \
1229 static ssize_t                                                          \
1230 field ## _store(struct device *dev, struct device_attribute *attr,      \
1231                 const char *buf, size_t size)                           \
1232 {                                                                       \
1233         int value;                                                      \
1234         if (sscanf(buf, format_string, &value) == 1) {                  \
1235                 device_desc.field = value;                              \
1236                 return size;                                            \
1237         }                                                               \
1238         return -1;                                                      \
1239 }                                                                       \
1240 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
1241
1242 #define DESCRIPTOR_STRING_ATTR(field, buffer)                           \
1243 static ssize_t                                                          \
1244 field ## _show(struct device *dev, struct device_attribute *attr,       \
1245                 char *buf)                                              \
1246 {                                                                       \
1247         return sprintf(buf, "%s", buffer);                              \
1248 }                                                                       \
1249 static ssize_t                                                          \
1250 field ## _store(struct device *dev, struct device_attribute *attr,      \
1251                 const char *buf, size_t size)                           \
1252 {                                                                       \
1253         if (size >= sizeof(buffer))                                     \
1254                 return -EINVAL;                                         \
1255         return strlcpy(buffer, buf, sizeof(buffer));                    \
1256 }                                                                       \
1257 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
1258
1259
1260 DESCRIPTOR_ATTR(idVendor, "%04x\n")
1261 DESCRIPTOR_ATTR(idProduct, "%04x\n")
1262 DESCRIPTOR_ATTR(bcdDevice, "%04x\n")
1263 DESCRIPTOR_ATTR(bDeviceClass, "%d\n")
1264 DESCRIPTOR_ATTR(bDeviceSubClass, "%d\n")
1265 DESCRIPTOR_ATTR(bDeviceProtocol, "%d\n")
1266 DESCRIPTOR_STRING_ATTR(iManufacturer, manufacturer_string)
1267 DESCRIPTOR_STRING_ATTR(iProduct, product_string)
1268 DESCRIPTOR_STRING_ATTR(iSerial, serial_string)
1269
1270 static DEVICE_ATTR(functions, S_IRUGO | S_IWUSR, functions_show,
1271                                                  functions_store);
1272 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, enable_show, enable_store);
1273 static DEVICE_ATTR(state, S_IRUGO, state_show, NULL);
1274
1275 static struct device_attribute *android_usb_attributes[] = {
1276         &dev_attr_idVendor,
1277         &dev_attr_idProduct,
1278         &dev_attr_bcdDevice,
1279         &dev_attr_bDeviceClass,
1280         &dev_attr_bDeviceSubClass,
1281         &dev_attr_bDeviceProtocol,
1282         &dev_attr_iManufacturer,
1283         &dev_attr_iProduct,
1284         &dev_attr_iSerial,
1285         &dev_attr_functions,
1286         &dev_attr_enable,
1287         &dev_attr_state,
1288         NULL
1289 };
1290
1291 /*-------------------------------------------------------------------------*/
1292 /* Composite driver */
1293
1294 static int android_bind_config(struct usb_configuration *c)
1295 {
1296         struct android_dev *dev = _android_dev;
1297         int ret = 0;
1298
1299         ret = android_bind_enabled_functions(dev, c);
1300         if (ret)
1301                 return ret;
1302
1303         return 0;
1304 }
1305
1306 static void android_unbind_config(struct usb_configuration *c)
1307 {
1308         struct android_dev *dev = _android_dev;
1309
1310         android_unbind_enabled_functions(dev, c);
1311 }
1312
1313 static int android_bind(struct usb_composite_dev *cdev)
1314 {
1315         struct android_dev *dev = _android_dev;
1316         struct usb_gadget       *gadget = cdev->gadget;
1317         int                     id, ret;
1318
1319         /*
1320          * Start disconnected. Userspace will connect the gadget once
1321          * it is done configuring the functions.
1322          */
1323         usb_gadget_disconnect(gadget);
1324
1325         ret = android_init_functions(dev->functions, cdev);
1326         if (ret)
1327                 return ret;
1328
1329         /* Allocate string descriptor numbers ... note that string
1330          * contents can be overridden by the composite_dev glue.
1331          */
1332         id = usb_string_id(cdev);
1333         if (id < 0)
1334                 return id;
1335         strings_dev[STRING_MANUFACTURER_IDX].id = id;
1336         device_desc.iManufacturer = id;
1337
1338         id = usb_string_id(cdev);
1339         if (id < 0)
1340                 return id;
1341         strings_dev[STRING_PRODUCT_IDX].id = id;
1342         device_desc.iProduct = id;
1343
1344         /* Default strings - should be updated by userspace */
1345         strncpy(manufacturer_string, "Android", sizeof(manufacturer_string)-1);
1346         strncpy(product_string, "Android", sizeof(product_string) - 1);
1347         strncpy(serial_string, "0123456789ABCDEF", sizeof(serial_string) - 1);
1348
1349         id = usb_string_id(cdev);
1350         if (id < 0)
1351                 return id;
1352         strings_dev[STRING_SERIAL_IDX].id = id;
1353         device_desc.iSerialNumber = id;
1354         device_desc.bcdDevice = cpu_to_le16(get_default_bcdDevice());
1355
1356         usb_gadget_set_selfpowered(gadget);
1357         dev->cdev = cdev;
1358
1359         return 0;
1360 }
1361
1362 static int android_usb_unbind(struct usb_composite_dev *cdev)
1363 {
1364         struct android_dev *dev = _android_dev;
1365
1366         cancel_work_sync(&dev->work);
1367         android_cleanup_functions(dev->functions);
1368         return 0;
1369 }
1370
1371 /* HACK: android needs to override setup for accessory to work */
1372 static int (*composite_setup_func)(struct usb_gadget *gadget, const struct usb_ctrlrequest *c);
1373
1374 static int
1375 android_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c)
1376 {
1377         struct android_dev              *dev = _android_dev;
1378         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
1379         struct usb_request              *req = cdev->req;
1380         struct android_usb_function     *f;
1381         int value = -EOPNOTSUPP;
1382         unsigned long flags;
1383
1384         req->zero = 0;
1385         req->length = 0;
1386         gadget->ep0->driver_data = cdev;
1387
1388         list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1389                 if (f->ctrlrequest) {
1390                         value = f->ctrlrequest(f, cdev, c);
1391                         if (value >= 0)
1392                                 break;
1393                 }
1394         }
1395
1396         /* Special case the accessory function.
1397          * It needs to handle control requests before it is enabled.
1398          */
1399         if (value < 0)
1400                 value = acc_ctrlrequest(cdev, c);
1401
1402         if (value < 0)
1403                 value = composite_setup_func(gadget, c);
1404
1405         spin_lock_irqsave(&cdev->lock, flags);
1406         if (!dev->connected) {
1407                 dev->connected = 1;
1408                 schedule_work(&dev->work);
1409         } else if (c->bRequest == USB_REQ_SET_CONFIGURATION &&
1410                                                 cdev->config) {
1411                 schedule_work(&dev->work);
1412         }
1413         spin_unlock_irqrestore(&cdev->lock, flags);
1414
1415         return value;
1416 }
1417
1418 static void android_disconnect(struct usb_composite_dev *cdev)
1419 {
1420         struct android_dev *dev = _android_dev;
1421
1422         /* accessory HID support can be active while the
1423            accessory function is not actually enabled,
1424            so we need to inform it when we are disconnected.
1425          */
1426         acc_disconnect();
1427
1428         dev->connected = 0;
1429         schedule_work(&dev->work);
1430 }
1431
1432 static struct usb_composite_driver android_usb_driver = {
1433         .name           = "android_usb",
1434         .dev            = &device_desc,
1435         .strings        = dev_strings,
1436         .bind           = android_bind,
1437         .unbind         = android_usb_unbind,
1438         .disconnect     = android_disconnect,
1439         .max_speed      = USB_SPEED_HIGH,
1440 };
1441
1442 static int android_create_device(struct android_dev *dev)
1443 {
1444         struct device_attribute **attrs = android_usb_attributes;
1445         struct device_attribute *attr;
1446         int err;
1447
1448         dev->dev = device_create(android_class, NULL,
1449                                         MKDEV(0, 0), NULL, "android0");
1450         if (IS_ERR(dev->dev))
1451                 return PTR_ERR(dev->dev);
1452
1453         dev_set_drvdata(dev->dev, dev);
1454
1455         while ((attr = *attrs++)) {
1456                 err = device_create_file(dev->dev, attr);
1457                 if (err) {
1458                         device_destroy(android_class, dev->dev->devt);
1459                         return err;
1460                 }
1461         }
1462         return 0;
1463 }
1464
1465
1466 static int __init init(void)
1467 {
1468         struct android_dev *dev;
1469         int err;
1470
1471         android_class = class_create(THIS_MODULE, "android_usb");
1472         if (IS_ERR(android_class))
1473                 return PTR_ERR(android_class);
1474
1475         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1476         if (!dev) {
1477                 err = -ENOMEM;
1478                 goto err_dev;
1479         }
1480
1481         dev->disable_depth = 1;
1482         dev->functions = supported_functions;
1483         INIT_LIST_HEAD(&dev->enabled_functions);
1484         INIT_WORK(&dev->work, android_work);
1485         mutex_init(&dev->mutex);
1486
1487         err = android_create_device(dev);
1488         if (err) {
1489                 pr_err("%s: failed to create android device %d", __func__, err);
1490                 goto err_create;
1491         }
1492
1493         _android_dev = dev;
1494
1495         err = usb_composite_probe(&android_usb_driver);
1496         if (err) {
1497                 pr_err("%s: failed to probe driver %d", __func__, err);
1498                 goto err_probe;
1499         }
1500
1501         /* HACK: exchange composite's setup with ours */
1502         composite_setup_func = android_usb_driver.gadget_driver.setup;
1503         android_usb_driver.gadget_driver.setup = android_setup;
1504
1505         return 0;
1506
1507 err_probe:
1508         device_destroy(android_class, dev->dev->devt);
1509 err_create:
1510         kfree(dev);
1511 err_dev:
1512         class_destroy(android_class);
1513         return err;
1514 }
1515 late_initcall(init);
1516
1517 static void __exit cleanup(void)
1518 {
1519         usb_composite_unregister(&android_usb_driver);
1520         class_destroy(android_class);
1521         kfree(_android_dev);
1522         _android_dev = NULL;
1523 }
1524 module_exit(cleanup);