Merge branch 'upstream-davem' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
authorDavid S. Miller <davem@davemloft.net>
Fri, 15 Feb 2008 23:59:19 +0000 (15:59 -0800)
committerDavid S. Miller <davem@davemloft.net>
Fri, 15 Feb 2008 23:59:19 +0000 (15:59 -0800)
12 files changed:
drivers/net/e1000/e1000_ethtool.c
drivers/net/e1000/e1000_main.c
drivers/net/e1000e/netdev.c
drivers/net/gianfar.c
drivers/net/gianfar_mii.c
drivers/net/hamradio/mkiss.c
drivers/net/igb/igb_ethtool.c
drivers/net/igb/igb_main.c
drivers/net/ixgb/ixgb_ethtool.c
drivers/net/ixgbe/ixgbe_main.c
drivers/net/pcmcia/smc91c92_cs.c
drivers/net/tsi108_eth.c

index d876787ce336e51aa76c0d32dd7998ce97b9b538..85e66f4c788690872a766e10973a24d659b4ce28 100644 (file)
@@ -50,7 +50,7 @@ struct e1000_stats {
        int stat_offset;
 };
 
-#define E1000_STAT(m) sizeof(((struct e1000_adapter *)0)->m), \
+#define E1000_STAT(m) FIELD_SIZEOF(struct e1000_adapter, m), \
                      offsetof(struct e1000_adapter, m)
 static const struct e1000_stats e1000_gstrings_stats[] = {
        { "rx_packets", E1000_STAT(stats.gprc) },
index d4ee8ec34b564f7604876da854f539d00bf53c3c..0991648c53dc2f5bc0c1d5aee568c3a0a007d6e5 100644 (file)
@@ -1195,6 +1195,14 @@ e1000_probe(struct pci_dev *pdev,
 
        printk("%s\n", print_mac(mac, netdev->dev_addr));
 
+       if (adapter->hw.bus_type == e1000_bus_type_pci_express) {
+               DPRINTK(PROBE, WARNING, "This device (id %04x:%04x) will no "
+                       "longer be supported by this driver in the future.\n",
+                       pdev->vendor, pdev->device);
+               DPRINTK(PROBE, WARNING, "please use the \"e1000e\" "
+                       "driver instead.\n");
+       }
+
        /* reset the hardware with the new settings */
        e1000_reset(adapter);
 
index f58f017ee47ae837a45e3f0fcba3e2bafcf81d06..3031d6d16247abf5153884728aad6fe038d8c172 100644 (file)
@@ -1055,23 +1055,6 @@ static void e1000_release_hw_control(struct e1000_adapter *adapter)
        }
 }
 
-static void e1000_release_manageability(struct e1000_adapter *adapter)
-{
-       if (adapter->flags & FLAG_MNG_PT_ENABLED) {
-               struct e1000_hw *hw = &adapter->hw;
-
-               u32 manc = er32(MANC);
-
-               /* re-enable hardware interception of ARP */
-               manc |= E1000_MANC_ARP_EN;
-               manc &= ~E1000_MANC_EN_MNG2HOST;
-
-               /* don't explicitly have to mess with MANC2H since
-                * MANC has an enable disable that gates MANC2H */
-               ew32(MANC, manc);
-       }
-}
-
 /**
  * @e1000_alloc_ring - allocate memory for a ring structure
  **/
@@ -1561,9 +1544,6 @@ static void e1000_init_manageability(struct e1000_adapter *adapter)
 
        manc = er32(MANC);
 
-       /* disable hardware interception of ARP */
-       manc &= ~(E1000_MANC_ARP_EN);
-
        /* enable receiving management packets to the host. this will probably
         * generate destination unreachable messages from the host OS, but
         * the packets will be handled on SMBUS */
@@ -1690,6 +1670,9 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
        else
                rctl |= E1000_RCTL_LPE;
 
+       /* Enable hardware CRC frame stripping */
+       rctl |= E1000_RCTL_SECRC;
+
        /* Setup buffer sizes */
        rctl &= ~E1000_RCTL_SZ_4096;
        rctl |= E1000_RCTL_BSEX;
@@ -1755,9 +1738,6 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
 
                /* Enable Packet split descriptors */
                rctl |= E1000_RCTL_DTYP_PS;
-               
-               /* Enable hardware CRC frame stripping */
-               rctl |= E1000_RCTL_SECRC;
 
                psrctl |= adapter->rx_ps_bsize0 >>
                        E1000_PSRCTL_BSIZE0_SHIFT;
@@ -2008,7 +1988,7 @@ static void e1000_power_down_phy(struct e1000_adapter *adapter)
        u16 mii_reg;
 
        /* WoL is enabled */
-       if (!adapter->wol)
+       if (adapter->wol)
                return;
 
        /* non-copper PHY? */
@@ -2140,8 +2120,6 @@ void e1000e_reset(struct e1000_adapter *adapter)
                phy_data &= ~IGP02E1000_PM_SPD;
                e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, phy_data);
        }
-
-       e1000_release_manageability(adapter);
 }
 
 int e1000e_up(struct e1000_adapter *adapter)
@@ -3487,8 +3465,6 @@ static int e1000_suspend(struct pci_dev *pdev, pm_message_t state)
                pci_enable_wake(pdev, PCI_D3cold, 0);
        }
 
-       e1000_release_manageability(adapter);
-
        /* make sure adapter isn't asleep if manageability is enabled */
        if (adapter->flags & FLAG_MNG_PT_ENABLED) {
                pci_enable_wake(pdev, PCI_D3hot, 1);
@@ -4054,8 +4030,6 @@ static void __devexit e1000_remove(struct pci_dev *pdev)
 
        flush_scheduled_work();
 
-       e1000_release_manageability(adapter);
-
        /* Release control of h/w to f/w.  If f/w is AMT enabled, this
         * would have already happened in close and is redundant. */
        e1000_release_hw_control(adapter);
index 0431e9ed0fac56681615a495f9f2c1a5f2d30040..4244fc282f2128143425bfdc64ee8e5e13d153f1 100644 (file)
@@ -130,8 +130,8 @@ static void free_skb_resources(struct gfar_private *priv);
 static void gfar_set_multi(struct net_device *dev);
 static void gfar_set_hash_for_addr(struct net_device *dev, u8 *addr);
 static void gfar_configure_serdes(struct net_device *dev);
-extern int gfar_local_mdio_write(struct gfar_mii *regs, int mii_id, int regnum, u16 value);
-extern int gfar_local_mdio_read(struct gfar_mii *regs, int mii_id, int regnum);
+extern int gfar_local_mdio_write(struct gfar_mii __iomem *regs, int mii_id, int regnum, u16 value);
+extern int gfar_local_mdio_read(struct gfar_mii __iomem *regs, int mii_id, int regnum);
 #ifdef CONFIG_GFAR_NAPI
 static int gfar_poll(struct napi_struct *napi, int budget);
 #endif
index 6a647d95e6eafbba7a33547aff6af936b0a6218f..24327629bf039d989652f472133b807b6b22a1ba 100644 (file)
@@ -51,7 +51,7 @@
  * the local mdio pins, which may not be the same as system mdio bus, used for
  * controlling the external PHYs, for example.
  */
-int gfar_local_mdio_write(struct gfar_mii *regs, int mii_id,
+int gfar_local_mdio_write(struct gfar_mii __iomem *regs, int mii_id,
                          int regnum, u16 value)
 {
        /* Set the PHY address and the register address we want to write */
@@ -77,7 +77,7 @@ int gfar_local_mdio_write(struct gfar_mii *regs, int mii_id,
  * and are always tied to the local mdio pins, which may not be the
  * same as system mdio bus, used for controlling the external PHYs, for eg.
  */
-int gfar_local_mdio_read(struct gfar_mii *regs, int mii_id, int regnum)
+int gfar_local_mdio_read(struct gfar_mii __iomem *regs, int mii_id, int regnum)
 
 {
        u16 value;
index cfcd15af501e794777c0926ba45539b0dbfe89c1..30c9b3b0d1319fe0c18b4906594748ee3ddaa6e0 100644 (file)
@@ -289,7 +289,6 @@ static void ax_bump(struct mkiss *ax)
                        *ax->rbuff &= ~0x20;
                }
        }
-       spin_unlock_bh(&ax->buflock);
 
        count = ax->rcount;
 
@@ -297,17 +296,17 @@ static void ax_bump(struct mkiss *ax)
                printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n",
                       ax->dev->name);
                ax->stats.rx_dropped++;
+               spin_unlock_bh(&ax->buflock);
                return;
        }
 
-       spin_lock_bh(&ax->buflock);
        memcpy(skb_put(skb,count), ax->rbuff, count);
-       spin_unlock_bh(&ax->buflock);
        skb->protocol = ax25_type_trans(skb, ax->dev);
        netif_rx(skb);
        ax->dev->last_rx = jiffies;
        ax->stats.rx_packets++;
        ax->stats.rx_bytes += count;
+       spin_unlock_bh(&ax->buflock);
 }
 
 static void kiss_unesc(struct mkiss *ax, unsigned char s)
index f69721e4eaa15195bd6a0d069b56ae9643e88f00..0447f9bcd27abc5fe588c72cf7220fe66534e8aa 100644 (file)
@@ -43,7 +43,7 @@ struct igb_stats {
        int stat_offset;
 };
 
-#define IGB_STAT(m) sizeof(((struct igb_adapter *)0)->m), \
+#define IGB_STAT(m) FIELD_SIZEOF(struct igb_adapter, m), \
                      offsetof(struct igb_adapter, m)
 static const struct igb_stats igb_gstrings_stats[] = {
        { "rx_packets", IGB_STAT(stats.gprc) },
index d4eb8e2d87202b681cff99ff6cd8ec1eec1f3664..bff280eff5e335ec563c732c7b708b567fc60699 100644 (file)
@@ -606,9 +606,6 @@ static void igb_init_manageability(struct igb_adapter *adapter)
                u32 manc2h = rd32(E1000_MANC2H);
                u32 manc = rd32(E1000_MANC);
 
-               /* disable hardware interception of ARP */
-               manc &= ~(E1000_MANC_ARP_EN);
-
                /* enable receiving management packets to the host */
                /* this will probably generate destination unreachable messages
                 * from the host OS, but the packets will be handled on SMBUS */
@@ -623,25 +620,6 @@ static void igb_init_manageability(struct igb_adapter *adapter)
        }
 }
 
-static void igb_release_manageability(struct igb_adapter *adapter)
-{
-       struct e1000_hw *hw = &adapter->hw;
-
-       if (adapter->en_mng_pt) {
-               u32 manc = rd32(E1000_MANC);
-
-               /* re-enable hardware interception of ARP */
-               manc |= E1000_MANC_ARP_EN;
-               manc &= ~E1000_MANC_EN_MNG2HOST;
-
-               /* don't explicitly have to mess with MANC2H since
-                * MANC has an enable disable that gates MANC2H */
-
-               /* XXX stop the hardware watchdog ? */
-               wr32(E1000_MANC, manc);
-       }
-}
-
 /**
  * igb_configure - configure the hardware for RX and TX
  * @adapter: private board structure
@@ -844,7 +822,6 @@ void igb_reset(struct igb_adapter *adapter)
 
        igb_reset_adaptive(&adapter->hw);
        adapter->hw.phy.ops.get_phy_info(&adapter->hw);
-       igb_release_manageability(adapter);
 }
 
 /**
@@ -1178,9 +1155,6 @@ static void __devexit igb_remove(struct pci_dev *pdev)
 
        flush_scheduled_work();
 
-
-       igb_release_manageability(adapter);
-
        /* Release control of h/w to f/w.  If f/w is AMT enabled, this
         * would have already happened in close and is redundant. */
        igb_release_hw_control(adapter);
@@ -3955,8 +3929,6 @@ static int igb_suspend(struct pci_dev *pdev, pm_message_t state)
                pci_enable_wake(pdev, PCI_D3cold, 0);
        }
 
-       igb_release_manageability(adapter);
-
        /* make sure adapter isn't asleep if manageability is enabled */
        if (adapter->en_mng_pt) {
                pci_enable_wake(pdev, PCI_D3hot, 1);
index a267dd86252072927755fec2d120af904804e0fc..53a9fd086f960cdacd4704ee1d2d68fe0d5d181c 100644 (file)
@@ -49,7 +49,7 @@ struct ixgb_stats {
        int stat_offset;
 };
 
-#define IXGB_STAT(m) sizeof(((struct ixgb_adapter *)0)->m), \
+#define IXGB_STAT(m) FIELD_SIZEOF(struct ixgb_adapter, m), \
                      offsetof(struct ixgb_adapter, m)
 static struct ixgb_stats ixgb_gstrings_stats[] = {
        {"rx_packets", IXGB_STAT(net_stats.rx_packets)},
index ead49e54f31b8fef4349d5ec551d537db5d87a27..23d0a4afe0e1d786db4ace8b93ba352f7eef28c1 100644 (file)
@@ -220,7 +220,6 @@ static bool ixgbe_clean_tx_irq(struct ixgbe_adapter *adapter,
                        tx_ring->stats.bytes += tx_buffer_info->length;
                        if (cleaned) {
                                struct sk_buff *skb = tx_buffer_info->skb;
-#ifdef NETIF_F_TSO
                                unsigned int segs, bytecount;
                                segs = skb_shinfo(skb)->gso_segs ?: 1;
                                /* multiply data chunks by size of headers */
@@ -228,10 +227,6 @@ static bool ixgbe_clean_tx_irq(struct ixgbe_adapter *adapter,
                                            skb->len;
                                total_tx_packets += segs;
                                total_tx_bytes += bytecount;
-#else
-                               total_tx_packets++;
-                               total_tx_bytes += skb->len;
-#endif
                        }
                        ixgbe_unmap_and_free_tx_resource(adapter,
                                                         tx_buffer_info);
@@ -1942,6 +1937,10 @@ static int ixgbe_open(struct net_device *netdev)
        int err;
        u32 num_rx_queues = adapter->num_rx_queues;
 
+       /* disallow open during test */
+       if (test_bit(__IXGBE_TESTING, &adapter->state))
+               return -EBUSY;
+
 try_intr_reinit:
        /* allocate transmit descriptors */
        err = ixgbe_setup_all_tx_resources(adapter);
@@ -2278,11 +2277,29 @@ static bool ixgbe_tx_csum(struct ixgbe_adapter *adapter,
                                    IXGBE_ADVTXD_DTYP_CTXT);
 
                if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                       if (skb->protocol == htons(ETH_P_IP))
+                       switch (skb->protocol) {
+                       case __constant_htons(ETH_P_IP):
                                type_tucmd_mlhl |= IXGBE_ADVTXD_TUCMD_IPV4;
+                               if (ip_hdr(skb)->protocol == IPPROTO_TCP)
+                                       type_tucmd_mlhl |=
+                                               IXGBE_ADVTXD_TUCMD_L4T_TCP;
+                               break;
+
+                       case __constant_htons(ETH_P_IPV6):
+                               /* XXX what about other V6 headers?? */
+                               if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
+                                       type_tucmd_mlhl |=
+                                               IXGBE_ADVTXD_TUCMD_L4T_TCP;
+                               break;
 
-                       if (skb->sk->sk_protocol == IPPROTO_TCP)
-                               type_tucmd_mlhl |= IXGBE_ADVTXD_TUCMD_L4T_TCP;
+                       default:
+                               if (unlikely(net_ratelimit())) {
+                                       DPRINTK(PROBE, WARNING,
+                                        "partial checksum but proto=%x!\n",
+                                        skb->protocol);
+                               }
+                               break;
+                       }
                }
 
                context_desc->type_tucmd_mlhl = cpu_to_le32(type_tucmd_mlhl);
@@ -2778,6 +2795,14 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
                 hw->mac.type, hw->phy.type,
                 (part_num >> 8), (part_num & 0xff));
 
+       if (link_width <= IXGBE_PCI_LINK_WIDTH_4) {
+               dev_warn(&pdev->dev, "PCI-Express bandwidth available for "
+                        "this card is not sufficient for optimal "
+                        "performance.\n");
+               dev_warn(&pdev->dev, "For optimal performance a x8 "
+                        "PCI-Express slot is required.\n");
+       }
+
        /* reset the hardware with the new settings */
        ixgbe_start_hw(hw);
 
index f18eca9831e88f8169ad944d7e8f363cd5b26300..250eb1954c342d7ecf3c77e7ef62978c18d6a5b8 100644 (file)
@@ -559,8 +559,16 @@ static int mhz_setup(struct pcmcia_device *link)
 
     /* Read the station address from the CIS.  It is stored as the last
        (fourth) string in the Version 1 Version/ID tuple. */
-    if (link->prod_id[3]) {
-       station_addr = link->prod_id[3];
+    tuple->DesiredTuple = CISTPL_VERS_1;
+    if (first_tuple(link, tuple, parse) != CS_SUCCESS) {
+       rc = -1;
+       goto free_cfg_mem;
+    }
+    /* Ugh -- the EM1144 card has two VERS_1 tuples!?! */
+    if (next_tuple(link, tuple, parse) != CS_SUCCESS)
+       first_tuple(link, tuple, parse);
+    if (parse->version_1.ns > 3) {
+       station_addr = parse->version_1.str + parse->version_1.ofs[3];
        if (cvt_ascii_address(dev, station_addr) == 0) {
                rc = 0;
                goto free_cfg_mem;
index 35d15e850075f18b4aebc28cf51fcd3095eabf7d..6f33f84d37b0631652d04825b58a554cc7477dc7 100644 (file)
@@ -36,6 +36,7 @@
 #include <linux/net.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
+#include <linux/ethtool.h>
 #include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
@@ -297,18 +298,11 @@ static void tsi108_check_phy(struct net_device *dev)
        u32 speed;
        unsigned long flags;
 
-       /* Do a dummy read, as for some reason the first read
-        * after a link becomes up returns link down, even if
-        * it's been a while since the link came up.
-        */
-
        spin_lock_irqsave(&phy_lock, flags);
 
        if (!data->phy_ok)
                goto out;
 
-       tsi108_read_mii(data, MII_BMSR);
-
        duplex = mii_check_media(&data->mii_if, netif_msg_link(data), data->init_media);
        data->init_media = 0;
 
@@ -345,22 +339,21 @@ static void tsi108_check_phy(struct net_device *dev)
 
                        TSI_WRITE(TSI108_MAC_CFG2, mac_cfg2_reg);
                        TSI_WRITE(TSI108_EC_PORTCTRL, portctrl_reg);
+               }
 
-                       if (data->link_up == 0) {
-                               /* The manual says it can take 3-4 usecs for the speed change
-                                * to take effect.
-                                */
-                               udelay(5);
+               if (data->link_up == 0) {
+                       /* The manual says it can take 3-4 usecs for the speed change
+                        * to take effect.
+                        */
+                       udelay(5);
 
-                               spin_lock(&data->txlock);
-                               if (is_valid_ether_addr(dev->dev_addr) && data->txfree)
-                                       netif_wake_queue(dev);
+                       spin_lock(&data->txlock);
+                       if (is_valid_ether_addr(dev->dev_addr) && data->txfree)
+                               netif_wake_queue(dev);
 
-                               data->link_up = 1;
-                               spin_unlock(&data->txlock);
-                       }
+                       data->link_up = 1;
+                       spin_unlock(&data->txlock);
                }
-
        } else {
                if (data->link_up == 1) {
                        netif_stop_queue(dev);
@@ -1274,12 +1267,11 @@ static void tsi108_init_phy(struct net_device *dev)
         * PHY_STAT register before the link up status bit is set.
         */
 
-       data->link_up = 1;
+       data->link_up = 0;
 
        while (!((phyval = tsi108_read_mii(data, MII_BMSR)) &
                 BMSR_LSTATUS)) {
                if (i++ > (MII_READ_DELAY / 10)) {
-                       data->link_up = 0;
                        break;
                }
                spin_unlock_irqrestore(&phy_lock, flags);
@@ -1287,6 +1279,7 @@ static void tsi108_init_phy(struct net_device *dev)
                spin_lock_irqsave(&phy_lock, flags);
        }
 
+       data->mii_if.supports_gmii = mii_check_gmii_support(&data->mii_if);
        printk(KERN_DEBUG "PHY_STAT reg contains %08x\n", phyval);
        data->phy_ok = 1;
        data->init_media = 1;
@@ -1527,12 +1520,46 @@ static void tsi108_init_mac(struct net_device *dev)
        TSI_WRITE(TSI108_EC_INTMASK, ~0);
 }
 
+static int tsi108_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+       struct tsi108_prv_data *data = netdev_priv(dev);
+       unsigned long flags;
+       int rc;
+       
+       spin_lock_irqsave(&data->txlock, flags);
+       rc = mii_ethtool_gset(&data->mii_if, cmd);
+       spin_unlock_irqrestore(&data->txlock, flags);
+
+       return rc;
+}
+
+static int tsi108_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+{
+       struct tsi108_prv_data *data = netdev_priv(dev);
+       unsigned long flags;
+       int rc;
+
+       spin_lock_irqsave(&data->txlock, flags);
+       rc = mii_ethtool_sset(&data->mii_if, cmd);
+       spin_unlock_irqrestore(&data->txlock, flags);
+       
+       return rc;
+}
+
 static int tsi108_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
        struct tsi108_prv_data *data = netdev_priv(dev);
+       if (!netif_running(dev))
+               return -EINVAL;
        return generic_mii_ioctl(&data->mii_if, if_mii(rq), cmd, NULL);
 }
 
+static const struct ethtool_ops tsi108_ethtool_ops = {
+       .get_link       = ethtool_op_get_link,
+       .get_settings   = tsi108_get_settings,
+       .set_settings   = tsi108_set_settings,
+};
+
 static int
 tsi108_init_one(struct platform_device *pdev)
 {
@@ -1584,7 +1611,6 @@ tsi108_init_one(struct platform_device *pdev)
        data->mii_if.phy_id = einfo->phy;
        data->mii_if.phy_id_mask = 0x1f;
        data->mii_if.reg_num_mask = 0x1f;
-       data->mii_if.supports_gmii = mii_check_gmii_support(&data->mii_if);
 
        data->phy = einfo->phy;
        data->phy_type = einfo->phy_type;
@@ -1598,6 +1624,7 @@ tsi108_init_one(struct platform_device *pdev)
        dev->get_stats = tsi108_get_stats;
        netif_napi_add(dev, &data->napi, tsi108_poll, 64);
        dev->do_ioctl = tsi108_do_ioctl;
+       dev->ethtool_ops = &tsi108_ethtool_ops;
 
        /* Apparently, the Linux networking code won't use scatter-gather
         * if the hardware doesn't do checksums.  However, it's faster
@@ -1629,6 +1656,7 @@ tsi108_init_one(struct platform_device *pdev)
                goto register_fail;
        }
 
+       platform_set_drvdata(pdev, dev);
        printk(KERN_INFO "%s: Tsi108 Gigabit Ethernet, MAC: %s\n",
               dev->name, print_mac(mac, dev->dev_addr));
 #ifdef DEBUG