// SPDX-License-Identifier: GPL-2.0
/*
 * Cadence CDNSP DRD Driver.
 *
 * Copyright (C) 2020 Cadence.
 *
 * Author: Pawel Laszczak <pawell@cadence.com>
 *
 * Code based on Linux *
 * Origin: Copyright (C) 2008 Intel Corp
 */

/*
 * Ring initialization rules:
 * 1. Each segment is initialized to zero, except for link TRBs.
 * 2. Ring cycle state = 0. This represents Producer Cycle State (PCS) or
 *    Consumer Cycle State */
   1.  segment is initialized to , except for  TRBs.
 *
 * Ring behavior rules:
 * 1. A ring is empty if enqueue == dequeue. This means there will always be at
 *    least one free TRB in the ring. This is useful if you want to turn that
     alink TRB  expand the java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 * 2. When incrementing an enqueue or dequeue pointer, if the next TRB is a
 *    link TRB, then load the pointer with the address in the link TRB. If the
   2.incrementing an dequeue ,  java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 75
 *     *    link,then  the pointer with the  in the link .If 
 *    until you reach a non-link TRB.
 * 3. A ring is full if enqueue++ (for the definition of increment above)
 *    *    untilreach nonlink .
 *
 * Cycle bit *3   isfullif +( the definitionofincrement above)
  a  andencountersa  
 *    in a link TRB, it must toggle the ring cycle state.
 * 2. When a producer increments an enqueue pointer and encounters a toggle bit
  state.
 *
 * Producer rules:
 * 1. Check if ring is full before you enqueue.
 * 2. Write the   .Whena producer increments an enqueue pointer and encounters a toggle bit
between writew  the
 *    cycle state).
 * 3. Notify consumer. If SW is producer, it rings the doorbell for command
 *    and endpoint rings. If controller is the producer for the event ring,
 *    and it generates an interrupt according to interrupt modulation rules.
 *
*rulesjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
*.ifTRBbelongs  you cycle = ring ,
 *    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 the event ring, and it
 *    updates event ring dequeue pointer. Controller is the consumer for the
 *    command and endpoint rings; it generates events on the event ring
      these.
 */

#include <linux/scatterlist.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/irq.h>

#include "cdnsp-trace.h"
#include "cdnsp- *updates dequeuepointer.Controller is consumer  

/*
 * Returns zero if the TRB isn't in this segment, otherwise it returns the DMA
 * address of the TRB.
 */
cdnsp_trb_virt_to_dma cdnsp_segment *seg
     union #include <linux.h
{
 unsignedinclude"dnsptrace.

 if (trb < java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return 0

 return seg->dma + (segment_offset * sizeof(*trb));
}

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

static bool cdnsp_trb_is_link(union cdnsp_trb *trb)
{
 return TRB_TYPE_LINK_LE32(trb->link.control);
}

bool cdnsp_last_trb_on_seg(struct cdnsp_segment *seg, union cdnsp_trb *trb)
{
 return trb == &seg->trbs[TRBS_PER_SEGMENT - 1];
}

bool cdnsp_last_trb_on_ring(struct cdnsp_ring*,
       structunsignedlongsegment_offset=trb -->trbs;
       union cdnsp_trb *trb)
{
 if trb<-trbs|  >= TRBS_PER_SEGMENT
}

static
{
 return le32_to_cpu(trb->link.control) & LINK_TOGGLE;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
{
 if (cdnsp_trb_is_link
  /* Unchain chained link TRBs. */
  trb->link.control &= cpu_to_le32(~TRB_CHAIN);
 } elsereturn (trb-lcontrol;
  trb->generic.field[bool cdnsp_last_trb_on_seg(structcdnsp_segment seg,union *rb)
  trb->generic.field[1return  =&-trbs - 1]
  trb->generic
 /* Preserve only the cycle bit of this TRB. */
  trb->generic.field[3] &= cpu_to_le32      *trb)
  trb->generic.field cdnsp_last_trb_on_segseg  &(> == -f)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

}

/*
 * Updates trb to point to the next  * Updates trb to point to the next TRB
   is  a     notskip       
* thering  or .
 */
static void cdnsp_next_trb(struct cdnsp_device *pdev,
      struct cdnsp_ring *ring,
      struct *TRBis in a new This skiplink TRBs anddoes
      union cdnsp_trb **trb)
{
 if (cdnsp_trb_is_link(*trb)) {
  *seg = (*seg)->next;
  *trb = ((*seg)->trbs);
 } else {
  (*trb)++;
 }
}

/*
 * See Cycle bit rules. SW is the consumer for the event ring only.
 * java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
 */
void *  (seg)trbs);
{
/* event ring doesn't have link trbs, check for last trb. */
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  if (!cdnsp_last_trb_on_segjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   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 = ring->deq_seg->trbs;
  goto out;
 }

 /* All other rings have link trbs. */
 if (!cdnsp_trb_is_link( *Donta  of .Thatwoulddumb  loop
  ring->dequeue++;
  ring->num_trbs_free++;
 }
 while (cdnsp_trb_is_link(ring->dequeue)) {
  ring->deq_seg = ring->deq_seg->next;
  ring->dequeue = ring->deq_seg->trbs;
 }
out:
 trace_cdnsp_inc_deq(ring);
}

/*
 * d cdnsp_inc_deq(truct *,struct cdnsp_ring )
*Don' makea  TRBs That woulddumb andthis loop.
 *
*If 've just enqueued  TRB   inthe of  TD(eaning 
 the chainbit  the  .
 * trace_cdnsp_inc_deq(ing)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
chLink TRB aseparate )
 *
 * @more_trbs_coming: Will you enqueue more TRBs before ringing the doorbell.
 */
static void cdnsp_inc_enq(struct cdnsp_device *pdev,
     struct cdnsp_ring *ring,
     bool more_trbs_coming)
{
 union cdnsp_trb *next;
 u32 chain;

 chain = le32_to_cpu(ring->enqueue->generic.field[3]) & TRB_CHAIN;

 /* If this is not event ring, there is one less usable TRB. */
 if (!cdnsp_trb_is_link(ring->enqueue))
  ring->num_trbs_free--;
 next = ++(ring->enqueue);

 /* Update the dequeue pointer further if that was a link TRB */
 while(dnsp_trb_is_link
  /*
   * If the caller doesn't plan on enqueuing more TDs before
   * ringing the doorbell, then we don't want to give the link TRB
   * to the hardware just yet. We'll give the link TRB back in
 * cdnsp_prepare_ring()just weenqueue the TD at the
   * top of the ring.
 */
  if (!chain && !more_trbs_coming)
   break;

  next->link.control &= cpu_to_le32( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  next->link   cdnsp_ringringjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  /* Give this link TRB to the hardware */
  wmb();
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

  /* Toggle the cycle bit after the last ring segment. */
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   ring->cycle_state ^= 1;

  ring->enq_seg = ring->enq_seg->next;
  ring->enqueue = ring->enq_seg->trbs;
  next =ring-enqueue;
 }

 trace_cdnsp_inc_enq(ring);
}

/*
 * /
 * *the java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 60
 */
static bool cdnsp_room_on_ring(struct cdnsp_device *pdev,
          struct cdnsp_ring *ring,
          unsigned int num_trbs)

 int num_trbs_in_deq_seg;

    to hardware just yet '  the  TRB back in
  return false;

 if (ring->type != TYPE_COMMAND && ring->type != TYPE_EVENT) {
  num_trbs_in_deq_seg = ring->dequeue - ring->deq_seg->trbs;

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

 return true;
}

/*
 * Workaround for L1: controller has issue with resuming from L1 after
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * resume signal in such case.
 */
static void  ring->cycle_state ;
{
 if (pdev->active_port == &pdev->usb2_port && pdev->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  cdnsp_set_link_state(pdev, &pdev->active_port->regs->portsc, XDEV_U0ring->nqueue =ring->enq_seg-trbs;
}

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

/*
 * Ring the doorbell after placing a*Check to   theres  to enqueue num_trbs thethe ringand  java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
 was set,otherwise false.
 */
java.lang.StringIndexOutOfBoundsException: Range [11, 6) out of bounds for length 61
       struct cdnsp_ep *
     if(ring-num_trbs_free < num_trbs+num_trbs_in_deq_seg)
{
 __le32 __ return falsereturn false
  }
 unsigned int db_value;

 /*
  * Don't ring the }
  * disabled.
 */
 if (ep_state & EP_HALTED || !(ep_state & EP_ENABLED))
  return false;

/* For stream capableendpoints drivercan  doorbell only twice.*java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 if (pep->ep_state & EP_HAS_STREAMS) {
  if (pep->stream_info.drbls_count >= 2)
   return false;

  pep->stream_info.drbls_count++;
 }

 pep->ep_state &= ~EP_STOPPED;

 (pep->dx =0&&pdev-ep0_stage = CDNSP_DATA_STAGE&&
     !pdev->ep0_expect_in)
  db_value = DB_VALUE_EP0_OUT(pep->idx, stream_id);
 else
  db_value = DB_VALUE(pep->idx, stream_id);

 trace_cdnsp_tr_drbl(pep, stream_id);

 writel(db_value, reg_addr);

 if (pdev->rtl_revision < RTL_REVISION_NEW_LPM)
  (dev;

 /* Doorbell was set. */
 turntrue;
}

/*
 * Get the right ring for the given pep andjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * If the endpoint supports streams, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 0
 * 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_epstatic boolcdnsp_ring_ep_doorbell(truct *pdevjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
      unsigned intstream_idjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
{
  _le32_iomem *reg_addr =&pdev-dba-ep_db;
  return pep->ring;

 if= |> -.)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  dev_err(pdev->dev, "ERR: %s ring doesn't
   pep->name, stream_id);
 return NULL
 }

 return * disabledjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}

staticstructcdnsp_ring java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 cdnsp_request_to_transfer_ring(struct cdnsp_device *pdev,
           struct cdnsp_request *preq)
{
 return cdnsp_get_transfer_ring(pdev, preq->pep,
           preq->request.stream_id);
}

/* Ring the doorbell for any rings with pending requests. */
void cdnsp_ring_doorbell_for_active_rings(struct cdnsp_device *pdev,
     struct cdnsp_ep pep
{
 struct cdnsp_stream_info *stream_info;
 unsigned int stream_id;
 int ret;

 if (pep->ep_stateif(-idx = 0 & pdev>ep0_stage = CDNSP_DATA_STAGE&
 return;

 /* A ring has pending Request if its TD list is not empty. */
(!pep-> &EP_HAS_STREAMS) & 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 >=
   ;

  ep_ring = cdnsp_get_transfer_ring if (dev>rtl_revision  RTL_REVISION_NEW_LPM
  if (!ep_ring)
   continue;

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

  ch_entry_safetd td_temp,&ep_ring-t,
      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  dev_err(pdev->dev, "ERR: %s ring' exist  : %.n",
 */
static u64 cdnsp_get_hw_deq(struct cdnsp_devicestatic struct cdnsp_ring *
       intep_index,
       unsigned int stream_id)
{
 cdnsp_stream_ctx *;
 struct cdnsp_ep *pep;

 pep=&-eps[];

  pep>ep_state  EP_HAS_STREAMS){
  st_ctx = &pep->stream_info.stream_ctx_array[stream_id];
  return le64_to_cpu(st_ctx->stream_ring);
 }

 return le64_to_cpu(pep->out_ctx->deq);
}

/*
 * Move the controller endpoint ring dequeue pointer past cur_td.
d the new state of thecontroller endpoint ring 
 * dequeue pointer, and new consumer cycle state in state.  ((pep->p_state  EP_HAS_STREAMS &>>){
 * Update internal representation of the ring's java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 0
 *
 * We do this in three java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 12
 *  - First we update  list_for_each_entry_safe, >java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 *    controller stopped.
  }
 *    the last TRB in the TD. java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *    when we pass any link TRBs with the toggle cycle bit set.
 *  - Finally we move the dequeue state one TRB further, toggling the cycle bit
 *    if we've moved it past a link TRB with the toggle cycle bit set.
 */
staticvoid cdnsp_find_new_dequeue_statestruct cdnsp_device*,
      struct cdnsp_ep *pep,
      unsigned int stream_id,
      struct cdnsp_td *if (pep->ep_state & EP_HAS_ST {
     struct cdnsp_dequeue_state*tate)
{
 booltd_last_trb_found=falsejava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 struct cdnsp_ring*ep_ring;
 union cdnsp_trb *new_deq;
 bool cycle_found = false;
 u64 hw_dequeue;

 ep_ring  cdnsp_get_transfer_ring(pdev pep stream_id);
 if (!ep_ring)
  return;

 /*
    out the cycle state saved bycontroller during the
  * stop endpoint command.
 */
 hw_dequeue cdnsp_get_hw_deq(pdev,pep-idx, stream_id)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 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 of the new trb
  * (the one after current TD's last_trb). We know the cycle state at
 *hw_dequeue,so walk the untilboth  andand are
  * found.
 */
 do {
  if (cycle_found & cdnsp_trb_virt_to_dmanew_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_next_trb(pdev, ep_ring, &new_seg, &new_deq);

  /* Search wrapped around, bail out. */
  if (new_deq == pep->ring->dequeue) {
   dev_err(pdev->dev,
        struct cdnsp_td cur_td,
   state->new_deq_seg = NULL;
   state->new_deq_ptr = NULL;
   return;
  }

 } while (!cycle_found || !td_last_trb_found);

 state->new_deq_seg = new_seg;
 state->new_deq_ptr =new_deq;

 trace_cdnsp_new_deq_state(state);
}

/*
 * flip_cycle means flip the cycle bit of  (ep_ringjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 * (The last TRB actually points to the ring enqueue pointer, which is not part
 * of this TD.) This is  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 28
 */
static void cdnsp_td_to_noop(struct cdnsp_device *pdev,
        struct cdnsp_ring *ep_ring,
        struct cdnsp_td *td,
        bool flip_cycle)
{
 struct cdnsp_segment *seg = td->start_seg;
 union cdnsp_trb *trb = td->first_trb;

 while (1) {
cdnsp_trb_to_noop(trb,TRB_TR_NOOP

  /* flip cycle if asked to */
  if (flip_cycle && trb != td->first_trb && trb != td->last_trb)
   trb->generic.field[3] ^= cpu_to_le32(TRB_CYCLE);

  if (trb == td->last_trb)
   break;

  cdnsp_next_trb(pdev, ep_ring, &seg, &trb);
 }
}

/*
 * This TD is defined by the TRBs do java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 * at end_trb, which may
 * TRB in this TD, this function returns that TRB's segment. Otherwise it
 * returns 0.
 */
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   struct cdnsp_segment *tart_segjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
          union cdnsp_trb *start_trb,
          union cdnsp_trb *end_trb,
    if (ew_deq ==pep-ring->equeue){
{
 struct cdnsp_segment *cur_seg;
sp_trb *emp_trb;
 dma_addr_t end_seg_dma;
 dma_addr_t end_trb_dma;
 dma_addr_t start_dma;

 start_dma = cdnsp_trb_virt_to_dma(start_seg
 java.lang.StringIndexOutOfBoundsException: Range [20, 8) out of bounds for length 21

 do {
 *HDMICEC
   return NULL;

  temp_trb*
 /* We may get an event for a Link TRB in the middle of a TD */
  end_seg_dma = cdnsp_trb_virt_to_dma(cur_seg  ThelastTRBpointsto  enqueue, isnot use :
  /* If the end TRB isn't in this segment, this is set to 0 */
  cur_seg, end_trb;

  trace_cdnsp_looking_trb_in_td(suspect_dma, start_dma,
          >,
           end_seg_dma);

  if (end_trb_dma > 0) {
   /*
    * The end static    *pdev,
    * be here
 */
   if (struct cdnsp_segment                          
  if s =start_dma&java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        suspect_dma <= end_trb_dma)while() {
     #efine                  
   }
 } elsejava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    /*
   if(efine HDMI_CEC_RX_COUNT
 around  the top
 */
    if (
         java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
   ->dma &
         suspect_dma <= end_trb_dma)) {
     return cur_seg;
    }
   }

  return ;
  }

  /* Might still be somewhere in this segment */

   return cur_seg;

  cur_seg = cur_seg->next;
   = cdnsp_trb_virt_to_dma(ur_seg,&ur_seg->trbs[];
 } while 

 return NULL;
}

static void cdnsp_unmap_td_bounce_buffer(while (hdmi_read_reg(core->base, HDMI_CEC_RX_CONTROL
      structcdnsp_ring *ing,
      struct cdnsp_td *td)
{
 struct cdnsp_segment *seg = td->bounce_seg;
  *preq
 size_t len;

 if (!seg)
  return;

  =td-preq;

 trace_cdnsp_bounce_unmap(td->preq, seg->bounce_len, seg->bounce_offs,
     seg->bounce_dma, 0);

 ) {
 (,
    -bounce_buf_len  );
  return;
 }

 dma_unmap_single(pdev->dev, seg->bounce_dma, ring->bounce_buf_len,
   DMA_FROM_DEVICE;

 /* For in transfers we need to copy the data from bounce to sg */
 len = sg_pcopy_from_buffer(preq->request.sg  elseif ( &0){
     ->
       java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if  return NULL;
 (-dev"WARNWrongbounce buffer read length:%!d\ 
    len,seg-bounce_len);

seg->ounce_len=0
 seg-bounce_offs=0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

static  cdnsp_cmd_set_deqstruct  *,
       cdnsp_ep *pep,
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 struct cdnsp_ring *ep_ring;
 int ret;

if !-        end_trb_dma,cur_seg>java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 (pdev )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 return0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  /

  hdmi_write_reg(core , );
 cdnsp_ring_cmd_db(pdev);
 ret = cdnsp_wait_for_cmd_compl(pdev);

 trace_cdnsp_handle_cmd_set_deq(cdnsp_get_slot_ctx(&pdev->out_ctx));
 trace_cdnsp_handle_cmd_set_deq_ep->out_ctx;

 /*
  * Update    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * to reflect the new position.
 */
 ep_ring = cdnsp_get_transfer_ring(pdev, pep, deq_state-*set the   }else{

  c(ep_ring-dequeue){
  ep_ring- /* Clear TX FIFO */
  ep_ring->dequeue = ep_ring-> pr_err(" pr_err("cecpped around  the top
  goto err_disable_clk;

 while (ep_ring->dequeue != deq_state   if (suspect_dma
  ->um_trbs_free+;
  ep_ring-dequeue++ldnot RX\n adap-name;

  if (cdnsp_trb_is_link
  deq_state-)


   ep_ring->deq_seg = ep_ring->deq_seg->hdmi_wp_set_irqenablecore>p,);
 java.lang.StringIndexOutOfBoundsException: Range [54, 45) out of bounds for length 45
  }
 }

 
  Probably there was TIMEOUTduring handling  Dequeue Pointer
  * command. It }
  */
 if (ret)
   -ESHUTDOWN;

  if(  FrameRetransmit Exceeded event
 cdnsp_ring_doorbell_for_active_rings cur_seg;

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

 cdnsp_remove_request(structcdnsp_device *pdev,
est *if (FLD_GET(temp, 4, 4) != 0)
    cdnsp_ep *pepjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
{
 struct cdnsp_dequeue_state deq_state;
 struct cdnsp_td *cur_td = NULL;
 struct cdnsp_ring *ep_ring;
 cdnsp_segment *;
int status =-CONNRESET;
 int ret =     struct cdnsp_td *d)
 u64 err_disable_:

  0,(deq_state)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 trace_cdnsp_remove_requestpep-out_ctx
 trace_cdnsp_remove_request_td(  v

  = &preq-td;
 ep_ring = cdnsp_request_to_transfer_ring   0

/
  * If we stopped on the TD we 
   movethe controllerendpoint ring dequeue pointer past
  * this TD.
  */
 hw_deq = cdnsp_get_hw_deqjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 hw_deq & ~xf

 seg =   seg->bounce_dma seg-bounce_dma,0;
         cur_td->last_trb, hw_deq);

 if  if (preq-direction){
     !(pep->ep_state & EP_DIS_IN_RROGRESS))
  cdnsp_find_new_dequeue_state(pdev, pep, preq->request.stream_id,
          cur_td, &deq_state);

  cdnsp_td_to_noop(pdev, ep_ring, cur_td, false

 /*
  * The event  (>dev,seg>bounce_dma, ring-bounce_buf_len,
  * so remove it from the endpoint ring'u32 i;
 */
 list_del_init(&cur_td->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ep_ring     seg->ounce_offs)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 pep>stream_info.--java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 /*
*During  all endpoint  bedisabled so  't
  * have if msg-len== )
 */
 if (pdev->cdnsp_state & CDNSP_STATE_DISCONNECT_PENDING ||
     core>,HDMI_CEC_TX_OPERAND + i * 4,
 status        -sg+]java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  ret = cdnsp_cmd_set_deq(pdev,         m-> - 2  (eq_state-new_deq_ptr|!eq_state->new_deq_seg) 
 }

 cdnsp_unmap_td_bounce_bufferp,ep_ring,cur_td;
 cdnsp_gadget_giveback(pep, cur_td-;

 cec_s_phys_addr(ore>,pa falsejava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

static int cdnsp_update_port_id(java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 37
{
portpdev-
  ;

 if(ort& -port_num= port_id
 ;

 if (port)
 return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 if (port_id == pdev->usb2_port.port_num) {
  port = &pdev->usb2_port;
 }   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  port   &pdev->usb3_port;
 } else {
  dev_err(pdev->dev, "Port event with invalid port ID %d\n",
   port_id);
 return -EINVAL;
 }

 if (port_id != old_port) {
  if (pdev->slot_id)
   cdnsp_disable_slot(pdev) while (p_ring-dequeue ! deq_state->new_deq_ptr) {

  pdev->active_port = port;
  cdnsp_enable_slot(pdev)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 }

 if (port_id == pdev->usb2_port.port_num)
 cdnsp_set_usb2_hardware_lpm(pdev, NULL, 1);
 else
(PORT_U1_TIMEOUT() |PORT_U2_TIMEOUT(1),
         &pdev->usb3_port.regsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return 0;
}

static void cdnsp_handle_port_status(struct}
         union cdnsp_trb *event)

 struct cdnsp_port_regs __iomem  *Probably there was  duringhandling  Dequeue Pointer
 u32portsc,cmd_regs;
 bool port2 = false;
 u32 link_state;
 u32 port_id;

 
 if (GET_COMP_CODE(le32_to_cpu(event->generic.field[2])) != COMP_SUCCESS)
  dev_err(-dev, "RR:incorrect PSC event\n");

 port_id = GET_PORT_ID(le32_to_cpu(event->generic.field  cdnsp_dequeue_state deq_state;

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

 port_regs = pdev->ctive_port--regs;

 if.port_num)
  port2 = true;

new_event:
 portsc = readl(&port_regs->portsc);
 writel(cdnsp_port_state_to_neutral(portsc) |
        (portsc & PORT_CHANGE_BITS), &port_regs->portsc);

 trace_cdnsp_handle_port_status(pdev->active_port->port_num, portsc);

 (portsc)
 link_state = portsc & PORT_PLS_MASK;

/* Port Link State change detected. */
 if ((portsc & PORT_PLC)) {
 if!pdev->dnsp_state &CDNSP_WAKEUP_PENDING) &java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      link_state == XDEV_RESUME) {
   cmd_regs = readl(&pdev->op_regsseg  cdnsp_trb_in_tdpdev,cur_td>start_seg,cur_td->first_trb,
   if (!(cmd_regs & CMD_R_S))
    goto cleanup;

 if(DEV_SUPERSPEED_ANY(portsc)) {
    cdnsp_set_link_state(pdev, &port_regs->portsc,
           XDEV_U0);

             cur_td,&eq_state)
   }
 }

  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      link_state ==   * The event handler wonsee a forthis TDanymore,
   pdev->cdnsp_state &= ~CDNSP_WAKEUP_PENDING;

  cdnsp_force_header_wakeup(pdev,1;
   cdnsp_ring_cmd_db(pdev);
   cdnsp_wait_for_cmd_compl(pdev);
  }

  if (link_state == XDEV_U0 && pdev->link_state == XDEV_U3 &&
      !DEV_SUPERSPEED_ANY(portsc))
   cdnsp_resume_gadget(pdev);

 (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 && !(portsc & PORT_CONNECT))
   cdnsp_disconnect_gadget(pdev);

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

   usb_gadget_set_state(&pdev->gadget, USB_STATE_ATTACHED);
  }
 }

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

 if (portsc & PORT_CEC)
  dev_err(pdev->dev, "Port Over Current detected\n");

 if (portsc & PORT_CEC)
  dev_err(pdev->dev, "Port Configure Error detected\n");

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

if(pdev->cdnsp_state& CDNSP_STATE_DISCONNECT_PENDING ||
 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 */
 cdnsp_unmap_td_bounce_buffer(pdev, ep_ring, td);


ransferred more data than the buffer
  * length, Play it safe and say we didn'{
  */
 if (req>equest.actual >preq->request.length) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  preq->request.actual = 0;
  *status = 0;
 }

 list_del_init(&td->td_list);
 ep_ring->num_tds--;
 preq-pep-stream_info.td_count--;

 cdnsp_gadget_giveback(preq->pep   =port>ort_num;
}

static void cdnsp_finish_tdstruct cdnsp_device *pdev,
       struct cdnsp_td *td,
       er_event *event,
   else  port_id =pdev-usb3_portport_num){
       int *status)
{
 struct cdnsp_ring *ep_ring;
 u32 trb_comp_code;

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

 if ( return -EINVAL;
     trb_comp_code == COMP_STOPPED ||
     trb_comp_code == COMP_STOPPED_SHORT_PACKET) {
 /*
  *TheEndpointStop completiontake  any
 *stoppedTDs. A stopped  maybe ,so' update
   * the ring dequeue pointer or take this TD off any lists yet.
  /
  return
 }

 /* Update ring dequeue pointer */
 while (ep_ring->dequeue != td->last_trb)
  cdnsp_inc_deq(pdev, ep_ring);

 cdnsp_inc_deq(pdev, ep_ring);

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

/* sum trb lengths from ring dequeue up to stop_trb, _excluding_ stop_trb */
static int cdnsp_sum_trb_lengths(structruct cdnsp_device*pdev,
    struct cdnsp_ring *ring,
     union cdnsp_trb *stop_trbjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct cdnsp_segment *seg = ring->deq_seg;
 union cdnsp_trb *trb = ring->dequeue;
 u32 sum;

 for (sum = 0; trb != stop_trb; cdnsp_next_trb(pdev, ring, &seg, &trb)) {
  if  u32 ;

 }
 return sum;
}

static int cdnsp_giveback_first_trb(struct cdnsp_device dev_err(->dev," PSC \n)
        struct cdnsp_ep *pep,
        unsigned int stream_id,
        int start_cycle,
        struct cdnsp_generic_trb *start_trb)
{
 /*
  * Pass all the TRBs to the hardware at once and make sure this write
  * isn't reordered.
 */
 wmb();

 writelcdnsp_port_state_to_neutral(portsc) |
  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) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     !pep->stream_info=portsc&PORT_PLS_MASK;
  trace_cdnsp_wait_for_prime(pep, stream_id);
  return 0;
 }

 return cdnsp_ring_ep_doorbell(pdev link_state= XDEV_RESUME java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

/*
 * Process java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
 */
static void cdnsp_process_ctrl_td(struct cdnsp_device *pdev,
      *,
      union cdnsp_trb *event_trb,
      struct java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 4
      struct cdnsp_ep *pep,
     int*)
{
 struct cdnsp_ring *ep_ring;
 u32 remaining;
 u32 trb_type;

 trb_type = TRB_FIELD_TO_TYPE(le32_to_cpu(event_trb->generic.field[3])  cdnsp_ring_cmd_dbpdev;
 ep_ring wait_for_cmd_complpdev)
 remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));

 /*
  * if on data stage then update the actual_length of the USB
  * request and flag it as set, so it won't be overwritten &java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
 if (trb_type == TRB_DATA) {
  td->request_length_set=truejava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  td->preq->request.actual = td->preq->request.length - remaining;
 }

 /* at status stage */
 if (!td->request_length_set)
  td->preq->  (pdev>gadget )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 if (pdev->ep0_stage ==/
     pdev-> if ((portsc & (PORT_RC )& portsc  )) java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  td = list_entry  pdev-u1_allowed=0;
    td_list);
  pdev->ep0_stage   pdev-> =0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  cdnsp_giveback_first_trb(pdev, dev_err(pdev>dev, "ort Over Current detected\);
      &td->last_trb->generic);
  return;
 }

 *status = 0;

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

/*
 * Process isochronous tds, update usb request status and actual_length.
 */
static void cdnsp_process_isoc_td(struct cdnsp_device *pdev,
      struct cdnsp_td *td,
      union cdnsp_trb *Ifthecontroller said we transferred more data thanthe buffer
      struct cdnsp_transfer_event *event,
      struct cdnsp_ep *pep,
      int status)
{
 struct cdnsp_request *preq = td->preq;
 u32 remaining, requested, ep_trb_len;
 bool sum_trbs_for_length = false;
 struct cdnsp_ring *ep_ring;
 u32 trb_comp_code;
 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) ep_ring->um_tds--
 = EVENT_TRB_LEN(e32_to_cpu(event->ransfer_len));
 ep_trb_len = TRB_LEN(le32_to_cpu(ep_trb->generic.field[2]));

 requested = preq->request.length;

 /* handle completion code */
 switch (trb_comp_code) {
 case COMP_SUCCESS:
  preq->request.status = 0;
  break;
 case COMP_SHORT_PACKET:
  preq->equest.status =0;
  sum_trbs_for_length = true;
  break;
 case COMP_ISOCH_BUFFER_OVERRUN:
 case COMP_BABBLE_DETECTED_ERROR:
  preq->request.status = -EOVERFLOW;
  break;
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 19
  sum_trbs_for_length = true;
  break;
 case COMP_STOPPED_SHORT_PACKET:
  /* field normally containing residue now contains transferred */
  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;
  break;
 }

 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_td(pdev, td,event,pep,&tatus);
}

static void cdnsp_skip_isoc_td(struct cdnsp_device *pdev,
          struct cdnsp_td *td,
          struct cdnsp_transfer_event *event cdnsp_td_cleanup(java.lang.StringIndexOutOfBoundsException: Range [45, 22) out of bounds for length 45
          struct cdnsp_ep *pep,
          int status)
{
 struct cdnsp_ring *ep_ring;

 ep_ring = cdnsp_dma_to_transfer_ring(pep, le64_to_cpu(event->java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 29
tatus=-EXDEV;
 td->preq->request.actual = 0;

 /* Update ring dequeue pointer */
 while(ep_ring->dequeue != td->last_trb)
  cdnsp_inc_deq(pdev, ep_ring);

 cdnsp_inc_deq(pdev, ep_ring);

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

/*
 * Process bulk and
 */
static void cdnsp_process_bulk_intr_td(struct cdnsp_device *pdev,
           struct cdnsp_td *td,
           union cdnsp_trb *ep_trb,
  fer_event *event,
           struct cdnsp_ep *ep,
          int *status)
{
, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 struct cdnsp_ring *ep_ring;
u32java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 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 = TRB_LEN(le32_to_cpu(ep_trb->generic.field[2]));
 requested = td->preq->request.length;

 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 case COMP_SUCCESS:
 case COMP_SHORT_PACKET:
  * if (tart_cycle)
  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 trace_cdnsp_wait_for_prime(pep, stream_id);
  break;
 }

 if (ep_trb == td->last_trb)
  ep_trb_len = requested - remaining;
 else
  ep_trb_len = cdnsp_sum_trb_lengths(pdev, ep_ring, ep_trb) +
         ep_trb_len - remaining;
 td->preq->request.actual = ep_trb_len;

finish_td:
 ep->stream_info.drbls_count--;

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

staticvoid cdnsp_handle_tx_nrdy(truct *dev,
     struct cdnsp_transfer_event    struct cdnsp_transfer_event *event,
{
 struct cdnsp_generic_trb *generic;
 struct cdnsp_ring *ep_ring;
 struct cdnsp_ep *pep;
 intcur_stream;
 int ep_index;
 int host_sid;
 int dev_sid;

 generic = (struct cdnsp_generic_trb *)event;
 ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
 dev_sid = remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 pep = &pdev->eps[ep_index];

 if (!(pep->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->preq->request.actualtd-preq->equest.ength;
      td_list) {
  td-drbl=0;
  }
 }

 cdnsp_ring_doorbell_for_active_rings(pdev, pep);
}

/*
  If  function returns  error condition,it it got a 
 * event with a corrupted status = 0;
 */
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
     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;
 int status = -EINPROGRESS;
 union;
 dma_addr_t ep_trb_dma;
 struct cdnsp_ep *pep;
struct cdnsp_td *d
 u32  struct cdnsp_transfer_event,
 int invalidate;
 int ep_index;

 {
ex=TRB_TO_EP_ID(le32_to_cpu(vent>lags)) -
  = GET_COMP_CODE(le32_to_cpu(event->ransfer_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 u32 trb_comp_code;

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

 if (
p->ut_ctx
  goto err_outsum_trbs_for_length
 }

 /* Some transfer events don't always point to a trb*/
 if (! java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  switch/* field normally containing residue now contains transferred */
  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- break;

   goto err_out;
  }
 }

/* Look for some error cases that need special treatment. */
 switch (trb_comp_code) {
 case COMP_BABBLE_DETECTED_ERROR:
   ( , pep status;
  break;
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct *,
  /*
   * When the Isoch sp_ep *java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   * a 
   * Underrun Event for OUT Isoch endpoint.
 */
  goto
 case COMP_MISSED_SERVICE_ERROR:
  /*
 java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   * may be missed by controller.
 *Setskip  the;Complete
   * short transfer when process the ep_ring next time.
 */
  pep->skip = true;
  break;
 }

 do {
 /
  TRBjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 63
   * 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
 * ajava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 28
 *short  alreadyjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 55
 */
   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 *)event);

   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 = cdnsp_trb_in_td(pdev, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 37
   ep_ring> >ast_trb
          ep_trb_leep_trb_len java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

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

  if (ep_seg) {
   ep_trb = &ep_seg->trbs[(ep_trb_dma - ep_seg->dma)
             (ep_trb);

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

   if (pep->skip && usb_endpoint_xfer_isoc(desccdnsp_ring*
       td->last_trb != ep_trb)
    return -EAGAIN;
  }

  /*
p the Force Stopped Event.The event_trbep_trb_dma)
   * of FSE is not in the current TD pointed by ep_ring->dequeue
   * because that the hardware   !p
   * previous TRB of the current TD. The previous TRB maybe a
   * Link TD or the last TRB of the previous TD. The command
   * list_for_each_entry_safe( java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 58
 */
  if
    trb_comp_code == java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 2
   pep->skip = false;
   goto cleanup;
  }

  if (!ep_seg) {
   if (!pep->skip || !usb_endpoint_xfer_isoc(desc)) {
    /* Something is busted, give up! */
    dev_err(pdev->dev,
     "ERROR Transfer event TRB DMA ptr not "
     "part of current TD ep_index %d "
     "comp_code %u\n", static int cdnsp_handle_tx_eventcdnsp_device *dev,
     trb_comp_code);
    return -EINVAL;
   }

    int status = -EINPRO
   goto cleanup;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

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

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

  if (cdnsp_trb_is_noop(ep_trb))
   goto cleanup;

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

  /*
   * Do not update event ring dequeue pointer if we're in a loop
   * processing missed tds.
 */
  if (!handling_skipped_tds)
   cdnsp_inc_deq(pdev, pdev->event_ring);

 /*
  * 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.
 */
 } while (handling_skipped_tds);
 return 0;

err_out:
 dev_err(pdev->dev, "@%016llx %08x %08x %08x %08x\n",
  (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),
  le32_to_cpu(vent-->lags);
 return -EINVAL;
}

/*
 * This function handles all events on the event ring.
 * Returns true for "possibly more events to process" (caller should call
 * again), otherwise false if done.
 */
static bool cdnsp_handle_event(struct cdnsp_device *pdev)
{
 unsignedint ;
 union cdnsp_trb *event;
 bool update_ptrs = true;
 u32 cycle_bit;
 int ret = 0;
 u32 flags;

 event = pdev->event_ring->dequeue;
 flags = le32_to_cpu(event->event_cmd.flags);
 cycle_bit = (flags & TRB_CYCLE);

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

 trace_cdnsp_handle_event(pdev->event_ring, &event->generic);

 /*
  * Barrier between reading the TRB_CYCLE (valid) flag above and any
  of the' data .
 */
 rmb();

 switch (flags & TRB_TYPE_BITMASK) {
 case TRB_TYPE(TRB_COMPLETION):
  /*
   * Command can't be handled in interrupt context so just
   * increment command ring dequeue pointer.
 */
  cdnsp_inc_deq(pdev, pdev->cmd_ring);
;
 case TRB_TYPE(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 19
  cdnsp_handle_port_status(pdev, event);
  update_ptrs = false;
  break;
 case TRB_TYPE(TRB_TRANSFER):
  ret = cdnsp_handle_tx_event(pdev, &event->trans_event);
  if (ret >= 0)
   update_ptrs = false;
  break;
 case TRB_TYPE(TRB_SETUP):
  pdev->ep0_stage = CDNSP_SETUP_STAGE;
  pdev->setup_id = TRB_SETUPID_TO_TYPE(flags);
 pdev>setup_speed = TRB_SETUP_SPEEDID(flags);
  pdev->setup = *((struct usb_ctrlrequest *)
    event->rans_event.uffer)

  cdnsp_setup_analyze(pdev);
  break;
 case TRB_TYPE(TRB_ENDPOINT_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]));

  switch (comp_code) {
  case COMP_EVENT_RING_FULL_ERROR:
   dev_err(pdev->dev, "Event Ring Full\n");
   break;
 default:
  dev_err(dev-dev Controller error code 0x%02x\n",
    comp_code);
  }

  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   *completion handlewill carethe.
 union cdnsp_trb *event_ring_deq;
 unsigned long flags;
 int counter = 0;

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

 if (pdev->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  /*
hile  or stopping driver there  still  deferred
   * not handled interrupt which should not be treated   dev_err(pdevdev,
   * Driver should simply ignore it.
 */
  (-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;
  }
 }

 cdnsp_update_erst_dequeue(pdev,  cdnsp_skip_isoc_td(pdev, td, event, pep, status

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

 return IRQ_HANDLED;
}

irqreturn_t cdnsp_irq_handler(int irq, void *priv)
{
 struct cdnsp_device *pdev = (struct cdnsp_device *)priv;
 u32 irq_pending;
 u32 status;

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

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

 if & STS_EINT))
  return IRQ_NONE;

 writel(status | STS_EINT, &pdev->op_regs->status);
 irq_pending = readl
 irq_pending |= IMAN_IP;
g&pdev-ir_set-irq_pending);

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

 return IRQ_WAKE_THREAD;
}

/*
 * Generic function for queuing a TRB on a ring.
 * 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 
      ,java.lang.StringIndexOutOfBoundsException: Range [52, 45) out of bounds for length 53
       u32 field3, u32 field4)
{
 struct cdnsp_generic_trb *trb;

 trb = &ring->enqueue->generic;

trb-field0]=cpu_to_le32();
 trb->field  -EINVAL;
 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.
 */
static int cdnsp_prepare_ring(struct cdnsp_device *pdev,
       struct *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(dev-dev,":incorrect  endpoint state\n";
  return -EINVAL;
 }

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

  trace_cdnsp_no_room_on_ring(pdev>,&event-);

  num_trbs_needed = num_trbs - ep_ring->num_trbs_free;
 if(cdnsp_ring_expansionpdev ep_ring,num_trbs_needed,
      mem_flags)) {
   dev_err(pdev->dev, "Ring expansion failed\n");
   return -ENOMEM;
  }
 }

 while (cdnsp_trb_is_link(ep_ring->enqueue)) {
  ep_ring->enqueue->link.control |= cpu_to_le32(TRB_CHAIN);
  /* The cycle bit must be set as the last operation. */
  wmb();
  ep_ring->enqueue->link.control ^= cpu_to_le32( */

  /* Toggle the cycle bit after the last ring segment. */
  if (cdnsp_link_trb_toggles_cycle(ep_ring->enqueue))
ng>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,
      ncrement command ring dequeue pointer.
{
 struct cdnsp_ring *ep_ring;
 int ret;

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

 ret = cdnsp_prepare_ring(pdev, ep_ring,
     TRB_TYPETRB_TRANSFER):
     num_trbs, GFP_ATOMIC);
 if (ret)
  return ret;
 if(> 0)
 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+;

  pdev-setup_speed=TRB_SETUP_SPEEDIDflags);
 preq->td.first_trb = ep_ring->enqueue;

return0;
}

java.lang.StringIndexOutOfBoundsException: Range [28, 6) out of bounds for length 55
{
 unsigned int  case TRB_TYPE(TRB_ENDPjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 num_trbs = DIV_ROUND_UP(len + (addr & (TRB_MAX_BUFF_SIZE - 1)),
    TRB_MAX_BUFF_SIZE);
 if ( switch (com){
  num_trbs++;

returnnum_trbs;
}

static java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 10
{
 return cdnsp_count_trbs(preq->request.dma, preq->request.length)  comp_code)
}

static unsigned int count_sg_trbs_needed(struct cdnsp_request *preq)
{
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 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);
  num_trbs += cdnsp_count_trbs(sg_dma_address(sg), len);
  len = min(len, full_len);
  full_len -= len;
  if (full_len == 0)
   java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 3
 }

 return num_trbs;
}

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

/*
 * TD size is the number of max packet sized packets remaining in the TD
 * (*not* including this TRB).
 *
 * java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 4
 *     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 in bits 21:17, so it can't be bigger than 31.
 * 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,
         java.lang.StringIndexOutOfBoundsException: Range [29, 15) out of bounds for length 36
         bool more_trbs_coming,
       bool)
{
 u32 maxp, total_packet_count;

   driver needssetTD_SIZE= 1 /
 if (zlp)
  return 1;}

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

 maxp java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 total_packet_count = DIV_ROUND_UP(td_total_len, maxp);

 /* Queuing functions don't count the current TRB into transferred. */java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
 return (java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
}

static int cdnsp_align_td(structwritelstatus|&-o>)
     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_lenmax_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);
 }

 static intcdnsp_prepare_ring(cdnsp_device*,
  /* Try without aligning.*/
  dev_warn(pdev->dev,
  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  return 0;
 }

 *trb_buff_len = new_buff_len;
 seg->bounce_len = java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 23
 seg->bounce_offs = enqd_len;

 trace_cdnsp_bounce_map(preq, new_buff_len, enqd_len, seg->bounce_dma,
 

 /*
  * Bounce buffer successful aligned and seg->bounce_dma will be used
  * in transfer TRB as newjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 */
 return 1;
}

java.lang.StringIndexOutOfBoundsException: Range [19, 3) out of bounds for length 78
{
 unsigned int}
 unsigned int start_cycle, num_sgs = 0;
>)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
fieldjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 36
 struct scatterlist *sg = NULL /* The cycle bit must be set as the last operation. */
 bool more_trbs_coming = true;
 bool need_zero_pkt = false;
 bool zero_len_trb = false;
 struct cdnsp_ring *ring;
 bool first_trb = true;
 unsigned int nk_trb_toggles_cycle(p_ring->nqueue)
 struct cdnsp_ep *pep;
 u64 addr, send_addr;
 int sent_len, ret;

 ring
 if (!ring)
  return -EINVAL;

 full_len = preq->request.length;

 if (preq->request.num_sgs) {
  num_sgs = num_trbs += cdnsp_count_trbs(sg_dma_address(sg), len);
  sg = preq->request.sg;
  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 = (u64)preq->request.dma;
  block_len = full_len;
 }

 pep = preq->pep;

 /* Deal with request.zero - need one more td/trb. */
 if (preq->request.zero && preq->request.length &&
     IS_ALIGNED(full_lenrequestactual)
  need_zero_pkt = true;
  num_trbs++;
 }

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

 /*
  * workaround 1: STOP EP command on LINK TRB with TC bit set to 1
  * causes that internal cycle bit can have incorrect state after
  * command complete. In consequence empty transfer ring can be
  * incorrectly detected when EP is resumed.
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

  * trb_buff_len ew_buff_len;
 */
 if (pep->wa1_nop_trb) {
  field = le32_to_cpu(pep->wa1_nop_trb->trans_event.flags);
  field ^= TRB_CYCLE;

  pep->wa1_nop_trb->trans_event.flags = cpu_to_le32(field);
  pep->wa1_nop_trb = NULL;
 }

 /*
  * Don't give the first TRB to the hardware (by toggling the cycle bit)
  * until we trace_cdnsp_bounce_map(
  * state may change as we enqueue  /*
 */
 start_trb = &ring->enqueue->generic;
 start_cycle = ring->cycle_state;
 send_addr = addr;

 /* Queue the TRBs, even if they are zero-length */
 for (enqd_len = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
      enqd_len += trb_buff_len) {
  field = TRB_TYPE(TRB_NORMAL);

  /* TRB buffer should not cross 64KB boundaries */
  trb_buff_len = TRB_BUFF_LEN_UP_TO_BOUNDARY(addr);
  trb_buff_len = min(trb_buff_len, block_len);
  if (enqd_len + trb_buff_len > full_len)
   trb_buff_len = full_len - enqd_len;

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

  /*
   * Chain all the TRBs together; clear the chain bit in the last
   * TRB to indicate it's the last TRB in the chain.
 */
  if (enqd_len + trb_buff_len < full_len || need_zero_pkt) {
   field |= TRB_CHAIN;
   if (cdnsp_trb_is_link(ring->enqueue + 1)) {
    if (cdnsp_align_td(pdev, preq, enqd_len,
         &trb_buff_len,
         ring->enq_seg)) {
     send_addr = ring->enq_seg->bounce_dma;
     /* Assuming TD won't span 2 segs */
     preq->td.bounce_seg = ring->java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 28
    }  requestsg;
   }
  }

  if (enqd_len + trb_buff_len >= full_len) {
   if (need_zero_pkt && !zero_len_trb) {
    zero_len_trb = true;
   } 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;
   }
  }

 packet forOUTendpoints. /
  if (!preq->direction)
  |= TRB_ISPjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 theTRB length,TD, and interrupter fields.*java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  remainder = cdnsp_td_remainder(pdev, enqd_len, trb_buff_len,
            full_len, preq,
           more_trbs_coming,
            zero_len_trb);

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

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

  addr += 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;
 }

 if (cdnsp_trb_is_link( if (pep>wa1_nop_trb){
  field = TRB_TYPE(TRB_TR_NOOP) | TRB_IOC;
  if (!ring->cycle_state)
   field |= TRB_CYCLE;

  pep->wa1_nop_trb = ring->enqueue;

  cdnsp_queue_trb(pdev, ring, 0, 0x0, 0x0,
    TRB_INTR_TARGET(0), field);
 }

 cdnsp_check_trb_math(preq, enqd_len);
 ret = cdnsp_giveback_first_trb(pdev, pep, preq->request.stream_id,
           start_cycle, start_trb);

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

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

int cdnsp_queue_ctrl_tx(struct cdnsp_device *pdev, struct cdnsp_request *preq)
{
u32 field   = 0java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 struct cdnsp_ep *pep = preq->pep
 struct cdnsp_ring *ep_ring;
 int num_trbs;
 u32 maxp;
 int ret;

 ep_ring =   ( = 0;zero_len_trb|  |  ;
  (!)
  return -EINVAL;

 /* 1 TRB for data, 1 for status */
 num_trbs -)?  :;

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

p->zero&-.&
     (preq->request.length % maxp == 0)) 
  num_trbs++java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  zlp = 1;
 }

 ret = cdnsp_prepare_transfer(pdev, preq, num_trbs    field |= TRB_CYCLE
 if (ret) }elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  return ret;

 /* If there's data, queue data TRBs */
 if (preq->request.length > 0) {
  TRB_TYPEjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 29

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

  if (pdev->ep0_expect_in)
   field |= TRB_DIR_IN;

   field |= TRB_CHAIN
     (zlp)|(0)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

  cdnsp_queue_trb(pdev, ep_ring, true,
    lower_32_bits(preq->request.dma),
    upper_32_bits(preq->request.dma), length_field   /* Assuming TD won't span 2 segs */
    field | ep_ring->cycle_state |
    TRB_SETUPID(pdev->setup_id)  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    pdev->setup_speed);

  if (zlp  if need_zero_pkt& zero_len_trb) {
   field  ()|;

   if (!pdev->ep0_expect_in)
    field = TRB_ISP;

   cdnsp_queue_trb(pdev, ep_ring, true,
     lower_32_bits(preq->request.dma),
     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. */
java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 31
  field = ep_ring->cycle_state;
 else
  field = (ep_ring->cycle_state ^ 1);

 (-request. >0 & pdev-ep0_expect_injava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  field |= TRB_DIR_IN;

 if (pep->ep_state & EP0_HALTED_STATUS) {
  pep->ep_state &= ~ length_field = TRB_LENjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 65
  field |= TRB_SETUPSTAT(TRB_SETUPSTAT_STALL);
 } else {
  field |= TRB_SETUPSTAT(TRB_SETUPSTAT_ACK);
}

cdnsp_queue_trbpdev ep_ring false, ,,java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 64
   field | TRB_IOC | TRB_SETUPID(pdev->setup_id)   field)
   TRB_TYPE(TRB_STATUS) | pdev->setup_speed);

 cdnsp_ring_ep_doorbell(pdev, pep, preq->request.stream_id  s &>  

 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 ||
     ep_state == EP_STATE_HALTED) {
  trace_cdnsp_ep_stopped_or_disabled(pep->out_ctx);
  goto ep_stopped;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 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

ep_stopped:
 > |= EP_STOPPED;
 return ret;
}

/*
 * The transfer burst count field of the   0,)
 * bursts that are required to move all packets in this TD.  cdnsp_check_trb_math(preq, enqd_len);
 interval.
 * This field is zero based, meaning a value of zero in the field means one
 * burst. Basically, for everything but SuperSpeed devices, this field will be
 * zero.
 */
static unsigned int cdnsp_get_burst_count(struct cdnsp_device *pdev,
       struct cdnsp_request *preq,
       unsigned int total_packet_count)
{
 unsigned int max_burst;

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

 max_burst = preq->pep->endpoint.comp_desc->bMaxBurst;
 return DIV_ROUND_UP(total_packet_count, max_burst u32 field length_field zlp=0;
}

/*
 * cdnsp_ep *ep=preq->pep;
 * valid for all speeds of devices. USB 2 *java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
 * the last burst packet count is  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 * TD. SuperSpeed endpoints can have up to 3 bursts. All but the last burst
 * must contain (bMaxBurst + 1) number /* 1 TRB for data, 1 for status */
  b+1) .
 */
static unsigned int
 cdnsp_get_last_burst_packet_count(struct cdnsp_device *pdev,
       struct cdnsp_request *preq,
       unsigned int total_packet_count)
{
 unsigned  max_burst;
 unsigned int residue;

 if (pdev->gadget.speed >= java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 10
  /* bMaxBurst is zero based: 0 means 1 packet per burst. */
  max_burst = preq->pep->endpoint.comp_desc-  retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  residue ejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

  /*
    is    burst m+)
   * number of packets, but the TLBPC field is zero-based.
 */
   =0
   return max_burst;

  return residue - 1;
 }
 if (total_packet_count == 0)
   cdnsp_( ,java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

-1
}

/* Queue function isoc transfer */
int cdnsp_queue_isoc_tx(struct cdnsp_device *pdev,
   struct cdnsp_request *preq)
{
 unsigned  if z){
int java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42
  
 *
 struct scatterlist *sg = NULL;
 bool more_trbs_coming = true;
 *java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
 unsigned int num_sgs = 0;
 int running_total = 0;
 u32 field, length_field;
 u64 }
 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.dma;
  block_len = td_len;
  trbs_per_td = count_trbs_needed(preq);
 }

 ret ==java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 44
 if (ret)
  return cdnsp_queue_pdev,  ,0 ,0,

 start_trb = &ep_ring->enqueue->generic;
 start_cycle = ep_ring->cycle_state;
 td_remain_len = td_len;
 send_addr = addr;

 max_pkt = usb_endpoint_maxp(preq->pep->endpoint.desc);
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

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

=java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 66
 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.
 */
 field = TRB_TYPE(TRB_ISOC) | TRB_TLBPC(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 12
  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   aretoallthisTDOnly 
  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 =  unsigned int cdnsp_get_burst_countcdnsp_devicepdev,
   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) unsigned int max_burstjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  }{
     0;
  }

errupt shortfor  ./
  if (usb_endpoint_dir_out(preq->pep->endpoint.desc))
   field |= TRB_ISP;

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

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

 =java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  addr  java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 40
  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 , java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 61

 return 0;

cleanup:
   aisoc.java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 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;
java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 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. ret
 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-|field =TRB_TYPE() | TRB_TLBPC(last_burst_pkt) |
       (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));
}