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

Commit 0a4b1fc0 authored by Krishna Gudipati's avatar Krishna Gudipati Committed by James Bottomley
Browse files

[SCSI] bfa: Replace bfa_get_attr() with specific APIs 



bfa_ioc_attr_s is a big structure and some times could cause
stack overflow if defined locally, so add specific APIs that
are needed to replace the use of ioc_attr local var.

Signed-off-by: default avatarKrishna Gudipati <kgudipat@brocade.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@suse.de>
parent f58e9ebb

drivers/scsi/bfa/bfa_fcport.c

+7 −26
Original line number Diff line number Diff line
@@ -145,35 +145,12 @@ bfa_fcport_aen_post(struct bfa_fcport_s *fcport, enum bfa_port_aen_event event) 
	struct bfa_log_mod_s *logmod = fcport->bfa->logm;

	wwn_t           pwwn = fcport->pwwn;

	char            pwwn_ptr[BFA_STRING_32];

	struct bfa_ioc_attr_s ioc_attr;



	memset(&aen_data, 0, sizeof(aen_data));

	wwn2str(pwwn_ptr, pwwn);

	switch (event) {

	case BFA_PORT_AEN_ONLINE:

		bfa_log(logmod, BFA_AEN_PORT_ONLINE, pwwn_ptr);

		break;

	case BFA_PORT_AEN_OFFLINE:

		bfa_log(logmod, BFA_AEN_PORT_OFFLINE, pwwn_ptr);

		break;

	case BFA_PORT_AEN_ENABLE:

		bfa_log(logmod, BFA_AEN_PORT_ENABLE, pwwn_ptr);

		break;

	case BFA_PORT_AEN_DISABLE:

		bfa_log(logmod, BFA_AEN_PORT_DISABLE, pwwn_ptr);

		break;

	case BFA_PORT_AEN_DISCONNECT:

		bfa_log(logmod, BFA_AEN_PORT_DISCONNECT, pwwn_ptr);

		break;

	case BFA_PORT_AEN_QOS_NEG:

		bfa_log(logmod, BFA_AEN_PORT_QOS_NEG, pwwn_ptr);

		break;

	default:

		break;

	}

	bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_PORT, event), pwwn_ptr);



	bfa_ioc_get_attr(&fcport->bfa->ioc, &ioc_attr);

	aen_data.port.ioc_type = ioc_attr.ioc_type;

	aen_data.port.ioc_type = bfa_get_type(fcport->bfa);

	aen_data.port.pwwn = pwwn;

}
@@ -2043,10 +2020,14 @@ void 
bfa_fcport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off)

{

	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);

	enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa);



	bfa_trc(bfa, on_off);

	bfa_trc(bfa, fcport->cfg.qos_enabled);



	bfa_trc(bfa, ioc_type);



	if (ioc_type == BFA_IOC_TYPE_FC)

		fcport->cfg.qos_enabled = on_off;

}

drivers/scsi/bfa/bfa_fcs_lport.c

+2 −24
Original line number Diff line number Diff line
@@ -263,30 +263,8 @@ bfa_fcs_port_aen_post(struct bfa_fcs_port_s *port, 


	bfa_assert(role <= BFA_PORT_ROLE_FCP_MAX);



	switch (event) {

	case BFA_LPORT_AEN_ONLINE:

		bfa_log(logmod, BFA_AEN_LPORT_ONLINE, lpwwn_ptr,

			role_str[role / 2]);

		break;

	case BFA_LPORT_AEN_OFFLINE:

		bfa_log(logmod, BFA_AEN_LPORT_OFFLINE, lpwwn_ptr,

			role_str[role / 2]);

		break;

	case BFA_LPORT_AEN_NEW:

		bfa_log(logmod, BFA_AEN_LPORT_NEW, lpwwn_ptr,

			role_str[role / 2]);

		break;

	case BFA_LPORT_AEN_DELETE:

		bfa_log(logmod, BFA_AEN_LPORT_DELETE, lpwwn_ptr,

	bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_LPORT, event), lpwwn_ptr,

		role_str[role/2]);

		break;

	case BFA_LPORT_AEN_DISCONNECT:

		bfa_log(logmod, BFA_AEN_LPORT_DISCONNECT, lpwwn_ptr,

			role_str[role / 2]);

		break;

	default:

		break;

	}



	aen_data.lport.vf_id = port->fabric->vf_id;

	aen_data.lport.roles = role;

drivers/scsi/bfa/bfa_ioc.c

+95 −60
Original line number Diff line number Diff line
@@ -1679,46 +1679,28 @@ bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc, 
			 struct bfa_adapter_attr_s *ad_attr)

{

	struct bfi_ioc_attr_s *ioc_attr;

	char            model[BFA_ADAPTER_MODEL_NAME_LEN];



	ioc_attr = ioc->attr;

	bfa_os_memcpy((void *)&ad_attr->serial_num,

		      (void *)ioc_attr->brcd_serialnum,

		      BFA_ADAPTER_SERIAL_NUM_LEN);



	bfa_os_memcpy(&ad_attr->fw_ver, ioc_attr->fw_version, BFA_VERSION_LEN);

	bfa_os_memcpy(&ad_attr->optrom_ver, ioc_attr->optrom_version,

		      BFA_VERSION_LEN);

	bfa_os_memcpy(&ad_attr->manufacturer, BFA_MFG_NAME,

		      BFA_ADAPTER_MFG_NAME_LEN);

	bfa_ioc_get_adapter_serial_num(ioc, ad_attr->serial_num);

	bfa_ioc_get_adapter_fw_ver(ioc, ad_attr->fw_ver);

	bfa_ioc_get_adapter_optrom_ver(ioc, ad_attr->optrom_ver);

	bfa_ioc_get_adapter_manufacturer(ioc, ad_attr->manufacturer);

	bfa_os_memcpy(&ad_attr->vpd, &ioc_attr->vpd,

		      sizeof(struct bfa_mfg_vpd_s));



	ad_attr->nports = BFI_ADAPTER_GETP(NPORTS, ioc_attr->adapter_prop);

	ad_attr->max_speed = BFI_ADAPTER_GETP(SPEED, ioc_attr->adapter_prop);

	ad_attr->nports = bfa_ioc_get_nports(ioc);

	ad_attr->max_speed = bfa_ioc_speed_sup(ioc);



	/**

	 * model name

	 */

	if (BFI_ADAPTER_GETP(SPEED, ioc_attr->adapter_prop) == 10) {

		strcpy(model, "BR-10?0");

		model[5] = '0' + ad_attr->nports;

	} else {

		strcpy(model, "Brocade-??5");

		model[8] =

			'0' + BFI_ADAPTER_GETP(SPEED, ioc_attr->adapter_prop);

		model[9] = '0' + ad_attr->nports;

	}

	bfa_ioc_get_adapter_model(ioc, ad_attr->model);

	/* For now, model descr uses same model string */

	bfa_ioc_get_adapter_model(ioc, ad_attr->model_descr);



	if (BFI_ADAPTER_IS_SPECIAL(ioc_attr->adapter_prop))

		ad_attr->prototype = 1;

	else

		ad_attr->prototype = 0;



	bfa_os_memcpy(&ad_attr->model, model, BFA_ADAPTER_MODEL_NAME_LEN);

	bfa_os_memcpy(&ad_attr->model_descr, &ad_attr->model,

		      BFA_ADAPTER_MODEL_NAME_LEN);



	ad_attr->pwwn = bfa_ioc_get_pwwn(ioc);

	ad_attr->mac = bfa_ioc_get_mac(ioc);
@@ -1726,12 +1708,8 @@ bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc, 
	ad_attr->pcie_lanes = ioc_attr->pcie_lanes;

	ad_attr->pcie_lanes_orig = ioc_attr->pcie_lanes_orig;

	ad_attr->asic_rev = ioc_attr->asic_rev;

	ad_attr->hw_ver[0] = 'R';

	ad_attr->hw_ver[1] = 'e';

	ad_attr->hw_ver[2] = 'v';

	ad_attr->hw_ver[3] = '-';

	ad_attr->hw_ver[4] = ioc_attr->asic_rev;

	ad_attr->hw_ver[5] = '\0';



	bfa_ioc_get_pci_chip_rev(ioc, ad_attr->hw_ver);



	ad_attr->cna_capable = ioc->cna;

}
@@ -1751,12 +1729,92 @@ bfa_ioc_get_type(struct bfa_ioc_s *ioc) 
	}

}



void

bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num)

{

	bfa_os_memset((void *)serial_num, 0, BFA_ADAPTER_SERIAL_NUM_LEN);

	bfa_os_memcpy((void *)serial_num,

			(void *)ioc->attr->brcd_serialnum,

			BFA_ADAPTER_SERIAL_NUM_LEN);

}



void

bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver)

{

	bfa_os_memset((void *)fw_ver, 0, BFA_VERSION_LEN);

	bfa_os_memcpy(fw_ver, ioc->attr->fw_version, BFA_VERSION_LEN);

}



void

bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev)

{

	bfa_assert(chip_rev);



	bfa_os_memset((void *)chip_rev, 0, BFA_IOC_CHIP_REV_LEN);



	chip_rev[0] = 'R';

	chip_rev[1] = 'e';

	chip_rev[2] = 'v';

	chip_rev[3] = '-';

	chip_rev[4] = ioc->attr->asic_rev;

	chip_rev[5] = '\0';

}



void

bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver)

{

	bfa_os_memset((void *)optrom_ver, 0, BFA_VERSION_LEN);

	bfa_os_memcpy(optrom_ver, ioc->attr->optrom_version,

		BFA_VERSION_LEN);

}



void

bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc, char *manufacturer)

{

	bfa_os_memset((void *)manufacturer, 0, BFA_ADAPTER_MFG_NAME_LEN);

	bfa_os_memcpy(manufacturer, BFA_MFG_NAME, BFA_ADAPTER_MFG_NAME_LEN);

}



void

bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model)

{

	struct bfi_ioc_attr_s   *ioc_attr;

	u8              nports;

	u8              max_speed;



	bfa_assert(model);

	bfa_os_memset((void *)model, 0, BFA_ADAPTER_MODEL_NAME_LEN);



	ioc_attr = ioc->attr;



	nports = bfa_ioc_get_nports(ioc);

	max_speed = bfa_ioc_speed_sup(ioc);



	/**

	 * model name

	 */

	if (max_speed == 10) {

		strcpy(model, "BR-10?0");

		model[5] = '0' + nports;

	} else {

		strcpy(model, "Brocade-??5");

		model[8] = '0' + max_speed;

		model[9] = '0' + nports;

	}

}



enum bfa_ioc_state

bfa_ioc_get_state(struct bfa_ioc_s *ioc)

{

	return bfa_sm_to_state(ioc_sm_table, ioc->fsm);

}



void

bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr)

{

	bfa_os_memset((void *)ioc_attr, 0, sizeof(struct bfa_ioc_attr_s));



	ioc_attr->state = bfa_sm_to_state(ioc_sm_table, ioc->fsm);

	ioc_attr->state = bfa_ioc_get_state(ioc);

	ioc_attr->port_id = ioc->port_id;



	ioc_attr->ioc_type = bfa_ioc_get_type(ioc);
@@ -1765,12 +1823,7 @@ bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr) 


	ioc_attr->pci_attr.device_id = ioc->pcidev.device_id;

	ioc_attr->pci_attr.pcifn = ioc->pcidev.pci_func;

	ioc_attr->pci_attr.chip_rev[0] = 'R';

	ioc_attr->pci_attr.chip_rev[1] = 'e';

	ioc_attr->pci_attr.chip_rev[2] = 'v';

	ioc_attr->pci_attr.chip_rev[3] = '-';

	ioc_attr->pci_attr.chip_rev[4] = ioc_attr->adapter_attr.asic_rev;

	ioc_attr->pci_attr.chip_rev[5] = '\0';

	bfa_ioc_get_pci_chip_rev(ioc, ioc_attr->pci_attr.chip_rev);

}



/**
@@ -1877,25 +1930,7 @@ bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event) 
	s32         inst_num = 0;

	enum bfa_ioc_type_e ioc_type;



	switch (event) {

	case BFA_IOC_AEN_HBGOOD:

		bfa_log(logmod, BFA_AEN_IOC_HBGOOD, inst_num);

		break;

	case BFA_IOC_AEN_HBFAIL:

		bfa_log(logmod, BFA_AEN_IOC_HBFAIL, inst_num);

		break;

	case BFA_IOC_AEN_ENABLE:

		bfa_log(logmod, BFA_AEN_IOC_ENABLE, inst_num);

		break;

	case BFA_IOC_AEN_DISABLE:

		bfa_log(logmod, BFA_AEN_IOC_DISABLE, inst_num);

		break;

	case BFA_IOC_AEN_FWMISMATCH:

		bfa_log(logmod, BFA_AEN_IOC_FWMISMATCH, inst_num);

		break;

	default:

		break;

	}

	bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_IOC, event), inst_num);



	memset(&aen_data.ioc.pwwn, 0, sizeof(aen_data.ioc.pwwn));

	memset(&aen_data.ioc.mac, 0, sizeof(aen_data.ioc.mac));

drivers/scsi/bfa/bfa_ioc.h

+10 −0
Original line number Diff line number Diff line
@@ -263,6 +263,16 @@ bfa_boolean_t bfa_ioc_is_disabled(struct bfa_ioc_s *ioc); 
bfa_boolean_t bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc);

bfa_boolean_t bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc);

void bfa_ioc_cfg_complete(struct bfa_ioc_s *ioc);

enum bfa_ioc_type_e bfa_ioc_get_type(struct bfa_ioc_s *ioc);

void bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num);

void bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver);

void bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver);

void bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model);

void bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc,

	char *manufacturer);

void bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev);

enum bfa_ioc_state bfa_ioc_get_state(struct bfa_ioc_s *ioc);



void bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr);

void bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,

		struct bfa_adapter_attr_s *ad_attr);

drivers/scsi/bfa/bfa_lps.c

+1 −5
Original line number Diff line number Diff line
@@ -631,11 +631,7 @@ bfa_lps_cvl_event(struct bfa_lps_s *lps) 
u32

bfa_lps_get_max_vport(struct bfa_s *bfa)

{

	struct bfa_ioc_attr_s ioc_attr;



	bfa_get_attr(bfa, &ioc_attr);



	if (ioc_attr.pci_attr.device_id == BFA_PCI_DEVICE_ID_CT)

	if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT)

		return BFA_LPS_MAX_VPORTS_SUPP_CT;

	else

		return BFA_LPS_MAX_VPORTS_SUPP_CB;