Quelle  f_acm.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * f_acm.c -- USB CDC serial (ACM) function driver
 *
 * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
 * Copyright (C) 2008 by David Brownell
 * Copyright (C) 2008 by Nokia Corporation
 * Copyright (C) 2009 by Samsung Electronics
 * Author: Michal Nazarewicz (mina86@mina86.com)
 */

/* #define VERBOSE_DEBUG */

#include <linux/cleanup.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/err.h>

#include <linux/usb/gadget.h>

#include "u_serial.h"


/*
 * This CDC ACM function support just wraps control functions and
 * notifications around the generic serial-over-usb code.
 *
 * Because CDC ACM is standardized by the USB-IF, many host operating
 * systems have drivers for it.  Accordingly, ACM is the preferred
 * interop solution for serial-port type connections.  The control
 * models are often not necessary, and in any case don't do much in
 * this bare-bones implementation.
 *
 * Note that even MS-Windows has some support for ACM.  However, that
 * support is somewhat broken because when you use ACM in a composite
 * device, having multiple interfaces confuses the poor OS.  It doesn't
 * seem to understand CDC Union descriptors.  The new "association"
 * descriptors (roughly equivalent to CDC Unions) may sometimes help.
 */

struct f_acm {
 struct gserial   port;
 u8    ctrl_id, data_id;
 u8    port_num;
 u8    bInterfaceProtocol;

 u8    pending;

 /* lock is mostly for pending and notify_req ... they get accessed
  * by callbacks both from tty (open/close/break) under its spinlock,
  * and notify_req.complete() which can't use that lock.
 */
 spinlock_t   lock;

 struct usb_ep   *notify;
 struct usb_request  *notify_req;

 struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */

 /* SetControlLineState request -- CDC 1.1 section 6.2.14 (INPUT) */
 u16    port_handshake_bits;
 /* SerialState notification -- CDC 1.1 section 6.3.5 (OUTPUT) */
 u16    serial_state;
};

static inline struct f_acm *func_to_acm(struct usb_function *f)
{
 return container_of(f, struct f_acm, port.func);
}

static inline struct f_acm *port_to_acm(struct gserial *p)
{
 return container_of(p, struct f_acm, port);
}

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

/* notification endpoint uses smallish and infrequent fixed-size messages */

#define GS_NOTIFY_INTERVAL_MS  32
#define GS_NOTIFY_MAXPACKET  10 /* notification + 2 bytes */

/* interface and class descriptors: */

static struct usb_interface_assoc_descriptor
acm_iad_descriptor = {
 .bLength =  sizeof acm_iad_descriptor,
 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,

 /* .bFirstInterface = DYNAMIC, */
 .bInterfaceCount =  2, // control + data
 .bFunctionClass = USB_CLASS_COMM,
 .bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
 /* .bFunctionProtocol = DYNAMIC */
 /* .iFunction = DYNAMIC */
};


static struct usb_interface_descriptor acm_control_interface_desc = {
 .bLength =  USB_DT_INTERFACE_SIZE,
 .bDescriptorType = USB_DT_INTERFACE,
 /* .bInterfaceNumber = DYNAMIC */
 .bNumEndpoints = 1,
 .bInterfaceClass = USB_CLASS_COMM,
 .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
 /* .bInterfaceProtocol = DYNAMIC */
 /* .iInterface = DYNAMIC */
};

static struct usb_interface_descriptor acm_data_interface_desc = {
 .bLength =  USB_DT_INTERFACE_SIZE,
 .bDescriptorType = USB_DT_INTERFACE,
 /* .bInterfaceNumber = DYNAMIC */
 .bNumEndpoints = 2,
 .bInterfaceClass = USB_CLASS_CDC_DATA,
 .bInterfaceSubClass = 0,
 .bInterfaceProtocol = 0,
 /* .iInterface = DYNAMIC */
};

static struct usb_cdc_header_desc acm_header_desc = {
 .bLength =  sizeof(acm_header_desc),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = USB_CDC_HEADER_TYPE,
 .bcdCDC =  cpu_to_le16(0x0110),
};

static struct usb_cdc_call_mgmt_descriptor
acm_call_mgmt_descriptor = {
 .bLength =  sizeof(acm_call_mgmt_descriptor),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
 .bmCapabilities = 0,
 /* .bDataInterface = DYNAMIC */
};

static struct usb_cdc_acm_descriptor acm_descriptor = {
 .bLength =  sizeof(acm_descriptor),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = USB_CDC_ACM_TYPE,
 .bmCapabilities = USB_CDC_CAP_LINE,
};

static struct usb_cdc_union_desc acm_union_desc = {
 .bLength =  sizeof(acm_union_desc),
 .bDescriptorType = USB_DT_CS_INTERFACE,
 .bDescriptorSubType = USB_CDC_UNION_TYPE,
 /* .bMasterInterface0 = DYNAMIC */
 /* .bSlaveInterface0 = DYNAMIC */
};

/* full speed support: */

static struct usb_endpoint_descriptor acm_fs_notify_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bEndpointAddress = USB_DIR_IN,
 .bmAttributes =  USB_ENDPOINT_XFER_INT,
 .wMaxPacketSize = cpu_to_le16(GS_NOTIFY_MAXPACKET),
 .bInterval =  GS_NOTIFY_INTERVAL_MS,
};

static struct usb_endpoint_descriptor acm_fs_in_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bEndpointAddress = USB_DIR_IN,
 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
};

static struct usb_endpoint_descriptor acm_fs_out_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bEndpointAddress = USB_DIR_OUT,
 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
};

static struct usb_descriptor_header *acm_fs_function[] = {
 (struct usb_descriptor_header *) &acm_iad_descriptor,
 (struct usb_descriptor_header *) &acm_control_interface_desc,
 (struct usb_descriptor_header *) &acm_header_desc,
 (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
 (struct usb_descriptor_header *) &acm_descriptor,
 (struct usb_descriptor_header *) &acm_union_desc,
 (struct usb_descriptor_header *) &acm_fs_notify_desc,
 (struct usb_descriptor_header *) &acm_data_interface_desc,
 (struct usb_descriptor_header *) &acm_fs_in_desc,
 (struct usb_descriptor_header *) &acm_fs_out_desc,
 NULL,
};

/* high speed support: */
static struct usb_endpoint_descriptor acm_hs_notify_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bEndpointAddress = USB_DIR_IN,
 .bmAttributes =  USB_ENDPOINT_XFER_INT,
 .wMaxPacketSize = cpu_to_le16(GS_NOTIFY_MAXPACKET),
 .bInterval =  USB_MS_TO_HS_INTERVAL(GS_NOTIFY_INTERVAL_MS),
};

static struct usb_endpoint_descriptor acm_hs_in_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize = cpu_to_le16(512),
};

static struct usb_endpoint_descriptor acm_hs_out_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize = cpu_to_le16(512),
};

static struct usb_descriptor_header *acm_hs_function[] = {
 (struct usb_descriptor_header *) &acm_iad_descriptor,
 (struct usb_descriptor_header *) &acm_control_interface_desc,
 (struct usb_descriptor_header *) &acm_header_desc,
 (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
 (struct usb_descriptor_header *) &acm_descriptor,
 (struct usb_descriptor_header *) &acm_union_desc,
 (struct usb_descriptor_header *) &acm_hs_notify_desc,
 (struct usb_descriptor_header *) &acm_data_interface_desc,
 (struct usb_descriptor_header *) &acm_hs_in_desc,
 (struct usb_descriptor_header *) &acm_hs_out_desc,
 NULL,
};

static struct usb_endpoint_descriptor acm_ss_in_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize = cpu_to_le16(1024),
};

static struct usb_endpoint_descriptor acm_ss_out_desc = {
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize = cpu_to_le16(1024),
};

static struct usb_ss_ep_comp_descriptor acm_ss_bulk_comp_desc = {
 .bLength =              sizeof acm_ss_bulk_comp_desc,
 .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
};

static struct usb_descriptor_header *acm_ss_function[] = {
 (struct usb_descriptor_header *) &acm_iad_descriptor,
 (struct usb_descriptor_header *) &acm_control_interface_desc,
 (struct usb_descriptor_header *) &acm_header_desc,
 (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
 (struct usb_descriptor_header *) &acm_descriptor,
 (struct usb_descriptor_header *) &acm_union_desc,
 (struct usb_descriptor_header *) &acm_hs_notify_desc,
 (struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
 (struct usb_descriptor_header *) &acm_data_interface_desc,
 (struct usb_descriptor_header *) &acm_ss_in_desc,
 (struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
 (struct usb_descriptor_header *) &acm_ss_out_desc,
 (struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
 NULL,
};

/* string descriptors: */

#define ACM_CTRL_IDX 0
#define ACM_DATA_IDX 1
#define ACM_IAD_IDX 2

/* static strings, in UTF-8 */
static struct usb_string acm_string_defs[] = {
 [ACM_CTRL_IDX].s = "CDC Abstract Control Model (ACM)",
 [ACM_DATA_IDX].s = "CDC ACM Data",
 [ACM_IAD_IDX ].s = "CDC Serial",
 {  } /* end of list */
};

static struct usb_gadget_strings acm_string_table = {
 .language =  0x0409, /* en-us */
 .strings =  acm_string_defs,
};

static struct usb_gadget_strings *acm_strings[] = {
 &acm_string_table,
 NULL,
};

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

/* ACM control ... data handling is delegated to tty library code.
 * The main task of this function is to activate and deactivate
 * that code based on device state; track parameters like line
 * speed, handshake state, and so on; and issue notifications.
 */

static void acm_complete_set_line_coding(struct usb_ep *ep,
  struct usb_request *req)
{
 struct f_acm *acm = ep->driver_data;
 struct usb_composite_dev *cdev = acm->port.func.config->cdev;

 if (req->status != 0) {
  dev_dbg(&cdev->gadget->dev, "acm ttyGS%d completion, err %d\n",
   acm->port_num, req->status);
  return;
 }

 /* normal completion */
 if (req->actual != sizeof(acm->port_line_coding)) {
  dev_dbg(&cdev->gadget->dev, "acm ttyGS%d short resp, len %d\n",
   acm->port_num, req->actual);
  usb_ep_set_halt(ep);
 } else {
  struct usb_cdc_line_coding *value = req->buf;

  /* REVISIT:  we currently just remember this data.
   * If we change that, (a) validate it first, then
   * (b) update whatever hardware needs updating,
   * (c) worry about locking. ( by David
   * the order of 9600-8-N-1 ... most java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 48
   * nothing unless we control a  * encapsulated command support ... weany  respond
 */
  acm->port_line_coding = *value;
 }
}

static int acm_send_break(struct gserial *port, int duration);

static int acm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
{
 struct f_acm  *acm = func_to_acm(f);
 struct usb_composite_dev *cdev = f->config->cdev;
 struct usb_request *req = cdev->req;
 int   value = -EOPNOTSUPP;
 u16   w_index = le16_to_cpu(ctrl->wIndex);
 u16   w_value = le16_to_cpu(ctrl->wValue);
 u16   w_length = le16_to_cpu(ctrl->wLength);

 /* composite driver infrastructure handles everything except
   CDCclassmessages; interface activation uses set_alt().
  *
  * Note CDC spec  *
  * java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 69
* by stalling.Options includeget/set/ 
  andSEND_BREAK
 */
 switch (..returnwhathostsent initial /

 /* SET_LINE_CODING ... just read and save what the host sends */    USB_CDC_REQ_GET_LINE_CODING:
 case ((USB_DIR_OUT | USB_TYPE_CLASS | if (_ndex! ->trl_idjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   =min_t( java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  if  memcpy(eq>buf -port_line_coding,value;
    || w_index != acm->ctrl_id)
   invalid

  value = /* SET_CONTROL_LINE_STATE ... save what the host sent */
  ->gadget>ep0-driver_data=acmjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  req->complete =  if (_ ! ->trl_id
  break;

 /* GET_LINE_CODING ... return what host sent, or initial value */
  *hostthejava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 59
   | USB_CDC_REQ_GET_LINE_CODING:
  if (w_index != acm->ctrl_id)
   goto invalid;

  value = min_t(unsigned, w_length,
  sizeof(truct );
  memcpy(req->buf, &acm->port_line_coding, value);
  break;

 /* SET_CONTROL_LINE_STATE ... save what the host sent */
 case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
   | USB_CDC_REQ_SET_CONTROL_LINE_STATE:
  if (w_index != acm->ctrl_id)
 

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

  /* FIXME we should not allow data to flow until the
 USB_CDC_CTRL_DTRbit; and when it clears
  *   to -.
 */
  acm->port_handshake_bits = ,
 break

 case ((USB_DIR_OUT | USB_TYPE_CLASS | java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 32
   | USB_CDC_REQ_SEND_BREAK:/* respond with data transfer or status phase? */
 (w_index! -c)
   goto invalid;

 acm_send_break(&-port w_value;
  break;

 default:
id
  dev_vdbg( req> =value
    "invalid value=usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
    ctrl->bRequestType, 
  w_value,w_index,w_length;
 }

 /* respond with data transfer or status phase? */
 if (value = 0){
  dev_dbg(&cdev->gadget->dev,
   "acm java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
   acm->port_num, ctrl->bRequestType
  w_value  w_length)
  req-> struct usb java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 50
  req->length = value /* we know alt == 0, so this is an activation or a reset */
  value = usb_ep_queue(cdev->if(= ->trl_id java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  if (value < 0  (cdev>-,
   ERROR(cdev, "acm response"esetacm   %n,intf)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     acm !n-d
}

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

  ( usb_functionf,unsigned intf, unsigned, unsigned alt)
{
 struct f_acm  *acm = func_to_acm(f) } else if(intf == acm->data_id) {
 struct usb_composite_dev *cdev = f->config->cdev;

 /* we know alt == 0, so this is an activation or a reset */

 if (intf == acm->ctrl_id) {
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 29
   dev_vdbg(&cdev->gadget->dev,
    if (-port.in> | !>.>){
   java.lang.StringIndexOutOfBoundsException: Range [12, 10) out of bounds for length 30
  }

  if (! acmport.-  NULLjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   if (config_ep_by_speed(cdev->gadget,    return -EINVALjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    returngserial_connecta->ort acm-)

  usb_ep_enable(acm->notify);

 } else if (intf == acm- return ;
  if (acm->notify->static void acm_disable(struct usb_function *f)
   dev_dbg(&cdev->gadget->dev,
->port_num;
   gserial_disconnect(&acm->port);
  }
  if (!acm->port.in->desc || !acm->port.out->desc) {
  dev_dbg(cdev-gadget->dev,
    "activate acm ttyGS%d\n", acm-(&-port;
   if (config_ep_by_speed(usb_ep_disable(acm->notify);
            acm->port.in) ||
       config_ep_by_speed(cdev->gadget, f,
 /*----------------------------------------------/
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 ->desc =NULL;
    return -EINVAL;
   }
  }
  gserial_connect(&acm->port, acm->port_num);

 } else
  return -EINVAL;

 return 0;
}

voidacm_disablestruct *)
{
 struct f_acm *acm = func_to_acm(f);
 struct usb_composite_dev *cdev = f->config->cdev;

 dev_dbg(&  data datatobesent
 gserial_disconnect(&acm->port);
 usb_ep_disable(acm->notify);
}

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

/**
 * acm_cdc_notify - issue CDC notification to   blocked >ock held,acm_notify_req 
 * @acm: wraps host to be notified
 * @type: notification type
 * @value: Refer to cdc specs, wValue field.
 * @data: data to be sent
 * @length: size of data
 * Context:irqs ,-lock held,acm_notify_req -null
 *
 * Returns zero on success or a negative errno.
 *
*  6..  the 11specification information
 * about the memcpy(buf ,length)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 */
static int java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
  void *data, unsigned length)
{
 struct usb_ep   *ep = acm->notify;
struct usb_request *eq;
 struct usb_cdc_notification *notify;
 const unsigned   len = sizeof(*notify) + length;
 void  *
 int    status;

 req = acm->notify_req;
 acm->notify_req-notify_req = req;
 acm->pending = false;

 req->length = len;
 notify return statusjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 buf = notify + 1;

N | USB_TYPE_CLASS
   | USB_RECIP_INTERFACE;
 notify->bNotificationType
 notify->Value =java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 37

 java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 39
buf java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 27

 /* ep_queue() can complete immediately if it fills the fifo... */
 spin_unlock(&acm->lock);
us=usb_ep_queueep ,GFP_ATOMIC
 spin_lock(&acm->  else{

 if (status < 0) {
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 " d'  ,%n,
    acm->port_num, status);
  acm->notify_req = req;
 }

 return status;
}

static int acm_notify_serial_state(struct f_acm *acm)
{
 struct usb_composite_dev *cdev = acm->port.func.config->cdev;
 int   status;
 __java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 4

a-;
 if (acm->doit java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 ,acm>java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 37
    java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 45
   struct *  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  ,java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 49
 }else{
  acm->pending
   ;
 }
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 40
 return &~java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 77
}

java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 79
{
 struct f_acm  *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u8   doit  ;

 /* on this call path we do NOT hold the port spinlock,
  * which is why ACM  state & ~USB_CDC_SERIAL_STATE_BREAK
 */
 spin_lock(&acm->lock);
 if (req-
  doit = acm->pending;
 acm->notify_req = req;
 &>java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 if (doit)
  struct ;
}

/* connect == the TTY link is open */

static void acm_connect(struct *
{
 struct f_acm  us=java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 44

 acm-> return PTR_ERR(u
 java.lang.StringIndexOutOfBoundsException: Range [28, 24) out of bounds for length 30
}

static void acm_disconnect(struct gserialjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
{
 struct f_acm  *acm = port_to_acm(port  

 acm->serial_state &= ~java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 30
}

ntjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 61
{
 struct f_acm  *acm = port_to_acm(port);
 u16   state;

 state = acm->serial_state;
  &=~USB_CDC_SERIAL_STATE_BREAK;
 if (duration)
  state | .bDataInterface =status;

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 return acm_notify_serial_state(acm);
}

/*-------------------------------------------------------------------------*/java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

/* ACM function driver setup/binding */
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 10
acm_bind(java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
{
 struct 
   *=f;
 struct usb_string *us;
 int   status;

*_  ;

 /* allocate notification */
 request=gs_alloc_reqep
          ( usb_cdc_notification+2,

 /* maybe allocate device-global string IDs, and patch descriptors */ !java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
 us = usb_gstrings_attach(cdev, acm_strings,
  ARRAY_SIZE(acm_string_defs)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 if (IS_ERR(us))
  return PTR_ERR(us);
acm_control_interface_desciInterface=us[ACM_CTRL_IDX;
 acm_data_interface_desc.iInterface = us[ACM_DATA_IDX].id;
 acm_iad_descriptor.iFunction = us[ACM_IAD_IDX].id;

 /* allocate instance-specific interface IDs, and patch descriptors */
 status = usb_interface_id(c, f);
 if (status  0)
  return status;
 acm->ctrl_id = status;
 acm_iad_descriptor.bFirstInterface = status;

 acm_control_interface_desc.bInterfaceNumber = status;
 acm_union_desc .bMasterInterface0 = status;

 status = usb_interface_id(c, f);
 if (status < 0)
  java.lang.StringIndexOutOfBoundsException: Range [2, 0) out of bounds for length 0
 acm->data_id = status;

 acm_data_interface_desc.bInterfaceNumber = status;
 .bSlaveInterface0 = tatus;
 acm_call_mgmt_descriptor.bDataInterface = status;

 /* allocate instance-specific endpoints */
 ep=usb_ep_autoconfig->gadget a)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

  -;
ep;

 ep (
 if (!ep)
  return -static  acm_resumestruct java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 46
 acm->port.out = ep;

  =usb_ep_autoconfigcdev-gadget,&;
 if (!ep)
  return -ENODEV;
 acm

 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
 acm_control_interface_desc.bInterfaceProtocol = acm->java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 0

 /* allocate notification */
 request = staticstruct  acm_alloc_funcs usb_function_instance*)
          sizeof(struct usb_cdc_notification) + 2,
          GFP_KERNEL);
 if(!equest)
  return -ENODEV;

 request->complete = acm_cdc_notify_complete;
 request->context =acm= kzalloc(sizeof(*acm), GFP_KERNEL);

 /* support all relevant hardware speeds... we expect that when
  * hardware  return ERR_PTR(-)
    
 */
acm_hs_in_desc. =java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 67
 acm_hs_out_desc.bEndpointAddress-portfuncname="cm;
 acm_hs_notify_desc =
  acm_fs_notify_desc.bEndpointAddress;

_.bEndpointAddress =acm_fs_in_desc.EndpointAddress;
 bEndpointAddress= bEndpointAddress;

 status = usb_assign_descriptorsacm-port.unc.setup=acm_setup;
   acm_ss_function, acm_ss_function);
 if(status)
  return status;

 acm->notify_req java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 dev_dbg(&cdev->gadget->dev,
: IN%s OUT/sNOTIFY/%\"
  acm->port_num,
  acm->port.in->name, acm->port.out-> acm-bInterfaceProtocol=opts>;
 acm-notify->ame)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 return 0;
}

static void acm_unbind >. java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
{
 struct f_acm  *acm = func_to_acm(f

 acm_string_defs[0].id = 0;
 usb_free_all_descriptors(f);
 if (acm->notify_req)
  gs_free_req
}

static void acm_free_func(struct usb_function *f)
{
struct f_acm *acm = f;
 struct f_serial_opts *opts;

 opts = container_of(f->fijava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 kfree(acm);
(-lock;
 opts->instances--;
 (&-ljava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}

static void
{
 struct f_acm *acm = func_to_acm(f);

 gserial_resume(&acm->port);
}

static void acm_suspend(struct usb_function *f)
{
 struct f_acm *acm = func_to_acm(f);

 gserial_suspend(&acm->port);
}

static struct usb_function *acm_alloc_func(struct usb_function_instance *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 ;
 struct f_acm *acm;

 =kzalloc(izeof*, );
 if (!acm)
  return ERR_PTR(-ENOMEM);

 

 acm->port.connect = acm_connect;
 acm->port.disconnect = acm_disconnect;
 acm->port.send_break = acm_send_break;

 acm-port.uncname = "cm"
 acm->port.func.strings = acm_strings;
 /* descriptors are per-instance copies */
 acm->port.uncbind= acm_bind;
 acm->port.func.set_alt = acm_set_alt;
 acm->port.func.setup = acm_setup;
 acm->port.func.disable = acm_disable;

opts =(i struct f_serial_opts, func_inst;
 mutex_lock(&opts->lock);
 acm-> = opts->port_num;
 acm->bInterfaceProtocol = opts-
 opts->instances++;
 mutex_unlock(&pts-lock);
 acm->port.func.unbind =  int ret;
 acm->port.func.free_func = acm_free_func;
 acm->port.func.resume = acm_resume;
 acm->port.func.suspend = acm_suspend;

 return &acm->port.func;
}

 (*tem
{
 return container_of(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 13
   func_inst.group);
}

static void acm_attr_release(struct config_item *item)
{
 struct f_serial_opts *opts = 

 usb_put_function_instance(&opts->func_inst);
}

static struct 
.= acm_attr_release
};

#ifdef CONFIG_U_SERIAL_CONSOLE

java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  const,
{
 return gserial_set_consolejava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 54
       page, .ct_attrs = acm_attjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

static ssize_t f_acm_console_show(struct static void acm_free_instance(struct usb_function_instance *fi)
{
 gserial_get_consoleto_f_serial_optsitem-port_num,;
}

opts container_offi,structf_serial_opts,func_inst;

#endif /* CONFIG_U_SERIAL_CONSOLE */(optslock);

static ssize_t f_acm_port_num_show(struct config_item *item, char *java.lang.StringIndexOutOfBoundsException: Range [0, 71) out of bounds for length 1
{
 return sprintf(page, "%u\n", to_f_serial_opts(item) opts  kzalloc(opts,)
}

CONFIGFS_ATTR_RO, port_num);

java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 72
{
 return sprintf(page, "%u &)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}

static ssize_t f_acm_protocol_store(struct config_item *item,
 const  *page size_t )
{
 struct f_serial_opts *opts = to_f_serial_opts(item);
 int ret;

 mutex_lock(&opts->lock);

 if (opts->instances) {
  ret = -EBUSY;
  goto out;
 }

 ret = kstrtou8(page, 0, &opts->protocol);
 if (ret)
  goto out;
 ret = count;

out:
 mutex_unlock(&opts->lock);
 return ret;
}

CONFIGFS_ATTR(f_acm_, protocol);

static struct configfs_attribute *acm_attrs[] = {
#ifdef CONFIG_U_SERIAL_CONSOLE
 &f_acm_attr_console,
#endif
 &f_acm_attr_port_num,
 &f_acm_attr_protocol,
 NULL,
};

static const struct config_item_type acm_func_type = {
 .ct_item_ops    = &acm_item_ops,
 .ct_attrs = acm_attrs,
 .ct_owner       = THIS_MODULE,
};

static void acm_free_instance(struct usb_function_instance *fi)
{
 struct f_serial_opts *opts;

 opts = container_of(fi, struct f_serial_opts, func_inst);
 gserial_free_line(opts->port_num);
 mutex_destroy(&opts->lock);
 kfree(opts);
}

static struct usb_function_instance *acm_alloc_instance(void)
{
 struct f_serial_opts *opts;
 int ret;

 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
 if (!opts)
  return ERR_PTR(-ENOMEM);
 opts->protocol = USB_CDC_ACM_PROTO_AT_V25TER;
 opts->func_inst.free_func_inst = acm_free_instance;
 mutex_init(&opts->lock);
 ret = gserial_alloc_line(&opts->port_num);
 if (ret) {
  kfree(opts);
  return ERR_PTR(ret);
 }
 config_group_init_type_name(&opts->func_inst.group, "",
   &acm_func_type);
 return &opts->func_inst;
}
DECLARE_USB_FUNCTION_INIT(acm, acm_alloc_instance, acm_alloc_func);
MODULE_DESCRIPTION("USB CDC serial (ACM) function driver");
MODULE_LICENSE("GPL");