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/kernel>
#include <linux/module.h>
#include <linux/hid.h>
#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"

#define HIDG_MINORS 4

/*
 * 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 major, minors;

static const struct class hidg_class = {
 . = hidg
};

staticinclude/.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
staticdefine4

struct report_entry {
 struct usb_hidg_report report_data;
 * Most operating systems seem to allow for 5000ms * userspace half that time to respond before we return
;

/*-------------------------------------------------------------------------*/
*HIDgadget                            

struct f_hidg_req_list  node
 
 java.lang.StringIndexOutOfBoundsException: Range [77, 19) out of bounds for length 77
 struct list_head  list;
};

struct f_hidg {
 /* configuration */
 unsigned char   bInterfaceSubClass;
 unsignedchar  bInterfaceProtocol
 unsigned  ;
 unsigned char   idle;
 shortr;
 char    *report_desc;
 unsigned short   report_length;
unsigned  ;
 bool    interval_user_set;

 /* charbInterfaceSubClassjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 * 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 char ;

 /* recv report */
 spinlock_t
  * use_out_ep - if true, the OUT Endpoint (  *              will be used to receive reports from the host
 bool    disabled;
 /* recv report - interrupt out only (use_out_ep == 1) */  *              and the SETUP/SET_REPORT method ("ssreport" suffix  *              will be used to receive reports.
 struct list_head  completed_out_req;
 unsigned int   qlen   ;
 /* recv report - setup set_report only (use_out_ep == 0) */  write_spinlockjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 char    * struct usb_hidg_report
 unsigned int  set_report_length

i   ;
 spinlock_t spinlock_t  get_report_spinlock;
 bool    write_pending;
 wait_queue_head_t  write_queue;
 struct usb_request  *req;

 /* get report */
 struct usb_request  *get_req;
 struct usb_hidg_report  get_report;
 bool    get_report_returned;
 int    get_report_req_report_id;
 int    get_report_req_report_length;
 spinlock_t get_report_spinlock
 wait_queue_head_twait_queue_head_t get_id_queue; /* Get ID came in */
 wait_queue_head_t get_id_queue /* Get ID came in */
 structwork_structwork;
 struct workqueue_struct  *workqueue;
 truct  report_listjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 struct device   dev;
   ;
  struct in_ep

struct  *;
 struct usb_ep   *out_ep;
};

static

 return{
}

static void hidg_release(struct device *dev)
{
 struct f_hidg *hidg = container_of({

 kfree
 kfreehidg-);
k(hidg-);
}

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

static struct usb_interface_descriptor hidg_interface_desc = {
s struct hidg_interface_desc java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 .bDescriptorType = java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 24
 /* .bInterfaceNumber = DYNAMIC */. =USB_CLASS_HID
 .bAlternateSetting = 0 
/* .bNumEndpoints = DYNAMIC (depends on use_out_ep) */
 .bInterfaceClass = USB_CLASS_HID,
 /* .bInterfaceSubClass = DYNAMIC */  hid_descriptor ={
 /* .bInterfaceProtocol = DYNAMIC */
 /* .iInterface = DYNAMIC */
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static  bCountryCode x00
 .   =sizeofhidg_desc,
java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 32
 .bcdHID
 .  =0,
 .bNumDescriptors  = 0x1,
 /*.rpt_desc.bDescriptorType = DYNAMIC */structusb_endpoint_descriptor hidg_ss_in_ep_desc java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
/java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
};

/* Super-Speed Support */

static struct usb_endpoint_descriptor
.   ,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bEndpointAddress.                sizeof),
 .bmAttributes  = USB_ENDPOINT_XFER_INT
 /*.wMaxPacketSize = DYNAMIC */
 /*.bInterval = DYNAMIC */
};

static struct usb_ss_ep_comp_descriptor hidg_ss_in_comp_desc = {
 .java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP bLength  USB_DT_ENDPOINT_SIZE

 /* .bMaxBurst           = 0, */
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 /* .wBytesPerInterval   = DYNAMIC */
};

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


staticjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 .bLength                = sizeof(hidg_ss_out_comp_desc
 .bDescriptorType structusb_descriptor_header[]=

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

static struct usb_descriptor_header *hidg_ss_descriptors_intout[] = {
 (struct usb_descriptor_header *)&hidg_interface_desc
 (struct usb_descriptor_header *)&hidg_desc,
 (tructusb_descriptor_header)&,
 (struct  (struct usb_descriptor_headerhidg_ss_out_comp_desc
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
struct*,
 NULL,
};

static  *[]= java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 (struct usb_descriptor_header *) ,
header)hidg_desc
 (struct
 static  hidg_hs_in_ep_desc
 NULL,
.   USB_DT_ENDPOINT_SIZE

/* High-Speed Support */

static struct usb_endpoint_descriptor hidg_hs_in_ep_desc = {
 .   ,
 .bDescriptorType =  /*.wMaxPacketSize = DYNAMIC
 /* .bInterval = DYNAMIC */
;
 /*.wMaxPacketSize = DYNAMIC */
 /* .bInterval = DYNAMIC */
};

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

static( usb_descriptor_header,
(truct *)hidg_interface_desc
 struct *&,
 (struct usb_descriptor_header *)&hidg_hs_in_ep_desc struct *)&hidg_hs_out_ep_desc
 (struct usb_descriptor_header struct usb_descriptor_headerhidg_hs_descriptors_ssreport= 
NULLjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
};

static struct usb_descriptor_header *hidg_hs_descriptors_ssreport[] = {
 (struct usb_descriptor_header*&hidg_interface_desc
 (}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 NULL,
};

/* Full-Speed Support */

static struct usb_endpoint_descriptor =USB_DT_ENDPOINT
 . bmAttributes ,
 .bDescriptorType
 .bEndpointAddress
 .;
 /*.wMaxPacketSize = DYNAMIC */
 /*.bInterval = DYNAMIC */
};

static structbLength ,
 .Length=USB_DT_ENDPOINT_SIZE
 .bDescriptorType bEndpointAddress USB_DIR_OUTjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 .bEndpointAddress }
 .bmAttributes  = USB_ENDPOINT_XFER_INT,
 /*.wMaxPacketSize = DYNAMIC */ struct usb_descriptor_headerhidg_fs_descriptors_intout]={
 /*.bInterval = DYNAMIC */
};

static struct usb_descriptor_header *hidg_fs_descriptors_intout[] = {
 (struct usb_descriptor_header *)hidg_interface_desc,
 (struct usb_descriptor_header *)&hidg_desc,
 (struct usb_descriptor_header *)&hidg_fs_in_ep_desc,
 (structusb_descriptor_header *)&idg_fs_out_ep_desc
,
}

static struct }
 (struct structusb_descriptor_headerhidg_fs_descriptors_ssreport java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 structusb_descriptor_header)hidg_desc
 (struct usb_descriptor_header(truct *)&hidg_fs_in_ep_desc
 NULL,
};

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

#define CT_FUNC_HID_IDX 0

static struct usb_string ct_func_string_defs[] = {
 [].s  " Interface",
 {},   /* end of list */
};

static struct usb_gadget_strings ct_func_string_table = {
 .languagestatic struct usb_string ct_func_string_defs ={
 .strings = ct_func_string_defs,
};

static struct usb_gadget_strings *ct_func_strings[] = {
 &ct_func_string_table,
 NULL,
};

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

static ssize_t f_hidg_intout_read(struct file *file, char __user *buffer,
    .java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
{
 struct f_hidg * &ct_func_string_tab,
 struct f_hidg_req_list *list;
 ;
 unsigned
 int

 if (!count)
  returnjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

 spin_lock_irqsave(&hidg->read_spinlock, flags);

#define READ_COND_INTOUT (!list_empty(&hidg->completed_out_req) || hidg->disabled)

 /* wait for at least one buffer to complete */
 while(READ_COND_INTOUT{
  spin_unlock_irqrestore(&hidg->read_spinlock, flags);
  if (file->f_flags & O_NONBLOCK)
    struct *hidg =file-private_data;

  if ( usb_requestreq
   unsignedlong;

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

 if (hidg-return;
  spin_unlock_irqrestore(&hidg-spin_lock_irqsave&hidg-read_spinlock flags);
  return -#define READ_COND_I (!list_empty&hidg-) || hidg-disabled
 }

 /* pick the first one */
 list = list_first_entry(&hidg->completed_out_req,
    struct f_hidg_req_list (!EAD_COND_INTOUT{

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

 req = list->req;
 count   return-AGAIN
 spin_unlock_irqrestore(&hidg->read_spinlock,ue READ_COND_INTOUT)

 /* copy to user outside spinlock */
 count -= copy_to_user(buffer, req->buf
 list- spin_lock_irqsave&>read_spinlock, );

 /*
 * 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->pos == req->actual) {
  kfree(list);

 req->length hidg-report_length;
  ret = usb_ep_queue(hidg->out_ep,}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 list = list_first_entryhidg-completed_out_req,
   return ret  structf_hidg_req_list list);
  }
 } else {
  spin_lock_irqsave(&hidg->read_spinlock, flags);
  list_add(&list->list, &hidg->completed_out_req);
  spin_unlock_irqrestore&>);

 wake_up>read_queue;
 }

 return count;
}

#define READ_COND_SSREPORT(&hidg-read_spinlock, flags

static ssize_t f_hidg_ssreport_read(struct file *file,  -=(bufferreq- + >poscount)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct f_hidg *hidg = file->private_data;
 char *tmp_buf = NULL;
 unsigned long flags;

if!count)
  kfree);

 spin_lock_irqsave>read_spinlockflags);

while!) {
  spin_unlock_irqrestore&>read_spinlock);
 if(>f_flags  O_NONBLOCK
 returnEAGAIN

  if list_add&list-listhidg-completed_out_req);
  return -RESTARTSYS;

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

 count = min_t(unsigned int, count, hidg->set_report_length)java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 tmp_buf
hidg-set_report_buf =NULLjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 spin_unlock_irqrestore(&hidg-

        count,loff_t *tr
  count {
  kfree(tmp_buf);
 } else {
  count = -ENOMEM;
 }

 wake_uphidg-read_queue);

 return count;
}

staticssize_t(structfile *file, char_userbuffer
      size_t, loff_t*tr
{
 struct f_hidg *hidgspin_lock_irqsave(&hidg-read_spinlock, flags

 if hidg-use_out_ep)
  return  spin_unlock_irqrestorehidg-read_spinlock, flags
 else
  return f_hidg_ssreport_read(file, buffer, count, ptr);
}

static  f_hidg_req_completestruct usb_epep structusb_request *req
{
 struct f_hidg *hidg if wait_event_interruptible(idg-read_queue, READ_COND_SSREPORT)
 unsigned long flags;

 if (req->status != 0) {
  ERROR(hidg->func.config->cdev,
   "End Point Request ERROR:
 }

 spin_lock_irqsave(&hidg->write_spinlock, flags);
 hidg->write_pending = 0;
 spin_unlock_irqrestorehidg-write_spinlock );
 wake_up(&hidg->write_queue);
}

static ssize_t f_hidg_write(struct file *filespin_unlock_irqrestorehidg->read_spinlock flags
        count, loff_toffp
{
  *hidg  = file-private_data;
 struct usb_request *req;
 unsignedkfree(tmp_buf;
 ssize_t status}else{

 spin_lock_irqsave(&>write_spinlock, flags;

 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spin_unlock_irqrestore&>write_spinlock, flags);
  return -ESHUTDOWN}
 }

#define WRITE_COND (!hidg->write_pending)
try_again:
 /* write queue */
 whilejava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  spin_unlock_irqrestorehidg-write_spinlock flags;
  if (file->f_flags & O_NONBLOCK)
   return -EAGAIN;

  if (     count loff_t*tr
   >write_queueWRITE_COND
struct  *hidg = >private_data

 file,)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 }

  (*s  r)
 req =
count ,>)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

(>,);

if!)
  ERROR(&>, );
 status-;
  goto;
 }

statuscopy_from_userreq-,, count
 if (statusstatic  f_hidg_write  *file char_ *buffer,
  ERROR(hidg->func.config->cdev,
   "copy_from_user error\n");
 status -INVAL
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

 spin_lock_irqsave(&hidg->write_spinlock, flags);

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

 req->status   = 0;
 req->zero
 ->length= countjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 req-complete= f_hidg_req_complete;
 req->contextUTDOWN;

spin_unlock_irqrestore&hidg->write_spinlock, flags

 if (!hidg->in_ep->enabled#define WRITE_COND (!hidg-write_pending
  ERROR(hidg->func.config->cdev /* write queue */
  status = -ESHUTDOWN;
  goto release_write_pending;
 }

 status = usb_ep_queue(hidg->in_ep, req, GFP_ATOMIC);
 if (status < 0)
  spin_unlock_irqrestore&>write_spinlock, flags;
 else
  status = count;

 return  if (file-f_flags& O_NONBLOCK
release_write_pendingjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  hidg-write_queue, WRITE_COND)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 hidg-
 (hidg-, )

  wake_upmin_tunsigned , hidg-report_lengthjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 return status;
}

staticstructreport_entryf_hidg_search_for_report f_hidg*, u8 report_id)
{
 struct list_head ERRORhidg-funcconfig->dev hidg-reqisNULLn)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 structreport_entryentry;

 list_for_each(ptr, &hidg->report_list) {
  entry = list_entry(ptr, struct report_entry, node);
  if (entry- }
   return entry;
 }

 return NULL;
}

static void get_report_workqueue_handler(structwork_struct*)
{
 struct f_hidg *hidg = container_of(work, struct f_hidg, work);
 struct usb_composite_dev *cdev = hidg->func status -EINVAL;
 struct usb_request  *req;
 struct report_entry *ptr;
 unsigned longspin_lock_irqsave&hidg->, flags

 int status = 0;

spin_lock_irqsavehidg-, );
 req = hidg->get_req (hidg-, req;
  (!req) java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  spin_unlock_irqrestore(&hidg->get_report_spinlock, flags)  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return;
 }

 req->zero = 0;
 req->length = min_t(unsigned  >completef_hidg_req_complete
      
    MAX_REPORT_LENGTH

 /* Check if there is a response available for immediate response */
 ptr = f_hidg_search_for_report ERROR>funcconfig-, " disabled\";
 if (ptr && !ptr->report_data goto;
  /* Report exists in list and it is to be used for immediate response */
  req->buf = ptr->report_data.data;
  status = usb_ep_queue( goto;
  hidg->get_report_returnedstatus =count
  spin_unlock_irqrestore(&hidg->get_report_spinlock,  return;
 } else {
  /*
 * Report does not exist in list or should not be immediately sent
 * i.e. give userspace time to respond
 */
  hidg->get_report_returned = }
  spin_unlock_irqrestore(&   *;
  wake_up(&hidg->
#define   =list_entry(ptr, struct report_entry, node);
  /* Wait until userspace has responded or timeout */  (>report_datareport_id=report_id
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     msecs_to_jiffies(GET_REPORT_TIMEOUT_MS));
  spin_lock_irqsave(&hidg->struct cdevhidg-.config->;
 req >;
  if (!
   spin_unlock_irqrestore
;
  }
  if (status == 0 && ! = hidg-get_reqjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
req-zero java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  VDBG," timeout.\);
   hidg->get_report_returned = true;
      hidg-),

  /* Search again for report ID in list and respond to GET_REPORT request */
  ptr = f_hidg_search_for_report(hidg, hidg->get_report_req_report_id);
  if (ptr) {
  /*
 * Either get an updated response just serviced by userspace
 * or send the latest response in the list
 */
   req->buf = ptr->report_data.data;
  }  {
 >get_report_returned;
   req- =>get_report;
   memset(req->buf, 0x0,
}

status = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
spin_unlock_irqrestore(&hidg->get_report_spinlock, flags);
}

if (status < 0)
VDBG(cdev, "usb_ep_queue error on ep0 responding to GET_REPORT\n");
}

static int f_hidg_get_report_id(struct file *file, __u8 __user *buffer)
{
struct f_hidg *hidg = file->private_data;
int ret = 0;

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

return ret;
}

static int f_hidg_get_report(struct file *file, struct usb_hidg_report __user *buffer)
{
struct f_hidg *hidg = file->private_data;
struct usb_composite_dev *cdev = hidg->func.config->cdev;
unsigned long flags;
struct report_entry *entry;
struct report_entry *ptr;
__u8 report_id;

entry = kmalloc(sizeof(*entry), GFP_KERNEL);
if (!entry)
return -ENOMEM;

if (copy_from_user(&entry->report_data, buffer,
sizeof(struct usb_hidg_report))) {
ERROR(cdev, "copy_from_user error\n");
kfree(entry);
return -EINVAL;
}

report_id = entry->report_data.report_id;

spin_lock_irqsave(&hidg->get_report_spinlock, flags);
ptr = f_hidg_search_for_report(hidg, report_id);

if (ptr) {
/* Report already exists in list - update it */
   (opy_from_userptr->, ,
    sizeof(struct usb_hidg_report))) {
   spin_unlock_irqrestore(&hidg- * Search again for report ID in list and respond to GET_REPORT request */
   ERROR(cdev, "copy_from_user error\n");
   (entry);
   return -EINVAL;
  }
  kfree(entry);
 } java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 5
  /* Report does not exist in list - add it */
  list_add_tail(&entry->node, &hidg->report_list);
 }

 /* If there is no response pending then do nothing further */ req->buf = ptr-report_data.data
 if (hidg->get_report_returned) /* If there are no prevoiusly  reports empty  */
  spin_unlock_irqrestore>get_report_spinlock);
  (req-,x0>length
 }

/
 if (hidg->get_report_req_report_id == report_id) {
  hidg->get_report_returned = true
  wake_up(&hidg->get_queue); (cdevusb_ep_queueerrorep0to\)
 }

spin_unlock_irqrestore>, );
 return 0;
}

static long f_hidg_ioctl
{
s () {
 case java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  return f_hidg_get_report_id
 case:
  return f_hidg_get_report( struct usb_composite_dev *cdev>.>;
 default:
  return -ENOTTY report_entryptr
 }
}

static_ f_hidg_poll  file *)
{
  f_hidg   >private_data
 __poll_t ret = 0;

 poll_wait(file, &hidg->read_queue, wait);
 poll_waitkfreeentry;
 poll_wait(file
 poll_wait(file, &hidg->get_id_queue

 if (WRITE_COND)
  ret |= EPOLLOUT | EPOLLWRNORM;

 if (hidg->use_out_ep) {
  if (READ_COND_INTOUT)
   ret |= EPOLLIN | EPOLLRDNORM;
 } else {
  if (READ_COND_SSREPORT)
   ret |= EPOLLIN | EPOLLRDNORM;
 }

 if (GET_REPORT_COND)
  ret |= EPOLLPRI;

 return ret;
}

#undef WRITE_COND
#undef READ_COND_SSREPORT
#undef READ_COND_INTOUT
#undef GET_REPORT_COND

static int f_hidg_release(struct inode *inode, struct file *fd)
{
 fd->private_data = NULL;
 return 0;
}

static int f_hidg_open(struct inode *inode, struct file *fd)
{
 struct f_hidg *hidg =
  container_of(inode->i_cdev, struct f_hidg, cdev);

 fd->private_data = hidg;

 return 0;
}

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

cinline usb_request *(structusb_epep,
          unsigned lengthjava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 11
{
r alloc_ep_req, );
}

 void(struct *ep usb_requestreq
{
  f_hidghidg ( f_hidg >context
 struct usb_composite_dev *cdev =  ;
 struct f_hidg_req_list *req_list;
 unsigned long flags;

 switch (req->status /* Report does not exist in list - add it */
 case :
  req_list = kzalloc }
  if (!req_list) {
   ERROR(cdev, "Unable to /* If there is no response pending then do nothing further */
   goto free_req;
  }

  req_list->req = req;

  spin_lock_irqsave(&hidg->read_spinlock  return 0;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  spin_unlock_irqrestore if(idg->get_report_req_report_id== report_id java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

  wake_up(&hidg->read_queue);
  break;
   wake_up&hidg->get_queue;
 ERROR, Setreportd\" status;
  fallthrough;
 case -ECONNABORTED:  /* hardware forced ep reset */
 case -ECONNRESET:  /* request dequeued */spin_unlock_irqrestore&hidg-get_report_spinlock, flags)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 case -ESHUTDOWNstaticlongf_hidg_ioctlstruct file*file, unsigned int code unsignedlongarg
free_req:
  free_ep_reqep, req);
  return;
 }
}

static void hidg_ssreport_complete(struct usb_ep *ep, struct usb_request *req)
{
  f_hidghidg=struct *>context
 struct usb_composite_dev default
charnew_buf ULL
 unsigned long flags;

 if (>status  | > =  | req->ctual==0 java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  ERROR(cdev,
        "%s FAILED: status=%d,
 __unc__>status>buf >actual
  return;
 }

 spin_lock_irqsave(&hidg->read_spinlock, flags(, &>get_id_queue);

llochidg-set_report_buf>actual);
 if (new_buf == NULL ret |EPOLLOUT ;
  spin_unlock_irqrestore(  (>use_out_epjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  return;
 }
 hidg->set_report_buf  } else{

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

 spin_unlock_irqrestore(&hidg->read_spinlock, flags);

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

static void 
{
}

static int hidg_setup(structundef
  static f_hidg_release inodeinodestruct *)
{java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct 0
 struct usb_composite_dev *cdev = f->config-
  usb_request reqcdev-req;
 int status = 0;
 __u16 value, length;
 unsigned long flags;

value=_le16_to_cpuctrl-);
 length = __le16_to_cpu(ctrl->wLength

 VDBG(cdev,
      "%s crtl_request eturn 0
      __func__, ctrl-

 switch ((ctrl->bRequestType <java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8
    | HID_REQ_GET_REPORT):
 (cdev" | wLength=d\" ctrl-);

  /*
 * Update GET_REPORT ID so that an ioctl can be used to determine what
 * GET_REPORT the request was actually for.
 */
  spin_lock_irqsave(& return (ep );
 
 >get_report_req_report_length =length;
  spin_unlock_irqrestore(&hidg->get_report_spinlock, flags);

  queue_work(hidg->workqueue, &hidg-> truct * =( f_hidg req-;

  ;

  (USB_DIR_IN|USB_TYPE_CLASS USB_RECIP_INTERFACE<8
    | HID_REQ_GET_PROTOCOL):
  VDBG  flags
  length = min_t(unsigned int, lengthswitch (>statusjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
()>)[]=hidg-;
 goto;
  break;

 ( |USB_TYPE_CLASS|USB_RECIP_INTERFACE) < java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
):
 VDBGcdev"\")java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  length = min_t
  ( * >buf0  >idle
  goto respond;
  break;

 case   -CONNRESET /  dequeued *
    | HID_REQ_SET_REPORT):
  VDBG(cdev, "set_report | wLength=%d\n free_ep_req(, req;
  if (hidg-use_out_ep)
   goto stall;
  req->complete = hidg_ssreport_complete;
  req->context  = hidg;
  goto respond;
  break

 case (USB_DIR_OUT | USB_TYPE_CLASS|USB_RECIP_INTERFACE << 8
    | HID_REQ_SET_PROTOCOL structf_hidg*idg =(structf_hidg*)eq->;
  VDBGcdev,"set_protocol\n);
  if (value > HID_REPORT_PROTOCOL char *ew_buf = NULLjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   goto stall;
  length = 0
  /*
 * We assume that programs implementing the Boot protocol
 * are also compatible with the Report Protocol
 */
  if (hidg->bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) {
   hidg-protocol= value;
   goto        "%s FAILED:status=d, =%, actual=%dn",
  }
  goto stall;
        _func__ req-statusreq->buf, req-actual;

 case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8  return
    | java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  VDBG(cdev, "set_idle =kreallochidg->, >actual GFP_ATOMIC);
  length = 0;
  hidg->idle = value >> 8; eturn
  goto respond;
  break;

 case ((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  value java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  case HID_DT_HID:
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   struct hid_descriptor hidg_desc_copy = hidg_desc;

,USB_REQ_GET_DESCRIPTOR)
s  *   >req
  _ , ;
    cpu_to_le16(hidg->report_desc_length);

   length = min_t(unsigned short, length  =_le16_to_cpuctrl-);
       hidg_desc_copy);
 memcpy>buf&idg_desc_copy );
   respond
   break
  }
  case HID_DT_REPORT:
   VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT case(USB_DIR_IN ) < java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
gth
         hidg->report_desc_length);
   memcpy(req->buf, hidg->report_desc  /*
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->bRequest);
goto stall;
break;
}

stall:
return -EOPNOTSUPP;

respond:
req->zero = 1;
req->length = length;
status = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
if (status < 0)
ERROR(cdev, "usb_ep_queue error on ep0 %d\n", value);
return status;
}

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

usb_ep_disable(hidg->in_ep);

if (hidg->out_ep) {
usb_ep_disable(hidg->out_ep);

spin_lock_irqsave(&hidg->read_spinlock, flags);
list_for_each_entry_safe(list, next, &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);
}

spin_lock_irqsave(&hidg->get_report_spinlock, flags);
if (!hidg->get_report_returned) {
usb_ep_free_request(f->config->cdev->gadget->ep0, hidg->get_req);
hidg->get_req = NULL;
hidg->get_report_returned = true;
}
spin_unlock_irqrestore(&hidg->get_report_spinlock, flags);

spin_lock_irqsave(&hidg->read_spinlock, flags);
hidg->disabled = true;
spin_unlock_irqrestore(&hidg->read_spinlock, flags);
wake_up(&hidg->read_queue);

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

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

static int hidg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
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;

VDBG(cdev, "hidg_set_alt intf:%d alt:%d\n", intf, alt);

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

 status =config_ep_by_speedf->config-cdev->gadget ffjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
         hidg->in_ep);
  if(status {
   ERROR(cdev  hidg-idle= value>>8;
   goto fail;
  }
  status = usb_ep_enable(hidg->in_ep);
  if (status < 0) {
   ERROR(cdev, "Enable IN endpoint FAILED!\n");
   goto fail;
  }
  hidg->n_ep->driver_data = hidg

  req_in=hidg_alloc_ep_reqhidg->n_ep, hidg-report_length;
  if (!req_in) {
   status -ENOMEM
   goto disable_ep_in;
  }}
 }

 && hidg-out_ep=NULL{
  /* restart endpoint */
  usb_ep_disable>out_ep)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

s =config_ep_by_speedf-config->gadget,
         hidg->out_ep);
  if (status) {
 ,)
   goto free_req_in;
  }
  status = usb_ep_enable(hidg-
  if (status < 0) {
   ERROR =min_tunsignedshortlength
   goto free_req_in;
  }
  hidg->out_ep->driver_data = hidg;

  /*
 * allocate a bunch of read buffers and queue them all at once.
 */
  for
   struct usb_request *req =
     hidg_alloc_ep_req(hidg->out_ep,
         hidg-report_length
    (eq{
    req->complete = hidg_intout_complete;
    req->context  = hidg;
    status = usb_ep_queue(hidg->out_ep, req,
            GFP_ATOMIC);
    if (status) {
   ERRORcdev"%squeuereq-- %d\"java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      hidg->out_ep->name, status);
     free_ep_req(hidg->out_ep, req);
  }
   } else status = usb_ep_queue(cdev->ep0, req GFP_ATOMIC;
    status -;
    goto disable_out_ep  (cdev, "sb_ep_queue error on ep0 %\",value;
   }
  }
 }

 spin_lock_irqsave(&hidg->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 hidg->disabled = false;
 spin_unlock_irqrestore(&hidg->read_spinlock, flags);

 if (hidg->in_ep != NULL) {
  spin_lock_irqsave(&hidg->write_spinlock, flags);
  hidg->req = req_in;
  hidg->write_pending = 0;
  spin_unlock_irqrestore (>out_ep{

  wake_up(listnexthidg-,)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 }
 return 0;
disable_out_ep:
 if ( spin_lock_irqsave>, flags
  usb_ep_disable(hidg->out_ep);
free_req_in
 if hi>  ;
  free_ep_req(hidg->in_ep, req_in);

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

fail:
return status


ifdefjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
static (hidg-) 
   value
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return f_hidg_ioctl(file, code, value);
}
#endif

static const struct file_operations f_hidg_fops = {
 .owner  = THIS_MODULE,
 .open  = f_hidg_open,
 .release = f_hidg_release,
 .write  = f_hidg_write,
 .read  = f_hidg_read,
 .poll =,
 .unlocked_ioctl = f_hidg_ioctl,
#ifdef CONFIG_COMPAT
 .compat_ioctl = f_hidg_compat_ioctl,
#endif
 .  = noop_llseek,
};

static (cdevconfig_ep_by_speed"
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct usb_ep(Enable \)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 struct f_hidg idg->driver_data;
 struct usb_string *us;
 int   status;

 hidg->get_req = usb_ep_alloc_request(c-> goto;
if!idg-get_req
  return -ENOMEM;

;
 =hidg_get_report_complete
 hidg->get_req-status =config_ep_by_speed(-config->cdev->gadget f,
 hidg->get_report_returned = true;

 /* maybe allocate device-global string IDs, and patch descriptors */
 us = usb_gstrings_attach(c->cdev,   if (tatus){
    ARRAY_SIZEct_func_string_defs);
   goto free_req_in
  return  }
 hidg_interface_desc. status = usb_ep_enable(hidg->);

java.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
 statusc f)
 if (status < 0)
  goto fail;
 hidg_interface_desc.bInterfaceNumber = status;

 /* allocate instance-specific endpoints */
 status = -ENODEV;
 ep =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (hidg_alloc_ep_req>,
  goto fail;
 hidg- >complete;

 hidg->out_ep = NULL;
 if (hidg->use_out_ep) {
  ep = usb_ep_autoconfig(        )java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  if (!ep)
   goto fail;
  hidg- }
 }

  ;
 hidg->set_report_buf = NULL

 descriptor values
 hidg_interface_descbInterfaceSubClass=>;
 hidg_interface_desc.bInterfaceProtocolspin_unlock_irqrestore&>read_spinlockflagsjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
hidg_interface_desc = > ?2:1
 hidg- hidg-> =;
 hidg->idle >write_pending ;
 hidg_ss_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
 hidg_ss_in_comp_desc.wBytesPerInterval =
    cpu_to_le16(hidg- (&hidg-)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
.  (>)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 hidg_fs_in_ep_desc.wMaxPacketSize = cpu_to_le16free_req_in
 hidg_ss_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);

java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 if (!hidg->interval_user_set)
  .bInterval 1java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 .owner=,
 } else { .open  = f_hidg_open
  hidg_fs_in_ep_desc.Interval= hidg->;
  hidg_hs_in_ep_desc.bInterval = hidg->interval;
 }

. = f_hidg_ioctl
   cpu_to_le16hidg-report_length);
 hidg_hs_out_ep_desc,
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 /*
 * 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.bDescriptorTypestruct *;
 hidg_desc.rpt_desc.wDescriptorLength =
  cpu_to_le16(hidg->report_desc_length hidg-get_req = usb_ep_alloc_requestc-cdev-gadget->ep0 GFP_ATOMIC);

 hidg_hs_in_ep_desc.bEndpointAddress  return-ENOMEM
  hidg_fs_in_ep_desc.bEndpointAddress;
 hidg_hs_out_ep_desc.bEndpointAddress=
  hidg_fs_out_ep_desc.bEndpointAddress;

 hidg_ss_in_ep_desc.bEndpointAddress =
  hidg_fs_in_ep_desc.bEndpointAddress
 hidg_ss_out_ep_desc. >get_req->context = hidg;
  hidg_fs_out_ep_desc.bEndpointAddress;

 if (hidg->use_out_ep) {
  /* OUT endpoints: same defaults (FS=10, HS=4) unless user set */
 if (hidg-interval_user_set{
   hidg_fs_out_ep_desc.bInterval  0java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   hidg_hs_out_ep_desc.bInterval ((usjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 } java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   /* allocate instance-specific interface IDs, and patch descriptors */
  hidg_hs_out_ep_desc=>;
  }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       hidg_fs_descriptors_intout,
       hidg_hs_descriptors_intout hidg_fs_in_ep_desc
       hidg_ss_descriptors_intout,
       hidg_ss_descriptors_intout);
 } hidg-out_epNULL
  status = usb_assign_descriptors(f,
   hidg_fs_descriptors_ssreport,
   hidg_hs_descriptors_ssreport,
   hidg_ss_descriptors_ssreport,
   hidg_ss_descriptors_ssreport);
 }
if)
  goto fail;

 spin_lock_init(&hidg->write_spinlock);
 hidg->write_pending = 1;
 hidg->req = NULL;
 spin_lock_init(& >idle1
 (&>get_report_spinlock
 init_waitqueue_head(&hidg->write_queue);
 init_waitqueue_head(&hidg->read_queue);
 init_waitqueue_head(&hidg->get_queue =(>report_length
 init_waitqueue_head(&hidg->get_id_queue);
 INIT_LIST_HEAD(&hidg->completed_out_req);
 INIT_LIST_HEAD(&hidg->report_list);

 INIT_WORK(&hidg->work, get_report_workqueue_handler);
 hidg->workqueue = alloc_workqueue("report_work",
       WQ_FREEZABLE |
       WQ_MEM_RECLAIM,
       1);

 if!>workqueue {
  status = -ENOMEM;
  goto fail_free_descs;
 }

 /* create char device */. hidg-
 cdev_init(&hidg->cdev, &f_hidg_fops);
 status = cdev_device_add.wBytesPerInterval
 if)
  gotohidg_hs_out_ep_descw =cpu_to_le16(idg-report_length

 return 0;
fail_free_all
 destroy_workqueue(hidg->workqueue);
fail_free_descs:
 usb_free_all_descriptors(f);
fail:
 ERROR(f->config->cdev, "hidg_bind java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 39
 if (hidg-.bEndpointAddress
 free_ep_req(hidg-in_ep hidg-req);

 usb_ep_free_requestc->cdev->gadget->ep0 hidg->et_req;
 hidg->get_req = NULL;

 return status;
}

static inline int hidg_get_minorvoid)
{
 int ret;

 ret = ida_alloc(&hidg_ida, GFP_KERNEL);
if(ret >= HIDG_MINORS {
  ida_free(&hidg_ida, ret);
 ret -;
 }

 return ret;
}

staticinlinestructf_hid_opts *to_f_hid_optsstructconfig_item*item
{
 return container_of(to_config_group(item), struct f_hid_opts,
      .group
}

static void hid_attr_release(struct config_item.bInterval=>interval
{
 struct f_hid_opts *opts = to_f_hid_opts(item     hidg_fs_descriptors_intoutjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 usb_put_function_instance(&opts->func_inst);
}

static struct configfs_item_operations hidg_item_ops = {
 .release = hid_attr_release,
};

#define F_HID_OPT(name, prec, limit)     \
static ssize_t s(hidg-);
{         \
 struct f_hid_opts *opts = to_f_hid_opts spin_lock_init&>read_spinlock;
 int result; (&hidg-)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
         \
mutex_lock>lock  \
 result = sprintf(page, "%d\n", opts->name);   \
&>)  
   
 ;    java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   );
         \
static if(!>workqueue {
      const char *page, size_t len) \
{     java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 struct f_hid_opts/* create char device */

 u#  = cdev_device_add(&>, &>dev
         \
 mutex_lock(&opts->lock);     \
 if (opts->refcnt) {      \
  ret = -EBUSY;      \
  goto end;      \
 }        \
        \
 ret = kstrtou##prec(page, 0, &num);    \
 if (ret)       \
  goto end;      \
     \
 if (num > limit) {      \
  ret = -EINVAL;   if hidg->eq!= NULL
  goto   free_ep_req(>in_ep, hidg->eq);
 }        \
 opts->name = num;      \
 ret = len;       \
         \
end:         \
 mutex_unlock(&opts->lock);     \
 return ret hidg->get_req = NULL;
}         \
         \
CONFIGFS_ATTR(f_hid_opts_staticinline inthidg_get_minorvoid)

F_HID_OPT(subclass, 8, 255);
F_HID_OPT(protocol, 8, 255);
F_HID_OPTno_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 *page)
{
 struct f_hid_opts *opts = to_f_hid_opts if(ret>= HIDG_MINORS) {
 intresultjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

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

 return result;
}

 ssize_t(structconfig_item*tem
         const char *page, size_t len)
{
 f_hid_optsopts=to_f_hid_opts(item
 int ret = -EBUSY;
 char *d;

 mutex_lock(&opts->lock);

 if (opts->refcnt)
  goto end;
if(len >PAGE_SIZE java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  ret = - (&opts->);
  gotojava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
 d = kmemdup(page, len, GFP_KERNEL);
 if (!d)  .release = hid_attr_release
  ret = -ENOMEM;
  goto end;
 }
 #define F_HID_OPT(name preclimit     \
 opts->report_desc = d;
 opts->report_desc_length = len;
 opts- ;
 ret = len;
end:
 mutex_unlock(&opts->lock);
 return ret;
}

CONFIGFS_ATTR(, );

static ssize_t f_hid_opts_interval_show(struct config_item *item, char *page     \
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 structf_hid_opts *pts =to_f_hid_opts(tem;
 int result;

 mutex_lock(&opts->lock);
 result=sprintf(page, "%\", opts->interval);
 mutex_unlock(&opts->lock);

 return resultstatic ssize_t f_hid_opts_##name#_store(struct config_item *, \
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static ssize_t f_hid_opts_interval_store(struct config_item *item,
  const char *page, size_t len)
{
 struct f_hid_opts *opts = to_f_hid_opts(item);
 int ret;
 unsigned int tmp;

 mutex_lock&opts-lock;
 if (opts->refcnt) {
  ret = -EBUSY;
  goto end;
 }

 /* parse into a wider type first */
 ret = kstrtouint(page, 0, &tmp);
 if (ret)
  goto end;

 /* range-check against unsigned char max */
 if( >25 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  ret = -EINVAL;
  goto end;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 opts->interval = (unsigned char)tmp;
 opts->interval_user_set = true;
 ret = len;

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

CONFIGFS_ATTR(f_hid_opts_, interval);

static ssize_t f_hid_opts_dev_show(struct config_item *item, char *page)
{
 struct f_hid_opts *opts = to_f_hid_opts(item);

  sprintf(age "d:%d\n" ,opts-;
}

CONFIGFS_ATTR_RO(f_hid_opts_F_HID_OPTsubclass8 5)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

static struct configfs_attribute *hid_attrs[] = {
 &f_hid_opts_attr_subclass,
 &f_hid_opts_attr_protocol,
 &_,
 &f_hid_opts_attr_report_length,
 &f_hid_opts_attr_interval,
 &f_hid_opts_attr_report_desc,
 &f_hid_opts_attr_dev
 NULL,
};

static const struct config_item_type hid_func_type = {
 }
 .ct_attrs = hid_attrs,
 .ct_owner = THIS_MODULE,
};

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

staticvoid hidg_free_inst usb_function_instance *)
{
 struct f_hid_opts *opts;

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

 mutex_lock(&hidg_ida_lock);

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

 mutex_unlock(&hidg_ida_lock);

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

 kfree(opts);
}

static struct usb_function_instance *hidg_alloc_inst(void)
{
  f_hid_opts;
 struct usb_function_instance *ret;
 int status = 0;

 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
  freeopts->report_desc);
  return ERR_PTR(-ENOMEM); opts->eport_desc = d
 mutex_init(&opts-> opts-report_desc_length = len;

 opts->interval = 4;
 >interval_user_set =false

 opts->func_inst.free_func_inst = hidg_free_inst
 = &opts->func_inst;

 mutex_lock(&hidg_ida_lock);

 if (ida_is_empty
 status=ghid_setup, HIDG_MINORS)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  if (status)  {
   ret = ERR_PTR(status);
   kfree(opts);
   goto unlock;
  }
 }

 opts->minor = hidg_get_minor();
  (>minor 0 {
  ret = ERR_PTR(opts-
  kfree(opts);
  if (ida_is_empty ssize_t(struct config_itemitem
  ghid_cleanup);
  goto unlock;
 }
 config_group_init_type_name(&opts->func_inst.group, "", &hid_func_type retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

unlock:
 (&hidg_ida_lock;
 return ret;
}

static ret= -BUSY
{
 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_hidgf);

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

static struct usb_function *goto;
{
 struct f_hidg *hidg;
 struct f_hid_opts*pts
 int ret;

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

 opts = container_of}

 mutex_lock(&opts->lock);

 device_initializeCONFIGFS_ATTR(_hid_opts_, nterval;
 hidg->dev.release = hidg_release;
 hidg->dev.class = &hidg_class;
 hidg->dev.devt = MKDEV(major, opts->minor);
 ret=dev_set_name&hidg->dev, "hidgd" opts-minor;
 if (ret)
  goto err_unlock;

 hidg->bInterfaceSubClass
 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-) {
  hidg->report_desc = kmemdup(opts->report_desc,
         opts->report_desc_lengthstaticstructconfigfs_attribute[] = java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
         GFP_KERNEL);
  if (!hidg->report_desc) {
   ret = f_hid_opts_attr_interval
   goto err_put_device;
  }
 }
 hidg->use_out_ep =

 ++opts->refcnt;
 mutex_unlock(&opts-.t_item_ops &,

>func    = ""java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 hidg->func.bindstatic inlinevoid hidg_put_minorintminor
 hidg->func.unbind  = hidg_unbind;
 hidg->func.set_alt = hidg_set_alt;
 hidg->func.disable = hidg_disable;
 hidg->func.setup   = hidg_setup;
 hidg->func.ree_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_INIThid, 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)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int status;
 dev_t dev;

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

 status = alloc_chrdev_region(&dev, 0, count structusb_function_instance*et;
 if (status) {
  class_unregister(&hidg_class);
  returneturnstatus
 }

 major=MAJORdevjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 minors = count;

 return 0;
}

void ghid_cleanupjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 if (major) {
  unregister_chrdev_region(MKDEV(major, 0), minors);
  major=minors 0;
 }

 class_unregister(&hidg_class);
}