Author: sbruno
Date: Wed Aug 30 18:56:24 2017
New Revision: 323027
URL: https://svnweb.freebsd.org/changeset/base/323027

Log:
  Revert r323008 and its conversion of e1000/iflib to using SX locks.
  
  This seems to be missing something on the 82574L causing NFS root mounts
  to hang.
  
  Reported by:  kib

Modified:
  head/sys/dev/e1000/e1000_80003es2lan.c
  head/sys/dev/e1000/e1000_82571.c
  head/sys/dev/e1000/e1000_82575.c
  head/sys/dev/e1000/e1000_hw.h
  head/sys/dev/e1000/e1000_i210.c
  head/sys/dev/e1000/e1000_i210.h
  head/sys/dev/e1000/e1000_ich8lan.c
  head/sys/dev/e1000/e1000_mac.c
  head/sys/dev/e1000/e1000_mac.h
  head/sys/dev/e1000/e1000_osdep.h
  head/sys/dev/e1000/if_em.c
  head/sys/net/iflib.c
  head/sys/net/iflib.h

Modified: head/sys/dev/e1000/e1000_80003es2lan.c
==============================================================================
--- head/sys/dev/e1000/e1000_80003es2lan.c      Wed Aug 30 18:46:38 2017        
(r323026)
+++ head/sys/dev/e1000/e1000_80003es2lan.c      Wed Aug 30 18:56:24 2017        
(r323027)
@@ -59,6 +59,7 @@ static s32  e1000_reset_hw_80003es2lan(struct e1000_hw
 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);
@@ -67,6 +68,7 @@ static s32  e1000_read_kmrn_reg_80003es2lan(struct e10
 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);
 
@@ -297,7 +299,7 @@ static s32 e1000_acquire_phy_80003es2lan(struct e1000_
        DEBUGFUNC("e1000_acquire_phy_80003es2lan");
 
        mask = hw->bus.func ? E1000_SWFW_PHY1_SM : E1000_SWFW_PHY0_SM;
-       return e1000_acquire_swfw_sync(hw, mask);
+       return e1000_acquire_swfw_sync_80003es2lan(hw, mask);
 }
 
 /**
@@ -313,7 +315,7 @@ static void e1000_release_phy_80003es2lan(struct e1000
        DEBUGFUNC("e1000_release_phy_80003es2lan");
 
        mask = hw->bus.func ? E1000_SWFW_PHY1_SM : E1000_SWFW_PHY0_SM;
-       e1000_release_swfw_sync(hw, mask);
+       e1000_release_swfw_sync_80003es2lan(hw, mask);
 }
 
 /**
@@ -331,7 +333,7 @@ static s32 e1000_acquire_mac_csr_80003es2lan(struct e1
 
        mask = E1000_SWFW_CSR_SM;
 
-       return e1000_acquire_swfw_sync(hw, mask);
+       return e1000_acquire_swfw_sync_80003es2lan(hw, mask);
 }
 
 /**
@@ -348,7 +350,7 @@ static void e1000_release_mac_csr_80003es2lan(struct e
 
        mask = E1000_SWFW_CSR_SM;
 
-       e1000_release_swfw_sync(hw, mask);
+       e1000_release_swfw_sync_80003es2lan(hw, mask);
 }
 
 /**
@@ -363,14 +365,14 @@ static s32 e1000_acquire_nvm_80003es2lan(struct e1000_
 
        DEBUGFUNC("e1000_acquire_nvm_80003es2lan");
 
-       ret_val = e1000_acquire_swfw_sync(hw, E1000_SWFW_EEP_SM);
+       ret_val = e1000_acquire_swfw_sync_80003es2lan(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(hw, E1000_SWFW_EEP_SM);
+               e1000_release_swfw_sync_80003es2lan(hw, E1000_SWFW_EEP_SM);
 
        return ret_val;
 }
@@ -386,7 +388,78 @@ static void e1000_release_nvm_80003es2lan(struct e1000
        DEBUGFUNC("e1000_release_nvm_80003es2lan");
 
        e1000_release_nvm_generic(hw);
-       e1000_release_swfw_sync(hw, E1000_SWFW_EEP_SM);
+       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");
+
+       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);
 }
 
 /**

Modified: head/sys/dev/e1000/e1000_82571.c
==============================================================================
--- head/sys/dev/e1000/e1000_82571.c    Wed Aug 30 18:46:38 2017        
(r323026)
+++ head/sys/dev/e1000/e1000_82571.c    Wed Aug 30 18:56:24 2017        
(r323027)
@@ -70,8 +70,11 @@ static s32  e1000_check_for_serdes_link_82571(struct e
 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,
@@ -122,8 +125,8 @@ static s32 e1000_init_phy_params_82571(struct e1000_hw
                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;
-               phy->ops.release        = e1000_put_hw_semaphore;
+               phy->ops.acquire        = e1000_get_hw_semaphore_82571;
+               phy->ops.release        = e1000_put_hw_semaphore_82571;
                break;
        case e1000_82573:
                phy->type               = e1000_phy_m88;
@@ -135,11 +138,12 @@ static s32 e1000_init_phy_params_82571(struct e1000_hw
                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;
-               phy->ops.release        = e1000_put_hw_semaphore;
+               phy->ops.acquire        = e1000_get_hw_semaphore_82571;
+               phy->ops.release        = e1000_put_hw_semaphore_82571;
                break;
        case e1000_82574:
        case e1000_82583:
+               E1000_MUTEX_INIT(&hw->dev_spec._82571.swflag_mutex);
 
                phy->type               = e1000_phy_bm;
                phy->ops.get_cfg_done   = e1000_get_cfg_done_generic;
@@ -502,21 +506,99 @@ static s32 e1000_get_phy_id_82571(struct e1000_hw *hw)
 }
 
 /**
- *  e1000_get_hw_semaphore_82574 - Acquire hardware semaphore
+ *  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_82574(struct e1000_hw *hw)
+static s32 e1000_get_hw_semaphore_82573(struct e1000_hw *hw)
 {
        u32 extcnf_ctrl;
        s32 i = 0;
-       /* XXX assert that mutex is held */
+
        DEBUGFUNC("e1000_get_hw_semaphore_82573");
 
-       ASSERT_CTX_LOCK_HELD(hw);
        extcnf_ctrl = E1000_READ_REG(hw, E1000_EXTCNF_CTRL);
        do {
                extcnf_ctrl |= E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
@@ -532,7 +614,7 @@ e1000_get_hw_semaphore_82574(struct e1000_hw *hw)
 
        if (i == MDIO_OWNERSHIP_TIMEOUT) {
                /* Release semaphores */
-               e1000_put_hw_semaphore_82574(hw);
+               e1000_put_hw_semaphore_82573(hw);
                DEBUGOUT("Driver can't access the PHY\n");
                return -E1000_ERR_PHY;
        }
@@ -541,18 +623,17 @@ e1000_get_hw_semaphore_82574(struct e1000_hw *hw)
 }
 
 /**
- *  e1000_put_hw_semaphore_82574 - Release hardware semaphore
+ *  e1000_put_hw_semaphore_82573 - Release hardware semaphore
  *  @hw: pointer to the HW structure
  *
  *  Release hardware semaphore used during reset.
  *
  **/
-static void
-e1000_put_hw_semaphore_82574(struct e1000_hw *hw)
+static void e1000_put_hw_semaphore_82573(struct e1000_hw *hw)
 {
        u32 extcnf_ctrl;
 
-       DEBUGFUNC("e1000_put_hw_semaphore_82574");
+       DEBUGFUNC("e1000_put_hw_semaphore_82573");
 
        extcnf_ctrl = E1000_READ_REG(hw, E1000_EXTCNF_CTRL);
        extcnf_ctrl &= ~E1000_EXTCNF_CTRL_MDIO_SW_OWNERSHIP;
@@ -560,6 +641,41 @@ e1000_put_hw_semaphore_82574(struct e1000_hw *hw)
 }
 
 /**
+ *  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
@@ -630,7 +746,7 @@ static s32 e1000_acquire_nvm_82571(struct e1000_hw *hw
 
        DEBUGFUNC("e1000_acquire_nvm_82571");
 
-       ret_val = e1000_get_hw_semaphore(hw);
+       ret_val = e1000_get_hw_semaphore_82571(hw);
        if (ret_val)
                return ret_val;
 
@@ -643,7 +759,7 @@ static s32 e1000_acquire_nvm_82571(struct e1000_hw *hw
        }
 
        if (ret_val)
-               e1000_put_hw_semaphore(hw);
+               e1000_put_hw_semaphore_82571(hw);
 
        return ret_val;
 }
@@ -659,7 +775,7 @@ static void e1000_release_nvm_82571(struct e1000_hw *h
        DEBUGFUNC("e1000_release_nvm_82571");
 
        e1000_release_nvm_generic(hw);
-       e1000_put_hw_semaphore(hw);
+       e1000_put_hw_semaphore_82571(hw);
 }
 
 /**
@@ -976,6 +1092,8 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
         */
        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);
@@ -992,6 +1110,10 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
        /* 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 */
@@ -999,7 +1121,6 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
                        e1000_put_hw_semaphore_82574(hw);
                break;
        default:
-               panic("unknown mac type %x\n", hw->mac.type);
                break;
        }
 

Modified: head/sys/dev/e1000/e1000_82575.c
==============================================================================
--- head/sys/dev/e1000/e1000_82575.c    Wed Aug 30 18:46:38 2017        
(r323026)
+++ head/sys/dev/e1000/e1000_82575.c    Wed Aug 30 18:56:24 2017        
(r323027)
@@ -79,9 +79,11 @@ static s32  e1000_valid_led_default_82575(struct e1000
 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);
@@ -509,8 +511,12 @@ static s32 e1000_init_mac_params_82575(struct e1000_hw
        /* 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;
-       mac->ops.release_swfw_sync = e1000_release_swfw_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;
+       }
 
        /* set lan id for port to determine which phy lock to use */
        hw->mac.ops.set_lan_id(hw);
@@ -982,7 +988,7 @@ static s32 e1000_acquire_nvm_82575(struct e1000_hw *hw
 
        DEBUGFUNC("e1000_acquire_nvm_82575");
 
-       ret_val = e1000_acquire_swfw_sync(hw, E1000_SWFW_EEP_SM);
+       ret_val = e1000_acquire_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
        if (ret_val)
                goto out;
 
@@ -1013,7 +1019,7 @@ static s32 e1000_acquire_nvm_82575(struct e1000_hw *hw
 
        ret_val = e1000_acquire_nvm_generic(hw);
        if (ret_val)
-               e1000_release_swfw_sync(hw, E1000_SWFW_EEP_SM);
+               e1000_release_swfw_sync_82575(hw, E1000_SWFW_EEP_SM);
 
 out:
        return ret_val;
@@ -1032,7 +1038,83 @@ static void e1000_release_nvm_82575(struct e1000_hw *h
 
        e1000_release_nvm_generic(hw);
 
-       e1000_release_swfw_sync(hw, E1000_SWFW_EEP_SM);
+       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");
+
+       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);
 }
 
 /**

Modified: head/sys/dev/e1000/e1000_hw.h
==============================================================================
--- head/sys/dev/e1000/e1000_hw.h       Wed Aug 30 18:46:38 2017        
(r323026)
+++ head/sys/dev/e1000/e1000_hw.h       Wed Aug 30 18:56:24 2017        
(r323027)
@@ -934,6 +934,7 @@ struct e1000_dev_spec_82543 {
 struct e1000_dev_spec_82571 {
        bool laa_is_present;
        u32 smb_counter;
+       E1000_MUTEX swflag_mutex;
 };
 
 struct e1000_dev_spec_80003es2lan {
@@ -957,6 +958,8 @@ enum e1000_ulp_state {
 struct e1000_dev_spec_ich8lan {
        bool kmrn_lock_loss_workaround_enabled;
        struct e1000_shadow_ram shadow_ram[E1000_SHADOW_RAM_WORDS];
+       E1000_MUTEX nvm_mutex;
+       E1000_MUTEX swflag_mutex;
        bool nvm_k1_enabled;
        bool disable_k1_off;
        bool eee_disable;

Modified: head/sys/dev/e1000/e1000_i210.c
==============================================================================
--- head/sys/dev/e1000/e1000_i210.c     Wed Aug 30 18:46:38 2017        
(r323026)
+++ head/sys/dev/e1000/e1000_i210.c     Wed Aug 30 18:56:24 2017        
(r323027)
@@ -37,6 +37,7 @@
 
 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);
@@ -57,7 +58,7 @@ static s32 e1000_acquire_nvm_i210(struct e1000_hw *hw)
 
        DEBUGFUNC("e1000_acquire_nvm_i210");
 
-       ret_val = e1000_acquire_swfw_sync(hw, E1000_SWFW_EEP_SM);
+       ret_val = e1000_acquire_swfw_sync_i210(hw, E1000_SWFW_EEP_SM);
 
        return ret_val;
 }
@@ -73,7 +74,152 @@ static void e1000_release_nvm_i210(struct e1000_hw *hw
 {
        DEBUGFUNC("e1000_release_nvm_i210");
 
-       e1000_release_swfw_sync(hw, E1000_SWFW_EEP_SM);
+       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;
+       s32 i = 0, timeout = 200; /* FIXME: find real value to use here */
+
+       DEBUGFUNC("e1000_acquire_swfw_sync_i210");
+
+       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;
 }
 
 /**

Modified: head/sys/dev/e1000/e1000_i210.h
==============================================================================
--- head/sys/dev/e1000/e1000_i210.h     Wed Aug 30 18:46:38 2017        
(r323026)
+++ head/sys/dev/e1000/e1000_i210.h     Wed Aug 30 18:56:24 2017        
(r323027)
@@ -43,6 +43,8 @@ s32 e1000_write_nvm_srwr_i210(struct e1000_hw *hw, u16
                              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,

Modified: head/sys/dev/e1000/e1000_ich8lan.c
==============================================================================
--- head/sys/dev/e1000/e1000_ich8lan.c  Wed Aug 30 18:46:38 2017        
(r323026)
+++ head/sys/dev/e1000/e1000_ich8lan.c  Wed Aug 30 18:56:24 2017        
(r323027)
@@ -694,6 +694,9 @@ static s32 e1000_init_nvm_params_ich8lan(struct e1000_
                dev_spec->shadow_ram[i].value    = 0xFFFF;
        }
 
+       E1000_MUTEX_INIT(&dev_spec->nvm_mutex);
+       E1000_MUTEX_INIT(&dev_spec->swflag_mutex);
+
        /* Function Pointers */
        nvm->ops.acquire        = e1000_acquire_nvm_ich8lan;
        nvm->ops.release        = e1000_release_nvm_ich8lan;
@@ -1844,7 +1847,7 @@ static s32 e1000_acquire_nvm_ich8lan(struct e1000_hw *
 {
        DEBUGFUNC("e1000_acquire_nvm_ich8lan");
 
-       ASSERT_CTX_LOCK_HELD(hw);
+       E1000_MUTEX_LOCK(&hw->dev_spec.ich8lan.nvm_mutex);
 
        return E1000_SUCCESS;
 }
@@ -1859,7 +1862,9 @@ static void e1000_release_nvm_ich8lan(struct e1000_hw 
 {
        DEBUGFUNC("e1000_release_nvm_ich8lan");
 
-       ASSERT_CTX_LOCK_HELD(hw);
+       E1000_MUTEX_UNLOCK(&hw->dev_spec.ich8lan.nvm_mutex);
+
+       return;
 }
 
 /**
@@ -1876,7 +1881,7 @@ static s32 e1000_acquire_swflag_ich8lan(struct e1000_h
 
        DEBUGFUNC("e1000_acquire_swflag_ich8lan");
 
-       ASSERT_CTX_LOCK_HELD(hw);
+       E1000_MUTEX_LOCK(&hw->dev_spec.ich8lan.swflag_mutex);
 
        while (timeout) {
                extcnf_ctrl = E1000_READ_REG(hw, E1000_EXTCNF_CTRL);
@@ -1917,6 +1922,9 @@ static s32 e1000_acquire_swflag_ich8lan(struct e1000_h
        }
 
 out:
+       if (ret_val)
+               E1000_MUTEX_UNLOCK(&hw->dev_spec.ich8lan.swflag_mutex);
+
        return ret_val;
 }
 
@@ -1941,6 +1949,10 @@ static void e1000_release_swflag_ich8lan(struct e1000_
        } else {
                DEBUGOUT("Semaphore unexpectedly released by sw/fw/hw\n");
        }
+
+       E1000_MUTEX_UNLOCK(&hw->dev_spec.ich8lan.swflag_mutex);
+
+       return;
 }
 
 /**
@@ -5010,6 +5022,8 @@ static s32 e1000_reset_hw_ich8lan(struct e1000_hw *hw)
                E1000_WRITE_REG(hw, E1000_FEXTNVM3, reg);
        }
 
+       if (!ret_val)
+               E1000_MUTEX_UNLOCK(&hw->dev_spec.ich8lan.swflag_mutex);
 
        if (ctrl & E1000_CTRL_PHY_RST) {
                ret_val = hw->phy.ops.get_cfg_done(hw);

Modified: head/sys/dev/e1000/e1000_mac.c
==============================================================================
--- head/sys/dev/e1000/e1000_mac.c      Wed Aug 30 18:46:38 2017        
(r323026)
+++ head/sys/dev/e1000/e1000_mac.c      Wed Aug 30 18:56:24 2017        
(r323027)
@@ -1707,6 +1707,76 @@ s32 e1000_get_speed_and_duplex_fiber_serdes_generic(st
 }
 
 /**
+ *  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
  *
@@ -2181,186 +2251,3 @@ s32 e1000_write_8bit_ctrl_reg_generic(struct e1000_hw 
 
        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) {
-#ifdef notyet
-               /*
-                * XXX This sounds more like a driver bug whereby we either
-                * recursed accidentally or missed clearing it previously
-                */
-               /* 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);
-                       }
-               }
-#endif
-
-               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

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
_______________________________________________
svn-src-head@freebsd.org mailing list
https://lists.freebsd.org/mailman/listinfo/svn-src-head
To unsubscribe, send any mail to "svn-src-head-unsubscr...@freebsd.org"

Reply via email to