drivers/usb/gadget/composite.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * composite.c - infrastructure for Composite USB Gadgets
   4  *
   5  * Copyright (C) 2006-2008 David Brownell
   6  * U-Boot porting: Lukasz Majewski <l.majewski@samsung.com>
   7  */
   8 #undef DEBUG
   9
  10 #include <log.h>
  11 #include <dm/devres.h>
  12 #include <linux/bitops.h>
  13 #include <linux/bug.h>
  14 #include <linux/usb/composite.h>
  15 #include "u_os_desc.h"
  16
  17 #define USB_BUFSIZ      4096
  18
  19 /* Helper type for accessing packed u16 pointers */
  20 typedef struct { __le16 val; } __packed __le16_packed;
  21
  22 static struct usb_composite_driver *composite;
  23 static struct usb_configuration *os_desc_config;
  24
  25 /* Microsoft OS String Descriptor */
  26 static char qw_sign_buf[OS_STRING_QW_SIGN_LEN / 2] = {'M', 'S', 'F', 'T', '1', '0', '0'};
  27
  28 static inline void le16_add_cpu_packed(__le16_packed *var, u16 val)
  29 {
  30         var->val = cpu_to_le16(le16_to_cpu(var->val) + val);
  31 }
  32
  33 /**
  34  * struct usb_os_string - represents OS String to be reported by a gadget
  35  * @bLength: total length of the entire descritor, always 0x12
  36  * @bDescriptorType: USB_DT_STRING
  37  * @qwSignature: the OS String proper
  38  * @bMS_VendorCode: code used by the host for subsequent requests
  39  * @bPad: not used, must be zero
  40  */
  41 struct usb_os_string {
  42         __u8    bLength;
  43         __u8    bDescriptorType;
  44         __u8    qwSignature[OS_STRING_QW_SIGN_LEN];
  45         __u8    bMS_VendorCode;
  46         __u8    bPad;
  47 } __packed;
  48
  49 /**
  50  * usb_add_function() - add a function to a configuration
  51  * @config: the configuration
  52  * @function: the function being added
  53  * Context: single threaded during gadget setup
  54  *
  55  * After initialization, each configuration must have one or more
  56  * functions added to it.  Adding a function involves calling its @bind()
  57  * method to allocate resources such as interface and string identifiers
  58  * and endpoints.
  59  *
  60  * This function returns the value of the function's bind(), which is
  61  * zero for success else a negative errno value.
  62  */
  63 int usb_add_function(struct usb_configuration *config,
  64                 struct usb_function *function)
  65 {
  66         int     value = -EINVAL;
  67
  68         debug("adding '%s'/%p to config '%s'/%p\n",
  69                         function->name, function,
  70                         config->label, config);
  71
  72         if (!function->set_alt || !function->disable)
  73                 goto done;
  74
  75         function->config = config;
  76         list_add_tail(&function->list, &config->functions);
  77
  78         if (function->bind) {
  79                 value = function->bind(config, function);
  80                 if (value < 0) {
  81                         list_del(&function->list);
  82                         function->config = NULL;
  83                 }
  84         } else
  85                 value = 0;
  86
  87         if (!config->fullspeed && function->descriptors)
  88                 config->fullspeed = 1;
  89         if (!config->highspeed && function->hs_descriptors)
  90                 config->highspeed = 1;
  91         if (!config->superspeed && function->ss_descriptors)
  92                 config->superspeed = 1;
  93
  94 done:
  95         if (value)
  96                 debug("adding '%s'/%p --> %d\n",
  97                                 function->name, function, value);
  98         return value;
  99 }
 100
 101 /**
 102  * usb_function_deactivate - prevent function and gadget enumeration
 103  * @function: the function that isn't yet ready to respond
 104  *
 105  * Blocks response of the gadget driver to host enumeration by
 106  * preventing the data line pullup from being activated.  This is
 107  * normally called during @bind() processing to change from the
 108  * initial "ready to respond" state, or when a required resource
 109  * becomes available.
 110  *
 111  * For example, drivers that serve as a passthrough to a userspace
 112  * daemon can block enumeration unless that daemon (such as an OBEX,
 113  * MTP, or print server) is ready to handle host requests.
 114  *
 115  * Not all systems support software control of their USB peripheral
 116  * data pullups.
 117  *
 118  * Returns zero on success, else negative errno.
 119  */
 120 int usb_function_deactivate(struct usb_function *function)
 121 {
 122         struct usb_composite_dev        *cdev = function->config->cdev;
 123         int                             status = 0;
 124
 125         if (cdev->deactivations == 0)
 126                 status = usb_gadget_disconnect(cdev->gadget);
 127         if (status == 0)
 128                 cdev->deactivations++;
 129
 130         return status;
 131 }
 132
 133 /**
 134  * usb_function_activate - allow function and gadget enumeration
 135  * @function: function on which usb_function_activate() was called
 136  *
 137  * Reverses effect of usb_function_deactivate().  If no more functions
 138  * are delaying their activation, the gadget driver will respond to
 139  * host enumeration procedures.
 140  *
 141  * Returns zero on success, else negative errno.
 142  */
 143 int usb_function_activate(struct usb_function *function)
 144 {
 145         struct usb_composite_dev        *cdev = function->config->cdev;
 146         int                             status = 0;
 147
 148         if (cdev->deactivations == 0)
 149                 status = -EINVAL;
 150         else {
 151                 cdev->deactivations--;
 152                 if (cdev->deactivations == 0)
 153                         status = usb_gadget_connect(cdev->gadget);
 154         }
 155
 156         return status;
 157 }
 158
 159 /**
 160  * usb_interface_id() - allocate an unused interface ID
 161  * @config: configuration associated with the interface
 162  * @function: function handling the interface
 163  * Context: single threaded during gadget setup
 164  *
 165  * usb_interface_id() is called from usb_function.bind() callbacks to
 166  * allocate new interface IDs.  The function driver will then store that
 167  * ID in interface, association, CDC union, and other descriptors.  It
 168  * will also handle any control requests targetted at that interface,
 169  * particularly changing its altsetting via set_alt().  There may
 170  * also be class-specific or vendor-specific requests to handle.
 171  *
 172  * All interface identifier should be allocated using this routine, to
 173  * ensure that for example different functions don't wrongly assign
 174  * different meanings to the same identifier.  Note that since interface
 175  * identifers are configuration-specific, functions used in more than
 176  * one configuration (or more than once in a given configuration) need
 177  * multiple versions of the relevant descriptors.
 178  *
 179  * Returns the interface ID which was allocated; or -ENODEV if no
 180  * more interface IDs can be allocated.
 181  */
 182 int usb_interface_id(struct usb_configuration *config,
 183                 struct usb_function *function)
 184 {
 185         unsigned char id = config->next_interface_id;
 186
 187         if (id < MAX_CONFIG_INTERFACES) {
 188                 config->interface[id] = function;
 189                 config->next_interface_id = id + 1;
 190                 return id;
 191         }
 192         return -ENODEV;
 193 }
 194
 195 static int config_buf(struct usb_configuration *config,
 196                 enum usb_device_speed speed, void *buf, u8 type)
 197 {
 198         int                             len = USB_BUFSIZ - USB_DT_CONFIG_SIZE;
 199         void                            *next = buf + USB_DT_CONFIG_SIZE;
 200         struct usb_descriptor_header    **descriptors;
 201         struct usb_config_descriptor    *c;
 202         int                             status;
 203         struct usb_function             *f;
 204
 205         /* write the config descriptor */
 206         c = buf;
 207         c->bLength = USB_DT_CONFIG_SIZE;
 208         c->bDescriptorType = type;
 209
 210         c->bNumInterfaces = config->next_interface_id;
 211         c->bConfigurationValue = config->bConfigurationValue;
 212         c->iConfiguration = config->iConfiguration;
 213         c->bmAttributes = USB_CONFIG_ATT_ONE | config->bmAttributes;
 214         c->bMaxPower = config->bMaxPower ? : (CONFIG_USB_GADGET_VBUS_DRAW / 2);
 215
 216         /* There may be e.g. OTG descriptors */
 217         if (config->descriptors) {
 218                 status = usb_descriptor_fillbuf(next, len,
 219                                 config->descriptors);
 220                 if (status < 0)
 221                         return status;
 222                 len -= status;
 223                 next += status;
 224         }
 225
 226         /* add each function's descriptors */
 227         list_for_each_entry(f, &config->functions, list) {
 228                 if (speed == USB_SPEED_SUPER)
 229                         descriptors = f->ss_descriptors;
 230                 else if (speed == USB_SPEED_HIGH)
 231                         descriptors = f->hs_descriptors;
 232                 else
 233                         descriptors = f->descriptors;
 234                 if (!descriptors)
 235                         continue;
 236                 status = usb_descriptor_fillbuf(next, len,
 237                         (const struct usb_descriptor_header **) descriptors);
 238                 if (status < 0)
 239                         return status;
 240                 len -= status;
 241                 next += status;
 242         }
 243
 244         len = next - buf;
 245         c->wTotalLength = cpu_to_le16(len);
 246         return len;
 247 }
 248
 249 static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
 250 {
 251         enum usb_device_speed           speed = USB_SPEED_UNKNOWN;
 252         struct usb_gadget               *gadget = cdev->gadget;
 253         u8                              type = w_value >> 8;
 254         int                             hs = 0;
 255         struct usb_configuration        *c;
 256         struct list_head                *pos;
 257
 258         if (gadget_is_superspeed(gadget)) {
 259                 speed = gadget->speed;
 260         } else if (gadget_is_dualspeed(gadget)) {
 261                 if (gadget->speed == USB_SPEED_HIGH)
 262                         hs = 1;
 263                 if (type == USB_DT_OTHER_SPEED_CONFIG)
 264                         hs = !hs;
 265                 if (hs)
 266                         speed = USB_SPEED_HIGH;
 267         }
 268
 269         w_value &= 0xff;
 270
 271         pos = &cdev->configs;
 272         c = cdev->os_desc_config;
 273         if (c)
 274                 goto check_config;
 275
 276         while ((pos = pos->next) !=  &cdev->configs) {
 277                 c = list_entry(pos, typeof(*c), list);
 278
 279                 /* skip OS Descriptors config which is handled separately */
 280                 if (c == cdev->os_desc_config)
 281                         continue;
 282
 283 check_config:
 284                 if (speed == USB_SPEED_SUPER) {
 285                         if (!c->superspeed)
 286                                 continue;
 287                 } else if (speed == USB_SPEED_HIGH) {
 288                         if (!c->highspeed)
 289                                 continue;
 290                 } else {
 291                         if (!c->fullspeed)
 292                                 continue;
 293                 }
 294                 if (w_value == 0)
 295                         return config_buf(c, speed, cdev->req->buf, type);
 296                 w_value--;
 297         }
 298         return -EINVAL;
 299 }
 300
 301 static int count_configs(struct usb_composite_dev *cdev, unsigned type)
 302 {
 303         struct usb_gadget               *gadget = cdev->gadget;
 304         unsigned                        count = 0;
 305         int                             hs = 0;
 306         int                             ss = 0;
 307         struct usb_configuration        *c;
 308
 309         if (gadget->speed == USB_SPEED_SUPER)
 310                 ss = 1;
 311
 312         if (gadget_is_dualspeed(gadget)) {
 313                 if (gadget->speed == USB_SPEED_HIGH)
 314                         hs = 1;
 315                 if (type == USB_DT_DEVICE_QUALIFIER)
 316                         hs = !hs;
 317         }
 318         list_for_each_entry(c, &cdev->configs, list) {
 319                 /* ignore configs that won't work at this speed */
 320                 if (ss) {
 321                         if (!c->superspeed)
 322                                 continue;
 323                 } else if (hs) {
 324                         if (!c->highspeed)
 325                                 continue;
 326                 } else {
 327                         if (!c->fullspeed)
 328                                 continue;
 329                 }
 330                 count++;
 331         }
 332         return count;
 333 }
 334
 335 static void device_qual(struct usb_composite_dev *cdev)
 336 {
 337         struct usb_qualifier_descriptor *qual = cdev->req->buf;
 338
 339         qual->bLength = sizeof(*qual);
 340         qual->bDescriptorType = USB_DT_DEVICE_QUALIFIER;
 341         /* POLICY: same bcdUSB and device type info at both speeds */
 342         qual->bcdUSB = cdev->desc.bcdUSB;
 343         qual->bDeviceClass = cdev->desc.bDeviceClass;
 344         qual->bDeviceSubClass = cdev->desc.bDeviceSubClass;
 345         qual->bDeviceProtocol = cdev->desc.bDeviceProtocol;
 346         /* ASSUME same EP0 fifo size at both speeds */
 347         qual->bMaxPacketSize0 = cdev->gadget->ep0->maxpacket;
 348         qual->bNumConfigurations = count_configs(cdev, USB_DT_DEVICE_QUALIFIER);
 349         qual->bRESERVED = 0;
 350 }
 351
 352 static void reset_config(struct usb_composite_dev *cdev)
 353 {
 354         struct usb_function             *f;
 355
 356         debug("%s:\n", __func__);
 357
 358         list_for_each_entry(f, &cdev->config->functions, list) {
 359                 if (f->disable)
 360                         f->disable(f);
 361
 362                 bitmap_zero(f->endpoints, 32);
 363         }
 364         cdev->config = NULL;
 365 }
 366
 367 static int set_config(struct usb_composite_dev *cdev,
 368                 const struct usb_ctrlrequest *ctrl, unsigned number)
 369 {
 370         struct usb_gadget       *gadget = cdev->gadget;
 371         unsigned                power = gadget_is_otg(gadget) ? 8 : 100;
 372         struct usb_descriptor_header **descriptors;
 373         int                     result = -EINVAL;
 374         struct usb_endpoint_descriptor *ep;
 375         struct usb_configuration *c = NULL;
 376         int                     addr;
 377         int                     tmp;
 378         struct usb_function     *f;
 379
 380         if (cdev->config)
 381                 reset_config(cdev);
 382
 383         if (number) {
 384                 list_for_each_entry(c, &cdev->configs, list) {
 385                         if (c->bConfigurationValue == number) {
 386                                 result = 0;
 387                                 break;
 388                         }
 389                 }
 390                 if (result < 0)
 391                         goto done;
 392         } else
 393                 result = 0;
 394
 395         debug("%s: %s speed config #%d: %s\n", __func__,
 396              ({ char *speed;
 397                      switch (gadget->speed) {
 398                      case USB_SPEED_LOW:
 399                              speed = "low";
 400                              break;
 401                      case USB_SPEED_FULL:
 402                              speed = "full";
 403                              break;
 404                      case USB_SPEED_HIGH:
 405                              speed = "high";
 406                              break;
 407                      case USB_SPEED_SUPER:
 408                              speed = "super";
 409                              break;
 410                      default:
 411                              speed = "?";
 412                              break;
 413                      };
 414                      speed;
 415              }), number, c ? c->label : "unconfigured");
 416
 417         if (!c)
 418                 goto done;
 419
 420         cdev->config = c;
 421
 422         /* Initialize all interfaces by setting them to altsetting zero. */
 423         for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
 424                 f = c->interface[tmp];
 425                 if (!f)
 426                         break;
 427
 428                 /*
 429                  * Record which endpoints are used by the function. This is used
 430                  * to dispatch control requests targeted at that endpoint to the
 431                  * function's setup callback instead of the current
 432                  * configuration's setup callback.
 433                  */
 434                 if (gadget->speed == USB_SPEED_SUPER)
 435                         descriptors = f->ss_descriptors;
 436                 else if (gadget->speed == USB_SPEED_HIGH)
 437                         descriptors = f->hs_descriptors;
 438                 else
 439                         descriptors = f->descriptors;
 440
 441                 for (; *descriptors; ++descriptors) {
 442                         if ((*descriptors)->bDescriptorType != USB_DT_ENDPOINT)
 443                                 continue;
 444
 445                         ep = (struct usb_endpoint_descriptor *)*descriptors;
 446                         addr = ((ep->bEndpointAddress & 0x80) >> 3)
 447                              |  (ep->bEndpointAddress & 0x0f);
 448                         generic_set_bit(addr, f->endpoints);
 449                 }
 450
 451                 result = f->set_alt(f, tmp, 0);
 452                 if (result < 0) {
 453                         debug("interface %d (%s/%p) alt 0 --> %d\n",
 454                                         tmp, f->name, f, result);
 455
 456                         reset_config(cdev);
 457                         goto done;
 458                 }
 459         }
 460
 461         /* when we return, be sure our power usage is valid */
 462         power = c->bMaxPower ? (2 * c->bMaxPower) : CONFIG_USB_GADGET_VBUS_DRAW;
 463 done:
 464         usb_gadget_vbus_draw(gadget, power);
 465         return result;
 466 }
 467
 468 /**
 469  * usb_add_config() - add a configuration to a device.
 470  * @cdev: wraps the USB gadget
 471  * @config: the configuration, with bConfigurationValue assigned
 472  * Context: single threaded during gadget setup
 473  *
 474  * One of the main tasks of a composite driver's bind() routine is to
 475  * add each of the configurations it supports, using this routine.
 476  *
 477  * This function returns the value of the configuration's bind(), which
 478  * is zero for success else a negative errno value.  Binding configurations
 479  * assigns global resources including string IDs, and per-configuration
 480  * resources such as interface IDs and endpoints.
 481  */
 482 int usb_add_config(struct usb_composite_dev *cdev,
 483                 struct usb_configuration *config)
 484 {
 485         int                             status = -EINVAL;
 486         struct usb_configuration        *c;
 487         struct usb_function             *f;
 488         unsigned int                    i;
 489
 490         debug("%s: adding config #%u '%s'/%p\n", __func__,
 491                         config->bConfigurationValue,
 492                         config->label, config);
 493
 494         if (!config->bConfigurationValue || !config->bind)
 495                 goto done;
 496
 497         /* Prevent duplicate configuration identifiers */
 498         list_for_each_entry(c, &cdev->configs, list) {
 499                 if (c->bConfigurationValue == config->bConfigurationValue) {
 500                         status = -EBUSY;
 501                         goto done;
 502                 }
 503         }
 504
 505         config->cdev = cdev;
 506         list_add_tail(&config->list, &cdev->configs);
 507
 508         INIT_LIST_HEAD(&config->functions);
 509         config->next_interface_id = 0;
 510
 511         status = config->bind(config);
 512         if (status < 0) {
 513                 list_del(&config->list);
 514                 config->cdev = NULL;
 515         } else {
 516                 debug("cfg %d/%p speeds:%s%s%s\n",
 517                         config->bConfigurationValue, config,
 518                         config->superspeed ? " super" : "",
 519                         config->highspeed ? " high" : "",
 520                         config->fullspeed
 521                                 ? (gadget_is_dualspeed(cdev->gadget)
 522                                         ? " full"
 523                                         : " full/low")
 524                                 : "");
 525
 526                 for (i = 0; i < MAX_CONFIG_INTERFACES; i++) {
 527                         f = config->interface[i];
 528                         if (!f)
 529                                 continue;
 530                         debug("%s: interface %d = %s/%p\n",
 531                               __func__, i, f->name, f);
 532                 }
 533         }
 534
 535         /*
 536          * If one function of config is not super speed capable,
 537          * force the gadget to be high speed so controller driver
 538          * can init HW to be USB 2.0
 539          */
 540         if (gadget_is_superspeed(cdev->gadget)) {
 541                 list_for_each_entry(f, &config->functions, list) {
 542                         if (!f->ss_descriptors)
 543                                 cdev->gadget->max_speed =
 544                                         USB_SPEED_HIGH;
 545                 }
 546         }
 547
 548         usb_ep_autoconfig_reset(cdev->gadget);
 549
 550         os_desc_config = config;
 551         cdev->os_desc_config = os_desc_config;
 552
 553 done:
 554         if (status)
 555                 debug("added config '%s'/%u --> %d\n", config->label,
 556                                 config->bConfigurationValue, status);
 557         return status;
 558 }
 559
 560 /*
 561  * We support strings in multiple languages ... string descriptor zero
 562  * says which languages are supported.  The typical case will be that
 563  * only one language (probably English) is used, with I18N handled on
 564  * the host side.
 565  */
 566
 567 static void collect_langs(struct usb_gadget_strings **sp, void *buf)
 568 {
 569         const struct usb_gadget_strings *s;
 570         u16                             language;
 571         __le16_packed                   *tmp;
 572         __le16_packed                   *end = (buf + 252);
 573
 574         while (*sp) {
 575                 s = *sp;
 576                 language = cpu_to_le16(s->language);
 577                 for (tmp = buf; tmp->val && tmp < end; tmp++) {
 578                         if (tmp->val == language)
 579                                 goto repeat;
 580                 }
 581                 tmp->val = language;
 582 repeat:
 583                 sp++;
 584         }
 585 }
 586
 587 static int lookup_string(
 588         struct usb_gadget_strings       **sp,
 589         void                            *buf,
 590         u16                             language,
 591         int                             id
 592 )
 593 {
 594         int                             value;
 595         struct usb_gadget_strings       *s;
 596
 597         while (*sp) {
 598                 s = *sp++;
 599                 if (s->language != language)
 600                         continue;
 601                 value = usb_gadget_get_string(s, id, buf);
 602                 if (value > 0)
 603                         return value;
 604         }
 605         return -EINVAL;
 606 }
 607
 608 static int get_string(struct usb_composite_dev *cdev,
 609                 void *buf, u16 language, int id)
 610 {
 611         struct usb_string_descriptor    *s = buf;
 612         struct usb_gadget_strings       **sp;
 613         int                             len;
 614         struct usb_configuration        *c;
 615         struct usb_function             *f;
 616
 617         /*
 618          * Yes, not only is USB's I18N support probably more than most
 619          * folk will ever care about ... also, it's all supported here.
 620          * (Except for UTF8 support for Unicode's "Astral Planes".)
 621          */
 622
 623         /* 0 == report all available language codes */
 624         if (id == 0) {
 625                 memset(s, 0, 256);
 626                 s->bDescriptorType = USB_DT_STRING;
 627
 628                 sp = composite->strings;
 629                 if (sp)
 630                         collect_langs(sp, s->wData);
 631
 632                 list_for_each_entry(c, &cdev->configs, list) {
 633                         sp = c->strings;
 634                         if (sp)
 635                                 collect_langs(sp, s->wData);
 636
 637                         list_for_each_entry(f, &c->functions, list) {
 638                                 sp = f->strings;
 639                                 if (sp)
 640                                         collect_langs(sp, s->wData);
 641                         }
 642                 }
 643
 644                 for (len = 0; len <= 126 && s->wData[len]; len++)
 645                         continue;
 646                 if (!len)
 647                         return -EINVAL;
 648
 649                 s->bLength = 2 * (len + 1);
 650                 return s->bLength;
 651         }
 652
 653         if (cdev->use_os_string && language == 0 && id == OS_STRING_IDX) {
 654                 struct usb_os_string *b = buf;
 655                 b->bLength = sizeof(*b);
 656                 b->bDescriptorType = USB_DT_STRING;
 657                 memcpy(&b->qwSignature, cdev->qw_sign, sizeof(b->qwSignature));
 658                 b->bMS_VendorCode = cdev->b_vendor_code;
 659                 b->bPad = 0;
 660                 return sizeof(*b);
 661         }
 662
 663         /*
 664          * Otherwise, look up and return a specified string.  String IDs
 665          * are device-scoped, so we look up each string table we're told
 666          * about.  These lookups are infrequent; simpler-is-better here.
 667          */
 668         if (composite->strings) {
 669                 len = lookup_string(composite->strings, buf, language, id);
 670                 if (len > 0)
 671                         return len;
 672         }
 673         list_for_each_entry(c, &cdev->configs, list) {
 674                 if (c->strings) {
 675                         len = lookup_string(c->strings, buf, language, id);
 676                         if (len > 0)
 677                                 return len;
 678                 }
 679                 list_for_each_entry(f, &c->functions, list) {
 680                         if (!f->strings)
 681                                 continue;
 682                         len = lookup_string(f->strings, buf, language, id);
 683                         if (len > 0)
 684                                 return len;
 685                 }
 686         }
 687         return -EINVAL;
 688 }
 689
 690 /**
 691  * usb_string_id() - allocate an unused string ID
 692  * @cdev: the device whose string descriptor IDs are being allocated
 693  * Context: single threaded during gadget setup
 694  *
 695  * @usb_string_id() is called from bind() callbacks to allocate
 696  * string IDs.  Drivers for functions, configurations, or gadgets will
 697  * then store that ID in the appropriate descriptors and string table.
 698  *
 699  * All string identifier should be allocated using this,
 700  * @usb_string_ids_tab() or @usb_string_ids_n() routine, to ensure
 701  * that for example different functions don't wrongly assign different
 702  * meanings to the same identifier.
 703  */
 704 int usb_string_id(struct usb_composite_dev *cdev)
 705 {
 706         if (cdev->next_string_id < 254) {
 707                 /*
 708                  * string id 0 is reserved by USB spec for list of
 709                  * supported languages
 710                  * 255 reserved as well? -- mina86
 711                  */
 712                 cdev->next_string_id++;
 713                 return cdev->next_string_id;
 714         }
 715         return -ENODEV;
 716 }
 717
 718 /**
 719  * usb_string_ids() - allocate unused string IDs in batch
 720  * @cdev: the device whose string descriptor IDs are being allocated
 721  * @str: an array of usb_string objects to assign numbers to
 722  * Context: single threaded during gadget setup
 723  *
 724  * @usb_string_ids() is called from bind() callbacks to allocate
 725  * string IDs.  Drivers for functions, configurations, or gadgets will
 726  * then copy IDs from the string table to the appropriate descriptors
 727  * and string table for other languages.
 728  *
 729  * All string identifier should be allocated using this,
 730  * @usb_string_id() or @usb_string_ids_n() routine, to ensure that for
 731  * example different functions don't wrongly assign different meanings
 732  * to the same identifier.
 733  */
 734 int usb_string_ids_tab(struct usb_composite_dev *cdev, struct usb_string *str)
 735 {
 736         u8 next = cdev->next_string_id;
 737
 738         for (; str->s; ++str) {
 739                 if (next >= 254)
 740                         return -ENODEV;
 741                 str->id = ++next;
 742         }
 743
 744         cdev->next_string_id = next;
 745
 746         return 0;
 747 }
 748
 749 /**
 750  * usb_string_ids_n() - allocate unused string IDs in batch
 751  * @c: the device whose string descriptor IDs are being allocated
 752  * @n: number of string IDs to allocate
 753  * Context: single threaded during gadget setup
 754  *
 755  * Returns the first requested ID.  This ID and next @n-1 IDs are now
 756  * valid IDs.  At least provided that @n is non-zero because if it
 757  * is, returns last requested ID which is now very useful information.
 758  *
 759  * @usb_string_ids_n() is called from bind() callbacks to allocate
 760  * string IDs.  Drivers for functions, configurations, or gadgets will
 761  * then store that ID in the appropriate descriptors and string table.
 762  *
 763  * All string identifier should be allocated using this,
 764  * @usb_string_id() or @usb_string_ids_n() routine, to ensure that for
 765  * example different functions don't wrongly assign different meanings
 766  * to the same identifier.
 767  */
 768 int usb_string_ids_n(struct usb_composite_dev *c, unsigned n)
 769 {
 770         u8 next = c->next_string_id;
 771
 772         if (n > 254 || next + n > 254)
 773                 return -ENODEV;
 774
 775         c->next_string_id += n;
 776         return next + 1;
 777 }
 778
 779 static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
 780 {
 781         if (req->status || req->actual != req->length)
 782                 debug("%s: setup complete --> %d, %d/%d\n", __func__,
 783                                 req->status, req->actual, req->length);
 784 }
 785
 786 static int bos_desc(struct usb_composite_dev *cdev)
 787 {
 788         struct usb_ext_cap_descriptor   *usb_ext;
 789         struct usb_dcd_config_params    dcd_config_params;
 790         struct usb_bos_descriptor       *bos = cdev->req->buf;
 791
 792         bos->bLength = USB_DT_BOS_SIZE;
 793         bos->bDescriptorType = USB_DT_BOS;
 794
 795         bos->wTotalLength = cpu_to_le16(USB_DT_BOS_SIZE);
 796         bos->bNumDeviceCaps = 0;
 797
 798         /*
 799          * A SuperSpeed device shall include the USB2.0 extension descriptor
 800          * and shall support LPM when operating in USB2.0 HS mode.
 801          */
 802         usb_ext = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
 803         bos->bNumDeviceCaps++;
 804         le16_add_cpu_packed((__le16_packed *)&bos->wTotalLength,
 805                             USB_DT_USB_EXT_CAP_SIZE);
 806         usb_ext->bLength = USB_DT_USB_EXT_CAP_SIZE;
 807         usb_ext->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
 808         usb_ext->bDevCapabilityType = USB_CAP_TYPE_EXT;
 809         usb_ext->bmAttributes =
 810                 cpu_to_le32(USB_LPM_SUPPORT | USB_BESL_SUPPORT);
 811
 812         /*
 813          * The Superspeed USB Capability descriptor shall be implemented
 814          * by all SuperSpeed devices.
 815          */
 816         if (gadget_is_superspeed(cdev->gadget)) {
 817                 struct usb_ss_cap_descriptor *ss_cap;
 818
 819                 ss_cap = cdev->req->buf + le16_to_cpu(bos->wTotalLength);
 820                 bos->bNumDeviceCaps++;
 821                 le16_add_cpu_packed((__le16_packed *)&bos->wTotalLength,
 822                                     USB_DT_USB_SS_CAP_SIZE);
 823                 ss_cap->bLength = USB_DT_USB_SS_CAP_SIZE;
 824                 ss_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
 825                 ss_cap->bDevCapabilityType = USB_SS_CAP_TYPE;
 826                 ss_cap->bmAttributes = 0; /* LTM is not supported yet */
 827                 ss_cap->wSpeedSupported =
 828                         cpu_to_le16(USB_LOW_SPEED_OPERATION |
 829                                     USB_FULL_SPEED_OPERATION |
 830                                     USB_HIGH_SPEED_OPERATION |
 831                                     USB_5GBPS_OPERATION);
 832                 ss_cap->bFunctionalitySupport = USB_LOW_SPEED_OPERATION;
 833
 834                 /* Get Controller configuration */
 835                 if (cdev->gadget->ops->get_config_params) {
 836                         cdev->gadget->ops->get_config_params(
 837                                 &dcd_config_params);
 838                 } else {
 839                         dcd_config_params.bU1devExitLat =
 840                                 USB_DEFAULT_U1_DEV_EXIT_LAT;
 841                         dcd_config_params.bU2DevExitLat =
 842                                 cpu_to_le16(USB_DEFAULT_U2_DEV_EXIT_LAT);
 843                 }
 844                 ss_cap->bU1devExitLat = dcd_config_params.bU1devExitLat;
 845                 ss_cap->bU2DevExitLat = dcd_config_params.bU2DevExitLat;
 846         }
 847         return le16_to_cpu(bos->wTotalLength);
 848 }
 849
 850 static int count_ext_compat(struct usb_configuration *c)
 851 {
 852         int i, res;
 853
 854         res = 0;
 855         for (i = 0; i < c->next_interface_id; ++i) {
 856                 struct usb_function *f;
 857                 int j;
 858
 859                 f = c->interface[i];
 860                 for (j = 0; j < f->os_desc_n; ++j) {
 861                         struct usb_os_desc *d;
 862
 863                         if (i != f->os_desc_table[j].if_id)
 864                                 continue;
 865                         d = f->os_desc_table[j].os_desc;
 866                         if (d && d->ext_compat_id)
 867                                 ++res;
 868                 }
 869         }
 870         BUG_ON(res > 255);
 871         return res;
 872 }
 873
 874 static void fill_ext_compat(struct usb_configuration *c, u8 *buf)
 875 {
 876         int i, count;
 877
 878         count = 16;
 879         for (i = 0; i < c->next_interface_id; ++i) {
 880                 struct usb_function *f;
 881                 int j;
 882
 883                 f = c->interface[i];
 884                 for (j = 0; j < f->os_desc_n; ++j) {
 885                         struct usb_os_desc *d;
 886
 887                         if (i != f->os_desc_table[j].if_id)
 888                                 continue;
 889                         d = f->os_desc_table[j].os_desc;
 890                         if (d && d->ext_compat_id) {
 891                                 *buf++ = i;
 892                                 *buf++ = 0x01;
 893                                 memcpy(buf, d->ext_compat_id, 16);
 894                                 buf += 22;
 895                         } else {
 896                                 ++buf;
 897                                 *buf = 0x01;
 898                                 buf += 23;
 899                         }
 900                         count += 24;
 901                         if (count >= 4096)
 902                                 return;
 903                 }
 904         }
 905 }
 906
 907 static int count_ext_prop(struct usb_configuration *c, int interface)
 908 {
 909         struct usb_function *f;
 910         int j;
 911
 912         f = c->interface[interface];
 913         for (j = 0; j < f->os_desc_n; ++j) {
 914                 struct usb_os_desc *d;
 915
 916                 if (interface != f->os_desc_table[j].if_id)
 917                         continue;
 918                 d = f->os_desc_table[j].os_desc;
 919                 if (d && d->ext_compat_id)
 920                         return d->ext_prop_count;
 921         }
 922         return 0;
 923 }
 924
 925 static int len_ext_prop(struct usb_configuration *c, int interface)
 926 {
 927         struct usb_function *f;
 928         struct usb_os_desc *d;
 929         int j, res;
 930
 931         res = 10; /* header length */
 932         f = c->interface[interface];
 933         for (j = 0; j < f->os_desc_n; ++j) {
 934                 if (interface != f->os_desc_table[j].if_id)
 935                         continue;
 936                 d = f->os_desc_table[j].os_desc;
 937                 if (d)
 938                         return min(res + d->ext_prop_len, 4096);
 939         }
 940         return res;
 941 }
 942
 943 static int fill_ext_prop(struct usb_configuration *c, int interface, u8 *buf)
 944 {
 945         struct usb_function *f;
 946         struct usb_os_desc *d;
 947         struct usb_os_desc_ext_prop *ext_prop;
 948         int j, count, n, ret;
 949         u8 *start = buf;
 950
 951         f = c->interface[interface];
 952         for (j = 0; j < f->os_desc_n; ++j) {
 953                 if (interface != f->os_desc_table[j].if_id)
 954                         continue;
 955                 d = f->os_desc_table[j].os_desc;
 956                 if (d)
 957                         list_for_each_entry(ext_prop, &d->ext_prop, entry) {
 958                                 /* 4kB minus header length */
 959                                 n = buf - start;
 960                                 if (n >= 4086)
 961                                         return 0;
 962
 963                                 count = ext_prop->data_len +
 964                                         ext_prop->name_len + 14;
 965                                 if (count > 4086 - n)
 966                                         return -EINVAL;
 967                                 usb_ext_prop_put_size(buf, count);
 968                                 usb_ext_prop_put_type(buf, ext_prop->type);
 969                                 ret = usb_ext_prop_put_name(buf, ext_prop->name,
 970                                                             ext_prop->name_len);
 971                                 if (ret < 0)
 972                                         return ret;
 973                                 switch (ext_prop->type) {
 974                                 case USB_EXT_PROP_UNICODE:
 975                                 case USB_EXT_PROP_UNICODE_ENV:
 976                                 case USB_EXT_PROP_UNICODE_LINK:
 977                                         usb_ext_prop_put_unicode(buf, ret,
 978                                                          ext_prop->data,
 979                                                          ext_prop->data_len);
 980                                         break;
 981                                 case USB_EXT_PROP_BINARY:
 982                                         usb_ext_prop_put_binary(buf, ret,
 983                                                         ext_prop->data,
 984                                                         ext_prop->data_len);
 985                                         break;
 986                                 case USB_EXT_PROP_LE32:
 987                                         /* not implemented */
 988                                 case USB_EXT_PROP_BE32:
 989                                         /* not implemented */
 990                                 default:
 991                                         return -EINVAL;
 992                                 }
 993                                 buf += count;
 994                         }
 995         }
 996
 997         return 0;
 998 }
 999
1000 /*
1001  * The setup() callback implements all the ep0 functionality that's
1002  * not handled lower down, in hardware or the hardware driver(like
1003  * device and endpoint feature flags, and their status).  It's all
1004  * housekeeping for the gadget function we're implementing.  Most of
1005  * the work is in config and function specific setup.
1006  */
1007 static int
1008 composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1009 {
1010         u16                             w_length = le16_to_cpu(ctrl->wLength);
1011         u16                             w_index = le16_to_cpu(ctrl->wIndex);
1012         u16                             w_value = le16_to_cpu(ctrl->wValue);
1013         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
1014         u8                              intf = w_index & 0xFF;
1015         int                             value = -EOPNOTSUPP;
1016         struct usb_request              *req = cdev->req;
1017         struct usb_function             *f = NULL;
1018         int                             standard;
1019         u8                              endp;
1020         struct usb_configuration        *c;
1021
1022         /*
1023          * partial re-init of the response message; the function or the
1024          * gadget might need to intercept e.g. a control-OUT completion
1025          * when we delegate to it.
1026          */
1027         req->zero = 0;
1028         req->complete = composite_setup_complete;
1029         req->length = USB_BUFSIZ;
1030         gadget->ep0->driver_data = cdev;
1031         standard = (ctrl->bRequestType & USB_TYPE_MASK)
1032                                                 == USB_TYPE_STANDARD;
1033         if (!standard)
1034                 goto unknown;
1035
1036         switch (ctrl->bRequest) {
1037
1038         /* we handle all standard USB descriptors */
1039         case USB_REQ_GET_DESCRIPTOR:
1040                 if (ctrl->bRequestType != USB_DIR_IN)
1041                         goto unknown;
1042                 switch (w_value >> 8) {
1043
1044                 case USB_DT_DEVICE:
1045                         cdev->desc.bNumConfigurations =
1046                                 count_configs(cdev, USB_DT_DEVICE);
1047
1048                         cdev->desc.bMaxPacketSize0 =
1049                                 cdev->gadget->ep0->maxpacket;
1050                         if (gadget->speed >= USB_SPEED_SUPER) {
1051                                 cdev->desc.bcdUSB = cpu_to_le16(0x0310);
1052                                 cdev->desc.bMaxPacketSize0 = 9;
1053                         } else {
1054                                 cdev->desc.bcdUSB = cpu_to_le16(0x0200);
1055                         }
1056                         value = min(w_length, (u16) sizeof cdev->desc);
1057                         memcpy(req->buf, &cdev->desc, value);
1058                         break;
1059                 case USB_DT_DEVICE_QUALIFIER:
1060                         if (!gadget_is_dualspeed(gadget) ||
1061                             gadget->speed >= USB_SPEED_SUPER)
1062                                 break;
1063                         device_qual(cdev);
1064                         value = min_t(int, w_length,
1065                                       sizeof(struct usb_qualifier_descriptor));
1066                         break;
1067                 case USB_DT_OTHER_SPEED_CONFIG:
1068                         if (!gadget_is_dualspeed(gadget) ||
1069                             gadget->speed >= USB_SPEED_SUPER)
1070                                 break;
1071                         fallthrough;
1072                 case USB_DT_CONFIG:
1073                         value = config_desc(cdev, w_value);
1074                         if (value >= 0)
1075                                 value = min(w_length, (u16) value);
1076                         break;
1077                 case USB_DT_STRING:
1078                         value = get_string(cdev, req->buf,
1079                                         w_index, w_value & 0xff);
1080                         if (value >= 0)
1081                                 value = min(w_length, (u16) value);
1082                         break;
1083                 case USB_DT_BOS:
1084                         /*
1085                          * Super speed connection should support BOS, and
1086                          * USB compliance test (USB 2.0 Command Verifier)
1087                          * also issues this request, return for now for
1088                          * USB 2.0 connection.
1089                          */
1090                         if (gadget->speed >= USB_SPEED_SUPER) {
1091                                 value = bos_desc(cdev);
1092                                 value = min(w_length, (u16)value);
1093                         }
1094                         break;
1095                 default:
1096                         goto unknown;
1097                 }
1098                 break;
1099
1100         /* any number of configs can work */
1101         case USB_REQ_SET_CONFIGURATION:
1102                 if (ctrl->bRequestType != 0)
1103                         goto unknown;
1104                 if (gadget_is_otg(gadget)) {
1105                         if (gadget->a_hnp_support)
1106                                 debug("HNP available\n");
1107                         else if (gadget->a_alt_hnp_support)
1108                                 debug("HNP on another port\n");
1109                         else
1110                                 debug("HNP inactive\n");
1111                 }
1112
1113                 value = set_config(cdev, ctrl, w_value);
1114                 break;
1115         case USB_REQ_GET_CONFIGURATION:
1116                 if (ctrl->bRequestType != USB_DIR_IN)
1117                         goto unknown;
1118                 if (cdev->config)
1119                         *(u8 *)req->buf = cdev->config->bConfigurationValue;
1120                 else
1121                         *(u8 *)req->buf = 0;
1122                 value = min(w_length, (u16) 1);
1123                 break;
1124
1125         /*
1126          * function drivers must handle get/set altsetting; if there's
1127          * no get() method, we know only altsetting zero works.
1128          */
1129         case USB_REQ_SET_INTERFACE:
1130                 if (ctrl->bRequestType != USB_RECIP_INTERFACE)
1131                         goto unknown;
1132                 if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
1133                         break;
1134                 f = cdev->config->interface[intf];
1135                 if (!f)
1136                         break;
1137                 if (w_value && !f->set_alt)
1138                         break;
1139                 value = f->set_alt(f, w_index, w_value);
1140                 break;
1141         case USB_REQ_GET_INTERFACE:
1142                 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
1143                         goto unknown;
1144                 if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
1145                         break;
1146                 f = cdev->config->interface[intf];
1147                 if (!f)
1148                         break;
1149                 /* lots of interfaces only need altsetting zero... */
1150                 value = f->get_alt ? f->get_alt(f, w_index) : 0;
1151                 if (value < 0)
1152                         break;
1153                 *((u8 *)req->buf) = value;
1154                 value = min(w_length, (u16) 1);
1155                 break;
1156         default:
1157 unknown:
1158                 /*
1159                  * OS descriptors handling
1160                  */
1161                 if (CONFIG_IS_ENABLED(USB_GADGET_OS_DESCRIPTORS) && cdev->use_os_string &&
1162                     cdev->os_desc_config && (ctrl->bRequestType & USB_TYPE_VENDOR) &&
1163                     ctrl->bRequest == cdev->b_vendor_code) {
1164                         struct usb_configuration        *os_desc_cfg;
1165                         u8                              *buf;
1166                         int                             interface;
1167                         int                             count = 0;
1168
1169                         buf = req->buf;
1170                         os_desc_cfg = cdev->os_desc_config;
1171                         memset(buf, 0, w_length);
1172                         buf[5] = 0x01;
1173                         switch (ctrl->bRequestType & USB_RECIP_MASK) {
1174                         case USB_RECIP_DEVICE:
1175                                 if (w_index != 0x4 || (w_value >> 8))
1176                                         break;
1177                                 buf[6] = w_index;
1178                                 if (w_length == 0x10) {
1179                                         /* Number of ext compat interfaces */
1180                                         count = count_ext_compat(os_desc_cfg);
1181                                         buf[8] = count;
1182                                         count *= 24; /* 24 B/ext compat desc */
1183                                         count += 16; /* header */
1184                                         put_unaligned_le32(count, buf);
1185                                         value = w_length;
1186                                 } else {
1187                                         /* "extended compatibility ID"s */
1188                                         count = count_ext_compat(os_desc_cfg);
1189                                         buf[8] = count;
1190                                         count *= 24; /* 24 B/ext compat desc */
1191                                         count += 16; /* header */
1192                                         put_unaligned_le32(count, buf);
1193                                         buf += 16;
1194                                         fill_ext_compat(os_desc_cfg, buf);
1195                                         value = w_length;
1196                                 }
1197                                 break;
1198                         case USB_RECIP_INTERFACE:
1199                                 if (w_index != 0x5 || (w_value >> 8))
1200                                         break;
1201                                 interface = w_value & 0xFF;
1202                                 buf[6] = w_index;
1203                                 if (w_length == 0x0A) {
1204                                         count = count_ext_prop(os_desc_cfg,
1205                                                 interface);
1206                                         put_unaligned_le16(count, buf + 8);
1207                                         count = len_ext_prop(os_desc_cfg,
1208                                                 interface);
1209                                         put_unaligned_le32(count, buf);
1210
1211                                         value = w_length;
1212                                 } else {
1213                                         count = count_ext_prop(os_desc_cfg,
1214                                                 interface);
1215                                         put_unaligned_le16(count, buf + 8);
1216                                         count = len_ext_prop(os_desc_cfg,
1217                                                 interface);
1218                                         put_unaligned_le32(count, buf);
1219                                         buf += 10;
1220                                         value = fill_ext_prop(os_desc_cfg,
1221                                                               interface, buf);
1222                                         if (value < 0)
1223                                                 return value;
1224
1225                                         value = w_length;
1226                                 }
1227                                 break;
1228                         }
1229
1230                         if (value >= 0) {
1231                                 req->length = value;
1232                                 req->zero = value < w_length;
1233                                 value = usb_ep_queue(gadget->ep0, req, GFP_KERNEL);
1234                                 if (value < 0) {
1235                                         debug("ep_queue --> %d\n", value);
1236                                         req->status = 0;
1237                                         composite_setup_complete(gadget->ep0, req);
1238                                 }
1239                         }
1240                         return value;
1241                 }
1242
1243                 debug("non-core control req%02x.%02x v%04x i%04x l%d\n",
1244                         ctrl->bRequestType, ctrl->bRequest,
1245                         w_value, w_index, w_length);
1246
1247                 if (!cdev->config)
1248                         goto done;
1249
1250                 /*
1251                  * functions always handle their interfaces and endpoints...
1252                  * punt other recipients (other, WUSB, ...) to the current
1253                  * configuration code.
1254                  */
1255                 switch (ctrl->bRequestType & USB_RECIP_MASK) {
1256                 case USB_RECIP_INTERFACE:
1257                         f = cdev->config->interface[intf];
1258                         break;
1259
1260                 case USB_RECIP_ENDPOINT:
1261                         endp = ((w_index & 0x80) >> 3) | (w_index & 0x0f);
1262                         list_for_each_entry(f, &cdev->config->functions, list) {
1263                                 if (test_bit(endp, f->endpoints))
1264                                         break;
1265                         }
1266                         if (&f->list == &cdev->config->functions)
1267                                 f = NULL;
1268                         break;
1269                 /*
1270                  * dfu-util (version 0.5) sets bmRequestType.Receipent = Device
1271                  * for non-standard request (w_value = 0x21,
1272                  * bRequest = GET_DESCRIPTOR in this case).
1273                  * When only one interface is registered (as it is done now),
1274                  * then this request shall be handled as it was requested for
1275                  * interface.
1276                  *
1277                  * In the below code it is checked if only one interface is
1278                  * present and proper function for it is extracted. Due to that
1279                  * function's setup (f->setup) is called to handle this
1280                  * special non-standard request.
1281                  */
1282                 case USB_RECIP_DEVICE:
1283                         debug("cdev->config->next_interface_id: %d intf: %d\n",
1284                                cdev->config->next_interface_id, intf);
1285                         if (cdev->config->next_interface_id == 1)
1286                                 f = cdev->config->interface[intf];
1287                         break;
1288                 }
1289
1290                 if (f && f->setup)
1291                         value = f->setup(f, ctrl);
1292                 else {
1293                         c = cdev->config;
1294                         if (c->setup)
1295                                 value = c->setup(c, ctrl);
1296                 }
1297
1298                 goto done;
1299         }
1300
1301         /* respond with data transfer before status phase? */
1302         if (value >= 0) {
1303                 req->length = value;
1304                 req->zero = value < w_length;
1305                 value = usb_ep_queue(gadget->ep0, req, GFP_KERNEL);
1306                 if (value < 0) {
1307                         debug("ep_queue --> %d\n", value);
1308                         req->status = 0;
1309                         composite_setup_complete(gadget->ep0, req);
1310                 }
1311         }
1312
1313 done:
1314         /* device either stalls (value < 0) or reports success */
1315         return value;
1316 }
1317
1318 static void composite_disconnect(struct usb_gadget *gadget)
1319 {
1320         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
1321
1322         if (cdev->config)
1323                 reset_config(cdev);
1324         if (composite->disconnect)
1325                 composite->disconnect(cdev);
1326 }
1327
1328 static void composite_unbind(struct usb_gadget *gadget)
1329 {
1330         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
1331         struct usb_configuration        *c;
1332         struct usb_function             *f;
1333
1334         /*
1335          * composite_disconnect() must already have been called
1336          * by the underlying peripheral controller driver!
1337          * so there's no i/o concurrency that could affect the
1338          * state protected by cdev->lock.
1339          */
1340 #ifdef __UBOOT__
1341         assert_noisy(!cdev->config);
1342 #else
1343         BUG_ON(cdev->config);
1344 #endif
1345
1346         while (!list_empty(&cdev->configs)) {
1347                 c = list_first_entry(&cdev->configs,
1348                                 struct usb_configuration, list);
1349                 while (!list_empty(&c->functions)) {
1350                         f = list_first_entry(&c->functions,
1351                                         struct usb_function, list);
1352                         list_del(&f->list);
1353                         if (f->unbind) {
1354                                 debug("unbind function '%s'/%p\n",
1355                                                 f->name, f);
1356                                 f->unbind(c, f);
1357                         }
1358                 }
1359                 list_del(&c->list);
1360                 if (c->unbind) {
1361                         debug("unbind config '%s'/%p\n", c->label, c);
1362                         c->unbind(c);
1363                 }
1364                 free(c);
1365         }
1366         if (composite->unbind)
1367                 composite->unbind(cdev);
1368
1369         if (cdev->req) {
1370                 kfree(cdev->req->buf);
1371                 usb_ep_free_request(gadget->ep0, cdev->req);
1372         }
1373         kfree(cdev);
1374         set_gadget_data(gadget, NULL);
1375
1376         composite = NULL;
1377 }
1378
1379 static int composite_bind(struct usb_gadget *gadget)
1380 {
1381         int                             status = -ENOMEM;
1382         struct usb_composite_dev        *cdev;
1383
1384         cdev = calloc(sizeof *cdev, 1);
1385         if (!cdev)
1386                 return status;
1387
1388         cdev->gadget = gadget;
1389         set_gadget_data(gadget, cdev);
1390         INIT_LIST_HEAD(&cdev->configs);
1391
1392         /* preallocate control response and buffer */
1393         cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
1394         if (!cdev->req)
1395                 goto fail;
1396         cdev->req->buf = memalign(CONFIG_SYS_CACHELINE_SIZE, USB_BUFSIZ);
1397         if (!cdev->req->buf)
1398                 goto fail;
1399         cdev->req->complete = composite_setup_complete;
1400         gadget->ep0->driver_data = cdev;
1401
1402         cdev->bufsiz = USB_BUFSIZ;
1403         cdev->driver = composite;
1404
1405         usb_gadget_set_selfpowered(gadget);
1406         usb_ep_autoconfig_reset(cdev->gadget);
1407
1408         status = composite->bind(cdev);
1409         if (status < 0)
1410                 goto fail;
1411
1412         memcpy(&cdev->desc, composite->dev,
1413                sizeof(struct usb_device_descriptor));
1414         cdev->desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1415
1416         if (cdev->use_os_string) {
1417                 /* TODO: Do we want to pass this via platform? */
1418                 cdev->b_vendor_code = 0x40;
1419
1420                 /* Microsoft OS String Descriptor */
1421                 utf8_to_utf16le(qw_sign_buf, (__le16 *)cdev->qw_sign,
1422                                 OS_STRING_QW_SIGN_LEN / 2);
1423         }
1424
1425         debug("%s: ready\n", composite->name);
1426         return 0;
1427
1428 fail:
1429         composite_unbind(gadget);
1430         return status;
1431 }
1432
1433 static void
1434 composite_suspend(struct usb_gadget *gadget)
1435 {
1436         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
1437         struct usb_function             *f;
1438
1439         debug("%s: suspend\n", __func__);
1440         if (cdev->config) {
1441                 list_for_each_entry(f, &cdev->config->functions, list) {
1442                         if (f->suspend)
1443                                 f->suspend(f);
1444                 }
1445         }
1446         if (composite->suspend)
1447                 composite->suspend(cdev);
1448
1449         cdev->suspended = 1;
1450 }
1451
1452 static void
1453 composite_resume(struct usb_gadget *gadget)
1454 {
1455         struct usb_composite_dev        *cdev = get_gadget_data(gadget);
1456         struct usb_function             *f;
1457
1458         debug("%s: resume\n", __func__);
1459         if (composite->resume)
1460                 composite->resume(cdev);
1461         if (cdev->config) {
1462                 list_for_each_entry(f, &cdev->config->functions, list) {
1463                         if (f->resume)
1464                                 f->resume(f);
1465                 }
1466         }
1467
1468         cdev->suspended = 0;
1469 }
1470
1471 static struct usb_gadget_driver composite_driver = {
1472         .speed          = USB_SPEED_SUPER,
1473
1474         .bind           = composite_bind,
1475         .unbind         = composite_unbind,
1476
1477         .setup          = composite_setup,
1478         .reset          = composite_disconnect,
1479         .disconnect     = composite_disconnect,
1480
1481         .suspend        = composite_suspend,
1482         .resume         = composite_resume,
1483 };
1484
1485 /**
1486  * usb_composite_register() - register a composite driver
1487  * @driver: the driver to register
1488  * Context: single threaded during gadget setup
1489  *
1490  * This function is used to register drivers using the composite driver
1491  * framework.  The return value is zero, or a negative errno value.
1492  * Those values normally come from the driver's @bind method, which does
1493  * all the work of setting up the driver to match the hardware.
1494  *
1495  * On successful return, the gadget is ready to respond to requests from
1496  * the host, unless one of its components invokes usb_gadget_disconnect()
1497  * while it was binding.  That would usually be done in order to wait for
1498  * some userspace participation.
1499  */
1500 int usb_composite_register(struct usb_composite_driver *driver)
1501 {
1502         int res;
1503
1504         if (!driver || !driver->dev || !driver->bind || composite)
1505                 return -EINVAL;
1506
1507         if (!driver->name)
1508                 driver->name = "composite";
1509         composite = driver;
1510
1511         res = usb_gadget_register_driver(&composite_driver);
1512         if (res != 0)
1513                 composite = NULL;
1514
1515         return res;
1516 }
1517
1518 /**
1519  * usb_composite_unregister() - unregister a composite driver
1520  * @driver: the driver to unregister
1521  *
1522  * This function is used to unregister drivers using the composite
1523  * driver framework.
1524  */
1525 void usb_composite_unregister(struct usb_composite_driver *driver)
1526 {
1527         if (composite != driver)
1528                 return;
1529         usb_gadget_unregister_driver(&composite_driver);
1530         composite = NULL;
1531 }