scsi: lpfc: Expand WQE capability of every NVME hardware queue

Hardware queues are a fast staging area to push commands into the
adapter.  The adapter should drain them extremely quickly. However,
under heavy io load, the host cpu is pushing commands faster than the
drain rate of the adapter causing the driver to resource busy commands.

Enlarge the hardware queue (wq & cq) to support a larger number of queue
entries (4x the prior size) before backpressure. Enlarging the queue
requires larger contiguous buffers (16k) per logical page for the
hardware. This changed calling sequences that were expecting 4K page
sizes that now must pass a parameter with the page sizes. It also
required use of a new version of an adapter command that can vary the
page size values.

Signed-off-by: Dick Kennedy <dick.kennedy@broadcom.com>
Signed-off-by: James Smart <james.smart@broadcom.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 2b145966c73f4fe92fa4d3ff35a41f9932ff387b..73c2f6971d2b41a6abc67cae112dbf2b1a3a4ad8 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -1122,6 +1122,7 @@ struct cq_context {
 #define LPFC_CQ_CNT_256                0x0
 #define LPFC_CQ_CNT_512                0x1
 #define LPFC_CQ_CNT_1024       0x2
+#define LPFC_CQ_CNT_WORD7      0x3
        uint32_t word1;
 #define lpfc_cq_eq_id_SHIFT            22      /* Version 0 Only */
 #define lpfc_cq_eq_id_MASK             0x000000FF
@@ -1129,7 +1130,7 @@ struct cq_context {
 #define lpfc_cq_eq_id_2_SHIFT          0       /* Version 2 Only */
 #define lpfc_cq_eq_id_2_MASK           0x0000FFFF
 #define lpfc_cq_eq_id_2_WORD           word1
-       uint32_t reserved0;
+       uint32_t lpfc_cq_context_count;         /* Version 2 Only */
        uint32_t reserved1;
 };
 
@@ -1193,6 +1194,9 @@ struct lpfc_mbx_cq_create_set {
 #define lpfc_mbx_cq_create_set_arm_SHIFT       31
 #define lpfc_mbx_cq_create_set_arm_MASK                0x00000001
 #define lpfc_mbx_cq_create_set_arm_WORD                word2
+#define lpfc_mbx_cq_create_set_cq_cnt_SHIFT    16
+#define lpfc_mbx_cq_create_set_cq_cnt_MASK     0x00007FFF
+#define lpfc_mbx_cq_create_set_cq_cnt_WORD     word2
 #define lpfc_mbx_cq_create_set_num_cq_SHIFT    0
 #define lpfc_mbx_cq_create_set_num_cq_MASK     0x0000FFFF
 #define lpfc_mbx_cq_create_set_num_cq_WORD     word2

diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 2b7ea7e53e12fbaeb9824439c533b311f1cfc9fb..e98fea93e518c5513366ea041a4c9b7e1ecf8f8c 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -7958,10 +7958,10 @@ static int
 lpfc_alloc_nvme_wq_cq(struct lpfc_hba *phba, int wqidx)
 {
        struct lpfc_queue *qdesc;
-       int cnt;
 
-       qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
-                                           phba->sli4_hba.cq_ecount);
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_NVME_PAGE_SIZE,
+                                     phba->sli4_hba.cq_esize,
+                                     LPFC_NVME_CQSIZE);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                "0508 Failed allocate fast-path NVME CQ (%d)\n",
@@ -7970,8 +7970,8 @@ lpfc_alloc_nvme_wq_cq(struct lpfc_hba *phba, int wqidx)
        }
        phba->sli4_hba.nvme_cq[wqidx] = qdesc;
 
-       cnt = LPFC_NVME_WQSIZE;
-       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_WQE128_SIZE, cnt);
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_NVME_PAGE_SIZE,
+                                     LPFC_WQE128_SIZE, LPFC_NVME_WQSIZE);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                "0509 Failed allocate fast-path NVME WQ (%d)\n",
@@ -7990,8 +7990,9 @@ lpfc_alloc_fcp_wq_cq(struct lpfc_hba *phba, int wqidx)
        uint32_t wqesize;
 
        /* Create Fast Path FCP CQs */
-       qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
-                                       phba->sli4_hba.cq_ecount);
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                     phba->sli4_hba.cq_esize,
+                                     phba->sli4_hba.cq_ecount);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                        "0499 Failed allocate fast-path FCP CQ (%d)\n", wqidx);
@@ -8002,7 +8003,8 @@ lpfc_alloc_fcp_wq_cq(struct lpfc_hba *phba, int wqidx)
        /* Create Fast Path FCP WQs */
        wqesize = (phba->fcp_embed_io) ?
                LPFC_WQE128_SIZE : phba->sli4_hba.wq_esize;
-       qdesc = lpfc_sli4_queue_alloc(phba, wqesize, phba->sli4_hba.wq_ecount);
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                     wqesize, phba->sli4_hba.wq_ecount);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                "0503 Failed allocate fast-path FCP WQ (%d)\n",
@@ -8173,7 +8175,8 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
        /* Create HBA Event Queues (EQs) */
        for (idx = 0; idx < io_channel; idx++) {
                /* Create EQs */
-               qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize,
+               qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                             phba->sli4_hba.eq_esize,
                                              phba->sli4_hba.eq_ecount);
                if (!qdesc) {
                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8196,8 +8199,9 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
        if (phba->nvmet_support) {
                for (idx = 0; idx < phba->cfg_nvmet_mrq; idx++) {
                        qdesc = lpfc_sli4_queue_alloc(phba,
-                                       phba->sli4_hba.cq_esize,
-                                       phba->sli4_hba.cq_ecount);
+                                                     LPFC_DEFAULT_PAGE_SIZE,
+                                                     phba->sli4_hba.cq_esize,
+                                                     phba->sli4_hba.cq_ecount);
                        if (!qdesc) {
                                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                        "3142 Failed allocate NVME "
@@ -8213,7 +8217,8 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
         */
 
        /* Create slow-path Mailbox Command Complete Queue */
-       qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                     phba->sli4_hba.cq_esize,
                                      phba->sli4_hba.cq_ecount);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8223,7 +8228,8 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
        phba->sli4_hba.mbx_cq = qdesc;
 
        /* Create slow-path ELS Complete Queue */
-       qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                     phba->sli4_hba.cq_esize,
                                      phba->sli4_hba.cq_ecount);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8239,7 +8245,8 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
 
        /* Create Mailbox Command Queue */
 
-       qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.mq_esize,
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                     phba->sli4_hba.mq_esize,
                                      phba->sli4_hba.mq_ecount);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8253,7 +8260,8 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
         */
 
        /* Create slow-path ELS Work Queue */
-       qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                     phba->sli4_hba.wq_esize,
                                      phba->sli4_hba.wq_ecount);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8265,7 +8273,8 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
 
        if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
                /* Create NVME LS Complete Queue */
-               qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
+               qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                             phba->sli4_hba.cq_esize,
                                              phba->sli4_hba.cq_ecount);
                if (!qdesc) {
                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8275,7 +8284,8 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
                phba->sli4_hba.nvmels_cq = qdesc;
 
                /* Create NVME LS Work Queue */
-               qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.wq_esize,
+               qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                             phba->sli4_hba.wq_esize,
                                              phba->sli4_hba.wq_ecount);
                if (!qdesc) {
                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8291,7 +8301,8 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
         */
 
        /* Create Receive Queue for header */
-       qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                     phba->sli4_hba.rq_esize,
                                      phba->sli4_hba.rq_ecount);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8301,7 +8312,8 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
        phba->sli4_hba.hdr_rq = qdesc;
 
        /* Create Receive Queue for data */
-       qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.rq_esize,
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                     phba->sli4_hba.rq_esize,
                                      phba->sli4_hba.rq_ecount);
        if (!qdesc) {
                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8314,6 +8326,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
                for (idx = 0; idx < phba->cfg_nvmet_mrq; idx++) {
                        /* Create NVMET Receive Queue for header */
                        qdesc = lpfc_sli4_queue_alloc(phba,
+                                                     LPFC_DEFAULT_PAGE_SIZE,
                                                      phba->sli4_hba.rq_esize,
                                                      LPFC_NVMET_RQE_DEF_COUNT);
                        if (!qdesc) {
@@ -8339,6 +8352,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
 
                        /* Create NVMET Receive Queue for data */
                        qdesc = lpfc_sli4_queue_alloc(phba,
+                                                     LPFC_DEFAULT_PAGE_SIZE,
                                                      phba->sli4_hba.rq_esize,
                                                      LPFC_NVMET_RQE_DEF_COUNT);
                        if (!qdesc) {
@@ -8514,6 +8528,7 @@ lpfc_create_wq_cq(struct lpfc_hba *phba, struct lpfc_queue *eq,
                        qidx, (uint32_t)rc);
                return rc;
        }
+       cq->chann = qidx;
 
        if (qtype != LPFC_MBOX) {
                /* Setup nvme_cq_map for fast lookup */
@@ -8533,6 +8548,7 @@ lpfc_create_wq_cq(struct lpfc_hba *phba, struct lpfc_queue *eq,
                        /* no need to tear down cq - caller will do so */
                        return rc;
                }
+               wq->chann = qidx;
 
                /* Bind this CQ/WQ to the NVME ring */
                pring = wq->pring;
@@ -8773,6 +8789,8 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba)
                                                "rc = 0x%x\n", (uint32_t)rc);
                                goto out_destroy;
                        }
+                       phba->sli4_hba.nvmet_cqset[0]->chann = 0;
+
                        lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
                                        "6090 NVMET CQ setup: cq-id=%d, "
                                        "parent eq-id=%d\n",
@@ -12141,7 +12159,8 @@ lpfc_fof_queue_create(struct lpfc_hba *phba)
        uint32_t wqesize;
 
        /* Create FOF EQ */
-       qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.eq_esize,
+       qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                     phba->sli4_hba.eq_esize,
                                      phba->sli4_hba.eq_ecount);
        if (!qdesc)
                goto out_error;
@@ -12151,8 +12170,9 @@ lpfc_fof_queue_create(struct lpfc_hba *phba)
        if (phba->cfg_fof) {
 
                /* Create OAS CQ */
-               qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
-                                                     phba->sli4_hba.cq_ecount);
+               qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                             phba->sli4_hba.cq_esize,
+                                             phba->sli4_hba.cq_ecount);
                if (!qdesc)
                        goto out_error;
 
@@ -12161,7 +12181,8 @@ lpfc_fof_queue_create(struct lpfc_hba *phba)
                /* Create OAS WQ */
                wqesize = (phba->fcp_embed_io) ?
                                LPFC_WQE128_SIZE : phba->sli4_hba.wq_esize;
-               qdesc = lpfc_sli4_queue_alloc(phba, wqesize,
+               qdesc = lpfc_sli4_queue_alloc(phba, LPFC_DEFAULT_PAGE_SIZE,
+                                             wqesize,
                                              phba->sli4_hba.wq_ecount);
 
                if (!qdesc)

diff --git a/drivers/scsi/lpfc/lpfc_nvme.h b/drivers/scsi/lpfc/lpfc_nvme.h
index d192bb268f998eea1183988cca48ced15b07eec8..fbfc1786cd04893f61987de55400b31c6402b331 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_nvme.h
+++ b/drivers/scsi/lpfc/lpfc_nvme.h
@@ -22,7 +22,8 @@
  ********************************************************************/
 
 #define LPFC_NVME_DEFAULT_SEGS         (64 + 1)        /* 256K IOs */
-#define LPFC_NVME_WQSIZE               256
+#define LPFC_NVME_WQSIZE               1024
+#define LPFC_NVME_CQSIZE               4096
 
 #define LPFC_NVME_ERSP_LEN             0x20
 

diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index aecd2399005d1ed57b87ea78eb7946147d96b137..ddc23428498004a3846847dd4c6064e99743fcb1 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -13919,7 +13919,7 @@ lpfc_sli4_queue_free(struct lpfc_queue *queue)
        while (!list_empty(&queue->page_list)) {
                list_remove_head(&queue->page_list, dmabuf, struct lpfc_dmabuf,
                                 list);
-               dma_free_coherent(&queue->phba->pcidev->dev, SLI4_PAGE_SIZE,
+               dma_free_coherent(&queue->phba->pcidev->dev, queue->page_size,
                                  dmabuf->virt, dmabuf->phys);
                kfree(dmabuf);
        }
@@ -13938,6 +13938,7 @@ lpfc_sli4_queue_free(struct lpfc_queue *queue)
 /**
  * lpfc_sli4_queue_alloc - Allocate and initialize a queue structure
  * @phba: The HBA that this queue is being created on.
+ * @page_size: The size of a queue page
  * @entry_size: The size of each queue entry for this queue.
  * @entry count: The number of entries that this queue will handle.
  *
@@ -13946,8 +13947,8 @@ lpfc_sli4_queue_free(struct lpfc_queue *queue)
  * queue on the HBA.
  **/
 struct lpfc_queue *
-lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t entry_size,
-                     uint32_t entry_count)
+lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t page_size,
+                     uint32_t entry_size, uint32_t entry_count)
 {
        struct lpfc_queue *queue;
        struct lpfc_dmabuf *dmabuf;
@@ -13956,7 +13957,7 @@ lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t entry_size,
        uint32_t hw_page_size = phba->sli4_hba.pc_sli4_params.if_page_sz;
 
        if (!phba->sli4_hba.pc_sli4_params.supported)
-               hw_page_size = SLI4_PAGE_SIZE;
+               hw_page_size = page_size;
 
        queue = kzalloc(sizeof(struct lpfc_queue) +
                        (sizeof(union sli4_qe) * entry_count), GFP_KERNEL);
@@ -13973,6 +13974,15 @@ lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t entry_size,
        INIT_LIST_HEAD(&queue->wq_list);
        INIT_LIST_HEAD(&queue->page_list);
        INIT_LIST_HEAD(&queue->child_list);
+
+       /* Set queue parameters now.  If the system cannot provide memory
+        * resources, the free routine needs to know what was allocated.
+        */
+       queue->entry_size = entry_size;
+       queue->entry_count = entry_count;
+       queue->page_size = hw_page_size;
+       queue->phba = phba;
+
        for (x = 0, total_qe_count = 0; x < queue->page_count; x++) {
                dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
                if (!dmabuf)
@@ -13994,9 +14004,6 @@ lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t entry_size,
                        queue->qe[total_qe_count].address = dma_pointer;
                }
        }
-       queue->entry_size = entry_size;
-       queue->entry_count = entry_count;
-       queue->phba = phba;
        INIT_WORK(&queue->irqwork, lpfc_sli4_hba_process_cq);
        INIT_WORK(&queue->spwork, lpfc_sli4_sp_process_cq);
 
@@ -14299,7 +14306,7 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
        if (!cq || !eq)
                return -ENODEV;
        if (!phba->sli4_hba.pc_sli4_params.supported)
-               hw_page_size = SLI4_PAGE_SIZE;
+               hw_page_size = cq->page_size;
 
        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
        if (!mbox)
@@ -14318,8 +14325,8 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
        bf_set(lpfc_mbox_hdr_version, &shdr->request,
               phba->sli4_hba.pc_sli4_params.cqv);
        if (phba->sli4_hba.pc_sli4_params.cqv == LPFC_Q_CREATE_VERSION_2) {
-               /* FW only supports 1. Should be PAGE_SIZE/SLI4_PAGE_SIZE */
-               bf_set(lpfc_mbx_cq_create_page_size, &cq_create->u.request, 1);
+               bf_set(lpfc_mbx_cq_create_page_size, &cq_create->u.request,
+                      (cq->page_size / SLI4_PAGE_SIZE));
                bf_set(lpfc_cq_eq_id_2, &cq_create->u.request.context,
                       eq->queue_id);
        } else {
@@ -14327,6 +14334,18 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
                       eq->queue_id);
        }
        switch (cq->entry_count) {
+       case 2048:
+       case 4096:
+               if (phba->sli4_hba.pc_sli4_params.cqv ==
+                   LPFC_Q_CREATE_VERSION_2) {
+                       cq_create->u.request.context.lpfc_cq_context_count =
+                               cq->entry_count;
+                       bf_set(lpfc_cq_context_count,
+                              &cq_create->u.request.context,
+                              LPFC_CQ_CNT_WORD7);
+                       break;
+               }
+               /* Fall Thru */
        default:
                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                "0361 Unsupported CQ count: "
@@ -14352,7 +14371,7 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
                break;
        }
        list_for_each_entry(dmabuf, &cq->page_list, list) {
-               memset(dmabuf->virt, 0, hw_page_size);
+               memset(dmabuf->virt, 0, cq->page_size);
                cq_create->u.request.page[dmabuf->buffer_tag].addr_lo =
                                        putPaddrLow(dmabuf->phys);
                cq_create->u.request.page[dmabuf->buffer_tag].addr_hi =
@@ -14433,8 +14452,6 @@ lpfc_cq_create_set(struct lpfc_hba *phba, struct lpfc_queue **cqp,
        numcq = phba->cfg_nvmet_mrq;
        if (!cqp || !eqp || !numcq)
                return -ENODEV;
-       if (!phba->sli4_hba.pc_sli4_params.supported)
-               hw_page_size = SLI4_PAGE_SIZE;
 
        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
        if (!mbox)
@@ -14465,6 +14482,8 @@ lpfc_cq_create_set(struct lpfc_hba *phba, struct lpfc_queue **cqp,
                        status = -ENOMEM;
                        goto out;
                }
+               if (!phba->sli4_hba.pc_sli4_params.supported)
+                       hw_page_size = cq->page_size;
 
                switch (idx) {
                case 0:
@@ -14482,6 +14501,19 @@ lpfc_cq_create_set(struct lpfc_hba *phba, struct lpfc_queue **cqp,
                        bf_set(lpfc_mbx_cq_create_set_num_cq,
                               &cq_set->u.request, numcq);
                        switch (cq->entry_count) {
+                       case 2048:
+                       case 4096:
+                               if (phba->sli4_hba.pc_sli4_params.cqv ==
+                                   LPFC_Q_CREATE_VERSION_2) {
+                                       bf_set(lpfc_mbx_cq_create_set_cqe_cnt,
+                                              &cq_set->u.request,
+                                               cq->entry_count);
+                                       bf_set(lpfc_mbx_cq_create_set_cqe_cnt,
+                                              &cq_set->u.request,
+                                              LPFC_CQ_CNT_WORD7);
+                                       break;
+                               }
+                               /* Fall Thru */
                        default:
                                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                                "3118 Bad CQ count. (%d)\n",
@@ -14578,6 +14610,7 @@ lpfc_cq_create_set(struct lpfc_hba *phba, struct lpfc_queue **cqp,
                cq->host_index = 0;
                cq->hba_index = 0;
                cq->entry_repost = LPFC_CQ_REPOST;
+               cq->chann = idx;
 
                rc = 0;
                list_for_each_entry(dmabuf, &cq->page_list, list) {
@@ -14872,12 +14905,13 @@ lpfc_wq_create(struct lpfc_hba *phba, struct lpfc_queue *wq,
        void __iomem *bar_memmap_p;
        uint32_t db_offset;
        uint16_t pci_barset;
+       uint8_t wq_create_version;
 
        /* sanity check on queue memory */
        if (!wq || !cq)
                return -ENODEV;
        if (!phba->sli4_hba.pc_sli4_params.supported)
-               hw_page_size = SLI4_PAGE_SIZE;
+               hw_page_size = wq->page_size;
 
        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
        if (!mbox)
@@ -14898,7 +14932,12 @@ lpfc_wq_create(struct lpfc_hba *phba, struct lpfc_queue *wq,
        bf_set(lpfc_mbox_hdr_version, &shdr->request,
               phba->sli4_hba.pc_sli4_params.wqv);
 
-       switch (phba->sli4_hba.pc_sli4_params.wqv) {
+       if (phba->sli4_hba.pc_sli4_params.wqsize & LPFC_WQ_SZ128_SUPPORT)
+               wq_create_version = LPFC_Q_CREATE_VERSION_1;
+       else
+               wq_create_version = LPFC_Q_CREATE_VERSION_0;
+
+       switch (wq_create_version) {
        case LPFC_Q_CREATE_VERSION_0:
                switch (wq->entry_size) {
                default:
@@ -14956,7 +14995,7 @@ lpfc_wq_create(struct lpfc_hba *phba, struct lpfc_queue *wq,
                }
                bf_set(lpfc_mbx_wq_create_page_size,
                       &wq_create->u.request_1,
-                      LPFC_WQ_PAGE_SIZE_4096);
+                      (wq->page_size / SLI4_PAGE_SIZE));
                page = wq_create->u.request_1.page;
                break;
        default:

diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index 13b8f4d4da34da4c119ed599a34e7d3dae2cc39c..301ce46d2d70df1a8a568be7cf818202bc66046e 100644 (file)
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -161,7 +161,6 @@ struct lpfc_queue {
 #define LPFC_RELEASE_NOTIFICATION_INTERVAL     32  /* For WQs */
        uint32_t queue_id;      /* Queue ID assigned by the hardware */
        uint32_t assoc_qid;     /* Queue ID associated with, for CQ/WQ/MQ */
-       uint32_t page_count;    /* Number of pages allocated for this queue */
        uint32_t host_index;    /* The host's index for putting or getting */
        uint32_t hba_index;     /* The last known hba index for get or put */
 
@@ -169,6 +168,11 @@ struct lpfc_queue {
        struct lpfc_rqb *rqbp;  /* ptr to RQ buffers */
 
        uint32_t q_mode;
+       uint16_t page_count;    /* Number of pages allocated for this queue */
+       uint16_t page_size;     /* size of page allocated for this queue */
+#define LPFC_NVME_PAGE_SIZE    16384
+#define LPFC_DEFAULT_PAGE_SIZE 4096
+       uint16_t chann;         /* IO channel this queue is associated with */
        uint16_t db_format;
 #define LPFC_DB_RING_FORMAT    0x01
 #define LPFC_DB_LIST_FORMAT    0x02
@@ -769,7 +773,7 @@ int lpfc_sli4_mbx_read_fcf_rec(struct lpfc_hba *, struct lpfcMboxq *,
 
 void lpfc_sli4_hba_reset(struct lpfc_hba *);
 struct lpfc_queue *lpfc_sli4_queue_alloc(struct lpfc_hba *, uint32_t,
-                       uint32_t);
+                                        uint32_t, uint32_t);
 void lpfc_sli4_queue_free(struct lpfc_queue *);
 int lpfc_eq_create(struct lpfc_hba *, struct lpfc_queue *, uint32_t);
 int lpfc_modify_hba_eq_delay(struct lpfc_hba *phba, uint32_t startq,