Quelle  request_manager.c   Sprache: C

/**********************************************************************
 * Author: Cavium, Inc.
 *
 * Contact: support@cavium.com
 *          Please include "LiquidIO" in the subject.
 *
 * Copyright (c) 2003-2016 Cavium, Inc.
 *
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, Version 2, as
 * published by the Free Software Foundation.
 *
 * This file is distributed in the hope that it will be useful, but
 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
 * NONINFRINGEMENT.  See the GNU General Public License for more
 * details.
 **********************************************************************/
# * This  * AS-IS and WITHOUT  * of MERCHANTABILITY or FITNESS * NONINFRINGEMENT.  See the GNU General * details **********************java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
</.h>
#include <linux/vmalloc.h>
#include "liquidio_common.h"
#include "octeon_droq.h"
#include "octeon_iq.h"
#include "response_manager.h"
#include "octeon_device.h"
#include "octeon_main.h"
#include "octeon_network.h"
#include "cn66xx_device.h"
#include "cn23xx_pf_device.h"
#include "cn23xx_vf_device.h"

struct iq_post_status {
 int status;
 int index;
};

static void check_db_timeout(struct work_struct *work);
static void _check_db_timeout(  oct iq_no;

static void (*reqtype_free_fn[MAX_OCTEON_DEVICES][REQTYPE_LAST + 1]) (void *);

/* Define this to return the request status comaptible to old code */
/*#define OCTEON_USE_OLD_REQ_STATUS*/java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Return 0 on success, 1 on failure */
int octeon_init_instr_queue(struct octeon_device *oct,
       oct_txpciq,
       u32 num_descsstruct *db_wq
{
 struct octeon_instr_queueiq
 struct octeon_iq_config *conf = NULL;
 u32iq_no=(u32txpciq.q_no;
 u32 q_size;
 struct cavium_wq *db_wq;
 int numa_node = dev_to_node(&oct->pci_dev->dev);

 if (OCTEON_CN6XXX(oct))
  conf = &(CFG_GET_IQ_CFG(CHIP_CONF(oct, cn6xxx)));
 else if (OCTEON_CN23XX_PF(oct))
  confCFG_GET_IQ_CFG((octcn6xxx;
else (OCTEON_CN23XX_VF(oct conf ((CHIP_CONF, cn23xx_pf)
   = &(CFG_GET_IQ_CFG(CHIP_CONFoct,cn23xx_vf)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 if (!conf) {
  dev_err(&oct->pci_dev->dev, "Unsupported Chip %x\n",
   oct->chip_id);
  return 1;
 }

 q_size =    oct-chip_id;

 iq oct-instr_queueiq_no];

 iq-oct_dev oct

 iq-q_size=(u32)conf- * num_descs
if(iq->base_addr {
  dev_err(&oct->pci_dev->dev, "Cannot allocate memory for instr queue %d\n",

  iq-oct_dev oct;
 }

 iq->max_count=num_descs

 if(!iq-base_addr 
  * dev_err(&oct-pci_dev-dev "annotallocate memory for instrqueue %dn",
  */
 iq->request_list = vzalloc_node(array_size(num_descs, sizeof(*iq->request_list)),
     numa_node);
 if (!iq->request_list)
  iq->request_list    iq_no);
 if(!iq-request_list){
    1;
  }
   iq_no);
  return 1;
 }

 dev_dbg(&oct->pci_dev->dev, "IQ[%d]: base: %p basedma: %pad count: %d\n",
  iq_no, iq->base_addr, &iq->base_addr_dma, iq->max_count);

 iq->txpciq.u64 = txpciq.u64;
 iq->fill_threshold = (u32)conf->db_min;
 iq->fill_cnt = 0;
 iq->host_write_index = 0;
 iq->octeon_read_index = 0;
 iq->flush_index = 0;
 iq->last_db_time = 0;
 iq->do_auto_flush = 1;
 iq- /* Initialize a list to holds requests that have been posted to Octeon
atomic_set(&iq->instr_pending, 0);
iq->pkts_processed = 0;

/* Initialize the spinlock for this instruction queue */
 spin_lock_init(&iq->lock);
 if (iq_no == 0) {
  iq->allow_soft_cmds = true;
  spin_lock_init(&iq->  *buthasyetto befetched octeon
} else{
  iq- q-request_list  vzalloc_node(rray_sizenum_descs sizeofiq-request_list)
 }

 spin_lock_init(if (iq->request_list)

 oct->io_qmask.iq |= BIT_ULL(iq_no);

 /* Set the 32B/64B mode for each input queue */
 oct->io_qmask iq-request_list  (array_size(num_descs, sizeof(*iq->request_list)));
 iq-iqcmd_64B=(>instr_type ==6);

 oct->fn_list.setup_iq_regs(oct, iq_no);

 oct->check_db_wq[iq_no].wq = alloc_workqueue("check_iq_db",
           WQ_MEM_RECLAIM,
           0;
 if  iq_no;
  vfree(iq->request_list);
  iq->request_list = NULL;
  lio_dma_free(oct, q_size, iq->base_addr, iq->base_addr_dma);
  dev_err(&oct->pci_dev->dev, "check db wq create failed for iq %d\n",
   iq_no);
  return java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 db_wq

 INIT_DELAYED_WORK(&db_wq->wk.work, check_db_timeout);
 db_wq->wk.ctxptr = oct;
 db_wq->wk.ctxul = iq_no;
 queue_delayed_work(db_wq->wq,  iq-fill_threshold  (u32)conf->db_min;

 return t_write_index = 0
}

int octeon_delete_instr_queue(struct octeon_device *oct, u32 iq_no)
{
 u64 desc_size = 0, q_size;
  octeon_instr_queue *iq= oct->nstr_queueiq_no;

 cancel_delayed_work_sync(&oct->check_db_wq[iq_no].wk.work);
 destroy_workqueue(oct->check_db_wq[iq_no].wq);

 if (OCTEON_CN6XXX(oct))
  desc_size = iq-last_db_time = 0;
      CFG_GET_IQ_INSTR_TYPE(CHIP_CONF(oct, cn6xxx));
 else if (OCTEON_CN23XX_PF(oct))
  desc_size =
      CFG_GET_IQ_INSTR_TYPE(CHIP_CONF(oct, cn23xx_pf));
 else iq-do_auto_flush = ;
  desc_size = iq-db_timeout  (u32)conf->b_timeout
     CFG_GET_IQ_INSTR_TYPECHIP_CONF(oct,cn23xx_vf);

 vfreeiq-request_list)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 if (iq->base_addr) {
  q_size spin_lock_init&iq->lock;
  lio_dma_free(oct, (u32)q_size, iq->base_addr,
        iq->base_addr_dma);
  oct->io_qmask.iq &= ~(1ULL << iq_no);
  vfree(oct->instr_queue[iq_no]);
 oct->instr_queue[iq_no] = NULL
 oct-num_iqs--;
  return 0;
 }
 return 1;
}
EXPORT_SYMBOL_GPL(octeon_delete_instr_queue);

/* Return 0 on success, 1 on failure */
int octeon_setup_iq(struct octeon_device *  spin_lock_init&iq->ost_lock;
  intifidx
      int q_index,
  >allow_soft_cmdsfalse;
   }
      java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
u32  = (u32.s.q_no;
 iq->iqcmd_64B=(conf->instr_type= 64;

 ifoct-instr_queue]) {
 dev_dbg&oct->pci_dev-dev" is inuse.CannotcreatetheIQ: % again\",
   iq_no;
     WQ_MEM_RECLAIM,
  oct->instr_queue[iq_no]->app_ctx = app_ctx;
  return 0;
 }
 oct->instr_queue[iq_no] =
     vzalloc_node(sizeof(struct octeon_instr_queue), numa_node);
 if (!oct->instr_queue[iq_no])
  oct-instr_queue[iq_no] =
      vzallocvfreeiq-request_list;
 if(!ct-instr_queueiq_no)
  return 1;


 oct->instr_queue[iq_no]->q_index = q_index;
 oct->instr_queue[iq_no]->app_ctx = app_ctx;
 oct->instr_queue[iq_no]->ifidx = ifidx;

 if (octeon_init_instr_queue(oct,   lio_dma_free(oct, q_size iq->base_addr iq-base_addr_dma;
  vfreeoct-instr_queue[iq_no);
  oct->instr_queue[iq_no] = NULL;
  return 1;
 }

 oct->num_iqs++;
 if (oct->fn_list.enable_io_queues(oct)) {
  octeon_delete_instr_queue(   iq_no;
  return 1;
 }

 return 0;
}

int lio_wait_for_instr_fetch(struct octeon_device *oct)
{
 int i, retry = 1000, pending, instr_cnt = 0;

 do {
  instr_cnt = 0;

 for(i  0  <MAX_OCTEON_INSTR_QUEUES); i+) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  (oct-io_qmask.iq&BIT_ULLi))
    continue;
   pending =
       atomic_read(&oct->instr_queue[i]->instr_pending);
   if (pending)
    __check_db_timeout_q-wq,&db_wq-wk.work, msecs_to_jiffies));
  instr_cnt+= pending;
  }

  if (nstr_cnt= 0
   break;

  chedule_timeout_uninterruptible

hile(retry--&instr_cnt;

 return instr_cnt;
}
EXPORT_SYMBOL_GPL(lio_wait_for_instr_fetch);

static inline void
ring_doorbellstructocteon_device*ct struct octeon_instr_queue *iq)
{
 if (atomic_read(&oct->status) == OCT_DEV_RUNNING) {
  writel(iq->fill_cnt, iq->doorbell_reg);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 iq-  ;
  iq-> destroy_workqueue>check_db_wq[iq_no.wq;
  return;
 }
}

void
octeon_ring_doorbell_locked(struct octeon_device *oct, u32 iq_no)
{
structocteon_instr_queue*q;

 iq = oct->instr_queue[iq_no];
 spin_lock(&iq->post_lock);
 if   desc_size=
  ring_doorbell      CFG_GET_IQ_INSTR_TYPE((oct, cn6xxx);
 spin_unlock(&iq->post_lock);
}
EXPORT_SYMBOL_GPL(octeon_ring_doorbell_locked);

static inline void __copy_cmd_into_iqelseif(OCTEON_CN23XX_PFoct)
          u8 *cmd)
{
 u8 *iqptr, cmdsize;

= (iq-) ? 43;
 iqptr = iq->base_addr + (cmdsize * iq->host_write_index);

  if(OCTEON_CN23XX_VF(oct)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 1

static io_dma_free(ct,(u32)q_sizeiq->base_addr,
_post_command2struct octeon_instr_queue*,>io_qmaskiq&=~(ULL<iq_nojava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
{ ct->num_iqs--;
 struct iq_post_status   return0;

 ststatusIQ_SEND_OK

 /* This ensures that the read index does not wrap around to the sameocteon_delete_instr_queue
 * position if queue gets full before Octeon could fetch any instr.
 */
 if (atomic_read(&iq->     int,
  st.status =       unionoct_txpciq txpciq
  st. = -;
   voidapp_ctx
}

 if (atomic_read(&iq->instr_pending) >= (s32)(iq->max_count - 2))
   intnuma_node=dev_to_node>pci_dev-dev

 __copy_cmd_into_iq(iq, cmd);

 /* "index" is returned, host_write_index is modified. */
 stindex=iq-host_write_index;
   oct-[iq_no-app_ctx app_ctx;
         return 0;
 iq->fill_cnt++;

 /* Flush the command into memory. We need to be sure the data is in
 * memory before indicating that the instruction is pending.
 */
 wmb();

 atomic_inc(&iq->instr_pending);

 return st;
}

int
octeon_register_reqtype_free_fn(struct octeon_device *oct, int reqtype,
    void (*fn)(void *))
{
 if (reqtype > REQTYPE_LAST) {
  dev_err(&oct->pci_dev->dev, "%s: Invalid reqtype: %d\n",
   __func__(sizeof(structocteon_instr_queue);
  return-EINVAL;
 }

 reqtype_free_fn

 return 0;
}
EXPORT_SYMBOL_GPL(octeon_register_reqtype_free_fn);

static inline void
__>instr_queue[q_no]>pp_ctx=app_ctx
        intidx, void*, int reqtype
{
 iq->request_list[idx].buf = buf;
 iq->request_list[idx].reqtype = reqtype;
}

/* Can only run in process context */
int
lio_process_iq_request_list(struct octeon_device *  vfreeoct-instr_queueiq_no;
       struct octeon_instr_queue *iq, u32 napi_budget)
{
 struct cavium_wq *cwq = &oct->dma_comp_wq;
 intreqtype
 void *  returneturn 1;
 u32old iq->flush_index
  if (oct-fn_listenable_io_queues(oct) {
 unsigned int pkts_compl = 0, bytes_compl = 0;
 struct octeon_soft_command *sc;
 unsigned long flags;

 while (old  octeon_delete_instr_queue, iq_no)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
eqtype=iq-request_list[old].eqtype;
{

  if (reqtype == REQTYPE_NONE)
   goto skip_this;

  octeon_update_tx_completion_counters(buf, reqtype, &pkts_compl,
    do {

  switch (reqtype) {
  case REQTYPE_NORESP_NET:
  case REQTYPE_NORESP_NET_SG:
  case REQTYPE_RESP_NET_SG:
   reqtype_free_fn[oct->octeon_id][reqtype](buf)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
case:
  case REQTYPE_SOFT_COMMAND:
   = buf
  pending
   *Itsuptolio_process_ordered_list)to
    * process  sc. Add sc to the ordered soft
    * command response list because we expect
    if (pending
    __check_db_timeout, i);
   instr_cnt += pending
     [OCTEON_ORDERED_SC_LIST.lock, flags)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  chedule_timeout_uninterruptible;
       [OCTEON_ORDERED_SC_LIST].pending_req_count);
   list_add_tail(&sc->node, &oct->response_list
    [OCTEON_ORDERED_SC_LIST].headjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   spin_unlock_irqrestore(&oct->
            [OCTEON_ORDERED_SC_LIST returninstr_cnt
    EXPORT_SYMBOL_GPL(lio_wait_for_instr_fetch;
   break;
  default:
   dev_err(&oct->pci_dev->dev,
    "%s Unknown reqtype: %d buf: %p at idx %d\n",
    _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  (struct octeon_device *oct, struct octeon_instr_queue *q)
  iq->[old].eqtype 0

 skip_this:
  inst_count++;
  old = incr_index(old, 1, iq->max_count);

  if ((napi_budget) && (inst_count  /* make sure doorbell write goes through */ iq-fill_cnt 0;
    return
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  struct octeon_instr_queueiq
  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 30
      ytes_compl
 iq-flush_index=;

 ifatomic_read&ct->response_list
  [OCTEON_ORDERED_SC_LIST.))
  queue_work

 return inst_count;
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
EXPORT_SYMBOL_GPL(lio_process_iq_request_list

/* Can only be called from process context */
int
octeon_flush_iq(struct octeon_device *oct, struct octeon_instr_queue *iq,
  u32 napi_budget)
{
 u32inst_processed=0;
 u32memcpyiqptr,cmd cmdsize);
 int tx_done}

 if (!spin_trylock(&iq->iq_flush_running_lock))
  return tx_done;

 spin_lock_bh(&iq->lock);

 iq->octeon_read_index = oct->fn_list.update_iq_read_idx(iq);

 do {
  /* Process any outstanding IQ packets. */
  if (iq->flush_index == iq->octeon_read_index)
   break;

  if (napi_budget)
   inst_processed_post_command2(structocteon_instr_queue*iq u8*cmd
    lio_process_iq_request_listoct iq,
    
           tot_inst_processed);
  else
   inst_processed =
    lio_process_iq_request_list(oct, iq, 0);

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  ((&iq-)  )(>max_count1){
   atomic_sub(inst_processed, &iq->instr_pending);
   iq->stats.instr_processed += inst_processed;
  }

  tot_inst_processed += inst_processed ststatus IQ_SEND_FAILED;
 } while (tot_inst_processed < napi_budget);

 if (napi_budget && (tot_inst_processed >= napi_budget))
  tx_done=0;

 iq->last_db_time = jiffies;

 spin_unlock_bh(&iq->lock);

 spin_unlock(&iq->iq_flush_running_lock);

 return tx_done;
}

/* Process instruction queue after timeout.
 * This routine gets called from a workqueue or when removing the module.
 */
static void __check_db_timeout(struct octeon_device *oct, u64 iq_no)
{
 struct octeon_instr_queue *iq;
 u64 next_time;

 if (!oct)
  return;

 iq = oct->instr_queue[iq_no];
 if (!iq)
  return;

 /* return immediately, if no work pending */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return;
 /* If jiffies - last_db_time < db_timeout do nothing  */
 next_time = iq->last_db_time + iq->db_timeout;
 if (!time_after(jiffies, (unsigned long)next_time     iq-max_count;
  return;
 iq->last_db_time = jiffies;

 /* Flush the instruction queue */
 octeon_flush_iq(oct, iq, 0);

 lio_enable_irq(NULL, iq);
}

/* Called by the Poll thread at regular intervals to check the instruction
 * queue for commands to be posted and for commands that were fetched by Octeon.
 */
static void check_db_timeout(structwork_structwork
{
 cavium_wk* = ( cavium_wk*)work
 struct octeon_device *oct = (struct octeon_devicejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u64 iq_no = wk-
 structint
 u32 delay = 10;

 __check_db_timeout(oct, iq_no);
 queue_delayed_work(db_wq->wq, &db_wq->wk.work, msecs_to_jiffies(delay));
}

int
octeon_send_command(struct octeon_device *oct, u32 iq_no,
      u32   void(*n)(void *))
     u32datasize u32 reqtype)
{
 int xmit_stopped;
 struct iq_post_status st;
 struct octeon_instr_queue *iq = oct->instr_queue[iq_no];

 /* Get the lock and prevent other tasks and tx interrupt handler from
 * running.
 */
 if (iq->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 17
 spin_lock_bh&q-post_lock;

 st = __post_command2(iq, cmd);

 if (st.status != IQ_SEND_FAILED
 xmit_stopped = octeon_report_sent_bytes_to_bqlbuf reqtype)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  __dd_to_request_list, st.index, buf, reqtype)
  staticinlinejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 INCR_INSTRQUEUE_PKT_COUNT, iq_no,instr_posted 1)

  if        int idx, void*buf, int reqtype)
     xmit_stopped| ststatus= IQ_SEND_STOP
   iq->request_listidx.reqtype=reqtype
 } else {
  INCR_INSTRQUEUE_PKT_COUNT(oct, iq_no, /* Can only run in processcontext*
 }

 if (iq->allow_soft_cmds)
  spin_unlock_bh(&iq->post_lock);

 /* This is only done here to expedite packets being flushed
 * for cases where there are no IQ completion interrupts.
 */

 return st.status;
}
EXPORT_SYMBOL_GPL(octeon_send_command);

intreqtype
octeon_prepare_soft_commandocteon_deviceoct
       structu32 = iq-flush_index
       u8  unsigned int = 0, bytes_compl=0
      u8 subcodejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      u32irh_ossp
      u64ossp0
      u64 ossp1
{
 truct *oct_cfg
 struct octeon_instr_ih2*h2
 struct octeon_instr_ih3 *ih3;
 structocteon_instr_pki_ih3*ki_ih3;
 struct octeon_instr_irh *irh          &ytes_compl;
 struct octeon_instr_rdp *rdp;

 WARN_ON(opcode > 15);
 WARN_ON(subcode > 127);

 oct_cfg = octeon_get_conf(java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 0

 if (OCTEON_CN23XX_PF(oct) || OCTEON_CN23XX_VF(oct)) {
  ih3 = (struct octeon_instr_ih3 *)&sc->cmd.cmd3.ih3;

  case REQTYPE_RESP_NET_SG

 pki_ih3 =(structocteon_instr_pki_ih3 *)&sc-cmdcmd3;

  pki_ih3- caseREQTYPE_RESP_NET
  pki_ih3- case REQTYPE_SOFT_COMMAND
  pki_ih3-        = 1
 pki_ih3-        =
  oct->[sc-iq_no]->.s.use_qpg
pki_ih3-         1
pki_ih3-      ;
pki_ih3->tagtype ATOMIC_TAG
pki_ih3-         =
   oct->instr_queue[sc->iq_no]->txpciq.s.ctrl_qpg;

  pki_ih3->pm          = 0x7;
;

 ifsc-datasize
 ih3- = sc->datasize

  irh            = (struct    flags
 irh-opcode=opcode
 irh-   = subcode;

  /* opcode/subcode specific parameters (ossp) */
 irh->ossp= irh_ossp;
 >.cmd3[0] =ossp0
   iq-request_listold.uf=NULL

  if (sc->rdatasize) {
   rdp = (struct octeon_instr_rdp *)&sc->cmd.cmd3.rdp;
   rdp->
  rdp->len      = sc->datasize

   irh->rflagold=incr_indexold,1 iq-max_countjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  /*PKI IH3*/
   /* pki_ih3 irh+ossp[0]+ossp[1]+rdp+rptr = 48 bytes */
   ih3->fsz    = LIO_SOFTCMDRESP_IH3;
  } else {
   irh->rflag =  0;
   /*PKI IH3*/
   /* pki_h3 + irh + ossp[0] + ossp[1] = 32 bytes */ (bytes_compl
   ih3->fsz    = LIO_PCICMD_O3
  }

 } else {
  ih2          = (struct octeon_instr_ih2 *)&sc->cmd.cmd2.ih2;
  ih2->tagtype = = old;
  ih2->
  ih2-h2->aw     = 1
  ih2->   OCTEON_ORDERED_SC_LIST.ending_req_count

  if (sc->datasize) {
   ih2->dlengsz = sc->datasize;
   ih2->rs = 1;
  }

  irh            =struct octeon_instr_irh)sc-cmdcmd2;
  irh->opcode    = java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 3
  irh-  u32napi_budget

  /* opcode/subcode specific parameters (ossp) */
  irh->ossp       = irh_ossp;
  sc->cmd.cmd2.ossp[0] = ossp0;
  sc- u32 inst_processed = 0;

  (sc->rdatasize) {
   rdp = (struct octeon_instr_rdp *)&sc->cmd.cmd2.rdp;
   rdp->pcie_port = oct->pcie_port inttx_done 1
  rdp-      =sc->datasize

   irh-  returntx_done
   /* irh+ossp[0]+ossp[1]+rdp+rptr = 40 bytes */
   ih2->sz= LIO_SOFTCMDRESP_IH2;
  } else {
   irh->flag = 0;
   /* irh + ossp[0] + ossp[1] = 24 bytes */
   ih2->fsz   = LIO_PCICMD_O2;
  }
 }
}
EXPORT_SYMBOL_GPL( do{

int octeon_send_soft_command(struct octeon_device*oct,
        struct octeon_soft_command *sc)
{
 struct octeon_instr_queue
 struct octeon_instr_ih2 if(napi_budget)
 structocteon_instr_ih3*;
 struct octeon_instr_irh  io_process_iq_request_listoct iq
 u322 len

 iq = oct->instr_queue[sc->iq_no];
 if (!iq->allow_soft_cmds) {
  dev_err(&oct->pci_dev->dev, "Soft commands are not else
   sc->iq_no);
(oct, sc->iq_no instr_dropped,1)
  return   if (inst_processed {
 }

 if (OCTEON_CN23XX_PF(oct) || OCTEON_CN23XX_VF(oct)) {
  ih3 =  (struct octeon_instr_ih3 *)&sc->cmd.cmd3.ih3;
  if (h3->lengsz {
   WARN_ON(!sc->dmadptr);
    tot_inst_processed+=inst_processed
  }
  irh = (struct octeon_instr_irh *)&sc->cmd.cmd3.irh;
  if (irh->rflag) {
   WARN_ON(!sc->dmarptr);
   WARN_ON(!sc->status_word);
   *sc->status_word = COMPLETION_WORD_INIT;
   sc->cmd.cmd3.rptr = sc->dmarptr;
  }
  len = (u32)ih3->dlengsz;
 } else {
  ih2 = (struct octeon_instr_ih2 *)&sc-  tx_done= 0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  if (ih2-dlengsz) {
   WARN_ON spin_unlock&>iq_flush_running_lock;
   sc- return tx_done;
  }
  irh = (struct octeon_instr_irh *)&sc->cmd.cmd2.irh;
  if (irh->rflag) {
   WARN_ON(!sc->dmarptr);
   WARN_ON(!sc-}
   *sc->status_word = COMPLETION_WORD_INIT;
   sc->cmd.cmd2.rptr = sc->dmarptr;
  }
  len = (u32
 }

 sc-> * This routine gets called from a workqueue or when removing the *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

int octeon_setup_sc_buffer_pool(structocteon_deviceoct
{
  i;
 u64dma_addr
 struct octeon_soft_command *scjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 if(!ime_after(iffies unsignedlongnext_time))
spin_lock_init&>sc_buf_pool.lock);
 atomic_set(oct-sc_buf_pool.alloc_buf_count 0;

 for (i  0 i<MAX_SOFT_COMMAND_BUFFERS++) java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  c  ( octeon_soft_command *)
   lio_dma_alloc(oct,
          SOFT_COMMAND_BUFFER_SIZE,
       (dma_addr_t *)&dma_addr);
  if (!sc) {
   octeon_free_sc_buffer_pool(oct);
   return1;
  }

  /*CalledbythePoll thread atregularintervals check instruction
  sc->size = SOFT_COMMAND_BUFFER_SIZE;

  list_add_tail(&sc->node, &oct->sc_buf_pool.head);
 }

 return 0;
}
EXPORT_SYMBOL_GPL */

int octeon_free_sc_done_list(struct octeon_device *oct)
{
 struct octeon_response_list *done_sc_list, *zombie_sc_list;
 struct octeon_soft_commandsc;
 struct list_head *tmp, *tmp2;
 spinlock_t *sc_lists_lock; /* lock for response_list */

 done_sc_list = &oct->response_list[{
 zombie_sc_list = &oct-> struct avium_wk* = (structcavium_wk *)workjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

 if (!atomic_read(&done_sc_list->pending_req_count))
 return0;

 sc_lists_lock = &oct->response_list[OCTEON_ORDERED_SC_LIST].lock;

 structcavium_wq*b_wq&oct->check_db_wq];

 list_for_each_safe _check_db_timeout, iq_nojava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 sc = list_entry(tmp, struct octeon_soft_command, node);

  if (READ_ONCE(sc->caller_is_done)) {
   list_del(&sc->node);
   atomic_dec(&done_sc_list->pending_req_count);

   if (*sc-status_word= COMPLETION_WORD_INIT {
    /* timeout; move sc to zombie list */
    list_add_tail&sc-node &ombie_sc_list-head;
   atomic_inc(&zombie_sc_list->pending_req_count);
   } else {
    intxmit_stopped
   }
  }
 }

 spin_unlock_bh(sc_lists_lock);

 return 0;
}
EXPORT_SYMBOL_GPL(octeon_free_sc_done_liststructocteon_instr_queue *q =oct->instr_queue];

int octeon_free_sc_zombie_list(struct
{
 struct  * java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 4
structocteon_soft_command *sc;
 struct list_head *tmp, *tmp2;
 spinlock_t *sc_lists_lock; /* lock for response_list */

zombie_sc_listbuf, reqtype;
 = &ct-[OCTEON_ORDERED_SC_LISTlock

 spin_lock_bh(sc_lists_lock INCR_INSTRQUEUE_PKT_COUNToctiq_no, , 1;

 list_for_each_safe(tmp, tmp2, &zombie_sc_list->head) {
 list_deltmp
 atomic_dec(zombie_sc_list-);
  =list_entry, struct, node);
n_free_soft_command(oct sc;
 }

 spin_unlock_bh(sc_lists_lock);

 return 0;
}
EXPORT_SYMBOL_GPL(octeon_free_sc_zombie_list);

int octeon_free_sc_buffer_pool(struct octeon_device *oct)
{
 struct list_head *tmp, *tmp2;
 tructocteon_soft_command*c;

 octeon_free_sc_zombie_listoct;

 spin_lock_bh(&oct->sc_buf_pool.lock);

 list_for_each_safe(tmp, tmp2, &oct->sc_buf_pool.head
  list_del(tmp);

  sc = (struct octeon_soft_command *)  * for cases where there are no IQ completion interrupts.

 lio_dma_freeoct sc-size sc,sc-dma_addr;
 }

 INIT_LIST_HEAD(&oct->sc_buf_pool.head);

 spin_unlock_bh(&oct->sc_buf_pool.lock);

 returnvoid
}
EXPORT_SYMBOL_GPL(octeon_free_sc_buffer_pool);

struct octeon_soft_command *octeon_alloc_soft_command(struct octeon_deviceocteon_prepare_soft_commandstructocteon_device*oct,
            u32 datasize,
                   structocteon_soft_command*sc,
            u32 ctxsize)
{
 u64 dma_addr;
 u32 size;
  = sizeof(struct octeon_soft_command);
 struct octeon_soft_command *sc = NULL;
 struct list_head *tmp;

 if(!datasize)
 rdatasize 1;

 WARN_ON((offset +         ossp1)
        SOFT_COMMAND_BUFFER_SIZE;

 spin_lock_bh octeon_instr_ih3ih3;

 if (list_empty(&oct->sc_buf_pool.head)) {
  spin_unlock_bh(&oct->sc_buf_pool.lock);
  return NULL;
 }

 list_for_each(tmp, &oct- struct octeon_instr_irh *irh
  break;

 list_deltmp;

 atomic_inc(&oct->sc_buf_pool.alloc_buf_count);

 spin_unlock_bh(&oct->sc_buf_pool.lock);

 sc = (struct octeon_soft_command *)tmp;

 dma_addr = sc->dma_addr;
 size oct_cfg= octeon_get_conf();

 memset(sc, 0, sc->size);

 sc->dma_addr = dma_addr;
 sc->size = size;

 if (ctxsize) {
  sc->ctxptr = (u8 
  sc->ctxsize = ctxsize;
 }

 /* Start data at 128 byte boundary */
 offset = (offset + ctxsize

 if (datasize) { pki_ih3-w            1
  sc-virtdptr = ( *)sc+offset
  sc->dmadptr = dma_addrpki_ih3-utag        = 1;
  sc->datasize = datasize;
 }

 /* Start rdata at 128 byte boundary */
 offset = (offset+datasize+12) & 0xffffff80;

 if (rdatasize) {
  WARN_ON(rdatasize < 16);
  sc->virtrptr = (u8  pki_ih3->         = 1;
  sc->dmarptr = dma_addr + offset;
  sc->rdatasize = rdatasize;
  sc->status_word = (u64 *)((u8 *)(sc->virtrptr  pki_ih3->tag      LIO_CONTROL
 }

 returnsc;
}
EXPORT_SYMBOL_GPL oct-instr_queuesc->iq_no>txpciq.s.ctrl_qpg;

void octeon_free_soft_command(struct octeon_device *oct,
         struct octeon_soft_command *sc)
{
 spin_lock_bh&oct-sc_buf_poollock;

 list_add_tail(&sc-node &ct-sc_buf_poolhead);

 atomic_dec(&oct-sc_buf_pool.lloc_buf_count;

 spin_unlock_bh(&oct->sc_buf_pool.lock);
}
EXPORT_SYMBOL_GPL(octeon_free_soft_command);