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

[SCSI] bfa: Extend BSG to support more user commands 



Extended BSG to support stats, port log and trace reset and to support
adapter, port SET operations.

Signed-off-by: default avatarKrishna Gudipati <kgudipat@brocade.com>
Signed-off-by: default avatarJames Bottomley <JBottomley@Parallels.com>
parent fb778b06

drivers/scsi/bfa/bfa_defs.h

+1 −0
Original line number Diff line number Diff line
@@ -144,6 +144,7 @@ enum bfa_status { 
	BFA_STATUS_INVLD_DFSZ	= 24,	/*  Invalid Max data field size */

	BFA_STATUS_CMD_NOTSUPP  = 26,   /*  Command/API not supported */

	BFA_STATUS_FABRIC_RJT	= 29,	/*  Reject from attached fabric */

	BFA_STATUS_UNKNOWN_VWWN = 30,	/*  VPORT PWWN not found */

	BFA_STATUS_PORT_OFFLINE = 34,	/*  Port is not online */

	BFA_STATUS_VPORT_WWN_BP	= 46,	/*  WWN is same as base port's WWN */

	BFA_STATUS_PORT_NOT_DISABLED = 47, /* Port not disabled disable port */

drivers/scsi/bfa/bfa_defs_svc.h

+1 −0
Original line number Diff line number Diff line
@@ -268,6 +268,7 @@ struct bfa_fw_port_snsm_stats_s { 
    u32    error_resets;       /*  error resets initiated by upsm      */

    u32    sync_lost;          /*  Sync loss count                     */

    u32    sig_lost;           /*  Signal loss count                   */

	u32	asn8g_attempts;	/* SNSM HWSM at 8Gbps attempts */

};



struct bfa_fw_port_physm_stats_s {

drivers/scsi/bfa/bfad_bsg.c

+535 −0
Original line number Diff line number Diff line
@@ -178,6 +178,38 @@ bfad_iocmd_ioc_get_fwstats(struct bfad_s *bfad, void *cmd, 
	return 0;

}



int

bfad_iocmd_ioc_reset_stats(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)

{

	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;

	unsigned long	flags;



	if (v_cmd == IOCMD_IOC_RESET_STATS) {

		bfa_ioc_clear_stats(&bfad->bfa);

		iocmd->status = BFA_STATUS_OK;

	} else if (v_cmd == IOCMD_IOC_RESET_FWSTATS) {

		spin_lock_irqsave(&bfad->bfad_lock, flags);

		iocmd->status = bfa_ioc_fw_stats_clear(&bfad->bfa.ioc);

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	}



	return 0;

}



int

bfad_iocmd_ioc_set_name(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)

{

	struct bfa_bsg_ioc_name_s *iocmd = (struct bfa_bsg_ioc_name_s *) cmd;



	if (v_cmd == IOCMD_IOC_SET_ADAPTER_NAME)

		strcpy(bfad->adapter_name, iocmd->name);

	else if (v_cmd == IOCMD_IOC_SET_PORT_NAME)

		strcpy(bfad->port_name, iocmd->name);



	iocmd->status = BFA_STATUS_OK;

	return 0;

}



int

bfad_iocmd_iocfc_get_attr(struct bfad_s *bfad, void *cmd)

{
@@ -307,6 +339,81 @@ bfad_iocmd_port_get_stats(struct bfad_s *bfad, void *cmd, 
	return 0;

}



int

bfad_iocmd_port_reset_stats(struct bfad_s *bfad, void *cmd)

{

	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;

	struct bfad_hal_comp fcomp;

	unsigned long	flags;



	init_completion(&fcomp.comp);

	spin_lock_irqsave(&bfad->bfad_lock, flags);

	iocmd->status = bfa_port_clear_stats(&bfad->bfa.modules.port,

					bfad_hcb_comp, &fcomp);

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	if (iocmd->status != BFA_STATUS_OK) {

		bfa_trc(bfad, iocmd->status);

		return 0;

	}

	wait_for_completion(&fcomp.comp);

	iocmd->status = fcomp.status;

	return 0;

}



int

bfad_iocmd_set_port_cfg(struct bfad_s *bfad, void *iocmd, unsigned int v_cmd)

{

	struct bfa_bsg_port_cfg_s *cmd = (struct bfa_bsg_port_cfg_s *)iocmd;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	if (v_cmd == IOCMD_PORT_CFG_TOPO)

		cmd->status = bfa_fcport_cfg_topology(&bfad->bfa, cmd->param);

	else if (v_cmd == IOCMD_PORT_CFG_SPEED)

		cmd->status = bfa_fcport_cfg_speed(&bfad->bfa, cmd->param);

	else if (v_cmd == IOCMD_PORT_CFG_ALPA)

		cmd->status = bfa_fcport_cfg_hardalpa(&bfad->bfa, cmd->param);

	else if (v_cmd == IOCMD_PORT_CLR_ALPA)

		cmd->status = bfa_fcport_clr_hardalpa(&bfad->bfa);

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);



	return 0;

}



int

bfad_iocmd_port_cfg_maxfrsize(struct bfad_s *bfad, void *cmd)

{

	struct bfa_bsg_port_cfg_maxfrsize_s *iocmd =

				(struct bfa_bsg_port_cfg_maxfrsize_s *)cmd;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	iocmd->status = bfa_fcport_cfg_maxfrsize(&bfad->bfa, iocmd->maxfrsize);

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);



	return 0;

}



int

bfad_iocmd_port_cfg_bbsc(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)

{

	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;

	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	if (bfa_ioc_get_type(&bfad->bfa.ioc) == BFA_IOC_TYPE_FC) {

		if (v_cmd == IOCMD_PORT_BBSC_ENABLE)

			fcport->cfg.bb_scn_state = BFA_TRUE;

		else if (v_cmd == IOCMD_PORT_BBSC_DISABLE)

			fcport->cfg.bb_scn_state = BFA_FALSE;

	}

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);



	iocmd->status = BFA_STATUS_OK;

	return 0;

}



static int

bfad_iocmd_lport_get_attr(struct bfad_s *bfad, void *cmd)

{
@@ -354,6 +461,40 @@ bfad_iocmd_lport_get_stats(struct bfad_s *bfad, void *cmd) 
	return 0;

}



int

bfad_iocmd_lport_reset_stats(struct bfad_s *bfad, void *cmd)

{

	struct bfa_fcs_lport_s *fcs_port;

	struct bfa_bsg_reset_stats_s *iocmd =

			(struct bfa_bsg_reset_stats_s *)cmd;

	struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);

	struct list_head *qe, *qen;

	struct bfa_itnim_s *itnim;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,

				iocmd->vf_id, iocmd->vpwwn);

	if (fcs_port == NULL) {

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

		iocmd->status = BFA_STATUS_UNKNOWN_LWWN;

		goto out;

	}



	bfa_fcs_lport_clear_stats(fcs_port);

	/* clear IO stats from all active itnims */

	list_for_each_safe(qe, qen, &fcpim->itnim_q) {

		itnim = (struct bfa_itnim_s *) qe;

		if (itnim->rport->rport_info.lp_tag != fcs_port->lp_tag)

			continue;

		bfa_itnim_clear_stats(itnim);

	}

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	iocmd->status = BFA_STATUS_OK;

out:

	return 0;

}



int

bfad_iocmd_lport_get_iostats(struct bfad_s *bfad, void *cmd)

{
@@ -540,6 +681,152 @@ bfad_iocmd_rport_get_stats(struct bfad_s *bfad, void *cmd) 
	return 0;

}



int

bfad_iocmd_rport_clr_stats(struct bfad_s *bfad, void *cmd)

{

	struct bfa_bsg_rport_reset_stats_s *iocmd =

				(struct bfa_bsg_rport_reset_stats_s *)cmd;

	struct bfa_fcs_lport_s *fcs_port;

	struct bfa_fcs_rport_s *fcs_rport;

	struct bfa_rport_s *rport;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,

				iocmd->vf_id, iocmd->pwwn);

	if (fcs_port == NULL) {

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

		iocmd->status = BFA_STATUS_UNKNOWN_LWWN;

		goto out;

	}



	fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);

	if (fcs_rport == NULL) {

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

		iocmd->status = BFA_STATUS_UNKNOWN_RWWN;

		goto out;

	}



	memset((char *)&fcs_rport->stats, 0, sizeof(struct bfa_rport_stats_s));

	rport = bfa_fcs_rport_get_halrport(fcs_rport);

	memset(&rport->stats, 0, sizeof(rport->stats));

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	iocmd->status = BFA_STATUS_OK;

out:

	return 0;

}



int

bfad_iocmd_rport_set_speed(struct bfad_s *bfad, void *cmd)

{

	struct bfa_bsg_rport_set_speed_s *iocmd =

				(struct bfa_bsg_rport_set_speed_s *)cmd;

	struct bfa_fcs_lport_s *fcs_port;

	struct bfa_fcs_rport_s *fcs_rport;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,

				iocmd->vf_id, iocmd->pwwn);

	if (fcs_port == NULL) {

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

		iocmd->status = BFA_STATUS_UNKNOWN_LWWN;

		goto out;

	}



	fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);

	if (fcs_rport == NULL) {

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

		iocmd->status = BFA_STATUS_UNKNOWN_RWWN;

		goto out;

	}



	fcs_rport->rpf.assigned_speed  = iocmd->speed;

	/* Set this speed in f/w only if the RPSC speed is not available */

	if (fcs_rport->rpf.rpsc_speed == BFA_PORT_SPEED_UNKNOWN)

		bfa_rport_speed(fcs_rport->bfa_rport, iocmd->speed);

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	iocmd->status = BFA_STATUS_OK;

out:

	return 0;

}



int

bfad_iocmd_vport_get_attr(struct bfad_s *bfad, void *cmd)

{

	struct bfa_fcs_vport_s *fcs_vport;

	struct bfa_bsg_vport_attr_s *iocmd = (struct bfa_bsg_vport_attr_s *)cmd;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,

				iocmd->vf_id, iocmd->vpwwn);

	if (fcs_vport == NULL) {

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

		iocmd->status = BFA_STATUS_UNKNOWN_VWWN;

		goto out;

	}



	bfa_fcs_vport_get_attr(fcs_vport, &iocmd->vport_attr);

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	iocmd->status = BFA_STATUS_OK;

out:

	return 0;

}



int

bfad_iocmd_vport_get_stats(struct bfad_s *bfad, void *cmd)

{

	struct bfa_fcs_vport_s *fcs_vport;

	struct bfa_bsg_vport_stats_s *iocmd =

				(struct bfa_bsg_vport_stats_s *)cmd;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,

				iocmd->vf_id, iocmd->vpwwn);

	if (fcs_vport == NULL) {

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

		iocmd->status = BFA_STATUS_UNKNOWN_VWWN;

		goto out;

	}



	memcpy((void *)&iocmd->vport_stats, (void *)&fcs_vport->vport_stats,

		sizeof(struct bfa_vport_stats_s));

	memcpy((void *)&iocmd->vport_stats.port_stats,

	       (void *)&fcs_vport->lport.stats,

		sizeof(struct bfa_lport_stats_s));

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	iocmd->status = BFA_STATUS_OK;

out:

	return 0;

}



int

bfad_iocmd_vport_clr_stats(struct bfad_s *bfad, void *cmd)

{

	struct bfa_fcs_vport_s *fcs_vport;

	struct bfa_bsg_reset_stats_s *iocmd =

				(struct bfa_bsg_reset_stats_s *)cmd;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	fcs_vport = bfa_fcs_vport_lookup(&bfad->bfa_fcs,

				iocmd->vf_id, iocmd->vpwwn);

	if (fcs_vport == NULL) {

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

		iocmd->status = BFA_STATUS_UNKNOWN_VWWN;

		goto out;

	}



	memset(&fcs_vport->vport_stats, 0, sizeof(struct bfa_vport_stats_s));

	memset(&fcs_vport->lport.stats, 0, sizeof(struct bfa_lport_stats_s));

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	iocmd->status = BFA_STATUS_OK;

out:

	return 0;

}



static int

bfad_iocmd_fabric_get_lports(struct bfad_s *bfad, void *cmd,

			unsigned int payload_len)
@@ -582,6 +869,66 @@ bfad_iocmd_fabric_get_lports(struct bfad_s *bfad, void *cmd, 
	return 0;

}



int

bfad_iocmd_ratelim(struct bfad_s *bfad, unsigned int cmd, void *pcmd)

{

	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)pcmd;

	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);



	if (cmd == IOCMD_RATELIM_ENABLE)

		fcport->cfg.ratelimit = BFA_TRUE;

	else if (cmd == IOCMD_RATELIM_DISABLE)

		fcport->cfg.ratelimit = BFA_FALSE;



	if (fcport->cfg.trl_def_speed == BFA_PORT_SPEED_UNKNOWN)

		fcport->cfg.trl_def_speed = BFA_PORT_SPEED_1GBPS;



	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	iocmd->status = BFA_STATUS_OK;



	return 0;

}



int

bfad_iocmd_ratelim_speed(struct bfad_s *bfad, unsigned int cmd, void *pcmd)

{

	struct bfa_bsg_trl_speed_s *iocmd = (struct bfa_bsg_trl_speed_s *)pcmd;

	struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(&bfad->bfa);

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);



	/* Auto and speeds greater than the supported speed, are invalid */

	if ((iocmd->speed == BFA_PORT_SPEED_AUTO) ||

	    (iocmd->speed > fcport->speed_sup)) {

		iocmd->status = BFA_STATUS_UNSUPP_SPEED;

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

		return 0;

	}



	fcport->cfg.trl_def_speed = iocmd->speed;

	iocmd->status = BFA_STATUS_OK;

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);



	return 0;

}



int

bfad_iocmd_cfg_fcpim(struct bfad_s *bfad, void *cmd)

{

	struct bfa_bsg_fcpim_s *iocmd = (struct bfa_bsg_fcpim_s *)cmd;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	bfa_fcpim_path_tov_set(&bfad->bfa, iocmd->param);

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	iocmd->status = BFA_STATUS_OK;

	return 0;

}



int

bfad_iocmd_fcpim_get_modstats(struct bfad_s *bfad, void *cmd)

{
@@ -604,6 +951,28 @@ bfad_iocmd_fcpim_get_modstats(struct bfad_s *bfad, void *cmd) 
	return 0;

}



int

bfad_iocmd_fcpim_clr_modstats(struct bfad_s *bfad, void *cmd)

{

	struct bfa_bsg_fcpim_modstatsclr_s *iocmd =

				(struct bfa_bsg_fcpim_modstatsclr_s *)cmd;

	struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);

	struct list_head *qe, *qen;

	struct bfa_itnim_s *itnim;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	list_for_each_safe(qe, qen, &fcpim->itnim_q) {

		itnim = (struct bfa_itnim_s *) qe;

		bfa_itnim_clear_stats(itnim);

	}

	memset(&fcpim->del_itn_stats, 0,

		sizeof(struct bfa_fcpim_del_itn_stats_s));

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	iocmd->status = BFA_STATUS_OK;

	return 0;

}



int

bfad_iocmd_fcpim_get_del_itn_stats(struct bfad_s *bfad, void *cmd)

{
@@ -670,6 +1039,35 @@ bfad_iocmd_itnim_get_iostats(struct bfad_s *bfad, void *cmd) 
	return 0;

}



static int

bfad_iocmd_itnim_reset_stats(struct bfad_s *bfad, void *cmd)

{

	struct bfa_bsg_rport_reset_stats_s *iocmd =

			(struct bfa_bsg_rport_reset_stats_s *)cmd;

	struct bfa_fcs_lport_s	*fcs_port;

	struct bfa_fcs_itnim_s	*itnim;

	unsigned long	flags;



	spin_lock_irqsave(&bfad->bfad_lock, flags);

	fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,

				iocmd->vf_id, iocmd->pwwn);

	if (!fcs_port)

		iocmd->status = BFA_STATUS_UNKNOWN_LWWN;

	else {

		itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);

		if (itnim == NULL)

			iocmd->status = BFA_STATUS_UNKNOWN_RWWN;

		else {

			iocmd->status = BFA_STATUS_OK;

			bfa_fcs_itnim_stats_clear(fcs_port, iocmd->rpwwn);

			bfa_itnim_clear_stats(bfa_fcs_itnim_get_halitn(itnim));

		}

	}

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);



	return 0;

}



static int

bfad_iocmd_itnim_get_itnstats(struct bfad_s *bfad, void *cmd)

{
@@ -1512,6 +1910,73 @@ bfad_iocmd_porglog_get(struct bfad_s *bfad, void *cmd) 
	return 0;

}



#define BFA_DEBUG_FW_CORE_CHUNK_SZ	0x4000U /* 16K chunks for FW dump */

int

bfad_iocmd_debug_fw_core(struct bfad_s *bfad, void *cmd,

			unsigned int payload_len)

{

	struct bfa_bsg_debug_s *iocmd = (struct bfa_bsg_debug_s *)cmd;

	void	*iocmd_bufptr;

	unsigned long	flags;



	if (bfad_chk_iocmd_sz(payload_len, sizeof(struct bfa_bsg_debug_s),

			BFA_DEBUG_FW_CORE_CHUNK_SZ) != BFA_STATUS_OK) {

		iocmd->status = BFA_STATUS_VERSION_FAIL;

		return 0;

	}



	if (iocmd->bufsz < BFA_DEBUG_FW_CORE_CHUNK_SZ ||

			!IS_ALIGNED(iocmd->bufsz, sizeof(u16)) ||

			!IS_ALIGNED(iocmd->offset, sizeof(u32))) {

		bfa_trc(bfad, BFA_DEBUG_FW_CORE_CHUNK_SZ);

		iocmd->status = BFA_STATUS_EINVAL;

		goto out;

	}



	iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_debug_s);

	spin_lock_irqsave(&bfad->bfad_lock, flags);

	iocmd->status = bfa_ioc_debug_fwcore(&bfad->bfa.ioc, iocmd_bufptr,

				(u32 *)&iocmd->offset, &iocmd->bufsz);

	spin_unlock_irqrestore(&bfad->bfad_lock, flags);

out:

	return 0;

}



int

bfad_iocmd_debug_ctl(struct bfad_s *bfad, void *cmd, unsigned int v_cmd)

{

	struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;

	unsigned long	flags;



	if (v_cmd == IOCMD_DEBUG_FW_STATE_CLR) {

		spin_lock_irqsave(&bfad->bfad_lock, flags);

		bfad->bfa.ioc.dbg_fwsave_once = BFA_TRUE;

		spin_unlock_irqrestore(&bfad->bfad_lock, flags);

	} else if (v_cmd == IOCMD_DEBUG_PORTLOG_CLR)

		bfad->plog_buf.head = bfad->plog_buf.tail = 0;

	else if (v_cmd == IOCMD_DEBUG_START_DTRC)

		bfa_trc_init(bfad->trcmod);

	else if (v_cmd == IOCMD_DEBUG_STOP_DTRC)

		bfa_trc_stop(bfad->trcmod);



	iocmd->status = BFA_STATUS_OK;

	return 0;

}



int

bfad_iocmd_porglog_ctl(struct bfad_s *bfad, void *cmd)

{

	struct bfa_bsg_portlogctl_s *iocmd = (struct bfa_bsg_portlogctl_s *)cmd;



	if (iocmd->ctl == BFA_TRUE)

		bfad->plog_buf.plog_enabled = 1;

	else

		bfad->plog_buf.plog_enabled = 0;



	iocmd->status = BFA_STATUS_OK;

	return 0;

}



static int

bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,

		unsigned int payload_len)
@@ -1537,6 +2002,14 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd, 
	case IOCMD_IOC_GET_FWSTATS:

		rc = bfad_iocmd_ioc_get_fwstats(bfad, iocmd, payload_len);

		break;

	case IOCMD_IOC_RESET_STATS:

	case IOCMD_IOC_RESET_FWSTATS:

		rc = bfad_iocmd_ioc_reset_stats(bfad, iocmd, cmd);

		break;

	case IOCMD_IOC_SET_ADAPTER_NAME:

	case IOCMD_IOC_SET_PORT_NAME:

		rc = bfad_iocmd_ioc_set_name(bfad, iocmd, cmd);

		break;

	case IOCMD_IOCFC_GET_ATTR:

		rc = bfad_iocmd_iocfc_get_attr(bfad, iocmd);

		break;
@@ -1555,12 +2028,31 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd, 
	case IOCMD_PORT_GET_STATS:

		rc = bfad_iocmd_port_get_stats(bfad, iocmd, payload_len);

		break;

	case IOCMD_PORT_RESET_STATS:

		rc = bfad_iocmd_port_reset_stats(bfad, iocmd);

		break;

	case IOCMD_PORT_CFG_TOPO:

	case IOCMD_PORT_CFG_SPEED:

	case IOCMD_PORT_CFG_ALPA:

	case IOCMD_PORT_CLR_ALPA:

		rc = bfad_iocmd_set_port_cfg(bfad, iocmd, cmd);

		break;

	case IOCMD_PORT_CFG_MAXFRSZ:

		rc = bfad_iocmd_port_cfg_maxfrsize(bfad, iocmd);

		break;

	case IOCMD_PORT_BBSC_ENABLE:

	case IOCMD_PORT_BBSC_DISABLE:

		rc = bfad_iocmd_port_cfg_bbsc(bfad, iocmd, cmd);

		break;

	case IOCMD_LPORT_GET_ATTR:

		rc = bfad_iocmd_lport_get_attr(bfad, iocmd);

		break;

	case IOCMD_LPORT_GET_STATS:

		rc = bfad_iocmd_lport_get_stats(bfad, iocmd);

		break;

	case IOCMD_LPORT_RESET_STATS:

		rc = bfad_iocmd_lport_reset_stats(bfad, iocmd);

		break;

	case IOCMD_LPORT_GET_IOSTATS:

		rc = bfad_iocmd_lport_get_iostats(bfad, iocmd);

		break;
@@ -1576,12 +2068,40 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd, 
	case IOCMD_RPORT_GET_STATS:

		rc = bfad_iocmd_rport_get_stats(bfad, iocmd);

		break;

	case IOCMD_RPORT_RESET_STATS:

		rc = bfad_iocmd_rport_clr_stats(bfad, iocmd);

		break;

	case IOCMD_RPORT_SET_SPEED:

		rc = bfad_iocmd_rport_set_speed(bfad, iocmd);

		break;

	case IOCMD_VPORT_GET_ATTR:

		rc = bfad_iocmd_vport_get_attr(bfad, iocmd);

		break;

	case IOCMD_VPORT_GET_STATS:

		rc = bfad_iocmd_vport_get_stats(bfad, iocmd);

		break;

	case IOCMD_VPORT_RESET_STATS:

		rc = bfad_iocmd_vport_clr_stats(bfad, iocmd);

		break;

	case IOCMD_FABRIC_GET_LPORTS:

		rc = bfad_iocmd_fabric_get_lports(bfad, iocmd, payload_len);

		break;

	case IOCMD_RATELIM_ENABLE:

	case IOCMD_RATELIM_DISABLE:

		rc = bfad_iocmd_ratelim(bfad, cmd, iocmd);

		break;

	case IOCMD_RATELIM_DEF_SPEED:

		rc = bfad_iocmd_ratelim_speed(bfad, cmd, iocmd);

		break;

	case IOCMD_FCPIM_FAILOVER:

		rc = bfad_iocmd_cfg_fcpim(bfad, iocmd);

		break;

	case IOCMD_FCPIM_MODSTATS:

		rc = bfad_iocmd_fcpim_get_modstats(bfad, iocmd);

		break;

	case IOCMD_FCPIM_MODSTATSCLR:

		rc = bfad_iocmd_fcpim_clr_modstats(bfad, iocmd);

		break;

	case IOCMD_FCPIM_DEL_ITN_STATS:

		rc = bfad_iocmd_fcpim_get_del_itn_stats(bfad, iocmd);

		break;
@@ -1591,6 +2111,9 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd, 
	case IOCMD_ITNIM_GET_IOSTATS:

		rc = bfad_iocmd_itnim_get_iostats(bfad, iocmd);

		break;

	case IOCMD_ITNIM_RESET_STATS:

		rc = bfad_iocmd_itnim_reset_stats(bfad, iocmd);

		break;

	case IOCMD_ITNIM_GET_ITNSTATS:

		rc = bfad_iocmd_itnim_get_itnstats(bfad, iocmd);

		break;
@@ -1703,6 +2226,18 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd, 
	case IOCMD_DEBUG_PORTLOG:

		rc = bfad_iocmd_porglog_get(bfad, iocmd);

		break;

	case IOCMD_DEBUG_FW_CORE:

		rc = bfad_iocmd_debug_fw_core(bfad, iocmd, payload_len);

		break;

	case IOCMD_DEBUG_FW_STATE_CLR:

	case IOCMD_DEBUG_PORTLOG_CLR:

	case IOCMD_DEBUG_START_DTRC:

	case IOCMD_DEBUG_STOP_DTRC:

		rc = bfad_iocmd_debug_ctl(bfad, iocmd, cmd);

		break;

	case IOCMD_DEBUG_PORTLOG_CTL:

		rc = bfad_iocmd_porglog_ctl(bfad, iocmd);

		break;

	default:

		rc = -EINVAL;

		break;

drivers/scsi/bfa/bfad_bsg.h

+118 −0
Original line number Diff line number Diff line
@@ -30,24 +30,48 @@ enum { 
	IOCMD_IOC_GET_INFO,

	IOCMD_IOC_GET_STATS,

	IOCMD_IOC_GET_FWSTATS,

	IOCMD_IOC_RESET_STATS,

	IOCMD_IOC_RESET_FWSTATS,

	IOCMD_IOC_SET_ADAPTER_NAME,

	IOCMD_IOC_SET_PORT_NAME,

	IOCMD_IOCFC_GET_ATTR,

	IOCMD_IOCFC_SET_INTR,

	IOCMD_PORT_ENABLE,

	IOCMD_PORT_DISABLE,

	IOCMD_PORT_GET_ATTR,

	IOCMD_PORT_GET_STATS,

	IOCMD_PORT_RESET_STATS,

	IOCMD_PORT_CFG_TOPO,

	IOCMD_PORT_CFG_SPEED,

	IOCMD_PORT_CFG_ALPA,

	IOCMD_PORT_CFG_MAXFRSZ,

	IOCMD_PORT_CLR_ALPA,

	IOCMD_PORT_BBSC_ENABLE,

	IOCMD_PORT_BBSC_DISABLE,

	IOCMD_LPORT_GET_ATTR,

	IOCMD_LPORT_GET_RPORTS,

	IOCMD_LPORT_GET_STATS,

	IOCMD_LPORT_RESET_STATS,

	IOCMD_LPORT_GET_IOSTATS,

	IOCMD_RPORT_GET_ATTR,

	IOCMD_RPORT_GET_ADDR,

	IOCMD_RPORT_GET_STATS,

	IOCMD_RPORT_RESET_STATS,

	IOCMD_RPORT_SET_SPEED,

	IOCMD_VPORT_GET_ATTR,

	IOCMD_VPORT_GET_STATS,

	IOCMD_VPORT_RESET_STATS,

	IOCMD_FABRIC_GET_LPORTS,

	IOCMD_RATELIM_ENABLE,

	IOCMD_RATELIM_DISABLE,

	IOCMD_RATELIM_DEF_SPEED,

	IOCMD_FCPIM_FAILOVER,

	IOCMD_FCPIM_MODSTATS,

	IOCMD_FCPIM_MODSTATSCLR,

	IOCMD_FCPIM_DEL_ITN_STATS,

	IOCMD_ITNIM_GET_ATTR,

	IOCMD_ITNIM_GET_IOSTATS,

	IOCMD_ITNIM_RESET_STATS,

	IOCMD_ITNIM_GET_ITNSTATS,

	IOCMD_IOC_PCIFN_CFG,

	IOCMD_FCPORT_ENABLE,
@@ -86,6 +110,12 @@ enum { 
	IOCMD_PHY_READ_FW,

	IOCMD_VHBA_QUERY,

	IOCMD_DEBUG_PORTLOG,

	IOCMD_DEBUG_FW_CORE,

	IOCMD_DEBUG_FW_STATE_CLR,

	IOCMD_DEBUG_PORTLOG_CLR,

	IOCMD_DEBUG_START_DTRC,

	IOCMD_DEBUG_STOP_DTRC,

	IOCMD_DEBUG_PORTLOG_CTL,

};



struct bfa_bsg_gen_s {
@@ -94,6 +124,21 @@ struct bfa_bsg_gen_s { 
	u16		rsvd;

};



struct bfa_bsg_portlogctl_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		rsvd;

	bfa_boolean_t	ctl;

	int		inst_no;

};



struct bfa_bsg_ioc_name_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		rsvd;

	char		name[BFA_ADAPTER_SYM_NAME_LEN];

};



struct bfa_bsg_ioc_info_s {

	bfa_status_t	status;

	u16		bfad_num;
@@ -164,6 +209,20 @@ struct bfa_bsg_port_attr_s { 
	struct bfa_port_attr_s	attr;

};



struct bfa_bsg_port_cfg_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		rsvd;

	u32		param;

	u32		rsvd1;

};



struct bfa_bsg_port_cfg_maxfrsize_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		maxfrsize;

};



struct bfa_bsg_port_stats_s {

	bfa_status_t	status;

	u16		bfad_num;
@@ -237,6 +296,47 @@ struct bfa_bsg_rport_scsi_addr_s { 
	u32		lun;

};



struct bfa_bsg_rport_reset_stats_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		vf_id;

	wwn_t		pwwn;

	wwn_t		rpwwn;

};



struct bfa_bsg_rport_set_speed_s {

	bfa_status_t		status;

	u16			bfad_num;

	u16			vf_id;

	enum bfa_port_speed	speed;

	u32			rsvd;

	wwn_t			pwwn;

	wwn_t			rpwwn;

};



struct bfa_bsg_vport_attr_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		vf_id;

	wwn_t		vpwwn;

	struct bfa_vport_attr_s vport_attr;

};



struct bfa_bsg_vport_stats_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		vf_id;

	wwn_t		vpwwn;

	struct bfa_vport_stats_s vport_stats;

};



struct bfa_bsg_reset_stats_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		vf_id;

	wwn_t		vpwwn;

};



struct bfa_bsg_fabric_get_lports_s {

	bfa_status_t	status;

	u16		bfad_num;
@@ -246,6 +346,19 @@ struct bfa_bsg_fabric_get_lports_s { 
	u32		rsvd;

};



struct bfa_bsg_trl_speed_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		rsvd;

	enum bfa_port_speed speed;

};



struct bfa_bsg_fcpim_s {

	bfa_status_t	status;

	u16		bfad_num;

	u16		param;

};



struct bfa_bsg_fcpim_modstats_s {

	bfa_status_t	status;

	u16		bfad_num;
@@ -258,6 +371,11 @@ struct bfa_bsg_fcpim_del_itn_stats_s { 
	struct bfa_fcpim_del_itn_stats_s modstats;

};



struct bfa_bsg_fcpim_modstatsclr_s {

	bfa_status_t	status;

	u16		bfad_num;

};



struct bfa_bsg_itnim_attr_s {

	bfa_status_t	status;

	u16		bfad_num;