D12101.id32314.diff
No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

D12101.id32314.diff
View Options

	Index: sys/dev/e1000/e1000_80003es2lan.c
	===================================================================
	--- sys/dev/e1000/e1000_80003es2lan.c
	+++ sys/dev/e1000/e1000_80003es2lan.c
	@@ -59,7 +59,6 @@
	static s32 e1000_init_hw_80003es2lan(struct e1000_hw *hw);
	static s32 e1000_setup_copper_link_80003es2lan(struct e1000_hw *hw);
	static void e1000_clear_hw_cntrs_80003es2lan(struct e1000_hw *hw);
	-static s32 e1000_acquire_swfw_sync_80003es2lan(struct e1000_hw *hw, u16 mask);
	static s32 e1000_cfg_kmrn_10_100_80003es2lan(struct e1000_hw *hw, u16 duplex);
	static s32 e1000_cfg_kmrn_1000_80003es2lan(struct e1000_hw *hw);
	static s32 e1000_cfg_on_link_up_80003es2lan(struct e1000_hw *hw);
	@@ -68,7 +67,6 @@
	static s32 e1000_write_kmrn_reg_80003es2lan(struct e1000_hw *hw, u32 offset,
	u16 data);
	static void e1000_initialize_hw_bits_80003es2lan(struct e1000_hw *hw);
	-static void e1000_release_swfw_sync_80003es2lan(struct e1000_hw *hw, u16 mask);
	static s32 e1000_read_mac_addr_80003es2lan(struct e1000_hw *hw);
	static void e1000_power_down_phy_copper_80003es2lan(struct e1000_hw *hw);

	@@ -299,7 +297,7 @@
	DEBUGFUNC("e1000_acquire_phy_80003es2lan");

	mask = hw->bus.func ? E1000_SWFW_PHY1_SM : E1000_SWFW_PHY0_SM;
	- return e1000_acquire_swfw_sync_80003es2lan(hw, mask);
	+ return e1000_acquire_swfw_sync(hw, mask);
	}

	/**
	@@ -315,7 +313,7 @@
	DEBUGFUNC("e1000_release_phy_80003es2lan");

	mask = hw->bus.func ? E1000_SWFW_PHY1_SM : E1000_SWFW_PHY0_SM;
	- e1000_release_swfw_sync_80003es2lan(hw, mask);
	+ e1000_release_swfw_sync(hw, mask);
	}

	/**
	@@ -333,7 +331,7 @@

	mask = E1000_SWFW_CSR_SM;

	- return e1000_acquire_swfw_sync_80003es2lan(hw, mask);
	+ return e1000_acquire_swfw_sync(hw, mask);
	}

	/**
	@@ -350,7 +348,7 @@

	mask = E1000_SWFW_CSR_SM;

	- e1000_release_swfw_sync_80003es2lan(hw, mask);
	+ e1000_release_swfw_sync(hw, mask);
	}

	/**
	@@ -365,14 +363,14 @@

	DEBUGFUNC("e1000_acquire_nvm_80003es2lan");

	- ret_val = e1000_acquire_swfw_sync_80003es2lan(hw, E1000_SWFW_EEP_SM);
	+ ret_val = e1000_acquire_swfw_sync(hw, E1000_SWFW_EEP_SM);
	if (ret_val)
	return ret_val;

	ret_val = e1000_acquire_nvm_generic(hw);

	if (ret_val)
	- e1000_release_swfw_sync_80003es2lan(hw, E1000_SWFW_EEP_SM);
	+ e1000_release_swfw_sync(hw, E1000_SWFW_EEP_SM);

	return ret_val;
	}
	@@ -388,78 +386,7 @@
	DEBUGFUNC("e1000_release_nvm_80003es2lan");

	e1000_release_nvm_generic(hw);
	- e1000_release_swfw_sync_80003es2lan(hw, E1000_SWFW_EEP_SM);
	-}
	-
	-/**
	- * e1000_acquire_swfw_sync_80003es2lan - Acquire SW/FW semaphore
	- * @hw: pointer to the HW structure
	- * @mask: specifies which semaphore to acquire
	- *
	- * Acquire the SW/FW semaphore to access the PHY or NVM. The mask
	- * will also specify which port we're acquiring the lock for.
	- **/
	-static s32 e1000_acquire_swfw_sync_80003es2lan(struct e1000_hw *hw, u16 mask)
	-{
	- u32 swfw_sync;
	- u32 swmask = mask;
	- u32 fwmask = mask << 16;
	- s32 i = 0;
	- s32 timeout = 50;
	-
	- DEBUGFUNC("e1000_acquire_swfw_sync_80003es2lan");
	- ASSERT_NO_LOCKS();
	- while (i < timeout) {
	- if (e1000_get_hw_semaphore_generic(hw))
	- return -E1000_ERR_SWFW_SYNC;
	-
	- swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
	- if (!(swfw_sync & (fwmask \| swmask)))
	- break;
	-
	- /* Firmware currently using resource (fwmask)
	- * or other software thread using resource (swmask)
	- */
	- e1000_put_hw_semaphore_generic(hw);
	- msec_delay_irq(5);
	- i++;
	- }
	-
	- if (i == timeout) {
	- DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
	- return -E1000_ERR_SWFW_SYNC;
	- }
	-
	- swfw_sync \|= swmask;
	- E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
	-
	- e1000_put_hw_semaphore_generic(hw);
	-
	- return E1000_SUCCESS;
	-}
	-
	-/**
	- * e1000_release_swfw_sync_80003es2lan - Release SW/FW semaphore
	- * @hw: pointer to the HW structure
	- * @mask: specifies which semaphore to acquire
	- *
	- * Release the SW/FW semaphore used to access the PHY or NVM. The mask
	- * will also specify which port we're releasing the lock for.
	- **/
	-static void e1000_release_swfw_sync_80003es2lan(struct e1000_hw *hw, u16 mask)
	-{
	- u32 swfw_sync;
	-
	- DEBUGFUNC("e1000_release_swfw_sync_80003es2lan");
	-
	- while (e1000_get_hw_semaphore_generic(hw) != E1000_SUCCESS)
	- ; /* Empty */
	-
	- swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
	- swfw_sync &= ~mask;
	- E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
	-
	- e1000_put_hw_semaphore_generic(hw);
	+ e1000_release_swfw_sync(hw, E1000_SWFW_EEP_SM);
	}

	/**
	Index: sys/dev/e1000/e1000_82571.c
	===================================================================
	--- sys/dev/e1000/e1000_82571.c
	+++ sys/dev/e1000/e1000_82571.c
	@@ -70,11 +70,8 @@
	static s32 e1000_setup_fiber_serdes_link_82571(struct e1000_hw *hw);
	static s32 e1000_valid_led_default_82571(struct e1000_hw hw, u16 data);
	static void e1000_clear_hw_cntrs_82571(struct e1000_hw *hw);
	-static s32 e1000_get_hw_semaphore_82571(struct e1000_hw *hw);
	static s32 e1000_fix_nvm_checksum_82571(struct e1000_hw *hw);
	static s32 e1000_get_phy_id_82571(struct e1000_hw *hw);
	-static void e1000_put_hw_semaphore_82571(struct e1000_hw *hw);
	-static void e1000_put_hw_semaphore_82573(struct e1000_hw *hw);
	static s32 e1000_get_hw_semaphore_82574(struct e1000_hw *hw);
	static void e1000_put_hw_semaphore_82574(struct e1000_hw *hw);
	static s32 e1000_set_d0_lplu_state_82574(struct e1000_hw *hw,
	@@ -125,8 +122,8 @@
	phy->ops.get_cable_length = e1000_get_cable_length_igp_2;
	phy->ops.read_reg = e1000_read_phy_reg_igp;
	phy->ops.write_reg = e1000_write_phy_reg_igp;
	- phy->ops.acquire = e1000_get_hw_semaphore_82571;
	- phy->ops.release = e1000_put_hw_semaphore_82571;
	+ phy->ops.acquire = e1000_get_hw_semaphore;
	+ phy->ops.release = e1000_put_hw_semaphore;
	break;
	case e1000_82573:
	phy->type = e1000_phy_m88;
	@@ -138,8 +135,8 @@
	phy->ops.get_cable_length = e1000_get_cable_length_m88;
	phy->ops.read_reg = e1000_read_phy_reg_m88;
	phy->ops.write_reg = e1000_write_phy_reg_m88;
	- phy->ops.acquire = e1000_get_hw_semaphore_82571;
	- phy->ops.release = e1000_put_hw_semaphore_82571;
	+ phy->ops.acquire = e1000_get_hw_semaphore;
	+ phy->ops.release = e1000_put_hw_semaphore;
	break;
	case e1000_82574:
	case e1000_82583:
	@@ -506,99 +503,24 @@
	}

	/**
	- * e1000_get_hw_semaphore_82571 - Acquire hardware semaphore
	- * @hw: pointer to the HW structure
	- *
	- * Acquire the HW semaphore to access the PHY or NVM
	- **/
	-static s32 e1000_get_hw_semaphore_82571(struct e1000_hw *hw)
	-{
	- u32 swsm;
	- s32 sw_timeout = hw->nvm.word_size + 1;
	- s32 fw_timeout = hw->nvm.word_size + 1;
	- s32 i = 0;
	-
	- DEBUGFUNC("e1000_get_hw_semaphore_82571");
	-
	- /* If we have timedout 3 times on trying to acquire
	- * the inter-port SMBI semaphore, there is old code
	- * operating on the other port, and it is not
	- * releasing SMBI. Modify the number of times that
	- * we try for the semaphore to interwork with this
	- * older code.
	- */
	- if (hw->dev_spec._82571.smb_counter > 2)
	- sw_timeout = 1;
	-
	- /* Get the SW semaphore */
	- while (i < sw_timeout) {
	- swsm = E1000_READ_REG(hw, E1000_SWSM);
	- if (!(swsm & E1000_SWSM_SMBI))
	- break;
	-
	- usec_delay(50);
	- i++;
	- }
	-
	- if (i == sw_timeout) {
	- DEBUGOUT("Driver can't access device - SMBI bit is set.\n");
	- hw->dev_spec._82571.smb_counter++;
	- }
	- /* Get the FW semaphore. */
	- for (i = 0; i < fw_timeout; i++) {
	- swsm = E1000_READ_REG(hw, E1000_SWSM);
	- E1000_WRITE_REG(hw, E1000_SWSM, swsm \| E1000_SWSM_SWESMBI);
	-
	- /* Semaphore acquired if bit latched */
	- if (E1000_READ_REG(hw, E1000_SWSM) & E1000_SWSM_SWESMBI)
	- break;
	-
	- usec_delay(50);
	- }
	-
	- if (i == fw_timeout) {
	- /* Release semaphores */
	- e1000_put_hw_semaphore_82571(hw);
	- DEBUGOUT("Driver can't access the NVM\n");
	- return -E1000_ERR_NVM;
	- }
	-
	- return E1000_SUCCESS;
	-}
	-
	-/**
	- * e1000_put_hw_semaphore_82571 - Release hardware semaphore
	- * @hw: pointer to the HW structure
	- *
	- * Release hardware semaphore used to access the PHY or NVM
	- **/
	-static void e1000_put_hw_semaphore_82571(struct e1000_hw *hw)
	-{
	- u32 swsm;
	-
	- DEBUGFUNC("e1000_put_hw_semaphore_generic");
	-
	- swsm = E1000_READ_REG(hw, E1000_SWSM);
	-
	- swsm &= ~(E1000_SWSM_SMBI \| E1000_SWSM_SWESMBI);
	-
	- E1000_WRITE_REG(hw, E1000_SWSM, swsm);
	-}
	-
	-/**
	* e1000_get_hw_semaphore_82573 - Acquire hardware semaphore
	* @hw: pointer to the HW structure
	*
	* Acquire the HW semaphore during reset.
	*
	**/
	-static s32 e1000_get_hw_semaphore_82573(struct e1000_hw *hw)
	+static s32
	+e1000_get_hw_semaphore_82574(struct e1000_hw *hw)
	{
	u32 extcnf_ctrl;
	s32 i = 0;
	+ struct e1000_osdep *os = hw->back;
	+ struct sx *lock = iflib_ctx_lock_get(os->ctx);

	+ /* XXX assert that mutex is held */
	DEBUGFUNC("e1000_get_hw_semaphore_82573");

	+ sx_assert(lock, SX_XLOCKED);
	extcnf_ctrl = E1000_READ_REG(hw, E1000_EXTCNF_CTRL);
	do {
	extcnf_ctrl \|= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
	@@ -614,7 +536,7 @@

	if (i == MDIO_OWNERSHIP_TIMEOUT) {
	/* Release semaphores */
	- e1000_put_hw_semaphore_82573(hw);
	+ e1000_put_hw_semaphore_82574(hw);
	DEBUGOUT("Driver can't access the PHY\n");
	return -E1000_ERR_PHY;
	}
	@@ -623,17 +545,18 @@
	}

	/**
	- * e1000_put_hw_semaphore_82573 - Release hardware semaphore
	+ * e1000_put_hw_semaphore_82574 - Release hardware semaphore
	* @hw: pointer to the HW structure
	*
	* Release hardware semaphore used during reset.
	*
	**/
	-static void e1000_put_hw_semaphore_82573(struct e1000_hw *hw)
	+static void
	+e1000_put_hw_semaphore_82574(struct e1000_hw *hw)
	{
	u32 extcnf_ctrl;

	- DEBUGFUNC("e1000_put_hw_semaphore_82573");
	+ DEBUGFUNC("e1000_put_hw_semaphore_82574");

	extcnf_ctrl = E1000_READ_REG(hw, E1000_EXTCNF_CTRL);
	extcnf_ctrl &= ~E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
	@@ -641,41 +564,6 @@
	}

	/**
	- * e1000_get_hw_semaphore_82574 - Acquire hardware semaphore
	- * @hw: pointer to the HW structure
	- *
	- * Acquire the HW semaphore to access the PHY or NVM.
	- *
	- **/
	-static s32 e1000_get_hw_semaphore_82574(struct e1000_hw *hw)
	-{
	- s32 ret_val;
	-
	- DEBUGFUNC("e1000_get_hw_semaphore_82574");
	-
	- E1000_MUTEX_LOCK(&hw->dev_spec._82571.swflag_mutex);
	- ret_val = e1000_get_hw_semaphore_82573(hw);
	- if (ret_val)
	- E1000_MUTEX_UNLOCK(&hw->dev_spec._82571.swflag_mutex);
	- return ret_val;
	-}
	-
	-/**
	- * e1000_put_hw_semaphore_82574 - Release hardware semaphore
	- * @hw: pointer to the HW structure
	- *
	- * Release hardware semaphore used to access the PHY or NVM
	- *
	- **/
	-static void e1000_put_hw_semaphore_82574(struct e1000_hw *hw)
	-{
	- DEBUGFUNC("e1000_put_hw_semaphore_82574");
	-
	- e1000_put_hw_semaphore_82573(hw);
	- E1000_MUTEX_UNLOCK(&hw->dev_spec._82571.swflag_mutex);
	-}
	-
	-/**
	* e1000_set_d0_lplu_state_82574 - Set Low Power Linkup D0 state
	* @hw: pointer to the HW structure
	* @active: TRUE to enable LPLU, FALSE to disable
	@@ -746,7 +634,7 @@

	DEBUGFUNC("e1000_acquire_nvm_82571");

	- ret_val = e1000_get_hw_semaphore_82571(hw);
	+ ret_val = e1000_get_hw_semaphore(hw);
	if (ret_val)
	return ret_val;

	@@ -759,7 +647,7 @@
	}

	if (ret_val)
	- e1000_put_hw_semaphore_82571(hw);
	+ e1000_put_hw_semaphore(hw);

	return ret_val;
	}
	@@ -775,7 +663,7 @@
	DEBUGFUNC("e1000_release_nvm_82571");

	e1000_release_nvm_generic(hw);
	- e1000_put_hw_semaphore_82571(hw);
	+ e1000_put_hw_semaphore(hw);
	}

	/**
	@@ -1092,8 +980,6 @@
	*/
	switch (hw->mac.type) {
	case e1000_82573:
	- ret_val = e1000_get_hw_semaphore_82573(hw);
	- break;
	case e1000_82574:
	case e1000_82583:
	ret_val = e1000_get_hw_semaphore_82574(hw);
	@@ -1110,10 +996,6 @@
	/* Must release MDIO ownership and mutex after MAC reset. */
	switch (hw->mac.type) {
	case e1000_82573:
	- /* Release mutex only if the hw semaphore is acquired */
	- if (!ret_val)
	- e1000_put_hw_semaphore_82573(hw);
	- break;
	case e1000_82574:
	case e1000_82583:
	/* Release mutex only if the hw semaphore is acquired */
	@@ -1121,6 +1003,7 @@
	e1000_put_hw_semaphore_82574(hw);
	break;
	default:
	+ panic("unknown mac type %x\n", hw->mac.type);
	break;
	}

	Index: sys/dev/e1000/e1000_82575.c
	===================================================================
	--- sys/dev/e1000/e1000_82575.c
	+++ sys/dev/e1000/e1000_82575.c
	@@ -79,11 +79,9 @@
	static s32 e1000_write_phy_reg_sgmii_82575(struct e1000_hw *hw,
	u32 offset, u16 data);
	static void e1000_clear_hw_cntrs_82575(struct e1000_hw *hw);
	-static s32 e1000_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
	static s32 e1000_get_pcs_speed_and_duplex_82575(struct e1000_hw *hw,
	u16 speed, u16 duplex);
	static s32 e1000_get_phy_id_82575(struct e1000_hw *hw);
	-static void e1000_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask);
	static bool e1000_sgmii_active_82575(struct e1000_hw *hw);
	static s32 e1000_reset_init_script_82575(struct e1000_hw *hw);
	static s32 e1000_read_mac_addr_82575(struct e1000_hw *hw);
	@@ -511,12 +509,8 @@
	/* link info */
	mac->ops.get_link_up_info = e1000_get_link_up_info_82575;
	/* acquire SW_FW sync */
	- mac->ops.acquire_swfw_sync = e1000_acquire_swfw_sync_82575;
	- mac->ops.release_swfw_sync = e1000_release_swfw_sync_82575;
	- if (mac->type >= e1000_i210) {
	- mac->ops.acquire_swfw_sync = e1000_acquire_swfw_sync_i210;
	- mac->ops.release_swfw_sync = e1000_release_swfw_sync_i210;
	- }
	+ mac->ops.acquire_swfw_sync = e1000_acquire_swfw_sync;
	+ mac->ops.release_swfw_sync = e1000_release_swfw_sync;

	/* set lan id for port to determine which phy lock to use */
	hw->mac.ops.set_lan_id(hw);
	@@ -988,7 +982,7 @@

	DEBUGFUNC("e1000_acquire_nvm_82575");

	- ret_val = e1000_acquire_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
	+ ret_val = e1000_acquire_swfw_sync(hw, E1000_SWFW_EEP_SM);
	if (ret_val)
	goto out;

	@@ -1019,7 +1013,7 @@

	ret_val = e1000_acquire_nvm_generic(hw);
	if (ret_val)
	- e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
	+ e1000_release_swfw_sync(hw, E1000_SWFW_EEP_SM);

	out:
	return ret_val;
	@@ -1038,83 +1032,7 @@

	e1000_release_nvm_generic(hw);

	- e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
	-}
	-
	-/**
	- * e1000_acquire_swfw_sync_82575 - Acquire SW/FW semaphore
	- * @hw: pointer to the HW structure
	- * @mask: specifies which semaphore to acquire
	- *
	- * Acquire the SW/FW semaphore to access the PHY or NVM. The mask
	- * will also specify which port we're acquiring the lock for.
	- **/
	-static s32 e1000_acquire_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
	-{
	- u32 swfw_sync;
	- u32 swmask = mask;
	- u32 fwmask = mask << 16;
	- s32 ret_val = E1000_SUCCESS;
	- s32 i = 0, timeout = 200;
	-
	- DEBUGFUNC("e1000_acquire_swfw_sync_82575");
	- ASSERT_NO_LOCKS();
	- while (i < timeout) {
	- if (e1000_get_hw_semaphore_generic(hw)) {
	- ret_val = -E1000_ERR_SWFW_SYNC;
	- goto out;
	- }
	-
	- swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
	- if (!(swfw_sync & (fwmask \| swmask)))
	- break;
	-
	- /*
	- * Firmware currently using resource (fwmask)
	- * or other software thread using resource (swmask)
	- */
	- e1000_put_hw_semaphore_generic(hw);
	- msec_delay_irq(5);
	- i++;
	- }
	-
	- if (i == timeout) {
	- DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
	- ret_val = -E1000_ERR_SWFW_SYNC;
	- goto out;
	- }
	-
	- swfw_sync \|= swmask;
	- E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
	-
	- e1000_put_hw_semaphore_generic(hw);
	-
	-out:
	- return ret_val;
	-}
	-
	-/**
	- * e1000_release_swfw_sync_82575 - Release SW/FW semaphore
	- * @hw: pointer to the HW structure
	- * @mask: specifies which semaphore to acquire
	- *
	- * Release the SW/FW semaphore used to access the PHY or NVM. The mask
	- * will also specify which port we're releasing the lock for.
	- **/
	-static void e1000_release_swfw_sync_82575(struct e1000_hw *hw, u16 mask)
	-{
	- u32 swfw_sync;
	-
	- DEBUGFUNC("e1000_release_swfw_sync_82575");
	-
	- while (e1000_get_hw_semaphore_generic(hw) != E1000_SUCCESS)
	- ; /* Empty */
	-
	- swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
	- swfw_sync &= ~mask;
	- E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
	-
	- e1000_put_hw_semaphore_generic(hw);
	+ e1000_release_swfw_sync(hw, E1000_SWFW_EEP_SM);
	}

	/**
	Index: sys/dev/e1000/e1000_i210.h
	===================================================================
	--- sys/dev/e1000/e1000_i210.h
	+++ sys/dev/e1000/e1000_i210.h
	@@ -43,8 +43,6 @@
	u16 words, u16 *data);
	s32 e1000_read_nvm_srrd_i210(struct e1000_hw *hw, u16 offset,
	u16 words, u16 *data);
	-s32 e1000_acquire_swfw_sync_i210(struct e1000_hw *hw, u16 mask);
	-void e1000_release_swfw_sync_i210(struct e1000_hw *hw, u16 mask);
	s32 e1000_read_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr,
	u16 *data);
	s32 e1000_write_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr,
	Index: sys/dev/e1000/e1000_i210.c
	===================================================================
	--- sys/dev/e1000/e1000_i210.c
	+++ sys/dev/e1000/e1000_i210.c
	@@ -37,7 +37,6 @@

	static s32 e1000_acquire_nvm_i210(struct e1000_hw *hw);
	static void e1000_release_nvm_i210(struct e1000_hw *hw);
	-static s32 e1000_get_hw_semaphore_i210(struct e1000_hw *hw);
	static s32 e1000_write_nvm_srwr(struct e1000_hw *hw, u16 offset, u16 words,
	u16 *data);
	static s32 e1000_pool_flash_update_done_i210(struct e1000_hw *hw);
	@@ -58,7 +57,7 @@

	DEBUGFUNC("e1000_acquire_nvm_i210");

	- ret_val = e1000_acquire_swfw_sync_i210(hw, E1000_SWFW_EEP_SM);
	+ ret_val = e1000_acquire_swfw_sync(hw, E1000_SWFW_EEP_SM);

	return ret_val;
	}
	@@ -74,154 +73,7 @@
	{
	DEBUGFUNC("e1000_release_nvm_i210");

	- e1000_release_swfw_sync_i210(hw, E1000_SWFW_EEP_SM);
	-}
	-
	-/**
	- * e1000_acquire_swfw_sync_i210 - Acquire SW/FW semaphore
	- * @hw: pointer to the HW structure
	- * @mask: specifies which semaphore to acquire
	- *
	- * Acquire the SW/FW semaphore to access the PHY or NVM. The mask
	- * will also specify which port we're acquiring the lock for.
	- **/
	-s32 e1000_acquire_swfw_sync_i210(struct e1000_hw *hw, u16 mask)
	-{
	- u32 swfw_sync;
	- u32 swmask = mask;
	- u32 fwmask = mask << 16;
	- s32 ret_val = E1000_SUCCESS;
	- /* Uhh the following line should read 'FIXME: this is a blazing tire fire' */
	- s32 i = 0, timeout = 200; /* FIXME: find real value to use here */
	-
	- DEBUGFUNC("e1000_acquire_swfw_sync_i210");
	- ASSERT_NO_LOCKS();
	-
	- while (i < timeout) {
	- if (e1000_get_hw_semaphore_i210(hw)) {
	- ret_val = -E1000_ERR_SWFW_SYNC;
	- goto out;
	- }
	-
	- swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
	- if (!(swfw_sync & (fwmask \| swmask)))
	- break;
	-
	- /*
	- * Firmware currently using resource (fwmask)
	- * or other software thread using resource (swmask)
	- */
	- e1000_put_hw_semaphore_generic(hw);
	- msec_delay_irq(5);
	- i++;
	- }
	-
	- if (i == timeout) {
	- DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
	- ret_val = -E1000_ERR_SWFW_SYNC;
	- goto out;
	- }
	-
	- swfw_sync \|= swmask;
	- E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
	-
	- e1000_put_hw_semaphore_generic(hw);
	-
	-out:
	- return ret_val;
	-}
	-
	-/**
	- * e1000_release_swfw_sync_i210 - Release SW/FW semaphore
	- * @hw: pointer to the HW structure
	- * @mask: specifies which semaphore to acquire
	- *
	- * Release the SW/FW semaphore used to access the PHY or NVM. The mask
	- * will also specify which port we're releasing the lock for.
	- **/
	-void e1000_release_swfw_sync_i210(struct e1000_hw *hw, u16 mask)
	-{
	- u32 swfw_sync;
	-
	- DEBUGFUNC("e1000_release_swfw_sync_i210");
	-
	- while (e1000_get_hw_semaphore_i210(hw) != E1000_SUCCESS)
	- ; /* Empty */
	-
	- swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
	- swfw_sync &= ~mask;
	- E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
	-
	- e1000_put_hw_semaphore_generic(hw);
	-}
	-
	-/**
	- * e1000_get_hw_semaphore_i210 - Acquire hardware semaphore
	- * @hw: pointer to the HW structure
	- *
	- * Acquire the HW semaphore to access the PHY or NVM
	- **/
	-static s32 e1000_get_hw_semaphore_i210(struct e1000_hw *hw)
	-{
	- u32 swsm;
	- s32 timeout = hw->nvm.word_size + 1;
	- s32 i = 0;
	-
	- DEBUGFUNC("e1000_get_hw_semaphore_i210");
	-
	- /* Get the SW semaphore */
	- while (i < timeout) {
	- swsm = E1000_READ_REG(hw, E1000_SWSM);
	- if (!(swsm & E1000_SWSM_SMBI))
	- break;
	-
	- usec_delay(50);
	- i++;
	- }
	-
	- if (i == timeout) {
	- /* In rare circumstances, the SW semaphore may already be held
	- * unintentionally. Clear the semaphore once before giving up.
	- */
	- if (hw->dev_spec._82575.clear_semaphore_once) {
	- hw->dev_spec._82575.clear_semaphore_once = FALSE;
	- e1000_put_hw_semaphore_generic(hw);
	- for (i = 0; i < timeout; i++) {
	- swsm = E1000_READ_REG(hw, E1000_SWSM);
	- if (!(swsm & E1000_SWSM_SMBI))
	- break;
	-
	- usec_delay(50);
	- }
	- }
	-
	- /* If we do not have the semaphore here, we have to give up. */
	- if (i == timeout) {
	- DEBUGOUT("Driver can't access device - SMBI bit is set.\n");
	- return -E1000_ERR_NVM;
	- }
	- }
	-
	- /* Get the FW semaphore. */
	- for (i = 0; i < timeout; i++) {
	- swsm = E1000_READ_REG(hw, E1000_SWSM);
	- E1000_WRITE_REG(hw, E1000_SWSM, swsm \| E1000_SWSM_SWESMBI);
	-
	- /* Semaphore acquired if bit latched */
	- if (E1000_READ_REG(hw, E1000_SWSM) & E1000_SWSM_SWESMBI)
	- break;
	-
	- usec_delay(50);
	- }
	-
	- if (i == timeout) {
	- /* Release semaphores */
	- e1000_put_hw_semaphore_generic(hw);
	- DEBUGOUT("Driver can't access the NVM\n");
	- return -E1000_ERR_NVM;
	- }
	-
	- return E1000_SUCCESS;
	+ e1000_release_swfw_sync(hw, E1000_SWFW_EEP_SM);
	}

	/**
	Index: sys/dev/e1000/e1000_mac.h
	===================================================================
	--- sys/dev/e1000/e1000_mac.h
	+++ sys/dev/e1000/e1000_mac.h
	@@ -60,7 +60,6 @@
	s32 e1000_get_bus_info_pcie_generic(struct e1000_hw *hw);
	void e1000_set_lan_id_single_port(struct e1000_hw *hw);
	void e1000_set_lan_id_multi_port_pci(struct e1000_hw *hw);
	-s32 e1000_get_hw_semaphore_generic(struct e1000_hw *hw);
	s32 e1000_get_speed_and_duplex_copper_generic(struct e1000_hw hw, u16 speed,
	u16 *duplex);
	s32 e1000_get_speed_and_duplex_fiber_serdes_generic(struct e1000_hw *hw,
	@@ -85,11 +84,15 @@
	void e1000_clear_vfta_generic(struct e1000_hw *hw);
	void e1000_init_rx_addrs_generic(struct e1000_hw *hw, u16 rar_count);
	void e1000_pcix_mmrbc_workaround_generic(struct e1000_hw *hw);
	-void e1000_put_hw_semaphore_generic(struct e1000_hw *hw);
	s32 e1000_check_alt_mac_addr_generic(struct e1000_hw *hw);
	void e1000_reset_adaptive_generic(struct e1000_hw *hw);
	void e1000_set_pcie_no_snoop_generic(struct e1000_hw *hw, u32 no_snoop);
	void e1000_update_adaptive_generic(struct e1000_hw *hw);
	void e1000_write_vfta_generic(struct e1000_hw *hw, u32 offset, u32 value);

	+s32 e1000_get_hw_semaphore(struct e1000_hw *hw);
	+void e1000_put_hw_semaphore(struct e1000_hw *hw);
	+s32 e1000_acquire_swfw_sync(struct e1000_hw *hw, u16 mask);
	+void e1000_release_swfw_sync(struct e1000_hw *hw, u16 mask);
	+
	#endif
	Index: sys/dev/e1000/e1000_mac.c
	===================================================================
	--- sys/dev/e1000/e1000_mac.c
	+++ sys/dev/e1000/e1000_mac.c
	@@ -1707,76 +1707,6 @@
	}

	/**
	- * e1000_get_hw_semaphore_generic - Acquire hardware semaphore
	- * @hw: pointer to the HW structure
	- *
	- * Acquire the HW semaphore to access the PHY or NVM
	- **/
	-s32 e1000_get_hw_semaphore_generic(struct e1000_hw *hw)
	-{
	- u32 swsm;
	- s32 timeout = hw->nvm.word_size + 1;
	- s32 i = 0;
	-
	- DEBUGFUNC("e1000_get_hw_semaphore_generic");
	-
	- /* Get the SW semaphore */
	- while (i < timeout) {
	- swsm = E1000_READ_REG(hw, E1000_SWSM);
	- if (!(swsm & E1000_SWSM_SMBI))
	- break;
	-
	- usec_delay(50);
	- i++;
	- }
	-
	- if (i == timeout) {
	- DEBUGOUT("Driver can't access device - SMBI bit is set.\n");
	- return -E1000_ERR_NVM;
	- }
	-
	- /* Get the FW semaphore. */
	- for (i = 0; i < timeout; i++) {
	- swsm = E1000_READ_REG(hw, E1000_SWSM);
	- E1000_WRITE_REG(hw, E1000_SWSM, swsm \| E1000_SWSM_SWESMBI);
	-
	- /* Semaphore acquired if bit latched */
	- if (E1000_READ_REG(hw, E1000_SWSM) & E1000_SWSM_SWESMBI)
	- break;
	-
	- usec_delay(50);
	- }
	-
	- if (i == timeout) {
	- /* Release semaphores */
	- e1000_put_hw_semaphore_generic(hw);
	- DEBUGOUT("Driver can't access the NVM\n");
	- return -E1000_ERR_NVM;
	- }
	-
	- return E1000_SUCCESS;
	-}
	-
	-/**
	- * e1000_put_hw_semaphore_generic - Release hardware semaphore
	- * @hw: pointer to the HW structure
	- *
	- * Release hardware semaphore used to access the PHY or NVM
	- **/
	-void e1000_put_hw_semaphore_generic(struct e1000_hw *hw)
	-{
	- u32 swsm;
	-
	- DEBUGFUNC("e1000_put_hw_semaphore_generic");
	-
	- swsm = E1000_READ_REG(hw, E1000_SWSM);
	-
	- swsm &= ~(E1000_SWSM_SMBI \| E1000_SWSM_SWESMBI);
	-
	- E1000_WRITE_REG(hw, E1000_SWSM, swsm);
	-}
	-
	-/**
	* e1000_get_auto_rd_done_generic - Check for auto read completion
	* @hw: pointer to the HW structure
	*
	@@ -2251,3 +2181,165 @@

	return E1000_SUCCESS;
	}
	+
	+/**
	+ * e1000_get_hw_semaphore - Acquire hardware semaphore
	+ * @hw: pointer to the HW structure
	+ *
	+ * Acquire the HW semaphore to access the PHY or NVM
	+ **/
	+s32 e1000_get_hw_semaphore(struct e1000_hw *hw)
	+{
	+ u32 swsm;
	+ s32 timeout = hw->nvm.word_size + 1;
	+ s32 i = 0;
	+
	+ DEBUGFUNC("e1000_get_hw_semaphore");
	+#ifdef notyet
	+ /* _82571 */
	+ /* If we have timedout 3 times on trying to acquire
	+ * the inter-port SMBI semaphore, there is old code
	+ * operating on the other port, and it is not
	+ * releasing SMBI. Modify the number of times that
	+ * we try for the semaphore to interwork with this
	+ * older code.
	+ */
	+ if (hw->dev_spec._82571.smb_counter > 2)
	+ sw_timeout = 1;
	+
	+#endif
	+ /* Get the SW semaphore */
	+ while (i < timeout) {
	+ swsm = E1000_READ_REG(hw, E1000_SWSM);
	+ if (!(swsm & E1000_SWSM_SMBI))
	+ break;
	+
	+ usec_delay(50);
	+ i++;
	+ }
	+
	+ if (i == timeout) {
	+ DEBUGOUT("Driver can't access device - SMBI bit is set.\n");
	+ return -E1000_ERR_NVM;
	+ }
	+
	+ /* Get the FW semaphore. */
	+ for (i = 0; i < timeout; i++) {
	+ swsm = E1000_READ_REG(hw, E1000_SWSM);
	+ E1000_WRITE_REG(hw, E1000_SWSM, swsm \| E1000_SWSM_SWESMBI);
	+
	+ /* Semaphore acquired if bit latched */
	+ if (E1000_READ_REG(hw, E1000_SWSM) & E1000_SWSM_SWESMBI)
	+ break;
	+
	+ usec_delay(50);
	+ }
	+
	+ if (i == timeout) {
	+ /* Release semaphores */
	+ e1000_put_hw_semaphore(hw);
	+ DEBUGOUT("Driver can't access the NVM\n");
	+ return -E1000_ERR_NVM;
	+ }
	+
	+ return E1000_SUCCESS;
	+}
	+
	+/**
	+ * e1000_put_hw_semaphore - Release hardware semaphore
	+ * @hw: pointer to the HW structure
	+ *
	+ * Release hardware semaphore used to access the PHY or NVM
	+ **/
	+void e1000_put_hw_semaphore(struct e1000_hw *hw)
	+{
	+ u32 swsm;
	+
	+ DEBUGFUNC("e1000_put_hw_semaphore");
	+
	+ swsm = E1000_READ_REG(hw, E1000_SWSM);
	+
	+ swsm &= ~(E1000_SWSM_SMBI \| E1000_SWSM_SWESMBI);
	+
	+ E1000_WRITE_REG(hw, E1000_SWSM, swsm);
	+}
	+
	+
	+/**
	+ * e1000_acquire_swfw_sync - Acquire SW/FW semaphore
	+ * @hw: pointer to the HW structure
	+ * @mask: specifies which semaphore to acquire
	+ *
	+ * Acquire the SW/FW semaphore to access the PHY or NVM. The mask
	+ * will also specify which port we're acquiring the lock for.
	+ **/
	+s32
	+e1000_acquire_swfw_sync(struct e1000_hw *hw, u16 mask)
	+{
	+ u32 swfw_sync;
	+ u32 swmask = mask;
	+ u32 fwmask = mask << 16;
	+ s32 ret_val = E1000_SUCCESS;
	+ s32 i = 0, timeout = 200;
	+
	+ DEBUGFUNC("e1000_acquire_swfw_sync");
	+ ASSERT_NO_LOCKS();
	+ while (i < timeout) {
	+ if (e1000_get_hw_semaphore(hw)) {
	+ ret_val = -E1000_ERR_SWFW_SYNC;
	+ goto out;
	+ }
	+
	+ swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
	+ if (!(swfw_sync & (fwmask \| swmask)))
	+ break;
	+
	+ /*
	+ * Firmware currently using resource (fwmask)
	+ * or other software thread using resource (swmask)
	+ */
	+ e1000_put_hw_semaphore(hw);
	+ msec_delay_irq(5);
	+ i++;
	+ }
	+
	+ if (i == timeout) {
	+ DEBUGOUT("Driver can't access resource, SW_FW_SYNC timeout.\n");
	+ ret_val = -E1000_ERR_SWFW_SYNC;
	+ goto out;
	+ }
	+
	+ swfw_sync \|= swmask;
	+ E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
	+
	+ e1000_put_hw_semaphore(hw);
	+
	+out:
	+ return ret_val;
	+}
	+
	+/**
	+ * e1000_release_swfw_sync - Release SW/FW semaphore
	+ * @hw: pointer to the HW structure
	+ * @mask: specifies which semaphore to acquire
	+ *
	+ * Release the SW/FW semaphore used to access the PHY or NVM. The mask
	+ * will also specify which port we're releasing the lock for.
	+ **/
	+void
	+e1000_release_swfw_sync(struct e1000_hw *hw, u16 mask)
	+{
	+ u32 swfw_sync;
	+
	+ DEBUGFUNC("e1000_release_swfw_sync");
	+
	+ while (e1000_get_hw_semaphore(hw) != E1000_SUCCESS)
	+ ; /* Empty */
	+
	+ swfw_sync = E1000_READ_REG(hw, E1000_SW_FW_SYNC);
	+ swfw_sync &= ~mask;
	+ E1000_WRITE_REG(hw, E1000_SW_FW_SYNC, swfw_sync);
	+
	+ e1000_put_hw_semaphore(hw);
	+}
	+
	Index: sys/dev/e1000/e1000_osdep.h
	===================================================================
	--- sys/dev/e1000/e1000_osdep.h
	+++ sys/dev/e1000/e1000_osdep.h
	@@ -39,6 +39,7 @@
	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/systm.h>
	+#include <sys/proc.h>
	#include <sys/lock.h>
	#include <sys/mutex.h>
	#include <sys/mbuf.h>
	@@ -47,6 +48,14 @@
	#include <sys/malloc.h>
	#include <sys/kernel.h>
	#include <sys/bus.h>
	+
	+#include <net/ethernet.h>
	+#include <net/if.h>
	+#include <net/if_var.h>
	+#include <net/iflib.h>
	+
	+
	+
	#include <machine/bus.h>
	#include <sys/rman.h>
	#include <machine/resource.h>
	@@ -58,11 +67,41 @@


	#define ASSERT(x) if(!(x)) panic("EM: x")
	+#define us_scale(x) max(1, (x/(1000000/hz)))
	+static inline int
	+ms_scale(int x) {
	+ if (hz == 1000) {
	+ return (x);
	+ } else if (hz > 1000) {
	+ return (x*(hz/1000));
	+ } else {
	+ return (max(1, x/(1000/hz)));
	+ }
	+}
	+extern int cold;
	+
	+static inline void
	+safe_pause_us(int x) {
	+ if (cold) {
	+ DELAY(x);
	+ } else {
	+ pause("e1000_delay", max(1, x/(1000000/hz)));
	+ }
	+}
	+
	+static inline void
	+safe_pause_ms(int x) {
	+ if (cold) {
	+ DELAY(x*1000);
	+ } else {
	+ pause("e1000_delay", ms_scale(x));
	+ }
	+}

	-#define usec_delay(x) DELAY(x)
	+#define usec_delay(x) safe_pause_us(x)
	#define usec_delay_irq(x) usec_delay(x)
	-#define msec_delay(x) DELAY(1000*(x))
	-#define msec_delay_irq(x) DELAY(1000*(x))
	+#define msec_delay(x) safe_pause_ms(x)
	+#define msec_delay_irq(x) msec_delay(x)

	/* Enable/disable debugging statements in shared code */
	#define DBG 0
	@@ -135,6 +174,7 @@
	bus_space_tag_t flash_bus_space_tag;
	bus_space_handle_t flash_bus_space_handle;
	device_t dev;
	+ if_ctx_t ctx;
	};

	#define E1000_REGISTER(hw, reg) (((hw)->mac.type >= e1000_82543) \
	Index: sys/dev/e1000/if_em.c
	===================================================================
	--- sys/dev/e1000/if_em.c
	+++ sys/dev/e1000/if_em.c
	@@ -717,7 +717,7 @@
	return (ENXIO);
	}

	- adapter->ctx = ctx;
	+ adapter->ctx = adapter->osdep.ctx = ctx;
	adapter->dev = adapter->osdep.dev = dev;
	scctx = adapter->shared = iflib_get_softc_ctx(ctx);
	adapter->media = iflib_get_media(ctx);
	Index: sys/net/iflib.c
	===================================================================
	--- sys/net/iflib.c
	+++ sys/net/iflib.c
	@@ -526,14 +526,6 @@

	#define CTX_ACTIVE(ctx) ((if_getdrvflags((ctx)->ifc_ifp) & IFF_DRV_RUNNING))

	-/*
	-#define CTX_LOCK_INIT(_sc, _name) mtx_init(&(_sc)->ifc_mtx, _name, "iflib ctx lock", MTX_DEF)
	-
	-#define CTX_LOCK(ctx) mtx_lock(&(ctx)->ifc_mtx)
	-#define CTX_UNLOCK(ctx) mtx_unlock(&(ctx)->ifc_mtx)
	-#define CTX_LOCK_DESTROY(ctx) mtx_destroy(&(ctx)->ifc_mtx)
	-*/
	-
	#define CTX_LOCK_INIT(_sc, _name) sx_init(&(_sc)->ifc_sx, _name)

	#define CTX_LOCK(ctx) sx_xlock(&(ctx)->ifc_sx)
	@@ -3599,9 +3591,9 @@
	ctx->ifc_flags &= ~IFC_DO_RESET;
	iflib_if_init_locked(ctx);
	}
	+ IFDI_UPDATE_ADMIN_STATUS(ctx);
	CTX_UNLOCK(ctx);

	- IFDI_UPDATE_ADMIN_STATUS(ctx);
	if (LINK_ACTIVE(ctx) == 0 \|\| !running)
	return;
	for (txq = ctx->ifc_txqs, i = 0; i < sctx->isc_ntxqsets; i++, txq++)
	@@ -4107,8 +4099,10 @@
	scctx->isc_ntxd[i] = sctx->isc_ntxd_max[i];
	}
	}
	-
	- if ((err = IFDI_ATTACH_PRE(ctx)) != 0) {
	+ CTX_LOCK(ctx);
	+ err = IFDI_ATTACH_PRE(ctx);
	+ CTX_UNLOCK(ctx);
	+ if (err) {
	device_printf(dev, "IFDI_ATTACH_PRE failed %d\n", err);
	return (err);
	}
	@@ -4246,7 +4240,10 @@
	}
	}
	ether_ifattach(ctx->ifc_ifp, ctx->ifc_mac);
	- if ((err = IFDI_ATTACH_POST(ctx)) != 0) {
	+ CTX_LOCK(ctx);
	+ err = IFDI_ATTACH_POST(ctx);
	+ CTX_UNLOCK(ctx);
	+ if (err) {
	device_printf(dev, "IFDI_ATTACH_POST failed %d\n", err);
	goto fail_detach;
	}

File Metadata

Mime Type: text/plain
Expires: Tue, Sep 8, 1:01 PM (22 h, 50 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 38517652
Default Alt Text: D12101.id32314.diff (31 KB)

D12101.id32314.diffNo OneTemporaryActions

D12101.id32314.diffView Options

File Metadata

Event Timeline

D12101.id32314.diff
No OneTemporary
Actions

D12101.id32314.diff
View Options