scsi: mpi3mr: Support for Segmented Hardware Trace buffer

Allocate segmented trace buffer if firmware advertises the capability in
IOCfacts.

Upon driver load, read the trace buffer size from driver page 1, calculate
the required segments for trace buffer, and allocate segmented buffers.
Each segment is 4096 bytes in size.

While posting driver diagnostic buffer to firmware, advertise that trace
buffer is segmented.

Signed-off-by: Sumit Saxena <sumit.saxena@broadcom.com>
Signed-off-by: Ranjan Kumar <ranjan.kumar@broadcom.com>
Link: https://lore.kernel.org/r/20250129100850.25430-3-ranjan.kumar@broadcom.com
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/mpi3mr/mpi/mpi30_tool.h b/drivers/scsi/mpi3mr/mpi/mpi30_tool.h
index 3b960893870f3b2596659c3d60f6ca7311346751..50a65b16a818c3fc47fbe2e0d8c3c8582701097a 100644 (file)
--- a/drivers/scsi/mpi3mr/mpi/mpi30_tool.h
+++ b/drivers/scsi/mpi3mr/mpi/mpi30_tool.h
@@ -9,6 +9,7 @@
 #define MPI3_DIAG_BUFFER_TYPE_FW       (0x02)
 #define MPI3_DIAG_BUFFER_ACTION_RELEASE        (0x01)
 
+#define MPI3_DIAG_BUFFER_POST_MSGFLAGS_SEGMENTED       (0x01)
 struct mpi3_diag_buffer_post_request {
        __le16                     host_tag;
        u8                         ioc_use_only02;

diff --git a/drivers/scsi/mpi3mr/mpi3mr.h b/drivers/scsi/mpi3mr/mpi3mr.h
index 9ed20ed581be6be769db4b61a52a1a16d65b9146..9aff390f0a165bfcb24eabbdaa32ccfdd2864570 100644 (file)
--- a/drivers/scsi/mpi3mr/mpi3mr.h
+++ b/drivers/scsi/mpi3mr/mpi3mr.h
@@ -934,6 +934,8 @@ struct trigger_event_data {
  * @size: Buffer size
  * @addr: Virtual address
  * @dma_addr: Buffer DMA address
+ * @is_segmented: The buffer is segmented or not
+ * @disabled_after_reset: The buffer is disabled after reset
  */
 struct diag_buffer_desc {
        u8 type;
@@ -943,6 +945,8 @@ struct diag_buffer_desc {
        u32 size;
        void *addr;
        dma_addr_t dma_addr;
+       bool is_segmented;
+       bool disabled_after_reset;
 };
 
 /**
@@ -1161,6 +1165,10 @@ struct scmd_priv {
  * @block_on_pci_err: Block IO during PCI error recovery
  * @reply_qfull_count: Occurences of reply queue full avoidance kicking-in
  * @prevent_reply_qfull: Enable reply queue prevention
+ * @seg_tb_support: Segmented trace buffer support
+ * @num_tb_segs: Number of Segments in Trace buffer
+ * @trace_buf_pool: DMA pool for Segmented trace buffer segments
+ * @trace_buf: Trace buffer segments memory descriptor
  */
 struct mpi3mr_ioc {
        struct list_head list;
@@ -1361,6 +1369,11 @@ struct mpi3mr_ioc {
        bool block_on_pci_err;
        atomic_t reply_qfull_count;
        bool prevent_reply_qfull;
+       bool seg_tb_support;
+       u32 num_tb_segs;
+       struct dma_pool *trace_buf_pool;
+       struct segments *trace_buf;
+
 };
 
 /**

diff --git a/drivers/scsi/mpi3mr/mpi3mr_app.c b/drivers/scsi/mpi3mr/mpi3mr_app.c
index 1532436f0f3af11096e4340fb3c433c9b4866705..26582776749fe6116fdeb3394bf87791ed7b0805 100644 (file)
--- a/drivers/scsi/mpi3mr/mpi3mr_app.c
+++ b/drivers/scsi/mpi3mr/mpi3mr_app.c
@@ -12,23 +12,98 @@
 #include <uapi/scsi/scsi_bsg_mpi3mr.h>
 
 /**
- * mpi3mr_alloc_trace_buffer:  Allocate trace buffer
+ * mpi3mr_alloc_trace_buffer: Allocate segmented trace buffer
  * @mrioc: Adapter instance reference
  * @trace_size: Trace buffer size
  *
- * Allocate trace buffer
+ * Allocate either segmented memory pools or contiguous buffer
+ * based on the controller capability for the host trace
+ * buffer.
+ *
  * Return: 0 on success, non-zero on failure.
  */
 static int mpi3mr_alloc_trace_buffer(struct mpi3mr_ioc *mrioc, u32 trace_size)
 {
        struct diag_buffer_desc *diag_buffer = &mrioc->diag_buffers[0];
+       int i, sz;
+       u64 *diag_buffer_list = NULL;
+       dma_addr_t diag_buffer_list_dma;
+       u32 seg_count;
+
+       if (mrioc->seg_tb_support) {
+               seg_count = (trace_size) / MPI3MR_PAGE_SIZE_4K;
+               trace_size = seg_count * MPI3MR_PAGE_SIZE_4K;
+
+               diag_buffer_list = dma_alloc_coherent(&mrioc->pdev->dev,
+                               sizeof(u64) * seg_count,
+                               &diag_buffer_list_dma, GFP_KERNEL);
+               if (!diag_buffer_list)
+                       return -1;
+
+               mrioc->num_tb_segs = seg_count;
+
+               sz = sizeof(struct segments) * seg_count;
+               mrioc->trace_buf = kzalloc(sz, GFP_KERNEL);
+               if (!mrioc->trace_buf)
+                       goto trace_buf_failed;
+
+               mrioc->trace_buf_pool = dma_pool_create("trace_buf pool",
+                   &mrioc->pdev->dev, MPI3MR_PAGE_SIZE_4K, MPI3MR_PAGE_SIZE_4K,
+                   0);
+               if (!mrioc->trace_buf_pool) {
+                       ioc_err(mrioc, "trace buf pool: dma_pool_create failed\n");
+                       goto trace_buf_pool_failed;
+               }
 
-       diag_buffer->addr = dma_alloc_coherent(&mrioc->pdev->dev,
-           trace_size, &diag_buffer->dma_addr, GFP_KERNEL);
-       if (diag_buffer->addr) {
-               dprint_init(mrioc, "trace diag buffer is allocated successfully\n");
+               for (i = 0; i < seg_count; i++) {
+                       mrioc->trace_buf[i].segment =
+                           dma_pool_zalloc(mrioc->trace_buf_pool, GFP_KERNEL,
+                           &mrioc->trace_buf[i].segment_dma);
+                       diag_buffer_list[i] =
+                           (u64) mrioc->trace_buf[i].segment_dma;
+                       if (!diag_buffer_list[i])
+                               goto tb_seg_alloc_failed;
+               }
+
+               diag_buffer->addr =  diag_buffer_list;
+               diag_buffer->dma_addr = diag_buffer_list_dma;
+               diag_buffer->is_segmented = true;
+
+               dprint_init(mrioc, "segmented trace diag buffer\n"
+                               "is allocated successfully seg_count:%d\n", seg_count);
                return 0;
+       } else {
+               diag_buffer->addr = dma_alloc_coherent(&mrioc->pdev->dev,
+                   trace_size, &diag_buffer->dma_addr, GFP_KERNEL);
+               if (diag_buffer->addr) {
+                       dprint_init(mrioc, "trace diag buffer is allocated successfully\n");
+                       return 0;
+               }
+               return -1;
        }
+
+tb_seg_alloc_failed:
+       if (mrioc->trace_buf_pool) {
+               for (i = 0; i < mrioc->num_tb_segs; i++) {
+                       if (mrioc->trace_buf[i].segment) {
+                               dma_pool_free(mrioc->trace_buf_pool,
+                                   mrioc->trace_buf[i].segment,
+                                   mrioc->trace_buf[i].segment_dma);
+                               mrioc->trace_buf[i].segment = NULL;
+                       }
+                       mrioc->trace_buf[i].segment = NULL;
+               }
+               dma_pool_destroy(mrioc->trace_buf_pool);
+               mrioc->trace_buf_pool = NULL;
+       }
+trace_buf_pool_failed:
+       kfree(mrioc->trace_buf);
+       mrioc->trace_buf = NULL;
+trace_buf_failed:
+       if (diag_buffer_list)
+               dma_free_coherent(&mrioc->pdev->dev,
+                   sizeof(u64) * mrioc->num_tb_segs,
+                   diag_buffer_list, diag_buffer_list_dma);
        return -1;
 }
 
@@ -100,8 +175,9 @@ retry_trace:
                        dprint_init(mrioc,
                            "trying to allocate trace diag buffer of size = %dKB\n",
                            trace_size / 1024);
-               if (get_order(trace_size) > MAX_PAGE_ORDER ||
+               if ((!mrioc->seg_tb_support && (get_order(trace_size) > MAX_PAGE_ORDER)) ||
                    mpi3mr_alloc_trace_buffer(mrioc, trace_size)) {
+
                        retry = true;
                        trace_size -= trace_dec_size;
                        dprint_init(mrioc, "trace diag buffer allocation failed\n"
@@ -161,6 +237,12 @@ int mpi3mr_issue_diag_buf_post(struct mpi3mr_ioc *mrioc,
        u8 prev_status;
        int retval = 0;
 
+       if (diag_buffer->disabled_after_reset) {
+               dprint_bsg_err(mrioc, "%s: skiping diag buffer posting\n"
+                               "as it is disabled after reset\n", __func__);
+               return -1;
+       }
+
        memset(&diag_buf_post_req, 0, sizeof(diag_buf_post_req));
        mutex_lock(&mrioc->init_cmds.mutex);
        if (mrioc->init_cmds.state & MPI3MR_CMD_PENDING) {
@@ -177,8 +259,12 @@ int mpi3mr_issue_diag_buf_post(struct mpi3mr_ioc *mrioc,
        diag_buf_post_req.address = le64_to_cpu(diag_buffer->dma_addr);
        diag_buf_post_req.length = le32_to_cpu(diag_buffer->size);
 
-       dprint_bsg_info(mrioc, "%s: posting diag buffer type %d\n", __func__,
-           diag_buffer->type);
+       if (diag_buffer->is_segmented)
+               diag_buf_post_req.msg_flags |= MPI3_DIAG_BUFFER_POST_MSGFLAGS_SEGMENTED;
+
+       dprint_bsg_info(mrioc, "%s: posting diag buffer type %d segmented:%d\n", __func__,
+           diag_buffer->type, diag_buffer->is_segmented);
+
        prev_status = diag_buffer->status;
        diag_buffer->status = MPI3MR_HDB_BUFSTATUS_POSTED_UNPAUSED;
        init_completion(&mrioc->init_cmds.done);

diff --git a/drivers/scsi/mpi3mr/mpi3mr_fw.c b/drivers/scsi/mpi3mr/mpi3mr_fw.c
index 656108dd2ee30e9dade9135e4c8c6bdc4f270245..d4d7a307e71cea4b7903afd32cad6ba9d06972d7 100644 (file)
--- a/drivers/scsi/mpi3mr/mpi3mr_fw.c
+++ b/drivers/scsi/mpi3mr/mpi3mr_fw.c
@@ -1302,7 +1302,7 @@ static int mpi3mr_issue_and_process_mur(struct mpi3mr_ioc *mrioc,
              (ioc_config & MPI3_SYSIF_IOC_CONFIG_ENABLE_IOC)))
                retval = 0;
 
-       ioc_info(mrioc, "Base IOC Sts/Config after %s MUR is (0x%x)/(0x%x)\n",
+       ioc_info(mrioc, "Base IOC Sts/Config after %s MUR is (0x%08x)/(0x%08x)\n",
            (!retval) ? "successful" : "failed", ioc_status, ioc_config);
        return retval;
 }
@@ -1355,6 +1355,19 @@ mpi3mr_revalidate_factsdata(struct mpi3mr_ioc *mrioc)
                    "\tcontroller while sas transport support is enabled at the\n"
                    "\tdriver, please reboot the system or reload the driver\n");
 
+       if (mrioc->seg_tb_support) {
+               if (!(mrioc->facts.ioc_capabilities &
+                    MPI3_IOCFACTS_CAPABILITY_SEG_DIAG_TRACE_SUPPORTED)) {
+                       ioc_err(mrioc,
+                           "critical error: previously enabled segmented trace\n"
+                           " buffer capability is disabled after reset. Please\n"
+                           " update the firmware or reboot the system or\n"
+                           " reload the driver to enable trace diag buffer\n");
+                       mrioc->diag_buffers[0].disabled_after_reset = true;
+               } else
+                       mrioc->diag_buffers[0].disabled_after_reset = false;
+       }
+
        if (mrioc->facts.max_devhandle > mrioc->dev_handle_bitmap_bits) {
                removepend_bitmap = bitmap_zalloc(mrioc->facts.max_devhandle,
                                                  GFP_KERNEL);
@@ -1717,7 +1730,7 @@ static int mpi3mr_issue_reset(struct mpi3mr_ioc *mrioc, u16 reset_type,
        ioc_config = readl(&mrioc->sysif_regs->ioc_configuration);
        ioc_status = readl(&mrioc->sysif_regs->ioc_status);
        ioc_info(mrioc,
-           "ioc_status/ioc_onfig after %s reset is (0x%x)/(0x%x)\n",
+           "ioc_status/ioc_config after %s reset is (0x%08x)/(0x%08x)\n",
            (!retval)?"successful":"failed", ioc_status,
            ioc_config);
        if (retval)
@@ -4238,6 +4251,10 @@ retry_init:
        if (mrioc->facts.max_req_limit)
                mrioc->prevent_reply_qfull = true;
 
+       if (mrioc->facts.ioc_capabilities &
+               MPI3_IOCFACTS_CAPABILITY_SEG_DIAG_TRACE_SUPPORTED)
+               mrioc->seg_tb_support = true;
+
        mrioc->reply_sz = mrioc->facts.reply_sz;
 
        retval = mpi3mr_check_reset_dma_mask(mrioc);
@@ -4695,7 +4712,7 @@ void mpi3mr_memset_buffers(struct mpi3mr_ioc *mrioc)
  */
 void mpi3mr_free_mem(struct mpi3mr_ioc *mrioc)
 {
-       u16 i;
+       u16 i, j;
        struct mpi3mr_intr_info *intr_info;
        struct diag_buffer_desc *diag_buffer;
 
@@ -4830,6 +4847,26 @@ void mpi3mr_free_mem(struct mpi3mr_ioc *mrioc)
 
        for (i = 0; i < MPI3MR_MAX_NUM_HDB; i++) {
                diag_buffer = &mrioc->diag_buffers[i];
+               if ((i == 0) && mrioc->seg_tb_support) {
+                       if (mrioc->trace_buf_pool) {
+                               for (j = 0; j < mrioc->num_tb_segs; j++) {
+                                       if (mrioc->trace_buf[j].segment) {
+                                               dma_pool_free(mrioc->trace_buf_pool,
+                                                   mrioc->trace_buf[j].segment,
+                                                   mrioc->trace_buf[j].segment_dma);
+                                               mrioc->trace_buf[j].segment = NULL;
+                                       }
+
+                                       mrioc->trace_buf[j].segment = NULL;
+                               }
+                               dma_pool_destroy(mrioc->trace_buf_pool);
+                               mrioc->trace_buf_pool = NULL;
+                       }
+
+                       kfree(mrioc->trace_buf);
+                       mrioc->trace_buf = NULL;
+                       diag_buffer->size = sizeof(u64) * mrioc->num_tb_segs;
+               }
                if (diag_buffer->addr) {
                        dma_free_coherent(&mrioc->pdev->dev,
                            diag_buffer->size, diag_buffer->addr,
@@ -4907,7 +4944,7 @@ static void mpi3mr_issue_ioc_shutdown(struct mpi3mr_ioc *mrioc)
        }
 
        ioc_info(mrioc,
-           "Base IOC Sts/Config after %s shutdown is (0x%x)/(0x%x)\n",
+           "Base IOC Sts/Config after %s shutdown is (0x%08x)/(0x%08x)\n",
            (!retval) ? "successful" : "failed", ioc_status,
            ioc_config);
 }