141 files changed, 3469 insertions, 492 deletions

diff --git a/drivers/net/ethernet/3com/3c59x.c b/drivers/net/ethernet/3com/3c59x.c
index 61477b8e8d24..059c7414e303 100644
--- a/drivers/net/ethernet/3com/3c59x.c
+++ b/drivers/net/ethernet/3com/3c59x.c
@@ -375,7 +375,7 @@ static struct vortex_chip_info {
 };
 
 
-static DEFINE_PCI_DEVICE_TABLE(vortex_pci_tbl) = {
+static const struct pci_device_id vortex_pci_tbl[] = {
         { 0x10B7, 0x5900, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C590 },
         { 0x10B7, 0x5920, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C592 },
         { 0x10B7, 0x5970, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C597 },
diff --git a/drivers/net/ethernet/3com/typhoon.c b/drivers/net/ethernet/3com/typhoon.c
index e13b04624ded..48775b88bac7 100644
--- a/drivers/net/ethernet/3com/typhoon.c
+++ b/drivers/net/ethernet/3com/typhoon.c
@@ -203,7 +203,7 @@ static struct typhoon_card_info typhoon_card_info[] = {
  * bit 8 indicates if this is a (0) copper or (1) fiber card
  * bits 12-16 indicate card type: (0) client and (1) server
  */
-static DEFINE_PCI_DEVICE_TABLE(typhoon_pci_tbl) = {
+static const struct pci_device_id typhoon_pci_tbl[] = {
         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0,TYPHOON_TX },
         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_TX_95,
diff --git a/drivers/net/ethernet/8390/Kconfig b/drivers/net/ethernet/8390/Kconfig
index 0988811f4e40..2d89bd00de61 100644
--- a/drivers/net/ethernet/8390/Kconfig
+++ b/drivers/net/ethernet/8390/Kconfig
@@ -91,7 +91,8 @@ config MCF8390
 
 config NE2000
         tristate "NE2000/NE1000 support"
-        depends on (ISA || (Q40 && m) || M32R || MACH_TX49XX)
+        depends on (ISA || (Q40 && m) || M32R || MACH_TX49XX || \
+                    ATARI_ETHERNEC)
         select CRC32
         ---help---
           If you have a network (Ethernet) card of this type, say Y and read
diff --git a/drivers/net/ethernet/8390/axnet_cs.c b/drivers/net/ethernet/8390/axnet_cs.c
index 73c57a4a7b9e..7769c05543f1 100644
--- a/drivers/net/ethernet/8390/axnet_cs.c
+++ b/drivers/net/ethernet/8390/axnet_cs.c
@@ -108,7 +108,7 @@ static u32 axnet_msg_enable;
 
 /*====================================================================*/
 
-typedef struct axnet_dev_t {
+struct axnet_dev {
         struct pcmcia_device    *p_dev;
         caddr_t base;
         struct timer_list       watchdog;
@@ -118,9 +118,9 @@ typedef struct axnet_dev_t {
         int     phy_id;
         int     flags;
         int     active_low;
-} axnet_dev_t;
+};
 
-static inline axnet_dev_t *PRIV(struct net_device *dev)
+static inline struct axnet_dev *PRIV(struct net_device *dev)
 {
         void *p = (char *)netdev_priv(dev) + sizeof(struct ei_device);
         return p;
@@ -141,13 +141,13 @@ static const struct net_device_ops axnet_netdev_ops = {
 
 static int axnet_probe(struct pcmcia_device *link)
 {
-    axnet_dev_t *info;
+    struct axnet_dev *info;
     struct net_device *dev;
     struct ei_device *ei_local;
 
     dev_dbg(&link->dev, "axnet_attach()\n");
 
-    dev = alloc_etherdev(sizeof(struct ei_device) + sizeof(axnet_dev_t));
+    dev = alloc_etherdev(sizeof(struct ei_device) + sizeof(struct axnet_dev));
     if (!dev)
         return -ENOMEM;
 
@@ -274,7 +274,7 @@ static int axnet_configcheck(struct pcmcia_device *p_dev, void *priv_data)
 static int axnet_config(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
-    axnet_dev_t *info = PRIV(dev);
+    struct axnet_dev *info = PRIV(dev);
     int i, j, j2, ret;
 
     dev_dbg(&link->dev, "axnet_config(0x%p)\n", link);
@@ -389,7 +389,7 @@ static int axnet_suspend(struct pcmcia_device *link)
 static int axnet_resume(struct pcmcia_device *link)
 {
         struct net_device *dev = link->priv;
-        axnet_dev_t *info = PRIV(dev);
+        struct axnet_dev *info = PRIV(dev);
 
         if (link->open) {
                 if (info->active_low == 1)
@@ -467,7 +467,7 @@ static void mdio_write(unsigned int addr, int phy_id, int loc, int value)
 static int axnet_open(struct net_device *dev)
 {
     int ret;
-    axnet_dev_t *info = PRIV(dev);
+    struct axnet_dev *info = PRIV(dev);
     struct pcmcia_device *link = info->p_dev;
     unsigned int nic_base = dev->base_addr;
     
@@ -497,7 +497,7 @@ static int axnet_open(struct net_device *dev)
 
 static int axnet_close(struct net_device *dev)
 {
-    axnet_dev_t *info = PRIV(dev);
+    struct axnet_dev *info = PRIV(dev);
     struct pcmcia_device *link = info->p_dev;
 
     dev_dbg(&link->dev, "axnet_close('%s')\n", dev->name);
@@ -554,7 +554,7 @@ static irqreturn_t ei_irq_wrapper(int irq, void *dev_id)
 static void ei_watchdog(u_long arg)
 {
     struct net_device *dev = (struct net_device *)(arg);
-    axnet_dev_t *info = PRIV(dev);
+    struct axnet_dev *info = PRIV(dev);
     unsigned int nic_base = dev->base_addr;
     unsigned int mii_addr = nic_base + AXNET_MII_EEP;
     u_short link;
@@ -610,7 +610,7 @@ reschedule:
 
 static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
-    axnet_dev_t *info = PRIV(dev);
+    struct axnet_dev *info = PRIV(dev);
     struct mii_ioctl_data *data = if_mii(rq);
     unsigned int mii_addr = dev->base_addr + AXNET_MII_EEP;
     switch (cmd) {
@@ -1452,7 +1452,7 @@ static void ei_receive(struct net_device *dev)
 
 static void ei_rx_overrun(struct net_device *dev)
 {
-        axnet_dev_t *info = PRIV(dev);
+        struct axnet_dev *info = PRIV(dev);
         long e8390_base = dev->base_addr;
         unsigned char was_txing, must_resend = 0;
         struct ei_device *ei_local = netdev_priv(dev);
@@ -1624,7 +1624,7 @@ static void set_multicast_list(struct net_device *dev)
 
 static void AX88190_init(struct net_device *dev, int startp)
 {
-        axnet_dev_t *info = PRIV(dev);
+        struct axnet_dev *info = PRIV(dev);
         long e8390_base = dev->base_addr;
         struct ei_device *ei_local = netdev_priv(dev);
         int i;
diff --git a/drivers/net/ethernet/8390/ne.c b/drivers/net/ethernet/8390/ne.c
index 58eaa8f34942..de566fb6e0f7 100644
--- a/drivers/net/ethernet/8390/ne.c
+++ b/drivers/net/ethernet/8390/ne.c
@@ -169,6 +169,8 @@ bad_clone_list[] __initdata = {
 #elif defined(CONFIG_PLAT_OAKS32R)  || \
    defined(CONFIG_MACH_TX49XX)
 #  define DCR_VAL 0x48          /* 8-bit mode */
+#elif defined(CONFIG_ATARI)     /* 8-bit mode on Atari, normal on Q40 */
+#  define DCR_VAL (MACH_IS_ATARI ? 0x48 : 0x49)
 #else
 #  define DCR_VAL 0x49
 #endif
diff --git a/drivers/net/ethernet/8390/ne2k-pci.c b/drivers/net/ethernet/8390/ne2k-pci.c
index f395c967262e..89c8d9fc97de 100644
--- a/drivers/net/ethernet/8390/ne2k-pci.c
+++ b/drivers/net/ethernet/8390/ne2k-pci.c
@@ -135,7 +135,7 @@ static struct {
 };
 
 
-static DEFINE_PCI_DEVICE_TABLE(ne2k_pci_tbl) = {
+static const struct pci_device_id ne2k_pci_tbl[] = {
         { 0x10ec, 0x8029, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RealTek_RTL_8029 },
         { 0x1050, 0x0940, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940 },
         { 0x11f6, 0x1401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Compex_RL2000 },
diff --git a/drivers/net/ethernet/8390/pcnet_cs.c b/drivers/net/ethernet/8390/pcnet_cs.c
index ca3c2b921cf6..9fb7b9d4fd6c 100644
--- a/drivers/net/ethernet/8390/pcnet_cs.c
+++ b/drivers/net/ethernet/8390/pcnet_cs.c
@@ -111,11 +111,11 @@ static void pcnet_detach(struct pcmcia_device *p_dev);
 
 /*====================================================================*/
 
-typedef struct hw_info_t {
+struct hw_info {
     u_int       offset;
     u_char      a0, a1, a2;
     u_int       flags;
-} hw_info_t;
+};
 
 #define DELAY_OUTPUT    0x01
 #define HAS_MISC_REG    0x02
@@ -132,7 +132,7 @@ typedef struct hw_info_t {
 #define MII_PHYID_REG1          0x02
 #define MII_PHYID_REG2          0x03
 
-static hw_info_t hw_info[] = {
+static struct hw_info hw_info[] = {
     { /* Accton EN2212 */ 0x0ff0, 0x00, 0x00, 0xe8, DELAY_OUTPUT },
     { /* Allied Telesis LA-PCM */ 0x0ff0, 0x00, 0x00, 0xf4, 0 },
     { /* APEX MultiCard */ 0x03f4, 0x00, 0x20, 0xe5, 0 },
@@ -196,11 +196,11 @@ static hw_info_t hw_info[] = {
 
 #define NR_INFO         ARRAY_SIZE(hw_info)
 
-static hw_info_t default_info = { 0, 0, 0, 0, 0 };
-static hw_info_t dl10019_info = { 0, 0, 0, 0, IS_DL10019|HAS_MII };
-static hw_info_t dl10022_info = { 0, 0, 0, 0, IS_DL10022|HAS_MII };
+static struct hw_info default_info = { 0, 0, 0, 0, 0 };
+static struct hw_info dl10019_info = { 0, 0, 0, 0, IS_DL10019|HAS_MII };
+static struct hw_info dl10022_info = { 0, 0, 0, 0, IS_DL10022|HAS_MII };
 
-typedef struct pcnet_dev_t {
+struct pcnet_dev {
         struct pcmcia_device    *p_dev;
     u_int               flags;
     void                __iomem *base;
@@ -210,12 +210,12 @@ typedef struct pcnet_dev_t {
     u_char              eth_phy, pna_phy;
     u_short             link_status;
     u_long              mii_reset;
-} pcnet_dev_t;
+};
 
-static inline pcnet_dev_t *PRIV(struct net_device *dev)
+static inline struct pcnet_dev *PRIV(struct net_device *dev)
 {
         char *p = netdev_priv(dev);
-        return (pcnet_dev_t *)(p + sizeof(struct ei_device));
+        return (struct pcnet_dev *)(p + sizeof(struct ei_device));
 }
 
 static const struct net_device_ops pcnet_netdev_ops = {
@@ -237,13 +237,13 @@ static const struct net_device_ops pcnet_netdev_ops = {
 
 static int pcnet_probe(struct pcmcia_device *link)
 {
-    pcnet_dev_t *info;
+    struct pcnet_dev *info;
     struct net_device *dev;
 
     dev_dbg(&link->dev, "pcnet_attach()\n");
 
     /* Create new ethernet device */
-    dev = __alloc_ei_netdev(sizeof(pcnet_dev_t));
+    dev = __alloc_ei_netdev(sizeof(struct pcnet_dev));
     if (!dev) return -ENOMEM;
     info = PRIV(dev);
     info->p_dev = link;
@@ -276,7 +276,7 @@ static void pcnet_detach(struct pcmcia_device *link)
 
 ======================================================================*/
 
-static hw_info_t *get_hwinfo(struct pcmcia_device *link)
+static struct hw_info *get_hwinfo(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
     u_char __iomem *base, *virt;
@@ -317,7 +317,7 @@ static hw_info_t *get_hwinfo(struct pcmcia_device *link)
 
 ======================================================================*/
 
-static hw_info_t *get_prom(struct pcmcia_device *link)
+static struct hw_info *get_prom(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
     unsigned int ioaddr = dev->base_addr;
@@ -371,7 +371,7 @@ static hw_info_t *get_prom(struct pcmcia_device *link)
 
 ======================================================================*/
 
-static hw_info_t *get_dl10019(struct pcmcia_device *link)
+static struct hw_info *get_dl10019(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
     int i;
@@ -393,7 +393,7 @@ static hw_info_t *get_dl10019(struct pcmcia_device *link)
 
 ======================================================================*/
 
-static hw_info_t *get_ax88190(struct pcmcia_device *link)
+static struct hw_info *get_ax88190(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
     unsigned int ioaddr = dev->base_addr;
@@ -424,7 +424,7 @@ static hw_info_t *get_ax88190(struct pcmcia_device *link)
 
 ======================================================================*/
 
-static hw_info_t *get_hwired(struct pcmcia_device *link)
+static struct hw_info *get_hwired(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
     int i;
@@ -489,12 +489,12 @@ static int pcnet_confcheck(struct pcmcia_device *p_dev, void *priv_data)
         return try_io_port(p_dev);
 }
 
-static hw_info_t *pcnet_try_config(struct pcmcia_device *link,
-                                   int *has_shmem, int try)
+static struct hw_info *pcnet_try_config(struct pcmcia_device *link,
+                                        int *has_shmem, int try)
 {
         struct net_device *dev = link->priv;
-        hw_info_t *local_hw_info;
-        pcnet_dev_t *info = PRIV(dev);
+        struct hw_info *local_hw_info;
+        struct pcnet_dev *info = PRIV(dev);
         int priv = try;
         int ret;
 
@@ -553,10 +553,10 @@ static hw_info_t *pcnet_try_config(struct pcmcia_device *link,
 static int pcnet_config(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
     int start_pg, stop_pg, cm_offset;
     int has_shmem = 0;
-    hw_info_t *local_hw_info;
+    struct hw_info *local_hw_info;
     struct ei_device *ei_local;
 
     dev_dbg(&link->dev, "pcnet_config\n");
@@ -639,7 +639,7 @@ failed:
 
 static void pcnet_release(struct pcmcia_device *link)
 {
-        pcnet_dev_t *info = PRIV(link->priv);
+        struct pcnet_dev *info = PRIV(link->priv);
 
         dev_dbg(&link->dev, "pcnet_release\n");
 
@@ -836,7 +836,7 @@ static void write_asic(unsigned int ioaddr, int location, short asic_data)
 static void set_misc_reg(struct net_device *dev)
 {
     unsigned int nic_base = dev->base_addr;
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
     u_char tmp;
 
     if (info->flags & HAS_MISC_REG) {
@@ -873,7 +873,7 @@ static void set_misc_reg(struct net_device *dev)
 
 static void mii_phy_probe(struct net_device *dev)
 {
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
     unsigned int mii_addr = dev->base_addr + DLINK_GPIO;
     int i;
     u_int tmp, phyid;
@@ -898,7 +898,7 @@ static void mii_phy_probe(struct net_device *dev)
 static int pcnet_open(struct net_device *dev)
 {
     int ret;
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
     struct pcmcia_device *link = info->p_dev;
     unsigned int nic_base = dev->base_addr;
 
@@ -931,7 +931,7 @@ static int pcnet_open(struct net_device *dev)
 
 static int pcnet_close(struct net_device *dev)
 {
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
     struct pcmcia_device *link = info->p_dev;
 
     dev_dbg(&link->dev, "pcnet_close('%s')\n", dev->name);
@@ -982,7 +982,7 @@ static void pcnet_reset_8390(struct net_device *dev)
 
 static int set_config(struct net_device *dev, struct ifmap *map)
 {
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
     if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
         if (!(info->flags & HAS_MISC_REG))
             return -EOPNOTSUPP;
@@ -1000,7 +1000,7 @@ static int set_config(struct net_device *dev, struct ifmap *map)
 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id)
 {
     struct net_device *dev = dev_id;
-    pcnet_dev_t *info;
+    struct pcnet_dev *info;
     irqreturn_t ret = ei_interrupt(irq, dev_id);
 
     if (ret == IRQ_HANDLED) {
@@ -1013,7 +1013,7 @@ static irqreturn_t ei_irq_wrapper(int irq, void *dev_id)
 static void ei_watchdog(u_long arg)
 {
     struct net_device *dev = (struct net_device *)arg;
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
     unsigned int nic_base = dev->base_addr;
     unsigned int mii_addr = nic_base + DLINK_GPIO;
     u_short link;
@@ -1101,7 +1101,7 @@ reschedule:
 
 static int ei_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
     struct mii_ioctl_data *data = if_mii(rq);
     unsigned int mii_addr = dev->base_addr + DLINK_GPIO;
 
@@ -1214,7 +1214,7 @@ static void dma_block_output(struct net_device *dev, int count,
                              const u_char *buf, const int start_page)
 {
     unsigned int nic_base = dev->base_addr;
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
 #ifdef PCMCIA_DEBUG
     int retries = 0;
     struct ei_device *ei_local = netdev_priv(dev);
@@ -1403,7 +1403,7 @@ static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
                               int stop_pg, int cm_offset)
 {
     struct net_device *dev = link->priv;
-    pcnet_dev_t *info = PRIV(dev);
+    struct pcnet_dev *info = PRIV(dev);
     int i, window_size, offset, ret;
 
     window_size = (stop_pg - start_pg) << 8;
diff --git a/drivers/net/ethernet/Kconfig b/drivers/net/ethernet/Kconfig
index edb718661850..dc7406c81c45 100644
--- a/drivers/net/ethernet/Kconfig
+++ b/drivers/net/ethernet/Kconfig
@@ -24,6 +24,7 @@ source "drivers/net/ethernet/allwinner/Kconfig"
 source "drivers/net/ethernet/alteon/Kconfig"
 source "drivers/net/ethernet/altera/Kconfig"
 source "drivers/net/ethernet/amd/Kconfig"
+source "drivers/net/ethernet/apm/Kconfig"
 source "drivers/net/ethernet/apple/Kconfig"
 source "drivers/net/ethernet/arc/Kconfig"
 source "drivers/net/ethernet/atheros/Kconfig"
diff --git a/drivers/net/ethernet/Makefile b/drivers/net/ethernet/Makefile
index 58de3339ab3c..224a01877149 100644
--- a/drivers/net/ethernet/Makefile
+++ b/drivers/net/ethernet/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_NET_VENDOR_ALLWINNER) += allwinner/
 obj-$(CONFIG_NET_VENDOR_ALTEON) += alteon/
 obj-$(CONFIG_ALTERA_TSE) += altera/
 obj-$(CONFIG_NET_VENDOR_AMD) += amd/
+obj-$(CONFIG_NET_XGENE) += apm/
 obj-$(CONFIG_NET_VENDOR_APPLE) += apple/
 obj-$(CONFIG_NET_VENDOR_ARC) += arc/
 obj-$(CONFIG_NET_VENDOR_ATHEROS) += atheros/
diff --git a/drivers/net/ethernet/adaptec/starfire.c b/drivers/net/ethernet/adaptec/starfire.c
index 40dbbf740331..ac7288240d55 100644
--- a/drivers/net/ethernet/adaptec/starfire.c
+++ b/drivers/net/ethernet/adaptec/starfire.c
@@ -285,7 +285,7 @@ enum chipset {
         CH_6915 = 0,
 };
 
-static DEFINE_PCI_DEVICE_TABLE(starfire_pci_tbl) = {
+static const struct pci_device_id starfire_pci_tbl[] = {
         { PCI_VDEVICE(ADAPTEC, 0x6915), CH_6915 },
         { 0, }
 };
diff --git a/drivers/net/ethernet/alteon/acenic.c b/drivers/net/ethernet/alteon/acenic.c
index 9a6991be9749..b68074803de3 100644
--- a/drivers/net/ethernet/alteon/acenic.c
+++ b/drivers/net/ethernet/alteon/acenic.c
@@ -131,7 +131,7 @@
 #define PCI_DEVICE_ID_SGI_ACENIC        0x0009
 #endif
 
-static DEFINE_PCI_DEVICE_TABLE(acenic_pci_tbl) = {
+static const struct pci_device_id acenic_pci_tbl[] = {
         { PCI_VENDOR_ID_ALTEON, PCI_DEVICE_ID_ALTEON_ACENIC_FIBRE,
           PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
         { PCI_VENDOR_ID_ALTEON, PCI_DEVICE_ID_ALTEON_ACENIC_COPPER,
diff --git a/drivers/net/ethernet/amd/au1000_eth.c b/drivers/net/ethernet/amd/au1000_eth.c
index a78e4c136959..31c48a7ac2b6 100644
--- a/drivers/net/ethernet/amd/au1000_eth.c
+++ b/drivers/net/ethernet/amd/au1000_eth.c
@@ -89,6 +89,124 @@ MODULE_DESCRIPTION(DRV_DESC);
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_VERSION);
 
+/* AU1000 MAC registers and bits */
+#define MAC_CONTROL             0x0
+#  define MAC_RX_ENABLE         (1 << 2)
+#  define MAC_TX_ENABLE         (1 << 3)
+#  define MAC_DEF_CHECK         (1 << 5)
+#  define MAC_SET_BL(X)         (((X) & 0x3) << 6)
+#  define MAC_AUTO_PAD          (1 << 8)
+#  define MAC_DISABLE_RETRY     (1 << 10)
+#  define MAC_DISABLE_BCAST     (1 << 11)
+#  define MAC_LATE_COL          (1 << 12)
+#  define MAC_HASH_MODE         (1 << 13)
+#  define MAC_HASH_ONLY         (1 << 15)
+#  define MAC_PASS_ALL          (1 << 16)
+#  define MAC_INVERSE_FILTER    (1 << 17)
+#  define MAC_PROMISCUOUS       (1 << 18)
+#  define MAC_PASS_ALL_MULTI    (1 << 19)
+#  define MAC_FULL_DUPLEX       (1 << 20)
+#  define MAC_NORMAL_MODE       0
+#  define MAC_INT_LOOPBACK      (1 << 21)
+#  define MAC_EXT_LOOPBACK      (1 << 22)
+#  define MAC_DISABLE_RX_OWN    (1 << 23)
+#  define MAC_BIG_ENDIAN        (1 << 30)
+#  define MAC_RX_ALL            (1 << 31)
+#define MAC_ADDRESS_HIGH        0x4
+#define MAC_ADDRESS_LOW         0x8
+#define MAC_MCAST_HIGH          0xC
+#define MAC_MCAST_LOW           0x10
+#define MAC_MII_CNTRL           0x14
+#  define MAC_MII_BUSY          (1 << 0)
+#  define MAC_MII_READ          0
+#  define MAC_MII_WRITE         (1 << 1)
+#  define MAC_SET_MII_SELECT_REG(X) (((X) & 0x1f) << 6)
+#  define MAC_SET_MII_SELECT_PHY(X) (((X) & 0x1f) << 11)
+#define MAC_MII_DATA            0x18
+#define MAC_FLOW_CNTRL          0x1C
+#  define MAC_FLOW_CNTRL_BUSY   (1 << 0)
+#  define MAC_FLOW_CNTRL_ENABLE (1 << 1)
+#  define MAC_PASS_CONTROL      (1 << 2)
+#  define MAC_SET_PAUSE(X)      (((X) & 0xffff) << 16)
+#define MAC_VLAN1_TAG           0x20
+#define MAC_VLAN2_TAG           0x24
+
+/* Ethernet Controller Enable */
+#  define MAC_EN_CLOCK_ENABLE   (1 << 0)
+#  define MAC_EN_RESET0         (1 << 1)
+#  define MAC_EN_TOSS           (0 << 2)
+#  define MAC_EN_CACHEABLE      (1 << 3)
+#  define MAC_EN_RESET1         (1 << 4)
+#  define MAC_EN_RESET2         (1 << 5)
+#  define MAC_DMA_RESET         (1 << 6)
+
+/* Ethernet Controller DMA Channels */
+/* offsets from MAC_TX_RING_ADDR address */
+#define MAC_TX_BUFF0_STATUS     0x0
+#  define TX_FRAME_ABORTED      (1 << 0)
+#  define TX_JAB_TIMEOUT        (1 << 1)
+#  define TX_NO_CARRIER         (1 << 2)
+#  define TX_LOSS_CARRIER       (1 << 3)
+#  define TX_EXC_DEF            (1 << 4)
+#  define TX_LATE_COLL_ABORT    (1 << 5)
+#  define TX_EXC_COLL           (1 << 6)
+#  define TX_UNDERRUN           (1 << 7)
+#  define TX_DEFERRED           (1 << 8)
+#  define TX_LATE_COLL          (1 << 9)
+#  define TX_COLL_CNT_MASK      (0xF << 10)
+#  define TX_PKT_RETRY          (1 << 31)
+#define MAC_TX_BUFF0_ADDR       0x4
+#  define TX_DMA_ENABLE         (1 << 0)
+#  define TX_T_DONE             (1 << 1)
+#  define TX_GET_DMA_BUFFER(X)  (((X) >> 2) & 0x3)
+#define MAC_TX_BUFF0_LEN        0x8
+#define MAC_TX_BUFF1_STATUS     0x10
+#define MAC_TX_BUFF1_ADDR       0x14
+#define MAC_TX_BUFF1_LEN        0x18
+#define MAC_TX_BUFF2_STATUS     0x20
+#define MAC_TX_BUFF2_ADDR       0x24
+#define MAC_TX_BUFF2_LEN        0x28
+#define MAC_TX_BUFF3_STATUS     0x30
+#define MAC_TX_BUFF3_ADDR       0x34
+#define MAC_TX_BUFF3_LEN        0x38
+
+/* offsets from MAC_RX_RING_ADDR */
+#define MAC_RX_BUFF0_STATUS     0x0
+#  define RX_FRAME_LEN_MASK     0x3fff
+#  define RX_WDOG_TIMER         (1 << 14)
+#  define RX_RUNT               (1 << 15)
+#  define RX_OVERLEN            (1 << 16)
+#  define RX_COLL               (1 << 17)
+#  define RX_ETHER              (1 << 18)
+#  define RX_MII_ERROR          (1 << 19)
+#  define RX_DRIBBLING          (1 << 20)
+#  define RX_CRC_ERROR          (1 << 21)
+#  define RX_VLAN1              (1 << 22)
+#  define RX_VLAN2              (1 << 23)
+#  define RX_LEN_ERROR          (1 << 24)
+#  define RX_CNTRL_FRAME        (1 << 25)
+#  define RX_U_CNTRL_FRAME      (1 << 26)
+#  define RX_MCAST_FRAME        (1 << 27)
+#  define RX_BCAST_FRAME        (1 << 28)
+#  define RX_FILTER_FAIL        (1 << 29)
+#  define RX_PACKET_FILTER      (1 << 30)
+#  define RX_MISSED_FRAME       (1 << 31)
+
+#  define RX_ERROR (RX_WDOG_TIMER | RX_RUNT | RX_OVERLEN |  \
+                    RX_COLL | RX_MII_ERROR | RX_CRC_ERROR | \
+                    RX_LEN_ERROR | RX_U_CNTRL_FRAME | RX_MISSED_FRAME)
+#define MAC_RX_BUFF0_ADDR       0x4
+#  define RX_DMA_ENABLE         (1 << 0)
+#  define RX_T_DONE             (1 << 1)
+#  define RX_GET_DMA_BUFFER(X)  (((X) >> 2) & 0x3)
+#  define RX_SET_BUFF_ADDR(X)   ((X) & 0xffffffc0)
+#define MAC_RX_BUFF1_STATUS     0x10
+#define MAC_RX_BUFF1_ADDR       0x14
+#define MAC_RX_BUFF2_STATUS     0x20
+#define MAC_RX_BUFF2_ADDR       0x24
+#define MAC_RX_BUFF3_STATUS     0x30
+#define MAC_RX_BUFF3_ADDR       0x34
+
 /*
  * Theory of operation
  *
@@ -152,10 +270,12 @@ static void au1000_enable_mac(struct net_device *dev, int force_reset)
 
         if (force_reset || (!aup->mac_enabled)) {
                 writel(MAC_EN_CLOCK_ENABLE, aup->enable);
-                au_sync_delay(2);
+                wmb(); /* drain writebuffer */
+                mdelay(2);
                 writel((MAC_EN_RESET0 | MAC_EN_RESET1 | MAC_EN_RESET2
                                 | MAC_EN_CLOCK_ENABLE), aup->enable);
-                au_sync_delay(2);
+                wmb(); /* drain writebuffer */
+                mdelay(2);
 
                 aup->mac_enabled = 1;
         }
@@ -273,7 +393,8 @@ static void au1000_hard_stop(struct net_device *dev)
         reg = readl(&aup->mac->control);
         reg &= ~(MAC_RX_ENABLE | MAC_TX_ENABLE);
         writel(reg, &aup->mac->control);
-        au_sync_delay(10);
+        wmb(); /* drain writebuffer */
+        mdelay(10);
 }
 
 static void au1000_enable_rx_tx(struct net_device *dev)
@@ -286,7 +407,8 @@ static void au1000_enable_rx_tx(struct net_device *dev)
         reg = readl(&aup->mac->control);
         reg |= (MAC_RX_ENABLE | MAC_TX_ENABLE);
         writel(reg, &aup->mac->control);
-        au_sync_delay(10);
+        wmb(); /* drain writebuffer */
+        mdelay(10);
 }
 
 static void
@@ -336,7 +458,8 @@ au1000_adjust_link(struct net_device *dev)
                         reg |= MAC_DISABLE_RX_OWN;
                 }
                 writel(reg, &aup->mac->control);
-                au_sync_delay(1);
+                wmb(); /* drain writebuffer */
+                mdelay(1);
 
                 au1000_enable_rx_tx(dev);
                 aup->old_duplex = phydev->duplex;
@@ -500,9 +623,11 @@ static void au1000_reset_mac_unlocked(struct net_device *dev)
         au1000_hard_stop(dev);
 
         writel(MAC_EN_CLOCK_ENABLE, aup->enable);
-        au_sync_delay(2);
+        wmb(); /* drain writebuffer */
+        mdelay(2);
         writel(0, aup->enable);
-        au_sync_delay(2);
+        wmb(); /* drain writebuffer */
+        mdelay(2);
 
         aup->tx_full = 0;
         for (i = 0; i < NUM_RX_DMA; i++) {
@@ -652,7 +777,7 @@ static int au1000_init(struct net_device *dev)
         for (i = 0; i < NUM_RX_DMA; i++)
                 aup->rx_dma_ring[i]->buff_stat |= RX_DMA_ENABLE;
 
-        au_sync();
+        wmb(); /* drain writebuffer */
 
         control = MAC_RX_ENABLE | MAC_TX_ENABLE;
 #ifndef CONFIG_CPU_LITTLE_ENDIAN
@@ -669,7 +794,7 @@ static int au1000_init(struct net_device *dev)
 
         writel(control, &aup->mac->control);
         writel(0x8100, &aup->mac->vlan1_tag); /* activate vlan support */
-        au_sync();
+        wmb(); /* drain writebuffer */
 
         spin_unlock_irqrestore(&aup->lock, flags);
         return 0;
@@ -760,7 +885,7 @@ static int au1000_rx(struct net_device *dev)
                 }
                 prxd->buff_stat = (u32)(pDB->dma_addr | RX_DMA_ENABLE);
                 aup->rx_head = (aup->rx_head + 1) & (NUM_RX_DMA - 1);
-                au_sync();
+                wmb(); /* drain writebuffer */
 
                 /* next descriptor */
                 prxd = aup->rx_dma_ring[aup->rx_head];
@@ -808,7 +933,7 @@ static void au1000_tx_ack(struct net_device *dev)
                 au1000_update_tx_stats(dev, ptxd->status);
                 ptxd->buff_stat &= ~TX_T_DONE;
                 ptxd->len = 0;
-                au_sync();
+                wmb(); /* drain writebuffer */
 
                 aup->tx_tail = (aup->tx_tail + 1) & (NUM_TX_DMA - 1);
                 ptxd = aup->tx_dma_ring[aup->tx_tail];
@@ -939,7 +1064,7 @@ static netdev_tx_t au1000_tx(struct sk_buff *skb, struct net_device *dev)
         ps->tx_bytes += ptxd->len;
 
         ptxd->buff_stat = pDB->dma_addr | TX_DMA_ENABLE;
-        au_sync();
+        wmb(); /* drain writebuffer */
         dev_kfree_skb(skb);
         aup->tx_head = (aup->tx_head + 1) & (NUM_TX_DMA - 1);
         return NETDEV_TX_OK;
diff --git a/drivers/net/ethernet/amd/pcnet32.c b/drivers/net/ethernet/amd/pcnet32.c
index e7cc9174e364..e2e3aaf501a2 100644
--- a/drivers/net/ethernet/amd/pcnet32.c
+++ b/drivers/net/ethernet/amd/pcnet32.c
@@ -61,7 +61,7 @@ static const char *const version =
 /*
  * PCI device identifiers for "new style" Linux PCI Device Drivers
  */
-static DEFINE_PCI_DEVICE_TABLE(pcnet32_pci_tbl) = {
+static const struct pci_device_id pcnet32_pci_tbl[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_LANCE_HOME), },
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_LANCE), },
 
@@ -481,37 +481,32 @@ static void pcnet32_realloc_tx_ring(struct net_device *dev,
         dma_addr_t *new_dma_addr_list;
         struct pcnet32_tx_head *new_tx_ring;
         struct sk_buff **new_skb_list;
+        unsigned int entries = BIT(size);
 
         pcnet32_purge_tx_ring(dev);
 
-        new_tx_ring = pci_alloc_consistent(lp->pci_dev,
-                                           sizeof(struct pcnet32_tx_head) *
-                                           (1 << size),
-                                           &new_ring_dma_addr);
-        if (new_tx_ring == NULL) {
-                netif_err(lp, drv, dev, "Consistent memory allocation failed\n");
+        new_tx_ring =
+                pci_zalloc_consistent(lp->pci_dev,
+                                      sizeof(struct pcnet32_tx_head) * entries,
+                                      &new_ring_dma_addr);
+        if (new_tx_ring == NULL)
                 return;
-        }
-        memset(new_tx_ring, 0, sizeof(struct pcnet32_tx_head) * (1 << size));
 
-        new_dma_addr_list = kcalloc(1 << size, sizeof(dma_addr_t),
-                                    GFP_ATOMIC);
+        new_dma_addr_list = kcalloc(entries, sizeof(dma_addr_t), GFP_ATOMIC);
         if (!new_dma_addr_list)
                 goto free_new_tx_ring;
 
-        new_skb_list = kcalloc(1 << size, sizeof(struct sk_buff *),
-                               GFP_ATOMIC);
+        new_skb_list = kcalloc(entries, sizeof(struct sk_buff *), GFP_ATOMIC);
         if (!new_skb_list)
                 goto free_new_lists;
 
         kfree(lp->tx_skbuff);
         kfree(lp->tx_dma_addr);
         pci_free_consistent(lp->pci_dev,
-                            sizeof(struct pcnet32_tx_head) *
-                            lp->tx_ring_size, lp->tx_ring,
-                            lp->tx_ring_dma_addr);
+                            sizeof(struct pcnet32_tx_head) * lp->tx_ring_size,
+                            lp->tx_ring, lp->tx_ring_dma_addr);
 
-        lp->tx_ring_size = (1 << size);
+        lp->tx_ring_size = entries;
         lp->tx_mod_mask = lp->tx_ring_size - 1;
         lp->tx_len_bits = (size << 12);
         lp->tx_ring = new_tx_ring;
@@ -524,8 +519,7 @@ free_new_lists:
         kfree(new_dma_addr_list);
 free_new_tx_ring:
         pci_free_consistent(lp->pci_dev,
-                            sizeof(struct pcnet32_tx_head) *
-                            (1 << size),
+                            sizeof(struct pcnet32_tx_head) * entries,
                             new_tx_ring,
                             new_ring_dma_addr);
 }
@@ -549,17 +543,14 @@ static void pcnet32_realloc_rx_ring(struct net_device *dev,
         struct pcnet32_rx_head *new_rx_ring;
         struct sk_buff **new_skb_list;
         int new, overlap;
-        unsigned int entries = 1 << size;
+        unsigned int entries = BIT(size);
 
-        new_rx_ring = pci_alloc_consistent(lp->pci_dev,
-                                           sizeof(struct pcnet32_rx_head) *
-                                           entries,
-                                           &new_ring_dma_addr);
-        if (new_rx_ring == NULL) {
-                netif_err(lp, drv, dev, "Consistent memory allocation failed\n");
+        new_rx_ring =
+                pci_zalloc_consistent(lp->pci_dev,
+                                      sizeof(struct pcnet32_rx_head) * entries,
+                                      &new_ring_dma_addr);
+        if (new_rx_ring == NULL)
                 return;
-        }
-        memset(new_rx_ring, 0, sizeof(struct pcnet32_rx_head) * entries);
 
         new_dma_addr_list = kcalloc(entries, sizeof(dma_addr_t), GFP_ATOMIC);
         if (!new_dma_addr_list)
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
index 1f5487f4888c..dc84f7193c2d 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
@@ -117,7 +117,6 @@
 #include <linux/spinlock.h>
 #include <linux/tcp.h>
 #include <linux/if_vlan.h>
-#include <linux/phy.h>
 #include <net/busy_poll.h>
 #include <linux/clk.h>
 #include <linux/if_ether.h>
diff --git a/drivers/net/ethernet/apm/Kconfig b/drivers/net/ethernet/apm/Kconfig
new file mode 100644
index 000000000000..ec63d706d464
--- /dev/null
+++ b/drivers/net/ethernet/apm/Kconfig
@@ -0,0 +1 @@
+source "drivers/net/ethernet/apm/xgene/Kconfig"
diff --git a/drivers/net/ethernet/apm/Makefile b/drivers/net/ethernet/apm/Makefile
new file mode 100644
index 000000000000..65ce32ad1b2c
--- /dev/null
+++ b/drivers/net/ethernet/apm/Makefile
@@ -0,0 +1,5 @@
+#
+# Makefile for APM X-GENE Ethernet driver.
+#
+
+obj-$(CONFIG_NET_XGENE) += xgene/
diff --git a/drivers/net/ethernet/apm/xgene/Kconfig b/drivers/net/ethernet/apm/xgene/Kconfig
new file mode 100644
index 000000000000..616dff6d3f5f
--- /dev/null
+++ b/drivers/net/ethernet/apm/xgene/Kconfig
@@ -0,0 +1,9 @@
+config NET_XGENE
+        tristate "APM X-Gene SoC Ethernet Driver"
+        select PHYLIB
+        help
+          This is the Ethernet driver for the on-chip ethernet interface on the
+          APM X-Gene SoC.
+
+          To compile this driver as a module, choose M here. This module will
+          be called xgene_enet.
diff --git a/drivers/net/ethernet/apm/xgene/Makefile b/drivers/net/ethernet/apm/xgene/Makefile
new file mode 100644
index 000000000000..c643e8a0a0dc
--- /dev/null
+++ b/drivers/net/ethernet/apm/xgene/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for APM X-Gene Ethernet Driver.
+#
+
+xgene-enet-objs := xgene_enet_hw.o xgene_enet_main.o xgene_enet_ethtool.o
+obj-$(CONFIG_NET_XGENE) += xgene-enet.o
diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_ethtool.c b/drivers/net/ethernet/apm/xgene/xgene_enet_ethtool.c
new file mode 100644
index 000000000000..63f2aa54a594
--- /dev/null
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_ethtool.c
@@ -0,0 +1,125 @@
+/* Applied Micro X-Gene SoC Ethernet Driver
+ *
+ * Copyright (c) 2014, Applied Micro Circuits Corporation
+ * Authors: Iyappan Subramanian <isubramanian@apm.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/ethtool.h>
+#include "xgene_enet_main.h"
+
+struct xgene_gstrings_stats {
+        char name[ETH_GSTRING_LEN];
+        int offset;
+};
+
+#define XGENE_STAT(m) { #m, offsetof(struct xgene_enet_pdata, stats.m) }
+
+static const struct xgene_gstrings_stats gstrings_stats[] = {
+        XGENE_STAT(rx_packets),
+        XGENE_STAT(tx_packets),
+        XGENE_STAT(rx_bytes),
+        XGENE_STAT(tx_bytes),
+        XGENE_STAT(rx_errors),
+        XGENE_STAT(tx_errors),
+        XGENE_STAT(rx_length_errors),
+        XGENE_STAT(rx_crc_errors),
+        XGENE_STAT(rx_frame_errors),
+        XGENE_STAT(rx_fifo_errors)
+};
+
+#define XGENE_STATS_LEN         ARRAY_SIZE(gstrings_stats)
+
+static void xgene_get_drvinfo(struct net_device *ndev,
+                              struct ethtool_drvinfo *info)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct platform_device *pdev = pdata->pdev;
+
+        strcpy(info->driver, "xgene_enet");
+        strcpy(info->version, XGENE_DRV_VERSION);
+        snprintf(info->fw_version, ETHTOOL_FWVERS_LEN, "N/A");
+        sprintf(info->bus_info, "%s", pdev->name);
+}
+
+static int xgene_get_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct phy_device *phydev = pdata->phy_dev;
+
+        if (phydev == NULL)
+                return -ENODEV;
+
+        return phy_ethtool_gset(phydev, cmd);
+}
+
+static int xgene_set_settings(struct net_device *ndev, struct ethtool_cmd *cmd)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct phy_device *phydev = pdata->phy_dev;
+
+        if (phydev == NULL)
+                return -ENODEV;
+
+        return phy_ethtool_sset(phydev, cmd);
+}
+
+static void xgene_get_strings(struct net_device *ndev, u32 stringset, u8 *data)
+{
+        int i;
+        u8 *p = data;
+
+        if (stringset != ETH_SS_STATS)
+                return;
+
+        for (i = 0; i < XGENE_STATS_LEN; i++) {
+                memcpy(p, gstrings_stats[i].name, ETH_GSTRING_LEN);
+                p += ETH_GSTRING_LEN;
+        }
+}
+
+static int xgene_get_sset_count(struct net_device *ndev, int sset)
+{
+        if (sset != ETH_SS_STATS)
+                return -EINVAL;
+
+        return XGENE_STATS_LEN;
+}
+
+static void xgene_get_ethtool_stats(struct net_device *ndev,
+                                    struct ethtool_stats *dummy,
+                                    u64 *data)
+{
+        void *pdata = netdev_priv(ndev);
+        int i;
+
+        for (i = 0; i < XGENE_STATS_LEN; i++)
+                *data++ = *(u64 *)(pdata + gstrings_stats[i].offset);
+}
+
+static const struct ethtool_ops xgene_ethtool_ops = {
+        .get_drvinfo = xgene_get_drvinfo,
+        .get_settings = xgene_get_settings,
+        .set_settings = xgene_set_settings,
+        .get_link = ethtool_op_get_link,
+        .get_strings = xgene_get_strings,
+        .get_sset_count = xgene_get_sset_count,
+        .get_ethtool_stats = xgene_get_ethtool_stats
+};
+
+void xgene_enet_set_ethtool_ops(struct net_device *ndev)
+{
+        ndev->ethtool_ops = &xgene_ethtool_ops;
+}
diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_hw.c b/drivers/net/ethernet/apm/xgene/xgene_enet_hw.c
new file mode 100644
index 000000000000..812d8d65159b
--- /dev/null
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_hw.c
@@ -0,0 +1,728 @@
+/* Applied Micro X-Gene SoC Ethernet Driver
+ *
+ * Copyright (c) 2014, Applied Micro Circuits Corporation
+ * Authors: Iyappan Subramanian <isubramanian@apm.com>
+ *          Ravi Patel <rapatel@apm.com>
+ *          Keyur Chudgar <kchudgar@apm.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "xgene_enet_main.h"
+#include "xgene_enet_hw.h"
+
+static void xgene_enet_ring_init(struct xgene_enet_desc_ring *ring)
+{
+        u32 *ring_cfg = ring->state;
+        u64 addr = ring->dma;
+        enum xgene_enet_ring_cfgsize cfgsize = ring->cfgsize;
+
+        ring_cfg[4] |= (1 << SELTHRSH_POS) &
+                        CREATE_MASK(SELTHRSH_POS, SELTHRSH_LEN);
+        ring_cfg[3] |= ACCEPTLERR;
+        ring_cfg[2] |= QCOHERENT;
+
+        addr >>= 8;
+        ring_cfg[2] |= (addr << RINGADDRL_POS) &
+                        CREATE_MASK_ULL(RINGADDRL_POS, RINGADDRL_LEN);
+        addr >>= RINGADDRL_LEN;
+        ring_cfg[3] |= addr & CREATE_MASK_ULL(RINGADDRH_POS, RINGADDRH_LEN);
+        ring_cfg[3] |= ((u32)cfgsize << RINGSIZE_POS) &
+                        CREATE_MASK(RINGSIZE_POS, RINGSIZE_LEN);
+}
+
+static void xgene_enet_ring_set_type(struct xgene_enet_desc_ring *ring)
+{
+        u32 *ring_cfg = ring->state;
+        bool is_bufpool;
+        u32 val;
+
+        is_bufpool = xgene_enet_is_bufpool(ring->id);
+        val = (is_bufpool) ? RING_BUFPOOL : RING_REGULAR;
+        ring_cfg[4] |= (val << RINGTYPE_POS) &
+                        CREATE_MASK(RINGTYPE_POS, RINGTYPE_LEN);
+
+        if (is_bufpool) {
+                ring_cfg[3] |= (BUFPOOL_MODE << RINGMODE_POS) &
+                                CREATE_MASK(RINGMODE_POS, RINGMODE_LEN);
+        }
+}
+
+static void xgene_enet_ring_set_recombbuf(struct xgene_enet_desc_ring *ring)
+{
+        u32 *ring_cfg = ring->state;
+
+        ring_cfg[3] |= RECOMBBUF;
+        ring_cfg[3] |= (0xf << RECOMTIMEOUTL_POS) &
+                        CREATE_MASK(RECOMTIMEOUTL_POS, RECOMTIMEOUTL_LEN);
+        ring_cfg[4] |= 0x7 & CREATE_MASK(RECOMTIMEOUTH_POS, RECOMTIMEOUTH_LEN);
+}
+
+static void xgene_enet_ring_wr32(struct xgene_enet_desc_ring *ring,
+                                 u32 offset, u32 data)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ring->ndev);
+
+        iowrite32(data, pdata->ring_csr_addr + offset);
+}
+
+static void xgene_enet_ring_rd32(struct xgene_enet_desc_ring *ring,
+                                 u32 offset, u32 *data)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ring->ndev);
+
+        *data = ioread32(pdata->ring_csr_addr + offset);
+}
+
+static void xgene_enet_write_ring_state(struct xgene_enet_desc_ring *ring)
+{
+        int i;
+
+        xgene_enet_ring_wr32(ring, CSR_RING_CONFIG, ring->num);
+        for (i = 0; i < NUM_RING_CONFIG; i++) {
+                xgene_enet_ring_wr32(ring, CSR_RING_WR_BASE + (i * 4),
+                                     ring->state[i]);
+        }
+}
+
+static void xgene_enet_clr_ring_state(struct xgene_enet_desc_ring *ring)
+{
+        memset(ring->state, 0, sizeof(u32) * NUM_RING_CONFIG);
+        xgene_enet_write_ring_state(ring);
+}
+
+static void xgene_enet_set_ring_state(struct xgene_enet_desc_ring *ring)
+{
+        xgene_enet_ring_set_type(ring);
+
+        if (xgene_enet_ring_owner(ring->id) == RING_OWNER_ETH0)
+                xgene_enet_ring_set_recombbuf(ring);
+
+        xgene_enet_ring_init(ring);
+        xgene_enet_write_ring_state(ring);
+}
+
+static void xgene_enet_set_ring_id(struct xgene_enet_desc_ring *ring)
+{
+        u32 ring_id_val, ring_id_buf;
+        bool is_bufpool;
+
+        is_bufpool = xgene_enet_is_bufpool(ring->id);
+
+        ring_id_val = ring->id & GENMASK(9, 0);
+        ring_id_val |= OVERWRITE;
+
+        ring_id_buf = (ring->num << 9) & GENMASK(18, 9);
+        ring_id_buf |= PREFETCH_BUF_EN;
+        if (is_bufpool)
+                ring_id_buf |= IS_BUFFER_POOL;
+
+        xgene_enet_ring_wr32(ring, CSR_RING_ID, ring_id_val);
+        xgene_enet_ring_wr32(ring, CSR_RING_ID_BUF, ring_id_buf);
+}
+
+static void xgene_enet_clr_desc_ring_id(struct xgene_enet_desc_ring *ring)
+{
+        u32 ring_id;
+
+        ring_id = ring->id | OVERWRITE;
+        xgene_enet_ring_wr32(ring, CSR_RING_ID, ring_id);
+        xgene_enet_ring_wr32(ring, CSR_RING_ID_BUF, 0);
+}
+
+struct xgene_enet_desc_ring *xgene_enet_setup_ring(
+                                        struct xgene_enet_desc_ring *ring)
+{
+        u32 size = ring->size;
+        u32 i, data;
+        bool is_bufpool;
+
+        xgene_enet_clr_ring_state(ring);
+        xgene_enet_set_ring_state(ring);
+        xgene_enet_set_ring_id(ring);
+
+        ring->slots = xgene_enet_get_numslots(ring->id, size);
+
+        is_bufpool = xgene_enet_is_bufpool(ring->id);
+        if (is_bufpool || xgene_enet_ring_owner(ring->id) != RING_OWNER_CPU)
+                return ring;
+
+        for (i = 0; i < ring->slots; i++)
+                xgene_enet_mark_desc_slot_empty(&ring->raw_desc[i]);
+
+        xgene_enet_ring_rd32(ring, CSR_RING_NE_INT_MODE, &data);
+        data |= BIT(31 - xgene_enet_ring_bufnum(ring->id));
+        xgene_enet_ring_wr32(ring, CSR_RING_NE_INT_MODE, data);
+
+        return ring;
+}
+
+void xgene_enet_clear_ring(struct xgene_enet_desc_ring *ring)
+{
+        u32 data;
+        bool is_bufpool;
+
+        is_bufpool = xgene_enet_is_bufpool(ring->id);
+        if (is_bufpool || xgene_enet_ring_owner(ring->id) != RING_OWNER_CPU)
+                goto out;
+
+        xgene_enet_ring_rd32(ring, CSR_RING_NE_INT_MODE, &data);
+        data &= ~BIT(31 - xgene_enet_ring_bufnum(ring->id));
+        xgene_enet_ring_wr32(ring, CSR_RING_NE_INT_MODE, data);
+
+out:
+        xgene_enet_clr_desc_ring_id(ring);
+        xgene_enet_clr_ring_state(ring);
+}
+
+void xgene_enet_parse_error(struct xgene_enet_desc_ring *ring,
+                            struct xgene_enet_pdata *pdata,
+                            enum xgene_enet_err_code status)
+{
+        struct rtnl_link_stats64 *stats = &pdata->stats;
+
+        switch (status) {
+        case INGRESS_CRC:
+                stats->rx_crc_errors++;
+                break;
+        case INGRESS_CHECKSUM:
+        case INGRESS_CHECKSUM_COMPUTE:
+                stats->rx_errors++;
+                break;
+        case INGRESS_TRUNC_FRAME:
+                stats->rx_frame_errors++;
+                break;
+        case INGRESS_PKT_LEN:
+                stats->rx_length_errors++;
+                break;
+        case INGRESS_PKT_UNDER:
+                stats->rx_frame_errors++;
+                break;
+        case INGRESS_FIFO_OVERRUN:
+                stats->rx_fifo_errors++;
+                break;
+        default:
+                break;
+        }
+}
+
+static void xgene_enet_wr_csr(struct xgene_enet_pdata *pdata,
+                              u32 offset, u32 val)
+{
+        void __iomem *addr = pdata->eth_csr_addr + offset;
+
+        iowrite32(val, addr);
+}
+
+static void xgene_enet_wr_ring_if(struct xgene_enet_pdata *pdata,
+                                  u32 offset, u32 val)
+{
+        void __iomem *addr = pdata->eth_ring_if_addr + offset;
+
+        iowrite32(val, addr);
+}
+
+static void xgene_enet_wr_diag_csr(struct xgene_enet_pdata *pdata,
+                                   u32 offset, u32 val)
+{
+        void __iomem *addr = pdata->eth_diag_csr_addr + offset;
+
+        iowrite32(val, addr);
+}
+
+static void xgene_enet_wr_mcx_csr(struct xgene_enet_pdata *pdata,
+                                  u32 offset, u32 val)
+{
+        void __iomem *addr = pdata->mcx_mac_csr_addr + offset;
+
+        iowrite32(val, addr);
+}
+
+static bool xgene_enet_wr_indirect(void __iomem *addr, void __iomem *wr,
+                                   void __iomem *cmd, void __iomem *cmd_done,
+                                   u32 wr_addr, u32 wr_data)
+{
+        u32 done;
+        u8 wait = 10;
+
+        iowrite32(wr_addr, addr);
+        iowrite32(wr_data, wr);
+        iowrite32(XGENE_ENET_WR_CMD, cmd);
+
+        /* wait for write command to complete */
+        while (!(done = ioread32(cmd_done)) && wait--)
+                udelay(1);
+
+        if (!done)
+                return false;
+
+        iowrite32(0, cmd);
+
+        return true;
+}
+
+static void xgene_enet_wr_mcx_mac(struct xgene_enet_pdata *pdata,
+                                  u32 wr_addr, u32 wr_data)
+{
+        void __iomem *addr, *wr, *cmd, *cmd_done;
+
+        addr = pdata->mcx_mac_addr + MAC_ADDR_REG_OFFSET;
+        wr = pdata->mcx_mac_addr + MAC_WRITE_REG_OFFSET;
+        cmd = pdata->mcx_mac_addr + MAC_COMMAND_REG_OFFSET;
+        cmd_done = pdata->mcx_mac_addr + MAC_COMMAND_DONE_REG_OFFSET;
+
+        if (!xgene_enet_wr_indirect(addr, wr, cmd, cmd_done, wr_addr, wr_data))
+                netdev_err(pdata->ndev, "MCX mac write failed, addr: %04x\n",
+                           wr_addr);
+}
+
+static void xgene_enet_rd_csr(struct xgene_enet_pdata *pdata,
+                              u32 offset, u32 *val)
+{
+        void __iomem *addr = pdata->eth_csr_addr + offset;
+
+        *val = ioread32(addr);
+}
+
+static void xgene_enet_rd_diag_csr(struct xgene_enet_pdata *pdata,
+                                   u32 offset, u32 *val)
+{
+        void __iomem *addr = pdata->eth_diag_csr_addr + offset;
+
+        *val = ioread32(addr);
+}
+
+static void xgene_enet_rd_mcx_csr(struct xgene_enet_pdata *pdata,
+                                  u32 offset, u32 *val)
+{
+        void __iomem *addr = pdata->mcx_mac_csr_addr + offset;
+
+        *val = ioread32(addr);
+}
+
+static bool xgene_enet_rd_indirect(void __iomem *addr, void __iomem *rd,
+                                   void __iomem *cmd, void __iomem *cmd_done,
+                                   u32 rd_addr, u32 *rd_data)
+{
+        u32 done;
+        u8 wait = 10;
+
+        iowrite32(rd_addr, addr);
+        iowrite32(XGENE_ENET_RD_CMD, cmd);
+
+        /* wait for read command to complete */
+        while (!(done = ioread32(cmd_done)) && wait--)
+                udelay(1);
+
+        if (!done)
+                return false;
+
+        *rd_data = ioread32(rd);
+        iowrite32(0, cmd);
+
+        return true;
+}
+
+static void xgene_enet_rd_mcx_mac(struct xgene_enet_pdata *pdata,
+                                  u32 rd_addr, u32 *rd_data)
+{
+        void __iomem *addr, *rd, *cmd, *cmd_done;
+
+        addr = pdata->mcx_mac_addr + MAC_ADDR_REG_OFFSET;
+        rd = pdata->mcx_mac_addr + MAC_READ_REG_OFFSET;
+        cmd = pdata->mcx_mac_addr + MAC_COMMAND_REG_OFFSET;
+        cmd_done = pdata->mcx_mac_addr + MAC_COMMAND_DONE_REG_OFFSET;
+
+        if (!xgene_enet_rd_indirect(addr, rd, cmd, cmd_done, rd_addr, rd_data))
+                netdev_err(pdata->ndev, "MCX mac read failed, addr: %04x\n",
+                           rd_addr);
+}
+
+static int xgene_mii_phy_write(struct xgene_enet_pdata *pdata, int phy_id,
+                               u32 reg, u16 data)
+{
+        u32 addr = 0, wr_data = 0;
+        u32 done;
+        u8 wait = 10;
+
+        PHY_ADDR_SET(&addr, phy_id);
+        REG_ADDR_SET(&addr, reg);
+        xgene_enet_wr_mcx_mac(pdata, MII_MGMT_ADDRESS_ADDR, addr);
+
+        PHY_CONTROL_SET(&wr_data, data);
+        xgene_enet_wr_mcx_mac(pdata, MII_MGMT_CONTROL_ADDR, wr_data);
+        do {
+                usleep_range(5, 10);
+                xgene_enet_rd_mcx_mac(pdata, MII_MGMT_INDICATORS_ADDR, &done);
+        } while ((done & BUSY_MASK) && wait--);
+
+        if (done & BUSY_MASK) {
+                netdev_err(pdata->ndev, "MII_MGMT write failed\n");
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+static int xgene_mii_phy_read(struct xgene_enet_pdata *pdata,
+                              u8 phy_id, u32 reg)
+{
+        u32 addr = 0;
+        u32 data, done;
+        u8 wait = 10;
+
+        PHY_ADDR_SET(&addr, phy_id);
+        REG_ADDR_SET(&addr, reg);
+        xgene_enet_wr_mcx_mac(pdata, MII_MGMT_ADDRESS_ADDR, addr);
+        xgene_enet_wr_mcx_mac(pdata, MII_MGMT_COMMAND_ADDR, READ_CYCLE_MASK);
+        do {
+                usleep_range(5, 10);
+                xgene_enet_rd_mcx_mac(pdata, MII_MGMT_INDICATORS_ADDR, &done);
+        } while ((done & BUSY_MASK) && wait--);
+
+        if (done & BUSY_MASK) {
+                netdev_err(pdata->ndev, "MII_MGMT read failed\n");
+                return -EBUSY;
+        }
+
+        xgene_enet_rd_mcx_mac(pdata, MII_MGMT_STATUS_ADDR, &data);
+        xgene_enet_wr_mcx_mac(pdata, MII_MGMT_COMMAND_ADDR, 0);
+
+        return data;
+}
+
+void xgene_gmac_set_mac_addr(struct xgene_enet_pdata *pdata)
+{
+        u32 addr0, addr1;
+        u8 *dev_addr = pdata->ndev->dev_addr;
+
+        addr0 = (dev_addr[3] << 24) | (dev_addr[2] << 16) |
+                (dev_addr[1] << 8) | dev_addr[0];
+        addr1 = (dev_addr[5] << 24) | (dev_addr[4] << 16);
+        addr1 |= pdata->phy_addr & 0xFFFF;
+
+        xgene_enet_wr_mcx_mac(pdata, STATION_ADDR0_ADDR, addr0);
+        xgene_enet_wr_mcx_mac(pdata, STATION_ADDR1_ADDR, addr1);
+}
+
+static int xgene_enet_ecc_init(struct xgene_enet_pdata *pdata)
+{
+        struct net_device *ndev = pdata->ndev;
+        u32 data;
+        u8 wait = 10;
+
+        xgene_enet_wr_diag_csr(pdata, ENET_CFG_MEM_RAM_SHUTDOWN_ADDR, 0x0);
+        do {
+                usleep_range(100, 110);
+                xgene_enet_rd_diag_csr(pdata, ENET_BLOCK_MEM_RDY_ADDR, &data);
+        } while ((data != 0xffffffff) && wait--);
+
+        if (data != 0xffffffff) {
+                netdev_err(ndev, "Failed to release memory from shutdown\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+void xgene_gmac_reset(struct xgene_enet_pdata *pdata)
+{
+        xgene_enet_wr_mcx_mac(pdata, MAC_CONFIG_1_ADDR, SOFT_RESET1);
+        xgene_enet_wr_mcx_mac(pdata, MAC_CONFIG_1_ADDR, 0);
+}
+
+void xgene_gmac_init(struct xgene_enet_pdata *pdata, int speed)
+{
+        u32 value, mc2;
+        u32 intf_ctl, rgmii;
+        u32 icm0, icm2;
+
+        xgene_gmac_reset(pdata);
+
+        xgene_enet_rd_mcx_csr(pdata, ICM_CONFIG0_REG_0_ADDR, &icm0);
+        xgene_enet_rd_mcx_csr(pdata, ICM_CONFIG2_REG_0_ADDR, &icm2);
+        xgene_enet_rd_mcx_mac(pdata, MAC_CONFIG_2_ADDR, &mc2);
+        xgene_enet_rd_mcx_mac(pdata, INTERFACE_CONTROL_ADDR, &intf_ctl);
+        xgene_enet_rd_csr(pdata, RGMII_REG_0_ADDR, &rgmii);
+
+        switch (speed) {
+        case SPEED_10:
+                ENET_INTERFACE_MODE2_SET(&mc2, 1);
+                CFG_MACMODE_SET(&icm0, 0);
+                CFG_WAITASYNCRD_SET(&icm2, 500);
+                rgmii &= ~CFG_SPEED_1250;
+                break;
+        case SPEED_100:
+                ENET_INTERFACE_MODE2_SET(&mc2, 1);
+                intf_ctl |= ENET_LHD_MODE;
+                CFG_MACMODE_SET(&icm0, 1);
+                CFG_WAITASYNCRD_SET(&icm2, 80);
+                rgmii &= ~CFG_SPEED_1250;
+                break;
+        default:
+                ENET_INTERFACE_MODE2_SET(&mc2, 2);
+                intf_ctl |= ENET_GHD_MODE;
+                CFG_TXCLK_MUXSEL0_SET(&rgmii, 4);
+                xgene_enet_rd_csr(pdata, DEBUG_REG_ADDR, &value);
+                value |= CFG_BYPASS_UNISEC_TX | CFG_BYPASS_UNISEC_RX;
+                xgene_enet_wr_csr(pdata, DEBUG_REG_ADDR, value);
+                break;
+        }
+
+        mc2 |= FULL_DUPLEX2;
+        xgene_enet_wr_mcx_mac(pdata, MAC_CONFIG_2_ADDR, mc2);
+        xgene_enet_wr_mcx_mac(pdata, INTERFACE_CONTROL_ADDR, intf_ctl);
+
+        xgene_gmac_set_mac_addr(pdata);
+
+        /* Adjust MDC clock frequency */
+        xgene_enet_rd_mcx_mac(pdata, MII_MGMT_CONFIG_ADDR, &value);
+        MGMT_CLOCK_SEL_SET(&value, 7);
+        xgene_enet_wr_mcx_mac(pdata, MII_MGMT_CONFIG_ADDR, value);
+
+        /* Enable drop if bufpool not available */
+        xgene_enet_rd_csr(pdata, RSIF_CONFIG_REG_ADDR, &value);
+        value |= CFG_RSIF_FPBUFF_TIMEOUT_EN;
+        xgene_enet_wr_csr(pdata, RSIF_CONFIG_REG_ADDR, value);
+
+        /* Rtype should be copied from FP */
+        xgene_enet_wr_csr(pdata, RSIF_RAM_DBG_REG0_ADDR, 0);
+        xgene_enet_wr_csr(pdata, RGMII_REG_0_ADDR, rgmii);
+
+        /* Rx-Tx traffic resume */
+        xgene_enet_wr_csr(pdata, CFG_LINK_AGGR_RESUME_0_ADDR, TX_PORT0);
+
+        xgene_enet_wr_mcx_csr(pdata, ICM_CONFIG0_REG_0_ADDR, icm0);
+        xgene_enet_wr_mcx_csr(pdata, ICM_CONFIG2_REG_0_ADDR, icm2);
+
+        xgene_enet_rd_mcx_csr(pdata, RX_DV_GATE_REG_0_ADDR, &value);
+        value &= ~TX_DV_GATE_EN0;
+        value &= ~RX_DV_GATE_EN0;
+        value |= RESUME_RX0;
+        xgene_enet_wr_mcx_csr(pdata, RX_DV_GATE_REG_0_ADDR, value);
+
+        xgene_enet_wr_csr(pdata, CFG_BYPASS_ADDR, RESUME_TX);
+}
+
+static void xgene_enet_config_ring_if_assoc(struct xgene_enet_pdata *pdata)
+{
+        u32 val = 0xffffffff;
+
+        xgene_enet_wr_ring_if(pdata, ENET_CFGSSQMIWQASSOC_ADDR, val);
+        xgene_enet_wr_ring_if(pdata, ENET_CFGSSQMIFPQASSOC_ADDR, val);
+        xgene_enet_wr_ring_if(pdata, ENET_CFGSSQMIQMLITEWQASSOC_ADDR, val);
+        xgene_enet_wr_ring_if(pdata, ENET_CFGSSQMIQMLITEFPQASSOC_ADDR, val);
+}
+
+void xgene_enet_cle_bypass(struct xgene_enet_pdata *pdata,
+                           u32 dst_ring_num, u16 bufpool_id)
+{
+        u32 cb;
+        u32 fpsel;
+
+        fpsel = xgene_enet_ring_bufnum(bufpool_id) - 0x20;
+
+        xgene_enet_rd_csr(pdata, CLE_BYPASS_REG0_0_ADDR, &cb);
+        cb |= CFG_CLE_BYPASS_EN0;
+        CFG_CLE_IP_PROTOCOL0_SET(&cb, 3);
+        xgene_enet_wr_csr(pdata, CLE_BYPASS_REG0_0_ADDR, cb);
+
+        xgene_enet_rd_csr(pdata, CLE_BYPASS_REG1_0_ADDR, &cb);
+        CFG_CLE_DSTQID0_SET(&cb, dst_ring_num);
+        CFG_CLE_FPSEL0_SET(&cb, fpsel);
+        xgene_enet_wr_csr(pdata, CLE_BYPASS_REG1_0_ADDR, cb);
+}
+
+void xgene_gmac_rx_enable(struct xgene_enet_pdata *pdata)
+{
+        u32 data;
+
+        xgene_enet_rd_mcx_mac(pdata, MAC_CONFIG_1_ADDR, &data);
+        xgene_enet_wr_mcx_mac(pdata, MAC_CONFIG_1_ADDR, data | RX_EN);
+}
+
+void xgene_gmac_tx_enable(struct xgene_enet_pdata *pdata)
+{
+        u32 data;
+
+        xgene_enet_rd_mcx_mac(pdata, MAC_CONFIG_1_ADDR, &data);
+        xgene_enet_wr_mcx_mac(pdata, MAC_CONFIG_1_ADDR, data | TX_EN);
+}
+
+void xgene_gmac_rx_disable(struct xgene_enet_pdata *pdata)
+{
+        u32 data;
+
+        xgene_enet_rd_mcx_mac(pdata, MAC_CONFIG_1_ADDR, &data);
+        xgene_enet_wr_mcx_mac(pdata, MAC_CONFIG_1_ADDR, data & ~RX_EN);
+}
+
+void xgene_gmac_tx_disable(struct xgene_enet_pdata *pdata)
+{
+        u32 data;
+
+        xgene_enet_rd_mcx_mac(pdata, MAC_CONFIG_1_ADDR, &data);
+        xgene_enet_wr_mcx_mac(pdata, MAC_CONFIG_1_ADDR, data & ~TX_EN);
+}
+
+void xgene_enet_reset(struct xgene_enet_pdata *pdata)
+{
+        u32 val;
+
+        clk_prepare_enable(pdata->clk);
+        clk_disable_unprepare(pdata->clk);
+        clk_prepare_enable(pdata->clk);
+        xgene_enet_ecc_init(pdata);
+        xgene_enet_config_ring_if_assoc(pdata);
+
+        /* Enable auto-incr for scanning */
+        xgene_enet_rd_mcx_mac(pdata, MII_MGMT_CONFIG_ADDR, &val);
+        val |= SCAN_AUTO_INCR;
+        MGMT_CLOCK_SEL_SET(&val, 1);
+        xgene_enet_wr_mcx_mac(pdata, MII_MGMT_CONFIG_ADDR, val);
+}
+
+void xgene_gport_shutdown(struct xgene_enet_pdata *pdata)
+{
+        clk_disable_unprepare(pdata->clk);
+}
+
+static int xgene_enet_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
+{
+        struct xgene_enet_pdata *pdata = bus->priv;
+        u32 val;
+
+        val = xgene_mii_phy_read(pdata, mii_id, regnum);
+        netdev_dbg(pdata->ndev, "mdio_rd: bus=%d reg=%d val=%x\n",
+                   mii_id, regnum, val);
+
+        return val;
+}
+
+static int xgene_enet_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
+                                 u16 val)
+{
+        struct xgene_enet_pdata *pdata = bus->priv;
+
+        netdev_dbg(pdata->ndev, "mdio_wr: bus=%d reg=%d val=%x\n",
+                   mii_id, regnum, val);
+        return xgene_mii_phy_write(pdata, mii_id, regnum, val);
+}
+
+static void xgene_enet_adjust_link(struct net_device *ndev)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct phy_device *phydev = pdata->phy_dev;
+
+        if (phydev->link) {
+                if (pdata->phy_speed != phydev->speed) {
+                        xgene_gmac_init(pdata, phydev->speed);
+                        xgene_gmac_rx_enable(pdata);
+                        xgene_gmac_tx_enable(pdata);
+                        pdata->phy_speed = phydev->speed;
+                        phy_print_status(phydev);
+                }
+        } else {
+                xgene_gmac_rx_disable(pdata);
+                xgene_gmac_tx_disable(pdata);
+                pdata->phy_speed = SPEED_UNKNOWN;
+                phy_print_status(phydev);
+        }
+}
+
+static int xgene_enet_phy_connect(struct net_device *ndev)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct device_node *phy_np;
+        struct phy_device *phy_dev;
+        struct device *dev = &pdata->pdev->dev;
+
+        phy_np = of_parse_phandle(dev->of_node, "phy-handle", 0);
+        if (!phy_np) {
+                netdev_dbg(ndev, "No phy-handle found\n");
+                return -ENODEV;
+        }
+
+        phy_dev = of_phy_connect(ndev, phy_np, &xgene_enet_adjust_link,
+                                 0, pdata->phy_mode);
+        if (!phy_dev) {
+                netdev_err(ndev, "Could not connect to PHY\n");
+                return  -ENODEV;
+        }
+
+        pdata->phy_speed = SPEED_UNKNOWN;
+        phy_dev->supported &= ~SUPPORTED_10baseT_Half &
+                              ~SUPPORTED_100baseT_Half &
+                              ~SUPPORTED_1000baseT_Half;
+        phy_dev->advertising = phy_dev->supported;
+        pdata->phy_dev = phy_dev;
+
+        return 0;
+}
+
+int xgene_enet_mdio_config(struct xgene_enet_pdata *pdata)
+{
+        struct net_device *ndev = pdata->ndev;
+        struct device *dev = &pdata->pdev->dev;
+        struct device_node *child_np;
+        struct device_node *mdio_np = NULL;
+        struct mii_bus *mdio_bus;
+        int ret;
+
+        for_each_child_of_node(dev->of_node, child_np) {
+                if (of_device_is_compatible(child_np, "apm,xgene-mdio")) {
+                        mdio_np = child_np;
+                        break;
+                }
+        }
+
+        if (!mdio_np) {
+                netdev_dbg(ndev, "No mdio node in the dts\n");
+                return -ENXIO;
+        }
+
+        mdio_bus = mdiobus_alloc();
+        if (!mdio_bus)
+                return -ENOMEM;
+
+        mdio_bus->name = "APM X-Gene MDIO bus";
+        mdio_bus->read = xgene_enet_mdio_read;
+        mdio_bus->write = xgene_enet_mdio_write;
+        snprintf(mdio_bus->id, MII_BUS_ID_SIZE, "%s-%s", "xgene-mii",
+                 ndev->name);
+
+        mdio_bus->priv = pdata;
+        mdio_bus->parent = &ndev->dev;
+
+        ret = of_mdiobus_register(mdio_bus, mdio_np);
+        if (ret) {
+                netdev_err(ndev, "Failed to register MDIO bus\n");
+                mdiobus_free(mdio_bus);
+                return ret;
+        }
+        pdata->mdio_bus = mdio_bus;
+
+        ret = xgene_enet_phy_connect(ndev);
+        if (ret)
+                xgene_enet_mdio_remove(pdata);
+
+        return ret;
+}
+
+void xgene_enet_mdio_remove(struct xgene_enet_pdata *pdata)
+{
+        mdiobus_unregister(pdata->mdio_bus);
+        mdiobus_free(pdata->mdio_bus);
+        pdata->mdio_bus = NULL;
+}
diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_hw.h b/drivers/net/ethernet/apm/xgene/xgene_enet_hw.h
new file mode 100644
index 000000000000..371e7a5b2507
--- /dev/null
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_hw.h
@@ -0,0 +1,337 @@
+/* Applied Micro X-Gene SoC Ethernet Driver
+ *
+ * Copyright (c) 2014, Applied Micro Circuits Corporation
+ * Authors: Iyappan Subramanian <isubramanian@apm.com>
+ *          Ravi Patel <rapatel@apm.com>
+ *          Keyur Chudgar <kchudgar@apm.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __XGENE_ENET_HW_H__
+#define __XGENE_ENET_HW_H__
+
+#include "xgene_enet_main.h"
+
+struct xgene_enet_pdata;
+struct xgene_enet_stats;
+
+/* clears and then set bits */
+static inline void xgene_set_bits(u32 *dst, u32 val, u32 start, u32 len)
+{
+        u32 end = start + len - 1;
+        u32 mask = GENMASK(end, start);
+
+        *dst &= ~mask;
+        *dst |= (val << start) & mask;
+}
+
+static inline u32 xgene_get_bits(u32 val, u32 start, u32 end)
+{
+        return (val & GENMASK(end, start)) >> start;
+}
+
+#define CSR_RING_ID             0x0008
+#define OVERWRITE               BIT(31)
+#define IS_BUFFER_POOL          BIT(20)
+#define PREFETCH_BUF_EN         BIT(21)
+#define CSR_RING_ID_BUF         0x000c
+#define CSR_RING_NE_INT_MODE    0x017c
+#define CSR_RING_CONFIG         0x006c
+#define CSR_RING_WR_BASE        0x0070
+#define NUM_RING_CONFIG         5
+#define BUFPOOL_MODE            3
+#define RM3                     3
+#define INC_DEC_CMD_ADDR        0x002c
+#define UDP_HDR_SIZE            2
+#define BUF_LEN_CODE_2K         0x5000
+
+#define CREATE_MASK(pos, len)           GENMASK((pos)+(len)-1, (pos))
+#define CREATE_MASK_ULL(pos, len)       GENMASK_ULL((pos)+(len)-1, (pos))
+
+/* Empty slot soft signature */
+#define EMPTY_SLOT_INDEX        1
+#define EMPTY_SLOT              ~0ULL
+
+#define WORK_DESC_SIZE          32
+#define BUFPOOL_DESC_SIZE       16
+
+#define RING_OWNER_MASK         GENMASK(9, 6)
+#define RING_BUFNUM_MASK        GENMASK(5, 0)
+
+#define SELTHRSH_POS            3
+#define SELTHRSH_LEN            3
+#define RINGADDRL_POS           5
+#define RINGADDRL_LEN           27
+#define RINGADDRH_POS           0
+#define RINGADDRH_LEN           6
+#define RINGSIZE_POS            23
+#define RINGSIZE_LEN            3
+#define RINGTYPE_POS            19
+#define RINGTYPE_LEN            2
+#define RINGMODE_POS            20
+#define RINGMODE_LEN            3
+#define RECOMTIMEOUTL_POS       28
+#define RECOMTIMEOUTL_LEN       3
+#define RECOMTIMEOUTH_POS       0
+#define RECOMTIMEOUTH_LEN       2
+#define NUMMSGSINQ_POS          1
+#define NUMMSGSINQ_LEN          16
+#define ACCEPTLERR              BIT(19)
+#define QCOHERENT               BIT(4)
+#define RECOMBBUF               BIT(27)
+
+#define BLOCK_ETH_CSR_OFFSET            0x2000
+#define BLOCK_ETH_RING_IF_OFFSET        0x9000
+#define BLOCK_ETH_CLKRST_CSR_OFFSET     0xC000
+#define BLOCK_ETH_DIAG_CSR_OFFSET       0xD000
+
+#define BLOCK_ETH_MAC_OFFSET            0x0000
+#define BLOCK_ETH_STATS_OFFSET          0x0014
+#define BLOCK_ETH_MAC_CSR_OFFSET        0x2800
+
+#define MAC_ADDR_REG_OFFSET             0x00
+#define MAC_COMMAND_REG_OFFSET          0x04
+#define MAC_WRITE_REG_OFFSET            0x08
+#define MAC_READ_REG_OFFSET             0x0c
+#define MAC_COMMAND_DONE_REG_OFFSET     0x10
+
+#define STAT_ADDR_REG_OFFSET            0x00
+#define STAT_COMMAND_REG_OFFSET         0x04
+#define STAT_WRITE_REG_OFFSET           0x08
+#define STAT_READ_REG_OFFSET            0x0c
+#define STAT_COMMAND_DONE_REG_OFFSET    0x10
+
+#define MII_MGMT_CONFIG_ADDR            0x20
+#define MII_MGMT_COMMAND_ADDR           0x24
+#define MII_MGMT_ADDRESS_ADDR           0x28
+#define MII_MGMT_CONTROL_ADDR           0x2c
+#define MII_MGMT_STATUS_ADDR            0x30
+#define MII_MGMT_INDICATORS_ADDR        0x34
+
+#define BUSY_MASK                       BIT(0)
+#define READ_CYCLE_MASK                 BIT(0)
+#define PHY_CONTROL_SET(dst, val)       xgene_set_bits(dst, val, 0, 16)
+
+#define ENET_SPARE_CFG_REG_ADDR         0x0750
+#define RSIF_CONFIG_REG_ADDR            0x0010
+#define RSIF_RAM_DBG_REG0_ADDR          0x0048
+#define RGMII_REG_0_ADDR                0x07e0
+#define CFG_LINK_AGGR_RESUME_0_ADDR     0x07c8
+#define DEBUG_REG_ADDR                  0x0700
+#define CFG_BYPASS_ADDR                 0x0294
+#define CLE_BYPASS_REG0_0_ADDR          0x0490
+#define CLE_BYPASS_REG1_0_ADDR          0x0494
+#define CFG_RSIF_FPBUFF_TIMEOUT_EN      BIT(31)
+#define RESUME_TX                       BIT(0)
+#define CFG_SPEED_1250                  BIT(24)
+#define TX_PORT0                        BIT(0)
+#define CFG_BYPASS_UNISEC_TX            BIT(2)
+#define CFG_BYPASS_UNISEC_RX            BIT(1)
+#define CFG_CLE_BYPASS_EN0              BIT(31)
+#define CFG_TXCLK_MUXSEL0_SET(dst, val) xgene_set_bits(dst, val, 29, 3)
+
+#define CFG_CLE_IP_PROTOCOL0_SET(dst, val)      xgene_set_bits(dst, val, 16, 2)
+#define CFG_CLE_DSTQID0_SET(dst, val)           xgene_set_bits(dst, val, 0, 12)
+#define CFG_CLE_FPSEL0_SET(dst, val)            xgene_set_bits(dst, val, 16, 4)
+#define CFG_MACMODE_SET(dst, val)               xgene_set_bits(dst, val, 18, 2)
+#define CFG_WAITASYNCRD_SET(dst, val)           xgene_set_bits(dst, val, 0, 16)
+#define ICM_CONFIG0_REG_0_ADDR          0x0400
+#define ICM_CONFIG2_REG_0_ADDR          0x0410
+#define RX_DV_GATE_REG_0_ADDR           0x05fc
+#define TX_DV_GATE_EN0                  BIT(2)
+#define RX_DV_GATE_EN0                  BIT(1)
+#define RESUME_RX0                      BIT(0)
+#define ENET_CFGSSQMIWQASSOC_ADDR               0xe0
+#define ENET_CFGSSQMIFPQASSOC_ADDR              0xdc
+#define ENET_CFGSSQMIQMLITEFPQASSOC_ADDR        0xf0
+#define ENET_CFGSSQMIQMLITEWQASSOC_ADDR         0xf4
+#define ENET_CFG_MEM_RAM_SHUTDOWN_ADDR          0x70
+#define ENET_BLOCK_MEM_RDY_ADDR                 0x74
+#define MAC_CONFIG_1_ADDR                       0x00
+#define MAC_CONFIG_2_ADDR                       0x04
+#define MAX_FRAME_LEN_ADDR                      0x10
+#define INTERFACE_CONTROL_ADDR                  0x38
+#define STATION_ADDR0_ADDR                      0x40
+#define STATION_ADDR1_ADDR                      0x44
+#define PHY_ADDR_SET(dst, val)                  xgene_set_bits(dst, val, 8, 5)
+#define REG_ADDR_SET(dst, val)                  xgene_set_bits(dst, val, 0, 5)
+#define ENET_INTERFACE_MODE2_SET(dst, val)      xgene_set_bits(dst, val, 8, 2)
+#define MGMT_CLOCK_SEL_SET(dst, val)            xgene_set_bits(dst, val, 0, 3)
+#define SOFT_RESET1                     BIT(31)
+#define TX_EN                           BIT(0)
+#define RX_EN                           BIT(2)
+#define ENET_LHD_MODE                   BIT(25)
+#define ENET_GHD_MODE                   BIT(26)
+#define FULL_DUPLEX2                    BIT(0)
+#define SCAN_AUTO_INCR                  BIT(5)
+#define TBYT_ADDR                       0x38
+#define TPKT_ADDR                       0x39
+#define TDRP_ADDR                       0x45
+#define TFCS_ADDR                       0x47
+#define TUND_ADDR                       0x4a
+
+#define TSO_IPPROTO_TCP                 1
+#define FULL_DUPLEX                     2
+
+#define USERINFO_POS                    0
+#define USERINFO_LEN                    32
+#define FPQNUM_POS                      32
+#define FPQNUM_LEN                      12
+#define LERR_POS                        60
+#define LERR_LEN                        3
+#define STASH_POS                       52
+#define STASH_LEN                       2
+#define BUFDATALEN_POS                  48
+#define BUFDATALEN_LEN                  12
+#define DATAADDR_POS                    0
+#define DATAADDR_LEN                    42
+#define COHERENT_POS                    63
+#define HENQNUM_POS                     48
+#define HENQNUM_LEN                     12
+#define TYPESEL_POS                     44
+#define TYPESEL_LEN                     4
+#define ETHHDR_POS                      12
+#define ETHHDR_LEN                      8
+#define IC_POS                          35      /* Insert CRC */
+#define TCPHDR_POS                      0
+#define TCPHDR_LEN                      6
+#define IPHDR_POS                       6
+#define IPHDR_LEN                       6
+#define EC_POS                          22      /* Enable checksum */
+#define EC_LEN                          1
+#define IS_POS                          24      /* IP protocol select */
+#define IS_LEN                          1
+#define TYPE_ETH_WORK_MESSAGE_POS       44
+
+struct xgene_enet_raw_desc {
+        __le64 m0;
+        __le64 m1;
+        __le64 m2;
+        __le64 m3;
+};
+
+struct xgene_enet_raw_desc16 {
+        __le64 m0;
+        __le64 m1;
+};
+
+static inline void xgene_enet_mark_desc_slot_empty(void *desc_slot_ptr)
+{
+        __le64 *desc_slot = desc_slot_ptr;
+
+        desc_slot[EMPTY_SLOT_INDEX] = cpu_to_le64(EMPTY_SLOT);
+}
+
+static inline bool xgene_enet_is_desc_slot_empty(void *desc_slot_ptr)
+{
+        __le64 *desc_slot = desc_slot_ptr;
+
+        return (desc_slot[EMPTY_SLOT_INDEX] == cpu_to_le64(EMPTY_SLOT));
+}
+
+enum xgene_enet_ring_cfgsize {
+        RING_CFGSIZE_512B,
+        RING_CFGSIZE_2KB,
+        RING_CFGSIZE_16KB,
+        RING_CFGSIZE_64KB,
+        RING_CFGSIZE_512KB,
+        RING_CFGSIZE_INVALID
+};
+
+enum xgene_enet_ring_type {
+        RING_DISABLED,
+        RING_REGULAR,
+        RING_BUFPOOL
+};
+
+enum xgene_ring_owner {
+        RING_OWNER_ETH0,
+        RING_OWNER_CPU = 15,
+        RING_OWNER_INVALID
+};
+
+enum xgene_enet_ring_bufnum {
+        RING_BUFNUM_REGULAR = 0x0,
+        RING_BUFNUM_BUFPOOL = 0x20,
+        RING_BUFNUM_INVALID
+};
+
+enum xgene_enet_cmd {
+        XGENE_ENET_WR_CMD = BIT(31),
+        XGENE_ENET_RD_CMD = BIT(30)
+};
+
+enum xgene_enet_err_code {
+        HBF_READ_DATA = 3,
+        HBF_LL_READ = 4,
+        BAD_WORK_MSG = 6,
+        BUFPOOL_TIMEOUT = 15,
+        INGRESS_CRC = 16,
+        INGRESS_CHECKSUM = 17,
+        INGRESS_TRUNC_FRAME = 18,
+        INGRESS_PKT_LEN = 19,
+        INGRESS_PKT_UNDER = 20,
+        INGRESS_FIFO_OVERRUN = 21,
+        INGRESS_CHECKSUM_COMPUTE = 26,
+        ERR_CODE_INVALID
+};
+
+static inline enum xgene_ring_owner xgene_enet_ring_owner(u16 id)
+{
+        return (id & RING_OWNER_MASK) >> 6;
+}
+
+static inline u8 xgene_enet_ring_bufnum(u16 id)
+{
+        return id & RING_BUFNUM_MASK;
+}
+
+static inline bool xgene_enet_is_bufpool(u16 id)
+{
+        return ((id & RING_BUFNUM_MASK) >= 0x20) ? true : false;
+}
+
+static inline u16 xgene_enet_get_numslots(u16 id, u32 size)
+{
+        bool is_bufpool = xgene_enet_is_bufpool(id);
+
+        return (is_bufpool) ? size / BUFPOOL_DESC_SIZE :
+                      size / WORK_DESC_SIZE;
+}
+
+struct xgene_enet_desc_ring *xgene_enet_setup_ring(
+                struct xgene_enet_desc_ring *ring);
+void xgene_enet_clear_ring(struct xgene_enet_desc_ring *ring);
+void xgene_enet_parse_error(struct xgene_enet_desc_ring *ring,
+                            struct xgene_enet_pdata *pdata,
+                            enum xgene_enet_err_code status);
+
+void xgene_enet_reset(struct xgene_enet_pdata *priv);
+void xgene_gmac_reset(struct xgene_enet_pdata *priv);
+void xgene_gmac_init(struct xgene_enet_pdata *priv, int speed);
+void xgene_gmac_tx_enable(struct xgene_enet_pdata *priv);
+void xgene_gmac_rx_enable(struct xgene_enet_pdata *priv);
+void xgene_gmac_tx_disable(struct xgene_enet_pdata *priv);
+void xgene_gmac_rx_disable(struct xgene_enet_pdata *priv);
+void xgene_gmac_set_mac_addr(struct xgene_enet_pdata *pdata);
+void xgene_enet_cle_bypass(struct xgene_enet_pdata *pdata,
+                           u32 dst_ring_num, u16 bufpool_id);
+void xgene_gport_shutdown(struct xgene_enet_pdata *priv);
+void xgene_gmac_get_tx_stats(struct xgene_enet_pdata *pdata);
+
+int xgene_enet_mdio_config(struct xgene_enet_pdata *pdata);
+void xgene_enet_mdio_remove(struct xgene_enet_pdata *pdata);
+
+#endif /* __XGENE_ENET_HW_H__ */
diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_main.c b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
new file mode 100644
index 000000000000..e1a8f4e19983
--- /dev/null
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_main.c
@@ -0,0 +1,954 @@
+/* Applied Micro X-Gene SoC Ethernet Driver
+ *
+ * Copyright (c) 2014, Applied Micro Circuits Corporation
+ * Authors: Iyappan Subramanian <isubramanian@apm.com>
+ *          Ravi Patel <rapatel@apm.com>
+ *          Keyur Chudgar <kchudgar@apm.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "xgene_enet_main.h"
+#include "xgene_enet_hw.h"
+
+static void xgene_enet_init_bufpool(struct xgene_enet_desc_ring *buf_pool)
+{
+        struct xgene_enet_raw_desc16 *raw_desc;
+        int i;
+
+        for (i = 0; i < buf_pool->slots; i++) {
+                raw_desc = &buf_pool->raw_desc16[i];
+
+                /* Hardware expects descriptor in little endian format */
+                raw_desc->m0 = cpu_to_le64(i |
+                                SET_VAL(FPQNUM, buf_pool->dst_ring_num) |
+                                SET_VAL(STASH, 3));
+        }
+}
+
+static int xgene_enet_refill_bufpool(struct xgene_enet_desc_ring *buf_pool,
+                                     u32 nbuf)
+{
+        struct sk_buff *skb;
+        struct xgene_enet_raw_desc16 *raw_desc;
+        struct net_device *ndev;
+        struct device *dev;
+        dma_addr_t dma_addr;
+        u32 tail = buf_pool->tail;
+        u32 slots = buf_pool->slots - 1;
+        u16 bufdatalen, len;
+        int i;
+
+        ndev = buf_pool->ndev;
+        dev = ndev_to_dev(buf_pool->ndev);
+        bufdatalen = BUF_LEN_CODE_2K | (SKB_BUFFER_SIZE & GENMASK(11, 0));
+        len = XGENE_ENET_MAX_MTU;
+
+        for (i = 0; i < nbuf; i++) {
+                raw_desc = &buf_pool->raw_desc16[tail];
+
+                skb = netdev_alloc_skb_ip_align(ndev, len);
+                if (unlikely(!skb))
+                        return -ENOMEM;
+                buf_pool->rx_skb[tail] = skb;
+
+                dma_addr = dma_map_single(dev, skb->data, len, DMA_FROM_DEVICE);
+                if (dma_mapping_error(dev, dma_addr)) {
+                        netdev_err(ndev, "DMA mapping error\n");
+                        dev_kfree_skb_any(skb);
+                        return -EINVAL;
+                }
+
+                raw_desc->m1 = cpu_to_le64(SET_VAL(DATAADDR, dma_addr) |
+                                           SET_VAL(BUFDATALEN, bufdatalen) |
+                                           SET_BIT(COHERENT));
+                tail = (tail + 1) & slots;
+        }
+
+        iowrite32(nbuf, buf_pool->cmd);
+        buf_pool->tail = tail;
+
+        return 0;
+}
+
+static u16 xgene_enet_dst_ring_num(struct xgene_enet_desc_ring *ring)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ring->ndev);
+
+        return ((u16)pdata->rm << 10) | ring->num;
+}
+
+static u8 xgene_enet_hdr_len(const void *data)
+{
+        const struct ethhdr *eth = data;
+
+        return (eth->h_proto == htons(ETH_P_8021Q)) ? VLAN_ETH_HLEN : ETH_HLEN;
+}
+
+static u32 xgene_enet_ring_len(struct xgene_enet_desc_ring *ring)
+{
+        u32 __iomem *cmd_base = ring->cmd_base;
+        u32 ring_state, num_msgs;
+
+        ring_state = ioread32(&cmd_base[1]);
+        num_msgs = ring_state & CREATE_MASK(NUMMSGSINQ_POS, NUMMSGSINQ_LEN);
+
+        return num_msgs >> NUMMSGSINQ_POS;
+}
+
+static void xgene_enet_delete_bufpool(struct xgene_enet_desc_ring *buf_pool)
+{
+        struct xgene_enet_raw_desc16 *raw_desc;
+        u32 slots = buf_pool->slots - 1;
+        u32 tail = buf_pool->tail;
+        u32 userinfo;
+        int i, len;
+
+        len = xgene_enet_ring_len(buf_pool);
+        for (i = 0; i < len; i++) {
+                tail = (tail - 1) & slots;
+                raw_desc = &buf_pool->raw_desc16[tail];
+
+                /* Hardware stores descriptor in little endian format */
+                userinfo = GET_VAL(USERINFO, le64_to_cpu(raw_desc->m0));
+                dev_kfree_skb_any(buf_pool->rx_skb[userinfo]);
+        }
+
+        iowrite32(-len, buf_pool->cmd);
+        buf_pool->tail = tail;
+}
+
+static irqreturn_t xgene_enet_rx_irq(const int irq, void *data)
+{
+        struct xgene_enet_desc_ring *rx_ring = data;
+
+        if (napi_schedule_prep(&rx_ring->napi)) {
+                disable_irq_nosync(irq);
+                __napi_schedule(&rx_ring->napi);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int xgene_enet_tx_completion(struct xgene_enet_desc_ring *cp_ring,
+                                    struct xgene_enet_raw_desc *raw_desc)
+{
+        struct sk_buff *skb;
+        struct device *dev;
+        u16 skb_index;
+        u8 status;
+        int ret = 0;
+
+        skb_index = GET_VAL(USERINFO, le64_to_cpu(raw_desc->m0));
+        skb = cp_ring->cp_skb[skb_index];
+
+        dev = ndev_to_dev(cp_ring->ndev);
+        dma_unmap_single(dev, GET_VAL(DATAADDR, le64_to_cpu(raw_desc->m1)),
+                         GET_VAL(BUFDATALEN, le64_to_cpu(raw_desc->m1)),
+                         DMA_TO_DEVICE);
+
+        /* Checking for error */
+        status = GET_VAL(LERR, le64_to_cpu(raw_desc->m0));
+        if (unlikely(status > 2)) {
+                xgene_enet_parse_error(cp_ring, netdev_priv(cp_ring->ndev),
+                                       status);
+                ret = -EIO;
+        }
+
+        if (likely(skb)) {
+                dev_kfree_skb_any(skb);
+        } else {
+                netdev_err(cp_ring->ndev, "completion skb is NULL\n");
+                ret = -EIO;
+        }
+
+        return ret;
+}
+
+static u64 xgene_enet_work_msg(struct sk_buff *skb)
+{
+        struct iphdr *iph;
+        u8 l3hlen, l4hlen = 0;
+        u8 csum_enable = 0;
+        u8 proto = 0;
+        u8 ethhdr;
+        u64 hopinfo;
+
+        if (unlikely(skb->protocol != htons(ETH_P_IP)) &&
+            unlikely(skb->protocol != htons(ETH_P_8021Q)))
+                goto out;
+
+        if (unlikely(!(skb->dev->features & NETIF_F_IP_CSUM)))
+                goto out;
+
+        iph = ip_hdr(skb);
+        if (unlikely(ip_is_fragment(iph)))
+                goto out;
+
+        if (likely(iph->protocol == IPPROTO_TCP)) {
+                l4hlen = tcp_hdrlen(skb) >> 2;
+                csum_enable = 1;
+                proto = TSO_IPPROTO_TCP;
+        } else if (iph->protocol == IPPROTO_UDP) {
+                l4hlen = UDP_HDR_SIZE;
+                csum_enable = 1;
+        }
+out:
+        l3hlen = ip_hdrlen(skb) >> 2;
+        ethhdr = xgene_enet_hdr_len(skb->data);
+        hopinfo = SET_VAL(TCPHDR, l4hlen) |
+                  SET_VAL(IPHDR, l3hlen) |
+                  SET_VAL(ETHHDR, ethhdr) |
+                  SET_VAL(EC, csum_enable) |
+                  SET_VAL(IS, proto) |
+                  SET_BIT(IC) |
+                  SET_BIT(TYPE_ETH_WORK_MESSAGE);
+
+        return hopinfo;
+}
+
+static int xgene_enet_setup_tx_desc(struct xgene_enet_desc_ring *tx_ring,
+                                    struct sk_buff *skb)
+{
+        struct device *dev = ndev_to_dev(tx_ring->ndev);
+        struct xgene_enet_raw_desc *raw_desc;
+        dma_addr_t dma_addr;
+        u16 tail = tx_ring->tail;
+        u64 hopinfo;
+
+        raw_desc = &tx_ring->raw_desc[tail];
+        memset(raw_desc, 0, sizeof(struct xgene_enet_raw_desc));
+
+        dma_addr = dma_map_single(dev, skb->data, skb->len, DMA_TO_DEVICE);
+        if (dma_mapping_error(dev, dma_addr)) {
+                netdev_err(tx_ring->ndev, "DMA mapping error\n");
+                return -EINVAL;
+        }
+
+        /* Hardware expects descriptor in little endian format */
+        raw_desc->m0 = cpu_to_le64(tail);
+        raw_desc->m1 = cpu_to_le64(SET_VAL(DATAADDR, dma_addr) |
+                                   SET_VAL(BUFDATALEN, skb->len) |
+                                   SET_BIT(COHERENT));
+        hopinfo = xgene_enet_work_msg(skb);
+        raw_desc->m3 = cpu_to_le64(SET_VAL(HENQNUM, tx_ring->dst_ring_num) |
+                                   hopinfo);
+        tx_ring->cp_ring->cp_skb[tail] = skb;
+
+        return 0;
+}
+
+static netdev_tx_t xgene_enet_start_xmit(struct sk_buff *skb,
+                                         struct net_device *ndev)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct xgene_enet_desc_ring *tx_ring = pdata->tx_ring;
+        struct xgene_enet_desc_ring *cp_ring = tx_ring->cp_ring;
+        u32 tx_level, cq_level;
+
+        tx_level = xgene_enet_ring_len(tx_ring);
+        cq_level = xgene_enet_ring_len(cp_ring);
+        if (unlikely(tx_level > pdata->tx_qcnt_hi ||
+                     cq_level > pdata->cp_qcnt_hi)) {
+                netif_stop_queue(ndev);
+                return NETDEV_TX_BUSY;
+        }
+
+        if (xgene_enet_setup_tx_desc(tx_ring, skb)) {
+                dev_kfree_skb_any(skb);
+                return NETDEV_TX_OK;
+        }
+
+        iowrite32(1, tx_ring->cmd);
+        skb_tx_timestamp(skb);
+        tx_ring->tail = (tx_ring->tail + 1) & (tx_ring->slots - 1);
+
+        pdata->stats.tx_packets++;
+        pdata->stats.tx_bytes += skb->len;
+
+        return NETDEV_TX_OK;
+}
+
+static void xgene_enet_skip_csum(struct sk_buff *skb)
+{
+        struct iphdr *iph = ip_hdr(skb);
+
+        if (!ip_is_fragment(iph) ||
+            (iph->protocol != IPPROTO_TCP && iph->protocol != IPPROTO_UDP)) {
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
+        }
+}
+
+static int xgene_enet_rx_frame(struct xgene_enet_desc_ring *rx_ring,
+                               struct xgene_enet_raw_desc *raw_desc)
+{
+        struct net_device *ndev;
+        struct xgene_enet_pdata *pdata;
+        struct device *dev;
+        struct xgene_enet_desc_ring *buf_pool;
+        u32 datalen, skb_index;
+        struct sk_buff *skb;
+        u8 status;
+        int ret = 0;
+
+        ndev = rx_ring->ndev;
+        pdata = netdev_priv(ndev);
+        dev = ndev_to_dev(rx_ring->ndev);
+        buf_pool = rx_ring->buf_pool;
+
+        dma_unmap_single(dev, GET_VAL(DATAADDR, le64_to_cpu(raw_desc->m1)),
+                         XGENE_ENET_MAX_MTU, DMA_FROM_DEVICE);
+        skb_index = GET_VAL(USERINFO, le64_to_cpu(raw_desc->m0));
+        skb = buf_pool->rx_skb[skb_index];
+
+        /* checking for error */
+        status = GET_VAL(LERR, le64_to_cpu(raw_desc->m0));
+        if (unlikely(status > 2)) {
+                dev_kfree_skb_any(skb);
+                xgene_enet_parse_error(rx_ring, netdev_priv(rx_ring->ndev),
+                                       status);
+                pdata->stats.rx_dropped++;
+                ret = -EIO;
+                goto out;
+        }
+
+        /* strip off CRC as HW isn't doing this */
+        datalen = GET_VAL(BUFDATALEN, le64_to_cpu(raw_desc->m1));
+        datalen -= 4;
+        prefetch(skb->data - NET_IP_ALIGN);
+        skb_put(skb, datalen);
+
+        skb_checksum_none_assert(skb);
+        skb->protocol = eth_type_trans(skb, ndev);
+        if (likely((ndev->features & NETIF_F_IP_CSUM) &&
+                   skb->protocol == htons(ETH_P_IP))) {
+                xgene_enet_skip_csum(skb);
+        }
+
+        pdata->stats.rx_packets++;
+        pdata->stats.rx_bytes += datalen;
+        napi_gro_receive(&rx_ring->napi, skb);
+out:
+        if (--rx_ring->nbufpool == 0) {
+                ret = xgene_enet_refill_bufpool(buf_pool, NUM_BUFPOOL);
+                rx_ring->nbufpool = NUM_BUFPOOL;
+        }
+
+        return ret;
+}
+
+static bool is_rx_desc(struct xgene_enet_raw_desc *raw_desc)
+{
+        return GET_VAL(FPQNUM, le64_to_cpu(raw_desc->m0)) ? true : false;
+}
+
+static int xgene_enet_process_ring(struct xgene_enet_desc_ring *ring,
+                                   int budget)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ring->ndev);
+        struct xgene_enet_raw_desc *raw_desc;
+        u16 head = ring->head;
+        u16 slots = ring->slots - 1;
+        int ret, count = 0;
+
+        do {
+                raw_desc = &ring->raw_desc[head];
+                if (unlikely(xgene_enet_is_desc_slot_empty(raw_desc)))
+                        break;
+
+                if (is_rx_desc(raw_desc))
+                        ret = xgene_enet_rx_frame(ring, raw_desc);
+                else
+                        ret = xgene_enet_tx_completion(ring, raw_desc);
+                xgene_enet_mark_desc_slot_empty(raw_desc);
+
+                head = (head + 1) & slots;
+                count++;
+
+                if (ret)
+                        break;
+        } while (--budget);
+
+        if (likely(count)) {
+                iowrite32(-count, ring->cmd);
+                ring->head = head;
+
+                if (netif_queue_stopped(ring->ndev)) {
+                        if (xgene_enet_ring_len(ring) < pdata->cp_qcnt_low)
+                                netif_wake_queue(ring->ndev);
+                }
+        }
+
+        return budget;
+}
+
+static int xgene_enet_napi(struct napi_struct *napi, const int budget)
+{
+        struct xgene_enet_desc_ring *ring;
+        int processed;
+
+        ring = container_of(napi, struct xgene_enet_desc_ring, napi);
+        processed = xgene_enet_process_ring(ring, budget);
+
+        if (processed != budget) {
+                napi_complete(napi);
+                enable_irq(ring->irq);
+        }
+
+        return processed;
+}
+
+static void xgene_enet_timeout(struct net_device *ndev)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+
+        xgene_gmac_reset(pdata);
+}
+
+static int xgene_enet_register_irq(struct net_device *ndev)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct device *dev = ndev_to_dev(ndev);
+        int ret;
+
+        ret = devm_request_irq(dev, pdata->rx_ring->irq, xgene_enet_rx_irq,
+                               IRQF_SHARED, ndev->name, pdata->rx_ring);
+        if (ret) {
+                netdev_err(ndev, "rx%d interrupt request failed\n",
+                           pdata->rx_ring->irq);
+        }
+
+        return ret;
+}
+
+static void xgene_enet_free_irq(struct net_device *ndev)
+{
+        struct xgene_enet_pdata *pdata;
+        struct device *dev;
+
+        pdata = netdev_priv(ndev);
+        dev = ndev_to_dev(ndev);
+        devm_free_irq(dev, pdata->rx_ring->irq, pdata->rx_ring);
+}
+
+static int xgene_enet_open(struct net_device *ndev)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        int ret;
+
+        xgene_gmac_tx_enable(pdata);
+        xgene_gmac_rx_enable(pdata);
+
+        ret = xgene_enet_register_irq(ndev);
+        if (ret)
+                return ret;
+        napi_enable(&pdata->rx_ring->napi);
+
+        if (pdata->phy_dev)
+                phy_start(pdata->phy_dev);
+
+        netif_start_queue(ndev);
+
+        return ret;
+}
+
+static int xgene_enet_close(struct net_device *ndev)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+
+        netif_stop_queue(ndev);
+
+        if (pdata->phy_dev)
+                phy_stop(pdata->phy_dev);
+
+        napi_disable(&pdata->rx_ring->napi);
+        xgene_enet_free_irq(ndev);
+        xgene_enet_process_ring(pdata->rx_ring, -1);
+
+        xgene_gmac_tx_disable(pdata);
+        xgene_gmac_rx_disable(pdata);
+
+        return 0;
+}
+
+static void xgene_enet_delete_ring(struct xgene_enet_desc_ring *ring)
+{
+        struct xgene_enet_pdata *pdata;
+        struct device *dev;
+
+        pdata = netdev_priv(ring->ndev);
+        dev = ndev_to_dev(ring->ndev);
+
+        xgene_enet_clear_ring(ring);
+        dma_free_coherent(dev, ring->size, ring->desc_addr, ring->dma);
+}
+
+static void xgene_enet_delete_desc_rings(struct xgene_enet_pdata *pdata)
+{
+        struct xgene_enet_desc_ring *buf_pool;
+
+        if (pdata->tx_ring) {
+                xgene_enet_delete_ring(pdata->tx_ring);
+                pdata->tx_ring = NULL;
+        }
+
+        if (pdata->rx_ring) {
+                buf_pool = pdata->rx_ring->buf_pool;
+                xgene_enet_delete_bufpool(buf_pool);
+                xgene_enet_delete_ring(buf_pool);
+                xgene_enet_delete_ring(pdata->rx_ring);
+                pdata->rx_ring = NULL;
+        }
+}
+
+static int xgene_enet_get_ring_size(struct device *dev,
+                                    enum xgene_enet_ring_cfgsize cfgsize)
+{
+        int size = -EINVAL;
+
+        switch (cfgsize) {
+        case RING_CFGSIZE_512B:
+                size = 0x200;
+                break;
+        case RING_CFGSIZE_2KB:
+                size = 0x800;
+                break;
+        case RING_CFGSIZE_16KB:
+                size = 0x4000;
+                break;
+        case RING_CFGSIZE_64KB:
+                size = 0x10000;
+                break;
+        case RING_CFGSIZE_512KB:
+                size = 0x80000;
+                break;
+        default:
+                dev_err(dev, "Unsupported cfg ring size %d\n", cfgsize);
+                break;
+        }
+
+        return size;
+}
+
+static void xgene_enet_free_desc_ring(struct xgene_enet_desc_ring *ring)
+{
+        struct device *dev;
+
+        if (!ring)
+                return;
+
+        dev = ndev_to_dev(ring->ndev);
+
+        if (ring->desc_addr) {
+                xgene_enet_clear_ring(ring);
+                dma_free_coherent(dev, ring->size, ring->desc_addr, ring->dma);
+        }
+        devm_kfree(dev, ring);
+}
+
+static void xgene_enet_free_desc_rings(struct xgene_enet_pdata *pdata)
+{
+        struct device *dev = &pdata->pdev->dev;
+        struct xgene_enet_desc_ring *ring;
+
+        ring = pdata->tx_ring;
+        if (ring && ring->cp_ring && ring->cp_ring->cp_skb)
+                devm_kfree(dev, ring->cp_ring->cp_skb);
+        xgene_enet_free_desc_ring(ring);
+
+        ring = pdata->rx_ring;
+        if (ring && ring->buf_pool && ring->buf_pool->rx_skb)
+                devm_kfree(dev, ring->buf_pool->rx_skb);
+        xgene_enet_free_desc_ring(ring->buf_pool);
+        xgene_enet_free_desc_ring(ring);
+}
+
+static struct xgene_enet_desc_ring *xgene_enet_create_desc_ring(
+                        struct net_device *ndev, u32 ring_num,
+                        enum xgene_enet_ring_cfgsize cfgsize, u32 ring_id)
+{
+        struct xgene_enet_desc_ring *ring;
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct device *dev = ndev_to_dev(ndev);
+        int size;
+
+        size = xgene_enet_get_ring_size(dev, cfgsize);
+        if (size < 0)
+                return NULL;
+
+        ring = devm_kzalloc(dev, sizeof(struct xgene_enet_desc_ring),
+                            GFP_KERNEL);
+        if (!ring)
+                return NULL;
+
+        ring->ndev = ndev;
+        ring->num = ring_num;
+        ring->cfgsize = cfgsize;
+        ring->id = ring_id;
+
+        ring->desc_addr = dma_zalloc_coherent(dev, size, &ring->dma,
+                                              GFP_KERNEL);
+        if (!ring->desc_addr) {
+                devm_kfree(dev, ring);
+                return NULL;
+        }
+        ring->size = size;
+
+        ring->cmd_base = pdata->ring_cmd_addr + (ring->num << 6);
+        ring->cmd = ring->cmd_base + INC_DEC_CMD_ADDR;
+        pdata->rm = RM3;
+        ring = xgene_enet_setup_ring(ring);
+        netdev_dbg(ndev, "ring info: num=%d  size=%d  id=%d  slots=%d\n",
+                   ring->num, ring->size, ring->id, ring->slots);
+
+        return ring;
+}
+
+static u16 xgene_enet_get_ring_id(enum xgene_ring_owner owner, u8 bufnum)
+{
+        return (owner << 6) | (bufnum & GENMASK(5, 0));
+}
+
+static int xgene_enet_create_desc_rings(struct net_device *ndev)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct device *dev = ndev_to_dev(ndev);
+        struct xgene_enet_desc_ring *rx_ring, *tx_ring, *cp_ring;
+        struct xgene_enet_desc_ring *buf_pool = NULL;
+        u8 cpu_bufnum = 0, eth_bufnum = 0;
+        u8 bp_bufnum = 0x20;
+        u16 ring_id, ring_num = 0;
+        int ret;
+
+        /* allocate rx descriptor ring */
+        ring_id = xgene_enet_get_ring_id(RING_OWNER_CPU, cpu_bufnum++);
+        rx_ring = xgene_enet_create_desc_ring(ndev, ring_num++,
+                                              RING_CFGSIZE_16KB, ring_id);
+        if (!rx_ring) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        /* allocate buffer pool for receiving packets */
+        ring_id = xgene_enet_get_ring_id(RING_OWNER_ETH0, bp_bufnum++);
+        buf_pool = xgene_enet_create_desc_ring(ndev, ring_num++,
+                                               RING_CFGSIZE_2KB, ring_id);
+        if (!buf_pool) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        rx_ring->nbufpool = NUM_BUFPOOL;
+        rx_ring->buf_pool = buf_pool;
+        rx_ring->irq = pdata->rx_irq;
+        buf_pool->rx_skb = devm_kcalloc(dev, buf_pool->slots,
+                                        sizeof(struct sk_buff *), GFP_KERNEL);
+        if (!buf_pool->rx_skb) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        buf_pool->dst_ring_num = xgene_enet_dst_ring_num(buf_pool);
+        rx_ring->buf_pool = buf_pool;
+        pdata->rx_ring = rx_ring;
+
+        /* allocate tx descriptor ring */
+        ring_id = xgene_enet_get_ring_id(RING_OWNER_ETH0, eth_bufnum++);
+        tx_ring = xgene_enet_create_desc_ring(ndev, ring_num++,
+                                              RING_CFGSIZE_16KB, ring_id);
+        if (!tx_ring) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        pdata->tx_ring = tx_ring;
+
+        cp_ring = pdata->rx_ring;
+        cp_ring->cp_skb = devm_kcalloc(dev, tx_ring->slots,
+                                       sizeof(struct sk_buff *), GFP_KERNEL);
+        if (!cp_ring->cp_skb) {
+                ret = -ENOMEM;
+                goto err;
+        }
+        pdata->tx_ring->cp_ring = cp_ring;
+        pdata->tx_ring->dst_ring_num = xgene_enet_dst_ring_num(cp_ring);
+
+        pdata->tx_qcnt_hi = pdata->tx_ring->slots / 2;
+        pdata->cp_qcnt_hi = pdata->rx_ring->slots / 2;
+        pdata->cp_qcnt_low = pdata->cp_qcnt_hi / 2;
+
+        return 0;
+
+err:
+        xgene_enet_free_desc_rings(pdata);
+        return ret;
+}
+
+static struct rtnl_link_stats64 *xgene_enet_get_stats64(
+                        struct net_device *ndev,
+                        struct rtnl_link_stats64 *storage)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        struct rtnl_link_stats64 *stats = &pdata->stats;
+
+        stats->rx_errors += stats->rx_length_errors +
+                            stats->rx_crc_errors +
+                            stats->rx_frame_errors +
+                            stats->rx_fifo_errors;
+        memcpy(storage, &pdata->stats, sizeof(struct rtnl_link_stats64));
+
+        return storage;
+}
+
+static int xgene_enet_set_mac_address(struct net_device *ndev, void *addr)
+{
+        struct xgene_enet_pdata *pdata = netdev_priv(ndev);
+        int ret;
+
+        ret = eth_mac_addr(ndev, addr);
+        if (ret)
+                return ret;
+        xgene_gmac_set_mac_addr(pdata);
+
+        return ret;
+}
+
+static const struct net_device_ops xgene_ndev_ops = {
+        .ndo_open = xgene_enet_open,
+        .ndo_stop = xgene_enet_close,
+        .ndo_start_xmit = xgene_enet_start_xmit,
+        .ndo_tx_timeout = xgene_enet_timeout,
+        .ndo_get_stats64 = xgene_enet_get_stats64,
+        .ndo_change_mtu = eth_change_mtu,
+        .ndo_set_mac_address = xgene_enet_set_mac_address,
+};
+
+static int xgene_enet_get_resources(struct xgene_enet_pdata *pdata)
+{
+        struct platform_device *pdev;
+        struct net_device *ndev;
+        struct device *dev;
+        struct resource *res;
+        void __iomem *base_addr;
+        const char *mac;
+        int ret;
+
+        pdev = pdata->pdev;
+        dev = &pdev->dev;
+        ndev = pdata->ndev;
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "enet_csr");
+        if (!res) {
+                dev_err(dev, "Resource enet_csr not defined\n");
+                return -ENODEV;
+        }
+        pdata->base_addr = devm_ioremap_resource(dev, res);
+        if (IS_ERR(pdata->base_addr)) {
+                dev_err(dev, "Unable to retrieve ENET Port CSR region\n");
+                return PTR_ERR(pdata->base_addr);
+        }
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ring_csr");
+        if (!res) {
+                dev_err(dev, "Resource ring_csr not defined\n");
+                return -ENODEV;
+        }
+        pdata->ring_csr_addr = devm_ioremap_resource(dev, res);
+        if (IS_ERR(pdata->ring_csr_addr)) {
+                dev_err(dev, "Unable to retrieve ENET Ring CSR region\n");
+                return PTR_ERR(pdata->ring_csr_addr);
+        }
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ring_cmd");
+        if (!res) {
+                dev_err(dev, "Resource ring_cmd not defined\n");
+                return -ENODEV;
+        }
+        pdata->ring_cmd_addr = devm_ioremap_resource(dev, res);
+        if (IS_ERR(pdata->ring_cmd_addr)) {
+                dev_err(dev, "Unable to retrieve ENET Ring command region\n");
+                return PTR_ERR(pdata->ring_cmd_addr);
+        }
+
+        ret = platform_get_irq(pdev, 0);
+        if (ret <= 0) {
+                dev_err(dev, "Unable to get ENET Rx IRQ\n");
+                ret = ret ? : -ENXIO;
+                return ret;
+        }
+        pdata->rx_irq = ret;
+
+        mac = of_get_mac_address(dev->of_node);
+        if (mac)
+                memcpy(ndev->dev_addr, mac, ndev->addr_len);
+        else
+                eth_hw_addr_random(ndev);
+        memcpy(ndev->perm_addr, ndev->dev_addr, ndev->addr_len);
+
+        pdata->phy_mode = of_get_phy_mode(pdev->dev.of_node);
+        if (pdata->phy_mode < 0) {
+                dev_err(dev, "Incorrect phy-connection-type in DTS\n");
+                return -EINVAL;
+        }
+
+        pdata->clk = devm_clk_get(&pdev->dev, NULL);
+        ret = IS_ERR(pdata->clk);
+        if (IS_ERR(pdata->clk)) {
+                dev_err(&pdev->dev, "can't get clock\n");
+                ret = PTR_ERR(pdata->clk);
+                return ret;
+        }
+
+        base_addr = pdata->base_addr;
+        pdata->eth_csr_addr = base_addr + BLOCK_ETH_CSR_OFFSET;
+        pdata->eth_ring_if_addr = base_addr + BLOCK_ETH_RING_IF_OFFSET;
+        pdata->eth_diag_csr_addr = base_addr + BLOCK_ETH_DIAG_CSR_OFFSET;
+        pdata->mcx_mac_addr = base_addr + BLOCK_ETH_MAC_OFFSET;
+        pdata->mcx_stats_addr = base_addr + BLOCK_ETH_STATS_OFFSET;
+        pdata->mcx_mac_csr_addr = base_addr + BLOCK_ETH_MAC_CSR_OFFSET;
+        pdata->rx_buff_cnt = NUM_PKT_BUF;
+
+        return ret;
+}
+
+static int xgene_enet_init_hw(struct xgene_enet_pdata *pdata)
+{
+        struct net_device *ndev = pdata->ndev;
+        struct xgene_enet_desc_ring *buf_pool;
+        u16 dst_ring_num;
+        int ret;
+
+        xgene_gmac_tx_disable(pdata);
+        xgene_gmac_rx_disable(pdata);
+
+        ret = xgene_enet_create_desc_rings(ndev);
+        if (ret) {
+                netdev_err(ndev, "Error in ring configuration\n");
+                return ret;
+        }
+
+        /* setup buffer pool */
+        buf_pool = pdata->rx_ring->buf_pool;
+        xgene_enet_init_bufpool(buf_pool);
+        ret = xgene_enet_refill_bufpool(buf_pool, pdata->rx_buff_cnt);
+        if (ret) {
+                xgene_enet_delete_desc_rings(pdata);
+                return ret;
+        }
+
+        dst_ring_num = xgene_enet_dst_ring_num(pdata->rx_ring);
+        xgene_enet_cle_bypass(pdata, dst_ring_num, buf_pool->id);
+
+        return ret;
+}
+
+static int xgene_enet_probe(struct platform_device *pdev)
+{
+        struct net_device *ndev;
+        struct xgene_enet_pdata *pdata;
+        struct device *dev = &pdev->dev;
+        struct napi_struct *napi;
+        int ret;
+
+        ndev = alloc_etherdev(sizeof(struct xgene_enet_pdata));
+        if (!ndev)
+                return -ENOMEM;
+
+        pdata = netdev_priv(ndev);
+
+        pdata->pdev = pdev;
+        pdata->ndev = ndev;
+        SET_NETDEV_DEV(ndev, dev);
+        platform_set_drvdata(pdev, pdata);
+        ndev->netdev_ops = &xgene_ndev_ops;
+        xgene_enet_set_ethtool_ops(ndev);
+        ndev->features |= NETIF_F_IP_CSUM |
+                          NETIF_F_GSO |
+                          NETIF_F_GRO;
+
+        ret = xgene_enet_get_resources(pdata);
+        if (ret)
+                goto err;
+
+        xgene_enet_reset(pdata);
+        xgene_gmac_init(pdata, SPEED_1000);
+
+        ret = register_netdev(ndev);
+        if (ret) {
+                netdev_err(ndev, "Failed to register netdev\n");
+                goto err;
+        }
+
+        ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
+        if (ret) {
+                netdev_err(ndev, "No usable DMA configuration\n");
+                goto err;
+        }
+
+        ret = xgene_enet_init_hw(pdata);
+        if (ret)
+                goto err;
+
+        napi = &pdata->rx_ring->napi;
+        netif_napi_add(ndev, napi, xgene_enet_napi, NAPI_POLL_WEIGHT);
+        ret = xgene_enet_mdio_config(pdata);
+
+        return ret;
+err:
+        free_netdev(ndev);
+        return ret;
+}
+
+static int xgene_enet_remove(struct platform_device *pdev)
+{
+        struct xgene_enet_pdata *pdata;
+        struct net_device *ndev;
+
+        pdata = platform_get_drvdata(pdev);
+        ndev = pdata->ndev;
+
+        xgene_gmac_rx_disable(pdata);
+        xgene_gmac_tx_disable(pdata);
+
+        netif_napi_del(&pdata->rx_ring->napi);
+        xgene_enet_mdio_remove(pdata);
+        xgene_enet_delete_desc_rings(pdata);
+        unregister_netdev(ndev);
+        xgene_gport_shutdown(pdata);
+        free_netdev(ndev);
+
+        return 0;
+}
+
+static struct of_device_id xgene_enet_match[] = {
+        {.compatible = "apm,xgene-enet",},
+        {},
+};
+
+MODULE_DEVICE_TABLE(of, xgene_enet_match);
+
+static struct platform_driver xgene_enet_driver = {
+        .driver = {
+                   .name = "xgene-enet",
+                   .of_match_table = xgene_enet_match,
+        },
+        .probe = xgene_enet_probe,
+        .remove = xgene_enet_remove,
+};
+
+module_platform_driver(xgene_enet_driver);
+
+MODULE_DESCRIPTION("APM X-Gene SoC Ethernet driver");
+MODULE_VERSION(XGENE_DRV_VERSION);
+MODULE_AUTHOR("Keyur Chudgar <kchudgar@apm.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/ethernet/apm/xgene/xgene_enet_main.h b/drivers/net/ethernet/apm/xgene/xgene_enet_main.h
new file mode 100644
index 000000000000..0815866986b0
--- /dev/null
+++ b/drivers/net/ethernet/apm/xgene/xgene_enet_main.h
@@ -0,0 +1,135 @@
+/* Applied Micro X-Gene SoC Ethernet Driver
+ *
+ * Copyright (c) 2014, Applied Micro Circuits Corporation
+ * Authors: Iyappan Subramanian <isubramanian@apm.com>
+ *          Ravi Patel <rapatel@apm.com>
+ *          Keyur Chudgar <kchudgar@apm.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __XGENE_ENET_MAIN_H__
+#define __XGENE_ENET_MAIN_H__
+
+#include <linux/clk.h>
+#include <linux/of_platform.h>
+#include <linux/of_net.h>
+#include <linux/of_mdio.h>
+#include <linux/module.h>
+#include <net/ip.h>
+#include <linux/prefetch.h>
+#include <linux/if_vlan.h>
+#include <linux/phy.h>
+#include "xgene_enet_hw.h"
+
+#define XGENE_DRV_VERSION       "v1.0"
+#define XGENE_ENET_MAX_MTU      1536
+#define SKB_BUFFER_SIZE         (XGENE_ENET_MAX_MTU - NET_IP_ALIGN)
+#define NUM_PKT_BUF     64
+#define NUM_BUFPOOL     32
+
+/* software context of a descriptor ring */
+struct xgene_enet_desc_ring {
+        struct net_device *ndev;
+        u16 id;
+        u16 num;
+        u16 head;
+        u16 tail;
+        u16 slots;
+        u16 irq;
+        u32 size;
+        u32 state[NUM_RING_CONFIG];
+        void __iomem *cmd_base;
+        void __iomem *cmd;
+        dma_addr_t dma;
+        u16 dst_ring_num;
+        u8 nbufpool;
+        struct sk_buff *(*rx_skb);
+        struct sk_buff *(*cp_skb);
+        enum xgene_enet_ring_cfgsize cfgsize;
+        struct xgene_enet_desc_ring *cp_ring;
+        struct xgene_enet_desc_ring *buf_pool;
+        struct napi_struct napi;
+        union {
+                void *desc_addr;
+                struct xgene_enet_raw_desc *raw_desc;
+                struct xgene_enet_raw_desc16 *raw_desc16;
+        };
+};
+
+/* ethernet private data */
+struct xgene_enet_pdata {
+        struct net_device *ndev;
+        struct mii_bus *mdio_bus;
+        struct phy_device *phy_dev;
+        int phy_speed;
+        struct clk *clk;
+        struct platform_device *pdev;
+        struct xgene_enet_desc_ring *tx_ring;
+        struct xgene_enet_desc_ring *rx_ring;
+        char *dev_name;
+        u32 rx_buff_cnt;
+        u32 tx_qcnt_hi;
+        u32 cp_qcnt_hi;
+        u32 cp_qcnt_low;
+        u32 rx_irq;
+        void __iomem *eth_csr_addr;
+        void __iomem *eth_ring_if_addr;
+        void __iomem *eth_diag_csr_addr;
+        void __iomem *mcx_mac_addr;
+        void __iomem *mcx_stats_addr;
+        void __iomem *mcx_mac_csr_addr;
+        void __iomem *base_addr;
+        void __iomem *ring_csr_addr;
+        void __iomem *ring_cmd_addr;
+        u32 phy_addr;
+        int phy_mode;
+        u32 speed;
+        u16 rm;
+        struct rtnl_link_stats64 stats;
+};
+
+/* Set the specified value into a bit-field defined by its starting position
+ * and length within a single u64.
+ */
+static inline u64 xgene_enet_set_field_value(int pos, int len, u64 val)
+{
+        return (val & ((1ULL << len) - 1)) << pos;
+}
+
+#define SET_VAL(field, val) \
+                xgene_enet_set_field_value(field ## _POS, field ## _LEN, val)
+
+#define SET_BIT(field) \
+                xgene_enet_set_field_value(field ## _POS, 1, 1)
+
+/* Get the value from a bit-field defined by its starting position
+ * and length within the specified u64.
+ */
+static inline u64 xgene_enet_get_field_value(int pos, int len, u64 src)
+{
+        return (src >> pos) & ((1ULL << len) - 1);
+}
+
+#define GET_VAL(field, src) \
+                xgene_enet_get_field_value(field ## _POS, field ## _LEN, src)
+
+static inline struct device *ndev_to_dev(struct net_device *ndev)
+{
+        return ndev->dev.parent;
+}
+
+void xgene_enet_set_ethtool_ops(struct net_device *netdev);
+
+#endif /* __XGENE_ENET_MAIN_H__ */
diff --git a/drivers/net/ethernet/atheros/alx/main.c b/drivers/net/ethernet/atheros/alx/main.c
index 49faa97a30c3..e398eda07298 100644
--- a/drivers/net/ethernet/atheros/alx/main.c
+++ b/drivers/net/ethernet/atheros/alx/main.c
@@ -1527,7 +1527,7 @@ static const struct pci_error_handlers alx_err_handlers = {
         .resume         = alx_pci_error_resume,
 };
 
-static DEFINE_PCI_DEVICE_TABLE(alx_pci_tbl) = {
+static const struct pci_device_id alx_pci_tbl[] = {
         { PCI_VDEVICE(ATTANSIC, ALX_DEV_ID_AR8161),
           .driver_data = ALX_DEV_QUIRK_MSI_INTX_DISABLE_BUG },
         { PCI_VDEVICE(ATTANSIC, ALX_DEV_ID_E2200),
diff --git a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
index e11bf18fbbd1..72fb86b9aa24 100644
--- a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
+++ b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
@@ -34,7 +34,7 @@ char atl1c_driver_version[] = ATL1C_DRV_VERSION;
  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  *   Class, Class Mask, private data (not used) }
  */
-static DEFINE_PCI_DEVICE_TABLE(atl1c_pci_tbl) = {
+static const struct pci_device_id atl1c_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATTANSIC_L1C)},
         {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATTANSIC_L2C)},
         {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATHEROS_L2C_B)},
diff --git a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c
index 4345332533ad..2326579f9454 100644
--- a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c
+++ b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c
@@ -35,7 +35,7 @@ char atl1e_driver_version[] = DRV_VERSION;
  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  *   Class, Class Mask, private data (not used) }
  */
-static DEFINE_PCI_DEVICE_TABLE(atl1e_pci_tbl) = {
+static const struct pci_device_id atl1e_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATTANSIC_L1E)},
         {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, 0x1066)},
         /* required last entry */
@@ -831,17 +831,14 @@ static int atl1e_setup_ring_resources(struct atl1e_adapter *adapter)
         /* real ring DMA buffer */
 
         size = adapter->ring_size;
-        adapter->ring_vir_addr = pci_alloc_consistent(pdev,
-                        adapter->ring_size, &adapter->ring_dma);
-
+        adapter->ring_vir_addr = pci_zalloc_consistent(pdev, adapter->ring_size,
+                                                       &adapter->ring_dma);
         if (adapter->ring_vir_addr == NULL) {
                 netdev_err(adapter->netdev,
                            "pci_alloc_consistent failed, size = D%d\n", size);
                 return -ENOMEM;
         }
 
-        memset(adapter->ring_vir_addr, 0, adapter->ring_size);
-
         rx_page_desc = rx_ring->rx_page_desc;
 
         /* Init TPD Ring */
diff --git a/drivers/net/ethernet/atheros/atlx/atl1.c b/drivers/net/ethernet/atheros/atlx/atl1.c
index 1546d550ac97..2c8f398aeda9 100644
--- a/drivers/net/ethernet/atheros/atlx/atl1.c
+++ b/drivers/net/ethernet/atheros/atlx/atl1.c
@@ -235,7 +235,7 @@ static void atl1_check_options(struct atl1_adapter *adapter)
 /*
  * atl1_pci_tbl - PCI Device ID Table
  */
-static DEFINE_PCI_DEVICE_TABLE(atl1_pci_tbl) = {
+static const struct pci_device_id atl1_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATTANSIC_L1)},
         /* required last entry */
         {0,}
diff --git a/drivers/net/ethernet/atheros/atlx/atl2.c b/drivers/net/ethernet/atheros/atlx/atl2.c
index c194bc687c30..84a09e8ddd9c 100644
--- a/drivers/net/ethernet/atheros/atlx/atl2.c
+++ b/drivers/net/ethernet/atheros/atlx/atl2.c
@@ -65,7 +65,7 @@ MODULE_VERSION(ATL2_DRV_VERSION);
 /*
  * atl2_pci_tbl - PCI Device ID Table
  */
-static DEFINE_PCI_DEVICE_TABLE(atl2_pci_tbl) = {
+static const struct pci_device_id atl2_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_ATTANSIC, PCI_DEVICE_ID_ATTANSIC_L2)},
         /* required last entry */
         {0,}
diff --git a/drivers/net/ethernet/broadcom/b44.c b/drivers/net/ethernet/broadcom/b44.c
index ca5a20a48b14..4a7028d65912 100644
--- a/drivers/net/ethernet/broadcom/b44.c
+++ b/drivers/net/ethernet/broadcom/b44.c
@@ -105,7 +105,7 @@ MODULE_PARM_DESC(b44_debug, "B44 bitmapped debugging message enable value");
 
 
 #ifdef CONFIG_B44_PCI
-static DEFINE_PCI_DEVICE_TABLE(b44_pci_tbl) = {
+static const struct pci_device_id b44_pci_tbl[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401) },
         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401B0) },
         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BCM4401B1) },
diff --git a/drivers/net/ethernet/broadcom/bnx2.c b/drivers/net/ethernet/broadcom/bnx2.c
index e64c963fe775..2fee73b878c2 100644
--- a/drivers/net/ethernet/broadcom/bnx2.c
+++ b/drivers/net/ethernet/broadcom/bnx2.c
@@ -120,7 +120,7 @@ static struct {
         { "Broadcom NetXtreme II BCM5716 1000Base-SX" },
         };
 
-static DEFINE_PCI_DEVICE_TABLE(bnx2_pci_tbl) = {
+static const struct pci_device_id bnx2_pci_tbl[] = {
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
           PCI_VENDOR_ID_HP, 0x3101, 0, 0, NC370T },
         { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index 3871ec49cc4d..c13364b6cc19 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -249,7 +249,7 @@ static struct {
 #define PCI_DEVICE_ID_NX2_57811_VF      CHIP_NUM_57811_VF
 #endif
 
-static DEFINE_PCI_DEVICE_TABLE(bnx2x_pci_tbl) = {
+static const struct pci_device_id bnx2x_pci_tbl[] = {
         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57710), BCM57710 },
         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711), BCM57711 },
         { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711E), BCM57711E },
diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.c b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
index ce455aed5a2f..3f9d4de8173c 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.c
+++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
@@ -739,7 +739,6 @@ static void bcmgenet_power_down(struct bcmgenet_priv *priv,
 
         case GENET_POWER_PASSIVE:
                 /* Power down LED */
-                bcmgenet_mii_reset(priv->dev);
                 if (priv->hw_params->flags & GENET_HAS_EXT) {
                         reg = bcmgenet_ext_readl(priv, EXT_EXT_PWR_MGMT);
                         reg |= (EXT_PWR_DOWN_PHY |
@@ -779,7 +778,9 @@ static void bcmgenet_power_up(struct bcmgenet_priv *priv,
         }
 
         bcmgenet_ext_writel(priv, reg, EXT_EXT_PWR_MGMT);
-        bcmgenet_mii_reset(priv->dev);
+
+        if (mode == GENET_POWER_PASSIVE)
+                bcmgenet_mii_reset(priv->dev);
 }
 
 /* ioctl handle special commands that are not present in ethtool. */
@@ -1961,7 +1962,8 @@ static void bcmgenet_set_hw_addr(struct bcmgenet_priv *priv,
 static int bcmgenet_wol_resume(struct bcmgenet_priv *priv)
 {
         /* From WOL-enabled suspend, switch to regular clock */
-        clk_disable_unprepare(priv->clk_wol);
+        if (priv->wolopts)
+                clk_disable_unprepare(priv->clk_wol);
 
         phy_init_hw(priv->phydev);
         /* Speed settings must be restored */
@@ -2164,6 +2166,10 @@ static void bcmgenet_netif_stop(struct net_device *dev)
          * disabled no new work will be scheduled.
          */
         cancel_work_sync(&priv->bcmgenet_irq_work);
+
+        priv->old_pause = -1;
+        priv->old_link = -1;
+        priv->old_duplex = -1;
 }
 
 static int bcmgenet_close(struct net_device *dev)
@@ -2533,6 +2539,13 @@ static int bcmgenet_probe(struct platform_device *pdev)
         priv->pdev = pdev;
         priv->version = (enum bcmgenet_version)of_id->data;
 
+        priv->clk = devm_clk_get(&priv->pdev->dev, "enet");
+        if (IS_ERR(priv->clk))
+                dev_warn(&priv->pdev->dev, "failed to get enet clock\n");
+
+        if (!IS_ERR(priv->clk))
+                clk_prepare_enable(priv->clk);
+
         bcmgenet_set_hw_params(priv);
 
         /* Mii wait queue */
@@ -2541,17 +2554,10 @@ static int bcmgenet_probe(struct platform_device *pdev)
         priv->rx_buf_len = RX_BUF_LENGTH;
         INIT_WORK(&priv->bcmgenet_irq_work, bcmgenet_irq_task);
 
-        priv->clk = devm_clk_get(&priv->pdev->dev, "enet");
-        if (IS_ERR(priv->clk))
-                dev_warn(&priv->pdev->dev, "failed to get enet clock\n");
-
         priv->clk_wol = devm_clk_get(&priv->pdev->dev, "enet-wol");
         if (IS_ERR(priv->clk_wol))
                 dev_warn(&priv->pdev->dev, "failed to get enet-wol clock\n");
 
-        if (!IS_ERR(priv->clk))
-                clk_prepare_enable(priv->clk);
-
         err = reset_umac(priv);
         if (err)
                 goto err_clk_disable;
@@ -2611,6 +2617,8 @@ static int bcmgenet_suspend(struct device *d)
 
         bcmgenet_netif_stop(dev);
 
+        phy_suspend(priv->phydev);
+
         netif_device_detach(dev);
 
         /* Disable MAC receive */
@@ -2661,9 +2669,7 @@ static int bcmgenet_resume(struct device *d)
         if (ret)
                 goto out_clk_disable;
 
-        if (priv->wolopts)
-                ret = bcmgenet_wol_resume(priv);
-
+        ret = bcmgenet_wol_resume(priv);
         if (ret)
                 goto out_clk_disable;
 
@@ -2678,6 +2684,9 @@ static int bcmgenet_resume(struct device *d)
                 bcmgenet_ext_writel(priv, reg, EXT_EXT_PWR_MGMT);
         }
 
+        if (priv->wolopts)
+                bcmgenet_power_up(priv, GENET_POWER_WOL_MAGIC);
+
         /* Disable RX/TX DMA and flush TX queues */
         dma_ctrl = bcmgenet_dma_disable(priv);
 
@@ -2693,6 +2702,8 @@ static int bcmgenet_resume(struct device *d)
 
         netif_device_attach(dev);
 
+        phy_resume(priv->phydev);
+
         bcmgenet_netif_start(dev);
 
         return 0;
diff --git a/drivers/net/ethernet/broadcom/genet/bcmmii.c b/drivers/net/ethernet/broadcom/genet/bcmmii.c
index 18961613d385..c88f7ae99636 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmmii.c
+++ b/drivers/net/ethernet/broadcom/genet/bcmmii.c
@@ -129,7 +129,10 @@ static void bcmgenet_mii_setup(struct net_device *dev)
                         cmd_bits |= CMD_RX_PAUSE_IGNORE | CMD_TX_PAUSE_IGNORE;
         }
 
-        if (status_changed) {
+        if (!status_changed)
+                return;
+
+        if (phydev->link) {
                 reg = bcmgenet_umac_readl(priv, UMAC_CMD);
                 reg &= ~((CMD_SPEED_MASK << CMD_SPEED_SHIFT) |
                                CMD_HD_EN |
@@ -137,8 +140,9 @@ static void bcmgenet_mii_setup(struct net_device *dev)
                 reg |= cmd_bits;
                 bcmgenet_umac_writel(priv, reg, UMAC_CMD);
 
-                phy_print_status(phydev);
         }
+
+        phy_print_status(phydev);
 }
 
 void bcmgenet_mii_reset(struct net_device *dev)
@@ -303,12 +307,12 @@ static int bcmgenet_mii_probe(struct net_device *dev)
         /* In the case of a fixed PHY, the DT node associated
          * to the PHY is the Ethernet MAC DT node.
          */
-        if (of_phy_is_fixed_link(dn)) {
+        if (!priv->phy_dn && of_phy_is_fixed_link(dn)) {
                 ret = of_phy_register_fixed_link(dn);
                 if (ret)
                         return ret;
 
-                priv->phy_dn = dn;
+                priv->phy_dn = of_node_get(dn);
         }
 
         phydev = of_phy_connect(dev, priv->phy_dn, bcmgenet_mii_setup, 0,
@@ -444,6 +448,7 @@ int bcmgenet_mii_init(struct net_device *dev)
         return 0;
 
 out:
+        of_node_put(priv->phy_dn);
         mdiobus_unregister(priv->mii_bus);
 out_free:
         kfree(priv->mii_bus->irq);
@@ -455,6 +460,7 @@ void bcmgenet_mii_exit(struct net_device *dev)
 {
         struct bcmgenet_priv *priv = netdev_priv(dev);
 
+        of_node_put(priv->phy_dn);
         mdiobus_unregister(priv->mii_bus);
         kfree(priv->mii_bus->irq);
         mdiobus_free(priv->mii_bus);
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index a3dd5dc64f4c..3ac5d23454a8 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -237,7 +237,7 @@ MODULE_PARM_DESC(tg3_debug, "Tigon3 bitmapped debugging message enable value");
 #define TG3_DRV_DATA_FLAG_10_100_ONLY   0x0001
 #define TG3_DRV_DATA_FLAG_5705_10_100   0x0002
 
-static DEFINE_PCI_DEVICE_TABLE(tg3_pci_tbl) = {
+static const struct pci_device_id tg3_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5700)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5701)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_TIGON3_5702)},
@@ -14093,8 +14093,9 @@ static struct rtnl_link_stats64 *tg3_get_stats64(struct net_device *dev,
 
         spin_lock_bh(&tp->lock);
         if (!tp->hw_stats) {
+                *stats = tp->net_stats_prev;
                 spin_unlock_bh(&tp->lock);
-                return &tp->net_stats_prev;
+                return stats;
         }
 
         tg3_get_nstats(tp, stats);
@@ -15926,7 +15927,7 @@ static inline u32 tg3_rx_ret_ring_size(struct tg3 *tp)
                 return TG3_RX_RET_MAX_SIZE_5705;
 }
 
-static DEFINE_PCI_DEVICE_TABLE(tg3_write_reorder_chipsets) = {
+static const struct pci_device_id tg3_write_reorder_chipsets[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_FE_GATE_700C) },
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8131_BRIDGE) },
         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8385_0) },
@@ -17185,7 +17186,7 @@ static int tg3_do_test_dma(struct tg3 *tp, u32 *buf, dma_addr_t buf_dma,
 
 #define TEST_BUFFER_SIZE        0x2000
 
-static DEFINE_PCI_DEVICE_TABLE(tg3_dma_wait_state_chipsets) = {
+static const struct pci_device_id tg3_dma_wait_state_chipsets[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_UNI_N_PCI15) },
         { },
 };
diff --git a/drivers/net/ethernet/brocade/bna/bnad.c b/drivers/net/ethernet/brocade/bna/bnad.c
index 556aab75f490..ff8cae5e2535 100644
--- a/drivers/net/ethernet/brocade/bna/bnad.c
+++ b/drivers/net/ethernet/brocade/bna/bnad.c
@@ -3836,7 +3836,7 @@ bnad_pci_remove(struct pci_dev *pdev)
         free_netdev(netdev);
 }
 
-static DEFINE_PCI_DEVICE_TABLE(bnad_pci_id_table) = {
+static const struct pci_device_id bnad_pci_id_table[] = {
         {
                 PCI_DEVICE(PCI_VENDOR_ID_BROCADE,
                         PCI_DEVICE_ID_BROCADE_CT),
diff --git a/drivers/net/ethernet/chelsio/cxgb/subr.c b/drivers/net/ethernet/chelsio/cxgb/subr.c
index 816719314cc8..ea0f8741d7cf 100644
--- a/drivers/net/ethernet/chelsio/cxgb/subr.c
+++ b/drivers/net/ethernet/chelsio/cxgb/subr.c
@@ -522,7 +522,7 @@ static const struct board_info t1_board[] = {
 
 };
 
-DEFINE_PCI_DEVICE_TABLE(t1_pci_tbl) = {
+const struct pci_device_id t1_pci_tbl[] = {
         CH_DEVICE(8, 0, CH_BRD_T110_1CU),
         CH_DEVICE(8, 1, CH_BRD_T110_1CU),
         CH_DEVICE(7, 0, CH_BRD_N110_1F),
diff --git a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
index 5d9cce053cc9..db76f7040455 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
@@ -85,7 +85,7 @@ enum {
 #define CH_DEVICE(devid, idx) \
         { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, idx }
 
-static DEFINE_PCI_DEVICE_TABLE(cxgb3_pci_tbl) = {
+static const struct pci_device_id cxgb3_pci_tbl[] = {
         CH_DEVICE(0x20, 0),     /* PE9000 */
         CH_DEVICE(0x21, 1),     /* T302E */
         CH_DEVICE(0x22, 2),     /* T310E */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
index c9b922cc3e67..d57282172ea5 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
@@ -50,13 +50,13 @@
 #include "cxgb4_uld.h"
 
 #define T4FW_VERSION_MAJOR 0x01
-#define T4FW_VERSION_MINOR 0x09
-#define T4FW_VERSION_MICRO 0x17
+#define T4FW_VERSION_MINOR 0x0B
+#define T4FW_VERSION_MICRO 0x1B
 #define T4FW_VERSION_BUILD 0x00
 
 #define T5FW_VERSION_MAJOR 0x01
-#define T5FW_VERSION_MINOR 0x09
-#define T5FW_VERSION_MICRO 0x17
+#define T5FW_VERSION_MINOR 0x0B
+#define T5FW_VERSION_MICRO 0x1B
 #define T5FW_VERSION_BUILD 0x00
 
 #define CH_WARN(adap, fmt, ...) dev_warn(adap->pdev_dev, fmt, ## __VA_ARGS__)
@@ -522,6 +522,9 @@ struct sge_txq {
 struct sge_eth_txq {                /* state for an SGE Ethernet Tx queue */
         struct sge_txq q;
         struct netdev_queue *txq;   /* associated netdev TX queue */
+#ifdef CONFIG_CHELSIO_T4_DCB
+        u8 dcb_prio;                /* DCB Priority bound to queue */
+#endif
         unsigned long tso;          /* # of TSO requests */
         unsigned long tx_cso;       /* # of Tx checksum offloads */
         unsigned long vlan_ins;     /* # of Tx VLAN insertions */
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.c
index 0d3a9df5be36..8edf0f5bd679 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.c
@@ -20,6 +20,17 @@
 
 #include "cxgb4.h"
 
+/* DCBx version control
+ */
+char *dcb_ver_array[] = {
+        "Unknown",
+        "DCBx-CIN",
+        "DCBx-CEE 1.01",
+        "DCBx-IEEE",
+        "", "", "",
+        "Auto Negotiated"
+};
+
 /* Initialize a port's Data Center Bridging state.  Typically used after a
  * Link Down event.
  */
@@ -27,25 +38,45 @@ void cxgb4_dcb_state_init(struct net_device *dev)
 {
         struct port_info *pi = netdev2pinfo(dev);
         struct port_dcb_info *dcb = &pi->dcb;
+        int version_temp = dcb->dcb_version;
 
         memset(dcb, 0, sizeof(struct port_dcb_info));
         dcb->state = CXGB4_DCB_STATE_START;
+        if (version_temp)
+                dcb->dcb_version = version_temp;
+
+        netdev_dbg(dev, "%s: Initializing DCB state for port[%d]\n",
+                    __func__, pi->port_id);
+}
+
+void cxgb4_dcb_version_init(struct net_device *dev)
+{
+        struct port_info *pi = netdev2pinfo(dev);
+        struct port_dcb_info *dcb = &pi->dcb;
+
+        /* Any writes here are only done on kernels that exlicitly need
+         * a specific version, say < 2.6.38 which only support CEE
+         */
+        dcb->dcb_version = FW_PORT_DCB_VER_AUTO;
 }
 
 /* Finite State machine for Data Center Bridging.
  */
 void cxgb4_dcb_state_fsm(struct net_device *dev,
-                         enum cxgb4_dcb_state_input input)
+                         enum cxgb4_dcb_state_input transition_to)
 {
         struct port_info *pi = netdev2pinfo(dev);
         struct port_dcb_info *dcb = &pi->dcb;
         struct adapter *adap = pi->adapter;
+        enum cxgb4_dcb_state current_state = dcb->state;
 
-        switch (input) {
-        case CXGB4_DCB_INPUT_FW_DISABLED: {
-                /* Firmware tells us it's not doing DCB */
-                switch (dcb->state) {
-                case CXGB4_DCB_STATE_START: {
+        netdev_dbg(dev, "%s: State change from %d to %d for %s\n",
+                    __func__, dcb->state, transition_to, dev->name);
+
+        switch (current_state) {
+        case CXGB4_DCB_STATE_START: {
+                switch (transition_to) {
+                case CXGB4_DCB_INPUT_FW_DISABLED: {
                         /* we're going to use Host DCB */
                         dcb->state = CXGB4_DCB_STATE_HOST;
                         dcb->supported = CXGB4_DCBX_HOST_SUPPORT;
@@ -53,48 +84,62 @@ void cxgb4_dcb_state_fsm(struct net_device *dev,
                         break;
                 }
 
-                case CXGB4_DCB_STATE_HOST: {
-                        /* we're alreaady in Host DCB mode */
+                case CXGB4_DCB_INPUT_FW_ENABLED: {
+                        /* we're going to use Firmware DCB */
+                        dcb->state = CXGB4_DCB_STATE_FW_INCOMPLETE;
+                        dcb->supported = CXGB4_DCBX_FW_SUPPORT;
+                        break;
+                }
+
+                case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
+                        /* expected transition */
+                        break;
+                }
+
+                case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
+                        dcb->state = CXGB4_DCB_STATE_FW_ALLSYNCED;
                         break;
                 }
 
                 default:
-                        goto bad_state_transition;
+                        goto bad_state_input;
                 }
                 break;
         }
 
-        case CXGB4_DCB_INPUT_FW_ENABLED: {
-                /* Firmware tells us that it is doing DCB */
-                switch (dcb->state) {
-                case CXGB4_DCB_STATE_START: {
-                        /* we're going to use Firmware DCB */
-                        dcb->state = CXGB4_DCB_STATE_FW_INCOMPLETE;
-                        dcb->supported = CXGB4_DCBX_FW_SUPPORT;
+        case CXGB4_DCB_STATE_FW_INCOMPLETE: {
+                switch (transition_to) {
+                case CXGB4_DCB_INPUT_FW_ENABLED: {
+                        /* we're alreaady in firmware DCB mode */
                         break;
                 }
 
-                case CXGB4_DCB_STATE_FW_INCOMPLETE:
-                case CXGB4_DCB_STATE_FW_ALLSYNCED: {
-                        /* we're alreaady in firmware DCB mode */
+                case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
+                        /* we're already incomplete */
+                        break;
+                }
+
+                case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
+                        dcb->state = CXGB4_DCB_STATE_FW_ALLSYNCED;
+                        dcb->enabled = 1;
+                        linkwatch_fire_event(dev);
                         break;
                 }
 
                 default:
-                        goto bad_state_transition;
+                        goto bad_state_input;
                 }
                 break;
         }
 
-        case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
-                /* Firmware tells us that its DCB state is incomplete */
-                switch (dcb->state) {
-                case CXGB4_DCB_STATE_FW_INCOMPLETE: {
-                        /* we're already incomplete */
+        case CXGB4_DCB_STATE_FW_ALLSYNCED: {
+                switch (transition_to) {
+                case CXGB4_DCB_INPUT_FW_ENABLED: {
+                        /* we're alreaady in firmware DCB mode */
                         break;
                 }
 
-                case CXGB4_DCB_STATE_FW_ALLSYNCED: {
+                case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
                         /* We were successfully running with firmware DCB but
                          * now it's telling us that it's in an "incomplete
                          * state.  We need to reset back to a ground state
@@ -107,46 +152,48 @@ void cxgb4_dcb_state_fsm(struct net_device *dev,
                         break;
                 }
 
-                default:
-                        goto bad_state_transition;
-                }
-                break;
-        }
-
-        case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
-                /* Firmware tells us that its DCB state is complete */
-                switch (dcb->state) {
-                case CXGB4_DCB_STATE_FW_INCOMPLETE: {
-                        dcb->state = CXGB4_DCB_STATE_FW_ALLSYNCED;
+                case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
+                        /* we're already all sync'ed
+                         * this is only applicable for IEEE or
+                         * when another VI already completed negotiaton
+                         */
                         dcb->enabled = 1;
                         linkwatch_fire_event(dev);
                         break;
                 }
 
-                case CXGB4_DCB_STATE_FW_ALLSYNCED: {
-                        /* we're already all sync'ed */
+                default:
+                        goto bad_state_input;
+                }
+                break;
+        }
+
+        case CXGB4_DCB_STATE_HOST: {
+                switch (transition_to) {
+                case CXGB4_DCB_INPUT_FW_DISABLED: {
+                        /* we're alreaady in Host DCB mode */
                         break;
                 }
 
                 default:
-                        goto bad_state_transition;
+                        goto bad_state_input;
                 }
                 break;
         }
 
         default:
-                goto  bad_state_input;
+                goto bad_state_transition;
         }
         return;
 
 bad_state_input:
         dev_err(adap->pdev_dev, "cxgb4_dcb_state_fsm: illegal input symbol %d\n",
-                input);
+                transition_to);
         return;
 
 bad_state_transition:
         dev_err(adap->pdev_dev, "cxgb4_dcb_state_fsm: bad state transition, state = %d, input = %d\n",
-                dcb->state, input);
+                current_state, transition_to);
 }
 
 /* Handle a DCB/DCBX update message from the firmware.
@@ -160,6 +207,7 @@ void cxgb4_dcb_handle_fw_update(struct adapter *adap,
         struct port_info *pi = netdev_priv(dev);
         struct port_dcb_info *dcb = &pi->dcb;
         int dcb_type = pcmd->u.dcb.pgid.type;
+        int dcb_running_version;
 
         /* Handle Firmware DCB Control messages separately since they drive
          * our state machine.
@@ -171,6 +219,25 @@ void cxgb4_dcb_handle_fw_update(struct adapter *adap,
                          ? CXGB4_DCB_STATE_FW_ALLSYNCED
                          : CXGB4_DCB_STATE_FW_INCOMPLETE);
 
+                if (dcb->dcb_version != FW_PORT_DCB_VER_UNKNOWN) {
+                        dcb_running_version = FW_PORT_CMD_DCB_VERSION_GET(
+                                be16_to_cpu(
+                                pcmd->u.dcb.control.dcb_version_to_app_state));
+                        if (dcb_running_version == FW_PORT_DCB_VER_CEE1D01 ||
+                            dcb_running_version == FW_PORT_DCB_VER_IEEE) {
+                                dcb->dcb_version = dcb_running_version;
+                                dev_warn(adap->pdev_dev, "Interface %s is running %s\n",
+                                         dev->name,
+                                         dcb_ver_array[dcb->dcb_version]);
+                        } else {
+                                dev_warn(adap->pdev_dev,
+                                         "Something screwed up, requested firmware for %s, but firmware returned %s instead\n",
+                                         dcb_ver_array[dcb->dcb_version],
+                                         dcb_ver_array[dcb_running_version]);
+                                dcb->dcb_version = FW_PORT_DCB_VER_UNKNOWN;
+                        }
+                }
+
                 cxgb4_dcb_state_fsm(dev, input);
                 return;
         }
@@ -199,7 +266,11 @@ void cxgb4_dcb_handle_fw_update(struct adapter *adap,
                 dcb->pg_num_tcs_supported = fwdcb->pgrate.num_tcs_supported;
                 memcpy(dcb->pgrate, &fwdcb->pgrate.pgrate,
                        sizeof(dcb->pgrate));
+                memcpy(dcb->tsa, &fwdcb->pgrate.tsa,
+                       sizeof(dcb->tsa));
                 dcb->msgs |= CXGB4_DCB_FW_PGRATE;
+                if (dcb->msgs & CXGB4_DCB_FW_PGID)
+                        IEEE_FAUX_SYNC(dev, dcb);
                 break;
 
         case FW_PORT_DCB_TYPE_PRIORATE:
@@ -212,6 +283,7 @@ void cxgb4_dcb_handle_fw_update(struct adapter *adap,
                 dcb->pfcen = fwdcb->pfc.pfcen;
                 dcb->pfc_num_tcs_supported = fwdcb->pfc.max_pfc_tcs;
                 dcb->msgs |= CXGB4_DCB_FW_PFC;
+                IEEE_FAUX_SYNC(dev, dcb);
                 break;
 
         case FW_PORT_DCB_TYPE_APP_ID: {
@@ -220,13 +292,25 @@ void cxgb4_dcb_handle_fw_update(struct adapter *adap,
                 struct app_priority *ap = &dcb->app_priority[idx];
 
                 struct dcb_app app = {
-                        .selector = fwap->sel_field,
                         .protocol = be16_to_cpu(fwap->protocolid),
-                        .priority = fwap->user_prio_map,
                 };
                 int err;
 
-                err = dcb_setapp(dev, &app);
+                /* Convert from firmware format to relevant format
+                 * when using app selector
+                 */
+                if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) {
+                        app.selector = (fwap->sel_field + 1);
+                        app.priority = ffs(fwap->user_prio_map) - 1;
+                        err = dcb_ieee_setapp(dev, &app);
+                        IEEE_FAUX_SYNC(dev, dcb);
+                } else {
+                        /* Default is CEE */
+                        app.selector = !!(fwap->sel_field);
+                        app.priority = fwap->user_prio_map;
+                        err = dcb_setapp(dev, &app);
+                }
+
                 if (err)
                         dev_err(adap->pdev_dev,
                                 "Failed DCB Set Application Priority: sel=%d, prot=%d, prio=%d, err=%d\n",
@@ -408,9 +492,10 @@ static void cxgb4_getpgbwgcfg(struct net_device *dev, int pgid, u8 *bw_per,
         if (err != FW_PORT_DCB_CFG_SUCCESS) {
                 dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
                         -err);
-        } else {
-                *bw_per = pcmd.u.dcb.pgrate.pgrate[pgid];
+                return;
         }
+
+        *bw_per = pcmd.u.dcb.pgrate.pgrate[pgid];
 }
 
 static void cxgb4_getpgbwgcfg_tx(struct net_device *dev, int pgid, u8 *bw_per)
@@ -637,7 +722,8 @@ static int __cxgb4_getapp(struct net_device *dev, u8 app_idtype, u16 app_id,
                         return err;
                 }
                 if (be16_to_cpu(pcmd.u.dcb.app_priority.protocolid) == app_id)
-                        return pcmd.u.dcb.app_priority.user_prio_map;
+                        if (pcmd.u.dcb.app_priority.sel_field == app_idtype)
+                                return pcmd.u.dcb.app_priority.user_prio_map;
 
                 /* exhausted app list */
                 if (!pcmd.u.dcb.app_priority.protocolid)
@@ -657,8 +743,8 @@ static int cxgb4_getapp(struct net_device *dev, u8 app_idtype, u16 app_id)
 
 /* Write a new Application User Priority Map for the specified Application ID
  */
-static int cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id,
-                        u8 app_prio)
+static int __cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id,
+                          u8 app_prio)
 {
         struct fw_port_cmd pcmd;
         struct port_info *pi = netdev2pinfo(dev);
@@ -673,10 +759,6 @@ static int cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id,
         if (!netif_carrier_ok(dev))
                 return -ENOLINK;
 
-        if (app_idtype != DCB_APP_IDTYPE_ETHTYPE &&
-            app_idtype != DCB_APP_IDTYPE_PORTNUM)
-                return -EINVAL;
-
         for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
                 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
                 pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
@@ -725,6 +807,30 @@ static int cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id,
         return 0;
 }
 
+/* Priority for CEE inside dcb_app is bitmask, with 0 being an invalid value */
+static int cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id,
+                        u8 app_prio)
+{
+        int ret;
+        struct dcb_app app = {
+                .selector = app_idtype,
+                .protocol = app_id,
+                .priority = app_prio,
+        };
+
+        if (app_idtype != DCB_APP_IDTYPE_ETHTYPE &&
+            app_idtype != DCB_APP_IDTYPE_PORTNUM)
+                return -EINVAL;
+
+        /* Convert app_idtype to a format that firmware understands */
+        ret = __cxgb4_setapp(dev, app_idtype == DCB_APP_IDTYPE_ETHTYPE ?
+                              app_idtype : 3, app_id, app_prio);
+        if (ret)
+                return ret;
+
+        return dcb_setapp(dev, &app);
+}
+
 /* Return whether IEEE Data Center Bridging has been negotiated.
  */
 static inline int cxgb4_ieee_negotiation_complete(struct net_device *dev)
@@ -738,6 +844,7 @@ static inline int cxgb4_ieee_negotiation_complete(struct net_device *dev)
 
 /* Fill in the Application User Priority Map associated with the
  * specified Application.
+ * Priority for IEEE dcb_app is an integer, with 0 being a valid value
  */
 static int cxgb4_ieee_getapp(struct net_device *dev, struct dcb_app *app)
 {
@@ -748,28 +855,39 @@ static int cxgb4_ieee_getapp(struct net_device *dev, struct dcb_app *app)
         if (!(app->selector && app->protocol))
                 return -EINVAL;
 
-        prio = dcb_getapp(dev, app);
-        if (prio == 0) {
-                /* If app doesn't exist in dcb_app table, try firmware
-                 * directly.
-                 */
-                prio = __cxgb4_getapp(dev, app->selector, app->protocol, 0);
-        }
+        /* Try querying firmware first, use firmware format */
+        prio = __cxgb4_getapp(dev, app->selector - 1, app->protocol, 0);
+
+        if (prio < 0)
+                prio = dcb_ieee_getapp_mask(dev, app);
 
-        app->priority = prio;
+        app->priority = ffs(prio) - 1;
         return 0;
 }
 
-/* Write a new Application User Priority Map for the specified App id. */
+/* Write a new Application User Priority Map for the specified Application ID.
+ * Priority for IEEE dcb_app is an integer, with 0 being a valid value
+ */
 static int cxgb4_ieee_setapp(struct net_device *dev, struct dcb_app *app)
 {
+        int ret;
+
         if (!cxgb4_ieee_negotiation_complete(dev))
                 return -EINVAL;
-        if (!(app->selector && app->protocol && app->priority))
+        if (!(app->selector && app->protocol))
+                return -EINVAL;
+
+        if (!(app->selector > IEEE_8021QAZ_APP_SEL_ETHERTYPE  &&
+              app->selector < IEEE_8021QAZ_APP_SEL_ANY))
                 return -EINVAL;
 
-        cxgb4_setapp(dev, app->selector, app->protocol, app->priority);
-        return dcb_setapp(dev, app);
+        /* change selector to a format that firmware understands */
+        ret = __cxgb4_setapp(dev, app->selector - 1, app->protocol,
+                             (1 << app->priority));
+        if (ret)
+                return ret;
+
+        return dcb_ieee_setapp(dev, app);
 }
 
 /* Return our DCBX parameters.
@@ -794,8 +912,9 @@ static u8 cxgb4_setdcbx(struct net_device *dev, u8 dcb_request)
             != dcb_request)
                 return 1;
 
-        /* Can't set DCBX capabilities if DCBX isn't enabled. */
-        if (!pi->dcb.state)
+        /* Can't enable DCB if we haven't successfully negotiated it.
+         */
+        if (pi->dcb.state != CXGB4_DCB_STATE_FW_ALLSYNCED)
                 return 1;
 
         /* There's currently no mechanism to allow for the firmware DCBX
@@ -874,7 +993,8 @@ static int cxgb4_getpeerapp_tbl(struct net_device *dev, struct dcb_app *table)
                 table[i].selector = pcmd.u.dcb.app_priority.sel_field;
                 table[i].protocol =
                         be16_to_cpu(pcmd.u.dcb.app_priority.protocolid);
-                table[i].priority = pcmd.u.dcb.app_priority.user_prio_map;
+                table[i].priority =
+                        ffs(pcmd.u.dcb.app_priority.user_prio_map) - 1;
         }
         return err;
 }
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.h
index 1ec1d834e257..2a6aa88984f4 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_dcb.h
@@ -63,6 +63,13 @@
 #define INIT_PORT_DCB_WRITE_CMD(__pcmd, __port) \
         INIT_PORT_DCB_CMD(__pcmd, __port, EXEC, FW_PORT_ACTION_L2_DCB_CFG)
 
+#define IEEE_FAUX_SYNC(__dev, __dcb) \
+        do { \
+                if ((__dcb)->dcb_version == FW_PORT_DCB_VER_IEEE) \
+                        cxgb4_dcb_state_fsm((__dev), \
+                                            CXGB4_DCB_STATE_FW_ALLSYNCED); \
+        } while (0)
+
 /* States we can be in for a port's Data Center Bridging.
  */
 enum cxgb4_dcb_state {
@@ -108,11 +115,13 @@ struct port_dcb_info {
          * Native Endian format).
          */
         u32     pgid;                   /* Priority Group[0..7] */
+        u8      dcb_version;            /* Running DCBx version */
         u8      pfcen;                  /* Priority Flow Control[0..7] */
         u8      pg_num_tcs_supported;   /* max PG Traffic Classes */
         u8      pfc_num_tcs_supported;  /* max PFC Traffic Classes */
         u8      pgrate[8];              /* Priority Group Rate[0..7] */
         u8      priorate[8];            /* Priority Rate[0..7] */
+        u8      tsa[8];                 /* TSA Algorithm[0..7] */
         struct app_priority { /* Application Information */
                 u8      user_prio_map;  /* Priority Map bitfield */
                 u8      sel_field;      /* Protocol ID interpretation */
@@ -121,6 +130,7 @@ struct port_dcb_info {
 };
 
 void cxgb4_dcb_state_init(struct net_device *);
+void cxgb4_dcb_version_init(struct net_device *);
 void cxgb4_dcb_state_fsm(struct net_device *, enum cxgb4_dcb_state_input);
 void cxgb4_dcb_handle_fw_update(struct adapter *, const struct fw_port_cmd *);
 void cxgb4_dcb_set_caps(struct adapter *, const struct fw_port_cmd *);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index 4247356c16ff..1afee70ce856 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -212,7 +212,7 @@ struct filter_entry {
 
 #define CH_DEVICE(devid, data) { PCI_VDEVICE(CHELSIO, devid), (data) }
 
-static DEFINE_PCI_DEVICE_TABLE(cxgb4_pci_tbl) = {
+static const struct pci_device_id cxgb4_pci_tbl[] = {
         CH_DEVICE(0xa000, 0),  /* PE10K */
         CH_DEVICE(0x4001, -1),
         CH_DEVICE(0x4002, -1),
@@ -522,6 +522,8 @@ static void dcb_tx_queue_prio_enable(struct net_device *dev, int enable)
                         dev_err(adap->pdev_dev,
                                 "Can't %s DCB Priority on port %d, TX Queue %d: err=%d\n",
                                 enable ? "set" : "unset", pi->port_id, i, -err);
+                else
+                        txq->dcb_prio = value;
         }
 }
 #endif /* CONFIG_CHELSIO_T4_DCB */
@@ -6527,11 +6529,9 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         /* We control everything through one PF */
         func = SOURCEPF_GET(readl(adapter->regs + PL_WHOAMI));
-        if ((pdev->device == 0xa000 && func != 0) ||
-            func != ent->driver_data) {
+        if (func != ent->driver_data) {
                 pci_save_state(pdev);        /* to restore SR-IOV later */
-                err = 0;
-                goto out_unmap_bar0;
+                goto sriov;
         }
 
         adapter->pdev = pdev;
@@ -6697,6 +6697,7 @@ static int init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (is_offload(adapter))
                 attach_ulds(adapter);
 
+sriov:
 #ifdef CONFIG_PCI_IOV
         if (func < ARRAY_SIZE(num_vf) && num_vf[func] > 0)
                 if (pci_enable_sriov(pdev, num_vf[func]) == 0)
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
index ff709e3b3e7e..0549170d7e2e 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
@@ -1629,6 +1629,14 @@ enum fw_port_l2cfg_ctlbf {
         FW_PORT_L2_CTLBF_TXIPG  = 0x20
 };
 
+enum fw_port_dcb_versions {
+        FW_PORT_DCB_VER_UNKNOWN,
+        FW_PORT_DCB_VER_CEE1D0,
+        FW_PORT_DCB_VER_CEE1D01,
+        FW_PORT_DCB_VER_IEEE,
+        FW_PORT_DCB_VER_AUTO = 7
+};
+
 enum fw_port_dcb_cfg {
         FW_PORT_DCB_CFG_PG      = 0x01,
         FW_PORT_DCB_CFG_PFC     = 0x02,
@@ -1709,6 +1717,7 @@ struct fw_port_cmd {
                                 __u8   r10_lo[5];
                                 __u8   num_tcs_supported;
                                 __u8   pgrate[8];
+                                __u8   tsa[8];
                         } pgrate;
                         struct fw_port_dcb_priorate {
                                 __u8   type;
@@ -1735,7 +1744,7 @@ struct fw_port_cmd {
                         struct fw_port_dcb_control {
                                 __u8   type;
                                 __u8   all_syncd_pkd;
-                                __be16 pfc_state_to_app_state;
+                                __be16 dcb_version_to_app_state;
                                 __be32 r11;
                                 __be64 r12;
                         } control;
@@ -1778,6 +1787,7 @@ struct fw_port_cmd {
 #define FW_PORT_CMD_DCBXDIS (1U << 7)
 #define FW_PORT_CMD_APPLY (1U <<  7)
 #define FW_PORT_CMD_ALL_SYNCD (1U << 7)
+#define FW_PORT_CMD_DCB_VERSION_GET(x) (((x) >> 8) & 0xf)
 
 #define FW_PORT_CMD_PPPEN(x) ((x) << 31)
 #define FW_PORT_CMD_TPSRC(x) ((x) << 28)
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
index d8d28e82ade1..2102a4c91737 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
@@ -2910,7 +2910,7 @@ static void cxgb4vf_pci_shutdown(struct pci_dev *pdev)
 #define CH_DEVICE(devid, idx) \
         { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, idx }
 
-static DEFINE_PCI_DEVICE_TABLE(cxgb4vf_pci_tbl) = {
+static const struct pci_device_id cxgb4vf_pci_tbl[] = {
         CH_DEVICE(0xb000, 0),   /* PE10K FPGA */
         CH_DEVICE(0x4800, 0),   /* T440-dbg */
         CH_DEVICE(0x4801, 0),   /* T420-cr */
diff --git a/drivers/net/ethernet/cisco/enic/enic_main.c b/drivers/net/ethernet/cisco/enic/enic_main.c
index 9348febc0743..c8832bc1c5f7 100644
--- a/drivers/net/ethernet/cisco/enic/enic_main.c
+++ b/drivers/net/ethernet/cisco/enic/enic_main.c
@@ -67,7 +67,7 @@
 #define PCI_DEVICE_ID_CISCO_VIC_ENET_VF      0x0071  /* enet SRIOV VF */
 
 /* Supported devices */
-static DEFINE_PCI_DEVICE_TABLE(enic_id_table) = {
+static const struct pci_device_id enic_id_table[] = {
         { PCI_VDEVICE(CISCO, PCI_DEVICE_ID_CISCO_VIC_ENET) },
         { PCI_VDEVICE(CISCO, PCI_DEVICE_ID_CISCO_VIC_ENET_DYN) },
         { PCI_VDEVICE(CISCO, PCI_DEVICE_ID_CISCO_VIC_ENET_VF) },
diff --git a/drivers/net/ethernet/cisco/enic/vnic_dev.c b/drivers/net/ethernet/cisco/enic/vnic_dev.c
index 5abc496bcf29..37472ce4fac3 100644
--- a/drivers/net/ethernet/cisco/enic/vnic_dev.c
+++ b/drivers/net/ethernet/cisco/enic/vnic_dev.c
@@ -432,14 +432,12 @@ int vnic_dev_fw_info(struct vnic_dev *vdev,
         int err = 0;
 
         if (!vdev->fw_info) {
-                vdev->fw_info = pci_alloc_consistent(vdev->pdev,
-                        sizeof(struct vnic_devcmd_fw_info),
-                        &vdev->fw_info_pa);
+                vdev->fw_info = pci_zalloc_consistent(vdev->pdev,
+                                                      sizeof(struct vnic_devcmd_fw_info),
+                                                      &vdev->fw_info_pa);
                 if (!vdev->fw_info)
                         return -ENOMEM;
 
-                memset(vdev->fw_info, 0, sizeof(struct vnic_devcmd_fw_info));
-
                 a0 = vdev->fw_info_pa;
                 a1 = sizeof(struct vnic_devcmd_fw_info);
 
diff --git a/drivers/net/ethernet/davicom/dm9000.c b/drivers/net/ethernet/davicom/dm9000.c
index 23084fb2090e..9b33057a9477 100644
--- a/drivers/net/ethernet/davicom/dm9000.c
+++ b/drivers/net/ethernet/davicom/dm9000.c
@@ -93,7 +93,7 @@ enum dm9000_type {
 };
 
 /* Structure/enum declaration ------------------------------- */
-typedef struct board_info {
+struct board_info {
 
         void __iomem    *io_addr;       /* Register I/O base address */
         void __iomem    *io_data;       /* Data I/O address */
@@ -141,7 +141,7 @@ typedef struct board_info {
         u32             wake_state;
 
         int             ip_summed;
-} board_info_t;
+};
 
 /* debug code */
 
@@ -151,7 +151,7 @@ typedef struct board_info {
         }                                               \
 } while (0)
 
-static inline board_info_t *to_dm9000_board(struct net_device *dev)
+static inline struct board_info *to_dm9000_board(struct net_device *dev)
 {
         return netdev_priv(dev);
 }
@@ -162,7 +162,7 @@ static inline board_info_t *to_dm9000_board(struct net_device *dev)
  *   Read a byte from I/O port
  */
 static u8
-ior(board_info_t *db, int reg)
+ior(struct board_info *db, int reg)
 {
         writeb(reg, db->io_addr);
         return readb(db->io_data);
@@ -173,14 +173,14 @@ ior(board_info_t *db, int reg)
  */
 
 static void
-iow(board_info_t *db, int reg, int value)
+iow(struct board_info *db, int reg, int value)
 {
         writeb(reg, db->io_addr);
         writeb(value, db->io_data);
 }
 
 static void
-dm9000_reset(board_info_t *db)
+dm9000_reset(struct board_info *db)
 {
         dev_dbg(db->dev, "resetting device\n");
 
@@ -272,7 +272,7 @@ static void dm9000_dumpblk_32bit(void __iomem *reg, int count)
  * Sleep, either by using msleep() or if we are suspending, then
  * use mdelay() to sleep.
  */
-static void dm9000_msleep(board_info_t *db, unsigned int ms)
+static void dm9000_msleep(struct board_info *db, unsigned int ms)
 {
         if (db->in_suspend || db->in_timeout)
                 mdelay(ms);
@@ -284,7 +284,7 @@ static void dm9000_msleep(board_info_t *db, unsigned int ms)
 static int
 dm9000_phy_read(struct net_device *dev, int phy_reg_unused, int reg)
 {
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         unsigned long flags;
         unsigned int reg_save;
         int ret;
@@ -330,7 +330,7 @@ static void
 dm9000_phy_write(struct net_device *dev,
                  int phyaddr_unused, int reg, int value)
 {
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         unsigned long flags;
         unsigned long reg_save;
 
@@ -408,7 +408,7 @@ static void dm9000_set_io(struct board_info *db, int byte_width)
         }
 }
 
-static void dm9000_schedule_poll(board_info_t *db)
+static void dm9000_schedule_poll(struct board_info *db)
 {
         if (db->type == TYPE_DM9000E)
                 schedule_delayed_work(&db->phy_poll, HZ * 2);
@@ -416,7 +416,7 @@ static void dm9000_schedule_poll(board_info_t *db)
 
 static int dm9000_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
 
         if (!netif_running(dev))
                 return -EINVAL;
@@ -425,7 +425,7 @@ static int dm9000_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
 }
 
 static unsigned int
-dm9000_read_locked(board_info_t *db, int reg)
+dm9000_read_locked(struct board_info *db, int reg)
 {
         unsigned long flags;
         unsigned int ret;
@@ -437,7 +437,7 @@ dm9000_read_locked(board_info_t *db, int reg)
         return ret;
 }
 
-static int dm9000_wait_eeprom(board_info_t *db)
+static int dm9000_wait_eeprom(struct board_info *db)
 {
         unsigned int status;
         int timeout = 8;        /* wait max 8msec */
@@ -474,7 +474,7 @@ static int dm9000_wait_eeprom(board_info_t *db)
  *  Read a word data from EEPROM
  */
 static void
-dm9000_read_eeprom(board_info_t *db, int offset, u8 *to)
+dm9000_read_eeprom(struct board_info *db, int offset, u8 *to)
 {
         unsigned long flags;
 
@@ -514,7 +514,7 @@ dm9000_read_eeprom(board_info_t *db, int offset, u8 *to)
  * Write a word data to SROM
  */
 static void
-dm9000_write_eeprom(board_info_t *db, int offset, u8 *data)
+dm9000_write_eeprom(struct board_info *db, int offset, u8 *data)
 {
         unsigned long flags;
 
@@ -546,7 +546,7 @@ dm9000_write_eeprom(board_info_t *db, int offset, u8 *data)
 static void dm9000_get_drvinfo(struct net_device *dev,
                                struct ethtool_drvinfo *info)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
 
         strlcpy(info->driver, CARDNAME, sizeof(info->driver));
         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
@@ -556,21 +556,21 @@ static void dm9000_get_drvinfo(struct net_device *dev,
 
 static u32 dm9000_get_msglevel(struct net_device *dev)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
 
         return dm->msg_enable;
 }
 
 static void dm9000_set_msglevel(struct net_device *dev, u32 value)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
 
         dm->msg_enable = value;
 }
 
 static int dm9000_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
 
         mii_ethtool_gset(&dm->mii, cmd);
         return 0;
@@ -578,21 +578,21 @@ static int dm9000_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 
 static int dm9000_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
 
         return mii_ethtool_sset(&dm->mii, cmd);
 }
 
 static int dm9000_nway_reset(struct net_device *dev)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
         return mii_nway_restart(&dm->mii);
 }
 
 static int dm9000_set_features(struct net_device *dev,
         netdev_features_t features)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
         netdev_features_t changed = dev->features ^ features;
         unsigned long flags;
 
@@ -608,7 +608,7 @@ static int dm9000_set_features(struct net_device *dev,
 
 static u32 dm9000_get_link(struct net_device *dev)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
         u32 ret;
 
         if (dm->flags & DM9000_PLATF_EXT_PHY)
@@ -629,7 +629,7 @@ static int dm9000_get_eeprom_len(struct net_device *dev)
 static int dm9000_get_eeprom(struct net_device *dev,
                              struct ethtool_eeprom *ee, u8 *data)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
         int offset = ee->offset;
         int len = ee->len;
         int i;
@@ -653,7 +653,7 @@ static int dm9000_get_eeprom(struct net_device *dev,
 static int dm9000_set_eeprom(struct net_device *dev,
                              struct ethtool_eeprom *ee, u8 *data)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
         int offset = ee->offset;
         int len = ee->len;
         int done;
@@ -691,7 +691,7 @@ static int dm9000_set_eeprom(struct net_device *dev,
 
 static void dm9000_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
 
         memset(w, 0, sizeof(struct ethtool_wolinfo));
 
@@ -702,7 +702,7 @@ static void dm9000_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)
 
 static int dm9000_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
         unsigned long flags;
         u32 opts = w->wolopts;
         u32 wcr = 0;
@@ -752,7 +752,7 @@ static const struct ethtool_ops dm9000_ethtool_ops = {
         .set_eeprom             = dm9000_set_eeprom,
 };
 
-static void dm9000_show_carrier(board_info_t *db,
+static void dm9000_show_carrier(struct board_info *db,
                                 unsigned carrier, unsigned nsr)
 {
         int lpa;
@@ -775,7 +775,7 @@ static void
 dm9000_poll_work(struct work_struct *w)
 {
         struct delayed_work *dw = to_delayed_work(w);
-        board_info_t *db = container_of(dw, board_info_t, phy_poll);
+        struct board_info *db = container_of(dw, struct board_info, phy_poll);
         struct net_device *ndev = db->ndev;
 
         if (db->flags & DM9000_PLATF_SIMPLE_PHY &&
@@ -843,7 +843,7 @@ static unsigned char dm9000_type_to_char(enum dm9000_type type)
 static void
 dm9000_hash_table_unlocked(struct net_device *dev)
 {
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         struct netdev_hw_addr *ha;
         int i, oft;
         u32 hash_val;
@@ -879,7 +879,7 @@ dm9000_hash_table_unlocked(struct net_device *dev)
 static void
 dm9000_hash_table(struct net_device *dev)
 {
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         unsigned long flags;
 
         spin_lock_irqsave(&db->lock, flags);
@@ -888,13 +888,13 @@ dm9000_hash_table(struct net_device *dev)
 }
 
 static void
-dm9000_mask_interrupts(board_info_t *db)
+dm9000_mask_interrupts(struct board_info *db)
 {
         iow(db, DM9000_IMR, IMR_PAR);
 }
 
 static void
-dm9000_unmask_interrupts(board_info_t *db)
+dm9000_unmask_interrupts(struct board_info *db)
 {
         iow(db, DM9000_IMR, db->imr_all);
 }
@@ -905,7 +905,7 @@ dm9000_unmask_interrupts(board_info_t *db)
 static void
 dm9000_init_dm9000(struct net_device *dev)
 {
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         unsigned int imr;
         unsigned int ncr;
 
@@ -970,7 +970,7 @@ dm9000_init_dm9000(struct net_device *dev)
 /* Our watchdog timed out. Called by the networking layer */
 static void dm9000_timeout(struct net_device *dev)
 {
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         u8 reg_save;
         unsigned long flags;
 
@@ -996,7 +996,7 @@ static void dm9000_send_packet(struct net_device *dev,
                                int ip_summed,
                                u16 pkt_len)
 {
-        board_info_t *dm = to_dm9000_board(dev);
+        struct board_info *dm = to_dm9000_board(dev);
 
         /* The DM9000 is not smart enough to leave fragmented packets alone. */
         if (dm->ip_summed != ip_summed) {
@@ -1023,7 +1023,7 @@ static int
 dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         unsigned long flags;
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
 
         dm9000_dbg(db, 3, "%s:\n", __func__);
 
@@ -1062,7 +1062,7 @@ dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev)
  * receive the packet to upper layer, free the transmitted packet
  */
 
-static void dm9000_tx_done(struct net_device *dev, board_info_t *db)
+static void dm9000_tx_done(struct net_device *dev, struct board_info *db)
 {
         int tx_status = ior(db, DM9000_NSR);    /* Got TX status */
 
@@ -1094,7 +1094,7 @@ struct dm9000_rxhdr {
 static void
 dm9000_rx(struct net_device *dev)
 {
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         struct dm9000_rxhdr rxhdr;
         struct sk_buff *skb;
         u8 rxbyte, *rdptr;
@@ -1196,7 +1196,7 @@ dm9000_rx(struct net_device *dev)
 static irqreturn_t dm9000_interrupt(int irq, void *dev_id)
 {
         struct net_device *dev = dev_id;
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         int int_status;
         unsigned long flags;
         u8 reg_save;
@@ -1246,7 +1246,7 @@ static irqreturn_t dm9000_interrupt(int irq, void *dev_id)
 static irqreturn_t dm9000_wol_interrupt(int irq, void *dev_id)
 {
         struct net_device *dev = dev_id;
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         unsigned long flags;
         unsigned nsr, wcr;
 
@@ -1296,7 +1296,7 @@ static void dm9000_poll_controller(struct net_device *dev)
 static int
 dm9000_open(struct net_device *dev)
 {
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
         unsigned long irqflags = db->irq_res->flags & IRQF_TRIGGER_MASK;
 
         if (netif_msg_ifup(db))
@@ -1342,7 +1342,7 @@ dm9000_open(struct net_device *dev)
 static void
 dm9000_shutdown(struct net_device *dev)
 {
-        board_info_t *db = netdev_priv(dev);
+        struct board_info *db = netdev_priv(dev);
 
         /* RESET device */
         dm9000_phy_write(dev, 0, MII_BMCR, BMCR_RESET); /* PHY RESET */
@@ -1358,7 +1358,7 @@ dm9000_shutdown(struct net_device *dev)
 static int
 dm9000_stop(struct net_device *ndev)
 {
-        board_info_t *db = netdev_priv(ndev);
+        struct board_info *db = netdev_priv(ndev);
 
         if (netif_msg_ifdown(db))
                 dev_dbg(db->dev, "shutting down %s\n", ndev->name);
@@ -1681,7 +1681,7 @@ dm9000_drv_suspend(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct net_device *ndev = platform_get_drvdata(pdev);
-        board_info_t *db;
+        struct board_info *db;
 
         if (ndev) {
                 db = netdev_priv(ndev);
@@ -1704,7 +1704,7 @@ dm9000_drv_resume(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct net_device *ndev = platform_get_drvdata(pdev);
-        board_info_t *db = netdev_priv(ndev);
+        struct board_info *db = netdev_priv(ndev);
 
         if (ndev) {
                 if (netif_running(ndev)) {
diff --git a/drivers/net/ethernet/dec/tulip/de2104x.c b/drivers/net/ethernet/dec/tulip/de2104x.c
index 38148b0e3a95..a02ecc4f9002 100644
--- a/drivers/net/ethernet/dec/tulip/de2104x.c
+++ b/drivers/net/ethernet/dec/tulip/de2104x.c
@@ -340,7 +340,7 @@ static void de21041_media_timer (unsigned long data);
 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
 
 
-static DEFINE_PCI_DEVICE_TABLE(de_pci_tbl) = {
+static const struct pci_device_id de_pci_tbl[] = {
         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
diff --git a/drivers/net/ethernet/dec/tulip/de4x5.c b/drivers/net/ethernet/dec/tulip/de4x5.c
index 7091fa6ed096..cf8b6ff21613 100644
--- a/drivers/net/ethernet/dec/tulip/de4x5.c
+++ b/drivers/net/ethernet/dec/tulip/de4x5.c
@@ -2328,7 +2328,7 @@ static void de4x5_pci_remove(struct pci_dev *pdev)
         pci_disable_device (pdev);
 }
 
-static DEFINE_PCI_DEVICE_TABLE(de4x5_pci_tbl) = {
+static const struct pci_device_id de4x5_pci_tbl[] = {
         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
diff --git a/drivers/net/ethernet/dec/tulip/dmfe.c b/drivers/net/ethernet/dec/tulip/dmfe.c
index 53f0c618045c..322213d901d5 100644
--- a/drivers/net/ethernet/dec/tulip/dmfe.c
+++ b/drivers/net/ethernet/dec/tulip/dmfe.c
@@ -2096,7 +2096,7 @@ static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info * db)
 
 
 
-static DEFINE_PCI_DEVICE_TABLE(dmfe_pci_tbl) = {
+static const struct pci_device_id dmfe_pci_tbl[] = {
         { 0x1282, 0x9132, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9132_ID },
         { 0x1282, 0x9102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9102_ID },
         { 0x1282, 0x9100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9100_ID },
diff --git a/drivers/net/ethernet/dec/tulip/tulip_core.c b/drivers/net/ethernet/dec/tulip/tulip_core.c
index 861660841ce2..3b42556f7f8d 100644
--- a/drivers/net/ethernet/dec/tulip/tulip_core.c
+++ b/drivers/net/ethernet/dec/tulip/tulip_core.c
@@ -207,7 +207,7 @@ struct tulip_chip_table tulip_tbl[] = {
 };
 
 
-static DEFINE_PCI_DEVICE_TABLE(tulip_pci_tbl) = {
+static const struct pci_device_id tulip_pci_tbl[] = {
         { 0x1011, 0x0009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DC21140 },
         { 0x1011, 0x0019, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DC21143 },
         { 0x11AD, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, LC82C168 },
@@ -1294,7 +1294,7 @@ static const struct net_device_ops tulip_netdev_ops = {
 #endif
 };
 
-DEFINE_PCI_DEVICE_TABLE(early_486_chipsets) = {
+const struct pci_device_id early_486_chipsets[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82424) },
         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_496) },
         { },
diff --git a/drivers/net/ethernet/dec/tulip/uli526x.c b/drivers/net/ethernet/dec/tulip/uli526x.c
index 80afec335a11..4061f9b22812 100644
--- a/drivers/net/ethernet/dec/tulip/uli526x.c
+++ b/drivers/net/ethernet/dec/tulip/uli526x.c
@@ -1768,7 +1768,7 @@ static u16 phy_read_1bit(struct uli526x_board_info *db)
 }
 
 
-static DEFINE_PCI_DEVICE_TABLE(uli526x_pci_tbl) = {
+static const struct pci_device_id uli526x_pci_tbl[] = {
         { 0x10B9, 0x5261, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_ULI5261_ID },
         { 0x10B9, 0x5263, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_ULI5263_ID },
         { 0, }
diff --git a/drivers/net/ethernet/dec/tulip/winbond-840.c b/drivers/net/ethernet/dec/tulip/winbond-840.c
index 62fe512bb216..6aa887e0e1cb 100644
--- a/drivers/net/ethernet/dec/tulip/winbond-840.c
+++ b/drivers/net/ethernet/dec/tulip/winbond-840.c
@@ -219,7 +219,7 @@ enum chip_capability_flags {
         CanHaveMII=1, HasBrokenTx=2, AlwaysFDX=4, FDXOnNoMII=8,
 };
 
-static DEFINE_PCI_DEVICE_TABLE(w840_pci_tbl) = {
+static const struct pci_device_id w840_pci_tbl[] = {
         { 0x1050, 0x0840, PCI_ANY_ID, 0x8153,     0, 0, 0 },
         { 0x1050, 0x0840, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
         { 0x11f6, 0x2011, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
diff --git a/drivers/net/ethernet/dec/tulip/xircom_cb.c b/drivers/net/ethernet/dec/tulip/xircom_cb.c
index 6204cdfe43a6..0e721cedfa67 100644
--- a/drivers/net/ethernet/dec/tulip/xircom_cb.c
+++ b/drivers/net/ethernet/dec/tulip/xircom_cb.c
@@ -137,7 +137,7 @@ static int link_status(struct xircom_private *card);
 
 
 
-static DEFINE_PCI_DEVICE_TABLE(xircom_pci_table) = {
+static const struct pci_device_id xircom_pci_table[] = {
         { PCI_VDEVICE(XIRCOM, 0x0003), },
         {0,},
 };
diff --git a/drivers/net/ethernet/dlink/dl2k.h b/drivers/net/ethernet/dlink/dl2k.h
index 7d07a0f5320d..23c07b007069 100644
--- a/drivers/net/ethernet/dlink/dl2k.h
+++ b/drivers/net/ethernet/dlink/dl2k.h
@@ -408,7 +408,7 @@ struct netdev_private {
         driver_data             Data private to the driver.
 */
 
-static DEFINE_PCI_DEVICE_TABLE(rio_pci_tbl) = {
+static const struct pci_device_id rio_pci_tbl[] = {
         {0x1186, 0x4000, PCI_ANY_ID, PCI_ANY_ID, },
         {0x13f0, 0x1021, PCI_ANY_ID, PCI_ANY_ID, },
         { }
diff --git a/drivers/net/ethernet/dlink/sundance.c b/drivers/net/ethernet/dlink/sundance.c
index 433c1e185442..a28a2e583f0f 100644
--- a/drivers/net/ethernet/dlink/sundance.c
+++ b/drivers/net/ethernet/dlink/sundance.c
@@ -199,7 +199,7 @@ IVc. Errata
 #define USE_IO_OPS 1
 #endif
 
-static DEFINE_PCI_DEVICE_TABLE(sundance_pci_tbl) = {
+static const struct pci_device_id sundance_pci_tbl[] = {
         { 0x1186, 0x1002, 0x1186, 0x1002, 0, 0, 0 },
         { 0x1186, 0x1002, 0x1186, 0x1003, 0, 0, 1 },
         { 0x1186, 0x1002, 0x1186, 0x1012, 0, 0, 2 },
diff --git a/drivers/net/ethernet/emulex/benet/be.h b/drivers/net/ethernet/emulex/benet/be.h
index 811f1351db7a..43e08d0bc3d3 100644
--- a/drivers/net/ethernet/emulex/benet/be.h
+++ b/drivers/net/ethernet/emulex/benet/be.h
@@ -897,5 +897,6 @@ void be_roce_dev_remove(struct be_adapter *);
  */
 void be_roce_dev_open(struct be_adapter *);
 void be_roce_dev_close(struct be_adapter *);
+void be_roce_dev_shutdown(struct be_adapter *);
 
 #endif                          /* BE_H */
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index db4ff14ff18f..93ff8ef39352 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -39,7 +39,7 @@ static ushort rx_frag_size = 2048;
 module_param(rx_frag_size, ushort, S_IRUGO);
 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
 
-static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
+static const struct pci_device_id be_dev_ids[] = {
         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
@@ -5014,6 +5014,7 @@ static void be_shutdown(struct pci_dev *pdev)
         if (!adapter)
                 return;
 
+        be_roce_dev_shutdown(adapter);
         cancel_delayed_work_sync(&adapter->work);
         cancel_delayed_work_sync(&adapter->func_recovery_work);
 
diff --git a/drivers/net/ethernet/emulex/benet/be_roce.c b/drivers/net/ethernet/emulex/benet/be_roce.c
index 5bf16603a3e9..ef4672dc7357 100644
--- a/drivers/net/ethernet/emulex/benet/be_roce.c
+++ b/drivers/net/ethernet/emulex/benet/be_roce.c
@@ -120,7 +120,8 @@ static void _be_roce_dev_open(struct be_adapter *adapter)
 {
         if (ocrdma_drv && adapter->ocrdma_dev &&
             ocrdma_drv->state_change_handler)
-                ocrdma_drv->state_change_handler(adapter->ocrdma_dev, 0);
+                ocrdma_drv->state_change_handler(adapter->ocrdma_dev,
+                                                 BE_DEV_UP);
 }
 
 void be_roce_dev_open(struct be_adapter *adapter)
@@ -136,7 +137,8 @@ static void _be_roce_dev_close(struct be_adapter *adapter)
 {
         if (ocrdma_drv && adapter->ocrdma_dev &&
             ocrdma_drv->state_change_handler)
-                ocrdma_drv->state_change_handler(adapter->ocrdma_dev, 1);
+                ocrdma_drv->state_change_handler(adapter->ocrdma_dev,
+                                                 BE_DEV_DOWN);
 }
 
 void be_roce_dev_close(struct be_adapter *adapter)
@@ -148,6 +150,18 @@ void be_roce_dev_close(struct be_adapter *adapter)
         }
 }
 
+void be_roce_dev_shutdown(struct be_adapter *adapter)
+{
+        if (be_roce_supported(adapter)) {
+                mutex_lock(&be_adapter_list_lock);
+                if (ocrdma_drv && adapter->ocrdma_dev &&
+                    ocrdma_drv->state_change_handler)
+                        ocrdma_drv->state_change_handler(adapter->ocrdma_dev,
+                                                         BE_DEV_SHUTDOWN);
+                mutex_unlock(&be_adapter_list_lock);
+        }
+}
+
 int be_roce_register_driver(struct ocrdma_driver *drv)
 {
         struct be_adapter *dev;
diff --git a/drivers/net/ethernet/emulex/benet/be_roce.h b/drivers/net/ethernet/emulex/benet/be_roce.h
index a3d9e96c18eb..e6f7eb1a7d87 100644
--- a/drivers/net/ethernet/emulex/benet/be_roce.h
+++ b/drivers/net/ethernet/emulex/benet/be_roce.h
@@ -62,7 +62,8 @@ struct ocrdma_driver {
 
 enum {
         BE_DEV_UP       = 0,
-        BE_DEV_DOWN     = 1
+        BE_DEV_DOWN     = 1,
+        BE_DEV_SHUTDOWN = 2
 };
 
 /* APIs for RoCE driver to register callback handlers,
diff --git a/drivers/net/ethernet/fealnx.c b/drivers/net/ethernet/fealnx.c
index 4b22a9579f85..b1b9ebafb354 100644
--- a/drivers/net/ethernet/fealnx.c
+++ b/drivers/net/ethernet/fealnx.c
@@ -1936,7 +1936,7 @@ static int netdev_close(struct net_device *dev)
         return 0;
 }
 
-static DEFINE_PCI_DEVICE_TABLE(fealnx_pci_tbl) = {
+static const struct pci_device_id fealnx_pci_tbl[] = {
         {0x1516, 0x0800, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {0x1516, 0x0803, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
         {0x1516, 0x0891, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
diff --git a/drivers/net/ethernet/freescale/fec.h b/drivers/net/ethernet/freescale/fec.h
index bd53caf1c1eb..9f7fa644a397 100644
--- a/drivers/net/ethernet/freescale/fec.h
+++ b/drivers/net/ethernet/freescale/fec.h
@@ -310,6 +310,7 @@ struct fec_enet_private {
         int     mii_timeout;
         uint    phy_speed;
         phy_interface_t phy_interface;
+        struct device_node *phy_node;
         int     link;
         int     full_duplex;
         int     speed;
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c
index 66fe1f672499..4f87dffcb9b2 100644
--- a/drivers/net/ethernet/freescale/fec_main.c
+++ b/drivers/net/ethernet/freescale/fec_main.c
@@ -52,6 +52,7 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_gpio.h>
+#include <linux/of_mdio.h>
 #include <linux/of_net.h>
 #include <linux/regulator/consumer.h>
 #include <linux/if_vlan.h>
@@ -1648,29 +1649,37 @@ static int fec_enet_mii_probe(struct net_device *ndev)
 
         fep->phy_dev = NULL;
 
-        /* check for attached phy */
-        for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
-                if ((fep->mii_bus->phy_mask & (1 << phy_id)))
-                        continue;
-                if (fep->mii_bus->phy_map[phy_id] == NULL)
-                        continue;
-                if (fep->mii_bus->phy_map[phy_id]->phy_id == 0)
-                        continue;
-                if (dev_id--)
-                        continue;
-                strncpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
-                break;
-        }
+        if (fep->phy_node) {
+                phy_dev = of_phy_connect(ndev, fep->phy_node,
+                                         &fec_enet_adjust_link, 0,
+                                         fep->phy_interface);
+        } else {
+                /* check for attached phy */
+                for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
+                        if ((fep->mii_bus->phy_mask & (1 << phy_id)))
+                                continue;
+                        if (fep->mii_bus->phy_map[phy_id] == NULL)
+                                continue;
+                        if (fep->mii_bus->phy_map[phy_id]->phy_id == 0)
+                                continue;
+                        if (dev_id--)
+                                continue;
+                        strncpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
+                        break;
+                }
 
-        if (phy_id >= PHY_MAX_ADDR) {
-                netdev_info(ndev, "no PHY, assuming direct connection to switch\n");
-                strncpy(mdio_bus_id, "fixed-0", MII_BUS_ID_SIZE);
-                phy_id = 0;
+                if (phy_id >= PHY_MAX_ADDR) {
+                        netdev_info(ndev, "no PHY, assuming direct connection to switch\n");
+                        strncpy(mdio_bus_id, "fixed-0", MII_BUS_ID_SIZE);
+                        phy_id = 0;
+                }
+
+                snprintf(phy_name, sizeof(phy_name),
+                         PHY_ID_FMT, mdio_bus_id, phy_id);
+                phy_dev = phy_connect(ndev, phy_name, &fec_enet_adjust_link,
+                                      fep->phy_interface);
         }
 
-        snprintf(phy_name, sizeof(phy_name), PHY_ID_FMT, mdio_bus_id, phy_id);
-        phy_dev = phy_connect(ndev, phy_name, &fec_enet_adjust_link,
-                              fep->phy_interface);
         if (IS_ERR(phy_dev)) {
                 netdev_err(ndev, "could not attach to PHY\n");
                 return PTR_ERR(phy_dev);
@@ -1707,6 +1716,7 @@ static int fec_enet_mii_init(struct platform_device *pdev)
         struct fec_enet_private *fep = netdev_priv(ndev);
         const struct platform_device_id *id_entry =
                                 platform_get_device_id(fep->pdev);
+        struct device_node *node;
         int err = -ENXIO, i;
 
         /*
@@ -1774,7 +1784,15 @@ static int fec_enet_mii_init(struct platform_device *pdev)
         for (i = 0; i < PHY_MAX_ADDR; i++)
                 fep->mii_bus->irq[i] = PHY_POLL;
 
-        if (mdiobus_register(fep->mii_bus))
+        node = of_get_child_by_name(pdev->dev.of_node, "mdio");
+        if (node) {
+                err = of_mdiobus_register(fep->mii_bus, node);
+                of_node_put(node);
+        } else {
+                err = mdiobus_register(fep->mii_bus);
+        }
+
+        if (err)
                 goto err_out_free_mdio_irq;
 
         mii_cnt++;
@@ -2527,6 +2545,7 @@ fec_probe(struct platform_device *pdev)
         struct resource *r;
         const struct of_device_id *of_id;
         static int dev_id;
+        struct device_node *np = pdev->dev.of_node, *phy_node;
 
         of_id = of_match_device(fec_dt_ids, &pdev->dev);
         if (of_id)
@@ -2566,6 +2585,18 @@ fec_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, ndev);
 
+        phy_node = of_parse_phandle(np, "phy-handle", 0);
+        if (!phy_node && of_phy_is_fixed_link(np)) {
+                ret = of_phy_register_fixed_link(np);
+                if (ret < 0) {
+                        dev_err(&pdev->dev,
+                                "broken fixed-link specification\n");
+                        goto failed_phy;
+                }
+                phy_node = of_node_get(np);
+        }
+        fep->phy_node = phy_node;
+
         ret = of_get_phy_mode(pdev->dev.of_node);
         if (ret < 0) {
                 pdata = dev_get_platdata(&pdev->dev);
@@ -2670,6 +2701,8 @@ failed_init:
 failed_regulator:
         fec_enet_clk_enable(ndev, false);
 failed_clk:
+failed_phy:
+        of_node_put(phy_node);
 failed_ioremap:
         free_netdev(ndev);
 
@@ -2691,6 +2724,7 @@ fec_drv_remove(struct platform_device *pdev)
         if (fep->ptp_clock)
                 ptp_clock_unregister(fep->ptp_clock);
         fec_enet_clk_enable(ndev, false);
+        of_node_put(fep->phy_node);
         free_netdev(ndev);
 
         return 0;
diff --git a/drivers/net/ethernet/freescale/fec_mpc52xx.c b/drivers/net/ethernet/freescale/fec_mpc52xx.c
index 9947765e90c5..ff55fbb20a75 100644
--- a/drivers/net/ethernet/freescale/fec_mpc52xx.c
+++ b/drivers/net/ethernet/freescale/fec_mpc52xx.c
@@ -1015,8 +1015,7 @@ mpc52xx_fec_remove(struct platform_device *op)
 
         unregister_netdev(ndev);
 
-        if (priv->phy_node)
-                of_node_put(priv->phy_node);
+        of_node_put(priv->phy_node);
         priv->phy_node = NULL;
 
         irq_dispose_mapping(ndev->irq);
diff --git a/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c b/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
index cfaf17b70f3f..748fd24d3d9e 100644
--- a/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
+++ b/drivers/net/ethernet/freescale/fs_enet/fs_enet-main.c
@@ -1033,7 +1033,7 @@ static int fs_enet_probe(struct platform_device *ofdev)
                 /* In the case of a fixed PHY, the DT node associated
                  * to the PHY is the Ethernet MAC DT node.
                  */
-                fpi->phy_node = ofdev->dev.of_node;
+                fpi->phy_node = of_node_get(ofdev->dev.of_node);
         }
 
         if (of_device_is_compatible(ofdev->dev.of_node, "fsl,mpc5125-fec")) {
diff --git a/drivers/net/ethernet/freescale/fs_enet/mac-fec.c b/drivers/net/ethernet/freescale/fs_enet/mac-fec.c
index fc5413488496..1eedfba2ad3c 100644
--- a/drivers/net/ethernet/freescale/fs_enet/mac-fec.c
+++ b/drivers/net/ethernet/freescale/fs_enet/mac-fec.c
@@ -41,7 +41,6 @@
 #ifdef CONFIG_8xx
 #include <asm/8xx_immap.h>
 #include <asm/pgtable.h>
-#include <asm/mpc8xx.h>
 #include <asm/cpm1.h>
 #endif
 
diff --git a/drivers/net/ethernet/freescale/fs_enet/mac-scc.c b/drivers/net/ethernet/freescale/fs_enet/mac-scc.c
index b4bf02f57d43..90b3b19b7cd3 100644
--- a/drivers/net/ethernet/freescale/fs_enet/mac-scc.c
+++ b/drivers/net/ethernet/freescale/fs_enet/mac-scc.c
@@ -40,7 +40,6 @@
 #ifdef CONFIG_8xx
 #include <asm/8xx_immap.h>
 #include <asm/pgtable.h>
-#include <asm/mpc8xx.h>
 #include <asm/cpm1.h>
 #endif
 
diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
index a6cf40e62f3a..fb29d049f4e1 100644
--- a/drivers/net/ethernet/freescale/gianfar.c
+++ b/drivers/net/ethernet/freescale/gianfar.c
@@ -892,12 +892,12 @@ static int gfar_of_init(struct platform_device *ofdev, struct net_device **pdev)
         /* In the case of a fixed PHY, the DT node associated
          * to the PHY is the Ethernet MAC DT node.
          */
-        if (of_phy_is_fixed_link(np)) {
+        if (!priv->phy_node && of_phy_is_fixed_link(np)) {
                 err = of_phy_register_fixed_link(np);
                 if (err)
                         goto err_grp_init;
 
-                priv->phy_node = np;
+                priv->phy_node = of_node_get(np);
         }
 
         /* Find the TBI PHY.  If it's not there, we don't support SGMII */
@@ -1435,10 +1435,8 @@ register_fail:
         unmap_group_regs(priv);
         gfar_free_rx_queues(priv);
         gfar_free_tx_queues(priv);
-        if (priv->phy_node)
-                of_node_put(priv->phy_node);
-        if (priv->tbi_node)
-                of_node_put(priv->tbi_node);
+        of_node_put(priv->phy_node);
+        of_node_put(priv->tbi_node);
         free_gfar_dev(priv);
         return err;
 }
@@ -1447,10 +1445,8 @@ static int gfar_remove(struct platform_device *ofdev)
 {
         struct gfar_private *priv = platform_get_drvdata(ofdev);
 
-        if (priv->phy_node)
-                of_node_put(priv->phy_node);
-        if (priv->tbi_node)
-                of_node_put(priv->tbi_node);
+        of_node_put(priv->phy_node);
+        of_node_put(priv->tbi_node);
 
         unregister_netdev(priv->ndev);
         unmap_group_regs(priv);
diff --git a/drivers/net/ethernet/freescale/ucc_geth.c b/drivers/net/ethernet/freescale/ucc_geth.c
index 8ceaf7a2660c..3cf0478b3728 100644
--- a/drivers/net/ethernet/freescale/ucc_geth.c
+++ b/drivers/net/ethernet/freescale/ucc_geth.c
@@ -3785,16 +3785,15 @@ static int ucc_geth_probe(struct platform_device* ofdev)
         ug_info->uf_info.irq = irq_of_parse_and_map(np, 0);
 
         ug_info->phy_node = of_parse_phandle(np, "phy-handle", 0);
-        if (!ug_info->phy_node) {
-                /* In the case of a fixed PHY, the DT node associated
+        if (!ug_info->phy_node && of_phy_is_fixed_link(np)) {
+                /*
+                 * In the case of a fixed PHY, the DT node associated
                  * to the PHY is the Ethernet MAC DT node.
                  */
-                if (of_phy_is_fixed_link(np)) {
-                        err = of_phy_register_fixed_link(np);
-                        if (err)
-                                return err;
-                }
-                ug_info->phy_node = np;
+                err = of_phy_register_fixed_link(np);
+                if (err)
+                        return err;
+                ug_info->phy_node = of_node_get(np);
         }
 
         /* Find the TBI PHY node.  If it's not there, we don't support SGMII */
@@ -3862,8 +3861,11 @@ static int ucc_geth_probe(struct platform_device* ofdev)
         /* Create an ethernet device instance */
         dev = alloc_etherdev(sizeof(*ugeth));
 
-        if (dev == NULL)
+        if (dev == NULL) {
+                of_node_put(ug_info->tbi_node);
+                of_node_put(ug_info->phy_node);
                 return -ENOMEM;
+        }
 
         ugeth = netdev_priv(dev);
         spin_lock_init(&ugeth->lock);
@@ -3897,6 +3899,8 @@ static int ucc_geth_probe(struct platform_device* ofdev)
                         pr_err("%s: Cannot register net device, aborting\n",
                                dev->name);
                 free_netdev(dev);
+                of_node_put(ug_info->tbi_node);
+                of_node_put(ug_info->phy_node);
                 return err;
         }
 
@@ -3920,6 +3924,8 @@ static int ucc_geth_remove(struct platform_device* ofdev)
         unregister_netdev(dev);
         free_netdev(dev);
         ucc_geth_memclean(ugeth);
+        of_node_put(ugeth->ug_info->tbi_node);
+        of_node_put(ugeth->ug_info->phy_node);
 
         return 0;
 }
diff --git a/drivers/net/ethernet/fujitsu/fmvj18x_cs.c b/drivers/net/ethernet/fujitsu/fmvj18x_cs.c
index cfe7a7431730..a7139f588ad2 100644
--- a/drivers/net/ethernet/fujitsu/fmvj18x_cs.c
+++ b/drivers/net/ethernet/fujitsu/fmvj18x_cs.c
@@ -99,23 +99,23 @@ static const struct ethtool_ops netdev_ethtool_ops;
 /*
     card type
  */
-typedef enum { MBH10302, MBH10304, TDK, CONTEC, LA501, UNGERMANN, 
+enum cardtype { MBH10302, MBH10304, TDK, CONTEC, LA501, UNGERMANN,
                XXX10304, NEC, KME
-} cardtype_t;
+};
 
 /*
     driver specific data structure
 */
-typedef struct local_info_t {
+struct local_info {
         struct pcmcia_device    *p_dev;
     long open_time;
     uint tx_started:1;
     uint tx_queue;
     u_short tx_queue_len;
-    cardtype_t cardtype;
+    enum cardtype cardtype;
     u_short sent;
     u_char __iomem *base;
-} local_info_t;
+};
 
 #define MC_FILTERBREAK 64
 
@@ -232,13 +232,13 @@ static const struct net_device_ops fjn_netdev_ops = {
 
 static int fmvj18x_probe(struct pcmcia_device *link)
 {
-    local_info_t *lp;
+    struct local_info *lp;
     struct net_device *dev;
 
     dev_dbg(&link->dev, "fmvj18x_attach()\n");
 
     /* Make up a FMVJ18x specific data structure */
-    dev = alloc_etherdev(sizeof(local_info_t));
+    dev = alloc_etherdev(sizeof(struct local_info));
     if (!dev)
         return -ENOMEM;
     lp = netdev_priv(dev);
@@ -327,10 +327,10 @@ static int fmvj18x_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
 static int fmvj18x_config(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
-    local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     int i, ret;
     unsigned int ioaddr;
-    cardtype_t cardtype;
+    enum cardtype cardtype;
     char *card_name = "unknown";
     u8 *buf;
     size_t len;
@@ -584,7 +584,7 @@ static int fmvj18x_setup_mfc(struct pcmcia_device *link)
     int i;
     struct net_device *dev = link->priv;
     unsigned int ioaddr;
-    local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
 
     /* Allocate a small memory window */
     link->resource[3]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
@@ -626,7 +626,7 @@ static void fmvj18x_release(struct pcmcia_device *link)
 {
 
     struct net_device *dev = link->priv;
-    local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     u_char __iomem *tmp;
 
     dev_dbg(&link->dev, "fmvj18x_release\n");
@@ -711,7 +711,7 @@ module_pcmcia_driver(fmvj18x_cs_driver);
 static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
 {
     struct net_device *dev = dev_id;
-    local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     unsigned int ioaddr;
     unsigned short tx_stat, rx_stat;
 
@@ -772,7 +772,7 @@ static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
 
 static void fjn_tx_timeout(struct net_device *dev)
 {
-    struct local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     unsigned int ioaddr = dev->base_addr;
 
     netdev_notice(dev, "transmit timed out with status %04x, %s?\n",
@@ -802,7 +802,7 @@ static void fjn_tx_timeout(struct net_device *dev)
 static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
                                         struct net_device *dev)
 {
-    struct local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     unsigned int ioaddr = dev->base_addr;
     short length = skb->len;
     
@@ -874,7 +874,7 @@ static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
 
 static void fjn_reset(struct net_device *dev)
 {
-    struct local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     unsigned int ioaddr = dev->base_addr;
     int i;
 
@@ -1058,7 +1058,7 @@ static int fjn_config(struct net_device *dev, struct ifmap *map){
 
 static int fjn_open(struct net_device *dev)
 {
-    struct local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     struct pcmcia_device *link = lp->p_dev;
 
     pr_debug("fjn_open('%s').\n", dev->name);
@@ -1083,7 +1083,7 @@ static int fjn_open(struct net_device *dev)
 
 static int fjn_close(struct net_device *dev)
 {
-    struct local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     struct pcmcia_device *link = lp->p_dev;
     unsigned int ioaddr = dev->base_addr;
 
diff --git a/drivers/net/ethernet/hp/hp100.c b/drivers/net/ethernet/hp/hp100.c
index 37860096f744..ed7916f6fbcf 100644
--- a/drivers/net/ethernet/hp/hp100.c
+++ b/drivers/net/ethernet/hp/hp100.c
@@ -208,7 +208,7 @@ MODULE_DEVICE_TABLE(eisa, hp100_eisa_tbl);
 #endif
 
 #ifdef CONFIG_PCI
-static DEFINE_PCI_DEVICE_TABLE(hp100_pci_tbl) = {
+static const struct pci_device_id hp100_pci_tbl[] = {
         {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585A, PCI_ANY_ID, PCI_ANY_ID,},
         {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2585B, PCI_ANY_ID, PCI_ANY_ID,},
         {PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_J2970A, PCI_ANY_ID, PCI_ANY_ID,},
diff --git a/drivers/net/ethernet/ibm/ehea/Makefile b/drivers/net/ethernet/ibm/ehea/Makefile
index 775d9969b5c2..cd473e295242 100644
--- a/drivers/net/ethernet/ibm/ehea/Makefile
+++ b/drivers/net/ethernet/ibm/ehea/Makefile
@@ -1,6 +1,6 @@
 #
 # Makefile for the eHEA ethernet device driver for IBM eServer System p
 #
-ehea-y = ehea_main.o ehea_phyp.o ehea_qmr.o ehea_ethtool.o ehea_phyp.o
+ehea-y = ehea_main.o ehea_phyp.o ehea_qmr.o ehea_ethtool.o
 obj-$(CONFIG_EHEA) += ehea.o
 
diff --git a/drivers/net/ethernet/icplus/ipg.c b/drivers/net/ethernet/icplus/ipg.c
index 5727779a7df2..ff2903652f4b 100644
--- a/drivers/net/ethernet/icplus/ipg.c
+++ b/drivers/net/ethernet/icplus/ipg.c
@@ -95,7 +95,7 @@ static const char * const ipg_brand_name[] = {
         "D-Link NIC IP1000A"
 };
 
-static DEFINE_PCI_DEVICE_TABLE(ipg_pci_tbl) = {
+static const struct pci_device_id ipg_pci_tbl[] = {
         { PCI_VDEVICE(SUNDANCE, 0x1023), 0 },
         { PCI_VDEVICE(SUNDANCE, 0x2021), 1 },
         { PCI_VDEVICE(DLINK,    0x9021), 2 },
diff --git a/drivers/net/ethernet/intel/e100.c b/drivers/net/ethernet/intel/e100.c
index 9d979d7debef..781065eb5431 100644
--- a/drivers/net/ethernet/intel/e100.c
+++ b/drivers/net/ethernet/intel/e100.c
@@ -208,7 +208,7 @@ MODULE_PARM_DESC(use_io, "Force use of i/o access mode");
 #define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {\
         PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, \
         PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }
-static DEFINE_PCI_DEVICE_TABLE(e100_id_table) = {
+static const struct pci_device_id e100_id_table[] = {
         INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),
         INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),
         INTEL_8255X_ETHERNET_DEVICE(0x1031, 3),
diff --git a/drivers/net/ethernet/intel/e1000/e1000_main.c b/drivers/net/ethernet/intel/e1000/e1000_main.c
index 660971f304b2..cbc330b301cd 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_main.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_main.c
@@ -46,7 +46,7 @@ static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation
  * Macro expands to...
  *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
  */
-static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
+static const struct pci_device_id e1000_pci_tbl[] = {
         INTEL_E1000_ETHERNET_DEVICE(0x1000),
         INTEL_E1000_ETHERNET_DEVICE(0x1001),
         INTEL_E1000_ETHERNET_DEVICE(0x1004),
diff --git a/drivers/net/ethernet/intel/e1000e/manage.c b/drivers/net/ethernet/intel/e1000e/manage.c
index 58856032298d..06edfca1a35e 100644
--- a/drivers/net/ethernet/intel/e1000e/manage.c
+++ b/drivers/net/ethernet/intel/e1000e/manage.c
@@ -47,7 +47,7 @@ static u8 e1000_calculate_checksum(u8 *buffer, u32 length)
  *  e1000_mng_enable_host_if - Checks host interface is enabled
  *  @hw: pointer to the HW structure
  *
- *  Returns E1000_success upon success, else E1000_ERR_HOST_INTERFACE_COMMAND
+ *  Returns 0 upon success, else -E1000_ERR_HOST_INTERFACE_COMMAND
  *
  *  This function checks whether the HOST IF is enabled for command operation
  *  and also checks whether the previous command is completed.  It busy waits
@@ -78,7 +78,7 @@ static s32 e1000_mng_enable_host_if(struct e1000_hw *hw)
         }
 
         if (i == E1000_MNG_DHCP_COMMAND_TIMEOUT) {
-                e_dbg("Previous command timeout failed .\n");
+                e_dbg("Previous command timeout failed.\n");
                 return -E1000_ERR_HOST_INTERFACE_COMMAND;
         }
 
diff --git a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
index 681a9e81ff51..e8ba7470700a 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_ethtool.c
@@ -1948,7 +1948,7 @@ static int i40e_update_ethtool_fdir_entry(struct i40e_vsi *vsi,
 
         /* add filter to the list */
         if (parent)
-                hlist_add_after(&parent->fdir_node, &input->fdir_node);
+                hlist_add_behind(&input->fdir_node, &parent->fdir_node);
         else
                 hlist_add_head(&input->fdir_node,
                                &pf->fdir_filter_list);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_fcoe.c b/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
index 6938fc1ad877..5d01db1d789b 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_fcoe.c
@@ -33,6 +33,7 @@
 #include <scsi/fc/fc_fcoe.h>
 #include <scsi/libfc.h>
 #include <scsi/libfcoe.h>
+#include <uapi/linux/dcbnl.h>
 
 #include "i40e.h"
 #include "i40e_fcoe.h"
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index 51bc03072ed3..eddec6ba095b 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -65,7 +65,7 @@ static int i40e_veb_get_bw_info(struct i40e_veb *veb);
  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  *   Class, Class Mask, private data (not used) }
  */
-static DEFINE_PCI_DEVICE_TABLE(i40e_pci_tbl) = {
+static const struct pci_device_id i40e_pci_tbl[] = {
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_XL710), 0},
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_QEMU), 0},
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_A), 0},
@@ -4415,13 +4415,13 @@ static void i40e_print_link_message(struct i40e_vsi *vsi, bool isup)
 
         switch (vsi->back->hw.phy.link_info.link_speed) {
         case I40E_LINK_SPEED_40GB:
-                strncpy(speed, "40 Gbps", SPEED_SIZE);
+                strlcpy(speed, "40 Gbps", SPEED_SIZE);
                 break;
         case I40E_LINK_SPEED_10GB:
-                strncpy(speed, "10 Gbps", SPEED_SIZE);
+                strlcpy(speed, "10 Gbps", SPEED_SIZE);
                 break;
         case I40E_LINK_SPEED_1GB:
-                strncpy(speed, "1000 Mbps", SPEED_SIZE);
+                strlcpy(speed, "1000 Mbps", SPEED_SIZE);
                 break;
         default:
                 break;
@@ -4429,16 +4429,16 @@ static void i40e_print_link_message(struct i40e_vsi *vsi, bool isup)
 
         switch (vsi->back->hw.fc.current_mode) {
         case I40E_FC_FULL:
-                strncpy(fc, "RX/TX", FC_SIZE);
+                strlcpy(fc, "RX/TX", FC_SIZE);
                 break;
         case I40E_FC_TX_PAUSE:
-                strncpy(fc, "TX", FC_SIZE);
+                strlcpy(fc, "TX", FC_SIZE);
                 break;
         case I40E_FC_RX_PAUSE:
-                strncpy(fc, "RX", FC_SIZE);
+                strlcpy(fc, "RX", FC_SIZE);
                 break;
         default:
-                strncpy(fc, "None", FC_SIZE);
+                strlcpy(fc, "None", FC_SIZE);
                 break;
         }
 
@@ -5839,7 +5839,7 @@ static void i40e_send_version(struct i40e_pf *pf)
         dv.minor_version = DRV_VERSION_MINOR;
         dv.build_version = DRV_VERSION_BUILD;
         dv.subbuild_version = 0;
-        strncpy(dv.driver_string, DRV_VERSION, sizeof(dv.driver_string));
+        strlcpy(dv.driver_string, DRV_VERSION, sizeof(dv.driver_string));
         i40e_aq_send_driver_version(&pf->hw, &dv, NULL);
 }
 
@@ -6293,7 +6293,7 @@ static int i40e_vsi_alloc_arrays(struct i40e_vsi *vsi, bool alloc_qvectors)
 
         if (alloc_qvectors) {
                 /* allocate memory for q_vector pointers */
-                size = sizeof(struct i40e_q_vectors *) * vsi->num_q_vectors;
+                size = sizeof(struct i40e_q_vector *) * vsi->num_q_vectors;
                 vsi->q_vectors = kzalloc(size, GFP_KERNEL);
                 if (!vsi->q_vectors) {
                         ret = -ENOMEM;
diff --git a/drivers/net/ethernet/intel/i40e/i40e_nvm.c b/drivers/net/ethernet/intel/i40e/i40e_nvm.c
index 97bda3dffd49..25c4f9a3011f 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_nvm.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_nvm.c
@@ -251,9 +251,9 @@ i40e_status i40e_read_nvm_buffer(struct i40e_hw *hw, u16 offset,
  *
  * Writes a 16 bit words buffer to the Shadow RAM using the admin command.
  **/
-i40e_status i40e_write_nvm_aq(struct i40e_hw *hw, u8 module_pointer,
-                              u32 offset, u16 words, void *data,
-                              bool last_command)
+static i40e_status i40e_write_nvm_aq(struct i40e_hw *hw, u8 module_pointer,
+                                     u32 offset, u16 words, void *data,
+                                     bool last_command)
 {
         i40e_status ret_code = I40E_ERR_NVM;
 
diff --git a/drivers/net/ethernet/intel/i40evf/i40evf_main.c b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
index ab15f4d07e41..38429fae4fcf 100644
--- a/drivers/net/ethernet/intel/i40evf/i40evf_main.c
+++ b/drivers/net/ethernet/intel/i40evf/i40evf_main.c
@@ -49,7 +49,7 @@ static const char i40evf_copyright[] =
  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  *   Class, Class Mask, private data (not used) }
  */
-static DEFINE_PCI_DEVICE_TABLE(i40evf_pci_tbl) = {
+static const struct pci_device_id i40evf_pci_tbl[] = {
         {PCI_VDEVICE(INTEL, I40E_DEV_ID_VF), 0},
         /* required last entry */
         {0, }
diff --git a/drivers/net/ethernet/intel/igbvf/netdev.c b/drivers/net/ethernet/intel/igbvf/netdev.c
index d608599e123a..63c807c9b21c 100644
--- a/drivers/net/ethernet/intel/igbvf/netdev.c
+++ b/drivers/net/ethernet/intel/igbvf/netdev.c
@@ -2853,7 +2853,7 @@ static const struct pci_error_handlers igbvf_err_handler = {
         .resume = igbvf_io_resume,
 };
 
-static DEFINE_PCI_DEVICE_TABLE(igbvf_pci_tbl) = {
+static const struct pci_device_id igbvf_pci_tbl[] = {
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_VF), board_vf },
         { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_VF), board_i350_vf },
         { } /* terminate list */
diff --git a/drivers/net/ethernet/intel/ixgb/ixgb_main.c b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
index 60801273915c..055961b0f24b 100644
--- a/drivers/net/ethernet/intel/ixgb/ixgb_main.c
+++ b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
@@ -53,7 +53,7 @@ MODULE_PARM_DESC(copybreak,
  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  *   Class, Class Mask, private data (not used) }
  */
-static DEFINE_PCI_DEVICE_TABLE(ixgb_pci_tbl) = {
+static const struct pci_device_id ixgb_pci_tbl[] = {
         {PCI_VENDOR_ID_INTEL, IXGB_DEVICE_ID_82597EX,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         {PCI_VENDOR_ID_INTEL, IXGB_DEVICE_ID_82597EX_CX4,
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
index 94a1c07efeb0..e4100b5737b6 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
@@ -2517,7 +2517,7 @@ static int ixgbe_update_ethtool_fdir_entry(struct ixgbe_adapter *adapter,
 
         /* add filter to the list */
         if (parent)
-                hlist_add_after(&parent->fdir_node, &input->fdir_node);
+                hlist_add_behind(&input->fdir_node, &parent->fdir_node);
         else
                 hlist_add_head(&input->fdir_node,
                                &adapter->fdir_filter_list);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index 5384ed30298a..87bd53fdd209 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -84,7 +84,7 @@ static const struct ixgbe_info *ixgbe_info_tbl[] = {
  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  *   Class, Class Mask, private data (not used) }
  */
-static DEFINE_PCI_DEVICE_TABLE(ixgbe_pci_tbl) = {
+static const struct pci_device_id ixgbe_pci_tbl[] = {
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598), board_82598 },
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AF_DUAL_PORT), board_82598 },
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AF_SINGLE_PORT), board_82598 },
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
index 75467f83772c..c22a00c3621a 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
@@ -76,7 +76,7 @@ static const struct ixgbevf_info *ixgbevf_info_tbl[] = {
  * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
  *   Class, Class Mask, private data (not used) }
  */
-static DEFINE_PCI_DEVICE_TABLE(ixgbevf_pci_tbl) = {
+static const struct pci_device_id ixgbevf_pci_tbl[] = {
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_VF), board_82599_vf },
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540_VF), board_X540_vf },
         /* required last entry */
diff --git a/drivers/net/ethernet/jme.c b/drivers/net/ethernet/jme.c
index b78378cea5e3..4a1be34d7214 100644
--- a/drivers/net/ethernet/jme.c
+++ b/drivers/net/ethernet/jme.c
@@ -3334,7 +3334,7 @@ static SIMPLE_DEV_PM_OPS(jme_pm_ops, jme_suspend, jme_resume);
 #define JME_PM_OPS NULL
 #endif
 
-static DEFINE_PCI_DEVICE_TABLE(jme_pci_tbl) = {
+static const struct pci_device_id jme_pci_tbl[] = {
         { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMC250) },
         { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMC260) },
         { }
diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
index dadd9a5f6323..c9f1d1b7ef37 100644
--- a/drivers/net/ethernet/marvell/mvneta.c
+++ b/drivers/net/ethernet/marvell/mvneta.c
@@ -2969,14 +2969,14 @@ static int mvneta_probe(struct platform_device *pdev)
                 /* In the case of a fixed PHY, the DT node associated
                  * to the PHY is the Ethernet MAC DT node.
                  */
-                phy_node = dn;
+                phy_node = of_node_get(dn);
         }
 
         phy_mode = of_get_phy_mode(dn);
         if (phy_mode < 0) {
                 dev_err(&pdev->dev, "incorrect phy-mode\n");
                 err = -EINVAL;
-                goto err_free_irq;
+                goto err_put_phy_node;
         }
 
         dev->tx_queue_len = MVNETA_MAX_TXD;
@@ -2992,7 +2992,7 @@ static int mvneta_probe(struct platform_device *pdev)
         pp->clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(pp->clk)) {
                 err = PTR_ERR(pp->clk);
-                goto err_free_irq;
+                goto err_put_phy_node;
         }
 
         clk_prepare_enable(pp->clk);
@@ -3071,6 +3071,8 @@ err_free_stats:
         free_percpu(pp->stats);
 err_clk:
         clk_disable_unprepare(pp->clk);
+err_put_phy_node:
+        of_node_put(phy_node);
 err_free_irq:
         irq_dispose_mapping(dev->irq);
 err_free_netdev:
@@ -3088,6 +3090,7 @@ static int mvneta_remove(struct platform_device *pdev)
         clk_disable_unprepare(pp->clk);
         free_percpu(pp->stats);
         irq_dispose_mapping(dev->irq);
+        of_node_put(pp->phy_node);
         free_netdev(dev);
 
         return 0;
diff --git a/drivers/net/ethernet/marvell/skge.c b/drivers/net/ethernet/marvell/skge.c
index e912b6887d40..24b242277ea1 100644
--- a/drivers/net/ethernet/marvell/skge.c
+++ b/drivers/net/ethernet/marvell/skge.c
@@ -82,7 +82,7 @@ static int debug = -1;	/* defaults above */
 module_param(debug, int, 0);
 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 
-static DEFINE_PCI_DEVICE_TABLE(skge_id_table) = {
+static const struct pci_device_id skge_id_table[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_3COM, 0x1700) },       /* 3Com 3C940 */
         { PCI_DEVICE(PCI_VENDOR_ID_3COM, 0x80EB) },       /* 3Com 3C940B */
 #ifdef CONFIG_SKGE_GENESIS
diff --git a/drivers/net/ethernet/marvell/sky2.c b/drivers/net/ethernet/marvell/sky2.c
index 69693384b58c..dba48a5ce7ab 100644
--- a/drivers/net/ethernet/marvell/sky2.c
+++ b/drivers/net/ethernet/marvell/sky2.c
@@ -101,7 +101,7 @@ static int legacy_pme = 0;
 module_param(legacy_pme, int, 0);
 MODULE_PARM_DESC(legacy_pme, "Legacy power management");
 
-static DEFINE_PCI_DEVICE_TABLE(sky2_id_table) = {
+static const struct pci_device_id sky2_id_table[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9000) }, /* SK-9Sxx */
         { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9E00) }, /* SK-9Exx */
         { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9E01) }, /* SK-9E21M */
@@ -1622,11 +1622,10 @@ static int sky2_alloc_buffers(struct sky2_port *sky2)
         if (!sky2->tx_ring)
                 goto nomem;
 
-        sky2->rx_le = pci_alloc_consistent(hw->pdev, RX_LE_BYTES,
-                                           &sky2->rx_le_map);
+        sky2->rx_le = pci_zalloc_consistent(hw->pdev, RX_LE_BYTES,
+                                            &sky2->rx_le_map);
         if (!sky2->rx_le)
                 goto nomem;
-        memset(sky2->rx_le, 0, RX_LE_BYTES);
 
         sky2->rx_ring = kcalloc(sky2->rx_pending, sizeof(struct rx_ring_info),
                                 GFP_KERNEL);
diff --git a/drivers/net/ethernet/mellanox/mlx4/cmd.c b/drivers/net/ethernet/mellanox/mlx4/cmd.c
index 5d940a26055c..65a4a0f88ea0 100644
--- a/drivers/net/ethernet/mellanox/mlx4/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx4/cmd.c
@@ -1311,6 +1311,15 @@ static struct mlx4_cmd_info cmd_info[] = {
                 .wrapper = mlx4_MAD_IFC_wrapper
         },
         {
+                .opcode = MLX4_CMD_MAD_DEMUX,
+                .has_inbox = false,
+                .has_outbox = false,
+                .out_is_imm = false,
+                .encode_slave_id = false,
+                .verify = NULL,
+                .wrapper = mlx4_CMD_EPERM_wrapper
+        },
+        {
                 .opcode = MLX4_CMD_QUERY_IF_STAT,
                 .has_inbox = false,
                 .has_outbox = true,
diff --git a/drivers/net/ethernet/mellanox/mlx4/fw.c b/drivers/net/ethernet/mellanox/mlx4/fw.c
index 688e1eabab29..494753e44ae3 100644
--- a/drivers/net/ethernet/mellanox/mlx4/fw.c
+++ b/drivers/net/ethernet/mellanox/mlx4/fw.c
@@ -136,7 +136,8 @@ static void dump_dev_cap_flags2(struct mlx4_dev *dev, u64 flags)
                 [7] = "FSM (MAC anti-spoofing) support",
                 [8] = "Dynamic QP updates support",
                 [9] = "Device managed flow steering IPoIB support",
-                [10] = "TCP/IP offloads/flow-steering for VXLAN support"
+                [10] = "TCP/IP offloads/flow-steering for VXLAN support",
+                [11] = "MAD DEMUX (Secure-Host) support"
         };
         int i;
 
@@ -571,6 +572,7 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
 #define QUERY_DEV_CAP_MAX_ICM_SZ_OFFSET         0xa0
 #define QUERY_DEV_CAP_FW_REASSIGN_MAC           0x9d
 #define QUERY_DEV_CAP_VXLAN                     0x9e
+#define QUERY_DEV_CAP_MAD_DEMUX_OFFSET          0xb0
 
         dev_cap->flags2 = 0;
         mailbox = mlx4_alloc_cmd_mailbox(dev);
@@ -748,6 +750,11 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
                 MLX4_GET(dev_cap->max_counters, outbox,
                          QUERY_DEV_CAP_MAX_COUNTERS_OFFSET);
 
+        MLX4_GET(field32, outbox,
+                 QUERY_DEV_CAP_MAD_DEMUX_OFFSET);
+        if (field32 & (1 << 0))
+                dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_MAD_DEMUX;
+
         MLX4_GET(field32, outbox, QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET);
         if (field32 & (1 << 16))
                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_UPDATE_QP;
@@ -2016,3 +2023,85 @@ void mlx4_opreq_action(struct work_struct *work)
 out:
         mlx4_free_cmd_mailbox(dev, mailbox);
 }
+
+static int mlx4_check_smp_firewall_active(struct mlx4_dev *dev,
+                                          struct mlx4_cmd_mailbox *mailbox)
+{
+#define MLX4_CMD_MAD_DEMUX_SET_ATTR_OFFSET              0x10
+#define MLX4_CMD_MAD_DEMUX_GETRESP_ATTR_OFFSET          0x20
+#define MLX4_CMD_MAD_DEMUX_TRAP_ATTR_OFFSET             0x40
+#define MLX4_CMD_MAD_DEMUX_TRAP_REPRESS_ATTR_OFFSET     0x70
+
+        u32 set_attr_mask, getresp_attr_mask;
+        u32 trap_attr_mask, traprepress_attr_mask;
+
+        MLX4_GET(set_attr_mask, mailbox->buf,
+                 MLX4_CMD_MAD_DEMUX_SET_ATTR_OFFSET);
+        mlx4_dbg(dev, "SMP firewall set_attribute_mask = 0x%x\n",
+                 set_attr_mask);
+
+        MLX4_GET(getresp_attr_mask, mailbox->buf,
+                 MLX4_CMD_MAD_DEMUX_GETRESP_ATTR_OFFSET);
+        mlx4_dbg(dev, "SMP firewall getresp_attribute_mask = 0x%x\n",
+                 getresp_attr_mask);
+
+        MLX4_GET(trap_attr_mask, mailbox->buf,
+                 MLX4_CMD_MAD_DEMUX_TRAP_ATTR_OFFSET);
+        mlx4_dbg(dev, "SMP firewall trap_attribute_mask = 0x%x\n",
+                 trap_attr_mask);
+
+        MLX4_GET(traprepress_attr_mask, mailbox->buf,
+                 MLX4_CMD_MAD_DEMUX_TRAP_REPRESS_ATTR_OFFSET);
+        mlx4_dbg(dev, "SMP firewall traprepress_attribute_mask = 0x%x\n",
+                 traprepress_attr_mask);
+
+        if (set_attr_mask && getresp_attr_mask && trap_attr_mask &&
+            traprepress_attr_mask)
+                return 1;
+
+        return 0;
+}
+
+int mlx4_config_mad_demux(struct mlx4_dev *dev)
+{
+        struct mlx4_cmd_mailbox *mailbox;
+        int secure_host_active;
+        int err;
+
+        /* Check if mad_demux is supported */
+        if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_MAD_DEMUX))
+                return 0;
+
+        mailbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(mailbox)) {
+                mlx4_warn(dev, "Failed to allocate mailbox for cmd MAD_DEMUX");
+                return -ENOMEM;
+        }
+
+        /* Query mad_demux to find out which MADs are handled by internal sma */
+        err = mlx4_cmd_box(dev, 0, mailbox->dma, 0x01 /* subn mgmt class */,
+                           MLX4_CMD_MAD_DEMUX_QUERY_RESTR, MLX4_CMD_MAD_DEMUX,
+                           MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
+        if (err) {
+                mlx4_warn(dev, "MLX4_CMD_MAD_DEMUX: query restrictions failed (%d)\n",
+                          err);
+                goto out;
+        }
+
+        secure_host_active = mlx4_check_smp_firewall_active(dev, mailbox);
+
+        /* Config mad_demux to handle all MADs returned by the query above */
+        err = mlx4_cmd(dev, mailbox->dma, 0x01 /* subn mgmt class */,
+                       MLX4_CMD_MAD_DEMUX_CONFIG, MLX4_CMD_MAD_DEMUX,
+                       MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
+        if (err) {
+                mlx4_warn(dev, "MLX4_CMD_MAD_DEMUX: configure failed (%d)\n", err);
+                goto out;
+        }
+
+        if (secure_host_active)
+                mlx4_warn(dev, "HCA operating in secure-host mode. SMP firewall activated.\n");
+out:
+        mlx4_free_cmd_mailbox(dev, mailbox);
+        return err;
+}
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index 80b8c5f30e4e..7e2d5d57c598 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -1853,6 +1853,11 @@ static int mlx4_setup_hca(struct mlx4_dev *dev)
                         mlx4_err(dev, "Failed to initialize multicast group table, aborting\n");
                         goto err_mr_table_free;
                 }
+                err = mlx4_config_mad_demux(dev);
+                if (err) {
+                        mlx4_err(dev, "Failed in config_mad_demux, aborting\n");
+                        goto err_mcg_table_free;
+                }
         }
 
         err = mlx4_init_eq_table(dev);
@@ -2727,7 +2732,7 @@ int mlx4_restart_one(struct pci_dev *pdev)
         return __mlx4_init_one(pdev, pci_dev_data);
 }
 
-static DEFINE_PCI_DEVICE_TABLE(mlx4_pci_table) = {
+static const struct pci_device_id mlx4_pci_table[] = {
         /* MT25408 "Hermon" SDR */
         { PCI_VDEVICE(MELLANOX, 0x6340), MLX4_PCI_DEV_FORCE_SENSE_PORT },
         /* MT25408 "Hermon" DDR */
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4.h b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
index 13fbcd03c3e4..b508c7887ef8 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
@@ -274,6 +274,8 @@ struct mlx4_icm_table {
 #define MLX4_MPT_FLAG_PHYSICAL      (1 <<  9)
 #define MLX4_MPT_FLAG_REGION        (1 <<  8)
 
+#define MLX4_MPT_PD_MASK            (0x1FFFFUL)
+#define MLX4_MPT_PD_VF_MASK         (0xFE0000UL)
 #define MLX4_MPT_PD_FLAG_FAST_REG   (1 << 27)
 #define MLX4_MPT_PD_FLAG_RAE        (1 << 28)
 #define MLX4_MPT_PD_FLAG_EN_INV     (3 << 24)
@@ -1306,5 +1308,6 @@ void mlx4_init_quotas(struct mlx4_dev *dev);
 int mlx4_get_slave_num_gids(struct mlx4_dev *dev, int slave, int port);
 /* Returns the VF index of slave */
 int mlx4_get_vf_indx(struct mlx4_dev *dev, int slave);
+int mlx4_config_mad_demux(struct mlx4_dev *dev);
 
 #endif /* MLX4_H */
diff --git a/drivers/net/ethernet/mellanox/mlx4/mr.c b/drivers/net/ethernet/mellanox/mlx4/mr.c
index 2839abb878a6..7d717eccb7b0 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mr.c
+++ b/drivers/net/ethernet/mellanox/mlx4/mr.c
@@ -298,6 +298,131 @@ static int mlx4_HW2SW_MPT(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox
                             MLX4_CMD_TIME_CLASS_B, MLX4_CMD_WRAPPED);
 }
 
+int mlx4_mr_hw_get_mpt(struct mlx4_dev *dev, struct mlx4_mr *mmr,
+                       struct mlx4_mpt_entry ***mpt_entry)
+{
+        int err;
+        int key = key_to_hw_index(mmr->key) & (dev->caps.num_mpts - 1);
+        struct mlx4_cmd_mailbox *mailbox = NULL;
+
+        /* Make sure that at this point we have single-threaded access only */
+
+        if (mmr->enabled != MLX4_MPT_EN_HW)
+                return -EINVAL;
+
+        err = mlx4_HW2SW_MPT(dev, NULL, key);
+
+        if (err) {
+                mlx4_warn(dev, "HW2SW_MPT failed (%d).", err);
+                mlx4_warn(dev, "Most likely the MR has MWs bound to it.\n");
+                return err;
+        }
+
+        mmr->enabled = MLX4_MPT_EN_SW;
+
+        if (!mlx4_is_mfunc(dev)) {
+                **mpt_entry = mlx4_table_find(
+                                &mlx4_priv(dev)->mr_table.dmpt_table,
+                                key, NULL);
+        } else {
+                mailbox = mlx4_alloc_cmd_mailbox(dev);
+                if (IS_ERR_OR_NULL(mailbox))
+                        return PTR_ERR(mailbox);
+
+                err = mlx4_cmd_box(dev, 0, mailbox->dma, key,
+                                   0, MLX4_CMD_QUERY_MPT,
+                                   MLX4_CMD_TIME_CLASS_B,
+                                   MLX4_CMD_WRAPPED);
+
+                if (err)
+                        goto free_mailbox;
+
+                *mpt_entry = (struct mlx4_mpt_entry **)&mailbox->buf;
+        }
+
+        if (!(*mpt_entry) || !(**mpt_entry)) {
+                err = -ENOMEM;
+                goto free_mailbox;
+        }
+
+        return 0;
+
+free_mailbox:
+        mlx4_free_cmd_mailbox(dev, mailbox);
+        return err;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_get_mpt);
+
+int mlx4_mr_hw_write_mpt(struct mlx4_dev *dev, struct mlx4_mr *mmr,
+                         struct mlx4_mpt_entry **mpt_entry)
+{
+        int err;
+
+        if (!mlx4_is_mfunc(dev)) {
+                /* Make sure any changes to this entry are flushed */
+                wmb();
+
+                *(u8 *)(*mpt_entry) = MLX4_MPT_STATUS_HW;
+
+                /* Make sure the new status is written */
+                wmb();
+
+                err = mlx4_SYNC_TPT(dev);
+        } else {
+                int key = key_to_hw_index(mmr->key) & (dev->caps.num_mpts - 1);
+
+                struct mlx4_cmd_mailbox *mailbox =
+                        container_of((void *)mpt_entry, struct mlx4_cmd_mailbox,
+                                     buf);
+
+                err = mlx4_SW2HW_MPT(dev, mailbox, key);
+        }
+
+        mmr->pd = be32_to_cpu((*mpt_entry)->pd_flags) & MLX4_MPT_PD_MASK;
+        if (!err)
+                mmr->enabled = MLX4_MPT_EN_HW;
+        return err;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_write_mpt);
+
+void mlx4_mr_hw_put_mpt(struct mlx4_dev *dev,
+                        struct mlx4_mpt_entry **mpt_entry)
+{
+        if (mlx4_is_mfunc(dev)) {
+                struct mlx4_cmd_mailbox *mailbox =
+                        container_of((void *)mpt_entry, struct mlx4_cmd_mailbox,
+                                     buf);
+                mlx4_free_cmd_mailbox(dev, mailbox);
+        }
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_put_mpt);
+
+int mlx4_mr_hw_change_pd(struct mlx4_dev *dev, struct mlx4_mpt_entry *mpt_entry,
+                         u32 pdn)
+{
+        u32 pd_flags = be32_to_cpu(mpt_entry->pd_flags);
+        /* The wrapper function will put the slave's id here */
+        if (mlx4_is_mfunc(dev))
+                pd_flags &= ~MLX4_MPT_PD_VF_MASK;
+        mpt_entry->pd_flags = cpu_to_be32((pd_flags &  ~MLX4_MPT_PD_MASK) |
+                                          (pdn & MLX4_MPT_PD_MASK)
+                                          | MLX4_MPT_PD_FLAG_EN_INV);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_change_pd);
+
+int mlx4_mr_hw_change_access(struct mlx4_dev *dev,
+                             struct mlx4_mpt_entry *mpt_entry,
+                             u32 access)
+{
+        u32 flags = (be32_to_cpu(mpt_entry->flags) & ~MLX4_PERM_MASK) |
+                    (access & MLX4_PERM_MASK);
+
+        mpt_entry->flags = cpu_to_be32(flags);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_change_access);
+
 static int mlx4_mr_alloc_reserved(struct mlx4_dev *dev, u32 mridx, u32 pd,
                            u64 iova, u64 size, u32 access, int npages,
                            int page_shift, struct mlx4_mr *mr)
@@ -463,6 +588,41 @@ int mlx4_mr_free(struct mlx4_dev *dev, struct mlx4_mr *mr)
 }
 EXPORT_SYMBOL_GPL(mlx4_mr_free);
 
+void mlx4_mr_rereg_mem_cleanup(struct mlx4_dev *dev, struct mlx4_mr *mr)
+{
+        mlx4_mtt_cleanup(dev, &mr->mtt);
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_rereg_mem_cleanup);
+
+int mlx4_mr_rereg_mem_write(struct mlx4_dev *dev, struct mlx4_mr *mr,
+                            u64 iova, u64 size, int npages,
+                            int page_shift, struct mlx4_mpt_entry *mpt_entry)
+{
+        int err;
+
+        mpt_entry->start       = cpu_to_be64(mr->iova);
+        mpt_entry->length      = cpu_to_be64(mr->size);
+        mpt_entry->entity_size = cpu_to_be32(mr->mtt.page_shift);
+
+        err = mlx4_mtt_init(dev, npages, page_shift, &mr->mtt);
+        if (err)
+                return err;
+
+        if (mr->mtt.order < 0) {
+                mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_PHYSICAL);
+                mpt_entry->mtt_addr = 0;
+        } else {
+                mpt_entry->mtt_addr = cpu_to_be64(mlx4_mtt_addr(dev,
+                                                  &mr->mtt));
+                if (mr->mtt.page_shift == 0)
+                        mpt_entry->mtt_sz    = cpu_to_be32(1 << mr->mtt.order);
+        }
+        mr->enabled = MLX4_MPT_EN_SW;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_rereg_mem_write);
+
 int mlx4_mr_enable(struct mlx4_dev *dev, struct mlx4_mr *mr)
 {
         struct mlx4_cmd_mailbox *mailbox;
diff --git a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
index 0efc1368e5a8..1089367fed22 100644
--- a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
+++ b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
@@ -2613,12 +2613,34 @@ int mlx4_QUERY_MPT_wrapper(struct mlx4_dev *dev, int slave,
         if (err)
                 return err;
 
-        if (mpt->com.from_state != RES_MPT_HW) {
+        if (mpt->com.from_state == RES_MPT_MAPPED) {
+                /* In order to allow rereg in SRIOV, we need to alter the MPT entry. To do
+                 * that, the VF must read the MPT. But since the MPT entry memory is not
+                 * in the VF's virtual memory space, it must use QUERY_MPT to obtain the
+                 * entry contents. To guarantee that the MPT cannot be changed, the driver
+                 * must perform HW2SW_MPT before this query and return the MPT entry to HW
+                 * ownership fofollowing the change. The change here allows the VF to
+                 * perform QUERY_MPT also when the entry is in SW ownership.
+                 */
+                struct mlx4_mpt_entry *mpt_entry = mlx4_table_find(
+                                        &mlx4_priv(dev)->mr_table.dmpt_table,
+                                        mpt->key, NULL);
+
+                if (NULL == mpt_entry || NULL == outbox->buf) {
+                        err = -EINVAL;
+                        goto out;
+                }
+
+                memcpy(outbox->buf, mpt_entry, sizeof(*mpt_entry));
+
+                err = 0;
+        } else if (mpt->com.from_state == RES_MPT_HW) {
+                err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
+        } else {
                 err = -EBUSY;
                 goto out;
         }
 
-        err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
 
 out:
         put_res(dev, slave, id, RES_MPT);
diff --git a/drivers/net/ethernet/micrel/ksz884x.c b/drivers/net/ethernet/micrel/ksz884x.c
index 064a48d0c368..f1ebed6c63b1 100644
--- a/drivers/net/ethernet/micrel/ksz884x.c
+++ b/drivers/net/ethernet/micrel/ksz884x.c
@@ -4409,14 +4409,13 @@ static int ksz_alloc_desc(struct dev_info *adapter)
                 DESC_ALIGNMENT;
 
         adapter->desc_pool.alloc_virt =
-                pci_alloc_consistent(
-                        adapter->pdev, adapter->desc_pool.alloc_size,
-                        &adapter->desc_pool.dma_addr);
+                pci_zalloc_consistent(adapter->pdev,
+                                      adapter->desc_pool.alloc_size,
+                                      &adapter->desc_pool.dma_addr);
         if (adapter->desc_pool.alloc_virt == NULL) {
                 adapter->desc_pool.alloc_size = 0;
                 return 1;
         }
-        memset(adapter->desc_pool.alloc_virt, 0, adapter->desc_pool.alloc_size);
 
         /* Align to the next cache line boundary. */
         offset = (((ulong) adapter->desc_pool.alloc_virt % DESC_ALIGNMENT) ?
@@ -7222,7 +7221,7 @@ static int pcidev_suspend(struct pci_dev *pdev, pm_message_t state)
 
 static char pcidev_name[] = "ksz884xp";
 
-static DEFINE_PCI_DEVICE_TABLE(pcidev_table) = {
+static const struct pci_device_id pcidev_table[] = {
         { PCI_VENDOR_ID_MICREL_KS, 0x8841,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
         { PCI_VENDOR_ID_MICREL_KS, 0x8842,
diff --git a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
index f3d5d79f1cd1..9e7e3f1dce3e 100644
--- a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
+++ b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
@@ -574,6 +574,7 @@ myri10ge_validate_firmware(struct myri10ge_priv *mgp,
 
         /* save firmware version for ethtool */
         strncpy(mgp->fw_version, hdr->version, sizeof(mgp->fw_version));
+        mgp->fw_version[sizeof(mgp->fw_version) - 1] = '\0';
 
         sscanf(mgp->fw_version, "%d.%d.%d", &mgp->fw_ver_major,
                &mgp->fw_ver_minor, &mgp->fw_ver_tiny);
@@ -872,6 +873,10 @@ static int myri10ge_dma_test(struct myri10ge_priv *mgp, int test_type)
                 return -ENOMEM;
         dmatest_bus = pci_map_page(mgp->pdev, dmatest_page, 0, PAGE_SIZE,
                                    DMA_BIDIRECTIONAL);
+        if (unlikely(pci_dma_mapping_error(mgp->pdev, dmatest_bus))) {
+                __free_page(dmatest_page);
+                return -ENOMEM;
+        }
 
         /* Run a small DMA test.
          * The magic multipliers to the length tell the firmware
@@ -1293,6 +1298,7 @@ myri10ge_alloc_rx_pages(struct myri10ge_priv *mgp, struct myri10ge_rx_buf *rx,
                         int bytes, int watchdog)
 {
         struct page *page;
+        dma_addr_t bus;
         int idx;
 #if MYRI10GE_ALLOC_SIZE > 4096
         int end_offset;
@@ -1317,11 +1323,21 @@ myri10ge_alloc_rx_pages(struct myri10ge_priv *mgp, struct myri10ge_rx_buf *rx,
                                         rx->watchdog_needed = 1;
                                 return;
                         }
+
+                        bus = pci_map_page(mgp->pdev, page, 0,
+                                           MYRI10GE_ALLOC_SIZE,
+                                           PCI_DMA_FROMDEVICE);
+                        if (unlikely(pci_dma_mapping_error(mgp->pdev, bus))) {
+                                __free_pages(page, MYRI10GE_ALLOC_ORDER);
+                                if (rx->fill_cnt - rx->cnt < 16)
+                                        rx->watchdog_needed = 1;
+                                return;
+                        }
+
                         rx->page = page;
                         rx->page_offset = 0;
-                        rx->bus = pci_map_page(mgp->pdev, page, 0,
-                                               MYRI10GE_ALLOC_SIZE,
-                                               PCI_DMA_FROMDEVICE);
+                        rx->bus = bus;
+
                 }
                 rx->info[idx].page = rx->page;
                 rx->info[idx].page_offset = rx->page_offset;
@@ -2763,6 +2779,35 @@ myri10ge_submit_req(struct myri10ge_tx_buf *tx, struct mcp_kreq_ether_send *src,
         mb();
 }
 
+static void myri10ge_unmap_tx_dma(struct myri10ge_priv *mgp,
+                                  struct myri10ge_tx_buf *tx, int idx)
+{
+        unsigned int len;
+        int last_idx;
+
+        /* Free any DMA resources we've alloced and clear out the skb slot */
+        last_idx = (idx + 1) & tx->mask;
+        idx = tx->req & tx->mask;
+        do {
+                len = dma_unmap_len(&tx->info[idx], len);
+                if (len) {
+                        if (tx->info[idx].skb != NULL)
+                                pci_unmap_single(mgp->pdev,
+                                                 dma_unmap_addr(&tx->info[idx],
+                                                                bus), len,
+                                                 PCI_DMA_TODEVICE);
+                        else
+                                pci_unmap_page(mgp->pdev,
+                                               dma_unmap_addr(&tx->info[idx],
+                                                              bus), len,
+                                               PCI_DMA_TODEVICE);
+                        dma_unmap_len_set(&tx->info[idx], len, 0);
+                        tx->info[idx].skb = NULL;
+                }
+                idx = (idx + 1) & tx->mask;
+        } while (idx != last_idx);
+}
+
 /*
  * Transmit a packet.  We need to split the packet so that a single
  * segment does not cross myri10ge->tx_boundary, so this makes segment
@@ -2786,7 +2831,7 @@ static netdev_tx_t myri10ge_xmit(struct sk_buff *skb,
         u32 low;
         __be32 high_swapped;
         unsigned int len;
-        int idx, last_idx, avail, frag_cnt, frag_idx, count, mss, max_segments;
+        int idx, avail, frag_cnt, frag_idx, count, mss, max_segments;
         u16 pseudo_hdr_offset, cksum_offset, queue;
         int cum_len, seglen, boundary, rdma_count;
         u8 flags, odd_flag;
@@ -2883,9 +2928,12 @@ again:
 
         /* map the skb for DMA */
         len = skb_headlen(skb);
+        bus = pci_map_single(mgp->pdev, skb->data, len, PCI_DMA_TODEVICE);
+        if (unlikely(pci_dma_mapping_error(mgp->pdev, bus)))
+                goto drop;
+
         idx = tx->req & tx->mask;
         tx->info[idx].skb = skb;
-        bus = pci_map_single(mgp->pdev, skb->data, len, PCI_DMA_TODEVICE);
         dma_unmap_addr_set(&tx->info[idx], bus, bus);
         dma_unmap_len_set(&tx->info[idx], len, len);
 
@@ -2984,12 +3032,16 @@ again:
                         break;
 
                 /* map next fragment for DMA */
-                idx = (count + tx->req) & tx->mask;
                 frag = &skb_shinfo(skb)->frags[frag_idx];
                 frag_idx++;
                 len = skb_frag_size(frag);
                 bus = skb_frag_dma_map(&mgp->pdev->dev, frag, 0, len,
                                        DMA_TO_DEVICE);
+                if (unlikely(pci_dma_mapping_error(mgp->pdev, bus))) {
+                        myri10ge_unmap_tx_dma(mgp, tx, idx);
+                        goto drop;
+                }
+                idx = (count + tx->req) & tx->mask;
                 dma_unmap_addr_set(&tx->info[idx], bus, bus);
                 dma_unmap_len_set(&tx->info[idx], len, len);
         }
@@ -3020,31 +3072,8 @@ again:
         return NETDEV_TX_OK;
 
 abort_linearize:
-        /* Free any DMA resources we've alloced and clear out the skb
-         * slot so as to not trip up assertions, and to avoid a
-         * double-free if linearizing fails */
+        myri10ge_unmap_tx_dma(mgp, tx, idx);
 
-        last_idx = (idx + 1) & tx->mask;
-        idx = tx->req & tx->mask;
-        tx->info[idx].skb = NULL;
-        do {
-                len = dma_unmap_len(&tx->info[idx], len);
-                if (len) {
-                        if (tx->info[idx].skb != NULL)
-                                pci_unmap_single(mgp->pdev,
-                                                 dma_unmap_addr(&tx->info[idx],
-                                                                bus), len,
-                                                 PCI_DMA_TODEVICE);
-                        else
-                                pci_unmap_page(mgp->pdev,
-                                               dma_unmap_addr(&tx->info[idx],
-                                                              bus), len,
-                                               PCI_DMA_TODEVICE);
-                        dma_unmap_len_set(&tx->info[idx], len, 0);
-                        tx->info[idx].skb = NULL;
-                }
-                idx = (idx + 1) & tx->mask;
-        } while (idx != last_idx);
         if (skb_is_gso(skb)) {
                 netdev_err(mgp->dev, "TSO but wanted to linearize?!?!?\n");
                 goto drop;
@@ -4213,7 +4242,7 @@ static void myri10ge_remove(struct pci_dev *pdev)
 #define PCI_DEVICE_ID_MYRICOM_MYRI10GE_Z8E      0x0008
 #define PCI_DEVICE_ID_MYRICOM_MYRI10GE_Z8E_9    0x0009
 
-static DEFINE_PCI_DEVICE_TABLE(myri10ge_pci_tbl) = {
+static const struct pci_device_id myri10ge_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_MYRICOM, PCI_DEVICE_ID_MYRICOM_MYRI10GE_Z8E)},
         {PCI_DEVICE
          (PCI_VENDOR_ID_MYRICOM, PCI_DEVICE_ID_MYRICOM_MYRI10GE_Z8E_9)},
diff --git a/drivers/net/ethernet/natsemi/natsemi.c b/drivers/net/ethernet/natsemi/natsemi.c
index 291fba8b9f07..b83f7c0fcf99 100644
--- a/drivers/net/ethernet/natsemi/natsemi.c
+++ b/drivers/net/ethernet/natsemi/natsemi.c
@@ -247,7 +247,7 @@ static struct {
         { "NatSemi DP8381[56]", 0, 24 },
 };
 
-static DEFINE_PCI_DEVICE_TABLE(natsemi_pci_tbl) = {
+static const struct pci_device_id natsemi_pci_tbl[] = {
         { PCI_VENDOR_ID_NS, 0x0020, 0x12d9,     0x000c,     0, 0, 0 },
         { PCI_VENDOR_ID_NS, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
         { }     /* terminate list */
diff --git a/drivers/net/ethernet/natsemi/ns83820.c b/drivers/net/ethernet/natsemi/ns83820.c
index 19bb8244b9e3..2552e550a78c 100644
--- a/drivers/net/ethernet/natsemi/ns83820.c
+++ b/drivers/net/ethernet/natsemi/ns83820.c
@@ -2260,7 +2260,7 @@ static void ns83820_remove_one(struct pci_dev *pci_dev)
         free_netdev(ndev);
 }
 
-static DEFINE_PCI_DEVICE_TABLE(ns83820_pci_tbl) = {
+static const struct pci_device_id ns83820_pci_tbl[] = {
         { 0x100b, 0x0022, PCI_ANY_ID, PCI_ANY_ID, 0, .driver_data = 0, },
         { 0, },
 };
diff --git a/drivers/net/ethernet/neterion/s2io.c b/drivers/net/ethernet/neterion/s2io.c
index be587647c706..f5e4b820128b 100644
--- a/drivers/net/ethernet/neterion/s2io.c
+++ b/drivers/net/ethernet/neterion/s2io.c
@@ -471,7 +471,7 @@ module_param_array(rts_frm_len, uint, NULL, 0);
  * S2IO device table.
  * This table lists all the devices that this driver supports.
  */
-static DEFINE_PCI_DEVICE_TABLE(s2io_tbl) = {
+static const struct pci_device_id s2io_tbl[] = {
         {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_S2IO_WIN,
          PCI_ANY_ID, PCI_ANY_ID},
         {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_S2IO_UNI,
diff --git a/drivers/net/ethernet/neterion/vxge/vxge-main.c b/drivers/net/ethernet/neterion/vxge/vxge-main.c
index 2eda153cb1e0..4f40d7b8629e 100644
--- a/drivers/net/ethernet/neterion/vxge/vxge-main.c
+++ b/drivers/net/ethernet/neterion/vxge/vxge-main.c
@@ -63,7 +63,7 @@ MODULE_LICENSE("Dual BSD/GPL");
 MODULE_DESCRIPTION("Neterion's X3100 Series 10GbE PCIe I/O"
         "Virtualized Server Adapter");
 
-static DEFINE_PCI_DEVICE_TABLE(vxge_id_table) = {
+static const struct pci_device_id vxge_id_table[] = {
         {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_TITAN_WIN, PCI_ANY_ID,
         PCI_ANY_ID},
         {PCI_VENDOR_ID_S2IO, PCI_DEVICE_ID_TITAN_UNI, PCI_ANY_ID,
diff --git a/drivers/net/ethernet/nvidia/forcedeth.c b/drivers/net/ethernet/nvidia/forcedeth.c
index 9afc536c5734..925b296d8ab8 100644
--- a/drivers/net/ethernet/nvidia/forcedeth.c
+++ b/drivers/net/ethernet/nvidia/forcedeth.c
@@ -6185,7 +6185,7 @@ static void nv_shutdown(struct pci_dev *pdev)
 #define nv_shutdown NULL
 #endif /* CONFIG_PM */
 
-static DEFINE_PCI_DEVICE_TABLE(pci_tbl) = {
+static const struct pci_device_id pci_tbl[] = {
         {       /* nForce Ethernet Controller */
                 PCI_DEVICE(0x10DE, 0x01C3),
                 .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER,
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
index 73e66838cfef..3b98b263bad0 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
@@ -2743,7 +2743,7 @@ static struct pch_gbe_privdata pch_gbe_minnow_privdata = {
         .platform_init = pch_gbe_minnow_platform_init,
 };
 
-static DEFINE_PCI_DEVICE_TABLE(pch_gbe_pcidev_id) = {
+static const struct pci_device_id pch_gbe_pcidev_id[] = {
         {.vendor = PCI_VENDOR_ID_INTEL,
          .device = PCI_DEVICE_ID_INTEL_IOH1_GBE,
          .subvendor = PCI_VENDOR_ID_CIRCUITCO,
diff --git a/drivers/net/ethernet/packetengines/hamachi.c b/drivers/net/ethernet/packetengines/hamachi.c
index 9a997e4c3e08..319d9d40f922 100644
--- a/drivers/net/ethernet/packetengines/hamachi.c
+++ b/drivers/net/ethernet/packetengines/hamachi.c
@@ -1911,7 +1911,7 @@ static void hamachi_remove_one(struct pci_dev *pdev)
         }
 }
 
-static DEFINE_PCI_DEVICE_TABLE(hamachi_pci_tbl) = {
+static const struct pci_device_id hamachi_pci_tbl[] = {
         { 0x1318, 0x0911, PCI_ANY_ID, PCI_ANY_ID, },
         { 0, }
 };
diff --git a/drivers/net/ethernet/packetengines/yellowfin.c b/drivers/net/ethernet/packetengines/yellowfin.c
index 69a8dc095072..2d6b148528dd 100644
--- a/drivers/net/ethernet/packetengines/yellowfin.c
+++ b/drivers/net/ethernet/packetengines/yellowfin.c
@@ -236,7 +236,7 @@ static const struct pci_id_info pci_id_tbl[] = {
         { }
 };
 
-static DEFINE_PCI_DEVICE_TABLE(yellowfin_pci_tbl) = {
+static const struct pci_device_id yellowfin_pci_tbl[] = {
         { 0x1000, 0x0702, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
         { 0x1000, 0x0701, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
         { }
diff --git a/drivers/net/ethernet/pasemi/pasemi_mac.c b/drivers/net/ethernet/pasemi/pasemi_mac.c
index 9abf70d74b31..30d934d66356 100644
--- a/drivers/net/ethernet/pasemi/pasemi_mac.c
+++ b/drivers/net/ethernet/pasemi/pasemi_mac.c
@@ -1871,7 +1871,7 @@ static void pasemi_mac_remove(struct pci_dev *pdev)
         free_netdev(netdev);
 }
 
-static DEFINE_PCI_DEVICE_TABLE(pasemi_mac_pci_tbl) = {
+static const struct pci_device_id pasemi_mac_pci_tbl[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_PASEMI, 0xa005) },
         { PCI_DEVICE(PCI_VENDOR_ID_PASEMI, 0xa006) },
         { },
diff --git a/drivers/net/ethernet/qlogic/netxen/netxen_nic_ctx.c b/drivers/net/ethernet/qlogic/netxen/netxen_nic_ctx.c
index 6f6be57f4690..b8d5270359cd 100644
--- a/drivers/net/ethernet/qlogic/netxen/netxen_nic_ctx.c
+++ b/drivers/net/ethernet/qlogic/netxen/netxen_nic_ctx.c
@@ -129,14 +129,12 @@ netxen_get_minidump_template(struct netxen_adapter *adapter)
                 return NX_RCODE_INVALID_ARGS;
         }
 
-        addr = pci_alloc_consistent(adapter->pdev, size, &md_template_addr);
-
+        addr = pci_zalloc_consistent(adapter->pdev, size, &md_template_addr);
         if (!addr) {
                 dev_err(&adapter->pdev->dev, "Unable to allocate dmable memory for template.\n");
                 return -ENOMEM;
         }
 
-        memset(addr, 0, size);
         memset(&cmd, 0, sizeof(cmd));
         memset(&cmd.rsp, 1, sizeof(struct _cdrp_cmd));
         cmd.req.cmd = NX_CDRP_CMD_GET_TEMP_HDR;
diff --git a/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c b/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
index 5bf05818a12c..1159031f885b 100644
--- a/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
+++ b/drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
@@ -99,7 +99,7 @@ static int netxen_nic_set_mac(struct net_device *netdev, void *p);
         {PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \
         .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
 
-static DEFINE_PCI_DEVICE_TABLE(netxen_pci_tbl) = {
+static const struct pci_device_id netxen_pci_tbl[] = {
         ENTRY(PCI_DEVICE_ID_NX2031_10GXSR),
         ENTRY(PCI_DEVICE_ID_NX2031_10GCX4),
         ENTRY(PCI_DEVICE_ID_NX2031_4GCU),
diff --git a/drivers/net/ethernet/qlogic/qla3xxx.c b/drivers/net/ethernet/qlogic/qla3xxx.c
index b5d6bc1a8b00..c2f09af5c25b 100644
--- a/drivers/net/ethernet/qlogic/qla3xxx.c
+++ b/drivers/net/ethernet/qlogic/qla3xxx.c
@@ -65,7 +65,7 @@ static int msi;
 module_param(msi, int, 0);
 MODULE_PARM_DESC(msi, "Turn on Message Signaled Interrupts.");
 
-static DEFINE_PCI_DEVICE_TABLE(ql3xxx_pci_tbl) = {
+static const struct pci_device_id ql3xxx_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, QL3022_DEVICE_ID)},
         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, QL3032_DEVICE_ID)},
         /* required last entry */
diff --git a/drivers/net/ethernet/qlogic/qlcnic/Makefile b/drivers/net/ethernet/qlogic/qlcnic/Makefile
index a848d2979722..3c2c2c7c1559 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/Makefile
+++ b/drivers/net/ethernet/qlogic/qlcnic/Makefile
@@ -8,7 +8,7 @@ qlcnic-y := qlcnic_hw.o qlcnic_main.o qlcnic_init.o \
         qlcnic_ethtool.o qlcnic_ctx.o qlcnic_io.o \
         qlcnic_sysfs.o qlcnic_minidump.o qlcnic_83xx_hw.o \
         qlcnic_83xx_init.o qlcnic_83xx_vnic.o \
-        qlcnic_minidump.o qlcnic_sriov_common.o
+        qlcnic_sriov_common.o
 
 qlcnic-$(CONFIG_QLCNIC_SRIOV) += qlcnic_sriov_pf.o
 
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
index 59846daf1379..cf08b2de071e 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
@@ -108,7 +108,7 @@ static u32 qlcnic_vlan_tx_check(struct qlcnic_adapter *adapter)
         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
         .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
 
-static DEFINE_PCI_DEVICE_TABLE(qlcnic_pci_tbl) = {
+static const struct pci_device_id qlcnic_pci_tbl[] = {
         ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
         ENTRY(PCI_DEVICE_ID_QLOGIC_QLE834X),
         ENTRY(PCI_DEVICE_ID_QLOGIC_VF_QLE834X),
diff --git a/drivers/net/ethernet/qlogic/qlge/qlge_main.c b/drivers/net/ethernet/qlogic/qlge/qlge_main.c
index b40050e03a56..188626e2a861 100644
--- a/drivers/net/ethernet/qlogic/qlge/qlge_main.c
+++ b/drivers/net/ethernet/qlogic/qlge/qlge_main.c
@@ -86,7 +86,7 @@ MODULE_PARM_DESC(qlge_force_coredump,
                 "Option to allow force of firmware core dump. "
                 "Default is OFF - Do not allow.");
 
-static DEFINE_PCI_DEVICE_TABLE(qlge_pci_tbl) = {
+static const struct pci_device_id qlge_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, QLGE_DEVICE_ID_8012)},
         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, QLGE_DEVICE_ID_8000)},
         /* required last entry */
@@ -2727,23 +2727,22 @@ static void ql_free_shadow_space(struct ql_adapter *qdev)
 static int ql_alloc_shadow_space(struct ql_adapter *qdev)
 {
         qdev->rx_ring_shadow_reg_area =
-            pci_alloc_consistent(qdev->pdev,
-                                 PAGE_SIZE, &qdev->rx_ring_shadow_reg_dma);
+                pci_zalloc_consistent(qdev->pdev, PAGE_SIZE,
+                                      &qdev->rx_ring_shadow_reg_dma);
         if (qdev->rx_ring_shadow_reg_area == NULL) {
                 netif_err(qdev, ifup, qdev->ndev,
                           "Allocation of RX shadow space failed.\n");
                 return -ENOMEM;
         }
-        memset(qdev->rx_ring_shadow_reg_area, 0, PAGE_SIZE);
+
         qdev->tx_ring_shadow_reg_area =
-            pci_alloc_consistent(qdev->pdev, PAGE_SIZE,
-                                 &qdev->tx_ring_shadow_reg_dma);
+                pci_zalloc_consistent(qdev->pdev, PAGE_SIZE,
+                                      &qdev->tx_ring_shadow_reg_dma);
         if (qdev->tx_ring_shadow_reg_area == NULL) {
                 netif_err(qdev, ifup, qdev->ndev,
                           "Allocation of TX shadow space failed.\n");
                 goto err_wqp_sh_area;
         }
-        memset(qdev->tx_ring_shadow_reg_area, 0, PAGE_SIZE);
         return 0;
 
 err_wqp_sh_area:
diff --git a/drivers/net/ethernet/rdc/r6040.c b/drivers/net/ethernet/rdc/r6040.c
index cd045ecb9816..9a37247cf4b8 100644
--- a/drivers/net/ethernet/rdc/r6040.c
+++ b/drivers/net/ethernet/rdc/r6040.c
@@ -1254,7 +1254,7 @@ static void r6040_remove_one(struct pci_dev *pdev)
 }
 
 
-static DEFINE_PCI_DEVICE_TABLE(r6040_pci_tbl) = {
+static const struct pci_device_id r6040_pci_tbl[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_RDC, 0x6040) },
         { 0 }
 };
diff --git a/drivers/net/ethernet/realtek/8139too.c b/drivers/net/ethernet/realtek/8139too.c
index 2e5df148af4c..007b38cce69a 100644
--- a/drivers/net/ethernet/realtek/8139too.c
+++ b/drivers/net/ethernet/realtek/8139too.c
@@ -234,7 +234,7 @@ static const struct {
 };
 
 
-static DEFINE_PCI_DEVICE_TABLE(rtl8139_pci_tbl) = {
+static const struct pci_device_id rtl8139_pci_tbl[] = {
         {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
         {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
         {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
diff --git a/drivers/net/ethernet/realtek/r8169.c b/drivers/net/ethernet/realtek/r8169.c
index 9887bcb45b84..91652e7235e4 100644
--- a/drivers/net/ethernet/realtek/r8169.c
+++ b/drivers/net/ethernet/realtek/r8169.c
@@ -291,7 +291,7 @@ enum cfg_version {
         RTL_CFG_2
 };
 
-static DEFINE_PCI_DEVICE_TABLE(rtl8169_pci_tbl) = {
+static const struct pci_device_id rtl8169_pci_tbl[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8129), 0, 0, RTL_CFG_0 },
         { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8136), 0, 0, RTL_CFG_2 },
         { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8167), 0, 0, RTL_CFG_0 },
diff --git a/drivers/net/ethernet/sfc/efx.c b/drivers/net/ethernet/sfc/efx.c
index 4cebe9d37816..b2cc590dd1dd 100644
--- a/drivers/net/ethernet/sfc/efx.c
+++ b/drivers/net/ethernet/sfc/efx.c
@@ -2642,7 +2642,7 @@ void efx_schedule_reset(struct efx_nic *efx, enum reset_type type)
  **************************************************************************/
 
 /* PCI device ID table */
-static DEFINE_PCI_DEVICE_TABLE(efx_pci_table) = {
+static const struct pci_device_id efx_pci_table[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_SOLARFLARE,
                     PCI_DEVICE_ID_SOLARFLARE_SFC4000A_0),
          .driver_data = (unsigned long) &falcon_a1_nic_type},
diff --git a/drivers/net/ethernet/sgi/ioc3-eth.c b/drivers/net/ethernet/sgi/ioc3-eth.c
index 7984ad05357d..7a254da85dd7 100644
--- a/drivers/net/ethernet/sgi/ioc3-eth.c
+++ b/drivers/net/ethernet/sgi/ioc3-eth.c
@@ -1384,7 +1384,7 @@ static void ioc3_remove_one(struct pci_dev *pdev)
          */
 }
 
-static DEFINE_PCI_DEVICE_TABLE(ioc3_pci_tbl) = {
+static const struct pci_device_id ioc3_pci_tbl[] = {
         { PCI_VENDOR_ID_SGI, PCI_DEVICE_ID_SGI_IOC3, PCI_ANY_ID, PCI_ANY_ID },
         { 0 }
 };
diff --git a/drivers/net/ethernet/silan/sc92031.c b/drivers/net/ethernet/silan/sc92031.c
index 7daa7d433099..7426f8b21252 100644
--- a/drivers/net/ethernet/silan/sc92031.c
+++ b/drivers/net/ethernet/silan/sc92031.c
@@ -1561,7 +1561,7 @@ out:
         return 0;
 }
 
-static DEFINE_PCI_DEVICE_TABLE(sc92031_pci_device_id_table) = {
+static const struct pci_device_id sc92031_pci_device_id_table[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_SILAN, 0x2031) },
         { PCI_DEVICE(PCI_VENDOR_ID_SILAN, 0x8139) },
         { PCI_DEVICE(0x1088, 0x2031) },
diff --git a/drivers/net/ethernet/sis/sis190.c b/drivers/net/ethernet/sis/sis190.c
index a86339903b9b..27be6c869315 100644
--- a/drivers/net/ethernet/sis/sis190.c
+++ b/drivers/net/ethernet/sis/sis190.c
@@ -330,7 +330,7 @@ static const struct {
         { "SiS 191 PCI Gigabit Ethernet adapter" },
 };
 
-static DEFINE_PCI_DEVICE_TABLE(sis190_pci_tbl) = {
+static const struct pci_device_id sis190_pci_tbl[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x0190), 0, 0, 0 },
         { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x0191), 0, 0, 1 },
         { 0, },
diff --git a/drivers/net/ethernet/sis/sis900.c b/drivers/net/ethernet/sis/sis900.c
index 7bea17c41dc9..fd812d2e5e1c 100644
--- a/drivers/net/ethernet/sis/sis900.c
+++ b/drivers/net/ethernet/sis/sis900.c
@@ -106,7 +106,8 @@ static const char * card_names[] = {
         "SiS 900 PCI Fast Ethernet",
         "SiS 7016 PCI Fast Ethernet"
 };
-static DEFINE_PCI_DEVICE_TABLE(sis900_pci_tbl) = {
+
+static const struct pci_device_id sis900_pci_tbl[] = {
         {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_900,
          PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_900},
         {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7016,
diff --git a/drivers/net/ethernet/smsc/epic100.c b/drivers/net/ethernet/smsc/epic100.c
index 8ae1f8a7bf38..443f1da9fc9e 100644
--- a/drivers/net/ethernet/smsc/epic100.c
+++ b/drivers/net/ethernet/smsc/epic100.c
@@ -173,7 +173,7 @@ static const struct epic_chip_info pci_id_tbl[] = {
 };
 
 
-static DEFINE_PCI_DEVICE_TABLE(epic_pci_tbl) = {
+static const struct pci_device_id epic_pci_tbl[] = {
         { 0x10B8, 0x0005, 0x1092, 0x0AB4, 0, 0, SMSC_83C170_0 },
         { 0x10B8, 0x0005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SMSC_83C170 },
         { 0x10B8, 0x0006, PCI_ANY_ID, PCI_ANY_ID,
diff --git a/drivers/net/ethernet/smsc/smsc911x.h b/drivers/net/ethernet/smsc/smsc911x.h
index 23953957fed8..54d648920a1b 100644
--- a/drivers/net/ethernet/smsc/smsc911x.h
+++ b/drivers/net/ethernet/smsc/smsc911x.h
@@ -51,7 +51,7 @@
 
 #ifdef CONFIG_DEBUG_SPINLOCK
 #define SMSC_ASSERT_MAC_LOCK(pdata) \
-                WARN_ON(!spin_is_locked(&pdata->mac_lock))
+                WARN_ON_SMP(!spin_is_locked(&pdata->mac_lock))
 #else
 #define SMSC_ASSERT_MAC_LOCK(pdata) do {} while (0)
 #endif                          /* CONFIG_DEBUG_SPINLOCK */
diff --git a/drivers/net/ethernet/smsc/smsc9420.c b/drivers/net/ethernet/smsc/smsc9420.c
index d3b967aff9e0..4a90cdae5444 100644
--- a/drivers/net/ethernet/smsc/smsc9420.c
+++ b/drivers/net/ethernet/smsc/smsc9420.c
@@ -83,7 +83,7 @@ struct smsc9420_pdata {
         int last_carrier;
 };
 
-static DEFINE_PCI_DEVICE_TABLE(smsc9420_id_table) = {
+static const struct pci_device_id smsc9420_id_table[] = {
         { PCI_VENDOR_ID_9420, PCI_DEVICE_ID_9420, PCI_ANY_ID, PCI_ANY_ID, },
         { 0, }
 };
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
index 291608924849..655a23bbc451 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
@@ -170,7 +170,7 @@ static int stmmac_pci_resume(struct pci_dev *pdev)
 #define STMMAC_VENDOR_ID 0x700
 #define STMMAC_DEVICE_ID 0x1108
 
-static DEFINE_PCI_DEVICE_TABLE(stmmac_id_table) = {
+static const struct pci_device_id stmmac_id_table[] = {
         {PCI_DEVICE(STMMAC_VENDOR_ID, STMMAC_DEVICE_ID)},
         {PCI_DEVICE(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_MAC)},
         {}
diff --git a/drivers/net/ethernet/sun/cassini.c b/drivers/net/ethernet/sun/cassini.c
index b9ac20f42651..37f87ff28f03 100644
--- a/drivers/net/ethernet/sun/cassini.c
+++ b/drivers/net/ethernet/sun/cassini.c
@@ -229,7 +229,7 @@ static u16 link_modes[] = {
         CAS_BMCR_SPEED1000|BMCR_FULLDPLX /* 5 : 1000bt full duplex */
 };
 
-static DEFINE_PCI_DEVICE_TABLE(cas_pci_tbl) = {
+static const struct pci_device_id cas_pci_tbl[] = {
         { PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_CASSINI,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SATURN,
diff --git a/drivers/net/ethernet/sun/niu.c b/drivers/net/ethernet/sun/niu.c
index db8ffde491b5..8216be46540f 100644
--- a/drivers/net/ethernet/sun/niu.c
+++ b/drivers/net/ethernet/sun/niu.c
@@ -59,7 +59,7 @@ static void writeq(u64 val, void __iomem *reg)
 }
 #endif
 
-static DEFINE_PCI_DEVICE_TABLE(niu_pci_tbl) = {
+static const struct pci_device_id niu_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_SUN, 0xabcd)},
         {}
 };
diff --git a/drivers/net/ethernet/sun/sungem.c b/drivers/net/ethernet/sun/sungem.c
index 102a66fc54a2..f7415b6bf141 100644
--- a/drivers/net/ethernet/sun/sungem.c
+++ b/drivers/net/ethernet/sun/sungem.c
@@ -85,7 +85,7 @@ MODULE_LICENSE("GPL");
 
 #define GEM_MODULE_NAME "gem"
 
-static DEFINE_PCI_DEVICE_TABLE(gem_pci_tbl) = {
+static const struct pci_device_id gem_pci_tbl[] = {
         { PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_GEM,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
 
diff --git a/drivers/net/ethernet/sun/sunhme.c b/drivers/net/ethernet/sun/sunhme.c
index 0dbf46f08ed5..72c8525d5457 100644
--- a/drivers/net/ethernet/sun/sunhme.c
+++ b/drivers/net/ethernet/sun/sunhme.c
@@ -3172,7 +3172,7 @@ static void happy_meal_pci_remove(struct pci_dev *pdev)
         free_netdev(net_dev);
 }
 
-static DEFINE_PCI_DEVICE_TABLE(happymeal_pci_ids) = {
+static const struct pci_device_id happymeal_pci_ids[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_HAPPYMEAL) },
         { }                     /* Terminating entry */
 };
diff --git a/drivers/net/ethernet/sun/sunvnet.c b/drivers/net/ethernet/sun/sunvnet.c
index d813bfb1a847..23c89ab5a6ad 100644
--- a/drivers/net/ethernet/sun/sunvnet.c
+++ b/drivers/net/ethernet/sun/sunvnet.c
@@ -32,6 +32,11 @@ MODULE_DESCRIPTION("Sun LDOM virtual network driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_MODULE_VERSION);
 
+/* Heuristic for the number of times to exponentially backoff and
+ * retry sending an LDC trigger when EAGAIN is encountered
+ */
+#define VNET_MAX_RETRIES        10
+
 /* Ordered from largest major to lowest */
 static struct vio_version vnet_versions[] = {
         { .major = 1, .minor = 0 },
@@ -260,6 +265,7 @@ static int vnet_send_ack(struct vnet_port *port, struct vio_dring_state *dr,
                 .state                  = vio_dring_state,
         };
         int err, delay;
+        int retries = 0;
 
         hdr.seq = dr->snd_nxt;
         delay = 1;
@@ -272,6 +278,13 @@ static int vnet_send_ack(struct vnet_port *port, struct vio_dring_state *dr,
                 udelay(delay);
                 if ((delay <<= 1) > 128)
                         delay = 128;
+                if (retries++ > VNET_MAX_RETRIES) {
+                        pr_info("ECONNRESET %x:%x:%x:%x:%x:%x\n",
+                                port->raddr[0], port->raddr[1],
+                                port->raddr[2], port->raddr[3],
+                                port->raddr[4], port->raddr[5]);
+                        err = -ECONNRESET;
+                }
         } while (err == -EAGAIN);
 
         return err;
@@ -475,8 +488,9 @@ static int handle_mcast(struct vnet_port *port, void *msgbuf)
         return 0;
 }
 
-static void maybe_tx_wakeup(struct vnet *vp)
+static void maybe_tx_wakeup(unsigned long param)
 {
+        struct vnet *vp = (struct vnet *)param;
         struct net_device *dev = vp->dev;
 
         netif_tx_lock(dev);
@@ -573,8 +587,13 @@ static void vnet_event(void *arg, int event)
                         break;
         }
         spin_unlock(&vio->lock);
+        /* Kick off a tasklet to wake the queue.  We cannot call
+         * maybe_tx_wakeup directly here because we could deadlock on
+         * netif_tx_lock() with dev_watchdog()
+         */
         if (unlikely(tx_wakeup && err != -ECONNRESET))
-                maybe_tx_wakeup(port->vp);
+                tasklet_schedule(&port->vp->vnet_tx_wakeup);
+
         local_irq_restore(flags);
 }
 
@@ -593,6 +612,7 @@ static int __vnet_tx_trigger(struct vnet_port *port)
                 .end_idx                = (u32) -1,
         };
         int err, delay;
+        int retries = 0;
 
         hdr.seq = dr->snd_nxt;
         delay = 1;
@@ -605,6 +625,8 @@ static int __vnet_tx_trigger(struct vnet_port *port)
                 udelay(delay);
                 if ((delay <<= 1) > 128)
                         delay = 128;
+                if (retries++ > VNET_MAX_RETRIES)
+                        break;
         } while (err == -EAGAIN);
 
         return err;
@@ -691,7 +713,15 @@ static int vnet_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 memset(tx_buf+VNET_PACKET_SKIP+skb->len, 0, len - skb->len);
         }
 
-        d->hdr.ack = VIO_ACK_ENABLE;
+        /* We don't rely on the ACKs to free the skb in vnet_start_xmit(),
+         * thus it is safe to not set VIO_ACK_ENABLE for each transmission:
+         * the protocol itself does not require it as long as the peer
+         * sends a VIO_SUBTYPE_ACK for VIO_DRING_STOPPED.
+         *
+         * An ACK for every packet in the ring is expensive as the
+         * sending of LDC messages is slow and affects performance.
+         */
+        d->hdr.ack = VIO_ACK_DISABLE;
         d->size = len;
         d->ncookies = port->tx_bufs[dr->prod].ncookies;
         for (i = 0; i < d->ncookies; i++)
@@ -1046,6 +1076,7 @@ static struct vnet *vnet_new(const u64 *local_mac)
         vp = netdev_priv(dev);
 
         spin_lock_init(&vp->lock);
+        tasklet_init(&vp->vnet_tx_wakeup, maybe_tx_wakeup, (unsigned long)vp);
         vp->dev = dev;
 
         INIT_LIST_HEAD(&vp->port_list);
@@ -1105,6 +1136,7 @@ static void vnet_cleanup(void)
                 vp = list_first_entry(&vnet_list, struct vnet, list);
                 list_del(&vp->list);
                 dev = vp->dev;
+                tasklet_kill(&vp->vnet_tx_wakeup);
                 /* vio_unregister_driver() should have cleaned up port_list */
                 BUG_ON(!list_empty(&vp->port_list));
                 unregister_netdev(dev);
diff --git a/drivers/net/ethernet/sun/sunvnet.h b/drivers/net/ethernet/sun/sunvnet.h
index d347a5bf24b0..de5c2c64996f 100644
--- a/drivers/net/ethernet/sun/sunvnet.h
+++ b/drivers/net/ethernet/sun/sunvnet.h
@@ -1,6 +1,8 @@
 #ifndef _SUNVNET_H
 #define _SUNVNET_H
 
+#include <linux/interrupt.h>
+
 #define DESC_NCOOKIES(entry_size)       \
         ((entry_size) - sizeof(struct vio_net_desc))
 
@@ -78,6 +80,8 @@ struct vnet {
 
         struct list_head        list;
         u64                     local_mac;
+
+        struct tasklet_struct   vnet_tx_wakeup;
 };
 
 #endif /* _SUNVNET_H */
diff --git a/drivers/net/ethernet/tehuti/tehuti.c b/drivers/net/ethernet/tehuti/tehuti.c
index 38da73a2a886..6ab36d9ff2ab 100644
--- a/drivers/net/ethernet/tehuti/tehuti.c
+++ b/drivers/net/ethernet/tehuti/tehuti.c
@@ -66,7 +66,7 @@
 
 #include "tehuti.h"
 
-static DEFINE_PCI_DEVICE_TABLE(bdx_pci_tbl) = {
+static const struct pci_device_id bdx_pci_tbl[] = {
         { PCI_VDEVICE(TEHUTI, 0x3009), },
         { PCI_VDEVICE(TEHUTI, 0x3010), },
         { PCI_VDEVICE(TEHUTI, 0x3014), },
diff --git a/drivers/net/ethernet/ti/cpmac.c b/drivers/net/ethernet/ti/cpmac.c
index 3809f4ec2820..f9bcf7aa88ca 100644
--- a/drivers/net/ethernet/ti/cpmac.c
+++ b/drivers/net/ethernet/ti/cpmac.c
@@ -1130,6 +1130,7 @@ static int cpmac_probe(struct platform_device *pdev)
                 strncpy(mdio_bus_id, "fixed-0", MII_BUS_ID_SIZE); /* fixed phys bus */
                 phy_id = pdev->id;
         }
+        mdio_bus_id[sizeof(mdio_bus_id) - 1] = '\0';
 
         dev = alloc_etherdev_mq(sizeof(*priv), CPMAC_QUEUES);
         if (!dev)
diff --git a/drivers/net/ethernet/ti/tlan.c b/drivers/net/ethernet/ti/tlan.c
index 6078342fe3f2..f2ff0074aac9 100644
--- a/drivers/net/ethernet/ti/tlan.c
+++ b/drivers/net/ethernet/ti/tlan.c
@@ -116,7 +116,7 @@ static struct board {
           TLAN_ADAPTER_ACTIVITY_LED, 0x83 }, /* EISA card */
 };
 
-static DEFINE_PCI_DEVICE_TABLE(tlan_pci_tbl) = {
+static const struct pci_device_id tlan_pci_tbl[] = {
         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100,
diff --git a/drivers/net/ethernet/toshiba/spider_net.c b/drivers/net/ethernet/toshiba/spider_net.c
index 0282d0161859..3e38f67c6011 100644
--- a/drivers/net/ethernet/toshiba/spider_net.c
+++ b/drivers/net/ethernet/toshiba/spider_net.c
@@ -73,7 +73,7 @@ MODULE_PARM_DESC(tx_descriptors, "number of descriptors used " \
 
 char spider_net_driver_name[] = "spidernet";
 
-static DEFINE_PCI_DEVICE_TABLE(spider_net_pci_tbl) = {
+static const struct pci_device_id spider_net_pci_tbl[] = {
         { PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_SPIDER_NET,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
         { 0, }
diff --git a/drivers/net/ethernet/toshiba/tc35815.c b/drivers/net/ethernet/toshiba/tc35815.c
index fef5573dbfca..45ac38d29ed8 100644
--- a/drivers/net/ethernet/toshiba/tc35815.c
+++ b/drivers/net/ethernet/toshiba/tc35815.c
@@ -65,7 +65,7 @@ static const struct {
         { "TOSHIBA TC35815/TX4939" },
 };
 
-static DEFINE_PCI_DEVICE_TABLE(tc35815_pci_tbl) = {
+static const struct pci_device_id tc35815_pci_tbl[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_TC35815CF), .driver_data = TC35815CF },
         {PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_TC35815_NWU), .driver_data = TC35815_NWU },
         {PCI_DEVICE(PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_TC35815_TX4939), .driver_data = TC35815_TX4939 },
diff --git a/drivers/net/ethernet/via/via-rhine.c b/drivers/net/ethernet/via/via-rhine.c
index 2d72f96a9e2c..68c5260cc322 100644
--- a/drivers/net/ethernet/via/via-rhine.c
+++ b/drivers/net/ethernet/via/via-rhine.c
@@ -273,7 +273,7 @@ enum rhine_quirks {
 /* Beware of PCI posted writes */
 #define IOSYNC  do { ioread8(ioaddr + StationAddr); } while (0)
 
-static DEFINE_PCI_DEVICE_TABLE(rhine_pci_tbl) = {
+static const struct pci_device_id rhine_pci_tbl[] = {
         { 0x1106, 0x3043, PCI_ANY_ID, PCI_ANY_ID, },    /* VT86C100A */
         { 0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, },    /* VT6102 */
         { 0x1106, 0x3106, PCI_ANY_ID, PCI_ANY_ID, },    /* 6105{,L,LOM} */
diff --git a/drivers/net/ethernet/via/via-velocity.c b/drivers/net/ethernet/via/via-velocity.c
index de08e86db209..f5fbc12d3e10 100644
--- a/drivers/net/ethernet/via/via-velocity.c
+++ b/drivers/net/ethernet/via/via-velocity.c
@@ -381,7 +381,7 @@ static struct velocity_info_tbl chip_info_table[] = {
  *      device driver. Used for hotplug autoloading.
  */
 
-static DEFINE_PCI_DEVICE_TABLE(velocity_pci_id_table) = {
+static const struct pci_device_id velocity_pci_id_table[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) },
         { }
 };
diff --git a/drivers/net/ethernet/xilinx/ll_temac_main.c b/drivers/net/ethernet/xilinx/ll_temac_main.c
index 8a6e5c2d6f95..fda5891835d4 100644
--- a/drivers/net/ethernet/xilinx/ll_temac_main.c
+++ b/drivers/net/ethernet/xilinx/ll_temac_main.c
@@ -1148,8 +1148,7 @@ static int temac_of_remove(struct platform_device *op)
         temac_mdio_teardown(lp);
         unregister_netdev(ndev);
         sysfs_remove_group(&lp->dev->kobj, &temac_attr_group);
-        if (lp->phy_node)
-                of_node_put(lp->phy_node);
+        of_node_put(lp->phy_node);
         lp->phy_node = NULL;
         iounmap(lp->regs);
         if (lp->sdma_regs)
@@ -1171,7 +1170,6 @@ static struct platform_driver temac_of_driver = {
         .probe = temac_of_probe,
         .remove = temac_of_remove,
         .driver = {
-                .owner = THIS_MODULE,
                 .name = "xilinx_temac",
                 .of_match_table = temac_of_match,
         },
diff --git a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
index 7b0a73556264..c8fd94133ecd 100644
--- a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
+++ b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
@@ -1630,8 +1630,7 @@ static int axienet_of_remove(struct platform_device *op)
         axienet_mdio_teardown(lp);
         unregister_netdev(ndev);
 
-        if (lp->phy_node)
-                of_node_put(lp->phy_node);
+        of_node_put(lp->phy_node);
         lp->phy_node = NULL;
 
         iounmap(lp->regs);
@@ -1646,7 +1645,6 @@ static struct platform_driver axienet_of_driver = {
         .probe = axienet_of_probe,
         .remove = axienet_of_remove,
         .driver = {
-                 .owner = THIS_MODULE,
                  .name = "xilinx_axienet",
                  .of_match_table = axienet_of_match,
         },
diff --git a/drivers/net/ethernet/xilinx/xilinx_emaclite.c b/drivers/net/ethernet/xilinx/xilinx_emaclite.c
index 782bb9373cd8..28dbbdc393eb 100644
--- a/drivers/net/ethernet/xilinx/xilinx_emaclite.c
+++ b/drivers/net/ethernet/xilinx/xilinx_emaclite.c
@@ -1245,7 +1245,6 @@ MODULE_DEVICE_TABLE(of, xemaclite_of_match);
 static struct platform_driver xemaclite_of_driver = {
         .driver = {
                 .name = DRIVER_NAME,
-                .owner = THIS_MODULE,
                 .of_match_table = xemaclite_of_match,
         },
         .probe          = xemaclite_of_probe,
diff --git a/drivers/net/ethernet/xircom/xirc2ps_cs.c b/drivers/net/ethernet/xircom/xirc2ps_cs.c
index 7c81ffb861e8..d56f8693202b 100644
--- a/drivers/net/ethernet/xircom/xirc2ps_cs.c
+++ b/drivers/net/ethernet/xircom/xirc2ps_cs.c
@@ -266,7 +266,7 @@ static void xirc2ps_detach(struct pcmcia_device *p_dev);
 
 static irqreturn_t xirc2ps_interrupt(int irq, void *dev_id);
 
-typedef struct local_info_t {
+struct local_info {
         struct net_device       *dev;
         struct pcmcia_device    *p_dev;
 
@@ -281,7 +281,7 @@ typedef struct local_info_t {
     unsigned last_ptr_value; /* last packets transmitted value */
     const char *manf_str;
     struct work_struct tx_timeout_task;
-} local_info_t;
+};
 
 /****************
  * Some more prototypes
@@ -475,12 +475,12 @@ static int
 xirc2ps_probe(struct pcmcia_device *link)
 {
     struct net_device *dev;
-    local_info_t *local;
+    struct local_info *local;
 
     dev_dbg(&link->dev, "attach()\n");
 
     /* Allocate the device structure */
-    dev = alloc_etherdev(sizeof(local_info_t));
+    dev = alloc_etherdev(sizeof(struct local_info));
     if (!dev)
             return -ENOMEM;
     local = netdev_priv(dev);
@@ -536,7 +536,7 @@ static int
 set_card_type(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
-    local_info_t *local = netdev_priv(dev);
+    struct local_info *local = netdev_priv(dev);
     u8 *buf;
     unsigned int cisrev, mediaid, prodid;
     size_t len;
@@ -690,7 +690,7 @@ static int
 xirc2ps_config(struct pcmcia_device * link)
 {
     struct net_device *dev = link->priv;
-    local_info_t *local = netdev_priv(dev);
+    struct local_info *local = netdev_priv(dev);
     unsigned int ioaddr;
     int err;
     u8 *buf;
@@ -931,7 +931,7 @@ xirc2ps_release(struct pcmcia_device *link)
 
         if (link->resource[2]->end) {
                 struct net_device *dev = link->priv;
-                local_info_t *local = netdev_priv(dev);
+                struct local_info *local = netdev_priv(dev);
                 if (local->dingo)
                         iounmap(local->dingo_ccr - 0x0800);
         }
@@ -975,7 +975,7 @@ static irqreturn_t
 xirc2ps_interrupt(int irq, void *dev_id)
 {
     struct net_device *dev = (struct net_device *)dev_id;
-    local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     unsigned int ioaddr;
     u_char saved_page;
     unsigned bytes_rcvd;
@@ -1194,8 +1194,8 @@ xirc2ps_interrupt(int irq, void *dev_id)
 static void
 xirc2ps_tx_timeout_task(struct work_struct *work)
 {
-        local_info_t *local =
-                container_of(work, local_info_t, tx_timeout_task);
+        struct local_info *local =
+                container_of(work, struct local_info, tx_timeout_task);
         struct net_device *dev = local->dev;
     /* reset the card */
     do_reset(dev,1);
@@ -1206,7 +1206,7 @@ xirc2ps_tx_timeout_task(struct work_struct *work)
 static void
 xirc_tx_timeout(struct net_device *dev)
 {
-    local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     dev->stats.tx_errors++;
     netdev_notice(dev, "transmit timed out\n");
     schedule_work(&lp->tx_timeout_task);
@@ -1215,7 +1215,7 @@ xirc_tx_timeout(struct net_device *dev)
 static netdev_tx_t
 do_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-    local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     unsigned int ioaddr = dev->base_addr;
     int okay;
     unsigned freespace;
@@ -1300,7 +1300,7 @@ static void set_address(struct set_address_info *sa_info, char *addr)
 static void set_addresses(struct net_device *dev)
 {
         unsigned int ioaddr = dev->base_addr;
-        local_info_t *lp = netdev_priv(dev);
+        struct local_info *lp = netdev_priv(dev);
         struct netdev_hw_addr *ha;
         struct set_address_info sa_info;
         int i;
@@ -1362,7 +1362,7 @@ set_multicast_list(struct net_device *dev)
 static int
 do_config(struct net_device *dev, struct ifmap *map)
 {
-    local_info_t *local = netdev_priv(dev);
+    struct local_info *local = netdev_priv(dev);
 
     pr_debug("do_config(%p)\n", dev);
     if (map->port != 255 && map->port != dev->if_port) {
@@ -1387,7 +1387,7 @@ do_config(struct net_device *dev, struct ifmap *map)
 static int
 do_open(struct net_device *dev)
 {
-    local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     struct pcmcia_device *link = lp->p_dev;
 
     dev_dbg(&link->dev, "do_open(%p)\n", dev);
@@ -1421,7 +1421,7 @@ static const struct ethtool_ops netdev_ethtool_ops = {
 static int
 do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
-    local_info_t *local = netdev_priv(dev);
+    struct local_info *local = netdev_priv(dev);
     unsigned int ioaddr = dev->base_addr;
     struct mii_ioctl_data *data = if_mii(rq);
 
@@ -1453,7 +1453,7 @@ do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 static void
 hardreset(struct net_device *dev)
 {
-    local_info_t *local = netdev_priv(dev);
+    struct local_info *local = netdev_priv(dev);
     unsigned int ioaddr = dev->base_addr;
 
     SelectPage(4);
@@ -1470,7 +1470,7 @@ hardreset(struct net_device *dev)
 static void
 do_reset(struct net_device *dev, int full)
 {
-    local_info_t *local = netdev_priv(dev);
+    struct local_info *local = netdev_priv(dev);
     unsigned int ioaddr = dev->base_addr;
     unsigned value;
 
@@ -1631,7 +1631,7 @@ do_reset(struct net_device *dev, int full)
 static int
 init_mii(struct net_device *dev)
 {
-    local_info_t *local = netdev_priv(dev);
+    struct local_info *local = netdev_priv(dev);
     unsigned int ioaddr = dev->base_addr;
     unsigned control, status, linkpartner;
     int i;
@@ -1715,7 +1715,7 @@ static int
 do_stop(struct net_device *dev)
 {
     unsigned int ioaddr = dev->base_addr;
-    local_info_t *lp = netdev_priv(dev);
+    struct local_info *lp = netdev_priv(dev);
     struct pcmcia_device *link = lp->p_dev;
 
     dev_dbg(&link->dev, "do_stop(%p)\n", dev);