Commit 2dc33bbc authored by Yuval Mintz's avatar Yuval Mintz Committed by David S. Miller
Browse files

bnx2x: Remove the sriov VFOP mechanism 



Since we now posses a workqueue dedicated for sriov, the paradigm that sriov-
related tasks cannot sleep is no longer correct.

The VFOP mechanism was the one previously supporting said paradigm - the sriov
related tasks were broken into segments which did not require sleep, and the
mechanism re-scheduled the next segment whenever possible.

This patch remvoes the VFOP mechanism altogether - the resulting code is a much
easier to follow code; The segments are gathered into straight-forward
functions which sleep whenever neccessary.

Signed-off-by: default avatarYuval Mintz <Yuval.Mintz@qlogic.com>
Signed-off-by: default avatarAriel Elior <Ariel.Elior@qlogic.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 370d4a26

drivers/net/ethernet/broadcom/bnx2x/bnx2x.h

+0 −1
Original line number Diff line number Diff line
@@ -1414,7 +1414,6 @@ enum sp_rtnl_flag { 


enum bnx2x_iov_flag {

	BNX2X_IOV_HANDLE_VF_MSG,

	BNX2X_IOV_CONT_VFOP,

	BNX2X_IOV_HANDLE_FLR,

};

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

+0 −2
Original line number Diff line number Diff line
@@ -1857,8 +1857,6 @@ void bnx2x_sp_event(struct bnx2x_fastpath *fp, union eth_rx_cqe *rr_cqe) 
#else

		return;

#endif

	/* SRIOV: reschedule any 'in_progress' operations */

	bnx2x_iov_sp_event(bp, cid);



	smp_mb__before_atomic_inc();

	atomic_inc(&bp->cq_spq_left);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.c

+431 −1373

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/ethernet/broadcom/bnx2x/bnx2x_sriov.h

+36 −312
Original line number Diff line number Diff line
@@ -88,113 +88,32 @@ struct bnx2x_vf_queue { 
	bool sp_initialized;

};



/* struct bnx2x_vfop_qctor_params - prepare queue construction parameters:

 * q-init, q-setup and SB index

/* struct bnx2x_vf_queue_construct_params - prepare queue construction

 * parameters: q-init, q-setup and SB index

 */

struct bnx2x_vfop_qctor_params {

struct bnx2x_vf_queue_construct_params {

	struct bnx2x_queue_state_params		qstate;

	struct bnx2x_queue_setup_params		prep_qsetup;

};



/* VFOP parameters (one copy per VF) */

union bnx2x_vfop_params {

	struct bnx2x_vlan_mac_ramrod_params	vlan_mac;

	struct bnx2x_rx_mode_ramrod_params	rx_mode;

	struct bnx2x_mcast_ramrod_params	mcast;

	struct bnx2x_config_rss_params		rss;

	struct bnx2x_vfop_qctor_params		qctor;

	struct bnx2x_queue_state_params		qstate;

};



/* forward */

struct bnx2x_virtf;



/* VFOP definitions */

typedef void (*vfop_handler_t)(struct bnx2x *bp, struct bnx2x_virtf *vf);



struct bnx2x_vfop_cmd {

	vfop_handler_t done;

	bool block;

};



/* VFOP queue filters command additional arguments */

struct bnx2x_vfop_filter {

	struct list_head link;

struct bnx2x_vf_mac_vlan_filter {

	int type;

#define BNX2X_VFOP_FILTER_MAC	1

#define BNX2X_VFOP_FILTER_VLAN	2

#define BNX2X_VF_FILTER_MAC	1

#define BNX2X_VF_FILTER_VLAN	2



	bool add;

	u8 *mac;

	u16 vid;

};



struct bnx2x_vfop_filters {

	int add_cnt;

	struct list_head head;

	struct bnx2x_vfop_filter filters[];

};



/* transient list allocated, built and saved until its

 * passed to the SP-VERBs layer.

 */

struct bnx2x_vfop_args_mcast {

	int mc_num;

	struct bnx2x_mcast_list_elem *mc;

};



struct bnx2x_vfop_args_qctor {

	int	qid;

	u16	sb_idx;

};



struct bnx2x_vfop_args_qdtor {

	int	qid;

	struct eth_context *cxt;

};



struct bnx2x_vfop_args_defvlan {

	int	qid;

	bool	enable;

	u16	vid;

	u8	prio;

};



struct bnx2x_vfop_args_qx {

	int	qid;

	bool	en_add;

};



struct bnx2x_vfop_args_filters {

	struct bnx2x_vfop_filters *multi_filter;

	atomic_t *credit;	/* non NULL means 'don't consume credit' */

};



struct bnx2x_vfop_args_tpa {

	int	   qid;

	dma_addr_t sge_map[PFVF_MAX_QUEUES_PER_VF];

};



union bnx2x_vfop_args {

	struct bnx2x_vfop_args_mcast	mc_list;

	struct bnx2x_vfop_args_qctor	qctor;

	struct bnx2x_vfop_args_qdtor	qdtor;

	struct bnx2x_vfop_args_defvlan	defvlan;

	struct bnx2x_vfop_args_qx	qx;

	struct bnx2x_vfop_args_filters	filters;

	struct bnx2x_vfop_args_tpa	tpa;

};



struct bnx2x_vfop {

	struct list_head link;

	int			rc;		/* return code */

	int			state;		/* next state */

	union bnx2x_vfop_args	args;		/* extra arguments */

	union bnx2x_vfop_params *op_p;		/* ramrod params */



	/* state machine callbacks */

	vfop_handler_t transition;

	vfop_handler_t done;

struct bnx2x_vf_mac_vlan_filters {

	int count;

	struct bnx2x_vf_mac_vlan_filter filters[];

};



/* vf context */
@@ -214,15 +133,7 @@ struct bnx2x_virtf { 
#define VF_ENABLED	2	/* VF Enabled */

#define VF_RESET	3	/* VF FLR'd, pending cleanup */



	/* non 0 during flr cleanup */

	u8 flr_clnup_stage;

#define VF_FLR_CLN	1	/* reclaim resources and do 'final cleanup'

				 * sans the end-wait

				 */

#define VF_FLR_ACK	2	/* ACK flr notification */

#define VF_FLR_EPILOG	3	/* wait for VF remnants to dissipate in the HW

				 * ~ final cleanup' end wait

				 */

	bool flr_clnup_stage;	/* true during flr cleanup */



	/* dma */

	dma_addr_t fw_stat_map;		/* valid iff VF_CFG_STATS */
@@ -286,11 +197,6 @@ struct bnx2x_virtf { 
	struct bnx2x_rss_config_obj     rss_conf_obj;



	/* slow-path operations */

	atomic_t			op_in_progress;

	int				op_rc;

	bool				op_wait_blocking;

	struct list_head		op_list_head;

	union bnx2x_vfop_params		op_params;

	struct mutex			op_mutex; /* one vfop at a time mutex */

	enum channel_tlvs		op_current;

};
@@ -477,7 +383,6 @@ void bnx2x_iov_init_dq(struct bnx2x *bp); 
void bnx2x_iov_init_dmae(struct bnx2x *bp);

void bnx2x_iov_set_queue_sp_obj(struct bnx2x *bp, int vf_cid,

				struct bnx2x_queue_sp_obj **q_obj);

void bnx2x_iov_sp_event(struct bnx2x *bp, int vf_cid);

int bnx2x_iov_eq_sp_event(struct bnx2x *bp, union event_ring_elem *elem);

void bnx2x_iov_adjust_stats_req(struct bnx2x *bp);

void bnx2x_iov_storm_stats_update(struct bnx2x *bp);
@@ -497,163 +402,6 @@ int bnx2x_vf_acquire(struct bnx2x *bp, struct bnx2x_virtf *vf, 
int bnx2x_vf_init(struct bnx2x *bp, struct bnx2x_virtf *vf,

		  dma_addr_t *sb_map);



/* VFOP generic helpers */

#define bnx2x_vfop_default(state) do {				\

		BNX2X_ERR("Bad state %d\n", (state));		\

		vfop->rc = -EINVAL;				\

		goto op_err;					\

	} while (0)



enum {

	VFOP_DONE,

	VFOP_CONT,

	VFOP_VERIFY_PEND,

};



#define bnx2x_vfop_finalize(vf, rc, next) do {				\

		if ((rc) < 0)						\

			goto op_err;					\

		else if ((rc) > 0)					\

			goto op_pending;				\

		else if ((next) == VFOP_DONE)				\

			goto op_done;					\

		else if ((next) == VFOP_VERIFY_PEND)			\

			BNX2X_ERR("expected pending\n");		\

		else {							\

			DP(BNX2X_MSG_IOV, "no ramrod. Scheduling\n");	\

			atomic_set(&vf->op_in_progress, 1);		\

			bnx2x_schedule_iov_task(bp,			\

						BNX2X_IOV_CONT_VFOP);	\

			return;						\

		}							\

	} while (0)



#define bnx2x_vfop_opset(first_state, trans_hndlr, done_hndlr)		\

	do {								\

		vfop->state = first_state;				\

		vfop->op_p = &vf->op_params;				\

		vfop->transition = trans_hndlr;				\

		vfop->done = done_hndlr;				\

	} while (0)



static inline struct bnx2x_vfop *bnx2x_vfop_cur(struct bnx2x *bp,

						struct bnx2x_virtf *vf)

{

	WARN(!mutex_is_locked(&vf->op_mutex), "about to access vf op linked list but mutex was not locked!");

	WARN_ON(list_empty(&vf->op_list_head));

	return list_first_entry(&vf->op_list_head, struct bnx2x_vfop, link);

}



static inline struct bnx2x_vfop *bnx2x_vfop_add(struct bnx2x *bp,

						struct bnx2x_virtf *vf)

{

	struct bnx2x_vfop *vfop = kzalloc(sizeof(*vfop), GFP_KERNEL);



	WARN(!mutex_is_locked(&vf->op_mutex), "about to access vf op linked list but mutex was not locked!");

	if (vfop) {

		INIT_LIST_HEAD(&vfop->link);

		list_add(&vfop->link, &vf->op_list_head);

	}

	return vfop;

}



static inline void bnx2x_vfop_end(struct bnx2x *bp, struct bnx2x_virtf *vf,

				  struct bnx2x_vfop *vfop)

{

	/* rc < 0 - error, otherwise set to 0 */

	DP(BNX2X_MSG_IOV, "rc was %d\n", vfop->rc);

	if (vfop->rc >= 0)

		vfop->rc = 0;

	DP(BNX2X_MSG_IOV, "rc is now %d\n", vfop->rc);



	/* unlink the current op context and propagate error code

	 * must be done before invoking the 'done()' handler

	 */

	WARN(!mutex_is_locked(&vf->op_mutex),

	     "about to access vf op linked list but mutex was not locked!");

	list_del(&vfop->link);



	if (list_empty(&vf->op_list_head)) {

		DP(BNX2X_MSG_IOV, "list was empty %d\n", vfop->rc);

		vf->op_rc = vfop->rc;

		DP(BNX2X_MSG_IOV, "copying rc vf->op_rc %d,  vfop->rc %d\n",

		   vf->op_rc, vfop->rc);

	} else {

		struct bnx2x_vfop *cur_vfop;



		DP(BNX2X_MSG_IOV, "list not empty %d\n", vfop->rc);

		cur_vfop = bnx2x_vfop_cur(bp, vf);

		cur_vfop->rc = vfop->rc;

		DP(BNX2X_MSG_IOV, "copying rc vf->op_rc %d, vfop->rc %d\n",

		   vf->op_rc, vfop->rc);

	}



	/* invoke done handler */

	if (vfop->done) {

		DP(BNX2X_MSG_IOV, "calling done handler\n");

		vfop->done(bp, vf);

	} else {

		/* there is no done handler for the operation to unlock

		 * the mutex. Must have gotten here from PF initiated VF RELEASE

		 */

		bnx2x_unlock_vf_pf_channel(bp, vf, CHANNEL_TLV_PF_RELEASE_VF);

	}



	DP(BNX2X_MSG_IOV, "done handler complete. vf->op_rc %d, vfop->rc %d\n",

	   vf->op_rc, vfop->rc);



	/* if this is the last nested op reset the wait_blocking flag

	 * to release any blocking wrappers, only after 'done()' is invoked

	 */

	if (list_empty(&vf->op_list_head)) {

		DP(BNX2X_MSG_IOV, "list was empty after done %d\n", vfop->rc);

		vf->op_wait_blocking = false;

	}



	kfree(vfop);

}



static inline int bnx2x_vfop_wait_blocking(struct bnx2x *bp,

					   struct bnx2x_virtf *vf)

{

	/* can take a while if any port is running */

	int cnt = 5000;



	might_sleep();

	while (cnt--) {

		if (vf->op_wait_blocking == false) {

#ifdef BNX2X_STOP_ON_ERROR

			DP(BNX2X_MSG_IOV, "exit  (cnt %d)\n", 5000 - cnt);

#endif

			return 0;

		}

		usleep_range(1000, 2000);



		if (bp->panic)

			return -EIO;

	}



	/* timeout! */

#ifdef BNX2X_STOP_ON_ERROR

	bnx2x_panic();

#endif



	return -EBUSY;

}



static inline int bnx2x_vfop_transition(struct bnx2x *bp,

					struct bnx2x_virtf *vf,

					vfop_handler_t transition,

					bool block)

{

	if (block)

		vf->op_wait_blocking = true;

	transition(bp, vf);

	if (block)

		return bnx2x_vfop_wait_blocking(bp, vf);

	return 0;

}



/* VFOP queue construction helpers */

void bnx2x_vfop_qctor_dump_tx(struct bnx2x *bp, struct bnx2x_virtf *vf,

			    struct bnx2x_queue_init_params *init_params,
@@ -668,64 +416,41 @@ void bnx2x_vfop_qctor_dump_rx(struct bnx2x *bp, struct bnx2x_virtf *vf, 
void bnx2x_vfop_qctor_prep(struct bnx2x *bp,

			   struct bnx2x_virtf *vf,

			   struct bnx2x_vf_queue *q,

			   struct bnx2x_vfop_qctor_params *p,

			   struct bnx2x_vf_queue_construct_params *p,

			   unsigned long q_type);

int bnx2x_vfop_mac_list_cmd(struct bnx2x *bp,

			    struct bnx2x_virtf *vf,

			    struct bnx2x_vfop_cmd *cmd,

			    struct bnx2x_vfop_filters *macs,

			    int qid, bool drv_only);



int bnx2x_vfop_vlan_list_cmd(struct bnx2x *bp,

			     struct bnx2x_virtf *vf,

			     struct bnx2x_vfop_cmd *cmd,

			     struct bnx2x_vfop_filters *vlans,

int bnx2x_vf_mac_vlan_config_list(struct bnx2x *bp, struct bnx2x_virtf *vf,

				  struct bnx2x_vf_mac_vlan_filters *filters,

				  int qid, bool drv_only);



int bnx2x_vfop_qsetup_cmd(struct bnx2x *bp,

			  struct bnx2x_virtf *vf,

			  struct bnx2x_vfop_cmd *cmd,

			  int qid);

int bnx2x_vf_queue_setup(struct bnx2x *bp, struct bnx2x_virtf *vf, int qid,

			 struct bnx2x_vf_queue_construct_params *qctor);



int bnx2x_vfop_qdown_cmd(struct bnx2x *bp,

			 struct bnx2x_virtf *vf,

			 struct bnx2x_vfop_cmd *cmd,

			 int qid);

int bnx2x_vf_queue_teardown(struct bnx2x *bp, struct bnx2x_virtf *vf, int qid);



int bnx2x_vfop_mcast_cmd(struct bnx2x *bp,

			 struct bnx2x_virtf *vf,

			 struct bnx2x_vfop_cmd *cmd,

			 bnx2x_mac_addr_t *mcasts,

			 int mcast_num, bool drv_only);

int bnx2x_vf_mcast(struct bnx2x *bp, struct bnx2x_virtf *vf,

		   bnx2x_mac_addr_t *mcasts, int mc_num, bool drv_only);



int bnx2x_vfop_rxmode_cmd(struct bnx2x *bp,

			  struct bnx2x_virtf *vf,

			  struct bnx2x_vfop_cmd *cmd,

int bnx2x_vf_rxmode(struct bnx2x *bp, struct bnx2x_virtf *vf,

		    int qid, unsigned long accept_flags);



int bnx2x_vfop_close_cmd(struct bnx2x *bp,

			 struct bnx2x_virtf *vf,

			 struct bnx2x_vfop_cmd *cmd);

int bnx2x_vf_close(struct bnx2x *bp, struct bnx2x_virtf *vf);



int bnx2x_vfop_release_cmd(struct bnx2x *bp,

			   struct bnx2x_virtf *vf,

			   struct bnx2x_vfop_cmd *cmd);

int bnx2x_vf_free(struct bnx2x *bp, struct bnx2x_virtf *vf);



int bnx2x_vfop_rss_cmd(struct bnx2x *bp,

		       struct bnx2x_virtf *vf,

		       struct bnx2x_vfop_cmd *cmd);

int bnx2x_vf_rss_update(struct bnx2x *bp, struct bnx2x_virtf *vf,

			struct bnx2x_config_rss_params *rss);



int bnx2x_vfop_tpa_cmd(struct bnx2x *bp,

		       struct bnx2x_virtf *vf,

		       struct bnx2x_vfop_cmd *cmd,

		       struct vfpf_tpa_tlv *tpa_tlv);

int bnx2x_vf_tpa_update(struct bnx2x *bp, struct bnx2x_virtf *vf,

			struct vfpf_tpa_tlv *tlv,

			struct bnx2x_queue_update_tpa_params *params);



/* VF release ~ VF close + VF release-resources

 *

 * Release is the ultimate SW shutdown and is called whenever an

 * irrecoverable error is encountered.

 */

void bnx2x_vf_release(struct bnx2x *bp, struct bnx2x_virtf *vf, bool block);

int bnx2x_vf_release(struct bnx2x *bp, struct bnx2x_virtf *vf);

int bnx2x_vf_idx_by_abs_fid(struct bnx2x *bp, u16 abs_vfid);

u8 bnx2x_vf_max_queue_cnt(struct bnx2x *bp, struct bnx2x_virtf *vf);
@@ -796,7 +521,6 @@ void bnx2x_schedule_iov_task(struct bnx2x *bp, enum bnx2x_iov_flag flag); 


static inline void bnx2x_iov_set_queue_sp_obj(struct bnx2x *bp, int vf_cid,

				struct bnx2x_queue_sp_obj **q_obj) {}

static inline void bnx2x_iov_sp_event(struct bnx2x *bp, int vf_cid) {}

static inline void bnx2x_vf_handle_flr_event(struct bnx2x *bp) {}

static inline int bnx2x_iov_eq_sp_event(struct bnx2x *bp,

					union event_ring_elem *elem) {return 1; }

drivers/net/ethernet/broadcom/bnx2x/bnx2x_vfpf.c

+155 −266

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE