Commit da99dcc9 authored by Maggie Zhang's avatar Maggie Zhang Committed by James Bottomley
Browse files

[SCSI] bfa: remove unused functions and misc cleanups 



Remove unused functions and fix checkpatch errors. Misc cleanups in
comment and formatting.

Signed-off-by: default avatarMaggie Zhang <xmzhang@brocade.com>
Signed-off-by: default avatarJing Huang <huangj@brocade.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@suse.de>
parent f16a1750

drivers/scsi/bfa/bfa_fcbuild.c

+1 −6
Original line number Diff line number Diff line
@@ -807,11 +807,6 @@ fc_rpsc_acc_build(struct fchs_s *fchs, struct fc_rpsc_acc_s *rpsc_acc, 
	return sizeof(struct fc_rpsc_acc_s);

}



/*

 * TBD -

 * . get rid of unnecessary memsets

 */



u16

fc_logo_rsp_parse(struct fchs_s *fchs, int len)

{

drivers/scsi/bfa/bfa_fcpim.c

+46 −294
Original line number Diff line number Diff line
@@ -21,11 +21,6 @@ 
BFA_TRC_FILE(HAL, FCPIM);

BFA_MODULE(fcpim);





#define bfa_fcpim_add_iostats(__l, __r, __stats)	\

	(__l->__stats += __r->__stats)





/*

 *  BFA ITNIM Related definitions

 */
@@ -73,10 +68,8 @@ static void bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim); 
} while (0)



/*

 *  bfa_itnim_sm BFA itnim state machine

 *  itnim state machine event

 */





enum bfa_itnim_event {

	BFA_ITNIM_SM_CREATE = 1,	/*  itnim is created */

	BFA_ITNIM_SM_ONLINE = 2,	/*  itnim is online */
@@ -228,7 +221,6 @@ static void __bfa_cb_ioim_failed(void *cbarg, bfa_boolean_t complete); 
static void __bfa_cb_ioim_pathtov(void *cbarg, bfa_boolean_t complete);

static bfa_boolean_t    bfa_ioim_is_abortable(struct bfa_ioim_s *ioim);





/*

 * forward declaration of BFA IO state machine

 */
@@ -256,7 +248,6 @@ static void bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim, 
					enum bfa_ioim_event event);

static void	bfa_ioim_sm_cmnd_retry(struct bfa_ioim_s *ioim,

					enum bfa_ioim_event event);



/*

 * forward declaration for BFA TSKIM functions

 */
@@ -271,7 +262,6 @@ static bfa_boolean_t bfa_tskim_send(struct bfa_tskim_s *tskim); 
static bfa_boolean_t bfa_tskim_send_abort(struct bfa_tskim_s *tskim);

static void     bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim);





/*

 * forward declaration of BFA TSKIM state machine

 */
@@ -289,7 +279,6 @@ static void bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim, 
					enum bfa_tskim_event event);

static void     bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim,

					enum bfa_tskim_event event);



/*

 *  BFA FCP Initiator Mode module

 */
@@ -378,56 +367,6 @@ bfa_fcpim_iocdisable(struct bfa_s *bfa) 
	}

}



void

bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *lstats,

		struct bfa_itnim_iostats_s *rstats)

{

	bfa_fcpim_add_iostats(lstats, rstats, total_ios);

	bfa_fcpim_add_iostats(lstats, rstats, qresumes);

	bfa_fcpim_add_iostats(lstats, rstats, no_iotags);

	bfa_fcpim_add_iostats(lstats, rstats, io_aborts);

	bfa_fcpim_add_iostats(lstats, rstats, no_tskims);

	bfa_fcpim_add_iostats(lstats, rstats, iocomp_ok);

	bfa_fcpim_add_iostats(lstats, rstats, iocomp_underrun);

	bfa_fcpim_add_iostats(lstats, rstats, iocomp_overrun);

	bfa_fcpim_add_iostats(lstats, rstats, iocomp_aborted);

	bfa_fcpim_add_iostats(lstats, rstats, iocomp_timedout);

	bfa_fcpim_add_iostats(lstats, rstats, iocom_nexus_abort);

	bfa_fcpim_add_iostats(lstats, rstats, iocom_proto_err);

	bfa_fcpim_add_iostats(lstats, rstats, iocom_dif_err);

	bfa_fcpim_add_iostats(lstats, rstats, iocom_sqer_needed);

	bfa_fcpim_add_iostats(lstats, rstats, iocom_res_free);

	bfa_fcpim_add_iostats(lstats, rstats, iocom_hostabrts);

	bfa_fcpim_add_iostats(lstats, rstats, iocom_utags);

	bfa_fcpim_add_iostats(lstats, rstats, io_cleanups);

	bfa_fcpim_add_iostats(lstats, rstats, io_tmaborts);

	bfa_fcpim_add_iostats(lstats, rstats, onlines);

	bfa_fcpim_add_iostats(lstats, rstats, offlines);

	bfa_fcpim_add_iostats(lstats, rstats, creates);

	bfa_fcpim_add_iostats(lstats, rstats, deletes);

	bfa_fcpim_add_iostats(lstats, rstats, create_comps);

	bfa_fcpim_add_iostats(lstats, rstats, delete_comps);

	bfa_fcpim_add_iostats(lstats, rstats, sler_events);

	bfa_fcpim_add_iostats(lstats, rstats, fw_create);

	bfa_fcpim_add_iostats(lstats, rstats, fw_delete);

	bfa_fcpim_add_iostats(lstats, rstats, ioc_disabled);

	bfa_fcpim_add_iostats(lstats, rstats, cleanup_comps);

	bfa_fcpim_add_iostats(lstats, rstats, tm_cmnds);

	bfa_fcpim_add_iostats(lstats, rstats, tm_fw_rsps);

	bfa_fcpim_add_iostats(lstats, rstats, tm_success);

	bfa_fcpim_add_iostats(lstats, rstats, tm_failures);

	bfa_fcpim_add_iostats(lstats, rstats, tm_io_comps);

	bfa_fcpim_add_iostats(lstats, rstats, tm_qresumes);

	bfa_fcpim_add_iostats(lstats, rstats, tm_iocdowns);

	bfa_fcpim_add_iostats(lstats, rstats, tm_cleanups);

	bfa_fcpim_add_iostats(lstats, rstats, tm_cleanup_comps);

	bfa_fcpim_add_iostats(lstats, rstats, io_comps);

	bfa_fcpim_add_iostats(lstats, rstats, input_reqs);

	bfa_fcpim_add_iostats(lstats, rstats, output_reqs);

	bfa_fcpim_add_iostats(lstats, rstats, rd_throughput);

	bfa_fcpim_add_iostats(lstats, rstats, wr_throughput);

}



void

bfa_fcpim_path_tov_set(struct bfa_s *bfa, u16 path_tov)

{
@@ -446,128 +385,6 @@ bfa_fcpim_path_tov_get(struct bfa_s *bfa) 
	return fcpim->path_tov / 1000;

}



bfa_status_t

bfa_fcpim_port_iostats(struct bfa_s *bfa, struct bfa_itnim_iostats_s *stats,

	u8 lp_tag)

{

	struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);

	struct list_head *qe, *qen;

	struct bfa_itnim_s *itnim;



	/* accumulate IO stats from itnim */

	memset(stats, 0, sizeof(struct bfa_itnim_iostats_s));

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

		itnim = (struct bfa_itnim_s *) qe;

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

			continue;

		bfa_fcpim_add_stats(stats, &(itnim->stats));

	}

	return BFA_STATUS_OK;

}

bfa_status_t

bfa_fcpim_get_modstats(struct bfa_s *bfa, struct bfa_itnim_iostats_s *modstats)

{

	struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);

	struct list_head *qe, *qen;

	struct bfa_itnim_s *itnim;



	/* accumulate IO stats from itnim */

	memset(modstats, 0, sizeof(struct bfa_itnim_iostats_s));

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

		itnim = (struct bfa_itnim_s *) qe;

		bfa_fcpim_add_stats(modstats, &(itnim->stats));

	}

	return BFA_STATUS_OK;

}



bfa_status_t

bfa_fcpim_get_del_itn_stats(struct bfa_s *bfa,

	 struct bfa_fcpim_del_itn_stats_s *modstats)

{

	struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);



	*modstats = fcpim->del_itn_stats;



	return BFA_STATUS_OK;

}





bfa_status_t

bfa_fcpim_profile_on(struct bfa_s *bfa, u32 time)

{

	struct bfa_itnim_s *itnim;

	struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);

	struct list_head *qe, *qen;



	/* accumulate IO stats from itnim */

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

		itnim = (struct bfa_itnim_s *) qe;

		bfa_itnim_clear_stats(itnim);

	}

	fcpim->io_profile = BFA_TRUE;

	fcpim->io_profile_start_time = time;

	fcpim->profile_comp = bfa_ioim_profile_comp;

	fcpim->profile_start = bfa_ioim_profile_start;



	return BFA_STATUS_OK;

}

bfa_status_t

bfa_fcpim_profile_off(struct bfa_s *bfa)

{

	struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);

	fcpim->io_profile = BFA_FALSE;

	fcpim->io_profile_start_time = 0;

	fcpim->profile_comp = NULL;

	fcpim->profile_start = NULL;

	return BFA_STATUS_OK;

}



bfa_status_t

bfa_fcpim_port_clear_iostats(struct bfa_s *bfa, u8 lp_tag)

{

	struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);

	struct list_head *qe, *qen;

	struct bfa_itnim_s *itnim;



	/* 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 != lp_tag)

			continue;

		bfa_itnim_clear_stats(itnim);

	}

	return BFA_STATUS_OK;



}



bfa_status_t

bfa_fcpim_clr_modstats(struct bfa_s *bfa)

{

	struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);

	struct list_head *qe, *qen;

	struct bfa_itnim_s *itnim;



	/* clear IO stats from all active itnims */

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



	return BFA_STATUS_OK;

}



void

bfa_fcpim_qdepth_set(struct bfa_s *bfa, u16 q_depth)

{

	struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);



	bfa_assert(q_depth <= BFA_IOCFC_QDEPTH_MAX);



	fcpim->q_depth = q_depth;

}



u16

bfa_fcpim_qdepth_get(struct bfa_s *bfa)

{
@@ -576,26 +393,6 @@ bfa_fcpim_qdepth_get(struct bfa_s *bfa) 
	return fcpim->q_depth;

}



void

bfa_fcpim_update_ioredirect(struct bfa_s *bfa)

{

	bfa_boolean_t ioredirect;



	/*

	 * IO redirection is turned off when QoS is enabled and vice versa

	 */

	ioredirect = bfa_fcport_is_qos_enabled(bfa) ? BFA_FALSE : BFA_TRUE;

}



void

bfa_fcpim_set_ioredirect(struct bfa_s *bfa, bfa_boolean_t state)

{

	struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);

	fcpim->ioredirect = state;

}







/*

 *  BFA ITNIM module state machine functions

 */
@@ -979,9 +776,6 @@ bfa_itnim_sm_offline(struct bfa_itnim_s *itnim, enum bfa_itnim_event event) 
	}

}



/*

 *	IOC h/w failed state.

 */

static void

bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,

				enum bfa_itnim_event event)
@@ -1179,9 +973,6 @@ bfa_itnim_qresume(void *cbarg) 
	bfa_sm_send_event(itnim, BFA_ITNIM_SM_QRESUME);

}









/*

 *  bfa_itnim_public

 */
@@ -1449,8 +1240,6 @@ bfa_itnim_update_del_itn_stats(struct bfa_itnim_s *itnim) 
	fcpim->del_itn_stats.del_tm_iocdowns += itnim->stats.tm_iocdowns;

}







/*

 * bfa_itnim_public

 */
@@ -1499,8 +1288,6 @@ bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *m) 
	}

}







/*

 * bfa_itnim_api

 */
@@ -2553,9 +2340,6 @@ bfa_ioim_is_abortable(struct bfa_ioim_s *ioim) 
	return BFA_TRUE;

}



/*

 *	or after the link comes back.

 */

void

bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim, bfa_boolean_t iotov)

{
@@ -2750,32 +2534,6 @@ bfa_ioim_good_comp_isr(struct bfa_s *bfa, struct bfi_msg_s *m) 
	bfa_sm_send_event(ioim, BFA_IOIM_SM_COMP_GOOD);

}



void

bfa_ioim_profile_start(struct bfa_ioim_s *ioim)

{

	ioim->start_time = jiffies;

}



void

bfa_ioim_profile_comp(struct bfa_ioim_s *ioim)

{

	struct scsi_cmnd *cmnd = (struct scsi_cmnd *) ioim->dio;

	u32 fcp_dl = scsi_bufflen(cmnd);

	u32 index = bfa_ioim_get_index(fcp_dl);

	u64 end_time = jiffies;

	struct bfa_itnim_latency_s *io_lat =

			&(ioim->itnim->ioprofile.io_latency);

	u32 val = (u32)(end_time - ioim->start_time);



	bfa_itnim_ioprofile_update(ioim->itnim, index);



	io_lat->count[index]++;

	io_lat->min[index] = (io_lat->min[index] < val) ?

		io_lat->min[index] : val;

	io_lat->max[index] = (io_lat->max[index] > val) ?

		io_lat->max[index] : val;

	io_lat->avg[index] += val;

}

/*

 * Called by itnim to clean up IO while going offline.

 */
@@ -2909,7 +2667,6 @@ bfa_ioim_abort(struct bfa_ioim_s *ioim) 
	return BFA_STATUS_OK;

}





/*

 *  BFA TSKIM state machine functions

 */
@@ -2952,7 +2709,6 @@ bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event) 
}



/*

 * brief

 * TM command is active, awaiting completion from firmware to

 * cleanup IO requests in TM scope.

 */
@@ -3098,10 +2854,8 @@ bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim, 
	case BFA_TSKIM_SM_DONE:

		bfa_reqq_wcancel(&tskim->reqq_wait);

		/*

		 *

		 * Fall through !!!

		 */



	case BFA_TSKIM_SM_QRESUME:

		bfa_sm_set_state(tskim, bfa_tskim_sm_cleanup);

		bfa_tskim_send_abort(tskim);
@@ -3145,7 +2899,6 @@ bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim, enum bfa_tskim_event event) 
	}

}





static void

__bfa_cb_tskim_done(void *cbarg, bfa_boolean_t complete)

{
@@ -3186,7 +2939,7 @@ bfa_tskim_match_scope(struct bfa_tskim_s *tskim, struct scsi_lun lun) 
	case FCP_TM_CLEAR_TASK_SET:

	case FCP_TM_LUN_RESET:

	case FCP_TM_CLEAR_ACA:

		return (!memcmp(&tskim->lun, &lun, sizeof(lun)));

		return !memcmp(&tskim->lun, &lun, sizeof(lun));



	default:

		bfa_assert(0);
@@ -3362,7 +3115,6 @@ bfa_tskim_iocdisable_ios(struct bfa_tskim_s *tskim) 
	}

}





/*

 * Notification on completions from related ioim.

 */

drivers/scsi/bfa/bfa_fcpim.h

+57 −101
Original line number Diff line number Diff line
@@ -127,7 +127,6 @@ struct bfa_ioim_s { 
	u64			start_time;	/*  IO's Profile start val */

};





struct bfa_ioim_sp_s {

	struct bfi_msg_s	comp_rspmsg;	/*  IO comp f/w response */

	u8			*snsinfo;	/*  sense info for this IO   */
@@ -159,7 +158,6 @@ struct bfa_tskim_s { 
	enum bfi_tskim_status   tsk_status;  /*  TM status	*/

};





/*

 * BFA i-t-n (initiator mode)

 */
@@ -189,7 +187,6 @@ struct bfa_itnim_s { 
	struct bfa_itnim_ioprofile_s  ioprofile;

};





#define bfa_itnim_is_online(_itnim) ((_itnim)->is_online)

#define BFA_FCPIM_MOD(_hal) (&(_hal)->modules.fcpim_mod)

#define BFA_IOIM_FROM_TAG(_fcpim, _iotag)	\
@@ -246,32 +243,14 @@ void bfa_itnim_isr(struct bfa_s *bfa, struct bfi_msg_s *msg); 
void	bfa_itnim_iodone(struct bfa_itnim_s *itnim);

void	bfa_itnim_tskdone(struct bfa_itnim_s *itnim);

bfa_boolean_t   bfa_itnim_hold_io(struct bfa_itnim_s *itnim);

void bfa_ioim_profile_comp(struct bfa_ioim_s *ioim);

void bfa_ioim_profile_start(struct bfa_ioim_s *ioim);





/*

 * bfa fcpim module API functions

 */

void	bfa_fcpim_path_tov_set(struct bfa_s *bfa, u16 path_tov);

u16	bfa_fcpim_path_tov_get(struct bfa_s *bfa);

void		bfa_fcpim_qdepth_set(struct bfa_s *bfa, u16 q_depth);

u16	bfa_fcpim_qdepth_get(struct bfa_s *bfa);

bfa_status_t bfa_fcpim_get_modstats(struct bfa_s *bfa,

	 struct bfa_itnim_iostats_s *modstats);

bfa_status_t bfa_fcpim_port_iostats(struct bfa_s *bfa,

		struct bfa_itnim_iostats_s *stats, u8 lp_tag);

bfa_status_t bfa_fcpim_get_del_itn_stats(struct bfa_s *bfa,

	 struct bfa_fcpim_del_itn_stats_s *modstats);

bfa_status_t bfa_fcpim_port_clear_iostats(struct bfa_s *bfa, u8 lp_tag);

void bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *fcpim_stats,

		struct bfa_itnim_iostats_s *itnim_stats);

bfa_status_t bfa_fcpim_clr_modstats(struct bfa_s *bfa);

void		bfa_fcpim_set_ioredirect(struct bfa_s *bfa,

				bfa_boolean_t state);

void		bfa_fcpim_update_ioredirect(struct bfa_s *bfa);

bfa_status_t bfa_fcpim_profile_on(struct bfa_s *bfa, u32 time);

bfa_status_t bfa_fcpim_profile_off(struct bfa_s *bfa);



#define bfa_fcpim_ioredirect_enabled(__bfa)				\

	(((struct bfa_fcpim_mod_s *)(BFA_FCPIM_MOD(__bfa)))->ioredirect)
@@ -291,29 +270,21 @@ bfa_status_t bfa_fcpim_profile_off(struct bfa_s *bfa); 
struct bfa_itnim_s *bfa_itnim_create(struct bfa_s *bfa,

		struct bfa_rport_s *rport, void *itnim);

void bfa_itnim_delete(struct bfa_itnim_s *itnim);

void		bfa_itnim_online(struct bfa_itnim_s *itnim,

				 bfa_boolean_t seq_rec);

void bfa_itnim_online(struct bfa_itnim_s *itnim, bfa_boolean_t seq_rec);

void bfa_itnim_offline(struct bfa_itnim_s *itnim);

void bfa_itnim_clear_stats(struct bfa_itnim_s *itnim);

bfa_status_t bfa_itnim_get_ioprofile(struct bfa_itnim_s *itnim,

			struct bfa_itnim_ioprofile_s *ioprofile);



#define bfa_itnim_get_reqq(__ioim) (((struct bfa_ioim_s *)__ioim)->itnim->reqq)



/*

 * BFA completion callback for bfa_itnim_online().

 *

 * @param[in]		itnim		FCS or driver itnim instance

 *

 * return None

 */

void	bfa_cb_itnim_online(void *itnim);



/*

 * BFA completion callback for bfa_itnim_offline().

 *

 * @param[in]		itnim		FCS or driver itnim instance

 *

 * return None

 */

void	bfa_cb_itnim_offline(void *itnim);

void	bfa_cb_itnim_tov_begin(void *itnim);
@@ -321,14 +292,9 @@ void bfa_cb_itnim_tov(void *itnim); 


/*

 * BFA notification to FCS/driver for second level error recovery.

 *

 * Atleast one I/O request has timedout and target is unresponsive to

 * repeated abort requests. Second level error recovery should be initiated

 * by starting implicit logout and recovery procedures.

 *

 * @param[in]		itnim		FCS or driver itnim instance

 *

 * return None

 */

void	bfa_cb_itnim_sler(void *itnim);
@@ -345,8 +311,6 @@ void bfa_ioim_start(struct bfa_ioim_s *ioim); 
bfa_status_t	bfa_ioim_abort(struct bfa_ioim_s *ioim);

void		bfa_ioim_delayed_comp(struct bfa_ioim_s *ioim,

				      bfa_boolean_t iotov);





/*

 * I/O completion notification.

 *
@@ -366,19 +330,11 @@ void bfa_cb_ioim_done(void *bfad, struct bfad_ioim_s *dio, 


/*

 * I/O good completion notification.

 *

 * @param[in]		dio			driver IO structure

 *

 * @return None

 */

void bfa_cb_ioim_good_comp(void *bfad, struct bfad_ioim_s *dio);



/*

 * I/O abort completion notification

 *

 * @param[in]		dio			driver IO that was aborted

 *

 * @return None

 */

void bfa_cb_ioim_abort(void *bfad, struct bfad_ioim_s *dio);

drivers/scsi/bfa/bfa_fcs_lport.c

+2 −1
Original line number Diff line number Diff line
@@ -883,7 +883,8 @@ bfa_fcs_lport_get_attr( 


	if (port->fabric) {

		port_attr->port_type = port->fabric->oper_type;

		port_attr->loopback = bfa_sm_cmp_state(port->fabric, bfa_fcs_fabric_sm_loopback);

		port_attr->loopback = bfa_sm_cmp_state(port->fabric,

				bfa_fcs_fabric_sm_loopback);

		port_attr->authfail =

			bfa_sm_cmp_state(port->fabric,

				bfa_fcs_fabric_sm_auth_failed);

drivers/scsi/bfa/bfa_fcs_rport.c

+2 −1
Original line number Diff line number Diff line
@@ -1974,7 +1974,8 @@ bfa_fcs_rport_alloc(struct bfa_fcs_lport_s *port, wwn_t pwwn, u32 rpid) 
		rport->itnim = bfa_fcs_itnim_create(rport);

		if (!rport->itnim) {

			bfa_trc(fcs, rpid);

			bfa_sm_send_event(rport->bfa_rport, BFA_RPORT_SM_DELETE);

			bfa_sm_send_event(rport->bfa_rport,

						BFA_RPORT_SM_DELETE);

			kfree(rport_drv);

			return NULL;

		}