Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9b3d028f authored by Shivasharan S's avatar Shivasharan S Committed by Martin K. Petersen
Browse files

scsi: megaraid_sas: Pre-allocate frequently used DMA buffers 



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

Signed-off-by: default avatarKashyap Desai <kashyap.desai@broadcom.com>
Signed-off-by: default avatarShivasharan S <shivasharan.srikanteshwara@broadcom.com>
Signed-off-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
parent 1b4bed20

drivers/scsi/megaraid/megaraid_sas.h

+13 −0
Original line number Diff line number Diff line
@@ -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;

drivers/scsi/megaraid/megaraid_sas_base.c

+97 −50
Original line number Diff line number Diff line
@@ -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,

drivers/scsi/megaraid/megaraid_sas_fusion.c

+3 −16
Original line number Diff line number Diff line
@@ -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",

drivers/scsi/megaraid/megaraid_sas_fusion.h

+3 −0
Original line number Diff line number Diff line
@@ -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 {