drivers/scsi/csiostor/csio_wr.c

   1 /*
   2  * This file is part of the Chelsio FCoE driver for Linux.
   3  *
   4  * Copyright (c) 2008-2012 Chelsio Communications, Inc. All rights reserved.
   5  *
   6  * This software is available to you under a choice of one of two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        provided with the distribution.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * SOFTWARE.
  33  */
  34
  35 #include <linux/kernel.h>
  36 #include <linux/string.h>
  37 #include <linux/compiler.h>
  38 #include <linux/slab.h>
  39 #include <asm/page.h>
  40 #include <linux/cache.h>
  41
  42 #include "t4_values.h"
  43 #include "csio_hw.h"
  44 #include "csio_wr.h"
  45 #include "csio_mb.h"
  46 #include "csio_defs.h"
  47
  48 int csio_intr_coalesce_cnt;             /* value:SGE_INGRESS_RX_THRESHOLD[0] */
  49 static int csio_sge_thresh_reg;         /* SGE_INGRESS_RX_THRESHOLD[0] */
  50
  51 int csio_intr_coalesce_time = 10;       /* value:SGE_TIMER_VALUE_1 */
  52 static int csio_sge_timer_reg = 1;
  53
  54 #define CSIO_SET_FLBUF_SIZE(_hw, _reg, _val)                            \
  55         csio_wr_reg32((_hw), (_val), SGE_FL_BUFFER_SIZE##_reg##_A)
  56
  57 static void
  58 csio_get_flbuf_size(struct csio_hw *hw, struct csio_sge *sge, uint32_t reg)
  59 {
  60         sge->sge_fl_buf_size[reg] = csio_rd_reg32(hw, SGE_FL_BUFFER_SIZE0_A +
  61                                                         reg * sizeof(uint32_t));
  62 }
  63
  64 /* Free list buffer size */
  65 static inline uint32_t
  66 csio_wr_fl_bufsz(struct csio_sge *sge, struct csio_dma_buf *buf)
  67 {
  68         return sge->sge_fl_buf_size[buf->paddr & 0xF];
  69 }
  70
  71 /* Size of the egress queue status page */
  72 static inline uint32_t
  73 csio_wr_qstat_pgsz(struct csio_hw *hw)
  74 {
  75         return (hw->wrm.sge.sge_control & EGRSTATUSPAGESIZE_F) ?  128 : 64;
  76 }
  77
  78 /* Ring freelist doorbell */
  79 static inline void
  80 csio_wr_ring_fldb(struct csio_hw *hw, struct csio_q *flq)
  81 {
  82         /*
  83          * Ring the doorbell only when we have atleast CSIO_QCREDIT_SZ
  84          * number of bytes in the freelist queue. This translates to atleast
  85          * 8 freelist buffer pointers (since each pointer is 8 bytes).
  86          */
  87         if (flq->inc_idx >= 8) {
  88                 csio_wr_reg32(hw, DBPRIO_F | QID_V(flq->un.fl.flid) |
  89                                   PIDX_T5_V(flq->inc_idx / 8) | DBTYPE_F,
  90                                   MYPF_REG(SGE_PF_KDOORBELL_A));
  91                 flq->inc_idx &= 7;
  92         }
  93 }
  94
  95 /* Write a 0 cidx increment value to enable SGE interrupts for this queue */
  96 static void
  97 csio_wr_sge_intr_enable(struct csio_hw *hw, uint16_t iqid)
  98 {
  99         csio_wr_reg32(hw, CIDXINC_V(0)          |
 100                           INGRESSQID_V(iqid)    |
 101                           TIMERREG_V(X_TIMERREG_RESTART_COUNTER),
 102                           MYPF_REG(SGE_PF_GTS_A));
 103 }
 104
 105 /*
 106  * csio_wr_fill_fl - Populate the FL buffers of a FL queue.
 107  * @hw: HW module.
 108  * @flq: Freelist queue.
 109  *
 110  * Fill up freelist buffer entries with buffers of size specified
 111  * in the size register.
 112  *
 113  */
 114 static int
 115 csio_wr_fill_fl(struct csio_hw *hw, struct csio_q *flq)
 116 {
 117         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
 118         struct csio_sge *sge = &wrm->sge;
 119         __be64 *d = (__be64 *)(flq->vstart);
 120         struct csio_dma_buf *buf = &flq->un.fl.bufs[0];
 121         uint64_t paddr;
 122         int sreg = flq->un.fl.sreg;
 123         int n = flq->credits;
 124
 125         while (n--) {
 126                 buf->len = sge->sge_fl_buf_size[sreg];
 127                 buf->vaddr = dma_alloc_coherent(&hw->pdev->dev, buf->len,
 128                                                 &buf->paddr, GFP_KERNEL);
 129                 if (!buf->vaddr) {
 130                         csio_err(hw, "Could only fill %d buffers!\n", n + 1);
 131                         return -ENOMEM;
 132                 }
 133
 134                 paddr = buf->paddr | (sreg & 0xF);
 135
 136                 *d++ = cpu_to_be64(paddr);
 137                 buf++;
 138         }
 139
 140         return 0;
 141 }
 142
 143 /*
 144  * csio_wr_update_fl -
 145  * @hw: HW module.
 146  * @flq: Freelist queue.
 147  *
 148  *
 149  */
 150 static inline void
 151 csio_wr_update_fl(struct csio_hw *hw, struct csio_q *flq, uint16_t n)
 152 {
 153
 154         flq->inc_idx += n;
 155         flq->pidx += n;
 156         if (unlikely(flq->pidx >= flq->credits))
 157                 flq->pidx -= (uint16_t)flq->credits;
 158
 159         CSIO_INC_STATS(flq, n_flq_refill);
 160 }
 161
 162 /*
 163  * csio_wr_alloc_q - Allocate a WR queue and initialize it.
 164  * @hw: HW module
 165  * @qsize: Size of the queue in bytes
 166  * @wrsize: Since of WR in this queue, if fixed.
 167  * @type: Type of queue (Ingress/Egress/Freelist)
 168  * @owner: Module that owns this queue.
 169  * @nflb: Number of freelist buffers for FL.
 170  * @sreg: What is the FL buffer size register?
 171  * @iq_int_handler: Ingress queue handler in INTx mode.
 172  *
 173  * This function allocates and sets up a queue for the caller
 174  * of size qsize, aligned at the required boundary. This is subject to
 175  * be free entries being available in the queue array. If one is found,
 176  * it is initialized with the allocated queue, marked as being used (owner),
 177  * and a handle returned to the caller in form of the queue's index
 178  * into the q_arr array.
 179  * If user has indicated a freelist (by specifying nflb > 0), create
 180  * another queue (with its own index into q_arr) for the freelist. Allocate
 181  * memory for DMA buffer metadata (vaddr, len etc). Save off the freelist
 182  * idx in the ingress queue's flq.idx. This is how a Freelist is associated
 183  * with its owning ingress queue.
 184  */
 185 int
 186 csio_wr_alloc_q(struct csio_hw *hw, uint32_t qsize, uint32_t wrsize,
 187                 uint16_t type, void *owner, uint32_t nflb, int sreg,
 188                 iq_handler_t iq_intx_handler)
 189 {
 190         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
 191         struct csio_q   *q, *flq;
 192         int             free_idx = wrm->free_qidx;
 193         int             ret_idx = free_idx;
 194         uint32_t        qsz;
 195         int flq_idx;
 196
 197         if (free_idx >= wrm->num_q) {
 198                 csio_err(hw, "No more free queues.\n");
 199                 return -1;
 200         }
 201
 202         switch (type) {
 203         case CSIO_EGRESS:
 204                 qsz = ALIGN(qsize, CSIO_QCREDIT_SZ) + csio_wr_qstat_pgsz(hw);
 205                 break;
 206         case CSIO_INGRESS:
 207                 switch (wrsize) {
 208                 case 16:
 209                 case 32:
 210                 case 64:
 211                 case 128:
 212                         break;
 213                 default:
 214                         csio_err(hw, "Invalid Ingress queue WR size:%d\n",
 215                                     wrsize);
 216                         return -1;
 217                 }
 218
 219                 /*
 220                  * Number of elements must be a multiple of 16
 221                  * So this includes status page size
 222                  */
 223                 qsz = ALIGN(qsize/wrsize, 16) * wrsize;
 224
 225                 break;
 226         case CSIO_FREELIST:
 227                 qsz = ALIGN(qsize/wrsize, 8) * wrsize + csio_wr_qstat_pgsz(hw);
 228                 break;
 229         default:
 230                 csio_err(hw, "Invalid queue type: 0x%x\n", type);
 231                 return -1;
 232         }
 233
 234         q = wrm->q_arr[free_idx];
 235
 236         q->vstart = dma_alloc_coherent(&hw->pdev->dev, qsz, &q->pstart,
 237                                        GFP_KERNEL);
 238         if (!q->vstart) {
 239                 csio_err(hw,
 240                          "Failed to allocate DMA memory for "
 241                          "queue at id: %d size: %d\n", free_idx, qsize);
 242                 return -1;
 243         }
 244
 245         q->type         = type;
 246         q->owner        = owner;
 247         q->pidx         = q->cidx = q->inc_idx = 0;
 248         q->size         = qsz;
 249         q->wr_sz        = wrsize;       /* If using fixed size WRs */
 250
 251         wrm->free_qidx++;
 252
 253         if (type == CSIO_INGRESS) {
 254                 /* Since queue area is set to zero */
 255                 q->un.iq.genbit = 1;
 256
 257                 /*
 258                  * Ingress queue status page size is always the size of
 259                  * the ingress queue entry.
 260                  */
 261                 q->credits      = (qsz - q->wr_sz) / q->wr_sz;
 262                 q->vwrap        = (void *)((uintptr_t)(q->vstart) + qsz
 263                                                         - q->wr_sz);
 264
 265                 /* Allocate memory for FL if requested */
 266                 if (nflb > 0) {
 267                         flq_idx = csio_wr_alloc_q(hw, nflb * sizeof(__be64),
 268                                                   sizeof(__be64), CSIO_FREELIST,
 269                                                   owner, 0, sreg, NULL);
 270                         if (flq_idx == -1) {
 271                                 csio_err(hw,
 272                                          "Failed to allocate FL queue"
 273                                          " for IQ idx:%d\n", free_idx);
 274                                 return -1;
 275                         }
 276
 277                         /* Associate the new FL with the Ingress quue */
 278                         q->un.iq.flq_idx = flq_idx;
 279
 280                         flq = wrm->q_arr[q->un.iq.flq_idx];
 281                         flq->un.fl.bufs = kcalloc(flq->credits,
 282                                                   sizeof(struct csio_dma_buf),
 283                                                   GFP_KERNEL);
 284                         if (!flq->un.fl.bufs) {
 285                                 csio_err(hw,
 286                                          "Failed to allocate FL queue bufs"
 287                                          " for IQ idx:%d\n", free_idx);
 288                                 return -1;
 289                         }
 290
 291                         flq->un.fl.packen = 0;
 292                         flq->un.fl.offset = 0;
 293                         flq->un.fl.sreg = sreg;
 294
 295                         /* Fill up the free list buffers */
 296                         if (csio_wr_fill_fl(hw, flq))
 297                                 return -1;
 298
 299                         /*
 300                          * Make sure in a FLQ, atleast 1 credit (8 FL buffers)
 301                          * remains unpopulated,otherwise HW thinks
 302                          * FLQ is empty.
 303                          */
 304                         flq->pidx = flq->inc_idx = flq->credits - 8;
 305                 } else {
 306                         q->un.iq.flq_idx = -1;
 307                 }
 308
 309                 /* Associate the IQ INTx handler. */
 310                 q->un.iq.iq_intx_handler = iq_intx_handler;
 311
 312                 csio_q_iqid(hw, ret_idx) = CSIO_MAX_QID;
 313
 314         } else if (type == CSIO_EGRESS) {
 315                 q->credits = (qsz - csio_wr_qstat_pgsz(hw)) / CSIO_QCREDIT_SZ;
 316                 q->vwrap   = (void *)((uintptr_t)(q->vstart) + qsz
 317                                                 - csio_wr_qstat_pgsz(hw));
 318                 csio_q_eqid(hw, ret_idx) = CSIO_MAX_QID;
 319         } else { /* Freelist */
 320                 q->credits = (qsz - csio_wr_qstat_pgsz(hw)) / sizeof(__be64);
 321                 q->vwrap   = (void *)((uintptr_t)(q->vstart) + qsz
 322                                                 - csio_wr_qstat_pgsz(hw));
 323                 csio_q_flid(hw, ret_idx) = CSIO_MAX_QID;
 324         }
 325
 326         return ret_idx;
 327 }
 328
 329 /*
 330  * csio_wr_iq_create_rsp - Response handler for IQ creation.
 331  * @hw: The HW module.
 332  * @mbp: Mailbox.
 333  * @iq_idx: Ingress queue that got created.
 334  *
 335  * Handle FW_IQ_CMD mailbox completion. Save off the assigned IQ/FL ids.
 336  */
 337 static int
 338 csio_wr_iq_create_rsp(struct csio_hw *hw, struct csio_mb *mbp, int iq_idx)
 339 {
 340         struct csio_iq_params iqp;
 341         enum fw_retval retval;
 342         uint32_t iq_id;
 343         int flq_idx;
 344
 345         memset(&iqp, 0, sizeof(struct csio_iq_params));
 346
 347         csio_mb_iq_alloc_write_rsp(hw, mbp, &retval, &iqp);
 348
 349         if (retval != FW_SUCCESS) {
 350                 csio_err(hw, "IQ cmd returned 0x%x!\n", retval);
 351                 mempool_free(mbp, hw->mb_mempool);
 352                 return -EINVAL;
 353         }
 354
 355         csio_q_iqid(hw, iq_idx)         = iqp.iqid;
 356         csio_q_physiqid(hw, iq_idx)     = iqp.physiqid;
 357         csio_q_pidx(hw, iq_idx)         = csio_q_cidx(hw, iq_idx) = 0;
 358         csio_q_inc_idx(hw, iq_idx)      = 0;
 359
 360         /* Actual iq-id. */
 361         iq_id = iqp.iqid - hw->wrm.fw_iq_start;
 362
 363         /* Set the iq-id to iq map table. */
 364         if (iq_id >= CSIO_MAX_IQ) {
 365                 csio_err(hw,
 366                          "Exceeding MAX_IQ(%d) supported!"
 367                          " iqid:%d rel_iqid:%d FW iq_start:%d\n",
 368                          CSIO_MAX_IQ, iq_id, iqp.iqid, hw->wrm.fw_iq_start);
 369                 mempool_free(mbp, hw->mb_mempool);
 370                 return -EINVAL;
 371         }
 372         csio_q_set_intr_map(hw, iq_idx, iq_id);
 373
 374         /*
 375          * During FW_IQ_CMD, FW sets interrupt_sent bit to 1 in the SGE
 376          * ingress context of this queue. This will block interrupts to
 377          * this queue until the next GTS write. Therefore, we do a
 378          * 0-cidx increment GTS write for this queue just to clear the
 379          * interrupt_sent bit. This will re-enable interrupts to this
 380          * queue.
 381          */
 382         csio_wr_sge_intr_enable(hw, iqp.physiqid);
 383
 384         flq_idx = csio_q_iq_flq_idx(hw, iq_idx);
 385         if (flq_idx != -1) {
 386                 struct csio_q *flq = hw->wrm.q_arr[flq_idx];
 387
 388                 csio_q_flid(hw, flq_idx) = iqp.fl0id;
 389                 csio_q_cidx(hw, flq_idx) = 0;
 390                 csio_q_pidx(hw, flq_idx)    = csio_q_credits(hw, flq_idx) - 8;
 391                 csio_q_inc_idx(hw, flq_idx) = csio_q_credits(hw, flq_idx) - 8;
 392
 393                 /* Now update SGE about the buffers allocated during init */
 394                 csio_wr_ring_fldb(hw, flq);
 395         }
 396
 397         mempool_free(mbp, hw->mb_mempool);
 398
 399         return 0;
 400 }
 401
 402 /*
 403  * csio_wr_iq_create - Configure an Ingress queue with FW.
 404  * @hw: The HW module.
 405  * @priv: Private data object.
 406  * @iq_idx: Ingress queue index in the WR module.
 407  * @vec: MSIX vector.
 408  * @portid: PCIE Channel to be associated with this queue.
 409  * @async: Is this a FW asynchronous message handling queue?
 410  * @cbfn: Completion callback.
 411  *
 412  * This API configures an ingress queue with FW by issuing a FW_IQ_CMD mailbox
 413  * with alloc/write bits set.
 414  */
 415 int
 416 csio_wr_iq_create(struct csio_hw *hw, void *priv, int iq_idx,
 417                   uint32_t vec, uint8_t portid, bool async,
 418                   void (*cbfn) (struct csio_hw *, struct csio_mb *))
 419 {
 420         struct csio_mb  *mbp;
 421         struct csio_iq_params iqp;
 422         int flq_idx;
 423
 424         memset(&iqp, 0, sizeof(struct csio_iq_params));
 425         csio_q_portid(hw, iq_idx) = portid;
 426
 427         mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
 428         if (!mbp) {
 429                 csio_err(hw, "IQ command out of memory!\n");
 430                 return -ENOMEM;
 431         }
 432
 433         switch (hw->intr_mode) {
 434         case CSIO_IM_INTX:
 435         case CSIO_IM_MSI:
 436                 /* For interrupt forwarding queue only */
 437                 if (hw->intr_iq_idx == iq_idx)
 438                         iqp.iqandst     = X_INTERRUPTDESTINATION_PCIE;
 439                 else
 440                         iqp.iqandst     = X_INTERRUPTDESTINATION_IQ;
 441                 iqp.iqandstindex        =
 442                         csio_q_physiqid(hw, hw->intr_iq_idx);
 443                 break;
 444         case CSIO_IM_MSIX:
 445                 iqp.iqandst             = X_INTERRUPTDESTINATION_PCIE;
 446                 iqp.iqandstindex        = (uint16_t)vec;
 447                 break;
 448         case CSIO_IM_NONE:
 449                 mempool_free(mbp, hw->mb_mempool);
 450                 return -EINVAL;
 451         }
 452
 453         /* Pass in the ingress queue cmd parameters */
 454         iqp.pfn                 = hw->pfn;
 455         iqp.vfn                 = 0;
 456         iqp.iq_start            = 1;
 457         iqp.viid                = 0;
 458         iqp.type                = FW_IQ_TYPE_FL_INT_CAP;
 459         iqp.iqasynch            = async;
 460         if (csio_intr_coalesce_cnt)
 461                 iqp.iqanus      = X_UPDATESCHEDULING_COUNTER_OPTTIMER;
 462         else
 463                 iqp.iqanus      = X_UPDATESCHEDULING_TIMER;
 464         iqp.iqanud              = X_UPDATEDELIVERY_INTERRUPT;
 465         iqp.iqpciech            = portid;
 466         iqp.iqintcntthresh      = (uint8_t)csio_sge_thresh_reg;
 467
 468         switch (csio_q_wr_sz(hw, iq_idx)) {
 469         case 16:
 470                 iqp.iqesize = 0; break;
 471         case 32:
 472                 iqp.iqesize = 1; break;
 473         case 64:
 474                 iqp.iqesize = 2; break;
 475         case 128:
 476                 iqp.iqesize = 3; break;
 477         }
 478
 479         iqp.iqsize              = csio_q_size(hw, iq_idx) /
 480                                                 csio_q_wr_sz(hw, iq_idx);
 481         iqp.iqaddr              = csio_q_pstart(hw, iq_idx);
 482
 483         flq_idx = csio_q_iq_flq_idx(hw, iq_idx);
 484         if (flq_idx != -1) {
 485                 enum chip_type chip = CHELSIO_CHIP_VERSION(hw->chip_id);
 486                 struct csio_q *flq = hw->wrm.q_arr[flq_idx];
 487
 488                 iqp.fl0paden    = 1;
 489                 iqp.fl0packen   = flq->un.fl.packen ? 1 : 0;
 490                 iqp.fl0fbmin    = X_FETCHBURSTMIN_64B;
 491                 iqp.fl0fbmax    = ((chip == CHELSIO_T5) ?
 492                                   X_FETCHBURSTMAX_512B : X_FETCHBURSTMAX_256B);
 493                 iqp.fl0size     = csio_q_size(hw, flq_idx) / CSIO_QCREDIT_SZ;
 494                 iqp.fl0addr     = csio_q_pstart(hw, flq_idx);
 495         }
 496
 497         csio_mb_iq_alloc_write(hw, mbp, priv, CSIO_MB_DEFAULT_TMO, &iqp, cbfn);
 498
 499         if (csio_mb_issue(hw, mbp)) {
 500                 csio_err(hw, "Issue of IQ cmd failed!\n");
 501                 mempool_free(mbp, hw->mb_mempool);
 502                 return -EINVAL;
 503         }
 504
 505         if (cbfn != NULL)
 506                 return 0;
 507
 508         return csio_wr_iq_create_rsp(hw, mbp, iq_idx);
 509 }
 510
 511 /*
 512  * csio_wr_eq_create_rsp - Response handler for EQ creation.
 513  * @hw: The HW module.
 514  * @mbp: Mailbox.
 515  * @eq_idx: Egress queue that got created.
 516  *
 517  * Handle FW_EQ_OFLD_CMD mailbox completion. Save off the assigned EQ ids.
 518  */
 519 static int
 520 csio_wr_eq_cfg_rsp(struct csio_hw *hw, struct csio_mb *mbp, int eq_idx)
 521 {
 522         struct csio_eq_params eqp;
 523         enum fw_retval retval;
 524
 525         memset(&eqp, 0, sizeof(struct csio_eq_params));
 526
 527         csio_mb_eq_ofld_alloc_write_rsp(hw, mbp, &retval, &eqp);
 528
 529         if (retval != FW_SUCCESS) {
 530                 csio_err(hw, "EQ OFLD cmd returned 0x%x!\n", retval);
 531                 mempool_free(mbp, hw->mb_mempool);
 532                 return -EINVAL;
 533         }
 534
 535         csio_q_eqid(hw, eq_idx) = (uint16_t)eqp.eqid;
 536         csio_q_physeqid(hw, eq_idx) = (uint16_t)eqp.physeqid;
 537         csio_q_pidx(hw, eq_idx) = csio_q_cidx(hw, eq_idx) = 0;
 538         csio_q_inc_idx(hw, eq_idx) = 0;
 539
 540         mempool_free(mbp, hw->mb_mempool);
 541
 542         return 0;
 543 }
 544
 545 /*
 546  * csio_wr_eq_create - Configure an Egress queue with FW.
 547  * @hw: HW module.
 548  * @priv: Private data.
 549  * @eq_idx: Egress queue index in the WR module.
 550  * @iq_idx: Associated ingress queue index.
 551  * @cbfn: Completion callback.
 552  *
 553  * This API configures a offload egress queue with FW by issuing a
 554  * FW_EQ_OFLD_CMD  (with alloc + write ) mailbox.
 555  */
 556 int
 557 csio_wr_eq_create(struct csio_hw *hw, void *priv, int eq_idx,
 558                   int iq_idx, uint8_t portid,
 559                   void (*cbfn) (struct csio_hw *, struct csio_mb *))
 560 {
 561         struct csio_mb  *mbp;
 562         struct csio_eq_params eqp;
 563
 564         memset(&eqp, 0, sizeof(struct csio_eq_params));
 565
 566         mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
 567         if (!mbp) {
 568                 csio_err(hw, "EQ command out of memory!\n");
 569                 return -ENOMEM;
 570         }
 571
 572         eqp.pfn                 = hw->pfn;
 573         eqp.vfn                 = 0;
 574         eqp.eqstart             = 1;
 575         eqp.hostfcmode          = X_HOSTFCMODE_STATUS_PAGE;
 576         eqp.iqid                = csio_q_iqid(hw, iq_idx);
 577         eqp.fbmin               = X_FETCHBURSTMIN_64B;
 578         eqp.fbmax               = X_FETCHBURSTMAX_512B;
 579         eqp.cidxfthresh         = 0;
 580         eqp.pciechn             = portid;
 581         eqp.eqsize              = csio_q_size(hw, eq_idx) / CSIO_QCREDIT_SZ;
 582         eqp.eqaddr              = csio_q_pstart(hw, eq_idx);
 583
 584         csio_mb_eq_ofld_alloc_write(hw, mbp, priv, CSIO_MB_DEFAULT_TMO,
 585                                     &eqp, cbfn);
 586
 587         if (csio_mb_issue(hw, mbp)) {
 588                 csio_err(hw, "Issue of EQ OFLD cmd failed!\n");
 589                 mempool_free(mbp, hw->mb_mempool);
 590                 return -EINVAL;
 591         }
 592
 593         if (cbfn != NULL)
 594                 return 0;
 595
 596         return csio_wr_eq_cfg_rsp(hw, mbp, eq_idx);
 597 }
 598
 599 /*
 600  * csio_wr_iq_destroy_rsp - Response handler for IQ removal.
 601  * @hw: The HW module.
 602  * @mbp: Mailbox.
 603  * @iq_idx: Ingress queue that was freed.
 604  *
 605  * Handle FW_IQ_CMD (free) mailbox completion.
 606  */
 607 static int
 608 csio_wr_iq_destroy_rsp(struct csio_hw *hw, struct csio_mb *mbp, int iq_idx)
 609 {
 610         enum fw_retval retval = csio_mb_fw_retval(mbp);
 611         int rv = 0;
 612
 613         if (retval != FW_SUCCESS)
 614                 rv = -EINVAL;
 615
 616         mempool_free(mbp, hw->mb_mempool);
 617
 618         return rv;
 619 }
 620
 621 /*
 622  * csio_wr_iq_destroy - Free an ingress queue.
 623  * @hw: The HW module.
 624  * @priv: Private data object.
 625  * @iq_idx: Ingress queue index to destroy
 626  * @cbfn: Completion callback.
 627  *
 628  * This API frees an ingress queue by issuing the FW_IQ_CMD
 629  * with the free bit set.
 630  */
 631 static int
 632 csio_wr_iq_destroy(struct csio_hw *hw, void *priv, int iq_idx,
 633                    void (*cbfn)(struct csio_hw *, struct csio_mb *))
 634 {
 635         int rv = 0;
 636         struct csio_mb  *mbp;
 637         struct csio_iq_params iqp;
 638         int flq_idx;
 639
 640         memset(&iqp, 0, sizeof(struct csio_iq_params));
 641
 642         mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
 643         if (!mbp)
 644                 return -ENOMEM;
 645
 646         iqp.pfn         = hw->pfn;
 647         iqp.vfn         = 0;
 648         iqp.iqid        = csio_q_iqid(hw, iq_idx);
 649         iqp.type        = FW_IQ_TYPE_FL_INT_CAP;
 650
 651         flq_idx = csio_q_iq_flq_idx(hw, iq_idx);
 652         if (flq_idx != -1)
 653                 iqp.fl0id = csio_q_flid(hw, flq_idx);
 654         else
 655                 iqp.fl0id = 0xFFFF;
 656
 657         iqp.fl1id = 0xFFFF;
 658
 659         csio_mb_iq_free(hw, mbp, priv, CSIO_MB_DEFAULT_TMO, &iqp, cbfn);
 660
 661         rv = csio_mb_issue(hw, mbp);
 662         if (rv != 0) {
 663                 mempool_free(mbp, hw->mb_mempool);
 664                 return rv;
 665         }
 666
 667         if (cbfn != NULL)
 668                 return 0;
 669
 670         return csio_wr_iq_destroy_rsp(hw, mbp, iq_idx);
 671 }
 672
 673 /*
 674  * csio_wr_eq_destroy_rsp - Response handler for OFLD EQ creation.
 675  * @hw: The HW module.
 676  * @mbp: Mailbox.
 677  * @eq_idx: Egress queue that was freed.
 678  *
 679  * Handle FW_OFLD_EQ_CMD (free) mailbox completion.
 680  */
 681 static int
 682 csio_wr_eq_destroy_rsp(struct csio_hw *hw, struct csio_mb *mbp, int eq_idx)
 683 {
 684         enum fw_retval retval = csio_mb_fw_retval(mbp);
 685         int rv = 0;
 686
 687         if (retval != FW_SUCCESS)
 688                 rv = -EINVAL;
 689
 690         mempool_free(mbp, hw->mb_mempool);
 691
 692         return rv;
 693 }
 694
 695 /*
 696  * csio_wr_eq_destroy - Free an Egress queue.
 697  * @hw: The HW module.
 698  * @priv: Private data object.
 699  * @eq_idx: Egress queue index to destroy
 700  * @cbfn: Completion callback.
 701  *
 702  * This API frees an Egress queue by issuing the FW_EQ_OFLD_CMD
 703  * with the free bit set.
 704  */
 705 static int
 706 csio_wr_eq_destroy(struct csio_hw *hw, void *priv, int eq_idx,
 707                    void (*cbfn) (struct csio_hw *, struct csio_mb *))
 708 {
 709         int rv = 0;
 710         struct csio_mb  *mbp;
 711         struct csio_eq_params eqp;
 712
 713         memset(&eqp, 0, sizeof(struct csio_eq_params));
 714
 715         mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
 716         if (!mbp)
 717                 return -ENOMEM;
 718
 719         eqp.pfn         = hw->pfn;
 720         eqp.vfn         = 0;
 721         eqp.eqid        = csio_q_eqid(hw, eq_idx);
 722
 723         csio_mb_eq_ofld_free(hw, mbp, priv, CSIO_MB_DEFAULT_TMO, &eqp, cbfn);
 724
 725         rv = csio_mb_issue(hw, mbp);
 726         if (rv != 0) {
 727                 mempool_free(mbp, hw->mb_mempool);
 728                 return rv;
 729         }
 730
 731         if (cbfn != NULL)
 732                 return 0;
 733
 734         return csio_wr_eq_destroy_rsp(hw, mbp, eq_idx);
 735 }
 736
 737 /*
 738  * csio_wr_cleanup_eq_stpg - Cleanup Egress queue status page
 739  * @hw: HW module
 740  * @qidx: Egress queue index
 741  *
 742  * Cleanup the Egress queue status page.
 743  */
 744 static void
 745 csio_wr_cleanup_eq_stpg(struct csio_hw *hw, int qidx)
 746 {
 747         struct csio_q   *q = csio_hw_to_wrm(hw)->q_arr[qidx];
 748         struct csio_qstatus_page *stp = (struct csio_qstatus_page *)q->vwrap;
 749
 750         memset(stp, 0, sizeof(*stp));
 751 }
 752
 753 /*
 754  * csio_wr_cleanup_iq_ftr - Cleanup Footer entries in IQ
 755  * @hw: HW module
 756  * @qidx: Ingress queue index
 757  *
 758  * Cleanup the footer entries in the given ingress queue,
 759  * set to 1 the internal copy of genbit.
 760  */
 761 static void
 762 csio_wr_cleanup_iq_ftr(struct csio_hw *hw, int qidx)
 763 {
 764         struct csio_wrm *wrm    = csio_hw_to_wrm(hw);
 765         struct csio_q   *q      = wrm->q_arr[qidx];
 766         void *wr;
 767         struct csio_iqwr_footer *ftr;
 768         uint32_t i = 0;
 769
 770         /* set to 1 since we are just about zero out genbit */
 771         q->un.iq.genbit = 1;
 772
 773         for (i = 0; i < q->credits; i++) {
 774                 /* Get the WR */
 775                 wr = (void *)((uintptr_t)q->vstart +
 776                                            (i * q->wr_sz));
 777                 /* Get the footer */
 778                 ftr = (struct csio_iqwr_footer *)((uintptr_t)wr +
 779                                           (q->wr_sz - sizeof(*ftr)));
 780                 /* Zero out footer */
 781                 memset(ftr, 0, sizeof(*ftr));
 782         }
 783 }
 784
 785 int
 786 csio_wr_destroy_queues(struct csio_hw *hw, bool cmd)
 787 {
 788         int i, flq_idx;
 789         struct csio_q *q;
 790         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
 791         int rv;
 792
 793         for (i = 0; i < wrm->free_qidx; i++) {
 794                 q = wrm->q_arr[i];
 795
 796                 switch (q->type) {
 797                 case CSIO_EGRESS:
 798                         if (csio_q_eqid(hw, i) != CSIO_MAX_QID) {
 799                                 csio_wr_cleanup_eq_stpg(hw, i);
 800                                 if (!cmd) {
 801                                         csio_q_eqid(hw, i) = CSIO_MAX_QID;
 802                                         continue;
 803                                 }
 804
 805                                 rv = csio_wr_eq_destroy(hw, NULL, i, NULL);
 806                                 if ((rv == -EBUSY) || (rv == -ETIMEDOUT))
 807                                         cmd = false;
 808
 809                                 csio_q_eqid(hw, i) = CSIO_MAX_QID;
 810                         }
 811                 case CSIO_INGRESS:
 812                         if (csio_q_iqid(hw, i) != CSIO_MAX_QID) {
 813                                 csio_wr_cleanup_iq_ftr(hw, i);
 814                                 if (!cmd) {
 815                                         csio_q_iqid(hw, i) = CSIO_MAX_QID;
 816                                         flq_idx = csio_q_iq_flq_idx(hw, i);
 817                                         if (flq_idx != -1)
 818                                                 csio_q_flid(hw, flq_idx) =
 819                                                                 CSIO_MAX_QID;
 820                                         continue;
 821                                 }
 822
 823                                 rv = csio_wr_iq_destroy(hw, NULL, i, NULL);
 824                                 if ((rv == -EBUSY) || (rv == -ETIMEDOUT))
 825                                         cmd = false;
 826
 827                                 csio_q_iqid(hw, i) = CSIO_MAX_QID;
 828                                 flq_idx = csio_q_iq_flq_idx(hw, i);
 829                                 if (flq_idx != -1)
 830                                         csio_q_flid(hw, flq_idx) = CSIO_MAX_QID;
 831                         }
 832                 default:
 833                         break;
 834                 }
 835         }
 836
 837         hw->flags &= ~CSIO_HWF_Q_FW_ALLOCED;
 838
 839         return 0;
 840 }
 841
 842 /*
 843  * csio_wr_get - Get requested size of WR entry/entries from queue.
 844  * @hw: HW module.
 845  * @qidx: Index of queue.
 846  * @size: Cumulative size of Work request(s).
 847  * @wrp: Work request pair.
 848  *
 849  * If requested credits are available, return the start address of the
 850  * work request in the work request pair. Set pidx accordingly and
 851  * return.
 852  *
 853  * NOTE about WR pair:
 854  * ==================
 855  * A WR can start towards the end of a queue, and then continue at the
 856  * beginning, since the queue is considered to be circular. This will
 857  * require a pair of address/size to be passed back to the caller -
 858  * hence Work request pair format.
 859  */
 860 int
 861 csio_wr_get(struct csio_hw *hw, int qidx, uint32_t size,
 862             struct csio_wr_pair *wrp)
 863 {
 864         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
 865         struct csio_q *q = wrm->q_arr[qidx];
 866         void *cwr = (void *)((uintptr_t)(q->vstart) +
 867                                                 (q->pidx * CSIO_QCREDIT_SZ));
 868         struct csio_qstatus_page *stp = (struct csio_qstatus_page *)q->vwrap;
 869         uint16_t cidx = q->cidx = ntohs(stp->cidx);
 870         uint16_t pidx = q->pidx;
 871         uint32_t req_sz = ALIGN(size, CSIO_QCREDIT_SZ);
 872         int req_credits = req_sz / CSIO_QCREDIT_SZ;
 873         int credits;
 874
 875         CSIO_DB_ASSERT(q->owner != NULL);
 876         CSIO_DB_ASSERT((qidx >= 0) && (qidx < wrm->free_qidx));
 877         CSIO_DB_ASSERT(cidx <= q->credits);
 878
 879         /* Calculate credits */
 880         if (pidx > cidx) {
 881                 credits = q->credits - (pidx - cidx) - 1;
 882         } else if (cidx > pidx) {
 883                 credits = cidx - pidx - 1;
 884         } else {
 885                 /* cidx == pidx, empty queue */
 886                 credits = q->credits;
 887                 CSIO_INC_STATS(q, n_qempty);
 888         }
 889
 890         /*
 891          * Check if we have enough credits.
 892          * credits = 1 implies queue is full.
 893          */
 894         if (!credits || (req_credits > credits)) {
 895                 CSIO_INC_STATS(q, n_qfull);
 896                 return -EBUSY;
 897         }
 898
 899         /*
 900          * If we are here, we have enough credits to satisfy the
 901          * request. Check if we are near the end of q, and if WR spills over.
 902          * If it does, use the first addr/size to cover the queue until
 903          * the end. Fit the remainder portion of the request at the top
 904          * of queue and return it in the second addr/len. Set pidx
 905          * accordingly.
 906          */
 907         if (unlikely(((uintptr_t)cwr + req_sz) > (uintptr_t)(q->vwrap))) {
 908                 wrp->addr1 = cwr;
 909                 wrp->size1 = (uint32_t)((uintptr_t)q->vwrap - (uintptr_t)cwr);
 910                 wrp->addr2 = q->vstart;
 911                 wrp->size2 = req_sz - wrp->size1;
 912                 q->pidx = (uint16_t)(ALIGN(wrp->size2, CSIO_QCREDIT_SZ) /
 913                                                         CSIO_QCREDIT_SZ);
 914                 CSIO_INC_STATS(q, n_qwrap);
 915                 CSIO_INC_STATS(q, n_eq_wr_split);
 916         } else {
 917                 wrp->addr1 = cwr;
 918                 wrp->size1 = req_sz;
 919                 wrp->addr2 = NULL;
 920                 wrp->size2 = 0;
 921                 q->pidx += (uint16_t)req_credits;
 922
 923                 /* We are the end of queue, roll back pidx to top of queue */
 924                 if (unlikely(q->pidx == q->credits)) {
 925                         q->pidx = 0;
 926                         CSIO_INC_STATS(q, n_qwrap);
 927                 }
 928         }
 929
 930         q->inc_idx = (uint16_t)req_credits;
 931
 932         CSIO_INC_STATS(q, n_tot_reqs);
 933
 934         return 0;
 935 }
 936
 937 /*
 938  * csio_wr_copy_to_wrp - Copies given data into WR.
 939  * @data_buf - Data buffer
 940  * @wrp - Work request pair.
 941  * @wr_off - Work request offset.
 942  * @data_len - Data length.
 943  *
 944  * Copies the given data in Work Request. Work request pair(wrp) specifies
 945  * address information of Work request.
 946  * Returns: none
 947  */
 948 void
 949 csio_wr_copy_to_wrp(void *data_buf, struct csio_wr_pair *wrp,
 950                    uint32_t wr_off, uint32_t data_len)
 951 {
 952         uint32_t nbytes;
 953
 954         /* Number of space available in buffer addr1 of WRP */
 955         nbytes = ((wrp->size1 - wr_off) >= data_len) ?
 956                                         data_len : (wrp->size1 - wr_off);
 957
 958         memcpy((uint8_t *) wrp->addr1 + wr_off, data_buf, nbytes);
 959         data_len -= nbytes;
 960
 961         /* Write the remaining data from the begining of circular buffer */
 962         if (data_len) {
 963                 CSIO_DB_ASSERT(data_len <= wrp->size2);
 964                 CSIO_DB_ASSERT(wrp->addr2 != NULL);
 965                 memcpy(wrp->addr2, (uint8_t *) data_buf + nbytes, data_len);
 966         }
 967 }
 968
 969 /*
 970  * csio_wr_issue - Notify chip of Work request.
 971  * @hw: HW module.
 972  * @qidx: Index of queue.
 973  * @prio: 0: Low priority, 1: High priority
 974  *
 975  * Rings the SGE Doorbell by writing the current producer index of the passed
 976  * in queue into the register.
 977  *
 978  */
 979 int
 980 csio_wr_issue(struct csio_hw *hw, int qidx, bool prio)
 981 {
 982         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
 983         struct csio_q *q = wrm->q_arr[qidx];
 984
 985         CSIO_DB_ASSERT((qidx >= 0) && (qidx < wrm->free_qidx));
 986
 987         wmb();
 988         /* Ring SGE Doorbell writing q->pidx into it */
 989         csio_wr_reg32(hw, DBPRIO_V(prio) | QID_V(q->un.eq.physeqid) |
 990                           PIDX_T5_V(q->inc_idx) | DBTYPE_F,
 991                           MYPF_REG(SGE_PF_KDOORBELL_A));
 992         q->inc_idx = 0;
 993
 994         return 0;
 995 }
 996
 997 static inline uint32_t
 998 csio_wr_avail_qcredits(struct csio_q *q)
 999 {
1000         if (q->pidx > q->cidx)
1001                 return q->pidx - q->cidx;
1002         else if (q->cidx > q->pidx)
1003                 return q->credits - (q->cidx - q->pidx);
1004         else
1005                 return 0;       /* cidx == pidx, empty queue */
1006 }
1007
1008 /*
1009  * csio_wr_inval_flq_buf - Invalidate a free list buffer entry.
1010  * @hw: HW module.
1011  * @flq: The freelist queue.
1012  *
1013  * Invalidate the driver's version of a freelist buffer entry,
1014  * without freeing the associated the DMA memory. The entry
1015  * to be invalidated is picked up from the current Free list
1016  * queue cidx.
1017  *
1018  */
1019 static inline void
1020 csio_wr_inval_flq_buf(struct csio_hw *hw, struct csio_q *flq)
1021 {
1022         flq->cidx++;
1023         if (flq->cidx == flq->credits) {
1024                 flq->cidx = 0;
1025                 CSIO_INC_STATS(flq, n_qwrap);
1026         }
1027 }
1028
1029 /*
1030  * csio_wr_process_fl - Process a freelist completion.
1031  * @hw: HW module.
1032  * @q: The ingress queue attached to the Freelist.
1033  * @wr: The freelist completion WR in the ingress queue.
1034  * @len_to_qid: The lower 32-bits of the first flit of the RSP footer
1035  * @iq_handler: Caller's handler for this completion.
1036  * @priv: Private pointer of caller
1037  *
1038  */
1039 static inline void
1040 csio_wr_process_fl(struct csio_hw *hw, struct csio_q *q,
1041                    void *wr, uint32_t len_to_qid,
1042                    void (*iq_handler)(struct csio_hw *, void *,
1043                                       uint32_t, struct csio_fl_dma_buf *,
1044                                       void *),
1045                    void *priv)
1046 {
1047         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
1048         struct csio_sge *sge = &wrm->sge;
1049         struct csio_fl_dma_buf flb;
1050         struct csio_dma_buf *buf, *fbuf;
1051         uint32_t bufsz, len, lastlen = 0;
1052         int n;
1053         struct csio_q *flq = hw->wrm.q_arr[q->un.iq.flq_idx];
1054
1055         CSIO_DB_ASSERT(flq != NULL);
1056
1057         len = len_to_qid;
1058
1059         if (len & IQWRF_NEWBUF) {
1060                 if (flq->un.fl.offset > 0) {
1061                         csio_wr_inval_flq_buf(hw, flq);
1062                         flq->un.fl.offset = 0;
1063                 }
1064                 len = IQWRF_LEN_GET(len);
1065         }
1066
1067         CSIO_DB_ASSERT(len != 0);
1068
1069         flb.totlen = len;
1070
1071         /* Consume all freelist buffers used for len bytes */
1072         for (n = 0, fbuf = flb.flbufs; ; n++, fbuf++) {
1073                 buf = &flq->un.fl.bufs[flq->cidx];
1074                 bufsz = csio_wr_fl_bufsz(sge, buf);
1075
1076                 fbuf->paddr     = buf->paddr;
1077                 fbuf->vaddr     = buf->vaddr;
1078
1079                 flb.offset      = flq->un.fl.offset;
1080                 lastlen         = min(bufsz, len);
1081                 fbuf->len       = lastlen;
1082
1083                 len -= lastlen;
1084                 if (!len)
1085                         break;
1086                 csio_wr_inval_flq_buf(hw, flq);
1087         }
1088
1089         flb.defer_free = flq->un.fl.packen ? 0 : 1;
1090
1091         iq_handler(hw, wr, q->wr_sz - sizeof(struct csio_iqwr_footer),
1092                    &flb, priv);
1093
1094         if (flq->un.fl.packen)
1095                 flq->un.fl.offset += ALIGN(lastlen, sge->csio_fl_align);
1096         else
1097                 csio_wr_inval_flq_buf(hw, flq);
1098
1099 }
1100
1101 /*
1102  * csio_is_new_iqwr - Is this a new Ingress queue entry ?
1103  * @q: Ingress quueue.
1104  * @ftr: Ingress queue WR SGE footer.
1105  *
1106  * The entry is new if our generation bit matches the corresponding
1107  * bit in the footer of the current WR.
1108  */
1109 static inline bool
1110 csio_is_new_iqwr(struct csio_q *q, struct csio_iqwr_footer *ftr)
1111 {
1112         return (q->un.iq.genbit == (ftr->u.type_gen >> IQWRF_GEN_SHIFT));
1113 }
1114
1115 /*
1116  * csio_wr_process_iq - Process elements in Ingress queue.
1117  * @hw:  HW pointer
1118  * @qidx: Index of queue
1119  * @iq_handler: Handler for this queue
1120  * @priv: Caller's private pointer
1121  *
1122  * This routine walks through every entry of the ingress queue, calling
1123  * the provided iq_handler with the entry, until the generation bit
1124  * flips.
1125  */
1126 int
1127 csio_wr_process_iq(struct csio_hw *hw, struct csio_q *q,
1128                    void (*iq_handler)(struct csio_hw *, void *,
1129                                       uint32_t, struct csio_fl_dma_buf *,
1130                                       void *),
1131                    void *priv)
1132 {
1133         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
1134         void *wr = (void *)((uintptr_t)q->vstart + (q->cidx * q->wr_sz));
1135         struct csio_iqwr_footer *ftr;
1136         uint32_t wr_type, fw_qid, qid;
1137         struct csio_q *q_completed;
1138         struct csio_q *flq = csio_iq_has_fl(q) ?
1139                                         wrm->q_arr[q->un.iq.flq_idx] : NULL;
1140         int rv = 0;
1141
1142         /* Get the footer */
1143         ftr = (struct csio_iqwr_footer *)((uintptr_t)wr +
1144                                           (q->wr_sz - sizeof(*ftr)));
1145
1146         /*
1147          * When q wrapped around last time, driver should have inverted
1148          * ic.genbit as well.
1149          */
1150         while (csio_is_new_iqwr(q, ftr)) {
1151
1152                 CSIO_DB_ASSERT(((uintptr_t)wr + q->wr_sz) <=
1153                                                 (uintptr_t)q->vwrap);
1154                 rmb();
1155                 wr_type = IQWRF_TYPE_GET(ftr->u.type_gen);
1156
1157                 switch (wr_type) {
1158                 case X_RSPD_TYPE_CPL:
1159                         /* Subtract footer from WR len */
1160                         iq_handler(hw, wr, q->wr_sz - sizeof(*ftr), NULL, priv);
1161                         break;
1162                 case X_RSPD_TYPE_FLBUF:
1163                         csio_wr_process_fl(hw, q, wr,
1164                                            ntohl(ftr->pldbuflen_qid),
1165                                            iq_handler, priv);
1166                         break;
1167                 case X_RSPD_TYPE_INTR:
1168                         fw_qid = ntohl(ftr->pldbuflen_qid);
1169                         qid = fw_qid - wrm->fw_iq_start;
1170                         q_completed = hw->wrm.intr_map[qid];
1171
1172                         if (unlikely(qid ==
1173                                         csio_q_physiqid(hw, hw->intr_iq_idx))) {
1174                                 /*
1175                                  * We are already in the Forward Interrupt
1176                                  * Interrupt Queue Service! Do-not service
1177                                  * again!
1178                                  *
1179                                  */
1180                         } else {
1181                                 CSIO_DB_ASSERT(q_completed);
1182                                 CSIO_DB_ASSERT(
1183                                         q_completed->un.iq.iq_intx_handler);
1184
1185                                 /* Call the queue handler. */
1186                                 q_completed->un.iq.iq_intx_handler(hw, NULL,
1187                                                 0, NULL, (void *)q_completed);
1188                         }
1189                         break;
1190                 default:
1191                         csio_warn(hw, "Unknown resp type 0x%x received\n",
1192                                  wr_type);
1193                         CSIO_INC_STATS(q, n_rsp_unknown);
1194                         break;
1195                 }
1196
1197                 /*
1198                  * Ingress *always* has fixed size WR entries. Therefore,
1199                  * there should always be complete WRs towards the end of
1200                  * queue.
1201                  */
1202                 if (((uintptr_t)wr + q->wr_sz) == (uintptr_t)q->vwrap) {
1203
1204                         /* Roll over to start of queue */
1205                         q->cidx = 0;
1206                         wr      = q->vstart;
1207
1208                         /* Toggle genbit */
1209                         q->un.iq.genbit ^= 0x1;
1210
1211                         CSIO_INC_STATS(q, n_qwrap);
1212                 } else {
1213                         q->cidx++;
1214                         wr      = (void *)((uintptr_t)(q->vstart) +
1215                                            (q->cidx * q->wr_sz));
1216                 }
1217
1218                 ftr = (struct csio_iqwr_footer *)((uintptr_t)wr +
1219                                                   (q->wr_sz - sizeof(*ftr)));
1220                 q->inc_idx++;
1221
1222         } /* while (q->un.iq.genbit == hdr->genbit) */
1223
1224         /*
1225          * We need to re-arm SGE interrupts in case we got a stray interrupt,
1226          * especially in msix mode. With INTx, this may be a common occurence.
1227          */
1228         if (unlikely(!q->inc_idx)) {
1229                 CSIO_INC_STATS(q, n_stray_comp);
1230                 rv = -EINVAL;
1231                 goto restart;
1232         }
1233
1234         /* Replenish free list buffers if pending falls below low water mark */
1235         if (flq) {
1236                 uint32_t avail  = csio_wr_avail_qcredits(flq);
1237                 if (avail <= 16) {
1238                         /* Make sure in FLQ, atleast 1 credit (8 FL buffers)
1239                          * remains unpopulated otherwise HW thinks
1240                          * FLQ is empty.
1241                          */
1242                         csio_wr_update_fl(hw, flq, (flq->credits - 8) - avail);
1243                         csio_wr_ring_fldb(hw, flq);
1244                 }
1245         }
1246
1247 restart:
1248         /* Now inform SGE about our incremental index value */
1249         csio_wr_reg32(hw, CIDXINC_V(q->inc_idx)         |
1250                           INGRESSQID_V(q->un.iq.physiqid)       |
1251                           TIMERREG_V(csio_sge_timer_reg),
1252                           MYPF_REG(SGE_PF_GTS_A));
1253         q->stats.n_tot_rsps += q->inc_idx;
1254
1255         q->inc_idx = 0;
1256
1257         return rv;
1258 }
1259
1260 int
1261 csio_wr_process_iq_idx(struct csio_hw *hw, int qidx,
1262                    void (*iq_handler)(struct csio_hw *, void *,
1263                                       uint32_t, struct csio_fl_dma_buf *,
1264                                       void *),
1265                    void *priv)
1266 {
1267         struct csio_wrm *wrm    = csio_hw_to_wrm(hw);
1268         struct csio_q   *iq     = wrm->q_arr[qidx];
1269
1270         return csio_wr_process_iq(hw, iq, iq_handler, priv);
1271 }
1272
1273 static int
1274 csio_closest_timer(struct csio_sge *s, int time)
1275 {
1276         int i, delta, match = 0, min_delta = INT_MAX;
1277
1278         for (i = 0; i < ARRAY_SIZE(s->timer_val); i++) {
1279                 delta = time - s->timer_val[i];
1280                 if (delta < 0)
1281                         delta = -delta;
1282                 if (delta < min_delta) {
1283                         min_delta = delta;
1284                         match = i;
1285                 }
1286         }
1287         return match;
1288 }
1289
1290 static int
1291 csio_closest_thresh(struct csio_sge *s, int cnt)
1292 {
1293         int i, delta, match = 0, min_delta = INT_MAX;
1294
1295         for (i = 0; i < ARRAY_SIZE(s->counter_val); i++) {
1296                 delta = cnt - s->counter_val[i];
1297                 if (delta < 0)
1298                         delta = -delta;
1299                 if (delta < min_delta) {
1300                         min_delta = delta;
1301                         match = i;
1302                 }
1303         }
1304         return match;
1305 }
1306
1307 static void
1308 csio_wr_fixup_host_params(struct csio_hw *hw)
1309 {
1310         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
1311         struct csio_sge *sge = &wrm->sge;
1312         uint32_t clsz = L1_CACHE_BYTES;
1313         uint32_t s_hps = PAGE_SHIFT - 10;
1314         uint32_t stat_len = clsz > 64 ? 128 : 64;
1315         u32 fl_align = clsz < 32 ? 32 : clsz;
1316         u32 pack_align;
1317         u32 ingpad, ingpack;
1318         int pcie_cap;
1319
1320         csio_wr_reg32(hw, HOSTPAGESIZEPF0_V(s_hps) | HOSTPAGESIZEPF1_V(s_hps) |
1321                       HOSTPAGESIZEPF2_V(s_hps) | HOSTPAGESIZEPF3_V(s_hps) |
1322                       HOSTPAGESIZEPF4_V(s_hps) | HOSTPAGESIZEPF5_V(s_hps) |
1323                       HOSTPAGESIZEPF6_V(s_hps) | HOSTPAGESIZEPF7_V(s_hps),
1324                       SGE_HOST_PAGE_SIZE_A);
1325
1326         /* T5 introduced the separation of the Free List Padding and
1327          * Packing Boundaries.  Thus, we can select a smaller Padding
1328          * Boundary to avoid uselessly chewing up PCIe Link and Memory
1329          * Bandwidth, and use a Packing Boundary which is large enough
1330          * to avoid false sharing between CPUs, etc.
1331          *
1332          * For the PCI Link, the smaller the Padding Boundary the
1333          * better.  For the Memory Controller, a smaller Padding
1334          * Boundary is better until we cross under the Memory Line
1335          * Size (the minimum unit of transfer to/from Memory).  If we
1336          * have a Padding Boundary which is smaller than the Memory
1337          * Line Size, that'll involve a Read-Modify-Write cycle on the
1338          * Memory Controller which is never good.
1339          */
1340
1341         /* We want the Packing Boundary to be based on the Cache Line
1342          * Size in order to help avoid False Sharing performance
1343          * issues between CPUs, etc.  We also want the Packing
1344          * Boundary to incorporate the PCI-E Maximum Payload Size.  We
1345          * get best performance when the Packing Boundary is a
1346          * multiple of the Maximum Payload Size.
1347          */
1348         pack_align = fl_align;
1349         pcie_cap = pci_find_capability(hw->pdev, PCI_CAP_ID_EXP);
1350         if (pcie_cap) {
1351                 u32 mps, mps_log;
1352                 u16 devctl;
1353
1354                 /* The PCIe Device Control Maximum Payload Size field
1355                  * [bits 7:5] encodes sizes as powers of 2 starting at
1356                  * 128 bytes.
1357                  */
1358                 pci_read_config_word(hw->pdev,
1359                                      pcie_cap + PCI_EXP_DEVCTL,
1360                                      &devctl);
1361                 mps_log = ((devctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5) + 7;
1362                 mps = 1 << mps_log;
1363                 if (mps > pack_align)
1364                         pack_align = mps;
1365         }
1366
1367         /* T5/T6 have a special interpretation of the "0"
1368          * value for the Packing Boundary.  This corresponds to 16
1369          * bytes instead of the expected 32 bytes.
1370          */
1371         if (pack_align <= 16) {
1372                 ingpack = INGPACKBOUNDARY_16B_X;
1373                 fl_align = 16;
1374         } else if (pack_align == 32) {
1375                 ingpack = INGPACKBOUNDARY_64B_X;
1376                 fl_align = 64;
1377         } else {
1378                 u32 pack_align_log = fls(pack_align) - 1;
1379
1380                 ingpack = pack_align_log - INGPACKBOUNDARY_SHIFT_X;
1381                 fl_align = pack_align;
1382         }
1383
1384         /* Use the smallest Ingress Padding which isn't smaller than
1385          * the Memory Controller Read/Write Size.  We'll take that as
1386          * being 8 bytes since we don't know of any system with a
1387          * wider Memory Controller Bus Width.
1388          */
1389         if (csio_is_t5(hw->pdev->device & CSIO_HW_CHIP_MASK))
1390                 ingpad = INGPADBOUNDARY_32B_X;
1391         else
1392                 ingpad = T6_INGPADBOUNDARY_8B_X;
1393
1394         csio_set_reg_field(hw, SGE_CONTROL_A,
1395                            INGPADBOUNDARY_V(INGPADBOUNDARY_M) |
1396                            EGRSTATUSPAGESIZE_F,
1397                            INGPADBOUNDARY_V(ingpad) |
1398                            EGRSTATUSPAGESIZE_V(stat_len != 64));
1399         csio_set_reg_field(hw, SGE_CONTROL2_A,
1400                            INGPACKBOUNDARY_V(INGPACKBOUNDARY_M),
1401                            INGPACKBOUNDARY_V(ingpack));
1402
1403         /* FL BUFFER SIZE#0 is Page size i,e already aligned to cache line */
1404         csio_wr_reg32(hw, PAGE_SIZE, SGE_FL_BUFFER_SIZE0_A);
1405
1406         /*
1407          * If using hard params, the following will get set correctly
1408          * in csio_wr_set_sge().
1409          */
1410         if (hw->flags & CSIO_HWF_USING_SOFT_PARAMS) {
1411                 csio_wr_reg32(hw,
1412                         (csio_rd_reg32(hw, SGE_FL_BUFFER_SIZE2_A) +
1413                         fl_align - 1) & ~(fl_align - 1),
1414                         SGE_FL_BUFFER_SIZE2_A);
1415                 csio_wr_reg32(hw,
1416                         (csio_rd_reg32(hw, SGE_FL_BUFFER_SIZE3_A) +
1417                         fl_align - 1) & ~(fl_align - 1),
1418                         SGE_FL_BUFFER_SIZE3_A);
1419         }
1420
1421         sge->csio_fl_align = fl_align;
1422
1423         csio_wr_reg32(hw, HPZ0_V(PAGE_SHIFT - 12), ULP_RX_TDDP_PSZ_A);
1424
1425         /* default value of rx_dma_offset of the NIC driver */
1426         csio_set_reg_field(hw, SGE_CONTROL_A,
1427                            PKTSHIFT_V(PKTSHIFT_M),
1428                            PKTSHIFT_V(CSIO_SGE_RX_DMA_OFFSET));
1429
1430         csio_hw_tp_wr_bits_indirect(hw, TP_INGRESS_CONFIG_A,
1431                                     CSUM_HAS_PSEUDO_HDR_F, 0);
1432 }
1433
1434 static void
1435 csio_init_intr_coalesce_parms(struct csio_hw *hw)
1436 {
1437         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
1438         struct csio_sge *sge = &wrm->sge;
1439
1440         csio_sge_thresh_reg = csio_closest_thresh(sge, csio_intr_coalesce_cnt);
1441         if (csio_intr_coalesce_cnt) {
1442                 csio_sge_thresh_reg = 0;
1443                 csio_sge_timer_reg = X_TIMERREG_RESTART_COUNTER;
1444                 return;
1445         }
1446
1447         csio_sge_timer_reg = csio_closest_timer(sge, csio_intr_coalesce_time);
1448 }
1449
1450 /*
1451  * csio_wr_get_sge - Get SGE register values.
1452  * @hw: HW module.
1453  *
1454  * Used by non-master functions and by master-functions relying on config file.
1455  */
1456 static void
1457 csio_wr_get_sge(struct csio_hw *hw)
1458 {
1459         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
1460         struct csio_sge *sge = &wrm->sge;
1461         uint32_t ingpad;
1462         int i;
1463         u32 timer_value_0_and_1, timer_value_2_and_3, timer_value_4_and_5;
1464         u32 ingress_rx_threshold;
1465
1466         sge->sge_control = csio_rd_reg32(hw, SGE_CONTROL_A);
1467
1468         ingpad = INGPADBOUNDARY_G(sge->sge_control);
1469
1470         switch (ingpad) {
1471         case X_INGPCIEBOUNDARY_32B:
1472                 sge->csio_fl_align = 32; break;
1473         case X_INGPCIEBOUNDARY_64B:
1474                 sge->csio_fl_align = 64; break;
1475         case X_INGPCIEBOUNDARY_128B:
1476                 sge->csio_fl_align = 128; break;
1477         case X_INGPCIEBOUNDARY_256B:
1478                 sge->csio_fl_align = 256; break;
1479         case X_INGPCIEBOUNDARY_512B:
1480                 sge->csio_fl_align = 512; break;
1481         case X_INGPCIEBOUNDARY_1024B:
1482                 sge->csio_fl_align = 1024; break;
1483         case X_INGPCIEBOUNDARY_2048B:
1484                 sge->csio_fl_align = 2048; break;
1485         case X_INGPCIEBOUNDARY_4096B:
1486                 sge->csio_fl_align = 4096; break;
1487         }
1488
1489         for (i = 0; i < CSIO_SGE_FL_SIZE_REGS; i++)
1490                 csio_get_flbuf_size(hw, sge, i);
1491
1492         timer_value_0_and_1 = csio_rd_reg32(hw, SGE_TIMER_VALUE_0_AND_1_A);
1493         timer_value_2_and_3 = csio_rd_reg32(hw, SGE_TIMER_VALUE_2_AND_3_A);
1494         timer_value_4_and_5 = csio_rd_reg32(hw, SGE_TIMER_VALUE_4_AND_5_A);
1495
1496         sge->timer_val[0] = (uint16_t)csio_core_ticks_to_us(hw,
1497                                         TIMERVALUE0_G(timer_value_0_and_1));
1498         sge->timer_val[1] = (uint16_t)csio_core_ticks_to_us(hw,
1499                                         TIMERVALUE1_G(timer_value_0_and_1));
1500         sge->timer_val[2] = (uint16_t)csio_core_ticks_to_us(hw,
1501                                         TIMERVALUE2_G(timer_value_2_and_3));
1502         sge->timer_val[3] = (uint16_t)csio_core_ticks_to_us(hw,
1503                                         TIMERVALUE3_G(timer_value_2_and_3));
1504         sge->timer_val[4] = (uint16_t)csio_core_ticks_to_us(hw,
1505                                         TIMERVALUE4_G(timer_value_4_and_5));
1506         sge->timer_val[5] = (uint16_t)csio_core_ticks_to_us(hw,
1507                                         TIMERVALUE5_G(timer_value_4_and_5));
1508
1509         ingress_rx_threshold = csio_rd_reg32(hw, SGE_INGRESS_RX_THRESHOLD_A);
1510         sge->counter_val[0] = THRESHOLD_0_G(ingress_rx_threshold);
1511         sge->counter_val[1] = THRESHOLD_1_G(ingress_rx_threshold);
1512         sge->counter_val[2] = THRESHOLD_2_G(ingress_rx_threshold);
1513         sge->counter_val[3] = THRESHOLD_3_G(ingress_rx_threshold);
1514
1515         csio_init_intr_coalesce_parms(hw);
1516 }
1517
1518 /*
1519  * csio_wr_set_sge - Initialize SGE registers
1520  * @hw: HW module.
1521  *
1522  * Used by Master function to initialize SGE registers in the absence
1523  * of a config file.
1524  */
1525 static void
1526 csio_wr_set_sge(struct csio_hw *hw)
1527 {
1528         struct csio_wrm *wrm = csio_hw_to_wrm(hw);
1529         struct csio_sge *sge = &wrm->sge;
1530         int i;
1531
1532         /*
1533          * Set up our basic SGE mode to deliver CPL messages to our Ingress
1534          * Queue and Packet Date to the Free List.
1535          */
1536         csio_set_reg_field(hw, SGE_CONTROL_A, RXPKTCPLMODE_F, RXPKTCPLMODE_F);
1537
1538         sge->sge_control = csio_rd_reg32(hw, SGE_CONTROL_A);
1539
1540         /* sge->csio_fl_align is set up by csio_wr_fixup_host_params(). */
1541
1542         /*
1543          * Set up to drop DOORBELL writes when the DOORBELL FIFO overflows
1544          * and generate an interrupt when this occurs so we can recover.
1545          */
1546         csio_set_reg_field(hw, SGE_DBFIFO_STATUS_A,
1547                            LP_INT_THRESH_T5_V(LP_INT_THRESH_T5_M),
1548                            LP_INT_THRESH_T5_V(CSIO_SGE_DBFIFO_INT_THRESH));
1549         csio_set_reg_field(hw, SGE_DBFIFO_STATUS2_A,
1550                            HP_INT_THRESH_T5_V(LP_INT_THRESH_T5_M),
1551                            HP_INT_THRESH_T5_V(CSIO_SGE_DBFIFO_INT_THRESH));
1552
1553         csio_set_reg_field(hw, SGE_DOORBELL_CONTROL_A, ENABLE_DROP_F,
1554                            ENABLE_DROP_F);
1555
1556         /* SGE_FL_BUFFER_SIZE0 is set up by csio_wr_fixup_host_params(). */
1557
1558         CSIO_SET_FLBUF_SIZE(hw, 1, CSIO_SGE_FLBUF_SIZE1);
1559         csio_wr_reg32(hw, (CSIO_SGE_FLBUF_SIZE2 + sge->csio_fl_align - 1)
1560                       & ~(sge->csio_fl_align - 1), SGE_FL_BUFFER_SIZE2_A);
1561         csio_wr_reg32(hw, (CSIO_SGE_FLBUF_SIZE3 + sge->csio_fl_align - 1)
1562                       & ~(sge->csio_fl_align - 1), SGE_FL_BUFFER_SIZE3_A);
1563         CSIO_SET_FLBUF_SIZE(hw, 4, CSIO_SGE_FLBUF_SIZE4);
1564         CSIO_SET_FLBUF_SIZE(hw, 5, CSIO_SGE_FLBUF_SIZE5);
1565         CSIO_SET_FLBUF_SIZE(hw, 6, CSIO_SGE_FLBUF_SIZE6);
1566         CSIO_SET_FLBUF_SIZE(hw, 7, CSIO_SGE_FLBUF_SIZE7);
1567         CSIO_SET_FLBUF_SIZE(hw, 8, CSIO_SGE_FLBUF_SIZE8);
1568
1569         for (i = 0; i < CSIO_SGE_FL_SIZE_REGS; i++)
1570                 csio_get_flbuf_size(hw, sge, i);
1571
1572         /* Initialize interrupt coalescing attributes */
1573         sge->timer_val[0] = CSIO_SGE_TIMER_VAL_0;
1574         sge->timer_val[1] = CSIO_SGE_TIMER_VAL_1;
1575         sge->timer_val[2] = CSIO_SGE_TIMER_VAL_2;
1576         sge->timer_val[3] = CSIO_SGE_TIMER_VAL_3;
1577         sge->timer_val[4] = CSIO_SGE_TIMER_VAL_4;
1578         sge->timer_val[5] = CSIO_SGE_TIMER_VAL_5;
1579
1580         sge->counter_val[0] = CSIO_SGE_INT_CNT_VAL_0;
1581         sge->counter_val[1] = CSIO_SGE_INT_CNT_VAL_1;
1582         sge->counter_val[2] = CSIO_SGE_INT_CNT_VAL_2;
1583         sge->counter_val[3] = CSIO_SGE_INT_CNT_VAL_3;
1584
1585         csio_wr_reg32(hw, THRESHOLD_0_V(sge->counter_val[0]) |
1586                       THRESHOLD_1_V(sge->counter_val[1]) |
1587                       THRESHOLD_2_V(sge->counter_val[2]) |
1588                       THRESHOLD_3_V(sge->counter_val[3]),
1589                       SGE_INGRESS_RX_THRESHOLD_A);
1590
1591         csio_wr_reg32(hw,
1592                    TIMERVALUE0_V(csio_us_to_core_ticks(hw, sge->timer_val[0])) |
1593                    TIMERVALUE1_V(csio_us_to_core_ticks(hw, sge->timer_val[1])),
1594                    SGE_TIMER_VALUE_0_AND_1_A);
1595
1596         csio_wr_reg32(hw,
1597                    TIMERVALUE2_V(csio_us_to_core_ticks(hw, sge->timer_val[2])) |
1598                    TIMERVALUE3_V(csio_us_to_core_ticks(hw, sge->timer_val[3])),
1599                    SGE_TIMER_VALUE_2_AND_3_A);
1600
1601         csio_wr_reg32(hw,
1602                    TIMERVALUE4_V(csio_us_to_core_ticks(hw, sge->timer_val[4])) |
1603                    TIMERVALUE5_V(csio_us_to_core_ticks(hw, sge->timer_val[5])),
1604                    SGE_TIMER_VALUE_4_AND_5_A);
1605
1606         csio_init_intr_coalesce_parms(hw);
1607 }
1608
1609 void
1610 csio_wr_sge_init(struct csio_hw *hw)
1611 {
1612         /*
1613          * If we are master and chip is not initialized:
1614          *    - If we plan to use the config file, we need to fixup some
1615          *      host specific registers, and read the rest of the SGE
1616          *      configuration.
1617          *    - If we dont plan to use the config file, we need to initialize
1618          *      SGE entirely, including fixing the host specific registers.
1619          * If we are master and chip is initialized, just read and work off of
1620          *      the already initialized SGE values.
1621          * If we arent the master, we are only allowed to read and work off of
1622          *      the already initialized SGE values.
1623          *
1624          * Therefore, before calling this function, we assume that the master-
1625          * ship of the card, state and whether to use config file or not, have
1626          * already been decided.
1627          */
1628         if (csio_is_hw_master(hw)) {
1629                 if (hw->fw_state != CSIO_DEV_STATE_INIT)
1630                         csio_wr_fixup_host_params(hw);
1631
1632                 if (hw->flags & CSIO_HWF_USING_SOFT_PARAMS)
1633                         csio_wr_get_sge(hw);
1634                 else
1635                         csio_wr_set_sge(hw);
1636         } else
1637                 csio_wr_get_sge(hw);
1638 }
1639
1640 /*
1641  * csio_wrm_init - Initialize Work request module.
1642  * @wrm: WR module
1643  * @hw: HW pointer
1644  *
1645  * Allocates memory for an array of queue pointers starting at q_arr.
1646  */
1647 int
1648 csio_wrm_init(struct csio_wrm *wrm, struct csio_hw *hw)
1649 {
1650         int i;
1651
1652         if (!wrm->num_q) {
1653                 csio_err(hw, "Num queues is not set\n");
1654                 return -EINVAL;
1655         }
1656
1657         wrm->q_arr = kcalloc(wrm->num_q, sizeof(struct csio_q *), GFP_KERNEL);
1658         if (!wrm->q_arr)
1659                 goto err;
1660
1661         for (i = 0; i < wrm->num_q; i++) {
1662                 wrm->q_arr[i] = kzalloc(sizeof(struct csio_q), GFP_KERNEL);
1663                 if (!wrm->q_arr[i]) {
1664                         while (--i >= 0)
1665                                 kfree(wrm->q_arr[i]);
1666                         goto err_free_arr;
1667                 }
1668         }
1669         wrm->free_qidx  = 0;
1670
1671         return 0;
1672
1673 err_free_arr:
1674         kfree(wrm->q_arr);
1675 err:
1676         return -ENOMEM;
1677 }
1678
1679 /*
1680  * csio_wrm_exit - Initialize Work request module.
1681  * @wrm: WR module
1682  * @hw: HW module
1683  *
1684  * Uninitialize WR module. Free q_arr and pointers in it.
1685  * We have the additional job of freeing the DMA memory associated
1686  * with the queues.
1687  */
1688 void
1689 csio_wrm_exit(struct csio_wrm *wrm, struct csio_hw *hw)
1690 {
1691         int i;
1692         uint32_t j;
1693         struct csio_q *q;
1694         struct csio_dma_buf *buf;
1695
1696         for (i = 0; i < wrm->num_q; i++) {
1697                 q = wrm->q_arr[i];
1698
1699                 if (wrm->free_qidx && (i < wrm->free_qidx)) {
1700                         if (q->type == CSIO_FREELIST) {
1701                                 if (!q->un.fl.bufs)
1702                                         continue;
1703                                 for (j = 0; j < q->credits; j++) {
1704                                         buf = &q->un.fl.bufs[j];
1705                                         if (!buf->vaddr)
1706                                                 continue;
1707                                         dma_free_coherent(&hw->pdev->dev,
1708                                                         buf->len, buf->vaddr,
1709                                                         buf->paddr);
1710                                 }
1711                                 kfree(q->un.fl.bufs);
1712                         }
1713                         dma_free_coherent(&hw->pdev->dev, q->size,
1714                                         q->vstart, q->pstart);
1715                 }
1716                 kfree(q);
1717         }
1718
1719         hw->flags &= ~CSIO_HWF_Q_MEM_ALLOCED;
1720
1721         kfree(wrm->q_arr);
1722 }