Merge branch 'master' into for-next

118 files changed, 3135 insertions, 809 deletions

diff --git a/drivers/net/3c507.c b/drivers/net/3c507.c
index 82eaf65d2d85..ea9b7a098c9b 100644
--- a/drivers/net/3c507.c
+++ b/drivers/net/3c507.c
@@ -551,8 +551,7 @@ static irqreturn_t el16_interrupt(int irq, void *dev_id)
         void __iomem *shmem;
 
         if (dev == NULL) {
-                pr_err("%s: net_interrupt(): irq %d for unknown device.\n",
-                        dev->name, irq);
+                pr_err("net_interrupt(): irq %d for unknown device.\n", irq);
                 return IRQ_NONE;
         }
 
diff --git a/drivers/net/8139cp.c b/drivers/net/8139cp.c
index 9c149750e2bf..284a5f4a63ac 100644
--- a/drivers/net/8139cp.c
+++ b/drivers/net/8139cp.c
@@ -598,8 +598,8 @@ rx_next:
                         goto rx_status_loop;
 
                 spin_lock_irqsave(&cp->lock, flags);
-                cpw16_f(IntrMask, cp_intr_mask);
                 __napi_complete(napi);
+                cpw16_f(IntrMask, cp_intr_mask);
                 spin_unlock_irqrestore(&cp->lock, flags);
         }
 
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index 4ba72933f0da..97d8068b372b 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -860,6 +860,7 @@ retry:
                 }
 
         /* if unknown chip, assume array element #0, original RTL-8139 in this case */
+        i = 0;
         dev_dbg(&pdev->dev, "unknown chip version, assuming RTL-8139\n");
         dev_dbg(&pdev->dev, "TxConfig = 0x%lx\n", RTL_R32 (TxConfig));
         tp->chipset = 0;
@@ -2088,8 +2089,8 @@ static int rtl8139_poll(struct napi_struct *napi, int budget)
                  * again when we think we are done.
                  */
                 spin_lock_irqsave(&tp->lock, flags);
-                RTL_W16_F(IntrMask, rtl8139_intr_mask);
                 __napi_complete(napi);
+                RTL_W16_F(IntrMask, rtl8139_intr_mask);
                 spin_unlock_irqrestore(&tp->lock, flags);
         }
         spin_unlock(&tp->rx_lock);
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index 373c1a563474..b46be490cd2a 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -283,6 +283,8 @@ struct be_adapter {
         u8 port_type;
         u8 transceiver;
         u8 generation;          /* BladeEngine ASIC generation */
+        u32 flash_status;
+        struct completion flash_compl;
 
         bool sriov_enabled;
         u32 vf_if_handle[BE_MAX_VF];
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index e79bf8b9af3b..b9ad799c719f 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -59,6 +59,13 @@ static int be_mcc_compl_process(struct be_adapter *adapter,
 
         compl_status = (compl->status >> CQE_STATUS_COMPL_SHIFT) &
                                 CQE_STATUS_COMPL_MASK;
+
+        if ((compl->tag0 == OPCODE_COMMON_WRITE_FLASHROM) &&
+                (compl->tag1 == CMD_SUBSYSTEM_COMMON)) {
+                adapter->flash_status = compl_status;
+                complete(&adapter->flash_compl);
+        }
+
         if (compl_status == MCC_STATUS_SUCCESS) {
                 if (compl->tag0 == OPCODE_ETH_GET_STATISTICS) {
                         struct be_cmd_resp_get_stats *resp =
@@ -287,7 +294,7 @@ int be_cmd_POST(struct be_adapter *adapter)
                 } else {
                         return 0;
                 }
-        } while (timeout < 20);
+        } while (timeout < 40);
 
         dev_err(&adapter->pdev->dev, "POST timeout; stage=0x%x\n", stage);
         return -1;
@@ -1417,17 +1424,19 @@ int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd,
         int status;
 
         spin_lock_bh(&adapter->mcc_lock);
+        adapter->flash_status = 0;
 
         wrb = wrb_from_mccq(adapter);
         if (!wrb) {
                 status = -EBUSY;
-                goto err;
+                goto err_unlock;
         }
         req = cmd->va;
         sge = nonembedded_sgl(wrb);
 
         be_wrb_hdr_prepare(wrb, cmd->size, false, 1,
                         OPCODE_COMMON_WRITE_FLASHROM);
+        wrb->tag1 = CMD_SUBSYSTEM_COMMON;
 
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
                 OPCODE_COMMON_WRITE_FLASHROM, cmd->size);
@@ -1439,9 +1448,18 @@ int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd,
         req->params.op_code = cpu_to_le32(flash_opcode);
         req->params.data_buf_size = cpu_to_le32(buf_size);
 
-        status = be_mcc_notify_wait(adapter);
+        be_mcc_notify(adapter);
+        spin_unlock_bh(&adapter->mcc_lock);
 
-err:
+        if (!wait_for_completion_timeout(&adapter->flash_compl,
+                        msecs_to_jiffies(12000)))
+                status = -1;
+        else
+                status = adapter->flash_status;
+
+        return status;
+
+err_unlock:
         spin_unlock_bh(&adapter->mcc_lock);
         return status;
 }
@@ -1482,7 +1500,7 @@ err:
         return status;
 }
 
-extern int be_cmd_enable_magic_wol(struct be_adapter *adapter, u8 *mac,
+int be_cmd_enable_magic_wol(struct be_adapter *adapter, u8 *mac,
                                 struct be_dma_mem *nonemb_cmd)
 {
         struct be_mcc_wrb *wrb;
@@ -1575,7 +1593,7 @@ int be_cmd_loopback_test(struct be_adapter *adapter, u32 port_num,
 
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_LOWLEVEL,
                         OPCODE_LOWLEVEL_LOOPBACK_TEST, sizeof(*req));
-        req->hdr.timeout = 4;
+        req->hdr.timeout = cpu_to_le32(4);
 
         req->pattern = cpu_to_le64(pattern);
         req->src_port = cpu_to_le32(port_num);
@@ -1647,7 +1665,7 @@ err:
         return status;
 }
 
-extern int be_cmd_get_seeprom_data(struct be_adapter *adapter,
+int be_cmd_get_seeprom_data(struct be_adapter *adapter,
                                 struct be_dma_mem *nonemb_cmd)
 {
         struct be_mcc_wrb *wrb;
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 058d7f95f5ae..54b14272f333 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -1861,7 +1861,7 @@ static int be_setup(struct be_adapter *adapter)
                                 goto if_destroy;
                         }
                         vf++;
-                } while (vf < num_vfs);
+                }
         } else if (!be_physfn(adapter)) {
                 status = be_cmd_mac_addr_query(adapter, mac,
                         MAC_ADDRESS_TYPE_NETWORK, false, adapter->if_handle);
@@ -2319,6 +2319,7 @@ static int be_ctrl_init(struct be_adapter *adapter)
         spin_lock_init(&adapter->mcc_lock);
         spin_lock_init(&adapter->mcc_cq_lock);
 
+        init_completion(&adapter->flash_compl);
         pci_save_state(adapter->pdev);
         return 0;
 
@@ -2487,10 +2488,6 @@ static int __devinit be_probe(struct pci_dev *pdev,
                 status = be_cmd_POST(adapter);
                 if (status)
                         goto ctrl_clean;
-
-                status = be_cmd_reset_function(adapter);
-                if (status)
-                        goto ctrl_clean;
         }
 
         /* tell fw we're ready to fire cmds */
@@ -2498,6 +2495,12 @@ static int __devinit be_probe(struct pci_dev *pdev,
         if (status)
                 goto ctrl_clean;
 
+        if (be_physfn(adapter)) {
+                status = be_cmd_reset_function(adapter);
+                if (status)
+                        goto ctrl_clean;
+        }
+
         status = be_stats_init(adapter);
         if (status)
                 goto ctrl_clean;
diff --git a/drivers/net/bfin_mac.c b/drivers/net/bfin_mac.c
index 39a54bad397f..368f33313fb6 100644
--- a/drivers/net/bfin_mac.c
+++ b/drivers/net/bfin_mac.c
@@ -1626,6 +1626,7 @@ static int __devinit bfin_mii_bus_probe(struct platform_device *pdev)
         return 0;
 
 out_err_mdiobus_register:
+        kfree(miibus->irq);
         mdiobus_free(miibus);
 out_err_alloc:
         peripheral_free_list(pin_req);
@@ -1638,6 +1639,7 @@ static int __devexit bfin_mii_bus_remove(struct platform_device *pdev)
         struct mii_bus *miibus = platform_get_drvdata(pdev);
         platform_set_drvdata(pdev, NULL);
         mdiobus_unregister(miibus);
+        kfree(miibus->irq);
         mdiobus_free(miibus);
         peripheral_free_list(pin_req);
         return 0;
diff --git a/drivers/net/bmac.c b/drivers/net/bmac.c
index 39250b2ca886..959add2410bf 100644
--- a/drivers/net/bmac.c
+++ b/drivers/net/bmac.c
@@ -1654,8 +1654,11 @@ MODULE_DEVICE_TABLE (of, bmac_match);
 
 static struct macio_driver bmac_driver =
 {
-        .name           = "bmac",
-        .match_table    = bmac_match,
+        .driver = {
+                .name           = "bmac",
+                .owner          = THIS_MODULE,
+                .of_match_table = bmac_match,
+        },
         .probe          = bmac_probe,
         .remove         = bmac_remove,
 #ifdef CONFIG_PM
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 188e356c30a3..949d7a9dcf92 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -247,6 +247,7 @@ static const struct flash_spec flash_5709 = {
 MODULE_DEVICE_TABLE(pci, bnx2_pci_tbl);
 
 static void bnx2_init_napi(struct bnx2 *bp);
+static void bnx2_del_napi(struct bnx2 *bp);
 
 static inline u32 bnx2_tx_avail(struct bnx2 *bp, struct bnx2_tx_ring_info *txr)
 {
@@ -6270,6 +6271,7 @@ open_err:
         bnx2_free_skbs(bp);
         bnx2_free_irq(bp);
         bnx2_free_mem(bp);
+        bnx2_del_napi(bp);
         return rc;
 }
 
@@ -6537,6 +6539,7 @@ bnx2_close(struct net_device *dev)
         bnx2_free_irq(bp);
         bnx2_free_skbs(bp);
         bnx2_free_mem(bp);
+        bnx2_del_napi(bp);
         bp->link_up = 0;
         netif_carrier_off(bp->dev);
         bnx2_set_power_state(bp, PCI_D3hot);
@@ -8227,7 +8230,16 @@ bnx2_bus_string(struct bnx2 *bp, char *str)
         return str;
 }
 
-static void __devinit
+static void
+bnx2_del_napi(struct bnx2 *bp)
+{
+        int i;
+
+        for (i = 0; i < bp->irq_nvecs; i++)
+                netif_napi_del(&bp->bnx2_napi[i].napi);
+}
+
+static void
 bnx2_init_napi(struct bnx2 *bp)
 {
         int i;
diff --git a/drivers/net/can/Kconfig b/drivers/net/can/Kconfig
index 05b751719bd5..2c5227c02fa0 100644
--- a/drivers/net/can/Kconfig
+++ b/drivers/net/can/Kconfig
@@ -63,6 +63,16 @@ config CAN_BFIN
           To compile this driver as a module, choose M here: the
           module will be called bfin_can.
 
+config CAN_JANZ_ICAN3
+        tristate "Janz VMOD-ICAN3 Intelligent CAN controller"
+        depends on CAN_DEV && MFD_JANZ_CMODIO
+        ---help---
+          Driver for Janz VMOD-ICAN3 Intelligent CAN controller module, which
+          connects to a MODULbus carrier board.
+
+          This driver can also be built as a module. If so, the module will be
+          called janz-ican3.ko.
+
 source "drivers/net/can/mscan/Kconfig"
 
 source "drivers/net/can/sja1000/Kconfig"
diff --git a/drivers/net/can/Makefile b/drivers/net/can/Makefile
index 7a702f28d01c..9047cd066fea 100644
--- a/drivers/net/can/Makefile
+++ b/drivers/net/can/Makefile
@@ -15,5 +15,6 @@ obj-$(CONFIG_CAN_AT91)		+= at91_can.o
 obj-$(CONFIG_CAN_TI_HECC)       += ti_hecc.o
 obj-$(CONFIG_CAN_MCP251X)       += mcp251x.o
 obj-$(CONFIG_CAN_BFIN)          += bfin_can.o
+obj-$(CONFIG_CAN_JANZ_ICAN3)    += janz-ican3.o
 
 ccflags-$(CONFIG_CAN_DEBUG_DEVICES) := -DDEBUG
diff --git a/drivers/net/can/janz-ican3.c b/drivers/net/can/janz-ican3.c
new file mode 100644
index 000000000000..6e533dcc36c0
--- /dev/null
+++ b/drivers/net/can/janz-ican3.c
@@ -0,0 +1,1830 @@
+/*
+ * Janz MODULbus VMOD-ICAN3 CAN Interface Driver
+ *
+ * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+
+#include <linux/netdevice.h>
+#include <linux/can.h>
+#include <linux/can/dev.h>
+#include <linux/can/error.h>
+
+#include <linux/mfd/janz.h>
+
+/* the DPM has 64k of memory, organized into 256x 256 byte pages */
+#define DPM_NUM_PAGES           256
+#define DPM_PAGE_SIZE           256
+#define DPM_PAGE_ADDR(p)        ((p) * DPM_PAGE_SIZE)
+
+/* JANZ ICAN3 "old-style" host interface queue page numbers */
+#define QUEUE_OLD_CONTROL       0
+#define QUEUE_OLD_RB0           1
+#define QUEUE_OLD_RB1           2
+#define QUEUE_OLD_WB0           3
+#define QUEUE_OLD_WB1           4
+
+/* Janz ICAN3 "old-style" host interface control registers */
+#define MSYNC_PEER              0x00            /* ICAN only */
+#define MSYNC_LOCL              0x01            /* host only */
+#define TARGET_RUNNING          0x02
+
+#define MSYNC_RB0               0x01
+#define MSYNC_RB1               0x02
+#define MSYNC_RBLW              0x04
+#define MSYNC_RB_MASK           (MSYNC_RB0 | MSYNC_RB1)
+
+#define MSYNC_WB0               0x10
+#define MSYNC_WB1               0x20
+#define MSYNC_WBLW              0x40
+#define MSYNC_WB_MASK           (MSYNC_WB0 | MSYNC_WB1)
+
+/* Janz ICAN3 "new-style" host interface queue page numbers */
+#define QUEUE_TOHOST            5
+#define QUEUE_FROMHOST_MID      6
+#define QUEUE_FROMHOST_HIGH     7
+#define QUEUE_FROMHOST_LOW      8
+
+/* The first free page in the DPM is #9 */
+#define DPM_FREE_START          9
+
+/* Janz ICAN3 "new-style" and "fast" host interface descriptor flags */
+#define DESC_VALID              0x80
+#define DESC_WRAP               0x40
+#define DESC_INTERRUPT          0x20
+#define DESC_IVALID             0x10
+#define DESC_LEN(len)           (len)
+
+/* Janz ICAN3 Firmware Messages */
+#define MSG_CONNECTI            0x02
+#define MSG_DISCONNECT          0x03
+#define MSG_IDVERS              0x04
+#define MSG_MSGLOST             0x05
+#define MSG_NEWHOSTIF           0x08
+#define MSG_INQUIRY             0x0a
+#define MSG_SETAFILMASK         0x10
+#define MSG_INITFDPMQUEUE       0x11
+#define MSG_HWCONF              0x12
+#define MSG_FMSGLOST            0x15
+#define MSG_CEVTIND             0x37
+#define MSG_CBTRREQ             0x41
+#define MSG_COFFREQ             0x42
+#define MSG_CONREQ              0x43
+#define MSG_CCONFREQ            0x47
+
+/*
+ * Janz ICAN3 CAN Inquiry Message Types
+ *
+ * NOTE: there appears to be a firmware bug here. You must send
+ * NOTE: INQUIRY_STATUS and expect to receive an INQUIRY_EXTENDED
+ * NOTE: response. The controller never responds to a message with
+ * NOTE: the INQUIRY_EXTENDED subspec :(
+ */
+#define INQUIRY_STATUS          0x00
+#define INQUIRY_TERMINATION     0x01
+#define INQUIRY_EXTENDED        0x04
+
+/* Janz ICAN3 CAN Set Acceptance Filter Mask Message Types */
+#define SETAFILMASK_REJECT      0x00
+#define SETAFILMASK_FASTIF      0x02
+
+/* Janz ICAN3 CAN Hardware Configuration Message Types */
+#define HWCONF_TERMINATE_ON     0x01
+#define HWCONF_TERMINATE_OFF    0x00
+
+/* Janz ICAN3 CAN Event Indication Message Types */
+#define CEVTIND_EI              0x01
+#define CEVTIND_DOI             0x02
+#define CEVTIND_LOST            0x04
+#define CEVTIND_FULL            0x08
+#define CEVTIND_BEI             0x10
+
+#define CEVTIND_CHIP_SJA1000    0x02
+
+#define ICAN3_BUSERR_QUOTA_MAX  255
+
+/* Janz ICAN3 CAN Frame Conversion */
+#define ICAN3_ECHO      0x10
+#define ICAN3_EFF_RTR   0x40
+#define ICAN3_SFF_RTR   0x10
+#define ICAN3_EFF       0x80
+
+#define ICAN3_CAN_TYPE_MASK     0x0f
+#define ICAN3_CAN_TYPE_SFF      0x00
+#define ICAN3_CAN_TYPE_EFF      0x01
+
+#define ICAN3_CAN_DLC_MASK      0x0f
+
+/*
+ * SJA1000 Status and Error Register Definitions
+ *
+ * Copied from drivers/net/can/sja1000/sja1000.h
+ */
+
+/* status register content */
+#define SR_BS           0x80
+#define SR_ES           0x40
+#define SR_TS           0x20
+#define SR_RS           0x10
+#define SR_TCS          0x08
+#define SR_TBS          0x04
+#define SR_DOS          0x02
+#define SR_RBS          0x01
+
+#define SR_CRIT (SR_BS|SR_ES)
+
+/* ECC register */
+#define ECC_SEG         0x1F
+#define ECC_DIR         0x20
+#define ECC_ERR         6
+#define ECC_BIT         0x00
+#define ECC_FORM        0x40
+#define ECC_STUFF       0x80
+#define ECC_MASK        0xc0
+
+/* Number of buffers for use in the "new-style" host interface */
+#define ICAN3_NEW_BUFFERS       16
+
+/* Number of buffers for use in the "fast" host interface */
+#define ICAN3_TX_BUFFERS        512
+#define ICAN3_RX_BUFFERS        1024
+
+/* SJA1000 Clock Input */
+#define ICAN3_CAN_CLOCK         8000000
+
+/* Driver Name */
+#define DRV_NAME "janz-ican3"
+
+/* DPM Control Registers -- starts at offset 0x100 in the MODULbus registers */
+struct ican3_dpm_control {
+        /* window address register */
+        u8 window_address;
+        u8 unused1;
+
+        /*
+         * Read access: clear interrupt from microcontroller
+         * Write access: send interrupt to microcontroller
+         */
+        u8 interrupt;
+        u8 unused2;
+
+        /* write-only: reset all hardware on the module */
+        u8 hwreset;
+        u8 unused3;
+
+        /* write-only: generate an interrupt to the TPU */
+        u8 tpuinterrupt;
+};
+
+struct ican3_dev {
+
+        /* must be the first member */
+        struct can_priv can;
+
+        /* CAN network device */
+        struct net_device *ndev;
+        struct napi_struct napi;
+
+        /* Device for printing */
+        struct device *dev;
+
+        /* module number */
+        unsigned int num;
+
+        /* base address of registers and IRQ */
+        struct janz_cmodio_onboard_regs __iomem *ctrl;
+        struct ican3_dpm_control __iomem *dpmctrl;
+        void __iomem *dpm;
+        int irq;
+
+        /* CAN bus termination status */
+        struct completion termination_comp;
+        bool termination_enabled;
+
+        /* CAN bus error status registers */
+        struct completion buserror_comp;
+        struct can_berr_counter bec;
+
+        /* old and new style host interface */
+        unsigned int iftype;
+
+        /*
+         * Any function which changes the current DPM page must hold this
+         * lock while it is performing data accesses. This ensures that the
+         * function will not be preempted and end up reading data from a
+         * different DPM page than it expects.
+         */
+        spinlock_t lock;
+
+        /* new host interface */
+        unsigned int rx_int;
+        unsigned int rx_num;
+        unsigned int tx_num;
+
+        /* fast host interface */
+        unsigned int fastrx_start;
+        unsigned int fastrx_int;
+        unsigned int fastrx_num;
+        unsigned int fasttx_start;
+        unsigned int fasttx_num;
+
+        /* first free DPM page */
+        unsigned int free_page;
+};
+
+struct ican3_msg {
+        u8 control;
+        u8 spec;
+        __le16 len;
+        u8 data[252];
+};
+
+struct ican3_new_desc {
+        u8 control;
+        u8 pointer;
+};
+
+struct ican3_fast_desc {
+        u8 control;
+        u8 command;
+        u8 data[14];
+};
+
+/* write to the window basic address register */
+static inline void ican3_set_page(struct ican3_dev *mod, unsigned int page)
+{
+        BUG_ON(page >= DPM_NUM_PAGES);
+        iowrite8(page, &mod->dpmctrl->window_address);
+}
+
+/*
+ * ICAN3 "old-style" host interface
+ */
+
+/*
+ * Recieve a message from the ICAN3 "old-style" firmware interface
+ *
+ * LOCKING: must hold mod->lock
+ *
+ * returns 0 on success, -ENOMEM when no message exists
+ */
+static int ican3_old_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        unsigned int mbox, mbox_page;
+        u8 locl, peer, xord;
+
+        /* get the MSYNC registers */
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        peer = ioread8(mod->dpm + MSYNC_PEER);
+        locl = ioread8(mod->dpm + MSYNC_LOCL);
+        xord = locl ^ peer;
+
+        if ((xord & MSYNC_RB_MASK) == 0x00) {
+                dev_dbg(mod->dev, "no mbox for reading\n");
+                return -ENOMEM;
+        }
+
+        /* find the first free mbox to read */
+        if ((xord & MSYNC_RB_MASK) == MSYNC_RB_MASK)
+                mbox = (xord & MSYNC_RBLW) ? MSYNC_RB0 : MSYNC_RB1;
+        else
+                mbox = (xord & MSYNC_RB0) ? MSYNC_RB0 : MSYNC_RB1;
+
+        /* copy the message */
+        mbox_page = (mbox == MSYNC_RB0) ? QUEUE_OLD_RB0 : QUEUE_OLD_RB1;
+        ican3_set_page(mod, mbox_page);
+        memcpy_fromio(msg, mod->dpm, sizeof(*msg));
+
+        /*
+         * notify the firmware that the read buffer is available
+         * for it to fill again
+         */
+        locl ^= mbox;
+
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        iowrite8(locl, mod->dpm + MSYNC_LOCL);
+        return 0;
+}
+
+/*
+ * Send a message through the "old-style" firmware interface
+ *
+ * LOCKING: must hold mod->lock
+ *
+ * returns 0 on success, -ENOMEM when no free space exists
+ */
+static int ican3_old_send_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        unsigned int mbox, mbox_page;
+        u8 locl, peer, xord;
+
+        /* get the MSYNC registers */
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        peer = ioread8(mod->dpm + MSYNC_PEER);
+        locl = ioread8(mod->dpm + MSYNC_LOCL);
+        xord = locl ^ peer;
+
+        if ((xord & MSYNC_WB_MASK) == MSYNC_WB_MASK) {
+                dev_err(mod->dev, "no mbox for writing\n");
+                return -ENOMEM;
+        }
+
+        /* calculate a free mbox to use */
+        mbox = (xord & MSYNC_WB0) ? MSYNC_WB1 : MSYNC_WB0;
+
+        /* copy the message to the DPM */
+        mbox_page = (mbox == MSYNC_WB0) ? QUEUE_OLD_WB0 : QUEUE_OLD_WB1;
+        ican3_set_page(mod, mbox_page);
+        memcpy_toio(mod->dpm, msg, sizeof(*msg));
+
+        locl ^= mbox;
+        if (mbox == MSYNC_WB1)
+                locl |= MSYNC_WBLW;
+
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        iowrite8(locl, mod->dpm + MSYNC_LOCL);
+        return 0;
+}
+
+/*
+ * ICAN3 "new-style" Host Interface Setup
+ */
+
+static void __devinit ican3_init_new_host_interface(struct ican3_dev *mod)
+{
+        struct ican3_new_desc desc;
+        unsigned long flags;
+        void __iomem *dst;
+        int i;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* setup the internal datastructures for RX */
+        mod->rx_num = 0;
+        mod->rx_int = 0;
+
+        /* tohost queue descriptors are in page 5 */
+        ican3_set_page(mod, QUEUE_TOHOST);
+        dst = mod->dpm;
+
+        /* initialize the tohost (rx) queue descriptors: pages 9-24 */
+        for (i = 0; i < ICAN3_NEW_BUFFERS; i++) {
+                desc.control = DESC_INTERRUPT | DESC_LEN(1); /* I L=1 */
+                desc.pointer = mod->free_page;
+
+                /* set wrap flag on last buffer */
+                if (i == ICAN3_NEW_BUFFERS - 1)
+                        desc.control |= DESC_WRAP;
+
+                memcpy_toio(dst, &desc, sizeof(desc));
+                dst += sizeof(desc);
+                mod->free_page++;
+        }
+
+        /* fromhost (tx) mid queue descriptors are in page 6 */
+        ican3_set_page(mod, QUEUE_FROMHOST_MID);
+        dst = mod->dpm;
+
+        /* setup the internal datastructures for TX */
+        mod->tx_num = 0;
+
+        /* initialize the fromhost mid queue descriptors: pages 25-40 */
+        for (i = 0; i < ICAN3_NEW_BUFFERS; i++) {
+                desc.control = DESC_VALID | DESC_LEN(1); /* V L=1 */
+                desc.pointer = mod->free_page;
+
+                /* set wrap flag on last buffer */
+                if (i == ICAN3_NEW_BUFFERS - 1)
+                        desc.control |= DESC_WRAP;
+
+                memcpy_toio(dst, &desc, sizeof(desc));
+                dst += sizeof(desc);
+                mod->free_page++;
+        }
+
+        /* fromhost hi queue descriptors are in page 7 */
+        ican3_set_page(mod, QUEUE_FROMHOST_HIGH);
+        dst = mod->dpm;
+
+        /* initialize only a single buffer in the fromhost hi queue (unused) */
+        desc.control = DESC_VALID | DESC_WRAP | DESC_LEN(1); /* VW L=1 */
+        desc.pointer = mod->free_page;
+        memcpy_toio(dst, &desc, sizeof(desc));
+        mod->free_page++;
+
+        /* fromhost low queue descriptors are in page 8 */
+        ican3_set_page(mod, QUEUE_FROMHOST_LOW);
+        dst = mod->dpm;
+
+        /* initialize only a single buffer in the fromhost low queue (unused) */
+        desc.control = DESC_VALID | DESC_WRAP | DESC_LEN(1); /* VW L=1 */
+        desc.pointer = mod->free_page;
+        memcpy_toio(dst, &desc, sizeof(desc));
+        mod->free_page++;
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+}
+
+/*
+ * ICAN3 Fast Host Interface Setup
+ */
+
+static void __devinit ican3_init_fast_host_interface(struct ican3_dev *mod)
+{
+        struct ican3_fast_desc desc;
+        unsigned long flags;
+        unsigned int addr;
+        void __iomem *dst;
+        int i;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* save the start recv page */
+        mod->fastrx_start = mod->free_page;
+        mod->fastrx_num = 0;
+        mod->fastrx_int = 0;
+
+        /* build a single fast tohost queue descriptor */
+        memset(&desc, 0, sizeof(desc));
+        desc.control = 0x00;
+        desc.command = 1;
+
+        /* build the tohost queue descriptor ring in memory */
+        addr = 0;
+        for (i = 0; i < ICAN3_RX_BUFFERS; i++) {
+
+                /* set the wrap bit on the last buffer */
+                if (i == ICAN3_RX_BUFFERS - 1)
+                        desc.control |= DESC_WRAP;
+
+                /* switch to the correct page */
+                ican3_set_page(mod, mod->free_page);
+
+                /* copy the descriptor to the DPM */
+                dst = mod->dpm + addr;
+                memcpy_toio(dst, &desc, sizeof(desc));
+                addr += sizeof(desc);
+
+                /* move to the next page if necessary */
+                if (addr >= DPM_PAGE_SIZE) {
+                        addr = 0;
+                        mod->free_page++;
+                }
+        }
+
+        /* make sure we page-align the next queue */
+        if (addr != 0)
+                mod->free_page++;
+
+        /* save the start xmit page */
+        mod->fasttx_start = mod->free_page;
+        mod->fasttx_num = 0;
+
+        /* build a single fast fromhost queue descriptor */
+        memset(&desc, 0, sizeof(desc));
+        desc.control = DESC_VALID;
+        desc.command = 1;
+
+        /* build the fromhost queue descriptor ring in memory */
+        addr = 0;
+        for (i = 0; i < ICAN3_TX_BUFFERS; i++) {
+
+                /* set the wrap bit on the last buffer */
+                if (i == ICAN3_TX_BUFFERS - 1)
+                        desc.control |= DESC_WRAP;
+
+                /* switch to the correct page */
+                ican3_set_page(mod, mod->free_page);
+
+                /* copy the descriptor to the DPM */
+                dst = mod->dpm + addr;
+                memcpy_toio(dst, &desc, sizeof(desc));
+                addr += sizeof(desc);
+
+                /* move to the next page if necessary */
+                if (addr >= DPM_PAGE_SIZE) {
+                        addr = 0;
+                        mod->free_page++;
+                }
+        }
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+}
+
+/*
+ * ICAN3 "new-style" Host Interface Message Helpers
+ */
+
+/*
+ * LOCKING: must hold mod->lock
+ */
+static int ican3_new_send_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        struct ican3_new_desc desc;
+        void __iomem *desc_addr = mod->dpm + (mod->tx_num * sizeof(desc));
+
+        /* switch to the fromhost mid queue, and read the buffer descriptor */
+        ican3_set_page(mod, QUEUE_FROMHOST_MID);
+        memcpy_fromio(&desc, desc_addr, sizeof(desc));
+
+        if (!(desc.control & DESC_VALID)) {
+                dev_dbg(mod->dev, "%s: no free buffers\n", __func__);
+                return -ENOMEM;
+        }
+
+        /* switch to the data page, copy the data */
+        ican3_set_page(mod, desc.pointer);
+        memcpy_toio(mod->dpm, msg, sizeof(*msg));
+
+        /* switch back to the descriptor, set the valid bit, write it back */
+        ican3_set_page(mod, QUEUE_FROMHOST_MID);
+        desc.control ^= DESC_VALID;
+        memcpy_toio(desc_addr, &desc, sizeof(desc));
+
+        /* update the tx number */
+        mod->tx_num = (desc.control & DESC_WRAP) ? 0 : (mod->tx_num + 1);
+        return 0;
+}
+
+/*
+ * LOCKING: must hold mod->lock
+ */
+static int ican3_new_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        struct ican3_new_desc desc;
+        void __iomem *desc_addr = mod->dpm + (mod->rx_num * sizeof(desc));
+
+        /* switch to the tohost queue, and read the buffer descriptor */
+        ican3_set_page(mod, QUEUE_TOHOST);
+        memcpy_fromio(&desc, desc_addr, sizeof(desc));
+
+        if (!(desc.control & DESC_VALID)) {
+                dev_dbg(mod->dev, "%s: no buffers to recv\n", __func__);
+                return -ENOMEM;
+        }
+
+        /* switch to the data page, copy the data */
+        ican3_set_page(mod, desc.pointer);
+        memcpy_fromio(msg, mod->dpm, sizeof(*msg));
+
+        /* switch back to the descriptor, toggle the valid bit, write it back */
+        ican3_set_page(mod, QUEUE_TOHOST);
+        desc.control ^= DESC_VALID;
+        memcpy_toio(desc_addr, &desc, sizeof(desc));
+
+        /* update the rx number */
+        mod->rx_num = (desc.control & DESC_WRAP) ? 0 : (mod->rx_num + 1);
+        return 0;
+}
+
+/*
+ * Message Send / Recv Helpers
+ */
+
+static int ican3_send_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        if (mod->iftype == 0)
+                ret = ican3_old_send_msg(mod, msg);
+        else
+                ret = ican3_new_send_msg(mod, msg);
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+        return ret;
+}
+
+static int ican3_recv_msg(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        if (mod->iftype == 0)
+                ret = ican3_old_recv_msg(mod, msg);
+        else
+                ret = ican3_new_recv_msg(mod, msg);
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+        return ret;
+}
+
+/*
+ * Quick Pre-constructed Messages
+ */
+
+static int __devinit ican3_msg_connect(struct ican3_dev *mod)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_CONNECTI;
+        msg.len = cpu_to_le16(0);
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int __devexit ican3_msg_disconnect(struct ican3_dev *mod)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_DISCONNECT;
+        msg.len = cpu_to_le16(0);
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int __devinit ican3_msg_newhostif(struct ican3_dev *mod)
+{
+        struct ican3_msg msg;
+        int ret;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_NEWHOSTIF;
+        msg.len = cpu_to_le16(0);
+
+        /* If we're not using the old interface, switching seems bogus */
+        WARN_ON(mod->iftype != 0);
+
+        ret = ican3_send_msg(mod, &msg);
+        if (ret)
+                return ret;
+
+        /* mark the module as using the new host interface */
+        mod->iftype = 1;
+        return 0;
+}
+
+static int __devinit ican3_msg_fasthostif(struct ican3_dev *mod)
+{
+        struct ican3_msg msg;
+        unsigned int addr;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_INITFDPMQUEUE;
+        msg.len = cpu_to_le16(8);
+
+        /* write the tohost queue start address */
+        addr = DPM_PAGE_ADDR(mod->fastrx_start);
+        msg.data[0] = addr & 0xff;
+        msg.data[1] = (addr >> 8) & 0xff;
+        msg.data[2] = (addr >> 16) & 0xff;
+        msg.data[3] = (addr >> 24) & 0xff;
+
+        /* write the fromhost queue start address */
+        addr = DPM_PAGE_ADDR(mod->fasttx_start);
+        msg.data[4] = addr & 0xff;
+        msg.data[5] = (addr >> 8) & 0xff;
+        msg.data[6] = (addr >> 16) & 0xff;
+        msg.data[7] = (addr >> 24) & 0xff;
+
+        /* If we're not using the new interface yet, we cannot do this */
+        WARN_ON(mod->iftype != 1);
+
+        return ican3_send_msg(mod, &msg);
+}
+
+/*
+ * Setup the CAN filter to either accept or reject all
+ * messages from the CAN bus.
+ */
+static int __devinit ican3_set_id_filter(struct ican3_dev *mod, bool accept)
+{
+        struct ican3_msg msg;
+        int ret;
+
+        /* Standard Frame Format */
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_SETAFILMASK;
+        msg.len = cpu_to_le16(5);
+        msg.data[0] = 0x00; /* IDLo LSB */
+        msg.data[1] = 0x00; /* IDLo MSB */
+        msg.data[2] = 0xff; /* IDHi LSB */
+        msg.data[3] = 0x07; /* IDHi MSB */
+
+        /* accept all frames for fast host if, or reject all frames */
+        msg.data[4] = accept ? SETAFILMASK_FASTIF : SETAFILMASK_REJECT;
+
+        ret = ican3_send_msg(mod, &msg);
+        if (ret)
+                return ret;
+
+        /* Extended Frame Format */
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_SETAFILMASK;
+        msg.len = cpu_to_le16(13);
+        msg.data[0] = 0;    /* MUX = 0 */
+        msg.data[1] = 0x00; /* IDLo LSB */
+        msg.data[2] = 0x00;
+        msg.data[3] = 0x00;
+        msg.data[4] = 0x20; /* IDLo MSB */
+        msg.data[5] = 0xff; /* IDHi LSB */
+        msg.data[6] = 0xff;
+        msg.data[7] = 0xff;
+        msg.data[8] = 0x3f; /* IDHi MSB */
+
+        /* accept all frames for fast host if, or reject all frames */
+        msg.data[9] = accept ? SETAFILMASK_FASTIF : SETAFILMASK_REJECT;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+/*
+ * Bring the CAN bus online or offline
+ */
+static int ican3_set_bus_state(struct ican3_dev *mod, bool on)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = on ? MSG_CONREQ : MSG_COFFREQ;
+        msg.len = cpu_to_le16(0);
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int ican3_set_termination(struct ican3_dev *mod, bool on)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_HWCONF;
+        msg.len = cpu_to_le16(2);
+        msg.data[0] = 0x00;
+        msg.data[1] = on ? HWCONF_TERMINATE_ON : HWCONF_TERMINATE_OFF;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int ican3_send_inquiry(struct ican3_dev *mod, u8 subspec)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_INQUIRY;
+        msg.len = cpu_to_le16(2);
+        msg.data[0] = subspec;
+        msg.data[1] = 0x00;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int ican3_set_buserror(struct ican3_dev *mod, u8 quota)
+{
+        struct ican3_msg msg;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_CCONFREQ;
+        msg.len = cpu_to_le16(2);
+        msg.data[0] = 0x00;
+        msg.data[1] = quota;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+/*
+ * ICAN3 to Linux CAN Frame Conversion
+ */
+
+static void ican3_to_can_frame(struct ican3_dev *mod,
+                               struct ican3_fast_desc *desc,
+                               struct can_frame *cf)
+{
+        if ((desc->command & ICAN3_CAN_TYPE_MASK) == ICAN3_CAN_TYPE_SFF) {
+                if (desc->data[1] & ICAN3_SFF_RTR)
+                        cf->can_id |= CAN_RTR_FLAG;
+
+                cf->can_id |= desc->data[0] << 3;
+                cf->can_id |= (desc->data[1] & 0xe0) >> 5;
+                cf->can_dlc = desc->data[1] & ICAN3_CAN_DLC_MASK;
+                memcpy(cf->data, &desc->data[2], sizeof(cf->data));
+        } else {
+                cf->can_dlc = desc->data[0] & ICAN3_CAN_DLC_MASK;
+                if (desc->data[0] & ICAN3_EFF_RTR)
+                        cf->can_id |= CAN_RTR_FLAG;
+
+                if (desc->data[0] & ICAN3_EFF) {
+                        cf->can_id |= CAN_EFF_FLAG;
+                        cf->can_id |= desc->data[2] << 21; /* 28-21 */
+                        cf->can_id |= desc->data[3] << 13; /* 20-13 */
+                        cf->can_id |= desc->data[4] << 5;  /* 12-5  */
+                        cf->can_id |= (desc->data[5] & 0xf8) >> 3;
+                } else {
+                        cf->can_id |= desc->data[2] << 3;  /* 10-3  */
+                        cf->can_id |= desc->data[3] >> 5;  /* 2-0   */
+                }
+
+                memcpy(cf->data, &desc->data[6], sizeof(cf->data));
+        }
+}
+
+static void can_frame_to_ican3(struct ican3_dev *mod,
+                               struct can_frame *cf,
+                               struct ican3_fast_desc *desc)
+{
+        /* clear out any stale data in the descriptor */
+        memset(desc->data, 0, sizeof(desc->data));
+
+        /* we always use the extended format, with the ECHO flag set */
+        desc->command = ICAN3_CAN_TYPE_EFF;
+        desc->data[0] |= cf->can_dlc;
+        desc->data[1] |= ICAN3_ECHO;
+
+        if (cf->can_id & CAN_RTR_FLAG)
+                desc->data[0] |= ICAN3_EFF_RTR;
+
+        /* pack the id into the correct places */
+        if (cf->can_id & CAN_EFF_FLAG) {
+                desc->data[0] |= ICAN3_EFF;
+                desc->data[2] = (cf->can_id & 0x1fe00000) >> 21; /* 28-21 */
+                desc->data[3] = (cf->can_id & 0x001fe000) >> 13; /* 20-13 */
+                desc->data[4] = (cf->can_id & 0x00001fe0) >> 5;  /* 12-5  */
+                desc->data[5] = (cf->can_id & 0x0000001f) << 3;  /* 4-0   */
+        } else {
+                desc->data[2] = (cf->can_id & 0x7F8) >> 3; /* bits 10-3 */
+                desc->data[3] = (cf->can_id & 0x007) << 5; /* bits 2-0  */
+        }
+
+        /* copy the data bits into the descriptor */
+        memcpy(&desc->data[6], cf->data, sizeof(cf->data));
+}
+
+/*
+ * Interrupt Handling
+ */
+
+/*
+ * Handle an ID + Version message response from the firmware. We never generate
+ * this message in production code, but it is very useful when debugging to be
+ * able to display this message.
+ */
+static void ican3_handle_idvers(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        dev_dbg(mod->dev, "IDVERS response: %s\n", msg->data);
+}
+
+static void ican3_handle_msglost(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        struct net_device *dev = mod->ndev;
+        struct net_device_stats *stats = &dev->stats;
+        struct can_frame *cf;
+        struct sk_buff *skb;
+
+        /*
+         * Report that communication messages with the microcontroller firmware
+         * are being lost. These are never CAN frames, so we do not generate an
+         * error frame for userspace
+         */
+        if (msg->spec == MSG_MSGLOST) {
+                dev_err(mod->dev, "lost %d control messages\n", msg->data[0]);
+                return;
+        }
+
+        /*
+         * Oops, this indicates that we have lost messages in the fast queue,
+         * which are exclusively CAN messages. Our driver isn't reading CAN
+         * frames fast enough.
+         *
+         * We'll pretend that the SJA1000 told us that it ran out of buffer
+         * space, because there is not a better message for this.
+         */
+        skb = alloc_can_err_skb(dev, &cf);
+        if (skb) {
+                cf->can_id |= CAN_ERR_CRTL;
+                cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
+                stats->rx_errors++;
+                stats->rx_bytes += cf->can_dlc;
+                netif_rx(skb);
+        }
+}
+
+/*
+ * Handle CAN Event Indication Messages from the firmware
+ *
+ * The ICAN3 firmware provides the values of some SJA1000 registers when it
+ * generates this message. The code below is largely copied from the
+ * drivers/net/can/sja1000/sja1000.c file, and adapted as necessary
+ */
+static int ican3_handle_cevtind(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        struct net_device *dev = mod->ndev;
+        struct net_device_stats *stats = &dev->stats;
+        enum can_state state = mod->can.state;
+        u8 status, isrc, rxerr, txerr;
+        struct can_frame *cf;
+        struct sk_buff *skb;
+
+        /* we can only handle the SJA1000 part */
+        if (msg->data[1] != CEVTIND_CHIP_SJA1000) {
+                dev_err(mod->dev, "unable to handle errors on non-SJA1000\n");
+                return -ENODEV;
+        }
+
+        /* check the message length for sanity */
+        if (le16_to_cpu(msg->len) < 6) {
+                dev_err(mod->dev, "error message too short\n");
+                return -EINVAL;
+        }
+
+        skb = alloc_can_err_skb(dev, &cf);
+        if (skb == NULL)
+                return -ENOMEM;
+
+        isrc = msg->data[0];
+        status = msg->data[3];
+        rxerr = msg->data[4];
+        txerr = msg->data[5];
+
+        /* data overrun interrupt */
+        if (isrc == CEVTIND_DOI || isrc == CEVTIND_LOST) {
+                dev_dbg(mod->dev, "data overrun interrupt\n");
+                cf->can_id |= CAN_ERR_CRTL;
+                cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
+                stats->rx_over_errors++;
+                stats->rx_errors++;
+        }
+
+        /* error warning + passive interrupt */
+        if (isrc == CEVTIND_EI) {
+                dev_dbg(mod->dev, "error warning + passive interrupt\n");
+                if (status & SR_BS) {
+                        state = CAN_STATE_BUS_OFF;
+                        cf->can_id |= CAN_ERR_BUSOFF;
+                        can_bus_off(dev);
+                } else if (status & SR_ES) {
+                        if (rxerr >= 128 || txerr >= 128)
+                                state = CAN_STATE_ERROR_PASSIVE;
+                        else
+                                state = CAN_STATE_ERROR_WARNING;
+                } else {
+                        state = CAN_STATE_ERROR_ACTIVE;
+                }
+        }
+
+        /* bus error interrupt */
+        if (isrc == CEVTIND_BEI) {
+                u8 ecc = msg->data[2];
+
+                dev_dbg(mod->dev, "bus error interrupt\n");
+                mod->can.can_stats.bus_error++;
+                stats->rx_errors++;
+                cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
+
+                switch (ecc & ECC_MASK) {
+                case ECC_BIT:
+                        cf->data[2] |= CAN_ERR_PROT_BIT;
+                        break;
+                case ECC_FORM:
+                        cf->data[2] |= CAN_ERR_PROT_FORM;
+                        break;
+                case ECC_STUFF:
+                        cf->data[2] |= CAN_ERR_PROT_STUFF;
+                        break;
+                default:
+                        cf->data[2] |= CAN_ERR_PROT_UNSPEC;
+                        cf->data[3] = ecc & ECC_SEG;
+                        break;
+                }
+
+                if ((ecc & ECC_DIR) == 0)
+                        cf->data[2] |= CAN_ERR_PROT_TX;
+
+                cf->data[6] = txerr;
+                cf->data[7] = rxerr;
+        }
+
+        if (state != mod->can.state && (state == CAN_STATE_ERROR_WARNING ||
+                                        state == CAN_STATE_ERROR_PASSIVE)) {
+                cf->can_id |= CAN_ERR_CRTL;
+                if (state == CAN_STATE_ERROR_WARNING) {
+                        mod->can.can_stats.error_warning++;
+                        cf->data[1] = (txerr > rxerr) ?
+                                CAN_ERR_CRTL_TX_WARNING :
+                                CAN_ERR_CRTL_RX_WARNING;
+                } else {
+                        mod->can.can_stats.error_passive++;
+                        cf->data[1] = (txerr > rxerr) ?
+                                CAN_ERR_CRTL_TX_PASSIVE :
+                                CAN_ERR_CRTL_RX_PASSIVE;
+                }
+
+                cf->data[6] = txerr;
+                cf->data[7] = rxerr;
+        }
+
+        mod->can.state = state;
+        stats->rx_errors++;
+        stats->rx_bytes += cf->can_dlc;
+        netif_rx(skb);
+        return 0;
+}
+
+static void ican3_handle_inquiry(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        switch (msg->data[0]) {
+        case INQUIRY_STATUS:
+        case INQUIRY_EXTENDED:
+                mod->bec.rxerr = msg->data[5];
+                mod->bec.txerr = msg->data[6];
+                complete(&mod->buserror_comp);
+                break;
+        case INQUIRY_TERMINATION:
+                mod->termination_enabled = msg->data[6] & HWCONF_TERMINATE_ON;
+                complete(&mod->termination_comp);
+                break;
+        default:
+                dev_err(mod->dev, "recieved an unknown inquiry response\n");
+                break;
+        }
+}
+
+static void ican3_handle_unknown_message(struct ican3_dev *mod,
+                                        struct ican3_msg *msg)
+{
+        dev_warn(mod->dev, "recieved unknown message: spec 0x%.2x length %d\n",
+                           msg->spec, le16_to_cpu(msg->len));
+}
+
+/*
+ * Handle a control message from the firmware
+ */
+static void ican3_handle_message(struct ican3_dev *mod, struct ican3_msg *msg)
+{
+        dev_dbg(mod->dev, "%s: modno %d spec 0x%.2x len %d bytes\n", __func__,
+                           mod->num, msg->spec, le16_to_cpu(msg->len));
+
+        switch (msg->spec) {
+        case MSG_IDVERS:
+                ican3_handle_idvers(mod, msg);
+                break;
+        case MSG_MSGLOST:
+        case MSG_FMSGLOST:
+                ican3_handle_msglost(mod, msg);
+                break;
+        case MSG_CEVTIND:
+                ican3_handle_cevtind(mod, msg);
+                break;
+        case MSG_INQUIRY:
+                ican3_handle_inquiry(mod, msg);
+                break;
+        default:
+                ican3_handle_unknown_message(mod, msg);
+                break;
+        }
+}
+
+/*
+ * Check that there is room in the TX ring to transmit another skb
+ *
+ * LOCKING: must hold mod->lock
+ */
+static bool ican3_txok(struct ican3_dev *mod)
+{
+        struct ican3_fast_desc __iomem *desc;
+        u8 control;
+
+        /* copy the control bits of the descriptor */
+        ican3_set_page(mod, mod->fasttx_start + (mod->fasttx_num / 16));
+        desc = mod->dpm + ((mod->fasttx_num % 16) * sizeof(*desc));
+        control = ioread8(&desc->control);
+
+        /* if the control bits are not valid, then we have no more space */
+        if (!(control & DESC_VALID))
+                return false;
+
+        return true;
+}
+
+/*
+ * Recieve one CAN frame from the hardware
+ *
+ * This works like the core of a NAPI function, but is intended to be called
+ * from workqueue context instead. This driver already needs a workqueue to
+ * process control messages, so we use the workqueue instead of using NAPI.
+ * This was done to simplify locking.
+ *
+ * CONTEXT: must be called from user context
+ */
+static int ican3_recv_skb(struct ican3_dev *mod)
+{
+        struct net_device *ndev = mod->ndev;
+        struct net_device_stats *stats = &ndev->stats;
+        struct ican3_fast_desc desc;
+        void __iomem *desc_addr;
+        struct can_frame *cf;
+        struct sk_buff *skb;
+        unsigned long flags;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* copy the whole descriptor */
+        ican3_set_page(mod, mod->fastrx_start + (mod->fastrx_num / 16));
+        desc_addr = mod->dpm + ((mod->fastrx_num % 16) * sizeof(desc));
+        memcpy_fromio(&desc, desc_addr, sizeof(desc));
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+
+        /* check that we actually have a CAN frame */
+        if (!(desc.control & DESC_VALID))
+                return -ENOBUFS;
+
+        /* allocate an skb */
+        skb = alloc_can_skb(ndev, &cf);
+        if (unlikely(skb == NULL)) {
+                stats->rx_dropped++;
+                goto err_noalloc;
+        }
+
+        /* convert the ICAN3 frame into Linux CAN format */
+        ican3_to_can_frame(mod, &desc, cf);
+
+        /* receive the skb, update statistics */
+        netif_receive_skb(skb);
+        stats->rx_packets++;
+        stats->rx_bytes += cf->can_dlc;
+
+err_noalloc:
+        /* toggle the valid bit and return the descriptor to the ring */
+        desc.control ^= DESC_VALID;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        ican3_set_page(mod, mod->fastrx_start + (mod->fastrx_num / 16));
+        memcpy_toio(desc_addr, &desc, 1);
+
+        /* update the next buffer pointer */
+        mod->fastrx_num = (desc.control & DESC_WRAP) ? 0
+                                                     : (mod->fastrx_num + 1);
+
+        /* there are still more buffers to process */
+        spin_unlock_irqrestore(&mod->lock, flags);
+        return 0;
+}
+
+static int ican3_napi(struct napi_struct *napi, int budget)
+{
+        struct ican3_dev *mod = container_of(napi, struct ican3_dev, napi);
+        struct ican3_msg msg;
+        unsigned long flags;
+        int received = 0;
+        int ret;
+
+        /* process all communication messages */
+        while (true) {
+                ret = ican3_recv_msg(mod, &msg);
+                if (ret)
+                        break;
+
+                ican3_handle_message(mod, &msg);
+        }
+
+        /* process all CAN frames from the fast interface */
+        while (received < budget) {
+                ret = ican3_recv_skb(mod);
+                if (ret)
+                        break;
+
+                received++;
+        }
+
+        /* We have processed all packets that the adapter had, but it
+         * was less than our budget, stop polling */
+        if (received < budget)
+                napi_complete(napi);
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* Wake up the transmit queue if necessary */
+        if (netif_queue_stopped(mod->ndev) && ican3_txok(mod))
+                netif_wake_queue(mod->ndev);
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+
+        /* re-enable interrupt generation */
+        iowrite8(1 << mod->num, &mod->ctrl->int_enable);
+        return received;
+}
+
+static irqreturn_t ican3_irq(int irq, void *dev_id)
+{
+        struct ican3_dev *mod = dev_id;
+        u8 stat;
+
+        /*
+         * The interrupt status register on this device reports interrupts
+         * as zeroes instead of using ones like most other devices
+         */
+        stat = ioread8(&mod->ctrl->int_disable) & (1 << mod->num);
+        if (stat == (1 << mod->num))
+                return IRQ_NONE;
+
+        /* clear the MODULbus interrupt from the microcontroller */
+        ioread8(&mod->dpmctrl->interrupt);
+
+        /* disable interrupt generation, schedule the NAPI poller */
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+        napi_schedule(&mod->napi);
+        return IRQ_HANDLED;
+}
+
+/*
+ * Firmware reset, startup, and shutdown
+ */
+
+/*
+ * Reset an ICAN module to its power-on state
+ *
+ * CONTEXT: no network device registered
+ * LOCKING: work function disabled
+ */
+static int ican3_reset_module(struct ican3_dev *mod)
+{
+        u8 val = 1 << mod->num;
+        unsigned long start;
+        u8 runold, runnew;
+
+        /* disable interrupts so no more work is scheduled */
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+
+        /* flush any pending work */
+        flush_scheduled_work();
+
+        /* the first unallocated page in the DPM is #9 */
+        mod->free_page = DPM_FREE_START;
+
+        ican3_set_page(mod, QUEUE_OLD_CONTROL);
+        runold = ioread8(mod->dpm + TARGET_RUNNING);
+
+        /* reset the module */
+        iowrite8(val, &mod->ctrl->reset_assert);
+        iowrite8(val, &mod->ctrl->reset_deassert);
+
+        /* wait until the module has finished resetting and is running */
+        start = jiffies;
+        do {
+                ican3_set_page(mod, QUEUE_OLD_CONTROL);
+                runnew = ioread8(mod->dpm + TARGET_RUNNING);
+                if (runnew == (runold ^ 0xff))
+                        return 0;
+
+                msleep(10);
+        } while (time_before(jiffies, start + HZ / 4));
+
+        dev_err(mod->dev, "failed to reset CAN module\n");
+        return -ETIMEDOUT;
+}
+
+static void __devexit ican3_shutdown_module(struct ican3_dev *mod)
+{
+        ican3_msg_disconnect(mod);
+        ican3_reset_module(mod);
+}
+
+/*
+ * Startup an ICAN module, bringing it into fast mode
+ */
+static int __devinit ican3_startup_module(struct ican3_dev *mod)
+{
+        int ret;
+
+        ret = ican3_reset_module(mod);
+        if (ret) {
+                dev_err(mod->dev, "unable to reset module\n");
+                return ret;
+        }
+
+        /* re-enable interrupts so we can send messages */
+        iowrite8(1 << mod->num, &mod->ctrl->int_enable);
+
+        ret = ican3_msg_connect(mod);
+        if (ret) {
+                dev_err(mod->dev, "unable to connect to module\n");
+                return ret;
+        }
+
+        ican3_init_new_host_interface(mod);
+        ret = ican3_msg_newhostif(mod);
+        if (ret) {
+                dev_err(mod->dev, "unable to switch to new-style interface\n");
+                return ret;
+        }
+
+        /* default to "termination on" */
+        ret = ican3_set_termination(mod, true);
+        if (ret) {
+                dev_err(mod->dev, "unable to enable termination\n");
+                return ret;
+        }
+
+        /* default to "bus errors enabled" */
+        ret = ican3_set_buserror(mod, ICAN3_BUSERR_QUOTA_MAX);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-error\n");
+                return ret;
+        }
+
+        ican3_init_fast_host_interface(mod);
+        ret = ican3_msg_fasthostif(mod);
+        if (ret) {
+                dev_err(mod->dev, "unable to switch to fast host interface\n");
+                return ret;
+        }
+
+        ret = ican3_set_id_filter(mod, true);
+        if (ret) {
+                dev_err(mod->dev, "unable to set acceptance filter\n");
+                return ret;
+        }
+
+        return 0;
+}
+
+/*
+ * CAN Network Device
+ */
+
+static int ican3_open(struct net_device *ndev)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        u8 quota;
+        int ret;
+
+        /* open the CAN layer */
+        ret = open_candev(ndev);
+        if (ret) {
+                dev_err(mod->dev, "unable to start CAN layer\n");
+                return ret;
+        }
+
+        /* set the bus error generation state appropriately */
+        if (mod->can.ctrlmode & CAN_CTRLMODE_BERR_REPORTING)
+                quota = ICAN3_BUSERR_QUOTA_MAX;
+        else
+                quota = 0;
+
+        ret = ican3_set_buserror(mod, quota);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-error\n");
+                close_candev(ndev);
+                return ret;
+        }
+
+        /* bring the bus online */
+        ret = ican3_set_bus_state(mod, true);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-on\n");
+                close_candev(ndev);
+                return ret;
+        }
+
+        /* start up the network device */
+        mod->can.state = CAN_STATE_ERROR_ACTIVE;
+        netif_start_queue(ndev);
+
+        return 0;
+}
+
+static int ican3_stop(struct net_device *ndev)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        int ret;
+
+        /* stop the network device xmit routine */
+        netif_stop_queue(ndev);
+        mod->can.state = CAN_STATE_STOPPED;
+
+        /* bring the bus offline, stop receiving packets */
+        ret = ican3_set_bus_state(mod, false);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-off\n");
+                return ret;
+        }
+
+        /* close the CAN layer */
+        close_candev(ndev);
+        return 0;
+}
+
+static int ican3_xmit(struct sk_buff *skb, struct net_device *ndev)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        struct net_device_stats *stats = &ndev->stats;
+        struct can_frame *cf = (struct can_frame *)skb->data;
+        struct ican3_fast_desc desc;
+        void __iomem *desc_addr;
+        unsigned long flags;
+
+        spin_lock_irqsave(&mod->lock, flags);
+
+        /* check that we can actually transmit */
+        if (!ican3_txok(mod)) {
+                dev_err(mod->dev, "no free descriptors, stopping queue\n");
+                netif_stop_queue(ndev);
+                spin_unlock_irqrestore(&mod->lock, flags);
+                return NETDEV_TX_BUSY;
+        }
+
+        /* copy the control bits of the descriptor */
+        ican3_set_page(mod, mod->fasttx_start + (mod->fasttx_num / 16));
+        desc_addr = mod->dpm + ((mod->fasttx_num % 16) * sizeof(desc));
+        memset(&desc, 0, sizeof(desc));
+        memcpy_fromio(&desc, desc_addr, 1);
+
+        /* convert the Linux CAN frame into ICAN3 format */
+        can_frame_to_ican3(mod, cf, &desc);
+
+        /*
+         * the programming manual says that you must set the IVALID bit, then
+         * interrupt, then set the valid bit. Quite weird, but it seems to be
+         * required for this to work
+         */
+        desc.control |= DESC_IVALID;
+        memcpy_toio(desc_addr, &desc, sizeof(desc));
+
+        /* generate a MODULbus interrupt to the microcontroller */
+        iowrite8(0x01, &mod->dpmctrl->interrupt);
+
+        desc.control ^= DESC_VALID;
+        memcpy_toio(desc_addr, &desc, sizeof(desc));
+
+        /* update the next buffer pointer */
+        mod->fasttx_num = (desc.control & DESC_WRAP) ? 0
+                                                     : (mod->fasttx_num + 1);
+
+        /* update statistics */
+        stats->tx_packets++;
+        stats->tx_bytes += cf->can_dlc;
+        kfree_skb(skb);
+
+        /*
+         * This hardware doesn't have TX-done notifications, so we'll try and
+         * emulate it the best we can using ECHO skbs. Get the next TX
+         * descriptor, and see if we have room to send. If not, stop the queue.
+         * It will be woken when the ECHO skb for the current packet is recv'd.
+         */
+
+        /* copy the control bits of the descriptor */
+        if (!ican3_txok(mod))
+                netif_stop_queue(ndev);
+
+        spin_unlock_irqrestore(&mod->lock, flags);
+        return NETDEV_TX_OK;
+}
+
+static const struct net_device_ops ican3_netdev_ops = {
+        .ndo_open       = ican3_open,
+        .ndo_stop       = ican3_stop,
+        .ndo_start_xmit = ican3_xmit,
+};
+
+/*
+ * Low-level CAN Device
+ */
+
+/* This structure was stolen from drivers/net/can/sja1000/sja1000.c */
+static struct can_bittiming_const ican3_bittiming_const = {
+        .name = DRV_NAME,
+        .tseg1_min = 1,
+        .tseg1_max = 16,
+        .tseg2_min = 1,
+        .tseg2_max = 8,
+        .sjw_max = 4,
+        .brp_min = 1,
+        .brp_max = 64,
+        .brp_inc = 1,
+};
+
+/*
+ * This routine was stolen from drivers/net/can/sja1000/sja1000.c
+ *
+ * The bittiming register command for the ICAN3 just sets the bit timing
+ * registers on the SJA1000 chip directly
+ */
+static int ican3_set_bittiming(struct net_device *ndev)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        struct can_bittiming *bt = &mod->can.bittiming;
+        struct ican3_msg msg;
+        u8 btr0, btr1;
+
+        btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
+        btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
+                (((bt->phase_seg2 - 1) & 0x7) << 4);
+        if (mod->can.ctrlmode & CAN_CTRLMODE_3_SAMPLES)
+                btr1 |= 0x80;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.spec = MSG_CBTRREQ;
+        msg.len = cpu_to_le16(4);
+        msg.data[0] = 0x00;
+        msg.data[1] = 0x00;
+        msg.data[2] = btr0;
+        msg.data[3] = btr1;
+
+        return ican3_send_msg(mod, &msg);
+}
+
+static int ican3_set_mode(struct net_device *ndev, enum can_mode mode)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        int ret;
+
+        if (mode != CAN_MODE_START)
+                return -ENOTSUPP;
+
+        /* bring the bus online */
+        ret = ican3_set_bus_state(mod, true);
+        if (ret) {
+                dev_err(mod->dev, "unable to set bus-on\n");
+                return ret;
+        }
+
+        /* start up the network device */
+        mod->can.state = CAN_STATE_ERROR_ACTIVE;
+
+        if (netif_queue_stopped(ndev))
+                netif_wake_queue(ndev);
+
+        return 0;
+}
+
+static int ican3_get_berr_counter(const struct net_device *ndev,
+                                  struct can_berr_counter *bec)
+{
+        struct ican3_dev *mod = netdev_priv(ndev);
+        int ret;
+
+        ret = ican3_send_inquiry(mod, INQUIRY_STATUS);
+        if (ret)
+                return ret;
+
+        ret = wait_for_completion_timeout(&mod->buserror_comp, HZ);
+        if (ret <= 0) {
+                dev_info(mod->dev, "%s timed out\n", __func__);
+                return -ETIMEDOUT;
+        }
+
+        bec->rxerr = mod->bec.rxerr;
+        bec->txerr = mod->bec.txerr;
+        return 0;
+}
+
+/*
+ * Sysfs Attributes
+ */
+
+static ssize_t ican3_sysfs_show_term(struct device *dev,
+                                     struct device_attribute *attr,
+                                     char *buf)
+{
+        struct ican3_dev *mod = netdev_priv(to_net_dev(dev));
+        int ret;
+
+        ret = ican3_send_inquiry(mod, INQUIRY_TERMINATION);
+        if (ret)
+                return ret;
+
+        ret = wait_for_completion_timeout(&mod->termination_comp, HZ);
+        if (ret <= 0) {
+                dev_info(mod->dev, "%s timed out\n", __func__);
+                return -ETIMEDOUT;
+        }
+
+        return snprintf(buf, PAGE_SIZE, "%u\n", mod->termination_enabled);
+}
+
+static ssize_t ican3_sysfs_set_term(struct device *dev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
+{
+        struct ican3_dev *mod = netdev_priv(to_net_dev(dev));
+        unsigned long enable;
+        int ret;
+
+        if (strict_strtoul(buf, 0, &enable))
+                return -EINVAL;
+
+        ret = ican3_set_termination(mod, enable);
+        if (ret)
+                return ret;
+
+        return count;
+}
+
+static DEVICE_ATTR(termination, S_IWUGO | S_IRUGO, ican3_sysfs_show_term,
+                                                   ican3_sysfs_set_term);
+
+static struct attribute *ican3_sysfs_attrs[] = {
+        &dev_attr_termination.attr,
+        NULL,
+};
+
+static struct attribute_group ican3_sysfs_attr_group = {
+        .attrs = ican3_sysfs_attrs,
+};
+
+/*
+ * PCI Subsystem
+ */
+
+static int __devinit ican3_probe(struct platform_device *pdev)
+{
+        struct janz_platform_data *pdata;
+        struct net_device *ndev;
+        struct ican3_dev *mod;
+        struct resource *res;
+        struct device *dev;
+        int ret;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata)
+                return -ENXIO;
+
+        dev_dbg(&pdev->dev, "probe: module number %d\n", pdata->modno);
+
+        /* save the struct device for printing */
+        dev = &pdev->dev;
+
+        /* allocate the CAN device and private data */
+        ndev = alloc_candev(sizeof(*mod), 0);
+        if (!ndev) {
+                dev_err(dev, "unable to allocate CANdev\n");
+                ret = -ENOMEM;
+                goto out_return;
+        }
+
+        platform_set_drvdata(pdev, ndev);
+        mod = netdev_priv(ndev);
+        mod->ndev = ndev;
+        mod->dev = &pdev->dev;
+        mod->num = pdata->modno;
+        netif_napi_add(ndev, &mod->napi, ican3_napi, ICAN3_RX_BUFFERS);
+        spin_lock_init(&mod->lock);
+        init_completion(&mod->termination_comp);
+        init_completion(&mod->buserror_comp);
+
+        /* setup device-specific sysfs attributes */
+        ndev->sysfs_groups[0] = &ican3_sysfs_attr_group;
+
+        /* the first unallocated page in the DPM is 9 */
+        mod->free_page = DPM_FREE_START;
+
+        ndev->netdev_ops = &ican3_netdev_ops;
+        ndev->flags |= IFF_ECHO;
+        SET_NETDEV_DEV(ndev, &pdev->dev);
+
+        mod->can.clock.freq = ICAN3_CAN_CLOCK;
+        mod->can.bittiming_const = &ican3_bittiming_const;
+        mod->can.do_set_bittiming = ican3_set_bittiming;
+        mod->can.do_set_mode = ican3_set_mode;
+        mod->can.do_get_berr_counter = ican3_get_berr_counter;
+        mod->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES
+                                    | CAN_CTRLMODE_BERR_REPORTING;
+
+        /* find our IRQ number */
+        mod->irq = platform_get_irq(pdev, 0);
+        if (mod->irq < 0) {
+                dev_err(dev, "IRQ line not found\n");
+                ret = -ENODEV;
+                goto out_free_ndev;
+        }
+
+        ndev->irq = mod->irq;
+
+        /* get access to the MODULbus registers for this module */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "MODULbus registers not found\n");
+                ret = -ENODEV;
+                goto out_free_ndev;
+        }
+
+        mod->dpm = ioremap(res->start, resource_size(res));
+        if (!mod->dpm) {
+                dev_err(dev, "MODULbus registers not ioremap\n");
+                ret = -ENOMEM;
+                goto out_free_ndev;
+        }
+
+        mod->dpmctrl = mod->dpm + DPM_PAGE_SIZE;
+
+        /* get access to the control registers for this module */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!res) {
+                dev_err(dev, "CONTROL registers not found\n");
+                ret = -ENODEV;
+                goto out_iounmap_dpm;
+        }
+
+        mod->ctrl = ioremap(res->start, resource_size(res));
+        if (!mod->ctrl) {
+                dev_err(dev, "CONTROL registers not ioremap\n");
+                ret = -ENOMEM;
+                goto out_iounmap_dpm;
+        }
+
+        /* disable our IRQ, then hookup the IRQ handler */
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+        ret = request_irq(mod->irq, ican3_irq, IRQF_SHARED, DRV_NAME, mod);
+        if (ret) {
+                dev_err(dev, "unable to request IRQ\n");
+                goto out_iounmap_ctrl;
+        }
+
+        /* reset and initialize the CAN controller into fast mode */
+        napi_enable(&mod->napi);
+        ret = ican3_startup_module(mod);
+        if (ret) {
+                dev_err(dev, "%s: unable to start CANdev\n", __func__);
+                goto out_free_irq;
+        }
+
+        /* register with the Linux CAN layer */
+        ret = register_candev(ndev);
+        if (ret) {
+                dev_err(dev, "%s: unable to register CANdev\n", __func__);
+                goto out_free_irq;
+        }
+
+        dev_info(dev, "module %d: registered CAN device\n", pdata->modno);
+        return 0;
+
+out_free_irq:
+        napi_disable(&mod->napi);
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+        free_irq(mod->irq, mod);
+out_iounmap_ctrl:
+        iounmap(mod->ctrl);
+out_iounmap_dpm:
+        iounmap(mod->dpm);
+out_free_ndev:
+        free_candev(ndev);
+out_return:
+        return ret;
+}
+
+static int __devexit ican3_remove(struct platform_device *pdev)
+{
+        struct net_device *ndev = platform_get_drvdata(pdev);
+        struct ican3_dev *mod = netdev_priv(ndev);
+
+        /* unregister the netdevice, stop interrupts */
+        unregister_netdev(ndev);
+        napi_disable(&mod->napi);
+        iowrite8(1 << mod->num, &mod->ctrl->int_disable);
+        free_irq(mod->irq, mod);
+
+        /* put the module into reset */
+        ican3_shutdown_module(mod);
+
+        /* unmap all registers */
+        iounmap(mod->ctrl);
+        iounmap(mod->dpm);
+
+        free_candev(ndev);
+
+        return 0;
+}
+
+static struct platform_driver ican3_driver = {
+        .driver         = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = ican3_probe,
+        .remove         = __devexit_p(ican3_remove),
+};
+
+static int __init ican3_init(void)
+{
+        return platform_driver_register(&ican3_driver);
+}
+
+static void __exit ican3_exit(void)
+{
+        platform_driver_unregister(&ican3_driver);
+}
+
+MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
+MODULE_DESCRIPTION("Janz MODULbus VMOD-ICAN3 Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:janz-ican3");
+
+module_init(ican3_init);
+module_exit(ican3_exit);
diff --git a/drivers/net/can/mscan/mpc5xxx_can.c b/drivers/net/can/mscan/mpc5xxx_can.c
index 225fd147774a..af753936e835 100644
--- a/drivers/net/can/mscan/mpc5xxx_can.c
+++ b/drivers/net/can/mscan/mpc5xxx_can.c
@@ -73,7 +73,7 @@ static u32 __devinit mpc52xx_can_get_clock(struct of_device *ofdev,
         else
                 *mscan_clksrc = MSCAN_CLKSRC_XTAL;
 
-        freq = mpc5xxx_get_bus_frequency(ofdev->node);
+        freq = mpc5xxx_get_bus_frequency(ofdev->dev.of_node);
         if (!freq)
                 return 0;
 
@@ -152,7 +152,7 @@ static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev,
         }
 
         /* Determine the MSCAN device index from the physical address */
-        pval = of_get_property(ofdev->node, "reg", &plen);
+        pval = of_get_property(ofdev->dev.of_node, "reg", &plen);
         BUG_ON(!pval || plen < sizeof(*pval));
         clockidx = (*pval & 0x80) ? 1 : 0;
         if (*pval & 0x2000)
@@ -168,11 +168,11 @@ static u32 __devinit mpc512x_can_get_clock(struct of_device *ofdev,
          */
         if (clock_name && !strcmp(clock_name, "ip")) {
                 *mscan_clksrc = MSCAN_CLKSRC_IPS;
-                freq = mpc5xxx_get_bus_frequency(ofdev->node);
+                freq = mpc5xxx_get_bus_frequency(ofdev->dev.of_node);
         } else {
                 *mscan_clksrc = MSCAN_CLKSRC_BUS;
 
-                pval = of_get_property(ofdev->node,
+                pval = of_get_property(ofdev->dev.of_node,
                                        "fsl,mscan-clock-divider", &plen);
                 if (pval && plen == sizeof(*pval))
                         clockdiv = *pval;
@@ -251,7 +251,7 @@ static int __devinit mpc5xxx_can_probe(struct of_device *ofdev,
                                        const struct of_device_id *id)
 {
         struct mpc5xxx_can_data *data = (struct mpc5xxx_can_data *)id->data;
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct net_device *dev;
         struct mscan_priv *priv;
         void __iomem *base;
@@ -392,15 +392,17 @@ static struct of_device_id __devinitdata mpc5xxx_can_table[] = {
 };
 
 static struct of_platform_driver mpc5xxx_can_driver = {
-        .owner = THIS_MODULE,
-        .name = "mpc5xxx_can",
+        .driver = {
+                .name = "mpc5xxx_can",
+                .owner = THIS_MODULE,
+                .of_match_table = mpc5xxx_can_table,
+        },
         .probe = mpc5xxx_can_probe,
         .remove = __devexit_p(mpc5xxx_can_remove),
 #ifdef CONFIG_PM
         .suspend = mpc5xxx_can_suspend,
         .resume = mpc5xxx_can_resume,
 #endif
-        .match_table = mpc5xxx_can_table,
 };
 
 static int __init mpc5xxx_can_init(void)
diff --git a/drivers/net/can/sja1000/sja1000.c b/drivers/net/can/sja1000/sja1000.c
index 85f7cbfe8e5f..0a8de01d52f7 100644
--- a/drivers/net/can/sja1000/sja1000.c
+++ b/drivers/net/can/sja1000/sja1000.c
@@ -599,6 +599,8 @@ struct net_device *alloc_sja1000dev(int sizeof_priv)
         priv->can.ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES |
                 CAN_CTRLMODE_BERR_REPORTING;
 
+        spin_lock_init(&priv->cmdreg_lock);
+
         if (sizeof_priv)
                 priv->priv = (void *)priv + sizeof(struct sja1000_priv);
 
diff --git a/drivers/net/can/sja1000/sja1000_of_platform.c b/drivers/net/can/sja1000/sja1000_of_platform.c
index 34e79efbd2fc..ac1a83d7c204 100644
--- a/drivers/net/can/sja1000/sja1000_of_platform.c
+++ b/drivers/net/can/sja1000/sja1000_of_platform.c
@@ -71,7 +71,7 @@ static int __devexit sja1000_ofp_remove(struct of_device *ofdev)
 {
         struct net_device *dev = dev_get_drvdata(&ofdev->dev);
         struct sja1000_priv *priv = netdev_priv(dev);
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct resource res;
 
         dev_set_drvdata(&ofdev->dev, NULL);
@@ -90,7 +90,7 @@ static int __devexit sja1000_ofp_remove(struct of_device *ofdev)
 static int __devinit sja1000_ofp_probe(struct of_device *ofdev,
                                        const struct of_device_id *id)
 {
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct net_device *dev;
         struct sja1000_priv *priv;
         struct resource res;
@@ -215,11 +215,13 @@ static struct of_device_id __devinitdata sja1000_ofp_table[] = {
 MODULE_DEVICE_TABLE(of, sja1000_ofp_table);
 
 static struct of_platform_driver sja1000_ofp_driver = {
-        .owner = THIS_MODULE,
-        .name = DRV_NAME,
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = DRV_NAME,
+                .of_match_table = sja1000_ofp_table,
+        },
         .probe = sja1000_ofp_probe,
         .remove = __devexit_p(sja1000_ofp_remove),
-        .match_table = sja1000_ofp_table,
 };
 
 static int __init sja1000_ofp_init(void)
diff --git a/drivers/net/cnic.c b/drivers/net/cnic.c
index be90d3598bca..fe925663d39a 100644
--- a/drivers/net/cnic.c
+++ b/drivers/net/cnic.c
@@ -3367,13 +3367,9 @@ static int cnic_cm_shutdown(struct cnic_dev *dev)
 
 static void cnic_init_context(struct cnic_dev *dev, u32 cid)
 {
-        struct cnic_local *cp = dev->cnic_priv;
         u32 cid_addr;
         int i;
 
-        if (CHIP_NUM(cp) == CHIP_NUM_5709)
-                return;
-
         cid_addr = GET_CID_ADDR(cid);
 
         for (i = 0; i < CTX_SIZE; i += 4)
@@ -3530,14 +3526,11 @@ static void cnic_init_bnx2_tx_ring(struct cnic_dev *dev)
 
         sb_id = cp->status_blk_num;
         tx_cid = 20;
-        cnic_init_context(dev, tx_cid);
-        cnic_init_context(dev, tx_cid + 1);
         cp->tx_cons_ptr = &s_blk->status_tx_quick_consumer_index2;
         if (ethdev->drv_state & CNIC_DRV_STATE_USING_MSIX) {
                 struct status_block_msix *sblk = cp->status_blk.bnx2;
 
                 tx_cid = TX_TSS_CID + sb_id - 1;
-                cnic_init_context(dev, tx_cid);
                 CNIC_WR(dev, BNX2_TSCH_TSS_CFG, (sb_id << 24) |
                         (TX_TSS_CID << 7));
                 cp->tx_cons_ptr = &sblk->status_tx_quick_consumer_index;
@@ -3556,6 +3549,9 @@ static void cnic_init_bnx2_tx_ring(struct cnic_dev *dev)
                 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI_XI;
                 offset3 = BNX2_L2CTX_TBDR_BHADDR_LO_XI;
         } else {
+                cnic_init_context(dev, tx_cid);
+                cnic_init_context(dev, tx_cid + 1);
+
                 offset0 = BNX2_L2CTX_TYPE;
                 offset1 = BNX2_L2CTX_CMD_TYPE;
                 offset2 = BNX2_L2CTX_TBDR_BHADDR_HI;
diff --git a/drivers/net/cnic_if.h b/drivers/net/cnic_if.h
index 110c62072e6f..0c55177db046 100644
--- a/drivers/net/cnic_if.h
+++ b/drivers/net/cnic_if.h
@@ -12,8 +12,8 @@
 #ifndef CNIC_IF_H
 #define CNIC_IF_H
 
-#define CNIC_MODULE_VERSION     "2.1.1"
-#define CNIC_MODULE_RELDATE     "Feb 22, 2010"
+#define CNIC_MODULE_VERSION     "2.1.2"
+#define CNIC_MODULE_RELDATE     "May 26, 2010"
 
 #define CNIC_ULP_RDMA           0
 #define CNIC_ULP_ISCSI          1
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 24507f3b8b17..57a7e41da69e 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -2554,7 +2554,7 @@ static void e1000_init_manageability_pt(struct e1000_adapter *adapter)
                         mdef = er32(MDEF(i));
 
                         /* Ignore filters with anything other than IPMI ports */
-                        if (mdef & !(E1000_MDEF_PORT_623 | E1000_MDEF_PORT_664))
+                        if (mdef & ~(E1000_MDEF_PORT_623 | E1000_MDEF_PORT_664))
                                 continue;
 
                         /* Enable this decision filter in MANC2H */
diff --git a/drivers/net/ehea/ehea_main.c b/drivers/net/ehea/ehea_main.c
index 02698a1c80b0..f547894ff48f 100644
--- a/drivers/net/ehea/ehea_main.c
+++ b/drivers/net/ehea/ehea_main.c
@@ -122,8 +122,11 @@ static struct of_device_id ehea_device_table[] = {
 MODULE_DEVICE_TABLE(of, ehea_device_table);
 
 static struct of_platform_driver ehea_driver = {
-        .name = "ehea",
-        .match_table = ehea_device_table,
+        .driver = {
+                .name = "ehea",
+                .owner = THIS_MODULE,
+                .of_match_table = ehea_device_table,
+        },
         .probe = ehea_probe_adapter,
         .remove = ehea_remove,
 };
@@ -3050,7 +3053,7 @@ static DEVICE_ATTR(log_port_id, S_IRUSR | S_IRGRP | S_IROTH, ehea_show_port_id,
 static void __devinit logical_port_release(struct device *dev)
 {
         struct ehea_port *port = container_of(dev, struct ehea_port, ofdev.dev);
-        of_node_put(port->ofdev.node);
+        of_node_put(port->ofdev.dev.of_node);
 }
 
 static struct device *ehea_register_port(struct ehea_port *port,
@@ -3058,7 +3061,7 @@ static struct device *ehea_register_port(struct ehea_port *port,
 {
         int ret;
 
-        port->ofdev.node = of_node_get(dn);
+        port->ofdev.dev.of_node = of_node_get(dn);
         port->ofdev.dev.parent = &port->adapter->ofdev->dev;
         port->ofdev.dev.bus = &ibmebus_bus_type;
 
@@ -3225,7 +3228,7 @@ static int ehea_setup_ports(struct ehea_adapter *adapter)
         const u32 *dn_log_port_id;
         int i = 0;
 
-        lhea_dn = adapter->ofdev->node;
+        lhea_dn = adapter->ofdev->dev.of_node;
         while ((eth_dn = of_get_next_child(lhea_dn, eth_dn))) {
 
                 dn_log_port_id = of_get_property(eth_dn, "ibm,hea-port-no",
@@ -3264,7 +3267,7 @@ static struct device_node *ehea_get_eth_dn(struct ehea_adapter *adapter,
         struct device_node *eth_dn = NULL;
         const u32 *dn_log_port_id;
 
-        lhea_dn = adapter->ofdev->node;
+        lhea_dn = adapter->ofdev->dev.of_node;
         while ((eth_dn = of_get_next_child(lhea_dn, eth_dn))) {
 
                 dn_log_port_id = of_get_property(eth_dn, "ibm,hea-port-no",
@@ -3394,7 +3397,7 @@ static int __devinit ehea_probe_adapter(struct of_device *dev,
         const u64 *adapter_handle;
         int ret;
 
-        if (!dev || !dev->node) {
+        if (!dev || !dev->dev.of_node) {
                 ehea_error("Invalid ibmebus device probed");
                 return -EINVAL;
         }
@@ -3410,14 +3413,14 @@ static int __devinit ehea_probe_adapter(struct of_device *dev,
 
         adapter->ofdev = dev;
 
-        adapter_handle = of_get_property(dev->node, "ibm,hea-handle",
+        adapter_handle = of_get_property(dev->dev.of_node, "ibm,hea-handle",
                                          NULL);
         if (adapter_handle)
                 adapter->handle = *adapter_handle;
 
         if (!adapter->handle) {
                 dev_err(&dev->dev, "failed getting handle for adapter"
-                        " '%s'\n", dev->node->full_name);
+                        " '%s'\n", dev->dev.of_node->full_name);
                 ret = -ENODEV;
                 goto out_free_ad;
         }
diff --git a/drivers/net/enic/enic.h b/drivers/net/enic/enic.h
index 85f2a2e7030a..45e86d1e5b1b 100644
--- a/drivers/net/enic/enic.h
+++ b/drivers/net/enic/enic.h
@@ -74,7 +74,14 @@ struct enic_msix_entry {
         void *devid;
 };
 
+#define ENIC_SET_APPLIED                (1 << 0)
+#define ENIC_SET_REQUEST                (1 << 1)
+#define ENIC_SET_NAME                   (1 << 2)
+#define ENIC_SET_INSTANCE               (1 << 3)
+#define ENIC_SET_HOST                   (1 << 4)
+
 struct enic_port_profile {
+        u32 set;
         u8 request;
         char name[PORT_PROFILE_MAX];
         u8 instance_uuid[PORT_UUID_MAX];
diff --git a/drivers/net/enic/enic_main.c b/drivers/net/enic/enic_main.c
index e125113759a5..bc7d6b96de3d 100644
--- a/drivers/net/enic/enic_main.c
+++ b/drivers/net/enic/enic_main.c
@@ -1029,127 +1029,133 @@ static int enic_dev_init_done(struct enic *enic, int *done, int *error)
         return err;
 }
 
-static int enic_set_port_profile(struct enic *enic, u8 request, u8 *mac,
-        char *name, u8 *instance_uuid, u8 *host_uuid)
+static int enic_set_port_profile(struct enic *enic, u8 *mac)
 {
         struct vic_provinfo *vp;
         u8 oui[3] = VIC_PROVINFO_CISCO_OUI;
-        unsigned short *uuid;
+        u8 *uuid;
         char uuid_str[38];
-        static char *uuid_fmt = "%04X%04X-%04X-%04X-%04X-%04X%04X%04X";
+        static char *uuid_fmt = "%02X%02X%02X%02X-%02X%02X-%02X%02X-"
+                "%02X%02X-%02X%02X%02X%02X%0X%02X";
         int err;
 
-        if (!name)
-                return -EINVAL;
+        err = enic_vnic_dev_deinit(enic);
+        if (err)
+                return err;
 
-        if (!is_valid_ether_addr(mac))
-                return -EADDRNOTAVAIL;
+        switch (enic->pp.request) {
 
-        vp = vic_provinfo_alloc(GFP_KERNEL, oui, VIC_PROVINFO_LINUX_TYPE);
-        if (!vp)
-                return -ENOMEM;
+        case PORT_REQUEST_ASSOCIATE:
 
-        vic_provinfo_add_tlv(vp,
-                VIC_LINUX_PROV_TLV_PORT_PROFILE_NAME_STR,
-                strlen(name) + 1, name);
+                if (!(enic->pp.set & ENIC_SET_NAME) || !strlen(enic->pp.name))
+                        return -EINVAL;
 
-        vic_provinfo_add_tlv(vp,
-                VIC_LINUX_PROV_TLV_CLIENT_MAC_ADDR,
-                ETH_ALEN, mac);
+                if (!is_valid_ether_addr(mac))
+                        return -EADDRNOTAVAIL;
 
-        if (instance_uuid) {
-                uuid = (unsigned short *)instance_uuid;
-                sprintf(uuid_str, uuid_fmt,
-                        uuid[0], uuid[1], uuid[2], uuid[3],
-                        uuid[4], uuid[5], uuid[6], uuid[7]);
-                vic_provinfo_add_tlv(vp,
-                        VIC_LINUX_PROV_TLV_CLIENT_UUID_STR,
-                        sizeof(uuid_str), uuid_str);
-        }
+                vp = vic_provinfo_alloc(GFP_KERNEL, oui,
+                        VIC_PROVINFO_LINUX_TYPE);
+                if (!vp)
+                        return -ENOMEM;
 
-        if (host_uuid) {
-                uuid = (unsigned short *)host_uuid;
-                sprintf(uuid_str, uuid_fmt,
-                        uuid[0], uuid[1], uuid[2], uuid[3],
-                        uuid[4], uuid[5], uuid[6], uuid[7]);
                 vic_provinfo_add_tlv(vp,
-                        VIC_LINUX_PROV_TLV_HOST_UUID_STR,
-                        sizeof(uuid_str), uuid_str);
-        }
+                        VIC_LINUX_PROV_TLV_PORT_PROFILE_NAME_STR,
+                        strlen(enic->pp.name) + 1, enic->pp.name);
 
-        err = enic_vnic_dev_deinit(enic);
-        if (err)
-                goto err_out;
-
-        memset(&enic->pp, 0, sizeof(enic->pp));
+                vic_provinfo_add_tlv(vp,
+                        VIC_LINUX_PROV_TLV_CLIENT_MAC_ADDR,
+                        ETH_ALEN, mac);
+
+                if (enic->pp.set & ENIC_SET_INSTANCE) {
+                        uuid = enic->pp.instance_uuid;
+                        sprintf(uuid_str, uuid_fmt,
+                                uuid[0],  uuid[1],  uuid[2],  uuid[3],
+                                uuid[4],  uuid[5],  uuid[6],  uuid[7],
+                                uuid[8],  uuid[9],  uuid[10], uuid[11],
+                                uuid[12], uuid[13], uuid[14], uuid[15]);
+                        vic_provinfo_add_tlv(vp,
+                                VIC_LINUX_PROV_TLV_CLIENT_UUID_STR,
+                                sizeof(uuid_str), uuid_str);
+                }
 
-        err = enic_dev_init_prov(enic, vp);
-        if (err)
-                goto err_out;
+                if (enic->pp.set & ENIC_SET_HOST) {
+                        uuid = enic->pp.host_uuid;
+                        sprintf(uuid_str, uuid_fmt,
+                                uuid[0],  uuid[1],  uuid[2],  uuid[3],
+                                uuid[4],  uuid[5],  uuid[6],  uuid[7],
+                                uuid[8],  uuid[9],  uuid[10], uuid[11],
+                                uuid[12], uuid[13], uuid[14], uuid[15]);
+                        vic_provinfo_add_tlv(vp,
+                                VIC_LINUX_PROV_TLV_HOST_UUID_STR,
+                                sizeof(uuid_str), uuid_str);
+                }
 
-        enic->pp.request = request;
-        memcpy(enic->pp.name, name, PORT_PROFILE_MAX);
-        if (instance_uuid)
-                memcpy(enic->pp.instance_uuid,
-                        instance_uuid, PORT_UUID_MAX);
-        if (host_uuid)
-                memcpy(enic->pp.host_uuid,
-                        host_uuid, PORT_UUID_MAX);
+                err = enic_dev_init_prov(enic, vp);
+                vic_provinfo_free(vp);
+                if (err)
+                        return err;
+                break;
 
-err_out:
-        vic_provinfo_free(vp);
+        case PORT_REQUEST_DISASSOCIATE:
+                break;
 
-        return err;
-}
+        default:
+                return -EINVAL;
+        }
 
-static int enic_unset_port_profile(struct enic *enic)
-{
-        memset(&enic->pp, 0, sizeof(enic->pp));
-        return enic_vnic_dev_deinit(enic);
+        enic->pp.set |= ENIC_SET_APPLIED;
+        return 0;
 }
 
 static int enic_set_vf_port(struct net_device *netdev, int vf,
         struct nlattr *port[])
 {
         struct enic *enic = netdev_priv(netdev);
-        char *name = NULL;
-        u8 *instance_uuid = NULL;
-        u8 *host_uuid = NULL;
-        u8 request = PORT_REQUEST_DISASSOCIATE;
 
-        /* don't support VFs, yet */
-        if (vf != PORT_SELF_VF)
-                return -EOPNOTSUPP;
+        memset(&enic->pp, 0, sizeof(enic->pp));
 
-        if (port[IFLA_PORT_REQUEST])
-                request = nla_get_u8(port[IFLA_PORT_REQUEST]);
+        if (port[IFLA_PORT_REQUEST]) {
+                enic->pp.set |= ENIC_SET_REQUEST;
+                enic->pp.request = nla_get_u8(port[IFLA_PORT_REQUEST]);
+        }
 
-        switch (request) {
-        case PORT_REQUEST_ASSOCIATE:
+        if (port[IFLA_PORT_PROFILE]) {
+                enic->pp.set |= ENIC_SET_NAME;
+                memcpy(enic->pp.name, nla_data(port[IFLA_PORT_PROFILE]),
+                        PORT_PROFILE_MAX);
+        }
 
-                if (port[IFLA_PORT_PROFILE])
-                        name = nla_data(port[IFLA_PORT_PROFILE]);
+        if (port[IFLA_PORT_INSTANCE_UUID]) {
+                enic->pp.set |= ENIC_SET_INSTANCE;
+                memcpy(enic->pp.instance_uuid,
+                        nla_data(port[IFLA_PORT_INSTANCE_UUID]), PORT_UUID_MAX);
+        }
 
-                if (port[IFLA_PORT_INSTANCE_UUID])
-                        instance_uuid =
-                                nla_data(port[IFLA_PORT_INSTANCE_UUID]);
+        if (port[IFLA_PORT_HOST_UUID]) {
+                enic->pp.set |= ENIC_SET_HOST;
+                memcpy(enic->pp.host_uuid,
+                        nla_data(port[IFLA_PORT_HOST_UUID]), PORT_UUID_MAX);
+        }
 
-                if (port[IFLA_PORT_HOST_UUID])
-                        host_uuid = nla_data(port[IFLA_PORT_HOST_UUID]);
+        /* don't support VFs, yet */
+        if (vf != PORT_SELF_VF)
+                return -EOPNOTSUPP;
 
-                return enic_set_port_profile(enic, request,
-                        netdev->dev_addr, name,
-                        instance_uuid, host_uuid);
+        if (!(enic->pp.set & ENIC_SET_REQUEST))
+                return -EOPNOTSUPP;
 
-        case PORT_REQUEST_DISASSOCIATE:
+        if (enic->pp.request == PORT_REQUEST_ASSOCIATE) {
 
-                return enic_unset_port_profile(enic);
+                /* If the interface mac addr hasn't been assigned,
+                 * assign a random mac addr before setting port-
+                 * profile.
+                 */
 
-        default:
-                break;
+                if (is_zero_ether_addr(netdev->dev_addr))
+                        random_ether_addr(netdev->dev_addr);
         }
 
-        return -EOPNOTSUPP;
+        return enic_set_port_profile(enic, netdev->dev_addr);
 }
 
 static int enic_get_vf_port(struct net_device *netdev, int vf,
@@ -1159,14 +1165,12 @@ static int enic_get_vf_port(struct net_device *netdev, int vf,
         int err, error, done;
         u16 response = PORT_PROFILE_RESPONSE_SUCCESS;
 
-        /* don't support VFs, yet */
-        if (vf != PORT_SELF_VF)
-                return -EOPNOTSUPP;
+        if (!(enic->pp.set & ENIC_SET_APPLIED))
+                return -ENODATA;
 
         err = enic_dev_init_done(enic, &done, &error);
-
         if (err)
-                return err;
+                error = err;
 
         switch (error) {
         case ERR_SUCCESS:
@@ -1189,12 +1193,15 @@ static int enic_get_vf_port(struct net_device *netdev, int vf,
 
         NLA_PUT_U16(skb, IFLA_PORT_REQUEST, enic->pp.request);
         NLA_PUT_U16(skb, IFLA_PORT_RESPONSE, response);
-        NLA_PUT(skb, IFLA_PORT_PROFILE, PORT_PROFILE_MAX,
-                enic->pp.name);
-        NLA_PUT(skb, IFLA_PORT_INSTANCE_UUID, PORT_UUID_MAX,
-                enic->pp.instance_uuid);
-        NLA_PUT(skb, IFLA_PORT_HOST_UUID, PORT_UUID_MAX,
-                enic->pp.host_uuid);
+        if (enic->pp.set & ENIC_SET_NAME)
+                NLA_PUT(skb, IFLA_PORT_PROFILE, PORT_PROFILE_MAX,
+                        enic->pp.name);
+        if (enic->pp.set & ENIC_SET_INSTANCE)
+                NLA_PUT(skb, IFLA_PORT_INSTANCE_UUID, PORT_UUID_MAX,
+                        enic->pp.instance_uuid);
+        if (enic->pp.set & ENIC_SET_HOST)
+                NLA_PUT(skb, IFLA_PORT_HOST_UUID, PORT_UUID_MAX,
+                        enic->pp.host_uuid);
 
         return 0;
 
diff --git a/drivers/net/epic100.c b/drivers/net/epic100.c
index 6838dfc9ef23..4c274657283c 100644
--- a/drivers/net/epic100.c
+++ b/drivers/net/epic100.c
@@ -87,6 +87,7 @@ static int rx_copybreak;
 #include <linux/bitops.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
+#include <asm/byteorder.h>
 
 /* These identify the driver base version and may not be removed. */
 static char version[] __devinitdata =
@@ -230,7 +231,7 @@ static const u16 media2miictl[16] = {
  * The EPIC100 Rx and Tx buffer descriptors.  Note that these
  * really ARE host-endian; it's not a misannotation.  We tell
  * the card to byteswap them internally on big-endian hosts -
- * look for #ifdef CONFIG_BIG_ENDIAN in epic_open().
+ * look for #ifdef __BIG_ENDIAN in epic_open().
  */
 
 struct epic_tx_desc {
@@ -690,7 +691,7 @@ static int epic_open(struct net_device *dev)
                 outl((inl(ioaddr + NVCTL) & ~0x003C) | 0x4800, ioaddr + NVCTL);
 
         /* Tell the chip to byteswap descriptors on big-endian hosts */
-#ifdef CONFIG_BIG_ENDIAN
+#ifdef __BIG_ENDIAN
         outl(0x4432 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
         inl(ioaddr + GENCTL);
         outl(0x0432 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
@@ -806,7 +807,7 @@ static void epic_restart(struct net_device *dev)
         for (i = 16; i > 0; i--)
                 outl(0x0008, ioaddr + TEST1);
 
-#ifdef CONFIG_BIG_ENDIAN
+#ifdef __BIG_ENDIAN
         outl(0x0432 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
 #else
         outl(0x0412 | (RX_FIFO_THRESH<<8), ioaddr + GENCTL);
diff --git a/drivers/net/ethoc.c b/drivers/net/ethoc.c
index 14cbde5cf68e..6ed2df14ec84 100644
--- a/drivers/net/ethoc.c
+++ b/drivers/net/ethoc.c
@@ -174,6 +174,7 @@ MODULE_PARM_DESC(buffer_size, "DMA buffer allocation size");
  * @iobase:     pointer to I/O memory region
  * @membase:    pointer to buffer memory region
  * @dma_alloc:  dma allocated buffer size
+ * @io_region_size:     I/O memory region size
  * @num_tx:     number of send buffers
  * @cur_tx:     last send buffer written
  * @dty_tx:     last buffer actually sent
@@ -193,6 +194,7 @@ struct ethoc {
         void __iomem *iobase;
         void __iomem *membase;
         int dma_alloc;
+        resource_size_t io_region_size;
 
         unsigned int num_tx;
         unsigned int cur_tx;
@@ -943,6 +945,7 @@ static int ethoc_probe(struct platform_device *pdev)
         priv = netdev_priv(netdev);
         priv->netdev = netdev;
         priv->dma_alloc = 0;
+        priv->io_region_size = mmio->end - mmio->start + 1;
 
         priv->iobase = devm_ioremap_nocache(&pdev->dev, netdev->base_addr,
                         resource_size(mmio));
@@ -1047,20 +1050,34 @@ static int ethoc_probe(struct platform_device *pdev)
         ret = register_netdev(netdev);
         if (ret < 0) {
                 dev_err(&netdev->dev, "failed to register interface\n");
-                goto error;
+                goto error2;
         }
 
         goto out;
 
+error2:
+        netif_napi_del(&priv->napi);
 error:
         mdiobus_unregister(priv->mdio);
 free_mdio:
         kfree(priv->mdio->irq);
         mdiobus_free(priv->mdio);
 free:
-        if (priv->dma_alloc)
-                dma_free_coherent(NULL, priv->dma_alloc, priv->membase,
-                        netdev->mem_start);
+        if (priv) {
+                if (priv->dma_alloc)
+                        dma_free_coherent(NULL, priv->dma_alloc, priv->membase,
+                                          netdev->mem_start);
+                else if (priv->membase)
+                        devm_iounmap(&pdev->dev, priv->membase);
+                if (priv->iobase)
+                        devm_iounmap(&pdev->dev, priv->iobase);
+        }
+        if (mem)
+                devm_release_mem_region(&pdev->dev, mem->start,
+                                        mem->end - mem->start + 1);
+        if (mmio)
+                devm_release_mem_region(&pdev->dev, mmio->start,
+                                        mmio->end - mmio->start + 1);
         free_netdev(netdev);
 out:
         return ret;
@@ -1078,6 +1095,7 @@ static int ethoc_remove(struct platform_device *pdev)
         platform_set_drvdata(pdev, NULL);
 
         if (netdev) {
+                netif_napi_del(&priv->napi);
                 phy_disconnect(priv->phy);
                 priv->phy = NULL;
 
@@ -1089,6 +1107,14 @@ static int ethoc_remove(struct platform_device *pdev)
                 if (priv->dma_alloc)
                         dma_free_coherent(NULL, priv->dma_alloc, priv->membase,
                                 netdev->mem_start);
+                else {
+                        devm_iounmap(&pdev->dev, priv->membase);
+                        devm_release_mem_region(&pdev->dev, netdev->mem_start,
+                                netdev->mem_end - netdev->mem_start + 1);
+                }
+                devm_iounmap(&pdev->dev, priv->iobase);
+                devm_release_mem_region(&pdev->dev, netdev->base_addr,
+                        priv->io_region_size);
                 unregister_netdev(netdev);
                 free_netdev(netdev);
         }
diff --git a/drivers/net/fec.c b/drivers/net/fec.c
index 42d9ac9ba395..edfff92a6d8e 100644
--- a/drivers/net/fec.c
+++ b/drivers/net/fec.c
@@ -41,6 +41,7 @@
 #include <linux/clk.h>
 #include <linux/platform_device.h>
 #include <linux/phy.h>
+#include <linux/fec.h>
 
 #include <asm/cacheflush.h>
 
@@ -182,6 +183,7 @@ struct fec_enet_private {
         struct  phy_device *phy_dev;
         int     mii_timeout;
         uint    phy_speed;
+        phy_interface_t phy_interface;
         int     index;
         int     link;
         int     full_duplex;
@@ -679,6 +681,8 @@ static int fec_enet_mii_probe(struct net_device *dev)
         struct phy_device *phy_dev = NULL;
         int phy_addr;
 
+        fep->phy_dev = NULL;
+
         /* find the first phy */
         for (phy_addr = 0; phy_addr < PHY_MAX_ADDR; phy_addr++) {
                 if (fep->mii_bus->phy_map[phy_addr]) {
@@ -709,6 +713,11 @@ static int fec_enet_mii_probe(struct net_device *dev)
         fep->link = 0;
         fep->full_duplex = 0;
 
+        printk(KERN_INFO "%s: Freescale FEC PHY driver [%s] "
+                "(mii_bus:phy_addr=%s, irq=%d)\n", dev->name,
+                fep->phy_dev->drv->name, dev_name(&fep->phy_dev->dev),
+                fep->phy_dev->irq);
+
         return 0;
 }
 
@@ -754,13 +763,8 @@ static int fec_enet_mii_init(struct platform_device *pdev)
         if (mdiobus_register(fep->mii_bus))
                 goto err_out_free_mdio_irq;
 
-        if (fec_enet_mii_probe(dev) != 0)
-                goto err_out_unregister_bus;
-
         return 0;
 
-err_out_unregister_bus:
-        mdiobus_unregister(fep->mii_bus);
 err_out_free_mdio_irq:
         kfree(fep->mii_bus->irq);
 err_out_free_mdiobus:
@@ -913,7 +917,12 @@ fec_enet_open(struct net_device *dev)
         if (ret)
                 return ret;
 
-        /* schedule a link state check */
+        /* Probe and connect to PHY when open the interface */
+        ret = fec_enet_mii_probe(dev);
+        if (ret) {
+                fec_enet_free_buffers(dev);
+                return ret;
+        }
         phy_start(fep->phy_dev);
         netif_start_queue(dev);
         fep->opened = 1;
@@ -927,10 +936,12 @@ fec_enet_close(struct net_device *dev)
 
         /* Don't know what to do yet. */
         fep->opened = 0;
-        phy_stop(fep->phy_dev);
         netif_stop_queue(dev);
         fec_stop(dev);
 
+        if (fep->phy_dev)
+                phy_disconnect(fep->phy_dev);
+
         fec_enet_free_buffers(dev);
 
         return 0;
@@ -1191,6 +1202,21 @@ fec_restart(struct net_device *dev, int duplex)
         /* Set MII speed */
         writel(fep->phy_speed, fep->hwp + FEC_MII_SPEED);
 
+#ifdef FEC_MIIGSK_ENR
+        if (fep->phy_interface == PHY_INTERFACE_MODE_RMII) {
+                /* disable the gasket and wait */
+                writel(0, fep->hwp + FEC_MIIGSK_ENR);
+                while (readl(fep->hwp + FEC_MIIGSK_ENR) & 4)
+                        udelay(1);
+
+                /* configure the gasket: RMII, 50 MHz, no loopback, no echo */
+                writel(1, fep->hwp + FEC_MIIGSK_CFGR);
+
+                /* re-enable the gasket */
+                writel(2, fep->hwp + FEC_MIIGSK_ENR);
+        }
+#endif
+
         /* And last, enable the transmit and receive processing */
         writel(2, fep->hwp + FEC_ECNTRL);
         writel(0, fep->hwp + FEC_R_DES_ACTIVE);
@@ -1226,6 +1252,7 @@ static int __devinit
 fec_probe(struct platform_device *pdev)
 {
         struct fec_enet_private *fep;
+        struct fec_platform_data *pdata;
         struct net_device *ndev;
         int i, irq, ret = 0;
         struct resource *r;
@@ -1259,6 +1286,10 @@ fec_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, ndev);
 
+        pdata = pdev->dev.platform_data;
+        if (pdata)
+                fep->phy_interface = pdata->phy;
+
         /* This device has up to three irqs on some platforms */
         for (i = 0; i < 3; i++) {
                 irq = platform_get_irq(pdev, i);
@@ -1294,11 +1325,6 @@ fec_probe(struct platform_device *pdev)
         if (ret)
                 goto failed_register;
 
-        printk(KERN_INFO "%s: Freescale FEC PHY driver [%s] "
-                "(mii_bus:phy_addr=%s, irq=%d)\n", ndev->name,
-                fep->phy_dev->drv->name, dev_name(&fep->phy_dev->dev),
-                fep->phy_dev->irq);
-
         return 0;
 
 failed_register:
@@ -1347,10 +1373,9 @@ fec_suspend(struct platform_device *dev, pm_message_t state)
 
         if (ndev) {
                 fep = netdev_priv(ndev);
-                if (netif_running(ndev)) {
-                        netif_device_detach(ndev);
-                        fec_stop(ndev);
-                }
+                if (netif_running(ndev))
+                        fec_enet_close(ndev);
+                clk_disable(fep->clk);
         }
         return 0;
 }
@@ -1359,12 +1384,13 @@ static int
 fec_resume(struct platform_device *dev)
 {
         struct net_device *ndev = platform_get_drvdata(dev);
+        struct fec_enet_private *fep;
 
         if (ndev) {
-                if (netif_running(ndev)) {
-                        fec_enet_init(ndev, 0);
-                        netif_device_attach(ndev);
-                }
+                fep = netdev_priv(ndev);
+                clk_enable(fep->clk);
+                if (netif_running(ndev))
+                        fec_enet_open(ndev);
         }
         return 0;
 }
diff --git a/drivers/net/fec.h b/drivers/net/fec.h
index cc47f3f057c7..2c48b25668d5 100644
--- a/drivers/net/fec.h
+++ b/drivers/net/fec.h
@@ -43,6 +43,8 @@
 #define FEC_R_DES_START         0x180 /* Receive descriptor ring */
 #define FEC_X_DES_START         0x184 /* Transmit descriptor ring */
 #define FEC_R_BUFF_SIZE         0x188 /* Maximum receive buff size */
+#define FEC_MIIGSK_CFGR         0x300 /* MIIGSK Configuration reg */
+#define FEC_MIIGSK_ENR          0x308 /* MIIGSK Enable reg */
 
 #else
 
diff --git a/drivers/net/fec_mpc52xx.c b/drivers/net/fec_mpc52xx.c
index 221f440c10f4..25e6cc6840b1 100644
--- a/drivers/net/fec_mpc52xx.c
+++ b/drivers/net/fec_mpc52xx.c
@@ -871,7 +871,7 @@ mpc52xx_fec_probe(struct of_device *op, const struct of_device_id *match)
         priv->ndev = ndev;
 
         /* Reserve FEC control zone */
-        rv = of_address_to_resource(op->node, 0, &mem);
+        rv = of_address_to_resource(op->dev.of_node, 0, &mem);
         if (rv) {
                 printk(KERN_ERR DRIVER_NAME ": "
                                 "Error while parsing device node resource\n" );
@@ -919,7 +919,7 @@ mpc52xx_fec_probe(struct of_device *op, const struct of_device_id *match)
 
         /* Get the IRQ we need one by one */
                 /* Control */
-        ndev->irq = irq_of_parse_and_map(op->node, 0);
+        ndev->irq = irq_of_parse_and_map(op->dev.of_node, 0);
 
                 /* RX */
         priv->r_irq = bcom_get_task_irq(priv->rx_dmatsk);
@@ -942,20 +942,20 @@ mpc52xx_fec_probe(struct of_device *op, const struct of_device_id *match)
         /* Start with safe defaults for link connection */
         priv->speed = 100;
         priv->duplex = DUPLEX_HALF;
-        priv->mdio_speed = ((mpc5xxx_get_bus_frequency(op->node) >> 20) / 5) << 1;
+        priv->mdio_speed = ((mpc5xxx_get_bus_frequency(op->dev.of_node) >> 20) / 5) << 1;
 
         /* The current speed preconfigures the speed of the MII link */
-        prop = of_get_property(op->node, "current-speed", &prop_size);
+        prop = of_get_property(op->dev.of_node, "current-speed", &prop_size);
         if (prop && (prop_size >= sizeof(u32) * 2)) {
                 priv->speed = prop[0];
                 priv->duplex = prop[1] ? DUPLEX_FULL : DUPLEX_HALF;
         }
 
         /* If there is a phy handle, then get the PHY node */
-        priv->phy_node = of_parse_phandle(op->node, "phy-handle", 0);
+        priv->phy_node = of_parse_phandle(op->dev.of_node, "phy-handle", 0);
 
         /* the 7-wire property means don't use MII mode */
-        if (of_find_property(op->node, "fsl,7-wire-mode", NULL)) {
+        if (of_find_property(op->dev.of_node, "fsl,7-wire-mode", NULL)) {
                 priv->seven_wire_mode = 1;
                 dev_info(&ndev->dev, "using 7-wire PHY mode\n");
         }
@@ -1063,9 +1063,11 @@ static struct of_device_id mpc52xx_fec_match[] = {
 MODULE_DEVICE_TABLE(of, mpc52xx_fec_match);
 
 static struct of_platform_driver mpc52xx_fec_driver = {
-        .owner          = THIS_MODULE,
-        .name           = DRIVER_NAME,
-        .match_table    = mpc52xx_fec_match,
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+                .of_match_table = mpc52xx_fec_match,
+        },
         .probe          = mpc52xx_fec_probe,
         .remove         = mpc52xx_fec_remove,
 #ifdef CONFIG_PM
diff --git a/drivers/net/fec_mpc52xx_phy.c b/drivers/net/fec_mpc52xx_phy.c
index 7658a082e390..006f64d9f96a 100644
--- a/drivers/net/fec_mpc52xx_phy.c
+++ b/drivers/net/fec_mpc52xx_phy.c
@@ -66,7 +66,7 @@ static int mpc52xx_fec_mdio_probe(struct of_device *of,
                 const struct of_device_id *match)
 {
         struct device *dev = &of->dev;
-        struct device_node *np = of->node;
+        struct device_node *np = of->dev.of_node;
         struct mii_bus *bus;
         struct mpc52xx_fec_mdio_priv *priv;
         struct resource res = {};
@@ -107,7 +107,7 @@ static int mpc52xx_fec_mdio_probe(struct of_device *of,
 
         /* set MII speed */
         out_be32(&priv->regs->mii_speed,
-                ((mpc5xxx_get_bus_frequency(of->node) >> 20) / 5) << 1);
+                ((mpc5xxx_get_bus_frequency(of->dev.of_node) >> 20) / 5) << 1);
 
         err = of_mdiobus_register(bus, np);
         if (err)
@@ -159,10 +159,13 @@ static struct of_device_id mpc52xx_fec_mdio_match[] = {
 MODULE_DEVICE_TABLE(of, mpc52xx_fec_mdio_match);
 
 struct of_platform_driver mpc52xx_fec_mdio_driver = {
-        .name = "mpc5200b-fec-phy",
+        .driver = {
+                .name = "mpc5200b-fec-phy",
+                .owner = THIS_MODULE,
+                .of_match_table = mpc52xx_fec_mdio_match,
+        },
         .probe = mpc52xx_fec_mdio_probe,
         .remove = mpc52xx_fec_mdio_remove,
-        .match_table = mpc52xx_fec_mdio_match,
 };
 
 /* let fec driver call it, since this has to be registered before it */
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
index 0fb0fefcb787..309a0eaddd81 100644
--- a/drivers/net/fs_enet/fs_enet-main.c
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -1013,7 +1013,7 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
                 return -ENOMEM;
 
         if (!IS_FEC(match)) {
-                data = of_get_property(ofdev->node, "fsl,cpm-command", &len);
+                data = of_get_property(ofdev->dev.of_node, "fsl,cpm-command", &len);
                 if (!data || len != 4)
                         goto out_free_fpi;
 
@@ -1025,8 +1025,8 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
         fpi->rx_copybreak = 240;
         fpi->use_napi = 1;
         fpi->napi_weight = 17;
-        fpi->phy_node = of_parse_phandle(ofdev->node, "phy-handle", 0);
-        if ((!fpi->phy_node) && (!of_get_property(ofdev->node, "fixed-link",
+        fpi->phy_node = of_parse_phandle(ofdev->dev.of_node, "phy-handle", 0);
+        if ((!fpi->phy_node) && (!of_get_property(ofdev->dev.of_node, "fixed-link",
                                                   NULL)))
                 goto out_free_fpi;
 
@@ -1059,7 +1059,7 @@ static int __devinit fs_enet_probe(struct of_device *ofdev,
         spin_lock_init(&fep->lock);
         spin_lock_init(&fep->tx_lock);
 
-        mac_addr = of_get_mac_address(ofdev->node);
+        mac_addr = of_get_mac_address(ofdev->dev.of_node);
         if (mac_addr)
                 memcpy(ndev->dev_addr, mac_addr, 6);
 
@@ -1156,8 +1156,11 @@ static struct of_device_id fs_enet_match[] = {
 MODULE_DEVICE_TABLE(of, fs_enet_match);
 
 static struct of_platform_driver fs_enet_driver = {
-        .name   = "fs_enet",
-        .match_table = fs_enet_match,
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "fs_enet",
+                .of_match_table = fs_enet_match,
+        },
         .probe = fs_enet_probe,
         .remove = fs_enet_remove,
 };
diff --git a/drivers/net/fs_enet/mac-fcc.c b/drivers/net/fs_enet/mac-fcc.c
index 714da967fa19..48e91b6242ce 100644
--- a/drivers/net/fs_enet/mac-fcc.c
+++ b/drivers/net/fs_enet/mac-fcc.c
@@ -88,19 +88,19 @@ static int do_pd_setup(struct fs_enet_private *fep)
         struct fs_platform_info *fpi = fep->fpi;
         int ret = -EINVAL;
 
-        fep->interrupt = of_irq_to_resource(ofdev->node, 0, NULL);
+        fep->interrupt = of_irq_to_resource(ofdev->dev.of_node, 0, NULL);
         if (fep->interrupt == NO_IRQ)
                 goto out;
 
-        fep->fcc.fccp = of_iomap(ofdev->node, 0);
+        fep->fcc.fccp = of_iomap(ofdev->dev.of_node, 0);
         if (!fep->fcc.fccp)
                 goto out;
 
-        fep->fcc.ep = of_iomap(ofdev->node, 1);
+        fep->fcc.ep = of_iomap(ofdev->dev.of_node, 1);
         if (!fep->fcc.ep)
                 goto out_fccp;
 
-        fep->fcc.fcccp = of_iomap(ofdev->node, 2);
+        fep->fcc.fcccp = of_iomap(ofdev->dev.of_node, 2);
         if (!fep->fcc.fcccp)
                 goto out_ep;
 
@@ -504,17 +504,54 @@ static int get_regs_len(struct net_device *dev)
 }
 
 /* Some transmit errors cause the transmitter to shut
- * down.  We now issue a restart transmit.  Since the
- * errors close the BD and update the pointers, the restart
- * _should_ pick up without having to reset any of our
- * pointers either.  Also, To workaround 8260 device erratum
- * CPM37, we must disable and then re-enable the transmitter
- * following a Late Collision, Underrun, or Retry Limit error.
+ * down.  We now issue a restart transmit.
+ * Also, to workaround 8260 device erratum CPM37, we must
+ * disable and then re-enable the transmitterfollowing a
+ * Late Collision, Underrun, or Retry Limit error.
+ * In addition, tbptr may point beyond BDs beyond still marked
+ * as ready due to internal pipelining, so we need to look back
+ * through the BDs and adjust tbptr to point to the last BD
+ * marked as ready.  This may result in some buffers being
+ * retransmitted.
  */
 static void tx_restart(struct net_device *dev)
 {
         struct fs_enet_private *fep = netdev_priv(dev);
         fcc_t __iomem *fccp = fep->fcc.fccp;
+        const struct fs_platform_info *fpi = fep->fpi;
+        fcc_enet_t __iomem *ep = fep->fcc.ep;
+        cbd_t __iomem *curr_tbptr;
+        cbd_t __iomem *recheck_bd;
+        cbd_t __iomem *prev_bd;
+        cbd_t __iomem *last_tx_bd;
+
+        last_tx_bd = fep->tx_bd_base + (fpi->tx_ring * sizeof(cbd_t));
+
+        /* get the current bd held in TBPTR  and scan back from this point */
+        recheck_bd = curr_tbptr = (cbd_t __iomem *)
+                ((R32(ep, fen_genfcc.fcc_tbptr) - fep->ring_mem_addr) +
+                fep->ring_base);
+
+        prev_bd = (recheck_bd == fep->tx_bd_base) ? last_tx_bd : recheck_bd - 1;
+
+        /* Move through the bds in reverse, look for the earliest buffer
+         * that is not ready.  Adjust TBPTR to the following buffer */
+        while ((CBDR_SC(prev_bd) & BD_ENET_TX_READY) != 0) {
+                /* Go back one buffer */
+                recheck_bd = prev_bd;
+
+                /* update the previous buffer */
+                prev_bd = (prev_bd == fep->tx_bd_base) ? last_tx_bd : prev_bd - 1;
+
+                /* We should never see all bds marked as ready, check anyway */
+                if (recheck_bd == curr_tbptr)
+                        break;
+        }
+        /* Now update the TBPTR and dirty flag to the current buffer */
+        W32(ep, fen_genfcc.fcc_tbptr,
+                (uint) (((void *)recheck_bd - fep->ring_base) +
+                fep->ring_mem_addr));
+        fep->dirty_tx = recheck_bd;
 
         C32(fccp, fcc_gfmr, FCC_GFMR_ENT);
         udelay(10);
diff --git a/drivers/net/fs_enet/mac-fec.c b/drivers/net/fs_enet/mac-fec.c
index 7eff92ef01da..7ca1642276d0 100644
--- a/drivers/net/fs_enet/mac-fec.c
+++ b/drivers/net/fs_enet/mac-fec.c
@@ -98,11 +98,11 @@ static int do_pd_setup(struct fs_enet_private *fep)
 {
         struct of_device *ofdev = to_of_device(fep->dev);
 
-        fep->interrupt = of_irq_to_resource(ofdev->node, 0, NULL);
+        fep->interrupt = of_irq_to_resource(ofdev->dev.of_node, 0, NULL);
         if (fep->interrupt == NO_IRQ)
                 return -EINVAL;
 
-        fep->fec.fecp = of_iomap(ofdev->node, 0);
+        fep->fec.fecp = of_iomap(ofdev->dev.of_node, 0);
         if (!fep->fcc.fccp)
                 return -EINVAL;
 
diff --git a/drivers/net/fs_enet/mac-scc.c b/drivers/net/fs_enet/mac-scc.c
index 7f0591e43cd9..a3c44544846d 100644
--- a/drivers/net/fs_enet/mac-scc.c
+++ b/drivers/net/fs_enet/mac-scc.c
@@ -98,15 +98,15 @@ static int do_pd_setup(struct fs_enet_private *fep)
 {
         struct of_device *ofdev = to_of_device(fep->dev);
 
-        fep->interrupt = of_irq_to_resource(ofdev->node, 0, NULL);
+        fep->interrupt = of_irq_to_resource(ofdev->dev.of_node, 0, NULL);
         if (fep->interrupt == NO_IRQ)
                 return -EINVAL;
 
-        fep->scc.sccp = of_iomap(ofdev->node, 0);
+        fep->scc.sccp = of_iomap(ofdev->dev.of_node, 0);
         if (!fep->scc.sccp)
                 return -EINVAL;
 
-        fep->scc.ep = of_iomap(ofdev->node, 1);
+        fep->scc.ep = of_iomap(ofdev->dev.of_node, 1);
         if (!fep->scc.ep) {
                 iounmap(fep->scc.sccp);
                 return -EINVAL;
diff --git a/drivers/net/fs_enet/mii-bitbang.c b/drivers/net/fs_enet/mii-bitbang.c
index 24ff9f43a62b..3607340f3da7 100644
--- a/drivers/net/fs_enet/mii-bitbang.c
+++ b/drivers/net/fs_enet/mii-bitbang.c
@@ -169,7 +169,7 @@ static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
 
         new_bus->name = "CPM2 Bitbanged MII",
 
-        ret = fs_mii_bitbang_init(new_bus, ofdev->node);
+        ret = fs_mii_bitbang_init(new_bus, ofdev->dev.of_node);
         if (ret)
                 goto out_free_bus;
 
@@ -181,7 +181,7 @@ static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
         new_bus->parent = &ofdev->dev;
         dev_set_drvdata(&ofdev->dev, new_bus);
 
-        ret = of_mdiobus_register(new_bus, ofdev->node);
+        ret = of_mdiobus_register(new_bus, ofdev->dev.of_node);
         if (ret)
                 goto out_free_irqs;
 
@@ -224,8 +224,11 @@ static struct of_device_id fs_enet_mdio_bb_match[] = {
 MODULE_DEVICE_TABLE(of, fs_enet_mdio_bb_match);
 
 static struct of_platform_driver fs_enet_bb_mdio_driver = {
-        .name = "fsl-bb-mdio",
-        .match_table = fs_enet_mdio_bb_match,
+        .driver = {
+                .name = "fsl-bb-mdio",
+                .owner = THIS_MODULE,
+                .of_match_table = fs_enet_mdio_bb_match,
+        },
         .probe = fs_enet_mdio_probe,
         .remove = fs_enet_mdio_remove,
 };
diff --git a/drivers/net/fs_enet/mii-fec.c b/drivers/net/fs_enet/mii-fec.c
index 5944b65082cb..bddffd169b93 100644
--- a/drivers/net/fs_enet/mii-fec.c
+++ b/drivers/net/fs_enet/mii-fec.c
@@ -124,7 +124,7 @@ static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
         new_bus->write = &fs_enet_fec_mii_write;
         new_bus->reset = &fs_enet_fec_mii_reset;
 
-        ret = of_address_to_resource(ofdev->node, 0, &res);
+        ret = of_address_to_resource(ofdev->dev.of_node, 0, &res);
         if (ret)
                 goto out_res;
 
@@ -135,7 +135,7 @@ static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
                 goto out_fec;
 
         if (get_bus_freq) {
-                clock = get_bus_freq(ofdev->node);
+                clock = get_bus_freq(ofdev->dev.of_node);
                 if (!clock) {
                         /* Use maximum divider if clock is unknown */
                         dev_warn(&ofdev->dev, "could not determine IPS clock\n");
@@ -172,7 +172,7 @@ static int __devinit fs_enet_mdio_probe(struct of_device *ofdev,
         new_bus->parent = &ofdev->dev;
         dev_set_drvdata(&ofdev->dev, new_bus);
 
-        ret = of_mdiobus_register(new_bus, ofdev->node);
+        ret = of_mdiobus_register(new_bus, ofdev->dev.of_node);
         if (ret)
                 goto out_free_irqs;
 
@@ -222,8 +222,11 @@ static struct of_device_id fs_enet_mdio_fec_match[] = {
 MODULE_DEVICE_TABLE(of, fs_enet_mdio_fec_match);
 
 static struct of_platform_driver fs_enet_fec_mdio_driver = {
-        .name = "fsl-fec-mdio",
-        .match_table = fs_enet_mdio_fec_match,
+        .driver = {
+                .name = "fsl-fec-mdio",
+                .owner = THIS_MODULE,
+                .of_match_table = fs_enet_mdio_fec_match,
+        },
         .probe = fs_enet_mdio_probe,
         .remove = fs_enet_mdio_remove,
 };
diff --git a/drivers/net/fsl_pq_mdio.c b/drivers/net/fsl_pq_mdio.c
index ff028f59b930..b4c41d72c423 100644
--- a/drivers/net/fsl_pq_mdio.c
+++ b/drivers/net/fsl_pq_mdio.c
@@ -267,7 +267,7 @@ static int get_ucc_id_for_range(u64 start, u64 end, u32 *ucc_id)
 static int fsl_pq_mdio_probe(struct of_device *ofdev,
                 const struct of_device_id *match)
 {
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct device_node *tbi;
         struct fsl_pq_mdio_priv *priv;
         struct fsl_pq_mdio __iomem *regs = NULL;
@@ -471,10 +471,13 @@ static struct of_device_id fsl_pq_mdio_match[] = {
 MODULE_DEVICE_TABLE(of, fsl_pq_mdio_match);
 
 static struct of_platform_driver fsl_pq_mdio_driver = {
-        .name = "fsl-pq_mdio",
+        .driver = {
+                .name = "fsl-pq_mdio",
+                .owner = THIS_MODULE,
+                .of_match_table = fsl_pq_mdio_match,
+        },
         .probe = fsl_pq_mdio_probe,
         .remove = fsl_pq_mdio_remove,
-        .match_table = fsl_pq_mdio_match,
 };
 
 int __init fsl_pq_mdio_init(void)
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index b3ca36270ce7..ba190376e030 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -608,7 +608,7 @@ static int gfar_of_init(struct of_device *ofdev, struct net_device **pdev)
         int err = 0, i;
         struct net_device *dev = NULL;
         struct gfar_private *priv = NULL;
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct device_node *child = NULL;
         const u32 *stash;
         const u32 *stash_len;
@@ -646,7 +646,7 @@ static int gfar_of_init(struct of_device *ofdev, struct net_device **pdev)
                 return -ENOMEM;
 
         priv = netdev_priv(dev);
-        priv->node = ofdev->node;
+        priv->node = ofdev->dev.of_node;
         priv->ndev = dev;
 
         dev->num_tx_queues = num_tx_qs;
@@ -747,8 +747,7 @@ static int gfar_of_init(struct of_device *ofdev, struct net_device **pdev)
                         FSL_GIANFAR_DEV_HAS_CSUM |
                         FSL_GIANFAR_DEV_HAS_VLAN |
                         FSL_GIANFAR_DEV_HAS_MAGIC_PACKET |
-                        FSL_GIANFAR_DEV_HAS_EXTENDED_HASH |
-                        FSL_GIANFAR_DEV_HAS_TIMER;
+                        FSL_GIANFAR_DEV_HAS_EXTENDED_HASH;
 
         ctype = of_get_property(np, "phy-connection-type", NULL);
 
@@ -939,7 +938,7 @@ static int gfar_probe(struct of_device *ofdev,
         priv = netdev_priv(dev);
         priv->ndev = dev;
         priv->ofdev = ofdev;
-        priv->node = ofdev->node;
+        priv->node = ofdev->dev.of_node;
         SET_NETDEV_DEV(dev, &ofdev->dev);
 
         spin_lock_init(&priv->bflock);
@@ -3167,12 +3166,14 @@ MODULE_DEVICE_TABLE(of, gfar_match);
 
 /* Structure for a device driver */
 static struct of_platform_driver gfar_driver = {
-        .name = "fsl-gianfar",
-        .match_table = gfar_match,
-
+        .driver = {
+                .name = "fsl-gianfar",
+                .owner = THIS_MODULE,
+                .pm = GFAR_PM_OPS,
+                .of_match_table = gfar_match,
+        },
         .probe = gfar_probe,
         .remove = gfar_remove,
-        .driver.pm = GFAR_PM_OPS,
 };
 
 static int __init gfar_init(void)
diff --git a/drivers/net/greth.c b/drivers/net/greth.c
index fd491e409488..3a029d02c2b4 100644
--- a/drivers/net/greth.c
+++ b/drivers/net/greth.c
@@ -1499,7 +1499,8 @@ static int __devinit greth_of_probe(struct of_device *ofdev, const struct of_dev
         if (i == 6) {
                 const unsigned char *addr;
                 int len;
-                addr = of_get_property(ofdev->node, "local-mac-address", &len);
+                addr = of_get_property(ofdev->dev.of_node, "local-mac-address",
+                                        &len);
                 if (addr != NULL && len == 6) {
                         for (i = 0; i < 6; i++)
                                 macaddr[i] = (unsigned int) addr[i];
@@ -1606,14 +1607,13 @@ static struct of_device_id greth_of_match[] = {
 MODULE_DEVICE_TABLE(of, greth_of_match);
 
 static struct of_platform_driver greth_of_driver = {
-        .name = "grlib-greth",
-        .match_table = greth_of_match,
+        .driver = {
+                .name = "grlib-greth",
+                .owner = THIS_MODULE,
+                .of_match_table = greth_of_match,
+        },
         .probe = greth_of_probe,
         .remove = __devexit_p(greth_of_remove),
-        .driver = {
-                   .owner = THIS_MODULE,
-                   .name = "grlib-greth",
-                   },
 };
 
 static int __init greth_init(void)
diff --git a/drivers/net/hamradio/yam.c b/drivers/net/hamradio/yam.c
index 694132e04af6..4e7d1d0a2340 100644
--- a/drivers/net/hamradio/yam.c
+++ b/drivers/net/hamradio/yam.c
@@ -1151,8 +1151,7 @@ static int __init yam_init_driver(void)
                 dev = alloc_netdev(sizeof(struct yam_port), name,
                                    yam_setup);
                 if (!dev) {
-                        printk(KERN_ERR "yam: cannot allocate net device %s\n",
-                               dev->name);
+                        pr_err("yam: cannot allocate net device\n");
                         err = -ENOMEM;
                         goto error;
                 }
diff --git a/drivers/net/ibm_newemac/core.c b/drivers/net/ibm_newemac/core.c
index 6a45f8f3a0c7..0f1d4e96cf89 100644
--- a/drivers/net/ibm_newemac/core.c
+++ b/drivers/net/ibm_newemac/core.c
@@ -136,7 +136,8 @@ static inline void emac_report_timeout_error(struct emac_instance *dev,
                                   EMAC_FTR_440EP_PHY_CLK_FIX))
                 DBG(dev, "%s" NL, error);
         else if (net_ratelimit())
-                printk(KERN_ERR "%s: %s\n", dev->ofdev->node->full_name, error);
+                printk(KERN_ERR "%s: %s\n", dev->ofdev->dev.of_node->full_name,
+                        error);
 }
 
 /* EMAC PHY clock workaround:
@@ -2185,7 +2186,7 @@ static void emac_ethtool_get_drvinfo(struct net_device *ndev,
         strcpy(info->version, DRV_VERSION);
         info->fw_version[0] = '\0';
         sprintf(info->bus_info, "PPC 4xx EMAC-%d %s",
-                dev->cell_index, dev->ofdev->node->full_name);
+                dev->cell_index, dev->ofdev->dev.of_node->full_name);
         info->regdump_len = emac_ethtool_get_regs_len(ndev);
 }
 
@@ -2379,7 +2380,7 @@ static int __devinit emac_read_uint_prop(struct device_node *np, const char *nam
 
 static int __devinit emac_init_phy(struct emac_instance *dev)
 {
-        struct device_node *np = dev->ofdev->node;
+        struct device_node *np = dev->ofdev->dev.of_node;
         struct net_device *ndev = dev->ndev;
         u32 phy_map, adv;
         int i;
@@ -2514,7 +2515,7 @@ static int __devinit emac_init_phy(struct emac_instance *dev)
 
 static int __devinit emac_init_config(struct emac_instance *dev)
 {
-        struct device_node *np = dev->ofdev->node;
+        struct device_node *np = dev->ofdev->dev.of_node;
         const void *p;
         unsigned int plen;
         const char *pm, *phy_modes[] = {
@@ -2723,7 +2724,7 @@ static int __devinit emac_probe(struct of_device *ofdev,
 {
         struct net_device *ndev;
         struct emac_instance *dev;
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct device_node **blist = NULL;
         int err, i;
 
@@ -2810,7 +2811,7 @@ static int __devinit emac_probe(struct of_device *ofdev,
         err = mal_register_commac(dev->mal, &dev->commac);
         if (err) {
                 printk(KERN_ERR "%s: failed to register with mal %s!\n",
-                       np->full_name, dev->mal_dev->node->full_name);
+                       np->full_name, dev->mal_dev->dev.of_node->full_name);
                 goto err_rel_deps;
         }
         dev->rx_skb_size = emac_rx_skb_size(ndev->mtu);
@@ -2995,9 +2996,11 @@ static struct of_device_id emac_match[] =
 MODULE_DEVICE_TABLE(of, emac_match);
 
 static struct of_platform_driver emac_driver = {
-        .name = "emac",
-        .match_table = emac_match,
-
+        .driver = {
+                .name = "emac",
+                .owner = THIS_MODULE,
+                .of_match_table = emac_match,
+        },
         .probe = emac_probe,
         .remove = emac_remove,
 };
diff --git a/drivers/net/ibm_newemac/debug.c b/drivers/net/ibm_newemac/debug.c
index 775c850a425a..3995fafc1e08 100644
--- a/drivers/net/ibm_newemac/debug.c
+++ b/drivers/net/ibm_newemac/debug.c
@@ -33,7 +33,7 @@ static void emac_desc_dump(struct emac_instance *p)
         int i;
         printk("** EMAC %s TX BDs **\n"
                " tx_cnt = %d tx_slot = %d ack_slot = %d\n",
-               p->ofdev->node->full_name,
+               p->ofdev->dev.of_node->full_name,
                p->tx_cnt, p->tx_slot, p->ack_slot);
         for (i = 0; i < NUM_TX_BUFF / 2; ++i)
                 printk
@@ -49,7 +49,7 @@ static void emac_desc_dump(struct emac_instance *p)
         printk("** EMAC %s RX BDs **\n"
                " rx_slot = %d flags = 0x%lx rx_skb_size = %d rx_sync_size = %d\n"
                " rx_sg_skb = 0x%p\n",
-               p->ofdev->node->full_name,
+               p->ofdev->dev.of_node->full_name,
                p->rx_slot, p->commac.flags, p->rx_skb_size,
                p->rx_sync_size, p->rx_sg_skb);
         for (i = 0; i < NUM_RX_BUFF / 2; ++i)
@@ -77,7 +77,8 @@ static void emac_mac_dump(struct emac_instance *dev)
                "MR0 = 0x%08x MR1 = 0x%08x TMR0 = 0x%08x TMR1 = 0x%08x\n"
                "RMR = 0x%08x ISR = 0x%08x ISER = 0x%08x\n"
                "IAR = %04x%08x VTPID = 0x%04x VTCI = 0x%04x\n",
-               dev->ofdev->node->full_name, in_be32(&p->mr0), in_be32(&p->mr1),
+               dev->ofdev->dev.of_node->full_name,
+               in_be32(&p->mr0), in_be32(&p->mr1),
                in_be32(&p->tmr0), in_be32(&p->tmr1),
                in_be32(&p->rmr), in_be32(&p->isr), in_be32(&p->iser),
                in_be32(&p->iahr), in_be32(&p->ialr), in_be32(&p->vtpid),
@@ -128,7 +129,7 @@ static void emac_mal_dump(struct mal_instance *mal)
                "CFG = 0x%08x ESR = 0x%08x IER = 0x%08x\n"
                "TX|CASR = 0x%08x CARR = 0x%08x EOBISR = 0x%08x DEIR = 0x%08x\n"
                "RX|CASR = 0x%08x CARR = 0x%08x EOBISR = 0x%08x DEIR = 0x%08x\n",
-               mal->ofdev->node->full_name,
+               mal->ofdev->dev.of_node->full_name,
                get_mal_dcrn(mal, MAL_CFG), get_mal_dcrn(mal, MAL_ESR),
                get_mal_dcrn(mal, MAL_IER),
                get_mal_dcrn(mal, MAL_TXCASR), get_mal_dcrn(mal, MAL_TXCARR),
diff --git a/drivers/net/ibm_newemac/debug.h b/drivers/net/ibm_newemac/debug.h
index b631842ec8d0..e596c77ccdf7 100644
--- a/drivers/net/ibm_newemac/debug.h
+++ b/drivers/net/ibm_newemac/debug.h
@@ -53,8 +53,8 @@ extern void emac_dbg_dump_all(void);
 
 #endif
 
-#define EMAC_DBG(dev, name, fmt, arg...) \
-        printk(KERN_DEBUG #name "%s: " fmt, dev->ofdev->node->full_name, ## arg)
+#define EMAC_DBG(d, name, fmt, arg...) \
+        printk(KERN_DEBUG #name "%s: " fmt, d->ofdev->dev.of_node->full_name, ## arg)
 
 #if DBG_LEVEL > 0
 #  define DBG(d,f,x...)         EMAC_DBG(d, emac, f, ##x)
diff --git a/drivers/net/ibm_newemac/mal.c b/drivers/net/ibm_newemac/mal.c
index 5b3d94419fe6..fcff9e0bd382 100644
--- a/drivers/net/ibm_newemac/mal.c
+++ b/drivers/net/ibm_newemac/mal.c
@@ -538,11 +538,11 @@ static int __devinit mal_probe(struct of_device *ofdev,
         }
         mal->index = index;
         mal->ofdev = ofdev;
-        mal->version = of_device_is_compatible(ofdev->node, "ibm,mcmal2") ? 2 : 1;
+        mal->version = of_device_is_compatible(ofdev->dev.of_node, "ibm,mcmal2") ? 2 : 1;
 
         MAL_DBG(mal, "probe" NL);
 
-        prop = of_get_property(ofdev->node, "num-tx-chans", NULL);
+        prop = of_get_property(ofdev->dev.of_node, "num-tx-chans", NULL);
         if (prop == NULL) {
                 printk(KERN_ERR
                        "mal%d: can't find MAL num-tx-chans property!\n",
@@ -552,7 +552,7 @@ static int __devinit mal_probe(struct of_device *ofdev,
         }
         mal->num_tx_chans = prop[0];
 
-        prop = of_get_property(ofdev->node, "num-rx-chans", NULL);
+        prop = of_get_property(ofdev->dev.of_node, "num-rx-chans", NULL);
         if (prop == NULL) {
                 printk(KERN_ERR
                        "mal%d: can't find MAL num-rx-chans property!\n",
@@ -562,14 +562,14 @@ static int __devinit mal_probe(struct of_device *ofdev,
         }
         mal->num_rx_chans = prop[0];
 
-        dcr_base = dcr_resource_start(ofdev->node, 0);
+        dcr_base = dcr_resource_start(ofdev->dev.of_node, 0);
         if (dcr_base == 0) {
                 printk(KERN_ERR
                        "mal%d: can't find DCR resource!\n", index);
                 err = -ENODEV;
                 goto fail;
         }
-        mal->dcr_host = dcr_map(ofdev->node, dcr_base, 0x100);
+        mal->dcr_host = dcr_map(ofdev->dev.of_node, dcr_base, 0x100);
         if (!DCR_MAP_OK(mal->dcr_host)) {
                 printk(KERN_ERR
                        "mal%d: failed to map DCRs !\n", index);
@@ -577,28 +577,28 @@ static int __devinit mal_probe(struct of_device *ofdev,
                 goto fail;
         }
 
-        if (of_device_is_compatible(ofdev->node, "ibm,mcmal-405ez")) {
+        if (of_device_is_compatible(ofdev->dev.of_node, "ibm,mcmal-405ez")) {
 #if defined(CONFIG_IBM_NEW_EMAC_MAL_CLR_ICINTSTAT) && \
                 defined(CONFIG_IBM_NEW_EMAC_MAL_COMMON_ERR)
                 mal->features |= (MAL_FTR_CLEAR_ICINTSTAT |
                                 MAL_FTR_COMMON_ERR_INT);
 #else
                 printk(KERN_ERR "%s: Support for 405EZ not enabled!\n",
-                                ofdev->node->full_name);
+                                ofdev->dev.of_node->full_name);
                 err = -ENODEV;
                 goto fail;
 #endif
         }
 
-        mal->txeob_irq = irq_of_parse_and_map(ofdev->node, 0);
-        mal->rxeob_irq = irq_of_parse_and_map(ofdev->node, 1);
-        mal->serr_irq = irq_of_parse_and_map(ofdev->node, 2);
+        mal->txeob_irq = irq_of_parse_and_map(ofdev->dev.of_node, 0);
+        mal->rxeob_irq = irq_of_parse_and_map(ofdev->dev.of_node, 1);
+        mal->serr_irq = irq_of_parse_and_map(ofdev->dev.of_node, 2);
 
         if (mal_has_feature(mal, MAL_FTR_COMMON_ERR_INT)) {
                 mal->txde_irq = mal->rxde_irq = mal->serr_irq;
         } else {
-                mal->txde_irq = irq_of_parse_and_map(ofdev->node, 3);
-                mal->rxde_irq = irq_of_parse_and_map(ofdev->node, 4);
+                mal->txde_irq = irq_of_parse_and_map(ofdev->dev.of_node, 3);
+                mal->rxde_irq = irq_of_parse_and_map(ofdev->dev.of_node, 4);
         }
 
         if (mal->txeob_irq == NO_IRQ || mal->rxeob_irq == NO_IRQ ||
@@ -629,7 +629,7 @@ static int __devinit mal_probe(struct of_device *ofdev,
         /* Current Axon is not happy with priority being non-0, it can
          * deadlock, fix it up here
          */
-        if (of_device_is_compatible(ofdev->node, "ibm,mcmal-axon"))
+        if (of_device_is_compatible(ofdev->dev.of_node, "ibm,mcmal-axon"))
                 cfg &= ~(MAL2_CFG_RPP_10 | MAL2_CFG_WPP_10);
 
         /* Apply configuration */
@@ -701,7 +701,7 @@ static int __devinit mal_probe(struct of_device *ofdev,
 
         printk(KERN_INFO
                "MAL v%d %s, %d TX channels, %d RX channels\n",
-               mal->version, ofdev->node->full_name,
+               mal->version, ofdev->dev.of_node->full_name,
                mal->num_tx_chans, mal->num_rx_chans);
 
         /* Advertise this instance to the rest of the world */
@@ -790,9 +790,11 @@ static struct of_device_id mal_platform_match[] =
 };
 
 static struct of_platform_driver mal_of_driver = {
-        .name = "mcmal",
-        .match_table = mal_platform_match,
-
+        .driver = {
+                .name = "mcmal",
+                .owner = THIS_MODULE,
+                .of_match_table = mal_platform_match,
+        },
         .probe = mal_probe,
         .remove = mal_remove,
 };
diff --git a/drivers/net/ibm_newemac/rgmii.c b/drivers/net/ibm_newemac/rgmii.c
index 5b90d34c8455..108919bcdf13 100644
--- a/drivers/net/ibm_newemac/rgmii.c
+++ b/drivers/net/ibm_newemac/rgmii.c
@@ -103,7 +103,7 @@ int __devinit rgmii_attach(struct of_device *ofdev, int input, int mode)
         /* Check if we need to attach to a RGMII */
         if (input < 0 || !rgmii_valid_mode(mode)) {
                 printk(KERN_ERR "%s: unsupported settings !\n",
-                       ofdev->node->full_name);
+                       ofdev->dev.of_node->full_name);
                 return -ENODEV;
         }
 
@@ -113,7 +113,7 @@ int __devinit rgmii_attach(struct of_device *ofdev, int input, int mode)
         out_be32(&p->fer, in_be32(&p->fer) | rgmii_mode_mask(mode, input));
 
         printk(KERN_NOTICE "%s: input %d in %s mode\n",
-               ofdev->node->full_name, input, rgmii_mode_name(mode));
+               ofdev->dev.of_node->full_name, input, rgmii_mode_name(mode));
 
         ++dev->users;
 
@@ -231,7 +231,7 @@ void *rgmii_dump_regs(struct of_device *ofdev, void *buf)
 static int __devinit rgmii_probe(struct of_device *ofdev,
                                  const struct of_device_id *match)
 {
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct rgmii_instance *dev;
         struct resource regs;
         int rc;
@@ -264,11 +264,11 @@ static int __devinit rgmii_probe(struct of_device *ofdev,
         }
 
         /* Check for RGMII flags */
-        if (of_get_property(ofdev->node, "has-mdio", NULL))
+        if (of_get_property(ofdev->dev.of_node, "has-mdio", NULL))
                 dev->flags |= EMAC_RGMII_FLAG_HAS_MDIO;
 
         /* CAB lacks the right properties, fix this up */
-        if (of_device_is_compatible(ofdev->node, "ibm,rgmii-axon"))
+        if (of_device_is_compatible(ofdev->dev.of_node, "ibm,rgmii-axon"))
                 dev->flags |= EMAC_RGMII_FLAG_HAS_MDIO;
 
         DBG2(dev, " Boot FER = 0x%08x, SSR = 0x%08x\n",
@@ -279,7 +279,7 @@ static int __devinit rgmii_probe(struct of_device *ofdev,
 
         printk(KERN_INFO
                "RGMII %s initialized with%s MDIO support\n",
-               ofdev->node->full_name,
+               ofdev->dev.of_node->full_name,
                (dev->flags & EMAC_RGMII_FLAG_HAS_MDIO) ? "" : "out");
 
         wmb();
@@ -319,9 +319,11 @@ static struct of_device_id rgmii_match[] =
 };
 
 static struct of_platform_driver rgmii_driver = {
-        .name = "emac-rgmii",
-        .match_table = rgmii_match,
-
+        .driver = {
+                .name = "emac-rgmii",
+                .owner = THIS_MODULE,
+                .of_match_table = rgmii_match,
+        },
         .probe = rgmii_probe,
         .remove = rgmii_remove,
 };
diff --git a/drivers/net/ibm_newemac/tah.c b/drivers/net/ibm_newemac/tah.c
index 30173a9fb557..044637144c43 100644
--- a/drivers/net/ibm_newemac/tah.c
+++ b/drivers/net/ibm_newemac/tah.c
@@ -57,7 +57,8 @@ void tah_reset(struct of_device *ofdev)
                 --n;
 
         if (unlikely(!n))
-                printk(KERN_ERR "%s: reset timeout\n", ofdev->node->full_name);
+                printk(KERN_ERR "%s: reset timeout\n",
+                        ofdev->dev.of_node->full_name);
 
         /* 10KB TAH TX FIFO accomodates the max MTU of 9000 */
         out_be32(&p->mr,
@@ -89,7 +90,7 @@ void *tah_dump_regs(struct of_device *ofdev, void *buf)
 static int __devinit tah_probe(struct of_device *ofdev,
                                const struct of_device_id *match)
 {
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct tah_instance *dev;
         struct resource regs;
         int rc;
@@ -127,7 +128,7 @@ static int __devinit tah_probe(struct of_device *ofdev,
         tah_reset(ofdev);
 
         printk(KERN_INFO
-               "TAH %s initialized\n", ofdev->node->full_name);
+               "TAH %s initialized\n", ofdev->dev.of_node->full_name);
         wmb();
 
         return 0;
@@ -165,9 +166,11 @@ static struct of_device_id tah_match[] =
 };
 
 static struct of_platform_driver tah_driver = {
-        .name = "emac-tah",
-        .match_table = tah_match,
-
+        .driver = {
+                .name = "emac-tah",
+                .owner = THIS_MODULE,
+                .of_match_table = tah_match,
+        },
         .probe = tah_probe,
         .remove = tah_remove,
 };
diff --git a/drivers/net/ibm_newemac/zmii.c b/drivers/net/ibm_newemac/zmii.c
index 1f038f808ab3..046dcd069c45 100644
--- a/drivers/net/ibm_newemac/zmii.c
+++ b/drivers/net/ibm_newemac/zmii.c
@@ -121,13 +121,14 @@ int __devinit zmii_attach(struct of_device *ofdev, int input, int *mode)
                         dev->mode = *mode;
 
                 printk(KERN_NOTICE "%s: bridge in %s mode\n",
-                       ofdev->node->full_name, zmii_mode_name(dev->mode));
+                       ofdev->dev.of_node->full_name,
+                       zmii_mode_name(dev->mode));
         } else {
                 /* All inputs must use the same mode */
                 if (*mode != PHY_MODE_NA && *mode != dev->mode) {
                         printk(KERN_ERR
                                "%s: invalid mode %d specified for input %d\n",
-                               ofdev->node->full_name, *mode, input);
+                               ofdev->dev.of_node->full_name, *mode, input);
                         mutex_unlock(&dev->lock);
                         return -EINVAL;
                 }
@@ -233,7 +234,7 @@ void *zmii_dump_regs(struct of_device *ofdev, void *buf)
 static int __devinit zmii_probe(struct of_device *ofdev,
                                 const struct of_device_id *match)
 {
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct zmii_instance *dev;
         struct resource regs;
         int rc;
@@ -273,7 +274,7 @@ static int __devinit zmii_probe(struct of_device *ofdev,
         out_be32(&dev->base->fer, 0);
 
         printk(KERN_INFO
-               "ZMII %s initialized\n", ofdev->node->full_name);
+               "ZMII %s initialized\n", ofdev->dev.of_node->full_name);
         wmb();
         dev_set_drvdata(&ofdev->dev, dev);
 
@@ -312,9 +313,11 @@ static struct of_device_id zmii_match[] =
 };
 
 static struct of_platform_driver zmii_driver = {
-        .name = "emac-zmii",
-        .match_table = zmii_match,
-
+        .driver = {
+                .name = "emac-zmii",
+                .owner = THIS_MODULE,
+                .of_match_table = zmii_match,
+        },
         .probe = zmii_probe,
         .remove = zmii_remove,
 };
diff --git a/drivers/net/irda/bfin_sir.c b/drivers/net/irda/bfin_sir.c
index 911c082cee5a..f940dfa1f7f8 100644
--- a/drivers/net/irda/bfin_sir.c
+++ b/drivers/net/irda/bfin_sir.c
@@ -107,8 +107,12 @@ static int bfin_sir_set_speed(struct bfin_sir_port *port, int speed)
         case 57600:
         case 115200:
 
-                quot = (port->clk + (8 * speed)) / (16 * speed)\
-                                                - ANOMALY_05000230;
+                /*
+                 * IRDA is not affected by anomaly 05000230, so there is no
+                 * need to tweak the divisor like he UART driver (which will
+                 * slightly speed up the baud rate on us).
+                 */
+                quot = (port->clk + (8 * speed)) / (16 * speed);
 
                 do {
                         udelay(utime);
diff --git a/drivers/net/ixgbe/ixgbe.h b/drivers/net/ixgbe/ixgbe.h
index d0ea3d6dea95..ffae480587ae 100644
--- a/drivers/net/ixgbe/ixgbe.h
+++ b/drivers/net/ixgbe/ixgbe.h
@@ -360,6 +360,7 @@ struct ixgbe_adapter {
         u32 flags2;
 #define IXGBE_FLAG2_RSC_CAPABLE                 (u32)(1)
 #define IXGBE_FLAG2_RSC_ENABLED                 (u32)(1 << 1)
+#define IXGBE_FLAG2_TEMP_SENSOR_CAPABLE         (u32)(1 << 2)
 /* default to trying for four seconds */
 #define IXGBE_TRY_LINK_TIMEOUT (4 * HZ)
 
@@ -407,6 +408,8 @@ struct ixgbe_adapter {
         u16 eeprom_version;
 
         int node;
+        struct work_struct check_overtemp_task;
+        u32 interrupt_event;
 
         /* SR-IOV */
         DECLARE_BITMAP(active_vfs, IXGBE_MAX_VF_FUNCTIONS);
diff --git a/drivers/net/ixgbe/ixgbe_82598.c b/drivers/net/ixgbe/ixgbe_82598.c
index f2b7ff44215b..9c02d6014cc4 100644
--- a/drivers/net/ixgbe/ixgbe_82598.c
+++ b/drivers/net/ixgbe/ixgbe_82598.c
@@ -1236,6 +1236,7 @@ static struct ixgbe_phy_operations phy_ops_82598 = {
         .setup_link             = &ixgbe_setup_phy_link_generic,
         .setup_link_speed       = &ixgbe_setup_phy_link_speed_generic,
         .read_i2c_eeprom        = &ixgbe_read_i2c_eeprom_82598,
+        .check_overtemp   = &ixgbe_tn_check_overtemp,
 };
 
 struct ixgbe_info ixgbe_82598_info = {
diff --git a/drivers/net/ixgbe/ixgbe_82599.c b/drivers/net/ixgbe/ixgbe_82599.c
index e9706eb8e4ff..a4e2901f2f08 100644
--- a/drivers/net/ixgbe/ixgbe_82599.c
+++ b/drivers/net/ixgbe/ixgbe_82599.c
@@ -2395,6 +2395,7 @@ static struct ixgbe_phy_operations phy_ops_82599 = {
         .write_i2c_byte         = &ixgbe_write_i2c_byte_generic,
         .read_i2c_eeprom        = &ixgbe_read_i2c_eeprom_generic,
         .write_i2c_eeprom       = &ixgbe_write_i2c_eeprom_generic,
+        .check_overtemp         = &ixgbe_tn_check_overtemp,
 };
 
 struct ixgbe_info ixgbe_82599_info = {
diff --git a/drivers/net/ixgbe/ixgbe_common.c b/drivers/net/ixgbe/ixgbe_common.c
index 1159d9138f05..9595b1bfb8dd 100644
--- a/drivers/net/ixgbe/ixgbe_common.c
+++ b/drivers/net/ixgbe/ixgbe_common.c
@@ -1188,6 +1188,7 @@ s32 ixgbe_set_rar_generic(struct ixgbe_hw *hw, u32 index, u8 *addr, u32 vmdq,
                 IXGBE_WRITE_REG(hw, IXGBE_RAH(index), rar_high);
         } else {
                 hw_dbg(hw, "RAR index %d is out of range.\n", index);
+                return IXGBE_ERR_RAR_INDEX;
         }
 
         return 0;
@@ -1219,6 +1220,7 @@ s32 ixgbe_clear_rar_generic(struct ixgbe_hw *hw, u32 index)
                 IXGBE_WRITE_REG(hw, IXGBE_RAH(index), rar_high);
         } else {
                 hw_dbg(hw, "RAR index %d is out of range.\n", index);
+                return IXGBE_ERR_RAR_INDEX;
         }
 
         /* clear VMDq pool/queue selection for this RAR */
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 9551cbb7bf01..b2af2f67f604 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -108,6 +108,8 @@ static DEFINE_PCI_DEVICE_TABLE(ixgbe_pci_tbl) = {
          board_82599 },
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_CX4),
          board_82599 },
+        {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_T3_LOM),
+         board_82599 },
         {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_COMBO_BACKPLANE),
          board_82599 },
 
@@ -640,7 +642,7 @@ static inline bool ixgbe_tx_xon_state(struct ixgbe_adapter *adapter,
         u32 txoff = IXGBE_TFCS_TXOFF;
 
 #ifdef CONFIG_IXGBE_DCB
-        if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
+        if (adapter->dcb_cfg.pfc_mode_enable) {
                 int tc;
                 int reg_idx = tx_ring->reg_idx;
                 int dcb_i = adapter->ring_feature[RING_F_DCB].indices;
@@ -1618,6 +1620,48 @@ static void ixgbe_set_itr_msix(struct ixgbe_q_vector *q_vector)
         }
 }
 
+/**
+ * ixgbe_check_overtemp_task - worker thread to check over tempurature
+ * @work: pointer to work_struct containing our data
+ **/
+static void ixgbe_check_overtemp_task(struct work_struct *work)
+{
+        struct ixgbe_adapter *adapter = container_of(work,
+                                                     struct ixgbe_adapter,
+                                                     check_overtemp_task);
+        struct ixgbe_hw *hw = &adapter->hw;
+        u32 eicr = adapter->interrupt_event;
+
+        if (adapter->flags2 & IXGBE_FLAG2_TEMP_SENSOR_CAPABLE) {
+                switch (hw->device_id) {
+                case IXGBE_DEV_ID_82599_T3_LOM: {
+                        u32 autoneg;
+                        bool link_up = false;
+
+                        if (hw->mac.ops.check_link)
+                                hw->mac.ops.check_link(hw, &autoneg, &link_up, false);
+
+                        if (((eicr & IXGBE_EICR_GPI_SDP0) && (!link_up)) ||
+                            (eicr & IXGBE_EICR_LSC))
+                                /* Check if this is due to overtemp */
+                                if (hw->phy.ops.check_overtemp(hw) == IXGBE_ERR_OVERTEMP)
+                                        break;
+                        }
+                        return;
+                default:
+                        if (!(eicr & IXGBE_EICR_GPI_SDP0))
+                                return;
+                        break;
+                }
+                DPRINTK(DRV, ERR, "Network adapter has been stopped because it "
+                        "has over heated. Restart the computer. If the problem "
+                        "persists, power off the system and replace the "
+                        "adapter\n");
+                /* write to clear the interrupt */
+                IXGBE_WRITE_REG(hw, IXGBE_EICR, IXGBE_EICR_GPI_SDP0);
+        }
+}
+
 static void ixgbe_check_fan_failure(struct ixgbe_adapter *adapter, u32 eicr)
 {
         struct ixgbe_hw *hw = &adapter->hw;
@@ -1689,6 +1733,10 @@ static irqreturn_t ixgbe_msix_lsc(int irq, void *data)
 
         if (hw->mac.type == ixgbe_mac_82599EB) {
                 ixgbe_check_sfp_event(adapter, eicr);
+                adapter->interrupt_event = eicr;
+                if ((adapter->flags2 & IXGBE_FLAG2_TEMP_SENSOR_CAPABLE) &&
+                    ((eicr & IXGBE_EICR_GPI_SDP0) || (eicr & IXGBE_EICR_LSC)))
+                        schedule_work(&adapter->check_overtemp_task);
 
                 /* Handle Flow Director Full threshold interrupt */
                 if (eicr & IXGBE_EICR_FLOW_DIR) {
@@ -2190,6 +2238,8 @@ static inline void ixgbe_irq_enable(struct ixgbe_adapter *adapter)
         u32 mask;
 
         mask = (IXGBE_EIMS_ENABLE_MASK & ~IXGBE_EIMS_RTX_QUEUE);
+        if (adapter->flags2 & IXGBE_FLAG2_TEMP_SENSOR_CAPABLE)
+                mask |= IXGBE_EIMS_GPI_SDP0;
         if (adapter->flags & IXGBE_FLAG_FAN_FAIL_CAPABLE)
                 mask |= IXGBE_EIMS_GPI_SDP1;
         if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
@@ -2250,6 +2300,9 @@ static irqreturn_t ixgbe_intr(int irq, void *data)
                 ixgbe_check_sfp_event(adapter, eicr);
 
         ixgbe_check_fan_failure(adapter, eicr);
+        if ((adapter->flags2 & IXGBE_FLAG2_TEMP_SENSOR_CAPABLE) &&
+            ((eicr & IXGBE_EICR_GPI_SDP0) || (eicr & IXGBE_EICR_LSC)))
+                schedule_work(&adapter->check_overtemp_task);
 
         if (napi_schedule_prep(&(q_vector->napi))) {
                 adapter->tx_ring[0]->total_packets = 0;
@@ -3265,6 +3318,13 @@ static int ixgbe_up_complete(struct ixgbe_adapter *adapter)
                 IXGBE_WRITE_REG(hw, IXGBE_EIAM, IXGBE_EICS_RTX_QUEUE);
         }
 
+        /* Enable Thermal over heat sensor interrupt */
+        if (adapter->flags2 & IXGBE_FLAG2_TEMP_SENSOR_CAPABLE) {
+                gpie = IXGBE_READ_REG(hw, IXGBE_GPIE);
+                gpie |= IXGBE_SDP0_GPIEN;
+                IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie);
+        }
+
         /* Enable fan failure interrupt if media type is copper */
         if (adapter->flags & IXGBE_FLAG_FAN_FAIL_CAPABLE) {
                 gpie = IXGBE_READ_REG(hw, IXGBE_GPIE);
@@ -3666,6 +3726,9 @@ void ixgbe_down(struct ixgbe_adapter *adapter)
             adapter->flags & IXGBE_FLAG_FDIR_PERFECT_CAPABLE)
                 cancel_work_sync(&adapter->fdir_reinit_task);
 
+        if (adapter->flags2 & IXGBE_FLAG2_TEMP_SENSOR_CAPABLE)
+                cancel_work_sync(&adapter->check_overtemp_task);
+
         /* disable transmits in the hardware now that interrupts are off */
         for (i = 0; i < adapter->num_tx_queues; i++) {
                 j = adapter->tx_ring[i]->reg_idx;
@@ -4645,6 +4708,8 @@ static int __devinit ixgbe_sw_init(struct ixgbe_adapter *adapter)
                 adapter->max_msix_q_vectors = MAX_MSIX_Q_VECTORS_82599;
                 adapter->flags2 |= IXGBE_FLAG2_RSC_CAPABLE;
                 adapter->flags2 |= IXGBE_FLAG2_RSC_ENABLED;
+                if (hw->device_id == IXGBE_DEV_ID_82599_T3_LOM)
+                        adapter->flags2 |= IXGBE_FLAG2_TEMP_SENSOR_CAPABLE;
                 if (dev->features & NETIF_F_NTUPLE) {
                         /* Flow Director perfect filter enabled */
                         adapter->flags |= IXGBE_FLAG_FDIR_PERFECT_CAPABLE;
@@ -6561,7 +6626,9 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
         }
 
         /* reset_hw fills in the perm_addr as well */
+        hw->phy.reset_if_overtemp = true;
         err = hw->mac.ops.reset_hw(hw);
+        hw->phy.reset_if_overtemp = false;
         if (err == IXGBE_ERR_SFP_NOT_PRESENT &&
             hw->mac.type == ixgbe_mac_82598EB) {
                 /*
@@ -6730,6 +6797,8 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
             adapter->flags & IXGBE_FLAG_FDIR_PERFECT_CAPABLE)
                 INIT_WORK(&adapter->fdir_reinit_task, ixgbe_fdir_reinit_task);
 
+        if (adapter->flags2 & IXGBE_FLAG2_TEMP_SENSOR_CAPABLE)
+                INIT_WORK(&adapter->check_overtemp_task, ixgbe_check_overtemp_task);
 #ifdef CONFIG_IXGBE_DCA
         if (dca_add_requester(&pdev->dev) == 0) {
                 adapter->flags |= IXGBE_FLAG_DCA_ENABLED;
diff --git a/drivers/net/ixgbe/ixgbe_phy.c b/drivers/net/ixgbe/ixgbe_phy.c
index 22d21af14783..09e1911ff510 100644
--- a/drivers/net/ixgbe/ixgbe_phy.c
+++ b/drivers/net/ixgbe/ixgbe_phy.c
@@ -135,6 +135,11 @@ static enum ixgbe_phy_type ixgbe_get_phy_type_from_id(u32 phy_id)
  **/
 s32 ixgbe_reset_phy_generic(struct ixgbe_hw *hw)
 {
+        /* Don't reset PHY if it's shut down due to overtemp. */
+        if (!hw->phy.reset_if_overtemp &&
+            (IXGBE_ERR_OVERTEMP == hw->phy.ops.check_overtemp(hw)))
+                return 0;
+
         /*
          * Perform soft PHY reset to the PHY_XS.
          * This will cause a soft reset to the PHY
@@ -1345,3 +1350,28 @@ s32 ixgbe_get_phy_firmware_version_tnx(struct ixgbe_hw *hw,
         return status;
 }
 
+/**
+ *  ixgbe_tn_check_overtemp - Checks if an overtemp occured.
+ *  @hw: pointer to hardware structure
+ *
+ *  Checks if the LASI temp alarm status was triggered due to overtemp
+ **/
+s32 ixgbe_tn_check_overtemp(struct ixgbe_hw *hw)
+{
+        s32 status = 0;
+        u16 phy_data = 0;
+
+        if (hw->device_id != IXGBE_DEV_ID_82599_T3_LOM)
+                goto out;
+
+        /* Check that the LASI temp alarm status was triggered */
+        hw->phy.ops.read_reg(hw, IXGBE_TN_LASI_STATUS_REG,
+                             MDIO_MMD_PMAPMD, &phy_data);
+
+        if (!(phy_data & IXGBE_TN_LASI_STATUS_TEMP_ALARM))
+                goto out;
+
+        status = IXGBE_ERR_OVERTEMP;
+out:
+        return status;
+}
diff --git a/drivers/net/ixgbe/ixgbe_phy.h b/drivers/net/ixgbe/ixgbe_phy.h
index c9c545941407..ef4ba834c593 100644
--- a/drivers/net/ixgbe/ixgbe_phy.h
+++ b/drivers/net/ixgbe/ixgbe_phy.h
@@ -80,6 +80,8 @@
 #define IXGBE_I2C_T_SU_STO  4
 #define IXGBE_I2C_T_BUF     5
 
+#define IXGBE_TN_LASI_STATUS_REG        0x9005
+#define IXGBE_TN_LASI_STATUS_TEMP_ALARM 0x0008
 
 s32 ixgbe_init_phy_ops_generic(struct ixgbe_hw *hw);
 s32 ixgbe_identify_phy_generic(struct ixgbe_hw *hw);
@@ -106,6 +108,7 @@ s32 ixgbe_identify_sfp_module_generic(struct ixgbe_hw *hw);
 s32 ixgbe_get_sfp_init_sequence_offsets(struct ixgbe_hw *hw,
                                         u16 *list_offset,
                                         u16 *data_offset);
+s32 ixgbe_tn_check_overtemp(struct ixgbe_hw *hw);
 s32 ixgbe_read_i2c_byte_generic(struct ixgbe_hw *hw, u8 byte_offset,
                                 u8 dev_addr, u8 *data);
 s32 ixgbe_write_i2c_byte_generic(struct ixgbe_hw *hw, u8 byte_offset,
diff --git a/drivers/net/ixgbe/ixgbe_type.h b/drivers/net/ixgbe/ixgbe_type.h
index 39b9be897439..cdd1998f18c7 100644
--- a/drivers/net/ixgbe/ixgbe_type.h
+++ b/drivers/net/ixgbe/ixgbe_type.h
@@ -51,6 +51,7 @@
 #define IXGBE_DEV_ID_82599_KX4           0x10F7
 #define IXGBE_DEV_ID_82599_KX4_MEZZ      0x1514
 #define IXGBE_DEV_ID_82599_KR            0x1517
+#define IXGBE_DEV_ID_82599_T3_LOM        0x151C
 #define IXGBE_DEV_ID_82599_CX4           0x10F9
 #define IXGBE_DEV_ID_82599_SFP           0x10FB
 #define IXGBE_DEV_ID_82599_SFP_EM        0x1507
@@ -2470,6 +2471,7 @@ struct ixgbe_phy_operations {
         s32 (*write_i2c_byte)(struct ixgbe_hw *, u8, u8, u8);
         s32 (*read_i2c_eeprom)(struct ixgbe_hw *, u8 , u8 *);
         s32 (*write_i2c_eeprom)(struct ixgbe_hw *, u8, u8);
+        s32 (*check_overtemp)(struct ixgbe_hw *);
 };
 
 struct ixgbe_eeprom_info {
@@ -2518,6 +2520,7 @@ struct ixgbe_phy_info {
         enum ixgbe_smart_speed          smart_speed;
         bool                            smart_speed_active;
         bool                            multispeed_fiber;
+        bool                            reset_if_overtemp;
 };
 
 #include "ixgbe_mbx.h"
@@ -2605,6 +2608,8 @@ struct ixgbe_info {
 #define IXGBE_ERR_FDIR_REINIT_FAILED            -23
 #define IXGBE_ERR_EEPROM_VERSION                -24
 #define IXGBE_ERR_NO_SPACE                      -25
+#define IXGBE_ERR_OVERTEMP                      -26
+#define IXGBE_ERR_RAR_INDEX                     -27
 #define IXGBE_NOT_IMPLEMENTED                   0x7FFFFFFF
 
 #endif /* _IXGBE_TYPE_H_ */
diff --git a/drivers/net/korina.c b/drivers/net/korina.c
index 26bf1b76b997..c7a9bef4dfb0 100644
--- a/drivers/net/korina.c
+++ b/drivers/net/korina.c
@@ -135,6 +135,7 @@ struct korina_private {
         struct napi_struct napi;
         struct timer_list media_check_timer;
         struct mii_if_info mii_if;
+        struct work_struct restart_task;
         struct net_device *dev;
         int phy_addr;
 };
@@ -375,7 +376,7 @@ static int korina_rx(struct net_device *dev, int limit)
                 if (devcs & ETH_RX_LE)
                         dev->stats.rx_length_errors++;
                 if (devcs & ETH_RX_OVR)
-                        dev->stats.rx_over_errors++;
+                        dev->stats.rx_fifo_errors++;
                 if (devcs & ETH_RX_CV)
                         dev->stats.rx_frame_errors++;
                 if (devcs & ETH_RX_CES)
@@ -764,10 +765,9 @@ static int korina_alloc_ring(struct net_device *dev)
 
         /* Initialize the receive descriptors */
         for (i = 0; i < KORINA_NUM_RDS; i++) {
-                skb = dev_alloc_skb(KORINA_RBSIZE + 2);
+                skb = netdev_alloc_skb_ip_align(dev, KORINA_RBSIZE);
                 if (!skb)
                         return -ENOMEM;
-                skb_reserve(skb, 2);
                 lp->rx_skb[i] = skb;
                 lp->rd_ring[i].control = DMA_DESC_IOD |
                                 DMA_COUNT(KORINA_RBSIZE);
@@ -890,12 +890,12 @@ static int korina_init(struct net_device *dev)
 
 /*
  * Restart the RC32434 ethernet controller.
- * FIXME: check the return status where we call it
  */
-static int korina_restart(struct net_device *dev)
+static void korina_restart_task(struct work_struct *work)
 {
-        struct korina_private *lp = netdev_priv(dev);
-        int ret;
+        struct korina_private *lp = container_of(work,
+                        struct korina_private, restart_task);
+        struct net_device *dev = lp->dev;
 
         /*
          * Disable interrupts
@@ -916,10 +916,9 @@ static int korina_restart(struct net_device *dev)
 
         napi_disable(&lp->napi);
 
-        ret = korina_init(dev);
-        if (ret < 0) {
+        if (korina_init(dev) < 0) {
                 printk(KERN_ERR "%s: cannot restart device\n", dev->name);
-                return ret;
+                return;
         }
         korina_multicast_list(dev);
 
@@ -927,8 +926,6 @@ static int korina_restart(struct net_device *dev)
         enable_irq(lp->ovr_irq);
         enable_irq(lp->tx_irq);
         enable_irq(lp->rx_irq);
-
-        return ret;
 }
 
 static void korina_clear_and_restart(struct net_device *dev, u32 value)
@@ -937,7 +934,7 @@ static void korina_clear_and_restart(struct net_device *dev, u32 value)
 
         netif_stop_queue(dev);
         writel(value, &lp->eth_regs->ethintfc);
-        korina_restart(dev);
+        schedule_work(&lp->restart_task);
 }
 
 /* Ethernet Tx Underflow interrupt */
@@ -962,11 +959,8 @@ static irqreturn_t korina_und_interrupt(int irq, void *dev_id)
 static void korina_tx_timeout(struct net_device *dev)
 {
         struct korina_private *lp = netdev_priv(dev);
-        unsigned long flags;
 
-        spin_lock_irqsave(&lp->lock, flags);
-        korina_restart(dev);
-        spin_unlock_irqrestore(&lp->lock, flags);
+        schedule_work(&lp->restart_task);
 }
 
 /* Ethernet Rx Overflow interrupt */
@@ -1086,6 +1080,8 @@ static int korina_close(struct net_device *dev)
 
         napi_disable(&lp->napi);
 
+        cancel_work_sync(&lp->restart_task);
+
         free_irq(lp->rx_irq, dev);
         free_irq(lp->tx_irq, dev);
         free_irq(lp->ovr_irq, dev);
@@ -1198,6 +1194,8 @@ static int korina_probe(struct platform_device *pdev)
         }
         setup_timer(&lp->media_check_timer, korina_poll_media, (unsigned long) dev);
 
+        INIT_WORK(&lp->restart_task, korina_restart_task);
+
         printk(KERN_INFO "%s: " DRV_NAME "-" DRV_VERSION " " DRV_RELDATE "\n",
                         dev->name);
 out:
diff --git a/drivers/net/ksz884x.c b/drivers/net/ksz884x.c
index c02ce1ab6571..aa50ee1b0247 100644
--- a/drivers/net/ksz884x.c
+++ b/drivers/net/ksz884x.c
@@ -4854,7 +4854,7 @@ static inline void copy_old_skb(struct sk_buff *old, struct sk_buff *skb)
  *
  * Return 0 if successful; otherwise an error code indicating failure.
  */
-static int netdev_tx(struct sk_buff *skb, struct net_device *dev)
+static netdev_tx_t netdev_tx(struct sk_buff *skb, struct net_device *dev)
 {
         struct dev_priv *priv = netdev_priv(dev);
         struct dev_info *hw_priv = priv->adapter;
@@ -6863,6 +6863,7 @@ static const struct net_device_ops netdev_ops = {
         .ndo_tx_timeout         = netdev_tx_timeout,
         .ndo_change_mtu         = netdev_change_mtu,
         .ndo_set_mac_address    = netdev_set_mac_address,
+        .ndo_validate_addr      = eth_validate_addr,
         .ndo_do_ioctl           = netdev_ioctl,
         .ndo_set_rx_mode        = netdev_set_rx_mode,
 #ifdef CONFIG_NET_POLL_CONTROLLER
diff --git a/drivers/net/ll_temac.h b/drivers/net/ll_temac.h
index c03358434acb..522abe2ff25a 100644
--- a/drivers/net/ll_temac.h
+++ b/drivers/net/ll_temac.h
@@ -295,6 +295,10 @@ This option defaults to enabled (set) */
 
 #define MULTICAST_CAM_TABLE_NUM 4
 
+/* TEMAC Synthesis features */
+#define TEMAC_FEATURE_RX_CSUM  (1 << 0)
+#define TEMAC_FEATURE_TX_CSUM  (1 << 1)
+
 /* TX/RX CURDESC_PTR points to first descriptor */
 /* TX/RX TAILDESC_PTR points to last descriptor in linked list */
 
@@ -353,6 +357,7 @@ struct temac_local {
         struct mutex indirect_mutex;
         u32 options;                    /* Current options word */
         int last_link;
+        unsigned int temac_features;
 
         /* Buffer descriptors */
         struct cdmac_bd *tx_bd_v;
diff --git a/drivers/net/ll_temac_main.c b/drivers/net/ll_temac_main.c
index 0ace2a46d31c..315eb4cdb58e 100644
--- a/drivers/net/ll_temac_main.c
+++ b/drivers/net/ll_temac_main.c
@@ -245,7 +245,7 @@ static int temac_dma_bd_init(struct net_device *ndev)
                                           CHNL_CTRL_IRQ_COAL_EN);
         /* 0x10220483 */
         /* 0x00100483 */
-        lp->dma_out(lp, RX_CHNL_CTRL, 0xff010000 |
+        lp->dma_out(lp, RX_CHNL_CTRL, 0xff070000 |
                                           CHNL_CTRL_IRQ_EN |
                                           CHNL_CTRL_IRQ_DLY_EN |
                                           CHNL_CTRL_IRQ_COAL_EN |
@@ -574,6 +574,10 @@ static void temac_start_xmit_done(struct net_device *ndev)
                 if (cur_p->app4)
                         dev_kfree_skb_irq((struct sk_buff *)cur_p->app4);
                 cur_p->app0 = 0;
+                cur_p->app1 = 0;
+                cur_p->app2 = 0;
+                cur_p->app3 = 0;
+                cur_p->app4 = 0;
 
                 ndev->stats.tx_packets++;
                 ndev->stats.tx_bytes += cur_p->len;
@@ -589,6 +593,29 @@ static void temac_start_xmit_done(struct net_device *ndev)
         netif_wake_queue(ndev);
 }
 
+static inline int temac_check_tx_bd_space(struct temac_local *lp, int num_frag)
+{
+        struct cdmac_bd *cur_p;
+        int tail;
+
+        tail = lp->tx_bd_tail;
+        cur_p = &lp->tx_bd_v[tail];
+
+        do {
+                if (cur_p->app0)
+                        return NETDEV_TX_BUSY;
+
+                tail++;
+                if (tail >= TX_BD_NUM)
+                        tail = 0;
+
+                cur_p = &lp->tx_bd_v[tail];
+                num_frag--;
+        } while (num_frag >= 0);
+
+        return 0;
+}
+
 static int temac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 {
         struct temac_local *lp = netdev_priv(ndev);
@@ -603,7 +630,7 @@ static int temac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         start_p = lp->tx_bd_p + sizeof(*lp->tx_bd_v) * lp->tx_bd_tail;
         cur_p = &lp->tx_bd_v[lp->tx_bd_tail];
 
-        if (cur_p->app0 & STS_CTRL_APP0_CMPLT) {
+        if (temac_check_tx_bd_space(lp, num_frag)) {
                 if (!netif_queue_stopped(ndev)) {
                         netif_stop_queue(ndev);
                         return NETDEV_TX_BUSY;
@@ -613,29 +640,14 @@ static int temac_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 
         cur_p->app0 = 0;
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                const struct iphdr *ip = ip_hdr(skb);
-                int length = 0, start = 0, insert = 0;
-
-                switch (ip->protocol) {
-                case IPPROTO_TCP:
-                        start = sizeof(struct iphdr) + ETH_HLEN;
-                        insert = sizeof(struct iphdr) + ETH_HLEN + 16;
-                        length = ip->tot_len - sizeof(struct iphdr);
-                        break;
-                case IPPROTO_UDP:
-                        start = sizeof(struct iphdr) + ETH_HLEN;
-                        insert = sizeof(struct iphdr) + ETH_HLEN + 6;
-                        length = ip->tot_len - sizeof(struct iphdr);
-                        break;
-                default:
-                        break;
-                }
-                cur_p->app1 = ((start << 16) | insert);
-                cur_p->app2 = csum_tcpudp_magic(ip->saddr, ip->daddr,
-                                                length, ip->protocol, 0);
-                skb->data[insert] = 0;
-                skb->data[insert + 1] = 0;
+                unsigned int csum_start_off = skb_transport_offset(skb);
+                unsigned int csum_index_off = csum_start_off + skb->csum_offset;
+
+                cur_p->app0 |= 1; /* TX Checksum Enabled */
+                cur_p->app1 = (csum_start_off << 16) | csum_index_off;
+                cur_p->app2 = 0;  /* initial checksum seed */
         }
+
         cur_p->app0 |= STS_CTRL_APP0_SOP;
         cur_p->len = skb_headlen(skb);
         cur_p->phys = dma_map_single(ndev->dev.parent, skb->data, skb->len,
@@ -699,6 +711,15 @@ static void ll_temac_recv(struct net_device *ndev)
                 skb->protocol = eth_type_trans(skb, ndev);
                 skb->ip_summed = CHECKSUM_NONE;
 
+                /* if we're doing rx csum offload, set it up */
+                if (((lp->temac_features & TEMAC_FEATURE_RX_CSUM) != 0) &&
+                        (skb->protocol == __constant_htons(ETH_P_IP)) &&
+                        (skb->len > 64)) {
+
+                        skb->csum = cur_p->app3 & 0xFFFF;
+                        skb->ip_summed = CHECKSUM_COMPLETE;
+                }
+
                 netif_rx(skb);
 
                 ndev->stats.rx_packets++;
@@ -883,6 +904,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         struct temac_local *lp;
         struct net_device *ndev;
         const void *addr;
+        __be32 *p;
         int size, rc = 0;
 
         /* Init network device structure */
@@ -920,14 +942,26 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         mutex_init(&lp->indirect_mutex);
 
         /* map device registers */
-        lp->regs = of_iomap(op->node, 0);
+        lp->regs = of_iomap(op->dev.of_node, 0);
         if (!lp->regs) {
                 dev_err(&op->dev, "could not map temac regs.\n");
                 goto nodev;
         }
 
+        /* Setup checksum offload, but default to off if not specified */
+        lp->temac_features = 0;
+        p = (__be32 *)of_get_property(op->dev.of_node, "xlnx,txcsum", NULL);
+        if (p && be32_to_cpu(*p)) {
+                lp->temac_features |= TEMAC_FEATURE_TX_CSUM;
+                /* Can checksum TCP/UDP over IPv4. */
+                ndev->features |= NETIF_F_IP_CSUM;
+        }
+        p = (__be32 *)of_get_property(op->dev.of_node, "xlnx,rxcsum", NULL);
+        if (p && be32_to_cpu(*p))
+                lp->temac_features |= TEMAC_FEATURE_RX_CSUM;
+
         /* Find the DMA node, map the DMA registers, and decode the DMA IRQs */
-        np = of_parse_phandle(op->node, "llink-connected", 0);
+        np = of_parse_phandle(op->dev.of_node, "llink-connected", 0);
         if (!np) {
                 dev_err(&op->dev, "could not find DMA node\n");
                 goto nodev;
@@ -950,7 +984,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
 
         lp->rx_irq = irq_of_parse_and_map(np, 0);
         lp->tx_irq = irq_of_parse_and_map(np, 1);
-        if (!lp->rx_irq || !lp->tx_irq) {
+        if ((lp->rx_irq == NO_IRQ) || (lp->tx_irq == NO_IRQ)) {
                 dev_err(&op->dev, "could not determine irqs\n");
                 rc = -ENOMEM;
                 goto nodev;
@@ -959,7 +993,7 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         of_node_put(np); /* Finished with the DMA node; drop the reference */
 
         /* Retrieve the MAC address */
-        addr = of_get_property(op->node, "local-mac-address", &size);
+        addr = of_get_property(op->dev.of_node, "local-mac-address", &size);
         if ((!addr) || (size != 6)) {
                 dev_err(&op->dev, "could not find MAC address\n");
                 rc = -ENODEV;
@@ -967,11 +1001,11 @@ temac_of_probe(struct of_device *op, const struct of_device_id *match)
         }
         temac_set_mac_address(ndev, (void *)addr);
 
-        rc = temac_mdio_setup(lp, op->node);
+        rc = temac_mdio_setup(lp, op->dev.of_node);
         if (rc)
                 dev_warn(&op->dev, "error registering MDIO bus\n");
 
-        lp->phy_node = of_parse_phandle(op->node, "phy-handle", 0);
+        lp->phy_node = of_parse_phandle(op->dev.of_node, "phy-handle", 0);
         if (lp->phy_node)
                 dev_dbg(lp->dev, "using PHY node %s (%p)\n", np->full_name, np);
 
@@ -1024,12 +1058,12 @@ static struct of_device_id temac_of_match[] __devinitdata = {
 MODULE_DEVICE_TABLE(of, temac_of_match);
 
 static struct of_platform_driver temac_of_driver = {
-        .match_table = temac_of_match,
         .probe = temac_of_probe,
         .remove = __devexit_p(temac_of_remove),
         .driver = {
                 .owner = THIS_MODULE,
                 .name = "xilinx_temac",
+                .of_match_table = temac_of_match,
         },
 };
 
diff --git a/drivers/net/mace.c b/drivers/net/mace.c
index b6855a6476f8..1c5221f79d6f 100644
--- a/drivers/net/mace.c
+++ b/drivers/net/mace.c
@@ -997,8 +997,11 @@ MODULE_DEVICE_TABLE (of, mace_match);
 
 static struct macio_driver mace_driver =
 {
-        .name           = "mace",
-        .match_table    = mace_match,
+        .driver = {
+                .name           = "mace",
+                .owner          = THIS_MODULE,
+                .of_match_table = mace_match,
+        },
         .probe          = mace_probe,
         .remove         = mace_remove,
 };
diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c
index 4e238afab4a3..87e8d4cb4057 100644
--- a/drivers/net/macvlan.c
+++ b/drivers/net/macvlan.c
@@ -634,11 +634,18 @@ int macvlan_common_newlink(struct net *src_net, struct net_device *dev,
 
         err = register_netdevice(dev);
         if (err < 0)
-                return err;
+                goto destroy_port;
 
         list_add_tail(&vlan->list, &port->vlans);
         netif_stacked_transfer_operstate(lowerdev, dev);
+
         return 0;
+
+destroy_port:
+        if (list_empty(&port->vlans))
+                macvlan_port_destroy(lowerdev);
+
+        return err;
 }
 EXPORT_SYMBOL_GPL(macvlan_common_newlink);
 
diff --git a/drivers/net/mlx4/icm.c b/drivers/net/mlx4/icm.c
index 57288ca1395f..b07e4dee80aa 100644
--- a/drivers/net/mlx4/icm.c
+++ b/drivers/net/mlx4/icm.c
@@ -163,28 +163,30 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
                         ret = mlx4_alloc_icm_pages(&chunk->mem[chunk->npages],
                                                    cur_order, gfp_mask);
 
-                if (!ret) {
-                        ++chunk->npages;
-
-                        if (coherent)
-                                ++chunk->nsg;
-                        else if (chunk->npages == MLX4_ICM_CHUNK_LEN) {
-                                chunk->nsg = pci_map_sg(dev->pdev, chunk->mem,
-                                                        chunk->npages,
-                                                        PCI_DMA_BIDIRECTIONAL);
+                if (ret) {
+                        if (--cur_order < 0)
+                                goto fail;
+                        else
+                                continue;
+                }
 
-                                if (chunk->nsg <= 0)
-                                        goto fail;
+                ++chunk->npages;
 
-                                chunk = NULL;
-                        }
+                if (coherent)
+                        ++chunk->nsg;
+                else if (chunk->npages == MLX4_ICM_CHUNK_LEN) {
+                        chunk->nsg = pci_map_sg(dev->pdev, chunk->mem,
+                                                chunk->npages,
+                                                PCI_DMA_BIDIRECTIONAL);
 
-                        npages -= 1 << cur_order;
-                } else {
-                        --cur_order;
-                        if (cur_order < 0)
+                        if (chunk->nsg <= 0)
                                 goto fail;
                 }
+
+                if (chunk->npages == MLX4_ICM_CHUNK_LEN)
+                        chunk = NULL;
+
+                npages -= 1 << cur_order;
         }
 
         if (!coherent && chunk) {
diff --git a/drivers/net/myri_sbus.c b/drivers/net/myri_sbus.c
index 3898108f98ce..1a57c3da1f49 100644
--- a/drivers/net/myri_sbus.c
+++ b/drivers/net/myri_sbus.c
@@ -928,7 +928,7 @@ static const struct net_device_ops myri_ops = {
 
 static int __devinit myri_sbus_probe(struct of_device *op, const struct of_device_id *match)
 {
-        struct device_node *dp = op->node;
+        struct device_node *dp = op->dev.of_node;
         static unsigned version_printed;
         struct net_device *dev;
         struct myri_eth *mp;
@@ -1161,8 +1161,11 @@ static const struct of_device_id myri_sbus_match[] = {
 MODULE_DEVICE_TABLE(of, myri_sbus_match);
 
 static struct of_platform_driver myri_sbus_driver = {
-        .name           = "myri",
-        .match_table    = myri_sbus_match,
+        .driver = {
+                .name = "myri",
+                .owner = THIS_MODULE,
+                .of_match_table = myri_sbus_match,
+        },
         .probe          = myri_sbus_probe,
         .remove         = __devexit_p(myri_sbus_remove),
 };
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index 30abb4e436f1..63e8e3893bd6 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -9115,7 +9115,7 @@ static int __devinit niu_n2_irq_init(struct niu *np, u8 *ldg_num_map)
         const u32 *int_prop;
         int i;
 
-        int_prop = of_get_property(op->node, "interrupts", NULL);
+        int_prop = of_get_property(op->dev.of_node, "interrupts", NULL);
         if (!int_prop)
                 return -ENODEV;
 
@@ -9266,7 +9266,7 @@ static int __devinit niu_get_of_props(struct niu *np)
         int prop_len;
 
         if (np->parent->plat_type == PLAT_TYPE_NIU)
-                dp = np->op->node;
+                dp = np->op->dev.of_node;
         else
                 dp = pci_device_to_OF_node(np->pdev);
 
@@ -10083,10 +10083,10 @@ static int __devinit niu_of_probe(struct of_device *op,
 
         niu_driver_version();
 
-        reg = of_get_property(op->node, "reg", NULL);
+        reg = of_get_property(op->dev.of_node, "reg", NULL);
         if (!reg) {
                 dev_err(&op->dev, "%s: No 'reg' property, aborting\n",
-                        op->node->full_name);
+                        op->dev.of_node->full_name);
                 return -ENODEV;
         }
 
@@ -10099,7 +10099,7 @@ static int __devinit niu_of_probe(struct of_device *op,
         np = netdev_priv(dev);
 
         memset(&parent_id, 0, sizeof(parent_id));
-        parent_id.of = of_get_parent(op->node);
+        parent_id.of = of_get_parent(op->dev.of_node);
 
         np->parent = niu_get_parent(np, &parent_id,
                                     PLAT_TYPE_NIU);
@@ -10234,8 +10234,11 @@ static const struct of_device_id niu_match[] = {
 MODULE_DEVICE_TABLE(of, niu_match);
 
 static struct of_platform_driver niu_of_driver = {
-        .name           = "niu",
-        .match_table    = niu_match,
+        .driver = {
+                .name = "niu",
+                .owner = THIS_MODULE,
+                .of_match_table = niu_match,
+        },
         .probe          = niu_of_probe,
         .remove         = __devexit_p(niu_of_remove),
 };
diff --git a/drivers/net/pcmcia/smc91c92_cs.c b/drivers/net/pcmcia/smc91c92_cs.c
index 7b6fe89f9db0..64e6a84bbbbe 100644
--- a/drivers/net/pcmcia/smc91c92_cs.c
+++ b/drivers/net/pcmcia/smc91c92_cs.c
@@ -322,6 +322,7 @@ static int smc91c92_probe(struct pcmcia_device *link)
         return -ENOMEM;
     smc = netdev_priv(dev);
     smc->p_dev = link;
+    link->priv = dev;
 
     spin_lock_init(&smc->lock);
     link->io.NumPorts1 = 16;
diff --git a/drivers/net/phy/lxt.c b/drivers/net/phy/lxt.c
index 8ee929b796d8..dbd003453737 100644
--- a/drivers/net/phy/lxt.c
+++ b/drivers/net/phy/lxt.c
@@ -53,6 +53,9 @@
 
 #define MII_LXT971_ISR          19  /* Interrupt Status Register */
 
+/* register definitions for the 973 */
+#define MII_LXT973_PCR 16 /* Port Configuration Register */
+#define PCR_FIBER_SELECT 1
 
 MODULE_DESCRIPTION("Intel LXT PHY driver");
 MODULE_AUTHOR("Andy Fleming");
@@ -119,6 +122,33 @@ static int lxt971_config_intr(struct phy_device *phydev)
         return err;
 }
 
+static int lxt973_probe(struct phy_device *phydev)
+{
+        int val = phy_read(phydev, MII_LXT973_PCR);
+
+        if (val & PCR_FIBER_SELECT) {
+                /*
+                 * If fiber is selected, then the only correct setting
+                 * is 100Mbps, full duplex, and auto negotiation off.
+                 */
+                val = phy_read(phydev, MII_BMCR);
+                val |= (BMCR_SPEED100 | BMCR_FULLDPLX);
+                val &= ~BMCR_ANENABLE;
+                phy_write(phydev, MII_BMCR, val);
+                /* Remember that the port is in fiber mode. */
+                phydev->priv = lxt973_probe;
+        } else {
+                phydev->priv = NULL;
+        }
+        return 0;
+}
+
+static int lxt973_config_aneg(struct phy_device *phydev)
+{
+        /* Do nothing if port is in fiber mode. */
+        return phydev->priv ? 0 : genphy_config_aneg(phydev);
+}
+
 static struct phy_driver lxt970_driver = {
         .phy_id         = 0x78100000,
         .name           = "LXT970",
@@ -146,6 +176,18 @@ static struct phy_driver lxt971_driver = {
         .driver         = { .owner = THIS_MODULE,},
 };
 
+static struct phy_driver lxt973_driver = {
+        .phy_id         = 0x00137a10,
+        .name           = "LXT973",
+        .phy_id_mask    = 0xfffffff0,
+        .features       = PHY_BASIC_FEATURES,
+        .flags          = 0,
+        .probe          = lxt973_probe,
+        .config_aneg    = lxt973_config_aneg,
+        .read_status    = genphy_read_status,
+        .driver         = { .owner = THIS_MODULE,},
+};
+
 static int __init lxt_init(void)
 {
         int ret;
@@ -157,9 +199,15 @@ static int __init lxt_init(void)
         ret = phy_driver_register(&lxt971_driver);
         if (ret)
                 goto err2;
+
+        ret = phy_driver_register(&lxt973_driver);
+        if (ret)
+                goto err3;
         return 0;
 
- err2:  
+ err3:
+        phy_driver_unregister(&lxt971_driver);
+ err2:
         phy_driver_unregister(&lxt970_driver);
  err1:
         return ret;
@@ -169,6 +217,7 @@ static void __exit lxt_exit(void)
 {
         phy_driver_unregister(&lxt970_driver);
         phy_driver_unregister(&lxt971_driver);
+        phy_driver_unregister(&lxt973_driver);
 }
 
 module_init(lxt_init);
diff --git a/drivers/net/phy/mdio-gpio.c b/drivers/net/phy/mdio-gpio.c
index 35897134a5dd..fc5fef2a8175 100644
--- a/drivers/net/phy/mdio-gpio.c
+++ b/drivers/net/phy/mdio-gpio.c
@@ -199,12 +199,12 @@ static int __devinit mdio_ofgpio_probe(struct of_device *ofdev,
         if (!pdata)
                 return -ENOMEM;
 
-        ret = of_get_gpio(ofdev->node, 0);
+        ret = of_get_gpio(ofdev->dev.of_node, 0);
         if (ret < 0)
                 goto out_free;
         pdata->mdc = ret;
 
-        ret = of_get_gpio(ofdev->node, 1);
+        ret = of_get_gpio(ofdev->dev.of_node, 1);
         if (ret < 0)
                 goto out_free;
         pdata->mdio = ret;
@@ -213,7 +213,7 @@ static int __devinit mdio_ofgpio_probe(struct of_device *ofdev,
         if (!new_bus)
                 goto out_free;
 
-        ret = of_mdiobus_register(new_bus, ofdev->node);
+        ret = of_mdiobus_register(new_bus, ofdev->dev.of_node);
         if (ret)
                 mdio_gpio_bus_deinit(&ofdev->dev);
 
@@ -241,8 +241,11 @@ static struct of_device_id mdio_ofgpio_match[] = {
 MODULE_DEVICE_TABLE(of, mdio_ofgpio_match);
 
 static struct of_platform_driver mdio_ofgpio_driver = {
-        .name = "mdio-gpio",
-        .match_table = mdio_ofgpio_match,
+        .driver = {
+                .name = "mdio-gpio",
+                .owner = THIS_MODULE,
+                .of_match_table = mdio_ofgpio_match,
+        },
         .probe = mdio_ofgpio_probe,
         .remove = __devexit_p(mdio_ofgpio_remove),
 };
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index 5441688daba7..1b2c29150202 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -1422,7 +1422,7 @@ static int ppp_mp_explode(struct ppp *ppp, struct sk_buff *skb)
                 flen = len;
                 if (nfree > 0) {
                         if (pch->speed == 0) {
-                                flen = totlen/nfree;
+                                flen = len/nfree;
                                 if (nbigger > 0) {
                                         flen++;
                                         nbigger--;
@@ -2926,5 +2926,5 @@ EXPORT_SYMBOL(ppp_output_wakeup);
 EXPORT_SYMBOL(ppp_register_compressor);
 EXPORT_SYMBOL(ppp_unregister_compressor);
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_CHARDEV_MAJOR(PPP_MAJOR);
-MODULE_ALIAS("/dev/ppp");
+MODULE_ALIAS_CHARDEV(PPP_MAJOR, 0);
+MODULE_ALIAS("devname:ppp");
diff --git a/drivers/net/pppoe.c b/drivers/net/pppoe.c
index b1b93ff2351f..805b64d1e893 100644
--- a/drivers/net/pppoe.c
+++ b/drivers/net/pppoe.c
@@ -289,6 +289,7 @@ static void pppoe_flush_dev(struct net_device *dev)
         struct pppoe_net *pn;
         int i;
 
+        pn = pppoe_pernet(dev_net(dev));
         write_lock_bh(&pn->hash_lock);
         for (i = 0; i < PPPOE_HASH_SIZE; i++) {
                 struct pppox_sock *po = pn->hash_table[i];
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 217e709bda3e..96b6cfbf0a3a 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -559,6 +559,11 @@ static void mdio_write(void __iomem *ioaddr, int reg_addr, int value)
                         break;
                 udelay(25);
         }
+        /*
+         * According to hardware specs a 20us delay is required after write
+         * complete indication, but before sending next command.
+         */
+        udelay(20);
 }
 
 static int mdio_read(void __iomem *ioaddr, int reg_addr)
@@ -578,6 +583,12 @@ static int mdio_read(void __iomem *ioaddr, int reg_addr)
                 }
                 udelay(25);
         }
+        /*
+         * According to hardware specs a 20us delay is required after read
+         * complete indication, but before sending next command.
+         */
+        udelay(20);
+
         return value;
 }
 
diff --git a/drivers/net/sfc/net_driver.h b/drivers/net/sfc/net_driver.h
index 2e6fd89f2a72..4762c91cb587 100644
--- a/drivers/net/sfc/net_driver.h
+++ b/drivers/net/sfc/net_driver.h
@@ -830,7 +830,7 @@ static inline const char *efx_dev_name(struct efx_nic *efx)
 
 static inline unsigned int efx_port_num(struct efx_nic *efx)
 {
-        return PCI_FUNC(efx->pci_dev->devfn);
+        return efx->net_dev->dev_id;
 }
 
 /**
diff --git a/drivers/net/sfc/siena.c b/drivers/net/sfc/siena.c
index 727b4228e081..f2b1e6180753 100644
--- a/drivers/net/sfc/siena.c
+++ b/drivers/net/sfc/siena.c
@@ -206,6 +206,7 @@ static int siena_probe_nic(struct efx_nic *efx)
 {
         struct siena_nic_data *nic_data;
         bool already_attached = 0;
+        efx_oword_t reg;
         int rc;
 
         /* Allocate storage for hardware specific data */
@@ -220,6 +221,9 @@ static int siena_probe_nic(struct efx_nic *efx)
                 goto fail1;
         }
 
+        efx_reado(efx, &reg, FR_AZ_CS_DEBUG);
+        efx->net_dev->dev_id = EFX_OWORD_FIELD(reg, FRF_CZ_CS_PORT_NUM) - 1;
+
         efx_mcdi_init(efx);
 
         /* Recover from a failed assertion before probing */
diff --git a/drivers/net/sh_eth.c b/drivers/net/sh_eth.c
index 586ed0915a29..501a55ffce57 100644
--- a/drivers/net/sh_eth.c
+++ b/drivers/net/sh_eth.c
@@ -1294,6 +1294,9 @@ static int sh_mdio_release(struct net_device *ndev)
         /* remove mdio bus info from net_device */
         dev_set_drvdata(&ndev->dev, NULL);
 
+        /* free interrupts memory */
+        kfree(bus->irq);
+
         /* free bitbang info */
         free_mdio_bitbang(bus);
 
diff --git a/drivers/net/sunbmac.c b/drivers/net/sunbmac.c
index 4591fe9bf0b9..367e96f317d4 100644
--- a/drivers/net/sunbmac.c
+++ b/drivers/net/sunbmac.c
@@ -1131,8 +1131,8 @@ static int __devinit bigmac_ether_init(struct of_device *op,
                 goto fail_and_cleanup;
 
         /* Get supported SBUS burst sizes. */
-        bsizes = of_getintprop_default(qec_op->node, "burst-sizes", 0xff);
-        bsizes_more = of_getintprop_default(qec_op->node, "burst-sizes", 0xff);
+        bsizes = of_getintprop_default(qec_op->dev.of_node, "burst-sizes", 0xff);
+        bsizes_more = of_getintprop_default(qec_op->dev.of_node, "burst-sizes", 0xff);
 
         bsizes &= 0xff;
         if (bsizes_more != 0xff)
@@ -1184,7 +1184,7 @@ static int __devinit bigmac_ether_init(struct of_device *op,
         }
 
         /* Get the board revision of this BigMAC. */
-        bp->board_rev = of_getintprop_default(bp->bigmac_op->node,
+        bp->board_rev = of_getintprop_default(bp->bigmac_op->dev.of_node,
                                               "board-version", 1);
 
         /* Init auto-negotiation timer state. */
@@ -1290,8 +1290,11 @@ static const struct of_device_id bigmac_sbus_match[] = {
 MODULE_DEVICE_TABLE(of, bigmac_sbus_match);
 
 static struct of_platform_driver bigmac_sbus_driver = {
-        .name           = "sunbmac",
-        .match_table    = bigmac_sbus_match,
+        .driver = {
+                .name = "sunbmac",
+                .owner = THIS_MODULE,
+                .of_match_table = bigmac_sbus_match,
+        },
         .probe          = bigmac_sbus_probe,
         .remove         = __devexit_p(bigmac_sbus_remove),
 };
diff --git a/drivers/net/sunhme.c b/drivers/net/sunhme.c
index 915c5909c7a8..3d9650b8d38f 100644
--- a/drivers/net/sunhme.c
+++ b/drivers/net/sunhme.c
@@ -2481,7 +2481,7 @@ static void hme_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info
         else {
                 const struct linux_prom_registers *regs;
                 struct of_device *op = hp->happy_dev;
-                regs = of_get_property(op->node, "regs", NULL);
+                regs = of_get_property(op->dev.of_node, "regs", NULL);
                 if (regs)
                         sprintf(info->bus_info, "SBUS:%d",
                                 regs->which_io);
@@ -2641,14 +2641,14 @@ static const struct net_device_ops hme_netdev_ops = {
 #ifdef CONFIG_SBUS
 static int __devinit happy_meal_sbus_probe_one(struct of_device *op, int is_qfe)
 {
-        struct device_node *dp = op->node, *sbus_dp;
+        struct device_node *dp = op->dev.of_node, *sbus_dp;
         struct quattro *qp = NULL;
         struct happy_meal *hp;
         struct net_device *dev;
         int i, qfe_slot = -1;
         int err = -ENODEV;
 
-        sbus_dp = to_of_device(op->dev.parent)->node;
+        sbus_dp = to_of_device(op->dev.parent)->dev.of_node;
 
         /* We can match PCI devices too, do not accept those here. */
         if (strcmp(sbus_dp->name, "sbus"))
@@ -3237,7 +3237,7 @@ static void happy_meal_pci_exit(void)
 #ifdef CONFIG_SBUS
 static int __devinit hme_sbus_probe(struct of_device *op, const struct of_device_id *match)
 {
-        struct device_node *dp = op->node;
+        struct device_node *dp = op->dev.of_node;
         const char *model = of_get_property(dp, "model", NULL);
         int is_qfe = (match->data != NULL);
 
@@ -3291,8 +3291,11 @@ static const struct of_device_id hme_sbus_match[] = {
 MODULE_DEVICE_TABLE(of, hme_sbus_match);
 
 static struct of_platform_driver hme_sbus_driver = {
-        .name           = "hme",
-        .match_table    = hme_sbus_match,
+        .driver = {
+                .name = "hme",
+                .owner = THIS_MODULE,
+                .of_match_table = hme_sbus_match,
+        },
         .probe          = hme_sbus_probe,
         .remove         = __devexit_p(hme_sbus_remove),
 };
diff --git a/drivers/net/sunlance.c b/drivers/net/sunlance.c
index 386af7bbe678..7d9c33dd9d1a 100644
--- a/drivers/net/sunlance.c
+++ b/drivers/net/sunlance.c
@@ -1323,7 +1323,7 @@ static int __devinit sparc_lance_probe_one(struct of_device *op,
                                            struct of_device *ledma,
                                            struct of_device *lebuffer)
 {
-        struct device_node *dp = op->node;
+        struct device_node *dp = op->dev.of_node;
         static unsigned version_printed;
         struct lance_private *lp;
         struct net_device *dev;
@@ -1410,7 +1410,7 @@ static int __devinit sparc_lance_probe_one(struct of_device *op,
 
         lp->burst_sizes = 0;
         if (lp->ledma) {
-                struct device_node *ledma_dp = ledma->node;
+                struct device_node *ledma_dp = ledma->dev.of_node;
                 struct device_node *sbus_dp;
                 unsigned int sbmask;
                 const char *prop;
@@ -1506,7 +1506,7 @@ fail:
 static int __devinit sunlance_sbus_probe(struct of_device *op, const struct of_device_id *match)
 {
         struct of_device *parent = to_of_device(op->dev.parent);
-        struct device_node *parent_dp = parent->node;
+        struct device_node *parent_dp = parent->dev.of_node;
         int err;
 
         if (!strcmp(parent_dp->name, "ledma")) {
@@ -1545,8 +1545,11 @@ static const struct of_device_id sunlance_sbus_match[] = {
 MODULE_DEVICE_TABLE(of, sunlance_sbus_match);
 
 static struct of_platform_driver sunlance_sbus_driver = {
-        .name           = "sunlance",
-        .match_table    = sunlance_sbus_match,
+        .driver = {
+                .name = "sunlance",
+                .owner = THIS_MODULE,
+                .of_match_table = sunlance_sbus_match,
+        },
         .probe          = sunlance_sbus_probe,
         .remove         = __devexit_p(sunlance_sbus_remove),
 };
diff --git a/drivers/net/sunqe.c b/drivers/net/sunqe.c
index a7542d25c845..72b579c8d812 100644
--- a/drivers/net/sunqe.c
+++ b/drivers/net/sunqe.c
@@ -695,7 +695,7 @@ static void qe_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
         strcpy(info->version, "3.0");
 
         op = qep->op;
-        regs = of_get_property(op->node, "reg", NULL);
+        regs = of_get_property(op->dev.of_node, "reg", NULL);
         if (regs)
                 sprintf(info->bus_info, "SBUS:%d", regs->which_io);
 
@@ -799,7 +799,7 @@ static struct sunqec * __devinit get_qec(struct of_device *child)
                         if (qec_global_reset(qecp->gregs))
                                 goto fail;
 
-                        qecp->qec_bursts = qec_get_burst(op->node);
+                        qecp->qec_bursts = qec_get_burst(op->dev.of_node);
 
                         qec_init_once(qecp, op);
 
@@ -857,7 +857,7 @@ static int __devinit qec_ether_init(struct of_device *op)
 
         res = -ENODEV;
 
-        i = of_getintprop_default(op->node, "channel#", -1);
+        i = of_getintprop_default(op->dev.of_node, "channel#", -1);
         if (i == -1)
                 goto fail;
         qe->channel = i;
@@ -977,8 +977,11 @@ static const struct of_device_id qec_sbus_match[] = {
 MODULE_DEVICE_TABLE(of, qec_sbus_match);
 
 static struct of_platform_driver qec_sbus_driver = {
-        .name           = "qec",
-        .match_table    = qec_sbus_match,
+        .driver = {
+                .name = "qec",
+                .owner = THIS_MODULE,
+                .of_match_table = qec_sbus_match,
+        },
         .probe          = qec_sbus_probe,
         .remove         = __devexit_p(qec_sbus_remove),
 };
diff --git a/drivers/net/tehuti.c b/drivers/net/tehuti.c
index 20ab16192325..737df6032bbc 100644
--- a/drivers/net/tehuti.c
+++ b/drivers/net/tehuti.c
@@ -646,7 +646,7 @@ static int bdx_ioctl_priv(struct net_device *ndev, struct ifreq *ifr, int cmd)
                 error = copy_from_user(data, ifr->ifr_data, sizeof(data));
                 if (error) {
                         pr_err("cant copy from user\n");
-                        RET(error);
+                        RET(-EFAULT);
                 }
                 DBG("%d 0x%x 0x%x\n", data[0], data[1], data[2]);
         }
@@ -665,7 +665,7 @@ static int bdx_ioctl_priv(struct net_device *ndev, struct ifreq *ifr, int cmd)
                     data[2]);
                 error = copy_to_user(ifr->ifr_data, data, sizeof(data));
                 if (error)
-                        RET(error);
+                        RET(-EFAULT);
                 break;
 
         case BDX_OP_WRITE:
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 97b25533e5fb..6ad6fe706312 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -526,6 +526,8 @@ static inline struct sk_buff *tun_alloc_skb(struct tun_struct *tun,
         struct sk_buff *skb;
         int err;
 
+        sock_update_classid(sk);
+
         /* Under a page?  Don't bother with paged skb. */
         if (prepad + len < PAGE_SIZE || !linear)
                 linear = len;
@@ -1649,3 +1651,4 @@ MODULE_DESCRIPTION(DRV_DESCRIPTION);
 MODULE_AUTHOR(DRV_COPYRIGHT);
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(TUN_MINOR);
+MODULE_ALIAS("devname:net/tun");
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 932602db54b3..4a34833b85dd 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -3719,7 +3719,7 @@ static const struct net_device_ops ucc_geth_netdev_ops = {
 static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *match)
 {
         struct device *device = &ofdev->dev;
-        struct device_node *np = ofdev->node;
+        struct device_node *np = ofdev->dev.of_node;
         struct net_device *dev = NULL;
         struct ucc_geth_private *ugeth = NULL;
         struct ucc_geth_info *ug_info;
@@ -3963,8 +3963,11 @@ static struct of_device_id ucc_geth_match[] = {
 MODULE_DEVICE_TABLE(of, ucc_geth_match);
 
 static struct of_platform_driver ucc_geth_driver = {
-        .name           = DRV_NAME,
-        .match_table    = ucc_geth_match,
+        .driver = {
+                .name = DRV_NAME,
+                .owner = THIS_MODULE,
+                .of_match_table = ucc_geth_match,
+        },
         .probe          = ucc_geth_probe,
         .remove         = ucc_geth_remove,
         .suspend        = ucc_geth_suspend,
diff --git a/drivers/net/usb/asix.c b/drivers/net/usb/asix.c
index 31b73310ec77..9516f382a6ba 100644
--- a/drivers/net/usb/asix.c
+++ b/drivers/net/usb/asix.c
@@ -322,7 +322,7 @@ static int asix_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                 size = (u16) (header & 0x0000ffff);
 
                 if ((skb->len) - ((size + 1) & 0xfffe) == 0) {
-                        u8 alignment = (u32)skb->data & 0x3;
+                        u8 alignment = (unsigned long)skb->data & 0x3;
                         if (alignment != 0x2) {
                                 /*
                                  * not 16bit aligned so use the room provided by
@@ -344,14 +344,14 @@ static int asix_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                         return 2;
                 }
 
-                if (size > ETH_FRAME_LEN) {
+                if (size > dev->net->mtu + ETH_HLEN) {
                         netdev_err(dev->net, "asix_rx_fixup() Bad RX Length %d\n",
                                    size);
                         return 0;
                 }
                 ax_skb = skb_clone(skb, GFP_ATOMIC);
                 if (ax_skb) {
-                        u8 alignment = (u32)packet & 0x3;
+                        u8 alignment = (unsigned long)packet & 0x3;
                         ax_skb->len = size;
 
                         if (alignment != 0x2) {
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index 9964df199511..0a3c41faea9c 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -475,6 +475,9 @@ static const struct usb_device_id hso_ids[] = {
         {USB_DEVICE(0x0af0, 0x8302)},
         {USB_DEVICE(0x0af0, 0x8304)},
         {USB_DEVICE(0x0af0, 0x8400)},
+        {USB_DEVICE(0x0af0, 0x8600)},
+        {USB_DEVICE(0x0af0, 0x8800)},
+        {USB_DEVICE(0x0af0, 0x8900)},
         {USB_DEVICE(0x0af0, 0xd035)},
         {USB_DEVICE(0x0af0, 0xd055)},
         {USB_DEVICE(0x0af0, 0xd155)},
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index b0a85d038796..1edb7a61983c 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -122,7 +122,7 @@ static void skb_xmit_done(struct virtqueue *svq)
         struct virtnet_info *vi = svq->vdev->priv;
 
         /* Suppress further interrupts. */
-        svq->vq_ops->disable_cb(svq);
+        virtqueue_disable_cb(svq);
 
         /* We were probably waiting for more output buffers. */
         netif_wake_queue(vi->dev);
@@ -210,7 +210,7 @@ static int receive_mergeable(struct virtnet_info *vi, struct sk_buff *skb)
                         return -EINVAL;
                 }
 
-                page = vi->rvq->vq_ops->get_buf(vi->rvq, &len);
+                page = virtqueue_get_buf(vi->rvq, &len);
                 if (!page) {
                         pr_debug("%s: rx error: %d buffers missing\n",
                                  skb->dev->name, hdr->mhdr.num_buffers);
@@ -340,7 +340,7 @@ static int add_recvbuf_small(struct virtnet_info *vi, gfp_t gfp)
 
         skb_to_sgvec(skb, vi->rx_sg + 1, 0, skb->len);
 
-        err = vi->rvq->vq_ops->add_buf(vi->rvq, vi->rx_sg, 0, 2, skb);
+        err = virtqueue_add_buf_gfp(vi->rvq, vi->rx_sg, 0, 2, skb, gfp);
         if (err < 0)
                 dev_kfree_skb(skb);
 
@@ -385,8 +385,8 @@ static int add_recvbuf_big(struct virtnet_info *vi, gfp_t gfp)
 
         /* chain first in list head */
         first->private = (unsigned long)list;
-        err = vi->rvq->vq_ops->add_buf(vi->rvq, vi->rx_sg, 0, MAX_SKB_FRAGS + 2,
-                                       first);
+        err = virtqueue_add_buf_gfp(vi->rvq, vi->rx_sg, 0, MAX_SKB_FRAGS + 2,
+                                    first, gfp);
         if (err < 0)
                 give_pages(vi, first);
 
@@ -404,7 +404,7 @@ static int add_recvbuf_mergeable(struct virtnet_info *vi, gfp_t gfp)
 
         sg_init_one(vi->rx_sg, page_address(page), PAGE_SIZE);
 
-        err = vi->rvq->vq_ops->add_buf(vi->rvq, vi->rx_sg, 0, 1, page);
+        err = virtqueue_add_buf_gfp(vi->rvq, vi->rx_sg, 0, 1, page, gfp);
         if (err < 0)
                 give_pages(vi, page);
 
@@ -433,7 +433,7 @@ static bool try_fill_recv(struct virtnet_info *vi, gfp_t gfp)
         } while (err > 0);
         if (unlikely(vi->num > vi->max))
                 vi->max = vi->num;
-        vi->rvq->vq_ops->kick(vi->rvq);
+        virtqueue_kick(vi->rvq);
         return !oom;
 }
 
@@ -442,7 +442,7 @@ static void skb_recv_done(struct virtqueue *rvq)
         struct virtnet_info *vi = rvq->vdev->priv;
         /* Schedule NAPI, Suppress further interrupts if successful. */
         if (napi_schedule_prep(&vi->napi)) {
-                rvq->vq_ops->disable_cb(rvq);
+                virtqueue_disable_cb(rvq);
                 __napi_schedule(&vi->napi);
         }
 }
@@ -471,7 +471,7 @@ static int virtnet_poll(struct napi_struct *napi, int budget)
 
 again:
         while (received < budget &&
-               (buf = vi->rvq->vq_ops->get_buf(vi->rvq, &len)) != NULL) {
+               (buf = virtqueue_get_buf(vi->rvq, &len)) != NULL) {
                 receive_buf(vi->dev, buf, len);
                 --vi->num;
                 received++;
@@ -485,9 +485,9 @@ again:
         /* Out of packets? */
         if (received < budget) {
                 napi_complete(napi);
-                if (unlikely(!vi->rvq->vq_ops->enable_cb(vi->rvq)) &&
+                if (unlikely(!virtqueue_enable_cb(vi->rvq)) &&
                     napi_schedule_prep(napi)) {
-                        vi->rvq->vq_ops->disable_cb(vi->rvq);
+                        virtqueue_disable_cb(vi->rvq);
                         __napi_schedule(napi);
                         goto again;
                 }
@@ -501,7 +501,7 @@ static unsigned int free_old_xmit_skbs(struct virtnet_info *vi)
         struct sk_buff *skb;
         unsigned int len, tot_sgs = 0;
 
-        while ((skb = vi->svq->vq_ops->get_buf(vi->svq, &len)) != NULL) {
+        while ((skb = virtqueue_get_buf(vi->svq, &len)) != NULL) {
                 pr_debug("Sent skb %p\n", skb);
                 vi->dev->stats.tx_bytes += skb->len;
                 vi->dev->stats.tx_packets++;
@@ -554,7 +554,7 @@ static int xmit_skb(struct virtnet_info *vi, struct sk_buff *skb)
                 sg_set_buf(vi->tx_sg, &hdr->hdr, sizeof hdr->hdr);
 
         hdr->num_sg = skb_to_sgvec(skb, vi->tx_sg + 1, 0, skb->len) + 1;
-        return vi->svq->vq_ops->add_buf(vi->svq, vi->tx_sg, hdr->num_sg,
+        return virtqueue_add_buf(vi->svq, vi->tx_sg, hdr->num_sg,
                                         0, skb);
 }
 
@@ -574,14 +574,14 @@ again:
         if (unlikely(capacity < 0)) {
                 netif_stop_queue(dev);
                 dev_warn(&dev->dev, "Unexpected full queue\n");
-                if (unlikely(!vi->svq->vq_ops->enable_cb(vi->svq))) {
-                        vi->svq->vq_ops->disable_cb(vi->svq);
+                if (unlikely(!virtqueue_enable_cb(vi->svq))) {
+                        virtqueue_disable_cb(vi->svq);
                         netif_start_queue(dev);
                         goto again;
                 }
                 return NETDEV_TX_BUSY;
         }
-        vi->svq->vq_ops->kick(vi->svq);
+        virtqueue_kick(vi->svq);
 
         /* Don't wait up for transmitted skbs to be freed. */
         skb_orphan(skb);
@@ -591,12 +591,12 @@ again:
          * before it gets out of hand.  Naturally, this wastes entries. */
         if (capacity < 2+MAX_SKB_FRAGS) {
                 netif_stop_queue(dev);
-                if (unlikely(!vi->svq->vq_ops->enable_cb(vi->svq))) {
+                if (unlikely(!virtqueue_enable_cb(vi->svq))) {
                         /* More just got used, free them then recheck. */
                         capacity += free_old_xmit_skbs(vi);
                         if (capacity >= 2+MAX_SKB_FRAGS) {
                                 netif_start_queue(dev);
-                                vi->svq->vq_ops->disable_cb(vi->svq);
+                                virtqueue_disable_cb(vi->svq);
                         }
                 }
         }
@@ -641,7 +641,7 @@ static int virtnet_open(struct net_device *dev)
          * now.  virtnet_poll wants re-enable the queue, so we disable here.
          * We synchronize against interrupts via NAPI_STATE_SCHED */
         if (napi_schedule_prep(&vi->napi)) {
-                vi->rvq->vq_ops->disable_cb(vi->rvq);
+                virtqueue_disable_cb(vi->rvq);
                 __napi_schedule(&vi->napi);
         }
         return 0;
@@ -678,15 +678,15 @@ static bool virtnet_send_command(struct virtnet_info *vi, u8 class, u8 cmd,
                 sg_set_buf(&sg[i + 1], sg_virt(s), s->length);
         sg_set_buf(&sg[out + in - 1], &status, sizeof(status));
 
-        BUG_ON(vi->cvq->vq_ops->add_buf(vi->cvq, sg, out, in, vi) < 0);
+        BUG_ON(virtqueue_add_buf(vi->cvq, sg, out, in, vi) < 0);
 
-        vi->cvq->vq_ops->kick(vi->cvq);
+        virtqueue_kick(vi->cvq);
 
         /*
          * Spin for a response, the kick causes an ioport write, trapping
          * into the hypervisor, so the request should be handled immediately.
          */
-        while (!vi->cvq->vq_ops->get_buf(vi->cvq, &tmp))
+        while (!virtqueue_get_buf(vi->cvq, &tmp))
                 cpu_relax();
 
         return status == VIRTIO_NET_OK;
@@ -1003,13 +1003,13 @@ static void free_unused_bufs(struct virtnet_info *vi)
 {
         void *buf;
         while (1) {
-                buf = vi->svq->vq_ops->detach_unused_buf(vi->svq);
+                buf = virtqueue_detach_unused_buf(vi->svq);
                 if (!buf)
                         break;
                 dev_kfree_skb(buf);
         }
         while (1) {
-                buf = vi->rvq->vq_ops->detach_unused_buf(vi->rvq);
+                buf = virtqueue_detach_unused_buf(vi->rvq);
                 if (!buf)
                         break;
                 if (vi->mergeable_rx_bufs || vi->big_packets)
diff --git a/drivers/net/wan/x25_asy.c b/drivers/net/wan/x25_asy.c
index 166e77dfffda..e47f5a986b1c 100644
--- a/drivers/net/wan/x25_asy.c
+++ b/drivers/net/wan/x25_asy.c
@@ -37,8 +37,6 @@
 #include <net/x25device.h>
 #include "x25_asy.h"
 
-#include <net/x25device.h>
-
 static struct net_device **x25_asy_devs;
 static int x25_asy_maxdev = SL_NRUNIT;
 
diff --git a/drivers/net/wimax/i2400m/fw.c b/drivers/net/wimax/i2400m/fw.c
index 3f283bff0ff7..11491354e5b5 100644
--- a/drivers/net/wimax/i2400m/fw.c
+++ b/drivers/net/wimax/i2400m/fw.c
@@ -1192,7 +1192,7 @@ int i2400m_fw_hdr_check(struct i2400m *i2400m,
         unsigned module_type, header_len, major_version, minor_version,
                 module_id, module_vendor, date, size;
 
-        module_type = bcf_hdr->module_type;
+        module_type = le32_to_cpu(bcf_hdr->module_type);
         header_len = sizeof(u32) * le32_to_cpu(bcf_hdr->header_len);
         major_version = (le32_to_cpu(bcf_hdr->header_version) & 0xffff0000)
                 >> 16;
diff --git a/drivers/net/wimax/i2400m/rx.c b/drivers/net/wimax/i2400m/rx.c
index 6537593fae66..8cc9e319f435 100644
--- a/drivers/net/wimax/i2400m/rx.c
+++ b/drivers/net/wimax/i2400m/rx.c
@@ -1027,12 +1027,12 @@ void i2400m_rx_edata(struct i2400m *i2400m, struct sk_buff *skb_rx,
                 ro_sn = (reorder >> I2400M_RO_SN_SHIFT) & I2400M_RO_SN;
 
                 spin_lock_irqsave(&i2400m->rx_lock, flags);
-                roq = &i2400m->rx_roq[ro_cin];
-                if (roq == NULL) {
+                if (i2400m->rx_roq == NULL) {
                         kfree_skb(skb); /* rx_roq is already destroyed */
                         spin_unlock_irqrestore(&i2400m->rx_lock, flags);
                         goto error;
                 }
+                roq = &i2400m->rx_roq[ro_cin];
                 kref_get(&i2400m->rx_roq_refcount);
                 spin_unlock_irqrestore(&i2400m->rx_lock, flags);
 
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index a441aad922c2..3b7ab20a5c54 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -5162,13 +5162,6 @@ static void proc_SSID_on_close(struct inode *inode, struct file *file)
         enable_MAC(ai, 1);
 }
 
-static inline u8 hexVal(char c) {
-        if (c>='0' && c<='9') return c -= '0';
-        if (c>='a' && c<='f') return c -= 'a'-10;
-        if (c>='A' && c<='F') return c -= 'A'-10;
-        return 0;
-}
-
 static void proc_APList_on_close( struct inode *inode, struct file *file ) {
         struct proc_data *data = (struct proc_data *)file->private_data;
         struct proc_dir_entry *dp = PDE(inode);
@@ -5188,11 +5181,11 @@ static void proc_APList_on_close( struct inode *inode, struct file *file ) {
                         switch(j%3) {
                         case 0:
                                 APList_rid.ap[i][j/3]=
-                                        hexVal(data->wbuffer[j+i*6*3])<<4;
+                                        hex_to_bin(data->wbuffer[j+i*6*3])<<4;
                                 break;
                         case 1:
                                 APList_rid.ap[i][j/3]|=
-                                        hexVal(data->wbuffer[j+i*6*3]);
+                                        hex_to_bin(data->wbuffer[j+i*6*3]);
                                 break;
                         }
                 }
@@ -5340,10 +5333,10 @@ static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
         for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
                 switch(i%3) {
                 case 0:
-                        key[i/3] = hexVal(data->wbuffer[i+j])<<4;
+                        key[i/3] = hex_to_bin(data->wbuffer[i+j])<<4;
                         break;
                 case 1:
-                        key[i/3] |= hexVal(data->wbuffer[i+j]);
+                        key[i/3] |= hex_to_bin(data->wbuffer[i+j]);
                         break;
                 }
         }
diff --git a/drivers/net/wireless/ath/ar9170/usb.c b/drivers/net/wireless/ath/ar9170/usb.c
index 82ab532a4923..a93dc18a45c3 100644
--- a/drivers/net/wireless/ath/ar9170/usb.c
+++ b/drivers/net/wireless/ath/ar9170/usb.c
@@ -739,17 +739,27 @@ err_out:
 static void ar9170_usb_firmware_failed(struct ar9170_usb *aru)
 {
         struct device *parent = aru->udev->dev.parent;
+        struct usb_device *udev;
+
+        /*
+         * Store a copy of the usb_device pointer locally.
+         * This is because device_release_driver initiates
+         * ar9170_usb_disconnect, which in turn frees our
+         * driver context (aru).
+         */
+        udev = aru->udev;
 
         complete(&aru->firmware_loading_complete);
 
         /* unbind anything failed */
         if (parent)
                 device_lock(parent);
-        device_release_driver(&aru->udev->dev);
+
+        device_release_driver(&udev->dev);
         if (parent)
                 device_unlock(parent);
 
-        usb_put_dev(aru->udev);
+        usb_put_dev(udev);
 }
 
 static void ar9170_usb_firmware_finish(const struct firmware *fw, void *context)
diff --git a/drivers/net/wireless/ath/ath5k/base.c b/drivers/net/wireless/ath/ath5k/base.c
index 5f04cf38a5bc..648972df369d 100644
--- a/drivers/net/wireless/ath/ath5k/base.c
+++ b/drivers/net/wireless/ath/ath5k/base.c
@@ -195,7 +195,7 @@ static const struct ieee80211_rate ath5k_rates[] = {
 static int __devinit    ath5k_pci_probe(struct pci_dev *pdev,
                                 const struct pci_device_id *id);
 static void __devexit   ath5k_pci_remove(struct pci_dev *pdev);
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int              ath5k_pci_suspend(struct device *dev);
 static int              ath5k_pci_resume(struct device *dev);
 
@@ -203,7 +203,7 @@ static SIMPLE_DEV_PM_OPS(ath5k_pm_ops, ath5k_pci_suspend, ath5k_pci_resume);
 #define ATH5K_PM_OPS    (&ath5k_pm_ops)
 #else
 #define ATH5K_PM_OPS    NULL
-#endif /* CONFIG_PM */
+#endif /* CONFIG_PM_SLEEP */
 
 static struct pci_driver ath5k_pci_driver = {
         .name           = KBUILD_MODNAME,
@@ -222,7 +222,6 @@ static int ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb);
 static int ath5k_tx_queue(struct ieee80211_hw *hw, struct sk_buff *skb,
                 struct ath5k_txq *txq);
 static int ath5k_reset(struct ath5k_softc *sc, struct ieee80211_channel *chan);
-static int ath5k_reset_wake(struct ath5k_softc *sc);
 static int ath5k_start(struct ieee80211_hw *hw);
 static void ath5k_stop(struct ieee80211_hw *hw);
 static int ath5k_add_interface(struct ieee80211_hw *hw,
@@ -709,7 +708,7 @@ ath5k_pci_remove(struct pci_dev *pdev)
         ieee80211_free_hw(hw);
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int ath5k_pci_suspend(struct device *dev)
 {
         struct ieee80211_hw *hw = pci_get_drvdata(to_pci_dev(dev));
@@ -735,7 +734,7 @@ static int ath5k_pci_resume(struct device *dev)
         ath5k_led_enable(sc);
         return 0;
 }
-#endif /* CONFIG_PM */
+#endif /* CONFIG_PM_SLEEP */
 
 
 /***********************\
@@ -1214,6 +1213,7 @@ ath5k_rxbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf)
         struct ath5k_hw *ah = sc->ah;
         struct sk_buff *skb = bf->skb;
         struct ath5k_desc *ds;
+        int ret;
 
         if (!skb) {
                 skb = ath5k_rx_skb_alloc(sc, &bf->skbaddr);
@@ -1240,9 +1240,9 @@ ath5k_rxbuf_setup(struct ath5k_softc *sc, struct ath5k_buf *bf)
         ds = bf->desc;
         ds->ds_link = bf->daddr;        /* link to self */
         ds->ds_data = bf->skbaddr;
-        ah->ah_setup_rx_desc(ah, ds,
-                skb_tailroom(skb),      /* buffer size */
-                0);
+        ret = ah->ah_setup_rx_desc(ah, ds, ah->common.rx_bufsize, 0);
+        if (ret)
+                return ret;
 
         if (sc->rxlink != NULL)
                 *sc->rxlink = bf->daddr;
@@ -2769,7 +2769,7 @@ ath5k_tasklet_reset(unsigned long data)
 {
         struct ath5k_softc *sc = (void *)data;
 
-        ath5k_reset_wake(sc);
+        ath5k_reset(sc, sc->curchan);
 }
 
 /*
@@ -2940,23 +2940,13 @@ ath5k_reset(struct ath5k_softc *sc, struct ieee80211_channel *chan)
         ath5k_beacon_config(sc);
         /* intrs are enabled by ath5k_beacon_config */
 
+        ieee80211_wake_queues(sc->hw);
+
         return 0;
 err:
         return ret;
 }
 
-static int
-ath5k_reset_wake(struct ath5k_softc *sc)
-{
-        int ret;
-
-        ret = ath5k_reset(sc, sc->curchan);
-        if (!ret)
-                ieee80211_wake_queues(sc->hw);
-
-        return ret;
-}
-
 static int ath5k_start(struct ieee80211_hw *hw)
 {
         return ath5k_init(hw->priv);
@@ -3150,13 +3140,15 @@ static void ath5k_configure_filter(struct ieee80211_hw *hw,
 
         if (changed_flags & (FIF_PROMISC_IN_BSS | FIF_OTHER_BSS)) {
                 if (*new_flags & FIF_PROMISC_IN_BSS) {
-                        rfilt |= AR5K_RX_FILTER_PROM;
                         __set_bit(ATH_STAT_PROMISC, sc->status);
                 } else {
                         __clear_bit(ATH_STAT_PROMISC, sc->status);
                 }
         }
 
+        if (test_bit(ATH_STAT_PROMISC, sc->status))
+                rfilt |= AR5K_RX_FILTER_PROM;
+
         /* Note, AR5K_RX_FILTER_MCAST is already enabled */
         if (*new_flags & FIF_ALLMULTI) {
                 mfilt[0] =  ~0;
diff --git a/drivers/net/wireless/ath/ath5k/phy.c b/drivers/net/wireless/ath/ath5k/phy.c
index 1b81c4778800..492cbb15720d 100644
--- a/drivers/net/wireless/ath/ath5k/phy.c
+++ b/drivers/net/wireless/ath/ath5k/phy.c
@@ -1814,6 +1814,13 @@ ath5k_hw_set_antenna_mode(struct ath5k_hw *ah, u8 ant_mode)
         u8 def_ant, tx_ant, ee_mode;
         u32 sta_id1 = 0;
 
+        /* if channel is not initialized yet we can't set the antennas
+         * so just store the mode. it will be set on the next reset */
+        if (channel == NULL) {
+                ah->ah_ant_mode = ant_mode;
+                return;
+        }
+
         def_ant = ah->ah_def_ant;
 
         ATH5K_TRACE(ah->ah_sc);
diff --git a/drivers/net/wireless/ath/ath9k/beacon.c b/drivers/net/wireless/ath/ath9k/beacon.c
index c8a4558f79ba..f43d85a302c4 100644
--- a/drivers/net/wireless/ath/ath9k/beacon.c
+++ b/drivers/net/wireless/ath/ath9k/beacon.c
@@ -76,22 +76,13 @@ static void ath_beacon_setup(struct ath_softc *sc, struct ath_vif *avp,
         ds = bf->bf_desc;
         flags = ATH9K_TXDESC_NOACK;
 
-        if (((sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC) ||
-             (sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT)) &&
-            (ah->caps.hw_caps & ATH9K_HW_CAP_VEOL)) {
-                ds->ds_link = bf->bf_daddr; /* self-linked */
-                flags |= ATH9K_TXDESC_VEOL;
-                /* Let hardware handle antenna switching. */
-                antenna = 0;
-        } else {
-                ds->ds_link = 0;
-                /*
-                 * Switch antenna every beacon.
-                 * Should only switch every beacon period, not for every SWBA
-                 * XXX assumes two antennae
-                 */
-                antenna = ((sc->beacon.ast_be_xmit / sc->nbcnvifs) & 1 ? 2 : 1);
-        }
+        ds->ds_link = 0;
+        /*
+         * Switch antenna every beacon.
+         * Should only switch every beacon period, not for every SWBA
+         * XXX assumes two antennae
+         */
+        antenna = ((sc->beacon.ast_be_xmit / sc->nbcnvifs) & 1 ? 2 : 1);
 
         sband = &sc->sbands[common->hw->conf.channel->band];
         rate = sband->bitrates[rateidx].hw_value;
@@ -215,36 +206,6 @@ static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw,
         return bf;
 }
 
-/*
- * Startup beacon transmission for adhoc mode when they are sent entirely
- * by the hardware using the self-linked descriptor + veol trick.
-*/
-static void ath_beacon_start_adhoc(struct ath_softc *sc,
-                                   struct ieee80211_vif *vif)
-{
-        struct ath_hw *ah = sc->sc_ah;
-        struct ath_common *common = ath9k_hw_common(ah);
-        struct ath_buf *bf;
-        struct ath_vif *avp;
-        struct sk_buff *skb;
-
-        avp = (void *)vif->drv_priv;
-
-        if (avp->av_bcbuf == NULL)
-                return;
-
-        bf = avp->av_bcbuf;
-        skb = bf->bf_mpdu;
-
-        ath_beacon_setup(sc, avp, bf, 0);
-
-        /* NB: caller is known to have already stopped tx dma */
-        ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr);
-        ath9k_hw_txstart(ah, sc->beacon.beaconq);
-        ath_print(common, ATH_DBG_BEACON, "TXDP%u = %llx (%p)\n",
-                  sc->beacon.beaconq, ito64(bf->bf_daddr), bf->bf_desc);
-}
-
 int ath_beacon_alloc(struct ath_wiphy *aphy, struct ieee80211_vif *vif)
 {
         struct ath_softc *sc = aphy->sc;
@@ -265,7 +226,8 @@ int ath_beacon_alloc(struct ath_wiphy *aphy, struct ieee80211_vif *vif)
                 list_del(&avp->av_bcbuf->list);
 
                 if (sc->sc_ah->opmode == NL80211_IFTYPE_AP ||
-                    !(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_VEOL)) {
+                    sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC ||
+                    sc->sc_ah->opmode == NL80211_IFTYPE_MESH_POINT) {
                         int slot;
                         /*
                          * Assign the vif to a beacon xmit slot. As
@@ -274,17 +236,11 @@ int ath_beacon_alloc(struct ath_wiphy *aphy, struct ieee80211_vif *vif)
                         avp->av_bslot = 0;
                         for (slot = 0; slot < ATH_BCBUF; slot++)
                                 if (sc->beacon.bslot[slot] == NULL) {
-                                        /*
-                                         * XXX hack, space out slots to better
-                                         * deal with misses
-                                         */
-                                        if (slot+1 < ATH_BCBUF &&
-                                            sc->beacon.bslot[slot+1] == NULL) {
-                                                avp->av_bslot = slot+1;
-                                                break;
-                                        }
                                         avp->av_bslot = slot;
+
                                         /* NB: keep looking for a double slot */
+                                        if (slot == 0 || !sc->beacon.bslot[slot-1])
+                                                break;
                                 }
                         BUG_ON(sc->beacon.bslot[avp->av_bslot] != NULL);
                         sc->beacon.bslot[avp->av_bslot] = vif;
@@ -721,8 +677,7 @@ static void ath_beacon_config_adhoc(struct ath_softc *sc,
          * self-linked tx descriptor and let the hardware deal with things.
          */
         intval |= ATH9K_BEACON_ENA;
-        if (!(ah->caps.hw_caps & ATH9K_HW_CAP_VEOL))
-                ah->imask |= ATH9K_INT_SWBA;
+        ah->imask |= ATH9K_INT_SWBA;
 
         ath_beaconq_config(sc);
 
@@ -732,10 +687,6 @@ static void ath_beacon_config_adhoc(struct ath_softc *sc,
         ath9k_beacon_init(sc, nexttbtt, intval);
         sc->beacon.bmisscnt = 0;
         ath9k_hw_set_interrupts(ah, ah->imask);
-
-        /* FIXME: Handle properly when vif is NULL */
-        if (vif && ah->caps.hw_caps & ATH9K_HW_CAP_VEOL)
-                ath_beacon_start_adhoc(sc, vif);
 }
 
 void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif)
diff --git a/drivers/net/wireless/ath/ath9k/hif_usb.c b/drivers/net/wireless/ath/ath9k/hif_usb.c
index 46dc41a16faa..77b359162d6c 100644
--- a/drivers/net/wireless/ath/ath9k/hif_usb.c
+++ b/drivers/net/wireless/ath/ath9k/hif_usb.c
@@ -107,12 +107,14 @@ static inline void ath9k_skb_queue_purge(struct hif_device_usb *hif_dev,
 static void hif_usb_tx_cb(struct urb *urb)
 {
         struct tx_buf *tx_buf = (struct tx_buf *) urb->context;
-        struct hif_device_usb *hif_dev = tx_buf->hif_dev;
+        struct hif_device_usb *hif_dev;
         struct sk_buff *skb;
 
-        if (!hif_dev || !tx_buf)
+        if (!tx_buf || !tx_buf->hif_dev)
                 return;
 
+        hif_dev = tx_buf->hif_dev;
+
         switch (urb->status) {
         case 0:
                 break;
@@ -607,6 +609,10 @@ static int ath9k_hif_usb_alloc_tx_urbs(struct hif_device_usb *hif_dev)
 
         return 0;
 err:
+        if (tx_buf) {
+                kfree(tx_buf->buf);
+                kfree(tx_buf);
+        }
         ath9k_hif_usb_dealloc_tx_urbs(hif_dev);
         return -ENOMEM;
 }
diff --git a/drivers/net/wireless/ath/ath9k/htc.h b/drivers/net/wireless/ath/ath9k/htc.h
index ad556aa8da39..c251603ab032 100644
--- a/drivers/net/wireless/ath/ath9k/htc.h
+++ b/drivers/net/wireless/ath/ath9k/htc.h
@@ -23,6 +23,7 @@
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/leds.h>
+#include <linux/slab.h>
 #include <net/mac80211.h>
 
 #include "common.h"
diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
index 893b552981a0..abfa0493236f 100644
--- a/drivers/net/wireless/ath/ath9k/main.c
+++ b/drivers/net/wireless/ath/ath9k/main.c
@@ -752,7 +752,6 @@ static int ath_key_config(struct ath_common *common,
         struct ath_hw *ah = common->ah;
         struct ath9k_keyval hk;
         const u8 *mac = NULL;
-        u8 gmac[ETH_ALEN];
         int ret = 0;
         int idx;
 
@@ -776,30 +775,9 @@ static int ath_key_config(struct ath_common *common,
         memcpy(hk.kv_val, key->key, key->keylen);
 
         if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
-
-                if (key->ap_addr) {
-                        /*
-                         * Group keys on hardware that supports multicast frame
-                         * key search use a mac that is the sender's address with
-                         * the high bit set instead of the app-specified address.
-                         */
-                        memcpy(gmac, key->ap_addr, ETH_ALEN);
-                        gmac[0] |= 0x80;
-                        mac = gmac;
-
-                        if (key->alg == ALG_TKIP)
-                                idx = ath_reserve_key_cache_slot_tkip(common);
-                        else
-                                idx = ath_reserve_key_cache_slot(common);
-                        if (idx < 0)
-                                mac = NULL; /* no free key cache entries */
-                }
-
-                if (!mac) {
-                        /* For now, use the default keys for broadcast keys. This may
-                         * need to change with virtual interfaces. */
-                        idx = key->keyidx;
-                }
+                /* For now, use the default keys for broadcast keys. This may
+                 * need to change with virtual interfaces. */
+                idx = key->keyidx;
         } else if (key->keyidx) {
                 if (WARN_ON(!sta))
                         return -EOPNOTSUPP;
diff --git a/drivers/net/wireless/ath/ath9k/pci.c b/drivers/net/wireless/ath/ath9k/pci.c
index 257b10ba6f57..1ec836cf1c0d 100644
--- a/drivers/net/wireless/ath/ath9k/pci.c
+++ b/drivers/net/wireless/ath/ath9k/pci.c
@@ -28,7 +28,6 @@ static DEFINE_PCI_DEVICE_TABLE(ath_pci_id_table) = {
         { PCI_VDEVICE(ATHEROS, 0x002C) }, /* PCI-E 802.11n bonded out */
         { PCI_VDEVICE(ATHEROS, 0x002D) }, /* PCI   */
         { PCI_VDEVICE(ATHEROS, 0x002E) }, /* PCI-E */
-        { PCI_VDEVICE(ATHEROS, 0x0030) }, /* PCI-E  AR9300 */
         { 0 }
 };
 
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index ba139132c85f..ca6065b71b46 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -19,6 +19,12 @@
 
 #define SKB_CB_ATHBUF(__skb)    (*((struct ath_buf **)__skb->cb))
 
+static inline bool ath9k_check_auto_sleep(struct ath_softc *sc)
+{
+        return sc->ps_enabled &&
+               (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP);
+}
+
 static struct ieee80211_hw * ath_get_virt_hw(struct ath_softc *sc,
                                              struct ieee80211_hdr *hdr)
 {
@@ -616,8 +622,8 @@ static void ath_rx_ps(struct ath_softc *sc, struct sk_buff *skb)
         hdr = (struct ieee80211_hdr *)skb->data;
 
         /* Process Beacon and CAB receive in PS state */
-        if ((sc->ps_flags & PS_WAIT_FOR_BEACON) &&
-            ieee80211_is_beacon(hdr->frame_control))
+        if (((sc->ps_flags & PS_WAIT_FOR_BEACON) || ath9k_check_auto_sleep(sc))
+            && ieee80211_is_beacon(hdr->frame_control))
                 ath_rx_ps_beacon(sc, skb);
         else if ((sc->ps_flags & PS_WAIT_FOR_CAB) &&
                  (ieee80211_is_data(hdr->frame_control) ||
@@ -932,9 +938,10 @@ int ath_rx_tasklet(struct ath_softc *sc, int flush, bool hp)
                         sc->rx.rxotherant = 0;
                 }
 
-                if (unlikely(sc->ps_flags & (PS_WAIT_FOR_BEACON |
-                                             PS_WAIT_FOR_CAB |
-                                             PS_WAIT_FOR_PSPOLL_DATA)))
+                if (unlikely(ath9k_check_auto_sleep(sc) ||
+                             (sc->ps_flags & (PS_WAIT_FOR_BEACON |
+                                              PS_WAIT_FOR_CAB |
+                                              PS_WAIT_FOR_PSPOLL_DATA))))
                         ath_rx_ps(sc, skb);
 
                 ath_rx_send_to_mac80211(hw, sc, skb, rxs);
diff --git a/drivers/net/wireless/ath/ath9k/xmit.c b/drivers/net/wireless/ath/ath9k/xmit.c
index 3db19172b43b..859aa4ab0769 100644
--- a/drivers/net/wireless/ath/ath9k/xmit.c
+++ b/drivers/net/wireless/ath/ath9k/xmit.c
@@ -1198,7 +1198,7 @@ void ath_drain_all_txq(struct ath_softc *sc, bool retry_tx)
                 int r;
 
                 ath_print(common, ATH_DBG_FATAL,
-                          "Unable to stop TxDMA. Reset HAL!\n");
+                          "Failed to stop TX DMA. Resetting hardware!\n");
 
                 spin_lock_bh(&sc->sc_resetlock);
                 r = ath9k_hw_reset(ah, sc->sc_ah->curchan, false);
@@ -1728,6 +1728,8 @@ static int ath_tx_setup_buffer(struct ieee80211_hw *hw, struct ath_buf *bf,
         } else
                 bf->bf_isnullfunc = false;
 
+        bf->bf_tx_aborted = false;
+
         return 0;
 }
 
@@ -1989,7 +1991,7 @@ static int ath_tx_num_badfrms(struct ath_softc *sc, struct ath_buf *bf,
         int nbad = 0;
         int isaggr = 0;
 
-        if (bf->bf_tx_aborted)
+        if (bf->bf_lastbf->bf_tx_aborted)
                 return 0;
 
         isaggr = bf_isaggr(bf);
diff --git a/drivers/net/wireless/hostap/hostap_hw.c b/drivers/net/wireless/hostap/hostap_hw.c
index d70732819423..ff9b5c882184 100644
--- a/drivers/net/wireless/hostap/hostap_hw.c
+++ b/drivers/net/wireless/hostap/hostap_hw.c
@@ -2618,15 +2618,6 @@ static irqreturn_t prism2_interrupt(int irq, void *dev_id)
         int events = 0;
         u16 ev;
 
-        /* Detect early interrupt before driver is fully configued */
-        if (!dev->base_addr) {
-                if (net_ratelimit()) {
-                        printk(KERN_DEBUG "%s: Interrupt, but dev not configured\n",
-                               dev->name);
-                }
-                return IRQ_HANDLED;
-        }
-
         iface = netdev_priv(dev);
         local = iface->local;
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.c b/drivers/net/wireless/iwlwifi/iwl-3945.c
index 068f7f8435c5..c44a303e62ed 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945.c
@@ -2852,6 +2852,7 @@ static struct iwl_lib_ops iwl3945_lib = {
         .isr = iwl_isr_legacy,
         .config_ap = iwl3945_config_ap,
         .manage_ibss_station = iwl3945_manage_ibss_station,
+        .recover_from_tx_stall = iwl_bg_monitor_recover,
         .check_plcp_health = iwl3945_good_plcp_health,
 
         .debugfs_ops = {
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-ict.c b/drivers/net/wireless/iwlwifi/iwl-agn-ict.c
index a273e373b7b0..c92b2c0cbd91 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-ict.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-ict.c
@@ -30,6 +30,7 @@
 #include <linux/module.h>
 #include <linux/etherdevice.h>
 #include <linux/sched.h>
+#include <linux/gfp.h>
 #include <net/mac80211.h>
 
 #include "iwl-dev.h"
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-lib.c b/drivers/net/wireless/iwlwifi/iwl-agn-lib.c
index 1004cfc403b1..0f292a210ed9 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-lib.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-lib.c
@@ -1119,10 +1119,9 @@ static int iwl_get_single_channel_for_scan(struct iwl_priv *priv,
                                            struct iwl_scan_channel *scan_ch)
 {
         const struct ieee80211_supported_band *sband;
-        const struct iwl_channel_info *ch_info;
         u16 passive_dwell = 0;
         u16 active_dwell = 0;
-        int i, added = 0;
+        int added = 0;
         u16 channel = 0;
 
         sband = iwl_get_hw_mode(priv, band);
@@ -1137,32 +1136,7 @@ static int iwl_get_single_channel_for_scan(struct iwl_priv *priv,
         if (passive_dwell <= active_dwell)
                 passive_dwell = active_dwell + 1;
 
-        /* only scan single channel, good enough to reset the RF */
-        /* pick the first valid not in-use channel */
-        if (band == IEEE80211_BAND_5GHZ) {
-                for (i = 14; i < priv->channel_count; i++) {
-                        if (priv->channel_info[i].channel !=
-                            le16_to_cpu(priv->staging_rxon.channel)) {
-                                channel = priv->channel_info[i].channel;
-                                ch_info = iwl_get_channel_info(priv,
-                                        band, channel);
-                                if (is_channel_valid(ch_info))
-                                        break;
-                        }
-                }
-        } else {
-                for (i = 0; i < 14; i++) {
-                        if (priv->channel_info[i].channel !=
-                            le16_to_cpu(priv->staging_rxon.channel)) {
-                                        channel =
-                                                priv->channel_info[i].channel;
-                                        ch_info = iwl_get_channel_info(priv,
-                                                band, channel);
-                                        if (is_channel_valid(ch_info))
-                                                break;
-                        }
-                }
-        }
+        channel = iwl_get_single_channel_number(priv, band);
         if (channel) {
                 scan_ch->channel = cpu_to_le16(channel);
                 scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE;
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-tx.c b/drivers/net/wireless/iwlwifi/iwl-agn-tx.c
index c402bfc83f36..a732f1094e5d 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-tx.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-tx.c
@@ -1125,6 +1125,7 @@ static void iwlagn_tx_status(struct iwl_priv *priv, struct sk_buff *skb)
         struct ieee80211_sta *sta;
         struct iwl_station_priv *sta_priv;
 
+        rcu_read_lock();
         sta = ieee80211_find_sta(priv->vif, hdr->addr1);
         if (sta) {
                 sta_priv = (void *)sta->drv_priv;
@@ -1133,6 +1134,7 @@ static void iwlagn_tx_status(struct iwl_priv *priv, struct sk_buff *skb)
                     atomic_dec_return(&sta_priv->pending_frames) == 0)
                         ieee80211_sta_block_awake(priv->hw, sta, false);
         }
+        rcu_read_unlock();
 
         ieee80211_tx_status_irqsafe(priv->hw, skb);
 }
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index aef4f71f1981..7726e67044c0 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -1484,6 +1484,156 @@ bool iwl_good_ack_health(struct iwl_priv *priv,
 }
 
 
+/*****************************************************************************
+ *
+ * sysfs attributes
+ *
+ *****************************************************************************/
+
+#ifdef CONFIG_IWLWIFI_DEBUG
+
+/*
+ * The following adds a new attribute to the sysfs representation
+ * of this device driver (i.e. a new file in /sys/class/net/wlan0/device/)
+ * used for controlling the debug level.
+ *
+ * See the level definitions in iwl for details.
+ *
+ * The debug_level being managed using sysfs below is a per device debug
+ * level that is used instead of the global debug level if it (the per
+ * device debug level) is set.
+ */
+static ssize_t show_debug_level(struct device *d,
+                                struct device_attribute *attr, char *buf)
+{
+        struct iwl_priv *priv = dev_get_drvdata(d);
+        return sprintf(buf, "0x%08X\n", iwl_get_debug_level(priv));
+}
+static ssize_t store_debug_level(struct device *d,
+                                struct device_attribute *attr,
+                                 const char *buf, size_t count)
+{
+        struct iwl_priv *priv = dev_get_drvdata(d);
+        unsigned long val;
+        int ret;
+
+        ret = strict_strtoul(buf, 0, &val);
+        if (ret)
+                IWL_ERR(priv, "%s is not in hex or decimal form.\n", buf);
+        else {
+                priv->debug_level = val;
+                if (iwl_alloc_traffic_mem(priv))
+                        IWL_ERR(priv,
+                                "Not enough memory to generate traffic log\n");
+        }
+        return strnlen(buf, count);
+}
+
+static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
+                        show_debug_level, store_debug_level);
+
+
+#endif /* CONFIG_IWLWIFI_DEBUG */
+
+
+static ssize_t show_temperature(struct device *d,
+                                struct device_attribute *attr, char *buf)
+{
+        struct iwl_priv *priv = dev_get_drvdata(d);
+
+        if (!iwl_is_alive(priv))
+                return -EAGAIN;
+
+        return sprintf(buf, "%d\n", priv->temperature);
+}
+
+static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);
+
+static ssize_t show_tx_power(struct device *d,
+                             struct device_attribute *attr, char *buf)
+{
+        struct iwl_priv *priv = dev_get_drvdata(d);
+
+        if (!iwl_is_ready_rf(priv))
+                return sprintf(buf, "off\n");
+        else
+                return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
+}
+
+static ssize_t store_tx_power(struct device *d,
+                              struct device_attribute *attr,
+                              const char *buf, size_t count)
+{
+        struct iwl_priv *priv = dev_get_drvdata(d);
+        unsigned long val;
+        int ret;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret)
+                IWL_INFO(priv, "%s is not in decimal form.\n", buf);
+        else {
+                ret = iwl_set_tx_power(priv, val, false);
+                if (ret)
+                        IWL_ERR(priv, "failed setting tx power (0x%d).\n",
+                                ret);
+                else
+                        ret = count;
+        }
+        return ret;
+}
+
+static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, show_tx_power, store_tx_power);
+
+static ssize_t show_rts_ht_protection(struct device *d,
+                             struct device_attribute *attr, char *buf)
+{
+        struct iwl_priv *priv = dev_get_drvdata(d);
+
+        return sprintf(buf, "%s\n",
+                priv->cfg->use_rts_for_ht ? "RTS/CTS" : "CTS-to-self");
+}
+
+static ssize_t store_rts_ht_protection(struct device *d,
+                              struct device_attribute *attr,
+                              const char *buf, size_t count)
+{
+        struct iwl_priv *priv = dev_get_drvdata(d);
+        unsigned long val;
+        int ret;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret)
+                IWL_INFO(priv, "Input is not in decimal form.\n");
+        else {
+                if (!iwl_is_associated(priv))
+                        priv->cfg->use_rts_for_ht = val ? true : false;
+                else
+                        IWL_ERR(priv, "Sta associated with AP - "
+                                "Change protection mechanism is not allowed\n");
+                ret = count;
+        }
+        return ret;
+}
+
+static DEVICE_ATTR(rts_ht_protection, S_IWUSR | S_IRUGO,
+                        show_rts_ht_protection, store_rts_ht_protection);
+
+
+static struct attribute *iwl_sysfs_entries[] = {
+        &dev_attr_temperature.attr,
+        &dev_attr_tx_power.attr,
+        &dev_attr_rts_ht_protection.attr,
+#ifdef CONFIG_IWLWIFI_DEBUG
+        &dev_attr_debug_level.attr,
+#endif
+        NULL
+};
+
+static struct attribute_group iwl_attribute_group = {
+        .name = NULL,           /* put in device directory */
+        .attrs = iwl_sysfs_entries,
+};
+
 /******************************************************************************
  *
  * uCode download functions
@@ -1965,6 +2115,13 @@ static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
         if (err)
                 IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);
 
+        err = sysfs_create_group(&priv->pci_dev->dev.kobj,
+                                        &iwl_attribute_group);
+        if (err) {
+                IWL_ERR(priv, "failed to create sysfs device attributes\n");
+                goto out_unbind;
+        }
+
         /* We have our copies now, allow OS release its copies */
         release_firmware(ucode_raw);
         complete(&priv->_agn.firmware_loading_complete);
@@ -3264,141 +3421,6 @@ static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
 
 /*****************************************************************************
  *
- * sysfs attributes
- *
- *****************************************************************************/
-
-#ifdef CONFIG_IWLWIFI_DEBUG
-
-/*
- * The following adds a new attribute to the sysfs representation
- * of this device driver (i.e. a new file in /sys/class/net/wlan0/device/)
- * used for controlling the debug level.
- *
- * See the level definitions in iwl for details.
- *
- * The debug_level being managed using sysfs below is a per device debug
- * level that is used instead of the global debug level if it (the per
- * device debug level) is set.
- */
-static ssize_t show_debug_level(struct device *d,
-                                struct device_attribute *attr, char *buf)
-{
-        struct iwl_priv *priv = dev_get_drvdata(d);
-        return sprintf(buf, "0x%08X\n", iwl_get_debug_level(priv));
-}
-static ssize_t store_debug_level(struct device *d,
-                                struct device_attribute *attr,
-                                 const char *buf, size_t count)
-{
-        struct iwl_priv *priv = dev_get_drvdata(d);
-        unsigned long val;
-        int ret;
-
-        ret = strict_strtoul(buf, 0, &val);
-        if (ret)
-                IWL_ERR(priv, "%s is not in hex or decimal form.\n", buf);
-        else {
-                priv->debug_level = val;
-                if (iwl_alloc_traffic_mem(priv))
-                        IWL_ERR(priv,
-                                "Not enough memory to generate traffic log\n");
-        }
-        return strnlen(buf, count);
-}
-
-static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
-                        show_debug_level, store_debug_level);
-
-
-#endif /* CONFIG_IWLWIFI_DEBUG */
-
-
-static ssize_t show_temperature(struct device *d,
-                                struct device_attribute *attr, char *buf)
-{
-        struct iwl_priv *priv = dev_get_drvdata(d);
-
-        if (!iwl_is_alive(priv))
-                return -EAGAIN;
-
-        return sprintf(buf, "%d\n", priv->temperature);
-}
-
-static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);
-
-static ssize_t show_tx_power(struct device *d,
-                             struct device_attribute *attr, char *buf)
-{
-        struct iwl_priv *priv = dev_get_drvdata(d);
-
-        if (!iwl_is_ready_rf(priv))
-                return sprintf(buf, "off\n");
-        else
-                return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
-}
-
-static ssize_t store_tx_power(struct device *d,
-                              struct device_attribute *attr,
-                              const char *buf, size_t count)
-{
-        struct iwl_priv *priv = dev_get_drvdata(d);
-        unsigned long val;
-        int ret;
-
-        ret = strict_strtoul(buf, 10, &val);
-        if (ret)
-                IWL_INFO(priv, "%s is not in decimal form.\n", buf);
-        else {
-                ret = iwl_set_tx_power(priv, val, false);
-                if (ret)
-                        IWL_ERR(priv, "failed setting tx power (0x%d).\n",
-                                ret);
-                else
-                        ret = count;
-        }
-        return ret;
-}
-
-static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, show_tx_power, store_tx_power);
-
-static ssize_t show_rts_ht_protection(struct device *d,
-                             struct device_attribute *attr, char *buf)
-{
-        struct iwl_priv *priv = dev_get_drvdata(d);
-
-        return sprintf(buf, "%s\n",
-                priv->cfg->use_rts_for_ht ? "RTS/CTS" : "CTS-to-self");
-}
-
-static ssize_t store_rts_ht_protection(struct device *d,
-                              struct device_attribute *attr,
-                              const char *buf, size_t count)
-{
-        struct iwl_priv *priv = dev_get_drvdata(d);
-        unsigned long val;
-        int ret;
-
-        ret = strict_strtoul(buf, 10, &val);
-        if (ret)
-                IWL_INFO(priv, "Input is not in decimal form.\n");
-        else {
-                if (!iwl_is_associated(priv))
-                        priv->cfg->use_rts_for_ht = val ? true : false;
-                else
-                        IWL_ERR(priv, "Sta associated with AP - "
-                                "Change protection mechanism is not allowed\n");
-                ret = count;
-        }
-        return ret;
-}
-
-static DEVICE_ATTR(rts_ht_protection, S_IWUSR | S_IRUGO,
-                        show_rts_ht_protection, store_rts_ht_protection);
-
-
-/*****************************************************************************
- *
  * driver setup and teardown
  *
  *****************************************************************************/
@@ -3550,21 +3572,6 @@ static void iwl_uninit_drv(struct iwl_priv *priv)
         kfree(priv->scan_cmd);
 }
 
-static struct attribute *iwl_sysfs_entries[] = {
-        &dev_attr_temperature.attr,
-        &dev_attr_tx_power.attr,
-        &dev_attr_rts_ht_protection.attr,
-#ifdef CONFIG_IWLWIFI_DEBUG
-        &dev_attr_debug_level.attr,
-#endif
-        NULL
-};
-
-static struct attribute_group iwl_attribute_group = {
-        .name = NULL,           /* put in device directory */
-        .attrs = iwl_sysfs_entries,
-};
-
 static struct ieee80211_ops iwl_hw_ops = {
         .tx = iwl_mac_tx,
         .start = iwl_mac_start,
@@ -3750,11 +3757,6 @@ static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
                 goto out_disable_msi;
         }
-        err = sysfs_create_group(&pdev->dev.kobj, &iwl_attribute_group);
-        if (err) {
-                IWL_ERR(priv, "failed to create sysfs device attributes\n");
-                goto out_free_irq;
-        }
 
         iwl_setup_deferred_work(priv);
         iwl_setup_rx_handlers(priv);
@@ -3788,15 +3790,13 @@ static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         err = iwl_request_firmware(priv, true);
         if (err)
-                goto out_remove_sysfs;
+                goto out_destroy_workqueue;
 
         return 0;
 
- out_remove_sysfs:
+ out_destroy_workqueue:
         destroy_workqueue(priv->workqueue);
         priv->workqueue = NULL;
-        sysfs_remove_group(&pdev->dev.kobj, &iwl_attribute_group);
- out_free_irq:
         free_irq(priv->pci_dev->irq, priv);
         iwl_free_isr_ict(priv);
  out_disable_msi:
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.c b/drivers/net/wireless/iwlwifi/iwl-core.c
index 5a7eca8fb789..426e95567de3 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.c
+++ b/drivers/net/wireless/iwlwifi/iwl-core.c
@@ -854,6 +854,45 @@ void iwl_set_rxon_chain(struct iwl_priv *priv)
 }
 EXPORT_SYMBOL(iwl_set_rxon_chain);
 
+/* Return valid channel */
+u8 iwl_get_single_channel_number(struct iwl_priv *priv,
+                                  enum ieee80211_band band)
+{
+        const struct iwl_channel_info *ch_info;
+        int i;
+        u8 channel = 0;
+
+        /* only scan single channel, good enough to reset the RF */
+        /* pick the first valid not in-use channel */
+        if (band == IEEE80211_BAND_5GHZ) {
+                for (i = 14; i < priv->channel_count; i++) {
+                        if (priv->channel_info[i].channel !=
+                            le16_to_cpu(priv->staging_rxon.channel)) {
+                                channel = priv->channel_info[i].channel;
+                                ch_info = iwl_get_channel_info(priv,
+                                        band, channel);
+                                if (is_channel_valid(ch_info))
+                                        break;
+                        }
+                }
+        } else {
+                for (i = 0; i < 14; i++) {
+                        if (priv->channel_info[i].channel !=
+                            le16_to_cpu(priv->staging_rxon.channel)) {
+                                        channel =
+                                                priv->channel_info[i].channel;
+                                        ch_info = iwl_get_channel_info(priv,
+                                                band, channel);
+                                        if (is_channel_valid(ch_info))
+                                                break;
+                        }
+                }
+        }
+
+        return channel;
+}
+EXPORT_SYMBOL(iwl_get_single_channel_number);
+
 /**
  * iwl_set_rxon_channel - Set the phymode and channel values in staging RXON
  * @phymode: MODE_IEEE80211A sets to 5.2GHz; all else set to 2.4GHz
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.h b/drivers/net/wireless/iwlwifi/iwl-core.h
index 7e5a5ba41fd2..31775bd9c361 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.h
+++ b/drivers/net/wireless/iwlwifi/iwl-core.h
@@ -343,6 +343,8 @@ int iwl_check_rxon_cmd(struct iwl_priv *priv);
 int iwl_full_rxon_required(struct iwl_priv *priv);
 void iwl_set_rxon_chain(struct iwl_priv *priv);
 int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch);
+u8 iwl_get_single_channel_number(struct iwl_priv *priv,
+                                  enum ieee80211_band band);
 void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_config *ht_conf);
 u8 iwl_is_ht40_tx_allowed(struct iwl_priv *priv,
                          struct ieee80211_sta_ht_cap *sta_ht_inf);
diff --git a/drivers/net/wireless/iwlwifi/iwl-scan.c b/drivers/net/wireless/iwlwifi/iwl-scan.c
index 107e173112f6..5d3f51ff2f0d 100644
--- a/drivers/net/wireless/iwlwifi/iwl-scan.c
+++ b/drivers/net/wireless/iwlwifi/iwl-scan.c
@@ -376,6 +376,11 @@ void iwl_bg_start_internal_scan(struct work_struct *work)
 
         mutex_lock(&priv->mutex);
 
+        if (priv->is_internal_short_scan == true) {
+                IWL_DEBUG_SCAN(priv, "Internal scan already in progress\n");
+                goto unlock;
+        }
+
         if (!iwl_is_ready_rf(priv)) {
                 IWL_DEBUG_SCAN(priv, "not ready or exit pending\n");
                 goto unlock;
@@ -497,17 +502,27 @@ void iwl_bg_scan_completed(struct work_struct *work)
 {
         struct iwl_priv *priv =
             container_of(work, struct iwl_priv, scan_completed);
+        bool internal = false;
 
         IWL_DEBUG_SCAN(priv, "SCAN complete scan\n");
 
         cancel_delayed_work(&priv->scan_check);
 
-        if (!priv->is_internal_short_scan)
-                ieee80211_scan_completed(priv->hw, false);
-        else {
+        mutex_lock(&priv->mutex);
+        if (priv->is_internal_short_scan) {
                 priv->is_internal_short_scan = false;
                 IWL_DEBUG_SCAN(priv, "internal short scan completed\n");
+                internal = true;
         }
+        mutex_unlock(&priv->mutex);
+
+        /*
+         * Do not hold mutex here since this will cause mac80211 to call
+         * into driver again into functions that will attempt to take
+         * mutex.
+         */
+        if (!internal)
+                ieee80211_scan_completed(priv->hw, false);
 
         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
                 return;
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.c b/drivers/net/wireless/iwlwifi/iwl-sta.c
index 85ed235ac901..83a26361a9b5 100644
--- a/drivers/net/wireless/iwlwifi/iwl-sta.c
+++ b/drivers/net/wireless/iwlwifi/iwl-sta.c
@@ -431,7 +431,7 @@ int iwl_add_bssid_station(struct iwl_priv *priv, const u8 *addr, bool init_rs,
         struct iwl_link_quality_cmd *link_cmd;
         unsigned long flags;
 
-        if (*sta_id_r)
+        if (sta_id_r)
                 *sta_id_r = IWL_INVALID_STATION;
 
         ret = iwl_add_station_common(priv, addr, 0, NULL, &sta_id);
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index 3e5bffb6034f..6c353cacc8d6 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -1844,6 +1844,49 @@ static void iwl3945_irq_tasklet(struct iwl_priv *priv)
 #endif
 }
 
+static int iwl3945_get_single_channel_for_scan(struct iwl_priv *priv,
+                                               struct ieee80211_vif *vif,
+                                               enum ieee80211_band band,
+                                               struct iwl3945_scan_channel *scan_ch)
+{
+        const struct ieee80211_supported_band *sband;
+        u16 passive_dwell = 0;
+        u16 active_dwell = 0;
+        int added = 0;
+        u8 channel = 0;
+
+        sband = iwl_get_hw_mode(priv, band);
+        if (!sband) {
+                IWL_ERR(priv, "invalid band\n");
+                return added;
+        }
+
+        active_dwell = iwl_get_active_dwell_time(priv, band, 0);
+        passive_dwell = iwl_get_passive_dwell_time(priv, band, vif);
+
+        if (passive_dwell <= active_dwell)
+                passive_dwell = active_dwell + 1;
+
+
+        channel = iwl_get_single_channel_number(priv, band);
+
+        if (channel) {
+                scan_ch->channel = channel;
+                scan_ch->type = 0;      /* passive */
+                scan_ch->active_dwell = cpu_to_le16(active_dwell);
+                scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
+                /* Set txpower levels to defaults */
+                scan_ch->tpc.dsp_atten = 110;
+                if (band == IEEE80211_BAND_5GHZ)
+                        scan_ch->tpc.tx_gain = ((1 << 5) | (3 << 3)) | 3;
+                else
+                        scan_ch->tpc.tx_gain = ((1 << 5) | (5 << 3));
+                added++;
+        } else
+                IWL_ERR(priv, "no valid channel found\n");
+        return added;
+}
+
 static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
                                          enum ieee80211_band band,
                                      u8 is_active, u8 n_probes,
@@ -2992,9 +3035,16 @@ void iwl3945_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
         /* select Rx antennas */
         scan->flags |= iwl3945_get_antenna_flags(priv);
 
-        scan->channel_count =
-                iwl3945_get_channels_for_scan(priv, band, is_active, n_probes,
-                        (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)], vif);
+        if (priv->is_internal_short_scan) {
+                scan->channel_count =
+                        iwl3945_get_single_channel_for_scan(priv, vif, band,
+                                (void *)&scan->data[le16_to_cpu(
+                                scan->tx_cmd.len)]);
+        } else {
+                scan->channel_count =
+                        iwl3945_get_channels_for_scan(priv, band, is_active, n_probes,
+                                (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)], vif);
+        }
 
         if (scan->channel_count == 0) {
                 IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
diff --git a/drivers/net/wireless/libertas/rx.c b/drivers/net/wireless/libertas/rx.c
index a115bfa9513a..7a377f5b7662 100644
--- a/drivers/net/wireless/libertas/rx.c
+++ b/drivers/net/wireless/libertas/rx.c
@@ -329,9 +329,8 @@ static int process_rxed_802_11_packet(struct lbs_private *priv,
         /* create the exported radio header */
 
         /* radiotap header */
-        radiotap_hdr.hdr.it_version = 0;
-        /* XXX must check this value for pad */
-        radiotap_hdr.hdr.it_pad = 0;
+        memset(&radiotap_hdr, 0, sizeof(radiotap_hdr));
+        /* XXX must check radiotap_hdr.hdr.it_pad for pad */
         radiotap_hdr.hdr.it_len = cpu_to_le16 (sizeof(struct rx_radiotap_hdr));
         radiotap_hdr.hdr.it_present = cpu_to_le32 (RX_RADIOTAP_PRESENT);
         radiotap_hdr.rate = convert_mv_rate_to_radiotap(prxpd->rx_rate);
diff --git a/drivers/net/wireless/orinoco/airport.c b/drivers/net/wireless/orinoco/airport.c
index 9bcee10c9308..4a0a0e5265c9 100644
--- a/drivers/net/wireless/orinoco/airport.c
+++ b/drivers/net/wireless/orinoco/airport.c
@@ -239,8 +239,11 @@ static struct of_device_id airport_match[] =
 MODULE_DEVICE_TABLE(of, airport_match);
 
 static struct macio_driver airport_driver = {
-        .name           = DRIVER_NAME,
-        .match_table    = airport_match,
+        .driver = {
+                .name           = DRIVER_NAME,
+                .owner          = THIS_MODULE,
+                .of_match_table = airport_match,
+        },
         .probe          = airport_attach,
         .remove         = airport_detach,
         .suspend        = airport_suspend,
diff --git a/drivers/net/wireless/p54/p54usb.c b/drivers/net/wireless/p54/p54usb.c
index d5b197b4d5bb..73073259f508 100644
--- a/drivers/net/wireless/p54/p54usb.c
+++ b/drivers/net/wireless/p54/p54usb.c
@@ -80,6 +80,7 @@ static struct usb_device_id p54u_table[] __devinitdata = {
         {USB_DEVICE(0x1413, 0x5400)},   /* Telsey 802.11g USB2.0 Adapter */
         {USB_DEVICE(0x1435, 0x0427)},   /* Inventel UR054G */
         {USB_DEVICE(0x2001, 0x3704)},   /* DLink DWL-G122 rev A2 */
+        {USB_DEVICE(0x413c, 0x5513)},   /* Dell WLA3310 USB Wireless Adapter */
         {USB_DEVICE(0x413c, 0x8102)},   /* Spinnaker DUT */
         {USB_DEVICE(0x413c, 0x8104)},   /* Cohiba Proto board */
         {}
diff --git a/drivers/net/wireless/rndis_wlan.c b/drivers/net/wireless/rndis_wlan.c
index 2d2890878dea..4bd61ee627c0 100644
--- a/drivers/net/wireless/rndis_wlan.c
+++ b/drivers/net/wireless/rndis_wlan.c
@@ -2572,14 +2572,18 @@ static void rndis_wlan_do_link_up_work(struct usbnet *usbdev)
 
 static void rndis_wlan_do_link_down_work(struct usbnet *usbdev)
 {
-        union iwreq_data evt;
+        struct rndis_wlan_private *priv = get_rndis_wlan_priv(usbdev);
 
-        netif_carrier_off(usbdev->net);
+        if (priv->connected) {
+                priv->connected = false;
+                memset(priv->bssid, 0, ETH_ALEN);
+
+                deauthenticate(usbdev);
 
-        evt.data.flags = 0;
-        evt.data.length = 0;
-        memset(evt.ap_addr.sa_data, 0, ETH_ALEN);
-        wireless_send_event(usbdev->net, SIOCGIWAP, &evt, NULL);
+                cfg80211_disconnected(usbdev->net, 0, NULL, 0, GFP_KERNEL);
+        }
+
+        netif_carrier_off(usbdev->net);
 }
 
 static void rndis_wlan_worker(struct work_struct *work)
diff --git a/drivers/net/wireless/rt2x00/rt2400pci.c b/drivers/net/wireless/rt2x00/rt2400pci.c
index 4ba7b038928f..ad2c98af7e9d 100644
--- a/drivers/net/wireless/rt2x00/rt2400pci.c
+++ b/drivers/net/wireless/rt2x00/rt2400pci.c
@@ -926,7 +926,7 @@ static void rt2400pci_disable_radio(struct rt2x00_dev *rt2x00dev)
 static int rt2400pci_set_state(struct rt2x00_dev *rt2x00dev,
                                enum dev_state state)
 {
-        u32 reg;
+        u32 reg, reg2;
         unsigned int i;
         char put_to_sleep;
         char bbp_state;
@@ -947,11 +947,12 @@ static int rt2400pci_set_state(struct rt2x00_dev *rt2x00dev,
          * device has entered the correct state.
          */
         for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
-                rt2x00pci_register_read(rt2x00dev, PWRCSR1, &reg);
-                bbp_state = rt2x00_get_field32(reg, PWRCSR1_BBP_CURR_STATE);
-                rf_state = rt2x00_get_field32(reg, PWRCSR1_RF_CURR_STATE);
+                rt2x00pci_register_read(rt2x00dev, PWRCSR1, &reg2);
+                bbp_state = rt2x00_get_field32(reg2, PWRCSR1_BBP_CURR_STATE);
+                rf_state = rt2x00_get_field32(reg2, PWRCSR1_RF_CURR_STATE);
                 if (bbp_state == state && rf_state == state)
                         return 0;
+                rt2x00pci_register_write(rt2x00dev, PWRCSR1, reg);
                 msleep(10);
         }
 
diff --git a/drivers/net/wireless/rt2x00/rt2500pci.c b/drivers/net/wireless/rt2x00/rt2500pci.c
index 89d132d4af12..41da3d218c65 100644
--- a/drivers/net/wireless/rt2x00/rt2500pci.c
+++ b/drivers/net/wireless/rt2x00/rt2500pci.c
@@ -1084,7 +1084,7 @@ static void rt2500pci_disable_radio(struct rt2x00_dev *rt2x00dev)
 static int rt2500pci_set_state(struct rt2x00_dev *rt2x00dev,
                                enum dev_state state)
 {
-        u32 reg;
+        u32 reg, reg2;
         unsigned int i;
         char put_to_sleep;
         char bbp_state;
@@ -1105,11 +1105,12 @@ static int rt2500pci_set_state(struct rt2x00_dev *rt2x00dev,
          * device has entered the correct state.
          */
         for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
-                rt2x00pci_register_read(rt2x00dev, PWRCSR1, &reg);
-                bbp_state = rt2x00_get_field32(reg, PWRCSR1_BBP_CURR_STATE);
-                rf_state = rt2x00_get_field32(reg, PWRCSR1_RF_CURR_STATE);
+                rt2x00pci_register_read(rt2x00dev, PWRCSR1, &reg2);
+                bbp_state = rt2x00_get_field32(reg2, PWRCSR1_BBP_CURR_STATE);
+                rf_state = rt2x00_get_field32(reg2, PWRCSR1_RF_CURR_STATE);
                 if (bbp_state == state && rf_state == state)
                         return 0;
+                rt2x00pci_register_write(rt2x00dev, PWRCSR1, reg);
                 msleep(10);
         }
 
diff --git a/drivers/net/wireless/rt2x00/rt2x00pci.c b/drivers/net/wireless/rt2x00/rt2x00pci.c
index a016f7ccde29..f71eee67f977 100644
--- a/drivers/net/wireless/rt2x00/rt2x00pci.c
+++ b/drivers/net/wireless/rt2x00/rt2x00pci.c
@@ -206,7 +206,7 @@ void rt2x00pci_uninitialize(struct rt2x00_dev *rt2x00dev)
         /*
          * Free irq line.
          */
-        free_irq(to_pci_dev(rt2x00dev->dev)->irq, rt2x00dev);
+        free_irq(rt2x00dev->irq, rt2x00dev);
 
         /*
          * Free DMA
diff --git a/drivers/net/wireless/rt2x00/rt61pci.c b/drivers/net/wireless/rt2x00/rt61pci.c
index 2e3076f67535..6a74baf4e934 100644
--- a/drivers/net/wireless/rt2x00/rt61pci.c
+++ b/drivers/net/wireless/rt2x00/rt61pci.c
@@ -1689,7 +1689,7 @@ static void rt61pci_disable_radio(struct rt2x00_dev *rt2x00dev)
 
 static int rt61pci_set_state(struct rt2x00_dev *rt2x00dev, enum dev_state state)
 {
-        u32 reg;
+        u32 reg, reg2;
         unsigned int i;
         char put_to_sleep;
 
@@ -1706,10 +1706,11 @@ static int rt61pci_set_state(struct rt2x00_dev *rt2x00dev, enum dev_state state)
          * device has entered the correct state.
          */
         for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
-                rt2x00pci_register_read(rt2x00dev, MAC_CSR12, &reg);
-                state = rt2x00_get_field32(reg, MAC_CSR12_BBP_CURRENT_STATE);
+                rt2x00pci_register_read(rt2x00dev, MAC_CSR12, &reg2);
+                state = rt2x00_get_field32(reg2, MAC_CSR12_BBP_CURRENT_STATE);
                 if (state == !put_to_sleep)
                         return 0;
+                rt2x00pci_register_write(rt2x00dev, MAC_CSR12, reg);
                 msleep(10);
         }
 
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index e35bd19c3c5a..6e0d82efe924 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -1366,7 +1366,7 @@ static void rt73usb_disable_radio(struct rt2x00_dev *rt2x00dev)
 
 static int rt73usb_set_state(struct rt2x00_dev *rt2x00dev, enum dev_state state)
 {
-        u32 reg;
+        u32 reg, reg2;
         unsigned int i;
         char put_to_sleep;
 
@@ -1383,10 +1383,11 @@ static int rt73usb_set_state(struct rt2x00_dev *rt2x00dev, enum dev_state state)
          * device has entered the correct state.
          */
         for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
-                rt2x00usb_register_read(rt2x00dev, MAC_CSR12, &reg);
-                state = rt2x00_get_field32(reg, MAC_CSR12_BBP_CURRENT_STATE);
+                rt2x00usb_register_read(rt2x00dev, MAC_CSR12, &reg2);
+                state = rt2x00_get_field32(reg2, MAC_CSR12_BBP_CURRENT_STATE);
                 if (state == !put_to_sleep)
                         return 0;
+                rt2x00usb_register_write(rt2x00dev, MAC_CSR12, reg);
                 msleep(10);
         }
 
diff --git a/drivers/net/wireless/wl12xx/wl1251_sdio.c b/drivers/net/wireless/wl12xx/wl1251_sdio.c
index d234285c2c81..c561332e7009 100644
--- a/drivers/net/wireless/wl12xx/wl1251_sdio.c
+++ b/drivers/net/wireless/wl12xx/wl1251_sdio.c
@@ -259,6 +259,7 @@ disable:
         sdio_disable_func(func);
 release:
         sdio_release_host(func);
+        wl1251_free_hw(wl);
         return ret;
 }
 
diff --git a/drivers/net/wireless/wl12xx/wl1271_rx.c b/drivers/net/wireless/wl12xx/wl1271_rx.c
index 57f4bfd959c8..b98fb643fab0 100644
--- a/drivers/net/wireless/wl12xx/wl1271_rx.c
+++ b/drivers/net/wireless/wl12xx/wl1271_rx.c
@@ -113,6 +113,8 @@ static void wl1271_rx_handle_data(struct wl1271 *wl, u32 length)
         wl1271_debug(DEBUG_RX, "rx skb 0x%p: %d B %s", skb, skb->len,
                      beacon ? "beacon" : "");
 
+        skb_trim(skb, skb->len - desc->pad_len);
+
         memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
         ieee80211_rx_ni(wl->hw, skb);
 }
diff --git a/drivers/net/xilinx_emaclite.c b/drivers/net/xilinx_emaclite.c
index a7db68d37ee9..d04c5b262050 100644
--- a/drivers/net/xilinx_emaclite.c
+++ b/drivers/net/xilinx_emaclite.c
@@ -1088,7 +1088,7 @@ static void xemaclite_remove_ndev(struct net_device *ndev)
  */
 static bool get_bool(struct of_device *ofdev, const char *s)
 {
-        u32 *p = (u32 *)of_get_property(ofdev->node, s, NULL);
+        u32 *p = (u32 *)of_get_property(ofdev->dev.of_node, s, NULL);
 
         if (p) {
                 return (bool)*p;
@@ -1130,14 +1130,14 @@ static int __devinit xemaclite_of_probe(struct of_device *ofdev,
         dev_info(dev, "Device Tree Probing\n");
 
         /* Get iospace for the device */
-        rc = of_address_to_resource(ofdev->node, 0, &r_mem);
+        rc = of_address_to_resource(ofdev->dev.of_node, 0, &r_mem);
         if (rc) {
                 dev_err(dev, "invalid address\n");
                 return rc;
         }
 
         /* Get IRQ for the device */
-        rc = of_irq_to_resource(ofdev->node, 0, &r_irq);
+        rc = of_irq_to_resource(ofdev->dev.of_node, 0, &r_irq);
         if (rc == NO_IRQ) {
                 dev_err(dev, "no IRQ found\n");
                 return rc;
@@ -1182,7 +1182,7 @@ static int __devinit xemaclite_of_probe(struct of_device *ofdev,
         lp->next_rx_buf_to_use = 0x0;
         lp->tx_ping_pong = get_bool(ofdev, "xlnx,tx-ping-pong");
         lp->rx_ping_pong = get_bool(ofdev, "xlnx,rx-ping-pong");
-        mac_address = of_get_mac_address(ofdev->node);
+        mac_address = of_get_mac_address(ofdev->dev.of_node);
 
         if (mac_address)
                 /* Set the MAC address. */
@@ -1197,7 +1197,7 @@ static int __devinit xemaclite_of_probe(struct of_device *ofdev,
         /* Set the MAC address in the EmacLite device */
         xemaclite_update_address(lp, ndev->dev_addr);
 
-        lp->phy_node = of_parse_phandle(ofdev->node, "phy-handle", 0);
+        lp->phy_node = of_parse_phandle(ofdev->dev.of_node, "phy-handle", 0);
         rc = xemaclite_mdio_setup(lp, &ofdev->dev);
         if (rc)
                 dev_warn(&ofdev->dev, "error registering MDIO bus\n");
@@ -1291,8 +1291,11 @@ static struct of_device_id xemaclite_of_match[] __devinitdata = {
 MODULE_DEVICE_TABLE(of, xemaclite_of_match);
 
 static struct of_platform_driver xemaclite_of_driver = {
-        .name           = DRIVER_NAME,
-        .match_table    = xemaclite_of_match,
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+                .of_match_table = xemaclite_of_match,
+        },
         .probe          = xemaclite_of_probe,
         .remove         = __devexit_p(xemaclite_of_remove),
 };