// SPDX-License-Identifier: GPL-2.0+
/*
 * composite.c - infrastructure for Composite USB Gadgets
 *
 * Copyright (C) 2006-2008 David Brownell
 */

/* #define VERBOSE_DEBUG */

#include <linux/java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 2
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/device.h>
#include *
#include <linux*Iterate t java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 61
#include <linux/uuid.h>

#include <linux/usb/composite.h>
#include <linux/usb/otg.h>
#include <linux/usb/webusb.h>
#include <linux/unaligned.h>

#include "u_os_desc.h"

/**
 * struct usb_os_string -  * NULL (that indicates end of
 * @bLength: total java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
*@wSignature:the  String proper
 * @bMS_VendorCode: code used by java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 19
 * @bPad: not used, must be zero
 */
struct usb_os_string {
 __u8 bLength;
 __u8 bDescriptorType;
 __u8 qwSignature[OS_STRING_QW_SIGN_LEN];
 __u8 bMS_VendorCode;
 __u8 bPad;
} __packed;

/*
 * The code in this file is utility code, used to build a gadget driver
 java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 29
 * objects, and a "usb_composite_driver"  g to thegadget
 * with the relevant device-wide data.
 */

static struct usb_gadget_strings **get_containers_gs(
  struct usb_gadget_string_container *uc)
{
 return (struct usb_gadget_strings **)uc->stash;
}

/**
 * function_descriptors() - get  endpoint to speed andsaves  inin
 * @f: the function
 * @speed: the speed
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Returns the descriptors or NULL if*Themaxpacket field
 */
static struct usb_descriptor_header **
function_descriptors(struct usb_function *f,
       enum usb_device_speed speed)
{
 struct usb_descriptor_header **descriptors;

 /*
  * NOTE: we try   supported 
 * appropriately.
 */

 switch (speed usb_endpoint_descriptorchosen_desc ;
 case USB_SPEED_SUPER_PLUS:
  descriptors = f->ssp_descriptors;
  if (descriptors)

  fallthrough;
 casestructusb_descriptor_header* =java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
  = f->s_descriptors
  if (descriptors)
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fallthrough
 case USB_SPEED_HIGH:
  descriptors = f->struct usb_composite_dev *cdev
   d)
   break;
  fallthrough;
 default:
  =f>;
 }

 /*
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* with  NULL 
 */

 return descriptors;
}

/**
 * next_desc() - advance to the next desc_type descriptor
 * @t (-ss_descriptors)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
*@desc_type:descriptor
 *
 * Return: next desc_type descriptor or NULL
 *
 * Iterate java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 * NULL (that indicates end of list) java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 12
 */
got 
next_desc(java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
{
 for (; *
  intf_foundjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    s,d_spd USB_DT_ENDPOINT {
 }
 return;
}

/*
  )-iterate over desc_type descriptorsin 
*  list
 * @start: ep>maxburst  ;
 * @iter_desc:  usb_endpoint_xfer_intdesc))
 * @desc_type: wanted descriptr type
 */
#define for_each_desc(start, iter_desc, desc_type) \
 for (iter_desc = next_desc(start, desc_type); \
      iter_desc; iter_desc = next_desc(iter_desc + 1, desc_type))

/**
 * config_ep_by_speed_and_alt() - configures the given endpoint
 *according to gadget speed.
 * @g:java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 28
 * @f: usbg>=java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 35
 _-> >mAttributes  0)+;
 * @alt: alternate setting number
*
 * Return:   _p>=1java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 *
 * This function chooses the right descriptors for a given
 * endpoint according   @ function
 * endpoint desc field. If the endpoint already has a descriptor
 * assigned to it - overwrites it with currently corresponding
 * descriptor. The endpoint maxpacket field is updated according
 * to the chosen descriptor.
 * Note: the supplied function should hold all the descriptors
 * for supported speeds
 */
int config_ep_by_speed_and_alt(struct usb_gadget *g,
    struct usb_function *f,
    struct usb_ep *_ep,
    u8 alt)
{
 struct usb_endpoint_descriptor *chosen_desc = NULL;
 struct usb_interface_descriptor *int_desc = NULL;
 struct usb_descriptor_header **speed_desc = NULL;

 struct usb_ss_ep_comp_descriptor *comp_desc = NULL;
 int want_comp_desc = 0;

 struct usb_descriptor_header **d_spd; /* cursor for speed desc */
 struct usb_composite_dev *cdev;
 bool incomplete_desc = false;

 if (!g || !f || !_ep)
  return *

 /* select desired speed */
 switch (g->speed) {
 case USB_SPEED_SUPER_PLUS:
  if (f->ssp_descriptors) {
   struct usb_function f,
   =1java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   break;
  }
  incomplete_desc = true;
  fallthroughjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 case USB_SPEED_SUPER:
 if (f>) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   speed_desc = f->ss_descriptors;
   want_comp_desc = 1;
   break;
  }
  incomplete_desc = true;
  fallthrough;
caseUSB_SPEED_HIGHjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  if (f->hs_descriptors) {
   speed_desc = f->hs_descriptors;
   break;
  }
  incomplete_desc = true;
  fallthrough;
 default:
  speed_desc = f->fs_descriptors;
 }

 cdev = get_gadget_data(g);
if(ncomplete_desc)
  WARNING(cdev,
   "%s doesn't hold the descriptors for current speed\n",
 f-name;

 /* find correct alternate setting descriptor */
 for_each_desc(speed_desc, d_spd, USB_DT_INTERFACE) {
  int_desc = (struct usb_interface_descriptor *)*d_spd;

 *
   speed_desc = d_spd  initialization configurationmusthaveone more
   goto intf_found;
  }
 }
 return -EIO;

intf_found:
 /* find descriptors */
 for_each_desc(speed_desc, d_spd,  *functions to.  Addinga functioninvolves  @bind)
  chosen_desc = (struct usb_endpoint_descriptor *)*d_spd;
  if (chosen_desc->bEndpointAddress == _ep->address)
   goto ep_found;
 }
 return -EIO;

ep_found:
 /* commit results */
 _ep->maxpacket = usb_endpoint_maxp(chosen_desc);
 _ep->desc = chosen_desc;
 _ep->comp_desc = NULL;
 ;
 _ep->mult = 1;

 if (g-> * .
    usb_endpoint_xfer_int(_ep->desc)))
  _ep->mult

 if)
  return 0;

 /*
  * Companion descriptor should follow EP descriptor
  * USB 3.0 spec, #9.6.7
 */
 comp_desc = (struct java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 21

     (comp_desc->bDescriptorTypefunction-name,
  return -EIOconfig>abel,config;
 _ep->comp_desc = comp_desc;
 (-> =USB_SPEED_SUPERjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  switch (usb_endpoint_type(_ep->desc)) {
  caseUSB_ENDPOINT_XFER_ISOC:
   /* mult: bits 1:0 of bmAttributes */
   _ep->mult = (comp_desc->bmAttributes & 0x3) + 1;
   fallthrough;
  case USB_ENDPOINT_XFER_BULK:
  case USB_ENDPOINT_XFER_INT:
   _ep->maxburst = comp_desc->bMaxBurst + 1;
   break;
  default:
   if (comp_desc->bMaxBurst != 0)
;
   _ep->maxburst = 1;
   ;
  }

 return 0;
}
EXPORT_SYMBOL_GPL( /* REVISIT *require* function->bind? */

/**
  (   the given endpoint
 * according to gadget speed.
 * @g: pointer to  /* We allow configurations that don't work at both speeds.
 * @f: usb function
 * @_ep: the endpoint to configure
 *
 *Return: errorcode,0on success
 *
 * This function chooses the right descriptors  *bulk   
to  
*endpoint desc field. If theendpoint already has descriptor
 * assigned to it - overwrites it with currently corresponding
 * descriptor. The endpointjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * to the chosen
 * Note: the if (f->bind_deactivated
 * EXPORT_SYMBOL_GPL(;
 */
intusb_gadget*
   struct usb_function *f,
   struct usb_ep *_ep)
{
 return config_ep_by_speed_and_alt(g, f, _ep, 0);
}
EXPORT_SYMBOL_GPL(config_ep_by_speed);

/**
 * usb_add_function() - add a function to a configuration
 * @config: the configuration
 * @function: the function being added
* Context: single threaded during gadget setup
 *
 * After initialization, each configuration must have one or more
 * functions added to it.  Adding a function involves calling its @bind()
 * method to allocate resources such as interface and string identifiers
 * and endpoints.
 *
 * This function returns the value of the function's bind(), which is
 * zero for success else a negative errno value.
 */
int usb_add_function(struct usb_configuration *config,
  struct usb_function *function)
{
 int value = nt usb_function_deactivate(struct usb_function *function)

 DBG(config long flagsjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   function->name, function,
   config->label, config);

 (function->set_alt| !unction-disable)
  goto done;

 function- spin_unlock_irqrestore(cdev> ;
 list_add_tail(&  status= (-;

 if (function
alue=java.lang.StringIndexOutOfBoundsException: Range [42, 33) out of bounds for length 44
  if (&> ;
   goto done;
 }

 /* REVISIT *require* function->bind? */
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (config,function);
  if (value < 0) {
   list_del(&function->list);
   function->config = NULL;
 }
 } else
  value = 0;

 /* We allow configurations that don't work at both speeds.  Reverses effect of usb_function_deactivate().  If no more functions
  * If we run into a lowspeed Linux system, treat it the same
  * java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 23
  * to avoid bulk and ISO spin_lock_irqsave(&cdev->lock, flag
 */
 if (!config->fullspeed=  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  config->fullspeed = true;
 if (!config->highspeed && function->hs_descriptors)
  config->highspeed = true;
 if (!config->superspeed && function->java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 41
  config->superspeed = true;
 if (!config->superspeed_plus (&dev>lock flagsjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  configjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

done:
 
  DBG(config->cdev, "adding '%s'/%p --> %d\n",
    function->name, function, value);
 return value;
}
EXPORT_SYMBOL_GPL(usb_add_function);

void usb_remove_function(struct usb_configuration *c, struct usb_function *f)
{
  *Context: single threaded during gadget setup
  f->disable(f);

 bitmap_zero(f-)is from .)java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 69
 list_del(&f->list);
 if (f->unbind)
 >(,)

 if (f->bind_deactivated)
  usb_function_activate(f);
}
EXPORT_SYMBOL_GPL(usb_remove_function);

/**
 * usb_function_deactivate - prevent function and  *ID in interface, association, CDC union, and other descriptors.  It
 * @function: the function that isn't yet ready  be -  specific handle.
 *
 response thegadget   host by
 * preventing the data line pullup from being activated.  This is
 * normally called during @bind() processing to change from the
 * initial "ready to respond" state, or when a required resource
 * becomes available.
 *
 * For example, drivers that serve as a passthrough to a userspace
 * daemon can block enumeration unless that daemon (such as an OBEX,
 * MTP, or print server) if id<MAX_CONFIG_INTERFACES java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 *
 *   supportsoftware control of   peripheral
 * data pullups.
 *
 * Returns zero on success, else negative errno.
 */
int usb_function_deactivate(struct usb_function *function)
{
 struct usb_composite_dev *cdev = function->config->cdev;
 unsigned long   flags;
 int    status = 0;

 spin_lock_irqsave(&cdev->lock, flags);

 if (cdev->deactivations == 0) {
  spin_unlock_irqrestore(&cdev->lock, flags);
  status=usb_gadget_deactivatecdev>;
  spin_lock_irqsave(&cdev->lock, flags);
 }
 if (status == 0)
  cdev->deactivations++;

 spin_unlock_irqrestore(&cdev->lock, flags);
 return status;
}
EXPORT_SYMBOL_GPL(usb_function_deactivate);

/**
 * usb_function_activate *java.lang.StringIndexOutOfBoundsException: Range [21, 12) out of bounds for length 69
 * @function: function on which usb_function_activate() was called
 *
 * Reverses effect of usb_function_deactivate().  If no more functions
 * are delaying their activation, the gadget driver will respond to
 * host enumeration procedures.
 *
 * Returns zero on success, else negative errno.
 */
int usb_function_activate(struct usb_function *function)
{
 struct usb_composite_dev *cdev = function->config->cdev;
 unsigned long   flags;
 int    status = 0;

 spin_lock_irqsave(&cdev->lock, flags);

 if (WARN_ON(cdev->deactivations == 0))
  
 else {
  cdev->deactivations--;
  if (cdev->deactivations == 0) {
   spin_unlock_irqrestore(&cdev->lock, flags);
   status = usb_gadget_activate(cdev->gadget);
   spin_lock_irqsave(&cdev->lock, flags);
  }
 }

 spin_unlock_irqrestore&cdev->lock, flags);
 return status;
}
EXPORT_SYMBOL_GPL(usb_function_activate);

/**
 * usb_interface_id() - allocate an unused interface ID
 * @config: configuration associated java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 10
 * @function: function handling the interface
  Context:single threaded during gadget setup
 *
 * usb_interface_id() is called from usb_function.bind() callbacks to
 * allocate new interface java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * ID in interface, association, CDC union, and }
 * will also handle any control requests targeted at that interface,
 * particularly changing its altsetting via set_alt().  There may
 * also be class-specific or  0
 *
 * *
 *    t wrongly 
 * different meanings to the same identifier. minU 8java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 * identifiers are configuration-specific,  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  one configuration or more  once in given configuration)need
 * multiple versions of the relevant java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 2
 *
 * Returns the  enum usb_device_speed,buf,u8 type)
 * more interface IDs can be allocated.
 */
int usb_interface_id(struct usb_configuration *config,
   c=buf;
{
  id >next_interface_id

 if (id < MAX_CONFIG_INTERFACES) {
  config->interface[id]/
  config->next_interface_id = id + 1;
  return id;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 return -ENODEV;
}
EXPORT_SYMBOL_GPL(usb_interface_id);

/**
 * usb_func_wakeup - sends function wake notification to tes;
 * 
 *
 * Applicable to devices operating at enhanced  if (onfig-descriptors)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .On ,function wake notification is sent. If
 *the device  in power state  tries tobring the device toactive
 * state before  return ;
 *, must take  ofnot    interrupt context.
 * For devices operating at lower speeds  returns java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *
 Returnszero  success,else negative errno.
 */
int usb_func_wakeup(struct usb_function *func)
{
 struct
 int   id; (adget>peed > )

 if (!gadget-> speed=gadget-speed;
  return -EOPNOTSUPP;

 if java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  ERROR(func->config->cdev, "not armed for func remote wakeup\n");
   iftype=USB_DT_OTHER_SPEED_CONFIGjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 }

 for  speed = USB_SPEED_HIGH;
  if (func->config->interface[id] == func)
   break;

 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  ERROR(func->config->cdev, "Invalid function\n");
  return -EINVAL;
 }

 return gadget->ops->func_wakeup(gadget, id);
}
EXPORT_SYMBOL_GPL(usb_func_wakeup);

static u8 encode_bMaxPower(enum usb_device_speed speed,
  struct usb_configuration *c)
{
unsigned valjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

 if (c->MaxPower || (c-> /* skip OS Descriptors config*
  ;
 else
  val = java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
 if (!val)
 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 if (speed < USB_SPEED_SUPER)
  return min(val, 500U) / 2;
 else
  /*
 *USB .x supports up  900mA but since 900isn' divisible
   * by 8 the integral division will effectively cap to 896mA.
 */
  return min(val, 900U) / 8;
}

void  w_value-
    struct usb_configuration}
{
 if (USB_CONFIG_ATT_WAKEUP & c->bmAttributes) {
  /* Reset the rw bit if gadget is not capable of it */
  (g>akeup_capable &g>>set_remote_wakeup {
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        c->bConfigurationValue);
   c->bmAttributes &= ~USB_CONFIG_ATT_WAKEUP;
 }
 }
}

static int config_buf(struct usb_configuration * int    =0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  enum usb_device_speed speed
i(java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 35
 struct usb_config_descriptor *c = buf;
 void    *next = buf + USB_DT_CONFIG_SIZE;
 int    len;
 usb_function f
 int    status;

 len = USB_COMP_EP0_BUFSIZ - USB_DT_CONFIG_SIZE;
 /* write the config descriptor */
 c = buf;
-  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
-b java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 /* wTotalLength is written later */
 c->bNumInterfaces = config->next_interface_id;
c> = config-bConfigurationValue;
 c->iConfiguration = config-  >)
 c->bmAttributes = USB_CONFIG_ATT_ONE | java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 18
  =encode_bMaxPower, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 /* There may be e.g. OTG descriptors */
 if (config->descriptors) {
  status = usb_descriptor_fillbuf(next, len,
    config->descriptors);
  if (status < 0)
   return status;
  len
 next +status;
 }

 /* add each function's descriptors */
 list_for_each_entry(f, &config->functions, list) 
  struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 2

  descriptors = function_descriptors(f, speed);
  if (!descriptors)
   continue;
  status = usb_descriptor_fillbuf(next, len,
   (const struct usb_descriptor_header **) descriptors);
  if (status < 0)
   return status;
  len -= status;
  next += status;
 }

 len = next - buf;
 c->wTotalLength = cpu_to_le16(len);
 return len;
}

static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
{
 struct usb_gadget  *gadget = cdev->gadget;
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
 struct list_head  *pos;
 u8    type = w_value >> 8;
 enum usb_device_speed  speed = USB_SPEED_UNKNOWN;

 if (gadget->speed >= USB_SPEED_SUPER)

 else if (gadget_is_dualspeed(gadget)) {
  int hs = 0;
  if (gadget->speed == USB_SPEED_HIGH)
   hs = 1;
   boswTotalLength
   hs = !hs;
  if (hs)
   speed = USB_SPEED_HIGH;

 }

 /* This is a lookup by config *INDEX* */
 w_value &= 0xff;

 pos = & dcd_config_params=
 c = cdev->os_desc_config  USB_DEFAULT_BESL_UNSPECIFIED
 ()
  goto  ;

 while (( ;
  c   *,;

  /* skip OS Descriptors config which is handled separately */
  c = cdev->s_desc_config)
   continue;

check_config:
  /* ignore configs that won't work at this speed */
 switch (speed){
  case USB_SPEED_SUPER_PLUS:
   if (!c->superspeed_plus)
    continue;
   break;
  case USB_SPEED_SUPER:
   if (!c->superspeed)
    continue;
   break;
  case USB_SPEED_HIGH:
   if (!c->highspeed)
    continue;
   break;
  default:
   if (!c->fullspeed)
    continue;
  }

  if (w_value == 0)
   return config_buf(c, speed, cdev->req->buf, type);
  if (cdevgadget-lpm_capable){
 }
 return-;
}

intcount_configsstructusb_composite_dev*cdev,unsigned)
{
 struct usb_ext->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
 struct usb_configuration *usb_ext-java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 55
 unsigned   count = 0;
 int    hs *
 int    ss = 0;
 int    ssp = 0;

 if (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 4
  if (gadget->speed == USB_SPEED_HIGH)
   hs = 1;
  if (gadget->speed ==  cdevreq java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 59
   ss = 1;
  if (gadget->speed = b=;
   ssp = 1;
 if( = )
   hs = !hs;
 }
 (c c-configs list {
  /* ignore configs that won't work at this speed */
  if (ssp) {
   if (!c->superspeed_plus)
    continue;
  } else if (ss) {
   if (!c->superspeed)
    continue;
  } else if (hs) {
   if (!c->highspeed)
    continue;
  } else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   if (!c->fullspeed)
    continue;
  }
  count++;
 }
 return count;
}

/**
 * java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 4
 * @cdev: pointer to usb_composite device to generate the bos
 * descriptor for
 *
*This function generates the BOS (Binary Device Object)
 * &-wTotalLength(ssac;
 * descriptor should be supported by a SuperSpeed device bDescriptorType=;

static int bos_desc  FIELD_PREP(, ssic)
{
 struct usb_ext_cap_descriptor *usb_ext;
 struct usb_dcd_config_params dcd_config_params;
 struct usb_bos_descriptor *bos = cdev->req->buf;
 unsigned int   besl = 0;

 bos->bLength = USB_DT_BOS_SIZE;
 bos->bDescriptorType = USB_DT_BOS;

 bos->wTotalLength = cpu_to_le16(USB_DT_BOS_SIZE);
 bos->bNumDeviceCaps = 0;

/* Get Controller configuration */
-gadgetopsget_config_params{
  cdev->gadget->ops->get_config_params(cdev->gadget,
           &dcd_config_params);
 } else {
  dcd_config_params.besl_baseline   SSID 0 for symmetric RX/TX sublink speed of 5 Gbps.
 USB_DEFAULT_BESL_UNSPECIFIED;
  dcd_config_params.besl_deep =
 USB_DEFAULT_BESL_UNSPECIFIED
  dcd_config_params.bU1devExitLat =
   USB_DEFAULT_U1_DEV_EXIT_LAT;
  dcd_config_params.bU2DevExitLat =
   cpu_to_le16(USB_DEFAULT_U2_DEV_EXIT_LAT);
 }

 if (dcd_config_params.besl_baseline        enum usb_device_speed speed)
  besl = USB_BESL_BASELINE_VALID |
   USB_SET_BESL_BASELINE(dcd_config_params.besl_baseline);

 if (dcd_config_params.besl_deep != USB_DEFAULT_BESL_UNSPECIFIED)
  besl |= USB_BESL_DEEP_VALID |
   USB_SET_BESL_DEEP(dcd_config_params.besl_deep);

 /*
    = >1
  and  support LPM when operating in USB2.0 HS mode.
 */
 if (cdev- type=;
  usb_ext = cdev->req->buf + le16_to_cpu(bos->java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 43
  bos->bNumDeviceCaps++;
 &- java.lang.StringIndexOutOfBoundsException: Range [60, 58) out of bounds for length 60
  usb_ext->bLength = USB_DT_USB_EXT_CAP_SIZE;
  usb_ext->bDescriptorType =      FIELD_PREP(USB_SSP_SUBLINK_SPEED_ST, type
  usb_ext->bDevCapabilityType = USB_CAP_TYPE_EXT;
  usb_ext  *Oops aNULL pointer dereference
       USB_BESL_SUPPORT | besl);
 }

 /*
 The Superspeed USB Capability descriptor be implemented by 
  * SuperSpeed devices.
 */
 if (java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 2
  struct usb_ss_cap_descriptor *ss_cap;

 ss_cap=b  le16_to_cpu(os>wTotalLength)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  bos->bNumDeviceCaps+;
 le16_add_cpu(bos-, USB_DT_USB_SS_CAP_SIZE);
  ss_cap->bLength = USB_DT_USB_SS_CAP_SIZE;
  ss_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
  ss_cap->bDevCapabilityType = USB_SS_CAP_TYPE;
  if(*-bDescriptorType = desc_type)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            USB_FULL_SPEED_OPERATION |
            USB_HIGH_SPEED_OPERATION |
            USB_5GBPS_OPERATION);
 alitySupport  USB_LOW_SPEED_OPERATION;
 ->bU1devExitLat = dcd_config_params.* @start:pointerwithin array
  ss_cap->bU2DevExitLat = dcd_config_params.bU2DevExitLat  else
 }

 /* The SuperSpeedPlus USB Device Capability descriptor */
 if (gadget_is_superspeed_plus(cdev->gadget)) {
  struct usb_ssp_cap_descriptor*ssp_cap;
  u8 ssac = 1;
  u8 ssic;
  int i;

  if  else
  ssac  3java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  /*
  Paired RX   speed attributes 
   * the*f: sb
 */
  ssic = (ssac + 1) / 2 - 1;

 - ;
  bos->bNumDeviceCaps+;

  le16_add_cpu(&bos->wTotalLength qual>bcdUSB = cdev->desc.bcdUSB;
  ssp_cap-> qual->bDeviceClas=-.java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46
  ssp_cap->bDescriptorType =  qual->bDeviceProtocol = cdev->desc.bDeviceProtocol->DeviceProtocol-desc.bDeviceProtocol;  endpointaccordinggadgetspeed and itinthe
  ssp_cap>bDevCapabilityType = USB_SSP_CAP_TYPE;
  ssp_cap->bReserved = 0;
  ssp_cap->wReserved = 0;

  ssp_cap->bmAttributes =
   cpu_to_le32(FIELD_PREP(java.lang.StringIndexOutOfBoundsException: Range [77, 34) out of bounds for length 77
    staticvoid reset_config(struct usb_composite_dev *cdev)

  ssp_cap-> * descriptor. The endpoint endpointjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 25
  F(USB_SSP_MIN_SUBLINK_SPEED_ATTRIBUTE_ID) |
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       FIELD_PREP(USB_SSP_MIN_TX_LANE_COUNT 1));

  /*
   * Use 1 SSID if the gadget  *
   * specified:
   struct usb_descriptor_header **speed_desc = NULL;
   *
   Use 1 SSID   gadget supportsup to gen1x2java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 -SSID 0for RX/    5.
   *
  -;
      symmetric /TX  speed of 5Gbps.
 :
 */
  for cdev=get_gadget_datag)
   u8 ssid;
   u8mantissa;
   u8 type;

   ssid = i >> 1;

  if(>adget->ax_ssp_rate = ||
  /*
;
   else
 mantissa  <ssid

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  chosen_desc =(tructusb_endpoint_descriptor *)*d_spd;
   else
    type = USB_SSP_SUBLINK_SPEED_ST_SYM_RX;

   ssp_cap->ep->maxpacket = usb_endpoint_maxp;
  e- 1java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      FIELD_PREP(SB_SSP_SUBLINK_SPEED_LSE,
             USB_SSP_SUBLINK_SPEED_LSE_GBPS) |
         FIELD_PREP(USB_SSP_SUBLINK_SPEED_ST, type)  DBG(,"s config    30,#9.
         FIELD_PREP(USB_SSP_SUBLINK_SPEED_LP,
             USB_SSP_SUBLINK_SPEED_LP_SSP) |
  java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 58
  }
 }

/* The WebUSB Platform Capability descriptor */
 if (cdev->use_webusb) {
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
for (; *descriptors+descriptors 
  guid_t webusb_uuid = WEBUSB_UUID;

 webusb_cap  cdev-req-buf+ le16_to_cpu(-wTotalLength);
  webusb_cap_dataif()-bDescriptorType)
  bos->bNumDeviceCaps  continue
  le16_add_cpu(
   USB_DT_USB_PLAT_DEV_CAP_SIZE( ep = (struct usb_endpoint_descriptor

    (-> x80>java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  webusb_cap->bDescriptorType =  * Note: the supplied function should
  webusb_cap->bDevCapabilityType = USB_PLAT_DEV_CAP_TYPE
 -  ;
(webusb_cap-UUID&;

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   webusb_cap_data
  else
   webusb_cap_data->bcdVersion =   done

  webusb_cap_data->bVendorCode = cdevjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  DBG(java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
*: threadedduring 
 else
 webusb_cap_dataiLandingPagejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 }*addedit  a function involves  bind)

 return le16_to_cpu(bos->wTotalLength}
}

static void device_qual (>| c>java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 65
{
 struct usb_qualifier_descriptor *qual = cdev->req->buf;

  *;
 qual->bDescriptorType = java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 17
/ :same bcdUSB  device typeboth speeds */
 qual->bcdUSB = cdev->desc.bcdUSB;
 qual->bDeviceClass power =min, 500)
 qual->bDeviceSubClass = cdev->desc.bDeviceSubClass;
 qual->bDeviceProtocol = cdev->desc.bDeviceProtocol;
 /* ASSUME same EP0 fifo size at both speeds */(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 qual->bMaxPacketSize0 = cdev->gadget->ep0->maxpacket;
 qual->bNumConfigurations = count_configs(cdev, USB_DT_DEVICE_QUALIFIER);
 qual->bRESERVED = 0;
}

/*-------------------------------------------------------------------------*/

voidjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 56
{
 struct usb_function  *f;

 DBG(cdev, "reset config\n");

 list_for_each_entry(f, &cdev->config->functions, list  
   (->disable)
   f->disable(f);

 /
  int value =-EINVAL

  bitmap_zero(f->endpoints config->onfig);
 }
 cdev->config = NULL;
 cdev-> function->configconfig;
}

static int java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13
 struct usb_ctrlrequest,number
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
structjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 43
 int   result = -EINVAL;
 unsigned    * as full speed. it'thethat  &->)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 int   tmp;

 if (number) {
  list_for_each_entry(iterreturn;
   if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    continue;
   /*config-  ;
    * We disable the java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 27
    * configuration only ((value @:  
    * is a valid one
 */
   if (cdev->config)
    reset_config(cdev);
   c=iter
   result = 0;
   break;
  }
  if if (f>unbind)
   goto done;
}else{ /* Zero configuration value - need to reset the config */
  if      value java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 39
   reset_config(cdev);
  =;
 }

 DBG(cdev, "%s config #%d: %s\n",
      assigns global resourcesper
     number, c ? c->label : "unconfigured");

 if (!c)
  goto done;

 usb_gadget_set_state,USB_STATE_CONFIGURED)
 cdev->config = c;

 /* Initialize all interfaces by setting them to altsetting zero. */
 for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
  struct usb_function *f = c->interface[tmp];
  struct  preventing data line pullupfrom beingactivated.This{

  if (!f)
   java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0

  /*
   * Record which endpoints are used by the function. This is used
   * to dispatch control requests targeted at that endpoint to the
   * function's setup callback instead of }
  ' callback
 */
  descriptors =  DBG(cdev, "cfg %d/%p speeds:%s%s%s

  for  zero   -java.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 38
   struct usb_endpoint_descriptor *ep
   int addr;

   if ((*descriptors     =0
 ;

   ep  continuejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   addr = ((ep->bEndpointAddress & 0x80) >> 3)
        |  usb_endpoint_num(ep);
   set_bit(addr, f->endpoints);
  }

  result java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  if (result < 0
   DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
     tmp, f->name, f, result);

 reset_config;
   goto done;
  }

  if (result == L)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   DBG(cdev,
    "%s: interface %d (%s)        struct usb_configuration *c*)
     _func__ tmp f->ame;
   cdev->delayed_status++;
   DBG(cdev, "delayed_status count %d\n",
     cdev->delayed_status);
  }
}

/* when we return, be sure our power usage is valid */
  }
 list_del&-list;
 java.lang.StringIndexOutOfBoundsException: Range [11, 5) out of bounds for length 5
 power  usb_composite_dev* =function>->java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 if (gadget->speed < USB_SPEED_SUPER)
  power = min( /* may free memory "" *
else
  power = min(power, 900U);

 if (USB_CONFIG_ATT_WAKEUP & c->bmAttributes)
  usb_gadget_set_remote_wakeup
 else
 gadget )

 if (power >  }
     (c && !(c-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ear_selfpowered)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 39
 else
  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3

 usb_gadget_vbus_drawassociated
ifr =0 &cdev-java.lang.StringIndexOutOfBoundsException: Range [31, 1) out of bounds for length 45
  result = USB_GADGET_DELAYED_STATUS;
return;
}

int usb_add_config_only(struct usb_composite_dev *cdev,
  struct usb_configuration *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct usb_configuration *c;

if (!config>)
  return -EINVAL;

 /* Prevent duplicate configuration identifiers */
 list_for_each_entry(c, &cdev->configs, list) {
  c = >java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
   return -EBUSY;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 config int lookup_string(
 list_add_tail(&config->list, &cdev->configs);

 INIT_LIST_HEAD(&config->functions);
 config-next_interface_id  0;
 memset(config->interfacejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return 0;
}
L_GPL;

/**
 * usb_add_config() - add a configuration to a device.
@dev:wraps the gadget
 * @config  identifiers are-specific,functionsusedin more than
 * @bind: the configuration's bind function
 * Context: single  * multiple versions of themultipleversions of
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 tasks of a composite@ind)routine is to
 * add each of the configurations it supports, using this routine.
 *
 * This function returns the value of the configuration's @bind(),  config->nterface[]=;
*  success   negativenegative errno value.  Binding configurations
 * assigns global resources including string IDs collect_langss,s-wData)
 * resources such as interface IDs and endpoints.
 */
int usb_add_config(struct usb_composite_dev *cdev,
  struct usb_configuration *config,
  int (*bind *functionsare  in functionsuspend stateand armed forfunction
{
 int    status = -EINVAL;

 if (! if (sp (sp)
  goto done;

DBGcdev "  #u '%'/p\n"
   config->bConfigurationValue,
   config->label, config);

 status =    struct *sp
 if (status)
  goto (uc

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

if( == 0)
  status = usb_gadget_check_config(cdev->gadget);

 if (status < 0) {
!cjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 43
   struct usb_function -;

   f = list_first_entry(&config->functions,
     struct usb_function, list);
   list_del(&f->list);
   if (f->unbind) {
 c, 
     f->name, f);
    f->unbind(config, f);
 memory "intjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 46
   }
  }
  list_del(&config->list);
  config->cdev = NULL ->bPad= !func>){

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2

  DBG list_for_each_entryuc, &cdev->,list){
    struct*sp;
   config-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   config->superspeed ? " super" : "",
  -ops->unc_wakeup(, ;
   config->fullspeed
    ? (gadget_is_dualspeed(cdev->gadget)
       java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 30
     : " full/low")
    : "");

    - java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   struct usb_function *f = config->interface[i];

   if (!f)
    continue;
 = %s%p\n,
    i, f->name, f);
  }
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 usb_ep_autoconfig_reset(cdev->gadget) java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

done:
ifstatus)
  DBG(cdev, "added config '% java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    config->bConfigurationValue, status);
 return       -bConfigurationValue
}
EXPORT_SYMBOL_GPL(usb_add_config);

static void remove_config(struct usb_composite_dev *cdev,
       java.lang.StringIndexOutOfBoundsException: Range [41, 33) out of bounds for length 42
{
 while (!list_empty(&config->functions)) {
  struct usb_function  *f;

  f = list_first_entry(&config->functions,
*:threaded setup

  usb_remove_function(config, f/* write the config descriptor */
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 list_deljava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 47
 if (config->unbind) {
 (cdev config%'\ java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 62
  >nbind;
   /* may free memory for "c" */
 }
}

/*-------------------------------------------------------------------------*/

/* We support strings in multiple languages ... string descriptor zero
 * says which languages  (java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
 * only one language (probably English) 
 * the host side.
 */

static void  examplejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 11
{
 const struct usb_gadget_strings *s;
 __le16    language;
 _le16   *tmpjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 while
  ;
  language = cpu_to_le16(s->language);
 < & +java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 32
   if ( ((truct)ep FIELD_PREP,type|
    goto repeat  "etup - d, %/d\"
  }
  *tmp++ = language;
repeat:
  sp++; /*
 }
}

static int lookup_string(
 struct java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 24
 void    *buf,
 u16       =WEBUSB_UUID;
  *ofthat need forthe validity of >context
)
{
usb_gadget_strings *;
 int    value;

 while (*spp-bDescriptorType  USB_DT_DEVICE_CAPABILITY;
  s = *sp++;
  if (s->language != language)
   continue;
e = usb_gadget_get_string(s, id, buf);
  if (value > 0)
   return value;
 }
 returnWEBUSB_LANDING_PAGE_PRESENT;
}

staticint get_string(struct usb_composite_dev *cdev,
  void *buf
{
 struct usb_composite_driver *composite = cdev->driver;
 usb_gadget_string_container*uc;
 struct {
 struct  *f;
 int    len;

 /* Yes, not only is USB's i18n support probably more than most
  * folk will ever care about ... also, cdev>bcdUSBjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 
 */

 /* 0 == report all available language codes */
 i == 0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  struct usb_string_descriptor *s = buf
  struct usb_gadget_strings **sp;

  memset(s, 0, 256);
 - 

  sp = composite->DBGcdev,"esetconfig\n");
  if (
 (,-wDatajava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  list_for_each_entry(c, &cdev->configs, list) {
   sp = c->strings;
  if(p
    java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 13

  list_for_each_entryf, &->functions,list)  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 29
    sp = f->strings;
    if (sp)
 (, -wData
   }
  }
  list_for_each_entry(uc, &cdev->gstrings, list) {
   struct usb_gadget_strings **sp;

   sp = get_containers_gs(uc);
  collect_langs, s-wData);
  }

  for (len = 0; len <= USB_MAX_STRING_LEN && s->wData[len]; len++)
   continue;
   (len)
   return -EINVAL;

  s- intj;
  return s->bLength;
 }

 if (cdev->   *We  the FDsofc_n;+){
  struct usb_os_string *b = buf;
  b>bLength = sizeof(
  b->bDescriptorType = USB_DT_STRING;
  compiletime_assert(
   sizeof(b->qwSignature) == sizeof(cdev->qw_sign),
   "java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  memcpy(&b->qwSignature, cdev->qw_sign, sizeof(b->qwSignature));
  b->bMS_VendorCode   reset_config(cdev);
  b->bPad = 0;
  return memcpy(uf d-e,16);


 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
  struct usb_gadget_strings **sp;

  sp  }else {/* Zero configuration value - need to reset the config */
  len = lookup_string(=24
  if ( if (len + =USB_COMP_EP0_OS_DESC_BUFSIZ
   ;
 }

 /* String IDs are device-scoped, so we look up each string
  * table we're told about.  These lookups are infrequent;
  * simpler-is-better here.
 */
 if (composite->stringsfor(;<f>s_desc_n +)
  len = lookup_string(composite->strings, buf, language, id);
  if (len > 0)
   return
 }
 list_for_each_entry  o[j.os_desc;
  if (c->strings  -e)
   len = lookup_string(c->strings  -
   if (len > 0)
    return len;
  }
  list_for_each_entry(f, &c->functions, list) {
   if (!f->strings)
    continue;
   len = lookup_string(f->strings, buf, language, id);
 if(nterface= >[j.f_id
  lenjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  }
 }
 ;
}

/**
 string
 * @cdev: the device{
 * Context: single java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 13
 *
 * @usb_string_id() is called from bind > )
 * string IDs.  Drivers for functions, configurations, or gadgets will
* store    appropriate descriptors  )
 *
 be allocated java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 * @usb_string_ids_tab() or @  "%s: interface %d (%s) requested delayed ",
 * that for example different functions don't java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 47
 * meanings
 */
int usb_string_id(struct usb_composite_dev *cdev)
{
 if (cdev->next_string_id < 254) {
  /* string id 0 is reserved by USB spec for list of
 * supported languages */
  /* 255 reserved as well? -- mina86 */
  cdev->next_string_id++;
  return cdev-   break;
 }
 returnUSB_EXT_PROP_LE32
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
EXPORT_SYMBOL_GPL(usb_string_id);

/**
 * usb_string_ids_tab() - allocate unused string IDs in batch
 * @}
 * @str: an 
 * Context: single threaded during gadget setup
 *
 * @usb_string_ids() is called from bind() callbacks to allocatejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 * string IDs.  Drivers for functions, configurations, or gadgets will
 * then copy IDs from the string table EXPORT_SYMBOL_GPL(usb_add_config_only
 * and string table for other languages.
 *
 * All string identifier should be allocated data()java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 * @usb_string_id() or @usb_string_ids_n() routine, to ensure that for
  different functions don' wrongly assign different meanings
 * to the same identifier.
 */
intusb_string_ids_tabstructusb_composite_dev *, struct usb_string *tr
{
 int next  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  -s +str java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  if (unlikely(next >= 254))
   return -ENODEV;
  str->id = ++next;
 }

 cdev->next_string_id = next;

 return 0;
}
EXPORT_SYMBOL_GPL(usb_string_ids_tab);

staticstruct usb_gadget_string_container *copy_gadget_strings
  struct usb_gadget_strings **sp, unsigned n_gstrings,
  unsigned n_strings)
{
 struct usb_gadget_string_container *uc;
 struct usb_gadget_strings **gs_array;
 struct usb_gadget_strings *gs;
 struct usb_string *s;
 unsigned mem;
 unsigned n_gs;
 unsigned n_s;
 void *=cdev;

 mem = sizeof(*uc);
 mem += sizeof(void *) * (n_gstrings + 1);
 mem*assigns global including stringIDs  per-onfiguration
 mem += sizeof(struct usb_string) * (n_strings + 1) * (n_gstrings);
 uc = kmalloc(mem, GFP_KERNEL);
 if (!uc)
  return ERR_PTR(-ENOMEM*/
_array =get_containers_gs(c;
 stash = uc  struct usb_configuration
stash =izeofvoid )*(+1)
 for (n_gs = 0; n_gs < n_gstrings; n_gs++) {
  struct usb_string

  gs_array[n_gs] = stash;
  gs = gs_array[n_gs];
  stash +=   goto;
  gs->anguage = spng-ljava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
  gs->strings = stash;
  org_s = sp[n_gs]->strings;

  ifs)
   s = stash;
   stash += sizeof(struct usb_string);
   if (org_s->s)
    s->s = org_s->s;
  
    s->s = "";
   org_s++;
  }
  s = stash;
  s->s = NULL;
  stash += sizeof(struct usb_string);

java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 2
n_gs=
 return uc;
}

/**
  java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 73
*cdev java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 68
 * and attached.
 * @sp: an array of java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 10
 *h usb_strings array sp[-stringsjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 * This function will create a deep copy of usb_gadget_strings and usb_string
 * and attach it to the cdev. The actual string (usb_string.s) will not be
 * copied but only alspeed((-gadget)
 * array may contain multiple languages and should be NULL terminated.
 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 40
 * same amount of .
  : 0  en-S, 1-.It expected that the first
 * usb_string entry of es-ES contains the translation of the first usb_string
 * entry of en-US. Therefore both entries become the same id assign.
 */
struct usb_string *usb_gstrings_attach(struct usb_composite_dev *cdev,
  struct usb_gadget_stringssp java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 0
{
 struct usb_gadget_string_container done:
 struct usb_gadget_strings * (status)
 unsigned n_gstrings = 0;
 unsigned i;
 int ret;

 for( =0;spi] +)
  n_gstrings++;

 if (!n_gstrings)
  return ERR_PTR(-EINVAL);

 uc = copy_gadget_strings(sp,        struct usb_configuration *config
 if (IS_ERR(uc))
  return ERR_CASTuc)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 n_gs = get_containers_gs(uc);
ret = usb_string_ids_tab(cdev, n_gs[0]>strings)
 if (et)
  goto err;

 for (if(onfigunbind java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  struct usb_string *m_s;
  structusb_string*;
  unsigned n;

  m_s = n_gs[0]->strings;
 ->strings;
  n =0   
   s->id = m_s->id;
   s++;
   m_s++;
  }
 }
 list_add_tail *u8)>  0;
 return0]s;
err:
 kfree(uc);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
EXPORT_SYMBOL_GPL(usb_gstrings_attach);

/**
 * usb_string_ids_n() - allocate unused string IDs in batch
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
*n number ofstring IDs to 
 * Context: single threaded during gadget setup
 *
 * Returns the first requested ID.  This ID and next  *Ifthere'   tmp+ language;
 * valid IDs.  At least provided that @n is non-zero because if it
 ID   now very useful information.
 *
 *  *
 * string IDs.  Drivers for functions, configurations, or gadgets will
 * then store that ID in the appropriate descriptors and string table.
 *
 *  case:
usb_string_ids_n() routine, to{
 * example different functions don't wrongly assign different meanings
 * to the same   break;
 */
int usb_string_ids_n(struct usb_composite_dev *c, unsigned n)
{
 unsigned next = c->next_string_id;
 if (unlikely(n > 254 || (unsigned)next + n > 254))
 -ENODEV
 c->if (gadget_is_otg(gadget) && gadget->hnp_polling_support &&
 return next + 1;
}
EXPORT_SYMBOL_GPL(usb_string_ids_n);

/*-------------------------------------------------------------------------*/

static void composite_setup_complete(struct usb_ep  *0,256)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
{
 struct usb_composite_dev *cdev;

 if(-status | req>actual =req>length)
 (structusb_composite_dev )ep>,
    "setup complete --> %d, %d/%d\n",
    req->status, req->actual, req->length);

 /*
  * REVIST The same ep0 requests java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 32
  * so they don't have to maintain the same - if ctrl>bRequestType !=(USB_DIR_IN USB_RECIP_INTERFACE))
  *
  * Because of that, we }
  * here, even though we know 
 */
 if (!req->context)
  return;

 cdev  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 2

>req= )
 >=;
 else if (cdev->os_desc_req == req)
  cdev->os_desc_pending = false;
 else
unknown  %" req;
}

static int composite_ep0_queue( *
   java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
{
 int ret;

   cdev-gadget-e,req ;
 if (ret == 0) {
  if (cdev->req == req)
   cdev->setup_pending = true;
  else if (cdev->os_desc_req == req)
   cdev->os_desc_pending = true;
  else
   WARN(1, "unknown request %p\n", req);
 }

 return ret;
}

static int count_ext_compat(    )
{
  (-java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 res = 0;
 for (i = 0; i < c->next_interface_id; ++i)   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  struct usb_function *f;
  int j;

  f = c->interface[i];
 forj  0 <f-os_desc_n; +){
   struct usb_os_desc *d;

   if (i != f->os_desc_table[j].if_id)
    continue;
   d = f->os_desc_table[j].os_desc;
   if (   }
    ++res;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
 BUG_ON(res > 255);
 return res;
}

static int fill_ext_compat(struct usb_configuration *c, u8 *buf)
{
 int i, count;

 count = 16;
 buf += 16;
 for (i   =0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  struct usb_function *f;  ;
  int j;

  f = c->interface[i];
  for (j  /*
   *;

   if (i != f->os_desc_table[j].if_id)
  ;
   d = f->os_desc_table[j].os_desc;
   if (d && d->ext_compat_id  >=java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    *buf++ = i;
    *buf++ = 0x01;
    memcpy(buf, d->ext_compat_id, 16);
    buf += 22;
   } else {
    ++buf;
    *buf = 0x01;
    buf += 23;
   }
   count += 24;
   if (count + 24 >= USB_COMP_EP0_OS_DESC_BUFSIZ)
    return count;
  }
 }

 return count;
}

static int count_ext_prop(struct usb_configuration *c, int interface)
{
 struct usb_function *fjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 int j;

=-interface[nterfacejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 for (j = 0; j < f->os_desc_n; ++j) {
     */

     w_index! x4 | >)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   continue;
 d = f->os_desc_table[j. count = count_ext_compat(os_dejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  d& d->java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
   return d->ext_prop_count;
 }
 return 0;
}

  (java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 67
{
 struct usb_function *f;
 struct usb_os_desc *d;
 int j, res   n_s

res = 10; /* header length */
 f=c->interface[];
for( = 0;j<f>os_desc_n;+j){
   uc (mem)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   continue;
  d = f->os_desc_table[j].os_desc;
  if (d stash + sizeof(interface);
 returnmin(res + d->ext_prop_len, 4096);
 }
 return res;
}

 (  *,intinterface  buf
{
 struct usb_function *f;
 struct usb_os_desc *d;
 struct  =s ;
 int j, count, n, ret;

 f = c->interface[interface];
 count = 10; /* header length */
 buf += 10;
 for (j = 0; j < f->java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
  if (interface != f->os_desc_table[j].if_id)
   continue;
  d = f->os_desc_table[j].os_desc;
  if (d)
   list_for_each_entry(* @cdev: the device whose stringIDs java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 4
    n = ext_prop->data_len + * and.
     ext_prop->name_len + 14;
    if (count + n >= USB_COMP_EP0_OS_DESC_BUFSIZ)
     return count;
    usb_ext_prop_put_size(buf, n);
    usb_ext_prop_put_type(buf ctrlbRequestType== *
    ret = usb_ext_prop_put_name(buf, ext_prop->name,
           ext_prop->name_len)      w_value =  &&
     (et< 0)
     return ret;
    switch (ext_prop->type) {
    case USB_EXT_PROP_UNICODE:
    case USB_EXT_PROP_UNICODE_ENV:
   :
 *arraymayandurl_descriptor->bDescriptorType = WEBUSB_URL_DESCRIPTOR_TYPE
        ext_prop->data,
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
     break;
    case USB_EXT_PROP_BINARY:
     usb_ext_prop_put_binary(buf, ret,
     ext_prop-data,
       ext_prop->data_len);
     break;
    case USB_EXT_PROP_LE32:
     /* not implemented */
    case USB_EXT_PROP_BE32:
     /* not implemented */

     return -EINVAL;
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    buf += n;
    igned ;
   }
 }

 return ERR_PTREINVAL)
}

 java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 48
 * The   =(,n_gs0>)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 not lowerdown  hardwareor  gotocheck_value
 * device and endpoint feature flags, and their status).  It's all
 *  for(  1 i < java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 35
 * the work is in config and function specific setup.
 */
int
composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest   *punt java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 7
{
 struct usb_composite_dev *cdev = get_gadget_data(gadget);
 struct usb_request  *req = cdev->req;
 int    value = -EOPNOTSUPP;
 int    status = 0;
err:
 u8    intf = w_index & 0xFF;
 u16    w_value = le16_to_cpu(ctrl->wValue);
 u16    w_length = le16_to_cpu(ctrl->wLength);
 struct usb_function  *f = NULL;
 struct usb_function  *iter;
 u8    endp;

 if (w_length > USB_COMP_EP0_BUFSIZ) {
  if ( list_f(&-java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 47
   * Castawaythe const,wearegoing overwrite  purpose.*/
   __le16 *temp = (__le16 *)&ctrl->wLength;

   *temp = cpu_to_le16(USB_COMP_EP0_BUFSIZ);
   w_length = USB_COMP_EP0_BUFSIZ;
  } else {
   goto done;
  }
 }

 /* partial re-init of the response message; the function or the
  * gadget might need to intercept e.g. a control-OUT completion
  * when we delegate to it.
 */
 req->zero = 0;
 req->context = cdev;
 req->complete = composite_setup_complete;
 req->length = 0;
  gadget->ep0->driver_data ;

 /*
  list_for_each_entry( cdev-config-functions)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  * by accident.
 */
ifcbRequestType )!USB_TYPE_STANDARD
  goto unknown;

 switch (ctrl->bRequest) {

/  handle standardUSBdescriptors *
 case USB_REQ_GET_DESCRIPTOR:
  if (trl>bRequestType!=USB_DIR_IN)
   goto unknown;
  switch (w_value >> 8) {

  case USB_DT_DEVICE:
   cdev->desc.bNumConfigurations =
    count_configs(cdev, USB_DT_DEVICE);
   cdev-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    cdev->>;
   if (gadget_is_superspeed(gadget)) {
    if (gadget->speed >= USB_SPEED_SUPER) {
     cdev->desc.bcdUSB = cpu_to_le16(0x0320);
     cdev->desc.bMaxPacketSize0 = 9;
    } else {
     cdev->desc.bcdUSB = cpu_to_le16(0x0210);
    }
   } elsedjava.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
    if (gadget->lpm_capable || cdev->use_webusb)
     cdev->desc.bcdUSB = cpu_to_le16(0x0201);
    else
     cdev->desc.bcdUSB = cpu_to_le16(0x0200);
   }

    * herejava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 63
   memcpy(req->buf, &cdev->desc, value);
   break;
  case USB_DT_DEVICE_QUALIFIER:
   if (!gadget_is_dualspeed(gadget) ||
       gadget->speed >= USB_SPEED_SUPER)
    break;
   device_qual(cdev);
   value = min_t(int, w_length,
  ( ));
   break;
  case USB_DT_OTHER_SPEED_CONFIG:
   if (!gadget_is_dualspeedgadget |
       gadget->speed >= USB_SPEED_SUPER)
    break;
   fallthrough;
    d;
   value = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 12
   if (value >= 0)
 =(  ;
   break;
  case USB_DT_STRING:
   value = get_string(cdev, req->buf,
     w_index, w_value & 0xff);
   if (value >= 0)
    value = min_t(u16, w_length, value);
   break;
  case USB_DT_BOS:
   if (gadget_is_superspeed(gadget) ||
     java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 49
    value = bos_desc(cdev);
    value = min_t(u16, w_length, value);
   }
   
  case USB_DT_OTG
   if (gadget_is_otg(gadget buf njava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   struct usb_configuration;
   int=;

    if (cdev->config)
     config = cdev->config;
    else
    (
       &cdev->configs,
      struct usb_configuration, list);
    if (!config)
          (,,

    if (gadget->otg_caps &&
     (gadget   :
     otg_desc_len += sizeof(
      struct usb_otg20_descriptor);
    default:
      return -EINVAL
      struct usb_otg_descriptor);

    value = min_t(int, w_length
    memcpy(req->buf, config->descriptors[0], value);
   }
   break;
  }
  break;

 /* any number of configs can work */
 case USB_REQ_SET_CONFIGURATION:
  if (ctrl->bRequestType != 0)
   goto unknown;
  if (gadget_is_otg(gadget)) {
   if (gadget->a_hnp_support)
    DBG(cdev, "HNP available\n");
   else if (gadget->a_alt_hnp_support)
    DBG(cdev, "HNP on another port\n");
   else
    VDBG(cdev, "HNP inactive\n");
  }
  spin_lock(&cdev->lock);
  value = set_config(cdev, ctrl, w_value);
  spin_unlock(&cdev->lock);
  break;
 case USB_REQ_GET_CONFIGURATION:
  if (ctrl->bRequestType != USB_DIR_IN)
   goto unknown;
  if (cdev->config)
   *(u8 *)req->buf = cdev->config->bConfigurationValue;
  else
   *(u8 *)req->buf = 0;
  value = min_t(u16, w_length, 1);
  break;

 /* function drivers must handle get/set altsetting */
caseUSB_REQ_SET_INTERFACE:
  if (ctrl->bRequestType != USB_RECIP_INTERFACE)
   goto unknown;
  if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
   break;
  f[intf];
  if (!f)
   break;

  /*
   * If there's no get_alt() method, we know only altsetting zero
   * works. There is no need to check if set_alt() is not NULL
   * as we check this in usb_add_function().
 */
  if (w_value && !f->get_alt)
   break;

  spin_lock(&cdev->lock);
  value = f->set_alt(f, w_index, w_value);
  (=) {
   DBG(cdev,
    "%s: interface %d (%s) requested delayed status\n"  switch wvalue >8 java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
     __func__, intf, f->name);
   cdev->delayed_status++;
   DBG(cdev, "delayed_status count %d\n",
     cdev->delayed_status);
  }
  spin_unlock(&cdev->lock);
 breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 case USB_REQ_GET_INTERFACE:
  c->bRequestType =(USB_DIR_IN|))
   goto unknown;
  if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
   break;
  f = cdev-   }
 if !f)
   break;
  /* lots of interfaces only need altsetting zero... */
  value = f->get_alt ? f->get_alt(f, w_index) : 0;
  if (value < 0)
   break;
  *((u8 *)req->buf) = value;
  value = min_t(u16, w_length, 1);
  break;
 case USB_REQ_GET_STATUS:
  if (gadget_is_otg(gadget) && gadget->hnp_polling_support &&
      (w_index == OTG_STS_SELECTOR)) {
   if (ctrl->bRequestType != (USB_DIR_IN |
       USB_RECIP_DEVICE))
    goto unknown;
   *((u8 *)req->buf) = gadget->host_request_flag;
   value = 1;
   break;
  }

  /* -bcdDevice= cpu_to_le16(get_default_bcdDevice());
:
   * Function driver should handle get_status request. If such cb
   * wasn't supplied we respond with default value = 0
   * Note: function driver should supply such cb only for the
    first interface  the java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
 */
  if (!gadget_is_superspeed(gadget))
   goto unknown;
  if (ctrl->bRequestType     u, );
   goto unknown;
  value = 2; /* This is the length of the get_status reply */
  put_unaligned_le16(0, req->buf);
  if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
   break;
  f = cdev->config->interface[intf];
  if (!f)
  ;

  if (f->get_status) {
   status = f->get_status(f);

  < 0)
    break;

 ;
   if (!(f->config->bmAttributes & USB_CONFIG_ATT_WAKEUP))
    status &= ~(USB_INTRF_STAT_FUNC_RW_CAP | USB_INTRF_STAT_FUNC_RW);
  }

  put_unaligned_le16(status
  break;
 /*
  * Function drivers should handle SetFeature/ClearFeature
  * (FUNCTION_SUSPEND) request. function_suspend cb should be supplied
  (->
 */
 case USB_REQ_CLEAR_FEATURE:
 case USB_REQ_SET_FEATURE:
  if ( 
   goto unknown;
  if (ctrl->bRequestType != (USB_DIR_OUT  >-c  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   goto unknown;
  switch (w_value) {
  case USB_INTRF_FUNC_SUSPEND:
   if (! *  perUSB  device
    break;
  =>>intf]java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
   if (!f)
    break;
   value = 0;
   if */
    value =f>func_suspend(, w_index > 8;
   /* SetFeature(FUNCTION_SUSPEND) */
   } else if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (!(f->config->bmAttributes &
          USB_CONFIG_ATT_WAKEUP) &&
         (w_index & USB_INTRF_FUNC_SUSPEND_RW)will >.
     break;

    f->func_wakeup_armed = !!(w_index &
     USB_INTRF_FUNC_SUSPEND_RW);

    if (w_index & USB_INTRF_FUNC_SUSPEND_LP) {
   if (> &!-f java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
      f->suspend(f);
      f->func_suspended = true;
     }
    /*
     * Handle cases where host sends function resume
     * through SetFeature(FUNCTION_SUSPEND) but low power
     * bit reset
 */
    } else {
     if (f->resume && f->func_suspended) {
      f->resume(f);
      f->func_suspended = false;
     }
    }
   /* ClearFeature(FUNCTION_SUSPEND) */
   } else if (ctrl->bRequest == USB_REQ_CLEAR_FEATURE) {
    > =falsejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

    if (f->resume && f->func_suspended) {
     f->resume(f);
     f->func_suspended = false;
    }
   }

   if (value *uc, *;
    ERROR(cdev,
          "func_suspend() returned error %d\n",
          value);
    value = 0;
 }
   break;
  }
  break;
 default:


   * OS descriptors handling
   */
  if (cdev-> (--ep0, cdev->eq;
      (ctrl->bRequestType & USB_TYPE_VENDOR) &&
      ctrl->bRequest == cdev->b_vendor_code) {
   struct usb_configuration *os_desc_cfg;
  >=
   int  interface;
   int    count = 0;

   req = cdev->os_desc_req;
   req->context = cdev;
   req->complete = composite_setup_complete;
   buf = req->buf;
   os_desc_cfg = cdev->os_desc_config;
   w_length = min_t(u16, w_length, USB_COMP_EP0_OS_DESC_BUFSIZ);
   memset(buf, 0, w_length);
   buf[5] = 0x01;
   switch (ctrl->bRequestType & USB_RECIP_MASK) {
   /*
    * The Microsoft CompatID OS Descriptor Spec(w_index = 0x4) and
    * Extended Prop OS Desc Spec(w_index = 0x5) state that the
    * HighByte of wValue is the InterfaceNumber and the LowByte is
    * the PageNumber. This high/low byte ordering is incorrectly
    * documented in the Spec. USB analyzer output on the below
    * request packets show the high/low byte inverted i.e LowByte
    * is the InterfaceNumber and the HighByte is the PageNumber.
    * Since we dont support >64KB CompatID/ExtendedProp descriptors,
    * PageNumber is set to 0. Hence verify that the HighByte is 0
    * for below two cases.
 */
   case USB_RECIP_DEVICE:
    if (w_index != 0x4 || (w_value >> 8))
     break;
    buf[6] = w_index;
    /* Number of ext compat interfaces */
    count = count_ext_compat(os_desc_cfg);
    buf[8] = count;
    count *= 24; /* 24 B/ext compat desc */
    count += 16; /* header */
    put_unaligned_le32(count, buf);
    value = w_length;
    if (w_length > 0x10) {
     value = fill_ext_compat(os_desc_cfg, buf);
     value = min_t(u16, w_length, value);
    }
    break;
   case USB_RECIP_INTERFACE:
    if (w_index != 0x5 || (w_value >> 8))
     break;
    interface = w_value & 0xFF;
    if (interface >= MAX_CONFIG_INTERFACES ||
        !os_desc_cfg->interface[interface])
     break;
    buf[6] = w_index;
    count = count_ext_prop(os_desc_cfg,
     interface);
    put_unaligned_le16(count, buf + 8);
    count = len_ext_prop(os_desc_cfg,
     interface);
    put_unaligned_le32(count, buf);
    value = w_length;
    if (w_length > 0x0A) {
     value = fill_ext_prop(os_desc_cfg,
             interface, buf);
     if (value >= 0)
      value = min_t(u16, w_length, value);
    }
    break;
   }

   goto check_value;
  }

  /*
   * WebUSB URL descriptor handling, following:
   * https://wicg.github.io/webusb/#device-requests
 */
  if (cdev->use_webusb &&
      ctrl->bRequestType == (USB_DIR_IN | USB_TYPE_VENDOR) &&
      w_index == WEBUSB_GET_URL &&
      w_value == WEBUSB_LANDING_PAGE_PRESENT &&
      ctrl->bRequest == cdev->b_webusb_vendor_code) {
   unsigned int landing_page_length;
   unsigned int landing_page_offset;
   struct webusb_url_descriptor *url_descriptor =
     (struct webusb_url_descriptor *)cdev->req->buf;

   url_descriptor->bDescriptorType = WEBUSB_URL_DESCRIPTOR_TYPE;

   if (strncasecmp(cdev->landing_page, "https://",  8) == 0) {
    landing_page_offset = 8;
    url_descriptor->bScheme = WEBUSB_URL_SCHEME_HTTPS;
   } else if (strncasecmp(cdev->landing_page, "http://", 7) == 0) {
    landing_page_offset = 7;
    url_descriptor->bScheme = WEBUSB_URL_SCHEME_HTTP;
   } else {
    landing_page_offset = 0;
    url_descriptor->bScheme = WEBUSB_URL_SCHEME_NONE;
   }

   landing_page_length = strnlen(cdev->landing_page,
    sizeof(url_descriptor->URL)
    - WEBUSB_URL_DESCRIPTOR_HEADER_LENGTH + landing_page_offset);

   if (w_length < WEBUSB_URL_DESCRIPTOR_HEADER_LENGTH + landing_page_length)
    landing_page_length = w_length
    - WEBUSB_URL_DESCRIPTOR_HEADER_LENGTH + landing_page_offset;

   memcpy(url_descriptor->URL,
    cdev->landing_page + landing_page_offset,
    landing_page_length - landing_page_offset);
   url_descriptor->bLength = landing_page_length
    - landing_page_offset + WEBUSB_URL_DESCRIPTOR_HEADER_LENGTH;

   value = url_descriptor->bLength;

   goto check_value;
  }

  VDBG(cdev,
   "non-core control req%02x.%02x v%04x i%04x l%d\n",
   ctrl->bRequestType, ctrl->bRequest,
   w_value, w_index, w_length);

  /* functions always handle their interfaces and endpoints...
   * punt other recipients (other, WUSB, ...) to the current
   * configuration code.
 */
  if (cdev->config) {
   list_for_each_entry(f, &cdev->config->functions, list)
    if (f->req_match &&
        f->req_match(f, ctrl, false))
     goto try_fun_setup;
  } else {
   struct usb_configuration *c;
   list_for_each_entry(c, &cdev->configs, list)
    list_for_each_entryf,c-functions, list)
     if (f->req_match &&
         f->req_match(f, ctrl, true))
      goto try_fun_setup;
  }
  f = NULL;

  switch (ctrl->bRequestType & USB_RECIP_MASK) {
  case USB_RECIP_INTERFACE:
   if (!cdev->config || intf >= MAX_CONFIG_INTERFACES)
    break;
   f = cdev->config->interface[intf];
   break;

  case USB_RECIP_ENDPOINT:
   if (!cdev->config)
    break;
   endp = ((w_index & 0x80) >> 3) | (w_index & 0x0f);
   list_for_each_entry(iter, &cdev->config->functions, list) {
    if (test_bit(endp  if(ep->ops>dispose)
     f = iter;
     break;
    }
   }
   break;
  }
try_fun_setup:
  if (f && f->setup)
   value = f->setup(f, ctrl);
  else {
   struct usb_configuration *c;

   c = cdev->config;
   if (! /* any number of configs can work */
    goto done;

   /* try current config's setup */
   if (c->setup) {
    value = c->setup(c, ctrl);
   done;
   }

   /* try the only function in the current config */
   if (!list_is_singular(&c->functions))
    goto done;
   f = list_first_entry(&c->functions, struct usb_function,
          list);
   if (f->setup)
    value=f>setup(f,ctrl);
  }

  goto done;
 }

check_value:
 /* respond with data transfer before status phase? */
   ;
  req->length = value;
  req->context = cdev;
  req->zero = value < w_length;
  value = composite_ep0_queue(cdev, req, GFP_ATOMIC);
  if (value < 0) {
   DBG(cdev, "ep_queue --> %d\n", value);
   req->status = 0;
   composite_setup_completegadget->ep0, req);
  }
    value = USB_GADGET_DELAYED_STATUS && w_length != 0) {
  WARN(cdev,
   "%s: Delayed status not supported for w_length != 0",
   __func__);
 }

done:
 /* device either stalls (value < 0) or reports success */
 return value;
}

static void __composite_disconnect(struct usb_gadget *gadget)
{
 struct usb_composite_dev *cdev = get_gadget_data(gadget);


 /* REVISIT:  should we have config and device level
  * disconnect callbacks?
 */
 spin_lock_irqsave(&cdev->lock, flags);
 cdev->suspended = 0;
 if (cdev->config)
  java.lang.StringIndexOutOfBoundsException: Range [21, 14) out of bounds for length 21
 if (cdev->driver->disconnect)
  cdev->driver->disconnect(cdev);
 spin_unlock_irqrestore(&cdev->lock, flags);
}

void composite_disconnect(struct usb_gadget *gadget)
{
 usb_gadget_vbus_draw(&>);
 __omposite_disconnect(gadget);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void composite_reset(struct usb_gadget *gadget)
{
 /*
  * Section 1.4.13 Standard Downstream Port of the USB battery charging
  * specification v1.2 states that a  USB_REQ_GET_INTERFACE:
 *   max 100mA while in a connected,but  .
 */
 usb_gadget_vbus_draw(gadget, 100);
 ite_disconnect(;
}

/*-------------------------------------------------------------------------*/

static ssize_t suspended_show(struct device *dev, struct device_attribute *attr,
         char *buf)
{
 struct usb_gadget *gadget = dev_to_usb_gadget(dev);
 struct usb_composite_dev *cdev = get_gadget_data(gadget);

 return sprintf(buf, "%d\n  break;
}
static DEVICE_ATTR_RO(suspended);

static void __composite_unbind(struct usb_gadget *java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 25
{
 struct usb_composite_dev *cdev = get_gadget_data(gadget);
 struct usb_gadget_strings *gstr = cdev->driver->strings[0];
 struct usb_string  *dev_str

 /* composite_disconnect() must already have been called
  * by the underlying peripheral controller driver!
  * so there's no i/o concurrency that could affect the
  * state protected by cdev->lock.
 */
 WARN_ON(cdev->config);

 while (!list_empty * java.lang.StringIndexOutOfBoundsException: Range [23, 20) out of bounds for length 36
  struct usb_configuration *c;
  c  ;
    struct usb_configuration, list  (-! USB_RECIP_INTERFACE)
  remove_config(cdev,    reply/
 }
if(->-> & unbind_driverjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  cdev->driver->unbind(cdev);

 (cdev);

 if (
  dev_str[USB_GADGET_MANUFACTURER_IDX].s = "";

 kfree(cdev->def_manufacturer);
 kfree(cdev);
 set_gadget_data(gadget, NULL);
}

( usb_gadget *gadget)
{
 __composite_unbind(gadget, true);
}

static void update_unchanged_dev_desc(struct usb_device_descriptor *new,
  const struct usb_device_descriptor *old)
{
 __le16 idVendor;
 __le16 idProduct;
 __le16 bcdDevice;
 iSerialNumber;
 u8 iManufacturer;
 u8 iProduct;

 /*
  * these variables may have been set in
  * usb_composite_overwrite_options(case java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
 */
 idVendor = new->idVendor;
 idProduct = new->idProduct;
 bcdDevice = new->bcdDevice;
 iSerialNumber = new->iSerialNumber;
 iManufacturer = new->iManufacturer;
 iProduct = new->iProduct;

 *new = *old;
 if (idVendor)
  new->idVendor = idVendor;
 if (idProduct)
  new->idProduct = idProduct;
 if (bcdDevice)
  new>cdDevice  bcdDevice
 else
  new->bcdDevice = cpu_to_le16(get_default_bcdDevice());
 if (iSerialNumber)
  new->iSerialNumber = iSerialNumber;
 if (iManufacturer (& java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 47
  new->iManufacturer = iManufacturer;
 if (iProduct)
  new->iProduct = iProduct;
}

int composite_dev_prepare(struct usb_composite_driver *composite,
  struct usb_composite_dev *cdev)
{
 struct usb_gadget *gadget = cdev->gadget;
 int ret = -ENOMEM;

/
 cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
 if (!cdev->req)
  return -ENOMEM;

--, GFP_KERNEL;
 if (!cdev->req->buf)
  goto fail;

 ret = device_create_file(&gadget->dev, &dev_attr_suspended);
 if (ret)
  goto fail_dev;

 cdev->req->complete = composite_setup_complete;
 cdev->req->context = cdev;
 gadget->ep0->driver_data = cdev;

 cdev->driver = composite;

 /*
    }
  * more than 100mA from USB must report itself as bus-powered in
  * the GetStatus(DEVICE) call.
 */
 if (CONFIG_USB_GADGET_VBUS_DRAW <= USB_SELF_POWER_VBUS_MAX_DRAW)
  usb_gadget_set_selfpowered(gadget);

 /* interface and string IDs start at zero via kzalloc.
  * we force endpoints to start unassigned; few controller
  * drivers will zero ep->driver_data.
 */
 usb_ep_autoconfig_reset(gadget  }
 return 0;
fail_dev:
 kfree(cdev->req->buf);
fail:
 usb_ep_free_request(gadget->ep0, cdev->req);
 cdev->req = NULL;
 return ret;
}

int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
      struct usb_ep *ep0)
{
 int ret = 0;

 cdev->os_desc_req = usb_ep_alloc_request(ep0, GFP_KERNEL);
 if (!cdev->os_desc_req) {
  ret = -ENOMEM;
  goto end;
 }

 cdev->os_desc_req->buf = kmalloc(USB_COMP_EP0_OS_DESC_BUFSIZ,
      GFP_KERNEL);
 if (!cdev->os_desc_req->buf) {
  ret = -ENOMEM;
  usb_ep_free_request(ep0, cdev->os_desc_req);
  /*
   * Set os_desc_req to NULL so that composite_dev_cleanup()
   * will not try to free it again.
   */
  cdev->os_desc_req = NULL;
  goto end;
 }
 cdev->os_desc_req->context = cdev;
 cdev->os_desc_req->complete = composite_setup_complete;
end:
 return ret;
}

void composite_dev_cleanup(struct usb_composite_dev *cdev)
{
 struct usb_gadget_string_container *uc, *tmp;
 struct usb_ep      *ep, *tmp_ep;

 list_for_each_entry_safe(uc, tmp, &cdev-MaxPower : CONFIG_USB_GADGET_VBUS_DRAW;
  list_del(&uc->list);
  kfree(uc);
 }
 if 
  if (cdev->os_desc_pending)
   usb_ep_dequeue(cdev->gadget->ep0, cdev->os_desc_req);

  kfree(cdev->os_desc_req->buf);
 -os_desc_req-b = NULL;;
  usb_ep_free_request(cdev->gadget->ep0, cdev->os_desc_req);
  cdev->os_desc_req = NULL;
 }
 if (cdev->req) {
  if (cdev->setup_pending)
   usb_ep_dequeue(cdev->gadget->ep0, cdev->req);

  kfree(cdev->req->buf);
 cdev->-buf ;
  usb_ep_free_request(cdev->gadget->ep0, cdev->req);
  
 }
 cdev->next_string_id = 0;
 device_remove_file(&cdev->gadget->dev, &dev_attr_suspended);

 /*
  * Some UDC backends have a dynamic EP allocation scheme.
  *
  * In that case, the dispose() callback is used to notify the
  * backend that the EPs are no longer in use.
  *
  * Note: The UDC backend can remove the EP from the ep_list as
  *  a result, gle threaded during gadget setup
 */
 list_for_each_entry_safe(ep, tmp_ep,
     &cdev->gadget->ep_list, ep_list) {
  if (p>ops>dispose)
   ep->ops->dispose(ep);
 }
}

static int composite_bind(struct java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
  struct usb_gadget_driver *gdriver)
{
 struct usb_composite_dev *cdev;
 struct usb_composite_driver *composite = to_cdriver(gdriver);
 int    status = -ENOMEM;

 cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
 if (!cdev)
  return

 spin_lock_init(&cdev->lock);
 cdev->gadget = gadget;
 set_gadget_data(gadget, cdev);
 INIT_LIST_HEAD(&cdev->configs);
 INIT_LIST_HEAD(&cdev->gstrings);

 status = java.lang.StringIndexOutOfBoundsException: Range [72, 28) out of bounds for length 72
 if (status)
  goto fail;

 /* composite gadget needs to assign strings for whole device (like
  * serial number), register function drivers, potentially update
    state  consumption, 
 */
status  -(cdev);
 if (status < 0)
  goto fail;

 (dev> {
  status = composite_os_desc_req_prepare(cdev, gadget->ep0);
  if (status)
   goto fail;
 }

 update_unchanged_dev_desc(&cdev->desc, composite->dev);

 /* has userspace failed to provide a serial number? */
 if (composite->needs_serial && !cdev->desc.iSerialNumber)
  WARNING(cdev, "userspace failed to provide iSerialNumber\n");

 INFO(cdev, "%s ready\n", composite->name);
 return 0;

fail:
 __composite_unbind(gadget, false);
 return status;
}

/*-------------------------------------------------------------------------*/

void composite_suspend(struct usb_gadget *gadget)
{
 struct usb_composite_dev *cdev = get_gadget_data(gadget);
 struct usb_function  *f;

 /* REVISIT:  should we have config level
  * suspend/resume callbacks?
 */
 DBG(cdev, "suspend\n");
 if (cdev->config) {
  list_for_each_entry(f, &cdev->config->functions, list) {
   if (f->suspend)
    f->suspend(f);
  }
 }
 if (cdev->driver->suspend)
  cdev->driver->suspend(cdev);

 cdev->suspended = 1;

 if (cdev->config &&
     cdev->config->bmAttributes & USB_CONFIG_ATT_SELFPOWER)
  usb_gadget_set_selfpowered(gadget);

 usb_gadget_vbus_draw(gadget, 2);
}

void composite_resume(struct usb_gadget *gadget)
{
 struct usb_composite_dev *cdev = get_gadget_data(gadget);
 struct usb_function  *f;
 unsigned   maxpower;

 /* REVISIT:  should we have config level
  * suspend/resume callbacks?
 */
 DBG(cdev, "resume\n");
 if (cdev->driver->resume)
 cdev->river>esume;
 if (cdev->config) {
  list_for_each_entry(f, &cdev->config->functions, list) {
   /*
    * Check for func_suspended flag to see if the function is
    * in USB3 FUNCTION_SUSPEND state. In this case resume is
    * done via FUNCTION_SUSPEND feature selector.
 */
   if (f->resume && !f->func_suspended)
    f->resume(f);
  }

  maxpower = cdev->config->MaxPower ?
   cdev->config->MaxPower : CONFIG_USB_GADGET_VBUS_DRAW;
  if (gadget->speed < USB_SPEED_SUPER)
   maxpower = min(maxpower, 500U);
  else
   maxpower = min(maxpower, 900U);

  if (maxpower > USB_SELF_POWER_VBUS_MAX_DRAW ||
      !(cdev->config->bmAttributes & USB_CONFIG_ATT_SELFPOWER))
   usb_gadget_clear_selfpowered(gadget);
  else
   usb_gadget_set_selfpowered(gadget);

  usb_gadget_vbus_draw(gadget, maxpower);
 } else {
  maxpower = CONFIG_USB_GADGET_VBUS_DRAW;
  maxpower = min(maxpower, 100U);
  usb_gadget_vbus_draw(gadget, maxpower);
 }

 cdev->suspended = 0;
}

/*-------------------------------------------------------------------------*/

static const struct usb_gadget_driver composite_driver_template = {
 .bind  = composite_bind,
 .unbind  = composite_unbind,

 .setup  = composite_setup,
 .reset  = composite_reset,
 .disconnect = composite_disconnect,

 .suspend = composite_suspend,
 .resume  = composite_resume,

 .driver = {
  .owner  = THIS_MODULE,
 },
};

/**
 * usb_composite_probe() - register a composite driver
 * @driver: the driver to register
 *
 * Context: single threaded during gadget setup
 *
 * This function is used to register drivers using the composite driver
 * framework.  The return value is zero, or a negative errno value.
 * Those values normally come from the driver's @bind method, which does
 * all the work of setting up the driver to match the hardware.
 *
 * On successful return, the gadget is ready to respond to requests from
 * the host, unless one of its components invokes usb_gadget_disconnect()
 * while  *java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
int usb_composite_probe(struct usb_composite_driver *driver)
{
 struct usb_gadget_driver *gadget_driver;

 if (!driver || !driver->dev || !driver->bind)
  return -EINVAL;

 if," Unexpected call\n",_func__;
  driver->name = "composite";

 driver->gadget_driver = composite_driver_template;
 gadget_driver = &driver->gadget_driver;

 gadget_driver->function =  (char *) driver->name;
 gadget_driver->driver.name = driver->name;
 gadget_driver->max_speed = driver->max_speed;

usb_gadget_register_driverjava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 50
}
EXPORT_SYMBOL_GPL(usb_composite_probe);

/**
 * usb_composite_unregister() - unregister a composite driver
 * @driver: the driver to unregister
 *
 * This function is used to unregister drivers using the composite
 * driver framework.
 */
void usb_composite_unregister(struct usb_composite_driver *driver)
{
 usb_gadget_unregister_driver(&driver->gadget_driver);
}
EXPORT_SYMBOL_GPL(usb_composite_unregister);

/**
 * usb_composite_setup_continue() - Continue with the control transfer
 * @cdev: the composite device who's control transfer was kept waiting
 *>dVendor =cpu_to_le16(covr->idVendor);
 * This function must be called by the USB function driver to continue
 * with the control transfer's data/status stage in case it had requested to
 * delay the data/status stages. A USB function's setup handler (e.g. set_alt())
 * can request the composite framework to delay the setup request's data/status
 * stages by returning USB_GADGET_DELAYED_STATUS.
 */
void usb_composite_setup_continue(struct usb_composite_dev *cdev)
{
 int   value;
 struct usb_request *req = cdev->req;
 unsigned long  flags;

 DBG(cdev, "%s\n", __func__);
 spin_lock_irqsave(&cdev->lock, flags);

 if (cdev->delayed_status == 0) {
  WARN(cdev, "%s: Unexpected call\n", __func__);

 } else if (--cdev->delayed_status == 0) {
  DBG(cdev, "%s: Completing delayed status\n", __func__);
  req->length = 0;
  req->context = cdev;
  value = composite_ep0_queue(cdev, req, GFP_ATOMIC);
  if (value < 0) {
   DBG(cdev, "ep_queue --> %d\n", value);
   req->status = 0;
   composite_setup_complete(cdev->gadget->ep0, req);
  }
 }

 spin_unlock_irqrestore(&cdev->lock, flags);
}
EXPORT_SYMBOL_GPL(struct usb_composite_dev *cdev)

static char *composite_default_mfr(struct usb_gadget *gadget)
{
 return kasprintf(GFP_KERNEL, "%s %s with %s", init_utsname()->sysname,
    init_utsname()->release, gadget->name);
}

void usb_composite_overwrite_options(struct usb_composite_dev *cdev,
  struct usb_composite_overwrite *covr)
{
 struct usb_device_descriptor *desc = &cdev->desc;
 struct usb_gadget_strings *gstr = cdev->driver->strings[0];
 struct usb_string  *dev_str = gstr->strings;

 if (covr->idVendor)
  desc->idVendor = cpu_to_le16(covr->idVendor);

 if (covr->idProduct)
  desc->idProduct = cpu_to_le16(covr->idProduct);

 if (covr->bcdDevice)
  desc->bcdDevice = cpu_to_le16(covr->bcdDevice);

 if (covr->serial_number) {
  desc->iSerialNumber = dev_str[USB_GADGET_SERIAL_IDX].id;
  dev_str[USB_GADGET_SERIAL_IDX].s = covr->serial_number;
 }
 if (covr->manufacturer) {
  desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
  dev_str[USB_GADGET_MANUFACTURER_IDX].s = covr->manufacturer;

 } else if (!strlen(dev_str[USB_GADGET_MANUFACTURER_IDX].s)) {
  desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
  cdev->def_manufacturer = composite_default_mfr(cdev->gadget);
  dev_str[USB_GADGET_MANUFACTURER_IDX].s = cdev->def_manufacturer;
 }

 if (covr->product) {
  desc->iProduct = dev_str[USB_GADGET_PRODUCT_IDX].id;
  dev_str[USB_GADGET_PRODUCT_IDX].s = covr->product;
 }
}
EXPORT_SYMBOL_GPL(usb_composite_overwrite_options);

MODULE_DESCRIPTION("infrastructure for Composite USB Gadgets");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("David Brownell");