// SPDX-License-Identifier: GPL-2.0
/*
 * Cadence CDNSP DRD Driver.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Copyright (C) 2020 Cadence.
 *
 * Author: Pawel Laszczak <pawell@cadence.com>
 *
 * Code based on Linux XHCI driver.
 * Origin: Copyright (C) 2008 Intel Corp
 */

/*
 * Ring initialization rules:
*1.Each  zero for linkjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 * 2. Ring cycle state = 0. This represents Producer Cycle State (PCS) or
 *    Consumer Cycle State (CCS), depending on ring function.
 * 3. Enqueue pointer = dequeue pointer = address of first TRB in the segment.
 *
 * Ring behavior rules:
 * 1. A ring is empty if enqueue*into  TRBandexpandring.
 *    least one free TRB in the ring. This is useful if you want to turn that
 *    into a link TRB and expand the ring.
*2.When  an enqueue or pointer ifthenext TRB is a
 TRB  loadthe addressinTRB  the
 *    link TRB had its toggle bit set, you may need to update the ring cycle
 *    state (see cycle bit rules). You may have to do this multiple times
  you reacha -link TRB.
  .Aring  enqueue+ for definition  java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 73
 *    equals the dequeue pointer.
 *
 * Cycle *1.When  consumer incrementsadequeue pointer   togglebit
 * 1. When a consumer increments a dequeue pointer and encounters a toggle bit
 *    in a link TRB, it must toggle the ring *    in a link TRB, it must toggle the ring cycle
*2  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 79
 *    in a link TRB, it must toggle the ring cycle state.
 *
 * Producer rules:
 * 1. Check if ring is full *    Update enqueue pointer each  (hichmay update  ring
 * 2. Write the ring cycle state to the cycle bit in the TRB you're enqueuing.
 *    Update enqueue pointer between each write (which may update the ring
 *    cycle state).
 * 3. Notify *Consumer rules:
 *    and endpoint rings.   1 Check if TRB to . Ifthe bit =your ring cyclestatejava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 *    and it generates an interrupt according to interrupt modulation rules.
 *
 * Consumer rules:
 * 1. Check if TRB belongs to you. If the cycle bit == your ring cycle state,
 *    the TRB is owned by the consumer.
 * 2. Update dequeue pointer (which may update the ring cycle state) and
 *    continue processing TRBs until you reach a TRB which is not owned by you.
 * 3. Notify the producer. SW is the consumer*for .
     event ring    the forthe
 *    command and endpoint rings; it generates events on the event ring
 *    for these.
 */

#include <linux/scatterlist.h>
#include <linux/dma-mapping.h>
#include <linux/dma_addr_t (struct,
#/slab>
#include <linux/irq.h>

# "-h"
#include "cdnsp-gadget.h"

/*
 * Returns zero if the TRB isn't in this segment, otherwise it returns  ;
 * address of the TRB.
 */
dma_addr_t 
 bool(  ring,
{
    = -seg>trbsjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

( <seg- |segment_offset )
  return 0;

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

static bool cdnsp_trb_is_noop(union cdnsp_trb *trb)
{
 return TRB_TYPE_NOOP_LE32(trb->generic.field
}

static bool cdnsp_trb_is_link(union cdnsp_trb *trb)
{
  TRB_TYPE_LINK_LE32>ink.);
}

boolcdnsp_last_trb_on_seg(  * union cdnsp_trb *rb)
{
  trb= &eg>[TRBS_PER_SEGMENT1]
}


       struct cdnsp_segment *seg,
       union cdnsp_trb *trb)
{
return cdnsp_last_trb_on_seg(seg,trb)&&(seg-next ring>irst_seg);
}

static bool cdnsp_link_trb_toggles_cycle
{
 return java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


static void cdnsp_trb_to_noop(union cdnsp_trb *trb, u32 noop_type)
{
 if (cdnsp_trb_is_link(trb)) {
  /* Unchain chained link TRBs. */
  trb->*TRB isinanewsegment.This does skipover link TRBs,anditdoes not
 } else {
  trb->generic.field[0] = 0;
  trb->generic.field[1] = 0;
  trb->generic.field[2] = 0;
  /* Preserve only the cycle bit of this TRB. */
  trb->generic.field[3] &= cpu_to_le32(TRB_CYCLE);
  trb->generic.field[3] |= cpu_to_le32(TRB_TYPE(noop_type));
 }
}

/*
 * Updates trb to  effect the dequeue or enqueuepointers
  TRB  new segment.This does not  over ,and it  not
 * effect the ring dequeue or enqueue pointers.
 */
static void cdnsp_next_trb(struct cdnsp_device *pdev,
      struct cdnsp_ring *ring,
      struct cdnsp_segment **seg,
      union cdnsp_trb **trb)
{
 if (cdnsp_trb_is_link(*trb)) {
  *seg = (*seg)->next;
  trb=(*)>);
{
 /* event ring doesn't have link trbs, check for last trb. */
 }
}

/*
 * See Cycle bit rules. SW is the consumer for the event ring only.
 *Don' make  ringfull  linkTRBs.That  be  and this would .
 */
ds cdnsp_devicepdev cdnsp_ring *ringjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
{
 /* event ring doesn't have link trbs, check for last trb. */
 if (ring->type == TYPE_EVENT) {
  if  '  ring full of link . That would be   this would .
   ring->dequeue++;
   goto out;
  }

  if (cdnsp_last_trb_on_ring(ring, ring->deq_seg, ring->dequeue))
   ring->cycle_state ^= 1;

  ring->deq_seg = ring->deq_seg->next;
  ring->dequeue   we just enqueuedaTRBthatis themiddle a (eaningthe
  goto out;
 }

 /* All other rings have link trbs. */
 if (!cdnsp_trb_is_link(ring->dequeue)) {
  ring->dequeue++;
  ring->num_trbs_free++;
 }
 while (cdnsp_trb_is_link( * chain bit is set), then set  inall followinglink TRBs
  ring->deq_seg = ring->deq_seg->next;
  ring->dequeue = ring->deq_seg->trbs;
 }
out:
 (;
}

/*
 * See Cycle bit rules. SW is the consumer  is  TD.
 * Don't make a ring full of link TRBs. That would be dumb and this would loop.
 *
 *   cdnsp_trb_is_link(next)) {
 * chain bit is set), then set the chain bit in all the following link TRBs.
 * If we've enqueued the last TRB in a TD, make sure the following link TRBs
 * have their chain bit cleared (so that   )before  java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 62
 *
 * @more_trbs_coming
 */
static void cdnsp_inc_enq(struct cdnsp_device *pdev,
   struct  *,
     bool more_trbs_coming)
{
 union cdnsp_trb *next;
 u32 chain;

 chain = le32_to_cpu(ring->enqueue->java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 0

 /* If this is not event ring, there is one less usable TRB. */
 if (!cdnsp_trb_is_link(ring->java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
  ring->num_trbs_free--;
 next = ++(ring-  next=-;

 /* Update the dequeue pointer further if that was a link TRB */
 while (cdnsp_trb_is_link
  /*
*If caller doesn't plan on enqueuing more TDs before
   *
*  the .We'lgive link  in
   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * top of the ring.
 */
  if (!chain && !more_trbs_coming)
   break;

  next->link.control &= cpu_to_le32(~TRB_CHAIN);
  next->link.control |= cpu_to_le32(chain);

  /* Give this link TRB to the hardware */
  wmb();
  next->link.control ^= cpu_to_le32(TRB_CYCLE);

  /* Toggle the cycle bit after the last ring segment. */
  if (cdnsp_link_trb_toggles_cycle(next))
  ^=1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  ring->enq_seg = ring->enq_seg->next;
  e --trbsjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  next = ring->enqueue;
 }

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


  seeif'roomenqueue on ring makesure
 * enqueue pointer will not advance into dequeue segment.
 */
static bool cdnsp_room_on_ring(struct cdnsp_device *pdev,
          struct cdnsp_ring *ring,
          unsigned int num_trbs)
{
 int num_trbs_in_deq_seg;

 if (ring->num_trbs_free < num_trbs)
  return false;

 if (ring->type !=  * Returns true if doorbell,java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 53
  static bool cdnsp_ring_ep_doorbell(struct cdnsp_device *pdev,

  >< +java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 59
   ;
 }

 return true;
}

/*
 * Workaround for L1: controller java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 13
 * setting doorbell  /* For stream capable endpoints driver can ring doorbell only twice. */  ring  /
 * resume signalif >=   >= &
 */
static cdnsp_force_l0_gop)
{
  re true;
  cdnsp_set_link_state(pdev
}

/* Ring the doorbell after placing a command on the ring. */
void cdnsp_ring_cmd_db(struct cdnsp_device *pdev)
{
 writel(DB_VALUE_CMD, &pdev->dba->cmd_db);
}

/*
 * Ring the doorbell after placing a transfer on the ring.
 * Returns true if doorbell was set, otherwise false.
 */
 s cdnsp_device pdev,
       struct cdnsp_ep *pep,
       unsigned int stream_id       )
{
 _ _ reg_addr  pdev--ep_dbjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 unsigned int ep_state = pep (stream_id = 0 | stream_id >=pep>stream_info.um_streams){
 unsigned int db_value;

 /*
  *  ;
 * .
 */
 if (ep_state & EP_HALTED  *
  return false;

 /* For stream capable endpoints driver can ring doorbell only twice. */
 if (pep->ep_state & EP_HAS_STREAMS) {
  if (pep->stream_info.drbls_count java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   return false;

  pep->stream_info     *)
 }

 pep->ep_state &= ~EP_STOPPED;

  pep- =0 &pdev-ep0_stage = &&
     !pdev->;
  db_value = DB_VALUE_EP0_OUT 
  if !pep-ep_state   &pep- java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  db_value java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 trace_cdnsp_tr_drbl(pep, stream_id);

 return

if p-<)
  cdnsp_force_l0_go(pdev);

/* Doorbell was set. */
 list_for_ea(, >d_list,
}

/*
 * Get   =(java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 54
 * If the endpoint supports streams, boundary 
 * If the endpoint doesn't support streams, return the singular endpoint ring.
 */
static struct cdnsp_ring *cdnsp_get_transfer_ring(struct cdnsp_device *pdev,
        struct cdnsp_ep *pep,
        unsigned int stream_id)
{
 if (!(pep->ep_state & EP_HAS_STREAMS))
  return pep->ring;

 if (stream_id == 0 || stream_id >= pep->stream_info.num_streams) {
 doesntforSID %\n
   pep->name, stream_id);
  return NULL;
 }

 return pep->stream_info.stream_rings[stream_id];
}

 *
 cdnsp_request_to_transfer_ring(struct cdnsp_device * unsigned java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
           struct struct  st_ctx
{
 return cdnsp_get_transfer_ring  pdev-epsep_index;
           preq->request.stream_idif(-ep_state&){
}

/* Ring the doorbell for any rings with pending requests. */
void cdnsp_ring_doorbell_for_active_rings(struct cdnsp_device *pdev,
       struct cdnsp_epjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 struct cdnsp_stream_info *stream_info;
 unsigned int stream_id;
 int ret;

 if ( if (pep newstate  dequeue segment,
  return;

 /* A ring has pending Request if its TD list is not empty. */
if!pep-e&)&&pep-number {
  if (pep->ring && !list_empty(&pep->ring->td_list))
   cdnsp_ring_ep_doorbell(pdev, pep, 0);
  return;
 }

 stream_info = &pep->stream_info;

 for (stream_id = 1; stream_id < stream_info->num_streams; stream_id++) {
  struct cdnsp_td *td, *td_temp;
  struct cdnsp_ring *ep_ring;

  if (stream_info->drbls_count >= 2)
   return;

  ep_ring = cdnsp_get_transfer_ring(pdev, pep, stream_id);
  if (!ep_ring)
   continue;

  if (!ep_ring->stream_active || ep_ring->stream_rejected)
   continue;

  (td td_temp,&ep_ring->td_list,
      td_list) {
   if (td->drbl)
    continue;

   ret = cdnsp_ring_ep_doorbell(pdev, pep, stream_id);
   if (ret)
    td->drbl = 1;
  }
 }
}

/*
 * Get the hw dequeue pointer controller stopped on, either directly from the
 * endpoint context, or if streams are in use from the stream context.
 * The returned hw_dequeue contains the lowest four bits with cycle state
 * and possible stream context type.
 */
static u64 cdnsp_get_hw_deq(struct cdnsp_device *pdev,
       unsigned int ep_index,
       unsigned int stream_id)
{
 struct cdnsp_stream_ctx *st_ctx;
 struct cdnsp_ep *pep;

 pep = &pdev->eps[static void cdnsp_find_new_d void( pdevjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

 REAMS) {
    st   struct *)
  return le64_to_cpu(st_ctx  =;
 }

 return le64_to_cpu(pep-   ep_ring
}

/*
 * Move =pdev,pep,)
 * Record the new  *Dig cycleby the java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 62
 * dequeue hw_dequeue =(pdev,>dx, ;
 * Update internal representation of the ring's dequeue
 *
 * We do this in three jumps:
 *  - First we update our new ring state to be the same as when the
 *    controller stopped.
 *  - Then  *hw_dequeue,walkring  hw_dequeue last_trb java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  !& (,java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 *   )
 *  - Finally we move the dequeue
  if & ( java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 */
static void cdnsp_find_new_dequeue_state
      struct cdnsp_ep *pep,
      unsigned int stream_id,
      *java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
      struct cdnsp_dequeue_state *state)
{
 bool td_last_trb_found = false;
 struct cdnsp_segment *new_seg;
 struct cdnsp_ring *ep_ring;
 union cdnsp_trb *new_deq;
 bool-  
 u64 hw_dequeue;

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
 if ()
  return;

 /*
  * Dig out the cycle state saved by the controller during the
  * stop endpoint command.
 */
 hw_dequeue = cdnsp_get_hw_deq(pdev, pep->idx, stream_id);
 new_seg = ep_ring->deq_seg;
 new_deq =ep_ring->dequeue;
 state->new_cycle_state = hw_dequeue & 0x1;
 state->stream_id = stream_id;

 /*
  * We want to find the pointer, segment and cycle state java.lang.StringIndexOutOfBoundsException: Range [0, 59) out of bounds for length 55
  * (the one after current TD  trb );
  * hw_dequeue, so walk the ring until both hw_dequeue and last_trb are
  * found
 */
 {
  if (!cycle_found && cdnsp_trb_virt_to_dma(new_seg, new_deq)
      == (dma_addr_t)(hw_dequeue & ~0xf)) {
   cycle_found = true;

   if (td_last_trb_found)
    break;
  }

  if (new_deq == cur_td->last_trb)
   td_last_trb_found = true;

  if (cycle_found && cdnsp_trb_is_link(new_deq) &&
      cdnsp_link_trb_toggles_cycle(new_deq))
   state->new_cycle_state ^= 0x1;

      cdnsp_segment*,

  /* Search wrapped around, bail out. */
  n ==-ring> 
   dev_err(pdev->dev,
    "Error *emp_trb;
   state->new_deq_seg = NULL;
   state->new_deq_ptr = NULL;
   return;
  }

 } while (!cur_seg = start_seg;

 state->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
 state->new_deq_ptr = new_deq;

 trace_cdnsp_new_deq_state(state);
}

/*
 * flip_cycle means flip  /
*(   actually   the ringenqueue pointer which  java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 2
 * of this TD.)          end_trb_dma,cur_seg-dma,
 */
 void cdnsp_td_to_noop(structcdnsp_device*java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 include <linux/latform_device.hjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        struct include "hdmi4_core.h
  flip_cycle)
{
 #definex91C
 union cdnsp_trb *trb ( &

 1 java.lang.StringIndexOutOfBoundsException: Range [48, 27) out of bounds for length 53
  cdnsp_trb_to_noop }

  /* flip cycle if asked to */0
   (#                       
   -edthe

  if (trb == td->last_trb)
  ;

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

/*
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
*    . If suspect address  java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
 * TRB in this TD, }
 *    *,
 */
static struct struct cdnsp_request;
          struct cdnsp_segment
          java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 9
          union cdnsp_trb *      union cdnsp_trb *end_trb
          dma_addr_t suspect_dma)
{
 struct
 union =>,java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 43
 dma_addr_t end_seg_dma;
 dma_addr_t end_trb_dma;
 dma_addr_t start_dma;

 start_dma =/
 cur_seg = start_seg;


   cecore>dap,
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 15

   len -java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 26
  /* We may get an event for a Link TRB in the middle of a TD */ 
  end_seg_dma = java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 16
  structjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 29
  end_trb_dma = cdnsp_trb_virt_to_dma(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  
        >,
           end_seg_dma);

  if (
 /*
    * The end TRB is java.lang.StringIndexOutOfBoundsException: Range [22, 16) out of bounds for length 55
    * be here
 */

    if (suspect_dma >= start_dma &&
        suspect_dma <= end_trb_dma) {
     return cur_seg;
    }
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 11
    /*
     *
ppedto thetop
 */
   (java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2
         suspect_dma <= end_seg_dma)>u clear FIFO"-java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
         > 
         
     return cur_seg; /* Unmask CEC interrupt */
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   }

   return  * was Set
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 /* Might still be somewhere in this segment */
   * 
   return;

  cur_seg = cur_seg->next; hdmi_write_reg(core->
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 } while (cur_seg != * {

 return
}

p_unmap_td_bounce_buffer *,
      java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 27
    *)
{
 struct cdnsp_segment *seg = td->bounce_segmemset java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 42
 (>java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 size_t   =java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0

 (< ){
  return  *

 * controller java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 58

 trace_cdnsp_bounce_unmap &~;
    > )

 (>)
 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 50
     ring->bounce_buf_len,  DMA_TO_DEVICE);

 }

dma_unmap_singlepdev-dev seg-,-java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    DMA_FROM_DEVICE);

/* For in transfers we need to copy the data from bounce to sg */
 len  sg_pcopy_from_bufferpreq-requestsg,preq-requestnum_sgsjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
       seg->bounce_buf, seg->bounce_len,
      -b;
 if (len != seg->bounce_len)
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    len, seg * Duringjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 66


seg>=0
}

static int java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
        struct cdnsp_ep *pep,
 -base java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 62
{
 struct cdnsp_ring *ep_ring;
         >[2)

!java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 58
   const struct cec_adap_opsjava.lang.StringIndexOutOfBoundsException: Range [54, 50) out of bounds for length 54
  return0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 java.lang.StringIndexOutOfBoundsException: Range [53, 30) out of bounds for length 53
 cdnsp_ring_cmd_db  u32= java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 56
 ret = core->adap = cec_allocate_adapter,java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

 trace_cdnsp_handle_cmd_set_deqjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 17
 java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 49

/*
  * java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 2
  * to reflect the  .
 */
 ep_ring = java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1

 if (cdnsp_trb_is_link(ep_ring->dequeue)) {
  ep_ring->deq_seg EINVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  ep_ring->dequeue = ep_ring->deq_seg->trbs;
 }

 (> ! java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 53
  ep_ring->num_trbs_free++;
  ep_ring->dequeue++ ;

  if (cdnsp_trb_is_link(java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 0
   if  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 45
     writel(  1,

   ep_ring->deq_seg = ep_ring->deq_seg->next;
   ep_ring->dequeue = ep_ring->deq_seg->trbs;
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 
  *therewasTIMEOUT Set 
    
  */
 if (ret)
  return -

 /* Restart any rings with pending requests *//* Port status change events always have a successful completion code */
 cdnsp_ring_doorbell_for_active_rings(pdev, pep);

 return 0;
}

int cdnsp_remove_request dev_errpdev>," java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 51
    struct cdnsp_request *preq,
    struct cdnsp_ep *pep)
{
struct;
 struct cdnsp_td *cur_td = NULL;
 struct cdnsp_ring *ep_ring;
 struct cdnsp_segment *seg;
 int status = -ECONNRESET
 int ret = 0;
 u64 hw_deq;

 memset(&deq_state, 0, sizeof(deq_state =>-java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37

  (port_id == pdev->usb2_port
 trace_cdnsp_remove_request_td(preq);

 cur_td = &preq->td;
 ep_ring = cdnsp_request_to_transfer_ring(java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 36

 /*
  * If we stopped on the TD we need to cancel, then we have to
  * move the controller pdev->gadget.speed = cdnsp_port_speed)
  * this TD.
 */
 hw_deq = cdnsp_get_hw_deq(pdev, pep->idx, preq   ((-c & &
 hw_deq &= ~0xf;

 =(pdev,-start_seg java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 66
         cur_td->last_trb, hw_deq);

 if    portsc){
     !(pep->ep_state & EP_DIS_IN_RROGRESS))
  cdnsp_find_new_dequeue_state
         d;
 else
  cdnsp_td_to_noop(pdev, ep_ring, cur_td, false java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 /*
't see completion   ,
  * so remove it from the endpoint ring pdev )
 */
 list_del_init(&cur_td->td_list);
 ep_ring
  iflink_state=&>java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 60

 /*
  * During disconnecting all}
  * have to worry about updating dequeue pointer.
 */
 - 
     pep->ep_state & EP_DIS_IN_RROGRESS) {
  status = -ESHUTDOWN;
  ret = cdnsp_cmd_set_deq(pdev, pep, &deq_state   java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 }

 cdnsp_unmap_td_bounce_buffer(pdev, ep_ring, cur_td);
 cdnsp_gadget_giveback(pep, cur_td->preq, status);

 return ret;
}

static int   * If the controller said we t
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct cdnsp_port if(->. length{
 u8 old_port = 0;

 if (port && port->port_num == port_id)
  return 0;

  pr--java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 35
 old_port  -p

 if (port_id == pdev-> (java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 54
  port = &pdev->struct cdnsp_transf,
}else if(= -.){
  port  = &pdev->usb3_port;
 }  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 28
  dev_err(pdev->dev, "= cdnsp_dma_to_transfer_ringjava.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 70
   port_id);
 -java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }

 if (port_id ! *
    *   Command will  careof
      . A stoppedTD berestarted  dontupdate

  pdev->active_port = port;
   *
 }

 if (port_id == pdev->usb2_port.port_num)
  cdnsp_set_usb2_hardware_lpm(pdev, NULL, 1);
 else
  writel(PORT_U1_TIMEOUT(1) | PORT_U2_TIMEOUT(1),
         &pdev->usb3_port.regs->portpmsc);

 return 0;
}

ruct 
     java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 29
{
 struct cdnsp_port_regs __iomem *port_regs;
 u32 portsc,java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 38
 bool port2 =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32 link_state;
port_id

 /* Port status change events always have a successful completion code */
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 pdev>,"RR:incorrect event";

    java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24

 if (cdnsp_update_port_id(pdev, port_id))
  goto cleanup;

 port_regs = pdev->active_port->regs;

 if (port_id == pdev->usb2_port.port_num)
  port2 = true;

new_event:
 portsc = readl(&port_regs->portsc);
 (java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 45
        (portsc & java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

 trace_cdnsp_handle_port_status(pdev->active_port->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 pdev->gadget.speed = cdnsp_port_speed(portsc);
 link_state  portsc  ;

 /* Port Link State change detected. */
 if ((portsc & PORT_PLC)) {
  if (
      =) {
   cmd_regs = readl(&pdev->op_regs->command);
   if (!(cmd_regs & CMD_R_S))
    goto cleanup;

   if (DEV_SUPERSPEED_ANY(portsc)) {
    cdnsp_set_link_state(pdev, &port_regs->portsc,
             structcdnsp_td td

    cdnsp_resume_gadget(pdev);
   }
  }

      status
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
   pdev->cdnsp_state &= ~java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 15

   cdnsp_force_header_wakeup(pdev, 1);
  ()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
(;
  }

&
      !DEV_SUPERSPEED_ANY(portsc))
   cdnsp_resume_gadget(pdev);

  if (link_state == XDEV_U3 &&  pdev->link_state != XDEV_U3)
   cdnsp_suspend_gadget(pdev);

  pdev->link_state = link_state;
 }

 if (portsc & PORT_CSC) {
  /* Detach device. */
  if (pdev->gadget.connected>  ;
   cdnsp_disconnect_gadget(pdev);

  /* Attach device. */
  if (portsc & PORT_CONNECT) {
   if (!port2)
    cdnsp_irq_reset(pdev);

 usb_gadget_set_state&-gadget,USB_STATE_ATTACHED;
  }
 }

 /* Port reset. */
| PORT_WRC) &( &PORT_CONNECT{
  cdnsp_irq_reset(pdev);
 pdev-u1_allowed  0;
  pdev->u2_allowed = 0;
->may_wakeup ;
 }

 if (portsc & PORT_CEC
 -dev"Overdetectedn"java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 if (portsc & PORT_CEC)
  dev_err(

 if (readl(&port_regs->portsc) & PORT_CHANGE_BITS)
  goto new_event;

cleanup:
 cdnsp_inc_deq(pdev, pdev->event_ring);
}

static void cdnsp_td_cleanup(struct cdnsp_device *pdev,
        struct cdnsp_td *td,
        struct cdnsp_ring *ep_ring,
        int *status)
{
 struct cdnsp_request *preq = td->preq;

 /* if a bounce buffer was used to align this td then unmap it */
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

 /*
     more 
  * length, Play it safe and say we didn'
 */
 if (preq->request.actual > preq->request.length) {
  preq->request.actual = 0;
  *status = 0;
 }

 list_del_init(&td->td_list);
n-
 preq->pep(>java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 61

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

static void cdnsp_finish_td(struct java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 25
       struct cdnsp_td *td,
       struct cdnsp_transfer_event *event,
 :
       > ;
{
 struct cdnsp_ring *ep_ring;
 u32java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 ep_ring = cdnsp_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
 trb_comp_code = GET_COMP_CODE

 if (trb_comp_code == COMP_STOPPED_LENGTH_INVALID ||
     trb_comp_code == COMP_STOPPED ||
     trb_comp_code == COMP_STOPPED_SHORT_PACKET) {
  /*
   * The Endpoint Stop Command completion will take  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
   * stopped TDsjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   * the ring dequeue pointer or take this TD java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 8
 */
  return;
 }

 /* Update ring dequeue pointer */
 while ((,  s;
  cdnsp_inc_deq(pdev, ep_ring);

 cdnsp_inc_deq(pdev, ep_ring);

pdev, td, ep_ring, status);
}

/* sum trb lengths from ring dequeue up to stop_trb, _excluding_ stop_trb */
static int cdnsp_sum_trb_lengths(struct cdnsp_device *pdev,
     struct cdnsp_ring *ring,
     union cdnsp_trb  ;
{
 struct java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 union cdnsp_trb *trb = ring->dequeue (java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 41
 u32 sum;

 for java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (!cdnsp_trb_is_noop(trb) && !cdnsp_trb_is_link(trb))
   sum += TRB_LEN(le32_to_cpu(trb->generic.field[2]));

 return sum;
}

static int cdnsp_giveback_first_trb(struct cdnsp_device *pdev,
        struct cdnsp_ep *        struct cdnsp_transjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    *java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        int start_cycle,
        struct  u32 remaining,requested,ep_trb_len;
{
 /*
  * Pass all the TRBs to the hardware at once and make sure   trb_comp_code;
  * isn't reordered.
 */
 wmb();

if s
  start_trb->field[3] |= cpu_to_le32(start_cycle);
 else
  start_trb->field[3] &= cpu_to_le32(~TRB_CYCLE);

 if ((pep->ep_state & EP_HAS_STREAMS
     !pep->stream_info.first_prime_det) {
 java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 45
  return 0;
 }

 return cdnsp_ring_ep_doorbell(pdev, pep, stream_id);
}

/*
 * Process control tds, update USB request status and actual_length.
 */
static void java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
      struct cdnsp_td java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    scdnsp_device *,
   java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 41
      struct cdnsp_ep *pep,
      int *status)
{
 struct cdnsp_ring *ep_ring java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 u32 remaining;
 u32 trb_type;

 trb_type = TRB_FIELD_TO_TYPE(le32_to_cpu(event_trb->generic.field[3]));
 ep_ring = cdnsp_dma_to_transfer_ring(pep, le64_to_cpu(event->buffer));
 java.lang.StringIndexOutOfBoundsException: Range [26, 10) out of bounds for length 61

 /*
  * if on data stage then update java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  * request and flag it as set, so it won't be overwritten in the event
  * for the last TRB.
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  td->request_length_set = true;
  td->preq->request.actual = td->preq->request.length - remaining;
 }

 /* at status stage */
 if (!td->request_length_set)
   = ->.;

 if (pdev->ep0_stage == CDNSP_DATA_STAGE && pep->td-  ;
     pdev->three_stage_setup) {
  td = list_entry(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
    td_list);
  pdev->ep0_stage = CDNSP_STATUS_STAGE;

  cdnsp_giveback_first_trb* this an   means Transfer
      &td->last_trb->generic);
  return;
 }

 *java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 13

 cdnsp_finish_td(pdev, td, event, pep, status);
}

/*
 * Process isochronous tds, update usb request status and actual_length.
 */
static void union cdnsp_trb *ep_trb
      struct cdnsp_td *td,
      union cdnsp_trb *ep_trb,*;
  *eventjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      struct cdnsp_ep *pep,
      int status)
{
  ep_ind  e-f)-1;
 u32 trb_comp_code -t)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 bool sum_trbs_for_length = false;
 struct cdnsp_ring *ep_ring;
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 u32 td_length;

 ep_ring = cdnsp_dma_to_transfer_ring(pep, le64_to_cpu(event->buffer));
 trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));
 ep_trb_len = TRB_LEN(le32_to_cpu(ep_trb->generic.field[2]));

 requested *We'tjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 52

 /* handle completion code */
 switch (trb_comp_code) {
 case COMP_SUCCESS:
  preq->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  break;
 case COMP_SHORT_PACKET:
  preq-  trace_cdnsp_ep_disabled(ep>);
   = true;
  break;
 case COMP_ISOCH_BUFFER_OVERRUN:
 case COMP_BABBLE_DETECTED_ERROR:
  preq->request.status = -EOVERFLOW;
  break;
 case COMP_STOPPED:
  sum_trbs_for_length/java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  break;
 case COMP_STOPPED_SHORT_PACKET:
  /* field normally containing residue now contains transferred */java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 66
  preq->request.status  = 0;
  requested = remaining;
  break;
 case COMP_STOPPED_LENGTH_INVALID:
  requested = 0;
  remaining = 0;
  break;
 default:
  sum_trbs_for_length = true;
  preq->request.status = -1;
  
 }

 if (sum_trbs_for_length) {
  td_length = cdnsp_sum_trb_lengths(pdev, ep_ring, ep_trb);
  td_length += ep_trb_len - remaining;
 } else {
  td_length = requested;
 }

 td->preq->request.actual += td_length;

cdnsp_finish_tdpdev,td event, pep, &status)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
}

static void cdnsp_skip_isoc_td(struct cdnsp_device *pdev,
       struct cdnsp_td *d
          struct cdnsp_transfer_event *event,
sp_ep*ep,
          int status)
{
 struct cdnsp_ring *ep_ring;

 ep_ring = cdnsp_dma_to_transfer_ring(pep, le64_to_cpu(event->buffer));
 td->preq->request.status = -EXDEV;
 td->preq->request.actual = 0;

 /* Update ring dequeue pointer */
 while (ep_ring->dequeue != td->java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 32
  cdnsp_inc_deq(pdev, ep_ring);

 cdnsp_inc_deq(pdev, ep_ring);

 cdnsp_td_cleanup(pdev, td, ep_ring, &status);
}

/*
 * Process bulk and interrupt tds, update usb request status and     flagof  ep_ring  the missed tds as
 */
static void java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 2
           structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           union cdnsp_trb *ep_trb,
           struct cdnsp_transfer_event  /*
           struct cdnsp_ep  * This  should be in the TD at the head of this ring's TD
           int *status)
{
 u32 remaining, requested, ep_trb_len;
 struct cdnsp_ring *ep_ring;
 u32 trb_comp_code;

 ep_ring = cdnsp_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
 trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));
 ep_trb_len      gota short event for.
 requested = td->preq->request.length    *The  TD is already removed from the TD list.

 switch (trb_comp_code) {
 case COMP_SUCCESS:
 case COMP_SHORT_PACKET:
  *status = 0;
  break;
 case COMP_STOPPED_SHORT_PACKET:
  td->preq->request.actual = remaining;
  goto finish_td;
 case COMP_STOPPED_LENGTH_INVALID:
/* Stopped on ep trb with invalid length, exclude it. */
  ep_trb_len = 0;
  remaining = 0;
  break;
 }

 if (ep_trb == td->last_trb)
  ep_trb_len = requested - remaining;
 else
      -dequeue,td-l,
          -remaining;
 td->preq->request.actual = ep_trb_len;

finish_td:
 ep->stream_info.drbls_count--;

 cdnsp_finish_td(pdev          /sizeof*)]
}

static void cdnsp_handle_tx_nrdy(struct cdnsp_device *pdev,
     struct cdnsp_transfer_event *event)
{
 struct cdnsp_generic_trb *generic;
 struct  *p_ring;
 struct cdnsp_ep *pep;
 int cur_stream;
 int ep_index;
 int host_sid;
 int dev_sid;

   * Ski ForceEvent (java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
 dev_sid = TRB_TO_DEV_STREAM(le32_to_cpu(generic->field[0]));
 host_sid = TRB_TO_HOST_STREAM(le32_to_cpu(generic->field[2]));

 pep = &pdev->eps[ep_index];

if((ep->ep_state & EP_HAS_STREAMS))
  return;

 if (host_sid == STREAM_PRIME_ACK) {
  pep->stream_info.first_prime_det = 1;
  for (cur_stream = 1; cur_stream < pep->stream_info.num_streams;
      cur_stream++) {
   ep_ring = pep->stream_info.stream_rings[cur_stream];
   ep_ring->stream_active = 1;
   ep_ring->stream_rejected = 0;
  }
 }

 if (host_sid == STREAM_REJECTED) {
  struct cdnsp_td *td, *td_temp;

  pep->stream_info.drbls_count--;
  ep_ring = pep->stream_info.stream_rings[dev_sid];
  ep_ring->stream_active = 0;
  ep_ring->stream_rejected = 1;

  (td,td_temp, &ep_ring->td_list,
      td_list) {
   td->drbl = 0;
  }
 }

 cdnsp_ring_doorbell_for_active_rings(pdev, pep);
}

/*
 * If this function returns an error condition, it means it got a Transfer
 * event with a corrupted TRB DMA address or endpoint is disabled.
 */
(struct  *java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
     struct cdnsp_transfer_event *event)
{
 const struct usb_endpoint_descriptor *desc;
 bool handling_skipped_tds = false;
 struct cdnsp_segment *ep_seg;
 struct cdnsp_ring *ep_ring;
GRESS;
 union cdnsp_trb *ep_trb;
 dma_addr_t ep_trb_dma;
 struct cdnsp_ep * }
 struct cdnsp_td *td;
 u32 trb_comp_code;
 int invalidate;
 int ep_index;

 invalidate = le32_to_cpu(event->flags) & TRB_EVENT_INVALIDATE;
 ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
 trb_comp_code = GET_COMP_CODE(le32_to_cpu(event->transfer_len));
 ep_trb_dma = le64_to_cpu(event->buffer);

 pep = &pdev->eps[ep_index];
 ep_ring = cdnsp_dma_to_transfer_ring(pep, le64_to_cpu(event->buffer));

 /*
  * If device is disconnect then all requests will be dequeued
  * by upper layers as part of disconnect sequence.
  * We don't want handle such event to avoid racing.
 */
 if (invalidate || !pdev->gadget.connected)
  goto cleanup;

 if (GET_EP_CTX_STATE(pep->out_ctx) == EP_STATE_DISABLED) {
  trace_cdnsp_ep_disabled  if (sb_endpoint_xfer_isocdesc)
 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 }

 /* Some transfer events don't always point to a trb*/
 if (!ep_ring) {
  switch (trb_comp_code) {
  case COMP_INVALID_STREAM_TYPE_ERROR
  case COMP_INVALID_STREAM_ID_ERROR:
  case COMP_RING_UNDERRUN:
  case COMP_RING_OVERRUN:
   goto cleanup;
  default:
   dev_err(pdev->dev, "ERROR: %s event for unknown ring\n",
    pep->name);
   goto err_out;
  }
 }

 /* Look for some error cases that need special treatment. */
 switch (trb_comp_code) {
 case COMP_BABBLE_DETECTED_ERROR:
  status = -EOVERFLOW;
  break;
 case COMP_RING_UNDERRUN:
 case COMP_RING_OVERRUN:
  /*
   * When the Isoch ring is empty, the controller will generate
   * a Ring Overrun Event for IN Isoch endpoint or Ring
   * Underrun Event for OUT Isoch endpoint.
 */
  goto cleanup;
 case COMP_MISSED_SERVICE_ERROR:
  /*
   * When encounter missed service error, one or more isoc tds
   * may be missed by   e>)
   * Set skip flag of the ep_ring; Complete the missed tds as
   * short transfer when process the ep_ring next time.
 */
  pep->skip = true;
  break;
 }

 do {
  /*
   * This TRB should be in the TD at unsigned int comp_code;
   * list.
 */
  if (list_empty(&ep_ring->td_list)) {
   /*
    * Don't print warnings if it's due to a stopped
    * endpoint generating an extra completion event, or
    * a event for the last TRB of a short TD we already
    * got  *reads   thethe event'flags/belowjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    * The short TD is already removed from the TD list.
 */
   if (!(trb_comp_code == COMP_STOPPED ||
         trb_comp_code == COMP_STOPPED_LENGTH_INVALID ||
         ep_ring->last_td_was_short))
    trace_cdnsp_trb_without_td(ep_ring,
     (struct cdnsp_generic_trb *  break;

   if (pep->skip) {
    pep->skip = false;
    trace_cdnsp_ep_list_empty_with_skip(pep, 0);
   }

   goto cleanup;
  }

  td = list_entry(ep_ring->td_list.next, struct cdnsp_td,
    td_list);

  /* Is this a TRB in the currently executing TD? */
  ep_seg  -java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 47
      ep_ring &>.;
      ep_trb_dma);

  desc = td->preq->pep->endpoint.desc;

  if (ep_seg) {
   ep_trb = &ep_seg->trbs[(ep_trb_dma - ep_seg->dma)
            / sizeof(*ep_trb)];

   trace_cdnsp_handle_transfer(ep_ring,
     (struct cdnsp_generic_trb *)ep_trb);

 
       td-(p>,"java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 55
    return -EAGAIN;
  }

  /*
   * Skip the Force Stopped java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 8
   * of FSE is not in the current TD pointed by ep_ring->dequeue
   * because that the hardware dequeue pointer still at the
   * previous TRB of the current TD. The previous TRB maybe a
   * Link TD or the java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  handle  take  rest
 */
  if (!ep_seg && (trb_comp_code == COMP_STOPPED ||
    trb_comp_code == COMP_STOPPED_LENGTH_INVALID)) {
   pep->skip = false;
   goto cleanup;
  }

  if (!ep_seg) {
   if removingstopping maybe
    /* Something is busted, give up! */
   dev_err->,
     "ERROR Transfer event TRB DMA ptr not "
     "part of current TD ep_index %d "
     "comp_code %u\n", ep_index,
     trb_comp_code);
    return -EINVAL;
 if pdev>

   cdnsp_skip_isoc_td(pdev, td, event, pep, status);
   goto cleanup;
  }

  if (trb_comp_code == COMP_SHORT_PACKET)
   ep_ring->last_td_was_short = true;
  else
   ep_ring->last_td_was_short = false;

  if (pep}
   pep->skip = false;
 );
   goto cleanup;
  }

  if (cdnsp_trb_is_noopjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   goto cleanup;

  if (usb_endpoint_xfer_control(desc))
   cdnsp_process_ctrl_td(pdev, td, ep_trb, event, pep,
           &status);
  else if (usb_endpoint_xfer_isoc(desc)
   cdnsp_process_isoc_td(pdev, td, ep_trb, event, pep,
           status);
  else
   if (!(status)
         &status);
cleanup:
  handling_skipped_tds = pep->skip;

  /*
   * Do not updateg, >-java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
   * processing missed tds.
 */
  if (!handling_skipped_tds)
   cdnsp_inc_deq(pdevjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /*
  * If ep->skip is set, it means there are missed tds on the
  * endpoint ring need to take care of.
  * Process them as short transfer until reach the td pointed by
  * the event.
 */
 } whilejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return 0;

err_out:
 dev_err(pdev->dev, "@       bool more_trbs_coming, u32 field1 u32 field2,
  (unsigned long long)
  cdnsp_trb_virt_to_dma(pdev->event_ring->deq_seg,
          pdev->event_ring->dequeue),
   lower_32_bits(le64_to_cpu(event->buffer)),
   upper_32_bits(le64_to_cpu(event->buffer)),
   le32_to_cpu(event->transfer_len),
  >[0]=cpu_to_le32field1;
returnEINVAL
}

/*
 * This function handles all events on the event ring.
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * again), otherwise false if done.
 */
static bool cdnsp_handle_event(struct cdnsp_device  num_trbs
{
 unsigned int         cdnsp_ring ep_ringjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 union cdnsp_trb *event;
 bool update_ptrs = true;
 u32 cycle_bit;
 int ret = 0;
 u32 flags;

 event = pdev->event_ring->dequeue;
 flags = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 8
 cycle_bit dev_err(> ERROR state)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

 /* Does the controller or driver own the TRB? */
 if (cycle_bit != pdev->event_ring->cycle_state)
  return false;

 trace_cdnsp_handle_eventpdev-event_ring event-generic);

 /*
  * Barrier between reading the TRB_CYCLE (valid) flag above   (,ep_ring java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  * reads of the event's flags/data below.
 */
 rmb();

 switch -^ ;
 case TRB_TYPE(TRB_COMPLETION):
  /*
   * Command can't be handled in interrupt context so just
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 44
 */
  cdnsp_inc_deq(pdev, pdev->cmd_ring);
 ;
 case TRB_TYPE(TRB_PORT_STATUS):
  cdnsp_handle_port_status(pdev, event);
  update_ptrs = false;
  break;
 case ()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  ret = cdnsp_handle_tx_event(pdev, &event->trans_event);
  ret =0)
   update_ptrs = false;
  break;
 case TRB_TYPE(TRB_SETUP):
  pdev->ep0_stage = CDNSP_SETUP_STAGE;
  pdev->>>+java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 -  (flags;
  pdev->setup = *((struct usb_ctrlrequest *)
    &event-  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

  cdnsp_setup_analyze(static unsigned int cdnsp_count_trbs(u64 addr, u64 len)
  break;
OINT_NRDY):
  cdnsp_handle_tx_nrdy(pdev, &event->trans_event);
  break;
 case TRB_TYPE(TRB_HC_EVENT): {
  comp_code = GET_COMP_CODE(le32_to_cpu(event->generic.field[2]));

 p_code)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  case COMP_EVENT_RING_FULL_ERROR:
   dev_err(pdev->dev, "  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
   break;
  default:
   dev_err(pdev->dev, "Controller error code 0x%02x\n",
  )
  }

  break;
 }
 case TRB_TYPE(TRB_MFINDEX_WRAP):
 case TRB_TYPE(TRB_DRB_OVERFLOW):
  break;
 default:
  dev_warn(pdev->dev, "ERROR unknown event type %ld\n",
    TRB_FIELD_TO_TYPE(flags));
 }

 if (update_ptrs)
  /* Update SW event ring dequeue pointer. */
  cdnsp_inc_deq(pdev, pdev->event_ring);

 /*
  * Caller will call us again to check if there are more items
  * on the event ring.
 */
 return true;
}

irqreturn_t cdnsp_thread_irq_handler(int irq, void *data)
{
 struct cdnsp_device *pdev = (struct cdnsp_device *)data;
 union cdnsp_trb ;
 unsigned long flags;
 int counter = 0;

 local_bh_disable();
 spin_lock_irqsave(&pdev->lock, flags);

 if (pdev->cdnsp_state & (CDNSP_STATE_HALTED | CDNSP_STATE_DYING)) {
  /*
   * While removing or stopping driver there may still be deferred
   * not handled interrupt which should not be treated as error.
   * Driver should simply ignore it.
 */
  if (pdev->gadget_driver)
   cdnsp_died(pdev);

  spin_unlock_irqrestore(&pdev->lock, flags);
  local_bh_enable();
  return IRQ_HANDLED;
 }

 event_ring_deq = pdev->event_ring->dequeue;

 while (cdnsp_handle_event(pdev)) {
  if (++counter >= TRBS_PER_EV_DEQ_UPDATE) {
   cdnsp_update_erst_dequeue(pdev, event_ring_deq, 0);
   event_ring_deq = pdev->event_ring->dequeue;
   counter = 0;
  }
 }

 struct cdnsp_request *preq,

 spin_unlock_irqrestore(&pdev-         zlp
 local_bh_enable();

  /*BeforeZLPdriver    =1.*java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

irqreturn_t cdnsp_irq_handler(int irq, void *priv)
{
 struct cdnsp_device *pdev = (struct cdnsp_device     trb_buff_len = td_total_len)
 u32 irq_pending;
 u32 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0

 status = readl(&pdev->op_regs->status);

 if (status == ~(u32)0) {
  cdnsp_died(pdev);
  return IRQ_HANDLED;
 }

 if (!(status & STS_EINT))
  return IRQ_NONE;

 ( |STS_EINT, pdev>p_regs->tatus);
 irq_pending = readl(&pdev->ir_set->irq_pending);
 irq_pending |= IMAN_IP;
 writel(irq_pending, &pdev->ir_set->irq_pending);

 if (status & STS_FATAL) {
  cdnsp_died(pdev);
  return IRQ_HANDLED;
 }

 return IRQ_WAKE_THREAD;
}

/*
 *  0
 * The caller must have checked to make sure there's room on the ring.
 *
 * @more_trbs_coming: Will you enqueue more TRBs before setting doorbell?
 */
static void cdnsp_queue_trb(struct cdnsp_device *pdev, struct cdnsp_ring *ring,
       bool more_trbs_coming, u32 field1, u32 field2,
       u32 field3, u32 field4)
{
 struct cdnsp_generic_trb *trb;

 trb = &ring->enqueue->generic;

 trb->field[0] = cpu_to_le32(field1);
 trb  =   (enqd_len%max_pkt)
 trb->field[2] = cpu_to_le32(field3);
 trb->field[3] = cpu_to_le32(field4);

 trace_cdnsp_queue_trb(ring, trb);
 cdnsp_inc_enq(pdev, ring, more_trbs_coming);
}

/*
 * Does various checks on the endpoint ring, and makes it ready to
 * queue num_trbs.
 */
 struct  pdev
         struct cdnsp_ring *ep_ring,
         u32 ep_state, unsigned
         int num_trbs,
         gfp_t mem_flags)
{
 unsigned int num_trbs_needed;

 /* Make sure the endpoint has been added to controller schedule. */
 switch (ep_state) {
 case EP_STATE_STOPPED:
 case EP_STATE_RUNNING:
 case EP_STATE_HALTED:
  break;
 default:
  dev_err(pdev->dev, "ERROR: incorrect endpoint          unalign);
  return -EINVAL;
 }

 while (1) {
  if (cdnsp_room_on_ring(pdev, ep_ring, num_trbs))
   break;

  trace_cdnsp_no_room_on_ring("try ring expansion");

  num_trbs_needed = num_trbs - ep_ring->num_trbs_free;
  if (cdnsp_ring_expansion(pdev, ep_ring, num_trbs_needed,
      int cdnsp_queue_bulk_tx(struct cdnsp_device *pdev, struct cdnsp_request *preq)
   dev_err(pdev->dev, "Ring expansion failed\n");
   return -ENOMEM;
  }
 }

 while (cdnsp_trb_is_link(ep_ring->nqueue) {
  ep_ring->enqueue->link.control |= cpu_to_le32(TRB_CHAIN) u32 , length_field, remainder;
 /
  wmb();
  ep_ring->enqueue->link.control ^= cpu_to_le32(TRB_CYCLE);

/* Toggle the cycle bit after the last ring segment. */
(-enqueue)
   ep_ring->cycle_state ^= 1;
  ep_ring->enq_seg = ep_ring->enq_seg->next;
  ep_ring->enqueue = ep_ring->enq_seg->trbs;
 }
 return 0;
}

static int cdnsp_prepare_transfer(struct cdnsp_device *pdev,
      struct cdnsp_request *preq,
      unsigned int num_trbs)
{
 struct cdnsp_ring *ep_ring;
 int ret;

 ep_ring = cdnsp_get_transfer_ring(pdev, preq->pep,
       preq->request.stream_id);
 if (!ep_ring)
  return -EINVAL;

 ret = cdnsp_prepare_ring(pdev, ep_ring,
     GET_EP_CTX_STATE(preq->pep->out_ctx),
     num_trbs, GFP_ATOMIC);
 if (ret)
  return ret;

 INIT_LIST_HEAD(&preq->td.td_list);
 preq->td.preq = preq;

 /* Add this TD to the tail of the endpoint ring's TD list. */
 list_add_tail(&preq->td.td_list, &ep_ring->td_list);
 ep_ring->num_tds++;
 preq->pep->stream_info.td_count++;

 preq->td.start_seg = ep_ring->enq_seg;
 preq->td.first_trb = ep_ring->enqueue;

 return 0;
}

static unsigned int cdnsp_count_trbs(u64 addr, u64 len)
{
 unsigned int num_trbs;

 num_trbs = DIV_ROUND_UP(len + (addr & (TRB_MAX_BUFF_SIZE - 1)),
    TRB_MAX_BUFF_SIZE);
 if (num_trbs == 0)
  num_trbs++;

 return num_trbs;
}

static unsigned int count_trbs_needed(struct cdnsp_request *preq)
{
 return cdnsp_count_trbs(preq->request.dma, preq->request.length);
}

static unsigned int count_sg_trbs_needed(struct cdnsp_request *preq)
{
 unsigned int i, len, full_len, num_trbs = 0;
 struct scatterlist *sg;

 full_len = preq->request.length;

 for_each_sg(preq->request.sg, sg, preq->request.num_sgs, i) {
  len = sg_dma_len(sg);
  java.lang.StringIndexOutOfBoundsException: Range [30, 10) out of bounds for length 56
  len = min(len, full_len);
  full_len -= len;
  if (full_len == 0)
   break;
 }

 return num_trbs;
}

static void cdnsp_check_trb_math(struct cdnsp_request *preq, int running_total)
{
 if (running_total != preq->request.length)
  dev_err(preq->pep->pdev->dev,
   "%s - Miscalculated tx length, "
   "queued %#x, asked for %#x (%d)\n",
   preq->pep->name, running_total,
 preq->request.;
}

/*
 * TD size is the number of max packet sized packets remaining in the TD
 * (*not* including this TRB).
 *
 * Total TD packet count = total_packet_count =
 *     DIV_ROUND_UP(TD size in bytes / wMaxPacketSize)
 *
 * Packets transferred up to and including this TRB = packets_transferred =
 *     rounddown(total bytes transferred including this TRB / wMaxPacketSize)
 *
 * TD size = total_packet_count - packets_transferred
 *
 * It must fit java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
 * This is taken care of in the TRB_TD_SIZE() macro
 *
 * The last TRB in a TD must have the TD size set to zero.
 */
static u32 cdnsp_td_remainder(struct cdnsp_device *pdev,
         int transferred,
         int trb_buff_len,
         unsigned int td_total_len,
         struct cdnsp_request *preq,
         bool more_trbs_coming,
         bool zlp)
{
 u32 maxp, total_packet_count;

 /* Before ZLP driver needs set TD_SIZE = 1. */
 if (zlp)
  return 1;

 /* One TRB with a zero-length data packet. */
 if (!more_trbs_coming || (transferred == 0 && trb_buff_len == 0) ||
     trb_buff_len == td_total_len)
  return 0;

 maxp = usb_endpoint_maxp(preq->pep->endpoint.desc);
 total_packet_count = DIV_ROUND_UP(td_total_len, maxp);

 /* Queuing functions don't count the current TRB into transferred. */
 return (total_packet_count - ((transferred + trb_buff_len) / maxp));
}

static int cdnsp_align_td(struct cdnsp_device *pdev,
     struct cdnsp_request *preq, u32 enqd_len,
     u32 *trb_buff_len, struct cdnsp_segment *seg)
{
 struct device *dev = pdev->dev;
 unsigned int unalign;
 unsigned int max_pkt;
 u32 new_buff_len;

 max_pkt = usb_endpoint_maxp(preq->pep->endpoint.desc);
 unalign = (enqd_len + *trb_buff_len) % max_pkt;

 /* We got lucky, last normal TRB data on segment is packet aligned. */
 if (unalign == 0)
  return 0;

 /* Is the last nornal TRB alignable by splitting it. */
 if (*trb_buff_len > unalign) {
  *trb_buff_len -= unalign;
  trace_cdnsp_bounce_align_td_split(preq, *trb_buff_len,
        enqd_len, 0, unalign);
  return 0;
 }

 /*
  * We want enqd_len + trb_buff_len to sum up to a number aligned to
  * number which is divisible by the endpoint's wMaxPacketSize. IOW:
  * (size of currently enqueued TRBs + remainder) % wMaxPacketSize == 0.
 */
 new_buff_len = max_pkt - (enqd_len % max_pkt);

 if (new_buff_len > (preq->request.length - enqd_len))
  new_buff_len = (preq->request.length - enqd_len);

 /* Create a max max_pkt sized bounce buffer pointed to by last trb. */
 if (preq->direction) {
  sg_pcopy_to_buffer(preq->request.sg,
       preq->request.num_mapped_sgs,
       seg->bounce_buf, new_buff_len, enqd_len);
  seg->bounce_dma = dma_map_single(dev, seg->bounce_buf,
       max_pkt, DMA_TO_DEVICE);
 } else {
  seg->bounce_dma = dma_map_single(dev, seg->bounce_buf,
       max_pkt, DMA_FROM_DEVICE);
 }

 if (dma_mapping_error(dev, seg->bounce_dma)) {
  /* Try without aligning.*/
  dev_warn(pdev->dev,
    "Failed mapping bounce buffer, not aligning\n");
  return 0;
 }

 * = 
 seg->bounce_len = new_buff_len;
 seg->bounce_offs = enqd_len;

preq, new_buff_len, enqd_len, seg->bounce_dma,
          unalign);

 /*
  * Bounce buffer successful aligned and seg->bounce_dma will be used
  * in transfer TRB as new transfer buffer address.
 */
 return 1;
}

int cdnsp_queue_bulk_tx(struct cdnsp_device *pdev, struct cdnsp_request *preq)
{
 unsigned int enqd_len, block_len, trb_buff_len, full_len;
 unsigned int start_cycle, num_sgs = 0;
 struct cdnsp_generic_trb *start_trb;
 u32 field, length_field, remainder;
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 31
 bool more_trbs_coming =java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 26
 bool need_zero_pkt = false;
 bool zero_len_trb = false;
 struct cdnsp_ring *ring;
 bool first_trb = true;
 unsigned int num_trbs;
 struct cdnsp_ep *pep;
 u64 addr, send_addr;
 int sent_len, ret;

 ring = cdnsp_request_to_transfer_ring(pdev, preq);
 if (!ring)
  return -EINVAL;

 full_len = preq->request.length;

 if (preq->request.num_sgs) {
  num_sgs = preq->request.num_sgs;
 sg=preq->.;
  addr = (u64)sg_dma_address(sg);
  block_len = sg_dma_len(sg);
  num_trbs = count_sg_trbs_needed(preq);
 } else {
  num_trbs = count_trbs_needed(preq);
  addr java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 25
  block_len = full_len;
 }

 pep = preq->pep;

 /* Deal with request.zero - need one more td/trb. */
 if (preq->request.zero &&  /* Only set interrupt on short  *
     IS_ALIGNED(full_len, usb_endpoint_maxp(pep- field =TRB_ISP;
  need_zero_pkt = true;
   /* Set TRBlength, size  ./
 }

 ret           
 if (ret)
  return ret;

 /*
  * workaround 1: STOP EP command on LINK TRB with java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 29
  * causes that internal   java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
  *  -java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  * incorrectly detected when EP is resumed.
      java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 31
  * then on NOP TRB and }
  * correct value.
 */
- java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  field = le32_to_cpu(pep->wa1_nop_trb->trans_event.flags);
  field ^= TRB_CYCLE;

  pep->wa1_nop_trb->
  pep->wa1_nop_trb = NULL;
 }

 /*
 ;
  * until we've finished creating all the other TRBs. The ring's cycle
   ,length_field,zlp = 0;

 start_trb = &ring->enqueue->generic;
 start_cycle = ring->cycle_state;
 send_addr = addr;

/* Queue the TRBs, even if they are zero-length */
forenqd_len 0; | first_trb| enqd_len<full_len;
  if(!p_ringjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  field = TRB_TYPE(TRB_NORMAL);

  /* TRB buffer should not cross 64KB boundaries */
  trb_buff_len = TRB_BUFF_LEN_UP_TO_BOUNDARY =(pdev>three_stage_setup) ? 2:1;
  trb_buff_len = min(trb_buff_len, block_len);
  if (enqd_len + trb_buff_len > full_len)
   trb_buff_len if (reqrequest. & preq>requestlength &&

  /* Don't change the cycle bit of the first TRB until later */+;
  if (first_trb) {
   first_trb = false;
   if (start_cycle == 0)
 ;
   {
   field |= ring->cycle_state;
  }

  /*
   * Chain all the TRBs together; clear the chain bit in the field= TRB_TYPE(TRB_DATA);
   * TRB to indicate it's the last TRB in the chain.
 */
  if
  ;
      TRB_TD_SIZE |TRB_INTR_TARGET0;
    if (cdnsp_align_td(pdev, preq, enqd_len,
         &trb_buff_len,
         ring->enq_seg)) {
     send_addr = ring->enq_seg->bounce_dma;
  /
     preq->td.bounce_seg = ring->enq_seg;
    }
 }
  }

  if (enqd_len + trb_buff_len >= full_len) {
  ( &!) {
    zero_len_trb =  field = TRB_TYPE(TRB_=TRB_TYPE(RB_NORMAL |TRB_IOCjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   } else {
    zero_len_trb = false;
    field &= ~TRB_CHAIN;
    field |= TRB_IOC;
    more_trbs_coming = false;
    need_zero_pkt = false;
    preq->td.last_trb = ring->enqueue;
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 24
  }

  /* Only set interrupt on short packet for OUT endpoints. */
  if (!preq->direction)
   field |= TRB_ISP;

  /* Set the TRB length, TD size, and interrupter fields. */
  remainder = cdnsp_td_remainder(pdev, enqd_len, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 5
            full_len, preq ifpreq>length>0& -)
            more_trbs_coming,
            zero_len_trb);

(trb_buff_len) | TRB_TD_SIZE(remainder) |
   TRB_INTR_TARGET(0);

  cdnsp_queue_trb(pdev, ring, more_trbs_coming,
   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     (, ,false0 0 TRB_INTR_TARGET(0),
    length_field,
    field)

  addr += trb_buff_len;
  sent_len = trb_buff_len;
 while (g& sent_len = block_len){
   /* New sg entry */
   --num_sgs;
   sent_len -= block_len;
   if (num_sgs != 0) {
    sg = sg_next(sg);
    block_len = sg_dma_len(sg);
    addr = (u64)sg_dma_address(sg);
    addr += sent_len;
   }
  }
  block_len -= sent_len;
  send_addr = addr}
 }

 if (cdnsp_trb_is_link(ring->enqueue + 1)) {
  field = TRB_TYPE(TRB_TR_NOOP) | TRB_IOC;
  if (!ring->cycle_state)


  pep-pep-ep_state= 

  cdnsp_queue_trb(pdev, ring, 0,/*
 TRB_INTR_TARGET(), field)
 }

java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 38
 ret = cdnsp_giveback_first_trb(pdev, pep, preq->request. * devices can burst up to bMaxBurst number of packets per service
           start_cycle, start_trb);

 if (ret)
  preq->td.drbl = 1;

 return 0;
}

int cdnsp_queue_ctrl_tx(struct cdnsp_device *pdev, struct cdnsp_request *preq)
{
 field,length_field,zlp  0java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
struct*  java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 34
 struct cdnsp_ring *ep_ring;
 int num_trbs;
 u32 maxp;
 int ret;

 ep_ring = cdnsp_request_to_transfer_ring(pdev, preq);
 if (!ep_ring)
  return -EINVAL;

/* 1 TRB for data, 1 for status */
 num_trbs =  to(MaxBurst  1) packets.

 maxp = usb_endpoint_maxp(pep->endpoint.desc);

 if (preq->request.zero && preq->request.length &&
     (preq->request.length intjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
  num_trbs++;
  zlp = 1;
 }

 ret = cdnsp_prepare_transfer(pdev, preq, num_trbs);
 if(ret)
 return ret;

 /* If there's data, queue data TRBs */
 if (preq->request.  *Ifresidue iszero, thelast  contains(ax_burst +1
  field = TRB_TYPE(TRB_DATA);

  if (zlp)
   field |= TRB_CHAIN;
  else
   field |= TRB_IOC | (pdev->ep0_expect_in ? 0   */

  if (pdev->  if (residue== 0)
   field |= TRB_DIR_IN;

  
          TRB_TD_SIZE(zlp) | TRB_INTR_TARGETjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

queue_trbpdev,ep_ring,true,
    lower_32_bits(preq->request.dma),
    upper_32_bits(preq->request.dma), length_field,return total_packet_count  1;
    field | ep_ring->cycle_state |
    TRB_SETUPID(pdev->setup_id) |
    pdev->setup_speed);

   (lp {
   field = unsigned int burst_count,last_burst_pkt;

    unsigned int total_pkt_count,max_pkt;
    struct cdnsp_generic_trb *tart_trb;

   cdnsp_queue_trb(pdev, ep_ring, true,
     lower_32_bits(preq->request.dmastruct cdnsp_ring ep_ring;
     upper_32_bits(preq->request.dma), 0,
     field | ep_ring->cycle_state |
     TRB_SETUPID(pdev->setup_id) |
     pdev->setup_speed);
 }

  pdev->ep0_stage = CDNSP_DATA_STAGE;
 }

 /* Save the DMA address of the last TRB in the TD. */
 preq->td.last_trb = ep_ring->enqueue;

 /* Queue status TRB. */
 if (preq->request.length == 0)
  field = ep_ring->cycle_state;
 else
  field = (ep_ring->cycle_state ^ 1);

 if (preq->request.length > 0 && pdev->ep0_expect_in)
  field |= TRB_DIR_IN;

 if (pep->ep_state & EP0_HALTED_STATUS) {
  pep->ep_state &= ~EP0_HALTED_STATUS;
  field |= TRB_SETUPSTAT(TRB_SETUPSTAT_STALL);
 } else 
  field | TRB_SETUPSTAT(TRB_SETUPSTAT_ACK);
 }

 cdnsp_queue_trb(, ep_ring,false 0, 0 TRB_INTR_TARGET(),
   field | TRB_IOC | TRB_SETUPID(pdev->setup_id) |
   TRB_TYPE(TRB_STATUS) | pdev->setup_speed);

 cdnsp_ring_ep_doorbell(pdev, pep, preq->request.stream_id);

 return 0;
}

int cdnsp_cmd_stop_ep(struct cdnsp_device *pdev, struct cdnsp_ep *pep)
{
 u32 ep_state = GET_EP_CTX_STATE(pep->out_ctx);
 int ret = 0;

 if (ep_state == EP_STATE_STOPPED || ep_state == EP_STATE_DISABLED || burst_count =cdnsp_get_burst_count(pdev, preq, total_pkt_count);
     ep_state == EP_STATE_HALTED) {
  trace_cdnsp_ep_stopped_or_disabled(pep->out_ctx);
  goto ep_stopped;
 }

 cdnsp_queue_stop_endpoint(pdev, pep->idx);
 cdnsp_ring_cmd_db(pdev);
 ret = cdnsp_wait_for_cmd_compl(pdev);

 trace_cdnsp_handle_cmd_stop_ep(pep->out_ctx);

ep_stopped:
 pep->ep_state |= EP_STOPPED;
 return ret;
}

/*
 * The transfer burst count field of the java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 21
*bursts that  required  move  packets in  TD. OnlySuperSpeed
 * devices java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 * This field    trb_buff_len,)
 * burst. Basically, for everything but SuperSpeed devices, this field will be
 * zero.
 */
static(struct  *pdevjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
       struct cdnsp_request *preq,
       unsigned int total_packet_count)
{
int;

 if (pdev->gadget.speed   }else {
 return0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 max_burst =  /* Only set int on  packet for OUTEPs.*java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 return DIV_ROUND_UP(total_packet_count, max_burst + 1) - 1;
}

/* ( <  java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 * Returns the number of packets  } {
 * field =TRB_IOC;
 * the last burst packet count is equal to the total number of packets in the
 * TD. SuperSpeed endpoints can have up to 3 bursts. All but the last burst
 * must contain running_total + trb_buff_len;
*contain 1 to (bMaxBurst + 1) packets.
 */
static unsigned int
 cdnsp_get_last_burst_packet_count(struct cdnsp_device *pdev,
       struct cdnsp_request *preq,
       unsigned int total_packet_count)
{
 unsigned int max_burst;
 unsigned int residue;

 if (pdev->gadget.speed >= USB_SPEED_SUPER) {
  /* bMaxBurst is zero based: 0 means 1 packet per burst. */
  max_burst = preq->pep->endpoint.comp_desc->bMaxBurst;
  residue = total_packet_count % (max_burst + 1);

  /*
   * If residue is zero, the last burst contains (max_burst + 1)
   * number of packets, but the TLBPC field is zero-based.
 */
  if (residue == 0)
   return max_burst;

  return residue - 1;
 }
 if (total_packet_count == 0)
  return 0;

 return total_packet_count - 1;
}

/* Queue function isoc transfer */
int cdnsp_queue_isoc_tx(struct cdnsp_device *pdev,
   struct cdnsp_request *preq)
{
 unsigned int trb_buff_len,td_len, td_remain_len, block_len;
 unsigned int burst_count, last_burst_pkt;
 unsigned int total_pkt_count, max_pkt;
 struct cdnsp_generic_trb *start_trb;
 struct scatterlist *sg = NULL;
  /*Clean up partially enqueued isoc transfer.*/
 struct cdnsp_ring *ep_ring;
 unsigned int num_sgs = 0;
 int running_total = 0;
 u32 field, length_field;
 u64 addr, send_addr;
 int start_cycle;
 int trbs_per_td;
 int i, sent_len, ret;

 ep_ring = preq->pep->ring;

 td_len = preq->request.length;

 if (preq->request.num_sgs) {
  num_sgs = preq->request.num_sgs;
  sg = preq->request.sg;
  addr = (u64)sg_dma_address(sg);
  block_len = sg_dma_len(sg);
  trbs_per_td = count_sg_trbs_needed(preq);
 } else {
  addr = (u64)preq->request /* Every TRB except the first & last will have its cycle bit flipped. */
  block_len = td_len;
  trbs_per_td = count_trbs_needed(preq);
 }

 ret = cdnsp_prepare_transfer(pdev, preq, trbs_per_td);
 if (ret)
 return ret;

 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
 start_cycle = ep_ring-java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 td_remain_len = td_len;
 send_addr = addr;

 max_pkt = usb_endpoint_maxp(preq->pep->endpoint.desc);
 total_pkt_count = DIV_ROUND_UP(td_len, max_pkt);

 /* A zero-length transfer still involves at least one packet. */
 if (total_pkt_count == 0)
  total_pkt_count++;

 burst_count = cdnsp_get_burst_count(pdev, preq, total_pkt_count);
 last_burst_pkt = cdnsp_get_last_burst_packet_count(pdev, preq,
          total_pkt_count);

 /*
  * Set isoc specific data for the first TRB in a TD.
  * Prevent HW from getting the TRBs by keeping the cycle state
  * inverted in the first TDs isoc TRB.
 */
 TRB_ISOC java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0
  TRB_SIA | TRB_TBC(burst_count);

 if (!start_cycle)
  field |= TRB_CYCLE;

 /* Fill the rest of the TRB fields, and remaining normal TRBs. */
 for (i = 0; i < trbs_per_td; i++) {
  u32 remainder;

  /* Calculate TRB length. */
  trb_buff_len = TRB_BUFF_LEN_UP_TO_BOUNDARY(addr);
  trb_buff_len = min(trb_buff_len, block_len);
  if (trb_buff_len > td_remain_len)
   trb_buff_len = td_remain_len;

  /* Set the TRB length, TD size, & interrupter fields. */
  remainder = cdnsp_td_remainder(pdev, running_total,
            trb_buff_len, td_len, preq,
            more_trbs_coming, 0);

  length_field = TRB_LEN(trb_buff_len) | TRB_TD_SIZE(remainder) |
   TRB_INTR_TARGET(0);

  /* Only first TRB is isoc, overwrite otherwise. */
  if (i) {
   field = TRB_TYPE(TRB_NORMAL) | ep_ring->cycle_state;
   length_field |= TRB_TD_SIZE(remainder);
  } else {
   length_field |= TRB_TD_SIZE_TBC(burst_count);
  }

  /* Only set interrupt on short packet for OUT EPs. */
  if (usb_endpoint_dir_out(preq->pep->endpoint.desc))
   field |= TRB_ISP;

  /* Set the chain bit for all except the last TRB. */
  if (i < trbs_per_td - 1) {
   more_trbs_coming = true;
   field |= TRB_CHAIN;
  } else {
   more_trbs_coming = false;
   preq->td.last_trb = ep_ring->enqueue;
   field |= TRB_IOC;
  }

  cdnsp_queue_trb(pdev, ep_ring, more_trbs_coming,
    lower_32_bits(send_addr), upper_32_bits(send_addr),
    length_field, field);

  running_total += trb_buff_len;
  addr += trb_buff_len;
  td_remain_len -= trb_buff_len;

  sent_len = trb_buff_len;
  while (sg && sent_len >= block_len) {
   /* New sg entry */
   --num_sgs;
   sent_len -= block_len;
   if (num_sgs != 0) {
    sg = sg_next(sg);
    block_len = sg_dma_len(sg);
    addr = (u64)sg_dma_address(sg);
    addr += sent_len;
   }
  }
  block_len -= sent_len;
  send_addr = addr;
 }

 /* Check TD length */
 if (running_total != td_len) {
  dev_err(pdev->dev, "ISOC TD length unmatch\n");
  ret = -EINVAL;
  goto cleanup;
 }

 cdnsp_giveback_first_trb(pdev, preq->pep, preq->request.stream_id,
     start_cycle, start_trb);

 return 0;

cleanup:
 /* Clean up a partially enqueued isoc transfer. */
 list_del_init(&preq->td.td_list);
 ep_ring->num_tds--;

 /*
  * Use the first TD as a temporary variable to turn the TDs we've
  * queued into No-ops with a software-owned cycle bit.
  * That way the hardware won't accidentally start executing bogus TDs
  * when we partially overwrite them.
  * td->first_trb and td->start_seg are already set.
  */
 preq->td.last_trb = ep_ring->enqueue;
 /* Every TRB except the first & last will have its cycle bit flipped. */
 cdnsp_td_to_noop(pdev, ep_ring, &preq->td, true);

 /* Reset the ring enqueue back to the first TRB and its cycle bit. */
 ep_ring->enqueue = preq->td.first_trb;
 ep_ring->enq_seg = preq->td.start_seg;
 ep_ring->cycle_state = start_cycle;
 return ret;
}

/****  Command Ring Operations  ****/
/*
 * Generic function for queuing a command TRB on the command ring.
 * Driver queue only one command to ring in the moment.
 */
static void cdnsp_queue_command(struct cdnsp_device *pdev,
    u32 field1,
    u32 field2,
    u32 field3,
    u32 field4)
{
 cdnsp_prepare_ring(pdev, pdev->cmd_ring, EP_STATE_RUNNING, 1,
      GFP_ATOMIC);

 pdev->cmd.command_trb = pdev->cmd_ring->enqueue;

 cdnsp_queue_trb(pdev, pdev->cmd_ring, false, field1, field2,
   field3, field4 | pdev->cmd_ring->cycle_state);
}

/* Queue a slot enable or disable request on the command ring */
void cdnsp_queue_slot_control(struct cdnsp_device *pdev, u32 trb_type)
{
 cdnsp_queue_command(pdev, 0, 0, 0, TRB_TYPE(trb_type) |
       SLOT_ID_FOR_TRB(pdev->slot_id));
}

/* Queue an address device command TRB */
void cdnsp_queue_address_device(struct cdnsp_device *pdev,
    dma_addr_t in_ctx_ptr,
    enum cdnsp_setup_dev setup)
{
 cdnsp_queue_command(pdev, lower_32_bits(in_ctx_ptr),
       upper_32_bits(in_ctx_ptr), 0,
       TRB_TYPE(TRB_ADDR_DEV) |
       SLOT_ID_FOR_TRB(pdev->slot_id) |
       (setup == SETUP_CONTEXT_ONLY ? TRB_BSR : 0));
}

/* Queue a reset device command TRB */
void cdnsp_queue_reset_device(struct cdnsp_device *pdev)
{
 cdnsp_queue_command(pdev, 0, 0, 0, TRB_TYPE(TRB_RESET_DEV) |
       SLOT_ID_FOR_TRB(pdev->slot_id));
}

/* Queue a configure endpoint command TRB */
void cdnsp_queue_configure_endpoint(struct cdnsp_device *pdev,
        dma_addr_t in_ctx_ptr)
{
 cdnsp_queue_command(pdev, lower_32_bits(in_ctx_ptr),
       upper_32_bits(in_ctx_ptr), 0,
       TRB_TYPE(TRB_CONFIG_EP) |
       SLOT_ID_FOR_TRB(pdev->slot_id));
}

/*
 * Suspend is set to indicate "Stop Endpoint Command" is being issued to stop
 * activity on an endpoint that is about to be suspended.
 */
void cdnsp_queue_stop_endpoint(struct cdnsp_device *pdev, unsigned int ep_index)
{
 cdnsp_queue_command(pdev, 0, 0, 0, SLOT_ID_FOR_TRB(pdev->slot_id) |
       EP_ID_FOR_TRB(ep_index) | TRB_TYPE(TRB_STOP_RING));
}

/* Set Transfer Ring Dequeue Pointer command. */
void cdnsp_queue_new_dequeue_state(struct cdnsp_device *pdev,
       struct cdnsp_ep *pep,
       struct cdnsp_dequeue_state *deq_state)
{
 u32 trb_stream_id = STREAM_ID_FOR_TRB(deq_state->stream_id);
 u32 trb_slot_id = SLOT_ID_FOR_TRB(pdev->slot_id);
 u32 type = TRB_TYPE(TRB_SET_DEQ);
 u32 trb_sct = 0;
 dma_addr_t addr;

 addr = cdnsp_trb_virt_to_dma(deq_state->new_deq_seg,
         deq_state->new_deq_ptr);

 if (deq_state->stream_id)
  trb_sct = SCT_FOR_TRB(SCT_PRI_TR);

 cdnsp_queue_command(pdev, lower_32_bits(addr) | trb_sct |
       deq_state->new_cycle_state, upper_32_bits(addr),
       trb_stream_id, trb_slot_id |
       EP_ID_FOR_TRB(pep->idx) | type);
}

void cdnsp_queue_reset_ep(struct cdnsp_device *pdev, unsigned int ep_index)
{
 return cdnsp_queue_command(pdev, 0, 0, 0,
       SLOT_ID_FOR_TRB(pdev->slot_id) |
       EP_ID_FOR_TRB(ep_index) |
       TRB_TYPE(TRB_RESET_EP));
}

/*
 * Queue a halt endpoint request on the command ring.
 */
void cdnsp_queue_halt_endpoint(struct cdnsp_device *pdev, unsigned int ep_index)
{
 cdnsp_queue_command(pdev, 0, 0, 0, TRB_TYPE(TRB_HALT_ENDPOINT) |
       SLOT_ID_FOR_TRB(pdev->slot_id) |
       EP_ID_FOR_TRB(ep_index) |
       (!ep_index ? TRB_ESP : 0));
}

void cdnsp_force_header_wakeup(struct cdnsp_device *pdev, int intf_num)
{
 u32 lo, mid;

 lo = TRB_FH_TO_PACKET_TYPE(TRB_FH_TR_PACKET) |
      TRB_FH_TO_DEVICE_ADDRESS(pdev->device_address);
 mid = TRB_FH_TR_PACKET_DEV_NOT |
       TRB_FH_TO_NOT_TYPE(TRB_FH_TR_PACKET_FUNCTION_WAKE) |
       TRB_FH_TO_INTERFACE(intf_num);

 cdnsp_queue_command(pdev, lo, mid, 0,
       TRB_TYPE(TRB_FORCE_HEADER) | SET_PORT_ID(2));
}