7 files changed, 327 insertions, 122 deletions

diff --git a/drivers/net/ixgbe/ixgbe_82598.c b/drivers/net/ixgbe/ixgbe_82598.c
index f726a14d1a73..525bd87fea56 100644
--- a/drivers/net/ixgbe/ixgbe_82598.c
+++ b/drivers/net/ixgbe/ixgbe_82598.c
@@ -255,104 +255,75 @@ static enum ixgbe_media_type ixgbe_get_media_type_82598(struct ixgbe_hw *hw)
 }
 
 /**
- *  ixgbe_setup_fc_82598 - Configure flow control settings
+ *  ixgbe_fc_enable_82598 - Enable flow control
  *  @hw: pointer to hardware structure
  *  @packetbuf_num: packet buffer number (0-7)
  *
- *  Configures the flow control settings based on SW configuration.  This
- *  function is used for 802.3x flow control configuration only.
+ *  Enable flow control according to the current settings.
  **/
-static s32 ixgbe_setup_fc_82598(struct ixgbe_hw *hw, s32 packetbuf_num)
+static s32 ixgbe_fc_enable_82598(struct ixgbe_hw *hw, s32 packetbuf_num)
 {
-        u32 frctl_reg;
+        s32 ret_val = 0;
+        u32 fctrl_reg;
         u32 rmcs_reg;
+        u32 reg;
 
-        if (packetbuf_num < 0 || packetbuf_num > 7) {
-                hw_dbg(hw, "Invalid packet buffer number [%d], expected range is"
-                          " 0-7\n", packetbuf_num);
-        }
-
-        frctl_reg = IXGBE_READ_REG(hw, IXGBE_FCTRL);
-        frctl_reg &= ~(IXGBE_FCTRL_RFCE | IXGBE_FCTRL_RPFCE);
+        fctrl_reg = IXGBE_READ_REG(hw, IXGBE_FCTRL);
+        fctrl_reg &= ~(IXGBE_FCTRL_RFCE | IXGBE_FCTRL_RPFCE);
 
         rmcs_reg = IXGBE_READ_REG(hw, IXGBE_RMCS);
         rmcs_reg &= ~(IXGBE_RMCS_TFCE_PRIORITY | IXGBE_RMCS_TFCE_802_3X);
 
         /*
-         * 10 gig parts do not have a word in the EEPROM to determine the
-         * default flow control setting, so we explicitly set it to full.
-         */
-        if (hw->fc.type == ixgbe_fc_default)
-                hw->fc.type = ixgbe_fc_full;
-
-        /*
-         * We want to save off the original Flow Control configuration just in
-         * case we get disconnected and then reconnected into a different hub
-         * or switch with different Flow Control capabilities.
-         */
-        hw->fc.original_type = hw->fc.type;
-
-        /*
-         * The possible values of the "flow_control" parameter are:
+         * The possible values of fc.current_mode are:
          * 0: Flow control is completely disabled
-         * 1: Rx flow control is enabled (we can receive pause frames but not
-         *    send pause frames).
-         * 2: Tx flow control is enabled (we can send pause frames but we do not
-         *    support receiving pause frames)
+         * 1: Rx flow control is enabled (we can receive pause frames,
+         *    but not send pause frames).
+         * 2:  Tx flow control is enabled (we can send pause frames but
+         *     we do not support receiving pause frames).
          * 3: Both Rx and Tx flow control (symmetric) are enabled.
          * other: Invalid.
          */
-        switch (hw->fc.type) {
+        switch (hw->fc.current_mode) {
         case ixgbe_fc_none:
+                /* Flow control completely disabled by software override. */
                 break;
         case ixgbe_fc_rx_pause:
                 /*
-                 * Rx Flow control is enabled,
-                 * and Tx Flow control is disabled.
+                 * Rx Flow control is enabled and Tx Flow control is
+                 * disabled by software override. Since there really
+                 * isn't a way to advertise that we are capable of RX
+                 * Pause ONLY, we will advertise that we support both
+                 * symmetric and asymmetric Rx PAUSE.  Later, we will
+                 * disable the adapter's ability to send PAUSE frames.
                  */
-                frctl_reg |= IXGBE_FCTRL_RFCE;
+                fctrl_reg |= IXGBE_FCTRL_RFCE;
                 break;
         case ixgbe_fc_tx_pause:
                 /*
-                 * Tx Flow control is enabled, and Rx Flow control is disabled,
-                 * by a software over-ride.
+                 * Tx Flow control is enabled, and Rx Flow control is
+                 * disabled by software override.
                  */
                 rmcs_reg |= IXGBE_RMCS_TFCE_802_3X;
                 break;
         case ixgbe_fc_full:
-                /*
-                 * Flow control (both Rx and Tx) is enabled by a software
-                 * over-ride.
-                 */
-                frctl_reg |= IXGBE_FCTRL_RFCE;
+                /* Flow control (both Rx and Tx) is enabled by SW override. */
+                fctrl_reg |= IXGBE_FCTRL_RFCE;
                 rmcs_reg |= IXGBE_RMCS_TFCE_802_3X;
                 break;
         default:
-                /* We should never get here.  The value should be 0-3. */
                 hw_dbg(hw, "Flow control param set incorrectly\n");
+                ret_val = -IXGBE_ERR_CONFIG;
+                goto out;
                 break;
         }
 
         /* Enable 802.3x based flow control settings. */
-        IXGBE_WRITE_REG(hw, IXGBE_FCTRL, frctl_reg);
+        IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl_reg);
         IXGBE_WRITE_REG(hw, IXGBE_RMCS, rmcs_reg);
 
-        /*
-         * Check for invalid software configuration, zeros are completely
-         * invalid for all parameters used past this point, and if we enable
-         * flow control with zero water marks, we blast flow control packets.
-         */
-        if (!hw->fc.low_water || !hw->fc.high_water || !hw->fc.pause_time) {
-                hw_dbg(hw, "Flow control structure initialized incorrectly\n");
-                return IXGBE_ERR_INVALID_LINK_SETTINGS;
-        }
-
-        /*
-         * We need to set up the Receive Threshold high and low water
-         * marks as well as (optionally) enabling the transmission of
-         * XON frames.
-         */
-        if (hw->fc.type & ixgbe_fc_tx_pause) {
+        /* Set up and enable Rx high/low water mark thresholds, enable XON. */
+        if (hw->fc.current_mode & ixgbe_fc_tx_pause) {
                 if (hw->fc.send_xon) {
                         IXGBE_WRITE_REG(hw, IXGBE_FCRTL(packetbuf_num),
                                         (hw->fc.low_water | IXGBE_FCRTL_XONE));
@@ -360,14 +331,93 @@ static s32 ixgbe_setup_fc_82598(struct ixgbe_hw *hw, s32 packetbuf_num)
                         IXGBE_WRITE_REG(hw, IXGBE_FCRTL(packetbuf_num),
                                         hw->fc.low_water);
                 }
+
                 IXGBE_WRITE_REG(hw, IXGBE_FCRTH(packetbuf_num),
-                                (hw->fc.high_water)|IXGBE_FCRTH_FCEN);
+                                (hw->fc.high_water | IXGBE_FCRTH_FCEN));
         }
 
-        IXGBE_WRITE_REG(hw, IXGBE_FCTTV(0), hw->fc.pause_time);
+        /* Configure pause time (2 TCs per register) */
+        reg = IXGBE_READ_REG(hw, IXGBE_FCTTV(packetbuf_num));
+        if ((packetbuf_num & 1) == 0)
+                reg = (reg & 0xFFFF0000) | hw->fc.pause_time;
+        else
+                reg = (reg & 0x0000FFFF) | (hw->fc.pause_time << 16);
+        IXGBE_WRITE_REG(hw, IXGBE_FCTTV(packetbuf_num / 2), reg);
+
         IXGBE_WRITE_REG(hw, IXGBE_FCRTV, (hw->fc.pause_time >> 1));
 
-        return 0;
+out:
+        return ret_val;
+}
+
+/**
+ *  ixgbe_setup_fc_82598 - Configure flow control settings
+ *  @hw: pointer to hardware structure
+ *  @packetbuf_num: packet buffer number (0-7)
+ *
+ *  Configures the flow control settings based on SW configuration.  This
+ *  function is used for 802.3x flow control configuration only.
+ **/
+static s32 ixgbe_setup_fc_82598(struct ixgbe_hw *hw, s32 packetbuf_num)
+{
+        s32 ret_val = 0;
+        ixgbe_link_speed speed;
+        bool link_up;
+
+        /* Validate the packetbuf configuration */
+        if (packetbuf_num < 0 || packetbuf_num > 7) {
+                hw_dbg(hw, "Invalid packet buffer number [%d], expected range is"
+                          " 0-7\n", packetbuf_num);
+                ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
+                goto out;
+        }
+
+        /*
+         * Validate the water mark configuration.  Zero water marks are invalid
+         * because it causes the controller to just blast out fc packets.
+         */
+        if (!hw->fc.low_water || !hw->fc.high_water || !hw->fc.pause_time) {
+                hw_dbg(hw, "Invalid water mark configuration\n");
+                ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
+                goto out;
+        }
+
+        /*
+         * Validate the requested mode.  Strict IEEE mode does not allow
+         * ixgbe_fc_rx_pause because it will cause testing anomalies.
+         */
+        if (hw->fc.strict_ieee && hw->fc.requested_mode == ixgbe_fc_rx_pause) {
+                hw_dbg(hw, "ixgbe_fc_rx_pause not valid in strict IEEE mode\n");
+                ret_val = IXGBE_ERR_INVALID_LINK_SETTINGS;
+                goto out;
+        }
+
+        /*
+         * 10gig parts do not have a word in the EEPROM to determine the
+         * default flow control setting, so we explicitly set it to full.
+         */
+        if (hw->fc.requested_mode == ixgbe_fc_default)
+                hw->fc.requested_mode = ixgbe_fc_full;
+
+        /*
+         * Save off the requested flow control mode for use later.  Depending
+         * on the link partner's capabilities, we may or may not use this mode.
+         */
+
+        hw->fc.current_mode = hw->fc.requested_mode;
+
+        /* Decide whether to use autoneg or not. */
+        hw->mac.ops.check_link(hw, &speed, &link_up, false);
+        if (hw->phy.multispeed_fiber && (speed == IXGBE_LINK_SPEED_1GB_FULL))
+                ret_val = ixgbe_fc_autoneg(hw);
+
+        if (ret_val)
+                goto out;
+
+        ret_val = ixgbe_fc_enable_82598(hw, packetbuf_num);
+
+out:
+        return ret_val;
 }
 
 /**
@@ -414,7 +464,6 @@ static s32 ixgbe_setup_mac_link_82598(struct ixgbe_hw *hw)
          * case we get disconnected and then reconnected into a different hub
          * or switch with different Flow Control capabilities.
          */
-        hw->fc.original_type = hw->fc.type;
         ixgbe_setup_fc_82598(hw, 0);
 
         /* Add delay to filter out noises during initial link setup */
diff --git a/drivers/net/ixgbe/ixgbe_common.c b/drivers/net/ixgbe/ixgbe_common.c
index 13ad5ba66b63..5ae93989784f 100644
--- a/drivers/net/ixgbe/ixgbe_common.c
+++ b/drivers/net/ixgbe/ixgbe_common.c
@@ -1487,6 +1487,144 @@ s32 ixgbe_disable_mc_generic(struct ixgbe_hw *hw)
 }
 
 /**
+ *  ixgbe_fc_autoneg - Configure flow control
+ *  @hw: pointer to hardware structure
+ *
+ *  Negotiates flow control capabilities with link partner using autoneg and
+ *  applies the results.
+ **/
+s32 ixgbe_fc_autoneg(struct ixgbe_hw *hw)
+{
+        s32 ret_val = 0;
+        u32 i, reg, pcs_anadv_reg, pcs_lpab_reg;
+
+        reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANA);
+
+        /*
+         * The possible values of fc.current_mode are:
+         * 0:  Flow control is completely disabled
+         * 1:  Rx flow control is enabled (we can receive pause frames,
+         *     but not send pause frames).
+         * 2:  Tx flow control is enabled (we can send pause frames but
+         *     we do not support receiving pause frames).
+         * 3:  Both Rx and Tx flow control (symmetric) are enabled.
+         * other: Invalid.
+         */
+        switch (hw->fc.current_mode) {
+        case ixgbe_fc_none:
+                /* Flow control completely disabled by software override. */
+                reg &= ~(IXGBE_PCS1GANA_SYM_PAUSE | IXGBE_PCS1GANA_ASM_PAUSE);
+                break;
+        case ixgbe_fc_rx_pause:
+                /*
+                 * Rx Flow control is enabled and Tx Flow control is
+                 * disabled by software override. Since there really
+                 * isn't a way to advertise that we are capable of RX
+                 * Pause ONLY, we will advertise that we support both
+                 * symmetric and asymmetric Rx PAUSE.  Later, we will
+                 * disable the adapter's ability to send PAUSE frames.
+                 */
+                reg |= (IXGBE_PCS1GANA_SYM_PAUSE | IXGBE_PCS1GANA_ASM_PAUSE);
+                break;
+        case ixgbe_fc_tx_pause:
+                /*
+                 * Tx Flow control is enabled, and Rx Flow control is
+                 * disabled by software override.
+                 */
+                reg |= (IXGBE_PCS1GANA_ASM_PAUSE);
+                reg &= ~(IXGBE_PCS1GANA_SYM_PAUSE);
+                break;
+        case ixgbe_fc_full:
+                /* Flow control (both Rx and Tx) is enabled by SW override. */
+                reg |= (IXGBE_PCS1GANA_SYM_PAUSE | IXGBE_PCS1GANA_ASM_PAUSE);
+                break;
+        default:
+                hw_dbg(hw, "Flow control param set incorrectly\n");
+                ret_val = -IXGBE_ERR_CONFIG;
+                goto out;
+                break;
+        }
+
+        IXGBE_WRITE_REG(hw, IXGBE_PCS1GANA, reg);
+        reg = IXGBE_READ_REG(hw, IXGBE_PCS1GLCTL);
+
+        /* Set PCS register for autoneg */
+        /* Enable and restart autoneg */
+        reg |= IXGBE_PCS1GLCTL_AN_ENABLE | IXGBE_PCS1GLCTL_AN_RESTART;
+
+        /* Disable AN timeout */
+        if (hw->fc.strict_ieee)
+                reg &= ~IXGBE_PCS1GLCTL_AN_1G_TIMEOUT_EN;
+
+        hw_dbg(hw, "Configuring Autoneg; PCS_LCTL = 0x%08X\n", reg);
+        IXGBE_WRITE_REG(hw, IXGBE_PCS1GLCTL, reg);
+
+        /* See if autonegotiation has succeeded */
+        hw->mac.autoneg_succeeded = 0;
+        for (i = 0; i < FIBER_LINK_UP_LIMIT; i++) {
+                msleep(10);
+                reg = IXGBE_READ_REG(hw, IXGBE_PCS1GLSTA);
+                if ((reg & (IXGBE_PCS1GLSTA_LINK_OK |
+                     IXGBE_PCS1GLSTA_AN_COMPLETE)) ==
+                    (IXGBE_PCS1GLSTA_LINK_OK |
+                     IXGBE_PCS1GLSTA_AN_COMPLETE)) {
+                        if (!(reg & IXGBE_PCS1GLSTA_AN_TIMED_OUT))
+                                hw->mac.autoneg_succeeded = 1;
+                        break;
+                }
+        }
+
+        if (!hw->mac.autoneg_succeeded) {
+                /* Autoneg failed to achieve a link, so we turn fc off */
+                hw->fc.current_mode = ixgbe_fc_none;
+                hw_dbg(hw, "Flow Control = NONE.\n");
+                goto out;
+        }
+
+        /*
+         * Read the AN advertisement and LP ability registers and resolve
+         * local flow control settings accordingly
+         */
+        pcs_anadv_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANA);
+        pcs_lpab_reg = IXGBE_READ_REG(hw, IXGBE_PCS1GANLP);
+        if ((pcs_anadv_reg & IXGBE_PCS1GANA_SYM_PAUSE) &&
+                (pcs_lpab_reg & IXGBE_PCS1GANA_SYM_PAUSE)) {
+                /*
+                 * Now we need to check if the user selected Rx ONLY
+                 * of pause frames.  In this case, we had to advertise
+                 * FULL flow control because we could not advertise RX
+                 * ONLY. Hence, we must now check to see if we need to
+                 * turn OFF the TRANSMISSION of PAUSE frames.
+                 */
+                if (hw->fc.requested_mode == ixgbe_fc_full) {
+                        hw->fc.current_mode = ixgbe_fc_full;
+                        hw_dbg(hw, "Flow Control = FULL.\n");
+                } else {
+                        hw->fc.current_mode = ixgbe_fc_rx_pause;
+                        hw_dbg(hw, "Flow Control = RX PAUSE frames only.\n");
+                }
+        } else if (!(pcs_anadv_reg & IXGBE_PCS1GANA_SYM_PAUSE) &&
+                   (pcs_anadv_reg & IXGBE_PCS1GANA_ASM_PAUSE) &&
+                   (pcs_lpab_reg & IXGBE_PCS1GANA_SYM_PAUSE) &&
+                   (pcs_lpab_reg & IXGBE_PCS1GANA_ASM_PAUSE)) {
+                hw->fc.current_mode = ixgbe_fc_tx_pause;
+                hw_dbg(hw, "Flow Control = TX PAUSE frames only.\n");
+        } else if ((pcs_anadv_reg & IXGBE_PCS1GANA_SYM_PAUSE) &&
+                   (pcs_anadv_reg & IXGBE_PCS1GANA_ASM_PAUSE) &&
+                   !(pcs_lpab_reg & IXGBE_PCS1GANA_SYM_PAUSE) &&
+                   (pcs_lpab_reg & IXGBE_PCS1GANA_ASM_PAUSE)) {
+                hw->fc.current_mode = ixgbe_fc_rx_pause;
+                hw_dbg(hw, "Flow Control = RX PAUSE frames only.\n");
+        } else {
+                hw->fc.current_mode = ixgbe_fc_none;
+                hw_dbg(hw, "Flow Control = NONE.\n");
+        }
+
+out:
+        return ret_val;
+}
+
+/**
  *  ixgbe_disable_pcie_master - Disable PCI-express master access
  *  @hw: pointer to hardware structure
  *
diff --git a/drivers/net/ixgbe/ixgbe_common.h b/drivers/net/ixgbe/ixgbe_common.h
index 0b5ba5755805..c63021261e56 100644
--- a/drivers/net/ixgbe/ixgbe_common.h
+++ b/drivers/net/ixgbe/ixgbe_common.h
@@ -61,6 +61,9 @@ s32 ixgbe_update_uc_addr_list_generic(struct ixgbe_hw *hw, u8 *addr_list,
                                       u32 addr_count, ixgbe_mc_addr_itr func);
 s32 ixgbe_enable_mc_generic(struct ixgbe_hw *hw);
 s32 ixgbe_disable_mc_generic(struct ixgbe_hw *hw);
+s32 ixgbe_setup_fc_generic(struct ixgbe_hw *hw, s32 packetbuf_num);
+s32 ixgbe_fc_enable(struct ixgbe_hw *hw, s32 packtetbuf_num);
+s32 ixgbe_fc_autoneg(struct ixgbe_hw *hw);
 
 s32 ixgbe_validate_mac_addr(u8 *mac_addr);
 s32 ixgbe_acquire_swfw_sync(struct ixgbe_hw *hw, u16 mask);
diff --git a/drivers/net/ixgbe/ixgbe_dcb_82598.c b/drivers/net/ixgbe/ixgbe_dcb_82598.c
index 560321148935..df359554d492 100644
--- a/drivers/net/ixgbe/ixgbe_dcb_82598.c
+++ b/drivers/net/ixgbe/ixgbe_dcb_82598.c
@@ -298,7 +298,7 @@ s32 ixgbe_dcb_config_pfc_82598(struct ixgbe_hw *hw,
         reg = IXGBE_READ_REG(hw, IXGBE_RMCS);
         reg &= ~IXGBE_RMCS_TFCE_802_3X;
         /* correct the reporting of our flow control status */
-        hw->fc.type = ixgbe_fc_none;
+        hw->fc.current_mode = ixgbe_fc_none;
         reg |= IXGBE_RMCS_TFCE_PRIORITY;
         IXGBE_WRITE_REG(hw, IXGBE_RMCS, reg);
 
diff --git a/drivers/net/ixgbe/ixgbe_ethtool.c b/drivers/net/ixgbe/ixgbe_ethtool.c
index 54d96cb05b48..cec2f4e8c61e 100644
--- a/drivers/net/ixgbe/ixgbe_ethtool.c
+++ b/drivers/net/ixgbe/ixgbe_ethtool.c
@@ -224,13 +224,13 @@ static void ixgbe_get_pauseparam(struct net_device *netdev,
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
         struct ixgbe_hw *hw = &adapter->hw;
 
-        pause->autoneg = (hw->fc.type == ixgbe_fc_full ? 1 : 0);
+        pause->autoneg = (hw->fc.current_mode == ixgbe_fc_full ? 1 : 0);
 
-        if (hw->fc.type == ixgbe_fc_rx_pause) {
+        if (hw->fc.current_mode == ixgbe_fc_rx_pause) {
                 pause->rx_pause = 1;
-        } else if (hw->fc.type == ixgbe_fc_tx_pause) {
+        } else if (hw->fc.current_mode == ixgbe_fc_tx_pause) {
                 pause->tx_pause = 1;
-        } else if (hw->fc.type == ixgbe_fc_full) {
+        } else if (hw->fc.current_mode == ixgbe_fc_full) {
                 pause->rx_pause = 1;
                 pause->tx_pause = 1;
         }
@@ -244,22 +244,17 @@ static int ixgbe_set_pauseparam(struct net_device *netdev,
 
         if ((pause->autoneg == AUTONEG_ENABLE) ||
             (pause->rx_pause && pause->tx_pause))
-                hw->fc.type = ixgbe_fc_full;
+                hw->fc.requested_mode = ixgbe_fc_full;
         else if (pause->rx_pause && !pause->tx_pause)
-                hw->fc.type = ixgbe_fc_rx_pause;
+                hw->fc.requested_mode = ixgbe_fc_rx_pause;
         else if (!pause->rx_pause && pause->tx_pause)
-                hw->fc.type = ixgbe_fc_tx_pause;
+                hw->fc.requested_mode = ixgbe_fc_tx_pause;
         else if (!pause->rx_pause && !pause->tx_pause)
-                hw->fc.type = ixgbe_fc_none;
+                hw->fc.requested_mode = ixgbe_fc_none;
         else
                 return -EINVAL;
 
-        hw->fc.original_type = hw->fc.type;
-
-        if (netif_running(netdev))
-                ixgbe_reinit_locked(adapter);
-        else
-                ixgbe_reset(adapter);
+        hw->mac.ops.setup_fc(hw, 0);
 
         return 0;
 }
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index dceae37fd57f..850361a4c38d 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -1954,11 +1954,43 @@ static void ixgbe_configure(struct ixgbe_adapter *adapter)
                                        (adapter->rx_ring[i].count - 1));
 }
 
+/**
+ * ixgbe_link_config - set up initial link with default speed and duplex
+ * @hw: pointer to private hardware struct
+ *
+ * Returns 0 on success, negative on failure
+ **/
+static int ixgbe_link_config(struct ixgbe_hw *hw)
+{
+        u32 autoneg;
+        bool link_up = false;
+        u32 ret = IXGBE_ERR_LINK_SETUP;
+
+        if (hw->mac.ops.check_link)
+                ret = hw->mac.ops.check_link(hw, &autoneg, &link_up, false);
+
+        if (ret)
+                goto link_cfg_out;
+
+        if (hw->mac.ops.get_link_capabilities)
+                ret = hw->mac.ops.get_link_capabilities(hw, &autoneg,
+                                                        &hw->mac.autoneg);
+        if (ret)
+                goto link_cfg_out;
+
+        if (hw->mac.ops.setup_link_speed)
+                ret = hw->mac.ops.setup_link_speed(hw, autoneg, true, link_up);
+
+link_cfg_out:
+        return ret;
+}
+
 static int ixgbe_up_complete(struct ixgbe_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
         struct ixgbe_hw *hw = &adapter->hw;
         int i, j = 0;
+        int err;
         int max_frame = netdev->mtu + ETH_HLEN + ETH_FCS_LEN;
         u32 txdctl, rxdctl, mhadd;
         u32 gpie;
@@ -2039,6 +2071,10 @@ static int ixgbe_up_complete(struct ixgbe_adapter *adapter)
 
         ixgbe_irq_enable(adapter);
 
+        err = ixgbe_link_config(hw);
+        if (err)
+                dev_err(&adapter->pdev->dev, "link_config FAILED %d\n", err);
+
         /* enable transmits */
         netif_tx_start_all_queues(netdev);
 
@@ -2792,8 +2828,7 @@ static int __devinit ixgbe_sw_init(struct ixgbe_adapter *adapter)
                 adapter->flags |= IXGBE_FLAG_FAN_FAIL_CAPABLE;
 
         /* default flow control settings */
-        hw->fc.original_type = ixgbe_fc_none;
-        hw->fc.type = ixgbe_fc_none;
+        hw->fc.requested_mode = ixgbe_fc_none;
         hw->fc.high_water = IXGBE_DEFAULT_FCRTH;
         hw->fc.low_water = IXGBE_DEFAULT_FCRTL;
         hw->fc.pause_time = IXGBE_DEFAULT_FCPAUSE;
@@ -3916,37 +3951,6 @@ static void ixgbe_netpoll(struct net_device *netdev)
 }
 #endif
 
-/**
- * ixgbe_link_config - set up initial link with default speed and duplex
- * @hw: pointer to private hardware struct
- *
- * Returns 0 on success, negative on failure
- **/
-static int ixgbe_link_config(struct ixgbe_hw *hw)
-{
-        u32 autoneg;
-        bool link_up = false;
-        u32 ret = IXGBE_ERR_LINK_SETUP;
-
-        if (hw->mac.ops.check_link)
-                ret = hw->mac.ops.check_link(hw, &autoneg, &link_up, false);
-
-        if (ret || !link_up)
-                goto link_cfg_out;
-
-        if (hw->mac.ops.get_link_capabilities)
-                ret = hw->mac.ops.get_link_capabilities(hw, &autoneg,
-                                                        &hw->mac.autoneg);
-        if (ret)
-                goto link_cfg_out;
-
-        if (hw->mac.ops.setup_link_speed)
-                ret = hw->mac.ops.setup_link_speed(hw, autoneg, true, true);
-
-link_cfg_out:
-        return ret;
-}
-
 static const struct net_device_ops ixgbe_netdev_ops = {
         .ndo_open               = ixgbe_open,
         .ndo_stop               = ixgbe_close,
@@ -4197,13 +4201,6 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
         /* reset the hardware with the new settings */
         hw->mac.ops.start_hw(hw);
 
-        /* link_config depends on start_hw being called at least once */
-        err = ixgbe_link_config(hw);
-        if (err) {
-                dev_err(&pdev->dev, "setup_link_speed FAILED %d\n", err);
-                goto err_register;
-        }
-
         netif_carrier_off(netdev);
 
         strcpy(netdev->name, "eth%d");
diff --git a/drivers/net/ixgbe/ixgbe_type.h b/drivers/net/ixgbe/ixgbe_type.h
index 984b4ed372f1..237c688f8b6e 100644
--- a/drivers/net/ixgbe/ixgbe_type.h
+++ b/drivers/net/ixgbe/ixgbe_type.h
@@ -771,6 +771,28 @@
 #define IXGBE_LINK_UP_TIME      90 /* 9.0 Seconds */
 #define IXGBE_AUTO_NEG_TIME     45 /* 4.5 Seconds */
 
+#define FIBER_LINK_UP_LIMIT     50
+
+/* PCS1GLSTA Bit Masks */
+#define IXGBE_PCS1GLSTA_LINK_OK         1
+#define IXGBE_PCS1GLSTA_SYNK_OK         0x10
+#define IXGBE_PCS1GLSTA_AN_COMPLETE     0x10000
+#define IXGBE_PCS1GLSTA_AN_PAGE_RX      0x20000
+#define IXGBE_PCS1GLSTA_AN_TIMED_OUT    0x40000
+#define IXGBE_PCS1GLSTA_AN_REMOTE_FAULT 0x80000
+#define IXGBE_PCS1GLSTA_AN_ERROR_RWS    0x100000
+
+#define IXGBE_PCS1GANA_SYM_PAUSE        0x80
+#define IXGBE_PCS1GANA_ASM_PAUSE        0x100
+
+/* PCS1GLCTL Bit Masks */
+#define IXGBE_PCS1GLCTL_AN_1G_TIMEOUT_EN  0x00040000 /* PCS 1G autoneg to en */
+#define IXGBE_PCS1GLCTL_FLV_LINK_UP     1
+#define IXGBE_PCS1GLCTL_FORCE_LINK      0x20
+#define IXGBE_PCS1GLCTL_LOW_LINK_LATCH  0x40
+#define IXGBE_PCS1GLCTL_AN_ENABLE       0x10000
+#define IXGBE_PCS1GLCTL_AN_RESTART      0x20000
+
 /* SW Semaphore Register bitmasks */
 #define IXGBE_SWSM_SMBI 0x00000001 /* Driver Semaphore bit */
 #define IXGBE_SWSM_SWESMBI 0x00000002 /* FW Semaphore bit */
@@ -1270,7 +1292,7 @@ enum ixgbe_media_type {
 };
 
 /* Flow Control Settings */
-enum ixgbe_fc_type {
+enum ixgbe_fc_mode {
         ixgbe_fc_none = 0,
         ixgbe_fc_rx_pause,
         ixgbe_fc_tx_pause,
@@ -1294,8 +1316,8 @@ struct ixgbe_fc_info {
         u16 pause_time; /* Flow Control Pause timer */
         bool send_xon; /* Flow control send XON */
         bool strict_ieee; /* Strict IEEE mode */
-        enum ixgbe_fc_type type; /* Type of flow control */
-        enum ixgbe_fc_type original_type;
+        enum ixgbe_fc_mode current_mode; /* FC mode in effect */
+        enum ixgbe_fc_mode requested_mode; /* FC mode requested by caller */
 };
 
 /* Statistics counters collected by the MAC */
@@ -1475,6 +1497,7 @@ struct ixgbe_phy_info {
         bool                            reset_disable;
         ixgbe_autoneg_advertised        autoneg_advertised;
         bool                            autoneg_wait_to_complete;
+        bool                            multispeed_fiber;
 };
 
 struct ixgbe_hw {