117 files changed, 2487 insertions, 1362 deletions
diff --git a/Documentation/devicetree/bindings/net/davicom-dm9000.txt b/Documentation/devicetree/bindings/net/davicom-dm9000.txt
new file mode 100644
index 000000000000..2d39c990e641
--- /dev/null
+++ b/Documentation/devicetree/bindings/net/davicom-dm9000.txt
@@ -0,0 +1,26 @@
+Davicom DM9000 Fast Ethernet controller
+Required properties:
+- compatible = "davicom,dm9000";
+- reg : physical addresses and sizes of registers, must contain 2 entries:
+    first entry : address register,
+    second entry : data register.
+- interrupt-parent : interrupt controller to which the device is connected
+- interrupts : interrupt specifier specific to interrupt controller
+Optional properties:
+- local-mac-address : A bytestring of 6 bytes specifying Ethernet MAC address
+    to use (from firmware or bootloader)
+- davicom,no-eeprom : Configuration EEPROM is not available
+- davicom,ext-phy : Use external PHY
+Example:
+        ethernet@18000000 {
+                compatible = "davicom,dm9000";
+                reg = <0x18000000 0x2 0x18000004 0x2>;
+                interrupt-parent = <&gpn>;
+                interrupts = <7 4>;
+                local-mac-address = [00 00 de ad be ef];
+                davicom,no-eeprom;
+        };
diff --git a/Documentation/devicetree/bindings/net/via-velocity.txt b/Documentation/devicetree/bindings/net/via-velocity.txt
new file mode 100644
index 000000000000..b3db469b1ad7
--- /dev/null
+++ b/Documentation/devicetree/bindings/net/via-velocity.txt
@@ -0,0 +1,20 @@
+* VIA Velocity 10/100/1000 Network Controller
+Required properties:
+- compatible : Should be "via,velocity-vt6110"
+- reg : Address and length of the io space
+- interrupts : Should contain the controller interrupt line
+Optional properties:
+- no-eeprom : PCI network cards use an external EEPROM to store data. Embedded
+        devices quite often set this data in uboot and do not provide an eeprom.
+        Specify this option if you have no external eeprom.
+Examples:
+eth0@d8004000 {
+        compatible = "via,velocity-vt6110";
+        reg = <0xd8004000 0x400>;
+        interrupts = <10>;
+        no-eeprom;
+};
diff --git a/Documentation/devicetree/bindings/vendor-prefixes.txt b/Documentation/devicetree/bindings/vendor-prefixes.txt
index 6931c4348d24..2fe74e6ec209 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.txt
+++ b/Documentation/devicetree/bindings/vendor-prefixes.txt
@@ -18,6 +18,7 @@ chrp	Common Hardware Reference Platform
 cirrus  Cirrus Logic, Inc.
 cortina Cortina Systems, Inc.
 dallas  Maxim Integrated Products (formerly Dallas Semiconductor)
+davicom DAVICOM Semiconductor, Inc.
 denx    Denx Software Engineering
 emmicro EM Microelectronic
 epson   Seiko Epson Corp.
diff --git a/Documentation/networking/scaling.txt b/Documentation/networking/scaling.txt
index 579994afbe06..ca6977f5b2ed 100644
--- a/Documentation/networking/scaling.txt
+++ b/Documentation/networking/scaling.txt
@@ -163,6 +163,64 @@ and unnecessary. If there are fewer hardware queues than CPUs, then
 RPS might be beneficial if the rps_cpus for each queue are the ones that
 share the same memory domain as the interrupting CPU for that queue.
+==== RPS Flow Limit
+RPS scales kernel receive processing across CPUs without introducing
+reordering. The trade-off to sending all packets from the same flow
+to the same CPU is CPU load imbalance if flows vary in packet rate.
+In the extreme case a single flow dominates traffic. Especially on
+common server workloads with many concurrent connections, such
+behavior indicates a problem such as a misconfiguration or spoofed
+source Denial of Service attack.
+Flow Limit is an optional RPS feature that prioritizes small flows
+during CPU contention by dropping packets from large flows slightly
+ahead of those from small flows. It is active only when an RPS or RFS
+destination CPU approaches saturation.  Once a CPU's input packet
+queue exceeds half the maximum queue length (as set by sysctl
+net.core.netdev_max_backlog), the kernel starts a per-flow packet
+count over the last 256 packets. If a flow exceeds a set ratio (by
+default, half) of these packets when a new packet arrives, then the
+new packet is dropped. Packets from other flows are still only
+dropped once the input packet queue reaches netdev_max_backlog.
+No packets are dropped when the input packet queue length is below
+the threshold, so flow limit does not sever connections outright:
+even large flows maintain connectivity.
+== Interface
+Flow limit is compiled in by default (CONFIG_NET_FLOW_LIMIT), but not
+turned on. It is implemented for each CPU independently (to avoid lock
+and cache contention) and toggled per CPU by setting the relevant bit
+in sysctl net.core.flow_limit_cpu_bitmap. It exposes the same CPU
+bitmap interface as rps_cpus (see above) when called from procfs:
+ /proc/sys/net/core/flow_limit_cpu_bitmap
+Per-flow rate is calculated by hashing each packet into a hashtable
+bucket and incrementing a per-bucket counter. The hash function is
+the same that selects a CPU in RPS, but as the number of buckets can
+be much larger than the number of CPUs, flow limit has finer-grained
+identification of large flows and fewer false positives. The default
+table has 4096 buckets. This value can be modified through sysctl
+ net.core.flow_limit_table_len
+The value is only consulted when a new table is allocated. Modifying
+it does not update active tables.
+== Suggested Configuration
+Flow limit is useful on systems with many concurrent connections,
+where a single connection taking up 50% of a CPU indicates a problem.
+In such environments, enable the feature on all CPUs that handle
+network rx interrupts (as set in /proc/irq/N/smp_affinity).
+The feature depends on the input packet queue length to exceed
+the flow limit threshold (50%) + the flow history length (256).
+Setting net.core.netdev_max_backlog to either 1000 or 10000
+performed well in experiments.
 RFS: Receive Flow Steering
 ==========================
diff --git a/Documentation/sysctl/net.txt b/Documentation/sysctl/net.txt
index 98335b7a5337..c1f8640c2fc8 100644
--- a/Documentation/sysctl/net.txt
+++ b/Documentation/sysctl/net.txt
@@ -93,8 +93,7 @@ netdev_budget
 Maximum number of packets taken from all interfaces in one polling cycle (NAPI
 poll). In one polling cycle interfaces which are registered to polling are
-probed in a round-robin manner. The limit of packets in one such probe can be
+probed in a round-robin manner.
-set per-device via sysfs class/net/<device>/weight .
 netdev_max_backlog
 ------------------
diff --git a/arch/arm/net/bpf_jit_32.c b/arch/arm/net/bpf_jit_32.c
index 1a643ee8e082..f50d223a0bd3 100644
--- a/arch/arm/net/bpf_jit_32.c
+++ b/arch/arm/net/bpf_jit_32.c
@@ -900,8 +900,7 @@ void bpf_jit_compile(struct sk_filter *fp)
 #endif
        alloc_size = 4 * ctx.idx;
-        ctx.target = module_alloc(max(sizeof(struct work_struct),
+        ctx.target = module_alloc(alloc_size);
-                                      alloc_size));
        if (unlikely(ctx.target == NULL))
                goto out;
@@ -927,19 +926,8 @@ out:
        return;
 }
-static void bpf_jit_free_worker(struct work_struct *work)
-{
-        module_free(NULL, work);
-}
 void bpf_jit_free(struct sk_filter *fp)
 {
-        struct work_struct *work;
+        if (fp->bpf_func != sk_run_filter)
+                module_free(NULL, fp->bpf_func);
-        if (fp->bpf_func != sk_run_filter) {
-                work = (struct work_struct *)fp->bpf_func;
-                INIT_WORK(work, bpf_jit_free_worker);
-                schedule_work(work);
-        }
 }
diff --git a/arch/powerpc/net/bpf_jit_comp.c b/arch/powerpc/net/bpf_jit_comp.c
index c427ae36374a..bf56e33f8257 100644
--- a/arch/powerpc/net/bpf_jit_comp.c
+++ b/arch/powerpc/net/bpf_jit_comp.c
@@ -650,8 +650,7 @@ void bpf_jit_compile(struct sk_filter *fp)
        proglen = cgctx.idx * 4;
        alloclen = proglen + FUNCTION_DESCR_SIZE;
-        image = module_alloc(max_t(unsigned int, alloclen,
+        image = module_alloc(alloclen);
-                                   sizeof(struct work_struct)));
        if (!image)
                goto out;
@@ -688,20 +687,8 @@ out:
        return;
 }
-static void jit_free_defer(struct work_struct *arg)
-{
-        module_free(NULL, arg);
-}
-/* run from softirq, we must use a work_struct to call
- * module_free() from process context
- */
 void bpf_jit_free(struct sk_filter *fp)
 {
-        if (fp->bpf_func != sk_run_filter) {
+        if (fp->bpf_func != sk_run_filter)
-                struct work_struct *work = (struct work_struct *)fp->bpf_func;
+                module_free(NULL, fp->bpf_func);
-                INIT_WORK(work, jit_free_defer);
-                schedule_work(work);
-        }
 }
diff --git a/arch/sparc/net/bpf_jit_comp.c b/arch/sparc/net/bpf_jit_comp.c
index d36a85ebb5e0..9c7be59e6f5a 100644
--- a/arch/sparc/net/bpf_jit_comp.c
+++ b/arch/sparc/net/bpf_jit_comp.c
@@ -785,9 +785,7 @@ cond_branch:			f_offset = addrs[i + filter[i].jf];
                        break;
                }
                if (proglen == oldproglen) {
-                        image = module_alloc(max_t(unsigned int,
+                        image = module_alloc(proglen);
-                                                   proglen,
-                                                   sizeof(struct work_struct)));
                        if (!image)
                                goto out;
                }
@@ -806,20 +804,8 @@ out:
        return;
 }
-static void jit_free_defer(struct work_struct *arg)
-{
-        module_free(NULL, arg);
-}
-/* run from softirq, we must use a work_struct to call
- * module_free() from process context
- */
 void bpf_jit_free(struct sk_filter *fp)
 {
-        if (fp->bpf_func != sk_run_filter) {
+        if (fp->bpf_func != sk_run_filter)
-                struct work_struct *work = (struct work_struct *)fp->bpf_func;
+                module_free(NULL, fp->bpf_func);
-                INIT_WORK(work, jit_free_defer);
-                schedule_work(work);
-        }
 }
diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c
index f66b54086ce5..79c216aa0e2b 100644
--- a/arch/x86/net/bpf_jit_comp.c
+++ b/arch/x86/net/bpf_jit_comp.c
@@ -12,6 +12,7 @@
 #include <linux/netdevice.h>
 #include <linux/filter.h>
 #include <linux/if_vlan.h>
+#include <linux/random.h>
 /*
 * Conventions :
@@ -144,6 +145,39 @@ static int pkt_type_offset(void)
        return -1;
 }
+struct bpf_binary_header {
+        unsigned int    pages;
+        /* Note : for security reasons, bpf code will follow a randomly
+         * sized amount of int3 instructions
+         */
+        u8              image[];
+};
+static struct bpf_binary_header *bpf_alloc_binary(unsigned int proglen,
+                                                  u8 **image_ptr)
+{
+        unsigned int sz, hole;
+        struct bpf_binary_header *header;
+        /* Most of BPF filters are really small,
+         * but if some of them fill a page, allow at least
+         * 128 extra bytes to insert a random section of int3
+         */
+        sz = round_up(proglen + sizeof(*header) + 128, PAGE_SIZE);
+        header = module_alloc(sz);
+        if (!header)
+                return NULL;
+        memset(header, 0xcc, sz); /* fill whole space with int3 instructions */
+        header->pages = sz / PAGE_SIZE;
+        hole = sz - (proglen + sizeof(*header));
+        /* insert a random number of int3 instructions before BPF code */
+        *image_ptr = &header->image[prandom_u32() % hole];
+        return header;
+}
 void bpf_jit_compile(struct sk_filter *fp)
 {
        u8 temp[64];
@@ -153,6 +187,7 @@ void bpf_jit_compile(struct sk_filter *fp)
        int t_offset, f_offset;
        u8 t_op, f_op, seen = 0, pass;
        u8 *image = NULL;
+        struct bpf_binary_header *header = NULL;
        u8 *func;
        int pc_ret0 = -1; /* bpf index of first RET #0 instruction (if any) */
        unsigned int cleanup_addr; /* epilogue code offset */
@@ -693,7 +728,7 @@ cond_branch:			f_offset = addrs[i + filter[i].jf] - addrs[i];
                                if (unlikely(proglen + ilen > oldproglen)) {
                                        pr_err("bpb_jit_compile fatal error\n");
                                        kfree(addrs);
-                                        module_free(NULL, image);
+                                        module_free(NULL, header);
                                        return;
                                }
                                memcpy(image + proglen, temp, ilen);
@@ -717,10 +752,8 @@ cond_branch:			f_offset = addrs[i + filter[i].jf] - addrs[i];
                        break;
                }
                if (proglen == oldproglen) {
-                        image = module_alloc(max_t(unsigned int,
+                        header = bpf_alloc_binary(proglen, &image);
-                                                   proglen,
+                        if (!header)
-                                                   sizeof(struct work_struct)));
-                        if (!image)
                                goto out;
                }
                oldproglen = proglen;
@@ -730,7 +763,8 @@ cond_branch:			f_offset = addrs[i + filter[i].jf] - addrs[i];
                bpf_jit_dump(flen, proglen, pass, image);
        if (image) {
-                bpf_flush_icache(image, image + proglen);
+                bpf_flush_icache(header, image + proglen);
+                set_memory_ro((unsigned long)header, header->pages);
                fp->bpf_func = (void *)image;
        }
 out:
@@ -738,20 +772,13 @@ out:
        return;
 }
-static void jit_free_defer(struct work_struct *arg)
-{
-        module_free(NULL, arg);
-}
-/* run from softirq, we must use a work_struct to call
- * module_free() from process context
- */
 void bpf_jit_free(struct sk_filter *fp)
 {
        if (fp->bpf_func != sk_run_filter) {
-                struct work_struct *work = (struct work_struct *)fp->bpf_func;
+                unsigned long addr = (unsigned long)fp->bpf_func & PAGE_MASK;
+                struct bpf_binary_header *header = (void *)addr;
-                INIT_WORK(work, jit_free_defer);
+                set_memory_rw(addr, header->pages);
-                schedule_work(work);
+                module_free(NULL, header);
        }
 }
diff --git a/drivers/net/can/at91_can.c b/drivers/net/can/at91_can.c
index db52f4414def..556656661d6b 100644
--- a/drivers/net/can/at91_can.c
+++ b/drivers/net/can/at91_can.c
@@ -1393,8 +1393,6 @@ static int at91_can_remove(struct platform_device *pdev)
        unregister_netdev(dev);
-        platform_set_drvdata(pdev, NULL);
        iounmap(priv->reg_base);
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/drivers/net/can/c_can/c_can_platform.c b/drivers/net/can/c_can/c_can_platform.c
index d63b91904f82..6b6130b8bdc4 100644
--- a/drivers/net/can/c_can/c_can_platform.c
+++ b/drivers/net/can/c_can/c_can_platform.c
@@ -234,7 +234,6 @@ static int c_can_plat_probe(struct platform_device *pdev)
        return 0;
 exit_free_device:
-        platform_set_drvdata(pdev, NULL);
        free_c_can_dev(dev);
 exit_iounmap:
        iounmap(addr);
@@ -255,7 +254,6 @@ static int c_can_plat_remove(struct platform_device *pdev)
        struct resource *mem;
        unregister_c_can_dev(dev);
-        platform_set_drvdata(pdev, NULL);
        free_c_can_dev(dev);
        iounmap(priv->base);
diff --git a/drivers/net/can/flexcan.c b/drivers/net/can/flexcan.c
index 769d29ed106d..4a40a186c8c8 100644
--- a/drivers/net/can/flexcan.c
+++ b/drivers/net/can/flexcan.c
@@ -1127,7 +1127,6 @@ static int flexcan_remove(struct platform_device *pdev)
        struct resource *mem;
        unregister_flexcandev(dev);
-        platform_set_drvdata(pdev, NULL);
        iounmap(priv->base);
        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
diff --git a/drivers/net/can/grcan.c b/drivers/net/can/grcan.c
index 17fbc7a09224..9e9d0d628e7b 100644
--- a/drivers/net/can/grcan.c
+++ b/drivers/net/can/grcan.c
@@ -1683,10 +1683,9 @@ static int grcan_probe(struct platform_device *ofdev)
        }
        res = platform_get_resource(ofdev, IORESOURCE_MEM, 0);
-        base = devm_request_and_ioremap(&ofdev->dev, res);
+        base = devm_ioremap_resource(&ofdev->dev, res);
-        if (!base) {
+        if (IS_ERR(base)) {
-                dev_err(&ofdev->dev, "couldn't map IO resource\n");
+                err = PTR_ERR(base);
-                err = -EADDRNOTAVAIL;
                goto exit_error;
        }
diff --git a/drivers/net/can/ti_hecc.c b/drivers/net/can/ti_hecc.c
index f21fc37ec578..3a349a22d5bc 100644
--- a/drivers/net/can/ti_hecc.c
+++ b/drivers/net/can/ti_hecc.c
@@ -1001,7 +1001,6 @@ static int ti_hecc_remove(struct platform_device *pdev)
        iounmap(priv->base);
        release_mem_region(res->start, resource_size(res));
        free_candev(ndev);
-        platform_set_drvdata(pdev, NULL);
        return 0;
 }
diff --git a/drivers/net/ethernet/3com/3c509.c b/drivers/net/ethernet/3com/3c509.c
index adb4bf5eb4b4..ede8daa68275 100644
--- a/drivers/net/ethernet/3com/3c509.c
+++ b/drivers/net/ethernet/3com/3c509.c
@@ -723,25 +723,6 @@ el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
                pr_debug("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
                           dev->name, skb->len, inw(ioaddr + EL3_STATUS));
        }
-#if 0
-#ifndef final_version
-        {       /* Error-checking code, delete someday. */
-                ushort status = inw(ioaddr + EL3_STATUS);
-                if (status & 0x0001 &&          /* IRQ line active, missed one. */
-                    inw(ioaddr + EL3_STATUS) & 1) {                     /* Make sure. */
-                        pr_debug("%s: Missed interrupt, status then %04x now %04x"
-                                   "  Tx %2.2x Rx %4.4x.\n", dev->name, status,
-                                   inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
-                                   inw(ioaddr + RX_STATUS));
-                        /* Fake interrupt trigger by masking, acknowledge interrupts. */
-                        outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
-                        outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
-                                 ioaddr + EL3_CMD);
-                        outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
-                }
-        }
-#endif
-#endif
        /*
         *      We lock the driver against other processors. Note
         *      we don't need to lock versus the IRQ as we suspended
diff --git a/drivers/net/ethernet/3com/3c59x.c b/drivers/net/ethernet/3com/3c59x.c
index 072c6f14e8fc..30e74211a755 100644
--- a/drivers/net/ethernet/3com/3c59x.c
+++ b/drivers/net/ethernet/3com/3c59x.c
@@ -1473,7 +1473,7 @@ static int vortex_probe1(struct device *gendev, void __iomem *ioaddr, int irq,
        if (pdev) {
                vp->pm_state_valid = 1;
-                pci_save_state(VORTEX_PCI(vp));
+                pci_save_state(pdev);
                acpi_set_WOL(dev);
        }
        retval = register_netdev(dev);
@@ -3233,21 +3233,20 @@ static void vortex_remove_one(struct pci_dev *pdev)
        vp = netdev_priv(dev);
        if (vp->cb_fn_base)
-                pci_iounmap(VORTEX_PCI(vp), vp->cb_fn_base);
+                pci_iounmap(pdev, vp->cb_fn_base);
        unregister_netdev(dev);
-        if (VORTEX_PCI(vp)) {
+        pci_set_power_state(pdev, PCI_D0);      /* Go active */
-                pci_set_power_state(VORTEX_PCI(vp), PCI_D0);    /* Go active */
+        if (vp->pm_state_valid)
-                if (vp->pm_state_valid)
+                pci_restore_state(pdev);
-                        pci_restore_state(VORTEX_PCI(vp));
+        pci_disable_device(pdev);
-                pci_disable_device(VORTEX_PCI(vp));
-        }
        /* Should really use issue_and_wait() here */
        iowrite16(TotalReset | ((vp->drv_flags & EEPROM_RESET) ? 0x04 : 0x14),
             vp->ioaddr + EL3_CMD);
-        pci_iounmap(VORTEX_PCI(vp), vp->ioaddr);
+        pci_iounmap(pdev, vp->ioaddr);
        pci_free_consistent(pdev,
                                                sizeof(struct boom_rx_desc) * RX_RING_SIZE
diff --git a/drivers/net/ethernet/alteon/acenic.c b/drivers/net/ethernet/alteon/acenic.c
index b7894f8af9d1..219be1bf3cfc 100644
--- a/drivers/net/ethernet/alteon/acenic.c
+++ b/drivers/net/ethernet/alteon/acenic.c
@@ -702,19 +702,6 @@ static struct pci_driver acenic_pci_driver = {
        .remove         = acenic_remove_one,
 };
-static int __init acenic_init(void)
-{
-        return pci_register_driver(&acenic_pci_driver);
-}
-static void __exit acenic_exit(void)
-{
-        pci_unregister_driver(&acenic_pci_driver);
-}
-module_init(acenic_init);
-module_exit(acenic_exit);
 static void ace_free_descriptors(struct net_device *dev)
 {
        struct ace_private *ap = netdev_priv(dev);
@@ -3199,3 +3186,5 @@ static int read_eeprom_byte(struct net_device *dev, unsigned long offset)
               ap->name, offset);
        goto out;
 }
+module_pci_driver(acenic_pci_driver);
diff --git a/drivers/net/ethernet/amd/amd8111e.c b/drivers/net/ethernet/amd/amd8111e.c
index 8e6b665a6726..bc71aec1159d 100644
--- a/drivers/net/ethernet/amd/amd8111e.c
+++ b/drivers/net/ethernet/amd/amd8111e.c
@@ -1981,15 +1981,4 @@ static struct pci_driver amd8111e_driver = {
        .resume         = amd8111e_resume
 };
-static int __init amd8111e_init(void)
+module_pci_driver(amd8111e_driver);
-{
-        return pci_register_driver(&amd8111e_driver);
-}
-static void __exit amd8111e_cleanup(void)
-{
-        pci_unregister_driver(&amd8111e_driver);
-}
-module_init(amd8111e_init);
-module_exit(amd8111e_cleanup);
diff --git a/drivers/net/ethernet/apple/bmac.c b/drivers/net/ethernet/apple/bmac.c
index f36bbd6d5085..714dcfe3a469 100644
--- a/drivers/net/ethernet/apple/bmac.c
+++ b/drivers/net/ethernet/apple/bmac.c
@@ -1030,14 +1030,12 @@ static void bmac_set_multicast(struct net_device *dev)
                rx_cfg |= RxPromiscEnable;
                bmwrite(dev, RXCFG, rx_cfg);
        } else {
-                u16 hash_table[4];
+                u16 hash_table[4] = { 0 };
                rx_cfg = bmread(dev, RXCFG);
                rx_cfg &= ~RxPromiscEnable;
                bmwrite(dev, RXCFG, rx_cfg);
-                for(i = 0; i < 4; i++) hash_table[i] = 0;
                netdev_for_each_mc_addr(ha, dev) {
                        crc = ether_crc_le(6, ha->addr);
                        crc >>= 26;
diff --git a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
index 0ba900762b13..786a87483298 100644
--- a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
+++ b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
@@ -2755,27 +2755,4 @@ static struct pci_driver atl1c_driver = {
        .driver.pm = &atl1c_pm_ops,
 };
-/**
+module_pci_driver(atl1c_driver);
- * atl1c_init_module - Driver Registration Routine
- *
- * atl1c_init_module is the first routine called when the driver is
- * loaded. All it does is register with the PCI subsystem.
- */
-static int __init atl1c_init_module(void)
-{
-        return pci_register_driver(&atl1c_driver);
-}
-/**
- * atl1c_exit_module - Driver Exit Cleanup Routine
- *
- * atl1c_exit_module is called just before the driver is removed
- * from memory.
- */
-static void __exit atl1c_exit_module(void)
-{
-        pci_unregister_driver(&atl1c_driver);
-}
-module_init(atl1c_init_module);
-module_exit(atl1c_exit_module);
diff --git a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c
index 0688bb82b442..895f5377ad1b 100644
--- a/drivers/net/ethernet/atheros/atl1e/atl1e_main.c
+++ b/drivers/net/ethernet/atheros/atl1e/atl1e_main.c
@@ -2489,27 +2489,4 @@ static struct pci_driver atl1e_driver = {
        .err_handler = &atl1e_err_handler
 };
-/**
+module_pci_driver(atl1e_driver);
- * atl1e_init_module - Driver Registration Routine
- *
- * atl1e_init_module is the first routine called when the driver is
- * loaded. All it does is register with the PCI subsystem.
- */
-static int __init atl1e_init_module(void)
-{
-        return pci_register_driver(&atl1e_driver);
-}
-/**
- * atl1e_exit_module - Driver Exit Cleanup Routine
- *
- * atl1e_exit_module is called just before the driver is removed
- * from memory.
- */
-static void __exit atl1e_exit_module(void)
-{
-        pci_unregister_driver(&atl1e_driver);
-}
-module_init(atl1e_init_module);
-module_exit(atl1e_exit_module);
diff --git a/drivers/net/ethernet/atheros/atlx/atl1.c b/drivers/net/ethernet/atheros/atlx/atl1.c
index fa0915f3999b..538211d6f7d9 100644
--- a/drivers/net/ethernet/atheros/atlx/atl1.c
+++ b/drivers/net/ethernet/atheros/atlx/atl1.c
@@ -3145,31 +3145,6 @@ static struct pci_driver atl1_driver = {
        .driver.pm = &atl1_pm_ops,
 };
-/**
- * atl1_exit_module - Driver Exit Cleanup Routine
- *
- * atl1_exit_module is called just before the driver is removed
- * from memory.
- */
-static void __exit atl1_exit_module(void)
-{
-        pci_unregister_driver(&atl1_driver);
-}
-/**
- * atl1_init_module - Driver Registration Routine
- *
- * atl1_init_module is the first routine called when the driver is
- * loaded. All it does is register with the PCI subsystem.
- */
-static int __init atl1_init_module(void)
-{
-        return pci_register_driver(&atl1_driver);
-}
-module_init(atl1_init_module);
-module_exit(atl1_exit_module);
 struct atl1_stats {
        char stat_string[ETH_GSTRING_LEN];
        int sizeof_stat;
@@ -3705,3 +3680,5 @@ static const struct ethtool_ops atl1_ethtool_ops = {
        .get_ethtool_stats      = atl1_get_ethtool_stats,
        .get_sset_count         = atl1_get_sset_count,
 };
+module_pci_driver(atl1_driver);
diff --git a/drivers/net/ethernet/broadcom/bnx2.c b/drivers/net/ethernet/broadcom/bnx2.c
index 5d204492c603..1a1b23eb13dc 100644
--- a/drivers/net/ethernet/broadcom/bnx2.c
+++ b/drivers/net/ethernet/broadcom/bnx2.c
@@ -8764,18 +8764,4 @@ static struct pci_driver bnx2_pci_driver = {
        .err_handler    = &bnx2_err_handler,
 };
-static int __init bnx2_init(void)
+module_pci_driver(bnx2_pci_driver);
-{
-        return pci_register_driver(&bnx2_pci_driver);
-}
-static void __exit bnx2_cleanup(void)
-{
-        pci_unregister_driver(&bnx2_pci_driver);
-}
-module_init(bnx2_init);
-module_exit(bnx2_cleanup);
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
index 3dba2a70a00e..946450d6d988 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
@@ -1937,6 +1937,8 @@ int bnx2x_sp_post(struct bnx2x *bp, int command, int cid,
 void bnx2x_update_coalesce(struct bnx2x *bp);
 int bnx2x_get_cur_phy_idx(struct bnx2x *bp);
+bool bnx2x_port_after_undi(struct bnx2x *bp);
 static inline u32 reg_poll(struct bnx2x *bp, u32 reg, u32 expected, int ms,
                           int wait)
 {
@@ -2137,6 +2139,8 @@ void bnx2x_igu_clear_sb_gen(struct bnx2x *bp, u8 func, u8 idu_sb_id,
 #define ATTN_HARD_WIRED_MASK            0xff00
 #define ATTENTION_ID                    4
+#define IS_MF_STORAGE_ONLY(bp) (IS_MF_STORAGE_SD(bp) || \
+                                 IS_MF_FCOE_AFEX(bp))
 /* stuff added to make the code fit 80Col */
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
index be59ec4b2c30..c80f1d26f40d 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c
@@ -2183,6 +2183,8 @@ alloc_mem_err:
 /* send load request to mcp and analyze response */
 static int bnx2x_nic_load_request(struct bnx2x *bp, u32 *load_code)
 {
+        u32 param;
        /* init fw_seq */
        bp->fw_seq =
                (SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
@@ -2195,9 +2197,13 @@ static int bnx2x_nic_load_request(struct bnx2x *bp, u32 *load_code)
                 DRV_PULSE_SEQ_MASK);
        BNX2X_DEV_INFO("drv_pulse 0x%x\n", bp->fw_drv_pulse_wr_seq);
+        param = DRV_MSG_CODE_LOAD_REQ_WITH_LFA;
+        if (IS_MF_SD(bp) && bnx2x_port_after_undi(bp))
+                param |= DRV_MSG_CODE_LOAD_REQ_FORCE_LFA;
        /* load request */
-        (*load_code) = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ,
+        (*load_code) = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ, param);
-                                        DRV_MSG_CODE_LOAD_REQ_WITH_LFA);
        /* if mcp fails to respond we must abort */
        if (!(*load_code)) {
@@ -4604,6 +4610,7 @@ int bnx2x_set_features(struct net_device *dev, netdev_features_t features)
 {
        struct bnx2x *bp = netdev_priv(dev);
        u32 flags = bp->flags;
+        u32 changes;
        bool bnx2x_reload = false;
        if (features & NETIF_F_LRO)
@@ -4628,10 +4635,16 @@ int bnx2x_set_features(struct net_device *dev, netdev_features_t features)
                }
        }
-        if (flags ^ bp->flags) {
+        changes = flags ^ bp->flags;
-                bp->flags = flags;
+        /* if GRO is changed while LRO is enabled, dont force a reload */
+        if ((changes & GRO_ENABLE_FLAG) && (flags & TPA_ENABLE_FLAG))
+                changes &= ~GRO_ENABLE_FLAG;
+        if (changes)
                bnx2x_reload = true;
-        }
+        bp->flags = flags;
        if (bnx2x_reload) {
                if (bp->recovery_state == BNX2X_RECOVERY_DONE)
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
index ce1a91618677..32aa88f520dc 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_ethtool.c
@@ -1921,6 +1921,19 @@ static const char bnx2x_tests_str_arr[BNX2X_NUM_TESTS_SF][ETH_GSTRING_LEN] = {
        "link_test (online)         "
 };
+enum {
+        BNX2X_PRI_FLAG_ISCSI,
+        BNX2X_PRI_FLAG_FCOE,
+        BNX2X_PRI_FLAG_STORAGE,
+        BNX2X_PRI_FLAG_LEN,
+};
+static const char bnx2x_private_arr[BNX2X_PRI_FLAG_LEN][ETH_GSTRING_LEN] = {
+        "iSCSI offload support",
+        "FCoE offload support",
+        "Storage only interface"
+};
 static u32 bnx2x_eee_to_adv(u32 eee_adv)
 {
        u32 modes = 0;
@@ -2978,32 +2991,47 @@ static int bnx2x_num_stat_queues(struct bnx2x *bp)
 static int bnx2x_get_sset_count(struct net_device *dev, int stringset)
 {
        struct bnx2x *bp = netdev_priv(dev);
-        int i, num_stats;
+        int i, num_strings = 0;
        switch (stringset) {
        case ETH_SS_STATS:
                if (is_multi(bp)) {
-                        num_stats = bnx2x_num_stat_queues(bp) *
+                        num_strings = bnx2x_num_stat_queues(bp) *
-                                                BNX2X_NUM_Q_STATS;
+                                      BNX2X_NUM_Q_STATS;
                } else
-                        num_stats = 0;
+                        num_strings = 0;
                if (IS_MF_MODE_STAT(bp)) {
                        for (i = 0; i < BNX2X_NUM_STATS; i++)
                                if (IS_FUNC_STAT(i))
-                                        num_stats++;
+                                        num_strings++;
                } else
-                        num_stats += BNX2X_NUM_STATS;
+                        num_strings += BNX2X_NUM_STATS;
-                return num_stats;
+                return num_strings;
        case ETH_SS_TEST:
                return BNX2X_NUM_TESTS(bp);
+        case ETH_SS_PRIV_FLAGS:
+                return BNX2X_PRI_FLAG_LEN;
        default:
                return -EINVAL;
        }
 }
+static u32 bnx2x_get_private_flags(struct net_device *dev)
+{
+        struct bnx2x *bp = netdev_priv(dev);
+        u32 flags = 0;
+        flags |= (!(bp->flags & NO_ISCSI_FLAG) ? 1 : 0) << BNX2X_PRI_FLAG_ISCSI;
+        flags |= (!(bp->flags & NO_FCOE_FLAG)  ? 1 : 0) << BNX2X_PRI_FLAG_FCOE;
+        flags |= (!!IS_MF_STORAGE_ONLY(bp)) << BNX2X_PRI_FLAG_STORAGE;
+        return flags;
+}
 static void bnx2x_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
 {
        struct bnx2x *bp = netdev_priv(dev);
@@ -3045,6 +3073,12 @@ static void bnx2x_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
                        start = 4;
                memcpy(buf, bnx2x_tests_str_arr + start,
                       ETH_GSTRING_LEN * BNX2X_NUM_TESTS(bp));
+                break;
+        case ETH_SS_PRIV_FLAGS:
+                memcpy(buf, bnx2x_private_arr,
+                       ETH_GSTRING_LEN * BNX2X_PRI_FLAG_LEN);
+                break;
        }
 }
@@ -3112,11 +3146,6 @@ static int bnx2x_set_phys_id(struct net_device *dev,
                return -EAGAIN;
        }
-        if (!bp->port.pmf) {
-                DP(BNX2X_MSG_ETHTOOL, "Interface is not pmf\n");
-                return -EOPNOTSUPP;
-        }
        switch (state) {
        case ETHTOOL_ID_ACTIVE:
                return 1;       /* cycle on/off once per second */
@@ -3445,6 +3474,7 @@ static const struct ethtool_ops bnx2x_ethtool_ops = {
        .set_pauseparam         = bnx2x_set_pauseparam,
        .self_test              = bnx2x_self_test,
        .get_sset_count         = bnx2x_get_sset_count,
+        .get_priv_flags         = bnx2x_get_private_flags,
        .get_strings            = bnx2x_get_strings,
        .set_phys_id            = bnx2x_set_phys_id,
        .get_ethtool_stats      = bnx2x_get_ethtool_stats,
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h
index 12f00a40cdf0..5ef3f964e544 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_hsi.h
@@ -1323,6 +1323,8 @@ struct drv_func_mb {
        #define DRV_MSG_CODE_UNLOAD_SKIP_LINK_RESET     0x00000002
        #define DRV_MSG_CODE_LOAD_REQ_WITH_LFA          0x0000100a
+        #define DRV_MSG_CODE_LOAD_REQ_FORCE_LFA         0x00002000
        u32 fw_mb_header;
        #define FW_MSG_CODE_MASK                        0xffff0000
        #define FW_MSG_CODE_DRV_LOAD_COMMON             0x10100000
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index b4c9dea93a53..7ed9cdfa115e 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -9780,6 +9780,21 @@ static bool bnx2x_prev_is_path_marked(struct bnx2x *bp)
        return rc;
 }
+bool bnx2x_port_after_undi(struct bnx2x *bp)
+{
+        struct bnx2x_prev_path_list *entry;
+        bool val;
+        down(&bnx2x_prev_sem);
+        entry = bnx2x_prev_path_get_entry(bp);
+        val = !!(entry && (entry->undi & (1 << BP_PORT(bp))));
+        up(&bnx2x_prev_sem);
+        return val;
+}
 static int bnx2x_prev_mark_path(struct bnx2x *bp, bool after_undi)
 {
        struct bnx2x_prev_path_list *tmp_list;
@@ -10036,7 +10051,6 @@ static int bnx2x_prev_unload(struct bnx2x *bp)
 {
        int time_counter = 10;
        u32 rc, fw, hw_lock_reg, hw_lock_val;
-        struct bnx2x_prev_path_list *prev_list;
        BNX2X_DEV_INFO("Entering Previous Unload Flow\n");
        /* clear hw from errors which may have resulted from an interrupted
@@ -10107,8 +10121,7 @@ static int bnx2x_prev_unload(struct bnx2x *bp)
        }
        /* Mark function if its port was used to boot from SAN */
-        prev_list = bnx2x_prev_path_get_entry(bp);
+        if (bnx2x_port_after_undi(bp))
-        if (prev_list && (prev_list->undi & (1 << BP_PORT(bp))))
                bp->link_params.feature_config_flags |=
                        FEATURE_CONFIG_BOOT_FROM_SAN;
@@ -12747,19 +12760,6 @@ static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
        return 0;
 }
-static void bnx2x_eeh_recover(struct bnx2x *bp)
-{
-        u32 val;
-        mutex_init(&bp->port.phy_mutex);
-        val = SHMEM_RD(bp, validity_map[BP_PORT(bp)]);
-        if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
-                != (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB))
-                BNX2X_ERR("BAD MCP validity signature\n");
-}
 /**
 * bnx2x_io_error_detected - called when PCI error is detected
 * @pdev: Pointer to PCI device
@@ -12828,6 +12828,10 @@ static pci_ers_result_t bnx2x_io_slot_reset(struct pci_dev *pdev)
        if (netif_running(dev)) {
                BNX2X_ERR("IO slot reset --> driver unload\n");
+                /* MCP should have been reset; Need to wait for validity */
+                bnx2x_init_shmem(bp);
                if (IS_PF(bp) && SHMEM2_HAS(bp, drv_capabilities_flag)) {
                        u32 v;
@@ -12886,8 +12890,6 @@ static void bnx2x_io_resume(struct pci_dev *pdev)
        rtnl_lock();
-        bnx2x_eeh_recover(bp);
        bp->fw_seq = SHMEM_RD(bp, func_mb[BP_FW_MB_IDX(bp)].drv_mb_header) &
                                                        DRV_MSG_SEQ_NUMBER_MASK;
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index 1f2dd928888a..c15a92d012ef 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -2320,6 +2320,46 @@ static void tg3_phy_apply_otp(struct tg3 *tp)
        tg3_phy_toggle_auxctl_smdsp(tp, false);
 }
+static void tg3_eee_pull_config(struct tg3 *tp, struct ethtool_eee *eee)
+{
+        u32 val;
+        struct ethtool_eee *dest = &tp->eee;
+        if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP))
+                return;
+        if (eee)
+                dest = eee;
+        if (tg3_phy_cl45_read(tp, MDIO_MMD_AN, TG3_CL45_D7_EEERES_STAT, &val))
+                return;
+        /* Pull eee_active */
+        if (val == TG3_CL45_D7_EEERES_STAT_LP_1000T ||
+            val == TG3_CL45_D7_EEERES_STAT_LP_100TX) {
+                dest->eee_active = 1;
+        } else
+                dest->eee_active = 0;
+        /* Pull lp advertised settings */
+        if (tg3_phy_cl45_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE, &val))
+                return;
+        dest->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
+        /* Pull advertised and eee_enabled settings */
+        if (tg3_phy_cl45_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV, &val))
+                return;
+        dest->eee_enabled = !!val;
+        dest->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
+        /* Pull tx_lpi_enabled */
+        val = tr32(TG3_CPMU_EEE_MODE);
+        dest->tx_lpi_enabled = !!(val & TG3_CPMU_EEEMD_LPI_IN_TX);
+        /* Pull lpi timer value */
+        dest->tx_lpi_timer = tr32(TG3_CPMU_EEE_DBTMR1) & 0xffff;
+}
 static void tg3_phy_eee_adjust(struct tg3 *tp, bool current_link_up)
 {
        u32 val;
@@ -2343,11 +2383,8 @@ static void tg3_phy_eee_adjust(struct tg3 *tp, bool current_link_up)
                tw32(TG3_CPMU_EEE_CTRL, eeectl);
-                tg3_phy_cl45_read(tp, MDIO_MMD_AN,
+                tg3_eee_pull_config(tp, NULL);
-                                  TG3_CL45_D7_EEERES_STAT, &val);
+                if (tp->eee.eee_active)
-                if (val == TG3_CL45_D7_EEERES_STAT_LP_1000T ||
-                    val == TG3_CL45_D7_EEERES_STAT_LP_100TX)
                        tp->setlpicnt = 2;
        }
@@ -4269,6 +4306,16 @@ static int tg3_phy_autoneg_cfg(struct tg3 *tp, u32 advertise, u32 flowctrl)
                /* Advertise 1000-BaseT EEE ability */
                if (advertise & ADVERTISED_1000baseT_Full)
                        val |= MDIO_AN_EEE_ADV_1000T;
+                if (!tp->eee.eee_enabled) {
+                        val = 0;
+                        tp->eee.advertised = 0;
+                } else {
+                        tp->eee.advertised = advertise &
+                                             (ADVERTISED_100baseT_Full |
+                                              ADVERTISED_1000baseT_Full);
+                }
                err = tg3_phy_cl45_write(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV, val);
                if (err)
                        val = 0;
@@ -4513,26 +4560,23 @@ static int tg3_init_5401phy_dsp(struct tg3 *tp)
 static bool tg3_phy_eee_config_ok(struct tg3 *tp)
 {
-        u32 val;
+        struct ethtool_eee eee;
-        u32 tgtadv = 0;
-        u32 advertising = tp->link_config.advertising;
        if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP))
                return true;
-        if (tg3_phy_cl45_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV, &val))
+        tg3_eee_pull_config(tp, &eee);
-                return false;
-        val &= (MDIO_AN_EEE_ADV_100TX | MDIO_AN_EEE_ADV_1000T);
-        if (advertising & ADVERTISED_100baseT_Full)
-                tgtadv |= MDIO_AN_EEE_ADV_100TX;
-        if (advertising & ADVERTISED_1000baseT_Full)
-                tgtadv |= MDIO_AN_EEE_ADV_1000T;
-        if (val != tgtadv)
+        if (tp->eee.eee_enabled) {
-                return false;
+                if (tp->eee.advertised != eee.advertised ||
+                    tp->eee.tx_lpi_timer != eee.tx_lpi_timer ||
+                    tp->eee.tx_lpi_enabled != eee.tx_lpi_enabled)
+                        return false;
+        } else {
+                /* EEE is disabled but we're advertising */
+                if (eee.advertised)
+                        return false;
+        }
        return true;
 }
@@ -4633,6 +4677,42 @@ static void tg3_clear_mac_status(struct tg3 *tp)
        udelay(40);
 }
+static void tg3_setup_eee(struct tg3 *tp)
+{
+        u32 val;
+        val = TG3_CPMU_EEE_LNKIDL_PCIE_NL0 |
+              TG3_CPMU_EEE_LNKIDL_UART_IDL;
+        if (tg3_chip_rev_id(tp) == CHIPREV_ID_57765_A0)
+                val |= TG3_CPMU_EEE_LNKIDL_APE_TX_MT;
+        tw32_f(TG3_CPMU_EEE_LNKIDL_CTRL, val);
+        tw32_f(TG3_CPMU_EEE_CTRL,
+               TG3_CPMU_EEE_CTRL_EXIT_20_1_US);
+        val = TG3_CPMU_EEEMD_ERLY_L1_XIT_DET |
+              (tp->eee.tx_lpi_enabled ? TG3_CPMU_EEEMD_LPI_IN_TX : 0) |
+              TG3_CPMU_EEEMD_LPI_IN_RX |
+              TG3_CPMU_EEEMD_EEE_ENABLE;
+        if (tg3_asic_rev(tp) != ASIC_REV_5717)
+                val |= TG3_CPMU_EEEMD_SND_IDX_DET_EN;
+        if (tg3_flag(tp, ENABLE_APE))
+                val |= TG3_CPMU_EEEMD_APE_TX_DET_EN;
+        tw32_f(TG3_CPMU_EEE_MODE, tp->eee.eee_enabled ? val : 0);
+        tw32_f(TG3_CPMU_EEE_DBTMR1,
+               TG3_CPMU_DBTMR1_PCIEXIT_2047US |
+               (tp->eee.tx_lpi_timer & 0xffff));
+        tw32_f(TG3_CPMU_EEE_DBTMR2,
+               TG3_CPMU_DBTMR2_APE_TX_2047US |
+               TG3_CPMU_DBTMR2_TXIDXEQ_2047US);
+}
 static int tg3_setup_copper_phy(struct tg3 *tp, bool force_reset)
 {
        bool current_link_up;
@@ -4799,8 +4879,10 @@ static int tg3_setup_copper_phy(struct tg3 *tp, bool force_reset)
                         */
                        if (!eee_config_ok &&
                            (tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN) &&
-                            !force_reset)
+                            !force_reset) {
+                                tg3_setup_eee(tp);
                                tg3_phy_reset(tp);
+                        }
                } else {
                        if (!(bmcr & BMCR_ANENABLE) &&
                            tp->link_config.speed == current_speed &&
@@ -9484,46 +9566,17 @@ static int tg3_reset_hw(struct tg3 *tp, bool reset_phy)
        if (tg3_flag(tp, INIT_COMPLETE))
                tg3_abort_hw(tp, 1);
-        /* Enable MAC control of LPI */
-        if (tp->phy_flags & TG3_PHYFLG_EEE_CAP) {
-                val = TG3_CPMU_EEE_LNKIDL_PCIE_NL0 |
-                      TG3_CPMU_EEE_LNKIDL_UART_IDL;
-                if (tg3_chip_rev_id(tp) == CHIPREV_ID_57765_A0)
-                        val |= TG3_CPMU_EEE_LNKIDL_APE_TX_MT;
-                tw32_f(TG3_CPMU_EEE_LNKIDL_CTRL, val);
-                tw32_f(TG3_CPMU_EEE_CTRL,
-                       TG3_CPMU_EEE_CTRL_EXIT_20_1_US);
-                val = TG3_CPMU_EEEMD_ERLY_L1_XIT_DET |
-                      TG3_CPMU_EEEMD_LPI_IN_TX |
-                      TG3_CPMU_EEEMD_LPI_IN_RX |
-                      TG3_CPMU_EEEMD_EEE_ENABLE;
-                if (tg3_asic_rev(tp) != ASIC_REV_5717)
-                        val |= TG3_CPMU_EEEMD_SND_IDX_DET_EN;
-                if (tg3_flag(tp, ENABLE_APE))
-                        val |= TG3_CPMU_EEEMD_APE_TX_DET_EN;
-                tw32_f(TG3_CPMU_EEE_MODE, val);
-                tw32_f(TG3_CPMU_EEE_DBTMR1,
-                       TG3_CPMU_DBTMR1_PCIEXIT_2047US |
-                       TG3_CPMU_DBTMR1_LNKIDLE_2047US);
-                tw32_f(TG3_CPMU_EEE_DBTMR2,
-                       TG3_CPMU_DBTMR2_APE_TX_2047US |
-                       TG3_CPMU_DBTMR2_TXIDXEQ_2047US);
-        }
        if ((tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN) &&
            !(tp->phy_flags & TG3_PHYFLG_USER_CONFIGURED)) {
                tg3_phy_pull_config(tp);
+                tg3_eee_pull_config(tp, NULL);
                tp->phy_flags |= TG3_PHYFLG_USER_CONFIGURED;
        }
+        /* Enable MAC control of LPI */
+        if (tp->phy_flags & TG3_PHYFLG_EEE_CAP)
+                tg3_setup_eee(tp);
        if (reset_phy)
                tg3_phy_reset(tp);
@@ -13602,6 +13655,57 @@ static int tg3_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
        return 0;
 }
+static int tg3_set_eee(struct net_device *dev, struct ethtool_eee *edata)
+{
+        struct tg3 *tp = netdev_priv(dev);
+        if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP)) {
+                netdev_warn(tp->dev, "Board does not support EEE!\n");
+                return -EOPNOTSUPP;
+        }
+        if (edata->advertised != tp->eee.advertised) {
+                netdev_warn(tp->dev,
+                            "Direct manipulation of EEE advertisement is not supported\n");
+                return -EINVAL;
+        }
+        if (edata->tx_lpi_timer > TG3_CPMU_DBTMR1_LNKIDLE_MAX) {
+                netdev_warn(tp->dev,
+                            "Maximal Tx Lpi timer supported is %#x(u)\n",
+                            TG3_CPMU_DBTMR1_LNKIDLE_MAX);
+                return -EINVAL;
+        }
+        tp->eee = *edata;
+        tp->phy_flags |= TG3_PHYFLG_USER_CONFIGURED;
+        tg3_warn_mgmt_link_flap(tp);
+        if (netif_running(tp->dev)) {
+                tg3_full_lock(tp, 0);
+                tg3_setup_eee(tp);
+                tg3_phy_reset(tp);
+                tg3_full_unlock(tp);
+        }
+        return 0;
+}
+static int tg3_get_eee(struct net_device *dev, struct ethtool_eee *edata)
+{
+        struct tg3 *tp = netdev_priv(dev);
+        if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP)) {
+                netdev_warn(tp->dev,
+                            "Board does not support EEE!\n");
+                return -EOPNOTSUPP;
+        }
+        *edata = tp->eee;
+        return 0;
+}
 static const struct ethtool_ops tg3_ethtool_ops = {
        .get_settings           = tg3_get_settings,
        .set_settings           = tg3_set_settings,
@@ -13635,6 +13739,8 @@ static const struct ethtool_ops tg3_ethtool_ops = {
        .get_channels           = tg3_get_channels,
        .set_channels           = tg3_set_channels,
        .get_ts_info            = tg3_get_ts_info,
+        .get_eee                = tg3_get_eee,
+        .set_eee                = tg3_set_eee,
 };
 static struct rtnl_link_stats64 *tg3_get_stats64(struct net_device *dev,
@@ -14983,9 +15089,18 @@ static int tg3_phy_probe(struct tg3 *tp)
             (tg3_asic_rev(tp) == ASIC_REV_5717 &&
              tg3_chip_rev_id(tp) != CHIPREV_ID_5717_A0) ||
             (tg3_asic_rev(tp) == ASIC_REV_57765 &&
-              tg3_chip_rev_id(tp) != CHIPREV_ID_57765_A0)))
+              tg3_chip_rev_id(tp) != CHIPREV_ID_57765_A0))) {
                tp->phy_flags |= TG3_PHYFLG_EEE_CAP;
+                tp->eee.supported = SUPPORTED_100baseT_Full |
+                                    SUPPORTED_1000baseT_Full;
+                tp->eee.advertised = ADVERTISED_100baseT_Full |
+                                     ADVERTISED_1000baseT_Full;
+                tp->eee.eee_enabled = 1;
+                tp->eee.tx_lpi_enabled = 1;
+                tp->eee.tx_lpi_timer = TG3_CPMU_DBTMR1_LNKIDLE_2047US;
+        }
        tg3_phy_init_link_config(tp);
        if (!(tp->phy_flags & TG3_PHYFLG_KEEP_LINK_ON_PWRDN) &&
@@ -17726,15 +17841,4 @@ static struct pci_driver tg3_driver = {
        .driver.pm      = &tg3_pm_ops,
 };
-static int __init tg3_init(void)
+module_pci_driver(tg3_driver);
-{
-        return pci_register_driver(&tg3_driver);
-}
-static void __exit tg3_cleanup(void)
-{
-        pci_unregister_driver(&tg3_driver);
-}
-module_init(tg3_init);
-module_exit(tg3_cleanup);
diff --git a/drivers/net/ethernet/broadcom/tg3.h b/drivers/net/ethernet/broadcom/tg3.h
index 9b2d3ac2474a..2530c20dd823 100644
--- a/drivers/net/ethernet/broadcom/tg3.h
+++ b/drivers/net/ethernet/broadcom/tg3.h
@@ -1175,6 +1175,7 @@
 #define TG3_CPMU_EEE_DBTMR1             0x000036b4
 #define  TG3_CPMU_DBTMR1_PCIEXIT_2047US  0x07ff0000
 #define  TG3_CPMU_DBTMR1_LNKIDLE_2047US  0x000007ff
+#define  TG3_CPMU_DBTMR1_LNKIDLE_MAX     0x0000ffff
 #define TG3_CPMU_EEE_DBTMR2             0x000036b8
 #define  TG3_CPMU_DBTMR2_APE_TX_2047US   0x07ff0000
 #define  TG3_CPMU_DBTMR2_TXIDXEQ_2047US  0x000007ff
@@ -3371,6 +3372,7 @@ struct tg3 {
        unsigned int                    irq_cnt;
        struct ethtool_coalesce         coal;
+        struct ethtool_eee              eee;
        /* firmware info */
        const char                      *fw_needed;
diff --git a/drivers/net/ethernet/brocade/bna/bfa_defs.h b/drivers/net/ethernet/brocade/bna/bfa_defs.h
index e423f82da490..b7d8127c198f 100644
--- a/drivers/net/ethernet/brocade/bna/bfa_defs.h
+++ b/drivers/net/ethernet/brocade/bna/bfa_defs.h
@@ -164,7 +164,8 @@ struct bfa_ioc_attr {
        u8                              port_mode;      /*!< enum bfa_mode */
        u8                              cap_bm;         /*!< capability */
        u8                              port_mode_cfg;  /*!< enum bfa_mode */
-        u8                              rsvd[4];        /*!< 64bit align */
+        u8                              def_fn;         /*!< 1 if default fn */
+        u8                              rsvd[3];        /*!< 64bit align */
 };
 /* Adapter capability mask definition */
diff --git a/drivers/net/ethernet/brocade/bna/bfa_ioc.c b/drivers/net/ethernet/brocade/bna/bfa_ioc.c
index f2b73ffa9122..6f3cac060f29 100644
--- a/drivers/net/ethernet/brocade/bna/bfa_ioc.c
+++ b/drivers/net/ethernet/brocade/bna/bfa_ioc.c
@@ -2371,7 +2371,7 @@ bfa_nw_ioc_get_attr(struct bfa_ioc *ioc, struct bfa_ioc_attr *ioc_attr)
        memset((void *)ioc_attr, 0, sizeof(struct bfa_ioc_attr));
        ioc_attr->state = bfa_ioc_get_state(ioc);
-        ioc_attr->port_id = ioc->port_id;
+        ioc_attr->port_id = bfa_ioc_portid(ioc);
        ioc_attr->port_mode = ioc->port_mode;
        ioc_attr->port_mode_cfg = ioc->port_mode_cfg;
@@ -2381,8 +2381,9 @@ bfa_nw_ioc_get_attr(struct bfa_ioc *ioc, struct bfa_ioc_attr *ioc_attr)
        bfa_ioc_get_adapter_attr(ioc, &ioc_attr->adapter_attr);
-        ioc_attr->pci_attr.device_id = ioc->pcidev.device_id;
+        ioc_attr->pci_attr.device_id = bfa_ioc_devid(ioc);
-        ioc_attr->pci_attr.pcifn = ioc->pcidev.pci_func;
+        ioc_attr->pci_attr.pcifn = bfa_ioc_pcifn(ioc);
+        ioc_attr->def_fn = bfa_ioc_is_default(ioc);
        bfa_ioc_get_pci_chip_rev(ioc, ioc_attr->pci_attr.chip_rev);
 }
diff --git a/drivers/net/ethernet/brocade/bna/bfa_ioc.h b/drivers/net/ethernet/brocade/bna/bfa_ioc.h
index 63a85e555df8..f04e0aab25b4 100644
--- a/drivers/net/ethernet/brocade/bna/bfa_ioc.h
+++ b/drivers/net/ethernet/brocade/bna/bfa_ioc.h
@@ -222,6 +222,8 @@ struct bfa_ioc_hwif {
 #define bfa_ioc_bar0(__ioc)             ((__ioc)->pcidev.pci_bar_kva)
 #define bfa_ioc_portid(__ioc)           ((__ioc)->port_id)
 #define bfa_ioc_asic_gen(__ioc)         ((__ioc)->asic_gen)
+#define bfa_ioc_is_default(__ioc)       \
+        (bfa_ioc_pcifn(__ioc) == bfa_ioc_portid(__ioc))
 #define bfa_ioc_fetch_stats(__ioc, __stats) \
                (((__stats)->drv_stats) = (__ioc)->stats)
 #define bfa_ioc_clr_stats(__ioc)        \
diff --git a/drivers/net/ethernet/brocade/bna/bna.h b/drivers/net/ethernet/brocade/bna/bna.h
index 25dae757e9c4..f1eafc409bbd 100644
--- a/drivers/net/ethernet/brocade/bna/bna.h
+++ b/drivers/net/ethernet/brocade/bna/bna.h
@@ -455,6 +455,8 @@ void bna_bfi_rx_enet_stop_rsp(struct bna_rx *rx,
 void bna_bfi_rxf_cfg_rsp(struct bna_rxf *rxf, struct bfi_msgq_mhdr *msghdr);
 void bna_bfi_rxf_mcast_add_rsp(struct bna_rxf *rxf,
                               struct bfi_msgq_mhdr *msghdr);
+void bna_bfi_rxf_ucast_set_rsp(struct bna_rxf *rxf,
+                               struct bfi_msgq_mhdr *msghdr);
 /* APIs for BNA */
 void bna_rx_mod_init(struct bna_rx_mod *rx_mod, struct bna *bna,
diff --git a/drivers/net/ethernet/brocade/bna/bna_enet.c b/drivers/net/ethernet/brocade/bna/bna_enet.c
index db14f69d63bc..3ca77fad4851 100644
--- a/drivers/net/ethernet/brocade/bna/bna_enet.c
+++ b/drivers/net/ethernet/brocade/bna/bna_enet.c
@@ -298,7 +298,6 @@ bna_msgq_rsp_handler(void *arg, struct bfi_msgq_mhdr *msghdr)
        case BFI_ENET_I2H_RSS_ENABLE_RSP:
        case BFI_ENET_I2H_RX_PROMISCUOUS_RSP:
        case BFI_ENET_I2H_RX_DEFAULT_RSP:
-        case BFI_ENET_I2H_MAC_UCAST_SET_RSP:
        case BFI_ENET_I2H_MAC_UCAST_CLR_RSP:
        case BFI_ENET_I2H_MAC_UCAST_ADD_RSP:
        case BFI_ENET_I2H_MAC_UCAST_DEL_RSP:
@@ -311,6 +310,12 @@ bna_msgq_rsp_handler(void *arg, struct bfi_msgq_mhdr *msghdr)
                        bna_bfi_rxf_cfg_rsp(&rx->rxf, msghdr);
                break;
+        case BFI_ENET_I2H_MAC_UCAST_SET_RSP:
+                bna_rx_from_rid(bna, msghdr->enet_id, rx);
+                if (rx)
+                        bna_bfi_rxf_ucast_set_rsp(&rx->rxf, msghdr);
+                break;
        case BFI_ENET_I2H_MAC_MCAST_ADD_RSP:
                bna_rx_from_rid(bna, msghdr->enet_id, rx);
                if (rx)
diff --git a/drivers/net/ethernet/brocade/bna/bna_tx_rx.c b/drivers/net/ethernet/brocade/bna/bna_tx_rx.c
index ea6f4a036401..57cd1bff59f1 100644
--- a/drivers/net/ethernet/brocade/bna/bna_tx_rx.c
+++ b/drivers/net/ethernet/brocade/bna/bna_tx_rx.c
@@ -711,6 +711,21 @@ bna_bfi_rxf_cfg_rsp(struct bna_rxf *rxf, struct bfi_msgq_mhdr *msghdr)
 }
 void
+bna_bfi_rxf_ucast_set_rsp(struct bna_rxf *rxf,
+                        struct bfi_msgq_mhdr *msghdr)
+{
+        struct bfi_enet_rsp *rsp =
+                (struct bfi_enet_rsp *)msghdr;
+        if (rsp->error) {
+                /* Clear ucast from cache */
+                rxf->ucast_active_set = 0;
+        }
+        bfa_fsm_send_event(rxf, RXF_E_FW_RESP);
+}
+void
 bna_bfi_rxf_mcast_add_rsp(struct bna_rxf *rxf,
                        struct bfi_msgq_mhdr *msghdr)
 {
diff --git a/drivers/net/ethernet/brocade/bna/bnad.c b/drivers/net/ethernet/brocade/bna/bnad.c
index 07f7ef05c3f2..b78e69e0e52a 100644
--- a/drivers/net/ethernet/brocade/bna/bnad.c
+++ b/drivers/net/ethernet/brocade/bna/bnad.c
@@ -2624,6 +2624,9 @@ bnad_stop(struct net_device *netdev)
        bnad_destroy_tx(bnad, 0);
        bnad_destroy_rx(bnad, 0);
+        /* These config flags are cleared in the hardware */
+        bnad->cfg_flags &= ~(BNAD_CF_ALLMULTI | BNAD_CF_PROMISC);
        /* Synchronize mailbox IRQ */
        bnad_mbox_irq_sync(bnad);
diff --git a/drivers/net/ethernet/brocade/bna/bnad.h b/drivers/net/ethernet/brocade/bna/bnad.h
index c1d0bc059bfd..aefee77523f2 100644
--- a/drivers/net/ethernet/brocade/bna/bnad.h
+++ b/drivers/net/ethernet/brocade/bna/bnad.h
@@ -71,7 +71,7 @@ struct bnad_rx_ctrl {
 #define BNAD_NAME                       "bna"
 #define BNAD_NAME_LEN                   64
-#define BNAD_VERSION                    "3.1.2.1"
+#define BNAD_VERSION                    "3.2.21.1"
 #define BNAD_MAILBOX_MSIX_INDEX         0
 #define BNAD_MAILBOX_MSIX_VECTORS       1
diff --git a/drivers/net/ethernet/brocade/bna/cna.h b/drivers/net/ethernet/brocade/bna/cna.h
index 14ca9317c915..c37f706d9992 100644
--- a/drivers/net/ethernet/brocade/bna/cna.h
+++ b/drivers/net/ethernet/brocade/bna/cna.h
@@ -37,8 +37,8 @@
 extern char bfa_version[];
-#define CNA_FW_FILE_CT  "ctfw-3.1.0.0.bin"
+#define CNA_FW_FILE_CT  "ctfw-3.2.1.0.bin"
-#define CNA_FW_FILE_CT2 "ct2fw-3.1.0.0.bin"
+#define CNA_FW_FILE_CT2 "ct2fw-3.2.1.0.bin"
 #define FC_SYMNAME_MAX  256     /*!< max name server symbolic name size */
 #pragma pack(1)
diff --git a/drivers/net/ethernet/chelsio/cxgb/cxgb2.c b/drivers/net/ethernet/chelsio/cxgb/cxgb2.c
index 9624cfe7df57..d7048db9863d 100644
--- a/drivers/net/ethernet/chelsio/cxgb/cxgb2.c
+++ b/drivers/net/ethernet/chelsio/cxgb/cxgb2.c
@@ -1351,22 +1351,11 @@ static void remove_one(struct pci_dev *pdev)
        t1_sw_reset(pdev);
 }
-static struct pci_driver driver = {
+static struct pci_driver cxgb_pci_driver = {
        .name     = DRV_NAME,
        .id_table = t1_pci_tbl,
        .probe    = init_one,
        .remove   = remove_one,
 };
-static int __init t1_init_module(void)
+module_pci_driver(cxgb_pci_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit t1_cleanup_module(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(t1_init_module);
-module_exit(t1_cleanup_module);
diff --git a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c
index 0c96e5fe99cc..4058b856eb71 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c
@@ -1246,6 +1246,7 @@ int cxgb3_offload_activate(struct adapter *adapter)
        struct tid_range stid_range, tid_range;
        struct mtutab mtutab;
        unsigned int l2t_capacity;
+        struct l2t_data *l2td;
        t = kzalloc(sizeof(*t), GFP_KERNEL);
        if (!t)
@@ -1261,8 +1262,8 @@ int cxgb3_offload_activate(struct adapter *adapter)
                goto out_free;
        err = -ENOMEM;
-        RCU_INIT_POINTER(dev->l2opt, t3_init_l2t(l2t_capacity));
+        l2td = t3_init_l2t(l2t_capacity);
-        if (!L2DATA(dev))
+        if (!l2td)
                goto out_free;
        natids = min(tid_range.num / 2, MAX_ATIDS);
@@ -1279,6 +1280,7 @@ int cxgb3_offload_activate(struct adapter *adapter)
        INIT_LIST_HEAD(&t->list_node);
        t->dev = dev;
+        RCU_INIT_POINTER(dev->l2opt, l2td);
        T3C_DATA(dev) = t;
        dev->recv = process_rx;
        dev->neigh_update = t3_l2t_update;
@@ -1294,8 +1296,7 @@ int cxgb3_offload_activate(struct adapter *adapter)
        return 0;
 out_free_l2t:
-        t3_free_l2t(L2DATA(dev));
+        t3_free_l2t(l2td);
-        RCU_INIT_POINTER(dev->l2opt, NULL);
 out_free:
        kfree(t);
        return err;
diff --git a/drivers/net/ethernet/chelsio/cxgb3/sge.c b/drivers/net/ethernet/chelsio/cxgb3/sge.c
index f12e6b85a653..2fd773e267dc 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/sge.c
@@ -455,6 +455,11 @@ static int alloc_pg_chunk(struct adapter *adapter, struct sge_fl *q,
                q->pg_chunk.offset = 0;
                mapping = pci_map_page(adapter->pdev, q->pg_chunk.page,
                                       0, q->alloc_size, PCI_DMA_FROMDEVICE);
+                if (unlikely(pci_dma_mapping_error(adapter->pdev, mapping))) {
+                        __free_pages(q->pg_chunk.page, order);
+                        q->pg_chunk.page = NULL;
+                        return -EIO;
+                }
                q->pg_chunk.mapping = mapping;
        }
        sd->pg_chunk = q->pg_chunk;
@@ -949,40 +954,75 @@ static inline unsigned int calc_tx_descs(const struct sk_buff *skb)
        return flits_to_desc(flits);
 }
+/*      map_skb - map a packet main body and its page fragments
+ *      @pdev: the PCI device
+ *      @skb: the packet
+ *      @addr: placeholder to save the mapped addresses
+ *
+ *      map the main body of an sk_buff and its page fragments, if any.
+ */
+static int map_skb(struct pci_dev *pdev, const struct sk_buff *skb,
+                   dma_addr_t *addr)
+{
+        const skb_frag_t *fp, *end;
+        const struct skb_shared_info *si;
+        *addr = pci_map_single(pdev, skb->data, skb_headlen(skb),
+                               PCI_DMA_TODEVICE);
+        if (pci_dma_mapping_error(pdev, *addr))
+                goto out_err;
+        si = skb_shinfo(skb);
+        end = &si->frags[si->nr_frags];
+        for (fp = si->frags; fp < end; fp++) {
+                *++addr = skb_frag_dma_map(&pdev->dev, fp, 0, skb_frag_size(fp),
+                                           DMA_TO_DEVICE);
+                if (pci_dma_mapping_error(pdev, *addr))
+                        goto unwind;
+        }
+        return 0;
+unwind:
+        while (fp-- > si->frags)
+                dma_unmap_page(&pdev->dev, *--addr, skb_frag_size(fp),
+                               DMA_TO_DEVICE);
+        pci_unmap_single(pdev, addr[-1], skb_headlen(skb), PCI_DMA_TODEVICE);
+out_err:
+        return -ENOMEM;
+}
 /**
- *      make_sgl - populate a scatter/gather list for a packet
+ *      write_sgl - populate a scatter/gather list for a packet
 *      @skb: the packet
 *      @sgp: the SGL to populate
 *      @start: start address of skb main body data to include in the SGL
 *      @len: length of skb main body data to include in the SGL
- *      @pdev: the PCI device
+ *      @addr: the list of the mapped addresses
 *
- *      Generates a scatter/gather list for the buffers that make up a packet
+ *      Copies the scatter/gather list for the buffers that make up a packet
 *      and returns the SGL size in 8-byte words.  The caller must size the SGL
 *      appropriately.
 */
-static inline unsigned int make_sgl(const struct sk_buff *skb,
+static inline unsigned int write_sgl(const struct sk_buff *skb,
                                    struct sg_ent *sgp, unsigned char *start,
-                                    unsigned int len, struct pci_dev *pdev)
+                                    unsigned int len, const dma_addr_t *addr)
 {
-        dma_addr_t mapping;
+        unsigned int i, j = 0, k = 0, nfrags;
-        unsigned int i, j = 0, nfrags;
        if (len) {
-                mapping = pci_map_single(pdev, start, len, PCI_DMA_TODEVICE);
                sgp->len[0] = cpu_to_be32(len);
-                sgp->addr[0] = cpu_to_be64(mapping);
+                sgp->addr[j++] = cpu_to_be64(addr[k++]);
-                j = 1;
        }
        nfrags = skb_shinfo(skb)->nr_frags;
        for (i = 0; i < nfrags; i++) {
                const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
-                mapping = skb_frag_dma_map(&pdev->dev, frag, 0, skb_frag_size(frag),
-                                           DMA_TO_DEVICE);
                sgp->len[j] = cpu_to_be32(skb_frag_size(frag));
-                sgp->addr[j] = cpu_to_be64(mapping);
+                sgp->addr[j] = cpu_to_be64(addr[k++]);
                j ^= 1;
                if (j == 0)
                        ++sgp;
@@ -1138,7 +1178,7 @@ static void write_tx_pkt_wr(struct adapter *adap, struct sk_buff *skb,
                            const struct port_info *pi,
                            unsigned int pidx, unsigned int gen,
                            struct sge_txq *q, unsigned int ndesc,
-                            unsigned int compl)
+                            unsigned int compl, const dma_addr_t *addr)
 {
        unsigned int flits, sgl_flits, cntrl, tso_info;
        struct sg_ent *sgp, sgl[MAX_SKB_FRAGS / 2 + 1];
@@ -1196,7 +1236,7 @@ static void write_tx_pkt_wr(struct adapter *adap, struct sk_buff *skb,
        }
        sgp = ndesc == 1 ? (struct sg_ent *)&d->flit[flits] : sgl;
-        sgl_flits = make_sgl(skb, sgp, skb->data, skb_headlen(skb), adap->pdev);
+        sgl_flits = write_sgl(skb, sgp, skb->data, skb_headlen(skb), addr);
        write_wr_hdr_sgl(ndesc, skb, d, pidx, q, sgl, flits, sgl_flits, gen,
                         htonl(V_WR_OP(FW_WROPCODE_TUNNEL_TX_PKT) | compl),
@@ -1227,6 +1267,7 @@ netdev_tx_t t3_eth_xmit(struct sk_buff *skb, struct net_device *dev)
        struct netdev_queue *txq;
        struct sge_qset *qs;
        struct sge_txq *q;
+        dma_addr_t addr[MAX_SKB_FRAGS + 1];
        /*
         * The chip min packet length is 9 octets but play safe and reject
@@ -1255,6 +1296,11 @@ netdev_tx_t t3_eth_xmit(struct sk_buff *skb, struct net_device *dev)
                return NETDEV_TX_BUSY;
        }
+        if (unlikely(map_skb(adap->pdev, skb, addr) < 0)) {
+                dev_kfree_skb(skb);
+                return NETDEV_TX_OK;
+        }
        q->in_use += ndesc;
        if (unlikely(credits - ndesc < q->stop_thres)) {
                t3_stop_tx_queue(txq, qs, q);
@@ -1312,7 +1358,7 @@ netdev_tx_t t3_eth_xmit(struct sk_buff *skb, struct net_device *dev)
        if (likely(!skb_shared(skb)))
                skb_orphan(skb);
-        write_tx_pkt_wr(adap, skb, pi, pidx, gen, q, ndesc, compl);
+        write_tx_pkt_wr(adap, skb, pi, pidx, gen, q, ndesc, compl, addr);
        check_ring_tx_db(adap, q);
        return NETDEV_TX_OK;
 }
@@ -1578,7 +1624,8 @@ static void setup_deferred_unmapping(struct sk_buff *skb, struct pci_dev *pdev,
 */
 static void write_ofld_wr(struct adapter *adap, struct sk_buff *skb,
                          struct sge_txq *q, unsigned int pidx,
-                          unsigned int gen, unsigned int ndesc)
+                          unsigned int gen, unsigned int ndesc,
+                          const dma_addr_t *addr)
 {
        unsigned int sgl_flits, flits;
        struct work_request_hdr *from;
@@ -1599,9 +1646,9 @@ static void write_ofld_wr(struct adapter *adap, struct sk_buff *skb,
        flits = skb_transport_offset(skb) / 8;
        sgp = ndesc == 1 ? (struct sg_ent *)&d->flit[flits] : sgl;
-        sgl_flits = make_sgl(skb, sgp, skb_transport_header(skb),
+        sgl_flits = write_sgl(skb, sgp, skb_transport_header(skb),
                             skb->tail - skb->transport_header,
-                             adap->pdev);
+                             addr);
        if (need_skb_unmap()) {
                setup_deferred_unmapping(skb, adap->pdev, sgp, sgl_flits);
                skb->destructor = deferred_unmap_destructor;
@@ -1659,6 +1706,11 @@ again:	reclaim_completed_tx(adap, q, TX_RECLAIM_CHUNK);
                goto again;
        }
+        if (map_skb(adap->pdev, skb, (dma_addr_t *)skb->head)) {
+                spin_unlock(&q->lock);
+                return NET_XMIT_SUCCESS;
+        }
        gen = q->gen;
        q->in_use += ndesc;
        pidx = q->pidx;
@@ -1669,7 +1721,7 @@ again:	reclaim_completed_tx(adap, q, TX_RECLAIM_CHUNK);
        }
        spin_unlock(&q->lock);
-        write_ofld_wr(adap, skb, q, pidx, gen, ndesc);
+        write_ofld_wr(adap, skb, q, pidx, gen, ndesc, (dma_addr_t *)skb->head);
        check_ring_tx_db(adap, q);
        return NET_XMIT_SUCCESS;
 }
@@ -1687,6 +1739,7 @@ static void restart_offloadq(unsigned long data)
        struct sge_txq *q = &qs->txq[TXQ_OFLD];
        const struct port_info *pi = netdev_priv(qs->netdev);
        struct adapter *adap = pi->adapter;
+        unsigned int written = 0;
        spin_lock(&q->lock);
 again:  reclaim_completed_tx(adap, q, TX_RECLAIM_CHUNK);
@@ -1706,10 +1759,14 @@ again:	reclaim_completed_tx(adap, q, TX_RECLAIM_CHUNK);
                        break;
                }
+                if (map_skb(adap->pdev, skb, (dma_addr_t *)skb->head))
+                        break;
                gen = q->gen;
                q->in_use += ndesc;
                pidx = q->pidx;
                q->pidx += ndesc;
+                written += ndesc;
                if (q->pidx >= q->size) {
                        q->pidx -= q->size;
                        q->gen ^= 1;
@@ -1717,7 +1774,8 @@ again:	reclaim_completed_tx(adap, q, TX_RECLAIM_CHUNK);
                __skb_unlink(skb, &q->sendq);
                spin_unlock(&q->lock);
-                write_ofld_wr(adap, skb, q, pidx, gen, ndesc);
+                write_ofld_wr(adap, skb, q, pidx, gen, ndesc,
+                             (dma_addr_t *)skb->head);
                spin_lock(&q->lock);
        }
        spin_unlock(&q->lock);
@@ -1727,8 +1785,9 @@ again:	reclaim_completed_tx(adap, q, TX_RECLAIM_CHUNK);
        set_bit(TXQ_LAST_PKT_DB, &q->flags);
 #endif
        wmb();
-        t3_write_reg(adap, A_SG_KDOORBELL,
+        if (likely(written))
-                     F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id));
+                t3_write_reg(adap, A_SG_KDOORBELL,
+                             F_SELEGRCNTX | V_EGRCNTX(q->cntxt_id));
 }
 /**
diff --git a/drivers/net/ethernet/davicom/dm9000.c b/drivers/net/ethernet/davicom/dm9000.c
index 9105465b2a1a..dd243a1b03e0 100644
--- a/drivers/net/ethernet/davicom/dm9000.c
+++ b/drivers/net/ethernet/davicom/dm9000.c
@@ -29,6 +29,8 @@
 #include <linux/spinlock.h>
 #include <linux/crc32.h>
 #include <linux/mii.h>
+#include <linux/of.h>
+#include <linux/of_net.h>
 #include <linux/ethtool.h>
 #include <linux/dm9000.h>
 #include <linux/delay.h>
@@ -827,7 +829,7 @@ dm9000_hash_table_unlocked(struct net_device *dev)
        struct netdev_hw_addr *ha;
        int i, oft;
        u32 hash_val;
-        u16 hash_table[4];
+        u16 hash_table[4] = { 0, 0, 0, 0x8000 }; /* broadcast address */
        u8 rcr = RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN;
        dm9000_dbg(db, 1, "entering %s\n", __func__);
@@ -835,13 +837,6 @@ dm9000_hash_table_unlocked(struct net_device *dev)
        for (i = 0, oft = DM9000_PAR; i < 6; i++, oft++)
                iow(db, oft, dev->dev_addr[i]);
-        /* Clear Hash Table */
-        for (i = 0; i < 4; i++)
-                hash_table[i] = 0x0;
-        /* broadcast address */
-        hash_table[3] = 0x8000;
        if (dev->flags & IFF_PROMISC)
                rcr |= RCR_PRMSC;
@@ -1358,6 +1353,31 @@ static const struct net_device_ops dm9000_netdev_ops = {
 #endif
 };
+static struct dm9000_plat_data *dm9000_parse_dt(struct device *dev)
+{
+        struct dm9000_plat_data *pdata;
+        struct device_node *np = dev->of_node;
+        const void *mac_addr;
+        if (!IS_ENABLED(CONFIG_OF) || !np)
+                return NULL;
+        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return ERR_PTR(-ENOMEM);
+        if (of_find_property(np, "davicom,ext-phy", NULL))
+                pdata->flags |= DM9000_PLATF_EXT_PHY;
+        if (of_find_property(np, "davicom,no-eeprom", NULL))
+                pdata->flags |= DM9000_PLATF_NO_EEPROM;
+        mac_addr = of_get_mac_address(np);
+        if (mac_addr)
+                memcpy(pdata->dev_addr, mac_addr, sizeof(pdata->dev_addr));
+        return pdata;
+}
 /*
 * Search DM9000 board, allocate space and register it
 */
@@ -1373,6 +1393,12 @@ dm9000_probe(struct platform_device *pdev)
        int i;
        u32 id_val;
+        if (!pdata) {
+                pdata = dm9000_parse_dt(&pdev->dev);
+                if (IS_ERR(pdata))
+                        return PTR_ERR(pdata);
+        }
        /* Init network device */
        ndev = alloc_etherdev(sizeof(struct board_info));
        if (!ndev)
@@ -1683,11 +1709,20 @@ dm9000_drv_remove(struct platform_device *pdev)
        return 0;
 }
+#ifdef CONFIG_OF
+static const struct of_device_id dm9000_of_matches[] = {
+        { .compatible = "davicom,dm9000", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, dm9000_of_matches);
+#endif
 static struct platform_driver dm9000_driver = {
        .driver = {
                .name    = "dm9000",
                .owner   = THIS_MODULE,
                .pm      = &dm9000_drv_pm_ops,
+                .of_match_table = of_match_ptr(dm9000_of_matches),
        },
        .probe   = dm9000_probe,
        .remove  = dm9000_drv_remove,
diff --git a/drivers/net/ethernet/dec/tulip/xircom_cb.c b/drivers/net/ethernet/dec/tulip/xircom_cb.c
index cdbcd1643141..9b84cb04fe5f 100644
--- a/drivers/net/ethernet/dec/tulip/xircom_cb.c
+++ b/drivers/net/ethernet/dec/tulip/xircom_cb.c
@@ -1171,16 +1171,4 @@ investigate_write_descriptor(struct net_device *dev,
        }
 }
-static int __init xircom_init(void)
+module_pci_driver(xircom_ops);
-{
-        return pci_register_driver(&xircom_ops);
-}
-static void __exit xircom_exit(void)
-{
-        pci_unregister_driver(&xircom_ops);
-}
-module_init(xircom_init)
-module_exit(xircom_exit)
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index ca2967b0f18b..3d5e1a8929ae 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -834,32 +834,27 @@ static int be_vlan_tag_tx_chk(struct be_adapter *adapter, struct sk_buff *skb)
        return vlan_tx_tag_present(skb) || adapter->pvid || adapter->qnq_vid;
 }
-static int be_ipv6_tx_stall_chk(struct be_adapter *adapter, struct sk_buff *skb)
+static int be_ipv6_tx_stall_chk(struct be_adapter *adapter,
+                                struct sk_buff *skb)
 {
-        return BE3_chip(adapter) &&
+        return BE3_chip(adapter) && be_ipv6_exthdr_check(skb);
-                be_ipv6_exthdr_check(skb);
 }
-static netdev_tx_t be_xmit(struct sk_buff *skb,
+static struct sk_buff *be_xmit_workarounds(struct be_adapter *adapter,
-                        struct net_device *netdev)
+                                           struct sk_buff *skb,
+                                           bool *skip_hw_vlan)
 {
-        struct be_adapter *adapter = netdev_priv(netdev);
-        struct be_tx_obj *txo = &adapter->tx_obj[skb_get_queue_mapping(skb)];
-        struct be_queue_info *txq = &txo->q;
-        struct iphdr *ip = NULL;
-        u32 wrb_cnt = 0, copied = 0;
-        u32 start = txq->head, eth_hdr_len;
-        bool dummy_wrb, stopped = false;
-        bool skip_hw_vlan = false;
        struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
+        unsigned int eth_hdr_len;
-        eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ?
+        struct iphdr *ip;
-                VLAN_ETH_HLEN : ETH_HLEN;
        /* For padded packets, BE HW modifies tot_len field in IP header
         * incorrecly when VLAN tag is inserted by HW.
         */
-        if (skb->len <= 60 && vlan_tx_tag_present(skb) && is_ipv4_pkt(skb)) {
+        eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ?
+                                                VLAN_ETH_HLEN : ETH_HLEN;
+        if (skb->len <= 60 && vlan_tx_tag_present(skb) &&
+            is_ipv4_pkt(skb)) {
                ip = (struct iphdr *)ip_hdr(skb);
                pskb_trim(skb, eth_hdr_len + ntohs(ip->tot_len));
        }
@@ -869,15 +864,15 @@ static netdev_tx_t be_xmit(struct sk_buff *skb,
         */
        if ((adapter->function_mode & UMC_ENABLED) &&
            veh->h_vlan_proto == htons(ETH_P_8021Q))
-                        skip_hw_vlan = true;
+                        *skip_hw_vlan = true;
        /* HW has a bug wherein it will calculate CSUM for VLAN
         * pkts even though it is disabled.
         * Manually insert VLAN in pkt.
         */
        if (skb->ip_summed != CHECKSUM_PARTIAL &&
-                        vlan_tx_tag_present(skb)) {
+            vlan_tx_tag_present(skb)) {
-                skb = be_insert_vlan_in_pkt(adapter, skb, &skip_hw_vlan);
+                skb = be_insert_vlan_in_pkt(adapter, skb, skip_hw_vlan);
                if (unlikely(!skb))
                        goto tx_drop;
        }
@@ -887,8 +882,8 @@ static netdev_tx_t be_xmit(struct sk_buff *skb,
         * skip HW tagging is not enabled by FW.
         */
        if (unlikely(be_ipv6_tx_stall_chk(adapter, skb) &&
-                     (adapter->pvid || adapter->qnq_vid) &&
+            (adapter->pvid || adapter->qnq_vid) &&
-                     !qnq_async_evt_rcvd(adapter)))
+            !qnq_async_evt_rcvd(adapter)))
                goto tx_drop;
        /* Manual VLAN tag insertion to prevent:
@@ -899,11 +894,31 @@ static netdev_tx_t be_xmit(struct sk_buff *skb,
         */
        if (be_ipv6_tx_stall_chk(adapter, skb) &&
            be_vlan_tag_tx_chk(adapter, skb)) {
-                skb = be_insert_vlan_in_pkt(adapter, skb, &skip_hw_vlan);
+                skb = be_insert_vlan_in_pkt(adapter, skb, skip_hw_vlan);
                if (unlikely(!skb))
                        goto tx_drop;
        }
+        return skb;
+tx_drop:
+        dev_kfree_skb_any(skb);
+        return NULL;
+}
+static netdev_tx_t be_xmit(struct sk_buff *skb, struct net_device *netdev)
+{
+        struct be_adapter *adapter = netdev_priv(netdev);
+        struct be_tx_obj *txo = &adapter->tx_obj[skb_get_queue_mapping(skb)];
+        struct be_queue_info *txq = &txo->q;
+        bool dummy_wrb, stopped = false;
+        u32 wrb_cnt = 0, copied = 0;
+        bool skip_hw_vlan = false;
+        u32 start = txq->head;
+        skb = be_xmit_workarounds(adapter, skb, &skip_hw_vlan);
+        if (!skb)
+                return NETDEV_TX_OK;
        wrb_cnt = wrb_cnt_for_skb(adapter, skb, &dummy_wrb);
        copied = make_tx_wrbs(adapter, txq, skb, wrb_cnt, dummy_wrb,
@@ -933,7 +948,6 @@ static netdev_tx_t be_xmit(struct sk_buff *skb,
                txq->head = start;
                dev_kfree_skb_any(skb);
        }
-tx_drop:
        return NETDEV_TX_OK;
 }
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c
index 85a06037b242..0936b26b5e1e 100644
--- a/drivers/net/ethernet/freescale/fec_main.c
+++ b/drivers/net/ethernet/freescale/fec_main.c
@@ -53,7 +53,6 @@
 #include <linux/of_device.h>
 #include <linux/of_gpio.h>
 #include <linux/of_net.h>
-#include <linux/pinctrl/consumer.h>
 #include <linux/regulator/consumer.h>
 #include <asm/cacheflush.h>
@@ -243,7 +242,7 @@ static void *swap_buffer(void *bufaddr, int len)
        int i;
        unsigned int *buf = bufaddr;
-        for (i = 0; i < (len + 3) / 4; i++, buf++)
+        for (i = 0; i < DIV_ROUND_UP(len, 4); i++, buf++)
                *buf = cpu_to_be32(*buf);
        return bufaddr;
@@ -1841,7 +1840,6 @@ fec_probe(struct platform_device *pdev)
        struct resource *r;
        const struct of_device_id *of_id;
        static int dev_id;
-        struct pinctrl *pinctrl;
        struct regulator *reg_phy;
        of_id = of_match_device(fec_dt_ids, &pdev->dev);
@@ -1891,12 +1889,6 @@ fec_probe(struct platform_device *pdev)
                fep->phy_interface = ret;
        }
-        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
-        if (IS_ERR(pinctrl)) {
-                ret = PTR_ERR(pinctrl);
-                goto failed_pin;
-        }
        fep->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
        if (IS_ERR(fep->clk_ipg)) {
                ret = PTR_ERR(fep->clk_ipg);
@@ -1996,7 +1988,6 @@ failed_regulator:
        clk_disable_unprepare(fep->clk_ipg);
        clk_disable_unprepare(fep->clk_enet_out);
        clk_disable_unprepare(fep->clk_ptp);
-failed_pin:
 failed_clk:
 failed_ioremap:
        free_netdev(ndev);
diff --git a/drivers/net/ethernet/icplus/ipg.c b/drivers/net/ethernet/icplus/ipg.c
index 068d78151658..1fde90b96685 100644
--- a/drivers/net/ethernet/icplus/ipg.c
+++ b/drivers/net/ethernet/icplus/ipg.c
@@ -2298,15 +2298,4 @@ static struct pci_driver ipg_pci_driver = {
        .remove         = ipg_remove,
 };
-static int __init ipg_init_module(void)
+module_pci_driver(ipg_pci_driver);
-{
-        return pci_register_driver(&ipg_pci_driver);
-}
-static void __exit ipg_exit_module(void)
-{
-        pci_unregister_driver(&ipg_pci_driver);
-}
-module_init(ipg_init_module);
-module_exit(ipg_exit_module);
diff --git a/drivers/net/ethernet/intel/e1000e/80003es2lan.c b/drivers/net/ethernet/intel/e1000e/80003es2lan.c
index b71c8502a2b3..895450e9bb3c 100644
--- a/drivers/net/ethernet/intel/e1000e/80003es2lan.c
+++ b/drivers/net/ethernet/intel/e1000e/80003es2lan.c
@@ -66,17 +66,17 @@ static s32 e1000_init_phy_params_80003es2lan(struct e1000_hw *hw)
        s32 ret_val;
        if (hw->phy.media_type != e1000_media_type_copper) {
-                phy->type       = e1000_phy_none;
+                phy->type = e1000_phy_none;
                return 0;
        } else {
                phy->ops.power_up = e1000_power_up_phy_copper;
                phy->ops.power_down = e1000_power_down_phy_copper_80003es2lan;
        }
-        phy->addr               = 1;
+        phy->addr = 1;
-        phy->autoneg_mask       = AUTONEG_ADVERTISE_SPEED_DEFAULT;
+        phy->autoneg_mask = AUTONEG_ADVERTISE_SPEED_DEFAULT;
-        phy->reset_delay_us      = 100;
+        phy->reset_delay_us = 100;
-        phy->type               = e1000_phy_gg82563;
+        phy->type = e1000_phy_gg82563;
        /* This can only be done after all function pointers are setup. */
        ret_val = e1000e_get_phy_id(hw);
@@ -98,19 +98,19 @@ static s32 e1000_init_nvm_params_80003es2lan(struct e1000_hw *hw)
        u32 eecd = er32(EECD);
        u16 size;
-        nvm->opcode_bits        = 8;
+        nvm->opcode_bits = 8;
-        nvm->delay_usec  = 1;
+        nvm->delay_usec = 1;
        switch (nvm->override) {
        case e1000_nvm_override_spi_large:
-                nvm->page_size    = 32;
+                nvm->page_size = 32;
                nvm->address_bits = 16;
                break;
        case e1000_nvm_override_spi_small:
-                nvm->page_size    = 8;
+                nvm->page_size = 8;
                nvm->address_bits = 8;
                break;
        default:
-                nvm->page_size    = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;
+                nvm->page_size = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;
                nvm->address_bits = eecd & E1000_EECD_ADDR_BITS ? 16 : 8;
                break;
        }
@@ -128,7 +128,7 @@ static s32 e1000_init_nvm_params_80003es2lan(struct e1000_hw *hw)
        /* EEPROM access above 16k is unsupported */
        if (size > 14)
                size = 14;
-        nvm->word_size  = 1 << size;
+        nvm->word_size = 1 << size;
        return 0;
 }
@@ -859,7 +859,7 @@ static void e1000_initialize_hw_bits_80003es2lan(struct e1000_hw *hw)
        /* Transmit Arbitration Control 0 */
        reg = er32(TARC(0));
-        reg &= ~(0xF << 27); /* 30:27 */
+        reg &= ~(0xF << 27);    /* 30:27 */
        if (hw->phy.media_type != e1000_media_type_copper)
                reg &= ~(1 << 20);
        ew32(TARC(0), reg);
diff --git a/drivers/net/ethernet/intel/e1000e/82571.c b/drivers/net/ethernet/intel/e1000e/82571.c
index 7380442a3829..4c303e2a7cb3 100644
--- a/drivers/net/ethernet/intel/e1000e/82571.c
+++ b/drivers/net/ethernet/intel/e1000e/82571.c
@@ -77,24 +77,24 @@ static s32 e1000_init_phy_params_82571(struct e1000_hw *hw)
                return 0;
        }
-        phy->addr                        = 1;
+        phy->addr = 1;
-        phy->autoneg_mask                = AUTONEG_ADVERTISE_SPEED_DEFAULT;
+        phy->autoneg_mask = AUTONEG_ADVERTISE_SPEED_DEFAULT;
-        phy->reset_delay_us              = 100;
+        phy->reset_delay_us = 100;
-        phy->ops.power_up                = e1000_power_up_phy_copper;
+        phy->ops.power_up = e1000_power_up_phy_copper;
-        phy->ops.power_down              = e1000_power_down_phy_copper_82571;
+        phy->ops.power_down = e1000_power_down_phy_copper_82571;
        switch (hw->mac.type) {
        case e1000_82571:
        case e1000_82572:
-                phy->type                = e1000_phy_igp_2;
+                phy->type = e1000_phy_igp_2;
                break;
        case e1000_82573:
-                phy->type                = e1000_phy_m88;
+                phy->type = e1000_phy_m88;
                break;
        case e1000_82574:
        case e1000_82583:
-                phy->type                = e1000_phy_bm;
+                phy->type = e1000_phy_bm;
                phy->ops.acquire = e1000_get_hw_semaphore_82574;
                phy->ops.release = e1000_put_hw_semaphore_82574;
                phy->ops.set_d0_lplu_state = e1000_set_d0_lplu_state_82574;
@@ -193,7 +193,7 @@ static s32 e1000_init_nvm_params_82571(struct e1000_hw *hw)
                /* EEPROM access above 16k is unsupported */
                if (size > 14)
                        size = 14;
-                nvm->word_size  = 1 << size;
+                nvm->word_size = 1 << size;
                break;
        }
@@ -339,7 +339,7 @@ static s32 e1000_init_mac_params_82571(struct e1000_hw *hw)
 static s32 e1000_get_variants_82571(struct e1000_adapter *adapter)
 {
        struct e1000_hw *hw = &adapter->hw;
-        static int global_quad_port_a; /* global port a indication */
+        static int global_quad_port_a;  /* global port a indication */
        struct pci_dev *pdev = adapter->pdev;
        int is_port_b = er32(STATUS) & E1000_STATUS_FUNC_1;
        s32 rc;
@@ -1003,8 +1003,6 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
        default:
                break;
        }
-        if (ret_val)
-                e_dbg("Cannot acquire MDIO ownership\n");
        ctrl = er32(CTRL);
@@ -1015,7 +1013,9 @@ static s32 e1000_reset_hw_82571(struct e1000_hw *hw)
        switch (hw->mac.type) {
        case e1000_82574:
        case e1000_82583:
-                e1000_put_hw_semaphore_82574(hw);
+                /* Release mutex only if the hw semaphore is acquired */
+                if (!ret_val)
+                        e1000_put_hw_semaphore_82574(hw);
                break;
        default:
                break;
@@ -1178,7 +1178,7 @@ static void e1000_initialize_hw_bits_82571(struct e1000_hw *hw)
        /* Transmit Arbitration Control 0 */
        reg = er32(TARC(0));
-        reg &= ~(0xF << 27); /* 30:27 */
+        reg &= ~(0xF << 27);    /* 30:27 */
        switch (hw->mac.type) {
        case e1000_82571:
        case e1000_82572:
@@ -1390,7 +1390,7 @@ bool e1000_check_phy_82574(struct e1000_hw *hw)
        ret_val = e1e_rphy(hw, E1000_RECEIVE_ERROR_COUNTER, &receive_errors);
        if (ret_val)
                return false;
-        if (receive_errors == E1000_RECEIVE_ERROR_MAX)  {
+        if (receive_errors == E1000_RECEIVE_ERROR_MAX) {
                ret_val = e1e_rphy(hw, E1000_BASE1000T_STATUS, &status_1kbt);
                if (ret_val)
                        return false;
diff --git a/drivers/net/ethernet/intel/e1000e/ethtool.c b/drivers/net/ethernet/intel/e1000e/ethtool.c
index 7c8ca658d553..59c22bf18701 100644
--- a/drivers/net/ethernet/intel/e1000e/ethtool.c
+++ b/drivers/net/ethernet/intel/e1000e/ethtool.c
@@ -244,7 +244,7 @@ static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
                mac->autoneg = 1;
                adapter->hw.phy.autoneg_advertised = ADVERTISE_1000_FULL;
                break;
-        case SPEED_1000 + DUPLEX_HALF: /* not supported */
+        case SPEED_1000 + DUPLEX_HALF:  /* not supported */
        default:
                goto err_inval;
        }
@@ -416,7 +416,7 @@ static void e1000_set_msglevel(struct net_device *netdev, u32 data)
 static int e1000_get_regs_len(struct net_device __always_unused *netdev)
 {
-#define E1000_REGS_LEN 32 /* overestimate */
+#define E1000_REGS_LEN 32       /* overestimate */
        return E1000_REGS_LEN * sizeof(u32);
 }
@@ -433,22 +433,22 @@ static void e1000_get_regs(struct net_device *netdev,
        regs->version = (1 << 24) | (adapter->pdev->revision << 16) |
            adapter->pdev->device;
-        regs_buff[0]  = er32(CTRL);
+        regs_buff[0] = er32(CTRL);
-        regs_buff[1]  = er32(STATUS);
+        regs_buff[1] = er32(STATUS);
-        regs_buff[2]  = er32(RCTL);
+        regs_buff[2] = er32(RCTL);
-        regs_buff[3]  = er32(RDLEN(0));
+        regs_buff[3] = er32(RDLEN(0));
-        regs_buff[4]  = er32(RDH(0));
+        regs_buff[4] = er32(RDH(0));
-        regs_buff[5]  = er32(RDT(0));
+        regs_buff[5] = er32(RDT(0));
-        regs_buff[6]  = er32(RDTR);
+        regs_buff[6] = er32(RDTR);
-        regs_buff[7]  = er32(TCTL);
+        regs_buff[7] = er32(TCTL);
-        regs_buff[8]  = er32(TDLEN(0));
+        regs_buff[8] = er32(TDLEN(0));
-        regs_buff[9]  = er32(TDH(0));
+        regs_buff[9] = er32(TDH(0));
        regs_buff[10] = er32(TDT(0));
        regs_buff[11] = er32(TIDV);
-        regs_buff[12] = adapter->hw.phy.type;  /* PHY type (IGP=1, M88=0) */
+        regs_buff[12] = adapter->hw.phy.type;   /* PHY type (IGP=1, M88=0) */
        /* ethtool doesn't use anything past this point, so all this
         * code is likely legacy junk for apps that may or may not exist
@@ -1379,7 +1379,7 @@ static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)
        if (hw->phy.media_type == e1000_media_type_copper &&
            hw->phy.type == e1000_phy_m88) {
-                ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */
+                ctrl_reg |= E1000_CTRL_ILOS;    /* Invert Loss of Signal */
        } else {
                /* Set the ILOS bit on the fiber Nic if half duplex link is
                 * detected.
@@ -1613,7 +1613,7 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
                ew32(TDT(0), k);
                e1e_flush();
                msleep(200);
-                time = jiffies; /* set the start time for the receive */
+                time = jiffies; /* set the start time for the receive */
                good_cnt = 0;
                /* receive the sent packets */
                do {
@@ -1636,11 +1636,11 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
                         */
                } while ((good_cnt < 64) && !time_after(jiffies, time + 20));
                if (good_cnt != 64) {
-                        ret_val = 13; /* ret_val is the same as mis-compare */
+                        ret_val = 13;   /* ret_val is the same as mis-compare */
                        break;
                }
                if (jiffies >= (time + 20)) {
-                        ret_val = 14; /* error code for time out error */
+                        ret_val = 14;   /* error code for time out error */
                        break;
                }
        }
diff --git a/drivers/net/ethernet/intel/e1000e/hw.h b/drivers/net/ethernet/intel/e1000e/hw.h
index 84850f7a23e4..a6f903a9b773 100644
--- a/drivers/net/ethernet/intel/e1000e/hw.h
+++ b/drivers/net/ethernet/intel/e1000e/hw.h
@@ -402,13 +402,13 @@ struct e1000_phy_stats {
 struct e1000_host_mng_dhcp_cookie {
        u32 signature;
-        u8  status;
+        u8 status;
-        u8  reserved0;
+        u8 reserved0;
        u16 vlan_id;
        u32 reserved1;
        u16 reserved2;
-        u8  reserved3;
+        u8 reserved3;
-        u8  checksum;
+        u8 checksum;
 };
 /* Host Interface "Rev 1" */
@@ -427,8 +427,8 @@ struct e1000_host_command_info {
 /* Host Interface "Rev 2" */
 struct e1000_host_mng_command_header {
-        u8  command_id;
+        u8 command_id;
-        u8  checksum;
+        u8 checksum;
        u16 reserved1;
        u16 reserved2;
        u16 command_length;
@@ -549,7 +549,7 @@ struct e1000_mac_info {
        u32 mta_shadow[MAX_MTA_REG];
        u16 rar_entry_count;
-        u8  forced_speed_duplex;
+        u8 forced_speed_duplex;
        bool adaptive_ifs;
        bool has_fwsm;
@@ -577,7 +577,7 @@ struct e1000_phy_info {
        u32 addr;
        u32 id;
-        u32 reset_delay_us; /* in usec */
+        u32 reset_delay_us;     /* in usec */
        u32 revision;
        enum e1000_media_type media_type;
@@ -636,11 +636,11 @@ struct e1000_dev_spec_82571 {
 };
 struct e1000_dev_spec_80003es2lan {
-        bool  mdic_wa_enable;
+        bool mdic_wa_enable;
 };
 struct e1000_shadow_ram {
-        u16  value;
+        u16 value;
        bool modified;
 };
@@ -660,17 +660,17 @@ struct e1000_hw {
        void __iomem *hw_addr;
        void __iomem *flash_address;
-        struct e1000_mac_info  mac;
+        struct e1000_mac_info mac;
-        struct e1000_fc_info   fc;
+        struct e1000_fc_info fc;
-        struct e1000_phy_info  phy;
+        struct e1000_phy_info phy;
-        struct e1000_nvm_info  nvm;
+        struct e1000_nvm_info nvm;
-        struct e1000_bus_info  bus;
+        struct e1000_bus_info bus;
        struct e1000_host_mng_dhcp_cookie mng_cookie;
        union {
-                struct e1000_dev_spec_82571     e82571;
+                struct e1000_dev_spec_82571 e82571;
                struct e1000_dev_spec_80003es2lan e80003es2lan;
-                struct e1000_dev_spec_ich8lan   ich8lan;
+                struct e1000_dev_spec_ich8lan ich8lan;
        } dev_spec;
 };
diff --git a/drivers/net/ethernet/intel/e1000e/ich8lan.c b/drivers/net/ethernet/intel/e1000e/ich8lan.c
index ad9d8f2dd868..9dde390f7e71 100644
--- a/drivers/net/ethernet/intel/e1000e/ich8lan.c
+++ b/drivers/net/ethernet/intel/e1000e/ich8lan.c
@@ -101,12 +101,12 @@ union ich8_hws_flash_regacc {
 /* ICH Flash Protected Region */
 union ich8_flash_protected_range {
        struct ich8_pr {
-                u32 base:13;     /* 0:12 Protected Range Base */
+                u32 base:13;    /* 0:12 Protected Range Base */
-                u32 reserved1:2; /* 13:14 Reserved */
+                u32 reserved1:2;        /* 13:14 Reserved */
-                u32 rpe:1;       /* 15 Read Protection Enable */
+                u32 rpe:1;      /* 15 Read Protection Enable */
-                u32 limit:13;    /* 16:28 Protected Range Limit */
+                u32 limit:13;   /* 16:28 Protected Range Limit */
-                u32 reserved2:2; /* 29:30 Reserved */
+                u32 reserved2:2;        /* 29:30 Reserved */
-                u32 wpe:1;       /* 31 Write Protection Enable */
+                u32 wpe:1;      /* 31 Write Protection Enable */
        } range;
        u32 regval;
 };
@@ -362,21 +362,21 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
        struct e1000_phy_info *phy = &hw->phy;
        s32 ret_val;
-        phy->addr                     = 1;
+        phy->addr = 1;
-        phy->reset_delay_us           = 100;
+        phy->reset_delay_us = 100;
-        phy->ops.set_page             = e1000_set_page_igp;
+        phy->ops.set_page = e1000_set_page_igp;
-        phy->ops.read_reg             = e1000_read_phy_reg_hv;
+        phy->ops.read_reg = e1000_read_phy_reg_hv;
-        phy->ops.read_reg_locked      = e1000_read_phy_reg_hv_locked;
+        phy->ops.read_reg_locked = e1000_read_phy_reg_hv_locked;
-        phy->ops.read_reg_page        = e1000_read_phy_reg_page_hv;
+        phy->ops.read_reg_page = e1000_read_phy_reg_page_hv;
-        phy->ops.set_d0_lplu_state    = e1000_set_lplu_state_pchlan;
+        phy->ops.set_d0_lplu_state = e1000_set_lplu_state_pchlan;
-        phy->ops.set_d3_lplu_state    = e1000_set_lplu_state_pchlan;
+        phy->ops.set_d3_lplu_state = e1000_set_lplu_state_pchlan;
-        phy->ops.write_reg            = e1000_write_phy_reg_hv;
+        phy->ops.write_reg = e1000_write_phy_reg_hv;
-        phy->ops.write_reg_locked     = e1000_write_phy_reg_hv_locked;
+        phy->ops.write_reg_locked = e1000_write_phy_reg_hv_locked;
-        phy->ops.write_reg_page       = e1000_write_phy_reg_page_hv;
+        phy->ops.write_reg_page = e1000_write_phy_reg_page_hv;
-        phy->ops.power_up             = e1000_power_up_phy_copper;
+        phy->ops.power_up = e1000_power_up_phy_copper;
-        phy->ops.power_down           = e1000_power_down_phy_copper_ich8lan;
+        phy->ops.power_down = e1000_power_down_phy_copper_ich8lan;
-        phy->autoneg_mask             = AUTONEG_ADVERTISE_SPEED_DEFAULT;
+        phy->autoneg_mask = AUTONEG_ADVERTISE_SPEED_DEFAULT;
        phy->id = e1000_phy_unknown;
@@ -445,11 +445,11 @@ static s32 e1000_init_phy_params_ich8lan(struct e1000_hw *hw)
        s32 ret_val;
        u16 i = 0;
-        phy->addr                       = 1;
+        phy->addr = 1;
-        phy->reset_delay_us             = 100;
+        phy->reset_delay_us = 100;
-        phy->ops.power_up               = e1000_power_up_phy_copper;
+        phy->ops.power_up = e1000_power_up_phy_copper;
-        phy->ops.power_down             = e1000_power_down_phy_copper_ich8lan;
+        phy->ops.power_down = e1000_power_down_phy_copper_ich8lan;
        /* We may need to do this twice - once for IGP and if that fails,
         * we'll set BM func pointers and try again
@@ -457,7 +457,7 @@ static s32 e1000_init_phy_params_ich8lan(struct e1000_hw *hw)
        ret_val = e1000e_determine_phy_address(hw);
        if (ret_val) {
                phy->ops.write_reg = e1000e_write_phy_reg_bm;
-                phy->ops.read_reg  = e1000e_read_phy_reg_bm;
+                phy->ops.read_reg = e1000e_read_phy_reg_bm;
                ret_val = e1000e_determine_phy_address(hw);
                if (ret_val) {
                        e_dbg("Cannot determine PHY addr. Erroring out\n");
@@ -560,7 +560,7 @@ static s32 e1000_init_nvm_params_ich8lan(struct e1000_hw *hw)
        /* Clear shadow ram */
        for (i = 0; i < nvm->word_size; i++) {
                dev_spec->shadow_ram[i].modified = false;
-                dev_spec->shadow_ram[i].value    = 0xFFFF;
+                dev_spec->shadow_ram[i].value = 0xFFFF;
        }
        return 0;
@@ -1012,7 +1012,7 @@ static s32 e1000_check_for_copper_link_ich8lan(struct e1000_hw *hw)
        hw->dev_spec.ich8lan.eee_lp_ability = 0;
        if (!link)
-                return 0; /* No link detected */
+                return 0;       /* No link detected */
        mac->get_link_status = false;
@@ -2816,7 +2816,7 @@ static s32 e1000_read_flash_data_ich8lan(struct e1000_hw *hw, u32 offset,
        s32 ret_val = -E1000_ERR_NVM;
        u8 count = 0;
-        if (size < 1  || size > 2 || offset > ICH_FLASH_LINEAR_ADDR_MASK)
+        if (size < 1 || size > 2 || offset > ICH_FLASH_LINEAR_ADDR_MASK)
                return -E1000_ERR_NVM;
        flash_linear_addr = ((ICH_FLASH_LINEAR_ADDR_MASK & offset) +
@@ -2939,7 +2939,7 @@ static s32 e1000_update_nvm_checksum_ich8lan(struct e1000_hw *hw)
         * write to bank 0 etc.  We also need to erase the segment that
         * is going to be written
         */
-        ret_val =  e1000_valid_nvm_bank_detect_ich8lan(hw, &bank);
+        ret_val = e1000_valid_nvm_bank_detect_ich8lan(hw, &bank);
        if (ret_val) {
                e_dbg("Could not detect valid bank, assuming bank 0\n");
                bank = 0;
@@ -4073,7 +4073,7 @@ void e1000e_igp3_phy_powerdown_workaround_ich8lan(struct e1000_hw *hw)
 {
        u32 reg;
        u16 data;
-        u8  retry = 0;
+        u8 retry = 0;
        if (hw->phy.type != e1000_phy_igp_3)
                return;
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index a27e3bcc3249..77f81cbb601a 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -1196,7 +1196,7 @@ static bool e1000_clean_tx_irq(struct e1000_ring *tx_ring)
        while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
               (count < tx_ring->count)) {
                bool cleaned = false;
-                rmb(); /* read buffer_info after eop_desc */
+                rmb();          /* read buffer_info after eop_desc */
                for (; !cleaned; count++) {
                        tx_desc = E1000_TX_DESC(*tx_ring, i);
                        buffer_info = &tx_ring->buffer_info[i];
@@ -1385,7 +1385,7 @@ static bool e1000_clean_rx_irq_ps(struct e1000_ring *rx_ring, int *work_done,
                                skb_put(skb, l1);
                                goto copydone;
-                        } /* if */
+                        }       /* if */
                }
                for (j = 0; j < PS_PAGE_BUFFERS; j++) {
@@ -1800,7 +1800,7 @@ static irqreturn_t e1000_intr(int __always_unused irq, void *data)
        u32 rctl, icr = er32(ICR);
        if (!icr || test_bit(__E1000_DOWN, &adapter->state))
-                return IRQ_NONE;  /* Not our interrupt */
+                return IRQ_NONE;        /* Not our interrupt */
        /* IMS will not auto-mask if INT_ASSERTED is not set, and if it is
         * not set, then the adapter didn't send an interrupt
@@ -2487,7 +2487,7 @@ static unsigned int e1000_update_itr(u16 itr_setting, int packets, int bytes)
                else if ((packets < 5) && (bytes > 512))
                        retval = low_latency;
                break;
-        case low_latency:  /* 50 usec aka 20000 ints/s */
+        case low_latency:       /* 50 usec aka 20000 ints/s */
                if (bytes > 10000) {
                        /* this if handles the TSO accounting */
                        if (bytes / packets > 8000)
@@ -2502,7 +2502,7 @@ static unsigned int e1000_update_itr(u16 itr_setting, int packets, int bytes)
                        retval = lowest_latency;
                }
                break;
-        case bulk_latency: /* 250 usec aka 4000 ints/s */
+        case bulk_latency:      /* 250 usec aka 4000 ints/s */
                if (bytes > 25000) {
                        if (packets > 35)
                                retval = low_latency;
@@ -2554,7 +2554,7 @@ static void e1000_set_itr(struct e1000_adapter *adapter)
                new_itr = 70000;
                break;
        case low_latency:
-                new_itr = 20000; /* aka hwitr = ~200 */
+                new_itr = 20000;        /* aka hwitr = ~200 */
                break;
        case bulk_latency:
                new_itr = 4000;
@@ -2673,7 +2673,7 @@ static int e1000e_poll(struct napi_struct *napi, int weight)
 }
 static int e1000_vlan_rx_add_vid(struct net_device *netdev,
-                                 __be16 proto, u16 vid)
+                                 __always_unused __be16 proto, u16 vid)
 {
        struct e1000_adapter *adapter = netdev_priv(netdev);
        struct e1000_hw *hw = &adapter->hw;
@@ -2699,7 +2699,7 @@ static int e1000_vlan_rx_add_vid(struct net_device *netdev,
 }
 static int e1000_vlan_rx_kill_vid(struct net_device *netdev,
-                                  __be16 proto, u16 vid)
+                                  __always_unused __be16 proto, u16 vid)
 {
        struct e1000_adapter *adapter = netdev_priv(netdev);
        struct e1000_hw *hw = &adapter->hw;
@@ -3104,13 +3104,13 @@ static void e1000_setup_rctl(struct e1000_adapter *adapter)
                /* UPE and MPE will be handled by normal PROMISC logic
                 * in e1000e_set_rx_mode
                 */
-                rctl |= (E1000_RCTL_SBP | /* Receive bad packets */
+                rctl |= (E1000_RCTL_SBP |       /* Receive bad packets */
-                         E1000_RCTL_BAM | /* RX All Bcast Pkts */
+                         E1000_RCTL_BAM |       /* RX All Bcast Pkts */
-                         E1000_RCTL_PMCF); /* RX All MAC Ctrl Pkts */
+                         E1000_RCTL_PMCF);      /* RX All MAC Ctrl Pkts */
-                rctl &= ~(E1000_RCTL_VFE | /* Disable VLAN filter */
+                rctl &= ~(E1000_RCTL_VFE |      /* Disable VLAN filter */
-                          E1000_RCTL_DPF | /* Allow filtered pause */
+                          E1000_RCTL_DPF |      /* Allow filtered pause */
-                          E1000_RCTL_CFIEN); /* Dis VLAN CFIEN Filter */
+                          E1000_RCTL_CFIEN);    /* Dis VLAN CFIEN Filter */
                /* Do not mess with E1000_CTRL_VME, it affects transmit as well,
                 * and that breaks VLANs.
                 */
@@ -3799,7 +3799,7 @@ void e1000e_reset(struct e1000_adapter *adapter)
                hwm = min(((pba << 10) * 9 / 10),
                          ((pba << 10) - adapter->max_frame_size));
-                fc->high_water = hwm & E1000_FCRTH_RTH; /* 8-byte granularity */
+                fc->high_water = hwm & E1000_FCRTH_RTH; /* 8-byte granularity */
                fc->low_water = fc->high_water - 8;
                break;
        case e1000_pchlan:
@@ -3808,10 +3808,10 @@ void e1000e_reset(struct e1000_adapter *adapter)
                 */
                if (adapter->netdev->mtu > ETH_DATA_LEN) {
                        fc->high_water = 0x3500;
-                        fc->low_water  = 0x1500;
+                        fc->low_water = 0x1500;
                } else {
                        fc->high_water = 0x5000;
-                        fc->low_water  = 0x3000;
+                        fc->low_water = 0x3000;
                }
                fc->refresh_time = 0x1000;
                break;
@@ -4581,7 +4581,7 @@ static void e1000e_update_stats(struct e1000_adapter *adapter)
        adapter->stats.crcerrs += er32(CRCERRS);
        adapter->stats.gprc += er32(GPRC);
        adapter->stats.gorc += er32(GORCL);
-        er32(GORCH); /* Clear gorc */
+        er32(GORCH);            /* Clear gorc */
        adapter->stats.bprc += er32(BPRC);
        adapter->stats.mprc += er32(MPRC);
        adapter->stats.roc += er32(ROC);
@@ -4614,7 +4614,7 @@ static void e1000e_update_stats(struct e1000_adapter *adapter)
        adapter->stats.xofftxc += er32(XOFFTXC);
        adapter->stats.gptc += er32(GPTC);
        adapter->stats.gotc += er32(GOTCL);
-        er32(GOTCH); /* Clear gotc */
+        er32(GOTCH);            /* Clear gotc */
        adapter->stats.rnbc += er32(RNBC);
        adapter->stats.ruc += er32(RUC);
@@ -5106,13 +5106,13 @@ static int e1000_tso(struct e1000_ring *tx_ring, struct sk_buff *skb)
        context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
        buffer_info = &tx_ring->buffer_info[i];
-        context_desc->lower_setup.ip_fields.ipcss  = ipcss;
+        context_desc->lower_setup.ip_fields.ipcss = ipcss;
-        context_desc->lower_setup.ip_fields.ipcso  = ipcso;
+        context_desc->lower_setup.ip_fields.ipcso = ipcso;
-        context_desc->lower_setup.ip_fields.ipcse  = cpu_to_le16(ipcse);
+        context_desc->lower_setup.ip_fields.ipcse = cpu_to_le16(ipcse);
        context_desc->upper_setup.tcp_fields.tucss = tucss;
        context_desc->upper_setup.tcp_fields.tucso = tucso;
        context_desc->upper_setup.tcp_fields.tucse = 0;
-        context_desc->tcp_seg_setup.fields.mss     = cpu_to_le16(mss);
+        context_desc->tcp_seg_setup.fields.mss = cpu_to_le16(mss);
        context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
        context_desc->cmd_and_length = cpu_to_le32(cmd_length);
@@ -5363,7 +5363,7 @@ static void e1000_tx_queue(struct e1000_ring *tx_ring, int tx_flags, int count)
 static int e1000_transfer_dhcp_info(struct e1000_adapter *adapter,
                                    struct sk_buff *skb)
 {
-        struct e1000_hw *hw =  &adapter->hw;
+        struct e1000_hw *hw = &adapter->hw;
        u16 length, offset;
        if (vlan_tx_tag_present(skb) &&
@@ -6259,7 +6259,7 @@ static void e1000_netpoll(struct net_device *netdev)
                e1000_intr_msi(adapter->pdev->irq, netdev);
                enable_irq(adapter->pdev->irq);
                break;
-        default: /* E1000E_INT_MODE_LEGACY */
+        default:                /* E1000E_INT_MODE_LEGACY */
                disable_irq(adapter->pdev->irq);
                e1000_intr(adapter->pdev->irq, netdev);
                enable_irq(adapter->pdev->irq);
@@ -6589,9 +6589,9 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                adapter->eee_advert = MDIO_EEE_100TX | MDIO_EEE_1000T;
        /* construct the net_device struct */
-        netdev->netdev_ops              = &e1000e_netdev_ops;
+        netdev->netdev_ops = &e1000e_netdev_ops;
        e1000e_set_ethtool_ops(netdev);
-        netdev->watchdog_timeo          = 5 * HZ;
+        netdev->watchdog_timeo = 5 * HZ;
        netif_napi_add(netdev, &adapter->napi, e1000e_poll, 64);
        strlcpy(netdev->name, pci_name(pdev), sizeof(netdev->name));
@@ -7034,7 +7034,6 @@ static void __exit e1000_exit_module(void)
 }
 module_exit(e1000_exit_module);
 MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
 MODULE_DESCRIPTION("Intel(R) PRO/1000 Network Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/net/ethernet/intel/e1000e/nvm.c b/drivers/net/ethernet/intel/e1000e/nvm.c
index 44ddc0a0ee0e..d70a03906ac0 100644
--- a/drivers/net/ethernet/intel/e1000e/nvm.c
+++ b/drivers/net/ethernet/intel/e1000e/nvm.c
@@ -117,7 +117,6 @@ static u16 e1000_shift_in_eec_bits(struct e1000_hw *hw, u16 count)
        u16 data;
        eecd = er32(EECD);
        eecd &= ~(E1000_EECD_DO | E1000_EECD_DI);
        data = 0;
diff --git a/drivers/net/ethernet/intel/e1000e/phy.c b/drivers/net/ethernet/intel/e1000e/phy.c
index 59c76a6815a0..da2be59505c0 100644
--- a/drivers/net/ethernet/intel/e1000e/phy.c
+++ b/drivers/net/ethernet/intel/e1000e/phy.c
@@ -1583,13 +1583,13 @@ s32 e1000e_check_downshift(struct e1000_hw *hw)
        case e1000_phy_gg82563:
        case e1000_phy_bm:
        case e1000_phy_82578:
-                offset  = M88E1000_PHY_SPEC_STATUS;
+                offset = M88E1000_PHY_SPEC_STATUS;
-                mask    = M88E1000_PSSR_DOWNSHIFT;
+                mask = M88E1000_PSSR_DOWNSHIFT;
                break;
        case e1000_phy_igp_2:
        case e1000_phy_igp_3:
-                offset  = IGP01E1000_PHY_LINK_HEALTH;
+                offset = IGP01E1000_PHY_LINK_HEALTH;
-                mask    = IGP01E1000_PLHR_SS_DOWNGRADE;
+                mask = IGP01E1000_PLHR_SS_DOWNGRADE;
                break;
        default:
                /* speed downshift not supported */
@@ -1653,14 +1653,14 @@ s32 e1000_check_polarity_igp(struct e1000_hw *hw)
        if ((data & IGP01E1000_PSSR_SPEED_MASK) ==
            IGP01E1000_PSSR_SPEED_1000MBPS) {
-                offset  = IGP01E1000_PHY_PCS_INIT_REG;
+                offset = IGP01E1000_PHY_PCS_INIT_REG;
-                mask    = IGP01E1000_PHY_POLARITY_MASK;
+                mask = IGP01E1000_PHY_POLARITY_MASK;
        } else {
                /* This really only applies to 10Mbps since
                 * there is no polarity for 100Mbps (always 0).
                 */
-                offset  = IGP01E1000_PHY_PORT_STATUS;
+                offset = IGP01E1000_PHY_PORT_STATUS;
-                mask    = IGP01E1000_PSSR_POLARITY_REVERSED;
+                mask = IGP01E1000_PSSR_POLARITY_REVERSED;
        }
        ret_val = e1e_rphy(hw, offset, &data);
@@ -1900,7 +1900,7 @@ s32 e1000e_get_cable_length_igp_2(struct e1000_hw *hw)
 s32 e1000e_get_phy_info_m88(struct e1000_hw *hw)
 {
        struct e1000_phy_info *phy = &hw->phy;
-        s32  ret_val;
+        s32 ret_val;
        u16 phy_data;
        bool link;
@@ -2253,7 +2253,7 @@ enum e1000_phy_type e1000e_get_phy_type_from_id(u32 phy_id)
        case M88E1011_I_PHY_ID:
                phy_type = e1000_phy_m88;
                break;
-        case IGP01E1000_I_PHY_ID: /* IGP 1 & 2 share this */
+        case IGP01E1000_I_PHY_ID:       /* IGP 1 & 2 share this */
                phy_type = e1000_phy_igp_2;
                break;
        case GG82563_E_PHY_ID:
@@ -2317,7 +2317,7 @@ s32 e1000e_determine_phy_address(struct e1000_hw *hw)
                        /* If phy_type is valid, break - we found our
                         * PHY address
                         */
-                        if (phy_type  != e1000_phy_unknown)
+                        if (phy_type != e1000_phy_unknown)
                                return 0;
                        usleep_range(1000, 2000);
diff --git a/drivers/net/ethernet/intel/igb/e1000_82575.c b/drivers/net/ethernet/intel/igb/e1000_82575.c
index ff6a17cb1362..f21a91a299a2 100644
--- a/drivers/net/ethernet/intel/igb/e1000_82575.c
+++ b/drivers/net/ethernet/intel/igb/e1000_82575.c
@@ -401,12 +401,82 @@ static s32 igb_init_mac_params_82575(struct e1000_hw *hw)
        return 0;
 }
+/**
+ *  igb_set_sfp_media_type_82575 - derives SFP module media type.
+ *  @hw: pointer to the HW structure
+ *
+ *  The media type is chosen based on SFP module.
+ *  compatibility flags retrieved from SFP ID EEPROM.
+ **/
+static s32 igb_set_sfp_media_type_82575(struct e1000_hw *hw)
+{
+        s32 ret_val = E1000_ERR_CONFIG;
+        u32 ctrl_ext = 0;
+        struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
+        struct e1000_sfp_flags *eth_flags = &dev_spec->eth_flags;
+        u8 tranceiver_type = 0;
+        s32 timeout = 3;
+        /* Turn I2C interface ON and power on sfp cage */
+        ctrl_ext = rd32(E1000_CTRL_EXT);
+        ctrl_ext &= ~E1000_CTRL_EXT_SDP3_DATA;
+        wr32(E1000_CTRL_EXT, ctrl_ext | E1000_CTRL_I2C_ENA);
+        wrfl();
+        /* Read SFP module data */
+        while (timeout) {
+                ret_val = igb_read_sfp_data_byte(hw,
+                        E1000_I2CCMD_SFP_DATA_ADDR(E1000_SFF_IDENTIFIER_OFFSET),
+                        &tranceiver_type);
+                if (ret_val == 0)
+                        break;
+                msleep(100);
+                timeout--;
+        }
+        if (ret_val != 0)
+                goto out;
+        ret_val = igb_read_sfp_data_byte(hw,
+                        E1000_I2CCMD_SFP_DATA_ADDR(E1000_SFF_ETH_FLAGS_OFFSET),
+                        (u8 *)eth_flags);
+        if (ret_val != 0)
+                goto out;
+        /* Check if there is some SFP module plugged and powered */
+        if ((tranceiver_type == E1000_SFF_IDENTIFIER_SFP) ||
+            (tranceiver_type == E1000_SFF_IDENTIFIER_SFF)) {
+                dev_spec->module_plugged = true;
+                if (eth_flags->e1000_base_lx || eth_flags->e1000_base_sx) {
+                        hw->phy.media_type = e1000_media_type_internal_serdes;
+                } else if (eth_flags->e100_base_fx) {
+                        dev_spec->sgmii_active = true;
+                        hw->phy.media_type = e1000_media_type_internal_serdes;
+                } else if (eth_flags->e1000_base_t) {
+                        dev_spec->sgmii_active = true;
+                        hw->phy.media_type = e1000_media_type_copper;
+                } else {
+                        hw->phy.media_type = e1000_media_type_unknown;
+                        hw_dbg("PHY module has not been recognized\n");
+                        goto out;
+                }
+        } else {
+                hw->phy.media_type = e1000_media_type_unknown;
+        }
+        ret_val = 0;
+out:
+        /* Restore I2C interface setting */
+        wr32(E1000_CTRL_EXT, ctrl_ext);
+        return ret_val;
+}
 static s32 igb_get_invariants_82575(struct e1000_hw *hw)
 {
        struct e1000_mac_info *mac = &hw->mac;
        struct e1000_dev_spec_82575 * dev_spec = &hw->dev_spec._82575;
        s32 ret_val;
        u32 ctrl_ext = 0;
+        u32 link_mode = 0;
        switch (hw->device_id) {
        case E1000_DEV_ID_82575EB_COPPER:
@@ -470,16 +540,56 @@ static s32 igb_get_invariants_82575(struct e1000_hw *hw)
         */
        hw->phy.media_type = e1000_media_type_copper;
        dev_spec->sgmii_active = false;
+        dev_spec->module_plugged = false;
        ctrl_ext = rd32(E1000_CTRL_EXT);
-        switch (ctrl_ext & E1000_CTRL_EXT_LINK_MODE_MASK) {
-        case E1000_CTRL_EXT_LINK_MODE_SGMII:
+        link_mode = ctrl_ext & E1000_CTRL_EXT_LINK_MODE_MASK;
-                dev_spec->sgmii_active = true;
+        switch (link_mode) {
-                break;
        case E1000_CTRL_EXT_LINK_MODE_1000BASE_KX:
-        case E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES:
                hw->phy.media_type = e1000_media_type_internal_serdes;
                break;
+        case E1000_CTRL_EXT_LINK_MODE_SGMII:
+                /* Get phy control interface type set (MDIO vs. I2C)*/
+                if (igb_sgmii_uses_mdio_82575(hw)) {
+                        hw->phy.media_type = e1000_media_type_copper;
+                        dev_spec->sgmii_active = true;
+                        break;
+                }
+                /* fall through for I2C based SGMII */
+        case E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES:
+                /* read media type from SFP EEPROM */
+                ret_val = igb_set_sfp_media_type_82575(hw);
+                if ((ret_val != 0) ||
+                    (hw->phy.media_type == e1000_media_type_unknown)) {
+                        /* If media type was not identified then return media
+                         * type defined by the CTRL_EXT settings.
+                         */
+                        hw->phy.media_type = e1000_media_type_internal_serdes;
+                        if (link_mode == E1000_CTRL_EXT_LINK_MODE_SGMII) {
+                                hw->phy.media_type = e1000_media_type_copper;
+                                dev_spec->sgmii_active = true;
+                        }
+                        break;
+                }
+                /* do not change link mode for 100BaseFX */
+                if (dev_spec->eth_flags.e100_base_fx)
+                        break;
+                /* change current link mode setting */
+                ctrl_ext &= ~E1000_CTRL_EXT_LINK_MODE_MASK;
+                if (hw->phy.media_type == e1000_media_type_copper)
+                        ctrl_ext |= E1000_CTRL_EXT_LINK_MODE_SGMII;
+                else
+                        ctrl_ext |= E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;
+                wr32(E1000_CTRL_EXT, ctrl_ext);
+                break;
        default:
                break;
        }
diff --git a/drivers/net/ethernet/intel/igb/e1000_defines.h b/drivers/net/ethernet/intel/igb/e1000_defines.h
index 31a0f82cc650..aa201abb8ad2 100644
--- a/drivers/net/ethernet/intel/igb/e1000_defines.h
+++ b/drivers/net/ethernet/intel/igb/e1000_defines.h
@@ -61,20 +61,22 @@
 /* Clear Interrupt timers after IMS clear */
 /* packet buffer parity error detection enabled */
 /* descriptor FIFO parity error detection enable */
-#define E1000_CTRL_EXT_PBA_CLR        0x80000000 /* PBA Clear */
+#define E1000_CTRL_EXT_PBA_CLR          0x80000000 /* PBA Clear */
-#define E1000_I2CCMD_REG_ADDR_SHIFT   16
+#define E1000_I2CCMD_REG_ADDR_SHIFT     16
-#define E1000_I2CCMD_PHY_ADDR_SHIFT   24
+#define E1000_I2CCMD_PHY_ADDR_SHIFT     24
-#define E1000_I2CCMD_OPCODE_READ      0x08000000
+#define E1000_I2CCMD_OPCODE_READ        0x08000000
-#define E1000_I2CCMD_OPCODE_WRITE     0x00000000
+#define E1000_I2CCMD_OPCODE_WRITE       0x00000000
-#define E1000_I2CCMD_READY            0x20000000
+#define E1000_I2CCMD_READY              0x20000000
-#define E1000_I2CCMD_ERROR            0x80000000
+#define E1000_I2CCMD_ERROR              0x80000000
-#define E1000_MAX_SGMII_PHY_REG_ADDR  255
+#define E1000_I2CCMD_SFP_DATA_ADDR(a)   (0x0000 + (a))
-#define E1000_I2CCMD_PHY_TIMEOUT      200
+#define E1000_I2CCMD_SFP_DIAG_ADDR(a)   (0x0100 + (a))
-#define E1000_IVAR_VALID              0x80
+#define E1000_MAX_SGMII_PHY_REG_ADDR    255
-#define E1000_GPIE_NSICR              0x00000001
+#define E1000_I2CCMD_PHY_TIMEOUT        200
-#define E1000_GPIE_MSIX_MODE          0x00000010
+#define E1000_IVAR_VALID                0x80
-#define E1000_GPIE_EIAME              0x40000000
+#define E1000_GPIE_NSICR                0x00000001
-#define E1000_GPIE_PBA                0x80000000
+#define E1000_GPIE_MSIX_MODE            0x00000010
+#define E1000_GPIE_EIAME                0x40000000
+#define E1000_GPIE_PBA                  0x80000000
 /* Receive Descriptor bit definitions */
 #define E1000_RXD_STAT_DD       0x01    /* Descriptor Done */
@@ -270,8 +272,10 @@
 #define AUTONEG_ADVERTISE_SPEED_DEFAULT   E1000_ALL_SPEED_DUPLEX
 /* LED Control */
-#define E1000_LEDCTL_LED0_MODE_SHIFT      0
+#define E1000_LEDCTL_LED0_MODE_SHIFT    0
-#define E1000_LEDCTL_LED0_BLINK           0x00000080
+#define E1000_LEDCTL_LED0_BLINK         0x00000080
+#define E1000_LEDCTL_LED0_MODE_MASK     0x0000000F
+#define E1000_LEDCTL_LED0_IVRT          0x00000040
 #define E1000_LEDCTL_MODE_LED_ON        0xE
 #define E1000_LEDCTL_MODE_LED_OFF       0xF
diff --git a/drivers/net/ethernet/intel/igb/e1000_hw.h b/drivers/net/ethernet/intel/igb/e1000_hw.h
index 488abb24a54f..94d7866b9c20 100644
--- a/drivers/net/ethernet/intel/igb/e1000_hw.h
+++ b/drivers/net/ethernet/intel/igb/e1000_hw.h
@@ -528,6 +528,8 @@ struct e1000_dev_spec_82575 {
        bool global_device_reset;
        bool eee_disable;
        bool clear_semaphore_once;
+        struct e1000_sfp_flags eth_flags;
+        bool module_plugged;
 };
 struct e1000_hw {
diff --git a/drivers/net/ethernet/intel/igb/e1000_i210.h b/drivers/net/ethernet/intel/igb/e1000_i210.h
index bfc08e05c907..5caa332e7556 100644
--- a/drivers/net/ethernet/intel/igb/e1000_i210.h
+++ b/drivers/net/ethernet/intel/igb/e1000_i210.h
@@ -82,11 +82,11 @@ enum E1000_INVM_STRUCTURE_TYPE {
 #define E1000_INVM_MAJOR_SHIFT          4
 #define ID_LED_DEFAULT_I210             ((ID_LED_OFF1_ON2  << 8) | \
-                                         (ID_LED_OFF1_OFF2 <<  4) | \
+                                         (ID_LED_DEF1_DEF2 <<  4) | \
-                                         (ID_LED_DEF1_DEF2))
+                                         (ID_LED_OFF1_OFF2))
 #define ID_LED_DEFAULT_I210_SERDES      ((ID_LED_DEF1_DEF2 << 8) | \
                                         (ID_LED_DEF1_DEF2 <<  4) | \
-                                         (ID_LED_DEF1_DEF2))
+                                         (ID_LED_OFF1_ON2))
 /* NVM offset defaults for i211 device */
 #define NVM_INIT_CTRL_2_DEFAULT_I211    0X7243
diff --git a/drivers/net/ethernet/intel/igb/e1000_mac.c b/drivers/net/ethernet/intel/igb/e1000_mac.c
index 2559d70a2321..bab556a47fcc 100644
--- a/drivers/net/ethernet/intel/igb/e1000_mac.c
+++ b/drivers/net/ethernet/intel/igb/e1000_mac.c
@@ -1332,7 +1332,13 @@ s32 igb_id_led_init(struct e1000_hw *hw)
        u16 data, i, temp;
        const u16 led_mask = 0x0F;
-        ret_val = igb_valid_led_default(hw, &data);
+        /* i210 and i211 devices have different LED mechanism */
+        if ((hw->mac.type == e1000_i210) ||
+            (hw->mac.type == e1000_i211))
+                ret_val = igb_valid_led_default_i210(hw, &data);
+        else
+                ret_val = igb_valid_led_default(hw, &data);
        if (ret_val)
                goto out;
@@ -1406,15 +1412,34 @@ s32 igb_blink_led(struct e1000_hw *hw)
        u32 ledctl_blink = 0;
        u32 i;
-        /* set the blink bit for each LED that's "on" (0x0E)
+        if (hw->phy.media_type == e1000_media_type_fiber) {
-         * in ledctl_mode2
+                /* always blink LED0 for PCI-E fiber */
-         */
+                ledctl_blink = E1000_LEDCTL_LED0_BLINK |
-        ledctl_blink = hw->mac.ledctl_mode2;
+                     (E1000_LEDCTL_MODE_LED_ON << E1000_LEDCTL_LED0_MODE_SHIFT);
-        for (i = 0; i < 4; i++)
+        } else {
-                if (((hw->mac.ledctl_mode2 >> (i * 8)) & 0xFF) ==
+                /* Set the blink bit for each LED that's "on" (0x0E)
-                    E1000_LEDCTL_MODE_LED_ON)
+                 * (or "off" if inverted) in ledctl_mode2.  The blink
-                        ledctl_blink |= (E1000_LEDCTL_LED0_BLINK <<
+                 * logic in hardware only works when mode is set to "on"
-                                         (i * 8));
+                 * so it must be changed accordingly when the mode is
+                 * "off" and inverted.
+                 */
+                ledctl_blink = hw->mac.ledctl_mode2;
+                for (i = 0; i < 32; i += 8) {
+                        u32 mode = (hw->mac.ledctl_mode2 >> i) &
+                            E1000_LEDCTL_LED0_MODE_MASK;
+                        u32 led_default = hw->mac.ledctl_default >> i;
+                        if ((!(led_default & E1000_LEDCTL_LED0_IVRT) &&
+                             (mode == E1000_LEDCTL_MODE_LED_ON)) ||
+                            ((led_default & E1000_LEDCTL_LED0_IVRT) &&
+                             (mode == E1000_LEDCTL_MODE_LED_OFF))) {
+                                ledctl_blink &=
+                                    ~(E1000_LEDCTL_LED0_MODE_MASK << i);
+                                ledctl_blink |= (E1000_LEDCTL_LED0_BLINK |
+                                                 E1000_LEDCTL_MODE_LED_ON) << i;
+                        }
+                }
+        }
        wr32(E1000_LEDCTL, ledctl_blink);
diff --git a/drivers/net/ethernet/intel/igb/e1000_phy.c b/drivers/net/ethernet/intel/igb/e1000_phy.c
index 115b0da6e013..1d6a401cc5d4 100644
--- a/drivers/net/ethernet/intel/igb/e1000_phy.c
+++ b/drivers/net/ethernet/intel/igb/e1000_phy.c
@@ -341,6 +341,130 @@ s32 igb_write_phy_reg_i2c(struct e1000_hw *hw, u32 offset, u16 data)
 }
 /**
+ *  igb_read_sfp_data_byte - Reads SFP module data.
+ *  @hw: pointer to the HW structure
+ *  @offset: byte location offset to be read
+ *  @data: read data buffer pointer
+ *
+ *  Reads one byte from SFP module data stored
+ *  in SFP resided EEPROM memory or SFP diagnostic area.
+ *  Function should be called with
+ *  E1000_I2CCMD_SFP_DATA_ADDR(<byte offset>) for SFP module database access
+ *  E1000_I2CCMD_SFP_DIAG_ADDR(<byte offset>) for SFP diagnostics parameters
+ *  access
+ **/
+s32 igb_read_sfp_data_byte(struct e1000_hw *hw, u16 offset, u8 *data)
+{
+        u32 i = 0;
+        u32 i2ccmd = 0;
+        u32 data_local = 0;
+        if (offset > E1000_I2CCMD_SFP_DIAG_ADDR(255)) {
+                hw_dbg("I2CCMD command address exceeds upper limit\n");
+                return -E1000_ERR_PHY;
+        }
+        /* Set up Op-code, EEPROM Address,in the I2CCMD
+         * register. The MAC will take care of interfacing with the
+         * EEPROM to retrieve the desired data.
+         */
+        i2ccmd = ((offset << E1000_I2CCMD_REG_ADDR_SHIFT) |
+                  E1000_I2CCMD_OPCODE_READ);
+        wr32(E1000_I2CCMD, i2ccmd);
+        /* Poll the ready bit to see if the I2C read completed */
+        for (i = 0; i < E1000_I2CCMD_PHY_TIMEOUT; i++) {
+                udelay(50);
+                data_local = rd32(E1000_I2CCMD);
+                if (data_local & E1000_I2CCMD_READY)
+                        break;
+        }
+        if (!(data_local & E1000_I2CCMD_READY)) {
+                hw_dbg("I2CCMD Read did not complete\n");
+                return -E1000_ERR_PHY;
+        }
+        if (data_local & E1000_I2CCMD_ERROR) {
+                hw_dbg("I2CCMD Error bit set\n");
+                return -E1000_ERR_PHY;
+        }
+        *data = (u8) data_local & 0xFF;
+        return 0;
+}
+/**
+ *  e1000_write_sfp_data_byte - Writes SFP module data.
+ *  @hw: pointer to the HW structure
+ *  @offset: byte location offset to write to
+ *  @data: data to write
+ *
+ *  Writes one byte to SFP module data stored
+ *  in SFP resided EEPROM memory or SFP diagnostic area.
+ *  Function should be called with
+ *  E1000_I2CCMD_SFP_DATA_ADDR(<byte offset>) for SFP module database access
+ *  E1000_I2CCMD_SFP_DIAG_ADDR(<byte offset>) for SFP diagnostics parameters
+ *  access
+ **/
+s32 e1000_write_sfp_data_byte(struct e1000_hw *hw, u16 offset, u8 data)
+{
+        u32 i = 0;
+        u32 i2ccmd = 0;
+        u32 data_local = 0;
+        if (offset > E1000_I2CCMD_SFP_DIAG_ADDR(255)) {
+                hw_dbg("I2CCMD command address exceeds upper limit\n");
+                return -E1000_ERR_PHY;
+        }
+        /* The programming interface is 16 bits wide
+         * so we need to read the whole word first
+         * then update appropriate byte lane and write
+         * the updated word back.
+         */
+        /* Set up Op-code, EEPROM Address,in the I2CCMD
+         * register. The MAC will take care of interfacing
+         * with an EEPROM to write the data given.
+         */
+        i2ccmd = ((offset << E1000_I2CCMD_REG_ADDR_SHIFT) |
+                  E1000_I2CCMD_OPCODE_READ);
+        /* Set a command to read single word */
+        wr32(E1000_I2CCMD, i2ccmd);
+        for (i = 0; i < E1000_I2CCMD_PHY_TIMEOUT; i++) {
+                udelay(50);
+                /* Poll the ready bit to see if lastly
+                 * launched I2C operation completed
+                 */
+                i2ccmd = rd32(E1000_I2CCMD);
+                if (i2ccmd & E1000_I2CCMD_READY) {
+                        /* Check if this is READ or WRITE phase */
+                        if ((i2ccmd & E1000_I2CCMD_OPCODE_READ) ==
+                            E1000_I2CCMD_OPCODE_READ) {
+                                /* Write the selected byte
+                                 * lane and update whole word
+                                 */
+                                data_local = i2ccmd & 0xFF00;
+                                data_local |= data;
+                                i2ccmd = ((offset <<
+                                        E1000_I2CCMD_REG_ADDR_SHIFT) |
+                                        E1000_I2CCMD_OPCODE_WRITE | data_local);
+                                wr32(E1000_I2CCMD, i2ccmd);
+                        } else {
+                                break;
+                        }
+                }
+        }
+        if (!(i2ccmd & E1000_I2CCMD_READY)) {
+                hw_dbg("I2CCMD Write did not complete\n");
+                return -E1000_ERR_PHY;
+        }
+        if (i2ccmd & E1000_I2CCMD_ERROR) {
+                hw_dbg("I2CCMD Error bit set\n");
+                return -E1000_ERR_PHY;
+        }
+        return 0;
+}
+/**
 *  igb_read_phy_reg_igp - Read igp PHY register
 *  @hw: pointer to the HW structure
 *  @offset: register offset to be read
diff --git a/drivers/net/ethernet/intel/igb/e1000_phy.h b/drivers/net/ethernet/intel/igb/e1000_phy.h
index 784fd1c40989..6a0873f2095a 100644
--- a/drivers/net/ethernet/intel/igb/e1000_phy.h
+++ b/drivers/net/ethernet/intel/igb/e1000_phy.h
@@ -69,6 +69,8 @@ s32  igb_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data);
 s32  igb_write_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 data);
 s32  igb_read_phy_reg_i2c(struct e1000_hw *hw, u32 offset, u16 *data);
 s32  igb_write_phy_reg_i2c(struct e1000_hw *hw, u32 offset, u16 data);
+s32  igb_read_sfp_data_byte(struct e1000_hw *hw, u16 offset, u8 *data);
+s32  e1000_write_sfp_data_byte(struct e1000_hw *hw, u16 offset, u8 data);
 s32  igb_copper_link_setup_82580(struct e1000_hw *hw);
 s32  igb_get_phy_info_82580(struct e1000_hw *hw);
 s32  igb_phy_force_speed_duplex_82580(struct e1000_hw *hw);
@@ -157,4 +159,22 @@ s32  igb_check_polarity_m88(struct e1000_hw *hw);
 #define GS40G_CS_POWER_DOWN             0x0002
 #define GS40G_LINE_LB                   0x4000
+/* SFP modules ID memory locations */
+#define E1000_SFF_IDENTIFIER_OFFSET     0x00
+#define E1000_SFF_IDENTIFIER_SFF        0x02
+#define E1000_SFF_IDENTIFIER_SFP        0x03
+#define E1000_SFF_ETH_FLAGS_OFFSET      0x06
+/* Flags for SFP modules compatible with ETH up to 1Gb */
+struct e1000_sfp_flags {
+        u8 e1000_base_sx:1;
+        u8 e1000_base_lx:1;
+        u8 e1000_base_cx:1;
+        u8 e1000_base_t:1;
+        u8 e100_base_lx:1;
+        u8 e100_base_fx:1;
+        u8 e10_base_bx10:1;
+        u8 e10_base_px:1;
+};
 #endif
diff --git a/drivers/net/ethernet/intel/igb/igb.h b/drivers/net/ethernet/intel/igb/igb.h
index 9d6c075e232d..15ea8dc9dad3 100644
--- a/drivers/net/ethernet/intel/igb/igb.h
+++ b/drivers/net/ethernet/intel/igb/igb.h
@@ -322,11 +322,6 @@ static inline int igb_desc_unused(struct igb_ring *ring)
        return ring->count + ring->next_to_clean - ring->next_to_use - 1;
 }
-struct igb_i2c_client_list {
-        struct i2c_client *client;
-        struct igb_i2c_client_list *next;
-};
 #ifdef CONFIG_IGB_HWMON
 #define IGB_HWMON_TYPE_LOC      0
@@ -514,13 +509,18 @@ extern void igb_ptp_rx_rgtstamp(struct igb_q_vector *q_vector,
 extern void igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector,
                                unsigned char *va,
                                struct sk_buff *skb);
-static inline void igb_ptp_rx_hwtstamp(struct igb_q_vector *q_vector,
+static inline void igb_ptp_rx_hwtstamp(struct igb_ring *rx_ring,
                                       union e1000_adv_rx_desc *rx_desc,
                                       struct sk_buff *skb)
 {
        if (igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TS) &&
            !igb_test_staterr(rx_desc, E1000_RXDADV_STAT_TSIP))
-                igb_ptp_rx_rgtstamp(q_vector, skb);
+                igb_ptp_rx_rgtstamp(rx_ring->q_vector, skb);
+        /* Update the last_rx_timestamp timer in order to enable watchdog check
+         * for error case of latched timestamp on a dropped packet.
+         */
+        rx_ring->last_rx_timestamp = jiffies;
 }
 extern int igb_ptp_hwtstamp_ioctl(struct net_device *netdev,
diff --git a/drivers/net/ethernet/intel/igb/igb_ethtool.c b/drivers/net/ethernet/intel/igb/igb_ethtool.c
index 7876240fa74e..85fe7b52f435 100644
--- a/drivers/net/ethernet/intel/igb/igb_ethtool.c
+++ b/drivers/net/ethernet/intel/igb/igb_ethtool.c
@@ -142,6 +142,8 @@ static int igb_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 {
        struct igb_adapter *adapter = netdev_priv(netdev);
        struct e1000_hw *hw = &adapter->hw;
+        struct e1000_dev_spec_82575 *dev_spec = &hw->dev_spec._82575;
+        struct e1000_sfp_flags *eth_flags = &dev_spec->eth_flags;
        u32 status;
        if (hw->phy.media_type == e1000_media_type_copper) {
@@ -162,49 +164,26 @@ static int igb_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
                        ecmd->advertising |= hw->phy.autoneg_advertised;
                }
-                if (hw->mac.autoneg != 1)
-                        ecmd->advertising &= ~(ADVERTISED_Pause |
-                                               ADVERTISED_Asym_Pause);
-                if (hw->fc.requested_mode == e1000_fc_full)
-                        ecmd->advertising |= ADVERTISED_Pause;
-                else if (hw->fc.requested_mode == e1000_fc_rx_pause)
-                        ecmd->advertising |= (ADVERTISED_Pause |
-                                              ADVERTISED_Asym_Pause);
-                else if (hw->fc.requested_mode == e1000_fc_tx_pause)
-                        ecmd->advertising |=  ADVERTISED_Asym_Pause;
-                else
-                        ecmd->advertising &= ~(ADVERTISED_Pause |
-                                               ADVERTISED_Asym_Pause);
                ecmd->port = PORT_TP;
                ecmd->phy_address = hw->phy.addr;
                ecmd->transceiver = XCVR_INTERNAL;
        } else {
-                ecmd->supported = (SUPPORTED_1000baseT_Full |
+                ecmd->supported = (SUPPORTED_FIBRE |
-                                   SUPPORTED_100baseT_Full |
-                                   SUPPORTED_FIBRE |
                                   SUPPORTED_Autoneg |
                                   SUPPORTED_Pause);
-                if (hw->mac.type == e1000_i354)
-                                ecmd->supported |= SUPPORTED_2500baseX_Full;
                ecmd->advertising = ADVERTISED_FIBRE;
+                if (hw->mac.type == e1000_i354) {
-                switch (adapter->link_speed) {
+                        ecmd->supported |= SUPPORTED_2500baseX_Full;
-                case SPEED_2500:
+                        ecmd->advertising |= ADVERTISED_2500baseX_Full;
-                        ecmd->advertising = ADVERTISED_2500baseX_Full;
+                }
-                        break;
+                if ((eth_flags->e1000_base_lx) || (eth_flags->e1000_base_sx)) {
-                case SPEED_1000:
+                        ecmd->supported |= SUPPORTED_1000baseT_Full;
-                        ecmd->advertising = ADVERTISED_1000baseT_Full;
+                        ecmd->advertising |= ADVERTISED_1000baseT_Full;
-                        break;
+                }
-                case SPEED_100:
+                if (eth_flags->e100_base_fx) {
-                        ecmd->advertising = ADVERTISED_100baseT_Full;
+                        ecmd->supported |= SUPPORTED_100baseT_Full;
-                        break;
+                        ecmd->advertising |= ADVERTISED_100baseT_Full;
-                default:
-                        break;
                }
                if (hw->mac.autoneg == 1)
                        ecmd->advertising |= ADVERTISED_Autoneg;
@@ -212,6 +191,21 @@ static int igb_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
                ecmd->transceiver = XCVR_EXTERNAL;
        }
+        if (hw->mac.autoneg != 1)
+                ecmd->advertising &= ~(ADVERTISED_Pause |
+                                       ADVERTISED_Asym_Pause);
+        if (hw->fc.requested_mode == e1000_fc_full)
+                ecmd->advertising |= ADVERTISED_Pause;
+        else if (hw->fc.requested_mode == e1000_fc_rx_pause)
+                ecmd->advertising |= (ADVERTISED_Pause |
+                                      ADVERTISED_Asym_Pause);
+        else if (hw->fc.requested_mode == e1000_fc_tx_pause)
+                ecmd->advertising |=  ADVERTISED_Asym_Pause;
+        else
+                ecmd->advertising &= ~(ADVERTISED_Pause |
+                                       ADVERTISED_Asym_Pause);
        status = rd32(E1000_STATUS);
        if (status & E1000_STATUS_LU) {
@@ -392,6 +386,10 @@ static int igb_set_pauseparam(struct net_device *netdev,
        struct e1000_hw *hw = &adapter->hw;
        int retval = 0;
+        /* 100basefx does not support setting link flow control */
+        if (hw->dev_spec._82575.eth_flags.e100_base_fx)
+                return -EINVAL;
        adapter->fc_autoneg = pause->autoneg;
        while (test_and_set_bit(__IGB_RESETTING, &adapter->state))
@@ -813,10 +811,8 @@ static int igb_set_eeprom(struct net_device *netdev,
        ret_val = hw->nvm.ops.write(hw, first_word,
                                    last_word - first_word + 1, eeprom_buff);
-        /* Update the checksum over the first part of the EEPROM if needed
+        /* Update the checksum if nvm write succeeded */
-         * and flush shadow RAM for 82573 controllers
+        if (ret_val == 0)
-         */
-        if ((ret_val == 0) && ((first_word <= NVM_CHECKSUM_REG)))
                hw->nvm.ops.update(hw);
        igb_set_fw_version(adapter);
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index 64cbe0dfe043..6a0c1b66ce54 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -1667,10 +1667,13 @@ void igb_down(struct igb_adapter *adapter)
        wrfl();
        msleep(10);
-        for (i = 0; i < adapter->num_q_vectors; i++)
+        igb_irq_disable(adapter);
+        for (i = 0; i < adapter->num_q_vectors; i++) {
+                napi_synchronize(&(adapter->q_vector[i]->napi));
                napi_disable(&(adapter->q_vector[i]->napi));
+        }
-        igb_irq_disable(adapter);
        del_timer_sync(&adapter->watchdog_timer);
        del_timer_sync(&adapter->phy_info_timer);
@@ -6622,7 +6625,7 @@ static void igb_process_skb_fields(struct igb_ring *rx_ring,
        igb_rx_checksum(rx_ring, rx_desc, skb);
-        igb_ptp_rx_hwtstamp(rx_ring->q_vector, rx_desc, skb);
+        igb_ptp_rx_hwtstamp(rx_ring, rx_desc, skb);
        if ((dev->features & NETIF_F_HW_VLAN_CTAG_RX) &&
            igb_test_staterr(rx_desc, E1000_RXD_STAT_VP)) {
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.c
index 1f2c805684dd..e055e000131b 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.c
@@ -380,3 +380,26 @@ s32 ixgbe_dcb_hw_ets_config(struct ixgbe_hw *hw,
        }
        return 0;
 }
+static void ixgbe_dcb_read_rtrup2tc_82599(struct ixgbe_hw *hw, u8 *map)
+{
+        u32 reg, i;
+        reg = IXGBE_READ_REG(hw, IXGBE_RTRUP2TC);
+        for (i = 0; i < MAX_USER_PRIORITY; i++)
+                map[i] = IXGBE_RTRUP2TC_UP_MASK &
+                        (reg >> (i * IXGBE_RTRUP2TC_UP_SHIFT));
+        return;
+}
+void ixgbe_dcb_read_rtrup2tc(struct ixgbe_hw *hw, u8 *map)
+{
+        switch (hw->mac.type) {
+        case ixgbe_mac_82599EB:
+        case ixgbe_mac_X540:
+                ixgbe_dcb_read_rtrup2tc_82599(hw, map);
+                break;
+        default:
+                break;
+        }
+}
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.h
index 1634de8b627f..fc0a2dd52499 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb.h
@@ -159,6 +159,8 @@ s32 ixgbe_dcb_hw_ets_config(struct ixgbe_hw *hw, u16 *refill, u16 *max,
 s32 ixgbe_dcb_hw_pfc_config(struct ixgbe_hw *hw, u8 pfc_en, u8 *tc_prio);
 s32 ixgbe_dcb_hw_config(struct ixgbe_hw *, struct ixgbe_dcb_config *);
+void ixgbe_dcb_read_rtrup2tc(struct ixgbe_hw *hw, u8 *map);
 /* DCB definitions for credit calculation */
 #define DCB_CREDIT_QUANTUM      64   /* DCB Quantum */
 #define MAX_CREDIT_REFILL       511  /* 0x1FF * 64B = 32704B */
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_82599.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_82599.h
index a4ef07631d1e..d71d9ce3e394 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_82599.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_82599.h
@@ -45,6 +45,7 @@
 /* Receive UP2TC mapping */
 #define IXGBE_RTRUP2TC_UP_SHIFT 3
+#define IXGBE_RTRUP2TC_UP_MASK  7
 /* Transmit UP2TC mapping */
 #define IXGBE_RTTUP2TC_UP_SHIFT 3
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c
index f3d68f9696ba..edd89a1ef27f 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_dcb_nl.c
@@ -554,6 +554,9 @@ static int ixgbe_dcbnl_ieee_setets(struct net_device *dev,
                for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
                        adapter->ixgbe_ieee_ets->prio_tc[i] =
                                IEEE_8021QAZ_MAX_TCS;
+                /* if possible update UP2TC mappings from HW */
+                ixgbe_dcb_read_rtrup2tc(&adapter->hw,
+                                        adapter->ixgbe_ieee_ets->prio_tc);
        }
        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
diff --git a/drivers/net/ethernet/korina.c b/drivers/net/ethernet/korina.c
index 5409fe876a44..0b5708520121 100644
--- a/drivers/net/ethernet/korina.c
+++ b/drivers/net/ethernet/korina.c
@@ -495,12 +495,9 @@ static void korina_multicast_list(struct net_device *dev)
        /* Build the hash table */
        if (netdev_mc_count(dev) > 4) {
-                u16 hash_table[4];
+                u16 hash_table[4] = { 0 };
                u32 crc;
-                for (i = 0; i < 4; i++)
-                        hash_table[i] = 0;
                netdev_for_each_mc_addr(ha, dev) {
                        crc = ether_crc_le(6, ha->addr);
                        crc >>= 26;
diff --git a/drivers/net/ethernet/nvidia/forcedeth.c b/drivers/net/ethernet/nvidia/forcedeth.c
index b003fe53c8e2..098b96dad66f 100644
--- a/drivers/net/ethernet/nvidia/forcedeth.c
+++ b/drivers/net/ethernet/nvidia/forcedeth.c
@@ -6340,7 +6340,7 @@ static DEFINE_PCI_DEVICE_TABLE(pci_tbl) = {
        {0,},
 };
-static struct pci_driver driver = {
+static struct pci_driver forcedeth_pci_driver = {
        .name           = DRV_NAME,
        .id_table       = pci_tbl,
        .probe          = nv_probe,
@@ -6349,16 +6349,6 @@ static struct pci_driver driver = {
        .driver.pm      = NV_PM_OPS,
 };
-static int __init init_nic(void)
-{
-        return pci_register_driver(&driver);
-}
-static void __exit exit_nic(void)
-{
-        pci_unregister_driver(&driver);
-}
 module_param(max_interrupt_work, int, 0);
 MODULE_PARM_DESC(max_interrupt_work, "forcedeth maximum events handled per interrupt");
 module_param(optimization_mode, int, 0);
@@ -6379,11 +6369,8 @@ module_param(debug_tx_timeout, bool, 0);
 MODULE_PARM_DESC(debug_tx_timeout,
                 "Dump tx related registers and ring when tx_timeout happens");
+module_pci_driver(forcedeth_pci_driver);
 MODULE_AUTHOR("Manfred Spraul <manfred@colorfullife.com>");
 MODULE_DESCRIPTION("Reverse Engineered nForce ethernet driver");
 MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, pci_tbl);
-module_init(init_nic);
-module_exit(exit_nic);
diff --git a/drivers/net/ethernet/qlogic/qlge/qlge_main.c b/drivers/net/ethernet/qlogic/qlge/qlge_main.c
index 50235d201592..e04d471acb10 100644
--- a/drivers/net/ethernet/qlogic/qlge/qlge_main.c
+++ b/drivers/net/ethernet/qlogic/qlge/qlge_main.c
@@ -4945,15 +4945,4 @@ static struct pci_driver qlge_driver = {
        .err_handler = &qlge_err_handler
 };
-static int __init qlge_init_module(void)
+module_pci_driver(qlge_driver);
-{
-        return pci_register_driver(&qlge_driver);
-}
-static void __exit qlge_exit(void)
-{
-        pci_unregister_driver(&qlge_driver);
-}
-module_init(qlge_init_module);
-module_exit(qlge_exit);
diff --git a/drivers/net/ethernet/sgi/ioc3-eth.c b/drivers/net/ethernet/sgi/ioc3-eth.c
index 7ed08c32a9c5..ffa78432164d 100644
--- a/drivers/net/ethernet/sgi/ioc3-eth.c
+++ b/drivers/net/ethernet/sgi/ioc3-eth.c
@@ -1398,16 +1398,6 @@ static struct pci_driver ioc3_driver = {
        .remove         = ioc3_remove_one,
 };
-static int __init ioc3_init_module(void)
-{
-        return pci_register_driver(&ioc3_driver);
-}
-static void __exit ioc3_cleanup_module(void)
-{
-        pci_unregister_driver(&ioc3_driver);
-}
 static int ioc3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        unsigned long data;
@@ -1677,9 +1667,7 @@ static void ioc3_set_multicast_list(struct net_device *dev)
        netif_wake_queue(dev);                  /* Let us get going again. */
 }
+module_pci_driver(ioc3_driver);
 MODULE_AUTHOR("Ralf Baechle <ralf@linux-mips.org>");
 MODULE_DESCRIPTION("SGI IOC3 Ethernet driver");
 MODULE_LICENSE("GPL");
-module_init(ioc3_init_module);
-module_exit(ioc3_cleanup_module);
diff --git a/drivers/net/ethernet/silan/sc92031.c b/drivers/net/ethernet/silan/sc92031.c
index 28f7268f1b88..5eb933c97bba 100644
--- a/drivers/net/ethernet/silan/sc92031.c
+++ b/drivers/net/ethernet/silan/sc92031.c
@@ -1578,19 +1578,7 @@ static struct pci_driver sc92031_pci_driver = {
        .resume         = sc92031_resume,
 };
-static int __init sc92031_init(void)
+module_pci_driver(sc92031_pci_driver);
-{
-        return pci_register_driver(&sc92031_pci_driver);
-}
-static void __exit sc92031_exit(void)
-{
-        pci_unregister_driver(&sc92031_pci_driver);
-}
-module_init(sc92031_init);
-module_exit(sc92031_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Cesar Eduardo Barros <cesarb@cesarb.net>");
 MODULE_DESCRIPTION("Silan SC92031 PCI Fast Ethernet Adapter driver");
diff --git a/drivers/net/ethernet/sis/sis190.c b/drivers/net/ethernet/sis/sis190.c
index 9a9c379420d1..02df0894690d 100644
--- a/drivers/net/ethernet/sis/sis190.c
+++ b/drivers/net/ethernet/sis/sis190.c
@@ -1934,15 +1934,4 @@ static struct pci_driver sis190_pci_driver = {
        .remove         = sis190_remove_one,
 };
-static int __init sis190_init_module(void)
+module_pci_driver(sis190_pci_driver);
-{
-        return pci_register_driver(&sis190_pci_driver);
-}
-static void __exit sis190_cleanup_module(void)
-{
-        pci_unregister_driver(&sis190_pci_driver);
-}
-module_init(sis190_init_module);
-module_exit(sis190_cleanup_module);
diff --git a/drivers/net/ethernet/smsc/Kconfig b/drivers/net/ethernet/smsc/Kconfig
index bb4c1674ff99..ff9e99474039 100644
--- a/drivers/net/ethernet/smsc/Kconfig
+++ b/drivers/net/ethernet/smsc/Kconfig
@@ -97,7 +97,7 @@ config SMC911X
 config SMSC911X
        tristate "SMSC LAN911x/LAN921x families embedded ethernet support"
-        depends on (ARM || SUPERH || BLACKFIN || MIPS || MN10300)
+        depends on HAS_IOMEM
        select CRC32
        select NET_CORE
        select MII
diff --git a/drivers/net/ethernet/sun/sunbmac.c b/drivers/net/ethernet/sun/sunbmac.c
index 054975939a18..09b4f8c0b199 100644
--- a/drivers/net/ethernet/sun/sunbmac.c
+++ b/drivers/net/ethernet/sun/sunbmac.c
@@ -1017,10 +1017,7 @@ static void bigmac_set_multicast(struct net_device *dev)
                tmp |= BIGMAC_RXCFG_PMISC;
                sbus_writel(tmp, bregs + BMAC_RXCFG);
        } else {
-                u16 hash_table[4];
+                u16 hash_table[4] = { 0 };
-                for (i = 0; i < 4; i++)
-                        hash_table[i] = 0;
                netdev_for_each_mc_addr(ha, dev) {
                        crc = ether_crc_le(6, ha->addr);
diff --git a/drivers/net/ethernet/sun/sungem.c b/drivers/net/ethernet/sun/sungem.c
index 5f3f9d52757d..e62df2b81302 100644
--- a/drivers/net/ethernet/sun/sungem.c
+++ b/drivers/net/ethernet/sun/sungem.c
@@ -3028,15 +3028,4 @@ static struct pci_driver gem_driver = {
 #endif /* CONFIG_PM */
 };
-static int __init gem_init(void)
+module_pci_driver(gem_driver);
-{
-        return pci_register_driver(&gem_driver);
-}
-static void __exit gem_cleanup(void)
-{
-        pci_unregister_driver(&gem_driver);
-}
-module_init(gem_init);
-module_exit(gem_cleanup);
diff --git a/drivers/net/ethernet/ti/tlan.c b/drivers/net/ethernet/ti/tlan.c
index 60c400f6d01f..59abfbcd0d55 100644
--- a/drivers/net/ethernet/ti/tlan.c
+++ b/drivers/net/ethernet/ti/tlan.c
@@ -533,7 +533,6 @@ static int tlan_probe1(struct pci_dev *pdev, long ioaddr, int irq, int rev,
                /* This is a hack. We need to know which board structure
                 * is suited for this adapter */
                device_id = inw(ioaddr + EISA_ID2);
-                priv->is_eisa = 1;
                if (device_id == 0x20F1) {
                        priv->adapter = &board_info[13]; /* NetFlex-3/E */
                        priv->adapter_rev = 23;         /* TLAN 2.3 */
diff --git a/drivers/net/ethernet/ti/tlan.h b/drivers/net/ethernet/ti/tlan.h
index 5fc98a8e4889..2eb33a250788 100644
--- a/drivers/net/ethernet/ti/tlan.h
+++ b/drivers/net/ethernet/ti/tlan.h
@@ -207,7 +207,6 @@ struct tlan_priv {
        u8                      tlan_full_duplex;
        spinlock_t              lock;
        u8                      link;
-        u8                      is_eisa;
        struct work_struct                      tlan_tqueue;
        u8                      neg_be_verbose;
 };
diff --git a/drivers/net/ethernet/toshiba/tc35815.c b/drivers/net/ethernet/toshiba/tc35815.c
index fe256094db35..a971b9cca564 100644
--- a/drivers/net/ethernet/toshiba/tc35815.c
+++ b/drivers/net/ethernet/toshiba/tc35815.c
@@ -2209,18 +2209,6 @@ MODULE_PARM_DESC(speed, "0:auto, 10:10Mbps, 100:100Mbps");
 module_param_named(duplex, options.duplex, int, 0);
 MODULE_PARM_DESC(duplex, "0:auto, 1:half, 2:full");
-static int __init tc35815_init_module(void)
+module_pci_driver(tc35815_pci_driver);
-{
-        return pci_register_driver(&tc35815_pci_driver);
-}
-static void __exit tc35815_cleanup_module(void)
-{
-        pci_unregister_driver(&tc35815_pci_driver);
-}
-module_init(tc35815_init_module);
-module_exit(tc35815_cleanup_module);
 MODULE_DESCRIPTION("TOSHIBA TC35815 PCI 10M/100M Ethernet driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/net/ethernet/via/Kconfig b/drivers/net/ethernet/via/Kconfig
index 68a9ba66feba..6a87097d88c0 100644
--- a/drivers/net/ethernet/via/Kconfig
+++ b/drivers/net/ethernet/via/Kconfig
@@ -5,7 +5,6 @@
 config NET_VENDOR_VIA
        bool "VIA devices"
        default y
-        depends on PCI
        ---help---
          If you have a network (Ethernet) card belonging to this class, say Y
          and read the Ethernet-HOWTO, available from
@@ -45,7 +44,7 @@ config VIA_RHINE_MMIO
 config VIA_VELOCITY
        tristate "VIA Velocity support"
-        depends on PCI
+        depends on (PCI || USE_OF)
        select CRC32
        select CRC_CCITT
        select NET_CORE
diff --git a/drivers/net/ethernet/via/via-velocity.c b/drivers/net/ethernet/via/via-velocity.c
index fb6248956ee2..76919948b4ee 100644
--- a/drivers/net/ethernet/via/via-velocity.c
+++ b/drivers/net/ethernet/via/via-velocity.c
@@ -46,6 +46,7 @@
 #include <linux/types.h>
 #include <linux/bitops.h>
 #include <linux/init.h>
+#include <linux/dma-mapping.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
 #include <linux/ioport.h>
@@ -64,7 +65,11 @@
 #include <linux/if.h>
 #include <linux/uaccess.h>
 #include <linux/proc_fs.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/of_irq.h>
 #include <linux/inetdevice.h>
+#include <linux/platform_device.h>
 #include <linux/reboot.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
@@ -79,10 +84,24 @@
 #include "via-velocity.h"
+enum velocity_bus_type {
+        BUS_PCI,
+        BUS_PLATFORM,
+};
 static int velocity_nics;
 static int msglevel = MSG_LEVEL_INFO;
+static void velocity_set_power_state(struct velocity_info *vptr, char state)
+{
+        void *addr = vptr->mac_regs;
+        if (vptr->pdev)
+                pci_set_power_state(vptr->pdev, state);
+        else
+                writeb(state, addr + 0x154);
+}
 /**
 *      mac_get_cam_mask        -       Read a CAM mask
 *      @regs: register block for this velocity
@@ -361,12 +380,23 @@ static struct velocity_info_tbl chip_info_table[] = {
 *      Describe the PCI device identifiers that we support in this
 *      device driver. Used for hotplug autoloading.
 */
-static DEFINE_PCI_DEVICE_TABLE(velocity_id_table) = {
+static DEFINE_PCI_DEVICE_TABLE(velocity_pci_id_table) = {
        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_612X) },
        { }
 };
-MODULE_DEVICE_TABLE(pci, velocity_id_table);
+MODULE_DEVICE_TABLE(pci, velocity_pci_id_table);
+/**
+ *      Describe the OF device identifiers that we support in this
+ *      device driver. Used for devicetree nodes.
+ */
+static struct of_device_id velocity_of_ids[] = {
+        { .compatible = "via,velocity-vt6110", .data = &chip_info_table[0] },
+        { /* Sentinel */ },
+};
+MODULE_DEVICE_TABLE(of, velocity_of_ids);
 /**
 *      get_chip_name   -       identifier to name
@@ -385,29 +415,6 @@ static const char *get_chip_name(enum chip_type chip_id)
 }
 /**
- *      velocity_remove1        -       device unplug
- *      @pdev: PCI device being removed
- *
- *      Device unload callback. Called on an unplug or on module
- *      unload for each active device that is present. Disconnects
- *      the device from the network layer and frees all the resources
- */
-static void velocity_remove1(struct pci_dev *pdev)
-{
-        struct net_device *dev = pci_get_drvdata(pdev);
-        struct velocity_info *vptr = netdev_priv(dev);
-        unregister_netdev(dev);
-        iounmap(vptr->mac_regs);
-        pci_release_regions(pdev);
-        pci_disable_device(pdev);
-        pci_set_drvdata(pdev, NULL);
-        free_netdev(dev);
-        velocity_nics--;
-}
-/**
 *      velocity_set_int_opt    -       parser for integer options
 *      @opt: pointer to option value
 *      @val: value the user requested (or -1 for default)
@@ -998,9 +1005,9 @@ static void velocity_print_link_status(struct velocity_info *vptr)
 {
        if (vptr->mii_status & VELOCITY_LINK_FAIL) {
-                VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->dev->name);
+                VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: failed to detect cable link\n", vptr->netdev->name);
        } else if (vptr->options.spd_dpx == SPD_DPX_AUTO) {
-                VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->dev->name);
+                VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link auto-negotiation", vptr->netdev->name);
                if (vptr->mii_status & VELOCITY_SPEED_1000)
                        VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps");
@@ -1014,7 +1021,7 @@ static void velocity_print_link_status(struct velocity_info *vptr)
                else
                        VELOCITY_PRT(MSG_LEVEL_INFO, " half duplex\n");
        } else {
-                VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->dev->name);
+                VELOCITY_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: Link forced", vptr->netdev->name);
                switch (vptr->options.spd_dpx) {
                case SPD_DPX_1000_FULL:
                        VELOCITY_PRT(MSG_LEVEL_INFO, " speed 1000M bps full duplex\n");
@@ -1180,6 +1187,17 @@ static void mii_init(struct velocity_info *vptr, u32 mii_status)
        u16 BMCR;
        switch (PHYID_GET_PHY_ID(vptr->phy_id)) {
+        case PHYID_ICPLUS_IP101A:
+                MII_REG_BITS_ON((ADVERTISE_PAUSE_ASYM | ADVERTISE_PAUSE_CAP),
+                                                MII_ADVERTISE, vptr->mac_regs);
+                if (vptr->mii_status & VELOCITY_DUPLEX_FULL)
+                        MII_REG_BITS_ON(TCSR_ECHODIS, MII_SREVISION,
+                                                                vptr->mac_regs);
+                else
+                        MII_REG_BITS_OFF(TCSR_ECHODIS, MII_SREVISION,
+                                                                vptr->mac_regs);
+                MII_REG_BITS_ON(PLED_LALBE, MII_TPISTATUS, vptr->mac_regs);
+                break;
        case PHYID_CICADA_CS8201:
                /*
                 *      Reset to hardware default
@@ -1311,6 +1329,7 @@ static void velocity_init_registers(struct velocity_info *vptr,
                                    enum velocity_init_type type)
 {
        struct mac_regs __iomem *regs = vptr->mac_regs;
+        struct net_device *netdev = vptr->netdev;
        int i, mii_status;
        mac_wol_reset(regs);
@@ -1319,7 +1338,7 @@ static void velocity_init_registers(struct velocity_info *vptr,
        case VELOCITY_INIT_RESET:
        case VELOCITY_INIT_WOL:
-                netif_stop_queue(vptr->dev);
+                netif_stop_queue(netdev);
                /*
                 *      Reset RX to prevent RX pointer not on the 4X location
@@ -1332,7 +1351,7 @@ static void velocity_init_registers(struct velocity_info *vptr,
                if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
                        velocity_print_link_status(vptr);
                        if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
-                                netif_wake_queue(vptr->dev);
+                                netif_wake_queue(netdev);
                }
                enable_flow_control_ability(vptr);
@@ -1352,9 +1371,11 @@ static void velocity_init_registers(struct velocity_info *vptr,
                velocity_soft_reset(vptr);
                mdelay(5);
-                mac_eeprom_reload(regs);
+                if (!vptr->no_eeprom) {
-                for (i = 0; i < 6; i++)
+                        mac_eeprom_reload(regs);
-                        writeb(vptr->dev->dev_addr[i], &(regs->PAR[i]));
+                        for (i = 0; i < 6; i++)
+                                writeb(netdev->dev_addr[i], regs->PAR + i);
+                }
                /*
                 *      clear Pre_ACPI bit.
@@ -1377,7 +1398,7 @@ static void velocity_init_registers(struct velocity_info *vptr,
                /*
                 *      Set packet filter: Receive directed and broadcast address
                 */
-                velocity_set_multi(vptr->dev);
+                velocity_set_multi(netdev);
                /*
                 *      Enable MII auto-polling
@@ -1404,14 +1425,14 @@ static void velocity_init_registers(struct velocity_info *vptr,
                writel((CR0_DPOLL | CR0_TXON | CR0_RXON | CR0_STRT), &regs->CR0Set);
                mii_status = velocity_get_opt_media_mode(vptr);
-                netif_stop_queue(vptr->dev);
+                netif_stop_queue(netdev);
                mii_init(vptr, mii_status);
                if (velocity_set_media_mode(vptr, mii_status) != VELOCITY_LINK_CHANGE) {
                        velocity_print_link_status(vptr);
                        if (!(vptr->mii_status & VELOCITY_LINK_FAIL))
-                                netif_wake_queue(vptr->dev);
+                                netif_wake_queue(netdev);
                }
                enable_flow_control_ability(vptr);
@@ -1459,7 +1480,6 @@ static int velocity_init_dma_rings(struct velocity_info *vptr)
        struct velocity_opt *opt = &vptr->options;
        const unsigned int rx_ring_size = opt->numrx * sizeof(struct rx_desc);
        const unsigned int tx_ring_size = opt->numtx * sizeof(struct tx_desc);
-        struct pci_dev *pdev = vptr->pdev;
        dma_addr_t pool_dma;
        void *pool;
        unsigned int i;
@@ -1467,14 +1487,14 @@ static int velocity_init_dma_rings(struct velocity_info *vptr)
        /*
         * Allocate all RD/TD rings a single pool.
         *
-         * pci_alloc_consistent() fulfills the requirement for 64 bytes
+         * dma_alloc_coherent() fulfills the requirement for 64 bytes
         * alignment
         */
-        pool = pci_alloc_consistent(pdev, tx_ring_size * vptr->tx.numq +
+        pool = dma_alloc_coherent(vptr->dev, tx_ring_size * vptr->tx.numq +
-                                    rx_ring_size, &pool_dma);
+                                    rx_ring_size, &pool_dma, GFP_ATOMIC);
        if (!pool) {
-                dev_err(&pdev->dev, "%s : DMA memory allocation failed.\n",
+                dev_err(vptr->dev, "%s : DMA memory allocation failed.\n",
-                        vptr->dev->name);
+                        vptr->netdev->name);
                return -ENOMEM;
        }
@@ -1514,7 +1534,7 @@ static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
        struct rx_desc *rd = &(vptr->rx.ring[idx]);
        struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
-        rd_info->skb = netdev_alloc_skb(vptr->dev, vptr->rx.buf_sz + 64);
+        rd_info->skb = netdev_alloc_skb(vptr->netdev, vptr->rx.buf_sz + 64);
        if (rd_info->skb == NULL)
                return -ENOMEM;
@@ -1524,8 +1544,8 @@ static int velocity_alloc_rx_buf(struct velocity_info *vptr, int idx)
         */
        skb_reserve(rd_info->skb,
                        64 - ((unsigned long) rd_info->skb->data & 63));
-        rd_info->skb_dma = pci_map_single(vptr->pdev, rd_info->skb->data,
+        rd_info->skb_dma = dma_map_single(vptr->dev, rd_info->skb->data,
-                                        vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
+                                        vptr->rx.buf_sz, DMA_FROM_DEVICE);
        /*
         *      Fill in the descriptor to match
@@ -1588,8 +1608,8 @@ static void velocity_free_rd_ring(struct velocity_info *vptr)
                if (!rd_info->skb)
                        continue;
-                pci_unmap_single(vptr->pdev, rd_info->skb_dma, vptr->rx.buf_sz,
+                dma_unmap_single(vptr->dev, rd_info->skb_dma, vptr->rx.buf_sz,
-                                 PCI_DMA_FROMDEVICE);
+                                 DMA_FROM_DEVICE);
                rd_info->skb_dma = 0;
                dev_kfree_skb(rd_info->skb);
@@ -1620,7 +1640,7 @@ static int velocity_init_rd_ring(struct velocity_info *vptr)
        if (velocity_rx_refill(vptr) != vptr->options.numrx) {
                VELOCITY_PRT(MSG_LEVEL_ERR, KERN_ERR
-                        "%s: failed to allocate RX buffer.\n", vptr->dev->name);
+                        "%s: failed to allocate RX buffer.\n", vptr->netdev->name);
                velocity_free_rd_ring(vptr);
                goto out;
        }
@@ -1670,7 +1690,7 @@ static void velocity_free_dma_rings(struct velocity_info *vptr)
        const int size = vptr->options.numrx * sizeof(struct rx_desc) +
                vptr->options.numtx * sizeof(struct tx_desc) * vptr->tx.numq;
-        pci_free_consistent(vptr->pdev, size, vptr->rx.ring, vptr->rx.pool_dma);
+        dma_free_coherent(vptr->dev, size, vptr->rx.ring, vptr->rx.pool_dma);
 }
 static int velocity_init_rings(struct velocity_info *vptr, int mtu)
@@ -1727,8 +1747,8 @@ static void velocity_free_tx_buf(struct velocity_info *vptr,
                                pktlen = max_t(size_t, pktlen,
                                                td->td_buf[i].size & ~TD_QUEUE);
-                        pci_unmap_single(vptr->pdev, tdinfo->skb_dma[i],
+                        dma_unmap_single(vptr->dev, tdinfo->skb_dma[i],
-                                        le16_to_cpu(pktlen), PCI_DMA_TODEVICE);
+                                        le16_to_cpu(pktlen), DMA_TO_DEVICE);
                }
        }
        dev_kfree_skb_irq(skb);
@@ -1750,8 +1770,8 @@ static void velocity_free_td_ring_entry(struct velocity_info *vptr,
        if (td_info->skb) {
                for (i = 0; i < td_info->nskb_dma; i++) {
                        if (td_info->skb_dma[i]) {
-                                pci_unmap_single(vptr->pdev, td_info->skb_dma[i],
+                                dma_unmap_single(vptr->dev, td_info->skb_dma[i],
-                                        td_info->skb->len, PCI_DMA_TODEVICE);
+                                        td_info->skb->len, DMA_TO_DEVICE);
                                td_info->skb_dma[i] = 0;
                        }
                }
@@ -1809,7 +1829,7 @@ static void velocity_error(struct velocity_info *vptr, int status)
                printk(KERN_ERR "TD structure error TDindex=%hx\n", readw(&regs->TDIdx[0]));
                BYTE_REG_BITS_ON(TXESR_TDSTR, &regs->TXESR);
                writew(TRDCSR_RUN, &regs->TDCSRClr);
-                netif_stop_queue(vptr->dev);
+                netif_stop_queue(vptr->netdev);
                /* FIXME: port over the pci_device_failed code and use it
                   here */
@@ -1850,10 +1870,10 @@ static void velocity_error(struct velocity_info *vptr, int status)
                if (linked) {
                        vptr->mii_status &= ~VELOCITY_LINK_FAIL;
-                        netif_carrier_on(vptr->dev);
+                        netif_carrier_on(vptr->netdev);
                } else {
                        vptr->mii_status |= VELOCITY_LINK_FAIL;
-                        netif_carrier_off(vptr->dev);
+                        netif_carrier_off(vptr->netdev);
                }
                velocity_print_link_status(vptr);
@@ -1867,9 +1887,9 @@ static void velocity_error(struct velocity_info *vptr, int status)
                enable_mii_autopoll(regs);
                if (vptr->mii_status & VELOCITY_LINK_FAIL)
-                        netif_stop_queue(vptr->dev);
+                        netif_stop_queue(vptr->netdev);
                else
-                        netif_wake_queue(vptr->dev);
+                        netif_wake_queue(vptr->netdev);
        }
        if (status & ISR_MIBFI)
@@ -1894,7 +1914,7 @@ static int velocity_tx_srv(struct velocity_info *vptr)
        int idx;
        int works = 0;
        struct velocity_td_info *tdinfo;
-        struct net_device_stats *stats = &vptr->dev->stats;
+        struct net_device_stats *stats = &vptr->netdev->stats;
        for (qnum = 0; qnum < vptr->tx.numq; qnum++) {
                for (idx = vptr->tx.tail[qnum]; vptr->tx.used[qnum] > 0;
@@ -1939,9 +1959,9 @@ static int velocity_tx_srv(struct velocity_info *vptr)
         *      Look to see if we should kick the transmit network
         *      layer for more work.
         */
-        if (netif_queue_stopped(vptr->dev) && (full == 0) &&
+        if (netif_queue_stopped(vptr->netdev) && (full == 0) &&
            (!(vptr->mii_status & VELOCITY_LINK_FAIL))) {
-                netif_wake_queue(vptr->dev);
+                netif_wake_queue(vptr->netdev);
        }
        return works;
 }
@@ -1989,7 +2009,7 @@ static int velocity_rx_copy(struct sk_buff **rx_skb, int pkt_size,
        if (pkt_size < rx_copybreak) {
                struct sk_buff *new_skb;
-                new_skb = netdev_alloc_skb_ip_align(vptr->dev, pkt_size);
+                new_skb = netdev_alloc_skb_ip_align(vptr->netdev, pkt_size);
                if (new_skb) {
                        new_skb->ip_summed = rx_skb[0]->ip_summed;
                        skb_copy_from_linear_data(*rx_skb, new_skb->data, pkt_size);
@@ -2029,15 +2049,14 @@ static inline void velocity_iph_realign(struct velocity_info *vptr,
 */
 static int velocity_receive_frame(struct velocity_info *vptr, int idx)
 {
-        void (*pci_action)(struct pci_dev *, dma_addr_t, size_t, int);
+        struct net_device_stats *stats = &vptr->netdev->stats;
-        struct net_device_stats *stats = &vptr->dev->stats;
        struct velocity_rd_info *rd_info = &(vptr->rx.info[idx]);
        struct rx_desc *rd = &(vptr->rx.ring[idx]);
        int pkt_len = le16_to_cpu(rd->rdesc0.len) & 0x3fff;
        struct sk_buff *skb;
        if (rd->rdesc0.RSR & (RSR_STP | RSR_EDP)) {
-                VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->dev->name);
+                VELOCITY_PRT(MSG_LEVEL_VERBOSE, KERN_ERR " %s : the received frame span multple RDs.\n", vptr->netdev->name);
                stats->rx_length_errors++;
                return -EINVAL;
        }
@@ -2047,8 +2066,8 @@ static int velocity_receive_frame(struct velocity_info *vptr, int idx)
        skb = rd_info->skb;
-        pci_dma_sync_single_for_cpu(vptr->pdev, rd_info->skb_dma,
+        dma_sync_single_for_cpu(vptr->dev, rd_info->skb_dma,
-                                    vptr->rx.buf_sz, PCI_DMA_FROMDEVICE);
+                                    vptr->rx.buf_sz, DMA_FROM_DEVICE);
        /*
         *      Drop frame not meeting IEEE 802.3
@@ -2061,21 +2080,20 @@ static int velocity_receive_frame(struct velocity_info *vptr, int idx)
                }
        }
-        pci_action = pci_dma_sync_single_for_device;
        velocity_rx_csum(rd, skb);
        if (velocity_rx_copy(&skb, pkt_len, vptr) < 0) {
                velocity_iph_realign(vptr, skb, pkt_len);
-                pci_action = pci_unmap_single;
                rd_info->skb = NULL;
+                dma_unmap_single(vptr->dev, rd_info->skb_dma, vptr->rx.buf_sz,
+                                 DMA_FROM_DEVICE);
+        } else {
+                dma_sync_single_for_device(vptr->dev, rd_info->skb_dma,
+                                           vptr->rx.buf_sz, DMA_FROM_DEVICE);
        }
-        pci_action(vptr->pdev, rd_info->skb_dma, vptr->rx.buf_sz,
-                   PCI_DMA_FROMDEVICE);
        skb_put(skb, pkt_len - 4);
-        skb->protocol = eth_type_trans(skb, vptr->dev);
+        skb->protocol = eth_type_trans(skb, vptr->netdev);
        if (rd->rdesc0.RSR & RSR_DETAG) {
                u16 vid = swab16(le16_to_cpu(rd->rdesc1.PQTAG));
@@ -2100,7 +2118,7 @@ static int velocity_receive_frame(struct velocity_info *vptr, int idx)
 */
 static int velocity_rx_srv(struct velocity_info *vptr, int budget_left)
 {
-        struct net_device_stats *stats = &vptr->dev->stats;
+        struct net_device_stats *stats = &vptr->netdev->stats;
        int rd_curr = vptr->rx.curr;
        int works = 0;
@@ -2235,15 +2253,15 @@ static int velocity_open(struct net_device *dev)
                goto out;
        /* Ensure chip is running */
-        pci_set_power_state(vptr->pdev, PCI_D0);
+        velocity_set_power_state(vptr, PCI_D0);
        velocity_init_registers(vptr, VELOCITY_INIT_COLD);
-        ret = request_irq(vptr->pdev->irq, velocity_intr, IRQF_SHARED,
+        ret = request_irq(dev->irq, velocity_intr, IRQF_SHARED,
                          dev->name, dev);
        if (ret < 0) {
                /* Power down the chip */
-                pci_set_power_state(vptr->pdev, PCI_D3hot);
+                velocity_set_power_state(vptr, PCI_D3hot);
                velocity_free_rings(vptr);
                goto out;
        }
@@ -2292,7 +2310,7 @@ static int velocity_change_mtu(struct net_device *dev, int new_mtu)
        if ((new_mtu < VELOCITY_MIN_MTU) || new_mtu > (VELOCITY_MAX_MTU)) {
                VELOCITY_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Invalid MTU.\n",
-                                vptr->dev->name);
+                                vptr->netdev->name);
                ret = -EINVAL;
                goto out_0;
        }
@@ -2314,8 +2332,9 @@ static int velocity_change_mtu(struct net_device *dev, int new_mtu)
                        goto out_0;
                }
-                tmp_vptr->dev = dev;
+                tmp_vptr->netdev = dev;
                tmp_vptr->pdev = vptr->pdev;
+                tmp_vptr->dev = vptr->dev;
                tmp_vptr->options = vptr->options;
                tmp_vptr->tx.numq = vptr->tx.numq;
@@ -2415,7 +2434,7 @@ static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
           saving then we need to bring the device back up to talk to it */
        if (!netif_running(dev))
-                pci_set_power_state(vptr->pdev, PCI_D0);
+                velocity_set_power_state(vptr, PCI_D0);
        switch (cmd) {
        case SIOCGMIIPHY:       /* Get address of MII PHY in use. */
@@ -2428,7 +2447,7 @@ static int velocity_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
                ret = -EOPNOTSUPP;
        }
        if (!netif_running(dev))
-                pci_set_power_state(vptr->pdev, PCI_D3hot);
+                velocity_set_power_state(vptr, PCI_D3hot);
        return ret;
@@ -2494,7 +2513,7 @@ static int velocity_close(struct net_device *dev)
        if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED)
                velocity_get_ip(vptr);
-        free_irq(vptr->pdev->irq, dev);
+        free_irq(dev->irq, dev);
        velocity_free_rings(vptr);
@@ -2550,7 +2569,8 @@ static netdev_tx_t velocity_xmit(struct sk_buff *skb,
         *      add it to the transmit ring.
         */
        tdinfo->skb = skb;
-        tdinfo->skb_dma[0] = pci_map_single(vptr->pdev, skb->data, pktlen, PCI_DMA_TODEVICE);
+        tdinfo->skb_dma[0] = dma_map_single(vptr->dev, skb->data, pktlen,
+                                                                DMA_TO_DEVICE);
        td_ptr->tdesc0.len = cpu_to_le16(pktlen);
        td_ptr->td_buf[0].pa_low = cpu_to_le32(tdinfo->skb_dma[0]);
        td_ptr->td_buf[0].pa_high = 0;
@@ -2560,7 +2580,7 @@ static netdev_tx_t velocity_xmit(struct sk_buff *skb,
        for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
                const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
-                tdinfo->skb_dma[i + 1] = skb_frag_dma_map(&vptr->pdev->dev,
+                tdinfo->skb_dma[i + 1] = skb_frag_dma_map(vptr->dev,
                                                          frag, 0,
                                                          skb_frag_size(frag),
                                                          DMA_TO_DEVICE);
@@ -2632,12 +2652,9 @@ static const struct net_device_ops velocity_netdev_ops = {
 *      Set up the initial velocity_info struct for the device that has been
 *      discovered.
 */
-static void velocity_init_info(struct pci_dev *pdev, struct velocity_info *vptr,
+static void velocity_init_info(struct velocity_info *vptr,
-                               const struct velocity_info_tbl *info)
+                                const struct velocity_info_tbl *info)
 {
-        memset(vptr, 0, sizeof(struct velocity_info));
-        vptr->pdev = pdev;
        vptr->chip_id = info->chip_id;
        vptr->tx.numq = info->txqueue;
        vptr->multicast_limit = MCAM_SIZE;
@@ -2652,10 +2669,9 @@ static void velocity_init_info(struct pci_dev *pdev, struct velocity_info *vptr,
 *      Retrieve the PCI configuration space data that interests us from
 *      the kernel PCI layer
 */
-static int velocity_get_pci_info(struct velocity_info *vptr,
+static int velocity_get_pci_info(struct velocity_info *vptr)
-                                 struct pci_dev *pdev)
 {
-        vptr->rev_id = pdev->revision;
+        struct pci_dev *pdev = vptr->pdev;
        pci_set_master(pdev);
@@ -2678,7 +2694,37 @@ static int velocity_get_pci_info(struct velocity_info *vptr,
                dev_err(&pdev->dev, "region #1 is too small.\n");
                return -EINVAL;
        }
-        vptr->pdev = pdev;
+        return 0;
+}
+/**
+ *      velocity_get_platform_info - retrieve platform info for device
+ *      @vptr: velocity device
+ *      @pdev: platform device it matches
+ *
+ *      Retrieve the Platform configuration data that interests us
+ */
+static int velocity_get_platform_info(struct velocity_info *vptr)
+{
+        struct resource res;
+        int ret;
+        if (of_get_property(vptr->dev->of_node, "no-eeprom", NULL))
+                vptr->no_eeprom = 1;
+        ret = of_address_to_resource(vptr->dev->of_node, 0, &res);
+        if (ret) {
+                dev_err(vptr->dev, "unable to find memory address\n");
+                return ret;
+        }
+        vptr->memaddr = res.start;
+        if (resource_size(&res) < VELOCITY_IO_SIZE) {
+                dev_err(vptr->dev, "memory region is too small.\n");
+                return -EINVAL;
+        }
        return 0;
 }
@@ -2692,7 +2738,7 @@ static int velocity_get_pci_info(struct velocity_info *vptr,
 */
 static void velocity_print_info(struct velocity_info *vptr)
 {
-        struct net_device *dev = vptr->dev;
+        struct net_device *dev = vptr->netdev;
        printk(KERN_INFO "%s: %s\n", dev->name, get_chip_name(vptr->chip_id));
        printk(KERN_INFO "%s: Ethernet Address: %pM\n",
@@ -2707,21 +2753,22 @@ static u32 velocity_get_link(struct net_device *dev)
 }
 /**
- *      velocity_found1         -       set up discovered velocity card
+ *      velocity_probe - set up discovered velocity device
 *      @pdev: PCI device
 *      @ent: PCI device table entry that matched
+ *      @bustype: bus that device is connected to
 *
 *      Configure a discovered adapter from scratch. Return a negative
 *      errno error code on failure paths.
 */
-static int velocity_found1(struct pci_dev *pdev,
+static int velocity_probe(struct device *dev, int irq,
-                           const struct pci_device_id *ent)
+                           const struct velocity_info_tbl *info,
+                           enum velocity_bus_type bustype)
 {
        static int first = 1;
-        struct net_device *dev;
+        struct net_device *netdev;
        int i;
        const char *drv_string;
-        const struct velocity_info_tbl *info = &chip_info_table[ent->driver_data];
        struct velocity_info *vptr;
        struct mac_regs __iomem *regs;
        int ret = -ENOMEM;
@@ -2730,20 +2777,18 @@ static int velocity_found1(struct pci_dev *pdev,
         * can support more than MAX_UNITS.
         */
        if (velocity_nics >= MAX_UNITS) {
-                dev_notice(&pdev->dev, "already found %d NICs.\n",
+                dev_notice(dev, "already found %d NICs.\n", velocity_nics);
-                           velocity_nics);
                return -ENODEV;
        }
-        dev = alloc_etherdev(sizeof(struct velocity_info));
+        netdev = alloc_etherdev(sizeof(struct velocity_info));
-        if (!dev)
+        if (!netdev)
                goto out;
        /* Chain it all together */
-        SET_NETDEV_DEV(dev, &pdev->dev);
+        SET_NETDEV_DEV(netdev, dev);
-        vptr = netdev_priv(dev);
+        vptr = netdev_priv(netdev);
        if (first) {
                printk(KERN_INFO "%s Ver. %s\n",
@@ -2753,41 +2798,41 @@ static int velocity_found1(struct pci_dev *pdev,
                first = 0;
        }
-        velocity_init_info(pdev, vptr, info);
+        netdev->irq = irq;
+        vptr->netdev = netdev;
        vptr->dev = dev;
-        ret = pci_enable_device(pdev);
+        velocity_init_info(vptr, info);
-        if (ret < 0)
-                goto err_free_dev;
-        ret = velocity_get_pci_info(vptr, pdev);
+        if (bustype == BUS_PCI) {
-        if (ret < 0) {
+                vptr->pdev = to_pci_dev(dev);
-                /* error message already printed */
-                goto err_disable;
-        }
-        ret = pci_request_regions(pdev, VELOCITY_NAME);
+                ret = velocity_get_pci_info(vptr);
-        if (ret < 0) {
+                if (ret < 0)
-                dev_err(&pdev->dev, "No PCI resources.\n");
+                        goto err_free_dev;
-                goto err_disable;
+        } else {
+                vptr->pdev = NULL;
+                ret = velocity_get_platform_info(vptr);
+                if (ret < 0)
+                        goto err_free_dev;
        }
        regs = ioremap(vptr->memaddr, VELOCITY_IO_SIZE);
        if (regs == NULL) {
                ret = -EIO;
-                goto err_release_res;
+                goto err_free_dev;
        }
        vptr->mac_regs = regs;
+        vptr->rev_id = readb(&regs->rev_id);
        mac_wol_reset(regs);
        for (i = 0; i < 6; i++)
-                dev->dev_addr[i] = readb(&regs->PAR[i]);
+                netdev->dev_addr[i] = readb(&regs->PAR[i]);
-        drv_string = dev_driver_string(&pdev->dev);
+        drv_string = dev_driver_string(dev);
        velocity_get_options(&vptr->options, velocity_nics, drv_string);
@@ -2808,46 +2853,125 @@ static int velocity_found1(struct pci_dev *pdev,
        vptr->phy_id = MII_GET_PHY_ID(vptr->mac_regs);
-        dev->netdev_ops = &velocity_netdev_ops;
+        netdev->netdev_ops = &velocity_netdev_ops;
-        dev->ethtool_ops = &velocity_ethtool_ops;
+        netdev->ethtool_ops = &velocity_ethtool_ops;
-        netif_napi_add(dev, &vptr->napi, velocity_poll, VELOCITY_NAPI_WEIGHT);
+        netif_napi_add(netdev, &vptr->napi, velocity_poll,
+                                                        VELOCITY_NAPI_WEIGHT);
-        dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
+        netdev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
                           NETIF_F_HW_VLAN_CTAG_TX;
-        dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_FILTER |
+        netdev->features |= NETIF_F_HW_VLAN_CTAG_TX |
-                         NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_IP_CSUM;
+                        NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_CTAG_RX |
+                        NETIF_F_IP_CSUM;
-        ret = register_netdev(dev);
+        ret = register_netdev(netdev);
        if (ret < 0)
                goto err_iounmap;
-        if (!velocity_get_link(dev)) {
+        if (!velocity_get_link(netdev)) {
-                netif_carrier_off(dev);
+                netif_carrier_off(netdev);
                vptr->mii_status |= VELOCITY_LINK_FAIL;
        }
        velocity_print_info(vptr);
-        pci_set_drvdata(pdev, dev);
+        dev_set_drvdata(vptr->dev, netdev);
        /* and leave the chip powered down */
-        pci_set_power_state(pdev, PCI_D3hot);
+        velocity_set_power_state(vptr, PCI_D3hot);
        velocity_nics++;
 out:
        return ret;
 err_iounmap:
        iounmap(regs);
-err_release_res:
-        pci_release_regions(pdev);
-err_disable:
-        pci_disable_device(pdev);
 err_free_dev:
-        free_netdev(dev);
+        free_netdev(netdev);
        goto out;
 }
-#ifdef CONFIG_PM
+/**
+ *      velocity_remove - device unplug
+ *      @dev: device being removed
+ *
+ *      Device unload callback. Called on an unplug or on module
+ *      unload for each active device that is present. Disconnects
+ *      the device from the network layer and frees all the resources
+ */
+static int velocity_remove(struct device *dev)
+{
+        struct net_device *netdev = dev_get_drvdata(dev);
+        struct velocity_info *vptr = netdev_priv(netdev);
+        unregister_netdev(netdev);
+        iounmap(vptr->mac_regs);
+        free_netdev(netdev);
+        velocity_nics--;
+        return 0;
+}
+static int velocity_pci_probe(struct pci_dev *pdev,
+                               const struct pci_device_id *ent)
+{
+        const struct velocity_info_tbl *info =
+                                        &chip_info_table[ent->driver_data];
+        int ret;
+        ret = pci_enable_device(pdev);
+        if (ret < 0)
+                return ret;
+        ret = pci_request_regions(pdev, VELOCITY_NAME);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "No PCI resources.\n");
+                goto fail1;
+        }
+        ret = velocity_probe(&pdev->dev, pdev->irq, info, BUS_PCI);
+        if (ret == 0)
+                return 0;
+        pci_release_regions(pdev);
+fail1:
+        pci_disable_device(pdev);
+        return ret;
+}
+static void velocity_pci_remove(struct pci_dev *pdev)
+{
+        velocity_remove(&pdev->dev);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+}
+static int velocity_platform_probe(struct platform_device *pdev)
+{
+        const struct of_device_id *of_id;
+        const struct velocity_info_tbl *info;
+        int irq;
+        of_id = of_match_device(velocity_of_ids, &pdev->dev);
+        if (!of_id)
+                return -EINVAL;
+        info = of_id->data;
+        irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
+        if (!irq)
+                return -EINVAL;
+        return velocity_probe(&pdev->dev, irq, info, BUS_PLATFORM);
+}
+static int velocity_platform_remove(struct platform_device *pdev)
+{
+        velocity_remove(&pdev->dev);
+        return 0;
+}
+#ifdef CONFIG_PM_SLEEP
 /**
 *      wol_calc_crc            -       WOL CRC
 *      @pattern: data pattern
@@ -3004,32 +3128,35 @@ static void velocity_save_context(struct velocity_info *vptr, struct velocity_co
 }
-static int velocity_suspend(struct pci_dev *pdev, pm_message_t state)
+static int velocity_suspend(struct device *dev)
 {
-        struct net_device *dev = pci_get_drvdata(pdev);
+        struct net_device *netdev = dev_get_drvdata(dev);
-        struct velocity_info *vptr = netdev_priv(dev);
+        struct velocity_info *vptr = netdev_priv(netdev);
        unsigned long flags;
-        if (!netif_running(vptr->dev))
+        if (!netif_running(vptr->netdev))
                return 0;
-        netif_device_detach(vptr->dev);
+        netif_device_detach(vptr->netdev);
        spin_lock_irqsave(&vptr->lock, flags);
-        pci_save_state(pdev);
+        if (vptr->pdev)
+                pci_save_state(vptr->pdev);
        if (vptr->flags & VELOCITY_FLAGS_WOL_ENABLED) {
                velocity_get_ip(vptr);
                velocity_save_context(vptr, &vptr->context);
                velocity_shutdown(vptr);
                velocity_set_wol(vptr);
-                pci_enable_wake(pdev, PCI_D3hot, 1);
+                if (vptr->pdev)
-                pci_set_power_state(pdev, PCI_D3hot);
+                        pci_enable_wake(vptr->pdev, PCI_D3hot, 1);
+                velocity_set_power_state(vptr, PCI_D3hot);
        } else {
                velocity_save_context(vptr, &vptr->context);
                velocity_shutdown(vptr);
-                pci_disable_device(pdev);
+                if (vptr->pdev)
-                pci_set_power_state(pdev, pci_choose_state(pdev, state));
+                        pci_disable_device(vptr->pdev);
+                velocity_set_power_state(vptr, PCI_D3hot);
        }
        spin_unlock_irqrestore(&vptr->lock, flags);
@@ -3071,19 +3198,22 @@ static void velocity_restore_context(struct velocity_info *vptr, struct velocity
                writeb(*((u8 *) (context->mac_reg + i)), ptr + i);
 }
-static int velocity_resume(struct pci_dev *pdev)
+static int velocity_resume(struct device *dev)
 {
-        struct net_device *dev = pci_get_drvdata(pdev);
+        struct net_device *netdev = dev_get_drvdata(dev);
-        struct velocity_info *vptr = netdev_priv(dev);
+        struct velocity_info *vptr = netdev_priv(netdev);
        unsigned long flags;
        int i;
-        if (!netif_running(vptr->dev))
+        if (!netif_running(vptr->netdev))
                return 0;
-        pci_set_power_state(pdev, PCI_D0);
+        velocity_set_power_state(vptr, PCI_D0);
-        pci_enable_wake(pdev, 0, 0);
-        pci_restore_state(pdev);
+        if (vptr->pdev) {
+                pci_enable_wake(vptr->pdev, 0, 0);
+                pci_restore_state(vptr->pdev);
+        }
        mac_wol_reset(vptr->mac_regs);
@@ -3101,27 +3231,38 @@ static int velocity_resume(struct pci_dev *pdev)
        mac_enable_int(vptr->mac_regs);
        spin_unlock_irqrestore(&vptr->lock, flags);
-        netif_device_attach(vptr->dev);
+        netif_device_attach(vptr->netdev);
        return 0;
 }
-#endif
+#endif  /* CONFIG_PM_SLEEP */
+static SIMPLE_DEV_PM_OPS(velocity_pm_ops, velocity_suspend, velocity_resume);
 /*
 *      Definition for our device driver. The PCI layer interface
 *      uses this to handle all our card discover and plugging
 */
-static struct pci_driver velocity_driver = {
+static struct pci_driver velocity_pci_driver = {
        .name           = VELOCITY_NAME,
-        .id_table       = velocity_id_table,
+        .id_table       = velocity_pci_id_table,
-        .probe          = velocity_found1,
+        .probe          = velocity_pci_probe,
-        .remove         = velocity_remove1,
+        .remove         = velocity_pci_remove,
-#ifdef CONFIG_PM
+        .driver = {
-        .suspend        = velocity_suspend,
+                .pm = &velocity_pm_ops,
-        .resume         = velocity_resume,
+        },
-#endif
 };
+static struct platform_driver velocity_platform_driver = {
+        .probe          = velocity_platform_probe,
+        .remove         = velocity_platform_remove,
+        .driver = {
+                .name = "via-velocity",
+                .owner = THIS_MODULE,
+                .of_match_table = velocity_of_ids,
+                .pm = &velocity_pm_ops,
+        },
+};
 /**
 *      velocity_ethtool_up     -       pre hook for ethtool
@@ -3134,7 +3275,7 @@ static int velocity_ethtool_up(struct net_device *dev)
 {
        struct velocity_info *vptr = netdev_priv(dev);
        if (!netif_running(dev))
-                pci_set_power_state(vptr->pdev, PCI_D0);
+                velocity_set_power_state(vptr, PCI_D0);
        return 0;
 }
@@ -3149,7 +3290,7 @@ static void velocity_ethtool_down(struct net_device *dev)
 {
        struct velocity_info *vptr = netdev_priv(dev);
        if (!netif_running(dev))
-                pci_set_power_state(vptr->pdev, PCI_D3hot);
+                velocity_set_power_state(vptr, PCI_D3hot);
 }
 static int velocity_get_settings(struct net_device *dev,
@@ -3269,9 +3410,14 @@ static int velocity_set_settings(struct net_device *dev,
 static void velocity_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 {
        struct velocity_info *vptr = netdev_priv(dev);
        strlcpy(info->driver, VELOCITY_NAME, sizeof(info->driver));
        strlcpy(info->version, VELOCITY_VERSION, sizeof(info->version));
-        strlcpy(info->bus_info, pci_name(vptr->pdev), sizeof(info->bus_info));
+        if (vptr->pdev)
+                strlcpy(info->bus_info, pci_name(vptr->pdev),
+                                                sizeof(info->bus_info));
+        else
+                strlcpy(info->bus_info, "platform", sizeof(info->bus_info));
 }
 static void velocity_ethtool_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
@@ -3561,13 +3707,20 @@ static void velocity_unregister_notifier(void)
 */
 static int __init velocity_init_module(void)
 {
-        int ret;
+        int ret_pci, ret_platform;
        velocity_register_notifier();
-        ret = pci_register_driver(&velocity_driver);
-        if (ret < 0)
+        ret_pci = pci_register_driver(&velocity_pci_driver);
+        ret_platform = platform_driver_register(&velocity_platform_driver);
+        /* if both_registers failed, remove the notifier */
+        if ((ret_pci < 0) && (ret_platform < 0)) {
                velocity_unregister_notifier();
-        return ret;
+                return ret_pci;
+        }
+        return 0;
 }
 /**
@@ -3581,7 +3734,9 @@ static int __init velocity_init_module(void)
 static void __exit velocity_cleanup_module(void)
 {
        velocity_unregister_notifier();
-        pci_unregister_driver(&velocity_driver);
+        pci_unregister_driver(&velocity_pci_driver);
+        platform_driver_unregister(&velocity_platform_driver);
 }
 module_init(velocity_init_module);
diff --git a/drivers/net/ethernet/via/via-velocity.h b/drivers/net/ethernet/via/via-velocity.h
index 4cb9f13485e9..9453bfa9324a 100644
--- a/drivers/net/ethernet/via/via-velocity.h
+++ b/drivers/net/ethernet/via/via-velocity.h
@@ -1265,7 +1265,7 @@ struct velocity_context {
 #define PHYID_VT3216_64BIT  0x000FC600UL
 #define PHYID_MARVELL_1000  0x01410C50UL
 #define PHYID_MARVELL_1000S 0x01410C40UL
+#define PHYID_ICPLUS_IP101A 0x02430C54UL
 #define PHYID_REV_ID_MASK   0x0000000FUL
 #define PHYID_GET_PHY_ID(i)         ((i) & ~PHYID_REV_ID_MASK)
@@ -1434,8 +1434,10 @@ struct velocity_opt {
 #define GET_RD_BY_IDX(vptr, idx)   (vptr->rd_ring[idx])
 struct velocity_info {
+        struct device *dev;
        struct pci_dev *pdev;
-        struct net_device *dev;
+        struct net_device *netdev;
+        int no_eeprom;
        unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
        u8 ip_addr[4];
@@ -1514,7 +1516,7 @@ static inline int velocity_get_ip(struct velocity_info *vptr)
        int res = -ENOENT;
        rcu_read_lock();
-        in_dev = __in_dev_get_rcu(vptr->dev);
+        in_dev = __in_dev_get_rcu(vptr->netdev);
        if (in_dev != NULL) {
                ifa = (struct in_ifaddr *) in_dev->ifa_list;
                if (ifa != NULL) {
diff --git a/drivers/net/fddi/skfp/skfddi.c b/drivers/net/fddi/skfp/skfddi.c
index d5bd563ac131..f5d7305a5784 100644
--- a/drivers/net/fddi/skfp/skfddi.c
+++ b/drivers/net/fddi/skfp/skfddi.c
@@ -2246,15 +2246,4 @@ static struct pci_driver skfddi_pci_driver = {
        .remove         = skfp_remove_one,
 };
-static int __init skfd_init(void)
+module_pci_driver(skfddi_pci_driver);
-{
-        return pci_register_driver(&skfddi_pci_driver);
-}
-static void __exit skfd_exit(void)
-{
-        pci_unregister_driver(&skfddi_pci_driver);
-}
-module_init(skfd_init);
-module_exit(skfd_exit);
diff --git a/drivers/net/hippi/rrunner.c b/drivers/net/hippi/rrunner.c
index 3c4d6274bb9b..00ed75155ce8 100644
--- a/drivers/net/hippi/rrunner.c
+++ b/drivers/net/hippi/rrunner.c
@@ -1686,15 +1686,4 @@ static struct pci_driver rr_driver = {
        .remove         = rr_remove_one,
 };
-static int __init rr_init_module(void)
+module_pci_driver(rr_driver);
-{
-        return pci_register_driver(&rr_driver);
-}
-static void __exit rr_cleanup_module(void)
-{
-        pci_unregister_driver(&rr_driver);
-}
-module_init(rr_init_module);
-module_exit(rr_cleanup_module);
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index c14f14741b3f..2d28a0ef4572 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -419,8 +419,6 @@ out_unlock:
 EXPORT_SYMBOL(phy_start_aneg);
-static void phy_change(struct work_struct *work);
 /**
 * phy_start_machine - start PHY state machine tracking
 * @phydev: the phy_device struct
@@ -565,8 +563,6 @@ int phy_start_interrupts(struct phy_device *phydev)
 {
        int err = 0;
-        INIT_WORK(&phydev->phy_queue, phy_change);
        atomic_set(&phydev->irq_disable, 0);
        if (request_irq(phydev->irq, phy_interrupt,
                                IRQF_SHARED,
@@ -623,7 +619,7 @@ EXPORT_SYMBOL(phy_stop_interrupts);
 * phy_change - Scheduled by the phy_interrupt/timer to handle PHY changes
 * @work: work_struct that describes the work to be done
 */
-static void phy_change(struct work_struct *work)
+void phy_change(struct work_struct *work)
 {
        int err;
        struct phy_device *phydev =
@@ -682,7 +678,7 @@ void phy_stop(struct phy_device *phydev)
        if (PHY_HALTED == phydev->state)
                goto out_unlock;
-        if (phydev->irq != PHY_POLL) {
+        if (phy_interrupt_is_valid(phydev)) {
                /* Disable PHY Interrupts */
                phy_config_interrupt(phydev, PHY_INTERRUPT_DISABLED);
@@ -828,8 +824,9 @@ void phy_state_machine(struct work_struct *work)
                        break;
                case PHY_RUNNING:
                        /* Only register a CHANGE if we are
-                         * polling */
+                         * polling or ignoring interrupts
-                        if (PHY_POLL == phydev->irq)
+                         */
+                        if (!phy_interrupt_is_valid(phydev))
                                phydev->state = PHY_CHANGELINK;
                        break;
                case PHY_CHANGELINK:
@@ -848,7 +845,7 @@ void phy_state_machine(struct work_struct *work)
                        phydev->adjust_link(phydev->attached_dev);
-                        if (PHY_POLL != phydev->irq)
+                        if (phy_interrupt_is_valid(phydev))
                                err = phy_config_interrupt(phydev,
                                                PHY_INTERRUPT_ENABLED);
                        break;
@@ -921,6 +918,14 @@ void phy_state_machine(struct work_struct *work)
        schedule_delayed_work(&phydev->state_queue, PHY_STATE_TIME * HZ);
 }
+void phy_mac_interrupt(struct phy_device *phydev, int new_link)
+{
+        cancel_work_sync(&phydev->phy_queue);
+        phydev->link = new_link;
+        schedule_work(&phydev->phy_queue);
+}
+EXPORT_SYMBOL(phy_mac_interrupt);
 static inline void mmd_phy_indirect(struct mii_bus *bus, int prtad, int devad,
                                    int addr)
 {
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index 3657b4a29124..b55aa33a5b8b 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -189,6 +189,7 @@ struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
        mutex_init(&dev->lock);
        INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine);
+        INIT_WORK(&dev->phy_queue, phy_change);
        /* Request the appropriate module unconditionally; don't
           bother trying to do so only if it isn't already loaded,
@@ -1009,8 +1010,11 @@ static int phy_probe(struct device *dev)
        phydrv = to_phy_driver(drv);
        phydev->drv = phydrv;
-        /* Disable the interrupt if the PHY doesn't support it */
+        /* Disable the interrupt if the PHY doesn't support it
-        if (!(phydrv->flags & PHY_HAS_INTERRUPT))
+         * but the interrupt is still a valid one
+         */
+        if (!(phydrv->flags & PHY_HAS_INTERRUPT) &&
+                        phy_interrupt_is_valid(phydev))
                phydev->irq = PHY_POLL;
        mutex_lock(&phydev->lock);
diff --git a/drivers/net/usb/r8152.c b/drivers/net/usb/r8152.c
index 14e519888631..d02bac82fc57 100644
--- a/drivers/net/usb/r8152.c
+++ b/drivers/net/usb/r8152.c
@@ -11,7 +11,6 @@
 #include <linux/signal.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <linux/version.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/mii.h>
@@ -1749,18 +1748,7 @@ static struct usb_driver rtl8152_driver = {
        .resume =       rtl8152_resume
 };
-static int __init usb_rtl8152_init(void)
+module_usb_driver(rtl8152_driver);
-{
-        return usb_register(&rtl8152_driver);
-}
-static void __exit usb_rtl8152_exit(void)
-{
-        usb_deregister(&rtl8152_driver);
-}
-module_init(usb_rtl8152_init);
-module_exit(usb_rtl8152_exit);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c
index 3b1d2ee7156b..5ed64d496f83 100644
--- a/drivers/net/vxlan.c
+++ b/drivers/net/vxlan.c
@@ -44,6 +44,8 @@
 #define VXLAN_VERSION   "0.1"
+#define PORT_HASH_BITS  8
+#define PORT_HASH_SIZE  (1<<PORT_HASH_BITS)
 #define VNI_HASH_BITS   10
 #define VNI_HASH_SIZE   (1<<VNI_HASH_BITS)
 #define FDB_HASH_BITS   8
@@ -76,13 +78,24 @@ static bool log_ecn_error = true;
 module_param(log_ecn_error, bool, 0644);
 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
-/* per-net private data for this module */
 static unsigned int vxlan_net_id;
-struct vxlan_net {
-        struct socket     *sock;        /* UDP encap socket */
+/* per UDP socket information */
+struct vxlan_sock {
+        struct hlist_node hlist;
+        struct rcu_head   rcu;
+        struct work_struct del_work;
+        unsigned int      refcnt;
+        struct socket     *sock;
        struct hlist_head vni_list[VNI_HASH_SIZE];
 };
+/* per-network namespace private data for this module */
+struct vxlan_net {
+        struct list_head  vxlan_list;
+        struct hlist_head sock_list[PORT_HASH_SIZE];
+};
 struct vxlan_rdst {
        struct rcu_head          rcu;
        __be32                   remote_ip;
@@ -106,7 +119,9 @@ struct vxlan_fdb {
 /* Pseudo network device */
 struct vxlan_dev {
-        struct hlist_node hlist;
+        struct hlist_node hlist;        /* vni hash table */
+        struct list_head  next;         /* vxlan's per namespace list */
+        struct vxlan_sock *vn_sock;     /* listening socket */
        struct net_device *dev;
        struct vxlan_rdst default_dst;  /* default destination */
        __be32            saddr;        /* source address */
@@ -135,19 +150,43 @@ struct vxlan_dev {
 /* salt for hash table */
 static u32 vxlan_salt __read_mostly;
-static inline struct hlist_head *vni_head(struct net *net, u32 id)
+/* Virtual Network hash table head */
+static inline struct hlist_head *vni_head(struct vxlan_sock *vs, u32 id)
+{
+        return &vs->vni_list[hash_32(id, VNI_HASH_BITS)];
+}
+/* Socket hash table head */
+static inline struct hlist_head *vs_head(struct net *net, __be16 port)
 {
        struct vxlan_net *vn = net_generic(net, vxlan_net_id);
-        return &vn->vni_list[hash_32(id, VNI_HASH_BITS)];
+        return &vn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];
+}
+/* Find VXLAN socket based on network namespace and UDP port */
+static struct vxlan_sock *vxlan_find_port(struct net *net, __be16 port)
+{
+        struct vxlan_sock *vs;
+        hlist_for_each_entry_rcu(vs, vs_head(net, port), hlist) {
+                if (inet_sk(vs->sock->sk)->inet_sport == port)
+                        return vs;
+        }
+        return NULL;
 }
 /* Look up VNI in a per net namespace table */
-static struct vxlan_dev *vxlan_find_vni(struct net *net, u32 id)
+static struct vxlan_dev *vxlan_find_vni(struct net *net, u32 id, __be16 port)
 {
+        struct vxlan_sock *vs;
        struct vxlan_dev *vxlan;
-        hlist_for_each_entry_rcu(vxlan, vni_head(net, id), hlist) {
+        vs = vxlan_find_port(net, port);
+        if (!vs)
+                return NULL;
+        hlist_for_each_entry_rcu(vxlan, vni_head(vs, id), hlist) {
                if (vxlan->default_dst.remote_vni == id)
                        return vxlan;
        }
@@ -603,20 +642,18 @@ static void vxlan_snoop(struct net_device *dev,
 static bool vxlan_group_used(struct vxlan_net *vn,
                             const struct vxlan_dev *this)
 {
-        const struct vxlan_dev *vxlan;
+        struct vxlan_dev *vxlan;
-        unsigned h;
-        for (h = 0; h < VNI_HASH_SIZE; ++h)
+        list_for_each_entry(vxlan, &vn->vxlan_list, next) {
-                hlist_for_each_entry(vxlan, &vn->vni_list[h], hlist) {
+                if (vxlan == this)
-                        if (vxlan == this)
+                        continue;
-                                continue;
-                        if (!netif_running(vxlan->dev))
+                if (!netif_running(vxlan->dev))
-                                continue;
+                        continue;
-                        if (vxlan->default_dst.remote_ip == this->default_dst.remote_ip)
+                if (vxlan->default_dst.remote_ip == this->default_dst.remote_ip)
-                                return true;
+                        return true;
-                }
+        }
        return false;
 }
@@ -626,7 +663,7 @@ static int vxlan_join_group(struct net_device *dev)
 {
        struct vxlan_dev *vxlan = netdev_priv(dev);
        struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
-        struct sock *sk = vn->sock->sk;
+        struct sock *sk = vxlan->vn_sock->sock->sk;
        struct ip_mreqn mreq = {
                .imr_multiaddr.s_addr   = vxlan->default_dst.remote_ip,
                .imr_ifindex            = vxlan->default_dst.remote_ifindex,
@@ -654,7 +691,7 @@ static int vxlan_leave_group(struct net_device *dev)
        struct vxlan_dev *vxlan = netdev_priv(dev);
        struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
        int err = 0;
-        struct sock *sk = vn->sock->sk;
+        struct sock *sk = vxlan->vn_sock->sock->sk;
        struct ip_mreqn mreq = {
                .imr_multiaddr.s_addr   = vxlan->default_dst.remote_ip,
                .imr_ifindex            = vxlan->default_dst.remote_ifindex,
@@ -681,6 +718,7 @@ static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
        struct vxlanhdr *vxh;
        struct vxlan_dev *vxlan;
        struct pcpu_tstats *stats;
+        __be16 port;
        __u32 vni;
        int err;
@@ -704,9 +742,11 @@ static int vxlan_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
        /* Is this VNI defined? */
        vni = ntohl(vxh->vx_vni) >> 8;
-        vxlan = vxlan_find_vni(sock_net(sk), vni);
+        port = inet_sk(sk)->inet_sport;
+        vxlan = vxlan_find_vni(sock_net(sk), vni, port);
        if (!vxlan) {
-                netdev_dbg(skb->dev, "unknown vni %d\n", vni);
+                netdev_dbg(skb->dev, "unknown vni %d port %u\n",
+                           vni, ntohs(port));
                goto drop;
        }
@@ -886,7 +926,7 @@ static bool route_shortcircuit(struct net_device *dev, struct sk_buff *skb)
        return false;
 }
-static void vxlan_sock_free(struct sk_buff *skb)
+static void vxlan_sock_put(struct sk_buff *skb)
 {
        sock_put(skb->sk);
 }
@@ -894,13 +934,13 @@ static void vxlan_sock_free(struct sk_buff *skb)
 /* On transmit, associate with the tunnel socket */
 static void vxlan_set_owner(struct net_device *dev, struct sk_buff *skb)
 {
-        struct vxlan_net *vn = net_generic(dev_net(dev), vxlan_net_id);
+        struct vxlan_dev *vxlan = netdev_priv(dev);
-        struct sock *sk = vn->sock->sk;
+        struct sock *sk = vxlan->vn_sock->sock->sk;
        skb_orphan(skb);
        sock_hold(sk);
        skb->sk = sk;
-        skb->destructor = vxlan_sock_free;
+        skb->destructor = vxlan_sock_put;
 }
 /* Compute source port for outgoing packet
@@ -1042,7 +1082,7 @@ static netdev_tx_t vxlan_xmit_one(struct sk_buff *skb, struct net_device *dev,
                struct vxlan_dev *dst_vxlan;
                ip_rt_put(rt);
-                dst_vxlan = vxlan_find_vni(dev_net(dev), vni);
+                dst_vxlan = vxlan_find_vni(dev_net(dev), vni, dst_port);
                if (!dst_vxlan)
                        goto tx_error;
                vxlan_encap_bypass(skb, vxlan, dst_vxlan);
@@ -1317,6 +1357,7 @@ static void vxlan_setup(struct net_device *dev)
        dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
        dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
+        INIT_LIST_HEAD(&vxlan->next);
        spin_lock_init(&vxlan->hash_lock);
        init_timer_deferrable(&vxlan->age_timer);
@@ -1401,11 +1442,78 @@ static const struct ethtool_ops vxlan_ethtool_ops = {
        .get_link       = ethtool_op_get_link,
 };
+static void vxlan_del_work(struct work_struct *work)
+{
+        struct vxlan_sock *vs = container_of(work, struct vxlan_sock, del_work);
+        sk_release_kernel(vs->sock->sk);
+        kfree_rcu(vs, rcu);
+}
+/* Create new listen socket if needed */
+static struct vxlan_sock *vxlan_socket_create(struct net *net, __be16 port)
+{
+        struct vxlan_sock *vs;
+        struct sock *sk;
+        struct sockaddr_in vxlan_addr = {
+                .sin_family = AF_INET,
+                .sin_addr.s_addr = htonl(INADDR_ANY),
+        };
+        int rc;
+        unsigned h;
+        vs = kmalloc(sizeof(*vs), GFP_KERNEL);
+        if (!vs)
+                return ERR_PTR(-ENOMEM);
+        for (h = 0; h < VNI_HASH_SIZE; ++h)
+                INIT_HLIST_HEAD(&vs->vni_list[h]);
+        INIT_WORK(&vs->del_work, vxlan_del_work);
+        /* Create UDP socket for encapsulation receive. */
+        rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &vs->sock);
+        if (rc < 0) {
+                pr_debug("UDP socket create failed\n");
+                kfree(vs);
+                return ERR_PTR(rc);
+        }
+        /* Put in proper namespace */
+        sk = vs->sock->sk;
+        sk_change_net(sk, net);
+        vxlan_addr.sin_port = port;
+        rc = kernel_bind(vs->sock, (struct sockaddr *) &vxlan_addr,
+                         sizeof(vxlan_addr));
+        if (rc < 0) {
+                pr_debug("bind for UDP socket %pI4:%u (%d)\n",
+                         &vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);
+                sk_release_kernel(sk);
+                kfree(vs);
+                return ERR_PTR(rc);
+        }
+        /* Disable multicast loopback */
+        inet_sk(sk)->mc_loop = 0;
+        /* Mark socket as an encapsulation socket. */
+        udp_sk(sk)->encap_type = 1;
+        udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
+        udp_encap_enable();
+        vs->refcnt = 1;
+        return vs;
+}
 static int vxlan_newlink(struct net *net, struct net_device *dev,
                         struct nlattr *tb[], struct nlattr *data[])
 {
+        struct vxlan_net *vn = net_generic(net, vxlan_net_id);
        struct vxlan_dev *vxlan = netdev_priv(dev);
        struct vxlan_rdst *dst = &vxlan->default_dst;
+        struct vxlan_sock *vs;
        __u32 vni;
        int err;
@@ -1413,10 +1521,6 @@ static int vxlan_newlink(struct net *net, struct net_device *dev,
                return -EINVAL;
        vni = nla_get_u32(data[IFLA_VXLAN_ID]);
-        if (vxlan_find_vni(net, vni)) {
-                pr_info("duplicate VNI %u\n", vni);
-                return -EEXIST;
-        }
        dst->remote_vni = vni;
        if (data[IFLA_VXLAN_GROUP])
@@ -1482,22 +1586,58 @@ static int vxlan_newlink(struct net *net, struct net_device *dev,
        if (data[IFLA_VXLAN_PORT])
                vxlan->dst_port = nla_get_be16(data[IFLA_VXLAN_PORT]);
+        if (vxlan_find_vni(net, vni, vxlan->dst_port)) {
+                pr_info("duplicate VNI %u\n", vni);
+                return -EEXIST;
+        }
+        vs = vxlan_find_port(net, vxlan->dst_port);
+        if (vs)
+                ++vs->refcnt;
+        else {
+                /* Drop lock because socket create acquires RTNL lock */
+                rtnl_unlock();
+                vs = vxlan_socket_create(net, vxlan->dst_port);
+                rtnl_lock();
+                if (IS_ERR(vs))
+                        return PTR_ERR(vs);
+                hlist_add_head_rcu(&vs->hlist, vs_head(net, vxlan->dst_port));
+        }
+        vxlan->vn_sock = vs;
        SET_ETHTOOL_OPS(dev, &vxlan_ethtool_ops);
        err = register_netdevice(dev);
-        if (!err)
+        if (err) {
-                hlist_add_head_rcu(&vxlan->hlist, vni_head(net, dst->remote_vni));
+                if (--vs->refcnt == 0) {
+                        rtnl_unlock();
+                        sk_release_kernel(vs->sock->sk);
+                        kfree(vs);
+                        rtnl_lock();
+                }
+                return err;
+        }
-        return err;
+        list_add(&vxlan->next, &vn->vxlan_list);
+        hlist_add_head_rcu(&vxlan->hlist, vni_head(vs, vni));
+        return 0;
 }
 static void vxlan_dellink(struct net_device *dev, struct list_head *head)
 {
        struct vxlan_dev *vxlan = netdev_priv(dev);
+        struct vxlan_sock *vs = vxlan->vn_sock;
        hlist_del_rcu(&vxlan->hlist);
+        list_del(&vxlan->next);
        unregister_netdevice_queue(dev, head);
+        if (--vs->refcnt == 0) {
+                hlist_del_rcu(&vs->hlist);
+                schedule_work(&vs->del_work);
+        }
 }
 static size_t vxlan_get_size(const struct net_device *dev)
@@ -1583,46 +1723,12 @@ static struct rtnl_link_ops vxlan_link_ops __read_mostly = {
 static __net_init int vxlan_init_net(struct net *net)
 {
        struct vxlan_net *vn = net_generic(net, vxlan_net_id);
-        struct sock *sk;
-        struct sockaddr_in vxlan_addr = {
-                .sin_family = AF_INET,
-                .sin_addr.s_addr = htonl(INADDR_ANY),
-        };
-        int rc;
        unsigned h;
-        /* Create UDP socket for encapsulation receive. */
+        INIT_LIST_HEAD(&vn->vxlan_list);
-        rc = sock_create_kern(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &vn->sock);
-        if (rc < 0) {
-                pr_debug("UDP socket create failed\n");
-                return rc;
-        }
-        /* Put in proper namespace */
-        sk = vn->sock->sk;
-        sk_change_net(sk, net);
-        vxlan_addr.sin_port = htons(vxlan_port);
-        rc = kernel_bind(vn->sock, (struct sockaddr *) &vxlan_addr,
-                         sizeof(vxlan_addr));
-        if (rc < 0) {
-                pr_debug("bind for UDP socket %pI4:%u (%d)\n",
-                         &vxlan_addr.sin_addr, ntohs(vxlan_addr.sin_port), rc);
-                sk_release_kernel(sk);
-                vn->sock = NULL;
-                return rc;
-        }
-        /* Disable multicast loopback */
-        inet_sk(sk)->mc_loop = 0;
-        /* Mark socket as an encapsulation socket. */
+        for (h = 0; h < PORT_HASH_SIZE; ++h)
-        udp_sk(sk)->encap_type = 1;
+                INIT_HLIST_HEAD(&vn->sock_list[h]);
-        udp_sk(sk)->encap_rcv = vxlan_udp_encap_recv;
-        udp_encap_enable();
-        for (h = 0; h < VNI_HASH_SIZE; ++h)
-                INIT_HLIST_HEAD(&vn->vni_list[h]);
        return 0;
 }
@@ -1631,18 +1737,11 @@ static __net_exit void vxlan_exit_net(struct net *net)
 {
        struct vxlan_net *vn = net_generic(net, vxlan_net_id);
        struct vxlan_dev *vxlan;
-        unsigned h;
        rtnl_lock();
-        for (h = 0; h < VNI_HASH_SIZE; ++h)
+        list_for_each_entry(vxlan, &vn->vxlan_list, next)
-                hlist_for_each_entry(vxlan, &vn->vni_list[h], hlist)
+                dev_close(vxlan->dev);
-                        dev_close(vxlan->dev);
        rtnl_unlock();
-        if (vn->sock) {
-                sk_release_kernel(vn->sock->sk);
-                vn->sock = NULL;
-        }
 }
 static struct pernet_operations vxlan_net_ops = {
diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h
index 9d7f1723dd8f..8a4d77ee9c5b 100644
--- a/drivers/net/xen-netback/common.h
+++ b/drivers/net/xen-netback/common.h
@@ -57,8 +57,12 @@ struct xenvif {
        u8               fe_dev_addr[6];
-        /* Physical parameters of the comms window. */
+        /* When feature-split-event-channels = 0, tx_irq = rx_irq. */
-        unsigned int     irq;
+        unsigned int tx_irq;
+        unsigned int rx_irq;
+        /* Only used when feature-split-event-channels = 1 */
+        char tx_irq_name[IFNAMSIZ+4]; /* DEVNAME-tx */
+        char rx_irq_name[IFNAMSIZ+4]; /* DEVNAME-rx */
        /* List of frontends to notify after a batch of frames sent. */
        struct list_head notify_list;
@@ -113,13 +117,15 @@ struct xenvif *xenvif_alloc(struct device *parent,
                            unsigned int handle);
 int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
-                   unsigned long rx_ring_ref, unsigned int evtchn);
+                   unsigned long rx_ring_ref, unsigned int tx_evtchn,
+                   unsigned int rx_evtchn);
 void xenvif_disconnect(struct xenvif *vif);
 void xenvif_get(struct xenvif *vif);
 void xenvif_put(struct xenvif *vif);
 int xenvif_xenbus_init(void);
+void xenvif_xenbus_fini(void);
 int xenvif_schedulable(struct xenvif *vif);
@@ -157,4 +163,6 @@ void xenvif_carrier_off(struct xenvif *vif);
 /* Returns number of ring slots required to send an skb to the frontend */
 unsigned int xen_netbk_count_skb_slots(struct xenvif *vif, struct sk_buff *skb);
+extern bool separate_tx_rx_irq;
 #endif /* __XEN_NETBACK__COMMON_H__ */
diff --git a/drivers/net/xen-netback/interface.c b/drivers/net/xen-netback/interface.c
index d98414168485..087d2db0389d 100644
--- a/drivers/net/xen-netback/interface.c
+++ b/drivers/net/xen-netback/interface.c
@@ -60,21 +60,39 @@ static int xenvif_rx_schedulable(struct xenvif *vif)
        return xenvif_schedulable(vif) && !xen_netbk_rx_ring_full(vif);
 }
-static irqreturn_t xenvif_interrupt(int irq, void *dev_id)
+static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id)
 {
        struct xenvif *vif = dev_id;
        if (vif->netbk == NULL)
-                return IRQ_NONE;
+                return IRQ_HANDLED;
        xen_netbk_schedule_xenvif(vif);
+        return IRQ_HANDLED;
+}
+static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id)
+{
+        struct xenvif *vif = dev_id;
+        if (vif->netbk == NULL)
+                return IRQ_HANDLED;
        if (xenvif_rx_schedulable(vif))
                netif_wake_queue(vif->dev);
        return IRQ_HANDLED;
 }
+static irqreturn_t xenvif_interrupt(int irq, void *dev_id)
+{
+        xenvif_tx_interrupt(irq, dev_id);
+        xenvif_rx_interrupt(irq, dev_id);
+        return IRQ_HANDLED;
+}
 static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct xenvif *vif = netdev_priv(dev);
@@ -125,13 +143,17 @@ static struct net_device_stats *xenvif_get_stats(struct net_device *dev)
 static void xenvif_up(struct xenvif *vif)
 {
        xen_netbk_add_xenvif(vif);
-        enable_irq(vif->irq);
+        enable_irq(vif->tx_irq);
+        if (vif->tx_irq != vif->rx_irq)
+                enable_irq(vif->rx_irq);
        xen_netbk_check_rx_xenvif(vif);
 }
 static void xenvif_down(struct xenvif *vif)
 {
-        disable_irq(vif->irq);
+        disable_irq(vif->tx_irq);
+        if (vif->tx_irq != vif->rx_irq)
+                disable_irq(vif->rx_irq);
        del_timer_sync(&vif->credit_timeout);
        xen_netbk_deschedule_xenvif(vif);
        xen_netbk_remove_xenvif(vif);
@@ -308,25 +330,52 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
 }
 int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
-                   unsigned long rx_ring_ref, unsigned int evtchn)
+                   unsigned long rx_ring_ref, unsigned int tx_evtchn,
+                   unsigned int rx_evtchn)
 {
        int err = -ENOMEM;
        /* Already connected through? */
-        if (vif->irq)
+        if (vif->tx_irq)
                return 0;
+        __module_get(THIS_MODULE);
        err = xen_netbk_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref);
        if (err < 0)
                goto err;
-        err = bind_interdomain_evtchn_to_irqhandler(
+        if (tx_evtchn == rx_evtchn) {
-                vif->domid, evtchn, xenvif_interrupt, 0,
+                /* feature-split-event-channels == 0 */
-                vif->dev->name, vif);
+                err = bind_interdomain_evtchn_to_irqhandler(
-        if (err < 0)
+                        vif->domid, tx_evtchn, xenvif_interrupt, 0,
-                goto err_unmap;
+                        vif->dev->name, vif);
-        vif->irq = err;
+                if (err < 0)
-        disable_irq(vif->irq);
+                        goto err_unmap;
+                vif->tx_irq = vif->rx_irq = err;
+                disable_irq(vif->tx_irq);
+        } else {
+                /* feature-split-event-channels == 1 */
+                snprintf(vif->tx_irq_name, sizeof(vif->tx_irq_name),
+                         "%s-tx", vif->dev->name);
+                err = bind_interdomain_evtchn_to_irqhandler(
+                        vif->domid, tx_evtchn, xenvif_tx_interrupt, 0,
+                        vif->tx_irq_name, vif);
+                if (err < 0)
+                        goto err_unmap;
+                vif->tx_irq = err;
+                disable_irq(vif->tx_irq);
+                snprintf(vif->rx_irq_name, sizeof(vif->rx_irq_name),
+                         "%s-rx", vif->dev->name);
+                err = bind_interdomain_evtchn_to_irqhandler(
+                        vif->domid, rx_evtchn, xenvif_rx_interrupt, 0,
+                        vif->rx_irq_name, vif);
+                if (err < 0)
+                        goto err_tx_unbind;
+                vif->rx_irq = err;
+                disable_irq(vif->rx_irq);
+        }
        xenvif_get(vif);
@@ -340,9 +389,13 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
        rtnl_unlock();
        return 0;
+err_tx_unbind:
+        unbind_from_irqhandler(vif->tx_irq, vif);
+        vif->tx_irq = 0;
 err_unmap:
        xen_netbk_unmap_frontend_rings(vif);
 err:
+        module_put(THIS_MODULE);
        return err;
 }
@@ -360,18 +413,37 @@ void xenvif_carrier_off(struct xenvif *vif)
 void xenvif_disconnect(struct xenvif *vif)
 {
+        /* Disconnect funtion might get called by generic framework
+         * even before vif connects, so we need to check if we really
+         * need to do a module_put.
+         */
+        int need_module_put = 0;
        if (netif_carrier_ok(vif->dev))
                xenvif_carrier_off(vif);
        atomic_dec(&vif->refcnt);
        wait_event(vif->waiting_to_free, atomic_read(&vif->refcnt) == 0);
-        if (vif->irq)
+        if (vif->tx_irq) {
-                unbind_from_irqhandler(vif->irq, vif);
+                if (vif->tx_irq == vif->rx_irq)
+                        unbind_from_irqhandler(vif->tx_irq, vif);
+                else {
+                        unbind_from_irqhandler(vif->tx_irq, vif);
+                        unbind_from_irqhandler(vif->rx_irq, vif);
+                }
+                /* vif->irq is valid, we had a module_get in
+                 * xenvif_connect.
+                 */
+                need_module_put = 1;
+        }
        unregister_netdev(vif->dev);
        xen_netbk_unmap_frontend_rings(vif);
        free_netdev(vif->dev);
+        if (need_module_put)
+                module_put(THIS_MODULE);
 }
diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
index 37984e6d4e99..82576fffb452 100644
--- a/drivers/net/xen-netback/netback.c
+++ b/drivers/net/xen-netback/netback.c
@@ -47,6 +47,13 @@
 #include <asm/xen/hypercall.h>
 #include <asm/xen/page.h>
+/* Provide an option to disable split event channels at load time as
+ * event channels are limited resource. Split event channels are
+ * enabled by default.
+ */
+bool separate_tx_rx_irq = 1;
+module_param(separate_tx_rx_irq, bool, 0644);
 /*
 * This is the maximum slots a skb can have. If a guest sends a skb
 * which exceeds this limit it is considered malicious.
@@ -662,7 +669,7 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
 {
        struct xenvif *vif = NULL, *tmp;
        s8 status;
-        u16 irq, flags;
+        u16 flags;
        struct xen_netif_rx_response *resp;
        struct sk_buff_head rxq;
        struct sk_buff *skb;
@@ -771,7 +778,6 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
                                         sco->meta_slots_used);
                RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&vif->rx, ret);
-                irq = vif->irq;
                if (ret && list_empty(&vif->notify_list))
                        list_add_tail(&vif->notify_list, &notify);
@@ -783,7 +789,7 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
        }
        list_for_each_entry_safe(vif, tmp, &notify, notify_list) {
-                notify_remote_via_irq(vif->irq);
+                notify_remote_via_irq(vif->rx_irq);
                list_del_init(&vif->notify_list);
        }
@@ -1762,7 +1768,7 @@ static void make_tx_response(struct xenvif *vif,
        vif->tx.rsp_prod_pvt = ++i;
        RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&vif->tx, notify);
        if (notify)
-                notify_remote_via_irq(vif->irq);
+                notify_remote_via_irq(vif->tx_irq);
 }
 static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif,
@@ -1939,10 +1945,6 @@ static int __init netback_init(void)
 failed_init:
        while (--group >= 0) {
                struct xen_netbk *netbk = &xen_netbk[group];
-                for (i = 0; i < MAX_PENDING_REQS; i++) {
-                        if (netbk->mmap_pages[i])
-                                __free_page(netbk->mmap_pages[i]);
-                }
                del_timer(&netbk->net_timer);
                kthread_stop(netbk->task);
        }
@@ -1953,5 +1955,25 @@ failed_init:
 module_init(netback_init);
+static void __exit netback_fini(void)
+{
+        int i, j;
+        xenvif_xenbus_fini();
+        for (i = 0; i < xen_netbk_group_nr; i++) {
+                struct xen_netbk *netbk = &xen_netbk[i];
+                del_timer_sync(&netbk->net_timer);
+                kthread_stop(netbk->task);
+                for (j = 0; j < MAX_PENDING_REQS; j++) {
+                        if (netbk->mmap_pages[i])
+                                __free_page(netbk->mmap_pages[i]);
+                }
+        }
+        vfree(xen_netbk);
+}
+module_exit(netback_fini);
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_ALIAS("xen-backend:vif");
diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index 410018c4c528..04bd860d16a9 100644
--- a/drivers/net/xen-netback/xenbus.c
+++ b/drivers/net/xen-netback/xenbus.c
@@ -122,6 +122,16 @@ static int netback_probe(struct xenbus_device *dev,
                goto fail;
        }
+        /*
+         * Split event channels support, this is optional so it is not
+         * put inside the above loop.
+         */
+        err = xenbus_printf(XBT_NIL, dev->nodename,
+                            "feature-split-event-channels",
+                            "%u", separate_tx_rx_irq);
+        if (err)
+                pr_debug("Error writing feature-split-event-channels");
        err = xenbus_switch_state(dev, XenbusStateInitWait);
        if (err)
                goto fail;
@@ -393,21 +403,36 @@ static int connect_rings(struct backend_info *be)
        struct xenvif *vif = be->vif;
        struct xenbus_device *dev = be->dev;
        unsigned long tx_ring_ref, rx_ring_ref;
-        unsigned int evtchn, rx_copy;
+        unsigned int tx_evtchn, rx_evtchn, rx_copy;
        int err;
        int val;
        err = xenbus_gather(XBT_NIL, dev->otherend,
                            "tx-ring-ref", "%lu", &tx_ring_ref,
-                            "rx-ring-ref", "%lu", &rx_ring_ref,
+                            "rx-ring-ref", "%lu", &rx_ring_ref, NULL);
-                            "event-channel", "%u", &evtchn, NULL);
        if (err) {
                xenbus_dev_fatal(dev, err,
-                                 "reading %s/ring-ref and event-channel",
+                                 "reading %s/ring-ref",
                                 dev->otherend);
                return err;
        }
+        /* Try split event channels first, then single event channel. */
+        err = xenbus_gather(XBT_NIL, dev->otherend,
+                            "event-channel-tx", "%u", &tx_evtchn,
+                            "event-channel-rx", "%u", &rx_evtchn, NULL);
+        if (err < 0) {
+                err = xenbus_scanf(XBT_NIL, dev->otherend,
+                                   "event-channel", "%u", &tx_evtchn);
+                if (err < 0) {
+                        xenbus_dev_fatal(dev, err,
+                                         "reading %s/event-channel(-tx/rx)",
+                                         dev->otherend);
+                        return err;
+                }
+                rx_evtchn = tx_evtchn;
+        }
        err = xenbus_scanf(XBT_NIL, dev->otherend, "request-rx-copy", "%u",
                           &rx_copy);
        if (err == -ENOENT) {
@@ -454,11 +479,13 @@ static int connect_rings(struct backend_info *be)
        vif->csum = !val;
        /* Map the shared frame, irq etc. */
-        err = xenvif_connect(vif, tx_ring_ref, rx_ring_ref, evtchn);
+        err = xenvif_connect(vif, tx_ring_ref, rx_ring_ref,
+                             tx_evtchn, rx_evtchn);
        if (err) {
                xenbus_dev_fatal(dev, err,
-                                 "mapping shared-frames %lu/%lu port %u",
+                                 "mapping shared-frames %lu/%lu port tx %u rx %u",
-                                 tx_ring_ref, rx_ring_ref, evtchn);
+                                 tx_ring_ref, rx_ring_ref,
+                                 tx_evtchn, rx_evtchn);
                return err;
        }
        return 0;
@@ -485,3 +512,8 @@ int xenvif_xenbus_init(void)
 {
        return xenbus_register_backend(&netback_driver);
 }
+void xenvif_xenbus_fini(void)
+{
+        return xenbus_unregister_driver(&netback_driver);
+}
diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
index 1db101415069..62238a08cb51 100644
--- a/drivers/net/xen-netfront.c
+++ b/drivers/net/xen-netfront.c
@@ -85,7 +85,15 @@ struct netfront_info {
        struct napi_struct napi;
-        unsigned int evtchn;
+        /* Split event channels support, tx_* == rx_* when using
+         * single event channel.
+         */
+        unsigned int tx_evtchn, rx_evtchn;
+        unsigned int tx_irq, rx_irq;
+        /* Only used when split event channels support is enabled */
+        char tx_irq_name[IFNAMSIZ+4]; /* DEVNAME-tx */
+        char rx_irq_name[IFNAMSIZ+4]; /* DEVNAME-rx */
        struct xenbus_device *xbdev;
        spinlock_t   tx_lock;
@@ -330,7 +338,7 @@ no_skb:
 push:
        RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&np->rx, notify);
        if (notify)
-                notify_remote_via_irq(np->netdev->irq);
+                notify_remote_via_irq(np->rx_irq);
 }
 static int xennet_open(struct net_device *dev)
@@ -623,7 +631,7 @@ static int xennet_start_xmit(struct sk_buff *skb, struct net_device *dev)
        RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&np->tx, notify);
        if (notify)
-                notify_remote_via_irq(np->netdev->irq);
+                notify_remote_via_irq(np->tx_irq);
        u64_stats_update_begin(&stats->syncp);
        stats->tx_bytes += skb->len;
@@ -1254,23 +1262,35 @@ static int xennet_set_features(struct net_device *dev,
        return 0;
 }
-static irqreturn_t xennet_interrupt(int irq, void *dev_id)
+static irqreturn_t xennet_tx_interrupt(int irq, void *dev_id)
 {
-        struct net_device *dev = dev_id;
+        struct netfront_info *np = dev_id;
-        struct netfront_info *np = netdev_priv(dev);
+        struct net_device *dev = np->netdev;
        unsigned long flags;
        spin_lock_irqsave(&np->tx_lock, flags);
+        xennet_tx_buf_gc(dev);
+        spin_unlock_irqrestore(&np->tx_lock, flags);
-        if (likely(netif_carrier_ok(dev))) {
+        return IRQ_HANDLED;
-                xennet_tx_buf_gc(dev);
+}
-                /* Under tx_lock: protects access to rx shared-ring indexes. */
-                if (RING_HAS_UNCONSUMED_RESPONSES(&np->rx))
+static irqreturn_t xennet_rx_interrupt(int irq, void *dev_id)
+{
+        struct netfront_info *np = dev_id;
+        struct net_device *dev = np->netdev;
+        if (likely(netif_carrier_ok(dev) &&
+                   RING_HAS_UNCONSUMED_RESPONSES(&np->rx)))
                        napi_schedule(&np->napi);
-        }
-        spin_unlock_irqrestore(&np->tx_lock, flags);
+        return IRQ_HANDLED;
+}
+static irqreturn_t xennet_interrupt(int irq, void *dev_id)
+{
+        xennet_tx_interrupt(irq, dev_id);
+        xennet_rx_interrupt(irq, dev_id);
        return IRQ_HANDLED;
 }
@@ -1451,9 +1471,14 @@ static void xennet_disconnect_backend(struct netfront_info *info)
        spin_unlock_irq(&info->tx_lock);
        spin_unlock_bh(&info->rx_lock);
-        if (info->netdev->irq)
+        if (info->tx_irq && (info->tx_irq == info->rx_irq))
-                unbind_from_irqhandler(info->netdev->irq, info->netdev);
+                unbind_from_irqhandler(info->tx_irq, info);
-        info->evtchn = info->netdev->irq = 0;
+        if (info->tx_irq && (info->tx_irq != info->rx_irq)) {
+                unbind_from_irqhandler(info->tx_irq, info);
+                unbind_from_irqhandler(info->rx_irq, info);
+        }
+        info->tx_evtchn = info->rx_evtchn = 0;
+        info->tx_irq = info->rx_irq = 0;
        /* End access and free the pages */
        xennet_end_access(info->tx_ring_ref, info->tx.sring);
@@ -1503,12 +1528,82 @@ static int xen_net_read_mac(struct xenbus_device *dev, u8 mac[])
        return 0;
 }
+static int setup_netfront_single(struct netfront_info *info)
+{
+        int err;
+        err = xenbus_alloc_evtchn(info->xbdev, &info->tx_evtchn);
+        if (err < 0)
+                goto fail;
+        err = bind_evtchn_to_irqhandler(info->tx_evtchn,
+                                        xennet_interrupt,
+                                        0, info->netdev->name, info);
+        if (err < 0)
+                goto bind_fail;
+        info->rx_evtchn = info->tx_evtchn;
+        info->rx_irq = info->tx_irq = err;
+        return 0;
+bind_fail:
+        xenbus_free_evtchn(info->xbdev, info->tx_evtchn);
+        info->tx_evtchn = 0;
+fail:
+        return err;
+}
+static int setup_netfront_split(struct netfront_info *info)
+{
+        int err;
+        err = xenbus_alloc_evtchn(info->xbdev, &info->tx_evtchn);
+        if (err < 0)
+                goto fail;
+        err = xenbus_alloc_evtchn(info->xbdev, &info->rx_evtchn);
+        if (err < 0)
+                goto alloc_rx_evtchn_fail;
+        snprintf(info->tx_irq_name, sizeof(info->tx_irq_name),
+                 "%s-tx", info->netdev->name);
+        err = bind_evtchn_to_irqhandler(info->tx_evtchn,
+                                        xennet_tx_interrupt,
+                                        0, info->tx_irq_name, info);
+        if (err < 0)
+                goto bind_tx_fail;
+        info->tx_irq = err;
+        snprintf(info->rx_irq_name, sizeof(info->rx_irq_name),
+                 "%s-rx", info->netdev->name);
+        err = bind_evtchn_to_irqhandler(info->rx_evtchn,
+                                        xennet_rx_interrupt,
+                                        0, info->rx_irq_name, info);
+        if (err < 0)
+                goto bind_rx_fail;
+        info->rx_irq = err;
+        return 0;
+bind_rx_fail:
+        unbind_from_irqhandler(info->tx_irq, info);
+        info->tx_irq = 0;
+bind_tx_fail:
+        xenbus_free_evtchn(info->xbdev, info->rx_evtchn);
+        info->rx_evtchn = 0;
+alloc_rx_evtchn_fail:
+        xenbus_free_evtchn(info->xbdev, info->tx_evtchn);
+        info->tx_evtchn = 0;
+fail:
+        return err;
+}
 static int setup_netfront(struct xenbus_device *dev, struct netfront_info *info)
 {
        struct xen_netif_tx_sring *txs;
        struct xen_netif_rx_sring *rxs;
        int err;
        struct net_device *netdev = info->netdev;
+        unsigned int feature_split_evtchn;
        info->tx_ring_ref = GRANT_INVALID_REF;
        info->rx_ring_ref = GRANT_INVALID_REF;
@@ -1516,6 +1611,12 @@ static int setup_netfront(struct xenbus_device *dev, struct netfront_info *info)
        info->tx.sring = NULL;
        netdev->irq = 0;
+        err = xenbus_scanf(XBT_NIL, info->xbdev->otherend,
+                           "feature-split-event-channels", "%u",
+                           &feature_split_evtchn);
+        if (err < 0)
+                feature_split_evtchn = 0;
        err = xen_net_read_mac(dev, netdev->dev_addr);
        if (err) {
                xenbus_dev_fatal(dev, err, "parsing %s/mac", dev->nodename);
@@ -1532,40 +1633,50 @@ static int setup_netfront(struct xenbus_device *dev, struct netfront_info *info)
        FRONT_RING_INIT(&info->tx, txs, PAGE_SIZE);
        err = xenbus_grant_ring(dev, virt_to_mfn(txs));
-        if (err < 0) {
+        if (err < 0)
-                free_page((unsigned long)txs);
+                goto grant_tx_ring_fail;
-                goto fail;
-        }
        info->tx_ring_ref = err;
        rxs = (struct xen_netif_rx_sring *)get_zeroed_page(GFP_NOIO | __GFP_HIGH);
        if (!rxs) {
                err = -ENOMEM;
                xenbus_dev_fatal(dev, err, "allocating rx ring page");
-                goto fail;
+                goto alloc_rx_ring_fail;
        }
        SHARED_RING_INIT(rxs);
        FRONT_RING_INIT(&info->rx, rxs, PAGE_SIZE);
        err = xenbus_grant_ring(dev, virt_to_mfn(rxs));
-        if (err < 0) {
+        if (err < 0)
-                free_page((unsigned long)rxs);
+                goto grant_rx_ring_fail;
-                goto fail;
-        }
        info->rx_ring_ref = err;
-        err = xenbus_alloc_evtchn(dev, &info->evtchn);
+        if (feature_split_evtchn)
+                err = setup_netfront_split(info);
+        /* setup single event channel if
+         *  a) feature-split-event-channels == 0
+         *  b) feature-split-event-channels == 1 but failed to setup
+         */
+        if (!feature_split_evtchn || (feature_split_evtchn && err))
+                err = setup_netfront_single(info);
        if (err)
-                goto fail;
+                goto alloc_evtchn_fail;
-        err = bind_evtchn_to_irqhandler(info->evtchn, xennet_interrupt,
-                                        0, netdev->name, netdev);
-        if (err < 0)
-                goto fail;
-        netdev->irq = err;
        return 0;
- fail:
+        /* If we fail to setup netfront, it is safe to just revoke access to
+         * granted pages because backend is not accessing it at this point.
+         */
+alloc_evtchn_fail:
+        gnttab_end_foreign_access_ref(info->rx_ring_ref, 0);
+grant_rx_ring_fail:
+        free_page((unsigned long)rxs);
+alloc_rx_ring_fail:
+        gnttab_end_foreign_access_ref(info->tx_ring_ref, 0);
+grant_tx_ring_fail:
+        free_page((unsigned long)txs);
+fail:
        return err;
 }
@@ -1601,11 +1712,27 @@ again:
                message = "writing rx ring-ref";
                goto abort_transaction;
        }
-        err = xenbus_printf(xbt, dev->nodename,
-                            "event-channel", "%u", info->evtchn);
+        if (info->tx_evtchn == info->rx_evtchn) {
-        if (err) {
+                err = xenbus_printf(xbt, dev->nodename,
-                message = "writing event-channel";
+                                    "event-channel", "%u", info->tx_evtchn);
-                goto abort_transaction;
+                if (err) {
+                        message = "writing event-channel";
+                        goto abort_transaction;
+                }
+        } else {
+                err = xenbus_printf(xbt, dev->nodename,
+                                    "event-channel-tx", "%u", info->tx_evtchn);
+                if (err) {
+                        message = "writing event-channel-tx";
+                        goto abort_transaction;
+                }
+                err = xenbus_printf(xbt, dev->nodename,
+                                    "event-channel-rx", "%u", info->rx_evtchn);
+                if (err) {
+                        message = "writing event-channel-rx";
+                        goto abort_transaction;
+                }
        }
        err = xenbus_printf(xbt, dev->nodename, "request-rx-copy", "%u",
@@ -1718,7 +1845,9 @@ static int xennet_connect(struct net_device *dev)
         * packets.
         */
        netif_carrier_on(np->netdev);
-        notify_remote_via_irq(np->netdev->irq);
+        notify_remote_via_irq(np->tx_irq);
+        if (np->tx_irq != np->rx_irq)
+                notify_remote_via_irq(np->rx_irq);
        xennet_tx_buf_gc(dev);
        xennet_alloc_rx_buffers(dev);
diff --git a/include/linux/filter.h b/include/linux/filter.h
index c050dcc322a4..56a6b7fbb3c6 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -58,10 +58,10 @@ extern void bpf_jit_free(struct sk_filter *fp);
 static inline void bpf_jit_dump(unsigned int flen, unsigned int proglen,
                                u32 pass, void *image)
 {
-        pr_err("flen=%u proglen=%u pass=%u image=%p\n",
+        pr_err("flen=%u proglen=%u pass=%u image=%pK\n",
               flen, proglen, pass, image);
        if (image)
-                print_hex_dump(KERN_ERR, "JIT code: ", DUMP_PREFIX_ADDRESS,
+                print_hex_dump(KERN_ERR, "JIT code: ", DUMP_PREFIX_OFFSET,
                               16, 1, image, proglen, false);
 }
 #define SK_RUN_FILTER(FILTER, SKB) (*FILTER->bpf_func)(SKB, FILTER->insns)
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 60584b185a0c..0ebd63ae2cc8 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1778,6 +1778,19 @@ static inline int unregister_gifconf(unsigned int family)
        return register_gifconf(family, NULL);
 }
+#ifdef CONFIG_NET_FLOW_LIMIT
+#define FLOW_LIMIT_HISTORY      (1 << 8)        /* must be ^2 */
+struct sd_flow_limit {
+        u64                     count;
+        unsigned int            num_buckets;
+        unsigned int            history_head;
+        u16                     history[FLOW_LIMIT_HISTORY];
+        u8                      buckets[];
+};
+extern int netdev_flow_limit_table_len;
+#endif /* CONFIG_NET_FLOW_LIMIT */
 /*
 * Incoming packets are placed on per-cpu queues
 */
@@ -1807,6 +1820,10 @@ struct softnet_data {
        unsigned int            dropped;
        struct sk_buff_head     input_pkt_queue;
        struct napi_struct      backlog;
+#ifdef CONFIG_NET_FLOW_LIMIT
+        struct sd_flow_limit    *flow_limit;
+#endif
 };
 static inline void input_queue_head_incr(struct softnet_data *sd)
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 9e11039dd7a3..fdfa11542974 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -508,6 +508,18 @@ static inline int phy_write(struct phy_device *phydev, u32 regnum, u16 val)
        return mdiobus_write(phydev->bus, phydev->addr, regnum, val);
 }
+/**
+ * phy_interrupt_is_valid - Convenience function for testing a given PHY irq
+ * @phydev: the phy_device struct
+ *
+ * NOTE: must be kept in sync with addition/removal of PHY_POLL and
+ * PHY_IGNORE_INTERRUPT
+ */
+static inline bool phy_interrupt_is_valid(struct phy_device *phydev)
+{
+        return phydev->irq != PHY_POLL && phydev->irq != PHY_IGNORE_INTERRUPT;
+}
 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
                bool is_c45, struct phy_c45_device_ids *c45_ids);
 struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45);
@@ -545,6 +557,8 @@ void phy_drivers_unregister(struct phy_driver *drv, int n);
 int phy_driver_register(struct phy_driver *new_driver);
 int phy_drivers_register(struct phy_driver *new_driver, int n);
 void phy_state_machine(struct work_struct *work);
+void phy_change(struct work_struct *work);
+void phy_mac_interrupt(struct phy_device *phydev, int new_link);
 void phy_start_machine(struct phy_device *phydev,
                void (*handler)(struct net_device *));
 void phy_stop_machine(struct phy_device *phydev);
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 5adbc33d1ab3..472120b4fac5 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -246,7 +246,6 @@ struct tcp_sock {
        /* from STCP, retrans queue hinting */
        struct sk_buff* lost_skb_hint;
-        struct sk_buff *scoreboard_skb_hint;
        struct sk_buff *retransmit_skb_hint;
        struct sk_buff_head     out_of_order_queue; /* Out of order segments go here */
diff --git a/include/net/if_inet6.h b/include/net/if_inet6.h
index 100fb8cec17c..e07feb456d19 100644
--- a/include/net/if_inet6.h
+++ b/include/net/if_inet6.h
@@ -74,6 +74,7 @@ struct inet6_ifaddr {
        bool                    tokenized;
        struct rcu_head         rcu;
+        struct in6_addr         peer_addr;
 };
 struct ip6_sf_socklist {
@@ -192,7 +193,6 @@ struct inet6_dev {
        struct in6_addr         token;
        struct neigh_parms      *nd_parms;
-        struct inet6_dev        *next;
        struct ipv6_devconf     cnf;
        struct ipv6_devstat     stats;
        unsigned long           tstamp; /* ipv6InterfaceTable update timestamp */
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 5bba80fbd1d9..bf1cc3dced5e 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -1193,7 +1193,6 @@ static inline void tcp_mib_init(struct net *net)
 static inline void tcp_clear_retrans_hints_partial(struct tcp_sock *tp)
 {
        tp->lost_skb_hint = NULL;
-        tp->scoreboard_skb_hint = NULL;
 }
 static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp)
@@ -1284,11 +1283,13 @@ static inline struct tcp_md5sig_key *tcp_md5_do_lookup(struct sock *sk,
 #define tcp_twsk_md5_key(twsk)  NULL
 #endif
-extern struct tcp_md5sig_pool __percpu *tcp_alloc_md5sig_pool(struct sock *);
+extern bool tcp_alloc_md5sig_pool(void);
-extern void tcp_free_md5sig_pool(void);
 extern struct tcp_md5sig_pool   *tcp_get_md5sig_pool(void);
-extern void tcp_put_md5sig_pool(void);
+static inline void tcp_put_md5sig_pool(void)
+{
+        local_bh_enable();
+}
 extern int tcp_md5_hash_header(struct tcp_md5sig_pool *, const struct tcphdr *);
 extern int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *, const struct sk_buff *,
diff --git a/include/xen/interface/io/netif.h b/include/xen/interface/io/netif.h
index 3ef3fe05ee99..eb262e3324d2 100644
--- a/include/xen/interface/io/netif.h
+++ b/include/xen/interface/io/netif.h
@@ -38,6 +38,18 @@
 * that it cannot safely queue packets (as it may not be kicked to send them).
 */
+ /*
+ * "feature-split-event-channels" is introduced to separate guest TX
+ * and RX notificaion. Backend either doesn't support this feature or
+ * advertise it via xenstore as 0 (disabled) or 1 (enabled).
+ *
+ * To make use of this feature, frontend should allocate two event
+ * channels for TX and RX, advertise them to backend as
+ * "event-channel-tx" and "event-channel-rx" respectively. If frontend
+ * doesn't want to use this feature, it just writes "event-channel"
+ * node as before.
+ */
 /*
 * This is the 'wire' format for packets:
 *  Request 1: xen_netif_tx_request  -- XEN_NETTXF_* (any flags)
diff --git a/net/Kconfig b/net/Kconfig
index 2ddc9046868e..08de901415ee 100644
--- a/net/Kconfig
+++ b/net/Kconfig
@@ -259,6 +259,18 @@ config BPF_JIT
          packet sniffing (libpcap/tcpdump). Note : Admin should enable
          this feature changing /proc/sys/net/core/bpf_jit_enable
+config NET_FLOW_LIMIT
+        boolean
+        depends on RPS
+        default y
+        ---help---
+          The network stack has to drop packets when a receive processing CPU's
+          backlog reaches netdev_max_backlog. If a few out of many active flows
+          generate the vast majority of load, drop their traffic earlier to
+          maintain capacity for the other flows. This feature provides servers
+          with many clients some protection against DoS by a single (spoofed)
+          flow that greatly exceeds average workload.
 menu "Network testing"
 config NET_PKTGEN
diff --git a/net/bridge/br_device.c b/net/bridge/br_device.c
index 967312803e41..75f3239130f8 100644
--- a/net/bridge/br_device.c
+++ b/net/bridge/br_device.c
@@ -22,6 +22,9 @@
 #include <asm/uaccess.h>
 #include "br_private.h"
+#define COMMON_FEATURES (NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | \
+                         NETIF_F_GSO_MASK | NETIF_F_HW_CSUM)
 /* net device transmit always called with BH disabled */
 netdev_tx_t br_dev_xmit(struct sk_buff *skb, struct net_device *dev)
 {
@@ -346,12 +349,10 @@ void br_dev_setup(struct net_device *dev)
        dev->tx_queue_len = 0;
        dev->priv_flags = IFF_EBRIDGE;
-        dev->features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA |
+        dev->features = COMMON_FEATURES | NETIF_F_LLTX | NETIF_F_NETNS_LOCAL |
-                        NETIF_F_GSO_MASK | NETIF_F_HW_CSUM | NETIF_F_LLTX |
+                        NETIF_F_HW_VLAN_CTAG_TX;
-                        NETIF_F_NETNS_LOCAL | NETIF_F_HW_VLAN_CTAG_TX;
+        dev->hw_features = COMMON_FEATURES | NETIF_F_HW_VLAN_CTAG_TX;
-        dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA |
+        dev->vlan_features = COMMON_FEATURES;
-                           NETIF_F_GSO_MASK | NETIF_F_HW_CSUM |
-                           NETIF_F_HW_VLAN_CTAG_TX;
        br->dev = dev;
        spin_lock_init(&br->lock);
diff --git a/net/bridge/br_multicast.c b/net/bridge/br_multicast.c
index 81f2389f78eb..37a467697967 100644
--- a/net/bridge/br_multicast.c
+++ b/net/bridge/br_multicast.c
@@ -23,6 +23,7 @@
 #include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/timer.h>
+#include <linux/inetdevice.h>
 #include <net/ip.h>
 #if IS_ENABLED(CONFIG_IPV6)
 #include <net/ipv6.h>
@@ -381,7 +382,8 @@ static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge *br,
        iph->frag_off = htons(IP_DF);
        iph->ttl = 1;
        iph->protocol = IPPROTO_IGMP;
-        iph->saddr = 0;
+        iph->saddr = br->multicast_query_use_ifaddr ?
+                     inet_select_addr(br->dev, 0, RT_SCOPE_LINK) : 0;
        iph->daddr = htonl(INADDR_ALLHOSTS_GROUP);
        ((u8 *)&iph[1])[0] = IPOPT_RA;
        ((u8 *)&iph[1])[1] = 4;
@@ -615,8 +617,6 @@ rehash:
        mp->br = br;
        mp->addr = *group;
-        setup_timer(&mp->timer, br_multicast_group_expired,
-                    (unsigned long)mp);
        hlist_add_head_rcu(&mp->hlist[mdb->ver], &mdb->mhash[hash]);
        mdb->size++;
@@ -654,7 +654,6 @@ static int br_multicast_add_group(struct net_bridge *br,
        struct net_bridge_mdb_entry *mp;
        struct net_bridge_port_group *p;
        struct net_bridge_port_group __rcu **pp;
-        unsigned long now = jiffies;
        int err;
        spin_lock(&br->multicast_lock);
@@ -669,7 +668,6 @@ static int br_multicast_add_group(struct net_bridge *br,
        if (!port) {
                mp->mglist = true;
-                mod_timer(&mp->timer, now + br->multicast_membership_interval);
                goto out;
        }
@@ -677,7 +675,7 @@ static int br_multicast_add_group(struct net_bridge *br,
             (p = mlock_dereference(*pp, br)) != NULL;
             pp = &p->next) {
                if (p->port == port)
-                        goto found;
+                        goto out;
                if ((unsigned long)p->port < (unsigned long)port)
                        break;
        }
@@ -688,8 +686,6 @@ static int br_multicast_add_group(struct net_bridge *br,
        rcu_assign_pointer(*pp, p);
        br_mdb_notify(br->dev, port, group, RTM_NEWMDB);
-found:
-        mod_timer(&p->timer, now + br->multicast_membership_interval);
 out:
        err = 0;
@@ -1129,6 +1125,10 @@ static int br_ip4_multicast_query(struct net_bridge *br,
        if (!mp)
                goto out;
+        setup_timer(&mp->timer, br_multicast_group_expired, (unsigned long)mp);
+        mod_timer(&mp->timer, now + br->multicast_membership_interval);
+        mp->timer_armed = true;
        max_delay *= br->multicast_last_member_count;
        if (mp->mglist &&
@@ -1203,6 +1203,10 @@ static int br_ip6_multicast_query(struct net_bridge *br,
        if (!mp)
                goto out;
+        setup_timer(&mp->timer, br_multicast_group_expired, (unsigned long)mp);
+        mod_timer(&mp->timer, now + br->multicast_membership_interval);
+        mp->timer_armed = true;
        max_delay *= br->multicast_last_member_count;
        if (mp->mglist &&
            (timer_pending(&mp->timer) ?
@@ -1246,6 +1250,32 @@ static void br_multicast_leave_group(struct net_bridge *br,
        if (!mp)
                goto out;
+        if (br->multicast_querier &&
+            !timer_pending(&br->multicast_querier_timer)) {
+                __br_multicast_send_query(br, port, &mp->addr);
+                time = jiffies + br->multicast_last_member_count *
+                                 br->multicast_last_member_interval;
+                mod_timer(port ? &port->multicast_query_timer :
+                                 &br->multicast_query_timer, time);
+                for (p = mlock_dereference(mp->ports, br);
+                     p != NULL;
+                     p = mlock_dereference(p->next, br)) {
+                        if (p->port != port)
+                                continue;
+                        if (!hlist_unhashed(&p->mglist) &&
+                            (timer_pending(&p->timer) ?
+                             time_after(p->timer.expires, time) :
+                             try_to_del_timer_sync(&p->timer) >= 0)) {
+                                mod_timer(&p->timer, time);
+                        }
+                        break;
+                }
+        }
        if (port && (port->flags & BR_MULTICAST_FAST_LEAVE)) {
                struct net_bridge_port_group __rcu **pp;
@@ -1261,7 +1291,7 @@ static void br_multicast_leave_group(struct net_bridge *br,
                        call_rcu_bh(&p->rcu, br_multicast_free_pg);
                        br_mdb_notify(br->dev, port, group, RTM_DELMDB);
-                        if (!mp->ports && !mp->mglist &&
+                        if (!mp->ports && !mp->mglist && mp->timer_armed &&
                            netif_running(br->dev))
                                mod_timer(&mp->timer, jiffies);
                }
@@ -1273,30 +1303,12 @@ static void br_multicast_leave_group(struct net_bridge *br,
                     br->multicast_last_member_interval;
        if (!port) {
-                if (mp->mglist &&
+                if (mp->mglist && mp->timer_armed &&
                    (timer_pending(&mp->timer) ?
                     time_after(mp->timer.expires, time) :
                     try_to_del_timer_sync(&mp->timer) >= 0)) {
                        mod_timer(&mp->timer, time);
                }
-                goto out;
-        }
-        for (p = mlock_dereference(mp->ports, br);
-             p != NULL;
-             p = mlock_dereference(p->next, br)) {
-                if (p->port != port)
-                        continue;
-                if (!hlist_unhashed(&p->mglist) &&
-                    (timer_pending(&p->timer) ?
-                     time_after(p->timer.expires, time) :
-                     try_to_del_timer_sync(&p->timer) >= 0)) {
-                        mod_timer(&p->timer, time);
-                }
-                break;
        }
 out:
@@ -1618,6 +1630,7 @@ void br_multicast_init(struct net_bridge *br)
        br->multicast_router = 1;
        br->multicast_querier = 0;
+        br->multicast_query_use_ifaddr = 0;
        br->multicast_last_member_count = 2;
        br->multicast_startup_query_count = 2;
@@ -1671,6 +1684,7 @@ void br_multicast_stop(struct net_bridge *br)
                hlist_for_each_entry_safe(mp, n, &mdb->mhash[i],
                                          hlist[ver]) {
                        del_timer(&mp->timer);
+                        mp->timer_armed = false;
                        call_rcu_bh(&mp->rcu, br_multicast_free_group);
                }
        }
diff --git a/net/bridge/br_private.h b/net/bridge/br_private.h
index d2c043a857b6..1b0ac95a5c37 100644
--- a/net/bridge/br_private.h
+++ b/net/bridge/br_private.h
@@ -112,6 +112,7 @@ struct net_bridge_mdb_entry
        struct timer_list               timer;
        struct br_ip                    addr;
        bool                            mglist;
+        bool                            timer_armed;
 };
 struct net_bridge_mdb_htable
@@ -249,6 +250,7 @@ struct net_bridge
        u8                              multicast_disabled:1;
        u8                              multicast_querier:1;
+        u8                              multicast_query_use_ifaddr:1;
        u32                             hash_elasticity;
        u32                             hash_max;
diff --git a/net/bridge/br_sysfs_br.c b/net/bridge/br_sysfs_br.c
index 8baa9c08e1a4..394bb96b6087 100644
--- a/net/bridge/br_sysfs_br.c
+++ b/net/bridge/br_sysfs_br.c
@@ -375,6 +375,31 @@ static ssize_t store_multicast_snooping(struct device *d,
 static DEVICE_ATTR(multicast_snooping, S_IRUGO | S_IWUSR,
                   show_multicast_snooping, store_multicast_snooping);
+static ssize_t show_multicast_query_use_ifaddr(struct device *d,
+                                      struct device_attribute *attr,
+                                      char *buf)
+{
+        struct net_bridge *br = to_bridge(d);
+        return sprintf(buf, "%d\n", br->multicast_query_use_ifaddr);
+}
+static int set_query_use_ifaddr(struct net_bridge *br, unsigned long val)
+{
+        br->multicast_query_use_ifaddr = !!val;
+        return 0;
+}
+static ssize_t
+store_multicast_query_use_ifaddr(struct device *d,
+                                 struct device_attribute *attr,
+                                 const char *buf, size_t len)
+{
+        return store_bridge_parm(d, buf, len, set_query_use_ifaddr);
+}
+static DEVICE_ATTR(multicast_query_use_ifaddr, S_IRUGO | S_IWUSR,
+                   show_multicast_query_use_ifaddr,
+                   store_multicast_query_use_ifaddr);
 static ssize_t show_multicast_querier(struct device *d,
                                      struct device_attribute *attr,
                                      char *buf)
@@ -734,6 +759,7 @@ static struct attribute *bridge_attrs[] = {
        &dev_attr_multicast_router.attr,
        &dev_attr_multicast_snooping.attr,
        &dev_attr_multicast_querier.attr,
+        &dev_attr_multicast_query_use_ifaddr.attr,
        &dev_attr_hash_elasticity.attr,
        &dev_attr_hash_max.attr,
        &dev_attr_multicast_last_member_count.attr,
diff --git a/net/core/dev.c b/net/core/dev.c
index fc1e289397f5..7229bc30e509 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1629,7 +1629,6 @@ int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
                return NET_RX_DROP;
        }
        skb->skb_iif = 0;
-        skb->dev = dev;
        skb_dst_drop(skb);
        skb->tstamp.tv64 = 0;
        skb->pkt_type = PACKET_HOST;
@@ -3065,6 +3064,46 @@ static int rps_ipi_queued(struct softnet_data *sd)
        return 0;
 }
+#ifdef CONFIG_NET_FLOW_LIMIT
+int netdev_flow_limit_table_len __read_mostly = (1 << 12);
+#endif
+static bool skb_flow_limit(struct sk_buff *skb, unsigned int qlen)
+{
+#ifdef CONFIG_NET_FLOW_LIMIT
+        struct sd_flow_limit *fl;
+        struct softnet_data *sd;
+        unsigned int old_flow, new_flow;
+        if (qlen < (netdev_max_backlog >> 1))
+                return false;
+        sd = &__get_cpu_var(softnet_data);
+        rcu_read_lock();
+        fl = rcu_dereference(sd->flow_limit);
+        if (fl) {
+                new_flow = skb_get_rxhash(skb) & (fl->num_buckets - 1);
+                old_flow = fl->history[fl->history_head];
+                fl->history[fl->history_head] = new_flow;
+                fl->history_head++;
+                fl->history_head &= FLOW_LIMIT_HISTORY - 1;
+                if (likely(fl->buckets[old_flow]))
+                        fl->buckets[old_flow]--;
+                if (++fl->buckets[new_flow] > (FLOW_LIMIT_HISTORY >> 1)) {
+                        fl->count++;
+                        rcu_read_unlock();
+                        return true;
+                }
+        }
+        rcu_read_unlock();
+#endif
+        return false;
+}
 /*
 * enqueue_to_backlog is called to queue an skb to a per CPU backlog
 * queue (may be a remote CPU queue).
@@ -3074,13 +3113,15 @@ static int enqueue_to_backlog(struct sk_buff *skb, int cpu,
 {
        struct softnet_data *sd;
        unsigned long flags;
+        unsigned int qlen;
        sd = &per_cpu(softnet_data, cpu);
        local_irq_save(flags);
        rps_lock(sd);
-        if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) {
+        qlen = skb_queue_len(&sd->input_pkt_queue);
+        if (qlen <= netdev_max_backlog && !skb_flow_limit(skb, qlen)) {
                if (skb_queue_len(&sd->input_pkt_queue)) {
 enqueue:
                        __skb_queue_tail(&sd->input_pkt_queue, skb);
@@ -6270,6 +6311,10 @@ static int __init net_dev_init(void)
                sd->backlog.weight = weight_p;
                sd->backlog.gro_list = NULL;
                sd->backlog.gro_count = 0;
+#ifdef CONFIG_NET_FLOW_LIMIT
+                sd->flow_limit = NULL;
+#endif
        }
        dev_boot_phase = 0;
diff --git a/net/core/net-procfs.c b/net/core/net-procfs.c
index 569d355fec3e..2bf83299600a 100644
--- a/net/core/net-procfs.c
+++ b/net/core/net-procfs.c
@@ -146,11 +146,23 @@ static void softnet_seq_stop(struct seq_file *seq, void *v)
 static int softnet_seq_show(struct seq_file *seq, void *v)
 {
        struct softnet_data *sd = v;
+        unsigned int flow_limit_count = 0;
-        seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
+#ifdef CONFIG_NET_FLOW_LIMIT
+        struct sd_flow_limit *fl;
+        rcu_read_lock();
+        fl = rcu_dereference(sd->flow_limit);
+        if (fl)
+                flow_limit_count = fl->count;
+        rcu_read_unlock();
+#endif
+        seq_printf(seq,
+                   "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
                   sd->processed, sd->dropped, sd->time_squeeze, 0,
                   0, 0, 0, 0, /* was fastroute */
-                   sd->cpu_collision, sd->received_rps);
+                   sd->cpu_collision, sd->received_rps, flow_limit_count);
        return 0;
 }
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index af9185d0be6a..d6298914f4e7 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -2853,7 +2853,7 @@ struct sk_buff *skb_segment(struct sk_buff *skb, netdev_features_t features)
                                                 doffset + tnl_hlen);
                if (fskb != skb_shinfo(skb)->frag_list)
-                        continue;
+                        goto perform_csum_check;
                if (!sg) {
                        nskb->ip_summed = CHECKSUM_NONE;
@@ -2917,6 +2917,7 @@ skip_fraglist:
                nskb->len += nskb->data_len;
                nskb->truesize += nskb->data_len;
+perform_csum_check:
                if (!csum) {
                        nskb->csum = skb_checksum(nskb, doffset,
                                                  nskb->len - doffset, 0);
diff --git a/net/core/sysctl_net_core.c b/net/core/sysctl_net_core.c
index cfdb46ab3a7f..741db5fc7806 100644
--- a/net/core/sysctl_net_core.c
+++ b/net/core/sysctl_net_core.c
@@ -87,6 +87,96 @@ static int rps_sock_flow_sysctl(ctl_table *table, int write,
 }
 #endif /* CONFIG_RPS */
+#ifdef CONFIG_NET_FLOW_LIMIT
+static DEFINE_MUTEX(flow_limit_update_mutex);
+static int flow_limit_cpu_sysctl(ctl_table *table, int write,
+                                 void __user *buffer, size_t *lenp,
+                                 loff_t *ppos)
+{
+        struct sd_flow_limit *cur;
+        struct softnet_data *sd;
+        cpumask_var_t mask;
+        int i, len, ret = 0;
+        if (!alloc_cpumask_var(&mask, GFP_KERNEL))
+                return -ENOMEM;
+        if (write) {
+                ret = cpumask_parse_user(buffer, *lenp, mask);
+                if (ret)
+                        goto done;
+                mutex_lock(&flow_limit_update_mutex);
+                len = sizeof(*cur) + netdev_flow_limit_table_len;
+                for_each_possible_cpu(i) {
+                        sd = &per_cpu(softnet_data, i);
+                        cur = rcu_dereference_protected(sd->flow_limit,
+                                     lockdep_is_held(&flow_limit_update_mutex));
+                        if (cur && !cpumask_test_cpu(i, mask)) {
+                                RCU_INIT_POINTER(sd->flow_limit, NULL);
+                                synchronize_rcu();
+                                kfree(cur);
+                        } else if (!cur && cpumask_test_cpu(i, mask)) {
+                                cur = kzalloc(len, GFP_KERNEL);
+                                if (!cur) {
+                                        /* not unwinding previous changes */
+                                        ret = -ENOMEM;
+                                        goto write_unlock;
+                                }
+                                cur->num_buckets = netdev_flow_limit_table_len;
+                                rcu_assign_pointer(sd->flow_limit, cur);
+                        }
+                }
+write_unlock:
+                mutex_unlock(&flow_limit_update_mutex);
+        } else {
+                if (*ppos || !*lenp) {
+                        *lenp = 0;
+                        goto done;
+                }
+                cpumask_clear(mask);
+                rcu_read_lock();
+                for_each_possible_cpu(i) {
+                        sd = &per_cpu(softnet_data, i);
+                        if (rcu_dereference(sd->flow_limit))
+                                cpumask_set_cpu(i, mask);
+                }
+                rcu_read_unlock();
+                len = cpumask_scnprintf(buffer, *lenp, mask);
+                *lenp = len + 1;
+                *ppos += len + 1;
+        }
+done:
+        free_cpumask_var(mask);
+        return ret;
+}
+static int flow_limit_table_len_sysctl(ctl_table *table, int write,
+                                       void __user *buffer, size_t *lenp,
+                                       loff_t *ppos)
+{
+        unsigned int old, *ptr;
+        int ret;
+        mutex_lock(&flow_limit_update_mutex);
+        ptr = table->data;
+        old = *ptr;
+        ret = proc_dointvec(table, write, buffer, lenp, ppos);
+        if (!ret && write && !is_power_of_2(*ptr)) {
+                *ptr = old;
+                ret = -EINVAL;
+        }
+        mutex_unlock(&flow_limit_update_mutex);
+        return ret;
+}
+#endif /* CONFIG_NET_FLOW_LIMIT */
 static struct ctl_table net_core_table[] = {
 #ifdef CONFIG_NET
        {
@@ -180,6 +270,20 @@ static struct ctl_table net_core_table[] = {
                .proc_handler   = rps_sock_flow_sysctl
        },
 #endif
+#ifdef CONFIG_NET_FLOW_LIMIT
+        {
+                .procname       = "flow_limit_cpu_bitmap",
+                .mode           = 0644,
+                .proc_handler   = flow_limit_cpu_sysctl
+        },
+        {
+                .procname       = "flow_limit_table_len",
+                .data           = &netdev_flow_limit_table_len,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = flow_limit_table_len_sysctl
+        },
+#endif /* CONFIG_NET_FLOW_LIMIT */
 #endif /* CONFIG_NET */
        {
                .procname       = "netdev_budget",
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index ab450c099aa4..d87ce72ca8aa 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -3115,9 +3115,8 @@ int tcp_gro_complete(struct sk_buff *skb)
 EXPORT_SYMBOL(tcp_gro_complete);
 #ifdef CONFIG_TCP_MD5SIG
-static unsigned long tcp_md5sig_users;
+static struct tcp_md5sig_pool __percpu *tcp_md5sig_pool __read_mostly;
-static struct tcp_md5sig_pool __percpu *tcp_md5sig_pool;
+static DEFINE_MUTEX(tcp_md5sig_mutex);
-static DEFINE_SPINLOCK(tcp_md5sig_pool_lock);
 static void __tcp_free_md5sig_pool(struct tcp_md5sig_pool __percpu *pool)
 {
@@ -3132,30 +3131,14 @@ static void __tcp_free_md5sig_pool(struct tcp_md5sig_pool __percpu *pool)
        free_percpu(pool);
 }
-void tcp_free_md5sig_pool(void)
+static void __tcp_alloc_md5sig_pool(void)
-{
-        struct tcp_md5sig_pool __percpu *pool = NULL;
-        spin_lock_bh(&tcp_md5sig_pool_lock);
-        if (--tcp_md5sig_users == 0) {
-                pool = tcp_md5sig_pool;
-                tcp_md5sig_pool = NULL;
-        }
-        spin_unlock_bh(&tcp_md5sig_pool_lock);
-        if (pool)
-                __tcp_free_md5sig_pool(pool);
-}
-EXPORT_SYMBOL(tcp_free_md5sig_pool);
-static struct tcp_md5sig_pool __percpu *
-__tcp_alloc_md5sig_pool(struct sock *sk)
 {
        int cpu;
        struct tcp_md5sig_pool __percpu *pool;
        pool = alloc_percpu(struct tcp_md5sig_pool);
        if (!pool)
-                return NULL;
+                return;
        for_each_possible_cpu(cpu) {
                struct crypto_hash *hash;
@@ -3166,53 +3149,27 @@ __tcp_alloc_md5sig_pool(struct sock *sk)
                per_cpu_ptr(pool, cpu)->md5_desc.tfm = hash;
        }
-        return pool;
+        /* before setting tcp_md5sig_pool, we must commit all writes
+         * to memory. See ACCESS_ONCE() in tcp_get_md5sig_pool()
+         */
+        smp_wmb();
+        tcp_md5sig_pool = pool;
+        return;
 out_free:
        __tcp_free_md5sig_pool(pool);
-        return NULL;
 }
-struct tcp_md5sig_pool __percpu *tcp_alloc_md5sig_pool(struct sock *sk)
+bool tcp_alloc_md5sig_pool(void)
 {
-        struct tcp_md5sig_pool __percpu *pool;
+        if (unlikely(!tcp_md5sig_pool)) {
-        bool alloc = false;
+                mutex_lock(&tcp_md5sig_mutex);
-retry:
+                if (!tcp_md5sig_pool)
-        spin_lock_bh(&tcp_md5sig_pool_lock);
+                        __tcp_alloc_md5sig_pool();
-        pool = tcp_md5sig_pool;
-        if (tcp_md5sig_users++ == 0) {
+                mutex_unlock(&tcp_md5sig_mutex);
-                alloc = true;
-                spin_unlock_bh(&tcp_md5sig_pool_lock);
-        } else if (!pool) {
-                tcp_md5sig_users--;
-                spin_unlock_bh(&tcp_md5sig_pool_lock);
-                cpu_relax();
-                goto retry;
-        } else
-                spin_unlock_bh(&tcp_md5sig_pool_lock);
-        if (alloc) {
-                /* we cannot hold spinlock here because this may sleep. */
-                struct tcp_md5sig_pool __percpu *p;
-                p = __tcp_alloc_md5sig_pool(sk);
-                spin_lock_bh(&tcp_md5sig_pool_lock);
-                if (!p) {
-                        tcp_md5sig_users--;
-                        spin_unlock_bh(&tcp_md5sig_pool_lock);
-                        return NULL;
-                }
-                pool = tcp_md5sig_pool;
-                if (pool) {
-                        /* oops, it has already been assigned. */
-                        spin_unlock_bh(&tcp_md5sig_pool_lock);
-                        __tcp_free_md5sig_pool(p);
-                } else {
-                        tcp_md5sig_pool = pool = p;
-                        spin_unlock_bh(&tcp_md5sig_pool_lock);
-                }
        }
-        return pool;
+        return tcp_md5sig_pool != NULL;
 }
 EXPORT_SYMBOL(tcp_alloc_md5sig_pool);
@@ -3229,28 +3186,15 @@ struct tcp_md5sig_pool *tcp_get_md5sig_pool(void)
        struct tcp_md5sig_pool __percpu *p;
        local_bh_disable();
+        p = ACCESS_ONCE(tcp_md5sig_pool);
-        spin_lock(&tcp_md5sig_pool_lock);
-        p = tcp_md5sig_pool;
-        if (p)
-                tcp_md5sig_users++;
-        spin_unlock(&tcp_md5sig_pool_lock);
        if (p)
-                return this_cpu_ptr(p);
+                return __this_cpu_ptr(p);
        local_bh_enable();
        return NULL;
 }
 EXPORT_SYMBOL(tcp_get_md5sig_pool);
-void tcp_put_md5sig_pool(void)
-{
-        local_bh_enable();
-        tcp_free_md5sig_pool();
-}
-EXPORT_SYMBOL(tcp_put_md5sig_pool);
 int tcp_md5_hash_header(struct tcp_md5sig_pool *hp,
                        const struct tcphdr *th)
 {
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 9c6225780bd5..8230cd6243aa 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -360,9 +360,7 @@ static void tcp_fixup_rcvbuf(struct sock *sk)
        if (mss > 1460)
                icwnd = max_t(u32, (1460 * TCP_DEFAULT_INIT_RCVWND) / mss, 2);
-        rcvmem = SKB_TRUESIZE(mss + MAX_TCP_HEADER);
+        rcvmem = 2 * SKB_TRUESIZE(mss + MAX_TCP_HEADER);
-        while (tcp_win_from_space(rcvmem) < mss)
-                rcvmem += 128;
        rcvmem *= icwnd;
@@ -1257,8 +1255,6 @@ static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *skb,
        if (skb == tp->retransmit_skb_hint)
                tp->retransmit_skb_hint = prev;
-        if (skb == tp->scoreboard_skb_hint)
-                tp->scoreboard_skb_hint = prev;
        if (skb == tp->lost_skb_hint) {
                tp->lost_skb_hint = prev;
                tp->lost_cnt_hint -= tcp_skb_pcount(prev);
@@ -1966,20 +1962,6 @@ static bool tcp_pause_early_retransmit(struct sock *sk, int flag)
        return true;
 }
-static inline int tcp_skb_timedout(const struct sock *sk,
-                                   const struct sk_buff *skb)
-{
-        return tcp_time_stamp - TCP_SKB_CB(skb)->when > inet_csk(sk)->icsk_rto;
-}
-static inline int tcp_head_timedout(const struct sock *sk)
-{
-        const struct tcp_sock *tp = tcp_sk(sk);
-        return tp->packets_out &&
-               tcp_skb_timedout(sk, tcp_write_queue_head(sk));
-}
 /* Linux NewReno/SACK/FACK/ECN state machine.
 * --------------------------------------
 *
@@ -2086,12 +2068,6 @@ static bool tcp_time_to_recover(struct sock *sk, int flag)
        if (tcp_dupack_heuristics(tp) > tp->reordering)
                return true;
-        /* Trick#3 : when we use RFC2988 timer restart, fast
-         * retransmit can be triggered by timeout of queue head.
-         */
-        if (tcp_is_fack(tp) && tcp_head_timedout(sk))
-                return true;
        /* Trick#4: It is still not OK... But will it be useful to delay
         * recovery more?
         */
@@ -2128,44 +2104,6 @@ static bool tcp_time_to_recover(struct sock *sk, int flag)
        return false;
 }
-/* New heuristics: it is possible only after we switched to restart timer
- * each time when something is ACKed. Hence, we can detect timed out packets
- * during fast retransmit without falling to slow start.
- *
- * Usefulness of this as is very questionable, since we should know which of
- * the segments is the next to timeout which is relatively expensive to find
- * in general case unless we add some data structure just for that. The
- * current approach certainly won't find the right one too often and when it
- * finally does find _something_ it usually marks large part of the window
- * right away (because a retransmission with a larger timestamp blocks the
- * loop from advancing). -ij
- */
-static void tcp_timeout_skbs(struct sock *sk)
-{
-        struct tcp_sock *tp = tcp_sk(sk);
-        struct sk_buff *skb;
-        if (!tcp_is_fack(tp) || !tcp_head_timedout(sk))
-                return;
-        skb = tp->scoreboard_skb_hint;
-        if (tp->scoreboard_skb_hint == NULL)
-                skb = tcp_write_queue_head(sk);
-        tcp_for_write_queue_from(skb, sk) {
-                if (skb == tcp_send_head(sk))
-                        break;
-                if (!tcp_skb_timedout(sk, skb))
-                        break;
-                tcp_skb_mark_lost(tp, skb);
-        }
-        tp->scoreboard_skb_hint = skb;
-        tcp_verify_left_out(tp);
-}
 /* Detect loss in event "A" above by marking head of queue up as lost.
 * For FACK or non-SACK(Reno) senders, the first "packets" number of segments
 * are considered lost. For RFC3517 SACK, a segment is considered lost if it
@@ -2251,8 +2189,6 @@ static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
                else if (fast_rexmit)
                        tcp_mark_head_lost(sk, 1, 1);
        }
-        tcp_timeout_skbs(sk);
 }
 /* CWND moderation, preventing bursts due to too big ACKs
@@ -2846,7 +2782,7 @@ static void tcp_fastretrans_alert(struct sock *sk, int pkts_acked,
                fast_rexmit = 1;
        }
-        if (do_lost || (tcp_is_fack(tp) && tcp_head_timedout(sk)))
+        if (do_lost)
                tcp_update_scoreboard(sk, fast_rexmit);
        tcp_cwnd_reduction(sk, newly_acked_sacked, fast_rexmit);
        tcp_xmit_retransmit_queue(sk);
@@ -3079,7 +3015,6 @@ static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
                tcp_unlink_write_queue(skb, sk);
                sk_wmem_free_skb(sk, skb);
-                tp->scoreboard_skb_hint = NULL;
                if (skb == tp->retransmit_skb_hint)
                        tp->retransmit_skb_hint = NULL;
                if (skb == tp->lost_skb_hint)
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 719652305a29..d20ede0c9593 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -1026,7 +1026,7 @@ int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
        key = sock_kmalloc(sk, sizeof(*key), gfp);
        if (!key)
                return -ENOMEM;
-        if (hlist_empty(&md5sig->head) && !tcp_alloc_md5sig_pool(sk)) {
+        if (!tcp_alloc_md5sig_pool()) {
                sock_kfree_s(sk, key, sizeof(*key));
                return -ENOMEM;
        }
@@ -1044,9 +1044,7 @@ EXPORT_SYMBOL(tcp_md5_do_add);
 int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family)
 {
-        struct tcp_sock *tp = tcp_sk(sk);
        struct tcp_md5sig_key *key;
-        struct tcp_md5sig_info *md5sig;
        key = tcp_md5_do_lookup(sk, (union tcp_md5_addr *)&addr, AF_INET);
        if (!key)
@@ -1054,10 +1052,6 @@ int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr, int family)
        hlist_del_rcu(&key->node);
        atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
        kfree_rcu(key, rcu);
-        md5sig = rcu_dereference_protected(tp->md5sig_info,
-                                           sock_owned_by_user(sk));
-        if (hlist_empty(&md5sig->head))
-                tcp_free_md5sig_pool();
        return 0;
 }
 EXPORT_SYMBOL(tcp_md5_do_del);
@@ -1071,8 +1065,6 @@ static void tcp_clear_md5_list(struct sock *sk)
        md5sig = rcu_dereference_protected(tp->md5sig_info, 1);
-        if (!hlist_empty(&md5sig->head))
-                tcp_free_md5sig_pool();
        hlist_for_each_entry_safe(key, n, &md5sig->head, node) {
                hlist_del_rcu(&key->node);
                atomic_sub(sizeof(*key), &sk->sk_omem_alloc);
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 0f0178827259..ab1c08658528 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -317,7 +317,7 @@ void tcp_time_wait(struct sock *sk, int state, int timeo)
                        key = tp->af_specific->md5_lookup(sk, sk);
                        if (key != NULL) {
                                tcptw->tw_md5_key = kmemdup(key, sizeof(*key), GFP_ATOMIC);
-                                if (tcptw->tw_md5_key && tcp_alloc_md5sig_pool(sk) == NULL)
+                                if (tcptw->tw_md5_key && !tcp_alloc_md5sig_pool())
                                        BUG();
                        }
                } while (0);
@@ -358,10 +358,8 @@ void tcp_twsk_destructor(struct sock *sk)
 #ifdef CONFIG_TCP_MD5SIG
        struct tcp_timewait_sock *twsk = tcp_twsk(sk);
-        if (twsk->tw_md5_key) {
+        if (twsk->tw_md5_key)
-                tcp_free_md5sig_pool();
                kfree_rcu(twsk->tw_md5_key, rcu);
-        }
 #endif
 }
 EXPORT_SYMBOL_GPL(tcp_twsk_destructor);
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index d1ab6ab29a55..432e084b6b62 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -1126,8 +1126,7 @@ retry:
        ift = !max_addresses ||
              ipv6_count_addresses(idev) < max_addresses ?
-                ipv6_add_addr(idev, &addr, tmp_plen,
+                ipv6_add_addr(idev, &addr, tmp_plen, ipv6_addr_scope(&addr),
-                              ipv6_addr_type(&addr)&IPV6_ADDR_SCOPE_MASK,
                              addr_flags) : NULL;
        if (IS_ERR_OR_NULL(ift)) {
                in6_ifa_put(ifp);
@@ -2402,6 +2401,7 @@ err_exit:
 *      Manual configuration of address on an interface
 */
 static int inet6_addr_add(struct net *net, int ifindex, const struct in6_addr *pfx,
+                          const struct in6_addr *peer_pfx,
                          unsigned int plen, __u8 ifa_flags, __u32 prefered_lft,
                          __u32 valid_lft)
 {
@@ -2457,6 +2457,8 @@ static int inet6_addr_add(struct net *net, int ifindex, const struct in6_addr *p
                ifp->valid_lft = valid_lft;
                ifp->prefered_lft = prefered_lft;
                ifp->tstamp = jiffies;
+                if (peer_pfx)
+                        ifp->peer_addr = *peer_pfx;
                spin_unlock_bh(&ifp->lock);
                addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
@@ -2526,7 +2528,7 @@ int addrconf_add_ifaddr(struct net *net, void __user *arg)
                return -EFAULT;
        rtnl_lock();
-        err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr,
+        err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL,
                             ireq.ifr6_prefixlen, IFA_F_PERMANENT,
                             INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
        rtnl_unlock();
@@ -3610,18 +3612,20 @@ restart:
        rcu_read_unlock_bh();
 }
-static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local)
+static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local,
+                                     struct in6_addr **peer_pfx)
 {
        struct in6_addr *pfx = NULL;
+        *peer_pfx = NULL;
        if (addr)
                pfx = nla_data(addr);
        if (local) {
                if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
-                        pfx = NULL;
+                        *peer_pfx = pfx;
-                else
+                pfx = nla_data(local);
-                        pfx = nla_data(local);
        }
        return pfx;
@@ -3639,7 +3643,7 @@ inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
        struct net *net = sock_net(skb->sk);
        struct ifaddrmsg *ifm;
        struct nlattr *tb[IFA_MAX+1];
-        struct in6_addr *pfx;
+        struct in6_addr *pfx, *peer_pfx;
        int err;
        err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
@@ -3647,7 +3651,7 @@ inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
                return err;
        ifm = nlmsg_data(nlh);
-        pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]);
+        pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
        if (pfx == NULL)
                return -EINVAL;
@@ -3705,7 +3709,7 @@ inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
        struct net *net = sock_net(skb->sk);
        struct ifaddrmsg *ifm;
        struct nlattr *tb[IFA_MAX+1];
-        struct in6_addr *pfx;
+        struct in6_addr *pfx, *peer_pfx;
        struct inet6_ifaddr *ifa;
        struct net_device *dev;
        u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
@@ -3717,7 +3721,7 @@ inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
                return err;
        ifm = nlmsg_data(nlh);
-        pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]);
+        pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
        if (pfx == NULL)
                return -EINVAL;
@@ -3745,7 +3749,7 @@ inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
                 * It would be best to check for !NLM_F_CREATE here but
                 * userspace alreay relies on not having to provide this.
                 */
-                return inet6_addr_add(net, ifm->ifa_index, pfx,
+                return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx,
                                      ifm->ifa_prefixlen, ifa_flags,
                                      preferred_lft, valid_lft);
        }
@@ -3802,6 +3806,7 @@ static inline int rt_scope(int ifa_scope)
 static inline int inet6_ifaddr_msgsize(void)
 {
        return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
+               + nla_total_size(16) /* IFA_LOCAL */
               + nla_total_size(16) /* IFA_ADDRESS */
               + nla_total_size(sizeof(struct ifa_cacheinfo));
 }
@@ -3840,13 +3845,22 @@ static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
                valid = INFINITY_LIFE_TIME;
        }
-        if (nla_put(skb, IFA_ADDRESS, 16, &ifa->addr) < 0 ||
+        if (!ipv6_addr_any(&ifa->peer_addr)) {
-            put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0) {
+                if (nla_put(skb, IFA_LOCAL, 16, &ifa->addr) < 0 ||
-                nlmsg_cancel(skb, nlh);
+                    nla_put(skb, IFA_ADDRESS, 16, &ifa->peer_addr) < 0)
-                return -EMSGSIZE;
+                        goto error;
-        }
+        } else
+                if (nla_put(skb, IFA_ADDRESS, 16, &ifa->addr) < 0)
+                        goto error;
+        if (put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0)
+                goto error;
        return nlmsg_end(skb, nlh);
+error:
+        nlmsg_cancel(skb, nlh);
+        return -EMSGSIZE;
 }
 static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
@@ -4046,7 +4060,7 @@ static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh)
        struct net *net = sock_net(in_skb->sk);
        struct ifaddrmsg *ifm;
        struct nlattr *tb[IFA_MAX+1];
-        struct in6_addr *addr = NULL;
+        struct in6_addr *addr = NULL, *peer;
        struct net_device *dev = NULL;
        struct inet6_ifaddr *ifa;
        struct sk_buff *skb;
@@ -4056,7 +4070,7 @@ static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh)
        if (err < 0)
                goto errout;
-        addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL]);
+        addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
        if (addr == NULL) {
                err = -EINVAL;
                goto errout;
@@ -4564,11 +4578,26 @@ static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
                        ip6_ins_rt(ifp->rt);
                if (ifp->idev->cnf.forwarding)
                        addrconf_join_anycast(ifp);
+                if (!ipv6_addr_any(&ifp->peer_addr))
+                        addrconf_prefix_route(&ifp->peer_addr, 128,
+                                              ifp->idev->dev, 0, 0);
                break;
        case RTM_DELADDR:
                if (ifp->idev->cnf.forwarding)
                        addrconf_leave_anycast(ifp);
                addrconf_leave_solict(ifp->idev, &ifp->addr);
+                if (!ipv6_addr_any(&ifp->peer_addr)) {
+                        struct rt6_info *rt;
+                        struct net_device *dev = ifp->idev->dev;
+                        rt = rt6_lookup(dev_net(dev), &ifp->peer_addr, NULL,
+                                        dev->ifindex, 1);
+                        if (rt) {
+                                dst_hold(&rt->dst);
+                                if (ip6_del_rt(rt))
+                                        dst_free(&rt->dst);
+                        }
+                }
                dst_hold(&ifp->rt->dst);
                if (ip6_del_rt(ifp->rt))
diff --git a/net/sched/sch_tbf.c b/net/sched/sch_tbf.c
index c8388f3c3426..38008b0980d9 100644
--- a/net/sched/sch_tbf.c
+++ b/net/sched/sch_tbf.c
@@ -116,14 +116,57 @@ struct tbf_sched_data {
        struct qdisc_watchdog watchdog; /* Watchdog timer */
 };
+/* GSO packet is too big, segment it so that tbf can transmit
+ * each segment in time
+ */
+static int tbf_segment(struct sk_buff *skb, struct Qdisc *sch)
+{
+        struct tbf_sched_data *q = qdisc_priv(sch);
+        struct sk_buff *segs, *nskb;
+        netdev_features_t features = netif_skb_features(skb);
+        int ret, nb;
+        segs = skb_gso_segment(skb, features & ~NETIF_F_GSO_MASK);
+        if (IS_ERR_OR_NULL(segs))
+                return qdisc_reshape_fail(skb, sch);
+        nb = 0;
+        while (segs) {
+                nskb = segs->next;
+                segs->next = NULL;
+                if (likely(segs->len <= q->max_size)) {
+                        qdisc_skb_cb(segs)->pkt_len = segs->len;
+                        ret = qdisc_enqueue(segs, q->qdisc);
+                } else {
+                        ret = qdisc_reshape_fail(skb, sch);
+                }
+                if (ret != NET_XMIT_SUCCESS) {
+                        if (net_xmit_drop_count(ret))
+                                sch->qstats.drops++;
+                } else {
+                        nb++;
+                }
+                segs = nskb;
+        }
+        sch->q.qlen += nb;
+        if (nb > 1)
+                qdisc_tree_decrease_qlen(sch, 1 - nb);
+        consume_skb(skb);
+        return nb > 0 ? NET_XMIT_SUCCESS : NET_XMIT_DROP;
+}
 static int tbf_enqueue(struct sk_buff *skb, struct Qdisc *sch)
 {
        struct tbf_sched_data *q = qdisc_priv(sch);
        int ret;
-        if (qdisc_pkt_len(skb) > q->max_size)
+        if (qdisc_pkt_len(skb) > q->max_size) {
+                if (skb_is_gso(skb))
+                        return tbf_segment(skb, sch);
                return qdisc_reshape_fail(skb, sch);
+        }
        ret = qdisc_enqueue(skb, q->qdisc);
        if (ret != NET_XMIT_SUCCESS) {
                if (net_xmit_drop_count(ret))