bnx2x: 57712 parity handling (c9ee9206) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/net/bnx2x/bnx2x.h

+17 −8

Original line number	Diff line number	Diff line
		@@ -733,7 +733,6 @@ struct bnx2x_common {

		#define CHIP_METAL(bp) (bp->common.chip_id & 0x00000ff0)
		#define CHIP_BOND_ID(bp) (bp->common.chip_id & 0x0000000f)
		#define CHIP_PARITY_ENABLED(bp) (CHIP_IS_E1(bp) \|\| CHIP_IS_E1H(bp))
		#define CHIP_REV_SIM(bp) (((CHIP_REV_MASK - CHIP_REV_VAL(bp)) >>\
		(CHIP_REV_SHIFT + 1)) \
		<< CHIP_REV_SHIFT)
		@@ -986,11 +985,13 @@ struct hw_context {
		/* forward */
		struct bnx2x_ilt;

		typedef enum {

		enum bnx2x_recovery_state {
		BNX2X_RECOVERY_DONE,
		BNX2X_RECOVERY_INIT,
		BNX2X_RECOVERY_WAIT,
		} bnx2x_recovery_state_t;
		BNX2X_RECOVERY_FAILED
		};

		/*
		* Event queue (EQ or event ring) MC hsi
		@@ -1076,7 +1077,7 @@ struct bnx2x {
		const struct iro *iro_arr;
		#define IRO (bp->iro_arr)

		bnx2x_recovery_state_t recovery_state;
		enum bnx2x_recovery_state recovery_state;
		int is_leader;
		struct msix_entry *msix_table;

		@@ -1800,12 +1801,14 @@ static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
		(AEU_INPUTS_ATTN_BITS_TSDM_HW_INTERRUPT \| \
		AEU_INPUTS_ATTN_BITS_TCM_HW_INTERRUPT \| \
		AEU_INPUTS_ATTN_BITS_TSEMI_HW_INTERRUPT \| \
		AEU_INPUTS_ATTN_BITS_PBF_HW_INTERRUPT)
		AEU_INPUTS_ATTN_BITS_PBCLIENT_HW_INTERRUPT)
		#define HW_PRTY_ASSERT_SET_0 (AEU_INPUTS_ATTN_BITS_BRB_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_PARSER_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_TSDM_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_SEARCHER_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_TSEMI_PARITY_ERROR)
		AEU_INPUTS_ATTN_BITS_TSEMI_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_TCM_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_PBCLIENT_PARITY_ERROR)
		#define HW_INTERRUT_ASSERT_SET_1 \
		(AEU_INPUTS_ATTN_BITS_QM_HW_INTERRUPT \| \
		AEU_INPUTS_ATTN_BITS_TIMERS_HW_INTERRUPT \| \
		@@ -1818,17 +1821,22 @@ static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
		AEU_INPUTS_ATTN_BITS_UPB_HW_INTERRUPT \| \
		AEU_INPUTS_ATTN_BITS_CSDM_HW_INTERRUPT \| \
		AEU_INPUTS_ATTN_BITS_CCM_HW_INTERRUPT)
		#define HW_PRTY_ASSERT_SET_1 (AEU_INPUTS_ATTN_BITS_PBCLIENT_PARITY_ERROR \|\
		#define HW_PRTY_ASSERT_SET_1 (AEU_INPUTS_ATTN_BITS_PBF_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_QM_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_TIMERS_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_XSDM_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_XCM_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_XSEMI_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_DOORBELLQ_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_NIG_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_VAUX_PCI_CORE_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_DEBUG_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_USDM_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_UCM_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_USEMI_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_UPB_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_CSDM_PARITY_ERROR)
		AEU_INPUTS_ATTN_BITS_CSDM_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_CCM_PARITY_ERROR)
		#define HW_INTERRUT_ASSERT_SET_2 \
		(AEU_INPUTS_ATTN_BITS_CSEMI_HW_INTERRUPT \| \
		AEU_INPUTS_ATTN_BITS_CDU_HW_INTERRUPT \| \
		@@ -1840,6 +1848,7 @@ static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
		AEU_INPUTS_ATTN_BITS_PXPPCICLOCKCLIENT_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_CFC_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_CDU_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_DMAE_PARITY_ERROR \|\
		AEU_INPUTS_ATTN_BITS_IGU_PARITY_ERROR \| \
		AEU_INPUTS_ATTN_BITS_MISC_PARITY_ERROR)

drivers/net/bnx2x/bnx2x_cmn.c

+45 −12

Original line number	Diff line number	Diff line
		@@ -1918,13 +1918,23 @@ load_error0:
		int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
		{
		int i;

		if (bp->state == BNX2X_STATE_CLOSED) {
		/* Interface has been removed - nothing to recover */
		bool global = false;

		if ((bp->state == BNX2X_STATE_CLOSED) \|\|
		(bp->state == BNX2X_STATE_ERROR)) {
		/* We can get here if the driver has been unloaded
		* during parity error recovery and is either waiting for a
		* leader to complete or for other functions to unload and
		* then ifdown has been issued. In this case we want to
		* unload and let other functions to complete a recovery
		* process.
		*/
		bp->recovery_state = BNX2X_RECOVERY_DONE;
		bp->is_leader = 0;
		bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_RESERVED_08);
		smp_wmb();
		bnx2x_release_leader_lock(bp);
		smp_mb();

		DP(NETIF_MSG_HW, "Releasing a leadership...\n");

		return -EINVAL;
		}
		@@ -1953,11 +1963,27 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
		if (unload_mode != UNLOAD_RECOVERY)
		bnx2x_chip_cleanup(bp, unload_mode);
		else {
		/* Disable HW interrupts, NAPI and Tx */
		/* Send the UNLOAD_REQUEST to the MCP */
		bnx2x_send_unload_req(bp, unload_mode);

		/*
		* Prevent transactions to host from the functions on the
		* engine that doesn't reset global blocks in case of global
		* attention once gloabl blocks are reset and gates are opened
		* (the engine which leader will perform the recovery
		* last).
		*/
		if (!CHIP_IS_E1x(bp))
		bnx2x_pf_disable(bp);

		/* Disable HW interrupts, NAPI */
		bnx2x_netif_stop(bp, 1);

		/* Release IRQs */
		bnx2x_free_irq(bp);

		/* Report UNLOAD_DONE to MCP */
		bnx2x_send_unload_done(bp);
		}

		/*
		@@ -1977,17 +2003,24 @@ int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)

		bp->state = BNX2X_STATE_CLOSED;

		/* Check if there are pending parity attentions. If there are - set
		* RECOVERY_IN_PROGRESS.
		*/
		if (bnx2x_chk_parity_attn(bp, &global, false)) {
		bnx2x_set_reset_in_progress(bp);

		/* Set RESET_IS_GLOBAL if needed */
		if (global)
		bnx2x_set_reset_global(bp);
		}


		/* The last driver must disable a "close the gate" if there is no
		* parity attention or "process kill" pending.
		*/
		if ((!bnx2x_dec_load_cnt(bp)) && (!bnx2x_chk_parity_attn(bp)) &&
		bnx2x_reset_is_done(bp))
		if (!bnx2x_dec_load_cnt(bp) && bnx2x_reset_is_done(bp, BP_PATH(bp)))
		bnx2x_disable_close_the_gate(bp);

		/* Reset MCP mail box sequence if there is on going recovery */
		if (unload_mode == UNLOAD_RECOVERY)
		bp->fw_seq = 0;

		return 0;
		}

drivers/net/bnx2x/bnx2x_cmn.h

+14 −2

Original line number	Diff line number	Diff line
		@@ -181,6 +181,9 @@ void bnx2x_drv_pulse(struct bnx2x *bp);
		void bnx2x_igu_ack_sb(struct bnx2x *bp, u8 igu_sb_id, u8 segment,
		u16 index, u8 op, u8 update);

		/* Disable transactions from chip to host */
		void bnx2x_pf_disable(struct bnx2x *bp);

		/**
		* bnx2x__link_status_update - handles link status change.
		*
		@@ -320,6 +323,13 @@ int bnx2x_acquire_hw_lock(struct bnx2x *bp, u32 resource);
		*/
		int bnx2x_release_hw_lock(struct bnx2x *bp, u32 resource);

		/**
		* bnx2x_release_leader_lock - release recovery leader lock
		*
		* @bp: driver handle
		*/
		int bnx2x_release_leader_lock(struct bnx2x *bp);

		/**
		* bnx2x_set_eth_mac - configure eth MAC address in the HW
		*
		@@ -370,8 +380,10 @@ void bnx2x_set_q_rx_mode(struct bnx2x *bp, u8 cl_id,
		/* Parity errors related */
		void bnx2x_inc_load_cnt(struct bnx2x *bp);
		u32 bnx2x_dec_load_cnt(struct bnx2x *bp);
		bool bnx2x_chk_parity_attn(struct bnx2x *bp);
		bool bnx2x_reset_is_done(struct bnx2x *bp);
		bool bnx2x_chk_parity_attn(struct bnx2x bp, bool global, bool print);
		bool bnx2x_reset_is_done(struct bnx2x *bp, int engine);
		void bnx2x_set_reset_in_progress(struct bnx2x *bp);
		void bnx2x_set_reset_global(struct bnx2x *bp);
		void bnx2x_disable_close_the_gate(struct bnx2x *bp);

		/**

drivers/net/bnx2x/bnx2x_ethtool.c

+1 −2

Original line number	Diff line number	Diff line
		@@ -634,7 +634,6 @@ static void bnx2x_get_regs(struct net_device *dev,
		}
		/* Re-enable parity attentions */
		bnx2x_clear_blocks_parity(bp);
		if (CHIP_PARITY_ENABLED(bp))
		bnx2x_enable_blocks_parity(bp);
		}

drivers/net/bnx2x/bnx2x_init.h

+10 −1

Original line number	Diff line number	Diff line
		@@ -377,12 +377,15 @@ static const struct {
		BLOCK_PRTY_INFO_0(PXP2, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff),
		BLOCK_PRTY_INFO_1(PXP2, 0x7ff, 0x7f, 0x7f, 0x7ff),
		BLOCK_PRTY_INFO(HC, 0x7, 0x7, 0x7, 0),
		BLOCK_PRTY_INFO(NIG, 0xffffffff, 0x3fffffff, 0xffffffff, 0),
		BLOCK_PRTY_INFO_0(NIG, 0xffffffff, 0, 0, 0xffffffff),
		BLOCK_PRTY_INFO_1(NIG, 0xffff, 0, 0, 0xffff),
		BLOCK_PRTY_INFO(IGU, 0x7ff, 0, 0, 0x7ff),
		BLOCK_PRTY_INFO(MISC, 0x1, 0x1, 0x1, 0x1),
		BLOCK_PRTY_INFO(QM, 0, 0x1ff, 0xfff, 0xfff),
		BLOCK_PRTY_INFO(DORQ, 0, 0x3, 0x3, 0x3),
		{GRCBASE_UPB + PB_REG_PB_PRTY_MASK,
		GRCBASE_UPB + PB_REG_PB_PRTY_STS_CLR, 0,
		GRCBASE_UPB + PB_REG_PB_PRTY_STS_CLR, 0xf,
		{0xf, 0xf, 0xf}, "UPB"},
		{GRCBASE_XPB + PB_REG_PB_PRTY_MASK,
		GRCBASE_XPB + PB_REG_PB_PRTY_STS_CLR, 0,
		@@ -394,10 +397,16 @@ static const struct {
		BLOCK_PRTY_INFO(DMAE, 0, 0xf, 0xf, 0xf),
		BLOCK_PRTY_INFO(BRB1, 0, 0xf, 0xf, 0xf),
		BLOCK_PRTY_INFO(PRS, (1<<6), 0xff, 0xff, 0xff),
		BLOCK_PRTY_INFO(PBF, 0, 0, 0x3ffff, 0xfffffff),
		BLOCK_PRTY_INFO(TM, 0, 0, 0x7f, 0x7f),
		BLOCK_PRTY_INFO(TSDM, 0x18, 0x7ff, 0x7ff, 0x7ff),
		BLOCK_PRTY_INFO(CSDM, 0x8, 0x7ff, 0x7ff, 0x7ff),
		BLOCK_PRTY_INFO(USDM, 0x38, 0x7ff, 0x7ff, 0x7ff),
		BLOCK_PRTY_INFO(XSDM, 0x8, 0x7ff, 0x7ff, 0x7ff),
		BLOCK_PRTY_INFO(TCM, 0, 0, 0x7ffffff, 0x7ffffff),
		BLOCK_PRTY_INFO(CCM, 0, 0, 0x7ffffff, 0x7ffffff),
		BLOCK_PRTY_INFO(UCM, 0, 0, 0x7ffffff, 0x7ffffff),
		BLOCK_PRTY_INFO(XCM, 0, 0, 0x3fffffff, 0x3fffffff),
		BLOCK_PRTY_INFO_0(TSEM, 0, 0xffffffff, 0xffffffff, 0xffffffff),
		BLOCK_PRTY_INFO_1(TSEM, 0, 0x3, 0x1f, 0x3f),
		BLOCK_PRTY_INFO_0(USEM, 0, 0xffffffff, 0xffffffff, 0xffffffff),