106 files changed, 3018 insertions, 3028 deletions

diff --git a/drivers/isdn/capi/Kconfig b/drivers/isdn/capi/Kconfig
index a168e8a891be..15c3ffd9d860 100644
--- a/drivers/isdn/capi/Kconfig
+++ b/drivers/isdn/capi/Kconfig
@@ -33,21 +33,6 @@ config ISDN_CAPI_CAPI20
           standardized libcapi20 to access this functionality.  You should say
           Y/M here.
 
-config ISDN_CAPI_CAPIFS_BOOL
-        bool "CAPI2.0 filesystem support (DEPRECATED)"
-        depends on ISDN_CAPI_MIDDLEWARE && ISDN_CAPI_CAPI20
-        help
-          This option provides a special file system, similar to /dev/pts with
-          device nodes for the special ttys established by using the
-          middleware extension above.
-          You no longer need this, udev fully replaces it. This feature is
-          scheduled for removal.
-
-config ISDN_CAPI_CAPIFS
-        tristate
-        depends on ISDN_CAPI_CAPIFS_BOOL
-        default ISDN_CAPI_CAPI20
-
 config ISDN_CAPI_CAPIDRV
         tristate "CAPI2.0 capidrv interface support"
         depends on ISDN_I4L
diff --git a/drivers/isdn/capi/Makefile b/drivers/isdn/capi/Makefile
index 57123e3e4978..4d5b4b71db1e 100644
--- a/drivers/isdn/capi/Makefile
+++ b/drivers/isdn/capi/Makefile
@@ -7,7 +7,6 @@
 obj-$(CONFIG_ISDN_CAPI)                 += kernelcapi.o
 obj-$(CONFIG_ISDN_CAPI_CAPI20)          += capi.o 
 obj-$(CONFIG_ISDN_CAPI_CAPIDRV)         += capidrv.o
-obj-$(CONFIG_ISDN_CAPI_CAPIFS)          += capifs.o
 
 # Multipart objects.
 
diff --git a/drivers/isdn/capi/capi.c b/drivers/isdn/capi/capi.c
index 0d7088367038..bea100983336 100644
--- a/drivers/isdn/capi/capi.c
+++ b/drivers/isdn/capi/capi.c
@@ -38,8 +38,6 @@
 #include <linux/isdn/capiutil.h>
 #include <linux/isdn/capicmd.h>
 
-#include "capifs.h"
-
 MODULE_DESCRIPTION("CAPI4Linux: Userspace /dev/capi20 interface");
 MODULE_AUTHOR("Carsten Paeth");
 MODULE_LICENSE("GPL");
@@ -85,7 +83,6 @@ struct capiminor {
         struct kref kref;
 
         unsigned int      minor;
-        struct dentry *capifs_dentry;
 
         struct capi20_appl      *ap;
         u32                     ncci;
@@ -300,17 +297,8 @@ static void capiminor_free(struct capiminor *mp)
 
 static void capincci_alloc_minor(struct capidev *cdev, struct capincci *np)
 {
-        struct capiminor *mp;
-        dev_t device;
-
-        if (!(cdev->userflags & CAPIFLAG_HIGHJACKING))
-                return;
-
-        mp = np->minorp = capiminor_alloc(&cdev->ap, np->ncci);
-        if (mp) {
-                device = MKDEV(capinc_tty_driver->major, mp->minor);
-                mp->capifs_dentry = capifs_new_ncci(mp->minor, device);
-        }
+        if (cdev->userflags & CAPIFLAG_HIGHJACKING)
+                np->minorp = capiminor_alloc(&cdev->ap, np->ncci);
 }
 
 static void capincci_free_minor(struct capincci *np)
@@ -319,8 +307,6 @@ static void capincci_free_minor(struct capincci *np)
         struct tty_struct *tty;
 
         if (mp) {
-                capifs_free_ncci(mp->capifs_dentry);
-
                 tty = tty_port_tty_get(&mp->port);
                 if (tty) {
                         tty_vhangup(tty);
@@ -1514,10 +1500,8 @@ static int __init capi_init(void)
 
         proc_init();
 
-#if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
-        compileinfo = " (middleware+capifs)";
-#elif defined(CONFIG_ISDN_CAPI_MIDDLEWARE)
-        compileinfo = " (no capifs)";
+#ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
+        compileinfo = " (middleware)";
 #else
         compileinfo = " (no middleware)";
 #endif
diff --git a/drivers/isdn/capi/capifs.c b/drivers/isdn/capi/capifs.c
deleted file mode 100644
index b4faed7fe0d3..000000000000
--- a/drivers/isdn/capi/capifs.c
+++ /dev/null
@@ -1,239 +0,0 @@
-/* $Id: capifs.c,v 1.1.2.3 2004/01/16 21:09:26 keil Exp $
- * 
- * Copyright 2000 by Carsten Paeth <calle@calle.de>
- *
- * Heavily based on devpts filesystem from H. Peter Anvin
- * 
- * This software may be used and distributed according to the terms
- * of the GNU General Public License, incorporated herein by reference.
- *
- */
-
-#include <linux/fs.h>
-#include <linux/mount.h>
-#include <linux/slab.h>
-#include <linux/namei.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/ctype.h>
-#include <linux/sched.h>        /* current */
-
-#include "capifs.h"
-
-MODULE_DESCRIPTION("CAPI4Linux: /dev/capi/ filesystem");
-MODULE_AUTHOR("Carsten Paeth");
-MODULE_LICENSE("GPL");
-
-/* ------------------------------------------------------------------ */
-
-#define CAPIFS_SUPER_MAGIC (('C'<<8)|'N')
-
-static struct vfsmount *capifs_mnt;
-static int capifs_mnt_count;
-
-static struct {
-        int setuid;
-        int setgid;
-        uid_t   uid;
-        gid_t   gid;
-        umode_t mode;
-} config = {.mode = 0600};
-
-/* ------------------------------------------------------------------ */
-
-static int capifs_remount(struct super_block *s, int *flags, char *data)
-{
-        int setuid = 0;
-        int setgid = 0;
-        uid_t uid = 0;
-        gid_t gid = 0;
-        umode_t mode = 0600;
-        char *this_char;
-        char *new_opt = kstrdup(data, GFP_KERNEL);
-
-        this_char = NULL;
-        while ((this_char = strsep(&data, ",")) != NULL) {
-                int n;
-                char dummy;
-                if (!*this_char)
-                        continue;
-                if (sscanf(this_char, "uid=%i%c", &n, &dummy) == 1) {
-                        setuid = 1;
-                        uid = n;
-                } else if (sscanf(this_char, "gid=%i%c", &n, &dummy) == 1) {
-                        setgid = 1;
-                        gid = n;
-                } else if (sscanf(this_char, "mode=%o%c", &n, &dummy) == 1)
-                        mode = n & ~S_IFMT;
-                else {
-                        kfree(new_opt);
-                        printk("capifs: called with bogus options\n");
-                        return -EINVAL;
-                }
-        }
-
-        mutex_lock(&s->s_root->d_inode->i_mutex);
-
-        replace_mount_options(s, new_opt);
-        config.setuid  = setuid;
-        config.setgid  = setgid;
-        config.uid     = uid;
-        config.gid     = gid;
-        config.mode    = mode;
-
-        mutex_unlock(&s->s_root->d_inode->i_mutex);
-
-        return 0;
-}
-
-static const struct super_operations capifs_sops =
-{
-        .statfs         = simple_statfs,
-        .remount_fs     = capifs_remount,
-        .show_options   = generic_show_options,
-};
-
-
-static int
-capifs_fill_super(struct super_block *s, void *data, int silent)
-{
-        struct inode * inode;
-
-        s->s_blocksize = 1024;
-        s->s_blocksize_bits = 10;
-        s->s_magic = CAPIFS_SUPER_MAGIC;
-        s->s_op = &capifs_sops;
-        s->s_time_gran = 1;
-
-        inode = new_inode(s);
-        if (!inode)
-                goto fail;
-        inode->i_ino = 1;
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
-        inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO | S_IWUSR;
-        inode->i_op = &simple_dir_inode_operations;
-        inode->i_fop = &simple_dir_operations;
-        inode->i_nlink = 2;
-
-        s->s_root = d_alloc_root(inode);
-        if (s->s_root)
-                return 0;
-        
-        printk("capifs: get root dentry failed\n");
-        iput(inode);
-fail:
-        return -ENOMEM;
-}
-
-static struct dentry *capifs_mount(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data)
-{
-        return mount_single(fs_type, flags, data, capifs_fill_super);
-}
-
-static struct file_system_type capifs_fs_type = {
-        .owner          = THIS_MODULE,
-        .name           = "capifs",
-        .mount          = capifs_mount,
-        .kill_sb        = kill_anon_super,
-};
-
-static struct dentry *new_ncci(unsigned int number, dev_t device)
-{
-        struct super_block *s = capifs_mnt->mnt_sb;
-        struct dentry *root = s->s_root;
-        struct dentry *dentry;
-        struct inode *inode;
-        char name[10];
-        int namelen;
-
-        mutex_lock(&root->d_inode->i_mutex);
-
-        namelen = sprintf(name, "%d", number);
-        dentry = lookup_one_len(name, root, namelen);
-        if (IS_ERR(dentry)) {
-                dentry = NULL;
-                goto unlock_out;
-        }
-
-        if (dentry->d_inode) {
-                dput(dentry);
-                dentry = NULL;
-                goto unlock_out;
-        }
-
-        inode = new_inode(s);
-        if (!inode) {
-                dput(dentry);
-                dentry = NULL;
-                goto unlock_out;
-        }
-
-        /* config contents is protected by root's i_mutex */
-        inode->i_uid = config.setuid ? config.uid : current_fsuid();
-        inode->i_gid = config.setgid ? config.gid : current_fsgid();
-        inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
-        inode->i_ino = number + 2;
-        init_special_inode(inode, S_IFCHR|config.mode, device);
-
-        d_instantiate(dentry, inode);
-        dget(dentry);
-
-unlock_out:
-        mutex_unlock(&root->d_inode->i_mutex);
-
-        return dentry;
-}
-
-struct dentry *capifs_new_ncci(unsigned int number, dev_t device)
-{
-        struct dentry *dentry;
-
-        if (simple_pin_fs(&capifs_fs_type, &capifs_mnt, &capifs_mnt_count) < 0)
-                return NULL;
-
-        dentry = new_ncci(number, device);
-        if (!dentry)
-                simple_release_fs(&capifs_mnt, &capifs_mnt_count);
-
-        return dentry;
-}
-
-void capifs_free_ncci(struct dentry *dentry)
-{
-        struct dentry *root = capifs_mnt->mnt_sb->s_root;
-        struct inode *inode;
-
-        if (!dentry)
-                return;
-
-        mutex_lock(&root->d_inode->i_mutex);
-
-        inode = dentry->d_inode;
-        if (inode) {
-                drop_nlink(inode);
-                d_delete(dentry);
-                dput(dentry);
-        }
-        dput(dentry);
-
-        mutex_unlock(&root->d_inode->i_mutex);
-
-        simple_release_fs(&capifs_mnt, &capifs_mnt_count);
-}
-
-static int __init capifs_init(void)
-{
-        return register_filesystem(&capifs_fs_type);
-}
-
-static void __exit capifs_exit(void)
-{
-        unregister_filesystem(&capifs_fs_type);
-}
-
-EXPORT_SYMBOL(capifs_new_ncci);
-EXPORT_SYMBOL(capifs_free_ncci);
-
-module_init(capifs_init);
-module_exit(capifs_exit);
diff --git a/drivers/isdn/capi/capifs.h b/drivers/isdn/capi/capifs.h
deleted file mode 100644
index e193d1189531..000000000000
--- a/drivers/isdn/capi/capifs.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/* $Id: capifs.h,v 1.1.2.2 2004/01/16 21:09:26 keil Exp $
- * 
- * Copyright 2000 by Carsten Paeth <calle@calle.de>
- *
- * This software may be used and distributed according to the terms
- * of the GNU General Public License, incorporated herein by reference.
- *
- */
-
-#include <linux/dcache.h>
-
-#if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
-
-struct dentry *capifs_new_ncci(unsigned int num, dev_t device);
-void capifs_free_ncci(struct dentry *dentry);
-
-#else
-
-static inline struct dentry *capifs_new_ncci(unsigned int num, dev_t device)
-{
-        return NULL;
-}
-
-static inline void capifs_free_ncci(struct dentry *dentry)
-{
-}
-
-#endif
diff --git a/drivers/isdn/gigaset/ev-layer.c b/drivers/isdn/gigaset/ev-layer.c
index a14187605f5e..ba74646cf0e4 100644
--- a/drivers/isdn/gigaset/ev-layer.c
+++ b/drivers/isdn/gigaset/ev-layer.c
@@ -390,12 +390,12 @@ static const struct zsau_resp_t {
  */
 static int cid_of_response(char *s)
 {
-        unsigned long cid;
+        int cid;
         int rc;
 
         if (s[-1] != ';')
                 return 0;       /* no CID separator */
-        rc = strict_strtoul(s, 10, &cid);
+        rc = kstrtoint(s, 10, &cid);
         if (rc)
                 return 0;       /* CID not numeric */
         if (cid < 1 || cid > 65535)
@@ -566,27 +566,19 @@ void gigaset_handle_modem_response(struct cardstate *cs)
                 case RT_ZCAU:
                         event->parameter = -1;
                         if (curarg + 1 < params) {
-                                unsigned long type, value;
-
-                                i = strict_strtoul(argv[curarg++], 16, &type);
-                                j = strict_strtoul(argv[curarg++], 16, &value);
+                                u8 type, value;
 
-                                if (i == 0 && type < 256 &&
-                                    j == 0 && value < 256)
+                                i = kstrtou8(argv[curarg++], 16, &type);
+                                j = kstrtou8(argv[curarg++], 16, &value);
+                                if (i == 0 && j == 0)
                                         event->parameter = (type << 8) | value;
                         } else
                                 curarg = params - 1;
                         break;
                 case RT_NUMBER:
-                        event->parameter = -1;
-                        if (curarg < params) {
-                                unsigned long res;
-                                int rc;
-
-                                rc = strict_strtoul(argv[curarg++], 10, &res);
-                                if (rc == 0)
-                                        event->parameter = res;
-                        }
+                        if (curarg >= params ||
+                            kstrtoint(argv[curarg++], 10, &event->parameter))
+                                event->parameter = -1;
                         gig_dbg(DEBUG_EVENT, "parameter==%d", event->parameter);
                         break;
                 }
diff --git a/drivers/isdn/hysdn/hysdn_proclog.c b/drivers/isdn/hysdn/hysdn_proclog.c
index 2ee93d04b2dd..236cc7dadfd0 100644
--- a/drivers/isdn/hysdn/hysdn_proclog.c
+++ b/drivers/isdn/hysdn/hysdn_proclog.c
@@ -155,7 +155,6 @@ put_log_buffer(hysdn_card * card, char *cp)
 static ssize_t
 hysdn_log_write(struct file *file, const char __user *buf, size_t count, loff_t * off)
 {
-        unsigned long u = 0;
         int rc;
         unsigned char valbuf[128];
         hysdn_card *card = file->private_data;
@@ -167,12 +166,10 @@ hysdn_log_write(struct file *file, const char __user *buf, size_t count, loff_t
 
         valbuf[count] = 0;      /* terminating 0 */
 
-        rc = strict_strtoul(valbuf, 0, &u);
-
-        if (rc == 0) {
-                card->debug_flags = u;  /* remember debug flags */
-                hysdn_addlog(card, "debug set to 0x%lx", card->debug_flags);
-        }
+        rc = kstrtoul(valbuf, 0, &card->debug_flags);
+        if (rc < 0)
+                return rc;
+        hysdn_addlog(card, "debug set to 0x%lx", card->debug_flags);
         return (count);
 }                               /* hysdn_log_write */
 
diff --git a/drivers/isdn/mISDN/layer2.c b/drivers/isdn/mISDN/layer2.c
index d0aeb44ee7c0..5bc00156315e 100644
--- a/drivers/isdn/mISDN/layer2.c
+++ b/drivers/isdn/mISDN/layer2.c
@@ -1640,7 +1640,7 @@ l2_tei_remove(struct FsmInst *fi, int event, void *arg)
 }
 
 static void
-l2_st14_persistant_da(struct FsmInst *fi, int event, void *arg)
+l2_st14_persistent_da(struct FsmInst *fi, int event, void *arg)
 {
         struct layer2 *l2 = fi->userdata;
         struct sk_buff *skb = arg;
@@ -1654,7 +1654,7 @@ l2_st14_persistant_da(struct FsmInst *fi, int event, void *arg)
 }
 
 static void
-l2_st5_persistant_da(struct FsmInst *fi, int event, void *arg)
+l2_st5_persistent_da(struct FsmInst *fi, int event, void *arg)
 {
         struct layer2 *l2 = fi->userdata;
         struct sk_buff *skb = arg;
@@ -1671,7 +1671,7 @@ l2_st5_persistant_da(struct FsmInst *fi, int event, void *arg)
 }
 
 static void
-l2_st6_persistant_da(struct FsmInst *fi, int event, void *arg)
+l2_st6_persistent_da(struct FsmInst *fi, int event, void *arg)
 {
         struct layer2 *l2 = fi->userdata;
         struct sk_buff *skb = arg;
@@ -1685,7 +1685,7 @@ l2_st6_persistant_da(struct FsmInst *fi, int event, void *arg)
 }
 
 static void
-l2_persistant_da(struct FsmInst *fi, int event, void *arg)
+l2_persistent_da(struct FsmInst *fi, int event, void *arg)
 {
         struct layer2 *l2 = fi->userdata;
         struct sk_buff *skb = arg;
@@ -1829,14 +1829,14 @@ static struct FsmNode L2FnList[] =
         {ST_L2_6, EV_L2_FRAME_ERROR, l2_frame_error},
         {ST_L2_7, EV_L2_FRAME_ERROR, l2_frame_error_reest},
         {ST_L2_8, EV_L2_FRAME_ERROR, l2_frame_error_reest},
-        {ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistant_da},
+        {ST_L2_1, EV_L1_DEACTIVATE, l2_st14_persistent_da},
         {ST_L2_2, EV_L1_DEACTIVATE, l2_st24_tei_remove},
         {ST_L2_3, EV_L1_DEACTIVATE, l2_st3_tei_remove},
-        {ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistant_da},
-        {ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistant_da},
-        {ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistant_da},
-        {ST_L2_7, EV_L1_DEACTIVATE, l2_persistant_da},
-        {ST_L2_8, EV_L1_DEACTIVATE, l2_persistant_da},
+        {ST_L2_4, EV_L1_DEACTIVATE, l2_st14_persistent_da},
+        {ST_L2_5, EV_L1_DEACTIVATE, l2_st5_persistent_da},
+        {ST_L2_6, EV_L1_DEACTIVATE, l2_st6_persistent_da},
+        {ST_L2_7, EV_L1_DEACTIVATE, l2_persistent_da},
+        {ST_L2_8, EV_L1_DEACTIVATE, l2_persistent_da},
 };
 
 static int
diff --git a/drivers/net/8139cp.c b/drivers/net/8139cp.c
index dd16e83933a2..10c45051caea 100644
--- a/drivers/net/8139cp.c
+++ b/drivers/net/8139cp.c
@@ -758,8 +758,7 @@ static netdev_tx_t cp_start_xmit (struct sk_buff *skb,
 
         entry = cp->tx_head;
         eor = (entry == (CP_TX_RING_SIZE - 1)) ? RingEnd : 0;
-        if (dev->features & NETIF_F_TSO)
-                mss = skb_shinfo(skb)->gso_size;
+        mss = skb_shinfo(skb)->gso_size;
 
         if (skb_shinfo(skb)->nr_frags == 0) {
                 struct cp_desc *txd = &cp->tx_ring[entry];
@@ -1416,32 +1415,23 @@ static void cp_set_msglevel(struct net_device *dev, u32 value)
         cp->msg_enable = value;
 }
 
-static u32 cp_get_rx_csum(struct net_device *dev)
+static int cp_set_features(struct net_device *dev, u32 features)
 {
         struct cp_private *cp = netdev_priv(dev);
-        return (cpr16(CpCmd) & RxChkSum) ? 1 : 0;
-}
+        unsigned long flags;
 
-static int cp_set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct cp_private *cp = netdev_priv(dev);
-        u16 cmd = cp->cpcmd, newcmd;
+        if (!((dev->features ^ features) & NETIF_F_RXCSUM))
+                return 0;
 
-        newcmd = cmd;
+        spin_lock_irqsave(&cp->lock, flags);
 
-        if (data)
-                newcmd |= RxChkSum;
+        if (features & NETIF_F_RXCSUM)
+                cp->cpcmd |= RxChkSum;
         else
-                newcmd &= ~RxChkSum;
-
-        if (newcmd != cmd) {
-                unsigned long flags;
+                cp->cpcmd &= ~RxChkSum;
 
-                spin_lock_irqsave(&cp->lock, flags);
-                cp->cpcmd = newcmd;
-                cpw16_f(CpCmd, newcmd);
-                spin_unlock_irqrestore(&cp->lock, flags);
-        }
+        cpw16_f(CpCmd, cp->cpcmd);
+        spin_unlock_irqrestore(&cp->lock, flags);
 
         return 0;
 }
@@ -1554,11 +1544,6 @@ static const struct ethtool_ops cp_ethtool_ops = {
         .get_link               = ethtool_op_get_link,
         .get_msglevel           = cp_get_msglevel,
         .set_msglevel           = cp_set_msglevel,
-        .get_rx_csum            = cp_get_rx_csum,
-        .set_rx_csum            = cp_set_rx_csum,
-        .set_tx_csum            = ethtool_op_set_tx_csum, /* local! */
-        .set_sg                 = ethtool_op_set_sg,
-        .set_tso                = ethtool_op_set_tso,
         .get_regs               = cp_get_regs,
         .get_wol                = cp_get_wol,
         .set_wol                = cp_set_wol,
@@ -1831,6 +1816,7 @@ static const struct net_device_ops cp_netdev_ops = {
         .ndo_do_ioctl           = cp_ioctl,
         .ndo_start_xmit         = cp_start_xmit,
         .ndo_tx_timeout         = cp_tx_timeout,
+        .ndo_set_features       = cp_set_features,
 #if CP_VLAN_TAG_USED
         .ndo_vlan_rx_register   = cp_vlan_rx_register,
 #endif
@@ -1934,6 +1920,9 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         cp->cpcmd = (pci_using_dac ? PCIDAC : 0) |
                     PCIMulRW | RxChkSum | CpRxOn | CpTxOn;
 
+        dev->features |= NETIF_F_RXCSUM;
+        dev->hw_features |= NETIF_F_RXCSUM;
+
         regs = ioremap(pciaddr, CP_REGS_SIZE);
         if (!regs) {
                 rc = -EIO;
@@ -1966,9 +1955,8 @@ static int cp_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
         if (pci_using_dac)
                 dev->features |= NETIF_F_HIGHDMA;
 
-#if 0 /* disabled by default until verified */
-        dev->features |= NETIF_F_TSO;
-#endif
+        /* disabled by default until verified */
+        dev->hw_features |= NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO;
 
         dev->irq = pdev->irq;
 
diff --git a/drivers/net/atl1c/atl1c_ethtool.c b/drivers/net/atl1c/atl1c_ethtool.c
index 7c521508313c..3af5a336a5af 100644
--- a/drivers/net/atl1c/atl1c_ethtool.c
+++ b/drivers/net/atl1c/atl1c_ethtool.c
@@ -113,11 +113,6 @@ static int atl1c_set_settings(struct net_device *netdev,
         return 0;
 }
 
-static u32 atl1c_get_tx_csum(struct net_device *netdev)
-{
-        return (netdev->features & NETIF_F_HW_CSUM) != 0;
-}
-
 static u32 atl1c_get_msglevel(struct net_device *netdev)
 {
         struct atl1c_adapter *adapter = netdev_priv(netdev);
@@ -307,9 +302,6 @@ static const struct ethtool_ops atl1c_ethtool_ops = {
         .get_link               = ethtool_op_get_link,
         .get_eeprom_len         = atl1c_get_eeprom_len,
         .get_eeprom             = atl1c_get_eeprom,
-        .get_tx_csum            = atl1c_get_tx_csum,
-        .get_sg                 = ethtool_op_get_sg,
-        .set_sg                 = ethtool_op_set_sg,
 };
 
 void atl1c_set_ethtool_ops(struct net_device *netdev)
diff --git a/drivers/net/atl1c/atl1c_main.c b/drivers/net/atl1c/atl1c_main.c
index 7d9d5067a65c..894d485bf5bc 100644
--- a/drivers/net/atl1c/atl1c_main.c
+++ b/drivers/net/atl1c/atl1c_main.c
@@ -484,6 +484,15 @@ static void atl1c_set_rxbufsize(struct atl1c_adapter *adapter,
         adapter->rx_buffer_len = mtu > AT_RX_BUF_SIZE ?
                 roundup(mtu + ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN, 8) : AT_RX_BUF_SIZE;
 }
+
+static u32 atl1c_fix_features(struct net_device *netdev, u32 features)
+{
+        if (netdev->mtu > MAX_TSO_FRAME_SIZE)
+                features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
+
+        return features;
+}
+
 /*
  * atl1c_change_mtu - Change the Maximum Transfer Unit
  * @netdev: network interface device structure
@@ -510,14 +519,8 @@ static int atl1c_change_mtu(struct net_device *netdev, int new_mtu)
                 netdev->mtu = new_mtu;
                 adapter->hw.max_frame_size = new_mtu;
                 atl1c_set_rxbufsize(adapter, netdev);
-                if (new_mtu > MAX_TSO_FRAME_SIZE) {
-                        adapter->netdev->features &= ~NETIF_F_TSO;
-                        adapter->netdev->features &= ~NETIF_F_TSO6;
-                } else {
-                        adapter->netdev->features |= NETIF_F_TSO;
-                        adapter->netdev->features |= NETIF_F_TSO6;
-                }
                 atl1c_down(adapter);
+                netdev_update_features(netdev);
                 atl1c_up(adapter);
                 clear_bit(__AT_RESETTING, &adapter->flags);
                 if (adapter->hw.ctrl_flags & ATL1C_FPGA_VERSION) {
@@ -2585,6 +2588,7 @@ static const struct net_device_ops atl1c_netdev_ops = {
         .ndo_set_mac_address    = atl1c_set_mac_addr,
         .ndo_set_multicast_list = atl1c_set_multi,
         .ndo_change_mtu         = atl1c_change_mtu,
+        .ndo_fix_features       = atl1c_fix_features,
         .ndo_do_ioctl           = atl1c_ioctl,
         .ndo_tx_timeout         = atl1c_tx_timeout,
         .ndo_get_stats          = atl1c_get_stats,
@@ -2605,12 +2609,13 @@ static int atl1c_init_netdev(struct net_device *netdev, struct pci_dev *pdev)
         atl1c_set_ethtool_ops(netdev);
 
         /* TODO: add when ready */
-        netdev->features =      NETIF_F_SG         |
+        netdev->hw_features =   NETIF_F_SG         |
                                 NETIF_F_HW_CSUM    |
                                 NETIF_F_HW_VLAN_TX |
-                                NETIF_F_HW_VLAN_RX |
                                 NETIF_F_TSO        |
                                 NETIF_F_TSO6;
+        netdev->features =      netdev->hw_features |
+                                NETIF_F_HW_VLAN_RX;
         return 0;
 }
 
diff --git a/drivers/net/atl1e/atl1e_ethtool.c b/drivers/net/atl1e/atl1e_ethtool.c
index 1209297433b8..47783749d9fa 100644
--- a/drivers/net/atl1e/atl1e_ethtool.c
+++ b/drivers/net/atl1e/atl1e_ethtool.c
@@ -382,9 +382,6 @@ static const struct ethtool_ops atl1e_ethtool_ops = {
         .get_eeprom_len         = atl1e_get_eeprom_len,
         .get_eeprom             = atl1e_get_eeprom,
         .set_eeprom             = atl1e_set_eeprom,
-        .set_tx_csum            = ethtool_op_set_tx_hw_csum,
-        .set_sg                 = ethtool_op_set_sg,
-        .set_tso                = ethtool_op_set_tso,
 };
 
 void atl1e_set_ethtool_ops(struct net_device *netdev)
diff --git a/drivers/net/atl1e/atl1e_main.c b/drivers/net/atl1e/atl1e_main.c
index b0a71e2f28a9..9900ca1d8eda 100644
--- a/drivers/net/atl1e/atl1e_main.c
+++ b/drivers/net/atl1e/atl1e_main.c
@@ -1927,11 +1927,7 @@ void atl1e_down(struct atl1e_adapter *adapter)
          * reschedule our watchdog timer */
         set_bit(__AT_DOWN, &adapter->flags);
 
-#ifdef NETIF_F_LLTX
         netif_stop_queue(netdev);
-#else
-        netif_tx_disable(netdev);
-#endif
 
         /* reset MAC to disable all RX/TX */
         atl1e_reset_hw(&adapter->hw);
@@ -2223,10 +2219,10 @@ static int atl1e_init_netdev(struct net_device *netdev, struct pci_dev *pdev)
         netdev->watchdog_timeo = AT_TX_WATCHDOG;
         atl1e_set_ethtool_ops(netdev);
 
-        netdev->features = NETIF_F_SG | NETIF_F_HW_CSUM |
-                NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
-        netdev->features |= NETIF_F_LLTX;
-        netdev->features |= NETIF_F_TSO;
+        netdev->hw_features = NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_TSO |
+                NETIF_F_HW_VLAN_TX;
+        netdev->features = netdev->hw_features |
+                NETIF_F_HW_VLAN_RX | NETIF_F_LLTX;
 
         return 0;
 }
diff --git a/drivers/net/atlx/atl1.c b/drivers/net/atlx/atl1.c
index 67f40b9c16ed..98334a1f0c5c 100644
--- a/drivers/net/atlx/atl1.c
+++ b/drivers/net/atlx/atl1.c
@@ -2572,7 +2572,7 @@ static s32 atl1_up(struct atl1_adapter *adapter)
 {
         struct net_device *netdev = adapter->netdev;
         int err;
-        int irq_flags = IRQF_SAMPLE_RANDOM;
+        int irq_flags = 0;
 
         /* hardware has been reset, we need to reload some things */
         atlx_set_multi(netdev);
@@ -2986,6 +2986,11 @@ static int __devinit atl1_probe(struct pci_dev *pdev,
         netdev->features |= NETIF_F_SG;
         netdev->features |= (NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX);
 
+        netdev->hw_features = NETIF_F_HW_CSUM | NETIF_F_SG | NETIF_F_TSO;
+
+        /* is this valid? see atl1_setup_mac_ctrl() */
+        netdev->features |= NETIF_F_RXCSUM;
+
         /*
          * patch for some L1 of old version,
          * the final version of L1 may not need these
@@ -3595,12 +3600,6 @@ static int atl1_set_pauseparam(struct net_device *netdev,
         return 0;
 }
 
-/* FIXME: is this right? -- CHS */
-static u32 atl1_get_rx_csum(struct net_device *netdev)
-{
-        return 1;
-}
-
 static void atl1_get_strings(struct net_device *netdev, u32 stringset,
         u8 *data)
 {
@@ -3668,13 +3667,9 @@ static const struct ethtool_ops atl1_ethtool_ops = {
         .set_ringparam          = atl1_set_ringparam,
         .get_pauseparam         = atl1_get_pauseparam,
         .set_pauseparam         = atl1_set_pauseparam,
-        .get_rx_csum            = atl1_get_rx_csum,
-        .set_tx_csum            = ethtool_op_set_tx_hw_csum,
         .get_link               = ethtool_op_get_link,
-        .set_sg                 = ethtool_op_set_sg,
         .get_strings            = atl1_get_strings,
         .nway_reset             = atl1_nway_reset,
         .get_ethtool_stats      = atl1_get_ethtool_stats,
         .get_sset_count         = atl1_get_sset_count,
-        .set_tso                = ethtool_op_set_tso,
 };
diff --git a/drivers/net/atlx/atl2.c b/drivers/net/atlx/atl2.c
index e3cbf45dc612..b75aa295d37e 100644
--- a/drivers/net/atlx/atl2.c
+++ b/drivers/net/atlx/atl2.c
@@ -1411,9 +1411,8 @@ static int __devinit atl2_probe(struct pci_dev *pdev,
 
         err = -EIO;
 
-#ifdef NETIF_F_HW_VLAN_TX
+        netdev->hw_features = NETIF_F_SG;
         netdev->features |= (NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX);
-#endif
 
         /* Init PHY as early as possible due to power saving issue  */
         atl2_phy_init(&adapter->hw);
@@ -1840,11 +1839,6 @@ static int atl2_set_settings(struct net_device *netdev,
         return 0;
 }
 
-static u32 atl2_get_tx_csum(struct net_device *netdev)
-{
-        return (netdev->features & NETIF_F_HW_CSUM) != 0;
-}
-
 static u32 atl2_get_msglevel(struct net_device *netdev)
 {
         return 0;
@@ -2112,12 +2106,6 @@ static const struct ethtool_ops atl2_ethtool_ops = {
         .get_eeprom_len         = atl2_get_eeprom_len,
         .get_eeprom             = atl2_get_eeprom,
         .set_eeprom             = atl2_set_eeprom,
-        .get_tx_csum            = atl2_get_tx_csum,
-        .get_sg                 = ethtool_op_get_sg,
-        .set_sg                 = ethtool_op_set_sg,
-#ifdef NETIF_F_TSO
-        .get_tso                = ethtool_op_get_tso,
-#endif
 };
 
 static void atl2_set_ethtool_ops(struct net_device *netdev)
diff --git a/drivers/net/bcm63xx_enet.c b/drivers/net/bcm63xx_enet.c
index c48104b08861..e68ffe622e69 100644
--- a/drivers/net/bcm63xx_enet.c
+++ b/drivers/net/bcm63xx_enet.c
@@ -839,8 +839,8 @@ static int bcm_enet_open(struct net_device *dev)
         if (ret)
                 goto out_phy_disconnect;
 
-        ret = request_irq(priv->irq_rx, bcm_enet_isr_dma,
-                          IRQF_SAMPLE_RANDOM | IRQF_DISABLED, dev->name, dev);
+        ret = request_irq(priv->irq_rx, bcm_enet_isr_dma, IRQF_DISABLED,
+                          dev->name, dev);
         if (ret)
                 goto out_freeirq;
 
diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h
index 66823eded7a3..a0b4743d7224 100644
--- a/drivers/net/benet/be.h
+++ b/drivers/net/benet/be.h
@@ -84,15 +84,14 @@ static inline char *nic_name(struct pci_dev *pdev)
 #define MCC_CQ_LEN              256
 
 #define MAX_RSS_QS              4       /* BE limit is 4 queues/port */
-#define BE_MAX_MSIX_VECTORS     (MAX_RSS_QS + 1 + 1)/* RSS qs + 1 def Rx + Tx */
+#define MAX_RX_QS               (MAX_RSS_QS + 1) /* RSS qs + 1 def Rx */
+#define BE_MAX_MSIX_VECTORS     (MAX_RX_QS + 1)/* RX + TX */
 #define BE_NAPI_WEIGHT          64
 #define MAX_RX_POST             BE_NAPI_WEIGHT /* Frags posted at a time */
 #define RX_FRAGS_REFILL_WM      (RX_Q_LEN - MAX_RX_POST)
 
 #define FW_VER_LEN              32
 
-#define BE_MAX_VF               32
-
 struct be_dma_mem {
         void *va;
         dma_addr_t dma;
@@ -276,7 +275,7 @@ struct be_adapter {
         spinlock_t mcc_cq_lock;
 
         struct msix_entry msix_entries[BE_MAX_MSIX_VECTORS];
-        bool msix_enabled;
+        u32 num_msix_vec;
         bool isr_registered;
 
         /* TX Rings */
@@ -287,7 +286,7 @@ struct be_adapter {
         u32 cache_line_break[8];
 
         /* Rx rings */
-        struct be_rx_obj rx_obj[MAX_RSS_QS + 1]; /* one default non-rss Q */
+        struct be_rx_obj rx_obj[MAX_RX_QS];
         u32 num_rx_qs;
         u32 big_page_size;      /* Compounded page size shared by rx wrbs */
 
@@ -308,10 +307,10 @@ struct be_adapter {
         u16 work_counter;
 
         /* Ethtool knobs and info */
-        bool rx_csum;           /* BE card must perform rx-checksumming */
         char fw_ver[FW_VER_LEN];
         u32 if_handle;          /* Used to configure filtering */
         u32 pmac_id;            /* MAC addr handle used by BE card */
+        u32 beacon_state;       /* for set_phys_id */
 
         bool eeh_err;
         bool link_up;
@@ -334,7 +333,7 @@ struct be_adapter {
 
         bool be3_native;
         bool sriov_enabled;
-        struct be_vf_cfg vf_cfg[BE_MAX_VF];
+        struct be_vf_cfg *vf_cfg;
         u8 is_virtfn;
         u32 sli_family;
         u8 hba_port_num;
@@ -351,6 +350,7 @@ struct be_adapter {
 
 extern const struct ethtool_ops be_ethtool_ops;
 
+#define msix_enabled(adapter)           (adapter->num_msix_vec > 0)
 #define tx_stats(adapter)               (&adapter->tx_stats)
 #define rx_stats(rxo)                   (&rxo->stats)
 
@@ -455,18 +455,10 @@ static inline u8 is_udp_pkt(struct sk_buff *skb)
 
 static inline void be_check_sriov_fn_type(struct be_adapter *adapter)
 {
-        u8 data;
         u32 sli_intf;
 
-        if (lancer_chip(adapter)) {
-                pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET,
-                                                                &sli_intf);
-                adapter->is_virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
-        } else {
-                pci_write_config_byte(adapter->pdev, 0xFE, 0xAA);
-                pci_read_config_byte(adapter->pdev, 0xFE, &data);
-                adapter->is_virtfn = (data != 0xAA);
-        }
+        pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
+        adapter->is_virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
 }
 
 static inline void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac)
@@ -482,6 +474,11 @@ static inline void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac)
         memcpy(mac, adapter->netdev->dev_addr, 3);
 }
 
+static inline bool be_multi_rxq(const struct be_adapter *adapter)
+{
+        return adapter->num_rx_qs > 1;
+}
+
 extern void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm,
                 u16 num_popped);
 extern void be_link_status_update(struct be_adapter *adapter, bool link_up);
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index 1e2d825bb94a..11b774a5eaff 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -1186,6 +1186,113 @@ err:
         return status;
 }
 
+/* Uses synchronous mcc */
+int be_cmd_get_reg_len(struct be_adapter *adapter, u32 *log_size)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_get_fat *req;
+        int status;
+
+        spin_lock_bh(&adapter->mcc_lock);
+
+        wrb = wrb_from_mccq(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+        req = embedded_payload(wrb);
+
+        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0,
+                        OPCODE_COMMON_MANAGE_FAT);
+
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                OPCODE_COMMON_MANAGE_FAT, sizeof(*req));
+        req->fat_operation = cpu_to_le32(QUERY_FAT);
+        status = be_mcc_notify_wait(adapter);
+        if (!status) {
+                struct be_cmd_resp_get_fat *resp = embedded_payload(wrb);
+                if (log_size && resp->log_size)
+                        *log_size = le32_to_cpu(resp->log_size -
+                                        sizeof(u32));
+        }
+err:
+        spin_unlock_bh(&adapter->mcc_lock);
+        return status;
+}
+
+void be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf)
+{
+        struct be_dma_mem get_fat_cmd;
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_get_fat *req;
+        struct be_sge *sge;
+        u32 offset = 0, total_size, buf_size, log_offset = sizeof(u32);
+        int status;
+
+        if (buf_len == 0)
+                return;
+
+        total_size = buf_len;
+
+        spin_lock_bh(&adapter->mcc_lock);
+
+        wrb = wrb_from_mccq(adapter);
+        if (!wrb) {
+                status = -EBUSY;
+                goto err;
+        }
+        while (total_size) {
+                buf_size = min(total_size, (u32)60*1024);
+                total_size -= buf_size;
+
+                get_fat_cmd.size = sizeof(struct be_cmd_req_get_fat) + buf_size;
+                get_fat_cmd.va = pci_alloc_consistent(adapter->pdev,
+                                        get_fat_cmd.size,
+                                        &get_fat_cmd.dma);
+                if (!get_fat_cmd.va) {
+                        status = -ENOMEM;
+                        dev_err(&adapter->pdev->dev,
+                                        "Memory allocation failure while retrieving FAT data\n");
+                        goto err;
+                }
+                req = get_fat_cmd.va;
+                sge = nonembedded_sgl(wrb);
+
+                be_wrb_hdr_prepare(wrb, get_fat_cmd.size, false, 1,
+                                OPCODE_COMMON_MANAGE_FAT);
+
+                be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                                OPCODE_COMMON_MANAGE_FAT, get_fat_cmd.size);
+
+                sge->pa_hi = cpu_to_le32(upper_32_bits(get_fat_cmd.size));
+                sge->pa_lo = cpu_to_le32(get_fat_cmd.dma & 0xFFFFFFFF);
+                sge->len = cpu_to_le32(get_fat_cmd.size);
+
+                req->fat_operation = cpu_to_le32(RETRIEVE_FAT);
+                req->read_log_offset = cpu_to_le32(log_offset);
+                req->read_log_length = cpu_to_le32(buf_size);
+                req->data_buffer_size = cpu_to_le32(buf_size);
+
+                status = be_mcc_notify_wait(adapter);
+                if (!status) {
+                        struct be_cmd_resp_get_fat *resp = get_fat_cmd.va;
+                        memcpy(buf + offset,
+                                resp->data_buffer,
+                                resp->read_log_length);
+                }
+                pci_free_consistent(adapter->pdev, get_fat_cmd.size,
+                                get_fat_cmd.va,
+                                get_fat_cmd.dma);
+                if (status)
+                        dev_err(&adapter->pdev->dev, "FAT Table Retrieve error\n");
+
+                offset += buf_size;
+                log_offset += buf_size;
+        }
+err:
+        spin_unlock_bh(&adapter->mcc_lock);
+}
+
 /* Uses Mbox */
 int be_cmd_get_fw_ver(struct be_adapter *adapter, char *fw_ver)
 {
diff --git a/drivers/net/benet/be_cmds.h b/drivers/net/benet/be_cmds.h
index 4f254cfaabe2..3fb6e0a3ad7a 100644
--- a/drivers/net/benet/be_cmds.h
+++ b/drivers/net/benet/be_cmds.h
@@ -186,6 +186,7 @@ struct be_mcc_mailbox {
 #define OPCODE_COMMON_NTWK_PMAC_ADD                     59
 #define OPCODE_COMMON_NTWK_PMAC_DEL                     60
 #define OPCODE_COMMON_FUNCTION_RESET                    61
+#define OPCODE_COMMON_MANAGE_FAT                        68
 #define OPCODE_COMMON_ENABLE_DISABLE_BEACON             69
 #define OPCODE_COMMON_GET_BEACON_STATE                  70
 #define OPCODE_COMMON_READ_TRANSRECV_DATA               73
@@ -380,6 +381,24 @@ struct be_cmd_resp_cq_create {
         u16 rsvd0;
 } __packed;
 
+struct be_cmd_req_get_fat {
+        struct be_cmd_req_hdr hdr;
+        u32 fat_operation;
+        u32 read_log_offset;
+        u32 read_log_length;
+        u32 data_buffer_size;
+        u32 data_buffer[1];
+} __packed;
+
+struct be_cmd_resp_get_fat {
+        struct be_cmd_resp_hdr hdr;
+        u32 log_size;
+        u32 read_log_length;
+        u32 rsvd[2];
+        u32 data_buffer[1];
+} __packed;
+
+
 /******************** Create MCCQ ***************************/
 /* Pseudo amap definition in which each bit of the actual structure is defined
  * as a byte: used to calculate offset/shift/mask of each field */
@@ -1148,4 +1167,6 @@ extern void be_detect_dump_ue(struct be_adapter *adapter);
 extern int be_cmd_get_die_temperature(struct be_adapter *adapter);
 extern int be_cmd_get_cntl_attributes(struct be_adapter *adapter);
 extern int be_cmd_check_native_mode(struct be_adapter *adapter);
+extern int be_cmd_get_reg_len(struct be_adapter *adapter, u32 *log_size);
+extern void be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf);
 
diff --git a/drivers/net/benet/be_ethtool.c b/drivers/net/benet/be_ethtool.c
index aac248fbd18b..96f5502e0ef7 100644
--- a/drivers/net/benet/be_ethtool.c
+++ b/drivers/net/benet/be_ethtool.c
@@ -156,6 +156,25 @@ be_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)
 }
 
 static int
+be_get_reg_len(struct net_device *netdev)
+{
+        struct be_adapter *adapter = netdev_priv(netdev);
+        u32 log_size = 0;
+
+        be_cmd_get_reg_len(adapter, &log_size);
+        return log_size;
+}
+
+static void
+be_get_regs(struct net_device *netdev, struct ethtool_regs *regs, void *buf)
+{
+        struct be_adapter *adapter = netdev_priv(netdev);
+
+        memset(buf, 0, regs->len);
+        be_cmd_get_regs(adapter, regs->len, buf);
+}
+
+static int
 be_get_coalesce(struct net_device *netdev, struct ethtool_coalesce *coalesce)
 {
         struct be_adapter *adapter = netdev_priv(netdev);
@@ -242,25 +261,6 @@ be_set_coalesce(struct net_device *netdev, struct ethtool_coalesce *coalesce)
         return 0;
 }
 
-static u32 be_get_rx_csum(struct net_device *netdev)
-{
-        struct be_adapter *adapter = netdev_priv(netdev);
-
-        return adapter->rx_csum;
-}
-
-static int be_set_rx_csum(struct net_device *netdev, uint32_t data)
-{
-        struct be_adapter *adapter = netdev_priv(netdev);
-
-        if (data)
-                adapter->rx_csum = true;
-        else
-                adapter->rx_csum = false;
-
-        return 0;
-}
-
 static void
 be_get_ethtool_stats(struct net_device *netdev,
                 struct ethtool_stats *stats, uint64_t *data)
@@ -507,29 +507,33 @@ be_set_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *ecmd)
 }
 
 static int
-be_phys_id(struct net_device *netdev, u32 data)
+be_set_phys_id(struct net_device *netdev,
+               enum ethtool_phys_id_state state)
 {
         struct be_adapter *adapter = netdev_priv(netdev);
-        int status;
-        u32 cur;
-
-        be_cmd_get_beacon_state(adapter, adapter->hba_port_num, &cur);
 
-        if (cur == BEACON_STATE_ENABLED)
-                return 0;
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                be_cmd_get_beacon_state(adapter, adapter->hba_port_num,
+                                        &adapter->beacon_state);
+                return -EINVAL;
 
-        if (data < 2)
-                data = 2;
+        case ETHTOOL_ID_ON:
+                be_cmd_set_beacon_state(adapter, adapter->hba_port_num, 0, 0,
+                                        BEACON_STATE_ENABLED);
+                break;
 
-        status = be_cmd_set_beacon_state(adapter, adapter->hba_port_num, 0, 0,
-                        BEACON_STATE_ENABLED);
-        set_current_state(TASK_INTERRUPTIBLE);
-        schedule_timeout(data*HZ);
+        case ETHTOOL_ID_OFF:
+                be_cmd_set_beacon_state(adapter, adapter->hba_port_num, 0, 0,
+                                        BEACON_STATE_DISABLED);
+                break;
 
-        status = be_cmd_set_beacon_state(adapter, adapter->hba_port_num, 0, 0,
-                        BEACON_STATE_DISABLED);
+        case ETHTOOL_ID_INACTIVE:
+                be_cmd_set_beacon_state(adapter, adapter->hba_port_num, 0, 0,
+                                        adapter->beacon_state);
+        }
 
-        return status;
+        return 0;
 }
 
 static bool
@@ -712,6 +716,18 @@ be_read_eeprom(struct net_device *netdev, struct ethtool_eeprom *eeprom,
         return status;
 }
 
+static int be_set_flags(struct net_device *netdev, u32 data)
+{
+        struct be_adapter *adapter = netdev_priv(netdev);
+        int rc = -1;
+
+        if (be_multi_rxq(adapter))
+                rc = ethtool_op_set_flags(netdev, data, ETH_FLAG_RXHASH |
+                                ETH_FLAG_TXVLAN | ETH_FLAG_RXVLAN);
+
+        return rc;
+}
+
 const struct ethtool_ops be_ethtool_ops = {
         .get_settings = be_get_settings,
         .get_drvinfo = be_get_drvinfo,
@@ -725,18 +741,13 @@ const struct ethtool_ops be_ethtool_ops = {
         .get_ringparam = be_get_ringparam,
         .get_pauseparam = be_get_pauseparam,
         .set_pauseparam = be_set_pauseparam,
-        .get_rx_csum = be_get_rx_csum,
-        .set_rx_csum = be_set_rx_csum,
-        .get_tx_csum = ethtool_op_get_tx_csum,
-        .set_tx_csum = ethtool_op_set_tx_hw_csum,
-        .get_sg = ethtool_op_get_sg,
-        .set_sg = ethtool_op_set_sg,
-        .get_tso = ethtool_op_get_tso,
-        .set_tso = ethtool_op_set_tso,
         .get_strings = be_get_stat_strings,
-        .phys_id = be_phys_id,
+        .set_phys_id = be_set_phys_id,
         .get_sset_count = be_get_sset_count,
         .get_ethtool_stats = be_get_ethtool_stats,
+        .get_regs_len = be_get_reg_len,
+        .get_regs = be_get_regs,
         .flash_device = be_do_flash,
         .self_test = be_self_test,
+        .set_flags = be_set_flags,
 };
diff --git a/drivers/net/benet/be_hw.h b/drivers/net/benet/be_hw.h
index d4344a06090b..53d658afea2a 100644
--- a/drivers/net/benet/be_hw.h
+++ b/drivers/net/benet/be_hw.h
@@ -155,6 +155,10 @@
 /********** SRIOV VF PCICFG OFFSET ********/
 #define SRIOV_VF_PCICFG_OFFSET          (4096)
 
+/********** FAT TABLE  ********/
+#define RETRIEVE_FAT    0
+#define QUERY_FAT       1
+
 /* Flashrom related descriptors */
 #define IMAGE_TYPE_FIRMWARE             160
 #define IMAGE_TYPE_BOOTCODE             224
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 7cb5a114c733..1bb763cda3ad 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -116,11 +116,6 @@ static char *ue_status_hi_desc[] = {
         "Unknown"
 };
 
-static inline bool be_multi_rxq(struct be_adapter *adapter)
-{
-        return (adapter->num_rx_qs > 1);
-}
-
 static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
 {
         struct be_dma_mem *mem = &q->dma_mem;
@@ -993,9 +988,10 @@ static void be_rx_compl_process(struct be_adapter *adapter,
                         struct be_rx_obj *rxo,
                         struct be_rx_compl_info *rxcp)
 {
+        struct net_device *netdev = adapter->netdev;
         struct sk_buff *skb;
 
-        skb = netdev_alloc_skb_ip_align(adapter->netdev, BE_HDR_LEN);
+        skb = netdev_alloc_skb_ip_align(netdev, BE_HDR_LEN);
         if (unlikely(!skb)) {
                 if (net_ratelimit())
                         dev_warn(&adapter->pdev->dev, "skb alloc failed\n");
@@ -1005,13 +1001,16 @@ static void be_rx_compl_process(struct be_adapter *adapter,
 
         skb_fill_rx_data(adapter, rxo, skb, rxcp);
 
-        if (likely(adapter->rx_csum && csum_passed(rxcp)))
+        if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
         else
                 skb_checksum_none_assert(skb);
 
         skb->truesize = skb->len + sizeof(struct sk_buff);
-        skb->protocol = eth_type_trans(skb, adapter->netdev);
+        skb->protocol = eth_type_trans(skb, netdev);
+        if (adapter->netdev->features & NETIF_F_RXHASH)
+                skb->rxhash = rxcp->rss_hash;
+
 
         if (unlikely(rxcp->vlanf)) {
                 if (!adapter->vlan_grp || adapter->vlans_added == 0) {
@@ -1072,6 +1071,8 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter,
         skb->data_len = rxcp->pkt_size;
         skb->truesize += rxcp->pkt_size;
         skb->ip_summed = CHECKSUM_UNNECESSARY;
+        if (adapter->netdev->features & NETIF_F_RXHASH)
+                skb->rxhash = rxcp->rss_hash;
 
         if (likely(!rxcp->vlanf))
                 napi_gro_frags(&eq_obj->napi);
@@ -1101,8 +1102,14 @@ static void be_parse_rx_compl_v1(struct be_adapter *adapter,
                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, numfrags, compl);
         rxcp->pkt_type =
                 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, cast_enc, compl);
-        rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtm, compl);
-        rxcp->vid = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vlan_tag, compl);
+        rxcp->rss_hash =
+                AMAP_GET_BITS(struct amap_eth_rx_compl_v1, rsshash, rxcp);
+        if (rxcp->vlanf) {
+                rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtm,
+                                compl);
+                rxcp->vid = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vlan_tag,
+                                compl);
+        }
 }
 
 static void be_parse_rx_compl_v0(struct be_adapter *adapter,
@@ -1127,8 +1134,14 @@ static void be_parse_rx_compl_v0(struct be_adapter *adapter,
                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, numfrags, compl);
         rxcp->pkt_type =
                 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, cast_enc, compl);
-        rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtm, compl);
-        rxcp->vid = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vlan_tag, compl);
+        rxcp->rss_hash =
+                AMAP_GET_BITS(struct amap_eth_rx_compl_v0, rsshash, rxcp);
+        if (rxcp->vlanf) {
+                rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtm,
+                                compl);
+                rxcp->vid = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vlan_tag,
+                                compl);
+        }
 }
 
 static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
@@ -1150,15 +1163,19 @@ static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
         else
                 be_parse_rx_compl_v0(adapter, compl, rxcp);
 
-        /* vlanf could be wrongly set in some cards. ignore if vtm is not set */
-        if ((adapter->function_mode & 0x400) && !rxcp->vtm)
-                rxcp->vlanf = 0;
+        if (rxcp->vlanf) {
+                /* vlanf could be wrongly set in some cards.
+                 * ignore if vtm is not set */
+                if ((adapter->function_mode & 0x400) && !rxcp->vtm)
+                        rxcp->vlanf = 0;
 
-        if (!lancer_chip(adapter))
-                rxcp->vid = swab16(rxcp->vid);
+                if (!lancer_chip(adapter))
+                        rxcp->vid = swab16(rxcp->vid);
 
-        if ((adapter->pvid == rxcp->vid) && !adapter->vlan_tag[rxcp->vid])
-                rxcp->vlanf = 0;
+                if ((adapter->pvid == rxcp->vid) &&
+                        !adapter->vlan_tag[rxcp->vid])
+                        rxcp->vlanf = 0;
+        }
 
         /* As the compl has been parsed, reset it; we wont touch it again */
         compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0;
@@ -1567,12 +1584,31 @@ static void be_rx_queues_destroy(struct be_adapter *adapter)
         }
 }
 
+static u32 be_num_rxqs_want(struct be_adapter *adapter)
+{
+        if (multi_rxq && (adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
+                !adapter->sriov_enabled && !(adapter->function_mode & 0x400)) {
+                return 1 + MAX_RSS_QS; /* one default non-RSS queue */
+        } else {
+                dev_warn(&adapter->pdev->dev,
+                        "No support for multiple RX queues\n");
+                return 1;
+        }
+}
+
 static int be_rx_queues_create(struct be_adapter *adapter)
 {
         struct be_queue_info *eq, *q, *cq;
         struct be_rx_obj *rxo;
         int rc, i;
 
+        adapter->num_rx_qs = min(be_num_rxqs_want(adapter),
+                                msix_enabled(adapter) ?
+                                        adapter->num_msix_vec - 1 : 1);
+        if (adapter->num_rx_qs != MAX_RX_QS)
+                dev_warn(&adapter->pdev->dev,
+                        "Can create only %d RX queues", adapter->num_rx_qs);
+
         adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
         for_all_rx_queues(adapter, rxo, i) {
                 rxo->adapter = adapter;
@@ -1837,6 +1873,9 @@ static void be_worker(struct work_struct *work)
         struct be_rx_obj *rxo;
         int i;
 
+        if (!adapter->ue_detected && !lancer_chip(adapter))
+                be_detect_dump_ue(adapter);
+
         /* when interrupts are not yet enabled, just reap any pending
         * mcc completions */
         if (!netif_running(adapter->netdev)) {
@@ -1849,9 +1888,6 @@ static void be_worker(struct work_struct *work)
                         be_cq_notify(adapter, mcc_obj->cq.id, false, mcc_compl);
                 }
 
-                if (!adapter->ue_detected && !lancer_chip(adapter))
-                        be_detect_dump_ue(adapter);
-
                 goto reschedule;
         }
 
@@ -1869,8 +1905,6 @@ static void be_worker(struct work_struct *work)
                         be_post_rx_frags(rxo, GFP_KERNEL);
                 }
         }
-        if (!adapter->ue_detected && !lancer_chip(adapter))
-                be_detect_dump_ue(adapter);
 
 reschedule:
         schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
@@ -1878,51 +1912,35 @@ reschedule:
 
 static void be_msix_disable(struct be_adapter *adapter)
 {
-        if (adapter->msix_enabled) {
+        if (msix_enabled(adapter)) {
                 pci_disable_msix(adapter->pdev);
-                adapter->msix_enabled = false;
-        }
-}
-
-static int be_num_rxqs_get(struct be_adapter *adapter)
-{
-        if (multi_rxq && (adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
-                !adapter->sriov_enabled && !(adapter->function_mode & 0x400)) {
-                return 1 + MAX_RSS_QS; /* one default non-RSS queue */
-        } else {
-                dev_warn(&adapter->pdev->dev,
-                        "No support for multiple RX queues\n");
-                return 1;
+                adapter->num_msix_vec = 0;
         }
 }
 
 static void be_msix_enable(struct be_adapter *adapter)
 {
 #define BE_MIN_MSIX_VECTORS     (1 + 1) /* Rx + Tx */
-        int i, status;
+        int i, status, num_vec;
 
-        adapter->num_rx_qs = be_num_rxqs_get(adapter);
+        num_vec = be_num_rxqs_want(adapter) + 1;
 
-        for (i = 0; i < (adapter->num_rx_qs + 1); i++)
+        for (i = 0; i < num_vec; i++)
                 adapter->msix_entries[i].entry = i;
 
-        status = pci_enable_msix(adapter->pdev, adapter->msix_entries,
-                        adapter->num_rx_qs + 1);
+        status = pci_enable_msix(adapter->pdev, adapter->msix_entries, num_vec);
         if (status == 0) {
                 goto done;
         } else if (status >= BE_MIN_MSIX_VECTORS) {
+                num_vec = status;
                 if (pci_enable_msix(adapter->pdev, adapter->msix_entries,
-                                status) == 0) {
-                        adapter->num_rx_qs = status - 1;
-                        dev_warn(&adapter->pdev->dev,
-                                "Could alloc only %d MSIx vectors. "
-                                "Using %d RX Qs\n", status, adapter->num_rx_qs);
+                                num_vec) == 0)
                         goto done;
-                }
         }
         return;
 done:
-        adapter->msix_enabled = true;
+        adapter->num_msix_vec = num_vec;
+        return;
 }
 
 static void be_sriov_enable(struct be_adapter *adapter)
@@ -1930,7 +1948,20 @@ static void be_sriov_enable(struct be_adapter *adapter)
         be_check_sriov_fn_type(adapter);
 #ifdef CONFIG_PCI_IOV
         if (be_physfn(adapter) && num_vfs) {
-                int status;
+                int status, pos;
+                u16 nvfs;
+
+                pos = pci_find_ext_capability(adapter->pdev,
+                                                PCI_EXT_CAP_ID_SRIOV);
+                pci_read_config_word(adapter->pdev,
+                                        pos + PCI_SRIOV_TOTAL_VF, &nvfs);
+
+                if (num_vfs > nvfs) {
+                        dev_info(&adapter->pdev->dev,
+                                        "Device supports %d VFs and not %d\n",
+                                        nvfs, num_vfs);
+                        num_vfs = nvfs;
+                }
 
                 status = pci_enable_sriov(adapter->pdev, num_vfs);
                 adapter->sriov_enabled = status ? false : true;
@@ -2003,8 +2034,7 @@ err_msix:
 err:
         dev_warn(&adapter->pdev->dev,
                 "MSIX Request IRQ failed - err %d\n", status);
-        pci_disable_msix(adapter->pdev);
-        adapter->msix_enabled = false;
+        be_msix_disable(adapter);
         return status;
 }
 
@@ -2013,7 +2043,7 @@ static int be_irq_register(struct be_adapter *adapter)
         struct net_device *netdev = adapter->netdev;
         int status;
 
-        if (adapter->msix_enabled) {
+        if (msix_enabled(adapter)) {
                 status = be_msix_register(adapter);
                 if (status == 0)
                         goto done;
@@ -2046,7 +2076,7 @@ static void be_irq_unregister(struct be_adapter *adapter)
                 return;
 
         /* INTx */
-        if (!adapter->msix_enabled) {
+        if (!msix_enabled(adapter)) {
                 free_irq(netdev->irq, adapter);
                 goto done;
         }
@@ -2088,7 +2118,7 @@ static int be_close(struct net_device *netdev)
                          be_cq_notify(adapter, rxo->cq.id, false, 0);
         }
 
-        if (adapter->msix_enabled) {
+        if (msix_enabled(adapter)) {
                 vec = be_msix_vec_get(adapter, tx_eq);
                 synchronize_irq(vec);
 
@@ -2261,7 +2291,7 @@ static int be_setup(struct be_adapter *adapter)
                                 BE_IF_FLAGS_PASS_L3L4_ERRORS;
                 en_flags |= BE_IF_FLAGS_PASS_L3L4_ERRORS;
 
-                if (be_multi_rxq(adapter)) {
+                if (adapter->function_caps & BE_FUNCTION_CAPS_RSS) {
                         cap_flags |= BE_IF_FLAGS_RSS;
                         en_flags |= BE_IF_FLAGS_RSS;
                 }
@@ -2318,7 +2348,6 @@ static int be_setup(struct be_adapter *adapter)
 
         return 0;
 
-        be_mcc_queues_destroy(adapter);
 rx_qs_destroy:
         be_rx_queues_destroy(adapter);
 tx_qs_destroy:
@@ -2599,10 +2628,14 @@ static void be_netdev_init(struct net_device *netdev)
         struct be_rx_obj *rxo;
         int i;
 
-        netdev->features |= NETIF_F_SG | NETIF_F_HW_VLAN_RX | NETIF_F_TSO |
-                NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
-                NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
-                NETIF_F_GRO | NETIF_F_TSO6;
+        netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
+                NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
+                NETIF_F_HW_VLAN_TX;
+        if (be_multi_rxq(adapter))
+                netdev->hw_features |= NETIF_F_RXHASH;
+
+        netdev->features |= netdev->hw_features |
+                NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER;
 
         netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO |
                 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
@@ -2612,8 +2645,6 @@ static void be_netdev_init(struct net_device *netdev)
 
         netdev->flags |= IFF_MULTICAST;
 
-        adapter->rx_csum = true;
-
         /* Default settings for Rx and Tx flow control */
         adapter->rx_fc = true;
         adapter->tx_fc = true;
@@ -2807,6 +2838,7 @@ static void __devexit be_remove(struct pci_dev *pdev)
 
         be_ctrl_cleanup(adapter);
 
+        kfree(adapter->vf_cfg);
         be_sriov_disable(adapter);
 
         be_msix_disable(adapter);
@@ -2991,16 +3023,23 @@ static int __devinit be_probe(struct pci_dev *pdev,
         }
 
         be_sriov_enable(adapter);
+        if (adapter->sriov_enabled) {
+                adapter->vf_cfg = kcalloc(num_vfs,
+                        sizeof(struct be_vf_cfg), GFP_KERNEL);
+
+                if (!adapter->vf_cfg)
+                        goto free_netdev;
+        }
 
         status = be_ctrl_init(adapter);
         if (status)
-                goto free_netdev;
+                goto free_vf_cfg;
 
         if (lancer_chip(adapter)) {
                 status = lancer_test_and_set_rdy_state(adapter);
                 if (status) {
                         dev_err(&pdev->dev, "Adapter in non recoverable error\n");
-                        goto free_netdev;
+                        goto ctrl_clean;
                 }
         }
 
@@ -3062,6 +3101,8 @@ stats_clean:
         be_stats_cleanup(adapter);
 ctrl_clean:
         be_ctrl_cleanup(adapter);
+free_vf_cfg:
+        kfree(adapter->vf_cfg);
 free_netdev:
         be_sriov_disable(adapter);
         free_netdev(netdev);
@@ -3146,16 +3187,15 @@ static void be_shutdown(struct pci_dev *pdev)
         if (!adapter)
                 return;
 
-        if (netif_running(adapter->netdev))
-                cancel_delayed_work_sync(&adapter->work);
+        cancel_delayed_work_sync(&adapter->work);
 
         netif_device_detach(adapter->netdev);
 
-        be_cmd_reset_function(adapter);
-
         if (adapter->wol)
                 be_setup_wol(adapter, true);
 
+        be_cmd_reset_function(adapter);
+
         pci_disable_device(pdev);
 }
 
@@ -3267,13 +3307,6 @@ static int __init be_init_module(void)
                 rx_frag_size = 2048;
         }
 
-        if (num_vfs > 32) {
-                printk(KERN_WARNING DRV_NAME
-                        " : Module param num_vfs must not be greater than 32."
-                        "Using 32\n");
-                num_vfs = 32;
-        }
-
         return pci_register_driver(&be_driver);
 }
 module_init(be_init_module);
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 8e6d618b5305..0a52079bafef 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -3174,7 +3174,7 @@ bnx2_rx_int(struct bnx2 *bp, struct bnx2_napi *bnapi, int budget)
                 }
 
                 skb_checksum_none_assert(skb);
-                if (bp->rx_csum &&
+                if ((bp->dev->features & NETIF_F_RXCSUM) &&
                         (status & (L2_FHDR_STATUS_TCP_SEGMENT |
                         L2_FHDR_STATUS_UDP_DATAGRAM))) {
 
@@ -7189,38 +7189,6 @@ bnx2_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam *epause)
         return 0;
 }
 
-static u32
-bnx2_get_rx_csum(struct net_device *dev)
-{
-        struct bnx2 *bp = netdev_priv(dev);
-
-        return bp->rx_csum;
-}
-
-static int
-bnx2_set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct bnx2 *bp = netdev_priv(dev);
-
-        bp->rx_csum = data;
-        return 0;
-}
-
-static int
-bnx2_set_tso(struct net_device *dev, u32 data)
-{
-        struct bnx2 *bp = netdev_priv(dev);
-
-        if (data) {
-                dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
-                if (CHIP_NUM(bp) == CHIP_NUM_5709)
-                        dev->features |= NETIF_F_TSO6;
-        } else
-                dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6 |
-                                   NETIF_F_TSO_ECN);
-        return 0;
-}
-
 static struct {
         char string[ETH_GSTRING_LEN];
 } bnx2_stats_str_arr[] = {
@@ -7495,82 +7463,74 @@ bnx2_get_ethtool_stats(struct net_device *dev,
 }
 
 static int
-bnx2_phys_id(struct net_device *dev, u32 data)
+bnx2_set_phys_id(struct net_device *dev, enum ethtool_phys_id_state state)
 {
         struct bnx2 *bp = netdev_priv(dev);
-        int i;
-        u32 save;
 
-        bnx2_set_power_state(bp, PCI_D0);
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                bnx2_set_power_state(bp, PCI_D0);
 
-        if (data == 0)
-                data = 2;
+                bp->leds_save = REG_RD(bp, BNX2_MISC_CFG);
+                REG_WR(bp, BNX2_MISC_CFG, BNX2_MISC_CFG_LEDMODE_MAC);
+                return -EINVAL;
 
-        save = REG_RD(bp, BNX2_MISC_CFG);
-        REG_WR(bp, BNX2_MISC_CFG, BNX2_MISC_CFG_LEDMODE_MAC);
+        case ETHTOOL_ID_ON:
+                REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE |
+                       BNX2_EMAC_LED_1000MB_OVERRIDE |
+                       BNX2_EMAC_LED_100MB_OVERRIDE |
+                       BNX2_EMAC_LED_10MB_OVERRIDE |
+                       BNX2_EMAC_LED_TRAFFIC_OVERRIDE |
+                       BNX2_EMAC_LED_TRAFFIC);
+                break;
 
-        for (i = 0; i < (data * 2); i++) {
-                if ((i % 2) == 0) {
-                        REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE);
-                }
-                else {
-                        REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE |
-                                BNX2_EMAC_LED_1000MB_OVERRIDE |
-                                BNX2_EMAC_LED_100MB_OVERRIDE |
-                                BNX2_EMAC_LED_10MB_OVERRIDE |
-                                BNX2_EMAC_LED_TRAFFIC_OVERRIDE |
-                                BNX2_EMAC_LED_TRAFFIC);
-                }
-                msleep_interruptible(500);
-                if (signal_pending(current))
-                        break;
-        }
-        REG_WR(bp, BNX2_EMAC_LED, 0);
-        REG_WR(bp, BNX2_MISC_CFG, save);
+        case ETHTOOL_ID_OFF:
+                REG_WR(bp, BNX2_EMAC_LED, BNX2_EMAC_LED_OVERRIDE);
+                break;
 
-        if (!netif_running(dev))
-                bnx2_set_power_state(bp, PCI_D3hot);
+        case ETHTOOL_ID_INACTIVE:
+                REG_WR(bp, BNX2_EMAC_LED, 0);
+                REG_WR(bp, BNX2_MISC_CFG, bp->leds_save);
+
+                if (!netif_running(dev))
+                        bnx2_set_power_state(bp, PCI_D3hot);
+                break;
+        }
 
         return 0;
 }
 
-static int
-bnx2_set_tx_csum(struct net_device *dev, u32 data)
+static u32
+bnx2_fix_features(struct net_device *dev, u32 features)
 {
         struct bnx2 *bp = netdev_priv(dev);
 
-        if (CHIP_NUM(bp) == CHIP_NUM_5709)
-                return ethtool_op_set_tx_ipv6_csum(dev, data);
-        else
-                return ethtool_op_set_tx_csum(dev, data);
+        if (!(bp->flags & BNX2_FLAG_CAN_KEEP_VLAN))
+                features |= NETIF_F_HW_VLAN_RX;
+
+        return features;
 }
 
 static int
-bnx2_set_flags(struct net_device *dev, u32 data)
+bnx2_set_features(struct net_device *dev, u32 features)
 {
         struct bnx2 *bp = netdev_priv(dev);
-        int rc;
-
-        if (!(bp->flags & BNX2_FLAG_CAN_KEEP_VLAN) &&
-            !(data & ETH_FLAG_RXVLAN))
-                return -EINVAL;
 
         /* TSO with VLAN tag won't work with current firmware */
-        if (!(data & ETH_FLAG_TXVLAN))
-                return -EINVAL;
-
-        rc = ethtool_op_set_flags(dev, data, ETH_FLAG_RXHASH | ETH_FLAG_RXVLAN |
-                                  ETH_FLAG_TXVLAN);
-        if (rc)
-                return rc;
+        if (features & NETIF_F_HW_VLAN_TX)
+                dev->vlan_features |= (dev->hw_features & NETIF_F_ALL_TSO);
+        else
+                dev->vlan_features &= ~NETIF_F_ALL_TSO;
 
-        if ((!!(data & ETH_FLAG_RXVLAN) !=
+        if ((!!(features & NETIF_F_HW_VLAN_RX) !=
             !!(bp->rx_mode & BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG)) &&
             netif_running(dev)) {
                 bnx2_netif_stop(bp, false);
+                dev->features = features;
                 bnx2_set_rx_mode(dev);
                 bnx2_fw_sync(bp, BNX2_DRV_MSG_CODE_KEEP_VLAN_UPDATE, 0, 1);
                 bnx2_netif_start(bp, false);
+                return 1;
         }
 
         return 0;
@@ -7595,18 +7555,11 @@ static const struct ethtool_ops bnx2_ethtool_ops = {
         .set_ringparam          = bnx2_set_ringparam,
         .get_pauseparam         = bnx2_get_pauseparam,
         .set_pauseparam         = bnx2_set_pauseparam,
-        .get_rx_csum            = bnx2_get_rx_csum,
-        .set_rx_csum            = bnx2_set_rx_csum,
-        .set_tx_csum            = bnx2_set_tx_csum,
-        .set_sg                 = ethtool_op_set_sg,
-        .set_tso                = bnx2_set_tso,
         .self_test              = bnx2_self_test,
         .get_strings            = bnx2_get_strings,
-        .phys_id                = bnx2_phys_id,
+        .set_phys_id            = bnx2_set_phys_id,
         .get_ethtool_stats      = bnx2_get_ethtool_stats,
         .get_sset_count         = bnx2_get_sset_count,
-        .set_flags              = bnx2_set_flags,
-        .get_flags              = ethtool_op_get_flags,
 };
 
 /* Called with rtnl_lock */
@@ -8118,8 +8071,6 @@ bnx2_init_board(struct pci_dev *pdev, struct net_device *dev)
         bp->tx_ring_size = MAX_TX_DESC_CNT;
         bnx2_set_rx_ring_size(bp, 255);
 
-        bp->rx_csum = 1;
-
         bp->tx_quick_cons_trip_int = 2;
         bp->tx_quick_cons_trip = 20;
         bp->tx_ticks_int = 18;
@@ -8311,17 +8262,14 @@ static const struct net_device_ops bnx2_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_set_mac_address    = bnx2_change_mac_addr,
         .ndo_change_mtu         = bnx2_change_mtu,
+        .ndo_fix_features       = bnx2_fix_features,
+        .ndo_set_features       = bnx2_set_features,
         .ndo_tx_timeout         = bnx2_tx_timeout,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = poll_bnx2,
 #endif
 };
 
-static inline void vlan_features_add(struct net_device *dev, u32 flags)
-{
-        dev->vlan_features |= flags;
-}
-
 static int __devinit
 bnx2_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
@@ -8361,20 +8309,17 @@ bnx2_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         memcpy(dev->dev_addr, bp->mac_addr, 6);
         memcpy(dev->perm_addr, bp->mac_addr, 6);
 
-        dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_GRO |
-                         NETIF_F_RXHASH;
-        vlan_features_add(dev, NETIF_F_IP_CSUM | NETIF_F_SG);
-        if (CHIP_NUM(bp) == CHIP_NUM_5709) {
-                dev->features |= NETIF_F_IPV6_CSUM;
-                vlan_features_add(dev, NETIF_F_IPV6_CSUM);
-        }
-        dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
-        dev->features |= NETIF_F_TSO | NETIF_F_TSO_ECN;
-        vlan_features_add(dev, NETIF_F_TSO | NETIF_F_TSO_ECN);
-        if (CHIP_NUM(bp) == CHIP_NUM_5709) {
-                dev->features |= NETIF_F_TSO6;
-                vlan_features_add(dev, NETIF_F_TSO6);
-        }
+        dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
+                NETIF_F_TSO | NETIF_F_TSO_ECN |
+                NETIF_F_RXHASH | NETIF_F_RXCSUM;
+
+        if (CHIP_NUM(bp) == CHIP_NUM_5709)
+                dev->hw_features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6;
+
+        dev->vlan_features = dev->hw_features;
+        dev->hw_features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
+        dev->features |= dev->hw_features;
+
         if ((rc = register_netdev(dev))) {
                 dev_err(&pdev->dev, "Cannot register net device\n");
                 goto error;
diff --git a/drivers/net/bnx2.h b/drivers/net/bnx2.h
index 68020451dc4f..bf371f6fe154 100644
--- a/drivers/net/bnx2.h
+++ b/drivers/net/bnx2.h
@@ -6754,8 +6754,6 @@ struct bnx2 {
         u32                     rx_max_ring_idx;
         u32                     rx_max_pg_ring_idx;
 
-        u32                     rx_csum;
-
         /* TX constants */
         int             tx_ring_size;
         u32             tx_wake_thresh;
@@ -6922,6 +6920,7 @@ struct bnx2 {
         u8                      num_tx_rings;
         u8                      num_rx_rings;
 
+        u32                     leds_save;
         u32                     idle_chk_status_idx;
 
 #ifdef BCM_CNIC
diff --git a/drivers/net/bnx2x/bnx2x_cmn.h b/drivers/net/bnx2x/bnx2x_cmn.h
index ef37b98d6146..775fef031ad8 100644
--- a/drivers/net/bnx2x/bnx2x_cmn.h
+++ b/drivers/net/bnx2x/bnx2x_cmn.h
@@ -1041,12 +1041,23 @@ static inline void storm_memset_cmng(struct bnx2x *bp,
                                 struct cmng_struct_per_port *cmng,
                                 u8 port)
 {
-        size_t size = sizeof(struct cmng_struct_per_port);
+        size_t size =
+                sizeof(struct rate_shaping_vars_per_port) +
+                sizeof(struct fairness_vars_per_port) +
+                sizeof(struct safc_struct_per_port) +
+                sizeof(struct pfc_struct_per_port);
 
         u32 addr = BAR_XSTRORM_INTMEM +
                         XSTORM_CMNG_PER_PORT_VARS_OFFSET(port);
 
         __storm_memset_struct(bp, addr, size, (u32 *)cmng);
+
+        addr += size + 4 /* SKIP DCB+LLFC */;
+        size = sizeof(struct cmng_struct_per_port) -
+                size /* written */ - 4 /*skipped*/;
+
+        __storm_memset_struct(bp, addr, size,
+                              (u32 *)(cmng->traffic_type_to_priority_cos));
 }
 
 /* HW Lock for shared dual port PHYs */
diff --git a/drivers/net/bnx2x/bnx2x_dcb.c b/drivers/net/bnx2x/bnx2x_dcb.c
index 9a24d79c71d9..1214907d00d9 100644
--- a/drivers/net/bnx2x/bnx2x_dcb.c
+++ b/drivers/net/bnx2x/bnx2x_dcb.c
@@ -571,6 +571,28 @@ void bnx2x_dcbx_set_params(struct bnx2x *bp, u32 state)
 {
         switch (state) {
         case BNX2X_DCBX_STATE_NEG_RECEIVED:
+#ifdef BCM_CNIC
+                if (bp->state != BNX2X_STATE_OPENING_WAIT4_LOAD) {
+                        struct cnic_ops *c_ops;
+                        struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
+                        bp->flags |= NO_ISCSI_OOO_FLAG | NO_ISCSI_FLAG;
+                        cp->drv_state |= CNIC_DRV_STATE_NO_ISCSI_OOO;
+                        cp->drv_state |= CNIC_DRV_STATE_NO_ISCSI;
+
+                        rcu_read_lock();
+                        c_ops = rcu_dereference(bp->cnic_ops);
+                        if (c_ops) {
+                                bnx2x_cnic_notify(bp, CNIC_CTL_STOP_ISCSI_CMD);
+                                rcu_read_unlock();
+                                return;
+                        }
+                        rcu_read_unlock();
+                }
+
+                /* fall through if no CNIC initialized  */
+        case BNX2X_DCBX_STATE_ISCSI_STOPPED:
+#endif
+
                 {
                         DP(NETIF_MSG_LINK, "BNX2X_DCBX_STATE_NEG_RECEIVED\n");
 #ifdef BCM_DCBNL
diff --git a/drivers/net/bnx2x/bnx2x_dcb.h b/drivers/net/bnx2x/bnx2x_dcb.h
index 71b8eda43bd0..1e14775a18cb 100644
--- a/drivers/net/bnx2x/bnx2x_dcb.h
+++ b/drivers/net/bnx2x/bnx2x_dcb.h
@@ -183,9 +183,13 @@ void bnx2x_dcbx_set_state(struct bnx2x *bp, bool dcb_on, u32 dcbx_enabled);
 
 enum {
         BNX2X_DCBX_STATE_NEG_RECEIVED = 0x1,
-        BNX2X_DCBX_STATE_TX_PAUSED = 0x2,
-        BNX2X_DCBX_STATE_TX_RELEASED = 0x4
+#ifdef BCM_CNIC
+        BNX2X_DCBX_STATE_ISCSI_STOPPED,
+#endif
+        BNX2X_DCBX_STATE_TX_PAUSED,
+        BNX2X_DCBX_STATE_TX_RELEASED
 };
+
 void bnx2x_dcbx_set_params(struct bnx2x *bp, u32 state);
 
 /* DCB netlink */
diff --git a/drivers/net/bnx2x/bnx2x_ethtool.c b/drivers/net/bnx2x/bnx2x_ethtool.c
index f5050155c6b5..147999459df5 100644
--- a/drivers/net/bnx2x/bnx2x_ethtool.c
+++ b/drivers/net/bnx2x/bnx2x_ethtool.c
@@ -2097,36 +2097,38 @@ static void bnx2x_get_ethtool_stats(struct net_device *dev,
         }
 }
 
-static int bnx2x_phys_id(struct net_device *dev, u32 data)
+static int bnx2x_set_phys_id(struct net_device *dev,
+                             enum ethtool_phys_id_state state)
 {
         struct bnx2x *bp = netdev_priv(dev);
-        int i;
 
         if (!netif_running(dev))
-                return 0;
+                return -EAGAIN;
 
         if (!bp->port.pmf)
-                return 0;
+                return -EOPNOTSUPP;
 
-        if (data == 0)
-                data = 2;
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                return -EINVAL;
 
-        for (i = 0; i < (data * 2); i++) {
-                if ((i % 2) == 0)
-                        bnx2x_set_led(&bp->link_params, &bp->link_vars,
-                                      LED_MODE_OPER, SPEED_1000);
-                else
-                        bnx2x_set_led(&bp->link_params, &bp->link_vars,
-                                      LED_MODE_OFF, 0);
+        case ETHTOOL_ID_ON:
+                bnx2x_set_led(&bp->link_params, &bp->link_vars,
+                              LED_MODE_OPER, SPEED_1000);
+                break;
 
-                msleep_interruptible(500);
-                if (signal_pending(current))
-                        break;
-        }
+        case ETHTOOL_ID_OFF:
+                bnx2x_set_led(&bp->link_params, &bp->link_vars,
+                              LED_MODE_OFF, 0);
 
-        if (bp->link_vars.link_up)
-                bnx2x_set_led(&bp->link_params, &bp->link_vars, LED_MODE_OPER,
-                              bp->link_vars.line_speed);
+                break;
+
+        case ETHTOOL_ID_INACTIVE:
+                if (bp->link_vars.link_up)
+                        bnx2x_set_led(&bp->link_params, &bp->link_vars,
+                                      LED_MODE_OPER,
+                                      bp->link_vars.line_speed);
+        }
 
         return 0;
 }
@@ -2218,7 +2220,7 @@ static const struct ethtool_ops bnx2x_ethtool_ops = {
         .self_test              = bnx2x_self_test,
         .get_sset_count         = bnx2x_get_sset_count,
         .get_strings            = bnx2x_get_strings,
-        .phys_id                = bnx2x_phys_id,
+        .set_phys_id            = bnx2x_set_phys_id,
         .get_ethtool_stats      = bnx2x_get_ethtool_stats,
         .get_rxnfc              = bnx2x_get_rxnfc,
         .get_rxfh_indir         = bnx2x_get_rxfh_indir,
diff --git a/drivers/net/bnx2x/bnx2x_hsi.h b/drivers/net/bnx2x/bnx2x_hsi.h
index dac1bf9cbbfa..2b5940af5d1b 100644
--- a/drivers/net/bnx2x/bnx2x_hsi.h
+++ b/drivers/net/bnx2x/bnx2x_hsi.h
@@ -1929,7 +1929,7 @@ struct host_func_stats {
 
 #define BCM_5710_FW_MAJOR_VERSION                       6
 #define BCM_5710_FW_MINOR_VERSION                       2
-#define BCM_5710_FW_REVISION_VERSION                    5
+#define BCM_5710_FW_REVISION_VERSION                    9
 #define BCM_5710_FW_ENGINEERING_VERSION                 0
 #define BCM_5710_FW_COMPILE_FLAGS                       1
 
diff --git a/drivers/net/bnx2x/bnx2x_main.c b/drivers/net/bnx2x/bnx2x_main.c
index a97a4a1c344f..a6915aafa695 100644
--- a/drivers/net/bnx2x/bnx2x_main.c
+++ b/drivers/net/bnx2x/bnx2x_main.c
@@ -10342,6 +10342,11 @@ static int bnx2x_drv_ctl(struct net_device *dev, struct drv_ctl_info *ctl)
                 break;
         }
 
+        case DRV_CTL_ISCSI_STOPPED_CMD: {
+                bnx2x_dcbx_set_params(bp, BNX2X_DCBX_STATE_ISCSI_STOPPED);
+                break;
+        }
+
         default:
                 BNX2X_ERR("unknown command %x\n", ctl->cmd);
                 rc = -EINVAL;
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 16d6fe954695..b51e021354b5 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -1407,7 +1407,7 @@ static int bond_compute_features(struct bonding *bond)
         int i;
 
         features &= ~(NETIF_F_ALL_CSUM | BOND_VLAN_FEATURES);
-        features |=  NETIF_F_GSO_MASK | NETIF_F_NO_CSUM;
+        features |=  NETIF_F_GSO_MASK | NETIF_F_NO_CSUM | NETIF_F_NOCACHE_COPY;
 
         if (!bond->first_slave)
                 goto done;
diff --git a/drivers/net/cnic.c b/drivers/net/cnic.c
index 8cca60e43444..cde59b4e5ef8 100644
--- a/drivers/net/cnic.c
+++ b/drivers/net/cnic.c
@@ -2966,31 +2966,36 @@ static int cnic_service_bnx2x(void *data, void *status_blk)
         return 0;
 }
 
-static void cnic_ulp_stop(struct cnic_dev *dev)
+static void cnic_ulp_stop_one(struct cnic_local *cp, int if_type)
 {
-        struct cnic_local *cp = dev->cnic_priv;
-        int if_type;
-
-        cnic_send_nlmsg(cp, ISCSI_KEVENT_IF_DOWN, NULL);
+        struct cnic_ulp_ops *ulp_ops;
 
-        for (if_type = 0; if_type < MAX_CNIC_ULP_TYPE; if_type++) {
-                struct cnic_ulp_ops *ulp_ops;
+        if (if_type == CNIC_ULP_ISCSI)
+                cnic_send_nlmsg(cp, ISCSI_KEVENT_IF_DOWN, NULL);
 
-                mutex_lock(&cnic_lock);
-                ulp_ops = rcu_dereference_protected(cp->ulp_ops[if_type],
-                                                    lockdep_is_held(&cnic_lock));
-                if (!ulp_ops) {
-                        mutex_unlock(&cnic_lock);
-                        continue;
-                }
-                set_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[if_type]);
+        mutex_lock(&cnic_lock);
+        ulp_ops = rcu_dereference_protected(cp->ulp_ops[if_type],
+                                            lockdep_is_held(&cnic_lock));
+        if (!ulp_ops) {
                 mutex_unlock(&cnic_lock);
+                return;
+        }
+        set_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[if_type]);
+        mutex_unlock(&cnic_lock);
 
-                if (test_and_clear_bit(ULP_F_START, &cp->ulp_flags[if_type]))
-                        ulp_ops->cnic_stop(cp->ulp_handle[if_type]);
+        if (test_and_clear_bit(ULP_F_START, &cp->ulp_flags[if_type]))
+                ulp_ops->cnic_stop(cp->ulp_handle[if_type]);
 
-                clear_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[if_type]);
-        }
+        clear_bit(ULP_F_CALL_PENDING, &cp->ulp_flags[if_type]);
+}
+
+static void cnic_ulp_stop(struct cnic_dev *dev)
+{
+        struct cnic_local *cp = dev->cnic_priv;
+        int if_type;
+
+        for (if_type = 0; if_type < MAX_CNIC_ULP_TYPE; if_type++)
+                cnic_ulp_stop_one(cp, if_type);
 }
 
 static void cnic_ulp_start(struct cnic_dev *dev)
@@ -3039,6 +3044,12 @@ static int cnic_ctl(void *data, struct cnic_ctl_info *info)
 
                 cnic_put(dev);
                 break;
+        case CNIC_CTL_STOP_ISCSI_CMD: {
+                struct cnic_local *cp = dev->cnic_priv;
+                set_bit(CNIC_LCL_FL_STOP_ISCSI, &cp->cnic_local_flags);
+                queue_delayed_work(cnic_wq, &cp->delete_task, 0);
+                break;
+        }
         case CNIC_CTL_COMPLETION_CMD: {
                 u32 cid = BNX2X_SW_CID(info->data.comp.cid);
                 u32 l5_cid;
@@ -3562,8 +3573,12 @@ static void cnic_init_csk_state(struct cnic_sock *csk)
 
 static int cnic_cm_connect(struct cnic_sock *csk, struct cnic_sockaddr *saddr)
 {
+        struct cnic_local *cp = csk->dev->cnic_priv;
         int err = 0;
 
+        if (cp->ethdev->drv_state & CNIC_DRV_STATE_NO_ISCSI)
+                return -EOPNOTSUPP;
+
         if (!cnic_in_use(csk))
                 return -EINVAL;
 
@@ -3965,6 +3980,15 @@ static void cnic_delete_task(struct work_struct *work)
         cp = container_of(work, struct cnic_local, delete_task.work);
         dev = cp->dev;
 
+        if (test_and_clear_bit(CNIC_LCL_FL_STOP_ISCSI, &cp->cnic_local_flags)) {
+                struct drv_ctl_info info;
+
+                cnic_ulp_stop_one(cp, CNIC_ULP_ISCSI);
+
+                info.cmd = DRV_CTL_ISCSI_STOPPED_CMD;
+                cp->ethdev->drv_ctl(dev->netdev, &info);
+        }
+
         for (i = 0; i < cp->max_cid_space; i++) {
                 struct cnic_context *ctx = &cp->ctx_tbl[i];
 
diff --git a/drivers/net/cnic.h b/drivers/net/cnic.h
index 4456260c653c..3367a6d3a774 100644
--- a/drivers/net/cnic.h
+++ b/drivers/net/cnic.h
@@ -226,6 +226,7 @@ struct cnic_local {
 #define CNIC_LCL_FL_KWQ_INIT            0x0
 #define CNIC_LCL_FL_L2_WAIT             0x1
 #define CNIC_LCL_FL_RINGS_INITED        0x2
+#define CNIC_LCL_FL_STOP_ISCSI          0x4
 
         struct cnic_dev *dev;
 
diff --git a/drivers/net/cnic_if.h b/drivers/net/cnic_if.h
index e01b49ee3591..fdd8e46a9050 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.2.13"
-#define CNIC_MODULE_RELDATE     "Jan 31, 2011"
+#define CNIC_MODULE_VERSION     "2.2.14"
+#define CNIC_MODULE_RELDATE     "Mar 30, 2011"
 
 #define CNIC_ULP_RDMA           0
 #define CNIC_ULP_ISCSI          1
@@ -85,6 +85,7 @@ struct kcqe {
 #define CNIC_CTL_STOP_CMD               1
 #define CNIC_CTL_START_CMD              2
 #define CNIC_CTL_COMPLETION_CMD         3
+#define CNIC_CTL_STOP_ISCSI_CMD         4
 
 #define DRV_CTL_IO_WR_CMD               0x101
 #define DRV_CTL_IO_RD_CMD               0x102
@@ -94,6 +95,7 @@ struct kcqe {
 #define DRV_CTL_START_L2_CMD            0x106
 #define DRV_CTL_STOP_L2_CMD             0x107
 #define DRV_CTL_RET_L2_SPQ_CREDIT_CMD   0x10c
+#define DRV_CTL_ISCSI_STOPPED_CMD       0x10d
 
 struct cnic_ctl_completion {
         u32     cid;
diff --git a/drivers/net/cris/eth_v10.c b/drivers/net/cris/eth_v10.c
index 9d267d3a6892..e66aceb57cef 100644
--- a/drivers/net/cris/eth_v10.c
+++ b/drivers/net/cris/eth_v10.c
@@ -491,8 +491,8 @@ e100_open(struct net_device *dev)
 
         /* allocate the irq corresponding to the receiving DMA */
 
-        if (request_irq(NETWORK_DMA_RX_IRQ_NBR, e100rxtx_interrupt,
-                        IRQF_SAMPLE_RANDOM, cardname, (void *)dev)) {
+        if (request_irq(NETWORK_DMA_RX_IRQ_NBR, e100rxtx_interrupt, 0, cardname,
+                        (void *)dev)) {
                 goto grace_exit0;
         }
 
diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c
index 910893143295..802c7a7c3b25 100644
--- a/drivers/net/cxgb3/cxgb3_main.c
+++ b/drivers/net/cxgb3/cxgb3_main.c
@@ -1749,23 +1749,26 @@ static int restart_autoneg(struct net_device *dev)
         return 0;
 }
 
-static int cxgb3_phys_id(struct net_device *dev, u32 data)
+static int set_phys_id(struct net_device *dev,
+                       enum ethtool_phys_id_state state)
 {
         struct port_info *pi = netdev_priv(dev);
         struct adapter *adapter = pi->adapter;
-        int i;
 
-        if (data == 0)
-                data = 2;
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                return -EINVAL;
+
+        case ETHTOOL_ID_OFF:
+                t3_set_reg_field(adapter, A_T3DBG_GPIO_EN, F_GPIO0_OUT_VAL, 0);
+                break;
 
-        for (i = 0; i < data * 2; i++) {
+        case ETHTOOL_ID_ON:
+        case ETHTOOL_ID_INACTIVE:
                 t3_set_reg_field(adapter, A_T3DBG_GPIO_EN, F_GPIO0_OUT_VAL,
-                                 (i & 1) ? F_GPIO0_OUT_VAL : 0);
-                if (msleep_interruptible(500))
-                        break;
-        }
-        t3_set_reg_field(adapter, A_T3DBG_GPIO_EN, F_GPIO0_OUT_VAL,
                          F_GPIO0_OUT_VAL);
+        }
+
         return 0;
 }
 
@@ -2107,7 +2110,7 @@ static const struct ethtool_ops cxgb_ethtool_ops = {
         .set_sg = ethtool_op_set_sg,
         .get_link = ethtool_op_get_link,
         .get_strings = get_strings,
-        .phys_id = cxgb3_phys_id,
+        .set_phys_id = set_phys_id,
         .nway_reset = restart_autoneg,
         .get_sset_count = get_sset_count,
         .get_ethtool_stats = get_stats,
diff --git a/drivers/net/cxgb4/cxgb4_main.c b/drivers/net/cxgb4/cxgb4_main.c
index 5352c8a23f4d..0af9c9f0ca78 100644
--- a/drivers/net/cxgb4/cxgb4_main.c
+++ b/drivers/net/cxgb4/cxgb4_main.c
@@ -1336,15 +1336,20 @@ static int restart_autoneg(struct net_device *dev)
         return 0;
 }
 
-static int identify_port(struct net_device *dev, u32 data)
+static int identify_port(struct net_device *dev,
+                         enum ethtool_phys_id_state state)
 {
+        unsigned int val;
         struct adapter *adap = netdev2adap(dev);
 
-        if (data == 0)
-                data = 2;     /* default to 2 seconds */
+        if (state == ETHTOOL_ID_ACTIVE)
+                val = 0xffff;
+        else if (state == ETHTOOL_ID_INACTIVE)
+                val = 0;
+        else
+                return -EINVAL;
 
-        return t4_identify_port(adap, adap->fn, netdev2pinfo(dev)->viid,
-                                data * 5);
+        return t4_identify_port(adap, adap->fn, netdev2pinfo(dev)->viid, val);
 }
 
 static unsigned int from_fw_linkcaps(unsigned int type, unsigned int caps)
@@ -2011,7 +2016,7 @@ static struct ethtool_ops cxgb_ethtool_ops = {
         .set_sg            = ethtool_op_set_sg,
         .get_link          = ethtool_op_get_link,
         .get_strings       = get_strings,
-        .phys_id           = identify_port,
+        .set_phys_id       = identify_port,
         .nway_reset        = restart_autoneg,
         .get_sset_count    = get_sset_count,
         .get_ethtool_stats = get_stats,
diff --git a/drivers/net/cxgb4vf/cxgb4vf_main.c b/drivers/net/cxgb4vf/cxgb4vf_main.c
index 4661cbbd9bd9..c662679de4fa 100644
--- a/drivers/net/cxgb4vf/cxgb4vf_main.c
+++ b/drivers/net/cxgb4vf/cxgb4vf_main.c
@@ -1352,11 +1352,20 @@ static int cxgb4vf_set_rx_csum(struct net_device *dev, u32 csum)
 /*
  * Identify the port by blinking the port's LED.
  */
-static int cxgb4vf_phys_id(struct net_device *dev, u32 id)
+static int cxgb4vf_phys_id(struct net_device *dev,
+                           enum ethtool_phys_id_state state)
 {
+        unsigned int val;
         struct port_info *pi = netdev_priv(dev);
 
-        return t4vf_identify_port(pi->adapter, pi->viid, 5);
+        if (state == ETHTOOL_ID_ACTIVE)
+                val = 0xffff;
+        else if (state == ETHTOOL_ID_INACTIVE)
+                val = 0;
+        else
+                return -EINVAL;
+
+        return t4vf_identify_port(pi->adapter, pi->viid, val);
 }
 
 /*
@@ -1588,7 +1597,7 @@ static struct ethtool_ops cxgb4vf_ethtool_ops = {
         .set_sg                 = ethtool_op_set_sg,
         .get_link               = ethtool_op_get_link,
         .get_strings            = cxgb4vf_get_strings,
-        .phys_id                = cxgb4vf_phys_id,
+        .set_phys_id            = cxgb4vf_phys_id,
         .get_sset_count         = cxgb4vf_get_sset_count,
         .get_ethtool_stats      = cxgb4vf_get_ethtool_stats,
         .get_regs_len           = cxgb4vf_get_regs_len,
diff --git a/drivers/net/enic/Makefile b/drivers/net/enic/Makefile
index 2e573be16c13..9d4974bba247 100644
--- a/drivers/net/enic/Makefile
+++ b/drivers/net/enic/Makefile
@@ -1,5 +1,5 @@
 obj-$(CONFIG_ENIC) := enic.o
 
 enic-y := enic_main.o vnic_cq.o vnic_intr.o vnic_wq.o \
-        enic_res.o enic_dev.o vnic_dev.o vnic_rq.o vnic_vic.o
+        enic_res.o enic_dev.o enic_pp.o vnic_dev.o vnic_rq.o vnic_vic.o
 
diff --git a/drivers/net/enic/enic.h b/drivers/net/enic/enic.h
index 3a3c3c8a3a9b..38b351c7b979 100644
--- a/drivers/net/enic/enic.h
+++ b/drivers/net/enic/enic.h
@@ -32,7 +32,7 @@
 
 #define DRV_NAME                "enic"
 #define DRV_DESCRIPTION         "Cisco VIC Ethernet NIC Driver"
-#define DRV_VERSION             "2.1.1.12"
+#define DRV_VERSION             "2.1.1.13"
 #define DRV_COPYRIGHT           "Copyright 2008-2011 Cisco Systems, Inc"
 
 #define ENIC_BARS_MAX           6
@@ -84,7 +84,6 @@ struct enic {
         unsigned int flags;
         unsigned int mc_count;
         unsigned int uc_count;
-        int csum_rx_enabled;
         u32 port_mtu;
         u32 rx_coalesce_usecs;
         u32 tx_coalesce_usecs;
@@ -120,4 +119,6 @@ static inline struct device *enic_get_dev(struct enic *enic)
         return &(enic->pdev->dev);
 }
 
+void enic_reset_addr_lists(struct enic *enic);
+
 #endif /* _ENIC_H_ */
diff --git a/drivers/net/enic/enic_dev.c b/drivers/net/enic/enic_dev.c
index 37ad3a1c82ee..90687b14e60f 100644
--- a/drivers/net/enic/enic_dev.c
+++ b/drivers/net/enic/enic_dev.c
@@ -177,24 +177,24 @@ int enic_vnic_dev_deinit(struct enic *enic)
         return err;
 }
 
-int enic_dev_init_prov(struct enic *enic, struct vic_provinfo *vp)
+int enic_dev_init_prov2(struct enic *enic, struct vic_provinfo *vp)
 {
         int err;
 
         spin_lock(&enic->devcmd_lock);
-        err = vnic_dev_init_prov(enic->vdev,
+        err = vnic_dev_init_prov2(enic->vdev,
                 (u8 *)vp, vic_provinfo_size(vp));
         spin_unlock(&enic->devcmd_lock);
 
         return err;
 }
 
-int enic_dev_init_done(struct enic *enic, int *done, int *error)
+int enic_dev_deinit_done(struct enic *enic, int *status)
 {
         int err;
 
         spin_lock(&enic->devcmd_lock);
-        err = vnic_dev_init_done(enic->vdev, done, error);
+        err = vnic_dev_deinit_done(enic->vdev, status);
         spin_unlock(&enic->devcmd_lock);
 
         return err;
@@ -219,3 +219,57 @@ void enic_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
         enic_del_vlan(enic, vid);
         spin_unlock(&enic->devcmd_lock);
 }
+
+int enic_dev_enable2(struct enic *enic, int active)
+{
+        int err;
+
+        spin_lock(&enic->devcmd_lock);
+        err = vnic_dev_enable2(enic->vdev, active);
+        spin_unlock(&enic->devcmd_lock);
+
+        return err;
+}
+
+int enic_dev_enable2_done(struct enic *enic, int *status)
+{
+        int err;
+
+        spin_lock(&enic->devcmd_lock);
+        err = vnic_dev_enable2_done(enic->vdev, status);
+        spin_unlock(&enic->devcmd_lock);
+
+        return err;
+}
+
+int enic_dev_status_to_errno(int devcmd_status)
+{
+        switch (devcmd_status) {
+        case ERR_SUCCESS:
+                return 0;
+        case ERR_EINVAL:
+                return -EINVAL;
+        case ERR_EFAULT:
+                return -EFAULT;
+        case ERR_EPERM:
+                return -EPERM;
+        case ERR_EBUSY:
+                return -EBUSY;
+        case ERR_ECMDUNKNOWN:
+        case ERR_ENOTSUPPORTED:
+                return -EOPNOTSUPP;
+        case ERR_EBADSTATE:
+                return -EINVAL;
+        case ERR_ENOMEM:
+                return -ENOMEM;
+        case ERR_ETIMEDOUT:
+                return -ETIMEDOUT;
+        case ERR_ELINKDOWN:
+                return -ENETDOWN;
+        case ERR_EINPROGRESS:
+                return -EINPROGRESS;
+        case ERR_EMAXRES:
+        default:
+                return (devcmd_status < 0) ? devcmd_status : -1;
+        }
+}
diff --git a/drivers/net/enic/enic_dev.h b/drivers/net/enic/enic_dev.h
index 495f57fcb887..d5f681337626 100644
--- a/drivers/net/enic/enic_dev.h
+++ b/drivers/net/enic/enic_dev.h
@@ -35,7 +35,10 @@ int enic_dev_set_ig_vlan_rewrite_mode(struct enic *enic);
 int enic_dev_enable(struct enic *enic);
 int enic_dev_disable(struct enic *enic);
 int enic_vnic_dev_deinit(struct enic *enic);
-int enic_dev_init_prov(struct enic *enic, struct vic_provinfo *vp);
-int enic_dev_init_done(struct enic *enic, int *done, int *error);
+int enic_dev_init_prov2(struct enic *enic, struct vic_provinfo *vp);
+int enic_dev_deinit_done(struct enic *enic, int *status);
+int enic_dev_enable2(struct enic *enic, int arg);
+int enic_dev_enable2_done(struct enic *enic, int *status);
+int enic_dev_status_to_errno(int devcmd_status);
 
 #endif /* _ENIC_DEV_H_ */
diff --git a/drivers/net/enic/enic_main.c b/drivers/net/enic/enic_main.c
index 8b9cad5e9712..b2245511c51a 100644
--- a/drivers/net/enic/enic_main.c
+++ b/drivers/net/enic/enic_main.c
@@ -45,6 +45,7 @@
 #include "enic_res.h"
 #include "enic.h"
 #include "enic_dev.h"
+#include "enic_pp.h"
 
 #define ENIC_NOTIFY_TIMER_PERIOD        (2 * HZ)
 #define WQ_ENET_MAX_DESC_LEN            (1 << WQ_ENET_LEN_BITS)
@@ -250,56 +251,6 @@ static void enic_get_ethtool_stats(struct net_device *netdev,
                 *(data++) = ((u64 *)&vstats->rx)[enic_rx_stats[i].offset];
 }
 
-static u32 enic_get_rx_csum(struct net_device *netdev)
-{
-        struct enic *enic = netdev_priv(netdev);
-        return enic->csum_rx_enabled;
-}
-
-static int enic_set_rx_csum(struct net_device *netdev, u32 data)
-{
-        struct enic *enic = netdev_priv(netdev);
-
-        if (data && !ENIC_SETTING(enic, RXCSUM))
-                return -EINVAL;
-
-        enic->csum_rx_enabled = !!data;
-
-        return 0;
-}
-
-static int enic_set_tx_csum(struct net_device *netdev, u32 data)
-{
-        struct enic *enic = netdev_priv(netdev);
-
-        if (data && !ENIC_SETTING(enic, TXCSUM))
-                return -EINVAL;
-
-        if (data)
-                netdev->features |= NETIF_F_HW_CSUM;
-        else
-                netdev->features &= ~NETIF_F_HW_CSUM;
-
-        return 0;
-}
-
-static int enic_set_tso(struct net_device *netdev, u32 data)
-{
-        struct enic *enic = netdev_priv(netdev);
-
-        if (data && !ENIC_SETTING(enic, TSO))
-                return -EINVAL;
-
-        if (data)
-                netdev->features |=
-                        NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN;
-        else
-                netdev->features &=
-                        ~(NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_TSO_ECN);
-
-        return 0;
-}
-
 static u32 enic_get_msglevel(struct net_device *netdev)
 {
         struct enic *enic = netdev_priv(netdev);
@@ -387,17 +338,8 @@ static const struct ethtool_ops enic_ethtool_ops = {
         .get_strings = enic_get_strings,
         .get_sset_count = enic_get_sset_count,
         .get_ethtool_stats = enic_get_ethtool_stats,
-        .get_rx_csum = enic_get_rx_csum,
-        .set_rx_csum = enic_set_rx_csum,
-        .get_tx_csum = ethtool_op_get_tx_csum,
-        .set_tx_csum = enic_set_tx_csum,
-        .get_sg = ethtool_op_get_sg,
-        .set_sg = ethtool_op_set_sg,
-        .get_tso = ethtool_op_get_tso,
-        .set_tso = enic_set_tso,
         .get_coalesce = enic_get_coalesce,
         .set_coalesce = enic_set_coalesce,
-        .get_flags = ethtool_op_get_flags,
 };
 
 static void enic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf)
@@ -874,7 +816,7 @@ static struct net_device_stats *enic_get_stats(struct net_device *netdev)
         return net_stats;
 }
 
-static void enic_reset_addr_lists(struct enic *enic)
+void enic_reset_addr_lists(struct enic *enic)
 {
         enic->mc_count = 0;
         enic->uc_count = 0;
@@ -1112,157 +1054,77 @@ static int enic_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
                 return -EINVAL;
 }
 
-static int enic_set_port_profile(struct enic *enic, u8 *mac)
-{
-        struct vic_provinfo *vp;
-        u8 oui[3] = VIC_PROVINFO_CISCO_OUI;
-        u16 os_type = VIC_GENERIC_PROV_OS_TYPE_LINUX;
-        char uuid_str[38];
-        char client_mac_str[18];
-        u8 *client_mac;
-        int err;
-
-        err = enic_vnic_dev_deinit(enic);
-        if (err)
-                return err;
-
-        enic_reset_addr_lists(enic);
-
-        switch (enic->pp.request) {
-
-        case PORT_REQUEST_ASSOCIATE:
-
-                if (!(enic->pp.set & ENIC_SET_NAME) || !strlen(enic->pp.name))
-                        return -EINVAL;
-
-                if (!is_valid_ether_addr(mac))
-                        return -EADDRNOTAVAIL;
-
-                vp = vic_provinfo_alloc(GFP_KERNEL, oui,
-                        VIC_PROVINFO_GENERIC_TYPE);
-                if (!vp)
-                        return -ENOMEM;
-
-                vic_provinfo_add_tlv(vp,
-                        VIC_GENERIC_PROV_TLV_PORT_PROFILE_NAME_STR,
-                        strlen(enic->pp.name) + 1, enic->pp.name);
-
-                if (!is_zero_ether_addr(enic->pp.mac_addr))
-                        client_mac = enic->pp.mac_addr;
-                else
-                        client_mac = mac;
-
-                vic_provinfo_add_tlv(vp,
-                        VIC_GENERIC_PROV_TLV_CLIENT_MAC_ADDR,
-                        ETH_ALEN, client_mac);
-
-                sprintf(client_mac_str, "%pM", client_mac);
-                vic_provinfo_add_tlv(vp,
-                        VIC_GENERIC_PROV_TLV_CLUSTER_PORT_UUID_STR,
-                        sizeof(client_mac_str), client_mac_str);
-
-                if (enic->pp.set & ENIC_SET_INSTANCE) {
-                        sprintf(uuid_str, "%pUB", enic->pp.instance_uuid);
-                        vic_provinfo_add_tlv(vp,
-                                VIC_GENERIC_PROV_TLV_CLIENT_UUID_STR,
-                                sizeof(uuid_str), uuid_str);
-                }
-
-                if (enic->pp.set & ENIC_SET_HOST) {
-                        sprintf(uuid_str, "%pUB", enic->pp.host_uuid);
-                        vic_provinfo_add_tlv(vp,
-                                VIC_GENERIC_PROV_TLV_HOST_UUID_STR,
-                                sizeof(uuid_str), uuid_str);
-                }
-
-                os_type = htons(os_type);
-                vic_provinfo_add_tlv(vp,
-                        VIC_GENERIC_PROV_TLV_OS_TYPE,
-                        sizeof(os_type), &os_type);
-
-                err = enic_dev_init_prov(enic, vp);
-                vic_provinfo_free(vp);
-                if (err)
-                        return err;
-                break;
-
-        case PORT_REQUEST_DISASSOCIATE:
-                break;
-
-        default:
-                return -EINVAL;
-        }
-
-        /* Set flag to indicate that the port assoc/disassoc
-         * request has been sent out to fw
-         */
-        enic->pp.set |= ENIC_PORT_REQUEST_APPLIED;
-
-        return 0;
-}
-
 static int enic_set_vf_port(struct net_device *netdev, int vf,
         struct nlattr *port[])
 {
         struct enic *enic = netdev_priv(netdev);
-        struct enic_port_profile new_pp;
-        int err = 0;
+        struct enic_port_profile prev_pp;
+        int err = 0, restore_pp = 1;
 
-        memset(&new_pp, 0, sizeof(new_pp));
+        /* don't support VFs, yet */
+        if (vf != PORT_SELF_VF)
+                return -EOPNOTSUPP;
 
-        if (port[IFLA_PORT_REQUEST]) {
-                new_pp.set |= ENIC_SET_REQUEST;
-                new_pp.request = nla_get_u8(port[IFLA_PORT_REQUEST]);
-        }
+        if (!port[IFLA_PORT_REQUEST])
+                return -EOPNOTSUPP;
+
+        memcpy(&prev_pp, &enic->pp, sizeof(enic->pp));
+        memset(&enic->pp, 0, sizeof(enic->pp));
+
+        enic->pp.set |= ENIC_SET_REQUEST;
+        enic->pp.request = nla_get_u8(port[IFLA_PORT_REQUEST]);
 
         if (port[IFLA_PORT_PROFILE]) {
-                new_pp.set |= ENIC_SET_NAME;
-                memcpy(new_pp.name, nla_data(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_INSTANCE_UUID]) {
-                new_pp.set |= ENIC_SET_INSTANCE;
-                memcpy(new_pp.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_HOST_UUID]) {
-                new_pp.set |= ENIC_SET_HOST;
-                memcpy(new_pp.host_uuid,
+                enic->pp.set |= ENIC_SET_HOST;
+                memcpy(enic->pp.host_uuid,
                         nla_data(port[IFLA_PORT_HOST_UUID]), PORT_UUID_MAX);
         }
 
-        /* don't support VFs, yet */
-        if (vf != PORT_SELF_VF)
-                return -EOPNOTSUPP;
-
-        if (!(new_pp.set & ENIC_SET_REQUEST))
-                return -EOPNOTSUPP;
-
-        if (new_pp.request == PORT_REQUEST_ASSOCIATE) {
-                /* Special case handling */
-                if (!is_zero_ether_addr(enic->pp.vf_mac))
-                        memcpy(new_pp.mac_addr, enic->pp.vf_mac, ETH_ALEN);
+        /* Special case handling: mac came from IFLA_VF_MAC */
+        if (!is_zero_ether_addr(prev_pp.vf_mac))
+                memcpy(enic->pp.mac_addr, prev_pp.vf_mac, ETH_ALEN);
 
                 if (is_zero_ether_addr(netdev->dev_addr))
                         random_ether_addr(netdev->dev_addr);
-        }
 
-        memcpy(&enic->pp, &new_pp, sizeof(struct enic_port_profile));
+        err = enic_process_set_pp_request(enic, &prev_pp, &restore_pp);
+        if (err) {
+                if (restore_pp) {
+                        /* Things are still the way they were: Implicit
+                         * DISASSOCIATE failed
+                         */
+                        memcpy(&enic->pp, &prev_pp, sizeof(enic->pp));
+                } else {
+                        memset(&enic->pp, 0, sizeof(enic->pp));
+                        memset(netdev->dev_addr, 0, ETH_ALEN);
+                }
+        } else {
+                /* Set flag to indicate that the port assoc/disassoc
+                 * request has been sent out to fw
+                 */
+                enic->pp.set |= ENIC_PORT_REQUEST_APPLIED;
 
-        err = enic_set_port_profile(enic, netdev->dev_addr);
-        if (err)
-                goto set_port_profile_cleanup;
+                /* If DISASSOCIATE, clean up all assigned/saved macaddresses */
+                if (enic->pp.request == PORT_REQUEST_DISASSOCIATE) {
+                        memset(enic->pp.mac_addr, 0, ETH_ALEN);
+                        memset(netdev->dev_addr, 0, ETH_ALEN);
+                }
+        }
 
-set_port_profile_cleanup:
         memset(enic->pp.vf_mac, 0, ETH_ALEN);
 
-        if (err || enic->pp.request == PORT_REQUEST_DISASSOCIATE) {
-                memset(netdev->dev_addr, 0, ETH_ALEN);
-                memset(enic->pp.mac_addr, 0, ETH_ALEN);
-        }
-
         return err;
 }
 
@@ -1270,34 +1132,15 @@ static int enic_get_vf_port(struct net_device *netdev, int vf,
         struct sk_buff *skb)
 {
         struct enic *enic = netdev_priv(netdev);
-        int err, error, done;
         u16 response = PORT_PROFILE_RESPONSE_SUCCESS;
+        int err;
 
         if (!(enic->pp.set & ENIC_PORT_REQUEST_APPLIED))
                 return -ENODATA;
 
-        err = enic_dev_init_done(enic, &done, &error);
+        err = enic_process_get_pp_request(enic, enic->pp.request, &response);
         if (err)
-                error = err;
-
-        switch (error) {
-        case ERR_SUCCESS:
-                if (!done)
-                        response = PORT_PROFILE_RESPONSE_INPROGRESS;
-                break;
-        case ERR_EINVAL:
-                response = PORT_PROFILE_RESPONSE_INVALID;
-                break;
-        case ERR_EBADSTATE:
-                response = PORT_PROFILE_RESPONSE_BADSTATE;
-                break;
-        case ERR_ENOMEM:
-                response = PORT_PROFILE_RESPONSE_INSUFFICIENT_RESOURCES;
-                break;
-        default:
-                response = PORT_PROFILE_RESPONSE_ERROR;
-                break;
-        }
+                return err;
 
         NLA_PUT_U16(skb, IFLA_PORT_REQUEST, enic->pp.request);
         NLA_PUT_U16(skb, IFLA_PORT_RESPONSE, response);
@@ -1407,7 +1250,7 @@ static void enic_rq_indicate_buf(struct vnic_rq *rq,
                 skb_put(skb, bytes_written);
                 skb->protocol = eth_type_trans(skb, netdev);
 
-                if (enic->csum_rx_enabled && !csum_not_calc) {
+                if ((netdev->features & NETIF_F_RXCSUM) && !csum_not_calc) {
                         skb->csum = htons(checksum);
                         skb->ip_summed = CHECKSUM_COMPLETE;
                 }
@@ -2536,17 +2379,18 @@ static int __devinit enic_probe(struct pci_dev *pdev,
                 dev_info(dev, "loopback tag=0x%04x\n", enic->loop_tag);
         }
         if (ENIC_SETTING(enic, TXCSUM))
-                netdev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
+                netdev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM;
         if (ENIC_SETTING(enic, TSO))
-                netdev->features |= NETIF_F_TSO |
+                netdev->hw_features |= NETIF_F_TSO |
                         NETIF_F_TSO6 | NETIF_F_TSO_ECN;
-        if (ENIC_SETTING(enic, LRO))
-                netdev->features |= NETIF_F_GRO;
+        if (ENIC_SETTING(enic, RXCSUM))
+                netdev->hw_features |= NETIF_F_RXCSUM;
+
+        netdev->features |= netdev->hw_features;
+
         if (using_dac)
                 netdev->features |= NETIF_F_HIGHDMA;
 
-        enic->csum_rx_enabled = ENIC_SETTING(enic, RXCSUM);
-
         err = register_netdev(netdev);
         if (err) {
                 dev_err(dev, "Cannot register net device, aborting\n");
diff --git a/drivers/net/enic/enic_pp.c b/drivers/net/enic/enic_pp.c
new file mode 100644
index 000000000000..ffaa75dd1ded
--- /dev/null
+++ b/drivers/net/enic/enic_pp.c
@@ -0,0 +1,264 @@
+/*
+ * Copyright 2011 Cisco Systems, Inc.  All rights reserved.
+ *
+ * This program is free software; you may redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/rtnetlink.h>
+#include <net/ip.h>
+
+#include "vnic_vic.h"
+#include "enic_res.h"
+#include "enic.h"
+#include "enic_dev.h"
+
+static int enic_set_port_profile(struct enic *enic)
+{
+        struct net_device *netdev = enic->netdev;
+        struct vic_provinfo *vp;
+        const u8 oui[3] = VIC_PROVINFO_CISCO_OUI;
+        const u16 os_type = htons(VIC_GENERIC_PROV_OS_TYPE_LINUX);
+        char uuid_str[38];
+        char client_mac_str[18];
+        u8 *client_mac;
+        int err;
+
+        if (!(enic->pp.set & ENIC_SET_NAME) || !strlen(enic->pp.name))
+                return -EINVAL;
+
+        vp = vic_provinfo_alloc(GFP_KERNEL, oui,
+                VIC_PROVINFO_GENERIC_TYPE);
+        if (!vp)
+                return -ENOMEM;
+
+        VIC_PROVINFO_ADD_TLV(vp,
+                VIC_GENERIC_PROV_TLV_PORT_PROFILE_NAME_STR,
+                strlen(enic->pp.name) + 1, enic->pp.name);
+
+        if (!is_zero_ether_addr(enic->pp.mac_addr))
+                client_mac = enic->pp.mac_addr;
+        else
+                client_mac = netdev->dev_addr;
+
+        VIC_PROVINFO_ADD_TLV(vp,
+                VIC_GENERIC_PROV_TLV_CLIENT_MAC_ADDR,
+                ETH_ALEN, client_mac);
+
+        snprintf(client_mac_str, sizeof(client_mac_str), "%pM", client_mac);
+        VIC_PROVINFO_ADD_TLV(vp,
+                VIC_GENERIC_PROV_TLV_CLUSTER_PORT_UUID_STR,
+                sizeof(client_mac_str), client_mac_str);
+
+        if (enic->pp.set & ENIC_SET_INSTANCE) {
+                sprintf(uuid_str, "%pUB", enic->pp.instance_uuid);
+                VIC_PROVINFO_ADD_TLV(vp,
+                        VIC_GENERIC_PROV_TLV_CLIENT_UUID_STR,
+                        sizeof(uuid_str), uuid_str);
+        }
+
+        if (enic->pp.set & ENIC_SET_HOST) {
+                sprintf(uuid_str, "%pUB", enic->pp.host_uuid);
+                VIC_PROVINFO_ADD_TLV(vp,
+                        VIC_GENERIC_PROV_TLV_HOST_UUID_STR,
+                        sizeof(uuid_str), uuid_str);
+        }
+
+        VIC_PROVINFO_ADD_TLV(vp,
+                VIC_GENERIC_PROV_TLV_OS_TYPE,
+                sizeof(os_type), &os_type);
+
+        err = enic_dev_status_to_errno(enic_dev_init_prov2(enic, vp));
+
+add_tlv_failure:
+        vic_provinfo_free(vp);
+
+        return err;
+}
+
+static int enic_unset_port_profile(struct enic *enic)
+{
+        int err;
+
+        err = enic_vnic_dev_deinit(enic);
+        if (err)
+                return enic_dev_status_to_errno(err);
+
+        enic_reset_addr_lists(enic);
+
+        return 0;
+}
+
+static int enic_are_pp_different(struct enic_port_profile *pp1,
+                struct enic_port_profile *pp2)
+{
+        return strcmp(pp1->name, pp2->name) | !!memcmp(pp1->instance_uuid,
+                pp2->instance_uuid, PORT_UUID_MAX) |
+                !!memcmp(pp1->host_uuid, pp2->host_uuid, PORT_UUID_MAX) |
+                !!memcmp(pp1->mac_addr, pp2->mac_addr, ETH_ALEN);
+}
+
+static int enic_pp_preassociate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp);
+static int enic_pp_disassociate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp);
+static int enic_pp_preassociate_rr(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp);
+static int enic_pp_associate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp);
+
+static int (*enic_pp_handlers[])(struct enic *enic,
+                struct enic_port_profile *prev_state, int *restore_pp) = {
+        [PORT_REQUEST_PREASSOCIATE]     = enic_pp_preassociate,
+        [PORT_REQUEST_PREASSOCIATE_RR]  = enic_pp_preassociate_rr,
+        [PORT_REQUEST_ASSOCIATE]        = enic_pp_associate,
+        [PORT_REQUEST_DISASSOCIATE]     = enic_pp_disassociate,
+};
+
+static const int enic_pp_handlers_count =
+                        sizeof(enic_pp_handlers)/sizeof(*enic_pp_handlers);
+
+static int enic_pp_preassociate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        return -EOPNOTSUPP;
+}
+
+static int enic_pp_disassociate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        return enic_unset_port_profile(enic);
+}
+
+static int enic_pp_preassociate_rr(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        int err;
+        int active = 0;
+
+        if (enic->pp.request != PORT_REQUEST_ASSOCIATE) {
+                /* If pre-associate is not part of an associate.
+                We always disassociate first */
+                err = enic_pp_handlers[PORT_REQUEST_DISASSOCIATE](enic,
+                        prev_pp, restore_pp);
+                if (err)
+                        return err;
+
+                *restore_pp = 0;
+        }
+
+        *restore_pp = 0;
+
+        err = enic_set_port_profile(enic);
+        if (err)
+                return err;
+
+        /* If pre-associate is not part of an associate. */
+        if (enic->pp.request != PORT_REQUEST_ASSOCIATE)
+                err = enic_dev_status_to_errno(enic_dev_enable2(enic, active));
+
+        return err;
+}
+
+static int enic_pp_associate(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        int err;
+        int active = 1;
+
+        /* Check if a pre-associate was called before */
+        if (prev_pp->request != PORT_REQUEST_PREASSOCIATE_RR ||
+                (prev_pp->request == PORT_REQUEST_PREASSOCIATE_RR &&
+                        enic_are_pp_different(prev_pp, &enic->pp))) {
+                err = enic_pp_handlers[PORT_REQUEST_DISASSOCIATE](
+                        enic, prev_pp, restore_pp);
+                if (err)
+                        return err;
+
+                *restore_pp = 0;
+        }
+
+        err = enic_pp_handlers[PORT_REQUEST_PREASSOCIATE_RR](
+                        enic, prev_pp, restore_pp);
+        if (err)
+                return err;
+
+        *restore_pp = 0;
+
+        return enic_dev_status_to_errno(enic_dev_enable2(enic, active));
+}
+
+int enic_process_set_pp_request(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp)
+{
+        if (enic->pp.request < enic_pp_handlers_count
+                && enic_pp_handlers[enic->pp.request])
+                return enic_pp_handlers[enic->pp.request](enic,
+                        prev_pp, restore_pp);
+        else
+                return -EOPNOTSUPP;
+}
+
+int enic_process_get_pp_request(struct enic *enic, int request,
+        u16 *response)
+{
+        int err, status = ERR_SUCCESS;
+
+        switch (request) {
+
+        case PORT_REQUEST_PREASSOCIATE_RR:
+        case PORT_REQUEST_ASSOCIATE:
+                err = enic_dev_enable2_done(enic, &status);
+                break;
+
+        case PORT_REQUEST_DISASSOCIATE:
+                err = enic_dev_deinit_done(enic, &status);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        if (err)
+                status = err;
+
+        switch (status) {
+        case ERR_SUCCESS:
+                *response = PORT_PROFILE_RESPONSE_SUCCESS;
+                break;
+        case ERR_EINVAL:
+                *response = PORT_PROFILE_RESPONSE_INVALID;
+                break;
+        case ERR_EBADSTATE:
+                *response = PORT_PROFILE_RESPONSE_BADSTATE;
+                break;
+        case ERR_ENOMEM:
+                *response = PORT_PROFILE_RESPONSE_INSUFFICIENT_RESOURCES;
+                break;
+        case ERR_EINPROGRESS:
+                *response = PORT_PROFILE_RESPONSE_INPROGRESS;
+                break;
+        default:
+                *response = PORT_PROFILE_RESPONSE_ERROR;
+                break;
+        }
+
+        return 0;
+}
diff --git a/drivers/net/enic/enic_pp.h b/drivers/net/enic/enic_pp.h
new file mode 100644
index 000000000000..699e365a944d
--- /dev/null
+++ b/drivers/net/enic/enic_pp.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2011 Cisco Systems, Inc.  All rights reserved.
+ *
+ * This program is free software; you may redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#ifndef _ENIC_PP_H_
+#define _ENIC_PP_H_
+
+int enic_process_set_pp_request(struct enic *enic,
+        struct enic_port_profile *prev_pp, int *restore_pp);
+int enic_process_get_pp_request(struct enic *enic, int request,
+        u16 *response);
+
+#endif /* _ENIC_PP_H_ */
diff --git a/drivers/net/enic/enic_res.c b/drivers/net/enic/enic_res.c
index f111a37419ce..6e5c6356e7df 100644
--- a/drivers/net/enic/enic_res.c
+++ b/drivers/net/enic/enic_res.c
@@ -98,9 +98,9 @@ int enic_get_vnic_config(struct enic *enic)
                 "vNIC MAC addr %pM wq/rq %d/%d mtu %d\n",
                 enic->mac_addr, c->wq_desc_count, c->rq_desc_count, c->mtu);
         dev_info(enic_get_dev(enic), "vNIC csum tx/rx %d/%d "
-                "tso/lro %d/%d intr timer %d usec rss %d\n",
+                "tso %d intr timer %d usec rss %d\n",
                 ENIC_SETTING(enic, TXCSUM), ENIC_SETTING(enic, RXCSUM),
-                ENIC_SETTING(enic, TSO), ENIC_SETTING(enic, LRO),
+                ENIC_SETTING(enic, TSO),
                 c->intr_timer_usec, ENIC_SETTING(enic, RSS));
 
         return 0;
diff --git a/drivers/net/enic/vnic_dev.c b/drivers/net/enic/vnic_dev.c
index c089b362a36f..68f24ae860ae 100644
--- a/drivers/net/enic/vnic_dev.c
+++ b/drivers/net/enic/vnic_dev.c
@@ -786,48 +786,6 @@ int vnic_dev_init(struct vnic_dev *vdev, int arg)
         return r;
 }
 
-int vnic_dev_init_done(struct vnic_dev *vdev, int *done, int *err)
-{
-        u64 a0 = 0, a1 = 0;
-        int wait = 1000;
-        int ret;
-
-        *done = 0;
-
-        ret = vnic_dev_cmd(vdev, CMD_INIT_STATUS, &a0, &a1, wait);
-        if (ret)
-                return ret;
-
-        *done = (a0 == 0);
-
-        *err = (a0 == 0) ? (int)a1:0;
-
-        return 0;
-}
-
-int vnic_dev_init_prov(struct vnic_dev *vdev, u8 *buf, u32 len)
-{
-        u64 a0, a1 = len;
-        int wait = 1000;
-        dma_addr_t prov_pa;
-        void *prov_buf;
-        int ret;
-
-        prov_buf = pci_alloc_consistent(vdev->pdev, len, &prov_pa);
-        if (!prov_buf)
-                return -ENOMEM;
-
-        memcpy(prov_buf, buf, len);
-
-        a0 = prov_pa;
-
-        ret = vnic_dev_cmd(vdev, CMD_INIT_PROV_INFO, &a0, &a1, wait);
-
-        pci_free_consistent(vdev->pdev, len, prov_buf, prov_pa);
-
-        return ret;
-}
-
 int vnic_dev_deinit(struct vnic_dev *vdev)
 {
         u64 a0 = 0, a1 = 0;
@@ -927,4 +885,59 @@ err_out:
         return NULL;
 }
 
+int vnic_dev_init_prov2(struct vnic_dev *vdev, u8 *buf, u32 len)
+{
+        u64 a0, a1 = len;
+        int wait = 1000;
+        dma_addr_t prov_pa;
+        void *prov_buf;
+        int ret;
+
+        prov_buf = pci_alloc_consistent(vdev->pdev, len, &prov_pa);
+        if (!prov_buf)
+                return -ENOMEM;
 
+        memcpy(prov_buf, buf, len);
+
+        a0 = prov_pa;
+
+        ret = vnic_dev_cmd(vdev, CMD_INIT_PROV_INFO2, &a0, &a1, wait);
+
+        pci_free_consistent(vdev->pdev, len, prov_buf, prov_pa);
+
+        return ret;
+}
+
+int vnic_dev_enable2(struct vnic_dev *vdev, int active)
+{
+        u64 a0, a1 = 0;
+        int wait = 1000;
+
+        a0 = (active ? CMD_ENABLE2_ACTIVE : 0);
+
+        return vnic_dev_cmd(vdev, CMD_ENABLE2, &a0, &a1, wait);
+}
+
+static int vnic_dev_cmd_status(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
+        int *status)
+{
+        u64 a0 = cmd, a1 = 0;
+        int wait = 1000;
+        int ret;
+
+        ret = vnic_dev_cmd(vdev, CMD_STATUS, &a0, &a1, wait);
+        if (!ret)
+                *status = (int)a0;
+
+        return ret;
+}
+
+int vnic_dev_enable2_done(struct vnic_dev *vdev, int *status)
+{
+        return vnic_dev_cmd_status(vdev, CMD_ENABLE2, status);
+}
+
+int vnic_dev_deinit_done(struct vnic_dev *vdev, int *status)
+{
+        return vnic_dev_cmd_status(vdev, CMD_DEINIT, status);
+}
diff --git a/drivers/net/enic/vnic_dev.h b/drivers/net/enic/vnic_dev.h
index e837546213a8..cf482a2c9dd9 100644
--- a/drivers/net/enic/vnic_dev.h
+++ b/drivers/net/enic/vnic_dev.h
@@ -108,8 +108,6 @@ int vnic_dev_disable(struct vnic_dev *vdev);
 int vnic_dev_open(struct vnic_dev *vdev, int arg);
 int vnic_dev_open_done(struct vnic_dev *vdev, int *done);
 int vnic_dev_init(struct vnic_dev *vdev, int arg);
-int vnic_dev_init_done(struct vnic_dev *vdev, int *done, int *err);
-int vnic_dev_init_prov(struct vnic_dev *vdev, u8 *buf, u32 len);
 int vnic_dev_deinit(struct vnic_dev *vdev);
 int vnic_dev_hang_reset(struct vnic_dev *vdev, int arg);
 int vnic_dev_hang_reset_done(struct vnic_dev *vdev, int *done);
@@ -122,5 +120,9 @@ int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev *vdev,
 struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev,
         void *priv, struct pci_dev *pdev, struct vnic_dev_bar *bar,
         unsigned int num_bars);
+int vnic_dev_init_prov2(struct vnic_dev *vdev, u8 *buf, u32 len);
+int vnic_dev_enable2(struct vnic_dev *vdev, int active);
+int vnic_dev_enable2_done(struct vnic_dev *vdev, int *status);
+int vnic_dev_deinit_done(struct vnic_dev *vdev, int *status);
 
 #endif /* _VNIC_DEV_H_ */
diff --git a/drivers/net/enic/vnic_devcmd.h b/drivers/net/enic/vnic_devcmd.h
index d833a071bac5..c5569bfb47ac 100644
--- a/drivers/net/enic/vnic_devcmd.h
+++ b/drivers/net/enic/vnic_devcmd.h
@@ -267,17 +267,62 @@ enum vnic_devcmd_cmd {
 
         /*
          * As for BY_BDF except a0 is index of hvnlink subordinate vnic
-         * or SR-IOV virtual vnic */
+         * or SR-IOV virtual vnic
+         */
         CMD_PROXY_BY_INDEX =    _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 43),
 
         /*
-         * in:  (u64)a0=paddr of buffer to put latest VIC VIF-CONFIG-INFO TLV in
-         *      (u32)a1=length of buffer in a0
-         * out: (u64)a0=paddr of buffer with latest VIC VIF-CONFIG-INFO TLV
-         *      (u32)a1=actual length of latest VIC VIF-CONFIG-INFO TLV */
+         * For HPP toggle:
+         * adapter-info-get
+         * in:  (u64)a0=phsical address of buffer passed in from caller.
+         *      (u16)a1=size of buffer specified in a0.
+         * out: (u64)a0=phsical address of buffer passed in from caller.
+         *      (u16)a1=actual bytes from VIF-CONFIG-INFO TLV, or
+         *              0 if no VIF-CONFIG-INFO TLV was ever received. */
         CMD_CONFIG_INFO_GET     = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 44),
+
+        /* init_prov_info2:
+         * Variant of CMD_INIT_PROV_INFO, where it will not try to enable
+         * the vnic until CMD_ENABLE2 is issued.
+         *     (u64)a0=paddr of vnic_devcmd_provinfo
+         *     (u32)a1=sizeof provision info */
+        CMD_INIT_PROV_INFO2  = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 47),
+
+        /* enable2:
+         *      (u32)a0=0                  ==> standby
+         *             =CMD_ENABLE2_ACTIVE ==> active
+         */
+        CMD_ENABLE2 = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 48),
+
+        /*
+         * cmd_status:
+         *     Returns the status of the specified command
+         * Input:
+         *     a0 = command for which status is being queried.
+         *          Possible values are:
+         *              CMD_SOFT_RESET
+         *              CMD_HANG_RESET
+         *              CMD_OPEN
+         *              CMD_INIT
+         *              CMD_INIT_PROV_INFO
+         *              CMD_DEINIT
+         *              CMD_INIT_PROV_INFO2
+         *              CMD_ENABLE2
+         * Output:
+         *     if status == STAT_ERROR
+         *        a0 = ERR_ENOTSUPPORTED - status for command in a0 is
+         *                                 not supported
+         *     if status == STAT_NONE
+         *        a0 = status of the devcmd specified in a0 as follows.
+         *             ERR_SUCCESS   - command in a0 completed successfully
+         *             ERR_EINPROGRESS - command in a0 is still in progress
+         */
+        CMD_STATUS = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 49),
 };
 
+/* CMD_ENABLE2 flags */
+#define CMD_ENABLE2_ACTIVE  0x1
+
 /* flags for CMD_OPEN */
 #define CMD_OPENF_OPROM         0x1     /* open coming from option rom */
 
@@ -315,6 +360,8 @@ enum vnic_devcmd_error {
         ERR_ETIMEDOUT = 8,
         ERR_ELINKDOWN = 9,
         ERR_EMAXRES = 10,
+        ERR_ENOTSUPPORTED = 11,
+        ERR_EINPROGRESS = 12,
 };
 
 /*
diff --git a/drivers/net/enic/vnic_vic.c b/drivers/net/enic/vnic_vic.c
index 4725b79de0ef..24ef8cd40545 100644
--- a/drivers/net/enic/vnic_vic.c
+++ b/drivers/net/enic/vnic_vic.c
@@ -23,7 +23,8 @@
 
 #include "vnic_vic.h"
 
-struct vic_provinfo *vic_provinfo_alloc(gfp_t flags, u8 *oui, u8 type)
+struct vic_provinfo *vic_provinfo_alloc(gfp_t flags, const u8 *oui,
+        const u8 type)
 {
         struct vic_provinfo *vp;
 
@@ -47,7 +48,7 @@ void vic_provinfo_free(struct vic_provinfo *vp)
 }
 
 int vic_provinfo_add_tlv(struct vic_provinfo *vp, u16 type, u16 length,
-        void *value)
+        const void *value)
 {
         struct vic_provinfo_tlv *tlv;
 
diff --git a/drivers/net/enic/vnic_vic.h b/drivers/net/enic/vnic_vic.h
index f700f5d9e81d..9ef81f148351 100644
--- a/drivers/net/enic/vnic_vic.h
+++ b/drivers/net/enic/vnic_vic.h
@@ -47,6 +47,7 @@ enum vic_generic_prov_os_type {
         VIC_GENERIC_PROV_OS_TYPE_ESX = 1,
         VIC_GENERIC_PROV_OS_TYPE_LINUX = 2,
         VIC_GENERIC_PROV_OS_TYPE_WINDOWS = 3,
+        VIC_GENERIC_PROV_OS_TYPE_SOLARIS = 4,
 };
 
 struct vic_provinfo {
@@ -61,14 +62,22 @@ struct vic_provinfo {
         } tlv[0];
 } __packed;
 
+#define VIC_PROVINFO_ADD_TLV(vp, tlvtype, tlvlen, data) \
+        do { \
+                err = vic_provinfo_add_tlv(vp, tlvtype, tlvlen, data); \
+                if (err) \
+                        goto add_tlv_failure; \
+        } while (0)
+
 #define VIC_PROVINFO_MAX_DATA           1385
 #define VIC_PROVINFO_MAX_TLV_DATA (VIC_PROVINFO_MAX_DATA - \
         sizeof(struct vic_provinfo))
 
-struct vic_provinfo *vic_provinfo_alloc(gfp_t flags, u8 *oui, u8 type);
+struct vic_provinfo *vic_provinfo_alloc(gfp_t flags, const u8 *oui,
+        const u8 type);
 void vic_provinfo_free(struct vic_provinfo *vp);
 int vic_provinfo_add_tlv(struct vic_provinfo *vp, u16 type, u16 length,
-        void *value);
+        const void *value);
 size_t vic_provinfo_size(struct vic_provinfo *vp);
 
 #endif  /* _VNIC_VIC_H_ */
diff --git a/drivers/net/ewrk3.c b/drivers/net/ewrk3.c
index 380d0614a89a..c7ce4438e923 100644
--- a/drivers/net/ewrk3.c
+++ b/drivers/net/ewrk3.c
@@ -1604,55 +1604,47 @@ static u32 ewrk3_get_link(struct net_device *dev)
         return !(cmr & CMR_LINK);
 }
 
-static int ewrk3_phys_id(struct net_device *dev, u32 data)
+static int ewrk3_set_phys_id(struct net_device *dev,
+                             enum ethtool_phys_id_state state)
 {
         struct ewrk3_private *lp = netdev_priv(dev);
         unsigned long iobase = dev->base_addr;
-        unsigned long flags;
         u8 cr;
-        int count;
-
-        /* Toggle LED 4x per second */
-        count = data << 2;
 
-        spin_lock_irqsave(&lp->hw_lock, flags);
-
-        /* Bail if a PHYS_ID is already in progress */
-        if (lp->led_mask == 0) {
-                spin_unlock_irqrestore(&lp->hw_lock, flags);
-                return -EBUSY;
-        }
+        spin_lock_irq(&lp->hw_lock);
 
-        /* Prevent ISR from twiddling the LED */
-        lp->led_mask = 0;
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                /* Prevent ISR from twiddling the LED */
+                lp->led_mask = 0;
+                spin_unlock_irq(&lp->hw_lock);
+                return -EINVAL;
 
-        while (count--) {
-                /* Toggle the LED */
+        case ETHTOOL_ID_ON:
                 cr = inb(EWRK3_CR);
-                outb(cr ^ CR_LED, EWRK3_CR);
+                outb(cr | CR_LED, EWRK3_CR);
+                break;
 
-                /* Wait a little while */
-                spin_unlock_irqrestore(&lp->hw_lock, flags);
-                msleep(250);
-                spin_lock_irqsave(&lp->hw_lock, flags);
+        case ETHTOOL_ID_OFF:
+                cr = inb(EWRK3_CR);
+                outb(cr & ~CR_LED, EWRK3_CR);
+                break;
 
-                /* Exit if we got a signal */
-                if (signal_pending(current))
-                        break;
+        case ETHTOOL_ID_INACTIVE:
+                lp->led_mask = CR_LED;
+                cr = inb(EWRK3_CR);
+                outb(cr & ~CR_LED, EWRK3_CR);
         }
+        spin_unlock_irq(&lp->hw_lock);
 
-        lp->led_mask = CR_LED;
-        cr = inb(EWRK3_CR);
-        outb(cr & ~CR_LED, EWRK3_CR);
-        spin_unlock_irqrestore(&lp->hw_lock, flags);
-        return signal_pending(current) ? -ERESTARTSYS : 0;
+        return 0;
 }
 
 static const struct ethtool_ops ethtool_ops_203 = {
         .get_drvinfo = ewrk3_get_drvinfo,
         .get_settings = ewrk3_get_settings,
         .set_settings = ewrk3_set_settings,
-        .phys_id = ewrk3_phys_id,
+        .set_phys_id = ewrk3_set_phys_id,
 };
 
 static const struct ethtool_ops ethtool_ops = {
@@ -1660,7 +1652,7 @@ static const struct ethtool_ops ethtool_ops = {
         .get_settings = ewrk3_get_settings,
         .set_settings = ewrk3_set_settings,
         .get_link = ewrk3_get_link,
-        .phys_id = ewrk3_phys_id,
+        .set_phys_id = ewrk3_set_phys_id,
 };
 
 /*
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
index 24cb953900dd..a9388944f1d3 100644
--- a/drivers/net/fs_enet/fs_enet-main.c
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -956,8 +956,6 @@ static const struct ethtool_ops fs_ethtool_ops = {
         .get_link = ethtool_op_get_link,
         .get_msglevel = fs_get_msglevel,
         .set_msglevel = fs_set_msglevel,
-        .set_tx_csum = ethtool_op_set_tx_csum,  /* local! */
-        .set_sg = ethtool_op_set_sg,
         .get_regs = fs_get_regs,
 };
 
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index b2fe7edefad9..0438d3551d5c 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -382,23 +382,6 @@ extern const char gfar_driver_version[];
 #define BD_LFLAG(flags) ((flags) << 16)
 #define BD_LENGTH_MASK          0x0000ffff
 
-#define CLASS_CODE_UNRECOG              0x00
-#define CLASS_CODE_DUMMY1               0x01
-#define CLASS_CODE_ETHERTYPE1           0x02
-#define CLASS_CODE_ETHERTYPE2           0x03
-#define CLASS_CODE_USER_PROG1           0x04
-#define CLASS_CODE_USER_PROG2           0x05
-#define CLASS_CODE_USER_PROG3           0x06
-#define CLASS_CODE_USER_PROG4           0x07
-#define CLASS_CODE_TCP_IPV4             0x08
-#define CLASS_CODE_UDP_IPV4             0x09
-#define CLASS_CODE_AH_ESP_IPV4          0x0a
-#define CLASS_CODE_SCTP_IPV4            0x0b
-#define CLASS_CODE_TCP_IPV6             0x0c
-#define CLASS_CODE_UDP_IPV6             0x0d
-#define CLASS_CODE_AH_ESP_IPV6          0x0e
-#define CLASS_CODE_SCTP_IPV6            0x0f
-
 #define FPR_FILER_MASK  0xFFFFFFFF
 #define MAX_FILER_IDX   0xFF
 
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index 3bc8e276ba4d..0840590958dd 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -645,42 +645,6 @@ static int gfar_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 }
 #endif
 
-static int gfar_ethflow_to_class(int flow_type, u64 *class)
-{
-        switch (flow_type) {
-        case TCP_V4_FLOW:
-                *class = CLASS_CODE_TCP_IPV4;
-                break;
-        case UDP_V4_FLOW:
-                *class = CLASS_CODE_UDP_IPV4;
-                break;
-        case AH_V4_FLOW:
-        case ESP_V4_FLOW:
-                *class = CLASS_CODE_AH_ESP_IPV4;
-                break;
-        case SCTP_V4_FLOW:
-                *class = CLASS_CODE_SCTP_IPV4;
-                break;
-        case TCP_V6_FLOW:
-                *class = CLASS_CODE_TCP_IPV6;
-                break;
-        case UDP_V6_FLOW:
-                *class = CLASS_CODE_UDP_IPV6;
-                break;
-        case AH_V6_FLOW:
-        case ESP_V6_FLOW:
-                *class = CLASS_CODE_AH_ESP_IPV6;
-                break;
-        case SCTP_V6_FLOW:
-                *class = CLASS_CODE_SCTP_IPV6;
-                break;
-        default:
-                return 0;
-        }
-
-        return 1;
-}
-
 static void ethflow_to_filer_rules (struct gfar_private *priv, u64 ethflow)
 {
         u32 fcr = 0x0, fpr = FPR_FILER_MASK;
@@ -778,11 +742,6 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
         case UDP_V6_FLOW:
                 cmp_rqfpr = RQFPR_IPV6 |RQFPR_UDP;
                 break;
-        case IPV4_FLOW:
-                cmp_rqfpr = RQFPR_IPV4;
-        case IPV6_FLOW:
-                cmp_rqfpr = RQFPR_IPV6;
-                break;
         default:
                 printk(KERN_ERR "Right now this class is not supported\n");
                 return 0;
@@ -848,18 +807,9 @@ static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow, u
 
 static int gfar_set_hash_opts(struct gfar_private *priv, struct ethtool_rxnfc *cmd)
 {
-        u64 class;
-
-        if (!gfar_ethflow_to_class(cmd->flow_type, &class))
-                return -EINVAL;
-
-        if (class < CLASS_CODE_USER_PROG1 ||
-                        class > CLASS_CODE_SCTP_IPV6)
-                return -EINVAL;
-
         /* write the filer rules here */
         if (!gfar_ethflow_to_filer_table(priv, cmd->data, cmd->flow_type))
-                return -1;
+                return -EINVAL;
 
         return 0;
 }
diff --git a/drivers/net/ibmlana.c b/drivers/net/ibmlana.c
index 8ff68ae6b520..a7d6cad32953 100644
--- a/drivers/net/ibmlana.c
+++ b/drivers/net/ibmlana.c
@@ -782,7 +782,8 @@ static int ibmlana_open(struct net_device *dev)
 
         /* register resources - only necessary for IRQ */
 
-        result = request_irq(priv->realirq, irq_handler, IRQF_SHARED | IRQF_SAMPLE_RANDOM, dev->name, dev);
+        result = request_irq(priv->realirq, irq_handler, IRQF_SHARED,
+                             dev->name, dev);
         if (result != 0) {
                 printk(KERN_ERR "%s: failed to register irq %d\n", dev->name, dev->irq);
                 return result;
diff --git a/drivers/net/jme.c b/drivers/net/jme.c
index 994c80939c7a..be4773f54a24 100644
--- a/drivers/net/jme.c
+++ b/drivers/net/jme.c
@@ -2230,17 +2230,9 @@ jme_change_mtu(struct net_device *netdev, int new_mtu)
                 jme_restart_rx_engine(jme);
         }
 
-        if (new_mtu > 1900) {
-                netdev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
-                                NETIF_F_TSO | NETIF_F_TSO6);
-        } else {
-                if (test_bit(JME_FLAG_TXCSUM, &jme->flags))
-                        netdev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
-                if (test_bit(JME_FLAG_TSO, &jme->flags))
-                        netdev->features |= NETIF_F_TSO | NETIF_F_TSO6;
-        }
-
         netdev->mtu = new_mtu;
+        netdev_update_features(netdev);
+
         jme_reset_link(jme);
 
         return 0;
@@ -2640,19 +2632,20 @@ jme_set_msglevel(struct net_device *netdev, u32 value)
 }
 
 static u32
-jme_get_rx_csum(struct net_device *netdev)
+jme_fix_features(struct net_device *netdev, u32 features)
 {
-        struct jme_adapter *jme = netdev_priv(netdev);
-        return jme->reg_rxmcs & RXMCS_CHECKSUM;
+        if (netdev->mtu > 1900)
+                features &= ~(NETIF_F_ALL_TSO | NETIF_F_ALL_CSUM);
+        return features;
 }
 
 static int
-jme_set_rx_csum(struct net_device *netdev, u32 on)
+jme_set_features(struct net_device *netdev, u32 features)
 {
         struct jme_adapter *jme = netdev_priv(netdev);
 
         spin_lock_bh(&jme->rxmcs_lock);
-        if (on)
+        if (features & NETIF_F_RXCSUM)
                 jme->reg_rxmcs |= RXMCS_CHECKSUM;
         else
                 jme->reg_rxmcs &= ~RXMCS_CHECKSUM;
@@ -2663,42 +2656,6 @@ jme_set_rx_csum(struct net_device *netdev, u32 on)
 }
 
 static int
-jme_set_tx_csum(struct net_device *netdev, u32 on)
-{
-        struct jme_adapter *jme = netdev_priv(netdev);
-
-        if (on) {
-                set_bit(JME_FLAG_TXCSUM, &jme->flags);
-                if (netdev->mtu <= 1900)
-                        netdev->features |=
-                                NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
-        } else {
-                clear_bit(JME_FLAG_TXCSUM, &jme->flags);
-                netdev->features &=
-                                ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
-        }
-
-        return 0;
-}
-
-static int
-jme_set_tso(struct net_device *netdev, u32 on)
-{
-        struct jme_adapter *jme = netdev_priv(netdev);
-
-        if (on) {
-                set_bit(JME_FLAG_TSO, &jme->flags);
-                if (netdev->mtu <= 1900)
-                        netdev->features |= NETIF_F_TSO | NETIF_F_TSO6;
-        } else {
-                clear_bit(JME_FLAG_TSO, &jme->flags);
-                netdev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
-        }
-
-        return 0;
-}
-
-static int
 jme_nway_reset(struct net_device *netdev)
 {
         struct jme_adapter *jme = netdev_priv(netdev);
@@ -2839,11 +2796,6 @@ static const struct ethtool_ops jme_ethtool_ops = {
         .get_link               = jme_get_link,
         .get_msglevel           = jme_get_msglevel,
         .set_msglevel           = jme_set_msglevel,
-        .get_rx_csum            = jme_get_rx_csum,
-        .set_rx_csum            = jme_set_rx_csum,
-        .set_tx_csum            = jme_set_tx_csum,
-        .set_tso                = jme_set_tso,
-        .set_sg                 = ethtool_op_set_sg,
         .nway_reset             = jme_nway_reset,
         .get_eeprom_len         = jme_get_eeprom_len,
         .get_eeprom             = jme_get_eeprom,
@@ -2903,6 +2855,8 @@ static const struct net_device_ops jme_netdev_ops = {
         .ndo_change_mtu         = jme_change_mtu,
         .ndo_tx_timeout         = jme_tx_timeout,
         .ndo_vlan_rx_register   = jme_vlan_rx_register,
+        .ndo_fix_features       = jme_fix_features,
+        .ndo_set_features       = jme_set_features,
 };
 
 static int __devinit
@@ -2957,6 +2911,12 @@ jme_init_one(struct pci_dev *pdev,
         netdev->netdev_ops = &jme_netdev_ops;
         netdev->ethtool_ops             = &jme_ethtool_ops;
         netdev->watchdog_timeo          = TX_TIMEOUT;
+        netdev->hw_features             =       NETIF_F_IP_CSUM |
+                                                NETIF_F_IPV6_CSUM |
+                                                NETIF_F_SG |
+                                                NETIF_F_TSO |
+                                                NETIF_F_TSO6 |
+                                                NETIF_F_RXCSUM;
         netdev->features                =       NETIF_F_IP_CSUM |
                                                 NETIF_F_IPV6_CSUM |
                                                 NETIF_F_SG |
@@ -3040,8 +3000,9 @@ jme_init_one(struct pci_dev *pdev,
         jme->reg_txpfc = 0;
         jme->reg_pmcs = PMCS_MFEN;
         jme->reg_gpreg1 = GPREG1_DEFAULT;
-        set_bit(JME_FLAG_TXCSUM, &jme->flags);
-        set_bit(JME_FLAG_TSO, &jme->flags);
+
+        if (jme->reg_rxmcs & RXMCS_CHECKSUM)
+                netdev->features |= NETIF_F_RXCSUM;
 
         /*
          * Get Max Read Req Size from PCI Config Space
diff --git a/drivers/net/jme.h b/drivers/net/jme.h
index 8bf30451e821..e9aaeca96abc 100644
--- a/drivers/net/jme.h
+++ b/drivers/net/jme.h
@@ -468,8 +468,6 @@ struct jme_adapter {
 enum jme_flags_bits {
         JME_FLAG_MSI            = 1,
         JME_FLAG_SSET           = 2,
-        JME_FLAG_TXCSUM         = 3,
-        JME_FLAG_TSO            = 4,
         JME_FLAG_POLL           = 5,
         JME_FLAG_SHUTDOWN       = 6,
 };
diff --git a/drivers/net/ksz884x.c b/drivers/net/ksz884x.c
index 7f7d5708a658..2c37a3804303 100644
--- a/drivers/net/ksz884x.c
+++ b/drivers/net/ksz884x.c
@@ -1221,7 +1221,6 @@ struct ksz_port_info {
 #define LINK_INT_WORKING                (1 << 0)
 #define SMALL_PACKET_TX_BUG             (1 << 1)
 #define HALF_DUPLEX_SIGNAL_BUG          (1 << 2)
-#define IPV6_CSUM_GEN_HACK              (1 << 3)
 #define RX_HUGE_FRAME                   (1 << 4)
 #define STP_SUPPORT                     (1 << 8)
 
@@ -3748,7 +3747,6 @@ static int hw_init(struct ksz_hw *hw)
                 if (1 == rc)
                         hw->features |= HALF_DUPLEX_SIGNAL_BUG;
         }
-        hw->features |= IPV6_CSUM_GEN_HACK;
         return rc;
 }
 
@@ -4887,8 +4885,7 @@ static netdev_tx_t netdev_tx(struct sk_buff *skb, struct net_device *dev)
         left = hw_alloc_pkt(hw, skb->len, num);
         if (left) {
                 if (left < num ||
-                                ((hw->features & IPV6_CSUM_GEN_HACK) &&
-                                (CHECKSUM_PARTIAL == skb->ip_summed) &&
+                                ((CHECKSUM_PARTIAL == skb->ip_summed) &&
                                 (ETH_P_IPV6 == htons(skb->protocol)))) {
                         struct sk_buff *org_skb = skb;
 
@@ -6583,57 +6580,33 @@ static void netdev_get_ethtool_stats(struct net_device *dev,
 }
 
 /**
- * netdev_get_rx_csum - get receive checksum support
+ * netdev_set_features - set receive checksum support
  * @dev:        Network device.
- *
- * This function gets receive checksum support setting.
- *
- * Return true if receive checksum is enabled; false otherwise.
- */
-static u32 netdev_get_rx_csum(struct net_device *dev)
-{
-        struct dev_priv *priv = netdev_priv(dev);
-        struct dev_info *hw_priv = priv->adapter;
-        struct ksz_hw *hw = &hw_priv->hw;
-
-        return hw->rx_cfg &
-                (DMA_RX_CSUM_UDP |
-                DMA_RX_CSUM_TCP |
-                DMA_RX_CSUM_IP);
-}
-
-/**
- * netdev_set_rx_csum - set receive checksum support
- * @dev:        Network device.
- * @data:       Zero to disable receive checksum support.
+ * @features:   New device features (offloads).
  *
  * This function sets receive checksum support setting.
  *
  * Return 0 if successful; otherwise an error code.
  */
-static int netdev_set_rx_csum(struct net_device *dev, u32 data)
+static int netdev_set_features(struct net_device *dev, u32 features)
 {
         struct dev_priv *priv = netdev_priv(dev);
         struct dev_info *hw_priv = priv->adapter;
         struct ksz_hw *hw = &hw_priv->hw;
-        u32 new_setting = hw->rx_cfg;
 
-        if (data)
-                new_setting |=
-                        (DMA_RX_CSUM_UDP | DMA_RX_CSUM_TCP |
-                        DMA_RX_CSUM_IP);
-        else
-                new_setting &=
-                        ~(DMA_RX_CSUM_UDP | DMA_RX_CSUM_TCP |
-                        DMA_RX_CSUM_IP);
-        new_setting &= ~DMA_RX_CSUM_UDP;
         mutex_lock(&hw_priv->lock);
-        if (new_setting != hw->rx_cfg) {
-                hw->rx_cfg = new_setting;
-                if (hw->enabled)
-                        writel(hw->rx_cfg, hw->io + KS_DMA_RX_CTRL);
-        }
+
+        /* see note in hw_setup() */
+        if (features & NETIF_F_RXCSUM)
+                hw->rx_cfg |= DMA_RX_CSUM_TCP | DMA_RX_CSUM_IP;
+        else
+                hw->rx_cfg &= ~(DMA_RX_CSUM_TCP | DMA_RX_CSUM_IP);
+
+        if (hw->enabled)
+                writel(hw->rx_cfg, hw->io + KS_DMA_RX_CTRL);
+
         mutex_unlock(&hw_priv->lock);
+
         return 0;
 }
 
@@ -6658,12 +6631,6 @@ static struct ethtool_ops netdev_ethtool_ops = {
         .get_strings            = netdev_get_strings,
         .get_sset_count         = netdev_get_sset_count,
         .get_ethtool_stats      = netdev_get_ethtool_stats,
-        .get_rx_csum            = netdev_get_rx_csum,
-        .set_rx_csum            = netdev_set_rx_csum,
-        .get_tx_csum            = ethtool_op_get_tx_csum,
-        .set_tx_csum            = ethtool_op_set_tx_csum,
-        .get_sg                 = ethtool_op_get_sg,
-        .set_sg                 = ethtool_op_set_sg,
 };
 
 /*
@@ -6828,14 +6795,15 @@ static int __init netdev_init(struct net_device *dev)
         /* 500 ms timeout */
         dev->watchdog_timeo = HZ / 2;
 
-        dev->features |= NETIF_F_IP_CSUM;
+        dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_RXCSUM;
 
         /*
          * Hardware does not really support IPv6 checksum generation, but
-         * driver actually runs faster with this on.  Refer IPV6_CSUM_GEN_HACK.
+         * driver actually runs faster with this on.
          */
-        dev->features |= NETIF_F_IPV6_CSUM;
-        dev->features |= NETIF_F_SG;
+        dev->hw_features |= NETIF_F_IPV6_CSUM;
+
+        dev->features |= dev->hw_features;
 
         sema_init(&priv->proc_sem, 1);
 
@@ -6860,6 +6828,7 @@ static const struct net_device_ops netdev_ops = {
         .ndo_start_xmit         = netdev_tx,
         .ndo_tx_timeout         = netdev_tx_timeout,
         .ndo_change_mtu         = netdev_change_mtu,
+        .ndo_set_features       = netdev_set_features,
         .ndo_set_mac_address    = netdev_set_mac_address,
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_do_ioctl           = netdev_ioctl,
diff --git a/drivers/net/macb.c b/drivers/net/macb.c
index 79ccb54ab00c..2cb4e792f871 100644
--- a/drivers/net/macb.c
+++ b/drivers/net/macb.c
@@ -1171,8 +1171,7 @@ static int __init macb_probe(struct platform_device *pdev)
         }
 
         dev->irq = platform_get_irq(pdev, 0);
-        err = request_irq(dev->irq, macb_interrupt, IRQF_SAMPLE_RANDOM,
-                          dev->name, dev);
+        err = request_irq(dev->irq, macb_interrupt, 0, dev->name, dev);
         if (err) {
                 printk(KERN_ERR
                        "%s: Unable to request IRQ %d (error %d)\n",
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index 679dc8519c5b..77220687b92a 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -1177,7 +1177,7 @@ struct netxen_adapter {
         u8 max_sds_rings;
         u8 driver_mismatch;
         u8 msix_supported;
-        u8 rx_csum;
+        u8 __pad;
         u8 pci_using_dac;
         u8 portnum;
         u8 physical_port;
diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
index 3bdcc803ec68..29f90baaa79b 100644
--- a/drivers/net/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/netxen/netxen_nic_ethtool.c
@@ -676,62 +676,6 @@ netxen_nic_get_ethtool_stats(struct net_device *dev,
         }
 }
 
-static u32 netxen_nic_get_tx_csum(struct net_device *dev)
-{
-        return dev->features & NETIF_F_IP_CSUM;
-}
-
-static u32 netxen_nic_get_rx_csum(struct net_device *dev)
-{
-        struct netxen_adapter *adapter = netdev_priv(dev);
-        return adapter->rx_csum;
-}
-
-static int netxen_nic_set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct netxen_adapter *adapter = netdev_priv(dev);
-
-        if (data) {
-                adapter->rx_csum = data;
-                return 0;
-        }
-
-        if (dev->features & NETIF_F_LRO) {
-                if (netxen_config_hw_lro(adapter, NETXEN_NIC_LRO_DISABLED))
-                        return -EIO;
-
-                dev->features &= ~NETIF_F_LRO;
-                netxen_send_lro_cleanup(adapter);
-                netdev_info(dev, "disabling LRO as rx_csum is off\n");
-        }
-        adapter->rx_csum = data;
-        return 0;
-}
-
-static u32 netxen_nic_get_tso(struct net_device *dev)
-{
-        struct netxen_adapter *adapter = netdev_priv(dev);
-
-        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
-                return (dev->features & (NETIF_F_TSO | NETIF_F_TSO6)) != 0;
-
-        return (dev->features & NETIF_F_TSO) != 0;
-}
-
-static int netxen_nic_set_tso(struct net_device *dev, u32 data)
-{
-        if (data) {
-                struct netxen_adapter *adapter = netdev_priv(dev);
-
-                dev->features |= NETIF_F_TSO;
-                if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
-                        dev->features |= NETIF_F_TSO6;
-        } else
-                dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
-
-        return 0;
-}
-
 static void
 netxen_nic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
 {
@@ -866,43 +810,6 @@ static int netxen_get_intr_coalesce(struct net_device *netdev,
         return 0;
 }
 
-static int netxen_nic_set_flags(struct net_device *netdev, u32 data)
-{
-        struct netxen_adapter *adapter = netdev_priv(netdev);
-        int hw_lro;
-
-        if (ethtool_invalid_flags(netdev, data, ETH_FLAG_LRO))
-                return -EINVAL;
-
-        if (!(adapter->capabilities & NX_FW_CAPABILITY_HW_LRO))
-                return -EINVAL;
-
-        if (!adapter->rx_csum) {
-                netdev_info(netdev, "rx csum is off, cannot toggle LRO\n");
-                return -EINVAL;
-        }
-
-        if (!!(data & ETH_FLAG_LRO) == !!(netdev->features & NETIF_F_LRO))
-                return 0;
-
-        if (data & ETH_FLAG_LRO) {
-                hw_lro = NETXEN_NIC_LRO_ENABLED;
-                netdev->features |= NETIF_F_LRO;
-        } else {
-                hw_lro = NETXEN_NIC_LRO_DISABLED;
-                netdev->features &= ~NETIF_F_LRO;
-        }
-
-        if (netxen_config_hw_lro(adapter, hw_lro))
-                return -EIO;
-
-        if ((hw_lro == 0) && netxen_send_lro_cleanup(adapter))
-                return -EIO;
-
-
-        return 0;
-}
-
 const struct ethtool_ops netxen_nic_ethtool_ops = {
         .get_settings = netxen_nic_get_settings,
         .set_settings = netxen_nic_set_settings,
@@ -916,21 +823,12 @@ const struct ethtool_ops netxen_nic_ethtool_ops = {
         .set_ringparam = netxen_nic_set_ringparam,
         .get_pauseparam = netxen_nic_get_pauseparam,
         .set_pauseparam = netxen_nic_set_pauseparam,
-        .get_tx_csum = netxen_nic_get_tx_csum,
-        .set_tx_csum = ethtool_op_set_tx_csum,
-        .set_sg = ethtool_op_set_sg,
-        .get_tso = netxen_nic_get_tso,
-        .set_tso = netxen_nic_set_tso,
         .get_wol = netxen_nic_get_wol,
         .set_wol = netxen_nic_set_wol,
         .self_test = netxen_nic_diag_test,
         .get_strings = netxen_nic_get_strings,
         .get_ethtool_stats = netxen_nic_get_ethtool_stats,
         .get_sset_count = netxen_get_sset_count,
-        .get_rx_csum = netxen_nic_get_rx_csum,
-        .set_rx_csum = netxen_nic_set_rx_csum,
         .get_coalesce = netxen_get_intr_coalesce,
         .set_coalesce = netxen_set_intr_coalesce,
-        .get_flags = ethtool_op_get_flags,
-        .set_flags = netxen_nic_set_flags,
 };
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index 731077d8d962..7f999671c7b2 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -1483,7 +1483,8 @@ static struct sk_buff *netxen_process_rxbuf(struct netxen_adapter *adapter,
         if (!skb)
                 goto no_skb;
 
-        if (likely(adapter->rx_csum && cksum == STATUS_CKSUM_OK)) {
+        if (likely((adapter->netdev->features & NETIF_F_RXCSUM)
+            && cksum == STATUS_CKSUM_OK)) {
                 adapter->stats.csummed++;
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
         } else
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index e8a4b6655999..b644383017f9 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -485,6 +485,37 @@ static void netxen_set_multicast_list(struct net_device *dev)
         adapter->set_multi(dev);
 }
 
+static u32 netxen_fix_features(struct net_device *dev, u32 features)
+{
+        if (!(features & NETIF_F_RXCSUM)) {
+                netdev_info(dev, "disabling LRO as RXCSUM is off\n");
+
+                features &= ~NETIF_F_LRO;
+        }
+
+        return features;
+}
+
+static int netxen_set_features(struct net_device *dev, u32 features)
+{
+        struct netxen_adapter *adapter = netdev_priv(dev);
+        int hw_lro;
+
+        if (!((dev->features ^ features) & NETIF_F_LRO))
+                return 0;
+
+        hw_lro = (features & NETIF_F_LRO) ? NETXEN_NIC_LRO_ENABLED
+                 : NETXEN_NIC_LRO_DISABLED;
+
+        if (netxen_config_hw_lro(adapter, hw_lro))
+                return -EIO;
+
+        if (!(features & NETIF_F_LRO) && netxen_send_lro_cleanup(adapter))
+                return -EIO;
+
+        return 0;
+}
+
 static const struct net_device_ops netxen_netdev_ops = {
         .ndo_open          = netxen_nic_open,
         .ndo_stop          = netxen_nic_close,
@@ -495,6 +526,8 @@ static const struct net_device_ops netxen_netdev_ops = {
         .ndo_set_mac_address    = netxen_nic_set_mac,
         .ndo_change_mtu    = netxen_nic_change_mtu,
         .ndo_tx_timeout    = netxen_tx_timeout,
+        .ndo_fix_features = netxen_fix_features,
+        .ndo_set_features = netxen_set_features,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller = netxen_nic_poll_controller,
 #endif
@@ -905,7 +938,7 @@ netxen_nic_request_irq(struct netxen_adapter *adapter)
         struct nx_host_sds_ring *sds_ring;
         int err, ring;
 
-        unsigned long flags = IRQF_SAMPLE_RANDOM;
+        unsigned long flags = 0;
         struct net_device *netdev = adapter->netdev;
         struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
@@ -1196,7 +1229,6 @@ netxen_setup_netdev(struct netxen_adapter *adapter,
         int err = 0;
         struct pci_dev *pdev = adapter->pdev;
 
-        adapter->rx_csum = 1;
         adapter->mc_enabled = 0;
         if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
                 adapter->max_mc_count = 38;
@@ -1210,14 +1242,13 @@ netxen_setup_netdev(struct netxen_adapter *adapter,
 
         SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
 
-        netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
-        netdev->features |= (NETIF_F_GRO);
-        netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
+        netdev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO |
+                              NETIF_F_RXCSUM;
 
-        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
-                netdev->features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
-                netdev->vlan_features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
-        }
+        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
+                netdev->hw_features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6;
+
+        netdev->vlan_features |= netdev->hw_features;
 
         if (adapter->pci_using_dac) {
                 netdev->features |= NETIF_F_HIGHDMA;
@@ -1225,10 +1256,12 @@ netxen_setup_netdev(struct netxen_adapter *adapter,
         }
 
         if (adapter->capabilities & NX_FW_CAPABILITY_FVLANTX)
-                netdev->features |= (NETIF_F_HW_VLAN_TX);
+                netdev->hw_features |= NETIF_F_HW_VLAN_TX;
 
         if (adapter->capabilities & NX_FW_CAPABILITY_HW_LRO)
-                netdev->features |= NETIF_F_LRO;
+                netdev->hw_features |= NETIF_F_LRO;
+
+        netdev->features |= netdev->hw_features;
 
         netdev->irq = adapter->msix_entries[0].vector;
 
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index 32678b6c6b39..9e6330bc0531 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -6071,8 +6071,7 @@ static int niu_request_irq(struct niu *np)
         for (i = 0; i < np->num_ldg; i++) {
                 struct niu_ldg *lp = &np->ldg[i];
 
-                err = request_irq(lp->irq, niu_interrupt,
-                                  IRQF_SHARED | IRQF_SAMPLE_RANDOM,
+                err = request_irq(lp->irq, niu_interrupt, IRQF_SHARED,
                                   np->irq_name[i], lp);
                 if (err)
                         goto out_free_irqs;
@@ -7023,6 +7022,7 @@ static int niu_ethflow_to_class(int flow_type, u64 *class)
         case UDP_V4_FLOW:
                 *class = CLASS_CODE_UDP_IPV4;
                 break;
+        case AH_ESP_V4_FLOW:
         case AH_V4_FLOW:
         case ESP_V4_FLOW:
                 *class = CLASS_CODE_AH_ESP_IPV4;
@@ -7036,6 +7036,7 @@ static int niu_ethflow_to_class(int flow_type, u64 *class)
         case UDP_V6_FLOW:
                 *class = CLASS_CODE_UDP_IPV6;
                 break;
+        case AH_ESP_V6_FLOW:
         case AH_V6_FLOW:
         case ESP_V6_FLOW:
                 *class = CLASS_CODE_AH_ESP_IPV6;
@@ -7889,28 +7890,31 @@ static void niu_force_led(struct niu *np, int on)
         nw64_mac(reg, val);
 }
 
-static int niu_phys_id(struct net_device *dev, u32 data)
+static int niu_set_phys_id(struct net_device *dev,
+                           enum ethtool_phys_id_state state)
+
 {
         struct niu *np = netdev_priv(dev);
-        u64 orig_led_state;
-        int i;
 
         if (!netif_running(dev))
                 return -EAGAIN;
 
-        if (data == 0)
-                data = 2;
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                np->orig_led_state = niu_led_state_save(np);
+                return -EINVAL;
 
-        orig_led_state = niu_led_state_save(np);
-        for (i = 0; i < (data * 2); i++) {
-                int on = ((i % 2) == 0);
+        case ETHTOOL_ID_ON:
+                niu_force_led(np, 1);
+                break;
 
-                niu_force_led(np, on);
+        case ETHTOOL_ID_OFF:
+                niu_force_led(np, 0);
+                break;
 
-                if (msleep_interruptible(500))
-                        break;
+        case ETHTOOL_ID_INACTIVE:
+                niu_led_state_restore(np, np->orig_led_state);
         }
-        niu_led_state_restore(np, orig_led_state);
 
         return 0;
 }
@@ -7933,7 +7937,7 @@ static const struct ethtool_ops niu_ethtool_ops = {
         .get_strings            = niu_get_strings,
         .get_sset_count         = niu_get_sset_count,
         .get_ethtool_stats      = niu_get_ethtool_stats,
-        .phys_id                = niu_phys_id,
+        .set_phys_id            = niu_set_phys_id,
         .get_rxnfc              = niu_get_nfc,
         .set_rxnfc              = niu_set_nfc,
         .set_flags              = niu_set_flags,
diff --git a/drivers/net/niu.h b/drivers/net/niu.h
index a41fa8ebe05f..51e177e1860d 100644
--- a/drivers/net/niu.h
+++ b/drivers/net/niu.h
@@ -3279,6 +3279,7 @@ struct niu {
         unsigned long                   xpcs_off;
 
         struct timer_list               timer;
+        u64                             orig_led_state;
         const struct niu_phy_ops        *phy_ops;
         int                             phy_addr;
 
diff --git a/drivers/net/pcnet32.c b/drivers/net/pcnet32.c
index 768037602dff..e89afb929740 100644
--- a/drivers/net/pcnet32.c
+++ b/drivers/net/pcnet32.c
@@ -295,12 +295,14 @@ struct pcnet32_private {
         struct net_device       *next;
         struct mii_if_info      mii_if;
         struct timer_list       watchdog_timer;
-        struct timer_list       blink_timer;
         u32                     msg_enable;     /* debug message level */
 
         /* each bit indicates an available PHY */
         u32                     phymask;
         unsigned short          chip_version;   /* which variant this is */
+
+        /* saved registers during ethtool blink */
+        u16                     save_regs[4];
 };
 
 static int pcnet32_probe_pci(struct pci_dev *, const struct pci_device_id *);
@@ -324,8 +326,6 @@ static void pcnet32_restart(struct net_device *dev, unsigned int csr0_bits);
 static void pcnet32_ethtool_test(struct net_device *dev,
                                  struct ethtool_test *eth_test, u64 * data);
 static int pcnet32_loopback_test(struct net_device *dev, uint64_t * data1);
-static int pcnet32_phys_id(struct net_device *dev, u32 data);
-static void pcnet32_led_blink_callback(struct net_device *dev);
 static int pcnet32_get_regs_len(struct net_device *dev);
 static void pcnet32_get_regs(struct net_device *dev, struct ethtool_regs *regs,
                              void *ptr);
@@ -1022,7 +1022,8 @@ clean_up:
         return rc;
 }                               /* end pcnet32_loopback_test  */
 
-static void pcnet32_led_blink_callback(struct net_device *dev)
+static int pcnet32_set_phys_id(struct net_device *dev,
+                               enum ethtool_phys_id_state state)
 {
         struct pcnet32_private *lp = netdev_priv(dev);
         struct pcnet32_access *a = &lp->a;
@@ -1030,50 +1031,31 @@ static void pcnet32_led_blink_callback(struct net_device *dev)
         unsigned long flags;
         int i;
 
-        spin_lock_irqsave(&lp->lock, flags);
-        for (i = 4; i < 8; i++)
-                a->write_bcr(ioaddr, i, a->read_bcr(ioaddr, i) ^ 0x4000);
-        spin_unlock_irqrestore(&lp->lock, flags);
-
-        mod_timer(&lp->blink_timer, PCNET32_BLINK_TIMEOUT);
-}
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                /* Save the current value of the bcrs */
+                spin_lock_irqsave(&lp->lock, flags);
+                for (i = 4; i < 8; i++)
+                        lp->save_regs[i - 4] = a->read_bcr(ioaddr, i);
+                spin_unlock_irqrestore(&lp->lock, flags);
+                return -EINVAL;
 
-static int pcnet32_phys_id(struct net_device *dev, u32 data)
-{
-        struct pcnet32_private *lp = netdev_priv(dev);
-        struct pcnet32_access *a = &lp->a;
-        ulong ioaddr = dev->base_addr;
-        unsigned long flags;
-        int i, regs[4];
+        case ETHTOOL_ID_ON:
+        case ETHTOOL_ID_OFF:
+                /* Blink the led */
+                spin_lock_irqsave(&lp->lock, flags);
+                for (i = 4; i < 8; i++)
+                        a->write_bcr(ioaddr, i, a->read_bcr(ioaddr, i) ^ 0x4000);
+                spin_unlock_irqrestore(&lp->lock, flags);
+                break;
 
-        if (!lp->blink_timer.function) {
-                init_timer(&lp->blink_timer);
-                lp->blink_timer.function = (void *)pcnet32_led_blink_callback;
-                lp->blink_timer.data = (unsigned long)dev;
+        case ETHTOOL_ID_INACTIVE:
+                /* Restore the original value of the bcrs */
+                spin_lock_irqsave(&lp->lock, flags);
+                for (i = 4; i < 8; i++)
+                        a->write_bcr(ioaddr, i, lp->save_regs[i - 4]);
+                spin_unlock_irqrestore(&lp->lock, flags);
         }
-
-        /* Save the current value of the bcrs */
-        spin_lock_irqsave(&lp->lock, flags);
-        for (i = 4; i < 8; i++)
-                regs[i - 4] = a->read_bcr(ioaddr, i);
-        spin_unlock_irqrestore(&lp->lock, flags);
-
-        mod_timer(&lp->blink_timer, jiffies);
-        set_current_state(TASK_INTERRUPTIBLE);
-
-        /* AV: the limit here makes no sense whatsoever */
-        if ((!data) || (data > (u32) (MAX_SCHEDULE_TIMEOUT / HZ)))
-                data = (u32) (MAX_SCHEDULE_TIMEOUT / HZ);
-
-        msleep_interruptible(data * 1000);
-        del_timer_sync(&lp->blink_timer);
-
-        /* Restore the original value of the bcrs */
-        spin_lock_irqsave(&lp->lock, flags);
-        for (i = 4; i < 8; i++)
-                a->write_bcr(ioaddr, i, regs[i - 4]);
-        spin_unlock_irqrestore(&lp->lock, flags);
-
         return 0;
 }
 
@@ -1450,7 +1432,7 @@ static const struct ethtool_ops pcnet32_ethtool_ops = {
         .set_ringparam          = pcnet32_set_ringparam,
         .get_strings            = pcnet32_get_strings,
         .self_test              = pcnet32_ethtool_test,
-        .phys_id                = pcnet32_phys_id,
+        .set_phys_id            = pcnet32_set_phys_id,
         .get_regs_len           = pcnet32_get_regs_len,
         .get_regs               = pcnet32_get_regs,
         .get_sset_count         = pcnet32_get_sset_count,
diff --git a/drivers/net/qla3xxx.c b/drivers/net/qla3xxx.c
index 348b4f1367c9..f3f737b91248 100644
--- a/drivers/net/qla3xxx.c
+++ b/drivers/net/qla3xxx.c
@@ -3468,7 +3468,7 @@ static int ql_adapter_up(struct ql3_adapter *qdev)
 {
         struct net_device *ndev = qdev->ndev;
         int err;
-        unsigned long irq_flags = IRQF_SAMPLE_RANDOM | IRQF_SHARED;
+        unsigned long irq_flags = IRQF_SHARED;
         unsigned long hw_flags;
 
         if (ql_alloc_mem_resources(qdev)) {
diff --git a/drivers/net/qlcnic/qlcnic.h b/drivers/net/qlcnic/qlcnic.h
index dc44564ef6f9..b6e0fc33585f 100644
--- a/drivers/net/qlcnic/qlcnic.h
+++ b/drivers/net/qlcnic/qlcnic.h
@@ -29,13 +29,15 @@
 
 #include <linux/io.h>
 #include <asm/byteorder.h>
+#include <linux/bitops.h>
+#include <linux/if_vlan.h>
 
 #include "qlcnic_hdr.h"
 
 #define _QLCNIC_LINUX_MAJOR 5
 #define _QLCNIC_LINUX_MINOR 0
-#define _QLCNIC_LINUX_SUBVERSION 15
-#define QLCNIC_LINUX_VERSIONID  "5.0.15"
+#define _QLCNIC_LINUX_SUBVERSION 16
+#define QLCNIC_LINUX_VERSIONID  "5.0.16"
 #define QLCNIC_DRV_IDC_VER  0x01
 #define QLCNIC_DRIVER_VERSION  ((_QLCNIC_LINUX_MAJOR << 16) |\
                  (_QLCNIC_LINUX_MINOR << 8) | (_QLCNIC_LINUX_SUBVERSION))
@@ -93,8 +95,6 @@
 #define TX_IP_PKT       0x04
 #define TX_TCP_LSO      0x05
 #define TX_TCP_LSO6     0x06
-#define TX_IPSEC        0x07
-#define TX_IPSEC_CMD    0x0a
 #define TX_TCPV6_PKT    0x0b
 #define TX_UDPV6_PKT    0x0c
 
@@ -200,7 +200,7 @@ struct rcv_desc {
         __le16 reserved;
         __le32 buffer_length;   /* allocated buffer length (usually 2K) */
         __le64 addr_buffer;
-};
+} __packed;
 
 /* opcode field in status_desc */
 #define QLCNIC_SYN_OFFLOAD      0x03
@@ -292,6 +292,7 @@ struct uni_data_desc{
 /* Flash Defines and Structures */
 #define QLCNIC_FLT_LOCATION     0x3F1000
 #define QLCNIC_FW_IMAGE_REGION  0x74
+#define QLCNIC_BOOTLD_REGION    0X72
 struct qlcnic_flt_header {
         u16 version;
         u16 len;
@@ -306,7 +307,7 @@ struct qlcnic_flt_entry {
         u8 reserved1;
         u32 size;
         u32 start_addr;
-        u32 end_add;
+        u32 end_addr;
 };
 
 /* Magic number to let user know flash is programmed */
@@ -365,12 +366,6 @@ struct qlcnic_skb_frag {
         u64 length;
 };
 
-struct qlcnic_recv_crb {
-        u32 crb_rcv_producer[NUM_RCV_DESC_RINGS];
-        u32 crb_sts_consumer[NUM_STS_DESC_RINGS];
-        u32 sw_int_mask[NUM_STS_DESC_RINGS];
-};
-
 /*    Following defines are for the state of the buffers    */
 #define QLCNIC_BUFFER_FREE      0
 #define QLCNIC_BUFFER_BUSY      1
@@ -387,10 +382,10 @@ struct qlcnic_cmd_buffer {
 
 /* In rx_buffer, we do not need multiple fragments as is a single buffer */
 struct qlcnic_rx_buffer {
-        struct list_head list;
+        u16 ref_handle;
         struct sk_buff *skb;
+        struct list_head list;
         u64 dma;
-        u16 ref_handle;
 };
 
 /* Board types */
@@ -398,6 +393,25 @@ struct qlcnic_rx_buffer {
 #define QLCNIC_XGBE     0x02
 
 /*
+ * Interrupt coalescing defaults. The defaults are for 1500 MTU. It is
+ * adjusted based on configured MTU.
+ */
+#define QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US 3
+#define QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS 256
+
+#define QLCNIC_INTR_DEFAULT                     0x04
+#define QLCNIC_CONFIG_INTR_COALESCE             3
+
+struct qlcnic_nic_intr_coalesce {
+        u8      type;
+        u8      sts_ring_mask;
+        u16     rx_packets;
+        u16     rx_time_us;
+        u16     flag;
+        u32     timer_out;
+};
+
+/*
  * One hardware_context{} per adapter
  * contains interrupt info as well shared hardware info.
  */
@@ -415,6 +429,8 @@ struct qlcnic_hardware_context {
         u8 linkup;
         u16 port_type;
         u16 board_type;
+
+        struct qlcnic_nic_intr_coalesce coal;
 };
 
 struct qlcnic_adapter_stats {
@@ -442,50 +458,49 @@ struct qlcnic_adapter_stats {
  * be one Rcv Descriptor for normal packets, one for jumbo and may be others.
  */
 struct qlcnic_host_rds_ring {
-        u32 producer;
+        void __iomem *crb_rcv_producer;
+        struct rcv_desc *desc_head;
+        struct qlcnic_rx_buffer *rx_buf_arr;
         u32 num_desc;
+        u32 producer;
         u32 dma_size;
         u32 skb_size;
         u32 flags;
-        void __iomem *crb_rcv_producer;
-        struct rcv_desc *desc_head;
-        struct qlcnic_rx_buffer *rx_buf_arr;
         struct list_head free_list;
         spinlock_t lock;
         dma_addr_t phys_addr;
-};
+} ____cacheline_internodealigned_in_smp;
 
 struct qlcnic_host_sds_ring {
         u32 consumer;
         u32 num_desc;
         void __iomem *crb_sts_consumer;
-        void __iomem *crb_intr_mask;
 
         struct status_desc *desc_head;
         struct qlcnic_adapter *adapter;
         struct napi_struct napi;
         struct list_head free_list[NUM_RCV_DESC_RINGS];
 
+        void __iomem *crb_intr_mask;
         int irq;
 
         dma_addr_t phys_addr;
         char name[IFNAMSIZ+4];
-};
+} ____cacheline_internodealigned_in_smp;
 
 struct qlcnic_host_tx_ring {
         u32 producer;
-        __le32 *hw_consumer;
         u32 sw_consumer;
-        void __iomem *crb_cmd_producer;
         u32 num_desc;
-
-        struct netdev_queue *txq;
-
-        struct qlcnic_cmd_buffer *cmd_buf_arr;
+        void __iomem *crb_cmd_producer;
         struct cmd_desc_type0 *desc_head;
+        struct qlcnic_cmd_buffer *cmd_buf_arr;
+        __le32 *hw_consumer;
+
         dma_addr_t phys_addr;
         dma_addr_t hw_cons_phys_addr;
-};
+        struct netdev_queue *txq;
+} ____cacheline_internodealigned_in_smp;
 
 /*
  * Receive context. There is one such structure per instance of the
@@ -494,12 +509,12 @@ struct qlcnic_host_tx_ring {
  * present elsewhere.
  */
 struct qlcnic_recv_context {
+        struct qlcnic_host_rds_ring *rds_rings;
+        struct qlcnic_host_sds_ring *sds_rings;
         u32 state;
         u16 context_id;
         u16 virt_port;
 
-        struct qlcnic_host_rds_ring *rds_rings;
-        struct qlcnic_host_sds_ring *sds_rings;
 };
 
 /* HW context creation */
@@ -538,9 +553,6 @@ struct qlcnic_recv_context {
 #define QLCNIC_CDRP_CMD_DESTROY_RX_CTX          0x00000008
 #define QLCNIC_CDRP_CMD_CREATE_TX_CTX           0x00000009
 #define QLCNIC_CDRP_CMD_DESTROY_TX_CTX          0x0000000a
-#define QLCNIC_CDRP_CMD_SETUP_STATISTICS        0x0000000e
-#define QLCNIC_CDRP_CMD_GET_STATISTICS          0x0000000f
-#define QLCNIC_CDRP_CMD_DELETE_STATISTICS       0x00000010
 #define QLCNIC_CDRP_CMD_SET_MTU                 0x00000012
 #define QLCNIC_CDRP_CMD_READ_PHY                0x00000013
 #define QLCNIC_CDRP_CMD_WRITE_PHY               0x00000014
@@ -549,17 +561,11 @@ struct qlcnic_recv_context {
 #define QLCNIC_CDRP_CMD_SET_FLOW_CTL            0x00000017
 #define QLCNIC_CDRP_CMD_READ_MAX_MTU            0x00000018
 #define QLCNIC_CDRP_CMD_READ_MAX_LRO            0x00000019
-#define QLCNIC_CDRP_CMD_CONFIGURE_TOE           0x0000001a
-#define QLCNIC_CDRP_CMD_FUNC_ATTRIB             0x0000001b
-#define QLCNIC_CDRP_CMD_READ_PEXQ_PARAMETERS    0x0000001c
-#define QLCNIC_CDRP_CMD_GET_LIC_CAPABILITIES    0x0000001d
-#define QLCNIC_CDRP_CMD_READ_MAX_LRO_PER_BOARD  0x0000001e
 #define QLCNIC_CDRP_CMD_MAC_ADDRESS             0x0000001f
 
 #define QLCNIC_CDRP_CMD_GET_PCI_INFO            0x00000020
 #define QLCNIC_CDRP_CMD_GET_NIC_INFO            0x00000021
 #define QLCNIC_CDRP_CMD_SET_NIC_INFO            0x00000022
-#define QLCNIC_CDRP_CMD_RESET_NPAR              0x00000023
 #define QLCNIC_CDRP_CMD_GET_ESWITCH_CAPABILITY  0x00000024
 #define QLCNIC_CDRP_CMD_TOGGLE_ESWITCH          0x00000025
 #define QLCNIC_CDRP_CMD_GET_ESWITCH_STATUS      0x00000026
@@ -597,14 +603,14 @@ struct qlcnic_hostrq_sds_ring {
         __le32 ring_size;               /* Ring entries */
         __le16 msi_index;
         __le16 rsvd;            /* Padding */
-};
+} __packed;
 
 struct qlcnic_hostrq_rds_ring {
         __le64 host_phys_addr;  /* Ring base addr */
         __le64 buff_size;               /* Packet buffer size */
         __le32 ring_size;               /* Ring entries */
         __le32 ring_kind;               /* Class of ring */
-};
+} __packed;
 
 struct qlcnic_hostrq_rx_ctx {
         __le64 host_rsp_dma_addr;       /* Response dma'd here */
@@ -625,17 +631,17 @@ struct qlcnic_hostrq_rx_ctx {
            - N hostrq_rds_rings
            - N hostrq_sds_rings */
         char data[0];
-};
+} __packed;
 
 struct qlcnic_cardrsp_rds_ring{
         __le32 host_producer_crb;       /* Crb to use */
         __le32 rsvd1;           /* Padding */
-};
+} __packed;
 
 struct qlcnic_cardrsp_sds_ring {
         __le32 host_consumer_crb;       /* Crb to use */
         __le32 interrupt_crb;   /* Crb to use */
-};
+} __packed;
 
 struct qlcnic_cardrsp_rx_ctx {
         /* These ring offsets are relative to data[0] below */
@@ -654,7 +660,7 @@ struct qlcnic_cardrsp_rx_ctx {
            - N cardrsp_rds_rings
            - N cardrs_sds_rings */
         char data[0];
-};
+} __packed;
 
 #define SIZEOF_HOSTRQ_RX(HOSTRQ_RX, rds_rings, sds_rings)       \
         (sizeof(HOSTRQ_RX) +                                    \
@@ -674,7 +680,7 @@ struct qlcnic_hostrq_cds_ring {
         __le64 host_phys_addr;  /* Ring base addr */
         __le32 ring_size;               /* Ring entries */
         __le32 rsvd;            /* Padding */
-};
+} __packed;
 
 struct qlcnic_hostrq_tx_ctx {
         __le64 host_rsp_dma_addr;       /* Response dma'd here */
@@ -689,12 +695,12 @@ struct qlcnic_hostrq_tx_ctx {
         __le16 rsvd3;           /* Padding */
         struct qlcnic_hostrq_cds_ring cds_ring; /* Desc of cds ring */
         u8  reserved[128];      /* future expansion */
-};
+} __packed;
 
 struct qlcnic_cardrsp_cds_ring {
         __le32 host_producer_crb;       /* Crb to use */
         __le32 interrupt_crb;   /* Crb to use */
-};
+} __packed;
 
 struct qlcnic_cardrsp_tx_ctx {
         __le32 host_ctx_state;  /* Starting state */
@@ -703,7 +709,7 @@ struct qlcnic_cardrsp_tx_ctx {
         u8  virt_port;          /* Virtual/Logical id of port */
         struct qlcnic_cardrsp_cds_ring cds_ring;        /* Card cds settings */
         u8  reserved[128];      /* future expansion */
-};
+} __packed;
 
 #define SIZEOF_HOSTRQ_TX(HOSTRQ_TX)     (sizeof(HOSTRQ_TX))
 #define SIZEOF_CARDRSP_TX(CARDRSP_TX)   (sizeof(CARDRSP_TX))
@@ -737,40 +743,6 @@ struct qlcnic_mac_list_s {
         uint8_t mac_addr[ETH_ALEN+2];
 };
 
-/*
- * Interrupt coalescing defaults. The defaults are for 1500 MTU. It is
- * adjusted based on configured MTU.
- */
-#define QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US 3
-#define QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS 256
-#define QLCNIC_DEFAULT_INTR_COALESCE_TX_PACKETS 64
-#define QLCNIC_DEFAULT_INTR_COALESCE_TX_TIME_US 4
-
-#define QLCNIC_INTR_DEFAULT                     0x04
-
-union qlcnic_nic_intr_coalesce_data {
-        struct {
-                u16     rx_packets;
-                u16     rx_time_us;
-                u16     tx_packets;
-                u16     tx_time_us;
-        } data;
-        u64             word;
-};
-
-struct qlcnic_nic_intr_coalesce {
-        u16             stats_time_us;
-        u16             rate_sample_time;
-        u16             flags;
-        u16             rsvd_1;
-        u32             low_threshold;
-        u32             high_threshold;
-        union qlcnic_nic_intr_coalesce_data     normal;
-        union qlcnic_nic_intr_coalesce_data     low;
-        union qlcnic_nic_intr_coalesce_data     high;
-        union qlcnic_nic_intr_coalesce_data     irq;
-};
-
 #define QLCNIC_HOST_REQUEST     0x13
 #define QLCNIC_REQUEST          0x14
 
@@ -782,50 +754,20 @@ struct qlcnic_nic_intr_coalesce {
 /*
  * Driver --> Firmware
  */
-#define QLCNIC_H2C_OPCODE_START                         0
-#define QLCNIC_H2C_OPCODE_CONFIG_RSS                    1
-#define QLCNIC_H2C_OPCODE_CONFIG_RSS_TBL                2
-#define QLCNIC_H2C_OPCODE_CONFIG_INTR_COALESCE          3
-#define QLCNIC_H2C_OPCODE_CONFIG_LED                    4
-#define QLCNIC_H2C_OPCODE_CONFIG_PROMISCUOUS            5
-#define QLCNIC_H2C_OPCODE_CONFIG_L2_MAC                 6
-#define QLCNIC_H2C_OPCODE_LRO_REQUEST                   7
-#define QLCNIC_H2C_OPCODE_GET_SNMP_STATS                8
-#define QLCNIC_H2C_OPCODE_PROXY_START_REQUEST           9
-#define QLCNIC_H2C_OPCODE_PROXY_STOP_REQUEST            10
-#define QLCNIC_H2C_OPCODE_PROXY_SET_MTU                 11
-#define QLCNIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE     12
-#define QLCNIC_H2C_OPCODE_GET_FINGER_PRINT_REQUEST      13
-#define QLCNIC_H2C_OPCODE_INSTALL_LICENSE_REQUEST       14
-#define QLCNIC_H2C_OPCODE_GET_LICENSE_CAPABILITY_REQUEST        15
-#define QLCNIC_H2C_OPCODE_GET_NET_STATS                 16
-#define QLCNIC_H2C_OPCODE_PROXY_UPDATE_P2V              17
-#define QLCNIC_H2C_OPCODE_CONFIG_IPADDR                 18
-#define QLCNIC_H2C_OPCODE_PROXY_STOP_DONE               20
-#define QLCNIC_H2C_OPCODE_GET_LINKEVENT                 21
-#define QLCNIC_C2C_OPCODE                               22
-#define QLCNIC_H2C_OPCODE_CONFIG_BRIDGING               23
-#define QLCNIC_H2C_OPCODE_CONFIG_HW_LRO                 24
-#define QLCNIC_H2C_OPCODE_LAST                          25
+#define QLCNIC_H2C_OPCODE_CONFIG_RSS                    0x1
+#define QLCNIC_H2C_OPCODE_CONFIG_INTR_COALESCE          0x3
+#define QLCNIC_H2C_OPCODE_CONFIG_LED                    0x4
+#define QLCNIC_H2C_OPCODE_LRO_REQUEST                   0x7
+#define QLCNIC_H2C_OPCODE_SET_MAC_RECEIVE_MODE          0xc
+#define QLCNIC_H2C_OPCODE_CONFIG_IPADDR         0x12
+#define QLCNIC_H2C_OPCODE_GET_LINKEVENT         0x15
+#define QLCNIC_H2C_OPCODE_CONFIG_BRIDGING               0x17
+#define QLCNIC_H2C_OPCODE_CONFIG_HW_LRO         0x18
 /*
  * Firmware --> Driver
  */
 
-#define QLCNIC_C2H_OPCODE_START                         128
-#define QLCNIC_C2H_OPCODE_CONFIG_RSS_RESPONSE           129
-#define QLCNIC_C2H_OPCODE_CONFIG_RSS_TBL_RESPONSE       130
-#define QLCNIC_C2H_OPCODE_CONFIG_MAC_RESPONSE           131
-#define QLCNIC_C2H_OPCODE_CONFIG_PROMISCUOUS_RESPONSE   132
-#define QLCNIC_C2H_OPCODE_CONFIG_L2_MAC_RESPONSE        133
-#define QLCNIC_C2H_OPCODE_LRO_DELETE_RESPONSE           134
-#define QLCNIC_C2H_OPCODE_LRO_ADD_FAILURE_RESPONSE      135
-#define QLCNIC_C2H_OPCODE_GET_SNMP_STATS                136
-#define QLCNIC_C2H_OPCODE_GET_FINGER_PRINT_REPLY        137
-#define QLCNIC_C2H_OPCODE_INSTALL_LICENSE_REPLY         138
-#define QLCNIC_C2H_OPCODE_GET_LICENSE_CAPABILITIES_REPLY 139
-#define QLCNIC_C2H_OPCODE_GET_NET_STATS_RESPONSE        140
 #define QLCNIC_C2H_OPCODE_GET_LINKEVENT_RESPONSE        141
-#define QLCNIC_C2H_OPCODE_LAST                          142
 
 #define VPORT_MISS_MODE_DROP            0 /* drop all unmatched */
 #define VPORT_MISS_MODE_ACCEPT_ALL      1 /* accept all packets */
@@ -894,7 +836,7 @@ struct qlcnic_nic_req {
         __le64 qhdr;
         __le64 req_hdr;
         __le64 words[6];
-};
+} __packed;
 
 struct qlcnic_mac_req {
         u8 op;
@@ -905,7 +847,7 @@ struct qlcnic_mac_req {
 struct qlcnic_vlan_req {
         __le16 vlan_id;
         __le16 rsvd[3];
-};
+} __packed;
 
 struct qlcnic_ipaddr {
         __be32 ipv4;
@@ -964,14 +906,15 @@ struct qlcnic_filter_hash {
 };
 
 struct qlcnic_adapter {
-        struct qlcnic_hardware_context ahw;
-
+        struct qlcnic_hardware_context *ahw;
+        struct qlcnic_recv_context *recv_ctx;
+        struct qlcnic_host_tx_ring *tx_ring;
         struct net_device *netdev;
         struct pci_dev *pdev;
-        struct list_head mac_list;
 
-        spinlock_t tx_clean_lock;
-        spinlock_t mac_learn_lock;
+        bool            blink_was_down;
+        unsigned long state;
+        u32 flags;
 
         u16 num_txd;
         u16 num_rxd;
@@ -989,7 +932,6 @@ struct qlcnic_adapter {
 
         u8 mc_enabled;
         u8 max_mc_count;
-        u8 rss_supported;
         u8 fw_wait_cnt;
         u8 fw_fail_cnt;
         u8 tx_timeo_cnt;
@@ -1014,7 +956,6 @@ struct qlcnic_adapter {
 
         u32 fw_hal_version;
         u32 capabilities;
-        u32 flags;
         u32 irq;
         u32 temp;
 
@@ -1032,16 +973,14 @@ struct qlcnic_adapter {
         u8 mac_addr[ETH_ALEN];
 
         u64 dev_rst_time;
+        unsigned long vlans[BITS_TO_LONGS(VLAN_N_VID)];
 
-        struct vlan_group *vlgrp;
         struct qlcnic_npar_info *npars;
         struct qlcnic_eswitch *eswitch;
         struct qlcnic_nic_template *nic_ops;
 
         struct qlcnic_adapter_stats stats;
-
-        struct qlcnic_recv_context recv_ctx;
-        struct qlcnic_host_tx_ring *tx_ring;
+        struct list_head mac_list;
 
         void __iomem    *tgt_mask_reg;
         void __iomem    *tgt_status_reg;
@@ -1052,11 +991,11 @@ struct qlcnic_adapter {
 
         struct delayed_work fw_work;
 
-        struct qlcnic_nic_intr_coalesce coal;
 
         struct qlcnic_filter_hash fhash;
 
-        unsigned long state;
+        spinlock_t tx_clean_lock;
+        spinlock_t mac_learn_lock;
         __le32 file_prd_off;    /*File fw product offset*/
         u32 fw_version;
         const struct firmware *fw;
@@ -1078,7 +1017,7 @@ struct qlcnic_info {
         __le16  min_tx_bw;
         __le16  max_tx_bw;
         u8      reserved2[104];
-};
+} __packed;
 
 struct qlcnic_pci_info {
         __le16  id; /* pci function id */
@@ -1092,7 +1031,7 @@ struct qlcnic_pci_info {
 
         u8      mac[ETH_ALEN];
         u8      reserved2[106];
-};
+} __packed;
 
 struct qlcnic_npar_info {
         u16     pvid;
@@ -1209,7 +1148,7 @@ struct __qlcnic_esw_statistics {
         __le64 local_frames;
         __le64 numbytes;
         __le64 rsvd[3];
-};
+} __packed;
 
 struct qlcnic_esw_statistics {
         struct __qlcnic_esw_statistics rx;
@@ -1293,7 +1232,7 @@ void qlcnic_release_tx_buffers(struct qlcnic_adapter *adapter);
 
 int qlcnic_check_fw_status(struct qlcnic_adapter *adapter);
 void qlcnic_watchdog_task(struct work_struct *work);
-void qlcnic_post_rx_buffers(struct qlcnic_adapter *adapter, u32 ringid,
+void qlcnic_post_rx_buffers(struct qlcnic_adapter *adapter,
                 struct qlcnic_host_rds_ring *rds_ring);
 int qlcnic_process_rcv_ring(struct qlcnic_host_sds_ring *sds_ring, int max);
 void qlcnic_set_multi(struct net_device *netdev);
@@ -1378,8 +1317,7 @@ static const struct qlcnic_brdinfo qlcnic_boards[] = {
 
 static inline u32 qlcnic_tx_avail(struct qlcnic_host_tx_ring *tx_ring)
 {
-        smp_mb();
-        if (tx_ring->producer < tx_ring->sw_consumer)
+        if (likely(tx_ring->producer < tx_ring->sw_consumer))
                 return tx_ring->sw_consumer - tx_ring->producer;
         else
                 return tx_ring->sw_consumer + tx_ring->num_desc -
diff --git a/drivers/net/qlcnic/qlcnic_ctx.c b/drivers/net/qlcnic/qlcnic_ctx.c
index 27631f23b3fd..050fa5a99ff7 100644
--- a/drivers/net/qlcnic/qlcnic_ctx.c
+++ b/drivers/net/qlcnic/qlcnic_ctx.c
@@ -67,11 +67,11 @@ qlcnic_issue_cmd(struct qlcnic_adapter *adapter,
 int
 qlcnic_fw_cmd_set_mtu(struct qlcnic_adapter *adapter, int mtu)
 {
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         if (recv_ctx->state == QLCNIC_HOST_CTX_STATE_ACTIVE) {
                 if (qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         recv_ctx->context_id,
                         mtu,
@@ -102,12 +102,12 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter)
         dma_addr_t hostrq_phys_addr, cardrsp_phys_addr;
         u64 phys_addr;
 
-        int i, nrds_rings, nsds_rings;
+        u8 i, nrds_rings, nsds_rings;
         size_t rq_size, rsp_size;
         u32 cap, reg, val, reg2;
         int err;
 
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         nrds_rings = adapter->max_rds_rings;
         nsds_rings = adapter->max_sds_rings;
@@ -119,14 +119,14 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter)
                 SIZEOF_CARDRSP_RX(struct qlcnic_cardrsp_rx_ctx, nrds_rings,
                                                 nsds_rings);
 
-        addr = pci_alloc_consistent(adapter->pdev,
-                                rq_size, &hostrq_phys_addr);
+        addr = dma_alloc_coherent(&adapter->pdev->dev, rq_size,
+                        &hostrq_phys_addr, GFP_KERNEL);
         if (addr == NULL)
                 return -ENOMEM;
         prq = (struct qlcnic_hostrq_rx_ctx *)addr;
 
-        addr = pci_alloc_consistent(adapter->pdev,
-                        rsp_size, &cardrsp_phys_addr);
+        addr = dma_alloc_coherent(&adapter->pdev->dev, rsp_size,
+                        &cardrsp_phys_addr, GFP_KERNEL);
         if (addr == NULL) {
                 err = -ENOMEM;
                 goto out_free_rq;
@@ -151,7 +151,7 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter)
 
         prq->num_rds_rings = cpu_to_le16(nrds_rings);
         prq->num_sds_rings = cpu_to_le16(nsds_rings);
-        prq->rds_ring_offset = cpu_to_le32(0);
+        prq->rds_ring_offset = 0;
 
         val = le32_to_cpu(prq->rds_ring_offset) +
                 (sizeof(struct qlcnic_hostrq_rds_ring) * nrds_rings);
@@ -187,7 +187,7 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter)
 
         phys_addr = hostrq_phys_addr;
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         (u32)(phys_addr >> 32),
                         (u32)(phys_addr & 0xffffffff),
@@ -207,7 +207,7 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter)
                 rds_ring = &recv_ctx->rds_rings[i];
 
                 reg = le32_to_cpu(prsp_rds[i].host_producer_crb);
-                rds_ring->crb_rcv_producer = adapter->ahw.pci_base0 + reg;
+                rds_ring->crb_rcv_producer = adapter->ahw->pci_base0 + reg;
         }
 
         prsp_sds = ((struct qlcnic_cardrsp_sds_ring *)
@@ -219,8 +219,8 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter)
                 reg = le32_to_cpu(prsp_sds[i].host_consumer_crb);
                 reg2 = le32_to_cpu(prsp_sds[i].interrupt_crb);
 
-                sds_ring->crb_sts_consumer = adapter->ahw.pci_base0 + reg;
-                sds_ring->crb_intr_mask = adapter->ahw.pci_base0 + reg2;
+                sds_ring->crb_sts_consumer = adapter->ahw->pci_base0 + reg;
+                sds_ring->crb_intr_mask = adapter->ahw->pci_base0 + reg2;
         }
 
         recv_ctx->state = le32_to_cpu(prsp->host_ctx_state);
@@ -228,19 +228,20 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter)
         recv_ctx->virt_port = prsp->virt_port;
 
 out_free_rsp:
-        pci_free_consistent(adapter->pdev, rsp_size, prsp, cardrsp_phys_addr);
+        dma_free_coherent(&adapter->pdev->dev, rsp_size, prsp,
+                cardrsp_phys_addr);
 out_free_rq:
-        pci_free_consistent(adapter->pdev, rq_size, prq, hostrq_phys_addr);
+        dma_free_coherent(&adapter->pdev->dev, rq_size, prq, hostrq_phys_addr);
         return err;
 }
 
 static void
 qlcnic_fw_cmd_destroy_rx_ctx(struct qlcnic_adapter *adapter)
 {
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         if (qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         recv_ctx->context_id,
                         QLCNIC_DESTROY_CTX_RESET,
@@ -274,14 +275,14 @@ qlcnic_fw_cmd_create_tx_ctx(struct qlcnic_adapter *adapter)
         *(tx_ring->hw_consumer) = 0;
 
         rq_size = SIZEOF_HOSTRQ_TX(struct qlcnic_hostrq_tx_ctx);
-        rq_addr = pci_alloc_consistent(adapter->pdev,
-                rq_size, &rq_phys_addr);
+        rq_addr = dma_alloc_coherent(&adapter->pdev->dev, rq_size,
+                        &rq_phys_addr, GFP_KERNEL);
         if (!rq_addr)
                 return -ENOMEM;
 
         rsp_size = SIZEOF_CARDRSP_TX(struct qlcnic_cardrsp_tx_ctx);
-        rsp_addr = pci_alloc_consistent(adapter->pdev,
-                rsp_size, &rsp_phys_addr);
+        rsp_addr = dma_alloc_coherent(&adapter->pdev->dev, rsp_size,
+                        &rsp_phys_addr, GFP_KERNEL);
         if (!rsp_addr) {
                 err = -ENOMEM;
                 goto out_free_rq;
@@ -313,7 +314,7 @@ qlcnic_fw_cmd_create_tx_ctx(struct qlcnic_adapter *adapter)
 
         phys_addr = rq_phys_addr;
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         (u32)(phys_addr >> 32),
                         ((u32)phys_addr & 0xffffffff),
@@ -322,7 +323,7 @@ qlcnic_fw_cmd_create_tx_ctx(struct qlcnic_adapter *adapter)
 
         if (err == QLCNIC_RCODE_SUCCESS) {
                 temp = le32_to_cpu(prsp->cds_ring.host_producer_crb);
-                tx_ring->crb_cmd_producer = adapter->ahw.pci_base0 + temp;
+                tx_ring->crb_cmd_producer = adapter->ahw->pci_base0 + temp;
 
                 adapter->tx_context_id =
                         le16_to_cpu(prsp->context_id);
@@ -332,10 +333,11 @@ qlcnic_fw_cmd_create_tx_ctx(struct qlcnic_adapter *adapter)
                 err = -EIO;
         }
 
-        pci_free_consistent(adapter->pdev, rsp_size, rsp_addr, rsp_phys_addr);
+        dma_free_coherent(&adapter->pdev->dev, rsp_size, rsp_addr,
+                rsp_phys_addr);
 
 out_free_rq:
-        pci_free_consistent(adapter->pdev, rq_size, rq_addr, rq_phys_addr);
+        dma_free_coherent(&adapter->pdev->dev, rq_size, rq_addr, rq_phys_addr);
 
         return err;
 }
@@ -344,7 +346,7 @@ static void
 qlcnic_fw_cmd_destroy_tx_ctx(struct qlcnic_adapter *adapter)
 {
         if (qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         adapter->tx_context_id,
                         QLCNIC_DESTROY_CTX_RESET,
@@ -361,7 +363,7 @@ qlcnic_fw_cmd_query_phy(struct qlcnic_adapter *adapter, u32 reg, u32 *val)
 {
 
         if (qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         reg,
                         0,
@@ -378,7 +380,7 @@ int
 qlcnic_fw_cmd_set_phy(struct qlcnic_adapter *adapter, u32 reg, u32 val)
 {
         return qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         reg,
                         val,
@@ -398,20 +400,19 @@ int qlcnic_alloc_hw_resources(struct qlcnic_adapter *adapter)
 
         struct pci_dev *pdev = adapter->pdev;
 
-        recv_ctx = &adapter->recv_ctx;
+        recv_ctx = adapter->recv_ctx;
         tx_ring = adapter->tx_ring;
 
-        tx_ring->hw_consumer = (__le32 *)pci_alloc_consistent(pdev, sizeof(u32),
-                                                &tx_ring->hw_cons_phys_addr);
+        tx_ring->hw_consumer = (__le32 *) dma_alloc_coherent(&pdev->dev,
+                sizeof(u32), &tx_ring->hw_cons_phys_addr, GFP_KERNEL);
         if (tx_ring->hw_consumer == NULL) {
                 dev_err(&pdev->dev, "failed to allocate tx consumer\n");
                 return -ENOMEM;
         }
-        *(tx_ring->hw_consumer) = 0;
 
         /* cmd desc ring */
-        addr = pci_alloc_consistent(pdev, TX_DESC_RINGSIZE(tx_ring),
-                        &tx_ring->phys_addr);
+        addr = dma_alloc_coherent(&pdev->dev, TX_DESC_RINGSIZE(tx_ring),
+                        &tx_ring->phys_addr, GFP_KERNEL);
 
         if (addr == NULL) {
                 dev_err(&pdev->dev, "failed to allocate tx desc ring\n");
@@ -423,9 +424,9 @@ int qlcnic_alloc_hw_resources(struct qlcnic_adapter *adapter)
 
         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
                 rds_ring = &recv_ctx->rds_rings[ring];
-                addr = pci_alloc_consistent(adapter->pdev,
+                addr = dma_alloc_coherent(&adapter->pdev->dev,
                                 RCV_DESC_RINGSIZE(rds_ring),
-                                &rds_ring->phys_addr);
+                                &rds_ring->phys_addr, GFP_KERNEL);
                 if (addr == NULL) {
                         dev_err(&pdev->dev,
                                 "failed to allocate rds ring [%d]\n", ring);
@@ -439,9 +440,9 @@ int qlcnic_alloc_hw_resources(struct qlcnic_adapter *adapter)
         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
                 sds_ring = &recv_ctx->sds_rings[ring];
 
-                addr = pci_alloc_consistent(adapter->pdev,
+                addr = dma_alloc_coherent(&adapter->pdev->dev,
                                 STATUS_DESC_RINGSIZE(sds_ring),
-                                &sds_ring->phys_addr);
+                                &sds_ring->phys_addr, GFP_KERNEL);
                 if (addr == NULL) {
                         dev_err(&pdev->dev,
                                 "failed to allocate sds ring [%d]\n", ring);
@@ -501,11 +502,11 @@ void qlcnic_free_hw_resources(struct qlcnic_adapter *adapter)
         struct qlcnic_host_tx_ring *tx_ring;
         int ring;
 
-        recv_ctx = &adapter->recv_ctx;
+        recv_ctx = adapter->recv_ctx;
 
         tx_ring = adapter->tx_ring;
         if (tx_ring->hw_consumer != NULL) {
-                pci_free_consistent(adapter->pdev,
+                dma_free_coherent(&adapter->pdev->dev,
                                 sizeof(u32),
                                 tx_ring->hw_consumer,
                                 tx_ring->hw_cons_phys_addr);
@@ -513,7 +514,7 @@ void qlcnic_free_hw_resources(struct qlcnic_adapter *adapter)
         }
 
         if (tx_ring->desc_head != NULL) {
-                pci_free_consistent(adapter->pdev,
+                dma_free_coherent(&adapter->pdev->dev,
                                 TX_DESC_RINGSIZE(tx_ring),
                                 tx_ring->desc_head, tx_ring->phys_addr);
                 tx_ring->desc_head = NULL;
@@ -523,7 +524,7 @@ void qlcnic_free_hw_resources(struct qlcnic_adapter *adapter)
                 rds_ring = &recv_ctx->rds_rings[ring];
 
                 if (rds_ring->desc_head != NULL) {
-                        pci_free_consistent(adapter->pdev,
+                        dma_free_coherent(&adapter->pdev->dev,
                                         RCV_DESC_RINGSIZE(rds_ring),
                                         rds_ring->desc_head,
                                         rds_ring->phys_addr);
@@ -535,7 +536,7 @@ void qlcnic_free_hw_resources(struct qlcnic_adapter *adapter)
                 sds_ring = &recv_ctx->sds_rings[ring];
 
                 if (sds_ring->desc_head != NULL) {
-                        pci_free_consistent(adapter->pdev,
+                        dma_free_coherent(&adapter->pdev->dev,
                                 STATUS_DESC_RINGSIZE(sds_ring),
                                 sds_ring->desc_head,
                                 sds_ring->phys_addr);
@@ -551,9 +552,9 @@ int qlcnic_get_mac_address(struct qlcnic_adapter *adapter, u8 *mac)
         int err;
         u32 arg1;
 
-        arg1 = adapter->ahw.pci_func | BIT_8;
+        arg1 = adapter->ahw->pci_func | BIT_8;
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         arg1,
                         0,
@@ -582,15 +583,15 @@ int qlcnic_get_nic_info(struct qlcnic_adapter *adapter,
         void *nic_info_addr;
         size_t  nic_size = sizeof(struct qlcnic_info);
 
-        nic_info_addr = pci_alloc_consistent(adapter->pdev,
-                nic_size, &nic_dma_t);
+        nic_info_addr = dma_alloc_coherent(&adapter->pdev->dev, nic_size,
+                                &nic_dma_t, GFP_KERNEL);
         if (!nic_info_addr)
                 return -ENOMEM;
         memset(nic_info_addr, 0, nic_size);
 
         nic_info = (struct qlcnic_info *) nic_info_addr;
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         MSD(nic_dma_t),
                         LSD(nic_dma_t),
@@ -623,7 +624,8 @@ int qlcnic_get_nic_info(struct qlcnic_adapter *adapter,
                 err = -EIO;
         }
 
-        pci_free_consistent(adapter->pdev, nic_size, nic_info_addr, nic_dma_t);
+        dma_free_coherent(&adapter->pdev->dev, nic_size, nic_info_addr,
+                nic_dma_t);
         return err;
 }
 
@@ -639,8 +641,8 @@ int qlcnic_set_nic_info(struct qlcnic_adapter *adapter, struct qlcnic_info *nic)
         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
                 return err;
 
-        nic_info_addr = pci_alloc_consistent(adapter->pdev, nic_size,
-                        &nic_dma_t);
+        nic_info_addr = dma_alloc_coherent(&adapter->pdev->dev, nic_size,
+                        &nic_dma_t, GFP_KERNEL);
         if (!nic_info_addr)
                 return -ENOMEM;
 
@@ -659,7 +661,7 @@ int qlcnic_set_nic_info(struct qlcnic_adapter *adapter, struct qlcnic_info *nic)
         nic_info->max_tx_bw = cpu_to_le16(nic->max_tx_bw);
 
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         MSD(nic_dma_t),
                         LSD(nic_dma_t),
@@ -672,7 +674,8 @@ int qlcnic_set_nic_info(struct qlcnic_adapter *adapter, struct qlcnic_info *nic)
                 err = -EIO;
         }
 
-        pci_free_consistent(adapter->pdev, nic_size, nic_info_addr, nic_dma_t);
+        dma_free_coherent(&adapter->pdev->dev, nic_size, nic_info_addr,
+                nic_dma_t);
         return err;
 }
 
@@ -687,15 +690,15 @@ int qlcnic_get_pci_info(struct qlcnic_adapter *adapter,
         size_t npar_size = sizeof(struct qlcnic_pci_info);
         size_t pci_size = npar_size * QLCNIC_MAX_PCI_FUNC;
 
-        pci_info_addr = pci_alloc_consistent(adapter->pdev, pci_size,
-                        &pci_info_dma_t);
+        pci_info_addr = dma_alloc_coherent(&adapter->pdev->dev, pci_size,
+                        &pci_info_dma_t, GFP_KERNEL);
         if (!pci_info_addr)
                 return -ENOMEM;
         memset(pci_info_addr, 0, pci_size);
 
         npar = (struct qlcnic_pci_info *) pci_info_addr;
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         MSD(pci_info_dma_t),
                         LSD(pci_info_dma_t),
@@ -721,7 +724,7 @@ int qlcnic_get_pci_info(struct qlcnic_adapter *adapter,
                 err = -EIO;
         }
 
-        pci_free_consistent(adapter->pdev, pci_size, pci_info_addr,
+        dma_free_coherent(&adapter->pdev->dev, pci_size, pci_info_addr,
                 pci_info_dma_t);
         return err;
 }
@@ -741,7 +744,7 @@ int qlcnic_config_port_mirroring(struct qlcnic_adapter *adapter, u8 id,
         arg1 |= pci_func << 8;
 
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         arg1,
                         0,
@@ -775,14 +778,14 @@ int qlcnic_get_port_stats(struct qlcnic_adapter *adapter, const u8 func,
                 return -ENOMEM;
 
         if (adapter->op_mode != QLCNIC_MGMT_FUNC &&
-            func != adapter->ahw.pci_func) {
+            func != adapter->ahw->pci_func) {
                 dev_err(&adapter->pdev->dev,
                         "Not privilege to query stats for func=%d", func);
                 return -EIO;
         }
 
-        stats_addr = pci_alloc_consistent(adapter->pdev, stats_size,
-                        &stats_dma_t);
+        stats_addr = dma_alloc_coherent(&adapter->pdev->dev, stats_size,
+                        &stats_dma_t, GFP_KERNEL);
         if (!stats_addr) {
                 dev_err(&adapter->pdev->dev, "Unable to allocate memory\n");
                 return -ENOMEM;
@@ -793,7 +796,7 @@ int qlcnic_get_port_stats(struct qlcnic_adapter *adapter, const u8 func,
         arg1 |= rx_tx << 15 | stats_size << 16;
 
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         arg1,
                         MSD(stats_dma_t),
@@ -816,7 +819,7 @@ int qlcnic_get_port_stats(struct qlcnic_adapter *adapter, const u8 func,
                 esw_stats->numbytes = le64_to_cpu(stats->numbytes);
         }
 
-        pci_free_consistent(adapter->pdev, stats_size, stats_addr,
+        dma_free_coherent(&adapter->pdev->dev, stats_size, stats_addr,
                 stats_dma_t);
         return err;
 }
@@ -900,7 +903,7 @@ int qlcnic_clear_esw_stats(struct qlcnic_adapter *adapter, const u8 func_esw,
         arg1 |= BIT_14 | rx_tx << 15;
 
         return qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         arg1,
                         0,
@@ -921,7 +924,7 @@ __qlcnic_get_eswitch_port_config(struct qlcnic_adapter *adapter,
         u8 pci_func;
         pci_func = (*arg1 >> 8);
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         *arg1,
                         0,
@@ -999,7 +1002,7 @@ int qlcnic_config_switch_port(struct qlcnic_adapter *adapter,
         }
 
         err = qlcnic_issue_cmd(adapter,
-                        adapter->ahw.pci_func,
+                        adapter->ahw->pci_func,
                         adapter->fw_hal_version,
                         arg1,
                         arg2,
diff --git a/drivers/net/qlcnic/qlcnic_ethtool.c b/drivers/net/qlcnic/qlcnic_ethtool.c
index 45b2755d6cba..3cd8a169694a 100644
--- a/drivers/net/qlcnic/qlcnic_ethtool.c
+++ b/drivers/net/qlcnic/qlcnic_ethtool.c
@@ -150,10 +150,10 @@ qlcnic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 {
         struct qlcnic_adapter *adapter = netdev_priv(dev);
         int check_sfp_module = 0;
-        u16 pcifn = adapter->ahw.pci_func;
+        u16 pcifn = adapter->ahw->pci_func;
 
         /* read which mode */
-        if (adapter->ahw.port_type == QLCNIC_GBE) {
+        if (adapter->ahw->port_type == QLCNIC_GBE) {
                 ecmd->supported = (SUPPORTED_10baseT_Half |
                                    SUPPORTED_10baseT_Full |
                                    SUPPORTED_100baseT_Half |
@@ -170,7 +170,7 @@ qlcnic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                 ecmd->duplex = adapter->link_duplex;
                 ecmd->autoneg = adapter->link_autoneg;
 
-        } else if (adapter->ahw.port_type == QLCNIC_XGBE) {
+        } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
                 u32 val;
 
                 val = QLCRD32(adapter, QLCNIC_PORT_MODE_ADDR);
@@ -201,7 +201,7 @@ skip:
         ecmd->phy_address = adapter->physical_port;
         ecmd->transceiver = XCVR_EXTERNAL;
 
-        switch (adapter->ahw.board_type) {
+        switch (adapter->ahw->board_type) {
         case QLCNIC_BRDTYPE_P3P_REF_QG:
         case QLCNIC_BRDTYPE_P3P_4_GB:
         case QLCNIC_BRDTYPE_P3P_4_GB_MM:
@@ -238,7 +238,7 @@ skip:
                 ecmd->autoneg = AUTONEG_DISABLE;
                 break;
         case QLCNIC_BRDTYPE_P3P_10G_TP:
-                if (adapter->ahw.port_type == QLCNIC_XGBE) {
+                if (adapter->ahw->port_type == QLCNIC_XGBE) {
                         ecmd->autoneg = AUTONEG_DISABLE;
                         ecmd->supported |= (SUPPORTED_FIBRE | SUPPORTED_TP);
                         ecmd->advertising |=
@@ -256,7 +256,7 @@ skip:
                 break;
         default:
                 dev_err(&adapter->pdev->dev, "Unsupported board model %d\n",
-                        adapter->ahw.board_type);
+                        adapter->ahw->board_type);
                 return -EIO;
         }
 
@@ -288,7 +288,7 @@ qlcnic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
         __u32 status;
 
         /* read which mode */
-        if (adapter->ahw.port_type == QLCNIC_GBE) {
+        if (adapter->ahw->port_type == QLCNIC_GBE) {
                 /* autonegotiation */
                 if (qlcnic_fw_cmd_set_phy(adapter,
                                QLCNIC_NIU_GB_MII_MGMT_ADDR_AUTONEG,
@@ -340,14 +340,14 @@ static void
 qlcnic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
 {
         struct qlcnic_adapter *adapter = netdev_priv(dev);
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
         struct qlcnic_host_sds_ring *sds_ring;
         u32 *regs_buff = p;
         int ring, i = 0, j = 0;
 
         memset(p, 0, qlcnic_get_regs_len(dev));
         regs->version = (QLCNIC_ETHTOOL_REGS_VER << 24) |
-                (adapter->ahw.revision_id << 16) | (adapter->pdev)->device;
+                (adapter->ahw->revision_id << 16) | (adapter->pdev)->device;
 
         regs_buff[0] = (0xcafe0000 | (QLCNIC_DEV_INFO_SIZE & 0xffff));
         regs_buff[1] = QLCNIC_MGMT_API_VERSION;
@@ -382,7 +382,7 @@ static u32 qlcnic_test_link(struct net_device *dev)
         u32 val;
 
         val = QLCRD32(adapter, CRB_XG_STATE_P3P);
-        val = XG_LINK_STATE_P3P(adapter->ahw.pci_func, val);
+        val = XG_LINK_STATE_P3P(adapter->ahw->pci_func, val);
         return (val == XG_LINK_UP_P3P) ? 0 : 1;
 }
 
@@ -482,7 +482,7 @@ qlcnic_get_pauseparam(struct net_device *netdev,
         int port = adapter->physical_port;
         __u32 val;
 
-        if (adapter->ahw.port_type == QLCNIC_GBE) {
+        if (adapter->ahw->port_type == QLCNIC_GBE) {
                 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
                         return;
                 /* get flow control settings */
@@ -504,7 +504,7 @@ qlcnic_get_pauseparam(struct net_device *netdev,
                         pause->tx_pause = !(qlcnic_gb_get_gb3_mask(val));
                         break;
                 }
-        } else if (adapter->ahw.port_type == QLCNIC_XGBE) {
+        } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
                 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
                         return;
                 pause->rx_pause = 1;
@@ -515,7 +515,7 @@ qlcnic_get_pauseparam(struct net_device *netdev,
                         pause->tx_pause = !(qlcnic_xg_get_xg1_mask(val));
         } else {
                 dev_err(&netdev->dev, "Unknown board type: %x\n",
-                                        adapter->ahw.port_type);
+                                        adapter->ahw->port_type);
         }
 }
 
@@ -528,7 +528,7 @@ qlcnic_set_pauseparam(struct net_device *netdev,
         __u32 val;
 
         /* read mode */
-        if (adapter->ahw.port_type == QLCNIC_GBE) {
+        if (adapter->ahw->port_type == QLCNIC_GBE) {
                 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
                         return -EIO;
                 /* set flow control */
@@ -571,7 +571,7 @@ qlcnic_set_pauseparam(struct net_device *netdev,
                         break;
                 }
                 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, val);
-        } else if (adapter->ahw.port_type == QLCNIC_XGBE) {
+        } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
                 if (!pause->rx_pause || pause->autoneg)
                         return -EOPNOTSUPP;
 
@@ -593,7 +593,7 @@ qlcnic_set_pauseparam(struct net_device *netdev,
                 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, val);
         } else {
                 dev_err(&netdev->dev, "Unknown board type: %x\n",
-                                adapter->ahw.port_type);
+                                adapter->ahw->port_type);
         }
         return 0;
 }
@@ -639,8 +639,8 @@ static int qlcnic_irq_test(struct net_device *netdev)
                 goto clear_it;
 
         adapter->diag_cnt = 0;
-        ret = qlcnic_issue_cmd(adapter, adapter->ahw.pci_func,
-                        adapter->fw_hal_version, adapter->portnum,
+        ret = qlcnic_issue_cmd(adapter, adapter->ahw->pci_func,
+                        adapter->fw_hal_version, adapter->ahw->pci_func,
                         0, 0, 0x00000011);
         if (ret)
                 goto done;
@@ -749,14 +749,14 @@ qlcnic_get_ethtool_stats(struct net_device *dev,
                 return;
 
         memset(&port_stats, 0, sizeof(struct qlcnic_esw_statistics));
-        ret = qlcnic_get_port_stats(adapter, adapter->ahw.pci_func,
+        ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
                         QLCNIC_QUERY_RX_COUNTER, &port_stats.rx);
         if (ret)
                 return;
 
         qlcnic_fill_device_stats(&index, data, &port_stats.rx);
 
-        ret = qlcnic_get_port_stats(adapter, adapter->ahw.pci_func,
+        ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
                         QLCNIC_QUERY_TX_COUNTER, &port_stats.tx);
         if (ret)
                 return;
@@ -831,48 +831,51 @@ static int qlcnic_set_tso(struct net_device *dev, u32 data)
         return 0;
 }
 
-static int qlcnic_blink_led(struct net_device *dev, u32 val)
+static int qlcnic_set_led(struct net_device *dev,
+                          enum ethtool_phys_id_state state)
 {
         struct qlcnic_adapter *adapter = netdev_priv(dev);
         int max_sds_rings = adapter->max_sds_rings;
-        int dev_down = 0;
-        int ret;
-
-        if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
-                dev_down = 1;
-                if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
-                        return -EIO;
 
-                ret = qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST);
-                if (ret) {
-                        clear_bit(__QLCNIC_RESETTING, &adapter->state);
-                        return ret;
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                adapter->blink_was_down = false;
+                if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
+                        if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
+                                return -EIO;
+
+                        if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST)) {
+                                clear_bit(__QLCNIC_RESETTING, &adapter->state);
+                                return -EIO;
+                        }
+                        adapter->blink_was_down = true;
                 }
-        }
 
-        ret = adapter->nic_ops->config_led(adapter, 1, 0xf);
-        if (ret) {
+                if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0)
+                        return 0;
+
                 dev_err(&adapter->pdev->dev,
                         "Failed to set LED blink state.\n");
-                goto done;
-        }
+                break;
 
-        msleep_interruptible(val * 1000);
+        case ETHTOOL_ID_INACTIVE:
+                if (adapter->nic_ops->config_led(adapter, 0, 0xf) == 0)
+                        return 0;
 
-        ret = adapter->nic_ops->config_led(adapter, 0, 0xf);
-        if (ret) {
                 dev_err(&adapter->pdev->dev,
                         "Failed to reset LED blink state.\n");
-                goto done;
+                break;
+
+        default:
+                return -EINVAL;
         }
 
-done:
-        if (dev_down) {
+        if (adapter->blink_was_down) {
                 qlcnic_diag_free_res(dev, max_sds_rings);
                 clear_bit(__QLCNIC_RESETTING, &adapter->state);
         }
-        return ret;
 
+        return -EIO;
 }
 
 static void
@@ -936,8 +939,8 @@ static int qlcnic_set_intr_coalesce(struct net_device *netdev,
         */
         if (ethcoal->rx_coalesce_usecs > 0xffff ||
                 ethcoal->rx_max_coalesced_frames > 0xffff ||
-                ethcoal->tx_coalesce_usecs > 0xffff ||
-                ethcoal->tx_max_coalesced_frames > 0xffff ||
+                ethcoal->tx_coalesce_usecs ||
+                ethcoal->tx_max_coalesced_frames ||
                 ethcoal->rx_coalesce_usecs_irq ||
                 ethcoal->rx_max_coalesced_frames_irq ||
                 ethcoal->tx_coalesce_usecs_irq ||
@@ -959,21 +962,17 @@ static int qlcnic_set_intr_coalesce(struct net_device *netdev,
 
         if (!ethcoal->rx_coalesce_usecs ||
                 !ethcoal->rx_max_coalesced_frames) {
-                adapter->coal.flags = QLCNIC_INTR_DEFAULT;
-                adapter->coal.normal.data.rx_time_us =
+                adapter->ahw->coal.flag = QLCNIC_INTR_DEFAULT;
+                adapter->ahw->coal.rx_time_us =
                         QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
-                adapter->coal.normal.data.rx_packets =
+                adapter->ahw->coal.rx_packets =
                         QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
         } else {
-                adapter->coal.flags = 0;
-                adapter->coal.normal.data.rx_time_us =
-                ethcoal->rx_coalesce_usecs;
-                adapter->coal.normal.data.rx_packets =
-                ethcoal->rx_max_coalesced_frames;
+                adapter->ahw->coal.flag = 0;
+                adapter->ahw->coal.rx_time_us = ethcoal->rx_coalesce_usecs;
+                adapter->ahw->coal.rx_packets =
+                        ethcoal->rx_max_coalesced_frames;
         }
-        adapter->coal.normal.data.tx_time_us = ethcoal->tx_coalesce_usecs;
-        adapter->coal.normal.data.tx_packets =
-        ethcoal->tx_max_coalesced_frames;
 
         qlcnic_config_intr_coalesce(adapter);
 
@@ -988,12 +987,8 @@ static int qlcnic_get_intr_coalesce(struct net_device *netdev,
         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
                 return -EINVAL;
 
-        ethcoal->rx_coalesce_usecs = adapter->coal.normal.data.rx_time_us;
-        ethcoal->tx_coalesce_usecs = adapter->coal.normal.data.tx_time_us;
-        ethcoal->rx_max_coalesced_frames =
-                adapter->coal.normal.data.rx_packets;
-        ethcoal->tx_max_coalesced_frames =
-                adapter->coal.normal.data.tx_packets;
+        ethcoal->rx_coalesce_usecs = adapter->ahw->coal.rx_time_us;
+        ethcoal->rx_max_coalesced_frames = adapter->ahw->coal.rx_packets;
 
         return 0;
 }
@@ -1006,22 +1001,28 @@ static int qlcnic_set_flags(struct net_device *netdev, u32 data)
         if (ethtool_invalid_flags(netdev, data, ETH_FLAG_LRO))
                 return -EINVAL;
 
-        if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO))
-                return -EINVAL;
+        if (data & ETH_FLAG_LRO) {
 
-        if (!adapter->rx_csum) {
-                dev_info(&adapter->pdev->dev, "rx csum is off, "
-                        "cannot toggle lro\n");
-                return -EINVAL;
-        }
+                if (netdev->features & NETIF_F_LRO)
+                        return 0;
 
-        if ((data & ETH_FLAG_LRO) && (netdev->features & NETIF_F_LRO))
-                return 0;
+                if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO))
+                        return -EINVAL;
+
+                if (!adapter->rx_csum) {
+                        dev_info(&adapter->pdev->dev, "rx csum is off, "
+                                "cannot toggle lro\n");
+                        return -EINVAL;
+                }
 
-        if (data & ETH_FLAG_LRO) {
                 hw_lro = QLCNIC_LRO_ENABLED;
                 netdev->features |= NETIF_F_LRO;
+
         } else {
+
+                if (!(netdev->features & NETIF_F_LRO))
+                        return 0;
+
                 hw_lro = 0;
                 netdev->features &= ~NETIF_F_LRO;
         }
@@ -1080,7 +1081,7 @@ const struct ethtool_ops qlcnic_ethtool_ops = {
         .set_coalesce = qlcnic_set_intr_coalesce,
         .get_flags = ethtool_op_get_flags,
         .set_flags = qlcnic_set_flags,
-        .phys_id = qlcnic_blink_led,
+        .set_phys_id = qlcnic_set_led,
         .set_msglevel = qlcnic_set_msglevel,
         .get_msglevel = qlcnic_get_msglevel,
 };
diff --git a/drivers/net/qlcnic/qlcnic_hw.c b/drivers/net/qlcnic/qlcnic_hw.c
index 616940f0a8d0..498cca92126a 100644
--- a/drivers/net/qlcnic/qlcnic_hw.c
+++ b/drivers/net/qlcnic/qlcnic_hw.c
@@ -457,7 +457,7 @@ int qlcnic_nic_set_promisc(struct qlcnic_adapter *adapter, u32 mode)
 
         req.qhdr = cpu_to_le64(QLCNIC_HOST_REQUEST << 23);
 
-        word = QLCNIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE |
+        word = QLCNIC_H2C_OPCODE_SET_MAC_RECEIVE_MODE |
                         ((u64)adapter->portnum << 16);
         req.req_hdr = cpu_to_le64(word);
 
@@ -532,33 +532,31 @@ void qlcnic_delete_lb_filters(struct qlcnic_adapter *adapter)
         }
 }
 
-#define QLCNIC_CONFIG_INTR_COALESCE     3
-
 /*
  * Send the interrupt coalescing parameter set by ethtool to the card.
  */
 int qlcnic_config_intr_coalesce(struct qlcnic_adapter *adapter)
 {
         struct qlcnic_nic_req req;
-        u64 word[6];
-        int rv, i;
+        int rv;
 
         memset(&req, 0, sizeof(struct qlcnic_nic_req));
 
         req.qhdr = cpu_to_le64(QLCNIC_HOST_REQUEST << 23);
 
-        word[0] = QLCNIC_CONFIG_INTR_COALESCE | ((u64)adapter->portnum << 16);
-        req.req_hdr = cpu_to_le64(word[0]);
-
-        memcpy(&word[0], &adapter->coal, sizeof(adapter->coal));
-        for (i = 0; i < 6; i++)
-                req.words[i] = cpu_to_le64(word[i]);
+        req.req_hdr = cpu_to_le64(QLCNIC_CONFIG_INTR_COALESCE |
+                ((u64) adapter->portnum << 16));
 
+        req.words[0] = cpu_to_le64(((u64) adapter->ahw->coal.flag) << 32);
+        req.words[2] = cpu_to_le64(adapter->ahw->coal.rx_packets |
+                        ((u64) adapter->ahw->coal.rx_time_us) << 16);
+        req.words[5] = cpu_to_le64(adapter->ahw->coal.timer_out |
+                        ((u64) adapter->ahw->coal.type) << 32 |
+                        ((u64) adapter->ahw->coal.sts_ring_mask) << 40);
         rv = qlcnic_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
         if (rv != 0)
                 dev_err(&adapter->netdev->dev,
                         "Could not send interrupt coalescing parameters\n");
-
         return rv;
 }
 
@@ -568,6 +566,9 @@ int qlcnic_config_hw_lro(struct qlcnic_adapter *adapter, int enable)
         u64 word;
         int rv;
 
+        if (!test_bit(__QLCNIC_FW_ATTACHED, &adapter->state))
+                return 0;
+
         memset(&req, 0, sizeof(struct qlcnic_nic_req));
 
         req.qhdr = cpu_to_le64(QLCNIC_HOST_REQUEST << 23);
@@ -713,6 +714,9 @@ int qlcnic_send_lro_cleanup(struct qlcnic_adapter *adapter)
         u64 word;
         int rv;
 
+        if (!test_bit(__QLCNIC_FW_ATTACHED, &adapter->state))
+                return 0;
+
         memset(&req, 0, sizeof(struct qlcnic_nic_req));
         req.qhdr = cpu_to_le64(QLCNIC_HOST_REQUEST << 23);
 
@@ -780,7 +784,7 @@ qlcnic_pci_get_crb_addr_2M(struct qlcnic_adapter *adapter,
         m = &crb_128M_2M_map[CRB_BLK(off)].sub_block[CRB_SUBBLK(off)];
 
         if (m->valid && (m->start_128M <= off) && (m->end_128M > off)) {
-                *addr = adapter->ahw.pci_base0 + m->start_2M +
+                *addr = adapter->ahw->pci_base0 + m->start_2M +
                         (off - m->start_128M);
                 return 0;
         }
@@ -788,7 +792,7 @@ qlcnic_pci_get_crb_addr_2M(struct qlcnic_adapter *adapter,
         /*
          * Not in direct map, use crb window
          */
-        *addr = adapter->ahw.pci_base0 + CRB_INDIRECT_2M + (off & MASK(16));
+        *addr = adapter->ahw->pci_base0 + CRB_INDIRECT_2M + (off & MASK(16));
         return 1;
 }
 
@@ -801,7 +805,7 @@ static int
 qlcnic_pci_set_crbwindow_2M(struct qlcnic_adapter *adapter, ulong off)
 {
         u32 window;
-        void __iomem *addr = adapter->ahw.pci_base0 + CRB_WINDOW_2M;
+        void __iomem *addr = adapter->ahw->pci_base0 + CRB_WINDOW_2M;
 
         off -= QLCNIC_PCI_CRBSPACE;
 
@@ -838,13 +842,13 @@ qlcnic_hw_write_wx_2M(struct qlcnic_adapter *adapter, ulong off, u32 data)
 
         if (rv > 0) {
                 /* indirect access */
-                write_lock_irqsave(&adapter->ahw.crb_lock, flags);
+                write_lock_irqsave(&adapter->ahw->crb_lock, flags);
                 crb_win_lock(adapter);
                 rv = qlcnic_pci_set_crbwindow_2M(adapter, off);
                 if (!rv)
                         writel(data, addr);
                 crb_win_unlock(adapter);
-                write_unlock_irqrestore(&adapter->ahw.crb_lock, flags);
+                write_unlock_irqrestore(&adapter->ahw->crb_lock, flags);
                 return rv;
         }
 
@@ -869,12 +873,12 @@ qlcnic_hw_read_wx_2M(struct qlcnic_adapter *adapter, ulong off)
 
         if (rv > 0) {
                 /* indirect access */
-                write_lock_irqsave(&adapter->ahw.crb_lock, flags);
+                write_lock_irqsave(&adapter->ahw->crb_lock, flags);
                 crb_win_lock(adapter);
                 if (!qlcnic_pci_set_crbwindow_2M(adapter, off))
                         data = readl(addr);
                 crb_win_unlock(adapter);
-                write_unlock_irqrestore(&adapter->ahw.crb_lock, flags);
+                write_unlock_irqrestore(&adapter->ahw->crb_lock, flags);
                 return data;
         }
 
@@ -904,9 +908,9 @@ qlcnic_pci_set_window_2M(struct qlcnic_adapter *adapter,
 
         window = OCM_WIN_P3P(addr);
 
-        writel(window, adapter->ahw.ocm_win_crb);
+        writel(window, adapter->ahw->ocm_win_crb);
         /* read back to flush */
-        readl(adapter->ahw.ocm_win_crb);
+        readl(adapter->ahw->ocm_win_crb);
 
         *start = QLCNIC_PCI_OCM0_2M + GET_MEM_OFFS_2M(addr);
         return 0;
@@ -920,13 +924,13 @@ qlcnic_pci_mem_access_direct(struct qlcnic_adapter *adapter, u64 off,
         int ret;
         u32 start;
 
-        mutex_lock(&adapter->ahw.mem_lock);
+        mutex_lock(&adapter->ahw->mem_lock);
 
         ret = qlcnic_pci_set_window_2M(adapter, off, &start);
         if (ret != 0)
                 goto unlock;
 
-        addr = adapter->ahw.pci_base0 + start;
+        addr = adapter->ahw->pci_base0 + start;
 
         if (op == 0)    /* read */
                 *data = readq(addr);
@@ -934,7 +938,7 @@ qlcnic_pci_mem_access_direct(struct qlcnic_adapter *adapter, u64 off,
                 writeq(*data, addr);
 
 unlock:
-        mutex_unlock(&adapter->ahw.mem_lock);
+        mutex_unlock(&adapter->ahw->mem_lock);
 
         return ret;
 }
@@ -942,23 +946,23 @@ unlock:
 void
 qlcnic_pci_camqm_read_2M(struct qlcnic_adapter *adapter, u64 off, u64 *data)
 {
-        void __iomem *addr = adapter->ahw.pci_base0 +
+        void __iomem *addr = adapter->ahw->pci_base0 +
                 QLCNIC_PCI_CAMQM_2M_BASE + (off - QLCNIC_PCI_CAMQM);
 
-        mutex_lock(&adapter->ahw.mem_lock);
+        mutex_lock(&adapter->ahw->mem_lock);
         *data = readq(addr);
-        mutex_unlock(&adapter->ahw.mem_lock);
+        mutex_unlock(&adapter->ahw->mem_lock);
 }
 
 void
 qlcnic_pci_camqm_write_2M(struct qlcnic_adapter *adapter, u64 off, u64 data)
 {
-        void __iomem *addr = adapter->ahw.pci_base0 +
+        void __iomem *addr = adapter->ahw->pci_base0 +
                 QLCNIC_PCI_CAMQM_2M_BASE + (off - QLCNIC_PCI_CAMQM);
 
-        mutex_lock(&adapter->ahw.mem_lock);
+        mutex_lock(&adapter->ahw->mem_lock);
         writeq(data, addr);
-        mutex_unlock(&adapter->ahw.mem_lock);
+        mutex_unlock(&adapter->ahw->mem_lock);
 }
 
 #define MAX_CTL_CHECK   1000
@@ -997,7 +1001,7 @@ qlcnic_pci_mem_write_2M(struct qlcnic_adapter *adapter,
 correct:
         off8 = off & ~0xf;
 
-        mutex_lock(&adapter->ahw.mem_lock);
+        mutex_lock(&adapter->ahw->mem_lock);
 
         writel(off8, (mem_crb + MIU_TEST_AGT_ADDR_LO));
         writel(0, (mem_crb + MIU_TEST_AGT_ADDR_HI));
@@ -1049,7 +1053,7 @@ correct:
                 ret = 0;
 
 done:
-        mutex_unlock(&adapter->ahw.mem_lock);
+        mutex_unlock(&adapter->ahw->mem_lock);
 
         return ret;
 }
@@ -1091,7 +1095,7 @@ qlcnic_pci_mem_read_2M(struct qlcnic_adapter *adapter,
 correct:
         off8 = off & ~0xf;
 
-        mutex_lock(&adapter->ahw.mem_lock);
+        mutex_lock(&adapter->ahw->mem_lock);
 
         writel(off8, (mem_crb + MIU_TEST_AGT_ADDR_LO));
         writel(0, (mem_crb + MIU_TEST_AGT_ADDR_HI));
@@ -1121,7 +1125,7 @@ correct:
                 ret = 0;
         }
 
-        mutex_unlock(&adapter->ahw.mem_lock);
+        mutex_unlock(&adapter->ahw->mem_lock);
 
         return ret;
 }
@@ -1145,7 +1149,7 @@ int qlcnic_get_board_info(struct qlcnic_adapter *adapter)
         if (qlcnic_rom_fast_read(adapter, offset, &board_type))
                 return -EIO;
 
-        adapter->ahw.board_type = board_type;
+        adapter->ahw->board_type = board_type;
 
         if (board_type == QLCNIC_BRDTYPE_P3P_4_GB_MM) {
                 u32 gpio = QLCRD32(adapter, QLCNIC_ROMUSB_GLB_PAD_GPIO_I);
@@ -1164,20 +1168,20 @@ int qlcnic_get_board_info(struct qlcnic_adapter *adapter)
         case QLCNIC_BRDTYPE_P3P_10G_SFP_QT:
         case QLCNIC_BRDTYPE_P3P_10G_XFP:
         case QLCNIC_BRDTYPE_P3P_10000_BASE_T:
-                adapter->ahw.port_type = QLCNIC_XGBE;
+                adapter->ahw->port_type = QLCNIC_XGBE;
                 break;
         case QLCNIC_BRDTYPE_P3P_REF_QG:
         case QLCNIC_BRDTYPE_P3P_4_GB:
         case QLCNIC_BRDTYPE_P3P_4_GB_MM:
-                adapter->ahw.port_type = QLCNIC_GBE;
+                adapter->ahw->port_type = QLCNIC_GBE;
                 break;
         case QLCNIC_BRDTYPE_P3P_10G_TP:
-                adapter->ahw.port_type = (adapter->portnum < 2) ?
+                adapter->ahw->port_type = (adapter->portnum < 2) ?
                         QLCNIC_XGBE : QLCNIC_GBE;
                 break;
         default:
                 dev_err(&pdev->dev, "unknown board type %x\n", board_type);
-                adapter->ahw.port_type = QLCNIC_XGBE;
+                adapter->ahw->port_type = QLCNIC_XGBE;
                 break;
         }
 
diff --git a/drivers/net/qlcnic/qlcnic_init.c b/drivers/net/qlcnic/qlcnic_init.c
index a7f1d5b7e811..4ec0eeb6bff9 100644
--- a/drivers/net/qlcnic/qlcnic_init.c
+++ b/drivers/net/qlcnic/qlcnic_init.c
@@ -94,7 +94,7 @@ void qlcnic_release_rx_buffers(struct qlcnic_adapter *adapter)
         struct qlcnic_rx_buffer *rx_buf;
         int i, ring;
 
-        recv_ctx = &adapter->recv_ctx;
+        recv_ctx = adapter->recv_ctx;
         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
                 rds_ring = &recv_ctx->rds_rings[ring];
                 for (i = 0; i < rds_ring->num_desc; ++i) {
@@ -119,7 +119,7 @@ void qlcnic_reset_rx_buffers_list(struct qlcnic_adapter *adapter)
         struct qlcnic_rx_buffer *rx_buf;
         int i, ring;
 
-        recv_ctx = &adapter->recv_ctx;
+        recv_ctx = adapter->recv_ctx;
         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
                 rds_ring = &recv_ctx->rds_rings[ring];
 
@@ -173,7 +173,7 @@ void qlcnic_free_sw_resources(struct qlcnic_adapter *adapter)
         struct qlcnic_host_tx_ring *tx_ring;
         int ring;
 
-        recv_ctx = &adapter->recv_ctx;
+        recv_ctx = adapter->recv_ctx;
 
         if (recv_ctx->rds_rings == NULL)
                 goto skip_rds;
@@ -226,7 +226,7 @@ int qlcnic_alloc_sw_resources(struct qlcnic_adapter *adapter)
         }
         tx_ring->cmd_buf_arr = cmd_buf_arr;
 
-        recv_ctx = &adapter->recv_ctx;
+        recv_ctx = adapter->recv_ctx;
 
         size = adapter->max_rds_rings * sizeof(struct qlcnic_host_rds_ring);
         rds_ring = kzalloc(size, GFP_KERNEL);
@@ -864,7 +864,7 @@ nomn:
         for (i = 0; i < entries; i++) {
 
                 __le32 flags, file_chiprev, offs;
-                u8 chiprev = adapter->ahw.revision_id;
+                u8 chiprev = adapter->ahw->revision_id;
                 u32 flagbit;
 
                 offs = cpu_to_le32(ptab_descr->findex) +
@@ -1130,9 +1130,20 @@ qlcnic_load_firmware(struct qlcnic_adapter *adapter)
         } else {
                 u64 data;
                 u32 hi, lo;
-
-                size = (QLCNIC_IMAGE_START - QLCNIC_BOOTLD_START) / 8;
-                flashaddr = QLCNIC_BOOTLD_START;
+                int ret;
+                struct qlcnic_flt_entry bootld_entry;
+
+                ret = qlcnic_get_flt_entry(adapter, QLCNIC_BOOTLD_REGION,
+                                        &bootld_entry);
+                if (!ret) {
+                        size = bootld_entry.size / 8;
+                        flashaddr = bootld_entry.start_addr;
+                } else {
+                        size = (QLCNIC_IMAGE_START - QLCNIC_BOOTLD_START) / 8;
+                        flashaddr = QLCNIC_BOOTLD_START;
+                        dev_info(&pdev->dev,
+                                "using legacy method to get flash fw region");
+                }
 
                 for (i = 0; i < size; i++) {
                         if (qlcnic_rom_fast_read(adapter,
@@ -1394,7 +1405,7 @@ static struct sk_buff *qlcnic_process_rxbuf(struct qlcnic_adapter *adapter,
         return skb;
 }
 
-static int
+static inline int
 qlcnic_check_rx_tagging(struct qlcnic_adapter *adapter, struct sk_buff *skb,
                         u16 *vlan_tag)
 {
@@ -1425,7 +1436,7 @@ qlcnic_process_rcv(struct qlcnic_adapter *adapter,
                 int ring, u64 sts_data0)
 {
         struct net_device *netdev = adapter->netdev;
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
         struct qlcnic_rx_buffer *buffer;
         struct sk_buff *skb;
         struct qlcnic_host_rds_ring *rds_ring;
@@ -1467,10 +1478,10 @@ qlcnic_process_rcv(struct qlcnic_adapter *adapter,
 
         skb->protocol = eth_type_trans(skb, netdev);
 
-        if ((vid != 0xffff) && adapter->vlgrp)
-                vlan_gro_receive(&sds_ring->napi, adapter->vlgrp, vid, skb);
-        else
-                napi_gro_receive(&sds_ring->napi, skb);
+        if (vid != 0xffff)
+                __vlan_hwaccel_put_tag(skb, vid);
+
+        napi_gro_receive(&sds_ring->napi, skb);
 
         adapter->stats.rx_pkts++;
         adapter->stats.rxbytes += length;
@@ -1488,7 +1499,7 @@ qlcnic_process_lro(struct qlcnic_adapter *adapter,
                 int ring, u64 sts_data0, u64 sts_data1)
 {
         struct net_device *netdev = adapter->netdev;
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
         struct qlcnic_rx_buffer *buffer;
         struct sk_buff *skb;
         struct qlcnic_host_rds_ring *rds_ring;
@@ -1552,10 +1563,9 @@ qlcnic_process_lro(struct qlcnic_adapter *adapter,
 
         length = skb->len;
 
-        if ((vid != 0xffff) && adapter->vlgrp)
-                vlan_hwaccel_receive_skb(skb, adapter->vlgrp, vid);
-        else
-                netif_receive_skb(skb);
+        if (vid != 0xffff)
+                __vlan_hwaccel_put_tag(skb, vid);
+        netif_receive_skb(skb);
 
         adapter->stats.lro_pkts++;
         adapter->stats.lrobytes += length;
@@ -1625,7 +1635,7 @@ skip:
 
         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
                 struct qlcnic_host_rds_ring *rds_ring =
-                        &adapter->recv_ctx.rds_rings[ring];
+                        &adapter->recv_ctx->rds_rings[ring];
 
                 if (!list_empty(&sds_ring->free_list[ring])) {
                         list_for_each(cur, &sds_ring->free_list[ring]) {
@@ -1651,12 +1661,13 @@ skip:
 }
 
 void
-qlcnic_post_rx_buffers(struct qlcnic_adapter *adapter, u32 ringid,
+qlcnic_post_rx_buffers(struct qlcnic_adapter *adapter,
         struct qlcnic_host_rds_ring *rds_ring)
 {
         struct rcv_desc *pdesc;
         struct qlcnic_rx_buffer *buffer;
-        int producer, count = 0;
+        int count = 0;
+        u32 producer;
         struct list_head *head;
 
         producer = rds_ring->producer;
@@ -1696,7 +1707,8 @@ qlcnic_post_rx_buffers_nodb(struct qlcnic_adapter *adapter,
 {
         struct rcv_desc *pdesc;
         struct qlcnic_rx_buffer *buffer;
-        int producer, count = 0;
+        int  count = 0;
+        uint32_t producer;
         struct list_head *head;
 
         if (!spin_trylock(&rds_ring->lock))
diff --git a/drivers/net/qlcnic/qlcnic_main.c b/drivers/net/qlcnic/qlcnic_main.c
index cd88c7e1bfa9..7f9edb2f1474 100644
--- a/drivers/net/qlcnic/qlcnic_main.c
+++ b/drivers/net/qlcnic/qlcnic_main.c
@@ -13,7 +13,6 @@
 
 #include <linux/swab.h>
 #include <linux/dma-mapping.h>
-#include <linux/if_vlan.h>
 #include <net/ip.h>
 #include <linux/ipv6.h>
 #include <linux/inetdevice.h>
@@ -98,6 +97,9 @@ static int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *, u32);
 static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
 static void qlcnic_set_netdev_features(struct qlcnic_adapter *,
                                 struct qlcnic_esw_func_cfg *);
+static void qlcnic_vlan_rx_add(struct net_device *, u16);
+static void qlcnic_vlan_rx_del(struct net_device *, u16);
+
 /*  PCI Device ID Table  */
 #define ENTRY(device) \
         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
@@ -113,7 +115,7 @@ static DEFINE_PCI_DEVICE_TABLE(qlcnic_pci_tbl) = {
 MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
 
 
-void
+inline void
 qlcnic_update_cmd_producer(struct qlcnic_adapter *adapter,
                 struct qlcnic_host_tx_ring *tx_ring)
 {
@@ -169,7 +171,7 @@ qlcnic_napi_add(struct qlcnic_adapter *adapter, struct net_device *netdev)
 {
         int ring;
         struct qlcnic_host_sds_ring *sds_ring;
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         if (qlcnic_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
                 return -ENOMEM;
@@ -193,14 +195,14 @@ qlcnic_napi_del(struct qlcnic_adapter *adapter)
 {
         int ring;
         struct qlcnic_host_sds_ring *sds_ring;
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
                 sds_ring = &recv_ctx->sds_rings[ring];
                 netif_napi_del(&sds_ring->napi);
         }
 
-        qlcnic_free_sds_rings(&adapter->recv_ctx);
+        qlcnic_free_sds_rings(adapter->recv_ctx);
 }
 
 static void
@@ -208,7 +210,7 @@ qlcnic_napi_enable(struct qlcnic_adapter *adapter)
 {
         int ring;
         struct qlcnic_host_sds_ring *sds_ring;
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
                 return;
@@ -225,7 +227,7 @@ qlcnic_napi_disable(struct qlcnic_adapter *adapter)
 {
         int ring;
         struct qlcnic_host_sds_ring *sds_ring;
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
                 return;
@@ -317,13 +319,6 @@ static int qlcnic_set_mac(struct net_device *netdev, void *p)
         return 0;
 }
 
-static void qlcnic_vlan_rx_register(struct net_device *netdev,
-                struct vlan_group *grp)
-{
-        struct qlcnic_adapter *adapter = netdev_priv(netdev);
-        adapter->vlgrp = grp;
-}
-
 static const struct net_device_ops qlcnic_netdev_ops = {
         .ndo_open          = qlcnic_open,
         .ndo_stop          = qlcnic_close,
@@ -334,7 +329,8 @@ static const struct net_device_ops qlcnic_netdev_ops = {
         .ndo_set_mac_address    = qlcnic_set_mac,
         .ndo_change_mtu    = qlcnic_change_mtu,
         .ndo_tx_timeout    = qlcnic_tx_timeout,
-        .ndo_vlan_rx_register = qlcnic_vlan_rx_register,
+        .ndo_vlan_rx_add_vid    = qlcnic_vlan_rx_add,
+        .ndo_vlan_rx_kill_vid   = qlcnic_vlan_rx_del,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller = qlcnic_poll_controller,
 #endif
@@ -359,7 +355,7 @@ qlcnic_setup_intr(struct qlcnic_adapter *adapter)
         struct pci_dev *pdev = adapter->pdev;
         int err, num_msix;
 
-        if (adapter->rss_supported) {
+        if (adapter->msix_supported) {
                 num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
                         MSIX_ENTRIES_PER_ADAPTER : 2;
         } else
@@ -369,7 +365,7 @@ qlcnic_setup_intr(struct qlcnic_adapter *adapter)
 
         adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
 
-        legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
+        legacy_intrp = &legacy_intr[adapter->ahw->pci_func];
 
         adapter->int_vec_bit = legacy_intrp->int_vec_bit;
         adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
@@ -391,8 +387,7 @@ qlcnic_setup_intr(struct qlcnic_adapter *adapter)
                         adapter->flags |= QLCNIC_MSIX_ENABLED;
                         qlcnic_set_msix_bit(pdev, 1);
 
-                        if (adapter->rss_supported)
-                                adapter->max_sds_rings = num_msix;
+                        adapter->max_sds_rings = num_msix;
 
                         dev_info(&pdev->dev, "using msi-x interrupts\n");
                         return;
@@ -407,7 +402,7 @@ qlcnic_setup_intr(struct qlcnic_adapter *adapter)
         if (use_msi && !pci_enable_msi(pdev)) {
                 adapter->flags |= QLCNIC_MSI_ENABLED;
                 adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
-                                msi_tgt_status[adapter->ahw.pci_func]);
+                                msi_tgt_status[adapter->ahw->pci_func]);
                 dev_info(&pdev->dev, "using msi interrupts\n");
                 adapter->msix_entries[0].vector = pdev->irq;
                 return;
@@ -429,8 +424,8 @@ qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
 static void
 qlcnic_cleanup_pci_map(struct qlcnic_adapter *adapter)
 {
-        if (adapter->ahw.pci_base0 != NULL)
-                iounmap(adapter->ahw.pci_base0);
+        if (adapter->ahw->pci_base0 != NULL)
+                iounmap(adapter->ahw->pci_base0);
 }
 
 static int
@@ -464,8 +459,10 @@ qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
 
         for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
                 pfn = pci_info[i].id;
-                if (pfn > QLCNIC_MAX_PCI_FUNC)
-                        return QL_STATUS_INVALID_PARAM;
+                if (pfn > QLCNIC_MAX_PCI_FUNC) {
+                        ret = QL_STATUS_INVALID_PARAM;
+                        goto err_eswitch;
+                }
                 adapter->npars[pfn].active = (u8)pci_info[i].active;
                 adapter->npars[pfn].type = (u8)pci_info[i].type;
                 adapter->npars[pfn].phy_port = (u8)pci_info[i].default_port;
@@ -498,7 +495,7 @@ qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
         u32 ref_count;
         int i, ret = 1;
         u32 data = QLCNIC_MGMT_FUNC;
-        void __iomem *priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
+        void __iomem *priv_op = adapter->ahw->pci_base0 + QLCNIC_DRV_OP_MODE;
 
         /* If other drivers are not in use set their privilege level */
         ref_count = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
@@ -510,16 +507,16 @@ qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
                 for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
                         id = i;
                         if (adapter->npars[i].type != QLCNIC_TYPE_NIC ||
-                                id == adapter->ahw.pci_func)
+                                id == adapter->ahw->pci_func)
                                 continue;
                         data |= (qlcnic_config_npars &
                                         QLC_DEV_SET_DRV(0xf, id));
                 }
         } else {
                 data = readl(priv_op);
-                data = (data & ~QLC_DEV_SET_DRV(0xf, adapter->ahw.pci_func)) |
+                data = (data & ~QLC_DEV_SET_DRV(0xf, adapter->ahw->pci_func)) |
                         (QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC,
-                        adapter->ahw.pci_func));
+                        adapter->ahw->pci_func));
         }
         writel(data, priv_op);
         qlcnic_api_unlock(adapter);
@@ -537,22 +534,23 @@ qlcnic_check_vf(struct qlcnic_adapter *adapter)
         u32 op_mode, priv_level;
 
         /* Determine FW API version */
-        adapter->fw_hal_version = readl(adapter->ahw.pci_base0 + QLCNIC_FW_API);
+        adapter->fw_hal_version = readl(adapter->ahw->pci_base0 +
+                                        QLCNIC_FW_API);
 
         /* Find PCI function number */
         pci_read_config_dword(adapter->pdev, QLCNIC_MSIX_TABLE_OFFSET, &func);
-        msix_base_addr = adapter->ahw.pci_base0 + QLCNIC_MSIX_BASE;
+        msix_base_addr = adapter->ahw->pci_base0 + QLCNIC_MSIX_BASE;
         msix_base = readl(msix_base_addr);
         func = (func - msix_base)/QLCNIC_MSIX_TBL_PGSIZE;
-        adapter->ahw.pci_func = func;
+        adapter->ahw->pci_func = func;
 
         /* Determine function privilege level */
-        priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
+        priv_op = adapter->ahw->pci_base0 + QLCNIC_DRV_OP_MODE;
         op_mode = readl(priv_op);
         if (op_mode == QLC_DEV_DRV_DEFAULT)
                 priv_level = QLCNIC_MGMT_FUNC;
         else
-                priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw.pci_func);
+                priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
 
         if (priv_level == QLCNIC_NON_PRIV_FUNC) {
                 adapter->op_mode = QLCNIC_NON_PRIV_FUNC;
@@ -591,13 +589,14 @@ qlcnic_setup_pci_map(struct qlcnic_adapter *adapter)
 
         dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
 
-        adapter->ahw.pci_base0 = mem_ptr0;
-        adapter->ahw.pci_len0 = pci_len0;
+        adapter->ahw->pci_base0 = mem_ptr0;
+        adapter->ahw->pci_len0 = pci_len0;
 
         qlcnic_check_vf(adapter);
 
-        adapter->ahw.ocm_win_crb = qlcnic_get_ioaddr(adapter,
-                QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(adapter->ahw.pci_func)));
+        adapter->ahw->ocm_win_crb = qlcnic_get_ioaddr(adapter,
+                QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(
+                        adapter->ahw->pci_func)));
 
         return 0;
 }
@@ -639,7 +638,7 @@ qlcnic_check_options(struct qlcnic_adapter *adapter)
 
         dev_info(&pdev->dev, "firmware v%d.%d.%d\n",
                         fw_major, fw_minor, fw_build);
-        if (adapter->ahw.port_type == QLCNIC_XGBE) {
+        if (adapter->ahw->port_type == QLCNIC_XGBE) {
                 if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
                         adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_VF;
                         adapter->max_rxd = MAX_RCV_DESCRIPTORS_VF;
@@ -651,7 +650,7 @@ qlcnic_check_options(struct qlcnic_adapter *adapter)
                 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
                 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
 
-        } else if (adapter->ahw.port_type == QLCNIC_GBE) {
+        } else if (adapter->ahw->port_type == QLCNIC_GBE) {
                 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
                 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
                 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
@@ -659,7 +658,6 @@ qlcnic_check_options(struct qlcnic_adapter *adapter)
         }
 
         adapter->msix_supported = !!use_msi_x;
-        adapter->rss_supported = !!use_msi_x;
 
         adapter->num_txd = MAX_CMD_DESCRIPTORS;
 
@@ -672,7 +670,7 @@ qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
         int err;
         struct qlcnic_info nic_info;
 
-        err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw.pci_func);
+        err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw->pci_func);
         if (err)
                 return err;
 
@@ -708,6 +706,22 @@ qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
 }
 
 static void
+qlcnic_vlan_rx_add(struct net_device *netdev, u16 vid)
+{
+        struct qlcnic_adapter *adapter = netdev_priv(netdev);
+        set_bit(vid, adapter->vlans);
+}
+
+static void
+qlcnic_vlan_rx_del(struct net_device *netdev, u16 vid)
+{
+        struct qlcnic_adapter *adapter = netdev_priv(netdev);
+
+        qlcnic_restore_indev_addr(netdev, NETDEV_DOWN);
+        clear_bit(vid, adapter->vlans);
+}
+
+static void
 qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
                 struct qlcnic_esw_func_cfg *esw_cfg)
 {
@@ -734,7 +748,7 @@ qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
                 return 0;
 
-        esw_cfg.pci_func = adapter->ahw.pci_func;
+        esw_cfg.pci_func = adapter->ahw->pci_func;
         if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
                         return -EIO;
         qlcnic_set_vlan_config(adapter, &esw_cfg);
@@ -753,13 +767,14 @@ qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
         features = (NETIF_F_SG | NETIF_F_IP_CSUM |
                         NETIF_F_IPV6_CSUM | NETIF_F_GRO);
         vlan_features = (NETIF_F_SG | NETIF_F_IP_CSUM |
-                        NETIF_F_IPV6_CSUM);
+                        NETIF_F_IPV6_CSUM | NETIF_F_HW_VLAN_FILTER);
 
         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO) {
                 features |= (NETIF_F_TSO | NETIF_F_TSO6);
                 vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
         }
-        if (adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
+
+        if (netdev->features & NETIF_F_LRO)
                 features |= NETIF_F_LRO;
 
         if (esw_cfg->offload_flags & BIT_0) {
@@ -791,14 +806,14 @@ qlcnic_check_eswitch_mode(struct qlcnic_adapter *adapter)
         if (adapter->flags & QLCNIC_ADAPTER_INITIALIZED)
                 return 0;
 
-        priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
+        priv_op = adapter->ahw->pci_base0 + QLCNIC_DRV_OP_MODE;
         op_mode = readl(priv_op);
-        priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw.pci_func);
+        priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
 
         if (op_mode == QLC_DEV_DRV_DEFAULT)
                 priv_level = QLCNIC_MGMT_FUNC;
         else
-                priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw.pci_func);
+                priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
 
         if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
                 if (priv_level == QLCNIC_MGMT_FUNC) {
@@ -1038,7 +1053,7 @@ qlcnic_request_irq(struct qlcnic_adapter *adapter)
 
         unsigned long flags = 0;
         struct net_device *netdev = adapter->netdev;
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
                 handler = qlcnic_tmp_intr;
@@ -1075,7 +1090,7 @@ qlcnic_free_irq(struct qlcnic_adapter *adapter)
         int ring;
         struct qlcnic_host_sds_ring *sds_ring;
 
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
                 sds_ring = &recv_ctx->sds_rings[ring];
@@ -1083,20 +1098,6 @@ qlcnic_free_irq(struct qlcnic_adapter *adapter)
         }
 }
 
-static void
-qlcnic_init_coalesce_defaults(struct qlcnic_adapter *adapter)
-{
-        adapter->coal.flags = QLCNIC_INTR_DEFAULT;
-        adapter->coal.normal.data.rx_time_us =
-                QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
-        adapter->coal.normal.data.rx_packets =
-                QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
-        adapter->coal.normal.data.tx_time_us =
-                QLCNIC_DEFAULT_INTR_COALESCE_TX_TIME_US;
-        adapter->coal.normal.data.tx_packets =
-                QLCNIC_DEFAULT_INTR_COALESCE_TX_PACKETS;
-}
-
 static int
 __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
 {
@@ -1115,14 +1116,14 @@ __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
                 return -EIO;
 
         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
-                rds_ring = &adapter->recv_ctx.rds_rings[ring];
-                qlcnic_post_rx_buffers(adapter, ring, rds_ring);
+                rds_ring = &adapter->recv_ctx->rds_rings[ring];
+                qlcnic_post_rx_buffers(adapter, rds_ring);
         }
 
         qlcnic_set_multi(netdev);
         qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
 
-        adapter->ahw.linkup = 0;
+        adapter->ahw->linkup = 0;
 
         if (adapter->max_sds_rings > 1)
                 qlcnic_config_rss(adapter, 1);
@@ -1230,8 +1231,6 @@ qlcnic_attach(struct qlcnic_adapter *adapter)
                 goto err_out_free_hw;
         }
 
-        qlcnic_init_coalesce_defaults(adapter);
-
         qlcnic_create_sysfs_entries(adapter);
 
         adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
@@ -1272,7 +1271,7 @@ void qlcnic_diag_free_res(struct net_device *netdev, int max_sds_rings)
         clear_bit(__QLCNIC_DEV_UP, &adapter->state);
         if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
                 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
-                        sds_ring = &adapter->recv_ctx.sds_rings[ring];
+                        sds_ring = &adapter->recv_ctx->sds_rings[ring];
                         qlcnic_disable_int(sds_ring);
                 }
         }
@@ -1293,6 +1292,44 @@ out:
         netif_device_attach(netdev);
 }
 
+static int qlcnic_alloc_adapter_resources(struct qlcnic_adapter *adapter)
+{
+        int err = 0;
+        adapter->ahw = kzalloc(sizeof(struct qlcnic_hardware_context),
+                                GFP_KERNEL);
+        if (!adapter->ahw) {
+                dev_err(&adapter->pdev->dev,
+                        "Failed to allocate recv ctx resources for adapter\n");
+                err = -ENOMEM;
+                goto err_out;
+        }
+        adapter->recv_ctx = kzalloc(sizeof(struct qlcnic_recv_context),
+                                GFP_KERNEL);
+        if (!adapter->recv_ctx) {
+                dev_err(&adapter->pdev->dev,
+                        "Failed to allocate recv ctx resources for adapter\n");
+                kfree(adapter->ahw);
+                adapter->ahw = NULL;
+                err = -ENOMEM;
+                goto err_out;
+        }
+        /* Initialize interrupt coalesce parameters */
+        adapter->ahw->coal.flag = QLCNIC_INTR_DEFAULT;
+        adapter->ahw->coal.rx_time_us = QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
+        adapter->ahw->coal.rx_packets = QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
+err_out:
+        return err;
+}
+
+static void qlcnic_free_adapter_resources(struct qlcnic_adapter *adapter)
+{
+        kfree(adapter->recv_ctx);
+        adapter->recv_ctx = NULL;
+
+        kfree(adapter->ahw);
+        adapter->ahw = NULL;
+}
+
 int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
 {
         struct qlcnic_adapter *adapter = netdev_priv(netdev);
@@ -1325,13 +1362,13 @@ int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
         }
 
         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
-                rds_ring = &adapter->recv_ctx.rds_rings[ring];
-                qlcnic_post_rx_buffers(adapter, ring, rds_ring);
+                rds_ring = &adapter->recv_ctx->rds_rings[ring];
+                qlcnic_post_rx_buffers(adapter, rds_ring);
         }
 
         if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
                 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
-                        sds_ring = &adapter->recv_ctx.sds_rings[ring];
+                        sds_ring = &adapter->recv_ctx->sds_rings[ring];
                         qlcnic_enable_int(sds_ring);
                 }
         }
@@ -1413,7 +1450,7 @@ qlcnic_setup_netdev(struct qlcnic_adapter *adapter,
         netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
                 NETIF_F_IPV6_CSUM | NETIF_F_GRO | NETIF_F_HW_VLAN_RX);
         netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
-                NETIF_F_IPV6_CSUM);
+                NETIF_F_IPV6_CSUM | NETIF_F_HW_VLAN_FILTER);
 
         if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO) {
                 netdev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
@@ -1501,23 +1538,26 @@ qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         adapter = netdev_priv(netdev);
         adapter->netdev  = netdev;
         adapter->pdev    = pdev;
-        adapter->dev_rst_time = jiffies;
 
+        if (qlcnic_alloc_adapter_resources(adapter))
+                goto err_out_free_netdev;
+
+        adapter->dev_rst_time = jiffies;
         revision_id = pdev->revision;
-        adapter->ahw.revision_id = revision_id;
+        adapter->ahw->revision_id = revision_id;
 
-        rwlock_init(&adapter->ahw.crb_lock);
-        mutex_init(&adapter->ahw.mem_lock);
+        rwlock_init(&adapter->ahw->crb_lock);
+        mutex_init(&adapter->ahw->mem_lock);
 
         spin_lock_init(&adapter->tx_clean_lock);
         INIT_LIST_HEAD(&adapter->mac_list);
 
         err = qlcnic_setup_pci_map(adapter);
         if (err)
-                goto err_out_free_netdev;
+                goto err_out_free_hw;
 
         /* This will be reset for mezz cards  */
-        adapter->portnum = adapter->ahw.pci_func;
+        adapter->portnum = adapter->ahw->pci_func;
 
         err = qlcnic_get_board_info(adapter);
         if (err) {
@@ -1545,7 +1585,7 @@ qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
                 pr_info("%s: %s Board Chip rev 0x%x\n",
                                 module_name(THIS_MODULE),
-                                brd_name, adapter->ahw.revision_id);
+                                brd_name, adapter->ahw->revision_id);
         }
 
         qlcnic_clear_stats(adapter);
@@ -1560,7 +1600,7 @@ qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
 
-        switch (adapter->ahw.port_type) {
+        switch (adapter->ahw->port_type) {
         case QLCNIC_GBE:
                 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
                                 adapter->netdev->name);
@@ -1585,6 +1625,9 @@ err_out_decr_ref:
 err_out_iounmap:
         qlcnic_cleanup_pci_map(adapter);
 
+err_out_free_hw:
+        qlcnic_free_adapter_resources(adapter);
+
 err_out_free_netdev:
         free_netdev(netdev);
 
@@ -1638,6 +1681,7 @@ static void __devexit qlcnic_remove(struct pci_dev *pdev)
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
 
+        qlcnic_free_adapter_resources(adapter);
         free_netdev(netdev);
 }
 static int __qlcnic_shutdown(struct pci_dev *pdev)
@@ -1819,6 +1863,7 @@ static void qlcnic_change_filter(struct qlcnic_adapter *adapter,
         vlan_req->vlan_id = vlan_id;
 
         tx_ring->producer = get_next_index(producer, tx_ring->num_desc);
+        smp_mb();
 }
 
 #define QLCNIC_MAC_HASH(MAC)\
@@ -1879,58 +1924,122 @@ qlcnic_send_filter(struct qlcnic_adapter *adapter,
         spin_unlock(&adapter->mac_learn_lock);
 }
 
-static void
-qlcnic_tso_check(struct net_device *netdev,
-                struct qlcnic_host_tx_ring *tx_ring,
+static int
+qlcnic_tx_pkt(struct qlcnic_adapter *adapter,
                 struct cmd_desc_type0 *first_desc,
                 struct sk_buff *skb)
 {
-        u8 opcode = TX_ETHER_PKT;
-        __be16 protocol = skb->protocol;
-        u16 flags = 0;
-        int copied, offset, copy_len, hdr_len = 0, tso = 0;
+        u8 opcode = 0, hdr_len = 0;
+        u16 flags = 0, vlan_tci = 0;
+        int copied, offset, copy_len;
         struct cmd_desc_type0 *hwdesc;
         struct vlan_ethhdr *vh;
-        struct qlcnic_adapter *adapter = netdev_priv(netdev);
+        struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
+        u16 protocol = ntohs(skb->protocol);
         u32 producer = tx_ring->producer;
-        __le16 vlan_oob = first_desc->flags_opcode &
-                                cpu_to_le16(FLAGS_VLAN_OOB);
+
+        if (protocol == ETH_P_8021Q) {
+                vh = (struct vlan_ethhdr *)skb->data;
+                flags = FLAGS_VLAN_TAGGED;
+                vlan_tci = vh->h_vlan_TCI;
+        } else if (vlan_tx_tag_present(skb)) {
+                flags = FLAGS_VLAN_OOB;
+                vlan_tci = vlan_tx_tag_get(skb);
+        }
+        if (unlikely(adapter->pvid)) {
+                if (vlan_tci && !(adapter->flags & QLCNIC_TAGGING_ENABLED))
+                        return -EIO;
+                if (vlan_tci && (adapter->flags & QLCNIC_TAGGING_ENABLED))
+                        goto set_flags;
+
+                flags = FLAGS_VLAN_OOB;
+                vlan_tci = adapter->pvid;
+        }
+set_flags:
+        qlcnic_set_tx_vlan_tci(first_desc, vlan_tci);
+        qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
 
         if (*(skb->data) & BIT_0) {
                 flags |= BIT_0;
                 memcpy(&first_desc->eth_addr, skb->data, ETH_ALEN);
         }
-
-        if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
+        opcode = TX_ETHER_PKT;
+        if ((adapter->netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
                         skb_shinfo(skb)->gso_size > 0) {
 
                 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
 
                 first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
                 first_desc->total_hdr_length = hdr_len;
-                if (vlan_oob) {
+
+                opcode = (protocol == ETH_P_IPV6) ? TX_TCP_LSO6 : TX_TCP_LSO;
+
+                /* For LSO, we need to copy the MAC/IP/TCP headers into
+                * the descriptor ring */
+                copied = 0;
+                offset = 2;
+
+                if (flags & FLAGS_VLAN_OOB) {
                         first_desc->total_hdr_length += VLAN_HLEN;
                         first_desc->tcp_hdr_offset = VLAN_HLEN;
                         first_desc->ip_hdr_offset = VLAN_HLEN;
                         /* Only in case of TSO on vlan device */
                         flags |= FLAGS_VLAN_TAGGED;
+
+                        /* Create a TSO vlan header template for firmware */
+
+                        hwdesc = &tx_ring->desc_head[producer];
+                        tx_ring->cmd_buf_arr[producer].skb = NULL;
+
+                        copy_len = min((int)sizeof(struct cmd_desc_type0) -
+                                offset, hdr_len + VLAN_HLEN);
+
+                        vh = (struct vlan_ethhdr *)((char *) hwdesc + 2);
+                        skb_copy_from_linear_data(skb, vh, 12);
+                        vh->h_vlan_proto = htons(ETH_P_8021Q);
+                        vh->h_vlan_TCI = htons(vlan_tci);
+
+                        skb_copy_from_linear_data_offset(skb, 12,
+                                (char *)vh + 16, copy_len - 16);
+
+                        copied = copy_len - VLAN_HLEN;
+                        offset = 0;
+
+                        producer = get_next_index(producer, tx_ring->num_desc);
                 }
 
-                opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
-                                TX_TCP_LSO6 : TX_TCP_LSO;
-                tso = 1;
+                while (copied < hdr_len) {
+
+                        copy_len = min((int)sizeof(struct cmd_desc_type0) -
+                                offset, (hdr_len - copied));
+
+                        hwdesc = &tx_ring->desc_head[producer];
+                        tx_ring->cmd_buf_arr[producer].skb = NULL;
+
+                        skb_copy_from_linear_data_offset(skb, copied,
+                                 (char *) hwdesc + offset, copy_len);
+
+                        copied += copy_len;
+                        offset = 0;
+
+                        producer = get_next_index(producer, tx_ring->num_desc);
+                }
+
+                tx_ring->producer = producer;
+                smp_mb();
+                adapter->stats.lso_frames++;
 
         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
                 u8 l4proto;
 
-                if (protocol == cpu_to_be16(ETH_P_IP)) {
+                if (protocol == ETH_P_IP) {
                         l4proto = ip_hdr(skb)->protocol;
 
                         if (l4proto == IPPROTO_TCP)
                                 opcode = TX_TCP_PKT;
                         else if (l4proto == IPPROTO_UDP)
                                 opcode = TX_UDP_PKT;
-                } else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
+                } else if (protocol == ETH_P_IPV6) {
                         l4proto = ipv6_hdr(skb)->nexthdr;
 
                         if (l4proto == IPPROTO_TCP)
@@ -1939,63 +2048,11 @@ qlcnic_tso_check(struct net_device *netdev,
                                 opcode = TX_UDPV6_PKT;
                 }
         }
-
         first_desc->tcp_hdr_offset += skb_transport_offset(skb);
         first_desc->ip_hdr_offset += skb_network_offset(skb);
         qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
 
-        if (!tso)
-                return;
-
-        /* For LSO, we need to copy the MAC/IP/TCP headers into
-         * the descriptor ring
-         */
-        copied = 0;
-        offset = 2;
-
-        if (vlan_oob) {
-                /* Create a TSO vlan header template for firmware */
-
-                hwdesc = &tx_ring->desc_head[producer];
-                tx_ring->cmd_buf_arr[producer].skb = NULL;
-
-                copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
-                                hdr_len + VLAN_HLEN);
-
-                vh = (struct vlan_ethhdr *)((char *)hwdesc + 2);
-                skb_copy_from_linear_data(skb, vh, 12);
-                vh->h_vlan_proto = htons(ETH_P_8021Q);
-                vh->h_vlan_TCI = (__be16)swab16((u16)first_desc->vlan_TCI);
-
-                skb_copy_from_linear_data_offset(skb, 12,
-                                (char *)vh + 16, copy_len - 16);
-
-                copied = copy_len - VLAN_HLEN;
-                offset = 0;
-
-                producer = get_next_index(producer, tx_ring->num_desc);
-        }
-
-        while (copied < hdr_len) {
-
-                copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
-                                (hdr_len - copied));
-
-                hwdesc = &tx_ring->desc_head[producer];
-                tx_ring->cmd_buf_arr[producer].skb = NULL;
-
-                skb_copy_from_linear_data_offset(skb, copied,
-                                 (char *)hwdesc + offset, copy_len);
-
-                copied += copy_len;
-                offset = 0;
-
-                producer = get_next_index(producer, tx_ring->num_desc);
-        }
-
-        tx_ring->producer = producer;
-        barrier();
-        adapter->stats.lso_frames++;
+        return 0;
 }
 
 static int
@@ -2046,39 +2103,21 @@ out_err:
         return -ENOMEM;
 }
 
-static int
-qlcnic_check_tx_tagging(struct qlcnic_adapter *adapter,
-                        struct sk_buff *skb,
-                        struct cmd_desc_type0 *first_desc)
+static void
+qlcnic_unmap_buffers(struct pci_dev *pdev, struct sk_buff *skb,
+                        struct qlcnic_cmd_buffer *pbuf)
 {
-        u8 opcode = 0;
-        u16 flags = 0;
-        __be16 protocol = skb->protocol;
-        struct vlan_ethhdr *vh;
+        struct qlcnic_skb_frag *nf = &pbuf->frag_array[0];
+        int nr_frags = skb_shinfo(skb)->nr_frags;
+        int i;
 
-        if (protocol == cpu_to_be16(ETH_P_8021Q)) {
-                vh = (struct vlan_ethhdr *)skb->data;
-                protocol = vh->h_vlan_encapsulated_proto;
-                flags = FLAGS_VLAN_TAGGED;
-                qlcnic_set_tx_vlan_tci(first_desc, ntohs(vh->h_vlan_TCI));
-        } else if (vlan_tx_tag_present(skb)) {
-                flags = FLAGS_VLAN_OOB;
-                qlcnic_set_tx_vlan_tci(first_desc, vlan_tx_tag_get(skb));
+        for (i = 0; i < nr_frags; i++) {
+                nf = &pbuf->frag_array[i+1];
+                pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
         }
-        if (unlikely(adapter->pvid)) {
-                if (first_desc->vlan_TCI &&
-                                !(adapter->flags & QLCNIC_TAGGING_ENABLED))
-                        return -EIO;
-                if (first_desc->vlan_TCI &&
-                                (adapter->flags & QLCNIC_TAGGING_ENABLED))
-                        goto set_flags;
 
-                flags = FLAGS_VLAN_OOB;
-                qlcnic_set_tx_vlan_tci(first_desc, adapter->pvid);
-        }
-set_flags:
-        qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
-        return 0;
+        nf = &pbuf->frag_array[0];
+        pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
 }
 
 static inline void
@@ -2102,7 +2141,7 @@ qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         int i, k;
 
         u32 producer;
-        int frag_count, no_of_desc;
+        int frag_count;
         u32 num_txd = tx_ring->num_desc;
 
         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
@@ -2119,12 +2158,8 @@ qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 
         frag_count = skb_shinfo(skb)->nr_frags + 1;
 
-        /* 4 fragments per cmd des */
-        no_of_desc = (frag_count + 3) >> 2;
-
         if (unlikely(qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH)) {
                 netif_stop_queue(netdev);
-                smp_mb();
                 if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH)
                         netif_start_queue(netdev);
                 else {
@@ -2141,9 +2176,6 @@ qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         first_desc = hwdesc = &tx_ring->desc_head[producer];
         qlcnic_clear_cmddesc((u64 *)hwdesc);
 
-        if (qlcnic_check_tx_tagging(adapter, skb, first_desc))
-                goto drop_packet;
-
         if (qlcnic_map_tx_skb(pdev, skb, pbuf)) {
                 adapter->stats.tx_dma_map_error++;
                 goto drop_packet;
@@ -2187,8 +2219,10 @@ qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         }
 
         tx_ring->producer = get_next_index(producer, num_txd);
+        smp_mb();
 
-        qlcnic_tso_check(netdev, tx_ring, first_desc, skb);
+        if (unlikely(qlcnic_tx_pkt(adapter, first_desc, skb)))
+                goto unwind_buff;
 
         if (qlcnic_mac_learn)
                 qlcnic_send_filter(adapter, tx_ring, first_desc, skb);
@@ -2200,6 +2234,8 @@ qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 
         return NETDEV_TX_OK;
 
+unwind_buff:
+        qlcnic_unmap_buffers(pdev, skb, pbuf);
 drop_packet:
         adapter->stats.txdropped++;
         dev_kfree_skb_any(skb);
@@ -2246,16 +2282,16 @@ void qlcnic_advert_link_change(struct qlcnic_adapter *adapter, int linkup)
 {
         struct net_device *netdev = adapter->netdev;
 
-        if (adapter->ahw.linkup && !linkup) {
+        if (adapter->ahw->linkup && !linkup) {
                 netdev_info(netdev, "NIC Link is down\n");
-                adapter->ahw.linkup = 0;
+                adapter->ahw->linkup = 0;
                 if (netif_running(netdev)) {
                         netif_carrier_off(netdev);
                         netif_stop_queue(netdev);
                 }
-        } else if (!adapter->ahw.linkup && linkup) {
+        } else if (!adapter->ahw->linkup && linkup) {
                 netdev_info(netdev, "NIC Link is up\n");
-                adapter->ahw.linkup = 1;
+                adapter->ahw->linkup = 1;
                 if (netif_running(netdev)) {
                         netif_carrier_on(netdev);
                         netif_wake_queue(netdev);
@@ -2491,7 +2527,7 @@ static void qlcnic_poll_controller(struct net_device *netdev)
         int ring;
         struct qlcnic_host_sds_ring *sds_ring;
         struct qlcnic_adapter *adapter = netdev_priv(netdev);
-        struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
+        struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 
         disable_irq(adapter->irq);
         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
@@ -3501,7 +3537,7 @@ validate_esw_config(struct qlcnic_adapter *adapter,
         u8 pci_func;
         int i;
 
-        op_mode = readl(adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE);
+        op_mode = readl(adapter->ahw->pci_base0 + QLCNIC_DRV_OP_MODE);
 
         for (i = 0; i < count; i++) {
                 pci_func = esw_cfg[i].pci_func;
@@ -3567,13 +3603,13 @@ qlcnic_sysfs_write_esw_config(struct file *file, struct kobject *kobj,
                         if (qlcnic_config_switch_port(adapter, &esw_cfg[i]))
                                 return QL_STATUS_INVALID_PARAM;
 
-                if (adapter->ahw.pci_func != esw_cfg[i].pci_func)
+                if (adapter->ahw->pci_func != esw_cfg[i].pci_func)
                         continue;
 
                 op_mode = esw_cfg[i].op_mode;
                 qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]);
                 esw_cfg[i].op_mode = op_mode;
-                esw_cfg[i].pci_func = adapter->ahw.pci_func;
+                esw_cfg[i].pci_func = adapter->ahw->pci_func;
 
                 switch (esw_cfg[i].op_mode) {
                 case QLCNIC_PORT_DEFAULTS:
@@ -3954,14 +3990,14 @@ qlcnic_create_diag_entries(struct qlcnic_adapter *adapter)
                 dev_info(dev, "failed to create crb sysfs entry\n");
         if (device_create_bin_file(dev, &bin_attr_mem))
                 dev_info(dev, "failed to create mem sysfs entry\n");
+        if (device_create_bin_file(dev, &bin_attr_pci_config))
+                dev_info(dev, "failed to create pci config sysfs entry");
         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
                 return;
         if (device_create_bin_file(dev, &bin_attr_esw_config))
                 dev_info(dev, "failed to create esw config sysfs entry");
         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
                 return;
-        if (device_create_bin_file(dev, &bin_attr_pci_config))
-                dev_info(dev, "failed to create pci config sysfs entry");
         if (device_create_bin_file(dev, &bin_attr_npar_config))
                 dev_info(dev, "failed to create npar config sysfs entry");
         if (device_create_bin_file(dev, &bin_attr_pm_config))
@@ -3982,12 +4018,12 @@ qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter)
         device_remove_file(dev, &dev_attr_diag_mode);
         device_remove_bin_file(dev, &bin_attr_crb);
         device_remove_bin_file(dev, &bin_attr_mem);
+        device_remove_bin_file(dev, &bin_attr_pci_config);
         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
                 return;
         device_remove_bin_file(dev, &bin_attr_esw_config);
         if (adapter->op_mode != QLCNIC_MGMT_FUNC)
                 return;
-        device_remove_bin_file(dev, &bin_attr_pci_config);
         device_remove_bin_file(dev, &bin_attr_npar_config);
         device_remove_bin_file(dev, &bin_attr_pm_config);
         device_remove_bin_file(dev, &bin_attr_esw_stats);
@@ -4034,14 +4070,10 @@ qlcnic_restore_indev_addr(struct net_device *netdev, unsigned long event)
 
         qlcnic_config_indev_addr(adapter, netdev, event);
 
-        if (!adapter->vlgrp)
-                return;
-
-        for (vid = 0; vid < VLAN_N_VID; vid++) {
-                dev = vlan_group_get_device(adapter->vlgrp, vid);
+        for_each_set_bit(vid, adapter->vlans, VLAN_N_VID) {
+                dev = vlan_find_dev(netdev, vid);
                 if (!dev)
                         continue;
-
                 qlcnic_config_indev_addr(adapter, dev, event);
         }
 }
diff --git a/drivers/net/qlge/qlge_ethtool.c b/drivers/net/qlge/qlge_ethtool.c
index 8149cc9de4ca..687754da2a9f 100644
--- a/drivers/net/qlge/qlge_ethtool.c
+++ b/drivers/net/qlge/qlge_ethtool.c
@@ -412,31 +412,31 @@ static int ql_set_wol(struct net_device *ndev, struct ethtool_wolinfo *wol)
         return 0;
 }
 
-static int ql_phys_id(struct net_device *ndev, u32 data)
+static int ql_set_phys_id(struct net_device *ndev,
+                          enum ethtool_phys_id_state state)
+
 {
         struct ql_adapter *qdev = netdev_priv(ndev);
-        u32 led_reg, i;
-        int status;
 
-        /* Save the current LED settings */
-        status = ql_mb_get_led_cfg(qdev);
-        if (status)
-                return status;
-        led_reg = qdev->led_config;
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                /* Save the current LED settings */
+                if (ql_mb_get_led_cfg(qdev))
+                        return -EIO;
 
-        /* Start blinking the led */
-        if (!data || data > 300)
-                data = 300;
-
-        for (i = 0; i < (data * 10); i++)
+                /* Start blinking */
                 ql_mb_set_led_cfg(qdev, QL_LED_BLINK);
+                return 0;
 
-        /* Restore LED settings */
-        status = ql_mb_set_led_cfg(qdev, led_reg);
-        if (status)
-                return status;
+        case ETHTOOL_ID_INACTIVE:
+                /* Restore LED settings */
+                if (ql_mb_set_led_cfg(qdev, qdev->led_config))
+                        return -EIO;
+                return 0;
 
-        return 0;
+        default:
+                return -EINVAL;
+        }
 }
 
 static int ql_start_loopback(struct ql_adapter *qdev)
@@ -703,7 +703,7 @@ const struct ethtool_ops qlge_ethtool_ops = {
         .get_msglevel = ql_get_msglevel,
         .set_msglevel = ql_set_msglevel,
         .get_link = ethtool_op_get_link,
-        .phys_id                 = ql_phys_id,
+        .set_phys_id             = ql_set_phys_id,
         .self_test               = ql_self_test,
         .get_pauseparam          = ql_get_pauseparam,
         .set_pauseparam          = ql_set_pauseparam,
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 493b0de3848b..058524f3eb49 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -37,6 +37,8 @@
 
 #define FIRMWARE_8168D_1        "rtl_nic/rtl8168d-1.fw"
 #define FIRMWARE_8168D_2        "rtl_nic/rtl8168d-2.fw"
+#define FIRMWARE_8168E_1        "rtl_nic/rtl8168e-1.fw"
+#define FIRMWARE_8168E_2        "rtl_nic/rtl8168e-2.fw"
 #define FIRMWARE_8105E_1        "rtl_nic/rtl8105e-1.fw"
 
 #ifdef RTL8169_DEBUG
@@ -127,6 +129,9 @@ enum mac_version {
         RTL_GIGA_MAC_VER_28 = 0x1c, // 8168DP
         RTL_GIGA_MAC_VER_29 = 0x1d, // 8105E
         RTL_GIGA_MAC_VER_30 = 0x1e, // 8105E
+        RTL_GIGA_MAC_VER_31 = 0x1f, // 8168DP
+        RTL_GIGA_MAC_VER_32 = 0x20, // 8168E
+        RTL_GIGA_MAC_VER_33 = 0x21, // 8168E
 };
 
 #define _R(NAME,MAC,MASK) \
@@ -166,7 +171,10 @@ static const struct {
         _R("RTL8168dp/8111dp",  RTL_GIGA_MAC_VER_27, 0xff7e1880), // PCI-E
         _R("RTL8168dp/8111dp",  RTL_GIGA_MAC_VER_28, 0xff7e1880), // PCI-E
         _R("RTL8105e",          RTL_GIGA_MAC_VER_29, 0xff7e1880), // PCI-E
-        _R("RTL8105e",          RTL_GIGA_MAC_VER_30, 0xff7e1880)  // PCI-E
+        _R("RTL8105e",          RTL_GIGA_MAC_VER_30, 0xff7e1880), // PCI-E
+        _R("RTL8168dp/8111dp",  RTL_GIGA_MAC_VER_31, 0xff7e1880), // PCI-E
+        _R("RTL8168e/8111e",    RTL_GIGA_MAC_VER_32, 0xff7e1880), // PCI-E
+        _R("RTL8168e/8111e",    RTL_GIGA_MAC_VER_33, 0xff7e1880)  // PCI-E
 };
 #undef _R
 
@@ -315,7 +323,9 @@ enum rtl8168_registers {
 #define OCPAR_FLAG                      0x80000000
 #define OCPAR_GPHY_WRITE_CMD            0x8000f060
 #define OCPAR_GPHY_READ_CMD             0x0000f060
-        RDSAR1                  = 0xd0  /* 8168c only. Undocumented on 8168dp */
+        RDSAR1                  = 0xd0, /* 8168c only. Undocumented on 8168dp */
+        MISC                    = 0xf0, /* 8168e only. */
+        txpla_rst                       = (1 << 29)
 };
 
 enum rtl_register_content {
@@ -393,6 +403,7 @@ enum rtl_register_content {
         BWF             = (1 << 6),     /* Accept Broadcast wakeup frame */
         MWF             = (1 << 5),     /* Accept Multicast wakeup frame */
         UWF             = (1 << 4),     /* Accept Unicast wakeup frame */
+        spi_en          = (1 << 3),
         LanWake         = (1 << 1),     /* LanWake enable/disable */
         PMEStatus       = (1 << 0),     /* PME status can be reset by PCI RST# */
 
@@ -577,6 +588,8 @@ MODULE_LICENSE("GPL");
 MODULE_VERSION(RTL8169_VERSION);
 MODULE_FIRMWARE(FIRMWARE_8168D_1);
 MODULE_FIRMWARE(FIRMWARE_8168D_2);
+MODULE_FIRMWARE(FIRMWARE_8168E_1);
+MODULE_FIRMWARE(FIRMWARE_8168E_2);
 MODULE_FIRMWARE(FIRMWARE_8105E_1);
 
 static int rtl8169_open(struct net_device *dev);
@@ -651,12 +664,18 @@ static void rtl8168_oob_notify(struct rtl8169_private *tp, u8 cmd)
 static void rtl8168_driver_start(struct rtl8169_private *tp)
 {
         int i;
+        u32 reg;
 
         rtl8168_oob_notify(tp, OOB_CMD_DRIVER_START);
 
+        if (tp->mac_version == RTL_GIGA_MAC_VER_31)
+                reg = 0xb8;
+        else
+                reg = 0x10;
+
         for (i = 0; i < 10; i++) {
                 msleep(10);
-                if (ocp_read(tp, 0x0f, 0x0010) & 0x00000800)
+                if (ocp_read(tp, 0x0f, reg) & 0x00000800)
                         break;
         }
 }
@@ -664,16 +683,36 @@ static void rtl8168_driver_start(struct rtl8169_private *tp)
 static void rtl8168_driver_stop(struct rtl8169_private *tp)
 {
         int i;
+        u32 reg;
 
         rtl8168_oob_notify(tp, OOB_CMD_DRIVER_STOP);
 
+        if (tp->mac_version == RTL_GIGA_MAC_VER_31)
+                reg = 0xb8;
+        else
+                reg = 0x10;
+
         for (i = 0; i < 10; i++) {
                 msleep(10);
-                if ((ocp_read(tp, 0x0f, 0x0010) & 0x00000800) == 0)
+                if ((ocp_read(tp, 0x0f, reg) & 0x00000800) == 0)
                         break;
         }
 }
 
+static int r8168dp_check_dash(struct rtl8169_private *tp)
+{
+        u32 reg;
+
+        if (tp->mac_version == RTL_GIGA_MAC_VER_31)
+                reg = 0xb8;
+        else
+                reg = 0x10;
+
+        if (ocp_read(tp, 0xF, reg) & 0x00008000)
+                return 1;
+        else
+                return 0;
+}
 
 static void r8169_mdio_write(void __iomem *ioaddr, int reg_addr, int value)
 {
@@ -1247,14 +1286,15 @@ static int rtl8169_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
         return ret;
 }
 
-static u32 rtl8169_get_rx_csum(struct net_device *dev)
+static u32 rtl8169_fix_features(struct net_device *dev, u32 features)
 {
-        struct rtl8169_private *tp = netdev_priv(dev);
+        if (dev->mtu > MSSMask)
+                features &= ~NETIF_F_ALL_TSO;
 
-        return tp->cp_cmd & RxChkSum;
+        return features;
 }
 
-static int rtl8169_set_rx_csum(struct net_device *dev, u32 data)
+static int rtl8169_set_features(struct net_device *dev, u32 features)
 {
         struct rtl8169_private *tp = netdev_priv(dev);
         void __iomem *ioaddr = tp->mmio_addr;
@@ -1262,11 +1302,16 @@ static int rtl8169_set_rx_csum(struct net_device *dev, u32 data)
 
         spin_lock_irqsave(&tp->lock, flags);
 
-        if (data)
+        if (features & NETIF_F_RXCSUM)
                 tp->cp_cmd |= RxChkSum;
         else
                 tp->cp_cmd &= ~RxChkSum;
 
+        if (dev->features & NETIF_F_HW_VLAN_RX)
+                tp->cp_cmd |= RxVlan;
+        else
+                tp->cp_cmd &= ~RxVlan;
+
         RTL_W16(CPlusCmd, tp->cp_cmd);
         RTL_R16(CPlusCmd);
 
@@ -1282,27 +1327,6 @@ static inline u32 rtl8169_tx_vlan_tag(struct rtl8169_private *tp,
                 TxVlanTag | swab16(vlan_tx_tag_get(skb)) : 0x00;
 }
 
-#define NETIF_F_HW_VLAN_TX_RX   (NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX)
-
-static void rtl8169_vlan_mode(struct net_device *dev)
-{
-        struct rtl8169_private *tp = netdev_priv(dev);
-        void __iomem *ioaddr = tp->mmio_addr;
-        unsigned long flags;
-
-        spin_lock_irqsave(&tp->lock, flags);
-        if (dev->features & NETIF_F_HW_VLAN_RX)
-                tp->cp_cmd |= RxVlan;
-        else
-                tp->cp_cmd &= ~RxVlan;
-        RTL_W16(CPlusCmd, tp->cp_cmd);
-        /* PCI commit */
-        RTL_R16(CPlusCmd);
-        spin_unlock_irqrestore(&tp->lock, flags);
-
-        dev->vlan_features = dev->features &~ NETIF_F_HW_VLAN_TX_RX;
-}
-
 static void rtl8169_rx_vlan_tag(struct RxDesc *desc, struct sk_buff *skb)
 {
         u32 opts2 = le32_to_cpu(desc->opts2);
@@ -1483,28 +1507,6 @@ static void rtl8169_get_strings(struct net_device *dev, u32 stringset, u8 *data)
         }
 }
 
-static int rtl8169_set_flags(struct net_device *dev, u32 data)
-{
-        struct rtl8169_private *tp = netdev_priv(dev);
-        unsigned long old_feat = dev->features;
-        int rc;
-
-        if ((tp->mac_version == RTL_GIGA_MAC_VER_05) &&
-            !(data & ETH_FLAG_RXVLAN)) {
-                netif_info(tp, drv, dev, "8110SCd requires hardware Rx VLAN\n");
-                return -EINVAL;
-        }
-
-        rc = ethtool_op_set_flags(dev, data, ETH_FLAG_TXVLAN | ETH_FLAG_RXVLAN);
-        if (rc)
-                return rc;
-
-        if ((old_feat ^ dev->features) & NETIF_F_HW_VLAN_RX)
-                rtl8169_vlan_mode(dev);
-
-        return 0;
-}
-
 static const struct ethtool_ops rtl8169_ethtool_ops = {
         .get_drvinfo            = rtl8169_get_drvinfo,
         .get_regs_len           = rtl8169_get_regs_len,
@@ -1513,19 +1515,12 @@ static const struct ethtool_ops rtl8169_ethtool_ops = {
         .set_settings           = rtl8169_set_settings,
         .get_msglevel           = rtl8169_get_msglevel,
         .set_msglevel           = rtl8169_set_msglevel,
-        .get_rx_csum            = rtl8169_get_rx_csum,
-        .set_rx_csum            = rtl8169_set_rx_csum,
-        .set_tx_csum            = ethtool_op_set_tx_csum,
-        .set_sg                 = ethtool_op_set_sg,
-        .set_tso                = ethtool_op_set_tso,
         .get_regs               = rtl8169_get_regs,
         .get_wol                = rtl8169_get_wol,
         .set_wol                = rtl8169_set_wol,
         .get_strings            = rtl8169_get_strings,
         .get_sset_count         = rtl8169_get_sset_count,
         .get_ethtool_stats      = rtl8169_get_ethtool_stats,
-        .set_flags              = rtl8169_set_flags,
-        .get_flags              = ethtool_op_get_flags,
 };
 
 static void rtl8169_get_mac_version(struct rtl8169_private *tp,
@@ -1547,6 +1542,11 @@ static void rtl8169_get_mac_version(struct rtl8169_private *tp,
                 u32 val;
                 int mac_version;
         } mac_info[] = {
+                /* 8168E family. */
+                { 0x7cf00000, 0x2c200000,       RTL_GIGA_MAC_VER_33 },
+                { 0x7cf00000, 0x2c100000,       RTL_GIGA_MAC_VER_32 },
+                { 0x7c800000, 0x2c000000,       RTL_GIGA_MAC_VER_33 },
+
                 /* 8168D family. */
                 { 0x7cf00000, 0x28300000,       RTL_GIGA_MAC_VER_26 },
                 { 0x7cf00000, 0x28100000,       RTL_GIGA_MAC_VER_25 },
@@ -1555,6 +1555,7 @@ static void rtl8169_get_mac_version(struct rtl8169_private *tp,
                 /* 8168DP family. */
                 { 0x7cf00000, 0x28800000,       RTL_GIGA_MAC_VER_27 },
                 { 0x7cf00000, 0x28a00000,       RTL_GIGA_MAC_VER_28 },
+                { 0x7cf00000, 0x28b00000,       RTL_GIGA_MAC_VER_31 },
 
                 /* 8168C family. */
                 { 0x7cf00000, 0x3cb00000,       RTL_GIGA_MAC_VER_24 },
@@ -1574,6 +1575,7 @@ static void rtl8169_get_mac_version(struct rtl8169_private *tp,
                 { 0x7c800000, 0x30000000,       RTL_GIGA_MAC_VER_11 },
 
                 /* 8101 family. */
+                { 0x7cf00000, 0x40b00000,       RTL_GIGA_MAC_VER_30 },
                 { 0x7cf00000, 0x40a00000,       RTL_GIGA_MAC_VER_30 },
                 { 0x7cf00000, 0x40900000,       RTL_GIGA_MAC_VER_29 },
                 { 0x7c800000, 0x40800000,       RTL_GIGA_MAC_VER_30 },
@@ -2436,6 +2438,93 @@ static void rtl8168d_4_hw_phy_config(struct rtl8169_private *tp)
         rtl_patchphy(tp, 0x0d, 1 << 5);
 }
 
+static void rtl8168e_hw_phy_config(struct rtl8169_private *tp)
+{
+        static const struct phy_reg phy_reg_init[] = {
+                /* Enable Delay cap */
+                { 0x1f, 0x0005 },
+                { 0x05, 0x8b80 },
+                { 0x06, 0xc896 },
+                { 0x1f, 0x0000 },
+
+                /* Channel estimation fine tune */
+                { 0x1f, 0x0001 },
+                { 0x0b, 0x6c20 },
+                { 0x07, 0x2872 },
+                { 0x1c, 0xefff },
+                { 0x1f, 0x0003 },
+                { 0x14, 0x6420 },
+                { 0x1f, 0x0000 },
+
+                /* Update PFM & 10M TX idle timer */
+                { 0x1f, 0x0007 },
+                { 0x1e, 0x002f },
+                { 0x15, 0x1919 },
+                { 0x1f, 0x0000 },
+
+                { 0x1f, 0x0007 },
+                { 0x1e, 0x00ac },
+                { 0x18, 0x0006 },
+                { 0x1f, 0x0000 }
+        };
+
+        rtl_writephy_batch(tp, phy_reg_init, ARRAY_SIZE(phy_reg_init));
+
+        /* DCO enable for 10M IDLE Power */
+        rtl_writephy(tp, 0x1f, 0x0007);
+        rtl_writephy(tp, 0x1e, 0x0023);
+        rtl_w1w0_phy(tp, 0x17, 0x0006, 0x0000);
+        rtl_writephy(tp, 0x1f, 0x0000);
+
+        /* For impedance matching */
+        rtl_writephy(tp, 0x1f, 0x0002);
+        rtl_w1w0_phy(tp, 0x08, 0x8000, 0x7f00);
+        rtl_writephy(tp, 0x1F, 0x0000);
+
+        /* PHY auto speed down */
+        rtl_writephy(tp, 0x1f, 0x0007);
+        rtl_writephy(tp, 0x1e, 0x002d);
+        rtl_w1w0_phy(tp, 0x18, 0x0050, 0x0000);
+        rtl_writephy(tp, 0x1f, 0x0000);
+        rtl_w1w0_phy(tp, 0x14, 0x8000, 0x0000);
+
+        rtl_writephy(tp, 0x1f, 0x0005);
+        rtl_writephy(tp, 0x05, 0x8b86);
+        rtl_w1w0_phy(tp, 0x06, 0x0001, 0x0000);
+        rtl_writephy(tp, 0x1f, 0x0000);
+
+        rtl_writephy(tp, 0x1f, 0x0005);
+        rtl_writephy(tp, 0x05, 0x8b85);
+        rtl_w1w0_phy(tp, 0x06, 0x0000, 0x2000);
+        rtl_writephy(tp, 0x1f, 0x0007);
+        rtl_writephy(tp, 0x1e, 0x0020);
+        rtl_w1w0_phy(tp, 0x15, 0x0000, 0x1100);
+        rtl_writephy(tp, 0x1f, 0x0006);
+        rtl_writephy(tp, 0x00, 0x5a00);
+        rtl_writephy(tp, 0x1f, 0x0000);
+        rtl_writephy(tp, 0x0d, 0x0007);
+        rtl_writephy(tp, 0x0e, 0x003c);
+        rtl_writephy(tp, 0x0d, 0x4007);
+        rtl_writephy(tp, 0x0e, 0x0000);
+        rtl_writephy(tp, 0x0d, 0x0000);
+}
+
+static void rtl8168e_1_hw_phy_config(struct rtl8169_private *tp)
+{
+        if (rtl_apply_firmware(tp, FIRMWARE_8168E_1) < 0)
+                netif_warn(tp, probe, tp->dev, "unable to apply firmware patch\n");
+
+        rtl8168e_hw_phy_config(tp);
+}
+
+static void rtl8168e_2_hw_phy_config(struct rtl8169_private *tp)
+{
+        if (rtl_apply_firmware(tp, FIRMWARE_8168E_2) < 0)
+                netif_warn(tp, probe, tp->dev, "unable to apply firmware patch\n");
+
+        rtl8168e_hw_phy_config(tp);
+}
+
 static void rtl8102e_hw_phy_config(struct rtl8169_private *tp)
 {
         static const struct phy_reg phy_reg_init[] = {
@@ -2551,6 +2640,12 @@ static void rtl_hw_phy_config(struct net_device *dev)
         case RTL_GIGA_MAC_VER_30:
                 rtl8105e_hw_phy_config(tp);
                 break;
+        case RTL_GIGA_MAC_VER_32:
+                rtl8168e_1_hw_phy_config(tp);
+                break;
+        case RTL_GIGA_MAC_VER_33:
+                rtl8168e_2_hw_phy_config(tp);
+                break;
 
         default:
                 break;
@@ -2840,6 +2935,8 @@ static const struct net_device_ops rtl8169_netdev_ops = {
         .ndo_tx_timeout         = rtl8169_tx_timeout,
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_change_mtu         = rtl8169_change_mtu,
+        .ndo_fix_features       = rtl8169_fix_features,
+        .ndo_set_features       = rtl8169_set_features,
         .ndo_set_mac_address    = rtl_set_mac_address,
         .ndo_do_ioctl           = rtl8169_ioctl,
         .ndo_set_multicast_list = rtl_set_rx_mode,
@@ -2859,6 +2956,7 @@ static void __devinit rtl_init_mdio_ops(struct rtl8169_private *tp)
                 ops->read       = r8168dp_1_mdio_read;
                 break;
         case RTL_GIGA_MAC_VER_28:
+        case RTL_GIGA_MAC_VER_31:
                 ops->write      = r8168dp_2_mdio_write;
                 ops->read       = r8168dp_2_mdio_read;
                 break;
@@ -2900,15 +2998,59 @@ static void r810x_pll_power_up(struct rtl8169_private *tp)
 static void r8168_phy_power_up(struct rtl8169_private *tp)
 {
         rtl_writephy(tp, 0x1f, 0x0000);
-        rtl_writephy(tp, 0x0e, 0x0000);
+        switch (tp->mac_version) {
+        case RTL_GIGA_MAC_VER_11:
+        case RTL_GIGA_MAC_VER_12:
+        case RTL_GIGA_MAC_VER_17:
+        case RTL_GIGA_MAC_VER_18:
+        case RTL_GIGA_MAC_VER_19:
+        case RTL_GIGA_MAC_VER_20:
+        case RTL_GIGA_MAC_VER_21:
+        case RTL_GIGA_MAC_VER_22:
+        case RTL_GIGA_MAC_VER_23:
+        case RTL_GIGA_MAC_VER_24:
+        case RTL_GIGA_MAC_VER_25:
+        case RTL_GIGA_MAC_VER_26:
+        case RTL_GIGA_MAC_VER_27:
+        case RTL_GIGA_MAC_VER_28:
+        case RTL_GIGA_MAC_VER_31:
+                rtl_writephy(tp, 0x0e, 0x0000);
+                break;
+        default:
+                break;
+        }
         rtl_writephy(tp, MII_BMCR, BMCR_ANENABLE);
 }
 
 static void r8168_phy_power_down(struct rtl8169_private *tp)
 {
         rtl_writephy(tp, 0x1f, 0x0000);
-        rtl_writephy(tp, 0x0e, 0x0200);
-        rtl_writephy(tp, MII_BMCR, BMCR_PDOWN);
+        switch (tp->mac_version) {
+        case RTL_GIGA_MAC_VER_32:
+        case RTL_GIGA_MAC_VER_33:
+                rtl_writephy(tp, MII_BMCR, BMCR_ANENABLE | BMCR_PDOWN);
+                break;
+
+        case RTL_GIGA_MAC_VER_11:
+        case RTL_GIGA_MAC_VER_12:
+        case RTL_GIGA_MAC_VER_17:
+        case RTL_GIGA_MAC_VER_18:
+        case RTL_GIGA_MAC_VER_19:
+        case RTL_GIGA_MAC_VER_20:
+        case RTL_GIGA_MAC_VER_21:
+        case RTL_GIGA_MAC_VER_22:
+        case RTL_GIGA_MAC_VER_23:
+        case RTL_GIGA_MAC_VER_24:
+        case RTL_GIGA_MAC_VER_25:
+        case RTL_GIGA_MAC_VER_26:
+        case RTL_GIGA_MAC_VER_27:
+        case RTL_GIGA_MAC_VER_28:
+        case RTL_GIGA_MAC_VER_31:
+                rtl_writephy(tp, 0x0e, 0x0200);
+        default:
+                rtl_writephy(tp, MII_BMCR, BMCR_PDOWN);
+                break;
+        }
 }
 
 static void r8168_pll_power_down(struct rtl8169_private *tp)
@@ -2916,8 +3058,9 @@ static void r8168_pll_power_down(struct rtl8169_private *tp)
         void __iomem *ioaddr = tp->mmio_addr;
 
         if (((tp->mac_version == RTL_GIGA_MAC_VER_27) ||
-             (tp->mac_version == RTL_GIGA_MAC_VER_28)) &&
-            (ocp_read(tp, 0x0f, 0x0010) & 0x00008000)) {
+             (tp->mac_version == RTL_GIGA_MAC_VER_28) ||
+             (tp->mac_version == RTL_GIGA_MAC_VER_31)) &&
+            r8168dp_check_dash(tp)) {
                 return;
         }
 
@@ -2927,6 +3070,10 @@ static void r8168_pll_power_down(struct rtl8169_private *tp)
                 return;
         }
 
+        if (tp->mac_version == RTL_GIGA_MAC_VER_32 ||
+            tp->mac_version == RTL_GIGA_MAC_VER_33)
+                rtl_ephy_write(ioaddr, 0x19, 0xff64);
+
         if (__rtl8169_get_wol(tp) & WAKE_ANY) {
                 rtl_writephy(tp, 0x1f, 0x0000);
                 rtl_writephy(tp, MII_BMCR, 0x0000);
@@ -2943,6 +3090,9 @@ static void r8168_pll_power_down(struct rtl8169_private *tp)
         case RTL_GIGA_MAC_VER_26:
         case RTL_GIGA_MAC_VER_27:
         case RTL_GIGA_MAC_VER_28:
+        case RTL_GIGA_MAC_VER_31:
+        case RTL_GIGA_MAC_VER_32:
+        case RTL_GIGA_MAC_VER_33:
                 RTL_W8(PMCH, RTL_R8(PMCH) & ~0x80);
                 break;
         }
@@ -2953,8 +3103,9 @@ static void r8168_pll_power_up(struct rtl8169_private *tp)
         void __iomem *ioaddr = tp->mmio_addr;
 
         if (((tp->mac_version == RTL_GIGA_MAC_VER_27) ||
-             (tp->mac_version == RTL_GIGA_MAC_VER_28)) &&
-            (ocp_read(tp, 0x0f, 0x0010) & 0x00008000)) {
+             (tp->mac_version == RTL_GIGA_MAC_VER_28) ||
+             (tp->mac_version == RTL_GIGA_MAC_VER_31)) &&
+            r8168dp_check_dash(tp)) {
                 return;
         }
 
@@ -2963,6 +3114,9 @@ static void r8168_pll_power_up(struct rtl8169_private *tp)
         case RTL_GIGA_MAC_VER_26:
         case RTL_GIGA_MAC_VER_27:
         case RTL_GIGA_MAC_VER_28:
+        case RTL_GIGA_MAC_VER_31:
+        case RTL_GIGA_MAC_VER_32:
+        case RTL_GIGA_MAC_VER_33:
                 RTL_W8(PMCH, RTL_R8(PMCH) | 0x80);
                 break;
         }
@@ -3017,6 +3171,9 @@ static void __devinit rtl_init_pll_power_ops(struct rtl8169_private *tp)
         case RTL_GIGA_MAC_VER_26:
         case RTL_GIGA_MAC_VER_27:
         case RTL_GIGA_MAC_VER_28:
+        case RTL_GIGA_MAC_VER_31:
+        case RTL_GIGA_MAC_VER_32:
+        case RTL_GIGA_MAC_VER_33:
                 ops->down       = r8168_pll_power_down;
                 ops->up         = r8168_pll_power_up;
                 break;
@@ -3226,7 +3383,19 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         netif_napi_add(dev, &tp->napi, rtl8169_poll, R8169_NAPI_WEIGHT);
 
-        dev->features |= NETIF_F_HW_VLAN_TX_RX | NETIF_F_GRO;
+        /* don't enable SG, IP_CSUM and TSO by default - it might not work
+         * properly for all devices */
+        dev->features |= NETIF_F_RXCSUM |
+                NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
+
+        dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO |
+                NETIF_F_RXCSUM | NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
+        dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO |
+                NETIF_F_HIGHDMA;
+
+        if (tp->mac_version == RTL_GIGA_MAC_VER_05)
+                /* 8110SCd requires hardware Rx VLAN - disallow toggling */
+                dev->hw_features &= ~NETIF_F_HW_VLAN_RX;
 
         tp->intr_mask = 0xffff;
         tp->hw_start = cfg->hw_start;
@@ -3249,7 +3418,8 @@ rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                    (u32)(RTL_R32(TxConfig) & 0x9cf0f8ff), dev->irq);
 
         if ((tp->mac_version == RTL_GIGA_MAC_VER_27) ||
-            (tp->mac_version == RTL_GIGA_MAC_VER_28)) {
+            (tp->mac_version == RTL_GIGA_MAC_VER_28) ||
+            (tp->mac_version == RTL_GIGA_MAC_VER_31)) {
                 rtl8168_driver_start(tp);
         }
 
@@ -3282,7 +3452,8 @@ static void __devexit rtl8169_remove_one(struct pci_dev *pdev)
         struct rtl8169_private *tp = netdev_priv(dev);
 
         if ((tp->mac_version == RTL_GIGA_MAC_VER_27) ||
-            (tp->mac_version == RTL_GIGA_MAC_VER_28)) {
+            (tp->mac_version == RTL_GIGA_MAC_VER_28) ||
+            (tp->mac_version == RTL_GIGA_MAC_VER_31)) {
                 rtl8168_driver_stop(tp);
         }
 
@@ -3344,7 +3515,7 @@ static int rtl8169_open(struct net_device *dev)
 
         rtl8169_init_phy(dev, tp);
 
-        rtl8169_vlan_mode(dev);
+        rtl8169_set_features(dev, dev->features);
 
         rtl_pll_power_up(tp);
 
@@ -3382,7 +3553,8 @@ static void rtl8169_hw_reset(struct rtl8169_private *tp)
         rtl8169_irq_mask_and_ack(ioaddr);
 
         if (tp->mac_version == RTL_GIGA_MAC_VER_27 ||
-            tp->mac_version == RTL_GIGA_MAC_VER_28) {
+            tp->mac_version == RTL_GIGA_MAC_VER_28 ||
+            tp->mac_version == RTL_GIGA_MAC_VER_31) {
                 while (RTL_R8(TxPoll) & NPQ)
                         udelay(20);
 
@@ -3779,6 +3951,17 @@ static void rtl_hw_start_8168d(void __iomem *ioaddr, struct pci_dev *pdev)
         RTL_W16(CPlusCmd, RTL_R16(CPlusCmd) & ~R8168_CPCMD_QUIRK_MASK);
 }
 
+static void rtl_hw_start_8168dp(void __iomem *ioaddr, struct pci_dev *pdev)
+{
+        rtl_csi_access_enable_1(ioaddr);
+
+        rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
+
+        RTL_W8(MaxTxPacketSize, TxPacketMax);
+
+        rtl_disable_clock_request(pdev);
+}
+
 static void rtl_hw_start_8168d_4(void __iomem *ioaddr, struct pci_dev *pdev)
 {
         static const struct ephy_info e_info_8168d_4[] = {
@@ -3805,6 +3988,41 @@ static void rtl_hw_start_8168d_4(void __iomem *ioaddr, struct pci_dev *pdev)
         rtl_enable_clock_request(pdev);
 }
 
+static void rtl_hw_start_8168e(void __iomem *ioaddr, struct pci_dev *pdev)
+{
+        static const struct ephy_info e_info_8168e[] = {
+                { 0x00, 0x0200, 0x0100 },
+                { 0x00, 0x0000, 0x0004 },
+                { 0x06, 0x0002, 0x0001 },
+                { 0x06, 0x0000, 0x0030 },
+                { 0x07, 0x0000, 0x2000 },
+                { 0x00, 0x0000, 0x0020 },
+                { 0x03, 0x5800, 0x2000 },
+                { 0x03, 0x0000, 0x0001 },
+                { 0x01, 0x0800, 0x1000 },
+                { 0x07, 0x0000, 0x4000 },
+                { 0x1e, 0x0000, 0x2000 },
+                { 0x19, 0xffff, 0xfe6c },
+                { 0x0a, 0x0000, 0x0040 }
+        };
+
+        rtl_csi_access_enable_2(ioaddr);
+
+        rtl_ephy_init(ioaddr, e_info_8168e, ARRAY_SIZE(e_info_8168e));
+
+        rtl_tx_performance_tweak(pdev, 0x5 << MAX_READ_REQUEST_SHIFT);
+
+        RTL_W8(MaxTxPacketSize, TxPacketMax);
+
+        rtl_disable_clock_request(pdev);
+
+        /* Reset tx FIFO pointer */
+        RTL_W32(MISC, RTL_R32(MISC) | txpla_rst);
+        RTL_W32(MISC, RTL_R32(MISC) & ~txpla_rst);
+
+        RTL_W8(Config5, RTL_R8(Config5) & ~spi_en);
+}
+
 static void rtl_hw_start_8168(struct net_device *dev)
 {
         struct rtl8169_private *tp = netdev_priv(dev);
@@ -3842,55 +4060,63 @@ static void rtl_hw_start_8168(struct net_device *dev)
         switch (tp->mac_version) {
         case RTL_GIGA_MAC_VER_11:
                 rtl_hw_start_8168bb(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_12:
         case RTL_GIGA_MAC_VER_17:
                 rtl_hw_start_8168bef(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_18:
                 rtl_hw_start_8168cp_1(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_19:
                 rtl_hw_start_8168c_1(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_20:
                 rtl_hw_start_8168c_2(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_21:
                 rtl_hw_start_8168c_3(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_22:
                 rtl_hw_start_8168c_4(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_23:
                 rtl_hw_start_8168cp_2(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_24:
                 rtl_hw_start_8168cp_3(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_25:
         case RTL_GIGA_MAC_VER_26:
         case RTL_GIGA_MAC_VER_27:
                 rtl_hw_start_8168d(ioaddr, pdev);
-        break;
+                break;
 
         case RTL_GIGA_MAC_VER_28:
                 rtl_hw_start_8168d_4(ioaddr, pdev);
-        break;
+                break;
+        case RTL_GIGA_MAC_VER_31:
+                rtl_hw_start_8168dp(ioaddr, pdev);
+                break;
+
+        case RTL_GIGA_MAC_VER_32:
+        case RTL_GIGA_MAC_VER_33:
+                rtl_hw_start_8168e(ioaddr, pdev);
+                break;
 
         default:
                 printk(KERN_ERR PFX "%s: unknown chipset (mac_version = %d).\n",
                         dev->name, tp->mac_version);
-        break;
+                break;
         }
 
         RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
@@ -4062,6 +4288,8 @@ static int rtl8169_change_mtu(struct net_device *dev, int new_mtu)
                 return -EINVAL;
 
         dev->mtu = new_mtu;
+        netdev_update_features(dev);
+
         return 0;
 }
 
@@ -4386,12 +4614,11 @@ err_out:
 
 static inline u32 rtl8169_tso_csum(struct sk_buff *skb, struct net_device *dev)
 {
-        if (dev->features & NETIF_F_TSO) {
-                u32 mss = skb_shinfo(skb)->gso_size;
+        u32 mss = skb_shinfo(skb)->gso_size;
+
+        if (mss)
+                return LargeSend | ((mss & MSSMask) << MSSShift);
 
-                if (mss)
-                        return LargeSend | ((mss & MSSMask) << MSSShift);
-        }
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
                 const struct iphdr *ip = ip_hdr(skb);
 
@@ -4755,6 +4982,7 @@ static irqreturn_t rtl8169_interrupt(int irq, void *dev_instance)
                         case RTL_GIGA_MAC_VER_24:
                         case RTL_GIGA_MAC_VER_27:
                         case RTL_GIGA_MAC_VER_28:
+                        case RTL_GIGA_MAC_VER_31:
                         /* Experimental science. Pktgen proof. */
                         case RTL_GIGA_MAC_VER_12:
                         case RTL_GIGA_MAC_VER_25:
diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index 337bdcd5abc9..ca8e75e9a7ee 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -5484,83 +5484,79 @@ static void s2io_ethtool_gregs(struct net_device *dev,
         }
 }
 
-/**
- *  s2io_phy_id  - timer function that alternates adapter LED.
- *  @data : address of the private member of the device structure, which
- *  is a pointer to the s2io_nic structure, provided as an u32.
- * Description: This is actually the timer function that alternates the
- * adapter LED bit of the adapter control bit to set/reset every time on
- * invocation. The timer is set for 1/2 a second, hence tha NIC blinks
- *  once every second.
+/*
+ *  s2io_set_led - control NIC led
  */
-static void s2io_phy_id(unsigned long data)
+static void s2io_set_led(struct s2io_nic *sp, bool on)
 {
-        struct s2io_nic *sp = (struct s2io_nic *)data;
         struct XENA_dev_config __iomem *bar0 = sp->bar0;
-        u64 val64 = 0;
-        u16 subid;
+        u16 subid = sp->pdev->subsystem_device;
+        u64 val64;
 
-        subid = sp->pdev->subsystem_device;
         if ((sp->device_type == XFRAME_II_DEVICE) ||
             ((subid & 0xFF) >= 0x07)) {
                 val64 = readq(&bar0->gpio_control);
-                val64 ^= GPIO_CTRL_GPIO_0;
+                if (on)
+                        val64 |= GPIO_CTRL_GPIO_0;
+                else
+                        val64 &= ~GPIO_CTRL_GPIO_0;
+
                 writeq(val64, &bar0->gpio_control);
         } else {
                 val64 = readq(&bar0->adapter_control);
-                val64 ^= ADAPTER_LED_ON;
+                if (on)
+                        val64 |= ADAPTER_LED_ON;
+                else
+                        val64 &= ~ADAPTER_LED_ON;
+
                 writeq(val64, &bar0->adapter_control);
         }
 
-        mod_timer(&sp->id_timer, jiffies + HZ / 2);
 }
 
 /**
- * s2io_ethtool_idnic - To physically identify the nic on the system.
- * @sp : private member of the device structure, which is a pointer to the
- * s2io_nic structure.
- * @id : pointer to the structure with identification parameters given by
- * ethtool.
+ * s2io_ethtool_set_led - To physically identify the nic on the system.
+ * @dev : network device
+ * @state: led setting
+ *
  * Description: Used to physically identify the NIC on the system.
  * The Link LED will blink for a time specified by the user for
  * identification.
  * NOTE: The Link has to be Up to be able to blink the LED. Hence
  * identification is possible only if it's link is up.
- * Return value:
- * int , returns 0 on success
  */
 
-static int s2io_ethtool_idnic(struct net_device *dev, u32 data)
+static int s2io_ethtool_set_led(struct net_device *dev,
+                                enum ethtool_phys_id_state state)
 {
-        u64 val64 = 0, last_gpio_ctrl_val;
         struct s2io_nic *sp = netdev_priv(dev);
         struct XENA_dev_config __iomem *bar0 = sp->bar0;
-        u16 subid;
+        u16 subid = sp->pdev->subsystem_device;
 
-        subid = sp->pdev->subsystem_device;
-        last_gpio_ctrl_val = readq(&bar0->gpio_control);
         if ((sp->device_type == XFRAME_I_DEVICE) && ((subid & 0xFF) < 0x07)) {
-                val64 = readq(&bar0->adapter_control);
+                u64 val64 = readq(&bar0->adapter_control);
                 if (!(val64 & ADAPTER_CNTL_EN)) {
                         pr_err("Adapter Link down, cannot blink LED\n");
-                        return -EFAULT;
+                        return -EAGAIN;
                 }
         }
-        if (sp->id_timer.function == NULL) {
-                init_timer(&sp->id_timer);
-                sp->id_timer.function = s2io_phy_id;
-                sp->id_timer.data = (unsigned long)sp;
-        }
-        mod_timer(&sp->id_timer, jiffies);
-        if (data)
-                msleep_interruptible(data * HZ);
-        else
-                msleep_interruptible(MAX_FLICKER_TIME);
-        del_timer_sync(&sp->id_timer);
 
-        if (CARDS_WITH_FAULTY_LINK_INDICATORS(sp->device_type, subid)) {
-                writeq(last_gpio_ctrl_val, &bar0->gpio_control);
-                last_gpio_ctrl_val = readq(&bar0->gpio_control);
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                sp->adapt_ctrl_org = readq(&bar0->gpio_control);
+                return -EINVAL;
+
+        case ETHTOOL_ID_ON:
+                s2io_set_led(sp, true);
+                break;
+
+        case ETHTOOL_ID_OFF:
+                s2io_set_led(sp, false);
+                break;
+
+        case ETHTOOL_ID_INACTIVE:
+                if (CARDS_WITH_FAULTY_LINK_INDICATORS(sp->device_type, subid))
+                        writeq(sp->adapt_ctrl_org, &bar0->gpio_control);
         }
 
         return 0;
@@ -6776,7 +6772,7 @@ static const struct ethtool_ops netdev_ethtool_ops = {
         .set_ufo = ethtool_op_set_ufo,
         .self_test = s2io_ethtool_test,
         .get_strings = s2io_ethtool_get_strings,
-        .phys_id = s2io_ethtool_idnic,
+        .set_phys_id = s2io_ethtool_set_led,
         .get_ethtool_stats = s2io_get_ethtool_stats,
         .get_sset_count = s2io_get_sset_count,
 };
diff --git a/drivers/net/s2io.h b/drivers/net/s2io.h
index 2d144979f6f8..628fd278866a 100644
--- a/drivers/net/s2io.h
+++ b/drivers/net/s2io.h
@@ -893,9 +893,6 @@ struct s2io_nic {
         u16 all_multi_pos;
         u16 promisc_flg;
 
-        /*  Id timer, used to blink NIC to physically identify NIC. */
-        struct timer_list id_timer;
-
         /*  Restart timer, used to restart NIC if the device is stuck and
          *  a schedule task that will set the correct Link state once the
          *  NIC's PHY has stabilized after a state change.
diff --git a/drivers/net/sfc/efx.c b/drivers/net/sfc/efx.c
index d890679e4c4d..db72a6e054e1 100644
--- a/drivers/net/sfc/efx.c
+++ b/drivers/net/sfc/efx.c
@@ -1874,6 +1874,17 @@ static void efx_set_multicast_list(struct net_device *net_dev)
         /* Otherwise efx_start_port() will do this */
 }
 
+static int efx_set_features(struct net_device *net_dev, u32 data)
+{
+        struct efx_nic *efx = netdev_priv(net_dev);
+
+        /* If disabling RX n-tuple filtering, clear existing filters */
+        if (net_dev->features & ~data & NETIF_F_NTUPLE)
+                efx_filter_clear_rx(efx, EFX_FILTER_PRI_MANUAL);
+
+        return 0;
+}
+
 static const struct net_device_ops efx_netdev_ops = {
         .ndo_open               = efx_net_open,
         .ndo_stop               = efx_net_stop,
@@ -1885,6 +1896,7 @@ static const struct net_device_ops efx_netdev_ops = {
         .ndo_change_mtu         = efx_change_mtu,
         .ndo_set_mac_address    = efx_set_mac_address,
         .ndo_set_multicast_list = efx_set_multicast_list,
+        .ndo_set_features       = efx_set_features,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller = efx_netpoll,
 #endif
@@ -2269,7 +2281,6 @@ static int efx_init_struct(struct efx_nic *efx, struct efx_nic_type *type,
         strlcpy(efx->name, pci_name(pci_dev), sizeof(efx->name));
 
         efx->net_dev = net_dev;
-        efx->rx_checksum_enabled = true;
         spin_lock_init(&efx->stats_lock);
         mutex_init(&efx->mac_lock);
         efx->mac_op = type->default_mac_ops;
@@ -2452,12 +2463,15 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev,
                 return -ENOMEM;
         net_dev->features |= (type->offload_features | NETIF_F_SG |
                               NETIF_F_HIGHDMA | NETIF_F_TSO |
-                              NETIF_F_GRO);
+                              NETIF_F_RXCSUM);
         if (type->offload_features & NETIF_F_V6_CSUM)
                 net_dev->features |= NETIF_F_TSO6;
         /* Mask for features that also apply to VLAN devices */
         net_dev->vlan_features |= (NETIF_F_ALL_CSUM | NETIF_F_SG |
-                                   NETIF_F_HIGHDMA | NETIF_F_TSO);
+                                   NETIF_F_HIGHDMA | NETIF_F_ALL_TSO |
+                                   NETIF_F_RXCSUM);
+        /* All offloads can be toggled */
+        net_dev->hw_features = net_dev->features & ~NETIF_F_HIGHDMA;
         efx = netdev_priv(net_dev);
         pci_set_drvdata(pci_dev, efx);
         SET_NETDEV_DEV(net_dev, &pci_dev->dev);
diff --git a/drivers/net/sfc/ethtool.c b/drivers/net/sfc/ethtool.c
index 807178ef65ad..644f7c1d6e7b 100644
--- a/drivers/net/sfc/ethtool.c
+++ b/drivers/net/sfc/ethtool.c
@@ -178,19 +178,27 @@ static struct efx_ethtool_stat efx_ethtool_stats[] = {
  */
 
 /* Identify device by flashing LEDs */
-static int efx_ethtool_phys_id(struct net_device *net_dev, u32 count)
+static int efx_ethtool_phys_id(struct net_device *net_dev,
+                               enum ethtool_phys_id_state state)
 {
         struct efx_nic *efx = netdev_priv(net_dev);
+        enum efx_led_mode mode;
 
-        do {
-                efx->type->set_id_led(efx, EFX_LED_ON);
-                schedule_timeout_interruptible(HZ / 2);
-
-                efx->type->set_id_led(efx, EFX_LED_OFF);
-                schedule_timeout_interruptible(HZ / 2);
-        } while (!signal_pending(current) && --count != 0);
+        switch (state) {
+        case ETHTOOL_ID_ON:
+                mode = EFX_LED_ON;
+                break;
+        case ETHTOOL_ID_OFF:
+                mode = EFX_LED_OFF;
+                break;
+        case ETHTOOL_ID_INACTIVE:
+                mode = EFX_LED_DEFAULT;
+                break;
+        default:
+                return -EINVAL;
+        }
 
-        efx->type->set_id_led(efx, EFX_LED_DEFAULT);
+        efx->type->set_id_led(efx, mode);
         return 0;
 }
 
@@ -518,72 +526,6 @@ static void efx_ethtool_get_stats(struct net_device *net_dev,
         }
 }
 
-static int efx_ethtool_set_tso(struct net_device *net_dev, u32 enable)
-{
-        struct efx_nic *efx __attribute__ ((unused)) = netdev_priv(net_dev);
-        u32 features;
-
-        features = NETIF_F_TSO;
-        if (efx->type->offload_features & NETIF_F_V6_CSUM)
-                features |= NETIF_F_TSO6;
-
-        if (enable)
-                net_dev->features |= features;
-        else
-                net_dev->features &= ~features;
-
-        return 0;
-}
-
-static int efx_ethtool_set_tx_csum(struct net_device *net_dev, u32 enable)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        u32 features = efx->type->offload_features & NETIF_F_ALL_CSUM;
-
-        if (enable)
-                net_dev->features |= features;
-        else
-                net_dev->features &= ~features;
-
-        return 0;
-}
-
-static int efx_ethtool_set_rx_csum(struct net_device *net_dev, u32 enable)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-
-        /* No way to stop the hardware doing the checks; we just
-         * ignore the result.
-         */
-        efx->rx_checksum_enabled = !!enable;
-
-        return 0;
-}
-
-static u32 efx_ethtool_get_rx_csum(struct net_device *net_dev)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-
-        return efx->rx_checksum_enabled;
-}
-
-static int efx_ethtool_set_flags(struct net_device *net_dev, u32 data)
-{
-        struct efx_nic *efx = netdev_priv(net_dev);
-        u32 supported = (efx->type->offload_features &
-                         (ETH_FLAG_RXHASH | ETH_FLAG_NTUPLE));
-        int rc;
-
-        rc = ethtool_op_set_flags(net_dev, data, supported);
-        if (rc)
-                return rc;
-
-        if (!(data & ETH_FLAG_NTUPLE))
-                efx_filter_clear_rx(efx, EFX_FILTER_PRI_MANUAL);
-
-        return 0;
-}
-
 static void efx_ethtool_self_test(struct net_device *net_dev,
                                   struct ethtool_test *test, u64 *data)
 {
@@ -1070,22 +1012,10 @@ const struct ethtool_ops efx_ethtool_ops = {
         .set_ringparam          = efx_ethtool_set_ringparam,
         .get_pauseparam         = efx_ethtool_get_pauseparam,
         .set_pauseparam         = efx_ethtool_set_pauseparam,
-        .get_rx_csum            = efx_ethtool_get_rx_csum,
-        .set_rx_csum            = efx_ethtool_set_rx_csum,
-        .get_tx_csum            = ethtool_op_get_tx_csum,
-        /* Need to enable/disable IPv6 too */
-        .set_tx_csum            = efx_ethtool_set_tx_csum,
-        .get_sg                 = ethtool_op_get_sg,
-        .set_sg                 = ethtool_op_set_sg,
-        .get_tso                = ethtool_op_get_tso,
-        /* Need to enable/disable TSO-IPv6 too */
-        .set_tso                = efx_ethtool_set_tso,
-        .get_flags              = ethtool_op_get_flags,
-        .set_flags              = efx_ethtool_set_flags,
         .get_sset_count         = efx_ethtool_get_sset_count,
         .self_test              = efx_ethtool_self_test,
         .get_strings            = efx_ethtool_get_strings,
-        .phys_id                = efx_ethtool_phys_id,
+        .set_phys_id            = efx_ethtool_phys_id,
         .get_ethtool_stats      = efx_ethtool_get_stats,
         .get_wol                = efx_ethtool_get_wol,
         .set_wol                = efx_ethtool_set_wol,
diff --git a/drivers/net/sfc/net_driver.h b/drivers/net/sfc/net_driver.h
index 9ffa9a6b55a0..92a9067e8e77 100644
--- a/drivers/net/sfc/net_driver.h
+++ b/drivers/net/sfc/net_driver.h
@@ -681,7 +681,6 @@ struct efx_filter_state;
  * @port_inhibited: If set, the netif_carrier is always off. Hold the mac_lock
  * @port_initialized: Port initialized?
  * @net_dev: Operating system network device. Consider holding the rtnl lock
- * @rx_checksum_enabled: RX checksumming enabled
  * @stats_buffer: DMA buffer for statistics
  * @mac_op: MAC interface
  * @phy_type: PHY type
@@ -771,7 +770,6 @@ struct efx_nic {
 
         bool port_initialized;
         struct net_device *net_dev;
-        bool rx_checksum_enabled;
 
         struct efx_buffer stats_buffer;
 
diff --git a/drivers/net/sfc/nic.c b/drivers/net/sfc/nic.c
index e8396614daf3..2594f39c3ba4 100644
--- a/drivers/net/sfc/nic.c
+++ b/drivers/net/sfc/nic.c
@@ -850,7 +850,6 @@ efx_handle_rx_event(struct efx_channel *channel, const efx_qword_t *event)
         unsigned expected_ptr;
         bool rx_ev_pkt_ok, discard = false, checksummed;
         struct efx_rx_queue *rx_queue;
-        struct efx_nic *efx = channel->efx;
 
         /* Basic packet information */
         rx_ev_byte_cnt = EFX_QWORD_FIELD(*event, FSF_AZ_RX_EV_BYTE_CNT);
@@ -873,9 +872,8 @@ efx_handle_rx_event(struct efx_channel *channel, const efx_qword_t *event)
                  * UDP/IP, then we can rely on the hardware checksum.
                  */
                 checksummed =
-                        likely(efx->rx_checksum_enabled) &&
-                        (rx_ev_hdr_type == FSE_CZ_RX_EV_HDR_TYPE_IPV4V6_TCP ||
-                         rx_ev_hdr_type == FSE_CZ_RX_EV_HDR_TYPE_IPV4V6_UDP);
+                        rx_ev_hdr_type == FSE_CZ_RX_EV_HDR_TYPE_IPV4V6_TCP ||
+                        rx_ev_hdr_type == FSE_CZ_RX_EV_HDR_TYPE_IPV4V6_UDP;
         } else {
                 efx_handle_rx_not_ok(rx_queue, event, &rx_ev_pkt_ok, &discard);
                 checksummed = false;
diff --git a/drivers/net/sfc/rx.c b/drivers/net/sfc/rx.c
index c0fdb59030fb..b7dc891b4461 100644
--- a/drivers/net/sfc/rx.c
+++ b/drivers/net/sfc/rx.c
@@ -605,6 +605,9 @@ void __efx_rx_packet(struct efx_channel *channel,
                 skb_record_rx_queue(skb, channel->channel);
         }
 
+        if (unlikely(!(efx->net_dev->features & NETIF_F_RXCSUM)))
+                checksummed = false;
+
         if (likely(checksummed || rx_buf->is_page)) {
                 efx_rx_packet_gro(channel, rx_buf, eh, checksummed);
                 return;
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index 35b28f42d208..310dcbce2519 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -537,46 +537,6 @@ static int skge_nway_reset(struct net_device *dev)
         return 0;
 }
 
-static int skge_set_sg(struct net_device *dev, u32 data)
-{
-        struct skge_port *skge = netdev_priv(dev);
-        struct skge_hw *hw = skge->hw;
-
-        if (hw->chip_id == CHIP_ID_GENESIS && data)
-                return -EOPNOTSUPP;
-        return ethtool_op_set_sg(dev, data);
-}
-
-static int skge_set_tx_csum(struct net_device *dev, u32 data)
-{
-        struct skge_port *skge = netdev_priv(dev);
-        struct skge_hw *hw = skge->hw;
-
-        if (hw->chip_id == CHIP_ID_GENESIS && data)
-                return -EOPNOTSUPP;
-
-        return ethtool_op_set_tx_csum(dev, data);
-}
-
-static u32 skge_get_rx_csum(struct net_device *dev)
-{
-        struct skge_port *skge = netdev_priv(dev);
-
-        return skge->rx_csum;
-}
-
-/* Only Yukon supports checksum offload. */
-static int skge_set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct skge_port *skge = netdev_priv(dev);
-
-        if (skge->hw->chip_id == CHIP_ID_GENESIS && data)
-                return -EOPNOTSUPP;
-
-        skge->rx_csum = data;
-        return 0;
-}
-
 static void skge_get_pauseparam(struct net_device *dev,
                                 struct ethtool_pauseparam *ecmd)
 {
@@ -786,28 +746,27 @@ static void skge_led(struct skge_port *skge, enum led_mode mode)
 }
 
 /* blink LED's for finding board */
-static int skge_phys_id(struct net_device *dev, u32 data)
+static int skge_set_phys_id(struct net_device *dev,
+                            enum ethtool_phys_id_state state)
 {
         struct skge_port *skge = netdev_priv(dev);
-        unsigned long ms;
-        enum led_mode mode = LED_MODE_TST;
 
-        if (!data || data > (u32)(MAX_SCHEDULE_TIMEOUT / HZ))
-                ms = jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT / HZ) * 1000;
-        else
-                ms = data * 1000;
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                return -EINVAL;
 
-        while (ms > 0) {
-                skge_led(skge, mode);
-                mode ^= LED_MODE_TST;
+        case ETHTOOL_ID_ON:
+                skge_led(skge, LED_MODE_TST);
+                break;
 
-                if (msleep_interruptible(BLINK_MS))
-                        break;
-                ms -= BLINK_MS;
-        }
+        case ETHTOOL_ID_OFF:
+                skge_led(skge, LED_MODE_OFF);
+                break;
 
-        /* back to regular LED state */
-        skge_led(skge, netif_running(dev) ? LED_MODE_ON : LED_MODE_OFF);
+        case ETHTOOL_ID_INACTIVE:
+                /* back to regular LED state */
+                skge_led(skge, netif_running(dev) ? LED_MODE_ON : LED_MODE_OFF);
+        }
 
         return 0;
 }
@@ -925,12 +884,8 @@ static const struct ethtool_ops skge_ethtool_ops = {
         .set_pauseparam = skge_set_pauseparam,
         .get_coalesce   = skge_get_coalesce,
         .set_coalesce   = skge_set_coalesce,
-        .set_sg         = skge_set_sg,
-        .set_tx_csum    = skge_set_tx_csum,
-        .get_rx_csum    = skge_get_rx_csum,
-        .set_rx_csum    = skge_set_rx_csum,
         .get_strings    = skge_get_strings,
-        .phys_id        = skge_phys_id,
+        .set_phys_id    = skge_set_phys_id,
         .get_sset_count = skge_get_sset_count,
         .get_ethtool_stats = skge_get_ethtool_stats,
 };
@@ -3085,7 +3040,8 @@ static struct sk_buff *skge_rx_get(struct net_device *dev,
         }
 
         skb_put(skb, len);
-        if (skge->rx_csum) {
+
+        if (dev->features & NETIF_F_RXCSUM) {
                 skb->csum = csum;
                 skb->ip_summed = CHECKSUM_COMPLETE;
         }
@@ -3847,10 +3803,10 @@ static struct net_device *skge_devinit(struct skge_hw *hw, int port,
         setup_timer(&skge->link_timer, xm_link_timer, (unsigned long) skge);
 
         if (hw->chip_id != CHIP_ID_GENESIS) {
-                dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
-                skge->rx_csum = 1;
+                dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG |
+                                   NETIF_F_RXCSUM;
+                dev->features |= dev->hw_features;
         }
-        dev->features |= NETIF_F_GRO;
 
         /* read the mac address */
         memcpy_fromio(dev->dev_addr, hw->regs + B2_MAC_1 + port*8, ETH_ALEN);
diff --git a/drivers/net/skge.h b/drivers/net/skge.h
index 51c0214ac25c..598bf7a1a55e 100644
--- a/drivers/net/skge.h
+++ b/drivers/net/skge.h
@@ -2460,7 +2460,6 @@ struct skge_port {
         struct timer_list    link_timer;
         enum pause_control   flow_control;
         enum pause_status    flow_status;
-        u8                   rx_csum;
         u8                   blink_on;
         u8                   wol;
         u8                   autoneg;   /* AUTONEG_ENABLE, AUTONEG_DISABLE */
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index ff8d262dc276..336c762515b2 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -3826,23 +3826,24 @@ static void sky2_led(struct sky2_port *sky2, enum led_mode mode)
 }
 
 /* blink LED's for finding board */
-static int sky2_phys_id(struct net_device *dev, u32 data)
+static int sky2_set_phys_id(struct net_device *dev,
+                            enum ethtool_phys_id_state state)
 {
         struct sky2_port *sky2 = netdev_priv(dev);
-        unsigned int i;
-
-        if (data == 0)
-                data = UINT_MAX;
 
-        for (i = 0; i < data; i++) {
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                return -EINVAL;
+        case ETHTOOL_ID_INACTIVE:
+                sky2_led(sky2, MO_LED_NORM);
+                break;
+        case ETHTOOL_ID_ON:
                 sky2_led(sky2, MO_LED_ON);
-                if (msleep_interruptible(500))
-                        break;
+                break;
+        case ETHTOOL_ID_OFF:
                 sky2_led(sky2, MO_LED_OFF);
-                if (msleep_interruptible(500))
-                        break;
+                break;
         }
-        sky2_led(sky2, MO_LED_NORM);
 
         return 0;
 }
@@ -4269,7 +4270,7 @@ static const struct ethtool_ops sky2_ethtool_ops = {
         .set_ringparam  = sky2_set_ringparam,
         .get_pauseparam = sky2_get_pauseparam,
         .set_pauseparam = sky2_set_pauseparam,
-        .phys_id        = sky2_phys_id,
+        .set_phys_id    = sky2_set_phys_id,
         .get_sset_count = sky2_get_sset_count,
         .get_ethtool_stats = sky2_get_ethtool_stats,
         .set_flags      = sky2_set_flags,
diff --git a/drivers/net/smsc911x.c b/drivers/net/smsc911x.c
index 4b42ecc63dcf..b8faab7780da 100644
--- a/drivers/net/smsc911x.c
+++ b/drivers/net/smsc911x.c
@@ -29,6 +29,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/crc32.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
@@ -248,8 +250,8 @@ static int smsc911x_mac_complete(struct smsc911x_data *pdata)
                 if (!(val & MAC_CSR_CMD_CSR_BUSY_))
                         return 0;
         }
-        SMSC_WARNING(HW, "Timed out waiting for MAC not BUSY. "
-                "MAC_CSR_CMD: 0x%08X", val);
+        SMSC_WARN(pdata, hw, "Timed out waiting for MAC not BUSY. "
+                  "MAC_CSR_CMD: 0x%08X", val);
         return -EIO;
 }
 
@@ -262,7 +264,7 @@ static u32 smsc911x_mac_read(struct smsc911x_data *pdata, unsigned int offset)
 
         temp = smsc911x_reg_read(pdata, MAC_CSR_CMD);
         if (unlikely(temp & MAC_CSR_CMD_CSR_BUSY_)) {
-                SMSC_WARNING(HW, "MAC busy at entry");
+                SMSC_WARN(pdata, hw, "MAC busy at entry");
                 return 0xFFFFFFFF;
         }
 
@@ -277,7 +279,7 @@ static u32 smsc911x_mac_read(struct smsc911x_data *pdata, unsigned int offset)
         if (likely(smsc911x_mac_complete(pdata) == 0))
                 return smsc911x_reg_read(pdata, MAC_CSR_DATA);
 
-        SMSC_WARNING(HW, "MAC busy after read");
+        SMSC_WARN(pdata, hw, "MAC busy after read");
         return 0xFFFFFFFF;
 }
 
@@ -291,8 +293,8 @@ static void smsc911x_mac_write(struct smsc911x_data *pdata,
 
         temp = smsc911x_reg_read(pdata, MAC_CSR_CMD);
         if (unlikely(temp & MAC_CSR_CMD_CSR_BUSY_)) {
-                SMSC_WARNING(HW,
-                        "smsc911x_mac_write failed, MAC busy at entry");
+                SMSC_WARN(pdata, hw,
+                          "smsc911x_mac_write failed, MAC busy at entry");
                 return;
         }
 
@@ -310,8 +312,7 @@ static void smsc911x_mac_write(struct smsc911x_data *pdata,
         if (likely(smsc911x_mac_complete(pdata) == 0))
                 return;
 
-        SMSC_WARNING(HW,
-                "smsc911x_mac_write failed, MAC busy after write");
+        SMSC_WARN(pdata, hw, "smsc911x_mac_write failed, MAC busy after write");
 }
 
 /* Get a phy register */
@@ -326,8 +327,7 @@ static int smsc911x_mii_read(struct mii_bus *bus, int phyaddr, int regidx)
 
         /* Confirm MII not busy */
         if (unlikely(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
-                SMSC_WARNING(HW,
-                        "MII is busy in smsc911x_mii_read???");
+                SMSC_WARN(pdata, hw, "MII is busy in smsc911x_mii_read???");
                 reg = -EIO;
                 goto out;
         }
@@ -343,7 +343,7 @@ static int smsc911x_mii_read(struct mii_bus *bus, int phyaddr, int regidx)
                         goto out;
                 }
 
-        SMSC_WARNING(HW, "Timed out waiting for MII read to finish");
+        SMSC_WARN(pdata, hw, "Timed out waiting for MII read to finish");
         reg = -EIO;
 
 out:
@@ -364,8 +364,7 @@ static int smsc911x_mii_write(struct mii_bus *bus, int phyaddr, int regidx,
 
         /* Confirm MII not busy */
         if (unlikely(smsc911x_mac_read(pdata, MII_ACC) & MII_ACC_MII_BUSY_)) {
-                SMSC_WARNING(HW,
-                        "MII is busy in smsc911x_mii_write???");
+                SMSC_WARN(pdata, hw, "MII is busy in smsc911x_mii_write???");
                 reg = -EIO;
                 goto out;
         }
@@ -385,7 +384,7 @@ static int smsc911x_mii_write(struct mii_bus *bus, int phyaddr, int regidx,
                         goto out;
                 }
 
-        SMSC_WARNING(HW, "Timed out waiting for MII write to finish");
+        SMSC_WARN(pdata, hw, "Timed out waiting for MII write to finish");
         reg = -EIO;
 
 out:
@@ -426,18 +425,20 @@ static void smsc911x_phy_initialise_external(struct smsc911x_data *pdata)
         unsigned int hwcfg = smsc911x_reg_read(pdata, HW_CFG);
 
         if (pdata->config.flags & SMSC911X_FORCE_INTERNAL_PHY) {
-                SMSC_TRACE(HW, "Forcing internal PHY");
+                SMSC_TRACE(pdata, hw, "Forcing internal PHY");
                 pdata->using_extphy = 0;
         } else if (pdata->config.flags & SMSC911X_FORCE_EXTERNAL_PHY) {
-                SMSC_TRACE(HW, "Forcing external PHY");
+                SMSC_TRACE(pdata, hw, "Forcing external PHY");
                 smsc911x_phy_enable_external(pdata);
                 pdata->using_extphy = 1;
         } else if (hwcfg & HW_CFG_EXT_PHY_DET_) {
-                SMSC_TRACE(HW, "HW_CFG EXT_PHY_DET set, using external PHY");
+                SMSC_TRACE(pdata, hw,
+                           "HW_CFG EXT_PHY_DET set, using external PHY");
                 smsc911x_phy_enable_external(pdata);
                 pdata->using_extphy = 1;
         } else {
-                SMSC_TRACE(HW, "HW_CFG EXT_PHY_DET clear, using internal PHY");
+                SMSC_TRACE(pdata, hw,
+                           "HW_CFG EXT_PHY_DET clear, using internal PHY");
                 pdata->using_extphy = 0;
         }
 }
@@ -509,13 +510,13 @@ static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
                 } while ((i--) && (!status));
 
                 if (!status) {
-                        SMSC_WARNING(HW, "Failed to transmit "
-                                "during loopback test");
+                        SMSC_WARN(pdata, hw,
+                                  "Failed to transmit during loopback test");
                         continue;
                 }
                 if (status & TX_STS_ES_) {
-                        SMSC_WARNING(HW, "Transmit encountered "
-                                "errors during loopback test");
+                        SMSC_WARN(pdata, hw,
+                                  "Transmit encountered errors during loopback test");
                         continue;
                 }
 
@@ -527,13 +528,13 @@ static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
                 } while ((i--) && (!status));
 
                 if (!status) {
-                        SMSC_WARNING(HW,
-                                "Failed to receive during loopback test");
+                        SMSC_WARN(pdata, hw,
+                                  "Failed to receive during loopback test");
                         continue;
                 }
                 if (status & RX_STS_ES_) {
-                        SMSC_WARNING(HW, "Receive encountered "
-                                "errors during loopback test");
+                        SMSC_WARN(pdata, hw,
+                                  "Receive encountered errors during loopback test");
                         continue;
                 }
 
@@ -546,9 +547,9 @@ static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
                 smsc911x_rx_readfifo(pdata, (unsigned int *)bufp, rdsz);
 
                 if (pktlength != (MIN_PACKET_SIZE + 4)) {
-                        SMSC_WARNING(HW, "Unexpected packet size "
-                                "during loop back test, size=%d, will retry",
-                                pktlength);
+                        SMSC_WARN(pdata, hw, "Unexpected packet size "
+                                  "during loop back test, size=%d, will retry",
+                                  pktlength);
                 } else {
                         unsigned int j;
                         int mismatch = 0;
@@ -560,12 +561,12 @@ static int smsc911x_phy_check_loopbackpkt(struct smsc911x_data *pdata)
                                 }
                         }
                         if (!mismatch) {
-                                SMSC_TRACE(HW, "Successfully verified "
+                                SMSC_TRACE(pdata, hw, "Successfully verified "
                                            "loopback packet");
                                 return 0;
                         } else {
-                                SMSC_WARNING(HW, "Data mismatch "
-                                        "during loop back test, will retry");
+                                SMSC_WARN(pdata, hw, "Data mismatch "
+                                          "during loop back test, will retry");
                         }
                 }
         }
@@ -582,7 +583,7 @@ static int smsc911x_phy_reset(struct smsc911x_data *pdata)
         BUG_ON(!phy_dev);
         BUG_ON(!phy_dev->bus);
 
-        SMSC_TRACE(HW, "Performing PHY BCR Reset");
+        SMSC_TRACE(pdata, hw, "Performing PHY BCR Reset");
         smsc911x_mii_write(phy_dev->bus, phy_dev->addr, MII_BMCR, BMCR_RESET);
         do {
                 msleep(1);
@@ -591,7 +592,7 @@ static int smsc911x_phy_reset(struct smsc911x_data *pdata)
         } while ((i--) && (temp & BMCR_RESET));
 
         if (temp & BMCR_RESET) {
-                SMSC_WARNING(HW, "PHY reset failed to complete.");
+                SMSC_WARN(pdata, hw, "PHY reset failed to complete");
                 return -EIO;
         }
         /* Extra delay required because the phy may not be completed with
@@ -695,11 +696,11 @@ static void smsc911x_phy_update_flowcontrol(struct smsc911x_data *pdata)
                 else
                         afc &= ~0xF;
 
-                SMSC_TRACE(HW, "rx pause %s, tx pause %s",
-                        (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
-                        (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
+                SMSC_TRACE(pdata, hw, "rx pause %s, tx pause %s",
+                           (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
+                           (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
         } else {
-                SMSC_TRACE(HW, "half duplex");
+                SMSC_TRACE(pdata, hw, "half duplex");
                 flow = 0;
                 afc |= 0xF;
         }
@@ -722,17 +723,17 @@ static void smsc911x_phy_adjust_link(struct net_device *dev)
 
         if (phy_dev->duplex != pdata->last_duplex) {
                 unsigned int mac_cr;
-                SMSC_TRACE(HW, "duplex state has changed");
+                SMSC_TRACE(pdata, hw, "duplex state has changed");
 
                 spin_lock_irqsave(&pdata->mac_lock, flags);
                 mac_cr = smsc911x_mac_read(pdata, MAC_CR);
                 if (phy_dev->duplex) {
-                        SMSC_TRACE(HW,
-                                "configuring for full duplex mode");
+                        SMSC_TRACE(pdata, hw,
+                                   "configuring for full duplex mode");
                         mac_cr |= MAC_CR_FDPX_;
                 } else {
-                        SMSC_TRACE(HW,
-                                "configuring for half duplex mode");
+                        SMSC_TRACE(pdata, hw,
+                                   "configuring for half duplex mode");
                         mac_cr &= ~MAC_CR_FDPX_;
                 }
                 smsc911x_mac_write(pdata, MAC_CR, mac_cr);
@@ -744,9 +745,9 @@ static void smsc911x_phy_adjust_link(struct net_device *dev)
 
         carrier = netif_carrier_ok(dev);
         if (carrier != pdata->last_carrier) {
-                SMSC_TRACE(HW, "carrier state has changed");
+                SMSC_TRACE(pdata, hw, "carrier state has changed");
                 if (carrier) {
-                        SMSC_TRACE(HW, "configuring for carrier OK");
+                        SMSC_TRACE(pdata, hw, "configuring for carrier OK");
                         if ((pdata->gpio_orig_setting & GPIO_CFG_LED1_EN_) &&
                             (!pdata->using_extphy)) {
                                 /* Restore original GPIO configuration */
@@ -755,7 +756,7 @@ static void smsc911x_phy_adjust_link(struct net_device *dev)
                                         pdata->gpio_setting);
                         }
                 } else {
-                        SMSC_TRACE(HW, "configuring for no carrier");
+                        SMSC_TRACE(pdata, hw, "configuring for no carrier");
                         /* Check global setting that LED1
                          * usage is 10/100 indicator */
                         pdata->gpio_setting = smsc911x_reg_read(pdata,
@@ -787,25 +788,25 @@ static int smsc911x_mii_probe(struct net_device *dev)
         /* find the first phy */
         phydev = phy_find_first(pdata->mii_bus);
         if (!phydev) {
-                pr_err("%s: no PHY found\n", dev->name);
+                netdev_err(dev, "no PHY found\n");
                 return -ENODEV;
         }
 
-        SMSC_TRACE(PROBE, "PHY: addr %d, phy_id 0x%08X",
-                        phydev->addr, phydev->phy_id);
+        SMSC_TRACE(pdata, probe, "PHY: addr %d, phy_id 0x%08X",
+                   phydev->addr, phydev->phy_id);
 
         ret = phy_connect_direct(dev, phydev,
                         &smsc911x_phy_adjust_link, 0,
                         pdata->config.phy_interface);
 
         if (ret) {
-                pr_err("%s: Could not attach to PHY\n", dev->name);
+                netdev_err(dev, "Could not attach to PHY\n");
                 return ret;
         }
 
-        pr_info("%s: attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
-                dev->name, phydev->drv->name,
-                dev_name(&phydev->dev), phydev->irq);
+        netdev_info(dev,
+                    "attached PHY driver [%s] (mii_bus:phy_addr=%s, irq=%d)\n",
+                    phydev->drv->name, dev_name(&phydev->dev), phydev->irq);
 
         /* mask with MAC supported features */
         phydev->supported &= (PHY_BASIC_FEATURES | SUPPORTED_Pause |
@@ -818,13 +819,13 @@ static int smsc911x_mii_probe(struct net_device *dev)
 
 #ifdef USE_PHY_WORK_AROUND
         if (smsc911x_phy_loopbacktest(dev) < 0) {
-                SMSC_WARNING(HW, "Failed Loop Back Test");
+                SMSC_WARN(pdata, hw, "Failed Loop Back Test");
                 return -ENODEV;
         }
-        SMSC_TRACE(HW, "Passed Loop Back Test");
+        SMSC_TRACE(pdata, hw, "Passed Loop Back Test");
 #endif                          /* USE_PHY_WORK_AROUND */
 
-        SMSC_TRACE(HW, "phy initialised successfully");
+        SMSC_TRACE(pdata, hw, "phy initialised successfully");
         return 0;
 }
 
@@ -860,8 +861,8 @@ static int __devinit smsc911x_mii_init(struct platform_device *pdev,
                 smsc911x_phy_initialise_external(pdata);
                 break;
         default:
-                SMSC_TRACE(HW, "External PHY is not supported, "
-                        "using internal PHY");
+                SMSC_TRACE(pdata, hw, "External PHY is not supported, "
+                           "using internal PHY");
                 pdata->using_extphy = 0;
                 break;
         }
@@ -872,12 +873,12 @@ static int __devinit smsc911x_mii_init(struct platform_device *pdev,
         }
 
         if (mdiobus_register(pdata->mii_bus)) {
-                SMSC_WARNING(PROBE, "Error registering mii bus");
+                SMSC_WARN(pdata, probe, "Error registering mii bus");
                 goto err_out_free_bus_2;
         }
 
         if (smsc911x_mii_probe(dev) < 0) {
-                SMSC_WARNING(PROBE, "Error registering mii bus");
+                SMSC_WARN(pdata, probe, "Error registering mii bus");
                 goto err_out_unregister_bus_3;
         }
 
@@ -913,8 +914,7 @@ static void smsc911x_tx_update_txcounters(struct net_device *dev)
                          * does not reference a hardware defined reserved bit
                          * but rather a driver defined one.
                          */
-                        SMSC_WARNING(HW,
-                                "Packet tag reserved bit is high");
+                        SMSC_WARN(pdata, hw, "Packet tag reserved bit is high");
                 } else {
                         if (unlikely(tx_stat & TX_STS_ES_)) {
                                 dev->stats.tx_errors++;
@@ -977,8 +977,8 @@ smsc911x_rx_fastforward(struct smsc911x_data *pdata, unsigned int pktbytes)
                 } while ((val & RX_DP_CTRL_RX_FFWD_) && --timeout);
 
                 if (unlikely(timeout == 0))
-                        SMSC_WARNING(HW, "Timed out waiting for "
-                                "RX FFWD to finish, RX_DP_CTRL: 0x%08X", val);
+                        SMSC_WARN(pdata, hw, "Timed out waiting for "
+                                  "RX FFWD to finish, RX_DP_CTRL: 0x%08X", val);
         } else {
                 unsigned int temp;
                 while (pktwords--)
@@ -1021,8 +1021,8 @@ static int smsc911x_poll(struct napi_struct *napi, int budget)
                 smsc911x_rx_counterrors(dev, rxstat);
 
                 if (unlikely(rxstat & RX_STS_ES_)) {
-                        SMSC_WARNING(RX_ERR,
-                                "Discarding packet with error bit set");
+                        SMSC_WARN(pdata, rx_err,
+                                  "Discarding packet with error bit set");
                         /* Packet has an error, discard it and continue with
                          * the next */
                         smsc911x_rx_fastforward(pdata, pktwords);
@@ -1032,8 +1032,8 @@ static int smsc911x_poll(struct napi_struct *napi, int budget)
 
                 skb = netdev_alloc_skb(dev, pktlength + NET_IP_ALIGN);
                 if (unlikely(!skb)) {
-                        SMSC_WARNING(RX_ERR,
-                                "Unable to allocate skb for rx packet");
+                        SMSC_WARN(pdata, rx_err,
+                                  "Unable to allocate skb for rx packet");
                         /* Drop the packet and stop this polling iteration */
                         smsc911x_rx_fastforward(pdata, pktwords);
                         dev->stats.rx_dropped++;
@@ -1083,8 +1083,8 @@ static void smsc911x_rx_multicast_update(struct smsc911x_data *pdata)
         smsc911x_mac_write(pdata, MAC_CR, mac_cr);
         smsc911x_mac_write(pdata, HASHH, pdata->hashhi);
         smsc911x_mac_write(pdata, HASHL, pdata->hashlo);
-        SMSC_TRACE(HW, "maccr 0x%08X, HASHH 0x%08X, HASHL 0x%08X",
-                mac_cr, pdata->hashhi, pdata->hashlo);
+        SMSC_TRACE(pdata, hw, "maccr 0x%08X, HASHH 0x%08X, HASHL 0x%08X",
+                   mac_cr, pdata->hashhi, pdata->hashlo);
 }
 
 static void smsc911x_rx_multicast_update_workaround(struct smsc911x_data *pdata)
@@ -1102,7 +1102,7 @@ static void smsc911x_rx_multicast_update_workaround(struct smsc911x_data *pdata)
 
         /* Check Rx has stopped */
         if (smsc911x_mac_read(pdata, MAC_CR) & MAC_CR_RXEN_)
-                SMSC_WARNING(DRV, "Rx not stopped");
+                SMSC_WARN(pdata, drv, "Rx not stopped");
 
         /* Perform the update - safe to do now Rx has stopped */
         smsc911x_rx_multicast_update(pdata);
@@ -1131,7 +1131,7 @@ static int smsc911x_soft_reset(struct smsc911x_data *pdata)
         } while ((--timeout) && (temp & HW_CFG_SRST_));
 
         if (unlikely(temp & HW_CFG_SRST_)) {
-                SMSC_WARNING(DRV, "Failed to complete reset");
+                SMSC_WARN(pdata, drv, "Failed to complete reset");
                 return -EIO;
         }
         return 0;
@@ -1160,18 +1160,18 @@ static int smsc911x_open(struct net_device *dev)
 
         /* if the phy is not yet registered, retry later*/
         if (!pdata->phy_dev) {
-                SMSC_WARNING(HW, "phy_dev is NULL");
+                SMSC_WARN(pdata, hw, "phy_dev is NULL");
                 return -EAGAIN;
         }
 
         if (!is_valid_ether_addr(dev->dev_addr)) {
-                SMSC_WARNING(HW, "dev_addr is not a valid MAC address");
+                SMSC_WARN(pdata, hw, "dev_addr is not a valid MAC address");
                 return -EADDRNOTAVAIL;
         }
 
         /* Reset the LAN911x */
         if (smsc911x_soft_reset(pdata)) {
-                SMSC_WARNING(HW, "soft reset failed");
+                SMSC_WARN(pdata, hw, "soft reset failed");
                 return -EIO;
         }
 
@@ -1191,8 +1191,8 @@ static int smsc911x_open(struct net_device *dev)
         }
 
         if (unlikely(timeout == 0))
-                SMSC_WARNING(IFUP,
-                        "Timed out waiting for EEPROM busy bit to clear");
+                SMSC_WARN(pdata, ifup,
+                          "Timed out waiting for EEPROM busy bit to clear");
 
         smsc911x_reg_write(pdata, GPIO_CFG, 0x70070000);
 
@@ -1210,22 +1210,22 @@ static int smsc911x_open(struct net_device *dev)
         intcfg = ((10 << 24) | INT_CFG_IRQ_EN_);
 
         if (pdata->config.irq_polarity) {
-                SMSC_TRACE(IFUP, "irq polarity: active high");
+                SMSC_TRACE(pdata, ifup, "irq polarity: active high");
                 intcfg |= INT_CFG_IRQ_POL_;
         } else {
-                SMSC_TRACE(IFUP, "irq polarity: active low");
+                SMSC_TRACE(pdata, ifup, "irq polarity: active low");
         }
 
         if (pdata->config.irq_type) {
-                SMSC_TRACE(IFUP, "irq type: push-pull");
+                SMSC_TRACE(pdata, ifup, "irq type: push-pull");
                 intcfg |= INT_CFG_IRQ_TYPE_;
         } else {
-                SMSC_TRACE(IFUP, "irq type: open drain");
+                SMSC_TRACE(pdata, ifup, "irq type: open drain");
         }
 
         smsc911x_reg_write(pdata, INT_CFG, intcfg);
 
-        SMSC_TRACE(IFUP, "Testing irq handler using IRQ %d", dev->irq);
+        SMSC_TRACE(pdata, ifup, "Testing irq handler using IRQ %d", dev->irq);
         pdata->software_irq_signal = 0;
         smp_wmb();
 
@@ -1241,14 +1241,15 @@ static int smsc911x_open(struct net_device *dev)
         }
 
         if (!pdata->software_irq_signal) {
-                dev_warn(&dev->dev, "ISR failed signaling test (IRQ %d)\n",
-                         dev->irq);
+                netdev_warn(dev, "ISR failed signaling test (IRQ %d)\n",
+                            dev->irq);
                 return -ENODEV;
         }
-        SMSC_TRACE(IFUP, "IRQ handler passed test using IRQ %d", dev->irq);
+        SMSC_TRACE(pdata, ifup, "IRQ handler passed test using IRQ %d",
+                   dev->irq);
 
-        dev_info(&dev->dev, "SMSC911x/921x identified at %#08lx, IRQ: %d\n",
-                 (unsigned long)pdata->ioaddr, dev->irq);
+        netdev_info(dev, "SMSC911x/921x identified at %#08lx, IRQ: %d\n",
+                    (unsigned long)pdata->ioaddr, dev->irq);
 
         /* Reset the last known duplex and carrier */
         pdata->last_duplex = -1;
@@ -1313,7 +1314,7 @@ static int smsc911x_stop(struct net_device *dev)
         if (pdata->phy_dev)
                 phy_stop(pdata->phy_dev);
 
-        SMSC_TRACE(IFDOWN, "Interface stopped");
+        SMSC_TRACE(pdata, ifdown, "Interface stopped");
         return 0;
 }
 
@@ -1331,8 +1332,8 @@ static int smsc911x_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
         freespace = smsc911x_reg_read(pdata, TX_FIFO_INF) & TX_FIFO_INF_TDFREE_;
 
         if (unlikely(freespace < TX_FIFO_LOW_THRESHOLD))
-                SMSC_WARNING(TX_ERR,
-                        "Tx data fifo low, space available: %d", freespace);
+                SMSC_WARN(pdata, tx_err,
+                          "Tx data fifo low, space available: %d", freespace);
 
         /* Word alignment adjustment */
         tx_cmd_a = (u32)((ulong)skb->data & 0x03) << 16;
@@ -1432,7 +1433,7 @@ static void smsc911x_set_multicast_list(struct net_device *dev)
                  * receiving data */
                 if (!pdata->multicast_update_pending) {
                         unsigned int temp;
-                        SMSC_TRACE(HW, "scheduling mcast update");
+                        SMSC_TRACE(pdata, hw, "scheduling mcast update");
                         pdata->multicast_update_pending = 1;
 
                         /* Request the hardware to stop, then perform the
@@ -1474,7 +1475,7 @@ static irqreturn_t smsc911x_irqhandler(int irq, void *dev_id)
         if (unlikely(intsts & inten & INT_STS_RXSTOP_INT_)) {
                 /* Called when there is a multicast update scheduled and
                  * it is now safe to complete the update */
-                SMSC_TRACE(INTR, "RX Stop interrupt");
+                SMSC_TRACE(pdata, intr, "RX Stop interrupt");
                 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXSTOP_INT_);
                 if (pdata->multicast_update_pending)
                         smsc911x_rx_multicast_update_workaround(pdata);
@@ -1491,7 +1492,7 @@ static irqreturn_t smsc911x_irqhandler(int irq, void *dev_id)
         }
 
         if (unlikely(intsts & inten & INT_STS_RXE_)) {
-                SMSC_TRACE(INTR, "RX Error interrupt");
+                SMSC_TRACE(pdata, intr, "RX Error interrupt");
                 smsc911x_reg_write(pdata, INT_STS, INT_STS_RXE_);
                 serviced = IRQ_HANDLED;
         }
@@ -1505,8 +1506,7 @@ static irqreturn_t smsc911x_irqhandler(int irq, void *dev_id)
                         /* Schedule a NAPI poll */
                         __napi_schedule(&pdata->napi);
                 } else {
-                        SMSC_WARNING(RX_ERR,
-                                "napi_schedule_prep failed");
+                        SMSC_WARN(pdata, rx_err, "napi_schedule_prep failed");
                 }
                 serviced = IRQ_HANDLED;
         }
@@ -1543,7 +1543,7 @@ static int smsc911x_set_mac_address(struct net_device *dev, void *p)
         smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
         spin_unlock_irq(&pdata->mac_lock);
 
-        dev_info(&dev->dev, "MAC Address: %pM\n", dev->dev_addr);
+        netdev_info(dev, "MAC Address: %pM\n", dev->dev_addr);
 
         return 0;
 }
@@ -1649,9 +1649,9 @@ static int smsc911x_eeprom_send_cmd(struct smsc911x_data *pdata, u32 op)
         int timeout = 100;
         u32 e2cmd;
 
-        SMSC_TRACE(DRV, "op 0x%08x", op);
+        SMSC_TRACE(pdata, drv, "op 0x%08x", op);
         if (smsc911x_reg_read(pdata, E2P_CMD) & E2P_CMD_EPC_BUSY_) {
-                SMSC_WARNING(DRV, "Busy at start");
+                SMSC_WARN(pdata, drv, "Busy at start");
                 return -EBUSY;
         }
 
@@ -1664,12 +1664,12 @@ static int smsc911x_eeprom_send_cmd(struct smsc911x_data *pdata, u32 op)
         } while ((e2cmd & E2P_CMD_EPC_BUSY_) && (--timeout));
 
         if (!timeout) {
-                SMSC_TRACE(DRV, "TIMED OUT");
+                SMSC_TRACE(pdata, drv, "TIMED OUT");
                 return -EAGAIN;
         }
 
         if (e2cmd & E2P_CMD_EPC_TIMEOUT_) {
-                SMSC_TRACE(DRV, "Error occurred during eeprom operation");
+                SMSC_TRACE(pdata, drv, "Error occurred during eeprom operation");
                 return -EINVAL;
         }
 
@@ -1682,7 +1682,7 @@ static int smsc911x_eeprom_read_location(struct smsc911x_data *pdata,
         u32 op = E2P_CMD_EPC_CMD_READ_ | address;
         int ret;
 
-        SMSC_TRACE(DRV, "address 0x%x", address);
+        SMSC_TRACE(pdata, drv, "address 0x%x", address);
         ret = smsc911x_eeprom_send_cmd(pdata, op);
 
         if (!ret)
@@ -1698,7 +1698,7 @@ static int smsc911x_eeprom_write_location(struct smsc911x_data *pdata,
         u32 temp;
         int ret;
 
-        SMSC_TRACE(DRV, "address 0x%x, data 0x%x", address, data);
+        SMSC_TRACE(pdata, drv, "address 0x%x, data 0x%x", address, data);
         ret = smsc911x_eeprom_send_cmd(pdata, op);
 
         if (!ret) {
@@ -1811,26 +1811,26 @@ static int __devinit smsc911x_init(struct net_device *dev)
         struct smsc911x_data *pdata = netdev_priv(dev);
         unsigned int byte_test;
 
-        SMSC_TRACE(PROBE, "Driver Parameters:");
-        SMSC_TRACE(PROBE, "LAN base: 0x%08lX",
-                (unsigned long)pdata->ioaddr);
-        SMSC_TRACE(PROBE, "IRQ: %d", dev->irq);
-        SMSC_TRACE(PROBE, "PHY will be autodetected.");
+        SMSC_TRACE(pdata, probe, "Driver Parameters:");
+        SMSC_TRACE(pdata, probe, "LAN base: 0x%08lX",
+                   (unsigned long)pdata->ioaddr);
+        SMSC_TRACE(pdata, probe, "IRQ: %d", dev->irq);
+        SMSC_TRACE(pdata, probe, "PHY will be autodetected.");
 
         spin_lock_init(&pdata->dev_lock);
         spin_lock_init(&pdata->mac_lock);
 
         if (pdata->ioaddr == 0) {
-                SMSC_WARNING(PROBE, "pdata->ioaddr: 0x00000000");
+                SMSC_WARN(pdata, probe, "pdata->ioaddr: 0x00000000");
                 return -ENODEV;
         }
 
         /* Check byte ordering */
         byte_test = smsc911x_reg_read(pdata, BYTE_TEST);
-        SMSC_TRACE(PROBE, "BYTE_TEST: 0x%08X", byte_test);
+        SMSC_TRACE(pdata, probe, "BYTE_TEST: 0x%08X", byte_test);
         if (byte_test == 0x43218765) {
-                SMSC_TRACE(PROBE, "BYTE_TEST looks swapped, "
-                        "applying WORD_SWAP");
+                SMSC_TRACE(pdata, probe, "BYTE_TEST looks swapped, "
+                           "applying WORD_SWAP");
                 smsc911x_reg_write(pdata, WORD_SWAP, 0xffffffff);
 
                 /* 1 dummy read of BYTE_TEST is needed after a write to
@@ -1841,12 +1841,13 @@ static int __devinit smsc911x_init(struct net_device *dev)
         }
 
         if (byte_test != 0x87654321) {
-                SMSC_WARNING(DRV, "BYTE_TEST: 0x%08X", byte_test);
+                SMSC_WARN(pdata, drv, "BYTE_TEST: 0x%08X", byte_test);
                 if (((byte_test >> 16) & 0xFFFF) == (byte_test & 0xFFFF)) {
-                        SMSC_WARNING(PROBE,
-                                "top 16 bits equal to bottom 16 bits");
-                        SMSC_TRACE(PROBE, "This may mean the chip is set "
-                                "for 32 bit while the bus is reading 16 bit");
+                        SMSC_WARN(pdata, probe,
+                                  "top 16 bits equal to bottom 16 bits");
+                        SMSC_TRACE(pdata, probe,
+                                   "This may mean the chip is set "
+                                   "for 32 bit while the bus is reading 16 bit");
                 }
                 return -ENODEV;
         }
@@ -1881,17 +1882,18 @@ static int __devinit smsc911x_init(struct net_device *dev)
                 break;
 
         default:
-                SMSC_WARNING(PROBE, "LAN911x not identified, idrev: 0x%08X",
-                        pdata->idrev);
+                SMSC_WARN(pdata, probe, "LAN911x not identified, idrev: 0x%08X",
+                          pdata->idrev);
                 return -ENODEV;
         }
 
-        SMSC_TRACE(PROBE, "LAN911x identified, idrev: 0x%08X, generation: %d",
-                pdata->idrev, pdata->generation);
+        SMSC_TRACE(pdata, probe,
+                   "LAN911x identified, idrev: 0x%08X, generation: %d",
+                   pdata->idrev, pdata->generation);
 
         if (pdata->generation == 0)
-                SMSC_WARNING(PROBE,
-                        "This driver is not intended for this chip revision");
+                SMSC_WARN(pdata, probe,
+                          "This driver is not intended for this chip revision");
 
         /* workaround for platforms without an eeprom, where the mac address
          * is stored elsewhere and set by the bootloader.  This saves the
@@ -1931,7 +1933,7 @@ static int __devexit smsc911x_drv_remove(struct platform_device *pdev)
         BUG_ON(!pdata->ioaddr);
         BUG_ON(!pdata->phy_dev);
 
-        SMSC_TRACE(IFDOWN, "Stopping driver.");
+        SMSC_TRACE(pdata, ifdown, "Stopping driver");
 
         phy_disconnect(pdata->phy_dev);
         pdata->phy_dev = NULL;
@@ -1965,11 +1967,11 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
         int res_size, irq_flags;
         int retval;
 
-        pr_info("%s: Driver version %s.\n", SMSC_CHIPNAME, SMSC_DRV_VERSION);
+        pr_info("Driver version %s\n", SMSC_DRV_VERSION);
 
         /* platform data specifies irq & dynamic bus configuration */
         if (!pdev->dev.platform_data) {
-                pr_warning("%s: platform_data not provided\n", SMSC_CHIPNAME);
+                pr_warn("platform_data not provided\n");
                 retval = -ENODEV;
                 goto out_0;
         }
@@ -1979,8 +1981,7 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
         if (!res)
                 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
-                pr_warning("%s: Could not allocate resource.\n",
-                        SMSC_CHIPNAME);
+                pr_warn("Could not allocate resource\n");
                 retval = -ENODEV;
                 goto out_0;
         }
@@ -1988,8 +1989,7 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
 
         irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
         if (!irq_res) {
-                pr_warning("%s: Could not allocate irq resource.\n",
-                        SMSC_CHIPNAME);
+                pr_warn("Could not allocate irq resource\n");
                 retval = -ENODEV;
                 goto out_0;
         }
@@ -2001,7 +2001,7 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
 
         dev = alloc_etherdev(sizeof(struct smsc911x_data));
         if (!dev) {
-                pr_warning("%s: Could not allocate device.\n", SMSC_CHIPNAME);
+                pr_warn("Could not allocate device\n");
                 retval = -ENOMEM;
                 goto out_release_io_1;
         }
@@ -2021,8 +2021,7 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
         pdata->msg_enable = ((1 << debug) - 1);
 
         if (pdata->ioaddr == NULL) {
-                SMSC_WARNING(PROBE,
-                        "Error smsc911x base address invalid");
+                SMSC_WARN(pdata, probe, "Error smsc911x base address invalid");
                 retval = -ENOMEM;
                 goto out_free_netdev_2;
         }
@@ -2047,8 +2046,8 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
         retval = request_irq(dev->irq, smsc911x_irqhandler,
                              irq_flags | IRQF_SHARED, dev->name, dev);
         if (retval) {
-                SMSC_WARNING(PROBE,
-                        "Unable to claim requested irq: %d", dev->irq);
+                SMSC_WARN(pdata, probe,
+                          "Unable to claim requested irq: %d", dev->irq);
                 goto out_unmap_io_3;
         }
 
@@ -2056,17 +2055,16 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
 
         retval = register_netdev(dev);
         if (retval) {
-                SMSC_WARNING(PROBE,
-                        "Error %i registering device", retval);
+                SMSC_WARN(pdata, probe, "Error %i registering device", retval);
                 goto out_unset_drvdata_4;
         } else {
-                SMSC_TRACE(PROBE, "Network interface: \"%s\"", dev->name);
+                SMSC_TRACE(pdata, probe,
+                           "Network interface: \"%s\"", dev->name);
         }
 
         retval = smsc911x_mii_init(pdev, dev);
         if (retval) {
-                SMSC_WARNING(PROBE,
-                        "Error %i initialising mii", retval);
+                SMSC_WARN(pdata, probe, "Error %i initialising mii", retval);
                 goto out_unregister_netdev_5;
         }
 
@@ -2075,10 +2073,12 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
         /* Check if mac address has been specified when bringing interface up */
         if (is_valid_ether_addr(dev->dev_addr)) {
                 smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
-                SMSC_TRACE(PROBE, "MAC Address is specified by configuration");
+                SMSC_TRACE(pdata, probe,
+                           "MAC Address is specified by configuration");
         } else if (is_valid_ether_addr(pdata->config.mac)) {
                 memcpy(dev->dev_addr, pdata->config.mac, 6);
-                SMSC_TRACE(PROBE, "MAC Address specified by platform data");
+                SMSC_TRACE(pdata, probe,
+                           "MAC Address specified by platform data");
         } else {
                 /* Try reading mac address from device. if EEPROM is present
                  * it will already have been set */
@@ -2086,20 +2086,20 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
 
                 if (is_valid_ether_addr(dev->dev_addr)) {
                         /* eeprom values are valid  so use them */
-                        SMSC_TRACE(PROBE,
-                                "Mac Address is read from LAN911x EEPROM");
+                        SMSC_TRACE(pdata, probe,
+                                   "Mac Address is read from LAN911x EEPROM");
                 } else {
                         /* eeprom values are invalid, generate random MAC */
                         random_ether_addr(dev->dev_addr);
                         smsc911x_set_hw_mac_address(pdata, dev->dev_addr);
-                        SMSC_TRACE(PROBE,
-                                "MAC Address is set to random_ether_addr");
+                        SMSC_TRACE(pdata, probe,
+                                   "MAC Address is set to random_ether_addr");
                 }
         }
 
         spin_unlock_irq(&pdata->mac_lock);
 
-        dev_info(&dev->dev, "MAC Address: %pM\n", dev->dev_addr);
+        netdev_info(dev, "MAC Address: %pM\n", dev->dev_addr);
 
         return 0;
 
diff --git a/drivers/net/smsc911x.h b/drivers/net/smsc911x.h
index 50f712e99e96..8d67aacf8867 100644
--- a/drivers/net/smsc911x.h
+++ b/drivers/net/smsc911x.h
@@ -33,25 +33,21 @@
  * can be successfully looped back */
 #define USE_PHY_WORK_AROUND
 
-#define DPRINTK(nlevel, klevel, fmt, args...) \
-        ((void)((NETIF_MSG_##nlevel & pdata->msg_enable) && \
-        printk(KERN_##klevel "%s: %s: " fmt "\n", \
-        pdata->dev->name, __func__, ## args)))
-
 #if USE_DEBUG >= 1
-#define SMSC_WARNING(nlevel, fmt, args...) \
-        DPRINTK(nlevel, WARNING, fmt, ## args)
+#define SMSC_WARN(pdata, nlevel, fmt, args...)                  \
+        netif_warn(pdata, nlevel, (pdata)->dev,                 \
+                   "%s: " fmt "\n", __func__, ##args)
 #else
-#define SMSC_WARNING(nlevel, fmt, args...) \
-        ({ do {} while (0); 0; })
+#define SMSC_WARN(pdata, nlevel, fmt, args...)                  \
+        no_printk(fmt "\n", ##args)
 #endif
 
 #if USE_DEBUG >= 2
-#define SMSC_TRACE(nlevel, fmt, args...) \
-        DPRINTK(nlevel, INFO, fmt, ## args)
+#define SMSC_TRACE(pdata, nlevel, fmt, args...)                 \
+        netif_info(pdata, nlevel, pdata->dev, fmt "\n", ##args)
 #else
-#define SMSC_TRACE(nlevel, fmt, args...) \
-        ({ do {} while (0); 0; })
+#define SMSC_TRACE(pdata, nlevel, fmt, args...)                 \
+        no_printk(fmt "\n", ##args)
 #endif
 
 #ifdef CONFIG_DEBUG_SPINLOCK
diff --git a/drivers/net/stmmac/stmmac_ethtool.c b/drivers/net/stmmac/stmmac_ethtool.c
index fd719edc7f7c..156a805c6c23 100644
--- a/drivers/net/stmmac/stmmac_ethtool.c
+++ b/drivers/net/stmmac/stmmac_ethtool.c
@@ -197,13 +197,6 @@ static void stmmac_ethtool_gregs(struct net_device *dev,
         }
 }
 
-static u32 stmmac_ethtool_get_rx_csum(struct net_device *dev)
-{
-        struct stmmac_priv *priv = netdev_priv(dev);
-
-        return priv->rx_coe;
-}
-
 static void
 stmmac_get_pauseparam(struct net_device *netdev,
                       struct ethtool_pauseparam *pause)
@@ -358,11 +351,6 @@ static struct ethtool_ops stmmac_ethtool_ops = {
         .get_regs = stmmac_ethtool_gregs,
         .get_regs_len = stmmac_ethtool_get_regs_len,
         .get_link = ethtool_op_get_link,
-        .get_rx_csum = stmmac_ethtool_get_rx_csum,
-        .get_tx_csum = ethtool_op_get_tx_csum,
-        .set_tx_csum = ethtool_op_set_tx_ipv6_csum,
-        .get_sg = ethtool_op_get_sg,
-        .set_sg = ethtool_op_set_sg,
         .get_pauseparam = stmmac_get_pauseparam,
         .set_pauseparam = stmmac_set_pauseparam,
         .get_ethtool_stats = stmmac_get_ethtool_stats,
@@ -370,8 +358,6 @@ static struct ethtool_ops stmmac_ethtool_ops = {
         .get_wol = stmmac_get_wol,
         .set_wol = stmmac_set_wol,
         .get_sset_count = stmmac_get_sset_count,
-        .get_tso = ethtool_op_get_tso,
-        .set_tso = ethtool_op_set_tso,
 };
 
 void stmmac_set_ethtool_ops(struct net_device *netdev)
diff --git a/drivers/net/stmmac/stmmac_main.c b/drivers/net/stmmac/stmmac_main.c
index cc973fc38405..ba9daeccb8af 100644
--- a/drivers/net/stmmac/stmmac_main.c
+++ b/drivers/net/stmmac/stmmac_main.c
@@ -139,7 +139,6 @@ static const u32 default_msg_level = (NETIF_MSG_DRV | NETIF_MSG_PROBE |
                                       NETIF_MSG_IFDOWN | NETIF_MSG_TIMER);
 
 static irqreturn_t stmmac_interrupt(int irq, void *dev_id);
-static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev);
 
 /**
  * stmmac_verify_args - verify the driver parameters.
@@ -831,6 +830,7 @@ static int stmmac_open(struct net_device *dev)
                 pr_info("stmmac: Rx Checksum Offload Engine supported\n");
         if (priv->plat->tx_coe)
                 pr_info("\tTX Checksum insertion supported\n");
+        netdev_update_features(dev);
 
         /* Initialise the MMC (if present) to disable all interrupts. */
         writel(0xffffffff, priv->ioaddr + MMC_HIGH_INTR_MASK);
@@ -934,46 +934,6 @@ static int stmmac_release(struct net_device *dev)
         return 0;
 }
 
-/*
- * To perform emulated hardware segmentation on skb.
- */
-static int stmmac_sw_tso(struct stmmac_priv *priv, struct sk_buff *skb)
-{
-        struct sk_buff *segs, *curr_skb;
-        int gso_segs = skb_shinfo(skb)->gso_segs;
-
-        /* Estimate the number of fragments in the worst case */
-        if (unlikely(stmmac_tx_avail(priv) < gso_segs)) {
-                netif_stop_queue(priv->dev);
-                TX_DBG(KERN_ERR "%s: TSO BUG! Tx Ring full when queue awake\n",
-                       __func__);
-                if (stmmac_tx_avail(priv) < gso_segs)
-                        return NETDEV_TX_BUSY;
-
-                netif_wake_queue(priv->dev);
-        }
-        TX_DBG("\tstmmac_sw_tso: segmenting: skb %p (len %d)\n",
-               skb, skb->len);
-
-        segs = skb_gso_segment(skb, priv->dev->features & ~NETIF_F_TSO);
-        if (IS_ERR(segs))
-                goto sw_tso_end;
-
-        do {
-                curr_skb = segs;
-                segs = segs->next;
-                TX_DBG("\t\tcurrent skb->len: %d, *curr %p,"
-                       "*next %p\n", curr_skb->len, curr_skb, segs);
-                curr_skb->next = NULL;
-                stmmac_xmit(curr_skb, priv->dev);
-        } while (segs);
-
-sw_tso_end:
-        dev_kfree_skb(skb);
-
-        return NETDEV_TX_OK;
-}
-
 static unsigned int stmmac_handle_jumbo_frames(struct sk_buff *skb,
                                                struct net_device *dev,
                                                int csum_insertion)
@@ -1051,16 +1011,7 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev)
                        !skb_is_gso(skb) ? "isn't" : "is");
 #endif
 
-        if (unlikely(skb_is_gso(skb)))
-                return stmmac_sw_tso(priv, skb);
-
-        if (likely((skb->ip_summed == CHECKSUM_PARTIAL))) {
-                if (unlikely((!priv->plat->tx_coe) ||
-                             (priv->no_csum_insertion)))
-                        skb_checksum_help(skb);
-                else
-                        csum_insertion = 1;
-        }
+        csum_insertion = (skb->ip_summed == CHECKSUM_PARTIAL);
 
         desc = priv->dma_tx + entry;
         first = desc;
@@ -1380,18 +1331,29 @@ static int stmmac_change_mtu(struct net_device *dev, int new_mtu)
                 return -EINVAL;
         }
 
+        dev->mtu = new_mtu;
+        netdev_update_features(dev);
+
+        return 0;
+}
+
+static u32 stmmac_fix_features(struct net_device *dev, u32 features)
+{
+        struct stmmac_priv *priv = netdev_priv(dev);
+
+        if (!priv->rx_coe)
+                features &= ~NETIF_F_RXCSUM;
+        if (!priv->plat->tx_coe)
+                features &= ~NETIF_F_ALL_CSUM;
+
         /* Some GMAC devices have a bugged Jumbo frame support that
          * needs to have the Tx COE disabled for oversized frames
          * (due to limited buffer sizes). In this case we disable
          * the TX csum insertionin the TDES and not use SF. */
-        if ((priv->plat->bugged_jumbo) && (priv->dev->mtu > ETH_DATA_LEN))
-                priv->no_csum_insertion = 1;
-        else
-                priv->no_csum_insertion = 0;
+        if (priv->plat->bugged_jumbo && (dev->mtu > ETH_DATA_LEN))
+                features &= ~NETIF_F_ALL_CSUM;
 
-        dev->mtu = new_mtu;
-
-        return 0;
+        return features;
 }
 
 static irqreturn_t stmmac_interrupt(int irq, void *dev_id)
@@ -1471,6 +1433,7 @@ static const struct net_device_ops stmmac_netdev_ops = {
         .ndo_start_xmit = stmmac_xmit,
         .ndo_stop = stmmac_release,
         .ndo_change_mtu = stmmac_change_mtu,
+        .ndo_fix_features = stmmac_fix_features,
         .ndo_set_multicast_list = stmmac_multicast_list,
         .ndo_tx_timeout = stmmac_tx_timeout,
         .ndo_do_ioctl = stmmac_ioctl,
@@ -1501,8 +1464,8 @@ static int stmmac_probe(struct net_device *dev)
         dev->netdev_ops = &stmmac_netdev_ops;
         stmmac_set_ethtool_ops(dev);
 
-        dev->features |= NETIF_F_SG | NETIF_F_HIGHDMA |
-                NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
+        dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
+        dev->features |= dev->hw_features | NETIF_F_HIGHDMA;
         dev->watchdog_timeo = msecs_to_jiffies(watchdog);
 #ifdef STMMAC_VLAN_TAG_USED
         /* Both mac100 and gmac support receive VLAN tag detection */
diff --git a/drivers/net/sungem.c b/drivers/net/sungem.c
index d3be735c4719..81b6eb8ed4d7 100644
--- a/drivers/net/sungem.c
+++ b/drivers/net/sungem.c
@@ -3146,7 +3146,8 @@ static int __devinit gem_init_one(struct pci_dev *pdev,
                             gp->phy_mii.def ? gp->phy_mii.def->name : "no");
 
         /* GEM can do it all... */
-        dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_LLTX;
+        dev->hw_features = NETIF_F_SG | NETIF_F_HW_CSUM;
+        dev->features |= dev->hw_features | NETIF_F_RXCSUM | NETIF_F_LLTX;
         if (pci_using_dac)
                 dev->features |= NETIF_F_HIGHDMA;
 
diff --git a/drivers/net/sunhme.c b/drivers/net/sunhme.c
index eb4f59fb01e9..80e907df36b4 100644
--- a/drivers/net/sunhme.c
+++ b/drivers/net/sunhme.c
@@ -2788,7 +2788,8 @@ static int __devinit happy_meal_sbus_probe_one(struct platform_device *op, int i
         dev->ethtool_ops = &hme_ethtool_ops;
 
         /* Happy Meal can do it all... */
-        dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
+        dev->hw_features = NETIF_F_SG | NETIF_F_HW_CSUM;
+        dev->features |= dev->hw_features | NETIF_F_RXCSUM;
 
         dev->irq = op->archdata.irqs[0];
 
@@ -3113,7 +3114,8 @@ static int __devinit happy_meal_pci_probe(struct pci_dev *pdev,
         dev->dma = 0;
 
         /* Happy Meal can do it all... */
-        dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
+        dev->hw_features = NETIF_F_SG | NETIF_F_HW_CSUM;
+        dev->features |= dev->hw_features | NETIF_F_RXCSUM;
 
 #if defined(CONFIG_SBUS) && defined(CONFIG_PCI)
         /* Hook up PCI register/descriptor accessors. */
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index b8c5f35577e4..9d7defc2628d 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -97,14 +97,12 @@
  * them in the NIC onboard memory.
  */
 #define TG3_RX_STD_RING_SIZE(tp) \
-        ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 || \
-          GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719) ? \
-         RX_STD_MAX_SIZE_5717 : 512)
+        ((tp->tg3_flags3 & TG3_FLG3_LRG_PROD_RING_CAP) ? \
+         TG3_RX_STD_MAX_SIZE_5717 : TG3_RX_STD_MAX_SIZE_5700)
 #define TG3_DEF_RX_RING_PENDING         200
 #define TG3_RX_JMB_RING_SIZE(tp) \
-        ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 || \
-          GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719) ? \
-         1024 : 256)
+        ((tp->tg3_flags3 & TG3_FLG3_LRG_PROD_RING_CAP) ? \
+         TG3_RX_JMB_MAX_SIZE_5717 : TG3_RX_JMB_MAX_SIZE_5700)
 #define TG3_DEF_RX_JUMBO_RING_PENDING   100
 #define TG3_RSS_INDIR_TBL_SIZE          128
 
@@ -266,6 +264,7 @@ static DEFINE_PCI_DEVICE_TABLE(tg3_pci_tbl) = {
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57791)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_57795)},
         {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5719)},
+        {PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, TG3PCI_DEVICE_TIGON3_5720)},
         {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9DXX)},
         {PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_9MXX)},
         {PCI_DEVICE(PCI_VENDOR_ID_ALTIMA, PCI_DEVICE_ID_ALTIMA_AC1000)},
@@ -1044,8 +1043,7 @@ static int tg3_mdio_init(struct tg3 *tp)
         u32 reg;
         struct phy_device *phydev;
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719) {
+        if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS) {
                 u32 is_serdes;
 
                 tp->phy_addr = PCI_FUNC(tp->pdev->devfn) + 1;
@@ -1623,8 +1621,7 @@ static void tg3_phy_toggle_apd(struct tg3 *tp, bool enable)
         u32 reg;
 
         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS) ||
-            ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
-              GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719) &&
+            ((tp->tg3_flags3 & TG3_FLG3_5717_PLUS) &&
              (tp->phy_flags & TG3_PHYFLG_MII_SERDES)))
                 return;
 
@@ -2047,8 +2044,7 @@ static int tg3_phy_reset(struct tg3 *tp)
                 }
         }
 
-        if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
-             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719) &&
+        if ((tp->tg3_flags3 & TG3_FLG3_5717_PLUS) &&
             (tp->phy_flags & TG3_PHYFLG_MII_SERDES))
                 return 0;
 
@@ -2130,7 +2126,8 @@ static void tg3_frob_aux_power(struct tg3 *tp)
 
         if ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
              GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714 ||
-             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717) &&
+             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
+             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720) &&
             tp->pdev_peer != tp->pdev) {
                 struct net_device *dev_peer;
 
@@ -4394,6 +4391,7 @@ static void tg3_serdes_parallel_detect(struct tg3 *tp)
 
 static int tg3_setup_phy(struct tg3 *tp, int force_reset)
 {
+        u32 val;
         int err;
 
         if (tp->phy_flags & TG3_PHYFLG_PHY_SERDES)
@@ -4404,7 +4402,7 @@ static int tg3_setup_phy(struct tg3 *tp, int force_reset)
                 err = tg3_setup_copper_phy(tp, force_reset);
 
         if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5784_AX) {
-                u32 val, scale;
+                u32 scale;
 
                 val = tr32(TG3_CPMU_CLCK_STAT) & CPMU_CLCK_STAT_MAC_CLCK_MASK;
                 if (val == CPMU_CLCK_STAT_MAC_CLCK_62_5)
@@ -4419,17 +4417,20 @@ static int tg3_setup_phy(struct tg3 *tp, int force_reset)
                 tw32(GRC_MISC_CFG, val);
         }
 
+        val = (2 << TX_LENGTHS_IPG_CRS_SHIFT) |
+              (6 << TX_LENGTHS_IPG_SHIFT);
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720)
+                val |= tr32(MAC_TX_LENGTHS) &
+                       (TX_LENGTHS_JMB_FRM_LEN_MSK |
+                        TX_LENGTHS_CNT_DWN_VAL_MSK);
+
         if (tp->link_config.active_speed == SPEED_1000 &&
             tp->link_config.active_duplex == DUPLEX_HALF)
-                tw32(MAC_TX_LENGTHS,
-                     ((2 << TX_LENGTHS_IPG_CRS_SHIFT) |
-                      (6 << TX_LENGTHS_IPG_SHIFT) |
-                      (0xff << TX_LENGTHS_SLOT_TIME_SHIFT)));
+                tw32(MAC_TX_LENGTHS, val |
+                     (0xff << TX_LENGTHS_SLOT_TIME_SHIFT));
         else
-                tw32(MAC_TX_LENGTHS,
-                     ((2 << TX_LENGTHS_IPG_CRS_SHIFT) |
-                      (6 << TX_LENGTHS_IPG_SHIFT) |
-                      (32 << TX_LENGTHS_SLOT_TIME_SHIFT)));
+                tw32(MAC_TX_LENGTHS, val |
+                     (32 << TX_LENGTHS_SLOT_TIME_SHIFT));
 
         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS)) {
                 if (netif_carrier_ok(tp->dev)) {
@@ -4441,7 +4442,7 @@ static int tg3_setup_phy(struct tg3 *tp, int force_reset)
         }
 
         if (tp->tg3_flags & TG3_FLAG_ASPM_WORKAROUND) {
-                u32 val = tr32(PCIE_PWR_MGMT_THRESH);
+                val = tr32(PCIE_PWR_MGMT_THRESH);
                 if (!netif_carrier_ok(tp->dev))
                         val = (val & ~PCIE_PWR_MGMT_L1_THRESH_MSK) |
                               tp->pwrmgmt_thresh;
@@ -4815,7 +4816,7 @@ static int tg3_rx(struct tg3_napi *tnapi, int budget)
                         skb = copy_skb;
                 }
 
-                if ((tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) &&
+                if ((tp->dev->features & NETIF_F_RXCSUM) &&
                     (desc->type_flags & RXD_FLAG_TCPUDP_CSUM) &&
                     (((desc->ip_tcp_csum & RXD_TCPCSUM_MASK)
                       >> RXD_TCPCSUM_SHIFT) == 0xffff))
@@ -6126,6 +6127,16 @@ dma_error:
         return NETDEV_TX_OK;
 }
 
+static u32 tg3_fix_features(struct net_device *dev, u32 features)
+{
+        struct tg3 *tp = netdev_priv(dev);
+
+        if (dev->mtu > ETH_DATA_LEN && (tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
+                features &= ~NETIF_F_ALL_TSO;
+
+        return features;
+}
+
 static inline void tg3_set_mtu(struct net_device *dev, struct tg3 *tp,
                                int new_mtu)
 {
@@ -6133,14 +6144,16 @@ static inline void tg3_set_mtu(struct net_device *dev, struct tg3 *tp,
 
         if (new_mtu > ETH_DATA_LEN) {
                 if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
+                        netdev_update_features(dev);
                         tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
-                        ethtool_op_set_tso(dev, 0);
                 } else {
                         tp->tg3_flags |= TG3_FLAG_JUMBO_RING_ENABLE;
                 }
         } else {
-                if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS)
+                if (tp->tg3_flags2 & TG3_FLG2_5780_CLASS) {
                         tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
+                        netdev_update_features(dev);
+                }
                 tp->tg3_flags &= ~TG3_FLAG_JUMBO_RING_ENABLE;
         }
 }
@@ -7097,7 +7110,7 @@ static int tg3_chip_reset(struct tg3 *tp)
         if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
                 /* Force PCIe 1.0a mode */
                 if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5785 &&
-                    !(tp->tg3_flags3 & TG3_FLG3_5717_PLUS) &&
+                    !(tp->tg3_flags3 & TG3_FLG3_57765_PLUS) &&
                     tr32(TG3_PCIE_PHY_TSTCTL) ==
                     (TG3_PCIE_PHY_TSTCTL_PCIE10 | TG3_PCIE_PHY_TSTCTL_PSCRAM))
                         tw32(TG3_PCIE_PHY_TSTCTL, TG3_PCIE_PHY_TSTCTL_PSCRAM);
@@ -7250,12 +7263,17 @@ static int tg3_chip_reset(struct tg3 *tp)
         if ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) &&
             tp->pci_chip_rev_id != CHIPREV_ID_5750_A0 &&
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5785 &&
-            !(tp->tg3_flags3 & TG3_FLG3_5717_PLUS)) {
+            !(tp->tg3_flags3 & TG3_FLG3_57765_PLUS)) {
                 val = tr32(0x7c00);
 
                 tw32(0x7c00, val | (1 << 25));
         }
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720) {
+                val = tr32(TG3_CPMU_CLCK_ORIDE);
+                tw32(TG3_CPMU_CLCK_ORIDE, val & ~CPMU_CLCK_ORIDE_MAC_ORIDE_EN);
+        }
+
         /* Reprobe ASF enable state.  */
         tp->tg3_flags &= ~TG3_FLAG_ENABLE_ASF;
         tp->tg3_flags2 &= ~TG3_FLG2_ASF_NEW_HANDSHAKE;
@@ -7673,8 +7691,7 @@ static void tg3_rings_reset(struct tg3 *tp)
         /* Disable all transmit rings but the first. */
         if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
                 limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE * 16;
-        else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
-                 GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719)
+        else if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS)
                 limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE * 4;
         else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57765)
                 limit = NIC_SRAM_SEND_RCB + TG3_BDINFO_SIZE * 2;
@@ -7688,8 +7705,7 @@ static void tg3_rings_reset(struct tg3 *tp)
 
 
         /* Disable all receive return rings but the first. */
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719)
+        if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS)
                 limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE * 17;
         else if (!(tp->tg3_flags2 & TG3_FLG2_5705_PLUS))
                 limit = NIC_SRAM_RCV_RET_RCB + TG3_BDINFO_SIZE * 16;
@@ -7960,7 +7976,7 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
         if (err)
                 return err;
 
-        if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS) {
+        if (tp->tg3_flags3 & TG3_FLG3_57765_PLUS) {
                 val = tr32(TG3PCI_DMA_RW_CTRL) &
                       ~DMA_RWCTRL_DIS_CACHE_ALIGNMENT;
                 if (tp->pci_chip_rev_id == CHIPREV_ID_57765_A0)
@@ -8091,8 +8107,7 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
              ((u64) tpr->rx_std_mapping >> 32));
         tw32(RCVDBDI_STD_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW,
              ((u64) tpr->rx_std_mapping & 0xffffffff));
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5717 &&
-            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5719)
+        if (!(tp->tg3_flags3 & TG3_FLG3_5717_PLUS))
                 tw32(RCVDBDI_STD_BD + TG3_BDINFO_NIC_ADDR,
                      NIC_SRAM_RX_BUFFER_DESC);
 
@@ -8115,9 +8130,10 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
                              ((u64) tpr->rx_jmb_mapping >> 32));
                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_HOST_ADDR + TG3_64BIT_REG_LOW,
                              ((u64) tpr->rx_jmb_mapping & 0xffffffff));
+                        val = TG3_RX_JMB_RING_SIZE(tp) <<
+                              BDINFO_FLAGS_MAXLEN_SHIFT;
                         tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_MAXLEN_FLAGS,
-                             (RX_JUMBO_MAX_SIZE << BDINFO_FLAGS_MAXLEN_SHIFT) |
-                             BDINFO_FLAGS_USE_EXT_RECV);
+                             val | BDINFO_FLAGS_USE_EXT_RECV);
                         if (!(tp->tg3_flags3 & TG3_FLG3_USE_JUMBO_BDFLAG) ||
                             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57765)
                                 tw32(RCVDBDI_JUMBO_BD + TG3_BDINFO_NIC_ADDR,
@@ -8127,17 +8143,17 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
                              BDINFO_FLAGS_DISABLED);
                 }
 
-                if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS) {
+                if (tp->tg3_flags3 & TG3_FLG3_57765_PLUS) {
                         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57765)
-                                val = RX_STD_MAX_SIZE_5705;
+                                val = TG3_RX_STD_MAX_SIZE_5700;
                         else
-                                val = RX_STD_MAX_SIZE_5717;
+                                val = TG3_RX_STD_MAX_SIZE_5717;
                         val <<= BDINFO_FLAGS_MAXLEN_SHIFT;
                         val |= (TG3_RX_STD_DMA_SZ << 2);
                 } else
                         val = TG3_RX_STD_DMA_SZ << BDINFO_FLAGS_MAXLEN_SHIFT;
         } else
-                val = RX_STD_MAX_SIZE_5705 << BDINFO_FLAGS_MAXLEN_SHIFT;
+                val = TG3_RX_STD_MAX_SIZE_5700 << BDINFO_FLAGS_MAXLEN_SHIFT;
 
         tw32(RCVDBDI_STD_BD + TG3_BDINFO_MAXLEN_FLAGS, val);
 
@@ -8148,7 +8164,7 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
                           tp->rx_jumbo_pending : 0;
         tw32_rx_mbox(TG3_RX_JMB_PROD_IDX_REG, tpr->rx_jmb_prod_idx);
 
-        if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS) {
+        if (tp->tg3_flags3 & TG3_FLG3_57765_PLUS) {
                 tw32(STD_REPLENISH_LWM, 32);
                 tw32(JMB_REPLENISH_LWM, 16);
         }
@@ -8165,10 +8181,16 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
         /* The slot time is changed by tg3_setup_phy if we
          * run at gigabit with half duplex.
          */
-        tw32(MAC_TX_LENGTHS,
-             (2 << TX_LENGTHS_IPG_CRS_SHIFT) |
-             (6 << TX_LENGTHS_IPG_SHIFT) |
-             (32 << TX_LENGTHS_SLOT_TIME_SHIFT));
+        val = (2 << TX_LENGTHS_IPG_CRS_SHIFT) |
+              (6 << TX_LENGTHS_IPG_SHIFT) |
+              (32 << TX_LENGTHS_SLOT_TIME_SHIFT);
+
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720)
+                val |= tr32(MAC_TX_LENGTHS) &
+                       (TX_LENGTHS_JMB_FRM_LEN_MSK |
+                        TX_LENGTHS_CNT_DWN_VAL_MSK);
+
+        tw32(MAC_TX_LENGTHS, val);
 
         /* Receive rules. */
         tw32(MAC_RCV_RULE_CFG, RCV_RULE_CFG_DEFAULT_CLASS);
@@ -8215,13 +8237,17 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780)
                 rdmac_mode |= RDMAC_MODE_IPV6_LSO_EN;
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720)
+                rdmac_mode |= tr32(RDMAC_MODE) & RDMAC_MODE_H2BNC_VLAN_DET;
+
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5785 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780 ||
-            (tp->tg3_flags3 & TG3_FLG3_5717_PLUS)) {
+            (tp->tg3_flags3 & TG3_FLG3_57765_PLUS)) {
                 val = tr32(TG3_RDMA_RSRVCTRL_REG);
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719) {
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719 ||
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720) {
                         val &= ~(TG3_RDMA_RSRVCTRL_TXMRGN_MASK |
                                  TG3_RDMA_RSRVCTRL_FIFO_LWM_MASK |
                                  TG3_RDMA_RSRVCTRL_FIFO_HWM_MASK);
@@ -8233,7 +8259,8 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
                      val | TG3_RDMA_RSRVCTRL_FIFO_OFLW_FIX);
         }
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719) {
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720) {
                 val = tr32(TG3_LSO_RD_DMA_CRPTEN_CTRL);
                 tw32(TG3_LSO_RD_DMA_CRPTEN_CTRL, val |
                      TG3_LSO_RD_DMA_CRPTEN_CTRL_BLEN_BD_4K |
@@ -8421,8 +8448,7 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
         tw32(SNDBDC_MODE, SNDBDC_MODE_ENABLE | SNDBDC_MODE_ATTN_ENABLE);
         tw32(RCVBDI_MODE, RCVBDI_MODE_ENABLE | RCVBDI_MODE_RCB_ATTN_ENAB);
         val = RCVDBDI_MODE_ENABLE | RCVDBDI_MODE_INV_RING_SZ;
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719)
+        if (tp->tg3_flags3 & TG3_FLG3_LRG_PROD_RING_CAP)
                 val |= RCVDBDI_MODE_LRG_RING_SZ;
         tw32(RCVDBDI_MODE, val);
         tw32(SNDDATAI_MODE, SNDDATAI_MODE_ENABLE);
@@ -8447,9 +8473,17 @@ static int tg3_reset_hw(struct tg3 *tp, int reset_phy)
         }
 
         tp->tx_mode = TX_MODE_ENABLE;
+
         if ((tp->tg3_flags3 & TG3_FLG3_5755_PLUS) ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
                 tp->tx_mode |= TX_MODE_MBUF_LOCKUP_FIX;
+
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720) {
+                val = TX_MODE_JMB_FRM_LEN | TX_MODE_CNT_DN_MODE;
+                tp->tx_mode &= ~val;
+                tp->tx_mode |= tr32(MAC_TX_MODE) & val;
+        }
+
         tw32_f(MAC_TX_MODE, tp->tx_mode);
         udelay(100);
 
@@ -8839,12 +8873,12 @@ static int tg3_request_irq(struct tg3 *tp, int irq_num)
                 fn = tg3_msi;
                 if (tp->tg3_flags2 & TG3_FLG2_1SHOT_MSI)
                         fn = tg3_msi_1shot;
-                flags = IRQF_SAMPLE_RANDOM;
+                flags = 0;
         } else {
                 fn = tg3_interrupt;
                 if (tp->tg3_flags & TG3_FLAG_TAGGED_STATUS)
                         fn = tg3_interrupt_tagged;
-                flags = IRQF_SHARED | IRQF_SAMPLE_RANDOM;
+                flags = IRQF_SHARED;
         }
 
         return request_irq(tnapi->irq_vec, fn, flags, name, tnapi);
@@ -8868,7 +8902,7 @@ static int tg3_test_interrupt(struct tg3 *tp)
          * Turn off MSI one shot mode.  Otherwise this test has no
          * observable way to know whether the interrupt was delivered.
          */
-        if ((tp->tg3_flags3 & TG3_FLG3_5717_PLUS) &&
+        if ((tp->tg3_flags3 & TG3_FLG3_57765_PLUS) &&
             (tp->tg3_flags2 & TG3_FLG2_USING_MSI)) {
                 val = tr32(MSGINT_MODE) | MSGINT_MODE_ONE_SHOT_DISABLE;
                 tw32(MSGINT_MODE, val);
@@ -8911,7 +8945,7 @@ static int tg3_test_interrupt(struct tg3 *tp)
 
         if (intr_ok) {
                 /* Reenable MSI one shot mode. */
-                if ((tp->tg3_flags3 & TG3_FLG3_5717_PLUS) &&
+                if ((tp->tg3_flags3 & TG3_FLG3_57765_PLUS) &&
                     (tp->tg3_flags2 & TG3_FLG2_USING_MSI)) {
                         val = tr32(MSGINT_MODE) & ~MSGINT_MODE_ONE_SHOT_DISABLE;
                         tw32(MSGINT_MODE, val);
@@ -9058,7 +9092,9 @@ static bool tg3_enable_msix(struct tg3 *tp)
 
         if (tp->irq_cnt > 1) {
                 tp->tg3_flags3 |= TG3_FLG3_ENABLE_RSS;
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719) {
+
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719 ||
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720) {
                         tp->tg3_flags3 |= TG3_FLG3_ENABLE_TSS;
                         netif_set_real_num_tx_queues(tp->dev, tp->irq_cnt - 1);
                 }
@@ -9214,7 +9250,7 @@ static int tg3_open(struct net_device *dev)
                         goto err_out2;
                 }
 
-                if (!(tp->tg3_flags3 & TG3_FLG3_5717_PLUS) &&
+                if (!(tp->tg3_flags3 & TG3_FLG3_57765_PLUS) &&
                     (tp->tg3_flags2 & TG3_FLG2_USING_MSI)) {
                         u32 val = tr32(PCIE_TRANSACTION_CFG);
 
@@ -9997,33 +10033,6 @@ static void tg3_set_msglevel(struct net_device *dev, u32 value)
         tp->msg_enable = value;
 }
 
-static int tg3_set_tso(struct net_device *dev, u32 value)
-{
-        struct tg3 *tp = netdev_priv(dev);
-
-        if (!(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE)) {
-                if (value)
-                        return -EINVAL;
-                return 0;
-        }
-        if ((dev->features & NETIF_F_IPV6_CSUM) &&
-            ((tp->tg3_flags2 & TG3_FLG2_HW_TSO_2) ||
-             (tp->tg3_flags2 & TG3_FLG2_HW_TSO_3))) {
-                if (value) {
-                        dev->features |= NETIF_F_TSO6;
-                        if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO_3) ||
-                            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761 ||
-                            (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 &&
-                             GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5784_AX) ||
-                            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5785 ||
-                            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780)
-                                dev->features |= NETIF_F_TSO_ECN;
-                } else
-                        dev->features &= ~(NETIF_F_TSO6 | NETIF_F_TSO_ECN);
-        }
-        return ethtool_op_set_tso(dev, value);
-}
-
 static int tg3_nway_reset(struct net_device *dev)
 {
         struct tg3 *tp = netdev_priv(dev);
@@ -10246,50 +10255,6 @@ static int tg3_set_pauseparam(struct net_device *dev, struct ethtool_pauseparam
         return err;
 }
 
-static u32 tg3_get_rx_csum(struct net_device *dev)
-{
-        struct tg3 *tp = netdev_priv(dev);
-        return (tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) != 0;
-}
-
-static int tg3_set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct tg3 *tp = netdev_priv(dev);
-
-        if (tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) {
-                if (data != 0)
-                        return -EINVAL;
-                return 0;
-        }
-
-        spin_lock_bh(&tp->lock);
-        if (data)
-                tp->tg3_flags |= TG3_FLAG_RX_CHECKSUMS;
-        else
-                tp->tg3_flags &= ~TG3_FLAG_RX_CHECKSUMS;
-        spin_unlock_bh(&tp->lock);
-
-        return 0;
-}
-
-static int tg3_set_tx_csum(struct net_device *dev, u32 data)
-{
-        struct tg3 *tp = netdev_priv(dev);
-
-        if (tp->tg3_flags & TG3_FLAG_BROKEN_CHECKSUMS) {
-                if (data != 0)
-                        return -EINVAL;
-                return 0;
-        }
-
-        if (tp->tg3_flags3 & TG3_FLG3_5755_PLUS)
-                ethtool_op_set_tx_ipv6_csum(dev, data);
-        else
-                ethtool_op_set_tx_csum(dev, data);
-
-        return 0;
-}
-
 static int tg3_get_sset_count(struct net_device *dev, int sset)
 {
         switch (sset) {
@@ -10317,35 +10282,38 @@ static void tg3_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
         }
 }
 
-static int tg3_phys_id(struct net_device *dev, u32 data)
+static int tg3_set_phys_id(struct net_device *dev,
+                            enum ethtool_phys_id_state state)
 {
         struct tg3 *tp = netdev_priv(dev);
-        int i;
 
         if (!netif_running(tp->dev))
                 return -EAGAIN;
 
-        if (data == 0)
-                data = UINT_MAX / 2;
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                return -EINVAL;
 
-        for (i = 0; i < (data * 2); i++) {
-                if ((i % 2) == 0)
-                        tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
-                                           LED_CTRL_1000MBPS_ON |
-                                           LED_CTRL_100MBPS_ON |
-                                           LED_CTRL_10MBPS_ON |
-                                           LED_CTRL_TRAFFIC_OVERRIDE |
-                                           LED_CTRL_TRAFFIC_BLINK |
-                                           LED_CTRL_TRAFFIC_LED);
+        case ETHTOOL_ID_ON:
+                tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
+                     LED_CTRL_1000MBPS_ON |
+                     LED_CTRL_100MBPS_ON |
+                     LED_CTRL_10MBPS_ON |
+                     LED_CTRL_TRAFFIC_OVERRIDE |
+                     LED_CTRL_TRAFFIC_BLINK |
+                     LED_CTRL_TRAFFIC_LED);
+                break;
 
-                else
-                        tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
-                                           LED_CTRL_TRAFFIC_OVERRIDE);
+        case ETHTOOL_ID_OFF:
+                tw32(MAC_LED_CTRL, LED_CTRL_LNKLED_OVERRIDE |
+                     LED_CTRL_TRAFFIC_OVERRIDE);
+                break;
 
-                if (msleep_interruptible(500))
-                        break;
+        case ETHTOOL_ID_INACTIVE:
+                tw32(MAC_LED_CTRL, tp->led_ctrl);
+                break;
         }
-        tw32(MAC_LED_CTRL, tp->led_ctrl);
+
         return 0;
 }
 
@@ -10850,8 +10818,7 @@ static int tg3_test_memory(struct tg3 *tp)
         int err = 0;
         int i;
 
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719)
+        if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS)
                 mem_tbl = mem_tbl_5717;
         else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57765)
                 mem_tbl = mem_tbl_57765;
@@ -11364,14 +11331,9 @@ static const struct ethtool_ops tg3_ethtool_ops = {
         .set_ringparam          = tg3_set_ringparam,
         .get_pauseparam         = tg3_get_pauseparam,
         .set_pauseparam         = tg3_set_pauseparam,
-        .get_rx_csum            = tg3_get_rx_csum,
-        .set_rx_csum            = tg3_set_rx_csum,
-        .set_tx_csum            = tg3_set_tx_csum,
-        .set_sg                 = ethtool_op_set_sg,
-        .set_tso                = tg3_set_tso,
         .self_test              = tg3_self_test,
         .get_strings            = tg3_get_strings,
-        .phys_id                = tg3_phys_id,
+        .set_phys_id            = tg3_set_phys_id,
         .get_ethtool_stats      = tg3_get_ethtool_stats,
         .get_coalesce           = tg3_get_coalesce,
         .set_coalesce           = tg3_set_coalesce,
@@ -11843,6 +11805,8 @@ static void __devinit tg3_get_5717_nvram_info(struct tg3 *tp)
 
                 switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
                 case FLASH_5717VENDOR_ATMEL_MDB021D:
+                        /* Detect size with tg3_nvram_get_size() */
+                        break;
                 case FLASH_5717VENDOR_ATMEL_ADB021B:
                 case FLASH_5717VENDOR_ATMEL_ADB021D:
                         tp->nvram_size = TG3_NVRAM_SIZE_256KB;
@@ -11868,8 +11832,10 @@ static void __devinit tg3_get_5717_nvram_info(struct tg3 *tp)
 
                 switch (nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK) {
                 case FLASH_5717VENDOR_ST_M_M25PE20:
-                case FLASH_5717VENDOR_ST_A_M25PE20:
                 case FLASH_5717VENDOR_ST_M_M45PE20:
+                        /* Detect size with tg3_nvram_get_size() */
+                        break;
+                case FLASH_5717VENDOR_ST_A_M25PE20:
                 case FLASH_5717VENDOR_ST_A_M45PE20:
                         tp->nvram_size = TG3_NVRAM_SIZE_256KB;
                         break;
@@ -11888,6 +11854,118 @@ static void __devinit tg3_get_5717_nvram_info(struct tg3 *tp)
                 tp->tg3_flags3 |= TG3_FLG3_NO_NVRAM_ADDR_TRANS;
 }
 
+static void __devinit tg3_get_5720_nvram_info(struct tg3 *tp)
+{
+        u32 nvcfg1, nvmpinstrp;
+
+        nvcfg1 = tr32(NVRAM_CFG1);
+        nvmpinstrp = nvcfg1 & NVRAM_CFG1_5752VENDOR_MASK;
+
+        switch (nvmpinstrp) {
+        case FLASH_5720_EEPROM_HD:
+        case FLASH_5720_EEPROM_LD:
+                tp->nvram_jedecnum = JEDEC_ATMEL;
+                tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+
+                nvcfg1 &= ~NVRAM_CFG1_COMPAT_BYPASS;
+                tw32(NVRAM_CFG1, nvcfg1);
+                if (nvmpinstrp == FLASH_5720_EEPROM_HD)
+                        tp->nvram_pagesize = ATMEL_AT24C512_CHIP_SIZE;
+                else
+                        tp->nvram_pagesize = ATMEL_AT24C02_CHIP_SIZE;
+                return;
+        case FLASH_5720VENDOR_M_ATMEL_DB011D:
+        case FLASH_5720VENDOR_A_ATMEL_DB011B:
+        case FLASH_5720VENDOR_A_ATMEL_DB011D:
+        case FLASH_5720VENDOR_M_ATMEL_DB021D:
+        case FLASH_5720VENDOR_A_ATMEL_DB021B:
+        case FLASH_5720VENDOR_A_ATMEL_DB021D:
+        case FLASH_5720VENDOR_M_ATMEL_DB041D:
+        case FLASH_5720VENDOR_A_ATMEL_DB041B:
+        case FLASH_5720VENDOR_A_ATMEL_DB041D:
+        case FLASH_5720VENDOR_M_ATMEL_DB081D:
+        case FLASH_5720VENDOR_A_ATMEL_DB081D:
+        case FLASH_5720VENDOR_ATMEL_45USPT:
+                tp->nvram_jedecnum = JEDEC_ATMEL;
+                tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+                tp->tg3_flags2 |= TG3_FLG2_FLASH;
+
+                switch (nvmpinstrp) {
+                case FLASH_5720VENDOR_M_ATMEL_DB021D:
+                case FLASH_5720VENDOR_A_ATMEL_DB021B:
+                case FLASH_5720VENDOR_A_ATMEL_DB021D:
+                        tp->nvram_size = TG3_NVRAM_SIZE_256KB;
+                        break;
+                case FLASH_5720VENDOR_M_ATMEL_DB041D:
+                case FLASH_5720VENDOR_A_ATMEL_DB041B:
+                case FLASH_5720VENDOR_A_ATMEL_DB041D:
+                        tp->nvram_size = TG3_NVRAM_SIZE_512KB;
+                        break;
+                case FLASH_5720VENDOR_M_ATMEL_DB081D:
+                case FLASH_5720VENDOR_A_ATMEL_DB081D:
+                        tp->nvram_size = TG3_NVRAM_SIZE_1MB;
+                        break;
+                default:
+                        tp->nvram_size = TG3_NVRAM_SIZE_128KB;
+                        break;
+                }
+                break;
+        case FLASH_5720VENDOR_M_ST_M25PE10:
+        case FLASH_5720VENDOR_M_ST_M45PE10:
+        case FLASH_5720VENDOR_A_ST_M25PE10:
+        case FLASH_5720VENDOR_A_ST_M45PE10:
+        case FLASH_5720VENDOR_M_ST_M25PE20:
+        case FLASH_5720VENDOR_M_ST_M45PE20:
+        case FLASH_5720VENDOR_A_ST_M25PE20:
+        case FLASH_5720VENDOR_A_ST_M45PE20:
+        case FLASH_5720VENDOR_M_ST_M25PE40:
+        case FLASH_5720VENDOR_M_ST_M45PE40:
+        case FLASH_5720VENDOR_A_ST_M25PE40:
+        case FLASH_5720VENDOR_A_ST_M45PE40:
+        case FLASH_5720VENDOR_M_ST_M25PE80:
+        case FLASH_5720VENDOR_M_ST_M45PE80:
+        case FLASH_5720VENDOR_A_ST_M25PE80:
+        case FLASH_5720VENDOR_A_ST_M45PE80:
+        case FLASH_5720VENDOR_ST_25USPT:
+        case FLASH_5720VENDOR_ST_45USPT:
+                tp->nvram_jedecnum = JEDEC_ST;
+                tp->tg3_flags |= TG3_FLAG_NVRAM_BUFFERED;
+                tp->tg3_flags2 |= TG3_FLG2_FLASH;
+
+                switch (nvmpinstrp) {
+                case FLASH_5720VENDOR_M_ST_M25PE20:
+                case FLASH_5720VENDOR_M_ST_M45PE20:
+                case FLASH_5720VENDOR_A_ST_M25PE20:
+                case FLASH_5720VENDOR_A_ST_M45PE20:
+                        tp->nvram_size = TG3_NVRAM_SIZE_256KB;
+                        break;
+                case FLASH_5720VENDOR_M_ST_M25PE40:
+                case FLASH_5720VENDOR_M_ST_M45PE40:
+                case FLASH_5720VENDOR_A_ST_M25PE40:
+                case FLASH_5720VENDOR_A_ST_M45PE40:
+                        tp->nvram_size = TG3_NVRAM_SIZE_512KB;
+                        break;
+                case FLASH_5720VENDOR_M_ST_M25PE80:
+                case FLASH_5720VENDOR_M_ST_M45PE80:
+                case FLASH_5720VENDOR_A_ST_M25PE80:
+                case FLASH_5720VENDOR_A_ST_M45PE80:
+                        tp->nvram_size = TG3_NVRAM_SIZE_1MB;
+                        break;
+                default:
+                        tp->nvram_size = TG3_NVRAM_SIZE_128KB;
+                        break;
+                }
+                break;
+        default:
+                tp->tg3_flags3 |= TG3_FLG3_NO_NVRAM;
+                return;
+        }
+
+        tg3_nvram_get_pagesize(tp, nvcfg1);
+        if (tp->nvram_pagesize != 264 && tp->nvram_pagesize != 528)
+                tp->tg3_flags3 |= TG3_FLG3_NO_NVRAM_ADDR_TRANS;
+}
+
 /* Chips other than 5700/5701 use the NVRAM for fetching info. */
 static void __devinit tg3_nvram_init(struct tg3 *tp)
 {
@@ -11935,6 +12013,8 @@ static void __devinit tg3_nvram_init(struct tg3 *tp)
                 else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
                          GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719)
                         tg3_get_5717_nvram_info(tp);
+                else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720)
+                        tg3_get_5720_nvram_info(tp);
                 else
                         tg3_get_nvram_info(tp);
 
@@ -12472,7 +12552,7 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
                 if (cfg2 & (1 << 18))
                         tp->phy_flags |= TG3_PHYFLG_SERDES_PREEMPHASIS;
 
-                if (((tp->tg3_flags3 & TG3_FLG3_5717_PLUS) ||
+                if (((tp->tg3_flags3 & TG3_FLG3_57765_PLUS) ||
                     ((GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 &&
                       GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5784_AX))) &&
                     (cfg2 & NIC_SRAM_DATA_CFG_2_APD_EN))
@@ -12480,7 +12560,7 @@ static void __devinit tg3_get_eeprom_hw_cfg(struct tg3 *tp)
 
                 if ((tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) &&
                     GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5785 &&
-                    !(tp->tg3_flags3 & TG3_FLG3_5717_PLUS)) {
+                    !(tp->tg3_flags3 & TG3_FLG3_57765_PLUS)) {
                         u32 cfg3;
 
                         tg3_read_mem(tp, NIC_SRAM_DATA_CFG_3, &cfg3);
@@ -13118,21 +13198,15 @@ done:
 
 static struct pci_dev * __devinit tg3_find_peer(struct tg3 *);
 
-static inline void vlan_features_add(struct net_device *dev, unsigned long flags)
-{
-        dev->vlan_features |= flags;
-}
-
 static inline u32 tg3_rx_ret_ring_size(struct tg3 *tp)
 {
-        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719)
-                return 4096;
+        if (tp->tg3_flags3 & TG3_FLG3_LRG_PROD_RING_CAP)
+                return TG3_RX_RET_MAX_SIZE_5717;
         else if ((tp->tg3_flags & TG3_FLAG_JUMBO_CAPABLE) &&
                  !(tp->tg3_flags2 & TG3_FLG2_5780_CLASS))
-                return 1024;
+                return TG3_RX_RET_MAX_SIZE_5700;
         else
-                return 512;
+                return TG3_RX_RET_MAX_SIZE_5705;
 }
 
 static DEFINE_PCI_DEVICE_TABLE(tg3_write_reorder_chipsets) = {
@@ -13177,7 +13251,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
 
                 if (tp->pdev->device == TG3PCI_DEVICE_TIGON3_5717 ||
                     tp->pdev->device == TG3PCI_DEVICE_TIGON3_5718 ||
-                    tp->pdev->device == TG3PCI_DEVICE_TIGON3_5719)
+                    tp->pdev->device == TG3PCI_DEVICE_TIGON3_5719 ||
+                    tp->pdev->device == TG3PCI_DEVICE_TIGON3_5720)
                         pci_read_config_dword(tp->pdev,
                                               TG3PCI_GEN2_PRODID_ASICREV,
                                               &prod_id_asic_rev);
@@ -13332,14 +13407,19 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
 
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5714 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717)
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720)
                 tp->pdev_peer = tg3_find_peer(tp);
 
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719 ||
-            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57765)
+            GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720)
                 tp->tg3_flags3 |= TG3_FLG3_5717_PLUS;
 
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57765 ||
+            (tp->tg3_flags3 & TG3_FLG3_5717_PLUS))
+                tp->tg3_flags3 |= TG3_FLG3_57765_PLUS;
+
         /* Intentionally exclude ASIC_REV_5906 */
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
@@ -13347,7 +13427,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5785 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780 ||
-            (tp->tg3_flags3 & TG3_FLG3_5717_PLUS))
+            (tp->tg3_flags3 & TG3_FLG3_57765_PLUS))
                 tp->tg3_flags3 |= TG3_FLG3_5755_PLUS;
 
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5750 ||
@@ -13364,22 +13444,20 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
         /* 5700 B0 chips do not support checksumming correctly due
          * to hardware bugs.
          */
-        if (tp->pci_chip_rev_id == CHIPREV_ID_5700_B0)
-                tp->tg3_flags |= TG3_FLAG_BROKEN_CHECKSUMS;
-        else {
-                unsigned long features = NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_GRO;
+        if (tp->pci_chip_rev_id != CHIPREV_ID_5700_B0) {
+                u32 features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM;
 
-                tp->tg3_flags |= TG3_FLAG_RX_CHECKSUMS;
                 if (tp->tg3_flags3 & TG3_FLG3_5755_PLUS)
                         features |= NETIF_F_IPV6_CSUM;
                 tp->dev->features |= features;
-                vlan_features_add(tp->dev, features);
+                tp->dev->hw_features |= features;
+                tp->dev->vlan_features |= features;
         }
 
         /* Determine TSO capabilities */
         if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719)
                 ; /* Do nothing. HW bug. */
-        else if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS)
+        else if (tp->tg3_flags3 & TG3_FLG3_57765_PLUS)
                 tp->tg3_flags2 |= TG3_FLG2_HW_TSO_3;
         else if ((tp->tg3_flags3 & TG3_FLG3_5755_PLUS) ||
                  GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5906)
@@ -13415,7 +13493,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                         tp->tg3_flags2 |= TG3_FLG2_1SHOT_MSI;
                 }
 
-                if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS) {
+                if (tp->tg3_flags3 & TG3_FLG3_57765_PLUS) {
                         tp->tg3_flags |= TG3_FLAG_SUPPORT_MSIX;
                         tp->irq_max = TG3_IRQ_MAX_VECS;
                 }
@@ -13430,7 +13508,10 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                 tp->tg3_flags3 |= TG3_FLG3_40BIT_DMA_LIMIT_BUG;
         }
 
-        if ((tp->tg3_flags3 & TG3_FLG3_5717_PLUS) &&
+        if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS)
+                tp->tg3_flags3 |= TG3_FLG3_LRG_PROD_RING_CAP;
+
+        if ((tp->tg3_flags3 & TG3_FLG3_57765_PLUS) &&
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5719)
                 tp->tg3_flags3 |= TG3_FLG3_USE_JUMBO_BDFLAG;
 
@@ -13449,7 +13530,8 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
                 tp->tg3_flags2 |= TG3_FLG2_PCI_EXPRESS;
 
                 tp->pcie_readrq = 4096;
-                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719)
+                if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719 ||
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720)
                         tp->pcie_readrq = 2048;
 
                 pcie_set_readrq(tp->pdev, tp->pcie_readrq);
@@ -13636,7 +13718,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5785 ||
             GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780 ||
-            (tp->tg3_flags3 & TG3_FLG3_5717_PLUS))
+            (tp->tg3_flags3 & TG3_FLG3_57765_PLUS))
                 tp->tg3_flags |= TG3_FLAG_CPMU_PRESENT;
 
         /* Set up tp->grc_local_ctrl before calling tg_power_up().
@@ -13715,7 +13797,7 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
             !(tp->phy_flags & TG3_PHYFLG_IS_FET) &&
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5785 &&
             GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_57780 &&
-            !(tp->tg3_flags3 & TG3_FLG3_5717_PLUS)) {
+            !(tp->tg3_flags3 & TG3_FLG3_57765_PLUS)) {
                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5755 ||
                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5787 ||
                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 ||
@@ -13756,7 +13838,15 @@ static int __devinit tg3_get_invariants(struct tg3 *tp)
 
         /* Initialize data/descriptor byte/word swapping. */
         val = tr32(GRC_MODE);
-        val &= GRC_MODE_HOST_STACKUP;
+        if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5720)
+                val &= (GRC_MODE_BYTE_SWAP_B2HRX_DATA |
+                        GRC_MODE_WORD_SWAP_B2HRX_DATA |
+                        GRC_MODE_B2HRX_ENABLE |
+                        GRC_MODE_HTX2B_ENABLE |
+                        GRC_MODE_HOST_STACKUP);
+        else
+                val &= GRC_MODE_HOST_STACKUP;
+
         tw32(GRC_MODE, val | tp->grc_mode);
 
         tg3_switch_clocks(tp);
@@ -13961,8 +14051,7 @@ static int __devinit tg3_get_device_address(struct tg3 *tp)
                         tw32_f(NVRAM_CMD, NVRAM_CMD_RESET);
                 else
                         tg3_nvram_unlock(tp);
-        } else if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 ||
-                   GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5719) {
+        } else if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS) {
                 if (PCI_FUNC(tp->pdev->devfn) & 1)
                         mac_offset = 0xcc;
                 if (PCI_FUNC(tp->pdev->devfn) > 1)
@@ -14051,7 +14140,7 @@ static u32 __devinit tg3_calc_dma_bndry(struct tg3 *tp, u32 val)
 #endif
 #endif
 
-        if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS) {
+        if (tp->tg3_flags3 & TG3_FLG3_57765_PLUS) {
                 val = goal ? 0 : DMA_RWCTRL_DIS_CACHE_ALIGNMENT;
                 goto out;
         }
@@ -14268,7 +14357,7 @@ static int __devinit tg3_test_dma(struct tg3 *tp)
 
         tp->dma_rwctrl = tg3_calc_dma_bndry(tp, tp->dma_rwctrl);
 
-        if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS)
+        if (tp->tg3_flags3 & TG3_FLG3_57765_PLUS)
                 goto out;
 
         if (tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS) {
@@ -14443,7 +14532,7 @@ out_nofree:
 
 static void __devinit tg3_init_bufmgr_config(struct tg3 *tp)
 {
-        if (tp->tg3_flags3 & TG3_FLG3_5717_PLUS) {
+        if (tp->tg3_flags3 & TG3_FLG3_57765_PLUS) {
                 tp->bufmgr_config.mbuf_read_dma_low_water =
                         DEFAULT_MB_RDMA_LOW_WATER_5705;
                 tp->bufmgr_config.mbuf_mac_rx_low_water =
@@ -14521,6 +14610,7 @@ static char * __devinit tg3_phy_string(struct tg3 *tp)
         case TG3_PHY_ID_BCM5718S:       return "5718S";
         case TG3_PHY_ID_BCM57765:       return "57765";
         case TG3_PHY_ID_BCM5719C:       return "5719C";
+        case TG3_PHY_ID_BCM5720C:       return "5720C";
         case TG3_PHY_ID_BCM8002:        return "8002/serdes";
         case 0:                 return "serdes";
         default:                return "unknown";
@@ -14633,6 +14723,7 @@ static const struct net_device_ops tg3_netdev_ops = {
         .ndo_do_ioctl           = tg3_ioctl,
         .ndo_tx_timeout         = tg3_tx_timeout,
         .ndo_change_mtu         = tg3_change_mtu,
+        .ndo_fix_features       = tg3_fix_features,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = tg3_poll_controller,
 #endif
@@ -14663,6 +14754,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
         u32 sndmbx, rcvmbx, intmbx;
         char str[40];
         u64 dma_mask, persist_dma_mask;
+        u32 hw_features = 0;
 
         printk_once(KERN_INFO "%s\n", version);
 
@@ -14759,8 +14851,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
         }
 
         if ((tp->tg3_flags3 & TG3_FLG3_5755_PLUS) &&
-            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5717 &&
-            GET_ASIC_REV(tp->pci_chip_rev_id) != ASIC_REV_5719)
+            !(tp->tg3_flags3 & TG3_FLG3_5717_PLUS))
                 dev->netdev_ops = &tg3_netdev_ops;
         else
                 dev->netdev_ops = &tg3_netdev_ops_dma_bug;
@@ -14824,27 +14915,25 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
          * is off by default, but can be enabled using ethtool.
          */
         if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO) &&
-            (dev->features & NETIF_F_IP_CSUM)) {
-                dev->features |= NETIF_F_TSO;
-                vlan_features_add(dev, NETIF_F_TSO);
-        }
+            (dev->features & NETIF_F_IP_CSUM))
+                hw_features |= NETIF_F_TSO;
         if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO_2) ||
             (tp->tg3_flags2 & TG3_FLG2_HW_TSO_3)) {
-                if (dev->features & NETIF_F_IPV6_CSUM) {
-                        dev->features |= NETIF_F_TSO6;
-                        vlan_features_add(dev, NETIF_F_TSO6);
-                }
+                if (dev->features & NETIF_F_IPV6_CSUM)
+                        hw_features |= NETIF_F_TSO6;
                 if ((tp->tg3_flags2 & TG3_FLG2_HW_TSO_3) ||
                     GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761 ||
                     (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 &&
                      GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5784_AX) ||
                         GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5785 ||
-                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780) {
-                        dev->features |= NETIF_F_TSO_ECN;
-                        vlan_features_add(dev, NETIF_F_TSO_ECN);
-                }
+                    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_57780)
+                        hw_features |= NETIF_F_TSO_ECN;
         }
 
+        dev->hw_features |= hw_features;
+        dev->features |= hw_features;
+        dev->vlan_features |= hw_features;
+
         if (tp->pci_chip_rev_id == CHIPREV_ID_5705_A1 &&
             !(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) &&
             !(tr32(TG3PCI_PCISTATE) & PCISTATE_BUS_SPEED_HIGH)) {
@@ -14973,7 +15062,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
         }
 
         netdev_info(dev, "RXcsums[%d] LinkChgREG[%d] MIirq[%d] ASF[%d] TSOcap[%d]\n",
-                    (tp->tg3_flags & TG3_FLAG_RX_CHECKSUMS) != 0,
+                    (dev->features & NETIF_F_RXCSUM) != 0,
                     (tp->tg3_flags & TG3_FLAG_USE_LINKCHG_REG) != 0,
                     (tp->phy_flags & TG3_PHYFLG_USE_MI_INTERRUPT) != 0,
                     (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) != 0,
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index 5e96706ad108..829a84ad80f2 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -25,9 +25,13 @@
 
 #define TG3_RX_INTERNAL_RING_SZ_5906    32
 
-#define RX_STD_MAX_SIZE_5705            512
-#define RX_STD_MAX_SIZE_5717            2048
-#define RX_JUMBO_MAX_SIZE               0xdeadbeef /* XXX */
+#define TG3_RX_STD_MAX_SIZE_5700        512
+#define TG3_RX_STD_MAX_SIZE_5717        2048
+#define TG3_RX_JMB_MAX_SIZE_5700        256
+#define TG3_RX_JMB_MAX_SIZE_5717        1024
+#define TG3_RX_RET_MAX_SIZE_5700        1024
+#define TG3_RX_RET_MAX_SIZE_5705        512
+#define TG3_RX_RET_MAX_SIZE_5717        4096
 
 /* First 256 bytes are a mirror of PCI config space. */
 #define TG3PCI_VENDOR                   0x00000000
@@ -54,6 +58,7 @@
 #define  TG3PCI_DEVICE_TIGON3_57791      0x16b2
 #define  TG3PCI_DEVICE_TIGON3_57795      0x16b6
 #define  TG3PCI_DEVICE_TIGON3_5719       0x1657
+#define  TG3PCI_DEVICE_TIGON3_5720       0x165f
 /* 0x04 --> 0x2c unused */
 #define TG3PCI_SUBVENDOR_ID_BROADCOM            PCI_VENDOR_ID_BROADCOM
 #define TG3PCI_SUBDEVICE_ID_BROADCOM_95700A6    0x1644
@@ -163,6 +168,7 @@
 #define   ASIC_REV_5717                  0x5717
 #define   ASIC_REV_57765                 0x57785
 #define   ASIC_REV_5719                  0x5719
+#define   ASIC_REV_5720                  0x5720
 #define  GET_CHIP_REV(CHIP_REV_ID)      ((CHIP_REV_ID) >> 8)
 #define   CHIPREV_5700_AX                0x70
 #define   CHIPREV_5700_BX                0x71
@@ -473,6 +479,8 @@
 #define  TX_MODE_BIG_BCKOFF_ENABLE       0x00000020
 #define  TX_MODE_LONG_PAUSE_ENABLE       0x00000040
 #define  TX_MODE_MBUF_LOCKUP_FIX         0x00000100
+#define  TX_MODE_JMB_FRM_LEN             0x00400000
+#define  TX_MODE_CNT_DN_MODE             0x00800000
 #define MAC_TX_STATUS                   0x00000460
 #define  TX_STATUS_XOFFED                0x00000001
 #define  TX_STATUS_SENT_XOFF             0x00000002
@@ -487,6 +495,8 @@
 #define  TX_LENGTHS_IPG_SHIFT            8
 #define  TX_LENGTHS_IPG_CRS_MASK         0x00003000
 #define  TX_LENGTHS_IPG_CRS_SHIFT        12
+#define  TX_LENGTHS_JMB_FRM_LEN_MSK      0x00ff0000
+#define  TX_LENGTHS_CNT_DWN_VAL_MSK      0xff000000
 #define MAC_RX_MODE                     0x00000468
 #define  RX_MODE_RESET                   0x00000001
 #define  RX_MODE_ENABLE                  0x00000002
@@ -1079,6 +1089,9 @@
 #define  CPMU_HST_ACC_MACCLK_6_25        0x00130000
 /* 0x3620 --> 0x3630 unused */
 
+#define TG3_CPMU_CLCK_ORIDE             0x00003624
+#define  CPMU_CLCK_ORIDE_MAC_ORIDE_EN    0x80000000
+
 #define TG3_CPMU_CLCK_STAT              0x00003630
 #define  CPMU_CLCK_STAT_MAC_CLCK_MASK    0x001f0000
 #define  CPMU_CLCK_STAT_MAC_CLCK_62_5    0x00000000
@@ -1321,6 +1334,7 @@
 #define  RDMAC_MODE_MULT_DMA_RD_DIS      0x01000000
 #define  RDMAC_MODE_IPV4_LSO_EN          0x08000000
 #define  RDMAC_MODE_IPV6_LSO_EN          0x10000000
+#define  RDMAC_MODE_H2BNC_VLAN_DET       0x20000000
 #define RDMAC_STATUS                    0x00004804
 #define  RDMAC_STATUS_TGTABORT           0x00000004
 #define  RDMAC_STATUS_MSTABORT           0x00000008
@@ -1613,6 +1627,8 @@
 #define  GRC_MODE_WSWAP_NONFRM_DATA     0x00000004
 #define  GRC_MODE_BSWAP_DATA            0x00000010
 #define  GRC_MODE_WSWAP_DATA            0x00000020
+#define  GRC_MODE_BYTE_SWAP_B2HRX_DATA  0x00000040
+#define  GRC_MODE_WORD_SWAP_B2HRX_DATA  0x00000080
 #define  GRC_MODE_SPLITHDR              0x00000100
 #define  GRC_MODE_NOFRM_CRACKING        0x00000200
 #define  GRC_MODE_INCL_CRC              0x00000400
@@ -1620,8 +1636,10 @@
 #define  GRC_MODE_NOIRQ_ON_SENDS        0x00002000
 #define  GRC_MODE_NOIRQ_ON_RCV          0x00004000
 #define  GRC_MODE_FORCE_PCI32BIT        0x00008000
+#define  GRC_MODE_B2HRX_ENABLE          0x00008000
 #define  GRC_MODE_HOST_STACKUP          0x00010000
 #define  GRC_MODE_HOST_SENDBDS          0x00020000
+#define  GRC_MODE_HTX2B_ENABLE          0x00040000
 #define  GRC_MODE_NO_TX_PHDR_CSUM       0x00100000
 #define  GRC_MODE_NVRAM_WR_ENABLE       0x00200000
 #define  GRC_MODE_PCIE_TL_SEL           0x00000000
@@ -1818,6 +1836,38 @@
 #define  FLASH_5717VENDOR_ATMEL_45USPT   0x03400000
 #define  FLASH_5717VENDOR_ST_25USPT      0x03400002
 #define  FLASH_5717VENDOR_ST_45USPT      0x03400001
+#define  FLASH_5720_EEPROM_HD            0x00000001
+#define  FLASH_5720_EEPROM_LD            0x00000003
+#define  FLASH_5720VENDOR_M_ATMEL_DB011D 0x01000000
+#define  FLASH_5720VENDOR_M_ATMEL_DB021D 0x01000002
+#define  FLASH_5720VENDOR_M_ATMEL_DB041D 0x01000001
+#define  FLASH_5720VENDOR_M_ATMEL_DB081D 0x01000003
+#define  FLASH_5720VENDOR_M_ST_M25PE10   0x02000000
+#define  FLASH_5720VENDOR_M_ST_M25PE20   0x02000002
+#define  FLASH_5720VENDOR_M_ST_M25PE40   0x02000001
+#define  FLASH_5720VENDOR_M_ST_M25PE80   0x02000003
+#define  FLASH_5720VENDOR_M_ST_M45PE10   0x03000000
+#define  FLASH_5720VENDOR_M_ST_M45PE20   0x03000002
+#define  FLASH_5720VENDOR_M_ST_M45PE40   0x03000001
+#define  FLASH_5720VENDOR_M_ST_M45PE80   0x03000003
+#define  FLASH_5720VENDOR_A_ATMEL_DB011B 0x01800000
+#define  FLASH_5720VENDOR_A_ATMEL_DB021B 0x01800002
+#define  FLASH_5720VENDOR_A_ATMEL_DB041B 0x01800001
+#define  FLASH_5720VENDOR_A_ATMEL_DB011D 0x01c00000
+#define  FLASH_5720VENDOR_A_ATMEL_DB021D 0x01c00002
+#define  FLASH_5720VENDOR_A_ATMEL_DB041D 0x01c00001
+#define  FLASH_5720VENDOR_A_ATMEL_DB081D 0x01c00003
+#define  FLASH_5720VENDOR_A_ST_M25PE10   0x02800000
+#define  FLASH_5720VENDOR_A_ST_M25PE20   0x02800002
+#define  FLASH_5720VENDOR_A_ST_M25PE40   0x02800001
+#define  FLASH_5720VENDOR_A_ST_M25PE80   0x02800003
+#define  FLASH_5720VENDOR_A_ST_M45PE10   0x02c00000
+#define  FLASH_5720VENDOR_A_ST_M45PE20   0x02c00002
+#define  FLASH_5720VENDOR_A_ST_M45PE40   0x02c00001
+#define  FLASH_5720VENDOR_A_ST_M45PE80   0x02c00003
+#define  FLASH_5720VENDOR_ATMEL_45USPT   0x03c00000
+#define  FLASH_5720VENDOR_ST_25USPT      0x03c00002
+#define  FLASH_5720VENDOR_ST_45USPT      0x03c00001
 #define  NVRAM_CFG1_5752PAGE_SIZE_MASK   0x70000000
 #define  FLASH_5752PAGE_SIZE_256         0x00000000
 #define  FLASH_5752PAGE_SIZE_512         0x10000000
@@ -2833,7 +2883,6 @@ struct tg3 {
         u32                             tg3_flags;
 #define TG3_FLAG_TAGGED_STATUS          0x00000001
 #define TG3_FLAG_TXD_MBOX_HWBUG         0x00000002
-#define TG3_FLAG_RX_CHECKSUMS           0x00000004
 #define TG3_FLAG_USE_LINKCHG_REG        0x00000008
 #define TG3_FLAG_ENABLE_ASF             0x00000020
 #define TG3_FLAG_ASPM_WORKAROUND        0x00000040
@@ -2859,7 +2908,6 @@ struct tg3 {
 #define TG3_FLAG_PAUSE_AUTONEG          0x02000000
 #define TG3_FLAG_CPMU_PRESENT           0x04000000
 #define TG3_FLAG_40BIT_DMA_BUG          0x08000000
-#define TG3_FLAG_BROKEN_CHECKSUMS       0x10000000
 #define TG3_FLAG_JUMBO_CAPABLE          0x20000000
 #define TG3_FLAG_CHIP_RESETTING         0x40000000
 #define TG3_FLAG_INIT_COMPLETE          0x80000000
@@ -2897,6 +2945,7 @@ struct tg3 {
 #define TG3_FLG3_5701_DMA_BUG           0x00000008
 #define TG3_FLG3_USE_PHYLIB             0x00000010
 #define TG3_FLG3_MDIOBUS_INITED         0x00000020
+#define TG3_FLG3_LRG_PROD_RING_CAP      0x00000080
 #define TG3_FLG3_RGMII_INBAND_DISABLE   0x00000100
 #define TG3_FLG3_RGMII_EXT_IBND_RX_EN   0x00000200
 #define TG3_FLG3_RGMII_EXT_IBND_TX_EN   0x00000400
@@ -2910,8 +2959,9 @@ struct tg3 {
 #define TG3_FLG3_SHORT_DMA_BUG          0x00200000
 #define TG3_FLG3_USE_JUMBO_BDFLAG       0x00400000
 #define TG3_FLG3_L1PLLPD_EN             0x00800000
-#define TG3_FLG3_5717_PLUS              0x01000000
+#define TG3_FLG3_57765_PLUS             0x01000000
 #define TG3_FLG3_APE_HAS_NCSI           0x02000000
+#define TG3_FLG3_5717_PLUS              0x04000000
 
         struct timer_list               timer;
         u16                             timer_counter;
@@ -2983,6 +3033,7 @@ struct tg3 {
 #define TG3_PHY_ID_BCM5718S             0xbc050ff0
 #define TG3_PHY_ID_BCM57765             0x5c0d8a40
 #define TG3_PHY_ID_BCM5719C             0x5c0d8a20
+#define TG3_PHY_ID_BCM5720C             0x5c0d8b60
 #define TG3_PHY_ID_BCM5906              0xdc00ac40
 #define TG3_PHY_ID_BCM8002              0x60010140
 #define TG3_PHY_ID_INVALID              0xffffffff
@@ -3049,6 +3100,7 @@ struct tg3 {
 
         int                             nvram_lock_cnt;
         u32                             nvram_size;
+#define TG3_NVRAM_SIZE_2KB              0x00000800
 #define TG3_NVRAM_SIZE_64KB             0x00010000
 #define TG3_NVRAM_SIZE_128KB            0x00020000
 #define TG3_NVRAM_SIZE_256KB            0x00040000
@@ -3064,6 +3116,9 @@ struct tg3 {
 #define JEDEC_SAIFUN                    0x4f
 #define JEDEC_SST                       0xbf
 
+#define ATMEL_AT24C02_CHIP_SIZE         TG3_NVRAM_SIZE_2KB
+#define ATMEL_AT24C02_PAGE_SIZE         (8)
+
 #define ATMEL_AT24C64_CHIP_SIZE         TG3_NVRAM_SIZE_64KB
 #define ATMEL_AT24C64_PAGE_SIZE         (32)
 
diff --git a/drivers/net/ucc_geth_ethtool.c b/drivers/net/ucc_geth_ethtool.c
index 6f92e48f02d3..537fbc0a4401 100644
--- a/drivers/net/ucc_geth_ethtool.c
+++ b/drivers/net/ucc_geth_ethtool.c
@@ -410,7 +410,6 @@ static const struct ethtool_ops uec_ethtool_ops = {
         .set_ringparam          = uec_set_ringparam,
         .get_pauseparam         = uec_get_pauseparam,
         .set_pauseparam         = uec_set_pauseparam,
-        .set_sg                 = ethtool_op_set_sg,
         .get_sset_count         = uec_get_sset_count,
         .get_strings            = uec_get_strings,
         .get_ethtool_stats      = uec_get_ethtool_stats,
diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig
index 3ec22c307797..9d4f9117260f 100644
--- a/drivers/net/usb/Kconfig
+++ b/drivers/net/usb/Kconfig
@@ -258,7 +258,7 @@ config USB_NET_NET1080
           optionally with LEDs that indicate traffic
 
 config USB_NET_PLUSB
-        tristate "Prolific PL-2301/2302 based cables"
+        tristate "Prolific PL-2301/2302/25A1 based cables"
         # if the handshake/init/reset problems, from original 'plusb',
         # are ever resolved ... then remove "experimental"
         depends on USB_USBNET && EXPERIMENTAL
diff --git a/drivers/net/usb/plusb.c b/drivers/net/usb/plusb.c
index 823c53751307..217aec8a768f 100644
--- a/drivers/net/usb/plusb.c
+++ b/drivers/net/usb/plusb.c
@@ -45,6 +45,14 @@
  * seems to get wedged under load.  Prolific docs are weak, and
  * don't identify differences between PL2301 and PL2302, much less
  * anything to explain the different PL2302 versions observed.
+ *
+ * NOTE:  pl2501 has several modes, including pl2301 and pl2302
+ * compatibility.   Some docs suggest the difference between 2301
+ * and 2302 is only to make MS-Windows use a different driver...
+ *
+ * pl25a1 glue based on patch from Tony Gibbs.  Prolific "docs" on
+ * this chip are as usual incomplete about what control messages
+ * are supported.
  */
 
 /*
@@ -86,16 +94,20 @@ pl_set_QuickLink_features(struct usbnet *dev, int val)
 
 static int pl_reset(struct usbnet *dev)
 {
+        int status;
+
         /* some units seem to need this reset, others reject it utterly.
          * FIXME be more like "naplink" or windows drivers.
          */
-        (void) pl_set_QuickLink_features(dev,
+        status = pl_set_QuickLink_features(dev,
                 PL_S_EN|PL_RESET_OUT|PL_RESET_IN|PL_PEER_E);
+        if (status != 0 && netif_msg_probe(dev))
+                netif_dbg(dev, link, dev->net, "pl_reset --> %d\n", status);
         return 0;
 }
 
 static const struct driver_info prolific_info = {
-        .description =  "Prolific PL-2301/PL-2302",
+        .description =  "Prolific PL-2301/PL-2302/PL-25A1",
         .flags =        FLAG_POINTTOPOINT | FLAG_NO_SETINT,
                 /* some PL-2302 versions seem to fail usb_set_interface() */
         .reset =        pl_reset,
@@ -111,6 +123,7 @@ static const struct driver_info	prolific_info = {
 
 static const struct usb_device_id       products [] = {
 
+/* full speed cables */
 {
         USB_DEVICE(0x067b, 0x0000),     // PL-2301
         .driver_info =  (unsigned long) &prolific_info,
@@ -119,6 +132,15 @@ static const struct usb_device_id	products [] = {
         .driver_info =  (unsigned long) &prolific_info,
 },
 
+/* high speed cables */
+{
+        USB_DEVICE(0x067b, 0x25a1),     /* PL-25A1, no eeprom */
+        .driver_info =  (unsigned long) &prolific_info,
+}, {
+        USB_DEVICE(0x050d, 0x258a),     /* Belkin F5U258/F5U279 (PL-25A1) */
+        .driver_info =  (unsigned long) &prolific_info,
+},
+
         { },            // END
 };
 MODULE_DEVICE_TABLE(usb, products);
@@ -134,16 +156,16 @@ static struct usb_driver plusb_driver = {
 
 static int __init plusb_init(void)
 {
-        return usb_register(&plusb_driver);
+        return usb_register(&plusb_driver);
 }
 module_init(plusb_init);
 
 static void __exit plusb_exit(void)
 {
-        usb_deregister(&plusb_driver);
+        usb_deregister(&plusb_driver);
 }
 module_exit(plusb_exit);
 
 MODULE_AUTHOR("David Brownell");
-MODULE_DESCRIPTION("Prolific PL-2301/2302 USB Host to Host Link Driver");
+MODULE_DESCRIPTION("Prolific PL-2301/2302/25A1 USB Host to Host Link Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/net/usb/smsc75xx.c b/drivers/net/usb/smsc75xx.c
index 753ee6eb7edd..860a20c938b4 100644
--- a/drivers/net/usb/smsc75xx.c
+++ b/drivers/net/usb/smsc75xx.c
@@ -65,7 +65,6 @@ struct smsc75xx_priv {
         struct usbnet *dev;
         u32 rfe_ctl;
         u32 multicast_hash_table[DP_SEL_VHF_HASH_LEN];
-        bool use_rx_csum;
         struct mutex dataport_mutex;
         spinlock_t rfe_ctl_lock;
         struct work_struct set_multicast;
@@ -548,28 +547,6 @@ static void smsc75xx_status(struct usbnet *dev, struct urb *urb)
                         "unexpected interrupt, intdata=0x%08X", intdata);
 }
 
-/* Enable or disable Rx checksum offload engine */
-static int smsc75xx_set_rx_csum_offload(struct usbnet *dev)
-{
-        struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
-        unsigned long flags;
-        int ret;
-
-        spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
-
-        if (pdata->use_rx_csum)
-                pdata->rfe_ctl |= RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM;
-        else
-                pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM);
-
-        spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
-
-        ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
-        check_warn_return(ret, "Error writing RFE_CTL");
-
-        return 0;
-}
-
 static int smsc75xx_ethtool_get_eeprom_len(struct net_device *net)
 {
         return MAX_EEPROM_SIZE;
@@ -599,34 +576,6 @@ static int smsc75xx_ethtool_set_eeprom(struct net_device *netdev,
         return smsc75xx_write_eeprom(dev, ee->offset, ee->len, data);
 }
 
-static u32 smsc75xx_ethtool_get_rx_csum(struct net_device *netdev)
-{
-        struct usbnet *dev = netdev_priv(netdev);
-        struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
-
-        return pdata->use_rx_csum;
-}
-
-static int smsc75xx_ethtool_set_rx_csum(struct net_device *netdev, u32 val)
-{
-        struct usbnet *dev = netdev_priv(netdev);
-        struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
-
-        pdata->use_rx_csum = !!val;
-
-        return smsc75xx_set_rx_csum_offload(dev);
-}
-
-static int smsc75xx_ethtool_set_tso(struct net_device *netdev, u32 data)
-{
-        if (data)
-                netdev->features |= NETIF_F_TSO | NETIF_F_TSO6;
-        else
-                netdev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
-
-        return 0;
-}
-
 static const struct ethtool_ops smsc75xx_ethtool_ops = {
         .get_link       = usbnet_get_link,
         .nway_reset     = usbnet_nway_reset,
@@ -638,12 +587,6 @@ static const struct ethtool_ops smsc75xx_ethtool_ops = {
         .get_eeprom_len = smsc75xx_ethtool_get_eeprom_len,
         .get_eeprom     = smsc75xx_ethtool_get_eeprom,
         .set_eeprom     = smsc75xx_ethtool_set_eeprom,
-        .get_tx_csum    = ethtool_op_get_tx_csum,
-        .set_tx_csum    = ethtool_op_set_tx_hw_csum,
-        .get_rx_csum    = smsc75xx_ethtool_get_rx_csum,
-        .set_rx_csum    = smsc75xx_ethtool_set_rx_csum,
-        .get_tso        = ethtool_op_get_tso,
-        .set_tso        = smsc75xx_ethtool_set_tso,
 };
 
 static int smsc75xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
@@ -782,6 +725,30 @@ static int smsc75xx_change_mtu(struct net_device *netdev, int new_mtu)
         return usbnet_change_mtu(netdev, new_mtu);
 }
 
+/* Enable or disable Rx checksum offload engine */
+static int smsc75xx_set_features(struct net_device *netdev, u32 features)
+{
+        struct usbnet *dev = netdev_priv(netdev);
+        struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
+
+        if (features & NETIF_F_RXCSUM)
+                pdata->rfe_ctl |= RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM;
+        else
+                pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM);
+
+        spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
+        /* it's racing here! */
+
+        ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
+        check_warn_return(ret, "Error writing RFE_CTL");
+
+        return 0;
+}
+
 static int smsc75xx_reset(struct usbnet *dev)
 {
         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
@@ -960,11 +927,7 @@ static int smsc75xx_reset(struct usbnet *dev)
         netif_dbg(dev, ifup, dev->net, "RFE_CTL set to 0x%08x", pdata->rfe_ctl);
 
         /* Enable or disable checksum offload engines */
-        ethtool_op_set_tx_hw_csum(dev->net, DEFAULT_TX_CSUM_ENABLE);
-        ret = smsc75xx_set_rx_csum_offload(dev);
-        check_warn_return(ret, "Failed to set rx csum offload: %d", ret);
-
-        smsc75xx_ethtool_set_tso(dev->net, DEFAULT_TSO_ENABLE);
+        smsc75xx_set_features(dev->net, dev->net->features);
 
         smsc75xx_set_multicast(dev->net);
 
@@ -1037,6 +1000,7 @@ static const struct net_device_ops smsc75xx_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_do_ioctl           = smsc75xx_ioctl,
         .ndo_set_multicast_list = smsc75xx_set_multicast,
+        .ndo_set_features       = smsc75xx_set_features,
 };
 
 static int smsc75xx_bind(struct usbnet *dev, struct usb_interface *intf)
@@ -1065,10 +1029,17 @@ static int smsc75xx_bind(struct usbnet *dev, struct usb_interface *intf)
 
         INIT_WORK(&pdata->set_multicast, smsc75xx_deferred_multicast_write);
 
-        pdata->use_rx_csum = DEFAULT_RX_CSUM_ENABLE;
+        if (DEFAULT_TX_CSUM_ENABLE) {
+                dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
+                if (DEFAULT_TSO_ENABLE)
+                        dev->net->features |= NETIF_F_SG |
+                                NETIF_F_TSO | NETIF_F_TSO6;
+        }
+        if (DEFAULT_RX_CSUM_ENABLE)
+                dev->net->features |= NETIF_F_RXCSUM;
 
-        /* We have to advertise SG otherwise TSO cannot be enabled */
-        dev->net->features |= NETIF_F_SG;
+        dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
+                NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_RXCSUM;
 
         /* Init all registers */
         ret = smsc75xx_reset(dev);
@@ -1091,10 +1062,11 @@ static void smsc75xx_unbind(struct usbnet *dev, struct usb_interface *intf)
         }
 }
 
-static void smsc75xx_rx_csum_offload(struct sk_buff *skb, u32 rx_cmd_a,
-                                     u32 rx_cmd_b)
+static void smsc75xx_rx_csum_offload(struct usbnet *dev, struct sk_buff *skb,
+                                     u32 rx_cmd_a, u32 rx_cmd_b)
 {
-        if (unlikely(rx_cmd_a & RX_CMD_A_LCSM)) {
+        if (!(dev->net->features & NETIF_F_RXCSUM) ||
+            unlikely(rx_cmd_a & RX_CMD_A_LCSM)) {
                 skb->ip_summed = CHECKSUM_NONE;
         } else {
                 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT));
@@ -1104,8 +1076,6 @@ static void smsc75xx_rx_csum_offload(struct sk_buff *skb, u32 rx_cmd_a,
 
 static int smsc75xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
 {
-        struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
-
         while (skb->len > 0) {
                 u32 rx_cmd_a, rx_cmd_b, align_count, size;
                 struct sk_buff *ax_skb;
@@ -1145,11 +1115,8 @@ static int smsc75xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
 
                         /* last frame in this batch */
                         if (skb->len == size) {
-                                if (pdata->use_rx_csum)
-                                        smsc75xx_rx_csum_offload(skb, rx_cmd_a,
-                                                rx_cmd_b);
-                                else
-                                        skb->ip_summed = CHECKSUM_NONE;
+                                smsc75xx_rx_csum_offload(dev, skb, rx_cmd_a,
+                                        rx_cmd_b);
 
                                 skb_trim(skb, skb->len - 4); /* remove fcs */
                                 skb->truesize = size + sizeof(struct sk_buff);
@@ -1167,11 +1134,8 @@ static int smsc75xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                         ax_skb->data = packet;
                         skb_set_tail_pointer(ax_skb, size);
 
-                        if (pdata->use_rx_csum)
-                                smsc75xx_rx_csum_offload(ax_skb, rx_cmd_a,
-                                        rx_cmd_b);
-                        else
-                                ax_skb->ip_summed = CHECKSUM_NONE;
+                        smsc75xx_rx_csum_offload(dev, ax_skb, rx_cmd_a,
+                                rx_cmd_b);
 
                         skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
                         ax_skb->truesize = size + sizeof(struct sk_buff);
diff --git a/drivers/net/usb/smsc95xx.c b/drivers/net/usb/smsc95xx.c
index 47a6c870b51f..24f4b3739dd2 100644
--- a/drivers/net/usb/smsc95xx.c
+++ b/drivers/net/usb/smsc95xx.c
@@ -52,8 +52,6 @@ struct smsc95xx_priv {
         u32 hash_hi;
         u32 hash_lo;
         spinlock_t mac_cr_lock;
-        bool use_tx_csum;
-        bool use_rx_csum;
 };
 
 struct usb_context {
@@ -517,22 +515,24 @@ static void smsc95xx_status(struct usbnet *dev, struct urb *urb)
 }
 
 /* Enable or disable Tx & Rx checksum offload engines */
-static int smsc95xx_set_csums(struct usbnet *dev)
+static int smsc95xx_set_features(struct net_device *netdev, u32 features)
 {
-        struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
+        struct usbnet *dev = netdev_priv(netdev);
         u32 read_buf;
-        int ret = smsc95xx_read_reg(dev, COE_CR, &read_buf);
+        int ret;
+
+        ret = smsc95xx_read_reg(dev, COE_CR, &read_buf);
         if (ret < 0) {
                 netdev_warn(dev->net, "Failed to read COE_CR: %d\n", ret);
                 return ret;
         }
 
-        if (pdata->use_tx_csum)
+        if (features & NETIF_F_HW_CSUM)
                 read_buf |= Tx_COE_EN_;
         else
                 read_buf &= ~Tx_COE_EN_;
 
-        if (pdata->use_rx_csum)
+        if (features & NETIF_F_RXCSUM)
                 read_buf |= Rx_COE_EN_;
         else
                 read_buf &= ~Rx_COE_EN_;
@@ -576,43 +576,6 @@ static int smsc95xx_ethtool_set_eeprom(struct net_device *netdev,
         return smsc95xx_write_eeprom(dev, ee->offset, ee->len, data);
 }
 
-static u32 smsc95xx_ethtool_get_rx_csum(struct net_device *netdev)
-{
-        struct usbnet *dev = netdev_priv(netdev);
-        struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
-
-        return pdata->use_rx_csum;
-}
-
-static int smsc95xx_ethtool_set_rx_csum(struct net_device *netdev, u32 val)
-{
-        struct usbnet *dev = netdev_priv(netdev);
-        struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
-
-        pdata->use_rx_csum = !!val;
-
-        return smsc95xx_set_csums(dev);
-}
-
-static u32 smsc95xx_ethtool_get_tx_csum(struct net_device *netdev)
-{
-        struct usbnet *dev = netdev_priv(netdev);
-        struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
-
-        return pdata->use_tx_csum;
-}
-
-static int smsc95xx_ethtool_set_tx_csum(struct net_device *netdev, u32 val)
-{
-        struct usbnet *dev = netdev_priv(netdev);
-        struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
-
-        pdata->use_tx_csum = !!val;
-
-        ethtool_op_set_tx_hw_csum(netdev, pdata->use_tx_csum);
-        return smsc95xx_set_csums(dev);
-}
-
 static const struct ethtool_ops smsc95xx_ethtool_ops = {
         .get_link       = usbnet_get_link,
         .nway_reset     = usbnet_nway_reset,
@@ -624,10 +587,6 @@ static const struct ethtool_ops smsc95xx_ethtool_ops = {
         .get_eeprom_len = smsc95xx_ethtool_get_eeprom_len,
         .get_eeprom     = smsc95xx_ethtool_get_eeprom,
         .set_eeprom     = smsc95xx_ethtool_set_eeprom,
-        .get_tx_csum    = smsc95xx_ethtool_get_tx_csum,
-        .set_tx_csum    = smsc95xx_ethtool_set_tx_csum,
-        .get_rx_csum    = smsc95xx_ethtool_get_rx_csum,
-        .set_rx_csum    = smsc95xx_ethtool_set_rx_csum,
 };
 
 static int smsc95xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
@@ -755,7 +714,6 @@ static int smsc95xx_phy_initialize(struct usbnet *dev)
 static int smsc95xx_reset(struct usbnet *dev)
 {
         struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
-        struct net_device *netdev = dev->net;
         u32 read_buf, write_buf, burst_cap;
         int ret = 0, timeout;
 
@@ -975,12 +933,7 @@ static int smsc95xx_reset(struct usbnet *dev)
         }
 
         /* Enable or disable checksum offload engines */
-        ethtool_op_set_tx_hw_csum(netdev, pdata->use_tx_csum);
-        ret = smsc95xx_set_csums(dev);
-        if (ret < 0) {
-                netdev_warn(dev->net, "Failed to set csum offload: %d\n", ret);
-                return ret;
-        }
+        smsc95xx_set_features(dev->net, dev->net->features);
 
         smsc95xx_set_multicast(dev->net);
 
@@ -1019,6 +972,7 @@ static const struct net_device_ops smsc95xx_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_do_ioctl           = smsc95xx_ioctl,
         .ndo_set_multicast_list = smsc95xx_set_multicast,
+        .ndo_set_features       = smsc95xx_set_features,
 };
 
 static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
@@ -1045,8 +999,12 @@ static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
 
         spin_lock_init(&pdata->mac_cr_lock);
 
-        pdata->use_tx_csum = DEFAULT_TX_CSUM_ENABLE;
-        pdata->use_rx_csum = DEFAULT_RX_CSUM_ENABLE;
+        if (DEFAULT_TX_CSUM_ENABLE)
+                dev->net->features |= NETIF_F_HW_CSUM;
+        if (DEFAULT_RX_CSUM_ENABLE)
+                dev->net->features |= NETIF_F_RXCSUM;
+
+        dev->net->hw_features = NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
 
         smsc95xx_init_mac_address(dev);
 
@@ -1056,7 +1014,7 @@ static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
         dev->net->netdev_ops = &smsc95xx_netdev_ops;
         dev->net->ethtool_ops = &smsc95xx_ethtool_ops;
         dev->net->flags |= IFF_MULTICAST;
-        dev->net->hard_header_len += SMSC95XX_TX_OVERHEAD;
+        dev->net->hard_header_len += SMSC95XX_TX_OVERHEAD_CSUM;
         return 0;
 }
 
@@ -1080,8 +1038,6 @@ static void smsc95xx_rx_csum_offload(struct sk_buff *skb)
 
 static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
 {
-        struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
-
         while (skb->len > 0) {
                 u32 header, align_count;
                 struct sk_buff *ax_skb;
@@ -1123,7 +1079,7 @@ static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
 
                         /* last frame in this batch */
                         if (skb->len == size) {
-                                if (pdata->use_rx_csum)
+                                if (dev->net->features & NETIF_F_RXCSUM)
                                         smsc95xx_rx_csum_offload(skb);
                                 skb_trim(skb, skb->len - 4); /* remove fcs */
                                 skb->truesize = size + sizeof(struct sk_buff);
@@ -1141,7 +1097,7 @@ static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
                         ax_skb->data = packet;
                         skb_set_tail_pointer(ax_skb, size);
 
-                        if (pdata->use_rx_csum)
+                        if (dev->net->features & NETIF_F_RXCSUM)
                                 smsc95xx_rx_csum_offload(ax_skb);
                         skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
                         ax_skb->truesize = size + sizeof(struct sk_buff);
@@ -1174,8 +1130,7 @@ static u32 smsc95xx_calc_csum_preamble(struct sk_buff *skb)
 static struct sk_buff *smsc95xx_tx_fixup(struct usbnet *dev,
                                          struct sk_buff *skb, gfp_t flags)
 {
-        struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
-        bool csum = pdata->use_tx_csum && (skb->ip_summed == CHECKSUM_PARTIAL);
+        bool csum = skb->ip_summed == CHECKSUM_PARTIAL;
         int overhead = csum ? SMSC95XX_TX_OVERHEAD_CSUM : SMSC95XX_TX_OVERHEAD;
         u32 tx_cmd_a, tx_cmd_b;
 
diff --git a/drivers/net/veth.c b/drivers/net/veth.c
index 2de9b90c5f8f..654228849951 100644
--- a/drivers/net/veth.c
+++ b/drivers/net/veth.c
@@ -36,7 +36,6 @@ struct veth_net_stats {
 struct veth_priv {
         struct net_device *peer;
         struct veth_net_stats __percpu *stats;
-        unsigned ip_summed;
 };
 
 /*
@@ -99,47 +98,10 @@ static void veth_get_ethtool_stats(struct net_device *dev,
         data[0] = priv->peer->ifindex;
 }
 
-static u32 veth_get_rx_csum(struct net_device *dev)
-{
-        struct veth_priv *priv;
-
-        priv = netdev_priv(dev);
-        return priv->ip_summed == CHECKSUM_UNNECESSARY;
-}
-
-static int veth_set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct veth_priv *priv;
-
-        priv = netdev_priv(dev);
-        priv->ip_summed = data ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE;
-        return 0;
-}
-
-static u32 veth_get_tx_csum(struct net_device *dev)
-{
-        return (dev->features & NETIF_F_NO_CSUM) != 0;
-}
-
-static int veth_set_tx_csum(struct net_device *dev, u32 data)
-{
-        if (data)
-                dev->features |= NETIF_F_NO_CSUM;
-        else
-                dev->features &= ~NETIF_F_NO_CSUM;
-        return 0;
-}
-
 static const struct ethtool_ops veth_ethtool_ops = {
         .get_settings           = veth_get_settings,
         .get_drvinfo            = veth_get_drvinfo,
         .get_link               = ethtool_op_get_link,
-        .get_rx_csum            = veth_get_rx_csum,
-        .set_rx_csum            = veth_set_rx_csum,
-        .get_tx_csum            = veth_get_tx_csum,
-        .set_tx_csum            = veth_set_tx_csum,
-        .get_sg                 = ethtool_op_get_sg,
-        .set_sg                 = ethtool_op_set_sg,
         .get_strings            = veth_get_strings,
         .get_sset_count         = veth_get_sset_count,
         .get_ethtool_stats      = veth_get_ethtool_stats,
@@ -168,8 +130,9 @@ static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev)
 
         /* don't change ip_summed == CHECKSUM_PARTIAL, as that
            will cause bad checksum on forwarded packets */
-        if (skb->ip_summed == CHECKSUM_NONE)
-                skb->ip_summed = rcv_priv->ip_summed;
+        if (skb->ip_summed == CHECKSUM_NONE &&
+            rcv->features & NETIF_F_RXCSUM)
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
 
         length = skb->len;
         if (dev_forward_skb(rcv, skb) != NET_RX_SUCCESS)
@@ -304,6 +267,8 @@ static void veth_setup(struct net_device *dev)
         dev->ethtool_ops = &veth_ethtool_ops;
         dev->features |= NETIF_F_LLTX;
         dev->destructor = veth_dev_free;
+
+        dev->hw_features = NETIF_F_NO_CSUM | NETIF_F_SG | NETIF_F_RXCSUM;
 }
 
 /*
diff --git a/drivers/net/via-rhine.c b/drivers/net/via-rhine.c
index eb5d75df5d5d..0422a79acfd7 100644
--- a/drivers/net/via-rhine.c
+++ b/drivers/net/via-rhine.c
@@ -1703,7 +1703,7 @@ static void rhine_tx(struct net_device *dev)
 static inline u16 rhine_get_vlan_tci(struct sk_buff *skb, int data_size)
 {
         u8 *trailer = (u8 *)skb->data + ((data_size + 3) & ~3) + 2;
-        return ntohs(*(u16 *)trailer);
+        return be16_to_cpup((__be16 *)trailer);
 }
 
 /* Process up to limit frames from receive ring */
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index 4fe051753842..baf04b0a6575 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -2600,8 +2600,7 @@ static netdev_tx_t velocity_xmit(struct sk_buff *skb,
         /*
          *      Handle hardware checksum
          */
-        if ((dev->features & NETIF_F_IP_CSUM) &&
-            (skb->ip_summed == CHECKSUM_PARTIAL)) {
+        if (skb->ip_summed == CHECKSUM_PARTIAL) {
                 const struct iphdr *ip = ip_hdr(skb);
                 if (ip->protocol == IPPROTO_TCP)
                         td_ptr->tdesc1.TCR |= TCR0_TCPCK;
@@ -2841,6 +2840,7 @@ static int __devinit velocity_found1(struct pci_dev *pdev, const struct pci_devi
         dev->ethtool_ops = &velocity_ethtool_ops;
         netif_napi_add(dev, &vptr->napi, velocity_poll, VELOCITY_NAPI_WEIGHT);
 
+        dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_HW_VLAN_TX;
         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER |
                 NETIF_F_HW_VLAN_RX | NETIF_F_IP_CSUM;
 
@@ -3457,13 +3457,10 @@ static const struct ethtool_ops velocity_ethtool_ops = {
         .get_settings   =       velocity_get_settings,
         .set_settings   =       velocity_set_settings,
         .get_drvinfo    =       velocity_get_drvinfo,
-        .set_tx_csum    =       ethtool_op_set_tx_csum,
-        .get_tx_csum    =       ethtool_op_get_tx_csum,
         .get_wol        =       velocity_ethtool_get_wol,
         .set_wol        =       velocity_ethtool_set_wol,
         .get_msglevel   =       velocity_get_msglevel,
         .set_msglevel   =       velocity_set_msglevel,
-        .set_sg         =       ethtool_op_set_sg,
         .get_link       =       velocity_get_link,
         .get_coalesce   =       velocity_get_coalesce,
         .set_coalesce   =       velocity_set_coalesce,
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 82dba5aaf423..0cb0b0632672 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -710,17 +710,6 @@ static int virtnet_close(struct net_device *dev)
         return 0;
 }
 
-static int virtnet_set_tx_csum(struct net_device *dev, u32 data)
-{
-        struct virtnet_info *vi = netdev_priv(dev);
-        struct virtio_device *vdev = vi->vdev;
-
-        if (data && !virtio_has_feature(vdev, VIRTIO_NET_F_CSUM))
-                return -ENOSYS;
-
-        return ethtool_op_set_tx_hw_csum(dev, data);
-}
-
 static void virtnet_set_rx_mode(struct net_device *dev)
 {
         struct virtnet_info *vi = netdev_priv(dev);
@@ -822,10 +811,6 @@ static void virtnet_vlan_rx_kill_vid(struct net_device *dev, u16 vid)
 }
 
 static const struct ethtool_ops virtnet_ethtool_ops = {
-        .set_tx_csum = virtnet_set_tx_csum,
-        .set_sg = ethtool_op_set_sg,
-        .set_tso = ethtool_op_set_tso,
-        .set_ufo = ethtool_op_set_ufo,
         .get_link = ethtool_op_get_link,
 };
 
@@ -912,22 +897,29 @@ static int virtnet_probe(struct virtio_device *vdev)
         SET_NETDEV_DEV(dev, &vdev->dev);
 
         /* Do we support "hardware" checksums? */
-        if (csum && virtio_has_feature(vdev, VIRTIO_NET_F_CSUM)) {
+        if (virtio_has_feature(vdev, VIRTIO_NET_F_CSUM)) {
                 /* This opens up the world of extra features. */
-                dev->features |= NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST;
-                if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_GSO)) {
-                        dev->features |= NETIF_F_TSO | NETIF_F_UFO
+                dev->hw_features |= NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST;
+                if (csum)
+                        dev->features |= NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST;
+
+                if (virtio_has_feature(vdev, VIRTIO_NET_F_GSO)) {
+                        dev->hw_features |= NETIF_F_TSO | NETIF_F_UFO
                                 | NETIF_F_TSO_ECN | NETIF_F_TSO6;
                 }
                 /* Individual feature bits: what can host handle? */
-                if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO4))
-                        dev->features |= NETIF_F_TSO;
-                if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO6))
-                        dev->features |= NETIF_F_TSO6;
-                if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_ECN))
-                        dev->features |= NETIF_F_TSO_ECN;
-                if (gso && virtio_has_feature(vdev, VIRTIO_NET_F_HOST_UFO))
-                        dev->features |= NETIF_F_UFO;
+                if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO4))
+                        dev->hw_features |= NETIF_F_TSO;
+                if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_TSO6))
+                        dev->hw_features |= NETIF_F_TSO6;
+                if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_ECN))
+                        dev->hw_features |= NETIF_F_TSO_ECN;
+                if (virtio_has_feature(vdev, VIRTIO_NET_F_HOST_UFO))
+                        dev->hw_features |= NETIF_F_UFO;
+
+                if (gso)
+                        dev->features |= dev->hw_features & (NETIF_F_ALL_TSO|NETIF_F_UFO);
+                /* (!csum && gso) case will be fixed by register_netdev() */
         }
 
         /* Configuration may specify what MAC to use.  Otherwise random. */
diff --git a/drivers/net/vxge/vxge-ethtool.c b/drivers/net/vxge/vxge-ethtool.c
index c5eb034107fd..43c458323f83 100644
--- a/drivers/net/vxge/vxge-ethtool.c
+++ b/drivers/net/vxge/vxge-ethtool.c
@@ -134,22 +134,29 @@ static void vxge_ethtool_gregs(struct net_device *dev,
 /**
  * vxge_ethtool_idnic - To physically identify the nic on the system.
  * @dev : device pointer.
- * @id : pointer to the structure with identification parameters given by
- * ethtool.
+ * @state : requested LED state
  *
  * Used to physically identify the NIC on the system.
- * The Link LED will blink for a time specified by the user.
- * Return value:
  * 0 on success
  */
-static int vxge_ethtool_idnic(struct net_device *dev, u32 data)
+static int vxge_ethtool_idnic(struct net_device *dev,
+                              enum ethtool_phys_id_state state)
 {
         struct vxgedev *vdev = netdev_priv(dev);
         struct __vxge_hw_device *hldev = vdev->devh;
 
-        vxge_hw_device_flick_link_led(hldev, VXGE_FLICKER_ON);
-        msleep_interruptible(data ? (data * HZ) : VXGE_MAX_FLICKER_TIME);
-        vxge_hw_device_flick_link_led(hldev, VXGE_FLICKER_OFF);
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                vxge_hw_device_flick_link_led(hldev, VXGE_FLICKER_ON);
+                break;
+
+        case ETHTOOL_ID_INACTIVE:
+                vxge_hw_device_flick_link_led(hldev, VXGE_FLICKER_OFF);
+                break;
+
+        default:
+                return -EINVAL;
+        }
 
         return 0;
 }
@@ -1183,7 +1190,7 @@ static const struct ethtool_ops vxge_ethtool_ops = {
         .get_tso                = ethtool_op_get_tso,
         .set_tso                = vxge_ethtool_op_set_tso,
         .get_strings            = vxge_ethtool_get_strings,
-        .phys_id                = vxge_ethtool_idnic,
+        .set_phys_id            = vxge_ethtool_idnic,
         .get_sset_count         = vxge_ethtool_get_sset_count,
         .get_ethtool_stats      = vxge_get_ethtool_stats,
         .set_flags              = vxge_set_flags,
diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index 22b8c3505991..1ce729d6af75 100644
--- a/drivers/net/xen-netback/xenbus.c
+++ b/drivers/net/xen-netback/xenbus.c
@@ -26,7 +26,7 @@ struct backend_info {
         struct xenvif *vif;
         enum xenbus_state frontend_state;
         struct xenbus_watch hotplug_status_watch;
-        int have_hotplug_status_watch:1;
+        u8 have_hotplug_status_watch:1;
 };
 
 static int connect_rings(struct backend_info *);
diff --git a/drivers/net/xen-netfront.c b/drivers/net/xen-netfront.c
index 5c8d9c385be0..db9a763aaa7f 100644
--- a/drivers/net/xen-netfront.c
+++ b/drivers/net/xen-netfront.c
@@ -1140,6 +1140,42 @@ static void xennet_uninit(struct net_device *dev)
         gnttab_free_grant_references(np->gref_rx_head);
 }
 
+static u32 xennet_fix_features(struct net_device *dev, u32 features)
+{
+        struct netfront_info *np = netdev_priv(dev);
+        int val;
+
+        if (features & NETIF_F_SG) {
+                if (xenbus_scanf(XBT_NIL, np->xbdev->otherend, "feature-sg",
+                                 "%d", &val) < 0)
+                        val = 0;
+
+                if (!val)
+                        features &= ~NETIF_F_SG;
+        }
+
+        if (features & NETIF_F_TSO) {
+                if (xenbus_scanf(XBT_NIL, np->xbdev->otherend,
+                                 "feature-gso-tcpv4", "%d", &val) < 0)
+                        val = 0;
+
+                if (!val)
+                        features &= ~NETIF_F_TSO;
+        }
+
+        return features;
+}
+
+static int xennet_set_features(struct net_device *dev, u32 features)
+{
+        if (!(features & NETIF_F_SG) && dev->mtu > ETH_DATA_LEN) {
+                netdev_info(dev, "Reducing MTU because no SG offload");
+                dev->mtu = ETH_DATA_LEN;
+        }
+
+        return 0;
+}
+
 static const struct net_device_ops xennet_netdev_ops = {
         .ndo_open            = xennet_open,
         .ndo_uninit          = xennet_uninit,
@@ -1148,6 +1184,8 @@ static const struct net_device_ops xennet_netdev_ops = {
         .ndo_change_mtu      = xennet_change_mtu,
         .ndo_set_mac_address = eth_mac_addr,
         .ndo_validate_addr   = eth_validate_addr,
+        .ndo_fix_features    = xennet_fix_features,
+        .ndo_set_features    = xennet_set_features,
 };
 
 static struct net_device * __devinit xennet_create_dev(struct xenbus_device *dev)
@@ -1209,7 +1247,17 @@ static struct net_device * __devinit xennet_create_dev(struct xenbus_device *dev
         netdev->netdev_ops      = &xennet_netdev_ops;
 
         netif_napi_add(netdev, &np->napi, xennet_poll, 64);
-        netdev->features        = NETIF_F_IP_CSUM;
+        netdev->features        = NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
+                                  NETIF_F_GSO_ROBUST;
+        netdev->hw_features     = NETIF_F_IP_CSUM | NETIF_F_SG | NETIF_F_TSO;
+
+        /*
+         * Assume that all hw features are available for now. This set
+         * will be adjusted by the call to netdev_update_features() in
+         * xennet_connect() which is the earliest point where we can
+         * negotiate with the backend regarding supported features.
+         */
+        netdev->features |= netdev->hw_features;
 
         SET_ETHTOOL_OPS(netdev, &xennet_ethtool_ops);
         SET_NETDEV_DEV(netdev, &dev->dev);
@@ -1416,8 +1464,7 @@ static int setup_netfront(struct xenbus_device *dev, struct netfront_info *info)
                 goto fail;
 
         err = bind_evtchn_to_irqhandler(info->evtchn, xennet_interrupt,
-                                        IRQF_SAMPLE_RANDOM, netdev->name,
-                                        netdev);
+                                        0, netdev->name, netdev);
         if (err < 0)
                 goto fail;
         netdev->irq = err;
@@ -1510,54 +1557,6 @@ again:
         return err;
 }
 
-static int xennet_set_sg(struct net_device *dev, u32 data)
-{
-        if (data) {
-                struct netfront_info *np = netdev_priv(dev);
-                int val;
-
-                if (xenbus_scanf(XBT_NIL, np->xbdev->otherend, "feature-sg",
-                                 "%d", &val) < 0)
-                        val = 0;
-                if (!val)
-                        return -ENOSYS;
-        } else if (dev->mtu > ETH_DATA_LEN)
-                dev->mtu = ETH_DATA_LEN;
-
-        return ethtool_op_set_sg(dev, data);
-}
-
-static int xennet_set_tso(struct net_device *dev, u32 data)
-{
-        if (data) {
-                struct netfront_info *np = netdev_priv(dev);
-                int val;
-
-                if (xenbus_scanf(XBT_NIL, np->xbdev->otherend,
-                                 "feature-gso-tcpv4", "%d", &val) < 0)
-                        val = 0;
-                if (!val)
-                        return -ENOSYS;
-        }
-
-        return ethtool_op_set_tso(dev, data);
-}
-
-static void xennet_set_features(struct net_device *dev)
-{
-        /* Turn off all GSO bits except ROBUST. */
-        dev->features &= ~NETIF_F_GSO_MASK;
-        dev->features |= NETIF_F_GSO_ROBUST;
-        xennet_set_sg(dev, 0);
-
-        /* We need checksum offload to enable scatter/gather and TSO. */
-        if (!(dev->features & NETIF_F_IP_CSUM))
-                return;
-
-        if (!xennet_set_sg(dev, 1))
-                xennet_set_tso(dev, 1);
-}
-
 static int xennet_connect(struct net_device *dev)
 {
         struct netfront_info *np = netdev_priv(dev);
@@ -1582,7 +1581,7 @@ static int xennet_connect(struct net_device *dev)
         if (err)
                 return err;
 
-        xennet_set_features(dev);
+        netdev_update_features(dev);
 
         spin_lock_bh(&np->rx_lock);
         spin_lock_irq(&np->tx_lock);
@@ -1710,9 +1709,6 @@ static void xennet_get_strings(struct net_device *dev, u32 stringset, u8 * data)
 
 static const struct ethtool_ops xennet_ethtool_ops =
 {
-        .set_tx_csum = ethtool_op_set_tx_csum,
-        .set_sg = xennet_set_sg,
-        .set_tso = xennet_set_tso,
         .get_link = ethtool_op_get_link,
 
         .get_sset_count = xennet_get_sset_count,