merge by hand - fix up rejections in Documentation/DocBook/Makefile

1 files changed, 508 insertions, 154 deletions

diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 12de80884b1a..f79b02e80e75 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -61,8 +61,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.25"
-#define DRV_MODULE_RELDATE      "March 24, 2005"
+#define DRV_MODULE_VERSION      "3.27"
+#define DRV_MODULE_RELDATE      "May 5, 2005"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -85,8 +85,7 @@
 /* hardware minimum and maximum for a single frame's data payload */
 #define TG3_MIN_MTU                     60
 #define TG3_MAX_MTU(tp) \
-        ((GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705 && \
-          GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5750) ? 9000 : 1500)
+        (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS) ? 9000 : 1500)
 
 /* These numbers seem to be hard coded in the NIC firmware somehow.
  * You can't change the ring sizes, but you can change where you place
@@ -205,6 +204,8 @@ static struct pci_device_id tg3_pci_tbl[] = {
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5751F,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
+        { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5752,
+          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5753M,
@@ -425,9 +426,30 @@ static void tg3_enable_ints(struct tg3 *tp)
         tg3_cond_int(tp);
 }
 
+static inline unsigned int tg3_has_work(struct tg3 *tp)
+{
+        struct tg3_hw_status *sblk = tp->hw_status;
+        unsigned int work_exists = 0;
+
+        /* check for phy events */
+        if (!(tp->tg3_flags &
+              (TG3_FLAG_USE_LINKCHG_REG |
+               TG3_FLAG_POLL_SERDES))) {
+                if (sblk->status & SD_STATUS_LINK_CHG)
+                        work_exists = 1;
+        }
+        /* check for RX/TX work to do */
+        if (sblk->idx[0].tx_consumer != tp->tx_cons ||
+            sblk->idx[0].rx_producer != tp->rx_rcb_ptr)
+                work_exists = 1;
+
+        return work_exists;
+}
+
 /* tg3_restart_ints
- *  similar to tg3_enable_ints, but it can return without flushing the
- *  PIO write which reenables interrupts
+ *  similar to tg3_enable_ints, but it accurately determines whether there
+ *  is new work pending and can return without flushing the PIO write
+ *  which reenables interrupts 
  */
 static void tg3_restart_ints(struct tg3 *tp)
 {
@@ -436,7 +458,9 @@ static void tg3_restart_ints(struct tg3 *tp)
         tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000000);
         mmiowb();
 
-        tg3_cond_int(tp);
+        if (tg3_has_work(tp))
+                tw32(HOSTCC_MODE, tp->coalesce_mode |
+                     (HOSTCC_MODE_ENABLE | HOSTCC_MODE_NOW));
 }
 
 static inline void tg3_netif_stop(struct tg3 *tp)
@@ -860,8 +884,7 @@ out:
         if ((tp->phy_id & PHY_ID_MASK) == PHY_ID_BCM5401) {
                 /* Cannot do read-modify-write on 5401 */
                 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x4c20);
-        } else if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705 &&
-                   GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5750) {
+        } else if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
                 u32 phy_reg;
 
                 /* Set bit 14 with read-modify-write to preserve other bits */
@@ -873,8 +896,7 @@ out:
         /* Set phy register 0x10 bit 0 to high fifo elasticity to support
          * jumbo frames transmission.
          */
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705 &&
-            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5750) {
+        if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
                 u32 phy_reg;
 
                 if (!tg3_readphy(tp, MII_TG3_EXT_CTRL, &phy_reg))
@@ -1006,8 +1028,13 @@ static int tg3_set_power_state(struct tg3 *tp, int state)
                 pci_write_config_word(tp->pdev,
                                       pm + PCI_PM_CTRL,
                                       power_control);
-                tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
-                udelay(100);
+                udelay(100);    /* Delay after power state change */
+
+                /* Switch out of Vaux if it is not a LOM */
+                if (!(tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT)) {
+                        tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
+                        udelay(100);
+                }
 
                 return 0;
 
@@ -1068,7 +1095,7 @@ static int tg3_set_power_state(struct tg3 *tp, int state)
                         mac_mode = MAC_MODE_PORT_MODE_TBI;
                 }
 
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5750)
+                if (!(tp->tg3_flags2 & TG3_FLG2_5750_PLUS))
                         tw32(MAC_LED_CTRL, tp->led_ctrl);
 
                 if (((power_caps & PCI_PM_CAP_PME_D3cold) &&
@@ -1095,7 +1122,7 @@ static int tg3_set_power_state(struct tg3 *tp, int state)
                      CLOCK_CTRL_ALTCLK |
                      CLOCK_CTRL_PWRDOWN_PLL133);
                 udelay(40);
-        } else if (!((GET_ASIC_REV(tp->pci_chip_rev_id) == 5750) &&
+        } else if (!((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
                      (tp->tg3_flags & TG3_FLAG_ENABLE_ASF))) {
                 u32 newbits1, newbits2;
 
@@ -1152,6 +1179,7 @@ static int tg3_set_power_state(struct tg3 *tp, int state)
 
         /* Finally, set the new power state. */
         pci_write_config_word(tp->pdev, pm + PCI_PM_CTRL, power_control);
+        udelay(100);    /* Delay after power state change */
 
         tg3_write_sig_post_reset(tp, RESET_KIND_SHUTDOWN);
 
@@ -2681,8 +2709,8 @@ static int tg3_vlan_rx(struct tg3 *tp, struct sk_buff *skb, u16 vlan_tag)
 static int tg3_rx(struct tg3 *tp, int budget)
 {
         u32 work_mask;
-        u32 rx_rcb_ptr = tp->rx_rcb_ptr;
-        u16 hw_idx, sw_idx;
+        u32 sw_idx = tp->rx_rcb_ptr;
+        u16 hw_idx;
         int received;
 
         hw_idx = tp->hw_status->idx[0].rx_producer;
@@ -2691,7 +2719,6 @@ static int tg3_rx(struct tg3 *tp, int budget)
          * the opaque cookie.
          */
         rmb();
-        sw_idx = rx_rcb_ptr % TG3_RX_RCB_RING_SIZE(tp);
         work_mask = 0;
         received = 0;
         while (sw_idx != hw_idx && budget > 0) {
@@ -2796,14 +2823,19 @@ static int tg3_rx(struct tg3 *tp, int budget)
 next_pkt:
                 (*post_ptr)++;
 next_pkt_nopost:
-                rx_rcb_ptr++;
-                sw_idx = rx_rcb_ptr % TG3_RX_RCB_RING_SIZE(tp);
+                sw_idx++;
+                sw_idx %= TG3_RX_RCB_RING_SIZE(tp);
+
+                /* Refresh hw_idx to see if there is new work */
+                if (sw_idx == hw_idx) {
+                        hw_idx = tp->hw_status->idx[0].rx_producer;
+                        rmb();
+                }
         }
 
         /* ACK the status ring. */
-        tp->rx_rcb_ptr = rx_rcb_ptr;
-        tw32_rx_mbox(MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW,
-                     (rx_rcb_ptr % TG3_RX_RCB_RING_SIZE(tp)));
+        tp->rx_rcb_ptr = sw_idx;
+        tw32_rx_mbox(MAILBOX_RCVRET_CON_IDX_0 + TG3_64BIT_REG_LOW, sw_idx);
 
         /* Refill RX ring(s). */
         if (work_mask & RXD_OPAQUE_RING_STD) {
@@ -2882,24 +2914,41 @@ static int tg3_poll(struct net_device *netdev, int *budget)
         return (done ? 0 : 1);
 }
 
-static inline unsigned int tg3_has_work(struct net_device *dev, struct tg3 *tp)
+/* MSI ISR - No need to check for interrupt sharing and no need to
+ * flush status block and interrupt mailbox. PCI ordering rules
+ * guarantee that MSI will arrive after the status block.
+ */
+static irqreturn_t tg3_msi(int irq, void *dev_id, struct pt_regs *regs)
 {
+        struct net_device *dev = dev_id;
+        struct tg3 *tp = netdev_priv(dev);
         struct tg3_hw_status *sblk = tp->hw_status;
-        unsigned int work_exists = 0;
+        unsigned long flags;
 
-        /* check for phy events */
-        if (!(tp->tg3_flags &
-              (TG3_FLAG_USE_LINKCHG_REG |
-               TG3_FLAG_POLL_SERDES))) {
-                if (sblk->status & SD_STATUS_LINK_CHG)
-                        work_exists = 1;
+        spin_lock_irqsave(&tp->lock, flags);
+
+        /*
+         * writing any value to intr-mbox-0 clears PCI INTA# and
+         * chip-internal interrupt pending events.
+         * writing non-zero to intr-mbox-0 additional tells the
+         * NIC to stop sending us irqs, engaging "in-intr-handler"
+         * event coalescing.
+         */
+        tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000001);
+        sblk->status &= ~SD_STATUS_UPDATED;
+
+        if (likely(tg3_has_work(tp)))
+                netif_rx_schedule(dev);         /* schedule NAPI poll */
+        else {
+                /* no work, re-enable interrupts
+                 */
+                tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
+                             0x00000000);
         }
-        /* check for RX/TX work to do */
-        if (sblk->idx[0].tx_consumer != tp->tx_cons ||
-            sblk->idx[0].rx_producer != tp->rx_rcb_ptr)
-                work_exists = 1;
 
-        return work_exists;
+        spin_unlock_irqrestore(&tp->lock, flags);
+
+        return IRQ_RETVAL(1);
 }
 
 static irqreturn_t tg3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
@@ -2935,7 +2984,7 @@ static irqreturn_t tg3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                 tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW);
                 sblk->status &= ~SD_STATUS_UPDATED;
 
-                if (likely(tg3_has_work(dev, tp)))
+                if (likely(tg3_has_work(tp)))
                         netif_rx_schedule(dev);         /* schedule NAPI poll */
                 else {
                         /* no work, shared interrupt perhaps?  re-enable
@@ -2954,13 +3003,31 @@ static irqreturn_t tg3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         return IRQ_RETVAL(handled);
 }
 
+/* ISR for interrupt test */
+static irqreturn_t tg3_test_isr(int irq, void *dev_id,
+                struct pt_regs *regs)
+{
+        struct net_device *dev = dev_id;
+        struct tg3 *tp = netdev_priv(dev);
+        struct tg3_hw_status *sblk = tp->hw_status;
+
+        if (sblk->status & SD_STATUS_UPDATED) {
+                tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW,
+                             0x00000001);
+                return IRQ_RETVAL(1);
+        }
+        return IRQ_RETVAL(0);
+}
+
 static int tg3_init_hw(struct tg3 *);
-static int tg3_halt(struct tg3 *);
+static int tg3_halt(struct tg3 *, int);
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static void tg3_poll_controller(struct net_device *dev)
 {
-        tg3_interrupt(dev->irq, dev, NULL);
+        struct tg3 *tp = netdev_priv(dev);
+
+        tg3_interrupt(tp->pdev->irq, dev, NULL);
 }
 #endif
 
@@ -2977,7 +3044,7 @@ static void tg3_reset_task(void *_data)
         restart_timer = tp->tg3_flags2 & TG3_FLG2_RESTART_TIMER;
         tp->tg3_flags2 &= ~TG3_FLG2_RESTART_TIMER;
 
-        tg3_halt(tp);
+        tg3_halt(tp, 0);
         tg3_init_hw(tp);
 
         tg3_netif_start(tp);
@@ -3323,7 +3390,7 @@ static int tg3_change_mtu(struct net_device *dev, int new_mtu)
         spin_lock_irq(&tp->lock);
         spin_lock(&tp->tx_lock);
 
-        tg3_halt(tp);
+        tg3_halt(tp, 1);
 
         tg3_set_mtu(dev, tp, new_mtu);
 
@@ -3590,7 +3657,7 @@ err_out:
 /* To stop a block, clear the enable bit and poll till it
  * clears.  tp->lock is held.
  */
-static int tg3_stop_block(struct tg3 *tp, unsigned long ofs, u32 enable_bit)
+static int tg3_stop_block(struct tg3 *tp, unsigned long ofs, u32 enable_bit, int silent)
 {
         unsigned int i;
         u32 val;
@@ -3623,7 +3690,7 @@ static int tg3_stop_block(struct tg3 *tp, unsigned long ofs, u32 enable_bit)
                         break;
         }
 
-        if (i == MAX_WAIT_CNT) {
+        if (i == MAX_WAIT_CNT && !silent) {
                 printk(KERN_ERR PFX "tg3_stop_block timed out, "
                        "ofs=%lx enable_bit=%x\n",
                        ofs, enable_bit);
@@ -3634,7 +3701,7 @@ static int tg3_stop_block(struct tg3 *tp, unsigned long ofs, u32 enable_bit)
 }
 
 /* tp->lock is held. */
-static int tg3_abort_hw(struct tg3 *tp)
+static int tg3_abort_hw(struct tg3 *tp, int silent)
 {
         int i, err;
 
@@ -3644,22 +3711,20 @@ static int tg3_abort_hw(struct tg3 *tp)
         tw32_f(MAC_RX_MODE, tp->rx_mode);
         udelay(10);
 
-        err  = tg3_stop_block(tp, RCVBDI_MODE, RCVBDI_MODE_ENABLE);
-        err |= tg3_stop_block(tp, RCVLPC_MODE, RCVLPC_MODE_ENABLE);
-        err |= tg3_stop_block(tp, RCVLSC_MODE, RCVLSC_MODE_ENABLE);
-        err |= tg3_stop_block(tp, RCVDBDI_MODE, RCVDBDI_MODE_ENABLE);
-        err |= tg3_stop_block(tp, RCVDCC_MODE, RCVDCC_MODE_ENABLE);
-        err |= tg3_stop_block(tp, RCVCC_MODE, RCVCC_MODE_ENABLE);
-
-        err |= tg3_stop_block(tp, SNDBDS_MODE, SNDBDS_MODE_ENABLE);
-        err |= tg3_stop_block(tp, SNDBDI_MODE, SNDBDI_MODE_ENABLE);
-        err |= tg3_stop_block(tp, SNDDATAI_MODE, SNDDATAI_MODE_ENABLE);
-        err |= tg3_stop_block(tp, RDMAC_MODE, RDMAC_MODE_ENABLE);
-        err |= tg3_stop_block(tp, SNDDATAC_MODE, SNDDATAC_MODE_ENABLE);
-        err |= tg3_stop_block(tp, DMAC_MODE, DMAC_MODE_ENABLE);
-        err |= tg3_stop_block(tp, SNDBDC_MODE, SNDBDC_MODE_ENABLE);
-        if (err)
-                goto out;
+        err  = tg3_stop_block(tp, RCVBDI_MODE, RCVBDI_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, RCVLPC_MODE, RCVLPC_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, RCVLSC_MODE, RCVLSC_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, RCVDBDI_MODE, RCVDBDI_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, RCVDCC_MODE, RCVDCC_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, RCVCC_MODE, RCVCC_MODE_ENABLE, silent);
+
+        err |= tg3_stop_block(tp, SNDBDS_MODE, SNDBDS_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, SNDBDI_MODE, SNDBDI_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, SNDDATAI_MODE, SNDDATAI_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, RDMAC_MODE, RDMAC_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, SNDDATAC_MODE, SNDDATAC_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, DMAC_MODE, DMAC_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, SNDBDC_MODE, SNDBDC_MODE_ENABLE, silent);
 
         tp->mac_mode &= ~MAC_MODE_TDE_ENABLE;
         tw32_f(MAC_MODE, tp->mac_mode);
@@ -3677,27 +3742,24 @@ static int tg3_abort_hw(struct tg3 *tp)
                 printk(KERN_ERR PFX "tg3_abort_hw timed out for %s, "
                        "TX_MODE_ENABLE will not clear MAC_TX_MODE=%08x\n",
                        tp->dev->name, tr32(MAC_TX_MODE));
-                return -ENODEV;
+                err |= -ENODEV;
         }
 
-        err  = tg3_stop_block(tp, HOSTCC_MODE, HOSTCC_MODE_ENABLE);
-        err |= tg3_stop_block(tp, WDMAC_MODE, WDMAC_MODE_ENABLE);
-        err |= tg3_stop_block(tp, MBFREE_MODE, MBFREE_MODE_ENABLE);
+        err |= tg3_stop_block(tp, HOSTCC_MODE, HOSTCC_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, WDMAC_MODE, WDMAC_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, MBFREE_MODE, MBFREE_MODE_ENABLE, silent);
 
         tw32(FTQ_RESET, 0xffffffff);
         tw32(FTQ_RESET, 0x00000000);
 
-        err |= tg3_stop_block(tp, BUFMGR_MODE, BUFMGR_MODE_ENABLE);
-        err |= tg3_stop_block(tp, MEMARB_MODE, MEMARB_MODE_ENABLE);
-        if (err)
-                goto out;
+        err |= tg3_stop_block(tp, BUFMGR_MODE, BUFMGR_MODE_ENABLE, silent);
+        err |= tg3_stop_block(tp, MEMARB_MODE, MEMARB_MODE_ENABLE, silent);
 
         if (tp->hw_status)
                 memset(tp->hw_status, 0, TG3_HW_STATUS_SIZE);
         if (tp->hw_stats)
                 memset(tp->hw_stats, 0, sizeof(struct tg3_hw_stats));
 
-out:
         return err;
 }
 
@@ -3727,6 +3789,28 @@ static void tg3_nvram_unlock(struct tg3 *tp)
 }
 
 /* tp->lock is held. */
+static void tg3_enable_nvram_access(struct tg3 *tp)
+{
+        if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
+            !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM)) {
+                u32 nvaccess = tr32(NVRAM_ACCESS);
+
+                tw32(NVRAM_ACCESS, nvaccess | ACCESS_ENABLE);
+        }
+}
+
+/* tp->lock is held. */
+static void tg3_disable_nvram_access(struct tg3 *tp)
+{
+        if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
+            !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM)) {
+                u32 nvaccess = tr32(NVRAM_ACCESS);
+
+                tw32(NVRAM_ACCESS, nvaccess & ~ACCESS_ENABLE);
+        }
+}
+
+/* tp->lock is held. */
 static void tg3_write_sig_pre_reset(struct tg3 *tp, int kind)
 {
         if (!(tp->tg3_flags2 & TG3_FLG2_SUN_570X))
@@ -3967,7 +4051,7 @@ static int tg3_chip_reset(struct tg3 *tp)
                 tg3_read_mem(tp, NIC_SRAM_DATA_CFG, &nic_cfg);
                 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
                         tp->tg3_flags |= TG3_FLAG_ENABLE_ASF;
-                        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)
+                        if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
                                 tp->tg3_flags2 |= TG3_FLG2_ASF_NEW_HANDSHAKE;
                 }
         }
@@ -3997,7 +4081,7 @@ static void tg3_stop_fw(struct tg3 *tp)
 }
 
 /* tp->lock is held. */
-static int tg3_halt(struct tg3 *tp)
+static int tg3_halt(struct tg3 *tp, int silent)
 {
         int err;
 
@@ -4005,7 +4089,7 @@ static int tg3_halt(struct tg3 *tp)
 
         tg3_write_sig_pre_reset(tp, RESET_KIND_SHUTDOWN);
 
-        tg3_abort_hw(tp);
+        tg3_abort_hw(tp, silent);
         err = tg3_chip_reset(tp);
 
         tg3_write_sig_legacy(tp, RESET_KIND_SHUTDOWN);
@@ -4974,9 +5058,7 @@ static int tg3_reset_hw(struct tg3 *tp)
         tg3_write_sig_pre_reset(tp, RESET_KIND_INIT);
 
         if (tp->tg3_flags & TG3_FLAG_INIT_COMPLETE) {
-                err = tg3_abort_hw(tp);
-                if (err)
-                        return err;
+                tg3_abort_hw(tp, 1);
         }
 
         err = tg3_chip_reset(tp);
@@ -5041,7 +5123,7 @@ static int tg3_reset_hw(struct tg3 *tp)
         tw32(GRC_MISC_CFG, val);
 
         /* Initialize MBUF/DESC pool. */
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
+        if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS) {
                 /* Do nothing.  */
         } else if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5705) {
                 tw32(BUFMGR_MB_POOL_ADDR, NIC_SRAM_MBUF_POOL_BASE);
@@ -5238,6 +5320,8 @@ static int tg3_reset_hw(struct tg3 *tp)
                       RDMAC_MODE_LNGREAD_ENAB);
         if (tp->tg3_flags & TG3_FLAG_SPLIT_MODE)
                 rdmac_mode |= RDMAC_MODE_SPLIT_ENABLE;
+
+        /* If statement applies to 5705 and 5750 PCI devices only */
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
              tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) ||
             (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)) {
@@ -5251,6 +5335,9 @@ static int tg3_reset_hw(struct tg3 *tp)
                 }
         }
 
+        if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)
+                rdmac_mode |= RDMAC_MODE_FIFO_LONG_BURST;
+
 #if TG3_TSO_SUPPORT != 0
         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO)
                 rdmac_mode |= (1 << 27);
@@ -5332,10 +5419,28 @@ static int tg3_reset_hw(struct tg3 *tp)
         tw32_f(MAC_MODE, tp->mac_mode | MAC_MODE_RXSTAT_CLEAR | MAC_MODE_TXSTAT_CLEAR);
         udelay(40);
 
-        tp->grc_local_ctrl = GRC_LCLCTRL_INT_ON_ATTN | GRC_LCLCTRL_AUTO_SEEPROM;
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700)
+        /* tp->grc_local_ctrl is partially set up during tg3_get_invariants().
+         * If TG3_FLAG_EEPROM_WRITE_PROT is set, we should read the
+         * register to preserve the GPIO settings for LOMs. The GPIOs,
+         * whether used as inputs or outputs, are set by boot code after
+         * reset.
+         */
+        if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
+                u32 gpio_mask;
+
+                gpio_mask = GRC_LCLCTRL_GPIO_OE0 | GRC_LCLCTRL_GPIO_OE2 |
+                            GRC_LCLCTRL_GPIO_OUTPUT0 | GRC_LCLCTRL_GPIO_OUTPUT2;
+
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
+                        gpio_mask |= GRC_LCLCTRL_GPIO_OE3 |
+                                     GRC_LCLCTRL_GPIO_OUTPUT3;
+
+                tp->grc_local_ctrl |= tr32(GRC_LOCAL_CTRL) & gpio_mask;
+
+                /* GPIO1 must be driven high for eeprom write protect */
                 tp->grc_local_ctrl |= (GRC_LCLCTRL_GPIO_OE1 |
                                        GRC_LCLCTRL_GPIO_OUTPUT1);
+        }
         tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
         udelay(100);
 
@@ -5353,6 +5458,7 @@ static int tg3_reset_hw(struct tg3 *tp)
                WDMAC_MODE_FIFOURUN_ENAB | WDMAC_MODE_FIFOOREAD_ENAB |
                WDMAC_MODE_LNGREAD_ENAB);
 
+        /* If statement applies to 5705 and 5750 PCI devices only */
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 &&
              tp->pci_chip_rev_id != CHIPREV_ID_5705_A0) ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
@@ -5706,6 +5812,118 @@ static void tg3_timer(unsigned long __opaque)
         add_timer(&tp->timer);
 }
 
+static int tg3_test_interrupt(struct tg3 *tp)
+{
+        struct net_device *dev = tp->dev;
+        int err, i;
+        u32 int_mbox = 0;
+
+        tg3_disable_ints(tp);
+
+        free_irq(tp->pdev->irq, dev);
+
+        err = request_irq(tp->pdev->irq, tg3_test_isr,
+                          SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
+        if (err)
+                return err;
+
+        tg3_enable_ints(tp);
+
+        tw32_f(HOSTCC_MODE, tp->coalesce_mode | HOSTCC_MODE_ENABLE |
+               HOSTCC_MODE_NOW);
+
+        for (i = 0; i < 5; i++) {
+                int_mbox = tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW);
+                if (int_mbox != 0)
+                        break;
+                msleep(10);
+        }
+
+        tg3_disable_ints(tp);
+
+        free_irq(tp->pdev->irq, dev);
+        
+        if (tp->tg3_flags2 & TG3_FLG2_USING_MSI)
+                err = request_irq(tp->pdev->irq, tg3_msi,
+                                  SA_SAMPLE_RANDOM, dev->name, dev);
+        else
+                err = request_irq(tp->pdev->irq, tg3_interrupt,
+                                  SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
+
+        if (err)
+                return err;
+
+        if (int_mbox != 0)
+                return 0;
+
+        return -EIO;
+}
+
+/* Returns 0 if MSI test succeeds or MSI test fails and INTx mode is
+ * successfully restored
+ */
+static int tg3_test_msi(struct tg3 *tp)
+{
+        struct net_device *dev = tp->dev;
+        int err;
+        u16 pci_cmd;
+
+        if (!(tp->tg3_flags2 & TG3_FLG2_USING_MSI))
+                return 0;
+
+        /* Turn off SERR reporting in case MSI terminates with Master
+         * Abort.
+         */
+        pci_read_config_word(tp->pdev, PCI_COMMAND, &pci_cmd);
+        pci_write_config_word(tp->pdev, PCI_COMMAND,
+                              pci_cmd & ~PCI_COMMAND_SERR);
+
+        err = tg3_test_interrupt(tp);
+
+        pci_write_config_word(tp->pdev, PCI_COMMAND, pci_cmd);
+
+        if (!err)
+                return 0;
+
+        /* other failures */
+        if (err != -EIO)
+                return err;
+
+        /* MSI test failed, go back to INTx mode */
+        printk(KERN_WARNING PFX "%s: No interrupt was generated using MSI, "
+               "switching to INTx mode. Please report this failure to "
+               "the PCI maintainer and include system chipset information.\n",
+                       tp->dev->name);
+
+        free_irq(tp->pdev->irq, dev);
+        pci_disable_msi(tp->pdev);
+
+        tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
+
+        err = request_irq(tp->pdev->irq, tg3_interrupt,
+                          SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
+
+        if (err)
+                return err;
+
+        /* Need to reset the chip because the MSI cycle may have terminated
+         * with Master Abort.
+         */
+        spin_lock_irq(&tp->lock);
+        spin_lock(&tp->tx_lock);
+
+        tg3_halt(tp, 1);
+        err = tg3_init_hw(tp);
+
+        spin_unlock(&tp->tx_lock);
+        spin_unlock_irq(&tp->lock);
+
+        if (err)
+                free_irq(tp->pdev->irq, dev);
+
+        return err;
+}
+
 static int tg3_open(struct net_device *dev)
 {
         struct tg3 *tp = netdev_priv(dev);
@@ -5727,10 +5945,29 @@ static int tg3_open(struct net_device *dev)
         if (err)
                 return err;
 
-        err = request_irq(dev->irq, tg3_interrupt,
-                          SA_SHIRQ, dev->name, dev);
+        if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
+            (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5750_AX) &&
+            (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5750_BX)) {
+                if (pci_enable_msi(tp->pdev) == 0) {
+                        u32 msi_mode;
+
+                        msi_mode = tr32(MSGINT_MODE);
+                        tw32(MSGINT_MODE, msi_mode | MSGINT_MODE_ENABLE);
+                        tp->tg3_flags2 |= TG3_FLG2_USING_MSI;
+                }
+        }
+        if (tp->tg3_flags2 & TG3_FLG2_USING_MSI)
+                err = request_irq(tp->pdev->irq, tg3_msi,
+                                  SA_SAMPLE_RANDOM, dev->name, dev);
+        else
+                err = request_irq(tp->pdev->irq, tg3_interrupt,
+                                  SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
 
         if (err) {
+                if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
+                        pci_disable_msi(tp->pdev);
+                        tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
+                }
                 tg3_free_consistent(tp);
                 return err;
         }
@@ -5740,7 +5977,7 @@ static int tg3_open(struct net_device *dev)
 
         err = tg3_init_hw(tp);
         if (err) {
-                tg3_halt(tp);
+                tg3_halt(tp, 1);
                 tg3_free_rings(tp);
         } else {
                 tp->timer_offset = HZ / 10;
@@ -5751,23 +5988,47 @@ static int tg3_open(struct net_device *dev)
                 tp->timer.expires = jiffies + tp->timer_offset;
                 tp->timer.data = (unsigned long) tp;
                 tp->timer.function = tg3_timer;
-                add_timer(&tp->timer);
-
-                tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
         }
 
         spin_unlock(&tp->tx_lock);
         spin_unlock_irq(&tp->lock);
 
         if (err) {
-                free_irq(dev->irq, dev);
+                free_irq(tp->pdev->irq, dev);
+                if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
+                        pci_disable_msi(tp->pdev);
+                        tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
+                }
                 tg3_free_consistent(tp);
                 return err;
         }
 
+        if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
+                err = tg3_test_msi(tp);
+                if (err) {
+                        spin_lock_irq(&tp->lock);
+                        spin_lock(&tp->tx_lock);
+
+                        if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
+                                pci_disable_msi(tp->pdev);
+                                tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
+                        }
+                        tg3_halt(tp, 1);
+                        tg3_free_rings(tp);
+                        tg3_free_consistent(tp);
+
+                        spin_unlock(&tp->tx_lock);
+                        spin_unlock_irq(&tp->lock);
+
+                        return err;
+                }
+        }
+
         spin_lock_irq(&tp->lock);
         spin_lock(&tp->tx_lock);
 
+        add_timer(&tp->timer);
+        tp->tg3_flags |= TG3_FLAG_INIT_COMPLETE;
         tg3_enable_ints(tp);
 
         spin_unlock(&tp->tx_lock);
@@ -6025,7 +6286,7 @@ static int tg3_close(struct net_device *dev)
 
         tg3_disable_ints(tp);
 
-        tg3_halt(tp);
+        tg3_halt(tp, 1);
         tg3_free_rings(tp);
         tp->tg3_flags &=
                 ~(TG3_FLAG_INIT_COMPLETE |
@@ -6035,7 +6296,11 @@ static int tg3_close(struct net_device *dev)
         spin_unlock(&tp->tx_lock);
         spin_unlock_irq(&tp->lock);
 
-        free_irq(dev->irq, dev);
+        free_irq(tp->pdev->irq, dev);
+        if (tp->tg3_flags2 & TG3_FLG2_USING_MSI) {
+                pci_disable_msi(tp->pdev);
+                tp->tg3_flags2 &= ~TG3_FLG2_USING_MSI;
+        }
 
         memcpy(&tp->net_stats_prev, tg3_get_stats(tp->dev),
                sizeof(tp->net_stats_prev));
@@ -6509,10 +6774,12 @@ static int tg3_set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
                 start = cpu_to_le32(start);
                 len += b_offset;
                 offset &= ~3;
+                if (len < 4)
+                        len = 4;
         }
 
         odd_len = 0;
-        if ((len & 3) && ((len > 4) || (b_offset == 0))) {
+        if (len & 3) {
                 /* adjustments to end on required 4 byte boundary */
                 odd_len = 1;
                 len = (len + 3) & ~3;
@@ -6739,7 +7006,7 @@ static int tg3_set_ringparam(struct net_device *dev, struct ethtool_ringparam *e
         tp->tx_pending = ering->tx_pending;
 
         if (netif_running(dev)) {
-                tg3_halt(tp);
+                tg3_halt(tp, 1);
                 tg3_init_hw(tp);
                 tg3_netif_start(tp);
         }
@@ -6782,7 +7049,7 @@ static int tg3_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam
                 tp->tg3_flags &= ~TG3_FLAG_TX_PAUSE;
 
         if (netif_running(dev)) {
-                tg3_halt(tp);
+                tg3_halt(tp, 1);
                 tg3_init_hw(tp);
                 tg3_netif_start(tp);
         }
@@ -7067,6 +7334,67 @@ static void __devinit tg3_get_nvram_info(struct tg3 *tp)
         }
 }
 
+static void __devinit tg3_get_5752_nvram_info(struct tg3 *tp)
+{
+        u32 nvcfg1;
+
+        nvcfg1 = tr32(NVRAM_CFG1);
+
+        /* NVRAM protection for TPM */
+        if (nvcfg1 & (1 << 27))
+                tp->tg3_flags2 |= TG3_FLG2_PROTECTED_NVRAM;
+
+        switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
+                case FLASH_5752VENDOR_ATMEL_EEPROM_64KHZ:
+                case FLASH_5752VENDOR_ATMEL_EEPROM_376KHZ:
+                        tp->nvram_jedecnum = JEDEC_ATMEL;
+                        tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+                        break;
+                case FLASH_5752VENDOR_ATMEL_FLASH_BUFFERED:
+                        tp->nvram_jedecnum = JEDEC_ATMEL;
+                        tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+                        tp->tg3_flags2 |= TG3_FLG2_FLASH;
+                        break;
+                case FLASH_5752VENDOR_ST_M45PE10:
+                case FLASH_5752VENDOR_ST_M45PE20:
+                case FLASH_5752VENDOR_ST_M45PE40:
+                        tp->nvram_jedecnum = JEDEC_ST;
+                        tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+                        tp->tg3_flags2 |= TG3_FLG2_FLASH;
+                        break;
+        }
+
+        if (tp->tg3_flags2 & TG3_FLG2_FLASH) {
+                switch (nvcfg1 & NVRAM_CFG1_5752PAGE_SIZE_MASK) {
+                        case FLASH_5752PAGE_SIZE_256:
+                                tp->nvram_pagesize = 256;
+                                break;
+                        case FLASH_5752PAGE_SIZE_512:
+                                tp->nvram_pagesize = 512;
+                                break;
+                        case FLASH_5752PAGE_SIZE_1K:
+                                tp->nvram_pagesize = 1024;
+                                break;
+                        case FLASH_5752PAGE_SIZE_2K:
+                                tp->nvram_pagesize = 2048;
+                                break;
+                        case FLASH_5752PAGE_SIZE_4K:
+                                tp->nvram_pagesize = 4096;
+                                break;
+                        case FLASH_5752PAGE_SIZE_264:
+                                tp->nvram_pagesize = 264;
+                                break;
+                }
+        }
+        else {
+                /* For eeprom, set pagesize to maximum eeprom size */
+                tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
+
+                nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
+                tw32(NVRAM_CFG1, nvcfg1);
+        }
+}
+
 /* Chips other than 5700/5701 use the NVRAM for fetching info. */
 static void __devinit tg3_nvram_init(struct tg3 *tp)
 {
@@ -7093,20 +7421,16 @@ static void __devinit tg3_nvram_init(struct tg3 *tp)
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5701) {
                 tp->tg3_flags |= TG3_FLAG_NVRAM;
 
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
-                        u32 nvaccess = tr32(NVRAM_ACCESS);
+                tg3_enable_nvram_access(tp);
 
-                        tw32(NVRAM_ACCESS, nvaccess | ACCESS_ENABLE);
-                }
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
+                        tg3_get_5752_nvram_info(tp);
+                else
+                        tg3_get_nvram_info(tp);
 
-                tg3_get_nvram_info(tp);
                 tg3_get_nvram_size(tp);
 
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
-                        u32 nvaccess = tr32(NVRAM_ACCESS);
-
-                        tw32(NVRAM_ACCESS, nvaccess & ~ACCESS_ENABLE);
-                }
+                tg3_disable_nvram_access(tp);
 
         } else {
                 tp->tg3_flags &= ~(TG3_FLAG_NVRAM | TG3_FLAG_NVRAM_BUFFERED);
@@ -7195,11 +7519,7 @@ static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val)
 
         tg3_nvram_lock(tp);
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
-                u32 nvaccess = tr32(NVRAM_ACCESS);
-
-                tw32_f(NVRAM_ACCESS, nvaccess | ACCESS_ENABLE);
-        }
+        tg3_enable_nvram_access(tp);
 
         tw32(NVRAM_ADDR, offset);
         ret = tg3_nvram_exec_cmd(tp, NVRAM_CMD_RD | NVRAM_CMD_GO |
@@ -7210,11 +7530,7 @@ static int tg3_nvram_read(struct tg3 *tp, u32 offset, u32 *val)
 
         tg3_nvram_unlock(tp);
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
-                u32 nvaccess = tr32(NVRAM_ACCESS);
-
-                tw32_f(NVRAM_ACCESS, nvaccess & ~ACCESS_ENABLE);
-        }
+        tg3_disable_nvram_access(tp);
 
         return ret;
 }
@@ -7277,7 +7593,7 @@ static int tg3_nvram_write_block_unbuffered(struct tg3 *tp, u32 offset, u32 len,
 
         while (len) {
                 int j;
-                u32 phy_addr, page_off, size, nvaccess;
+                u32 phy_addr, page_off, size;
 
                 phy_addr = offset & ~pagemask;
         
@@ -7300,8 +7616,7 @@ static int tg3_nvram_write_block_unbuffered(struct tg3 *tp, u32 offset, u32 len,
 
                 offset = offset + (pagesize - page_off);
 
-                nvaccess = tr32(NVRAM_ACCESS);
-                tw32_f(NVRAM_ACCESS, nvaccess | ACCESS_ENABLE);
+                tg3_enable_nvram_access(tp);
 
                 /*
                  * Before we can erase the flash page, we need
@@ -7425,8 +7740,8 @@ static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf)
         }
 
         if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
-                tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
-                       GRC_LCLCTRL_GPIO_OE1);
+                tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl &
+                       ~GRC_LCLCTRL_GPIO_OUTPUT1);
                 udelay(40);
         }
 
@@ -7438,13 +7753,10 @@ static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf)
 
                 tg3_nvram_lock(tp);
 
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
-                        u32 nvaccess = tr32(NVRAM_ACCESS);
-
-                        tw32(NVRAM_ACCESS, nvaccess | ACCESS_ENABLE);
-
+                tg3_enable_nvram_access(tp);
+                if ((tp->tg3_flags2 & TG3_FLG2_5750_PLUS) &&
+                    !(tp->tg3_flags2 & TG3_FLG2_PROTECTED_NVRAM))
                         tw32(NVRAM_WRITE1, 0x406);
-                }
 
                 grc_mode = tr32(GRC_MODE);
                 tw32(GRC_MODE, grc_mode | GRC_MODE_NVRAM_WR_ENABLE);
@@ -7463,17 +7775,12 @@ static int tg3_nvram_write_block(struct tg3 *tp, u32 offset, u32 len, u8 *buf)
                 grc_mode = tr32(GRC_MODE);
                 tw32(GRC_MODE, grc_mode & ~GRC_MODE_NVRAM_WR_ENABLE);
 
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
-                        u32 nvaccess = tr32(NVRAM_ACCESS);
-
-                        tw32(NVRAM_ACCESS, nvaccess & ~ACCESS_ENABLE);
-                }
+                tg3_disable_nvram_access(tp);
                 tg3_nvram_unlock(tp);
         }
 
         if (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT) {
-                tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl |
-                       GRC_LCLCTRL_GPIO_OE1 | GRC_LCLCTRL_GPIO_OUTPUT1);
+                tw32_f(GRC_LOCAL_CTRL, tp->grc_local_ctrl);
                 udelay(40);
         }
 
@@ -7537,21 +7844,27 @@ static inline struct subsys_tbl_ent *lookup_by_subsys(struct tg3 *tp)
         return NULL;
 }
 
-static int __devinit tg3_phy_probe(struct tg3 *tp)
+/* Since this function may be called in D3-hot power state during
+ * tg3_init_one(), only config cycles are allowed.
+ */
+static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
 {
-        u32 eeprom_phy_id, hw_phy_id_1, hw_phy_id_2;
-        u32 hw_phy_id, hw_phy_id_masked;
         u32 val;
-        int eeprom_signature_found, eeprom_phy_serdes, err;
+
+        /* Make sure register accesses (indirect or otherwise)
+         * will function correctly.
+         */
+        pci_write_config_dword(tp->pdev, TG3PCI_MISC_HOST_CTRL,
+                               tp->misc_host_ctrl);
 
         tp->phy_id = PHY_ID_INVALID;
-        eeprom_phy_id = PHY_ID_INVALID;
-        eeprom_phy_serdes = 0;
-        eeprom_signature_found = 0;
+        tp->led_ctrl = LED_CTRL_MODE_PHY_1;
+
         tg3_read_mem(tp, NIC_SRAM_DATA_SIG, &val);
         if (val == NIC_SRAM_DATA_SIG_MAGIC) {
                 u32 nic_cfg, led_cfg;
-                u32 nic_phy_id, ver, cfg2 = 0;
+                u32 nic_phy_id, ver, cfg2 = 0, eeprom_phy_id;
+                int eeprom_phy_serdes = 0;
 
                 tg3_read_mem(tp, NIC_SRAM_DATA_CFG, &nic_cfg);
                 tp->nic_sram_data_cfg = nic_cfg;
@@ -7564,8 +7877,6 @@ static int __devinit tg3_phy_probe(struct tg3 *tp)
                     (ver > 0) && (ver < 0x100))
                         tg3_read_mem(tp, NIC_SRAM_DATA_CFG_2, &cfg2);
 
-                eeprom_signature_found = 1;
-
                 if ((nic_cfg & NIC_SRAM_DATA_CFG_PHY_TYPE_MASK) ==
                     NIC_SRAM_DATA_CFG_PHY_TYPE_FIBER)
                         eeprom_phy_serdes = 1;
@@ -7581,10 +7892,14 @@ static int __devinit tg3_phy_probe(struct tg3 *tp)
                 } else
                         eeprom_phy_id = 0;
 
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750) {
+                tp->phy_id = eeprom_phy_id;
+                if (eeprom_phy_serdes)
+                        tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
+
+                if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
                         led_cfg = cfg2 & (NIC_SRAM_DATA_CFG_LED_MODE_MASK |
                                     SHASTA_EXT_LED_MODE_MASK);
-                } else
+                else
                         led_cfg = nic_cfg & NIC_SRAM_DATA_CFG_LED_MODE_MASK;
 
                 switch (led_cfg) {
@@ -7634,7 +7949,7 @@ static int __devinit tg3_phy_probe(struct tg3 *tp)
 
                 if (nic_cfg & NIC_SRAM_DATA_CFG_ASF_ENABLE) {
                         tp->tg3_flags |= TG3_FLAG_ENABLE_ASF;
-                        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)
+                        if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
                                 tp->tg3_flags2 |= TG3_FLG2_ASF_NEW_HANDSHAKE;
                 }
                 if (nic_cfg & NIC_SRAM_DATA_CFG_FIBER_WOL)
@@ -7648,6 +7963,13 @@ static int __devinit tg3_phy_probe(struct tg3 *tp)
                 if (cfg2 & (1 << 18))
                         tp->tg3_flags2 |= TG3_FLG2_SERDES_PREEMPHASIS;
         }
+}
+
+static int __devinit tg3_phy_probe(struct tg3 *tp)
+{
+        u32 hw_phy_id_1, hw_phy_id_2;
+        u32 hw_phy_id, hw_phy_id_masked;
+        int err;
 
         /* Reading the PHY ID register can conflict with ASF
          * firwmare access to the PHY hardware.
@@ -7676,10 +7998,10 @@ static int __devinit tg3_phy_probe(struct tg3 *tp)
                 if (hw_phy_id_masked == PHY_ID_BCM8002)
                         tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
         } else {
-                if (eeprom_signature_found) {
-                        tp->phy_id = eeprom_phy_id;
-                        if (eeprom_phy_serdes)
-                                tp->tg3_flags2 |= TG3_FLG2_PHY_SERDES;
+                if (tp->phy_id != PHY_ID_INVALID) {
+                        /* Do nothing, phy ID already set up in
+                         * tg3_get_eeprom_hw_cfg().
+                         */
                 } else {
                         struct subsys_tbl_ent *p;
 
@@ -7750,9 +8072,6 @@ skip_phy_reset:
                 err = tg3_init_5401phy_dsp(tp);
         }
 
-        if (!eeprom_signature_found)
-                tp->led_ctrl = LED_CTRL_MODE_PHY_1;
-
         if (tp->tg3_flags2 & TG3_FLG2_PHY_SERDES)
                 tp->link_config.advertising =
                         (ADVERTISED_1000baseT_Half |
@@ -7917,6 +8236,12 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         tp->pci_chip_rev_id = (misc_ctrl_reg >>
                                MISC_HOST_CTRL_CHIPREV_SHIFT);
 
+        /* Wrong chip ID in 5752 A0. This code can be removed later
+         * as A0 is not in production.
+         */
+        if (tp->pci_chip_rev_id == CHIPREV_ID_5752_A0_HW)
+                tp->pci_chip_rev_id = CHIPREV_ID_5752_A0;
+
         /* Initialize misc host control in PCI block. */
         tp->misc_host_ctrl |= (misc_ctrl_reg &
                                MISC_HOST_CTRL_CHIPREV);
@@ -7931,11 +8256,15 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         tp->pci_hdr_type     = (cacheline_sz_reg >> 16) & 0xff;
         tp->pci_bist         = (cacheline_sz_reg >> 24) & 0xff;
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
+                tp->tg3_flags2 |= TG3_FLG2_5750_PLUS;
+
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705) ||
-            (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750))
+            (tp->tg3_flags2 & TG3_FLG2_5750_PLUS))
                 tp->tg3_flags2 |= TG3_FLG2_5705_PLUS;
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)
+        if (tp->tg3_flags2 & TG3_FLG2_5750_PLUS)
                 tp->tg3_flags2 |= TG3_FLG2_HW_TSO;
 
         if (pci_find_capability(tp->pdev, PCI_CAP_ID_EXP) != 0)
@@ -8013,6 +8342,31 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                 pci_write_config_dword(tp->pdev, TG3PCI_PCISTATE, pci_state_reg);
         }
 
+        /* Get eeprom hw config before calling tg3_set_power_state().
+         * In particular, the TG3_FLAG_EEPROM_WRITE_PROT flag must be
+         * determined before calling tg3_set_power_state() so that
+         * we know whether or not to switch out of Vaux power.
+         * When the flag is set, it means that GPIO1 is used for eeprom
+         * write protect and also implies that it is a LOM where GPIOs
+         * are not used to switch power.
+         */ 
+        tg3_get_eeprom_hw_cfg(tp);
+
+        /* Set up tp->grc_local_ctrl before calling tg3_set_power_state().
+         * GPIO1 driven high will bring 5700's external PHY out of reset.
+         * It is also used as eeprom write protect on LOMs.
+         */
+        tp->grc_local_ctrl = GRC_LCLCTRL_INT_ON_ATTN | GRC_LCLCTRL_AUTO_SEEPROM;
+        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700) ||
+            (tp->tg3_flags & TG3_FLAG_EEPROM_WRITE_PROT))
+                tp->grc_local_ctrl |= (GRC_LCLCTRL_GPIO_OE1 |
+                                       GRC_LCLCTRL_GPIO_OUTPUT1);
+        /* Unused GPIO3 must be driven as output on 5752 because there
+         * are no pull-up resistors on unused GPIO pins.
+         */
+        else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5752)
+                tp->grc_local_ctrl |= GRC_LCLCTRL_GPIO_OE3;
+
         /* Force the chip into D0. */
         err = tg3_set_power_state(tp, 0);
         if (err) {
@@ -8065,8 +8419,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         if (tp->pci_chip_rev_id == CHIPREV_ID_5704_A0)
                 tp->tg3_flags2 |= TG3_FLG2_PHY_5704_A0_BUG;
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750)
+        if (tp->tg3_flags2 & TG3_FLG2_5705_PLUS)
                 tp->tg3_flags2 |= TG3_FLG2_PHY_BER_BUG;
 
         /* Only 5701 and later support tagged irq status mode.
@@ -8628,6 +8981,7 @@ static char * __devinit tg3_phy_string(struct tg3 *tp)
         case PHY_ID_BCM5704:    return "5704";
         case PHY_ID_BCM5705:    return "5705";
         case PHY_ID_BCM5750:    return "5750";
+        case PHY_ID_BCM5752:    return "5752";
         case PHY_ID_BCM8002:    return "8002/serdes";
         case 0:                 return "serdes";
         default:                return "unknown";
@@ -8878,7 +9232,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
             (tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) {
                 pci_save_state(tp->pdev);
                 tw32(MEMARB_MODE, MEMARB_MODE_ENABLE);
-                tg3_halt(tp);
+                tg3_halt(tp, 1);
         }
 
         err = tg3_test_dma(tp);
@@ -9001,7 +9355,7 @@ static int tg3_suspend(struct pci_dev *pdev, pm_message_t state)
 
         spin_lock_irq(&tp->lock);
         spin_lock(&tp->tx_lock);
-        tg3_halt(tp);
+        tg3_halt(tp, 1);
         spin_unlock(&tp->tx_lock);
         spin_unlock_irq(&tp->lock);