leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

scsi: megaraid_sas: Pre-allocate frequently used DMA buffers

Browse Source 
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>
This commit is contained in:
Shivasharan S 2017-10-19 02:48:56 -07:00 committed by Martin K. Petersen
parent 1b4bed2061
commit 9b3d028f34
4 changed files with 116 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
drivers/scsi/megaraid/megaraid_sas.h
View File

@ -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;

147
drivers/scsi/megaraid/megaraid_sas_base.c
View File

@ -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,

19
drivers/scsi/megaraid/megaraid_sas_fusion.c
View File

@ -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",

3
drivers/scsi/megaraid/megaraid_sas_fusion.h
View File

@ -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 {