scsi: megaraid_sas: Pre-allocate frequently used DMA buffers

Pre-allocate few of the frequently used DMA buffers during load time.

Signed-off-by: Kashyap Desai <kashyap.desai@broadcom.com>
Signed-off-by: Shivasharan S <shivasharan.srikanteshwara@broadcom.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index 1f34577d898217eedd7c8ec0eca639d5e4477d25..80ba77b4b9e2b386da207bdb72688a5f04fb75af 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -2122,6 +2122,19 @@ struct megasas_instance {
 
        u32 *crash_dump_buf;
        dma_addr_t crash_dump_h;
+
+       struct MR_PD_LIST *pd_list_buf;
+       dma_addr_t pd_list_buf_h;
+
+       struct megasas_ctrl_info *ctrl_info_buf;
+       dma_addr_t ctrl_info_buf_h;
+
+       struct MR_LD_LIST *ld_list_buf;
+       dma_addr_t ld_list_buf_h;
+
+       struct MR_LD_TARGETID_LIST *ld_targetid_list_buf;
+       dma_addr_t ld_targetid_list_buf_h;
+
        void *crash_buf[MAX_CRASH_DUMP_SIZE];
        unsigned int    fw_crash_buffer_size;
        unsigned int    fw_crash_state;

diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index a0f40856711d6e17289ca2728354ddc1c068f751..19649ca11a1ff09158a6473869760580ee14a500 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -4211,6 +4211,9 @@ megasas_get_pd_list(struct megasas_instance *instance)
                return ret;
        }
 
+       ci = instance->pd_list_buf;
+       ci_h = instance->pd_list_buf_h;
+
        cmd = megasas_get_cmd(instance);
 
        if (!cmd) {
@@ -4220,15 +4223,6 @@ megasas_get_pd_list(struct megasas_instance *instance)
 
        dcmd = &cmd->frame->dcmd;
 
-       ci = pci_alloc_consistent(instance->pdev,
-                 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), &ci_h);
-
-       if (!ci) {
-               dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem for pd_list\n");
-               megasas_return_cmd(instance, cmd);
-               return -ENOMEM;
-       }
-
        memset(ci, 0, sizeof(*ci));
        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
 
@@ -4314,10 +4308,6 @@ megasas_get_pd_list(struct megasas_instance *instance)
 
        }
 
-       pci_free_consistent(instance->pdev,
-                               MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
-                               ci, ci_h);
-
        if (ret != DCMD_TIMEOUT)
                megasas_return_cmd(instance, cmd);
 
@@ -4343,6 +4333,9 @@ megasas_get_ld_list(struct megasas_instance *instance)
        dma_addr_t ci_h = 0;
        u32 ld_count;
 
+       ci = instance->ld_list_buf;
+       ci_h = instance->ld_list_buf_h;
+
        cmd = megasas_get_cmd(instance);
 
        if (!cmd) {
@@ -4352,16 +4345,6 @@ megasas_get_ld_list(struct megasas_instance *instance)
 
        dcmd = &cmd->frame->dcmd;
 
-       ci = pci_alloc_consistent(instance->pdev,
-                               sizeof(struct MR_LD_LIST),
-                               &ci_h);
-
-       if (!ci) {
-               dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem in get_ld_list\n");
-               megasas_return_cmd(instance, cmd);
-               return -ENOMEM;
-       }
-
        memset(ci, 0, sizeof(*ci));
        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
 
@@ -4433,8 +4416,6 @@ megasas_get_ld_list(struct megasas_instance *instance)
                break;
        }
 
-       pci_free_consistent(instance->pdev, sizeof(struct MR_LD_LIST), ci, ci_h);
-
        if (ret != DCMD_TIMEOUT)
                megasas_return_cmd(instance, cmd);
 
@@ -4460,6 +4441,9 @@ megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
        dma_addr_t ci_h = 0;
        u32 tgtid_count;
 
+       ci = instance->ld_targetid_list_buf;
+       ci_h = instance->ld_targetid_list_buf_h;
+
        cmd = megasas_get_cmd(instance);
 
        if (!cmd) {
@@ -4470,16 +4454,6 @@ megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
 
        dcmd = &cmd->frame->dcmd;
 
-       ci = pci_alloc_consistent(instance->pdev,
-                                 sizeof(struct MR_LD_TARGETID_LIST), &ci_h);
-
-       if (!ci) {
-               dev_warn(&instance->pdev->dev,
-                        "Failed to alloc mem for ld_list_query\n");
-               megasas_return_cmd(instance, cmd);
-               return -ENOMEM;
-       }
-
        memset(ci, 0, sizeof(*ci));
        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
 
@@ -4550,9 +4524,6 @@ megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
                break;
        }
 
-       pci_free_consistent(instance->pdev, sizeof(struct MR_LD_TARGETID_LIST),
-                   ci, ci_h);
-
        if (ret != DCMD_TIMEOUT)
                megasas_return_cmd(instance, cmd);
 
@@ -4639,6 +4610,9 @@ megasas_get_ctrl_info(struct megasas_instance *instance)
 
        ctrl_info = instance->ctrl_info;
 
+       ci = instance->ctrl_info_buf;
+       ci_h = instance->ctrl_info_buf_h;
+
        cmd = megasas_get_cmd(instance);
 
        if (!cmd) {
@@ -4648,15 +4622,6 @@ megasas_get_ctrl_info(struct megasas_instance *instance)
 
        dcmd = &cmd->frame->dcmd;
 
-       ci = pci_alloc_consistent(instance->pdev,
-                                 sizeof(struct megasas_ctrl_info), &ci_h);
-
-       if (!ci) {
-               dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc mem for ctrl info\n");
-               megasas_return_cmd(instance, cmd);
-               return -ENOMEM;
-       }
-
        memset(ci, 0, sizeof(*ci));
        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
 
@@ -4738,9 +4703,6 @@ megasas_get_ctrl_info(struct megasas_instance *instance)
 
        }
 
-       pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info),
-                           ci, ci_h);
-
        megasas_return_cmd(instance, cmd);
 
 
@@ -6103,6 +6065,7 @@ static inline
 int megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance)
 {
        struct pci_dev *pdev = instance->pdev;
+       struct fusion_context *fusion = instance->ctrl_context;
 
        instance->evt_detail =
                pci_alloc_consistent(pdev,
@@ -6115,6 +6078,62 @@ int megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance)
                return -ENOMEM;
        }
 
+       if (fusion) {
+               fusion->ioc_init_request =
+                       dma_alloc_coherent(&pdev->dev,
+                                          sizeof(struct MPI2_IOC_INIT_REQUEST),
+                                          &fusion->ioc_init_request_phys,
+                                          GFP_KERNEL);
+
+               if (!fusion->ioc_init_request) {
+                       dev_err(&pdev->dev,
+                               "Failed to allocate PD list buffer\n");
+                       return -ENOMEM;
+               }
+       }
+
+       instance->pd_list_buf =
+               pci_alloc_consistent(pdev,
+                                    MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
+                                    &instance->pd_list_buf_h);
+
+       if (!instance->pd_list_buf) {
+               dev_err(&pdev->dev, "Failed to allocate PD list buffer\n");
+               return -ENOMEM;
+       }
+
+       instance->ctrl_info_buf =
+               pci_alloc_consistent(pdev,
+                                    sizeof(struct megasas_ctrl_info),
+                                    &instance->ctrl_info_buf_h);
+
+       if (!instance->ctrl_info_buf) {
+               dev_err(&pdev->dev,
+                       "Failed to allocate controller info buffer\n");
+               return -ENOMEM;
+       }
+
+       instance->ld_list_buf =
+               pci_alloc_consistent(pdev,
+                                    sizeof(struct MR_LD_LIST),
+                                    &instance->ld_list_buf_h);
+
+       if (!instance->ld_list_buf) {
+               dev_err(&pdev->dev, "Failed to allocate LD list buffer\n");
+               return -ENOMEM;
+       }
+
+       instance->ld_targetid_list_buf =
+               pci_alloc_consistent(pdev,
+                                    sizeof(struct MR_LD_TARGETID_LIST),
+                                    &instance->ld_targetid_list_buf_h);
+
+       if (!instance->ld_targetid_list_buf) {
+               dev_err(&pdev->dev,
+                       "Failed to allocate LD targetid list buffer\n");
+               return -ENOMEM;
+       }
+
        if (!reset_devices) {
                instance->system_info_buf =
                        pci_alloc_consistent(pdev,
@@ -6164,12 +6183,40 @@ static inline
 void megasas_free_ctrl_dma_buffers(struct megasas_instance *instance)
 {
        struct pci_dev *pdev = instance->pdev;
+       struct fusion_context *fusion = instance->ctrl_context;
 
        if (instance->evt_detail)
                pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
                                    instance->evt_detail,
                                    instance->evt_detail_h);
 
+       if (fusion && fusion->ioc_init_request)
+               dma_free_coherent(&pdev->dev,
+                                 sizeof(struct MPI2_IOC_INIT_REQUEST),
+                                 fusion->ioc_init_request,
+                                 fusion->ioc_init_request_phys);
+
+       if (instance->pd_list_buf)
+               pci_free_consistent(pdev,
+                                   MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
+                                   instance->pd_list_buf,
+                                   instance->pd_list_buf_h);
+
+       if (instance->ld_list_buf)
+               pci_free_consistent(pdev, sizeof(struct MR_LD_LIST),
+                                   instance->ld_list_buf,
+                                   instance->ld_list_buf_h);
+
+       if (instance->ld_targetid_list_buf)
+               pci_free_consistent(pdev, sizeof(struct MR_LD_TARGETID_LIST),
+                                   instance->ld_targetid_list_buf,
+                                   instance->ld_targetid_list_buf_h);
+
+       if (instance->ctrl_info_buf)
+               pci_free_consistent(pdev, sizeof(struct megasas_ctrl_info),
+                                   instance->ctrl_info_buf,
+                                   instance->ctrl_info_buf_h);
+
        if (instance->system_info_buf)
                pci_free_consistent(pdev, sizeof(struct MR_DRV_SYSTEM_INFO),
                                    instance->system_info_buf,

diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index a8055341e8756dd8b379048a99ca034b35b19edb..a630a31aecf88d3115596350ab2a1aa9537ea952 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -776,6 +776,9 @@ megasas_ioc_init_fusion(struct megasas_instance *instance)
 
        fusion = instance->ctrl_context;
 
+       ioc_init_handle = fusion->ioc_init_request_phys;
+       IOCInitMessage = fusion->ioc_init_request;
+
        cmd = megasas_get_cmd(instance);
 
        if (!cmd) {
@@ -801,18 +804,6 @@ megasas_ioc_init_fusion(struct megasas_instance *instance)
        dev_info(&instance->pdev->dev, "FW supports sync cache\t: %s\n",
                 instance->fw_sync_cache_support ? "Yes" : "No");
 
-       IOCInitMessage =
-         dma_alloc_coherent(&instance->pdev->dev,
-                            sizeof(struct MPI2_IOC_INIT_REQUEST),
-                            &ioc_init_handle, GFP_KERNEL);
-
-       if (!IOCInitMessage) {
-               dev_err(&instance->pdev->dev, "Could not allocate memory for "
-                      "IOCInitMessage\n");
-               ret = 1;
-               goto fail_fw_init;
-       }
-
        memset(IOCInitMessage, 0, sizeof(struct MPI2_IOC_INIT_REQUEST));
 
        IOCInitMessage->Function = MPI2_FUNCTION_IOC_INIT;
@@ -921,10 +912,6 @@ megasas_ioc_init_fusion(struct megasas_instance *instance)
 
 fail_fw_init:
        megasas_return_cmd(instance, cmd);
-       if (IOCInitMessage)
-               dma_free_coherent(&instance->pdev->dev,
-                                 sizeof(struct MPI2_IOC_INIT_REQUEST),
-                                 IOCInitMessage, ioc_init_handle);
 fail_get_cmd:
        dev_err(&instance->pdev->dev,
                "Init cmd return status %s for SCSI host %d\n",

diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.h b/drivers/scsi/megaraid/megaraid_sas_fusion.h
index a2b56913f38205e3b0823fc644c4d8a69a8c339e..5b3f1dba1ab2bf23f0ffb26a5eb58c01a0216054 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.h
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.h
@@ -1315,6 +1315,9 @@ struct fusion_context {
        LD_SPAN_INFO *log_to_span;
        u32 log_to_span_pages;
        struct LD_STREAM_DETECT **stream_detect_by_ld;
+       dma_addr_t ioc_init_request_phys;
+       struct MPI2_IOC_INIT_REQUEST *ioc_init_request;
+
 };
 
 union desc_value {