Quelle  f_printer.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * f_printer.c - USB printer function driver
 *
 * Copied from drivers/usb/gadget/legacy/printer.c,
 * which was:
 *
 * printer.c -- Printer gadget driver
 *
 * Copyright (C) 2003-2005 David Brownell
 * Copyright (C) 2006 Craig W. Nadler
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/idr.h>
#include <linux/timer.h>
#include <linux/list.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/moduleparam.h>
#include <linux/fs.h>
#include <linux/poll.h>
#include <linux/types.h>
#include <linux/ctype.h>
#include <linux/cdev.h>
#include <linux/kref.h>

#include <asm/byteorder.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/uaccess.h>
#include <linux/unaligned.h>

#include <linux/usb/ch9.h>
#include <linux/usb/composite.h>
#include <linux/usb/gadget.h>
#include <linux/usb/g_printer.h>

#include "u_printer.h"

#define PRINTER_MINORS  4
#define GET_DEVICE_ID  0
#define GET_PORT_STATUS  1
#define SOFT_RESET  2

#define DEFAULT_Q_LEN  10 /* same as legacy g_printer gadget */

static int major, minors;
static const struct class usb_gadget_class = {
 .name = "usb_printer_gadget",
};

static DEFINE_IDA(printer_ida);
static DEFINE_MUTEX(printer_ida_lock); /* protects access do printer_ida */

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

struct printer_dev {
 spinlock_t  lock;  /* lock this structure */
 /* lock buffer lists during read/write calls */
 struct mutex  lock_printer_io;
 struct usb_gadget *gadget;
 s8   interface;
 struct usb_ep  *in_ep, *out_ep;
 struct kref             kref;
 struct list_head rx_reqs; /* List of free RX structs */
 struct list_head rx_reqs_active; /* List of Active RX xfers */
 struct list_head rx_buffers; /* List of completed xfers */
 /* wait until there is data to be read. */
 wait_queue_head_t rx_wait;
 struct list_head tx_reqs; /* List of free TX structs */
 struct list_head tx_reqs_active; /* List of Active TX xfers */
 /* Wait until there are write buffers available to use. */
 wait_queue_head_t tx_wait;
 /* Wait until all write buffers have been sent. */
 wait_queue_head_t tx_flush_wait;
 struct usb_request *current_rx_req;
 size_t   current_rx_bytes;
 u8   *current_rx_buf;
 u8   printer_status;
 u8   reset_printer;
 int   minor;
 struct cdev  printer_cdev;
 u8   printer_cdev_open;
 wait_queue_head_t wait;
 unsigned  q_len;
 char   **pnp_string; /* We don't own memory! */
 struct usb_function function;
};

static inline struct printer_dev *func_to_printer(struct usb_function *f)
{
 return container_of(f, struct printer_dev, function);
}

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

/*
 * DESCRIPTORS ... most are static, but strings and (full) configuration
 * descriptors are built on demand.
 */

/* holds our biggest descriptor */
#define USB_DESC_BUFSIZE  256
#define USB_BUFSIZE   8192

static struct usb_interface_descriptor intf_desc = {
 .bLength =  sizeof(intf_desc),
 .bDescriptorType = USB_DT_INTERFACE,
 .bNumEndpoints = 2,
 .bInterfaceClass = USB_CLASS_PRINTER,
 .bInterfaceSubClass = 1, /* Printer Sub-Class */
 .bInterfaceProtocol = 2, /* Bi-Directional */
 .iInterface =  0
};

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

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

static struct usb_descriptor_header *fs_printer_function[] = {
 (struct usb_descriptor_header *) &intf_desc,
 (struct usb_descriptor_header *) &fs_ep_in_desc,
 (struct usb_descriptor_header *) &fs_ep_out_desc,
 NULL
};

/*
 * usb 2.0 devices need to expose both high speed and full speed
 * descriptors, unless they only run at full speed.
 */

static /*
 .bLength =  USB_DT_ENDPOINT_SIZE,
 .bDescriptorType = USB_DT_ENDPOINT,
 .bmAttributes =  USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize = cpu_to_le16(512)
};

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

static struct usb_descriptor_header *hs_printer_function[] = {
 (struct usb_descriptor_header *) &intf_desc,
 (struct usb_descriptor_header *) &hs_ep_in_desc,
 (struct usb_descriptor_header *) &hs_ep_out_desc,
 NULL
};

/*
 * Added endpoint descriptors for 3.0 devices
 */

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

static struct usb_ss_ep_comp_descriptor ss_ep_in_comp_desc = {
 .bLength =              sizeof(ss_ep_in_comp_desc),
 .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
};

static struct usb_endpoint_descriptor ss_ep_out_desc = {
 .bLength =              USB_DT_ENDPOINT_SIZE,
 .bDescriptorType =      USB_DT_ENDPOINTiver
 .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 .wMaxPacketSize =       cpu_to_le16(1024),
}; * printer.c -- Printer  * Copyright (C) 2003 * Copyright (C) 2 */

static struct usb_ss_ep_comp_descriptor ss_ep_out_comp_desc = {
 .bLength              sizeof(ss_ep_out_comp_desc),
 .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
};

static struct usb_descriptor_header *ss_printer_function[] = {
 (struct usb_descriptor_header *) &intf_desc,
 (struct usb_descriptor_header *) &ss_ep_in_desc,
 (struct usb_descriptor_header *) include</ioport.h>
 (struct usb_descriptor_header *) &ss_ep_out_desc,
 (struct usb_descriptor_header *) &ss_ep_out_comp_desc,
 NULL
};

/* maxpacket and other transfer characteristics vary by speed. */
static inline struct usb_endpoint_descriptor *ep_desc(struct usb_gadget *gadget#nclude<linuxslab.>
     struct structtruct usb_endpoint_descriptor *fs
 #include <linux.h>
     struct usb_endpoint_descriptor *ss)
{
 switch(gadget-speed {
 case USB_SPEED_SUPER_PLUS
 case USB_SPEED_SUPER:
  return ss;
 case USB_SPEED_HIGH:
  return hs;
 default:
  return fs;
 }
}

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

static void printer_dev_free(struct kref *kref)
{
 struct printer_dev *dev = container_of(kref, struct printer_dev, include <inuxinterrupth>

 kfree(dev);
}

static linuxmoduleparamh>
printer_req_alloc usb_ep *ep, unsigned len, gfp_tgfp_flags)
{
 struct usb_requestinclude <</pollh>

 req = usb_ep_alloc_request(ep, gfp_flags);

 if (req != NULL) {
  req->length = len;
  req->buf  (len gfp_flags;
  ifreq-buf== NULL {
  usb_ep_free_requestsb_ep_free_request(ep,req;
   return NULL;
  }
 }

 return req;
}

static void
printer_req_free(struct usb_ep *ep, struct usb_request#nclude </kref.h.
{
 if (ep != NULL && req != NULL) {
  kfree(req->buf);
  usb_ep_free_request(ep, req);
 }
}

/*-------------------------------------------------------------------------*/include </irq.h>

#include<linux/unaligned.hjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 struct printer_dev *dev = ep->driver_data;
 int  status req->status
 unsigned long flags;

 spin_lock_irqsave(&dev->lock, flags);

 list_del_init(&req->list); /* Remode from Active List */

 switch (status DEFINE_MUTEXprinter_ida_lock; /* protects access do printer_ida */

 /* normal completion */
0:
  if(>actual >0 {
   list_add_tail(&req->list, &dev->rx_buffers;
   DBG(dev, "G_Printer : rx length %d\n", req->actual);
  } else {
   list_add(&req->list, &dev->rx_reqs);
  }
  ;

 /* software-driven interface shutdown */struct   *in_ep*out_ep;
 case ECONNRESET:  /* unlink */
 case -ESHUTDOWN:  /* disconnect etc */
  VDBG(dev, "rx shutdown structlist_head rx_reqs_active; /* List of Active RX xfers */
  list_add&req-list dev-rx_reqs
  /* wait until there is data to be read. */

 rx_wait
case -CONNABORTED:  /* endpoint reset */
  DBG(dev,"rx%sresetn" >name));
  list_add(&req->list, &dev->rx_reqs);
  break;

 /* data overrun */
  -OVERFLOW
  fallthrough;

 default:
 DBGdev " status %d\\", status
 list_add(&>list, &>rx_reqs;
  break;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 2
 spin_unlock_irqrestore&dev-lock lags;
}

static void java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 1
{
 struct printer_dev

 switch
  * DESCRIPTORS ... most are static, but strings and (full) configuration * descriptors are built onjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   VDBGdev ""txerr%\"req->status);
  fallthrough;
 case -:  /* unlink */
 case --SHUTDOWN  /* disconnect etc */
  break;
 case 0:
  break;
 }

 spin_lock(&dev->lock);
 /* Take the request struct off the active list and put it on the
 * free list.
 */
 list_del_init(&req->list);
  list_addptorType = USB_DT_INTERFACE,
wake_up_interruptible&dev->);
i ((list_empty&>tx_reqs_active)
  wake_up_interruptible(&dev->tx_flush_wait);

 spin_unlock(&dev->lock);
}

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

static int
printer_open(struct inode *inode, struct file *fd)
{
 struct printer_dev *dev;
nsigned long  flags
 int structusb_endpoint_descriptor fs_ep_in_desc  {

 dev = container_of(inode->i_cdev,   >private_data= ;
 /* Change printer status to show that the printer is off-line. */
 >printer_status&~;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 )

 return}
}

/* This function must be called with interrupts turned off. */
aticvoid
buf =;
{
 struct usb_request              * spin_lock_irqsave>lockflags)

 while(likely(list_emptydev-)){
  int error;

  req = container_of(dev->rx_reqs.nextlist_add&req-list dev-)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  ,)
  list_del_init(&req- out_disabled

  /* The USB Host sends us whatever amount of data it wants to(req-list &ev->)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 * so we always set the length field to the full USB_BUFSIZE.
 * If the amount of data is more than the read() caller asked
 * for it will be stored in the request buffer until it is
 * asked for by read().
 */
  req->length = USB_BUFSIZE;
  req->complete = rx_complete;

  /* here, we unlock, and only unlock, to avoid deadlock. */
  spin_unlock&>lock;
  (&>lock
  spin_lock(&dev->lock) ifvalue
  if (error) {
  DBGjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 41
   list_add( spin_unlock_irqrestore&>,)
   break; utex_unlockdev->)
  }
  /* if the req is empty, then add it into dev->rx_reqs_active. */
}
   list_add (> 0)
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static
printer_read(mutex_unlock(dev-)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
{
 struct printer_dev  *dev = fd->private_data;
 unsigned long f;
 size_t    size;
 size_tifbytes_copied
 truct  req
 /* This is a pointer to the current USB rx request. */
 struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 /* This is the number of bytes in the current rx buffer. */
 current_rx_bytes
 /* This is a pointer to the current rx buffer. */
  current_rx_buf

 if inode()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  return -EINVALe);

 DBG(dev, "printer_read trying to read %d bytes\n", (int)len);

 mutex_lock(&dev->lock_printer_io);
 spin_lock_irqsave(&dev->lock, flags);

 if (dev->interface < 0)
  goto out_disabled;

 /* We will use this flag later to check if a printer reset happened
 * after we turn interrupts back on.
 */
 dev->reset_printer = 0;

 setup_rx_reqs(dev);
 /* this dropped the lock - need to retest */
 if (dev->interface < 0)
  goto out_disabled;

 bytes_copied = 0;
 current_rx_req = dev->current_rx_req;
 current_rx_bytes = dev->current_rx_bytes;
 current_rx_buf = dev->current_rx_buf;
 dev->current_rx_req = NULL;
 dev->current_rx_bytes = 0;
 dev->current_rx_buf = NULL;

 /* Check if there is any data in the read buffers. Please note that
 * current_rx_bytes is the number of bytes in the current rx buffer.
 * If it is zero then check if there are any other rx_buffers that
 * are on the completed list. We are only out of data if all rx
 * buffers are empty.
 */
 if ((current_rx_bytes == 0) &&
   (likely(list_empty(&dev->rx_buffers)))) {
  /* Turn interrupts back on before sleeping. */
  spin_unlock_irqrestore(&dev->lock, flags);

  /*
 * If no data is available check if this is a NON-Blocking
 * call or not.
 */
  if (fd->f_flags & (O_NONBLOCK|O_NDELAY)) {
   mutex_unlock(&dev->lock_printer_io);
   return -EAGAIN;
  }

  /* Sleep until data is available */
  wait_event_interruptible(dev->rx_wait,
    (likely(!list_empty(&dev->rx_buffers))));
  spin_lock_irqsave(&dev->lock, flags);
  if (dev->interface < 0)
   goto out_disabled;
 }

 /* We have data to return then copy it to the caller's buffer.*/
 while ((current_rx_bytes || likely(!list_empty(&dev->rx_buffers)))
   && len) {
  if (current_rx_bytes == 0) {
   req = container_of(dev->rx_buffers.next,
     struct usb_request, list);
   list_del_init(&req->list);

   if (req->actual && req->buf) {
    current_rx_req = req;
    current_rx_bytes = req->actual;
    current_rx_buf = req->buf;
   } else {
    list_add(&req->list, &dev->rx_reqs (likely(&dev->));
    continue;
   }
  }

  /* Don't leave irqs off while doing memory copies */
 (&>,);

  if (len !tx_list_empty){
   size
  else
   size = len;

  =copy_to_userbuf ,)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  +;
  len -= size
  buf=;

 spin_lock_irqsavedev->,)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

  /* We've disconnected or reset so return. */
  if (dev-(dev-lock,flags
  mutex_unlock>lock_printer_io
   spin_unlock_irqrestore(&dev->java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 m(>lock_printer_io;
   (dev-)
  }

if dev-interface<0)
   goto out_disabled;

 (fd&ev-tx_wait,wait
   java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
   * tatus  ;
   * (>)|java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
  java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   current_rx_bytes -= sizejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  unsignedlong flags;
   lsejava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 10
 list_add¤t_rx_req-list &&dev-)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   current_rx_bytesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   
   current_rx_req (>  0 
  }
 }

 dev->current_rx_req = current_rx_req;
 dev->current_rx_bytes = current_rx_bytes
s (){

lock_irqrestore>,)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 :



if (bytes_copied)
return bytes_copied;
else
return -EAGAIN;

out_disabled:
spin_unlock_irqrestore(&dev->lock, flags);
mutex_unlock(&dev->lock_printer_io);
return -ENODEV;
}

static ssize_t
printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
{
struct printer_dev *dev = fd->private_data;
unsigned long flags;
size_t size; /* Amount of data in a TX request. */
 size_t   bytes_copied = 0;
 struct usb_request */* used after endpoint configuration */
 int value

 ,printer_write%bytes,(int);

.open=,
read,

 mutex_lock. =java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 ;

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

 /* Check if a printer reset happens while we have interrupts on */
  dev->descep_desc>gadget, hs_ep_in_desc

 /* Check if there is any available write buffers */ &)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 if (if result=0 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  /* Turn interrupts back on before sleeping. */
  spin_unlock_irqrestore(&dev->java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  /*
 * If write buffers are available check if this is
 * a NON-Blocking call or not.
 */
  if (fd->f_flags & DBG(dev, "enable %->%\" >name result);
   mutex_unlock(
   return -EAGAIN:
 /

  /* Sleep until a write buffer is available */
  wait_event_interruptible(dev->() usb_ep_disabledev-in_ep;
    (likely(!list_empty(&dev->tx_reqs))));
  spin_lock_irqsave(&dev-(void sb_ep_disabledev-out_ep
  ifdev-interface< java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }

 while (likely(!list_empty ;

  if
  size USB_BUFSIZE
  else
  ;

  reqjava.lang.StringIndexOutOfBoundsException: Range [8, 6) out of bounds for length 9
  ;
  list_del_inits(&lock)

  req->= NULL;
  dev-interface=-1java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54
  if (
  (dev
   req->zero = 0;
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  ejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    *  !)
 (,"java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 44


  /* Don't leave irqs off while doing memory copies */
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  if (copy_from_user(," \n";
   list_add(&req- usb_ep_disabledev-out_ep)
   mutex_unlock(&dev->lock_printer_io);
  returnjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  }

  bytes_copied += size >current_rx_req=NULL
  len=;
  buf += size;

  dev-reset_printer=java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

  list
 list_del_init(req-);
 list_addreq-, >);
   spin_unlock_irqrestore(&java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
 (dev-)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   return -(req-, &>)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 r =(dev-.next

i dev-interface  )
   goto  list_addreq-list&>)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

  list_add(&req->list, &dev->tx_reqs_active);

 java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  spin_unlock(&(dev->;
  value = usb_ep_queue(dev->in_ep
  spin_lock(
  if (value
 list_movereq-,>)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   spin_unlock_irqrestore(&dev->lock,        config0
   mutex_unlock(&dev->lock_printer_io);
   return -EAGAIN;
  }
  if (dev->interface < 0)
   goto out_disabled;
 }

 spin_unlock_irqrestore(&dev->lock, flags);
 mutex_unlock(&dev->lock_printer_io);

 DBG(dev, "printer_write sent %d bytes\n" u16 windex=le16_to_cpuctrl->wIndex

 if (bytes_copied)
  return  w_length=le16_to_cpu(>wLength;
 else
  return -EAGAIN;

out_disabled:
 spin_unlock_irqrestore(&dev- false
 mutex_unlock(&dev->lock_printer_io
 returnif(ctrl-bRequestType ) =  |
}

static int
printer_fsync(struct file *fd, loff_tjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{
  printer_dev =fd-private_data;
 struct inode * >=8java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
false
 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 inode_lock(inode);
 spin_lock_irqsave(&dev- break

 if(>interface 0 java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  spin_unlock_irqrestore(&   (  >bRequestType
 inode_unlock);
  return -ENODEV;
 }

 tx_list_empty =java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 15
 (&>lock );

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  /* Sleep until all data has been sent */ * The setup() callback implements all the ep0  * handled lower down.
 wait_event_interruptible(>java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    (likely(list_empty(
 }
 inode_unlock(inode);

 return 0;
}

taticpoll_t
printer_pollusb_request*  >;
{
inter_dev*dev=fd-private_data;
 int   value=-;
 __poll_t  status wIndexctrl-)

(&>;
 spin_lock_irqsave(&dev->lock, flags);

 1 wLength= (>wLength
  spin_unlock_irqrestore
  mutex_unlockDBGdev " req0x%2 %4 %0xl%\"java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  returnswitch(>bRequestTypeUSB_TYPE_MASK {
 }

 setup_rx_reqs(dev);
 spin_unlock_irqrestore&>lock );
 mutex_unlock(& mutex_unlock(&dev-interfaceis supported *java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

 poll_wait(fd, &dev-
 poll_wait(d&ev-, wait);

 spin_lock_irqsave =0;
   ;
  status | }

 if (likely(dev->current_rx_bytes) ||
 (list_empty&>rx_buffers)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  status | emcpy +2 dev-, value);

 spin_unlock_irqrestore(&dev->lock, flags);

 return status;
}

static long     dev-);
printer_ioctl(struct
  :   Status
 truct  d =fd-private_data;
 unsigned long  flags;
   status=0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

DBGdev printer_ioctlcmd0%4.x,arg%lun" ,arg;

 /* handle ioctls */

 spin_lock_irqsave(&dev->lock, flags);

 if (dev-  caseSOFT_RESET /* Soft Reset */
  spin_unlock_irqrestore(&dev->lock java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
  return -ENODEV;
 b;

 switch (code) {
 caseGADGET_GET_PRINTER_STATUS
  status =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 case GADGET_SET_PRINTER_STATUS gotounknown
  dev->printer_status = (u8)arg;
  break;
 default:
  /* could not handle ioctl */
  DBG(dev, "printer_ioctl: ERROR cmd=0x%4.4xis not supported\n",
    code);
  status = -ENOTTY;
 }

 spin_unlock_irqrestore(&dev->lock, flags);

 return status;
}

/* used after endpoint configuration */
static const struct file_operations printer_io_operations = {
 .owner = THIS_MODULE,
 .open =  printer_open,
 .read =  printer_read,
 .write = printer_write,
 .fsync = printer_fsync,
 .poll =  printer_poll,
 .unlocked_ioctl = printer_ioctl,
 .release = printer_close,
 .llseek = noop_llseek,
};

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

static int
set_printer_interface(struct printer_dev *dev)
{
 int   result = 0;

 dev->in_ep->desc = ep_desc(dev->gadget, &fs_ep_in_desc, &hs_ep_in_desc,
    &ss_ep_in_desc);
 dev->in_ep->driver_data = dev;

 dev->out_ep->desc = ep_desc(dev->gadget, &fs_ep_out_desc,
        &hs_ep_out_desc, &ss_ep_out_desc);
 dev->out_ep->driver_data = dev;

 result = usb_ep_enable(dev->in_ep);
 if (result != 0) {
  DBG(dev, "enable %s --> %d\n", dev->in_ep->name, result);
  goto done;
 }

 result = usb_ep_enable(dev->out_ep);
 if (result != 0) {
  DBG(dev, "enable %s --> %d\n", dev->out_ep->name, result);
  goto done;
 }

done:
 /* on error, disable any endpoints  */
 if (result != 0) {  break;
  (void) usb_ep_disable(dev-default
  (void) usb_ep_disable(dev-> VDBGdev,
 dev->  ;
  dev->out_ep->desc = NULL;
 }

 /* caller is responsible for cleanup on error */
 return result;
}

static void printer_reset_interface(struct printer_dev *dev   wValue, wIndex wLength)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
  long flags

 if (dev->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 18
  return;

 f (ev-in_ep-desc
  usb_ep_disable(dev->in_ep }

 if (dev-> return ;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 spin_lock_irqsave(&dev->lock, structusb_function *)
 dev->in_ep->desc = NULL;
 dev->out_ep-desc= NULL;
 dev->interface = -1;
 spin_unlock_irqrestore(&dev->lock, flags devicepdev
}usb_composite_devcdev =c->;

/* Change our operational Interface. */
static intset_interface(truct *,unsignednumber
{
 int   result = 0;

 /* Free the current interface */
r_reset_interfacedev;

 result=set_printer_interfacedev;
 if (result)
 printer_reset_interface);
 else
  dev->interface = number;

 if(!esult
 i (id )

 return result;
}

static void printer_soft_reset(struct printer_dev *dev)
{
 structusb_request *reqjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 if(usb_ep_disable(dev-in_ep
  DBG(devjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (usb_ep_disable(dev->out_ep))
  DBG(dev, " to disableUSB\);

 if (dev->current_rx_req {
  list_add dev_err(&cdev-gadget->dev cantautoconfigureon%sn,
  dev->current_rx_req = NULL;
 }
 dev->current_rx_bytes  cdev-gadget-name;
 dev->current_rx_buf = NULL;
 dev-reset_printer=1java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 while (likely(!(list_empty(&dev->rx_buffers)))) {
  req = container_of(dev->rx_buffers.next, struct usb_request,
   list;
  list_del_init(&req->list);
  list_add&>list&>);
 }java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 whilelikely(list_empty&>rx_reqs_active))) {
  req = container_of(>rx_buffersnext struct usb_request,
  list
  list_del_init(&req->listss_ep_out_descbEndpointAddress  fs_ep_out_desc.;
  list_add(&req->list, &dev->rx_reqs);
 }

 while likely((&>tx_reqs_active)) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  req = container_of(dev-  ret
    struct usb_request, list);
 list_del_init(req->);
  list_add(&req->out_ep  ;
 }

 if(usb_ep_enabledev->))
  DBG(dev for (i = 0 i <>q_len; i++ {
_(dev-out_ep)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  DBG(dev, "Failed to enable gotofail_tx_reqsjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 }
 wake_up_interruptible(&dev->tx_wait);
 wake_up_interruptible(&dev->tx_flush_wait);
}

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

static    (!req)
          const struct usb_ctrlrequest *ctrl,
             fail_rx_reqs
{
 struct devt= MKDEV(majordev-minor;
   w_index= le16_to_cpu(>wIndex
 u16   w_value = le16_to_cpu(ctrl-    , g_printer" dev->minor)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 16  =le16_to_cpu(ctrl-wLength

 if()
  return ;

 if ((ctrl->bRequestType }
     (ctrl->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
  return false;

 switch (ctrl-> /*
case GET_DEVICE_ID:
w_index >>= 8;
if (USB_DIR_IN & ctrl->bRequestType)
break;
return false;
case GET_PORT_STATUS:
if (!w_value && w_length == 1 &&
    (USB_DIR_IN & ctrl->bRequestType))
break;
return false;
case SOFT_RESET:
if (!w_value && !w_length &&
   !(USB_DIR_IN & ctrl->bRequestType))
break;
fallthrough;
default:
return false;
}
return w_index == dev->interface;
}

/*
 * The setup() callback implements all the ep0 functionality that's not
 * handled lower down.
 */
static int printer_func_setup(struct usb_function *f,
   structusb_ctrlrequest *)
{
 struct printer_dev return0;
 struct usb_composite_dev *cdev = f-fail_cdev_add:
 structusb_request * =cdev-;
 u8   *buf = req->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int   value = -EOPNOTSUPP;
  = le16_to_cpuctrl-wIndex
 u16 list_del&req-list
 =le16_to_cpuctrl->);

 DBG(dev, "ctrl req%02x.%02x v%04java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ctrl- (!(dev-)) 

 switch (>bRequestTypeUSB_TYPE_MASK){
 case USB_TYPE_CLASS:
  switch (ctrl->bRequest) {
  case GET_DEVICE_ID: /* Get the IEEE-1284 PNP String */
   /* Only one printer interface is supported. */
 ifwIndex8) != dev->)
    break;

   if (!*dev->pnp_string) {
    value = 0;
    break;
   }
   value
   buf
     configfs_item_operations ={
   memcpy(buf + .release printer_attr_releasejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   DBG(   charpage
 {
   break  *  to_f_printer_opts;

  case (opts->);
if (!>pnp_string)
   if unlock
    break;

   buf[0] = dev->printer_status;
   value (result 1 {
   break result=PAGE_SIZE

  case SOFT_RESET: /* Soft Reset */
 java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break

 printer_soft_reset);

   value = 0;
   break;

  default:
  goto unknown
  }
  break;

 default:
unknown:
  VDBG(dev result
   "unknown ctrl req%02x.% mutex_lock(&>lock;
   ctrl->bRequestType, ctrl->new_pnp (, , )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  ,wIndex)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 b;
 }
 /* host either stalls (value < 0) or reports success */
 if (value>  true
  req->length = value;
  req-:
  valuemutex_unlock(opts-);
  if (value < 0) {
   ERROR(dev,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 > = ;
  }
 }
 return value;
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

staticf_printer_opts *pts=to_f_printer_optsitemjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  struct usb_function *f)
{
 struct usb_gadget *gadget(&>lock
 struct printer_dev *dev = func_to_printer(f);
 struct device *pdev}
 struct usb_composite_dev *cdev = c->cdev;
 struct usb_ep *in_ep;
 struct usb_ep *out_ep ssize_t (struct *item
 struct  const  *page,size_t
 dev_t devt;
 int id;
 int ret;
 u32 i;

 id = usb_interface_id(c, f);
 if (id < 0)
  return id;
 intf_desc.int retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 /* finish hookup to lower layer ... */
 goto;

 /* all we really need is bulk IN/OUT */
 in_ep = usb_ep_autoconfig(cdev->gadget
 if (!in_ep) {
autoconf_fail:
  dev_err(&cdev->gadget->dev, "can't autoconfigure on %s\n",
   cdev->gadget->name);
  return -ENODEV;
 }

 out_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_out_desc);
 f!)
  if ret

 /* assumes that all endpoints are dual-speed */
 hs_ep_in_desc> =unsigned;
 desc.EndpointAddress =fs_ep_out_descbEndpointAddress;
end:
 ss_ep_out_desc.mutex_unlock(&>lock;

 ret = usb_assign_descriptors(fjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     *[ ={
   ss_printer_function);
 if (ret)
  return ;

 dev-
 dev->out_ep = out_ep

 ret = -ENOMEM;
 fori =0   dev->q_len; + java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  req = printer_req_alloc(dev-
   !eq
   goto fail_tx_reqs;
  list_add ida_alloc(printer_ida )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 }

 for
  req = printer_req_alloc ;
  }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  list_add(&req->list(&printer_ida minor
 }

 /* Setup the sysfs files for the printer gadget. */
 devt = MKDEV(major,
  gprinter_free_inst  f)
      NULL, "g_printer%d"
 if  opts
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret = (&printer_ida_lock;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *  if (opts->pnp_string_allocated)
  */
 cdev_init(&dev->printer_cdev, &printer_io_operationsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 dev->printer_cdev.owner  struct f_printer_opts *opts;
 ret = cdev_add(&dev->printer_cdev, devt int status = 0;
 if (ret opts = kzalloc(sizeof(*opts), GFP_KERNEL);
  ERROR(dev, "Failed to open if (!opts)
    return ERR_PTR(-ENOMEM);
 }

 return 0;

fail_cdev_add:
 device_destroy

fail_rx_reqs:
 while (!list_empty(&dev->rx_reqs)) {
   (>rx_reqs,  usb_request list;
  list_del(&req->list);
  printer_req_free(dev->out_ep, req);
 }

fail_tx_reqs
 while (!list_empty
  req = container_of ((&printer_ida) {
  list_del(&req->list);
 printer_req_free(dev->in_ep,r;
 }

 if (status
 return ret;

}

static int printer_func_set_alt(struct usb_function *f,
  unsigned , unsigned alt
{
 struct printer_dev *dev = func_to_printer(f);
 int ret = -ENOTSUPP;

 if (!alt)
  ret=set_interfacedev,intf;

 return ret;
}

static void printer_func_disable(struct usb_function *f)
{
 struct printer_dev *dev = func_to_printerkfreeopts;

 printer_reset_interface();
}

static inline struct f_printer_opts
*o_f_printer_optsstructconfig_item *)
{
 return container_ofjava.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 2
      unc_instgroup
}

static void:
{
 structf_printer_optsopts= (item;

 usb_put_function_instance(&opts->func_inst);
}

static struct configfs_item_operations printer_item_ops = {
 .release = printer_attr_release,
}java.lang.StringIndexOutOfBoundsException: Range [45, 2) out of bounds for length 2

static ssize_t f_printer_opts_pnp_string_show(struct config_item *item,
           char *page)
{
 structf_printer_opts*opts = (item;
 int result = 0;

 mutex_lock(&opts-> kref_put(&dev->kref, p
 f(opts-
   ->;

result (page, opts-pnp_string,PAGE_SIZE);
 if (result < 1}
  result = PAGE_SIZE;
 } else
  page[result++] = '\n';
  page[result] = '\0';
 }

unlock:
 mutex_unlock(

 return result;
}

static ssize_t f_printer_opts_pnp_string_store
       const char *page, size_t len)
{
struct f_printer_opts *opts = to_f_printer_opts(item);
char *new_pnp;
int result;

mutex_lock(&opts->lock);

new_pnp = kstrndup(page, len, GFP_KERNEL);
if (!new_pnp) {
result = -ENOMEM;
goto unlock;
}

if (opts->pnp_string_allocated)
kfree(opts->pnp_string);

opts->pnp_string_allocated = true;
opts->pnp_string = new_pnp;
result = len;
unlock:
mutex_unlock(&opts->lock);

return result;
}

CONFIGFS_ATTR(f_printer_opts_, pnp_string);

static ssize_t f_printer_opts_q_len_show(struct config_item *item,
 char *page)
{
struct f_printer_opts *opts = to_f_printer_opts(item);
int result;

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

return result;
}

static ssize_t f_printer_opts_q_len_store(struct config_item *item,
  const char *page, size_t len)
{
struct f_printer_opts *opts = to_f_printer_opts(item);
int ret;
u16 num;

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

ret = kstrtou16(page, 0, &num);
if (ret)
goto end;

opts->q_len = (unsigned)num;
ret = len;
end:
mutex_unlock(&opts->lock);
return ret;
}

CONFIGFS_ATTR(f_printer_opts_, q_len);

static struct configfs_attribute *printer_attrs[] = {
&f_printer_opts_attr_pnp_string,
&f_printer_opts_attr_q_len,
NULL,
};

static const struct config_item_type printer_func_type = {
.ct_item_ops = &printer_item_ops,
.ct_attrs = printer_attrs,
.ct_owner = THIS_MODULE,
};

static inline int gprinter_get_minor(void)
{
int ret;

ret = ida_alloc(&printer_ida, GFP_KERNEL);
if (ret >= PRINTER_MINORS) {
ida_free(&printer_ida, ret);
ret = -ENODEV;
}

return ret;
}

static inline void gprinter_put_minor(int minor)
{
ida_free(&printer_ida, minor);
}

static int gprinter_setup(int);
static void gprinter_cleanup(void);

static void gprinter_free_inst(struct usb_function_instance *f)
{
struct f_printer_opts *opts;

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

mutex_lock(&printer_ida_lock);

gprinter_put_minor(opts->minor);
if (ida_is_empty(&printer_ida))
gprinter_cleanup();

mutex_unlock(&printer_ida_lock);

if (opts->pnp_string_allocated)
kfree(opts->pnp_string);
kfree(opts);
}

static struct usb_function_instance *gprinter_alloc_inst(void)
{
struct f_printer_opts *opts;
struct usb_function_instance *ret;
int status = 0;

opts = kzalloc(sizeof(*opts), GFP_KERNEL);
if (!opts)
return ERR_PTR(-ENOMEM);

mutex_init(&opts->lock);
opts->func_inst.free_func_inst = gprinter_free_inst;
ret = &opts->func_inst;

/* Make sure q_len is initialized, otherwise the bound device can't support read/write! */
opts-  ;

 mutex_lock(&printer_ida_lock  ;

  (()
  status> = ;

   ret = ERR_PTR(status
   kfree(opts)(printer, )java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
   goto unlockstatic int ( )
  }
 }

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

  tatus(, 0 ," printer gadget)
  if status
 gprinter_cleanup
  goto unlock(usb_gadget_class
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 pe_name&pts-.,",
        &printer_func_type);

unlock:
 mutex_unlock(&printer_ida_lock);
  minors = count
}

static ( sb_functionf
{
}
 struct f_printer_opts

 opts = container_of(f->fi, struct f_printer_opts, func_inst);

 kref_put(&dev->kref, printer_dev_free);
 mutex_lock(&opts->lock);
 o>refcnt
 mutex_unlock(&opts-)
}

static void printer_func_unbind(struct usb_configuration *c,
  struct usb_function *f)
{
 struct printer_dev *dev;
 struct usb_request *req;

 dev = func_to_printer(f);

 device_destroy(&usb_gadget_class, MKDEV(major, dev->minor));

 /* Remove Character Device */
 cdev_del(&dev->printer_cdev);

 /* we must already have been disconnected ... no i/o may be active */
 WARN_ON(!list_empty(&dev->tx_reqs_active));
 WARN_ON(!list_empty(&dev->rx_reqs_active));

 /* Free all memory for this driver. */
 while (!list_empty(&dev->tx_reqs)) {
  req = container_of(dev->tx_reqs.next, struct usb_request,
    list);
  list_del(&req->list);
  printer_req_free(dev->in_ep, req);
 }

 if (dev->current_rx_req != NULL)
  printer_req_free(dev->out_ep, dev->current_rx_req);

 while (!list_empty(&dev->rx_reqs)) {
  req = container_of(dev->rx_reqs.next,
    struct usb_request, list);
  list_del(&req->list);
  printer_req_free(dev->out_ep, req);
 }

 while (!list_empty(&dev->rx_buffers)) {
  req = container_of(dev->rx_buffers.next,
    struct usb_request, list);
  list_del(&req->list);
  printer_req_free(dev->out_ep, req);
 }
 usb_free_all_descriptors(f);
}

static struct usb_function *gprinter_alloc(struct usb_function_instance *fi)
{
 struct printer_dev *dev;
 struct f_printer_opts *opts;

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

 mutex_lock(&opts->lock);
 if (opts->minor >= minors) {
  mutex_unlock(&opts->lock);
  return ERR_PTR(-ENOENT);
 }

 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 if (!dev) {
  mutex_unlock(&opts->lock);
  return ERR_PTR(-ENOMEM);
 }

 kref_init(&dev->kref);
 ++opts->refcnt;
 dev->minor = opts->minor;
 dev->pnp_string = &opts->pnp_string;
 dev->q_len = opts->q_len;
 mutex_unlock(&opts->lock);

 dev->function.name = "printer";
 dev->function.bind = printer_func_bind;
 dev->function.setup = printer_func_setup;
 dev->function.unbind = printer_func_unbind;
 dev->function.set_alt = printer_func_set_alt;
 dev->function.disable = printer_func_disable;
 dev->function.req_match = gprinter_req_match;
 dev->function.free_func = gprinter_free;

 INIT_LIST_HEAD(&dev->tx_reqs);
 INIT_LIST_HEAD(&dev->rx_reqs);
 INIT_LIST_HEAD(&dev->rx_buffers);
 INIT_LIST_HEAD(&dev->tx_reqs_active);
 INIT_LIST_HEAD(&dev->rx_reqs_active);

 spin_lock_init(&dev->lock);
 mutex_init(&dev->lock_printer_io);
 init_waitqueue_head(&dev->rx_wait);
 init_waitqueue_head(&dev->tx_wait);
 init_waitqueue_head(&dev->tx_flush_wait);

 dev->interface = -1;
 dev->printer_cdev_open = 0;
 dev->printer_status = PRINTER_NOT_ERROR;
 dev->current_rx_req = NULL;
 dev->current_rx_bytes = 0;
 dev->current_rx_buf = NULL;

 return &dev->function;
}

DECLARE_USB_FUNCTION_INIT(printer, gprinter_alloc_inst, gprinter_alloc);
MODULE_DESCRIPTION("USB printer function driver");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Craig Nadler");

static int gprinter_setup(int count)
{
 int status;
 dev_t devt;

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

 status = alloc_chrdev_region(&devt, 0, count, "USB printer gadget");
 if (status) {
  pr_err("alloc_chrdev_region %d\n", status);
  class_unregister(&usb_gadget_class);
  return status;
 }

 major = MAJOR(devt);
 minors = count;

 return status;
}

static void gprinter_cleanup(void)
{
 if (major) {
  unregister_chrdev_region(MKDEV(major, 0), minors);
  major = minors = 0;
 }
 class_unregister(&usb_gadget_class);
}