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  *
   7  * This software is licensed under the terms of the GNU General Public
   8  * License version 2, as published by the Free Software Foundation, and
   9  * may be copied, distributed, and modified under those terms.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  */
  17
  18 /* #define DEBUG */
  19 /* #define VERBOSE_DEBUG */
  20
  21 #include <linux/init.h>
  22 #include <linux/module.h>
  23 #include <linux/fs.h>
  24
  25 #include <linux/delay.h>
  26 #include <linux/kernel.h>
  27 #include <linux/utsname.h>
  28 #include <linux/platform_device.h>
  29
  30 #include <linux/usb/ch9.h>
  31 #include <linux/usb/composite.h>
  32 #include <linux/usb/gadget.h>
  33
  34 #include "gadget_chips.h"
  35
  36 /*
  37  * Kbuild is not very cooperative with respect to linking separately
  38  * compiled library objects into one module.  So for now we won't use
  39  * separate compilation ... ensuring init/exit sections work to shrink
  40  * the runtime footprint, and giving us at least some parts of what
  41  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  42  */
  43 #include "usbstring.c"
  44 #include "config.c"
  45 #include "epautoconf.c"
  46 #include "composite.c"
  47
  48 #include "f_mass_storage.c"
  49 #include "u_serial.c"
  50 #include "f_acm.c"
  51 #include "f_adb.c"
  52 #include "f_mtp.c"
  53 #include "f_accessory.c"
  54 #define USB_ETH_RNDIS y
  55 #include "f_rndis.c"
  56 #include "rndis.c"
  57 #include "u_ether.c"
  58
  59 MODULE_AUTHOR("Mike Lockwood");
  60 MODULE_DESCRIPTION("Android Composite USB Driver");
  61 MODULE_LICENSE("GPL");
  62 MODULE_VERSION("1.0");
  63
  64 static const char longname[] = "Gadget Android";
  65
  66 /* Default vendor and product IDs, overridden by userspace */
  67 #define VENDOR_ID               0x2207//0x18D1
  68 #define PRODUCT_ID              0x2910
  69
  70 struct android_usb_function {
  71         char *name;
  72         void *config;
  73
  74         struct device *dev;
  75         char *dev_name;
  76         struct device_attribute **attributes;
  77
  78         /* for android_dev.enabled_functions */
  79         struct list_head enabled_list;
  80
  81         /* Optional: initialization during gadget bind */
  82         int (*init)(struct android_usb_function *, struct usb_composite_dev *);
  83         /* Optional: cleanup during gadget unbind */
  84         void (*cleanup)(struct android_usb_function *);
  85
  86         int (*bind_config)(struct android_usb_function *, struct usb_configuration *);
  87
  88         /* Optional: called when the configuration is removed */
  89         void (*unbind_config)(struct android_usb_function *, struct usb_configuration *);
  90         /* Optional: handle ctrl requests before the device is configured */
  91         int (*ctrlrequest)(struct android_usb_function *,
  92                                         struct usb_composite_dev *,
  93                                         const struct usb_ctrlrequest *);
  94 };
  95
  96 struct android_dev {
  97         struct android_usb_function **functions;
  98         struct list_head enabled_functions;
  99         struct usb_composite_dev *cdev;
 100         struct device *dev;
 101
 102         bool enabled;
 103         struct mutex mutex;
 104         bool connected;
 105         bool sw_connected;
 106         struct work_struct work;
 107 };
 108
 109 static struct class *android_class;
 110 static struct android_dev *_android_dev;
 111 static int android_bind_config(struct usb_configuration *c);
 112 static void android_unbind_config(struct usb_configuration *c);
 113
 114 /* string IDs are assigned dynamically */
 115 #define STRING_MANUFACTURER_IDX         0
 116 #define STRING_PRODUCT_IDX              1
 117 #define STRING_SERIAL_IDX               2
 118
 119 static char manufacturer_string[256];
 120 static char product_string[256];
 121 static char serial_string[256];
 122
 123 /* String Table */
 124 static struct usb_string strings_dev[] = {
 125         [STRING_MANUFACTURER_IDX].s = manufacturer_string,
 126         [STRING_PRODUCT_IDX].s = product_string,
 127         [STRING_SERIAL_IDX].s = serial_string,
 128         {  }                    /* end of list */
 129 };
 130
 131 static struct usb_gadget_strings stringtab_dev = {
 132         .language       = 0x0409,       /* en-us */
 133         .strings        = strings_dev,
 134 };
 135
 136 static struct usb_gadget_strings *dev_strings[] = {
 137         &stringtab_dev,
 138         NULL,
 139 };
 140
 141 static struct usb_device_descriptor device_desc = {
 142         .bLength              = sizeof(device_desc),
 143         .bDescriptorType      = USB_DT_DEVICE,
 144         .bcdUSB               = __constant_cpu_to_le16(0x0200),
 145         .bDeviceClass         = USB_CLASS_PER_INTERFACE,
 146         .idVendor             = __constant_cpu_to_le16(VENDOR_ID),
 147         .idProduct            = __constant_cpu_to_le16(PRODUCT_ID),
 148         .bcdDevice            = __constant_cpu_to_le16(0xffff),
 149         .bNumConfigurations   = 1,
 150 };
 151
 152 static struct usb_configuration android_config_driver = {
 153         .label          = "android",
 154         .unbind         = android_unbind_config,
 155         .bConfigurationValue = 1,
 156         .bmAttributes   = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 157         .bMaxPower      = 0xFA, /* 500ma */
 158 };
 159
 160 static void android_work(struct work_struct *data)
 161 {
 162         struct android_dev *dev = container_of(data, struct android_dev, work);
 163         struct usb_composite_dev *cdev = dev->cdev;
 164         char *disconnected[2] = { "USB_STATE=DISCONNECTED", NULL };
 165         char *connected[2]    = { "USB_STATE=CONNECTED", NULL };
 166         char *configured[2]   = { "USB_STATE=CONFIGURED", NULL };
 167         char **uevent_envp = NULL;
 168         unsigned long flags;
 169
 170         spin_lock_irqsave(&cdev->lock, flags);
 171         if (cdev->config)
 172                 uevent_envp = configured;
 173         else if (dev->connected != dev->sw_connected)
 174                 uevent_envp = dev->connected ? connected : disconnected;
 175         dev->sw_connected = dev->connected;
 176         spin_unlock_irqrestore(&cdev->lock, flags);
 177
 178         if (uevent_envp) {
 179                 kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, uevent_envp);
 180                 pr_info("%s: sent uevent %s\n", __func__, uevent_envp[0]);
 181         } else {
 182                 pr_info("%s: did not send uevent (%d %d %p)\n", __func__,
 183                          dev->connected, dev->sw_connected, cdev->config);
 184         }
 185 }
 186
 187
 188 /*-------------------------------------------------------------------------*/
 189 /* Supported functions initialization */
 190
 191 static int adb_function_init(struct android_usb_function *f, struct usb_composite_dev *cdev)
 192 {
 193         return adb_setup();
 194 }
 195
 196 static void adb_function_cleanup(struct android_usb_function *f)
 197 {
 198         adb_cleanup();
 199 }
 200
 201 static int adb_function_bind_config(struct android_usb_function *f, struct usb_configuration *c)
 202 {
 203         return adb_bind_config(c);
 204 }
 205
 206 static struct android_usb_function adb_function = {
 207         .name           = "adb",
 208         .init           = adb_function_init,
 209         .cleanup        = adb_function_cleanup,
 210         .bind_config    = adb_function_bind_config,
 211 };
 212
 213
 214 #define MAX_ACM_INSTANCES 4
 215 struct acm_function_config {
 216         int instances;
 217 };
 218
 219 static int acm_function_init(struct android_usb_function *f, struct usb_composite_dev *cdev)
 220 {
 221         f->config = kzalloc(sizeof(struct acm_function_config), GFP_KERNEL);
 222         if (!f->config)
 223                 return -ENOMEM;
 224
 225         return gserial_setup(cdev->gadget, MAX_ACM_INSTANCES);
 226 }
 227
 228 static void acm_function_cleanup(struct android_usb_function *f)
 229 {
 230         gserial_cleanup();
 231         kfree(f->config);
 232         f->config = NULL;
 233 }
 234
 235 static int acm_function_bind_config(struct android_usb_function *f, struct usb_configuration *c)
 236 {
 237         int i;
 238         int ret = 0;
 239         struct acm_function_config *config = f->config;
 240
 241         for (i = 0; i < config->instances; i++) {
 242                 ret = acm_bind_config(c, i);
 243                 if (ret) {
 244                         pr_err("Could not bind acm%u config\n", i);
 245                         break;
 246                 }
 247         }
 248
 249         return ret;
 250 }
 251
 252 static ssize_t acm_instances_show(struct device *dev,
 253                 struct device_attribute *attr, char *buf)
 254 {
 255         struct android_usb_function *f = dev_get_drvdata(dev);
 256         struct acm_function_config *config = f->config;
 257         return sprintf(buf, "%d\n", config->instances);
 258 }
 259
 260 static ssize_t acm_instances_store(struct device *dev,
 261                 struct device_attribute *attr, const char *buf, size_t size)
 262 {
 263         struct android_usb_function *f = dev_get_drvdata(dev);
 264         struct acm_function_config *config = f->config;
 265         int value;
 266
 267         sscanf(buf, "%d", &value);
 268         if (value > MAX_ACM_INSTANCES)
 269                 value = MAX_ACM_INSTANCES;
 270         config->instances = value;
 271         return size;
 272 }
 273
 274 static DEVICE_ATTR(instances, S_IRUGO | S_IWUSR, acm_instances_show, acm_instances_store);
 275 static struct device_attribute *acm_function_attributes[] = { &dev_attr_instances, NULL };
 276
 277 static struct android_usb_function acm_function = {
 278         .name           = "acm",
 279         .init           = acm_function_init,
 280         .cleanup        = acm_function_cleanup,
 281         .bind_config    = acm_function_bind_config,
 282         .attributes     = acm_function_attributes,
 283 };
 284
 285
 286 static int mtp_function_init(struct android_usb_function *f, struct usb_composite_dev *cdev)
 287 {
 288         return mtp_setup();
 289 }
 290
 291 static void mtp_function_cleanup(struct android_usb_function *f)
 292 {
 293         mtp_cleanup();
 294 }
 295
 296 static int mtp_function_bind_config(struct android_usb_function *f, struct usb_configuration *c)
 297 {
 298         return mtp_bind_config(c, false);
 299 }
 300
 301 static int ptp_function_init(struct android_usb_function *f, struct usb_composite_dev *cdev)
 302 {
 303         /* nothing to do - initialization is handled by mtp_function_init */
 304         return 0;
 305 }
 306
 307 static void ptp_function_cleanup(struct android_usb_function *f)
 308 {
 309         /* nothing to do - cleanup is handled by mtp_function_cleanup */
 310 }
 311
 312 static int ptp_function_bind_config(struct android_usb_function *f, struct usb_configuration *c)
 313 {
 314         return mtp_bind_config(c, true);
 315 }
 316
 317 static int mtp_function_ctrlrequest(struct android_usb_function *f,
 318                                                 struct usb_composite_dev *cdev,
 319                                                 const struct usb_ctrlrequest *c)
 320 {
 321         return mtp_ctrlrequest(cdev, c);
 322 }
 323
 324 static struct android_usb_function mtp_function = {
 325         .name           = "mtp",
 326         .init           = mtp_function_init,
 327         .cleanup        = mtp_function_cleanup,
 328         .bind_config    = mtp_function_bind_config,
 329         .ctrlrequest    = mtp_function_ctrlrequest,
 330 };
 331
 332 /* PTP function is same as MTP with slightly different interface descriptor */
 333 static struct android_usb_function ptp_function = {
 334         .name           = "ptp",
 335         .init           = ptp_function_init,
 336         .cleanup        = ptp_function_cleanup,
 337         .bind_config    = ptp_function_bind_config,
 338 };
 339
 340
 341 struct rndis_function_config {
 342         u8      ethaddr[ETH_ALEN];
 343         u32     vendorID;
 344         char    manufacturer[256];
 345         bool    wceis;
 346 };
 347
 348 static int rndis_function_init(struct android_usb_function *f, struct usb_composite_dev *cdev)
 349 {
 350         f->config = kzalloc(sizeof(struct rndis_function_config), GFP_KERNEL);
 351         if (!f->config)
 352                 return -ENOMEM;
 353         return 0;
 354 }
 355
 356 static void rndis_function_cleanup(struct android_usb_function *f)
 357 {
 358         kfree(f->config);
 359         f->config = NULL;
 360 }
 361
 362 static int rndis_function_bind_config(struct android_usb_function *f,
 363                                         struct usb_configuration *c)
 364 {
 365         int ret;
 366         struct rndis_function_config *rndis = f->config;
 367
 368         if (!rndis) {
 369                 pr_err("%s: rndis_pdata\n", __func__);
 370                 return -1;
 371         }
 372
 373         pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__,
 374                 rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
 375                 rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
 376
 377         ret = gether_setup_name(c->cdev->gadget, rndis->ethaddr, "rndis");
 378         if (ret) {
 379                 pr_err("%s: gether_setup failed\n", __func__);
 380                 return ret;
 381         }
 382
 383         if (rndis->wceis) {
 384                 /* "Wireless" RNDIS; auto-detected by Windows */
 385                 rndis_iad_descriptor.bFunctionClass =
 386                                                 USB_CLASS_WIRELESS_CONTROLLER;
 387                 rndis_iad_descriptor.bFunctionSubClass = 0x01;
 388                 rndis_iad_descriptor.bFunctionProtocol = 0x03;
 389                 rndis_control_intf.bInterfaceClass =
 390                                                 USB_CLASS_WIRELESS_CONTROLLER;
 391                 rndis_control_intf.bInterfaceSubClass =  0x01;
 392                 rndis_control_intf.bInterfaceProtocol =  0x03;
 393         }
 394
 395         return rndis_bind_config(c, rndis->ethaddr, rndis->vendorID,
 396                                     rndis->manufacturer);
 397 }
 398
 399 static void rndis_function_unbind_config(struct android_usb_function *f,
 400                                                 struct usb_configuration *c)
 401 {
 402         gether_cleanup();
 403 }
 404
 405 static ssize_t rndis_manufacturer_show(struct device *dev,
 406                 struct device_attribute *attr, char *buf)
 407 {
 408         struct android_usb_function *f = dev_get_drvdata(dev);
 409         struct rndis_function_config *config = f->config;
 410         return sprintf(buf, "%s\n", config->manufacturer);
 411 }
 412
 413 static ssize_t rndis_manufacturer_store(struct device *dev,
 414                 struct device_attribute *attr, const char *buf, size_t size)
 415 {
 416         struct android_usb_function *f = dev_get_drvdata(dev);
 417         struct rndis_function_config *config = f->config;
 418
 419         if (size >= sizeof(config->manufacturer))
 420                 return -EINVAL;
 421         if (sscanf(buf, "%s", config->manufacturer) == 1)
 422                 return size;
 423         return -1;
 424 }
 425
 426 static DEVICE_ATTR(manufacturer, S_IRUGO | S_IWUSR, rndis_manufacturer_show,
 427                                                     rndis_manufacturer_store);
 428
 429 static ssize_t rndis_wceis_show(struct device *dev,
 430                 struct device_attribute *attr, char *buf)
 431 {
 432         struct android_usb_function *f = dev_get_drvdata(dev);
 433         struct rndis_function_config *config = f->config;
 434         return sprintf(buf, "%d\n", config->wceis);
 435 }
 436
 437 static ssize_t rndis_wceis_store(struct device *dev,
 438                 struct device_attribute *attr, const char *buf, size_t size)
 439 {
 440         struct android_usb_function *f = dev_get_drvdata(dev);
 441         struct rndis_function_config *config = f->config;
 442         int value;
 443
 444         if (sscanf(buf, "%d", &value) == 1) {
 445                 config->wceis = value;
 446                 return size;
 447         }
 448         return -EINVAL;
 449 }
 450
 451 static DEVICE_ATTR(wceis, S_IRUGO | S_IWUSR, rndis_wceis_show,
 452                                              rndis_wceis_store);
 453
 454 static ssize_t rndis_ethaddr_show(struct device *dev,
 455                 struct device_attribute *attr, char *buf)
 456 {
 457         struct android_usb_function *f = dev_get_drvdata(dev);
 458         struct rndis_function_config *rndis = f->config;
 459         return sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
 460                 rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2],
 461                 rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]);
 462 }
 463
 464 static ssize_t rndis_ethaddr_store(struct device *dev,
 465                 struct device_attribute *attr, const char *buf, size_t size)
 466 {
 467         struct android_usb_function *f = dev_get_drvdata(dev);
 468         struct rndis_function_config *rndis = f->config;
 469
 470         if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n",
 471                     (int *)&rndis->ethaddr[0], (int *)&rndis->ethaddr[1],
 472                     (int *)&rndis->ethaddr[2], (int *)&rndis->ethaddr[3],
 473                     (int *)&rndis->ethaddr[4], (int *)&rndis->ethaddr[5]) == 6)
 474                 return size;
 475         return -EINVAL;
 476 }
 477
 478 static DEVICE_ATTR(ethaddr, S_IRUGO | S_IWUSR, rndis_ethaddr_show,
 479                                                rndis_ethaddr_store);
 480
 481 static ssize_t rndis_vendorID_show(struct device *dev,
 482                 struct device_attribute *attr, char *buf)
 483 {
 484         struct android_usb_function *f = dev_get_drvdata(dev);
 485         struct rndis_function_config *config = f->config;
 486         return sprintf(buf, "%04x\n", config->vendorID);
 487 }
 488
 489 static ssize_t rndis_vendorID_store(struct device *dev,
 490                 struct device_attribute *attr, const char *buf, size_t size)
 491 {
 492         struct android_usb_function *f = dev_get_drvdata(dev);
 493         struct rndis_function_config *config = f->config;
 494         int value;
 495
 496         if (sscanf(buf, "%04x", &value) == 1) {
 497                 config->vendorID = value;
 498                 return size;
 499         }
 500         return -EINVAL;
 501 }
 502
 503 static DEVICE_ATTR(vendorID, S_IRUGO | S_IWUSR, rndis_vendorID_show,
 504                                                 rndis_vendorID_store);
 505
 506 static struct device_attribute *rndis_function_attributes[] = {
 507         &dev_attr_manufacturer,
 508         &dev_attr_wceis,
 509         &dev_attr_ethaddr,
 510         &dev_attr_vendorID,
 511         NULL
 512 };
 513
 514 static struct android_usb_function rndis_function = {
 515         .name           = "rndis",
 516         .init           = rndis_function_init,
 517         .cleanup        = rndis_function_cleanup,
 518         .bind_config    = rndis_function_bind_config,
 519         .unbind_config  = rndis_function_unbind_config,
 520         .attributes     = rndis_function_attributes,
 521 };
 522
 523
 524 struct mass_storage_function_config {
 525         struct fsg_config fsg;
 526         struct fsg_common *common;
 527 };
 528
 529 static int mass_storage_function_init(struct android_usb_function *f,
 530                                         struct usb_composite_dev *cdev)
 531 {
 532         struct mass_storage_function_config *config;
 533         struct fsg_common *common;
 534         int err;
 535
 536         config = kzalloc(sizeof(struct mass_storage_function_config),
 537                                                                 GFP_KERNEL);
 538         if (!config)
 539                 return -ENOMEM;
 540
 541         config->fsg.nluns = 1;
 542         config->fsg.luns[0].removable = 1;
 543
 544         common = fsg_common_init(NULL, cdev, &config->fsg);
 545         if (IS_ERR(common)) {
 546                 kfree(config);
 547                 return PTR_ERR(common);
 548         }
 549
 550         err = sysfs_create_link(&f->dev->kobj,
 551                                 &common->luns[0].dev.kobj,
 552                                 "lun");
 553         if (err) {
 554                 kfree(config);
 555                 return err;
 556         }
 557
 558         config->common = common;
 559         f->config = config;
 560         return 0;
 561 }
 562
 563 static void mass_storage_function_cleanup(struct android_usb_function *f)
 564 {
 565         kfree(f->config);
 566         f->config = NULL;
 567 }
 568
 569 static int mass_storage_function_bind_config(struct android_usb_function *f,
 570                                                 struct usb_configuration *c)
 571 {
 572         struct mass_storage_function_config *config = f->config;
 573         return fsg_bind_config(c->cdev, c, config->common);
 574 }
 575
 576 static ssize_t mass_storage_inquiry_show(struct device *dev,
 577                                 struct device_attribute *attr, char *buf)
 578 {
 579         struct android_usb_function *f = dev_get_drvdata(dev);
 580         struct mass_storage_function_config *config = f->config;
 581         return sprintf(buf, "%s\n", config->common->inquiry_string);
 582 }
 583
 584 static ssize_t mass_storage_inquiry_store(struct device *dev,
 585                 struct device_attribute *attr, const char *buf, size_t size)
 586 {
 587         struct android_usb_function *f = dev_get_drvdata(dev);
 588         struct mass_storage_function_config *config = f->config;
 589         if (size >= sizeof(config->common->inquiry_string))
 590                 return -EINVAL;
 591         if (sscanf(buf, "%s", config->common->inquiry_string) != 1)
 592                 return -EINVAL;
 593         return size;
 594 }
 595
 596 static DEVICE_ATTR(inquiry_string, S_IRUGO | S_IWUSR,
 597                                         mass_storage_inquiry_show,
 598                                         mass_storage_inquiry_store);
 599
 600 static struct device_attribute *mass_storage_function_attributes[] = {
 601         &dev_attr_inquiry_string,
 602         NULL
 603 };
 604
 605 static struct android_usb_function mass_storage_function = {
 606         .name           = "mass_storage",
 607         .init           = mass_storage_function_init,
 608         .cleanup        = mass_storage_function_cleanup,
 609         .bind_config    = mass_storage_function_bind_config,
 610         .attributes     = mass_storage_function_attributes,
 611 };
 612
 613
 614 static int accessory_function_init(struct android_usb_function *f,
 615                                         struct usb_composite_dev *cdev)
 616 {
 617         return acc_setup();
 618 }
 619
 620 static void accessory_function_cleanup(struct android_usb_function *f)
 621 {
 622         acc_cleanup();
 623 }
 624
 625 static int accessory_function_bind_config(struct android_usb_function *f,
 626                                                 struct usb_configuration *c)
 627 {
 628         return acc_bind_config(c);
 629 }
 630
 631 static int accessory_function_ctrlrequest(struct android_usb_function *f,
 632                                                 struct usb_composite_dev *cdev,
 633                                                 const struct usb_ctrlrequest *c)
 634 {
 635         return acc_ctrlrequest(cdev, c);
 636 }
 637
 638 static struct android_usb_function accessory_function = {
 639         .name           = "accessory",
 640         .init           = accessory_function_init,
 641         .cleanup        = accessory_function_cleanup,
 642         .bind_config    = accessory_function_bind_config,
 643         .ctrlrequest    = accessory_function_ctrlrequest,
 644 };
 645
 646
 647 static struct android_usb_function *supported_functions[] = {
 648         &adb_function,
 649         &acm_function,
 650         &mtp_function,
 651         &ptp_function,
 652         &rndis_function,
 653         &mass_storage_function,
 654         &accessory_function,
 655         NULL
 656 };
 657
 658
 659 static int android_init_functions(struct android_usb_function **functions,
 660                                   struct usb_composite_dev *cdev)
 661 {
 662         struct android_dev *dev = _android_dev;
 663         struct android_usb_function *f;
 664         struct device_attribute **attrs;
 665         struct device_attribute *attr;
 666         int err;
 667         int index = 0;
 668
 669         for (; (f = *functions++); index++) {
 670                 f->dev_name = kasprintf(GFP_KERNEL, "f_%s", f->name);
 671                 f->dev = device_create(android_class, dev->dev,
 672                                 MKDEV(0, index), f, f->dev_name);
 673                 if (IS_ERR(f->dev)) {
 674                         pr_err("%s: Failed to create dev %s", __func__,
 675                                                         f->dev_name);
 676                         err = PTR_ERR(f->dev);
 677                         goto err_create;
 678                 }
 679
 680                 if (f->init) {
 681                         err = f->init(f, cdev);
 682                         if (err) {
 683                                 pr_err("%s: Failed to init %s", __func__,
 684                                                                 f->name);
 685                                 goto err_out;
 686                         }
 687                 }
 688
 689                 attrs = f->attributes;
 690                 if (attrs) {
 691                         while ((attr = *attrs++) && !err)
 692                                 err = device_create_file(f->dev, attr);
 693                 }
 694                 if (err) {
 695                         pr_err("%s: Failed to create function %s attributes",
 696                                         __func__, f->name);
 697                         goto err_out;
 698                 }
 699         }
 700         return 0;
 701
 702 err_out:
 703         device_destroy(android_class, f->dev->devt);
 704 err_create:
 705         kfree(f->dev_name);
 706         return err;
 707 }
 708
 709 static void android_cleanup_functions(struct android_usb_function **functions)
 710 {
 711         struct android_usb_function *f;
 712
 713         while (*functions) {
 714                 f = *functions++;
 715
 716                 if (f->dev) {
 717                         device_destroy(android_class, f->dev->devt);
 718                         kfree(f->dev_name);
 719                 }
 720
 721                 if (f->cleanup)
 722                         f->cleanup(f);
 723         }
 724 }
 725
 726 static int
 727 android_bind_enabled_functions(struct android_dev *dev,
 728                                struct usb_configuration *c)
 729 {
 730         struct android_usb_function *f;
 731         int ret;
 732
 733         list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
 734                 ret = f->bind_config(f, c);
 735                 if (ret) {
 736                         pr_err("%s: %s failed", __func__, f->name);
 737                         return ret;
 738                 }
 739         }
 740         return 0;
 741 }
 742
 743 static void
 744 android_unbind_enabled_functions(struct android_dev *dev,
 745                                struct usb_configuration *c)
 746 {
 747         struct android_usb_function *f;
 748
 749         list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
 750                 if (f->unbind_config)
 751                         f->unbind_config(f, c);
 752         }
 753 }
 754
 755 static int android_enable_function(struct android_dev *dev, char *name)
 756 {
 757         struct android_usb_function **functions = dev->functions;
 758         struct android_usb_function *f;
 759         while ((f = *functions++)) {
 760                 if (!strcmp(name, f->name)) {
 761                         list_add_tail(&f->enabled_list, &dev->enabled_functions);
 762                         return 0;
 763                 }
 764         }
 765         return -EINVAL;
 766 }
 767
 768 /*-------------------------------------------------------------------------*/
 769 /* /sys/class/android_usb/android%d/ interface */
 770
 771 static ssize_t
 772 functions_show(struct device *pdev, struct device_attribute *attr, char *buf)
 773 {
 774         struct android_dev *dev = dev_get_drvdata(pdev);
 775         struct android_usb_function *f;
 776         char *buff = buf;
 777
 778         mutex_lock(&dev->mutex);
 779
 780         list_for_each_entry(f, &dev->enabled_functions, enabled_list)
 781                 buff += sprintf(buff, "%s,", f->name);
 782
 783         mutex_unlock(&dev->mutex);
 784
 785         if (buff != buf)
 786                 *(buff-1) = '\n';
 787         return buff - buf;
 788 }
 789
 790 static ssize_t
 791 functions_store(struct device *pdev, struct device_attribute *attr,
 792                                const char *buff, size_t size)
 793 {
 794         struct android_dev *dev = dev_get_drvdata(pdev);
 795         char *name;
 796         char buf[256], *b;
 797         int err;
 798
 799         mutex_lock(&dev->mutex);
 800
 801         if (dev->enabled) {
 802                 mutex_unlock(&dev->mutex);
 803                 return -EBUSY;
 804         }
 805
 806         INIT_LIST_HEAD(&dev->enabled_functions);
 807
 808         strncpy(buf, buff, sizeof(buf));
 809         b = strim(buf);
 810
 811         while (b) {
 812                 name = strsep(&b, ",");
 813                 if (name) {
 814                         err = android_enable_function(dev, name);
 815                         if (err)
 816                                 pr_err("android_usb: Cannot enable '%s'", name);
 817                 }
 818         }
 819
 820         mutex_unlock(&dev->mutex);
 821
 822         return size;
 823 }
 824
 825 static ssize_t enable_show(struct device *pdev, struct device_attribute *attr,
 826                            char *buf)
 827 {
 828         struct android_dev *dev = dev_get_drvdata(pdev);
 829         return sprintf(buf, "%d\n", dev->enabled);
 830 }
 831
 832 static ssize_t enable_store(struct device *pdev, struct device_attribute *attr,
 833                             const char *buff, size_t size)
 834 {
 835         struct android_dev *dev = dev_get_drvdata(pdev);
 836         struct usb_composite_dev *cdev = dev->cdev;
 837         int enabled = 0;
 838
 839         mutex_lock(&dev->mutex);
 840
 841         sscanf(buff, "%d", &enabled);
 842         if (enabled && !dev->enabled) {
 843                 cdev->next_string_id = 0;
 844                 /* update values in composite driver's copy of device descriptor */
 845                 cdev->desc.idVendor = device_desc.idVendor;
 846                 cdev->desc.idProduct = device_desc.idProduct;
 847                 cdev->desc.bcdDevice = device_desc.bcdDevice;
 848                 cdev->desc.bDeviceClass = device_desc.bDeviceClass;
 849                 cdev->desc.bDeviceSubClass = device_desc.bDeviceSubClass;
 850                 cdev->desc.bDeviceProtocol = device_desc.bDeviceProtocol;
 851                 usb_add_config(cdev, &android_config_driver,
 852                                         android_bind_config);
 853                 usb_gadget_connect(cdev->gadget);
 854                 dev->enabled = true;
 855         } else if (!enabled && dev->enabled) {
 856                 usb_gadget_disconnect(cdev->gadget);
 857                 /* Cancel pending control requests */
 858                 usb_ep_dequeue(cdev->gadget->ep0, cdev->req);
 859                 usb_remove_config(cdev, &android_config_driver);
 860                 dev->enabled = false;
 861         } else {
 862                 pr_err("android_usb: already %s\n",
 863                                 dev->enabled ? "enabled" : "disabled");
 864         }
 865
 866         mutex_unlock(&dev->mutex);
 867         return size;
 868 }
 869
 870 static ssize_t state_show(struct device *pdev, struct device_attribute *attr,
 871                            char *buf)
 872 {
 873         struct android_dev *dev = dev_get_drvdata(pdev);
 874         struct usb_composite_dev *cdev = dev->cdev;
 875         char *state = "DISCONNECTED";
 876         unsigned long flags;
 877
 878         if (!cdev)
 879                 goto out;
 880
 881         spin_lock_irqsave(&cdev->lock, flags);
 882         if (cdev->config)
 883                 state = "CONFIGURED";
 884         else if (dev->connected)
 885                 state = "CONNECTED";
 886         spin_unlock_irqrestore(&cdev->lock, flags);
 887 out:
 888         return sprintf(buf, "%s\n", state);
 889 }
 890
 891 #define DESCRIPTOR_ATTR(field, format_string)                           \
 892 static ssize_t                                                          \
 893 field ## _show(struct device *dev, struct device_attribute *attr,       \
 894                 char *buf)                                              \
 895 {                                                                       \
 896         return sprintf(buf, format_string, device_desc.field);          \
 897 }                                                                       \
 898 static ssize_t                                                          \
 899 field ## _store(struct device *dev, struct device_attribute *attr,      \
 900                 const char *buf, size_t size)                           \
 901 {                                                                       \
 902         int value;                                                      \
 903         if (sscanf(buf, format_string, &value) == 1) {                  \
 904                 device_desc.field = value;                              \
 905                 return size;                                            \
 906         }                                                               \
 907         return -1;                                                      \
 908 }                                                                       \
 909 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
 910
 911 #define DESCRIPTOR_STRING_ATTR(field, buffer)                           \
 912 static ssize_t                                                          \
 913 field ## _show(struct device *dev, struct device_attribute *attr,       \
 914                 char *buf)                                              \
 915 {                                                                       \
 916         return sprintf(buf, "%s", buffer);                              \
 917 }                                                                       \
 918 static ssize_t                                                          \
 919 field ## _store(struct device *dev, struct device_attribute *attr,      \
 920                 const char *buf, size_t size)                           \
 921 {                                                                       \
 922         if (size >= sizeof(buffer)) return -EINVAL;                     \
 923         if (sscanf(buf, "%s", buffer) == 1) {                           \
 924                 return size;                                            \
 925         }                                                               \
 926         return -1;                                                      \
 927 }                                                                       \
 928 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store);
 929
 930
 931 DESCRIPTOR_ATTR(idVendor, "%04x\n")
 932 DESCRIPTOR_ATTR(idProduct, "%04x\n")
 933 DESCRIPTOR_ATTR(bcdDevice, "%04x\n")
 934 DESCRIPTOR_ATTR(bDeviceClass, "%d\n")
 935 DESCRIPTOR_ATTR(bDeviceSubClass, "%d\n")
 936 DESCRIPTOR_ATTR(bDeviceProtocol, "%d\n")
 937 DESCRIPTOR_STRING_ATTR(iManufacturer, manufacturer_string)
 938 DESCRIPTOR_STRING_ATTR(iProduct, product_string)
 939 DESCRIPTOR_STRING_ATTR(iSerial, serial_string)
 940
 941 static DEVICE_ATTR(functions, S_IRUGO | S_IWUSR, functions_show, functions_store);
 942 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, enable_show, enable_store);
 943 static DEVICE_ATTR(state, S_IRUGO, state_show, NULL);
 944
 945 static struct device_attribute *android_usb_attributes[] = {
 946         &dev_attr_idVendor,
 947         &dev_attr_idProduct,
 948         &dev_attr_bcdDevice,
 949         &dev_attr_bDeviceClass,
 950         &dev_attr_bDeviceSubClass,
 951         &dev_attr_bDeviceProtocol,
 952         &dev_attr_iManufacturer,
 953         &dev_attr_iProduct,
 954         &dev_attr_iSerial,
 955         &dev_attr_functions,
 956         &dev_attr_enable,
 957         &dev_attr_state,
 958         NULL
 959 };
 960
 961 /*-------------------------------------------------------------------------*/
 962 /* Composite driver */
 963
 964 static int android_bind_config(struct usb_configuration *c)
 965 {
 966         struct android_dev *dev = _android_dev;
 967         int ret = 0;
 968
 969         ret = android_bind_enabled_functions(dev, c);
 970         if (ret)
 971                 return ret;
 972
 973         return 0;
 974 }
 975
 976 static void android_unbind_config(struct usb_configuration *c)
 977 {
 978         struct android_dev *dev = _android_dev;
 979
 980         android_unbind_enabled_functions(dev, c);
 981 }
 982
 983 static int android_bind(struct usb_composite_dev *cdev)
 984 {
 985         struct android_dev *dev = _android_dev;
 986         struct usb_gadget       *gadget = cdev->gadget;
 987         int                     gcnum, id, ret;
 988
 989         usb_gadget_disconnect(gadget);
 990
 991         ret = android_init_functions(dev->functions, cdev);
 992         if (ret)
 993                 return ret;
 994
 995         /* Allocate string descriptor numbers ... note that string
 996          * contents can be overridden by the composite_dev glue.
 997          */
 998         id = usb_string_id(cdev);
 999         if (id < 0)
1000                 return id;
1001         strings_dev[STRING_MANUFACTURER_IDX].id = id;
1002         device_desc.iManufacturer = id;
1003
1004         id = usb_string_id(cdev);
1005         if (id < 0)
1006                 return id;
1007         strings_dev[STRING_PRODUCT_IDX].id = id;
1008         device_desc.iProduct = id;
1009
1010         /* Default strings - should be updated by userspace */
1011         strncpy(manufacturer_string, "Android", sizeof(manufacturer_string) - 1);
1012         strncpy(product_string, "Android", sizeof(product_string) - 1);
1013         strncpy(serial_string, "0123456789ABCDEF", sizeof(serial_string) - 1);
1014
1015         id = usb_string_id(cdev);
1016         if (id < 0)
1017                 return id;
1018         strings_dev[STRING_SERIAL_IDX].id = id;
1019         device_desc.iSerialNumber = id;
1020
1021         gcnum = usb_gadget_controller_number(gadget);
1022         if (gcnum >= 0)
1023                 device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
1024         else {
1025                 /* gadget zero is so simple (for now, no altsettings) that
1026                  * it SHOULD NOT have problems with bulk-capable hardware.
1027                  * so just warn about unrcognized controllers -- don't panic.
1028                  *
1029                  * things like configuration and altsetting numbering
1030                  * can need hardware-specific attention though.
1031                  */
1032                 pr_warning("%s: controller '%s' not recognized\n",
1033                         longname, gadget->name);
1034                 device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
1035         }
1036
1037         usb_gadget_set_selfpowered(gadget);
1038         dev->cdev = cdev;
1039
1040         return 0;
1041 }
1042
1043 static int android_usb_unbind(struct usb_composite_dev *cdev)
1044 {
1045         struct android_dev *dev = _android_dev;
1046
1047         cancel_work_sync(&dev->work);
1048         android_cleanup_functions(dev->functions);
1049         return 0;
1050 }
1051
1052 static struct usb_composite_driver android_usb_driver = {
1053         .name           = "android_usb",
1054         .dev            = &device_desc,
1055         .strings        = dev_strings,
1056         .unbind         = android_usb_unbind,
1057 };
1058
1059 static int
1060 android_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c)
1061 {
1062         struct android_dev              *dev = _android_dev;
1063         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
1064         struct usb_request              *req = cdev->req;
1065         struct android_usb_function     *f;
1066         int value = -EOPNOTSUPP;
1067         unsigned long flags;
1068
1069         req->zero = 0;
1070         req->complete = composite_setup_complete;
1071         req->length = 0;
1072         gadget->ep0->driver_data = cdev;
1073
1074         list_for_each_entry(f, &dev->enabled_functions, enabled_list) {
1075                 if (f->ctrlrequest) {
1076                         value = f->ctrlrequest(f, cdev, c);
1077                         if (value >= 0)
1078                                 break;
1079                 }
1080         }
1081
1082         /* Special case the accessory function.
1083          * It needs to handle control requests before it is enabled.
1084          */
1085         if (value < 0)
1086                 value = acc_ctrlrequest(cdev, c);
1087
1088         if (value < 0)
1089                 value = composite_setup(gadget, c);
1090
1091         spin_lock_irqsave(&cdev->lock, flags);
1092         if (!dev->connected) {
1093                 dev->connected = 1;
1094                 schedule_work(&dev->work);
1095         }
1096         else if (c->bRequest == USB_REQ_SET_CONFIGURATION && cdev->config) {
1097                 schedule_work(&dev->work);
1098         }
1099         spin_unlock_irqrestore(&cdev->lock, flags);
1100
1101         return value;
1102 }
1103
1104 static void android_disconnect(struct usb_gadget *gadget)
1105 {
1106         struct android_dev *dev = _android_dev;
1107         struct usb_composite_dev *cdev = get_gadget_data(gadget);
1108         unsigned long flags;
1109
1110         composite_disconnect(gadget);
1111
1112         spin_lock_irqsave(&cdev->lock, flags);
1113         dev->connected = 0;
1114         schedule_work(&dev->work);
1115         spin_unlock_irqrestore(&cdev->lock, flags);
1116 }
1117
1118 static int android_create_device(struct android_dev *dev)
1119 {
1120         struct device_attribute **attrs = android_usb_attributes;
1121         struct device_attribute *attr;
1122         int err;
1123
1124         dev->dev = device_create(android_class, NULL,
1125                                         MKDEV(0, 0), NULL, "android0");
1126         if (IS_ERR(dev->dev))
1127                 return PTR_ERR(dev->dev);
1128
1129         dev_set_drvdata(dev->dev, dev);
1130
1131         while ((attr = *attrs++)) {
1132                 err = device_create_file(dev->dev, attr);
1133                 if (err) {
1134                         device_destroy(android_class, dev->dev->devt);
1135                         return err;
1136                 }
1137         }
1138         return 0;
1139 }
1140
1141
1142 static int __init init(void)
1143 {
1144         struct android_dev *dev;
1145         int err;
1146
1147         android_class = class_create(THIS_MODULE, "android_usb");
1148         if (IS_ERR(android_class))
1149                 return PTR_ERR(android_class);
1150
1151         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1152         if (!dev)
1153                 return -ENOMEM;
1154
1155         dev->functions = supported_functions;
1156         INIT_LIST_HEAD(&dev->enabled_functions);
1157         INIT_WORK(&dev->work, android_work);
1158         mutex_init(&dev->mutex);
1159
1160         err = android_create_device(dev);
1161         if (err) {
1162                 class_destroy(android_class);
1163                 kfree(dev);
1164                 return err;
1165         }
1166
1167         _android_dev = dev;
1168
1169         /* Override composite driver functions */
1170         composite_driver.setup = android_setup;
1171         composite_driver.disconnect = android_disconnect;
1172
1173         return usb_composite_probe(&android_usb_driver, android_bind);
1174 }
1175 module_init(init);
1176
1177 static void __exit cleanup(void)
1178 {
1179         usb_composite_unregister(&android_usb_driver);
1180         class_destroy(android_class);
1181         kfree(_android_dev);
1182         _android_dev = NULL;
1183 }
1184 module_exit(cleanup);