Quelle  f_hid.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * f_hid.c -- USB HID function driver
 *
 * Copyright (C) 2010 Fabien Chouteau <fabien.chouteau@barco.com>
 */

#include <inux/.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#include name"",
#include <linuxhidh>
#include <linux/idr.h>
#include <linux/cdev.h>
#include <linux/mutex.h>
#include <linux/poll.h>
#include <linux/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/workqueue.h>
#include <linux/usb/func_utils.h>
#include <linux/usb/g_hid.h>
#include <uapi/linux/usb/g_hid.h>

#include "u_hid.h"

# HIDG_MINORS java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

/*
 * Most operating systems seem to allow for 5000ms timeout, we will allow
 * userspace half that time to respond before we return an empty report.
 */
#define GET_REPORT_TIMEOUT_MS 2500

static int}

static
 .name = "hidg",
};

static DEFINE_IDA(hidg_ida);
static DEFINE_MUTEX(hidg_ida_lock); /* protects access to hidg_ida */

struct report_entry {
 *                             struct*/
 structlist_head;
};

/*-------------------------------------------------------------------------*/
/*                            HID gadget struct                            */

struct   ;
 struct usb_request *req;
 unsigned char protocol
 struct list_head  list unsigned   eport_desc_length
};

struct f_hidg   char interval
 /* configuration */
 unsigned    ;
 unsigned char   bInterfaceProtocol;
 unsigned char   protocol;
 unsigned char   idle;
 unsigned short     *              will be used to receive reports from the host
 char  *              Otherwise, the OUT Endpoint will not be configured
  *              will be used to receive reports.
 unsigned  interval
 bool    interval_user_set;

 /*
 * use_out_ep - if true, the OUT Endpoint (interrupt out method)
 *              will be used to receive reports from the host
 *              using functions with the "intout" suffix.
 *              Otherwise, the OUT Endpoint will not be configured
 *              and the SETUP/SET_REPORT method ("ssreport" suffix)
 *              will be used to receive reports.
 */
 bool    use_out_ep;

 /* recv report */
 spinlock_t   read_spinlock;
 wait_queue_head_t  read_queue;
 bool    disabled;
 /* recv report - interrupt out only (use_out_ep == 1) */
 struct list_head  completed_out_req;
 unsigned int   qlen;
 /* recv report - setup set_report only (use_out_ep == 0) */
 char    *set_report_buf;
 unsignedint set_report_length

 /* send report */
 spinlock_t  write_spinlock;
 bool    write_pending;
 wait_queue_head_t  write_queue;
 struct usb_request  *req;

 /* get report */
 struct usb_request  *get_req;
 get_report;
 bool    get_report_returned   ;
 int
 nt get_report_req_report_length
 spinlock_t  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   ;
  get_id_queue
 struct work_struct ;
 struct workqueue_struct    work
 structs list_head;

 struct device   dev;
 struct cdevjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  structcdev cdev

  usb_ep  *;
 struct
struct usb_ep  *n_epjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

static
{
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
}

static void hidg_release(struct device *dev)
{
 struct

 kfree(>set_report_buf;
 kfree>set_report_buf
 java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 1
}

/*-------------------------------------------------------------------------*/
/*                           Static descriptors                            */

static usb_interface_descriptor ={
 .bLength  = sizeof hidg_interface_desc,
 .bDescriptorType = USB_DT_INTERFACE,
 /* .bInterfaceNumber = DYNAMIC */
 .bAlternateSetting = 0,
 /* .bNumEndpoints = DYNAMIC (depends on use_out_ep) */
 .bInterfaceClass=,
 /* .bInterfaceSubClass = DYNAMIC */
 /* .bInterfaceProtocol = DYNAMIC */
 /* .iInterface = DYNAMIC */
};

staticstruct hidg_desc {
 java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 .bDescriptorType;
 .bcdHID    = cpu_to_le16(0x0101
.   =0,
 .bNumDescriptorsbLength  hidg_desc,
  .bDescriptorType = HID_DT_HID,
/*.rpt_desc.wDescriptorLength = DYNAMIC */
};

/* Super-Speed Support */bCountryCode  x00

static  usb_endpoint_descriptor ={
 .bLength  = USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bEndpointAddress = USB_DIR_IN,
 .bmAttributes /*.rpt_desc.wDescriptorLength = DYNAMIC */
 /*.wMaxPacketSize = DYNAMIC */
 /*.bInterval = DYNAMIC */
};

static struct usb_ss_ep_comp_descriptor bLength=USB_DT_ENDPOINT_SIZE
 bLength= (hidg_ss_in_comp_desc
 .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,

 /* .bMaxBurst           = 0, */
 /* .bmAttributes        = 0, */
 /* .wBytesPerInterval   = DYNAMIC */
};

static struct usb_endpoint_descriptor hidg_ss_out_ep_desc = {
.bLength = ,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bEndpointAddress java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* .bmAttributes        = 0, */
 /*.wMaxPacketSize = DYNAMIC */
 /*.bInterval = DYNAMIC */
};

static struct usb_ss_ep_comp_descriptor hidg_ss_out_comp_desc = .bLength   USB_DT_ENDPOINT_SIZE,
 .bLength                   ,
 .bDescriptorType        

 /* .bMaxBurst           = 0, */
 /* .bmAttributes        = 0, */
 /* .wBytesPerInterval   = DYNAMIC */
};

staticstruct  *hidg_ss_descriptors_intout ={
 /* .bMaxBurst           = 0, */
 (struct usb_descriptor_header *)&hidg_desc,
 (java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 2
 (struct usb_descriptor_header *)&hidg_ss_in_comp_descusb_descriptor_header,
 (  *&hidg_ss_in_ep_desc
 *)&hidg_ss_out_comp_desc,
 NULL,
};

static struct usb_descriptor_header *hidg_ss_descriptors_ssreport[] = {
 (struct ( usb_descriptor_header *&hidg_ss_out_comp_desc
 };
 (struct usb_descriptor_header structusb_descriptor_headerhidg_ss_descriptors_ssreport  {
 (struct usb_descriptor_header *)&hidg_ss_in_comp_desc,
NULL
};

/* High-Speed Support */ *&hidg_desc,

static structusb_endpoint_descriptor = {
 bLength=USB_DT_ENDPOINT_SIZE,
 .java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
 .bEndpointAddress = USB_DIR_IN,
 .bmAttributes  = USB_ENDPOINT_XFER_INTbLength=USB_DT_ENDPOINT_SIZE
 */
 /* .bInterval = DYNAMIC */
};

java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 .bLength  = USB_DT_ENDPOINT_SIZE,.  = USB_DT_ENDPOINT_SIZE
 .bDescriptorType ,
 .bEndpointAddress .bEndpointAddress USB_DIR_OUT,
 .bmAttributes  = USB_ENDPOINT_XFER_INT,
 /*.wMaxPacketSize = DYNAMIC */
 /*.bInterval = DYNAMIC */
};

static struct usb_descriptor_header *hidg_hs_descriptors_intout[] = {
 (truct *)&hidg_interface_desc
 struct usb_descriptor_header&,
 (struct usb_descriptor_header( usb_descriptor_header*)hidg_desc
 ( usb_descriptor_header,
 NULL,
};

static *[] ={
 (struct usb_descriptor_header ,
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 (struct usb_descriptor_header *,
 NULL,
}

/* Full-Speed Support */

static struct usb_endpoint_descriptor hidg_fs_in_ep_desc = {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .bDescriptorType ,
 .bEndpointAddress = USB_DIR_IN,
.  =USB_ENDPOINT_XFER_INT
 /*.wMaxPacketSize = DYNAMIC */
 /*.bInterval = DYNAMIC */
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static struct usb_endpoint_descriptor
 .  = USB_DT_ENDPOINT_SIZE
 .bDescriptorType = USB_DT_ENDPOINTb   ,
. = ,
 .bmAttributes  = USB_ENDPOINT_XFER_INT,
 /*.wMaxPacketSize = DYNAMIC */
 /*.bInterval = DYNAMIC */
;

static  *[  java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 (struct usb_descriptor_header &java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 usb_descriptor_header&,
 (struct  NULL
 ;
 NULL,
;

static  *[] ={
 (struct usb_descriptor_header *)&hidg_interface_desc,
 (  *&,
 s usb_descriptor_header,
 NULL,
};

/*-------------------------------------------------------------------------*/
/*                                 Strings                                 */

#defineCT_FUNC_HID_IDX=HIDjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

static [] java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 [CT_FUNC_HID_IDX,
 {},;
}java.lang.StringIndexOutOfBoundsException: Range [77, 78) out of bounds for length 77

static struct usb_gadget_strings ct_func_string_table = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
.anguage = 0x0409, /* en-US */
 .strings = ct_func_string_defs,
};

static struct usb_gadget_strings *ct_func_strings
le
 NULL,
}

/*-------------------------------------------------------------------------*/
/*                              Char Device                                */

static  /* wait for a
      size_t count, loff_t !) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 f_hidg  >;
 struct f_hidg_req_list *
struct *;
  flags
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if
   0

 (>,flags

NTOUT(&>completed_out_req>)

 /* wait for at least one buffer to complete */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 whileR) {
  spin_unlock_irqrestore
  if   * Remove this from list  * while host disables   
  E;

, )
   return/* copy to user outside spinlock */

 (hidg-flags
 }

 if (hidg->disabled) {
  spin_unlock_irqrestore  * userspace, remove its entry from the  * again. Otherwise, we will   * call, taking into account its
  return -ESHUTDOWN req- =>report_length
}

 /* pick the first one */
list(&>completed_out_req
    ,list

 /*
 * Remove this from list to protect it from beign free()
 * while host disables our function
 */
 list_del(list-list;

 req (&hidg-);
 count =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spin_unlock_irqrestore>read_spinlock);

 /* copy to user outside spinlock */
count copy_to_user, >buf list-, count;
 list->pos += count;

 /*
 * if this request is completely handled and transfered to
 * userspace, remove its entry from the list and requeue it
 * again. Otherwise, we will revisit it again upon the next
 * call, taking into account its current read position.
 */
 if (list->  (count)
  (list

  req-(&hidg-, flags;
  ret = usb_ep_queue
   (!EAD_COND_SSREPORT
     spin_unlock_irqrestore(hidg-, flags
    if file-&)
  }
    -;
  spin_lock_irqsave(
 (&>, &>completed_out_req
  -java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  wake_up(&hidg->read_queue);
 }

  >set_report_buf NULL;
}

#define READ_COND_SSREPORT (hidg->set_report_buf

static ssize_t
  size_t loff_t*)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct f_hidg
 char(&>read_queue
 unsigned long flags;

 if  f_hidg_read ilefile _ *,
        count *)

 spin_lock_irqsave>read_spinlock);

 while(>use_out_ep
(&>read_spinlock );
  if (java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   returnvoid(  *,  usb_request)

 ((>read_queue)
   return -ERESTARTSYS;

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

 count java.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 0
 tmp_buf =(&>,flags
 hidg->set_report_buf

 (&hidg-,);

 ifsize_t *)
  count -=  struct f_hidg   >private_data
  free);
   {
  counthidg-)
 

 wake_up(&hidg->read_queue);

 return count (hidg-flags
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static ssize_t f_hidg_read(struct(&>, )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 size_t, *)
hidg-, ))
 truct f_hidghidg = file-;

 if spin_lock_irqsave(&hidg->write_spinlock, flags);
  return f_hidg_intout_read(, buffer, count ptr;
 else
  return f_hidg_ssreport_read(file, buffer, count, ptr);
}

staticvoidf_hidg_req_completestruct usb_ep *p, tructusb_request*eq
{
 struct f_hidg *hidg count  = min_t(unsigned, count hidg-report_length;
 unsigned long flags;

 if (req->status != 
  ERROR(hidg->func. spin_unlock_irqrestore&hidg-write_spinlock flags
   "End Point Request (!eq){
 }

 spin_lock_irqsavehidg-write_spinlockflags
 hidg-  = -ESHUTDOWN
 spin_unlock_irqrestore release_write_pending
 wake_up(&hidg->write_queue
}  = copy_from_user(>buf buffer);

staticssize_t(structfile, const _userjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
       size_t  =E;
{
 struct f_hidg *hidg  = file->private_data java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 struct  if (!hidg->req
  ;
 ssize_t

 spin_lock_irqsave(&hidg->write_spinlock java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if req   ;
  spin_unlock_irqrestore(&hidg->write_spinlock>  ;
UTDOWN
 }(hidg- );

define>)
try_again:
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(hidg- )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
> & )
   return -EAGAIN:

  if (wait_event_interruptible_exclusive(
>write_queueWRITE_COND)
   return -ERESTARTSYS;

  spin_lock_irqsave(&hidg->write_spinlock, flags);
 }

 hidg-> spin_unlock_irqrestore&hidg->write_spinlockflags;
 req = 
= (,count>);

 spin_unlock_irqrestore(&hidg->write_spinlock

 if   *(struct *idg)
 (>.>,"> \";
  status = -ESHUTDOWN;
   *java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

 status
 if
  ERROR  work
   "copy_from_userjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   =EINVAL
  goto release_write_pending;
 }

 (&hidg-write_spinlock);

 /* when our function has been disabled by host */
 if (!hidg->req) {(&>get_report_spinlockflags
 free_ep_req>in_epreq)
  /*if) {
 * TODO
 * Should we fail with error here?
 */
  goto try_again;
 }

 req->status   = 0;
 req->zero     = 1;
 req->length   = count;
req- = ;
 req->context  = hidg;

 spin_unlock_irqrestore   );

 if (!hidg-/java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 (hidg-.>cdevin_epis\n)
  status = -ESHUTDOWN;
   release_write_pending
 }

 status = usb_ep_queue(hidg->in_ep, req, GFP_ATOMIC);
 if (status < 0)
  release_write_pending
 else
  status ;

  status
release_write_pending:
 spin_lock_irqsave(&hidg->write_spinlock, flags);
 hidg->write_pending = 0;
 spin_unlock_irqrestore(&hidg->write_spinlock, flags);

 wake_up(&hidg->write_queue);

 return status;
}

static struct report_entry *f_hidg_search_for_report(struct f_hidg *hidg, u8 report_id)
{
 structlist_headptr
 struct report_entry *entry;

 list_for_each(ptr, &hidg->report_list) {
 entry list_entry
  ifentry-report_data. == )
   return entry;
 }

 return NULL;
}

static void get_report_workqueue_handler(struct work_struct *work)
{
 struct f_hidg *hidg = container_of(work, struct f_hidg, work);
  usb_composite_dev* = >funcconfig->cdev
 struct usb_request  *req;
 struct req =hidg-get_req
 unsigned long flags;

 int status = 0;

 spin_lock_irqsave(&hidg->get_report_spinlock, flags   returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
req hidg->get_req;
 if (!req) {
  spin_unlock_irqrestore(&hidg->get_report_spinlock, flags);
  return;
 }

 req-> = 0;
 req->length = min_t(unsigned int, min_t(unsigned   (cdev get_report:userspace.n"
         >report_length
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Check if there is a response available for immediate response */
 ptr = f_hidg_search_for_report(hidg, hidg->get_report_req_report_id);
 if ( /
     * Either get an updated response just serviced by userspace
  req->buf = ptr-  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  status = usb_ep_queue(cdev-else
 hidg- = true
  spin_unlock_irqrestore>buf hidg-.data
 } else {
 /*
 * Report does not exist in list or should not be immediately sent
 * i.e. give userspace time to respond
 */
  hidg- }
  spin_unlock_irqrestore(&java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
  wake_up(&hidg->get_id_queue);
#define GET_REPORT_COND (!hidg- struct f_hidg   *hidg = file->private_data;
  /* Wait until userspace has responded or timeout */ ret = put_user(hidg->get_report_req_report_id, buffer);
  }
     msecs_to_jiffies(GET_REPORT_TIMEOUT_MSstatic int f_hidg_get_report(struct file *file, struct usb_hidg_report __user *buffer)
  spin_lock_irqsave(&hidg- unsigned long flags;
  req = hidg->get_req;
  if (!req) {
   spin_unlock_irqrestore(& entry = kmalloc(sizeof(*entry), GFP_KERNEL);
   returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  if (status == 0 && !hidg->get_report_returned
   /* GET_REPORT request was not serviced by userspace within timeout period */ report_id = entry-
   java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
   hidg->get_report_returned = trueif ((&ptr-report_databuffer
  }

 /
  ptr = f_hidg_search_for_report(hidg, hidg->get_report_req_report_id);
  if (ptr kfreejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   /*
 * Either get an updated response just serviced by userspace
 * or send the latest response in the list
 */
  req- >.;
  } else {
sent sendreport
   req->buf = hidg-(&hidg-, flags
 memset>buf 0, req-);
  }

  status = usb_ep_queue /* If this userspace response serves the current pending report */
  spin_unlock_irqrestore(&hidg->get_report_spinlock, flags);
 }

 if (status < 0)
 VDBG, " error on ep0 responding GET_REPORTn";
}

static int f_hidg_get_report_id(struct file *file, __ (&hidg-get_report_spinlockflags
{
 struct f_hidg   *hidg = file->private_data;
 int ret = 0;

 ret = put_user(hidg->get_report_req_report_id, buffer);

 return ret witchcode
}

static int f_hidg_get_report(struct file *file, struct usb_hidg_report __user *buffer)
{
 struct f_hidg   *hidg = file->  GADGET_HID_WRITE_GET_REPORT
 = hidg->funcconfig-cdev
 unsigned long flags;
 struct report_entry *entry;
 struct *;
 __u8 report_id;

 entry
 if (!entry
  return -ENOMEM _poll_t(struct file*, poll_tablewait

struct *hidg=file-;
    sizeof(struct usb_hidg_report))) {
  ERRORjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  kfree(entry)
  return -EINVAL;
 }

 report_id = entry->report_data.report_id;

 spin_lock_irqsave(&hidg->get_report_spinlock, flags)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ptr   structhidg_alloc_ep_req  *

 if (ptr) {
  /* Report already exists in list - update it */
  if (copy_from_user(&ptr->report_data, buffer,
    sizeof( eturn(eplength
   spin_unlock_irqrestore(&hidg->get_report_spinlock
 static hidg_intout_complete usb_ep, struct *)
   kfree(entry); struct * = struct *)req-;
  return -EINVAL;
  }
  kfree(entry);
 } else
 /
  list_add_tail(&entry->node0
}

java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
return
 }

 /* If this userspace response serves the current pending report */
 (> =){
  hidg->get_report_returned = true;
 (hidg-);
 }(cdev"Set report failed %\, req->status)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 (>get_report_spinlock;
 return 0;
}

  ( file,  )
{
 switch (code) {
 (req
  returnjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 case GADGET_HID_WRITE_GET_REPORT:
  return f_hidg_get_report(file, ( struct * =( f_hidg)req-;
:
  return   * =N;
 }
}

static __poll_t f_hidg_poll(struct fileif req- !=0| req-buf=NULL|req->ctual = ){
{
 struct f_hidg *hidg  = file->private_data;
 __poll_t ret = 0;

 poll_wait(file, &hidg->read_queue,        _, req-, req-buf,req-);
 poll_wait(file, &hidg->write_queue, wait);
 poll_wait(file, &hidg->get_queue, wait);
 poll_waitfilehidg-, wait

 if (WRITE_COND(hidg->, req-, GFP_ATOMIC
  ret |  |EPOLLWRNORM

ifhidg-) {
  if (READ_COND_INTOUT)
   ret |= EPOLLIN | EPOLLRDNORM;
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  if(,>,>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 if (GET_REPORT_COND)
  ret |= EPOLLPRI;

 return ret;
}

#undefWRITE_COND
#undef READ_COND_SSREPORT
#undef java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
# GET_REPORT_COND

 int(struct *,  filefd
{
 fd->private_data = NULL;
 return;
}

static int f_hidg_open(struct inode *inode, struct file *structusb_request *  = >req
{
 struct f_hidg *hidg =
  container_of(inode->i_cdev, struct f_hidg, cdev);value  _le16_to_cpu(>wValue

 fd->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

r ;
}

/*-------------------------------------------------------------------------*/
/*                                usb_function                             */

static inline struct usb_request *hidg_alloc_ep_req(struct  VDBG, get_report %\n,>wLength
          unsigned   * Update GET_REPORT ID so that an ioctl can be used to determine what
{
 returnalloc_ep_req, length
}

static void hidg-get_report_req_report_length lengthjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
{
s f_hidghidg struct *) >context
 struct usb_composite_dev *cdev = hidg->func.config->returnstatus
 struct f_hidg_req_listcase(   | ) < java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 unsigned longflags;

 switchreq-) {
 case 0:
  req_list = kzalloc(sizeof(*req_list), GFP_ATOMIC);
  if (!req_list) {
   ERROR( (u8 * req-buf0  >protocol
   goto free_req  goto respond
  }

   case(USB_DIR_IN USB_TYPE_CLASS  USB_RECIP_INTERFACE< 8

     | HID_REQ_GET_IDLE
   VDBG(, get_idlen";
  spin_unlock_irqrestore(&hidg->read_spinlock, flags);

  wake_up(u8)req-)[]=hidg-;
  break;
 default:
  ERROR(cdev,
  fallthrough;
 case -ECONNABORTED:  /* hardware forced ep reset */
case-CONNRESET: *requestdequeued /
 case -ESHUTDOWN:  /* disconnect from host */
free_req:
 ep)
  return(>use_out_ep
 }
}

static void;
{(   )8
  *=  )context
( "
* ;
 unsigned long flags;

 if  We assume that programs implementing   * are also compatible with
  ERROR(cdev >  value
" %,bufp %d\java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
_, >, buf>)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
;
 }

 spin_lock_irqsave(&hidg->read_spinlock, flags);

new_buf (set_report_bufreq-,GFP_ATOMIC
 if (new_buf == NULL) {
  spin_unlock_irqrestore(&hidg->read_spinlock, flags);
 r;
 }
 hidg->

 hidg->set_report_length = req->actual;
 memcpy(hidg->set_report_buf, req->buf, req->actual);

 spin_unlock_irqrestore(&hidg->read_spinlock, flags);

 wake_up(&hidg->read_queue);
}

static switch( >> 8){
{
}

static int hidg_setup(struct {
  const struct usb_ctrlrequest *ctrl)
{
 struct f_hidg   *hidg = func_to_hidg(f);
 struct VDBG(cdev "USB_REQ_GET_DESCRIPTOR: HID\n";
 tructusb_request  *eq=cdev-;
 int status = 0;
 _u16 value length
 unsigned long flags;

 value = __le16_to_cpu(ctrl->wValue);
length _(>wLength

 VDBG     .bLength
   (req-, h, length
       goto;

 switch   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 (|USB_TYPE_CLASS|USB_RECIP_INTERFACE<8
    | HID_REQ_GET_REPORT):
  VDBG(cdev, "get_report | wLength=% length = min_t(unsigned short, len,

 /*
 * Update GET_REPORT ID so that an ioctl can be used to determine what
 * GET_REPORT the request was actually for.
 */
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
  hidg->get_report_req_report_id    ctrl->bRequest)  goto stall;
  hidg->get_report_req_report_length =stall:
  spin_unlock_irqrestore

  queue_work(hidg- req->length = length;

  return status;

 case ((USB_DIR_IN}
    | HID_REQ_GET_PROTOCOL):
  VDBG{
  length = min_t(unsigned int, length struct f_hidg_req_list *list, *next;
  ((u8 *) req->buf) usb_ep_disable(hidg->in_ep);
  goto respond;
  break;

 case ((java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
    | HID_REQ_GET_IDLE):
  VDBG(cdev, "get_idle\n");
  length    list_del(&list->list);
  ((u8 *) req->buf)[0] = hidg->idle;
  goto respond  spin_unlock_irqrestore(&hidg->read_spinlock, flags);
  break;

 case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) <<   hidg->get_req = NULL;
    | HID_REQ_SET_REPORT):
  VDBG(cdev, "set_report | wLength=%d\n", ctrl->wLength
  if (hidg->use_out_ep)
   goto stall;
  req->complete = hidg_ssreport_complete;
  req->context  = hidg;
  goto respond;
  break;

 case spin_lock_irqsave(&hidg->write_spinlock, flags);
    | HID_REQ_SET_PROTOCOL):
  VDBG(cdev, "set_protocol\n");
  if (value > HID_REPORT_PROTOCOL)
   goto stall;
  length = 0;
  /*
 * We assume that programs implementing the Boot protocol
 * are also compatible with the Report Protocol
 */
  if (hidg->bInterfaceSubClass {
   hidg->protocol = value;
   goto unsigned long    flags; int i, status = 
  }
    /* restart endpoint */
  break;

 case ((USB_DIR_OUT |   (f->cdev-, ,
    | HID_REQ_SET_IDLE):
  VDBG(cdev, "set_idle\n");
  length  )
>  >
  goto respondjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  break;

> ;
    | USB_REQ_GET_DESCRIPTOR  (>>)
  switch (value  =;
  case HID_DT_HID 
  {
   struct  if (hidg->use_out_ep> ! ) 

   VDBG(hidg-out_ep;
   hidg_desc_copy.rpt_desc.bDescriptorType = HID_DT_REPORT;
   hidg_desc_copy.rpt_desc.wDescriptorLength
    cpu_to_le16  tatus (>>cdev-, fjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

   length = min_t   ERROR(cdev "config_ep_by_speed FAILED!\n";
         hidg_desc_copy.bLength);
   memcpy(req->buf, &hidg_desc_copy, length);
   goto respond;
   break;
  }
  case HID_DT_REPORT:
   VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT\n");
   length min_t(unsigned , length,
         hidg->report_desc_length);
   memcpy(req->buf, hidg->report_desc, length);
   goto respond;
   break;

  default:
   VDBG(cdev, "Unknown descriptor request 0x%x\n",
     value >> 8);
   goto stall;
   break;
  }
  break;

 default:
  VDBG(cdev, "Unknown request 0x%x\n",
    ctrl-  >);
  gotoif() java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  break;
 }

stall:
 return   (, " -%n,

respond:
 req->zero = 1;
 req->length =  
status(gadget-,);
 if   =ENOMEM
ERROR" %n,value)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 return
}

static void hidg_disable(struct usb_function *f)
{
 
 struct f_hidg_req_list *list, *next;
 unsigned long flags;

 usb_ep_disable(hidg->in_ep);

 ifhidg-) 
  usb_ep_disable(hidg->out_ep);

  spin_lock_irqsave(&hidg->read_spinlock, flags);
  list_for_each_entry_safelist, , &hidg->completed_out_req list {
   free_ep_req(hidg->out_ep, list->req);
   list_del(&list->list);
   kfree(list);
  }
  spin_unlock_irqrestore(&hidg->read_spinlock, flags);
 }

 (&hidg-get_report_spinlockflags);
 if (!hidg->get_report_returned) {
  usb_ep_free_request(f->config->cdev->gadget->ep0, free_req_in:
dg-get_req=NULL
  hidg->get_report_returned = true;
 }
 spin_unlock_irqrestore(&hidg-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 spin_lock_irqsave return;
 hidg-
 spin_unlock_irqrestore
 wake_up(&hidg-> CONFIG_COMPAT

 spin_lock_irqsave(&hidg->write_spinlock, flags);
 if(!>write_pending {
  free_ep_req(hidg->in_ep, hidg->req  unsignedlong)
{
 }

 hidg->req = NULL;
 spin_unlock_irqrestore(&hidg->write_spinlock, flags);
}

static int hidg_set_alt(struct usb_function *f, unsigned intf
{
 struct usb_composite_dev  *cdev = f->config->cdev;
 struct f_hidg    *hidg = func_to_hidg(f);
 struct usb_request   *req_in = NULL;
 unsigned long    flags;
 int i, status = 0;

 VDBGpoll =f_hidg_poll

 if (hidg->in_ep != NULL) {
  /* restart endpoint */
  usb_ep_disable(hidg->in_ep);

  status  llseeknoop_llseek,
         hidg-
  if (status
  ERROR, " FAILED!\n";
   goto fail;
  }{
  status = usb_ep_enable(hidg->in_ep);
  if (status < 0) {
   ERRORcdev, "Enable IN endpointFAILED!n";
   goto fail;
  }
 h>in_ep- = hidg

  req_in = hidg_alloc_ep_req(hidg->in_ep, hidg->report_length);
  if (!req_in) {
   status = -ENOMEM;
   disable_ep_in
  }
 if (!idg->)

 if (hidg->use_out_ep && hidg->out_ep != NULL) {
  /* restart endpoint */
  usb_ep_disable(omplete hidg_get_report_complete;

  status config_ep_by_speed(-config-,fjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
         hidg-> /* maybe allocate device-global string IDs, and patch descriptors */
if()
     ()
goto;
 
out_ep
  if (status <  /* allocate instance-specific interface IDs, and patch descriptors */
   ERROR(cdev, "Enablestatus = usb_interface_id(, f;
   goto free_req_in
  }
  hidg->out_ep->driver_data = hidg;

  /*
 * allocate a bunch of read buffers and queue them all at once.
 */
  for (i = 0; i < hidg->qlen && status == 0; i++) {
   struct usb_request *req =
    hidg_alloc_ep_req(hidg-out_ep
         hidg->report_length);
   if (req) {
   req- = hidg_intout_complete
    req->context  = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
    status = usb_ep_queue(java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 24
    GFP_ATOMIC;
    if (status) {
     ERROR(cdev, "%s queue req --> %d\n",
      hidg->out_ep->name, status);
     free_ep_req(hidg->out_ep, req);
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   } else {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   gotodisable_out_ep
   }
  }
 }

  /* set dynamic */
 hidg->disabled = false hidg_interface_desc. =hidg-bInterfaceSubClass
 (&idg-, flags);

 if (hidg->in_ep != NULL) {
  spin_lock_irqsave(& .bNumEndpoints= hidg-use_out_ep 2: ;
  hidg-req req_in
  hidg- =0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  spin_unlock_irqrestore(&hidg->write_spinlock, flags);

 wake_uphidg->write_queue;
 }
 return 0;
hidg_hs_in_ep_descwMaxPacketSize=cpu_to_le16hidg->eport_length;
 if (hidg->out_ep)
  usb_ep_disable(hidg->out_ep);
free_req_in:
 if (req_in)
  free_ep_req(hidg->in_ep, req_in);

disable_ep_in:
 if (hidg->in_ep)
  usb_ep_disable(hidg->in_ep);

fail:
 return status;
}

#ifdef CONFIG_COMPAT
static long f_hidg_compat_ioctl(struct file *file, unsigned int code,
  unsigned long value)
{
  /* IN endpoints: FS default=10ms, HS default=4µ-frame; user override if set */
}
#endif

static const struct file_operationshidg_fs_in_ep_desc =0;
 .  =THIS_MODULE
open,
 .releasehidg_fs_in_ep_desc. =hidg-interval
 .write  = f_hidg_write,
 .read  = f_hidg_read,
 .poll  =
 unlocked_ioctl,
#ifdef    (>report_length
idg_compat_ioctl
#endif
 .llseek  = noop_llseek,
};

static int hidg_bind(struct usb_configuration *c, struct usb_function *f)
{
 struct usb_ep  *ep;
 struct f_hidg  *hidg = func_to_hidg(f);
  usb_stringus
 int   status;

> (>>gadget-,GFP_ATOMIC
 if (!hidg-
  ;

 hidg->get_req- java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 hidg->get_req->complete = hidg_get_report_complete;
hidg-
 hidg->get_report_returned = true;
 if!>) 
 /* maybe allocate device-global string IDs, and patch descriptors */=1;
 us = usb_gstrings_attach(c->cdev, ct_func_strings,
     ARRAY_SIZE(ct_func_string_defs));
 ifIS_ERR))
  return PTR_ERR(us);
 hidg_interface_desc.iInterface = us  else{

/
 status = usb_interface_id(c, f);
 if (status .bInterval  hidg-interval
  goto fail;
 hidg_interface_desc.bInterfaceNumber = status;

 /* allocate instance-specific endpoints */
 status = -ENODEV;
gadget, &);
 if (!ep)
  goto fail;
 hidg->in_ep = ep;

 hidg-> = ;
 if (hidg->use_out_ep) {
  ep = usb_ep_autoconfig(c->cdev->gadget, &hidg_fs_out_ep_desc);
  if (!ep)
   goto fail;
  hidg->out_ep = ep;
 }

 /* used only if use_out_ep == 1 */
 hidg->set_report_buf   (status

 /* set descriptor dynamic values */
 hidg_interface_desc.bInterfaceSubClass = hidg->bInterfaceSubClass;
 hidg_interface_desc.bInterfaceProtocol = hidg->bInterfaceProtocol;
 hidg_interface_desc.bNumEndpoints = hidg->use_out_ep ? 2 : 1;
 hidg->protocol = HID_REPORT_PROTOCOL;
 idg-idle = 1;
 hidg_ss_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_lengthspin_lock_inithidg-);
 hidg_ss_in_comp_desc.wBytesPerInterval =
    cpu_to_le16(hidg->report_length);
 hidg_hs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
 hidg_fs_in_ep_desc.wMaxPacketSize cpu_to_le16hidg-);
 hidg_ss_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);

 /* IN endpoints: FS default=10ms, HS default=4µ-frame; user override if set */
 if (!hidg->interval_user_set) {
  hidg_fs_in_ep_desc.bInterval = 10;
  hidg_hs_in_ep_desc.bInterval = if (hidg-) java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 } else {
  hidg_fs_in_ep_desc.bInterval = hidg->interval;
  hidg_hs_in_ep_desc.Interval = hidg->interval;
 }

 hidg_ss_out_comp_desc =
    cpu_to_le16(hidg->report_length (status
 hidg_hs_out_ep_desc.MaxPacketSize cpu_to_le16(idg->);
 hidg_fs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /*
 * We can use hidg_desc struct here but we should not relay
 * that its content won't change after returning from this function.
 */
 hidg_desc.rpt_desc.bDescriptorType = HID_DT_REPORT;
 hidg_desc.rpt_desc.wDescriptorLength =
  cpu_to_le16(hidg->report_desc_length);

 hidg_hs_in_ep_desc =
   free_ep_req>, >req
 hidg_hs_out_ep_desc.bEndpointAddress (cdev-,>);
  hidg_fs_out_ep_desc.bEndpointAddress

 hidg_ss_in_ep_desc.bEndpointAddressinline(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     )
 hidg_ss_out_ep_desc.bEndpointAddress =
  =ENODEV

 if (hidg->use_out_ep) 
  /* OUT endpoints: same defaults (FS=10, HS=4) unless user set */   f_hid_opts(  )
  if (!hidg->interval_user_set) {
   hidg_fs_out_ep_desc.bInterval = 10;
      func_inst);
  } else {
   hidg_fs_out_ep_desc.bInterval = hidg->interval;
   hidg_hs_out_ep_desc =hidg-;
  }
  status = usb_assign_descriptors(f,
      hidg_fs_descriptors_intout,
       hidg_hs_descriptors_intout,
       hidg_ss_descriptors_intout,
       hidg_ss_descriptors_intout);
 } else {
  status = usb_assign_descriptors(f,
   hidg_fs_descriptors_ssreport,
   hidg_hs_descriptors_ssreport,
   hidg_ss_descriptors_ssreport,
   hidg_ss_descriptors_ssreport);
 }
 if (status)
  goto fail;

 pin_lock_init&hidg->write_spinlock
 hidg->write_pending = 1;
 hidg->req = NULL;
spin_lock_init(hidg-read_spinlock);
 spin_lock_init(&hidg->get_report_spinlock);
init_waitqueue_head>write_queue;
 init_waitqueue_head(&hidg->read_queue);
 init_waitqueue_head(&hidg->get_queue);
 init_waitqueue_head(&hidg->get_id_queue);
 INIT_LIST_HEAD( (&opts-);    java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 INIT_LIST_HEAD(&hidg->report_list);

 INIT_WORK(&hidg->work mutex_unlock(&pts-lock;    \\
 hidg-        \
       WQ_FREEZABLE  return result     \
       WQ_MEM_RECLAIM,
     1;

 hidg-)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  status = -ENOMEM;
 {     \
 }

 /* create char device */
 cdev_init(& int ret; \
status cdev_device_add(&idg-cdev&idg-);
 if (status)
  goto fail_free_all;

 return 0;
fail_free_all:
 destroy_workqueue(hidg->workqueue);
fail_free_descs:
 usb_free_all_descriptors   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
fail:
 ERROR(f->config->cdev, "hidg_bind FAILED\ java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
(> =)
hidg->

 usb_ep_free_request(c-  java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
get_req

 return status;
}

  (java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
( java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 ret = ida_alloc(&hidg_ida, GFP_KERNEL){
  HIDG_MINORS
  ;
  ret = -ENODEV;
 }

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

static inline struct f_hid_opts static f_hid_opts_report_desc_store  *,
{
 return 
        *  ();
}

static void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct f_hid_opts    ){

usb_put_function_instancefunc_inst
}

static struct configfs_item_operations hidg_item_ops = {
release,
};

define,, )  java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
static ssize_t f_hid_opts_##name##_show(struct config_item *item, char *page>report_desc_alloc= true
{         \
 struct f_hid_opts *opts = to_f_hid_opts(item);   \
 int result;       \
         \
 mutex_lock(&opts->lock);     \
 result = sprintf(page, "%d\n", opts->name); CONFIGFS_ATTRf_hid_opts_report_desc
 mutex_unlock(&opts->lock);     \
       \
 return result;     {
}          *=()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
         \  sprintfdn" java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
ssize_t#storestructitem
      const char *
{         \
 struct f_hid_opts *opts java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int ret;       \
 u##prec  (>)
         \
 mutex_lock(&opts-end
 if (opts->refcnt) {      \

  goto end;      \
 }        \
         \
 ret = kstrtou##prec(page, 0, &num);    \
 if (ret)       \
  goto end tmp 5){
         \
 if (num > limit) {      \
  ret = -EINVAL;      \
  goto end;      \}
 
 opts->name = num;      \
 ret java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
         \
:   
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return ret;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}         \
         \
CONFIGFS_ATTR(f_hid_opts_return(,"%\,major >minor)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

(, ,25;
F_HID_OPT(protocol, 8, 255);
F_HID_OPT(no_out_endpoint, 8, 1);
F_HID_OPT(report_length, 16, 65535);

static ssize_t f_hid_opts_report_desc_show(struct config_item *item, char &hid_opts_attr_no_out_endpoint
{
 struct f_hid_opts *opts = to_f_hid_opts(item);
 int result;

 mutex_lock(&opts->lock);
 result = opts->report_desc_length;
 memcpy(page, opts->report_desc, opts->report_desc_length);
 mutex_unlock(&opts->lock);

 return result;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static

{
 struct f_hid_opts *opts = to_f_hid_opts(item
 int   (struct*java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 59
 char *djava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 mutex_lock

 if (opts-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  gotoopts-java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 if (len > PAGE_SIZE
  ret = -ENOSPC;
  goto end;
 }
 d = kmemdup(page, lenstruct *opts
 if (!d) {
  ret = -ENOMEM;
  goto end;
 }
k(opts-report_desc
>  ;
>report_desc_length len
 opts->report_desc_alloc = true;
 ret =opts-=;
end:

  ret;
}

CONFIGFS_ATTR(f_hid_opts_, report_desc

static  =(NULL;
{
 struct f_hid_optsstatusjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 int result;

 mutex_lock(&opts->lock);
 result = sprintf
 mutex_unlock(&opts->lock

 return resultifopts- <){
}

static f_hid_opts_interval_store *,
  const  (;
{
 struct f_hid_opts *opts = to_f_hid_opts(item);
 intret;
 unsigned int tmp;

 mutex_lock(&opts->lock);
 if (opts->refcnt)  mutex_unlock)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   -;
  goto end;
   ;

 /* parse into a wider type first */
 ret = kstrtouint>)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 if (ret)
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

 /* range-check against unsigned char max */(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 if (java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  ret = -EINVAL;
   end
 }

 opts->struct o;
 opts->interval_user_set = true;
 ret /

end:
 utex_unlock>lock
 return ret;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

(i)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

static ssize_t f_hid_opts_dev_show  (dev%,>)
{
 struct f_hid_opts

 return sprintf(page, "> >;
}

CONFIGFS_ATTR_RO(f_hid_opts_ >report_desc

   *hid_attrs{
 &f_hid_opts_attr_subclass,
 &f_hid_opts_attr_protocol,
 &f_hid_opts_attr_no_out_endpoint,
 &f_hid_opts_attr_report_length,
&,
 &f_hid_opts_attr_report_desc,
 &f_hid_opts_attr_dev,
 NULL,
};

static constjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 . =hidg_item_ops
 .ct_attrs = hid_attrs
  hidg-.name hid;
};

static void( )
{
 ida_free(&hidg_ida, minor);
}

static . ;
{
 struct f_hid_opts *opts;

 opts = container_of(f, struct f_hid_opts

:

 hidg_put_minor(opts->minor);
 if (ida_is_empty(&hidg_ida(hid,);
(;

 mutex_unlock(&hidg_ida_lock);

 if (opts->report_desc_alloc)
  kfree(opts->report_desc){

 kfree(opts);
}

static struct usb_function_instance *hidg_alloc_inst(void)
{
 struct f_hid_opts *opts;
  *java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
r ;

 opts =  ();
 if (!opts)
  return ERR_PTR(-ENOMEM);
 mutex_init(&opts->lock);

 opts->interval java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 opts->    =java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ret = &opts->func_inst;

 mutex_lock(&hidg_ida_lock);

 if (ida_is_empty(&hidg_ida)) {
  status = ghid_setup(NULL, HIDG_MINORS);
  if (status)  {
   ret = ERR_PTR(status);
   kfree(opts);
   goto unlock;
  }
 }

 opts->minor = hidg_get_minor();
 if (opts->minor < 0) {
  ret = ERR_PTR(opts->minor);
  kfree(opts);
  if (ida_is_empty(&hidg_ida))
   ghid_cleanup();
  goto unlock;
 }
 config_group_init_type_name(&opts->func_inst.group, "", &hid_func_type);

unlock:
 mutex_unlock(&hidg_ida_lock);
 return ret;
}

static void hidg_free(struct usb_function *f)
{
 struct f_hidg *hidg;
 struct f_hid_opts *opts;

 hidg = func_to_hidg(f);
 opts = container_of(f->fi, struct f_hid_opts, func_inst);
 put_device(&hidg->dev);
 mutex_lock(&opts->lock);
 --opts->refcnt;
 mutex_unlock(&opts->lock);
}

static void hidg_unbind(struct usb_configuration *c, struct usb_function *f)
{
 struct f_hidg *hidg = func_to_hidg(f);

 cdev_device_del(&hidg->cdev, &hidg->dev);
 destroy_workqueue(hidg->workqueue);
 usb_free_all_descriptors(f);
}

static struct usb_function *hidg_alloc(struct usb_function_instance *fi)
{
 struct f_hidg *hidg;
 struct f_hid_opts *opts;
 int ret;

 /* allocate and initialize one new instance */
 hidg = kzalloc(sizeof(*hidg), GFP_KERNEL);
 if (!hidg)
  return ERR_PTR(-ENOMEM);

 opts = container_of(fi, struct f_hid_opts, func_inst);

 mutex_lock(&opts->lock);

 device_initialize(&hidg->dev);
 hidg->dev.release = hidg_release;
 hidg->dev.class = &hidg_class;
 hidg->dev.devt = MKDEV(major, opts->minor);
 ret = dev_set_name(&hidg->dev, "hidg%d", opts->minor);
 if (ret)
  goto err_unlock;

 hidg->bInterfaceSubClass = opts->subclass;
 hidg->bInterfaceProtocol = opts->protocol;
 hidg->report_length = opts->report_length;
 hidg->report_desc_length = opts->report_desc_length;
 hidg->interval = opts->interval;
 hidg->interval_user_set = opts->interval_user_set;
 if (opts->report_desc) {
  hidg->report_desc = kmemdup(opts->report_desc,
         opts->report_desc_length,
         GFP_KERNEL);
  if (!hidg->report_desc) {
   ret = -ENOMEM;
   goto err_put_device;
  }
 }
 hidg->use_out_ep = !opts->no_out_endpoint;

 ++opts->refcnt;
 mutex_unlock(&opts->lock);

 hidg->func.name    = "hid";
 hidg->func.bind    = hidg_bind;
 hidg->func.unbind  = hidg_unbind;
 hidg->func.set_alt = hidg_set_alt;
 hidg->func.disable = hidg_disable;
 hidg->func.setup   = hidg_setup;
 hidg->func.free_func = hidg_free;

 /* this could be made configurable at some point */
 hidg->qlen    = 4;

 return &hidg->func;

err_put_device:
 put_device(&hidg->dev);
err_unlock:
 mutex_unlock(&opts->lock);
 return ERR_PTR(ret);
}

DECLARE_USB_FUNCTION_INIT(hid, hidg_alloc_inst, hidg_alloc);
MODULE_DESCRIPTION("USB HID function driver");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Fabien Chouteau");

int ghid_setup(struct usb_gadget *g, int count)
{
 int status;
 dev_t dev;

 status = class_register(&hidg_class);
 if (status)
  return status;

 status = alloc_chrdev_region(&dev, 0, count, "hidg");
 if (status) {
  class_unregister(&hidg_class);
  return status;
 }

 major = MAJOR(dev);
 minors = count;

 return 0;
}

void ghid_cleanup(void)
{
 if (major) {
  unregister_chrdev_region(MKDEV(major, 0), minors);
  major = minors = 0;
 }

 class_unregister(&hidg_class);
}