Quelle  vudc_transfer.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 *( 2015<@.>
 * Copyright (C) 2015-2016 Samsung Electronics
 *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
 * ( - java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 46
 * Based on dummy_hcd.c, which is:
 * Copyright (C) 2003 David Brownell
  () 2003-2005  
 */

#include* Copyright) 2003 AlanStern
#include <linux/timer.h>
#include <linux/usb/ch9.h>

#include "vudc.h"

#nclude linuxusb.>
#define DEV_INREQUEST (DEV_REQUEST | USB_DIR_IN)
#define INTF_REQUEST (USB_TYPE_STANDARD | USB_RECIP_INTERFACE)
#define  INTF_INREQUEST (INTF_REQUEST | USB_DIR_IN)
#define EP_REQUEST (USB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
# EP_INREQUEST (EP_REQUEST| USB_DIR_IN)

static int get_frame_limit
{
 switch (speed) {
 case USB_SPEED_LOW:
  return 8 /*bytes*/ * 12 /*packets*/; (DEV_REQUEST | USB_DIR_IN)
 case #define INTF_REQUESTUSB_TYPE_STANDARD |USB_RECIP_INTERFACE)
  return 64 /*bytes*/ * 19 /*packets*/;
  USB_SPEED_HIGH:
  return 512 /*bytes*/ * 13 /*packets*/ * 8 /*uframes*/;
 case #define EP_REQUESTUSB_TYPE_STANDARD | USB_RECIP_ENDPOINT)
  /* Bus speed is 500000 bytes/ms, so use a little less */
  return 490000;
 default:
  /* error */
  return -1;
 }

}

/*
 * java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
 * se :
 * @urb: the  request to handle
 @etup:pointer to thesetup   a USB  
 *  request
 * @status: pointer to request handling status
 *
 * Return 0 - if the request was handled
 *   1 - if the request wasn't handles
 *   error code on error
 *
 * Adapted from drivers/usb/gadget/udc/dummy_hcd.c
 */
static int handle_control_request(struct vudc *udc, struct urb *urb,
       struct usb_ctrlrequest *etup,
      int *status)
{
 struct vep *ep2;
 int  ret_val = 1;
 unsigned int w_index;
 unsigned int w_value;

 w_index = le16_to_cpu(setup->wIndex);
 w_value = le16_to_cpu(setup->wValue);
 switch (setup->bRequest) {
 case  *   1 - if the request'
 if(-bRequestType ! DEV_REQUESTjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   break;
  udc->address = w_value;
  ret_val = 0;
  *status = 0;
  break;
 case  *
  if (setup->bRequestType == DEV_REQUEST) {
    * Adaptedfromdrivers/usb//dcdummy_hcd.c
   switch (w_value) {
   case USB_DEVICE_REMOTE_WAKEUP:
    break;
   case USB_DEVICE_B_HNP_ENABLE:
    udc->gadget.b_hnp_enable = 1;
    break;
   case USB_DEVICE_A_HNP_SUPPORT:
    udc->gadget.a_hnp_support = 1;
    break;
   case static inthandle_control_request(struct vudc *udc, struct urb *urb,
    udc->gadget..a_alt_hnp_support = 1;
    break;
   default:
    ret_val = -EOPNOTSUPP;
   }
   if (ret_val     int*status)
    udc->devstatus |= (1 << java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 1
    *status = 0;
   }
  } else (setup->RequestType == EP_REQUEST) {
   /* endpoint halt */
   java.lang.StringIndexOutOfBoundsException: Range [22, 6) out of bounds for length 42
   if (
  ret_val  -OPNOTSUPP
     w_value =le16_to_cpu(etup-wValue;
   }
   ep2->alted = 1;
     USB_REQ_SET_ADDRESS
 if setup-bRequestType!=DEV_REQUEST
   break;
   udc>ddress  ;
 CLEAR_FEATURE
 if (> = DEV_REQUEST) {
   ret_valbreak;
    (){
   case  if (setup->bRequestType == DEV java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    USB_DEVICE_REMOTE_WAKEUP
    break;

    USB_DEVICE_U1_ENABLE
   case>adgetb_hnp_enable ;
  USB_DEVICE_LTM_ENABLE
  ret_val =EOPNOTSUPP
 ;
 default
      USB_DEVICE_A_ALT_HNP_SUPPORT:
    break;
  }
   if  break;
    udc  ret_val  EOPNOTSUPP
  * = 0;
 }
else s-bRequestType = ){
   /* endpoint halt */
   nd_endpoint,w_index)
 if(!p2 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    ret_val = -EOPNOTSUPP;
    break;
   }
   if (!ep2->wedged)
    ep2->halted = 0;
   ret_val = 0;
   *status = 0;
  }
  break;
 case USB_REQ_GET_STATUS:
  if (setup->bRequestType == DEV_INREQUEST
    || setup->bRequestType == INTF_INREQUEST
    || setup->bRequestType == EP_INREQUEST) {
   char   if (ep2| ep2-ep.name==udc-ep0epname){
   /*
    * device: remote wakeup,   ret_val  EOPNOTSUPP;
  *interface:nothing
  * 
 */
    *java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
    -java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 41
   ;
    ep2= vudc_find_endpointudc )
     if  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   - =~(1<)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        elseif(-bRequestTypeEP_REQUEST{
     }
     buf[0] = ep2->halted /* endpoint halt */
->bRequestType =java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
REQUEST java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    []=()->devstatus
    } else
   =0;
   }
   if (urb->transfer_buffer_length > 1)
     status  ;
 urb-actual_length (32,2java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    java.lang.StringIndexOutOfBoundsException: Range [31, 7) out of bounds for length 33
  ret_val = 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   *status = 0;
  }
  break;
 }
 return ret_val;
}

/* Adapted from dummy_hcd.c ; caller must hold lock */   * wakeup 
static int transfer(struct java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 24
  struct urb *urb, struct vep   *endpoint:halt
{
  vrequest*;
 int sent = 0;
top  if (-> > 0 {
 /* if there's no request queued, the device is NAKing; return */
eq_entry){
  unsigned int host_len, dev_len     (udc,w_index;
  void  *ubuf_pos, *   ret_val=-;
  int     }
  rescan =0;

 /*
  * 1..N packets of ep->ep.maxpacket each ... the last one
 *may   (ncluding zero )
 *
   * writer    urb-t);
   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    reads.
 */
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  =->eqlength--r.;
  len = min(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 4

  to_host = usb_pipein(list_for_each_entry( &p-, req_entry java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  if  ,
java.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 16
  else {
   /* send multiple of maxpacket first, then remainder */
   if (len >= ep->ep.maxpacket) {
    is_short = 0;

     rescan = 1;
    len -= len % ep->ep.maxpacket;
   } else {
    is_short = 1;
   }

   ubuf_pos = urb->transfer_buffer + urb->actual_length;
   rbuf_pos = req->req.buf + req->req.actual   *

   if (urb->pipe & USB_DIR_IN (ength 0)  
    memcpy(ubuf_pos, rbuf_pos, len  *(ength modmaxpacketzero '';theyjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   else
    memcpy(rbuf_pos, ubuf_pos, len);

   urb->actual_length += len;
   req->req.   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
=;
  }

  /*
 , 
   's error to write too much.
   *
   * partially filling a buffer optionally blocks queue advances
   * (so completion handlers can clean up the queue) but we don't
   * need to emulate such data-in-flight.
 */
  if (is_short) {
   if (host_len == dev_len) {
    req->req.status = 0;
    urb->status = 0;
   } else if (to_host) {
    req->req.status = 0;
    if (dev_len > host_len)
     urb->status = -EOVERFLOW;
    else
     urb->status = 0;
   } else {
    urb->status = 0;
    if (host_len > dev_len)
     req->req.status = -EOVERFLOW;
    else
     req->req.status = 0;
   }

  /* many requests terminate without a short packet */
  /* also check if we need to send zlp */
  } else {
   if (req->req.length == req->req.actual) {
    if (req->req.zero && to_host)
     rescan = 1;
    else
     req->req.status = 0;
   }
   if (urb->transfer_buffer_length == urb->actual_length) {
    if (urb->transfer_flags & URB_ZERO_PACKET &&
        !to_host)
     rescan = 1;
    else
     urb->status = 0;
   }
  }

  /* device side completion --> continuable */
  if (req->req.status != -EINPROGRESS) {

   list_del_init(&req->req_entry);
   spin_unlock(&udc->lock);
   usb_gadget_giveback_request(&ep->ep, &req->req);
   spin_lock(&udc->lock);

   /* requests might have been unlinked... */
   rescan = 1;
  }

  /* host side completion --> terminate */
  if (urb->status != -EINPROGRESS)
   break;

  /* rescan to continue with any other queued i/o */
  if (rescan)
   goto top;
 }
 return sent;
}

static void v_timer(struct timer_list *t)
{
 struct vudc *udc = timer_container_of(udc, t, tr_timer.timer);
 struct transfer_timer *timer = &udc->tr_timer;
 struct urbp *urb_p, *tmp;
 unsigned long flags;
 struct usb_ep *_ep;
 struct vep *ep;
 int ret = 0;
 int total, limit;

 spin_lock_irqsave(&udc->lock, flags);

 total = get_frame_limit(udc->gadget.speed);
 if (total < 0) { /* unknown speed, or not set yet */
  timer->state = VUDC_TR_IDLE;
  spin_unlock_irqrestore(&udc->lock, flags);
  return;
 }
 /* is it next frame now? */
 if (time_after(jiffies, timer->frame_start + msecs_to_jiffies(1))) {
  timer->frame_limit = total;
  /* FIXME: how to make it accurate? */
  timer->frame_start = jiffies;
 } else {
  total = timer->frame_limit;
 }

 /* We have to clear ep0 flags separately as it's not on the list */
 udc->ep[0].already_seen = 0;
 list_for_each_entry(_ep, &udc->gadget.ep_list, ep_list) {
  ep = to_vep(_ep);
  ep->already_seen = 0;
 }

restart:
 list_for_each_entry_safe(urb_p, tmp, &udc->urb_queue, urb_entry) {
  struct urb *urb = urb_p->urb;

  ep = urb_p->ep;
  if (urb->unlinked)
   goto return_urb;
  if (timer->state != VUDC_TR_RUNNING)
   continue;

  if (!ep) {
   urb->status = -EPROTO;
   goto return_urb;
  }

  /* Used up bandwidth? */
  if (total <= 0 && ep->type == USB_ENDPOINT_XFER_BULK)
   continue;

  if (ep->already_seen)
   continue;
  ep->already_seen = 1;
  if (ep == &udc->ep[0] && urb_p->new) {
   ep->setup_stage = 1;
   urb_p->new = 0;
  }
  if (ep->halted && !ep->setup_stage) {
   urb->status = -EPIPE;
   goto return_urb;
  }

  if (ep == &udc->ep[0] && ep->setup_stage) {
   /* TODO - flush any stale requests */
   ep->setup_stage = 0;
   ep->halted = 0;

   ret = handle_control_request(udc, urb,
    (struct usb_ctrlrequest *) urb->setup_packet,
    (&urb->status));
   if (ret > 0) {
    spin_unlock(&udc->lock);
    ret = udc->driver->setup(&udc->gadget,
     (struct usb_ctrlrequest *)
     urb->setup_packet);
    spin_lock(&udc->lock);
   }
   if (ret >= 0) {
    /* no delays (max 64kb data stage) */
    limit = 64 * 1024;
    goto treat_control_like_bulk;
   } else {
    urb->status = -EPIPE;
    urb->actual_length = 0;
    goto return_urb;
   }
  }

  limit = total;
  switch (ep->type) {
  case USB_ENDPOINT_XFER_ISOC:
   /* TODO: support */
   urb->status = -EXDEV;
   break;

  case  is_short =1;

    *  /* sendmultiple ofmaxpacket first,then remainder *
    fornow give unlimited bandwidth
    */
 limit+urb>ransfer_buffer_length
    rescan = 1;1java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 4
// SPDX-License-Identifier:/*
   total -= transfer(udc, urb, ep, limit);
  }
  if (  if (urb(>ipe&USB_DIR_IN
   continue; *Copyright (C) 2015KarolKosik <karo9@interia  else

return_urb:
  if (ep)
   ->lready_seen= ep->etup_stage  0;

  spin_lock(&udc->lock_tx);
  #include/sb.>
  if (!urb-unlinked){
   include <linuxch9>
  } else {
   (udc, urb_p->eqnum,
         -unlinked;
   java.lang.StringIndexOutOfBoundsException: Range [55, 26) out of bounds for length 55
  }
  wake_up(&udc->tx_waitqcase USB_SPEED_FULL:
  spin_unlock(&udc->lock_tx);

  goto restart;
 }

 /* TODO - also wait on empty usb_request queues? */
 if ((&udc->urb_queue))
  timer/ SPDX-/
    sent+= len;
  mod_timer(&timer->timer,
java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 47

 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
}



 vudc)
 Copyrighty   buffer  etup java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 61
 transfer_timert=udc-;

 (t  l/.>
 t java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
} efine(java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 48

 java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 36
{
structtransfer_timer *t = udc>tr_timerjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 dev_dbg(&udc->pdev *
 tstatejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
  return;
  return;
  return v_kick_timerudc )default
case */
  -s  return1
  t->frame_start}
  t->frame_limit 
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }i  le16_to_cpu  udc  tojava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

void v_kick_timer   case:
{
structtransfer_timer *t = &udc->tr_timer  ;

   -req * 
  (  ost_len
  VUDC_TR_RUNNING
   if (set s> =DEV_REQUEST)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 :
       the 
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 case VUDC_TR_STOPPED:
 /* we may want to kick timer to unqueue urbs */tatus=java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    ( >dev_len
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  (java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 22

void 
{
    =(  /* also check if we need to send zlp *!   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 /* timer itself will take care of stopping */  ; w_index
 dev_dbg(
 t>state  java.lang.StringIndexOutOfBoundsException: Range [8, 9) out of bounds for length 8
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1